#!/usr/bin/env node
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/error.js
var require_error = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/error.js"(exports2) {
    var CommanderError2 = class extends Error {
      /**
       * Constructs the CommanderError class
       * @param {number} exitCode suggested exit code which could be used with process.exit
       * @param {string} code an id string representing the error
       * @param {string} message human-readable description of the error
       */
      constructor(exitCode, code, message) {
        super(message);
        Error.captureStackTrace(this, this.constructor);
        this.name = this.constructor.name;
        this.code = code;
        this.exitCode = exitCode;
        this.nestedError = void 0;
      }
    };
    var InvalidArgumentError2 = class extends CommanderError2 {
      /**
       * Constructs the InvalidArgumentError class
       * @param {string} [message] explanation of why argument is invalid
       */
      constructor(message) {
        super(1, "commander.invalidArgument", message);
        Error.captureStackTrace(this, this.constructor);
        this.name = this.constructor.name;
      }
    };
    exports2.CommanderError = CommanderError2;
    exports2.InvalidArgumentError = InvalidArgumentError2;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/argument.js
var require_argument = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/argument.js"(exports2) {
    var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
    var Argument2 = class {
      /**
       * Initialize a new command argument with the given name and description.
       * The default is that the argument is required, and you can explicitly
       * indicate this with <> around the name. Put [] around the name for an optional argument.
       *
       * @param {string} name
       * @param {string} [description]
       */
      constructor(name, description) {
        this.description = description || "";
        this.variadic = false;
        this.parseArg = void 0;
        this.defaultValue = void 0;
        this.defaultValueDescription = void 0;
        this.argChoices = void 0;
        switch (name[0]) {
          case "<":
            this.required = true;
            this._name = name.slice(1, -1);
            break;
          case "[":
            this.required = false;
            this._name = name.slice(1, -1);
            break;
          default:
            this.required = true;
            this._name = name;
            break;
        }
        if (this._name.endsWith("...")) {
          this.variadic = true;
          this._name = this._name.slice(0, -3);
        }
      }
      /**
       * Return argument name.
       *
       * @return {string}
       */
      name() {
        return this._name;
      }
      /**
       * @package
       */
      _collectValue(value, previous) {
        if (previous === this.defaultValue || !Array.isArray(previous)) {
          return [value];
        }
        previous.push(value);
        return previous;
      }
      /**
       * Set the default value, and optionally supply the description to be displayed in the help.
       *
       * @param {*} value
       * @param {string} [description]
       * @return {Argument}
       */
      default(value, description) {
        this.defaultValue = value;
        this.defaultValueDescription = description;
        return this;
      }
      /**
       * Set the custom handler for processing CLI command arguments into argument values.
       *
       * @param {Function} [fn]
       * @return {Argument}
       */
      argParser(fn) {
        this.parseArg = fn;
        return this;
      }
      /**
       * Only allow argument value to be one of choices.
       *
       * @param {string[]} values
       * @return {Argument}
       */
      choices(values) {
        this.argChoices = values.slice();
        this.parseArg = (arg, previous) => {
          if (!this.argChoices.includes(arg)) {
            throw new InvalidArgumentError2(
              `Allowed choices are ${this.argChoices.join(", ")}.`
            );
          }
          if (this.variadic) {
            return this._collectValue(arg, previous);
          }
          return arg;
        };
        return this;
      }
      /**
       * Make argument required.
       *
       * @returns {Argument}
       */
      argRequired() {
        this.required = true;
        return this;
      }
      /**
       * Make argument optional.
       *
       * @returns {Argument}
       */
      argOptional() {
        this.required = false;
        return this;
      }
    };
    function humanReadableArgName(arg) {
      const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
      return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
    }
    exports2.Argument = Argument2;
    exports2.humanReadableArgName = humanReadableArgName;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/help.js
var require_help = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/help.js"(exports2) {
    var { humanReadableArgName } = require_argument();
    var Help2 = class {
      constructor() {
        this.helpWidth = void 0;
        this.minWidthToWrap = 40;
        this.sortSubcommands = false;
        this.sortOptions = false;
        this.showGlobalOptions = false;
      }
      /**
       * prepareContext is called by Commander after applying overrides from `Command.configureHelp()`
       * and just before calling `formatHelp()`.
       *
       * Commander just uses the helpWidth and the rest is provided for optional use by more complex subclasses.
       *
       * @param {{ error?: boolean, helpWidth?: number, outputHasColors?: boolean }} contextOptions
       */
      prepareContext(contextOptions) {
        this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
      }
      /**
       * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
       *
       * @param {Command} cmd
       * @returns {Command[]}
       */
      visibleCommands(cmd) {
        const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
        const helpCommand = cmd._getHelpCommand();
        if (helpCommand && !helpCommand._hidden) {
          visibleCommands.push(helpCommand);
        }
        if (this.sortSubcommands) {
          visibleCommands.sort((a, b) => {
            return a.name().localeCompare(b.name());
          });
        }
        return visibleCommands;
      }
      /**
       * Compare options for sort.
       *
       * @param {Option} a
       * @param {Option} b
       * @returns {number}
       */
      compareOptions(a, b) {
        const getSortKey = (option) => {
          return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
        };
        return getSortKey(a).localeCompare(getSortKey(b));
      }
      /**
       * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
       *
       * @param {Command} cmd
       * @returns {Option[]}
       */
      visibleOptions(cmd) {
        const visibleOptions = cmd.options.filter((option) => !option.hidden);
        const helpOption = cmd._getHelpOption();
        if (helpOption && !helpOption.hidden) {
          const removeShort = helpOption.short && cmd._findOption(helpOption.short);
          const removeLong = helpOption.long && cmd._findOption(helpOption.long);
          if (!removeShort && !removeLong) {
            visibleOptions.push(helpOption);
          } else if (helpOption.long && !removeLong) {
            visibleOptions.push(
              cmd.createOption(helpOption.long, helpOption.description)
            );
          } else if (helpOption.short && !removeShort) {
            visibleOptions.push(
              cmd.createOption(helpOption.short, helpOption.description)
            );
          }
        }
        if (this.sortOptions) {
          visibleOptions.sort(this.compareOptions);
        }
        return visibleOptions;
      }
      /**
       * Get an array of the visible global options. (Not including help.)
       *
       * @param {Command} cmd
       * @returns {Option[]}
       */
      visibleGlobalOptions(cmd) {
        if (!this.showGlobalOptions) return [];
        const globalOptions = [];
        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
          const visibleOptions = ancestorCmd.options.filter(
            (option) => !option.hidden
          );
          globalOptions.push(...visibleOptions);
        }
        if (this.sortOptions) {
          globalOptions.sort(this.compareOptions);
        }
        return globalOptions;
      }
      /**
       * Get an array of the arguments if any have a description.
       *
       * @param {Command} cmd
       * @returns {Argument[]}
       */
      visibleArguments(cmd) {
        if (cmd._argsDescription) {
          cmd.registeredArguments.forEach((argument) => {
            argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
          });
        }
        if (cmd.registeredArguments.find((argument) => argument.description)) {
          return cmd.registeredArguments;
        }
        return [];
      }
      /**
       * Get the command term to show in the list of subcommands.
       *
       * @param {Command} cmd
       * @returns {string}
       */
      subcommandTerm(cmd) {
        const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
        return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
        (args ? " " + args : "");
      }
      /**
       * Get the option term to show in the list of options.
       *
       * @param {Option} option
       * @returns {string}
       */
      optionTerm(option) {
        return option.flags;
      }
      /**
       * Get the argument term to show in the list of arguments.
       *
       * @param {Argument} argument
       * @returns {string}
       */
      argumentTerm(argument) {
        return argument.name();
      }
      /**
       * Get the longest command term length.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {number}
       */
      longestSubcommandTermLength(cmd, helper) {
        return helper.visibleCommands(cmd).reduce((max, command) => {
          return Math.max(
            max,
            this.displayWidth(
              helper.styleSubcommandTerm(helper.subcommandTerm(command))
            )
          );
        }, 0);
      }
      /**
       * Get the longest option term length.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {number}
       */
      longestOptionTermLength(cmd, helper) {
        return helper.visibleOptions(cmd).reduce((max, option) => {
          return Math.max(
            max,
            this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))
          );
        }, 0);
      }
      /**
       * Get the longest global option term length.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {number}
       */
      longestGlobalOptionTermLength(cmd, helper) {
        return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
          return Math.max(
            max,
            this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option)))
          );
        }, 0);
      }
      /**
       * Get the longest argument term length.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {number}
       */
      longestArgumentTermLength(cmd, helper) {
        return helper.visibleArguments(cmd).reduce((max, argument) => {
          return Math.max(
            max,
            this.displayWidth(
              helper.styleArgumentTerm(helper.argumentTerm(argument))
            )
          );
        }, 0);
      }
      /**
       * Get the command usage to be displayed at the top of the built-in help.
       *
       * @param {Command} cmd
       * @returns {string}
       */
      commandUsage(cmd) {
        let cmdName = cmd._name;
        if (cmd._aliases[0]) {
          cmdName = cmdName + "|" + cmd._aliases[0];
        }
        let ancestorCmdNames = "";
        for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
          ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
        }
        return ancestorCmdNames + cmdName + " " + cmd.usage();
      }
      /**
       * Get the description for the command.
       *
       * @param {Command} cmd
       * @returns {string}
       */
      commandDescription(cmd) {
        return cmd.description();
      }
      /**
       * Get the subcommand summary to show in the list of subcommands.
       * (Fallback to description for backwards compatibility.)
       *
       * @param {Command} cmd
       * @returns {string}
       */
      subcommandDescription(cmd) {
        return cmd.summary() || cmd.description();
      }
      /**
       * Get the option description to show in the list of options.
       *
       * @param {Option} option
       * @return {string}
       */
      optionDescription(option) {
        const extraInfo = [];
        if (option.argChoices) {
          extraInfo.push(
            // use stringify to match the display of the default value
            `choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
          );
        }
        if (option.defaultValue !== void 0) {
          const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
          if (showDefault) {
            extraInfo.push(
              `default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`
            );
          }
        }
        if (option.presetArg !== void 0 && option.optional) {
          extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
        }
        if (option.envVar !== void 0) {
          extraInfo.push(`env: ${option.envVar}`);
        }
        if (extraInfo.length > 0) {
          const extraDescription = `(${extraInfo.join(", ")})`;
          if (option.description) {
            return `${option.description} ${extraDescription}`;
          }
          return extraDescription;
        }
        return option.description;
      }
      /**
       * Get the argument description to show in the list of arguments.
       *
       * @param {Argument} argument
       * @return {string}
       */
      argumentDescription(argument) {
        const extraInfo = [];
        if (argument.argChoices) {
          extraInfo.push(
            // use stringify to match the display of the default value
            `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
          );
        }
        if (argument.defaultValue !== void 0) {
          extraInfo.push(
            `default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`
          );
        }
        if (extraInfo.length > 0) {
          const extraDescription = `(${extraInfo.join(", ")})`;
          if (argument.description) {
            return `${argument.description} ${extraDescription}`;
          }
          return extraDescription;
        }
        return argument.description;
      }
      /**
       * Format a list of items, given a heading and an array of formatted items.
       *
       * @param {string} heading
       * @param {string[]} items
       * @param {Help} helper
       * @returns string[]
       */
      formatItemList(heading, items, helper) {
        if (items.length === 0) return [];
        return [helper.styleTitle(heading), ...items, ""];
      }
      /**
       * Group items by their help group heading.
       *
       * @param {Command[] | Option[]} unsortedItems
       * @param {Command[] | Option[]} visibleItems
       * @param {Function} getGroup
       * @returns {Map<string, Command[] | Option[]>}
       */
      groupItems(unsortedItems, visibleItems, getGroup) {
        const result = /* @__PURE__ */ new Map();
        unsortedItems.forEach((item) => {
          const group = getGroup(item);
          if (!result.has(group)) result.set(group, []);
        });
        visibleItems.forEach((item) => {
          const group = getGroup(item);
          if (!result.has(group)) {
            result.set(group, []);
          }
          result.get(group).push(item);
        });
        return result;
      }
      /**
       * Generate the built-in help text.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {string}
       */
      formatHelp(cmd, helper) {
        const termWidth = helper.padWidth(cmd, helper);
        const helpWidth = helper.helpWidth ?? 80;
        function callFormatItem(term, description) {
          return helper.formatItem(term, termWidth, description, helper);
        }
        let output = [
          `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
          ""
        ];
        const commandDescription = helper.commandDescription(cmd);
        if (commandDescription.length > 0) {
          output = output.concat([
            helper.boxWrap(
              helper.styleCommandDescription(commandDescription),
              helpWidth
            ),
            ""
          ]);
        }
        const argumentList = helper.visibleArguments(cmd).map((argument) => {
          return callFormatItem(
            helper.styleArgumentTerm(helper.argumentTerm(argument)),
            helper.styleArgumentDescription(helper.argumentDescription(argument))
          );
        });
        output = output.concat(
          this.formatItemList("Arguments:", argumentList, helper)
        );
        const optionGroups = this.groupItems(
          cmd.options,
          helper.visibleOptions(cmd),
          (option) => option.helpGroupHeading ?? "Options:"
        );
        optionGroups.forEach((options, group) => {
          const optionList = options.map((option) => {
            return callFormatItem(
              helper.styleOptionTerm(helper.optionTerm(option)),
              helper.styleOptionDescription(helper.optionDescription(option))
            );
          });
          output = output.concat(this.formatItemList(group, optionList, helper));
        });
        if (helper.showGlobalOptions) {
          const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
            return callFormatItem(
              helper.styleOptionTerm(helper.optionTerm(option)),
              helper.styleOptionDescription(helper.optionDescription(option))
            );
          });
          output = output.concat(
            this.formatItemList("Global Options:", globalOptionList, helper)
          );
        }
        const commandGroups = this.groupItems(
          cmd.commands,
          helper.visibleCommands(cmd),
          (sub) => sub.helpGroup() || "Commands:"
        );
        commandGroups.forEach((commands, group) => {
          const commandList = commands.map((sub) => {
            return callFormatItem(
              helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
              helper.styleSubcommandDescription(helper.subcommandDescription(sub))
            );
          });
          output = output.concat(this.formatItemList(group, commandList, helper));
        });
        return output.join("\n");
      }
      /**
       * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
       *
       * @param {string} str
       * @returns {number}
       */
      displayWidth(str) {
        return stripColor(str).length;
      }
      /**
       * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
       *
       * @param {string} str
       * @returns {string}
       */
      styleTitle(str) {
        return str;
      }
      styleUsage(str) {
        return str.split(" ").map((word) => {
          if (word === "[options]") return this.styleOptionText(word);
          if (word === "[command]") return this.styleSubcommandText(word);
          if (word[0] === "[" || word[0] === "<")
            return this.styleArgumentText(word);
          return this.styleCommandText(word);
        }).join(" ");
      }
      styleCommandDescription(str) {
        return this.styleDescriptionText(str);
      }
      styleOptionDescription(str) {
        return this.styleDescriptionText(str);
      }
      styleSubcommandDescription(str) {
        return this.styleDescriptionText(str);
      }
      styleArgumentDescription(str) {
        return this.styleDescriptionText(str);
      }
      styleDescriptionText(str) {
        return str;
      }
      styleOptionTerm(str) {
        return this.styleOptionText(str);
      }
      styleSubcommandTerm(str) {
        return str.split(" ").map((word) => {
          if (word === "[options]") return this.styleOptionText(word);
          if (word[0] === "[" || word[0] === "<")
            return this.styleArgumentText(word);
          return this.styleSubcommandText(word);
        }).join(" ");
      }
      styleArgumentTerm(str) {
        return this.styleArgumentText(str);
      }
      styleOptionText(str) {
        return str;
      }
      styleArgumentText(str) {
        return str;
      }
      styleSubcommandText(str) {
        return str;
      }
      styleCommandText(str) {
        return str;
      }
      /**
       * Calculate the pad width from the maximum term length.
       *
       * @param {Command} cmd
       * @param {Help} helper
       * @returns {number}
       */
      padWidth(cmd, helper) {
        return Math.max(
          helper.longestOptionTermLength(cmd, helper),
          helper.longestGlobalOptionTermLength(cmd, helper),
          helper.longestSubcommandTermLength(cmd, helper),
          helper.longestArgumentTermLength(cmd, helper)
        );
      }
      /**
       * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
       *
       * @param {string} str
       * @returns {boolean}
       */
      preformatted(str) {
        return /\n[^\S\r\n]/.test(str);
      }
      /**
       * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
       *
       * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
       *   TTT  DDD DDDD
       *        DD DDD
       *
       * @param {string} term
       * @param {number} termWidth
       * @param {string} description
       * @param {Help} helper
       * @returns {string}
       */
      formatItem(term, termWidth, description, helper) {
        const itemIndent = 2;
        const itemIndentStr = " ".repeat(itemIndent);
        if (!description) return itemIndentStr + term;
        const paddedTerm = term.padEnd(
          termWidth + term.length - helper.displayWidth(term)
        );
        const spacerWidth = 2;
        const helpWidth = this.helpWidth ?? 80;
        const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
        let formattedDescription;
        if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
          formattedDescription = description;
        } else {
          const wrappedDescription = helper.boxWrap(description, remainingWidth);
          formattedDescription = wrappedDescription.replace(
            /\n/g,
            "\n" + " ".repeat(termWidth + spacerWidth)
          );
        }
        return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
${itemIndentStr}`);
      }
      /**
       * Wrap a string at whitespace, preserving existing line breaks.
       * Wrapping is skipped if the width is less than `minWidthToWrap`.
       *
       * @param {string} str
       * @param {number} width
       * @returns {string}
       */
      boxWrap(str, width) {
        if (width < this.minWidthToWrap) return str;
        const rawLines = str.split(/\r\n|\n/);
        const chunkPattern = /[\s]*[^\s]+/g;
        const wrappedLines = [];
        rawLines.forEach((line) => {
          const chunks = line.match(chunkPattern);
          if (chunks === null) {
            wrappedLines.push("");
            return;
          }
          let sumChunks = [chunks.shift()];
          let sumWidth = this.displayWidth(sumChunks[0]);
          chunks.forEach((chunk) => {
            const visibleWidth = this.displayWidth(chunk);
            if (sumWidth + visibleWidth <= width) {
              sumChunks.push(chunk);
              sumWidth += visibleWidth;
              return;
            }
            wrappedLines.push(sumChunks.join(""));
            const nextChunk = chunk.trimStart();
            sumChunks = [nextChunk];
            sumWidth = this.displayWidth(nextChunk);
          });
          wrappedLines.push(sumChunks.join(""));
        });
        return wrappedLines.join("\n");
      }
    };
    function stripColor(str) {
      const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
      return str.replace(sgrPattern, "");
    }
    exports2.Help = Help2;
    exports2.stripColor = stripColor;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/option.js
var require_option = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/option.js"(exports2) {
    var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
    var Option2 = class {
      /**
       * Initialize a new `Option` with the given `flags` and `description`.
       *
       * @param {string} flags
       * @param {string} [description]
       */
      constructor(flags, description) {
        this.flags = flags;
        this.description = description || "";
        this.required = flags.includes("<");
        this.optional = flags.includes("[");
        this.variadic = /\w\.\.\.[>\]]$/.test(flags);
        this.mandatory = false;
        const optionFlags = splitOptionFlags(flags);
        this.short = optionFlags.shortFlag;
        this.long = optionFlags.longFlag;
        this.negate = false;
        if (this.long) {
          this.negate = this.long.startsWith("--no-");
        }
        this.defaultValue = void 0;
        this.defaultValueDescription = void 0;
        this.presetArg = void 0;
        this.envVar = void 0;
        this.parseArg = void 0;
        this.hidden = false;
        this.argChoices = void 0;
        this.conflictsWith = [];
        this.implied = void 0;
        this.helpGroupHeading = void 0;
      }
      /**
       * Set the default value, and optionally supply the description to be displayed in the help.
       *
       * @param {*} value
       * @param {string} [description]
       * @return {Option}
       */
      default(value, description) {
        this.defaultValue = value;
        this.defaultValueDescription = description;
        return this;
      }
      /**
       * Preset to use when option used without option-argument, especially optional but also boolean and negated.
       * The custom processing (parseArg) is called.
       *
       * @example
       * new Option('--color').default('GREYSCALE').preset('RGB');
       * new Option('--donate [amount]').preset('20').argParser(parseFloat);
       *
       * @param {*} arg
       * @return {Option}
       */
      preset(arg) {
        this.presetArg = arg;
        return this;
      }
      /**
       * Add option name(s) that conflict with this option.
       * An error will be displayed if conflicting options are found during parsing.
       *
       * @example
       * new Option('--rgb').conflicts('cmyk');
       * new Option('--js').conflicts(['ts', 'jsx']);
       *
       * @param {(string | string[])} names
       * @return {Option}
       */
      conflicts(names) {
        this.conflictsWith = this.conflictsWith.concat(names);
        return this;
      }
      /**
       * Specify implied option values for when this option is set and the implied options are not.
       *
       * The custom processing (parseArg) is not called on the implied values.
       *
       * @example
       * program
       *   .addOption(new Option('--log', 'write logging information to file'))
       *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
       *
       * @param {object} impliedOptionValues
       * @return {Option}
       */
      implies(impliedOptionValues) {
        let newImplied = impliedOptionValues;
        if (typeof impliedOptionValues === "string") {
          newImplied = { [impliedOptionValues]: true };
        }
        this.implied = Object.assign(this.implied || {}, newImplied);
        return this;
      }
      /**
       * Set environment variable to check for option value.
       *
       * An environment variable is only used if when processed the current option value is
       * undefined, or the source of the current value is 'default' or 'config' or 'env'.
       *
       * @param {string} name
       * @return {Option}
       */
      env(name) {
        this.envVar = name;
        return this;
      }
      /**
       * Set the custom handler for processing CLI option arguments into option values.
       *
       * @param {Function} [fn]
       * @return {Option}
       */
      argParser(fn) {
        this.parseArg = fn;
        return this;
      }
      /**
       * Whether the option is mandatory and must have a value after parsing.
       *
       * @param {boolean} [mandatory=true]
       * @return {Option}
       */
      makeOptionMandatory(mandatory = true) {
        this.mandatory = !!mandatory;
        return this;
      }
      /**
       * Hide option in help.
       *
       * @param {boolean} [hide=true]
       * @return {Option}
       */
      hideHelp(hide = true) {
        this.hidden = !!hide;
        return this;
      }
      /**
       * @package
       */
      _collectValue(value, previous) {
        if (previous === this.defaultValue || !Array.isArray(previous)) {
          return [value];
        }
        previous.push(value);
        return previous;
      }
      /**
       * Only allow option value to be one of choices.
       *
       * @param {string[]} values
       * @return {Option}
       */
      choices(values) {
        this.argChoices = values.slice();
        this.parseArg = (arg, previous) => {
          if (!this.argChoices.includes(arg)) {
            throw new InvalidArgumentError2(
              `Allowed choices are ${this.argChoices.join(", ")}.`
            );
          }
          if (this.variadic) {
            return this._collectValue(arg, previous);
          }
          return arg;
        };
        return this;
      }
      /**
       * Return option name.
       *
       * @return {string}
       */
      name() {
        if (this.long) {
          return this.long.replace(/^--/, "");
        }
        return this.short.replace(/^-/, "");
      }
      /**
       * Return option name, in a camelcase format that can be used
       * as an object attribute key.
       *
       * @return {string}
       */
      attributeName() {
        if (this.negate) {
          return camelcase(this.name().replace(/^no-/, ""));
        }
        return camelcase(this.name());
      }
      /**
       * Set the help group heading.
       *
       * @param {string} heading
       * @return {Option}
       */
      helpGroup(heading) {
        this.helpGroupHeading = heading;
        return this;
      }
      /**
       * Check if `arg` matches the short or long flag.
       *
       * @param {string} arg
       * @return {boolean}
       * @package
       */
      is(arg) {
        return this.short === arg || this.long === arg;
      }
      /**
       * Return whether a boolean option.
       *
       * Options are one of boolean, negated, required argument, or optional argument.
       *
       * @return {boolean}
       * @package
       */
      isBoolean() {
        return !this.required && !this.optional && !this.negate;
      }
    };
    var DualOptions = class {
      /**
       * @param {Option[]} options
       */
      constructor(options) {
        this.positiveOptions = /* @__PURE__ */ new Map();
        this.negativeOptions = /* @__PURE__ */ new Map();
        this.dualOptions = /* @__PURE__ */ new Set();
        options.forEach((option) => {
          if (option.negate) {
            this.negativeOptions.set(option.attributeName(), option);
          } else {
            this.positiveOptions.set(option.attributeName(), option);
          }
        });
        this.negativeOptions.forEach((value, key) => {
          if (this.positiveOptions.has(key)) {
            this.dualOptions.add(key);
          }
        });
      }
      /**
       * Did the value come from the option, and not from possible matching dual option?
       *
       * @param {*} value
       * @param {Option} option
       * @returns {boolean}
       */
      valueFromOption(value, option) {
        const optionKey = option.attributeName();
        if (!this.dualOptions.has(optionKey)) return true;
        const preset = this.negativeOptions.get(optionKey).presetArg;
        const negativeValue = preset !== void 0 ? preset : false;
        return option.negate === (negativeValue === value);
      }
    };
    function camelcase(str) {
      return str.split("-").reduce((str2, word) => {
        return str2 + word[0].toUpperCase() + word.slice(1);
      });
    }
    function splitOptionFlags(flags) {
      let shortFlag;
      let longFlag;
      const shortFlagExp = /^-[^-]$/;
      const longFlagExp = /^--[^-]/;
      const flagParts = flags.split(/[ |,]+/).concat("guard");
      if (shortFlagExp.test(flagParts[0])) shortFlag = flagParts.shift();
      if (longFlagExp.test(flagParts[0])) longFlag = flagParts.shift();
      if (!shortFlag && shortFlagExp.test(flagParts[0]))
        shortFlag = flagParts.shift();
      if (!shortFlag && longFlagExp.test(flagParts[0])) {
        shortFlag = longFlag;
        longFlag = flagParts.shift();
      }
      if (flagParts[0].startsWith("-")) {
        const unsupportedFlag = flagParts[0];
        const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
        if (/^-[^-][^-]/.test(unsupportedFlag))
          throw new Error(
            `${baseError}
- a short flag is a single dash and a single character
  - either use a single dash and a single character (for a short flag)
  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`
          );
        if (shortFlagExp.test(unsupportedFlag))
          throw new Error(`${baseError}
- too many short flags`);
        if (longFlagExp.test(unsupportedFlag))
          throw new Error(`${baseError}
- too many long flags`);
        throw new Error(`${baseError}
- unrecognised flag format`);
      }
      if (shortFlag === void 0 && longFlag === void 0)
        throw new Error(
          `option creation failed due to no flags found in '${flags}'.`
        );
      return { shortFlag, longFlag };
    }
    exports2.Option = Option2;
    exports2.DualOptions = DualOptions;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/suggestSimilar.js
var require_suggestSimilar = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/suggestSimilar.js"(exports2) {
    var maxDistance = 3;
    function editDistance(a, b) {
      if (Math.abs(a.length - b.length) > maxDistance)
        return Math.max(a.length, b.length);
      const d = [];
      for (let i = 0; i <= a.length; i++) {
        d[i] = [i];
      }
      for (let j = 0; j <= b.length; j++) {
        d[0][j] = j;
      }
      for (let j = 1; j <= b.length; j++) {
        for (let i = 1; i <= a.length; i++) {
          let cost = 1;
          if (a[i - 1] === b[j - 1]) {
            cost = 0;
          } else {
            cost = 1;
          }
          d[i][j] = Math.min(
            d[i - 1][j] + 1,
            // deletion
            d[i][j - 1] + 1,
            // insertion
            d[i - 1][j - 1] + cost
            // substitution
          );
          if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
            d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
          }
        }
      }
      return d[a.length][b.length];
    }
    function suggestSimilar(word, candidates) {
      if (!candidates || candidates.length === 0) return "";
      candidates = Array.from(new Set(candidates));
      const searchingOptions = word.startsWith("--");
      if (searchingOptions) {
        word = word.slice(2);
        candidates = candidates.map((candidate) => candidate.slice(2));
      }
      let similar = [];
      let bestDistance = maxDistance;
      const minSimilarity = 0.4;
      candidates.forEach((candidate) => {
        if (candidate.length <= 1) return;
        const distance = editDistance(word, candidate);
        const length = Math.max(word.length, candidate.length);
        const similarity = (length - distance) / length;
        if (similarity > minSimilarity) {
          if (distance < bestDistance) {
            bestDistance = distance;
            similar = [candidate];
          } else if (distance === bestDistance) {
            similar.push(candidate);
          }
        }
      });
      similar.sort((a, b) => a.localeCompare(b));
      if (searchingOptions) {
        similar = similar.map((candidate) => `--${candidate}`);
      }
      if (similar.length > 1) {
        return `
(Did you mean one of ${similar.join(", ")}?)`;
      }
      if (similar.length === 1) {
        return `
(Did you mean ${similar[0]}?)`;
      }
      return "";
    }
    exports2.suggestSimilar = suggestSimilar;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/command.js
var require_command = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/lib/command.js"(exports2) {
    var EventEmitter = require("node:events").EventEmitter;
    var childProcess = require("node:child_process");
    var path = require("node:path");
    var fs = require("node:fs");
    var process2 = require("node:process");
    var { Argument: Argument2, humanReadableArgName } = require_argument();
    var { CommanderError: CommanderError2 } = require_error();
    var { Help: Help2, stripColor } = require_help();
    var { Option: Option2, DualOptions } = require_option();
    var { suggestSimilar } = require_suggestSimilar();
    var Command2 = class _Command extends EventEmitter {
      /**
       * Initialize a new `Command`.
       *
       * @param {string} [name]
       */
      constructor(name) {
        super();
        this.commands = [];
        this.options = [];
        this.parent = null;
        this._allowUnknownOption = false;
        this._allowExcessArguments = false;
        this.registeredArguments = [];
        this._args = this.registeredArguments;
        this.args = [];
        this.rawArgs = [];
        this.processedArgs = [];
        this._scriptPath = null;
        this._name = name || "";
        this._optionValues = {};
        this._optionValueSources = {};
        this._storeOptionsAsProperties = false;
        this._actionHandler = null;
        this._executableHandler = false;
        this._executableFile = null;
        this._executableDir = null;
        this._defaultCommandName = null;
        this._exitCallback = null;
        this._aliases = [];
        this._combineFlagAndOptionalValue = true;
        this._description = "";
        this._summary = "";
        this._argsDescription = void 0;
        this._enablePositionalOptions = false;
        this._passThroughOptions = false;
        this._lifeCycleHooks = {};
        this._showHelpAfterError = false;
        this._showSuggestionAfterError = true;
        this._savedState = null;
        this._outputConfiguration = {
          writeOut: (str) => process2.stdout.write(str),
          writeErr: (str) => process2.stderr.write(str),
          outputError: (str, write) => write(str),
          getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : void 0,
          getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : void 0,
          getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
          getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
          stripColor: (str) => stripColor(str)
        };
        this._hidden = false;
        this._helpOption = void 0;
        this._addImplicitHelpCommand = void 0;
        this._helpCommand = void 0;
        this._helpConfiguration = {};
        this._helpGroupHeading = void 0;
        this._defaultCommandGroup = void 0;
        this._defaultOptionGroup = void 0;
      }
      /**
       * Copy settings that are useful to have in common across root command and subcommands.
       *
       * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
       *
       * @param {Command} sourceCommand
       * @return {Command} `this` command for chaining
       */
      copyInheritedSettings(sourceCommand) {
        this._outputConfiguration = sourceCommand._outputConfiguration;
        this._helpOption = sourceCommand._helpOption;
        this._helpCommand = sourceCommand._helpCommand;
        this._helpConfiguration = sourceCommand._helpConfiguration;
        this._exitCallback = sourceCommand._exitCallback;
        this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
        this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
        this._allowExcessArguments = sourceCommand._allowExcessArguments;
        this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
        this._showHelpAfterError = sourceCommand._showHelpAfterError;
        this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
        return this;
      }
      /**
       * @returns {Command[]}
       * @private
       */
      _getCommandAndAncestors() {
        const result = [];
        for (let command = this; command; command = command.parent) {
          result.push(command);
        }
        return result;
      }
      /**
       * Define a command.
       *
       * There are two styles of command: pay attention to where to put the description.
       *
       * @example
       * // Command implemented using action handler (description is supplied separately to `.command`)
       * program
       *   .command('clone <source> [destination]')
       *   .description('clone a repository into a newly created directory')
       *   .action((source, destination) => {
       *     console.log('clone command called');
       *   });
       *
       * // Command implemented using separate executable file (description is second parameter to `.command`)
       * program
       *   .command('start <service>', 'start named service')
       *   .command('stop [service]', 'stop named service, or all if no name supplied');
       *
       * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
       * @param {(object | string)} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
       * @param {object} [execOpts] - configuration options (for executable)
       * @return {Command} returns new command for action handler, or `this` for executable command
       */
      command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
        let desc = actionOptsOrExecDesc;
        let opts = execOpts;
        if (typeof desc === "object" && desc !== null) {
          opts = desc;
          desc = null;
        }
        opts = opts || {};
        const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
        const cmd = this.createCommand(name);
        if (desc) {
          cmd.description(desc);
          cmd._executableHandler = true;
        }
        if (opts.isDefault) this._defaultCommandName = cmd._name;
        cmd._hidden = !!(opts.noHelp || opts.hidden);
        cmd._executableFile = opts.executableFile || null;
        if (args) cmd.arguments(args);
        this._registerCommand(cmd);
        cmd.parent = this;
        cmd.copyInheritedSettings(this);
        if (desc) return this;
        return cmd;
      }
      /**
       * Factory routine to create a new unattached command.
       *
       * See .command() for creating an attached subcommand, which uses this routine to
       * create the command. You can override createCommand to customise subcommands.
       *
       * @param {string} [name]
       * @return {Command} new command
       */
      createCommand(name) {
        return new _Command(name);
      }
      /**
       * You can customise the help with a subclass of Help by overriding createHelp,
       * or by overriding Help properties using configureHelp().
       *
       * @return {Help}
       */
      createHelp() {
        return Object.assign(new Help2(), this.configureHelp());
      }
      /**
       * You can customise the help by overriding Help properties using configureHelp(),
       * or with a subclass of Help by overriding createHelp().
       *
       * @param {object} [configuration] - configuration options
       * @return {(Command | object)} `this` command for chaining, or stored configuration
       */
      configureHelp(configuration) {
        if (configuration === void 0) return this._helpConfiguration;
        this._helpConfiguration = configuration;
        return this;
      }
      /**
       * The default output goes to stdout and stderr. You can customise this for special
       * applications. You can also customise the display of errors by overriding outputError.
       *
       * The configuration properties are all functions:
       *
       *     // change how output being written, defaults to stdout and stderr
       *     writeOut(str)
       *     writeErr(str)
       *     // change how output being written for errors, defaults to writeErr
       *     outputError(str, write) // used for displaying errors and not used for displaying help
       *     // specify width for wrapping help
       *     getOutHelpWidth()
       *     getErrHelpWidth()
       *     // color support, currently only used with Help
       *     getOutHasColors()
       *     getErrHasColors()
       *     stripColor() // used to remove ANSI escape codes if output does not have colors
       *
       * @param {object} [configuration] - configuration options
       * @return {(Command | object)} `this` command for chaining, or stored configuration
       */
      configureOutput(configuration) {
        if (configuration === void 0) return this._outputConfiguration;
        this._outputConfiguration = {
          ...this._outputConfiguration,
          ...configuration
        };
        return this;
      }
      /**
       * Display the help or a custom message after an error occurs.
       *
       * @param {(boolean|string)} [displayHelp]
       * @return {Command} `this` command for chaining
       */
      showHelpAfterError(displayHelp = true) {
        if (typeof displayHelp !== "string") displayHelp = !!displayHelp;
        this._showHelpAfterError = displayHelp;
        return this;
      }
      /**
       * Display suggestion of similar commands for unknown commands, or options for unknown options.
       *
       * @param {boolean} [displaySuggestion]
       * @return {Command} `this` command for chaining
       */
      showSuggestionAfterError(displaySuggestion = true) {
        this._showSuggestionAfterError = !!displaySuggestion;
        return this;
      }
      /**
       * Add a prepared subcommand.
       *
       * See .command() for creating an attached subcommand which inherits settings from its parent.
       *
       * @param {Command} cmd - new subcommand
       * @param {object} [opts] - configuration options
       * @return {Command} `this` command for chaining
       */
      addCommand(cmd, opts) {
        if (!cmd._name) {
          throw new Error(`Command passed to .addCommand() must have a name
- specify the name in Command constructor or using .name()`);
        }
        opts = opts || {};
        if (opts.isDefault) this._defaultCommandName = cmd._name;
        if (opts.noHelp || opts.hidden) cmd._hidden = true;
        this._registerCommand(cmd);
        cmd.parent = this;
        cmd._checkForBrokenPassThrough();
        return this;
      }
      /**
       * Factory routine to create a new unattached argument.
       *
       * See .argument() for creating an attached argument, which uses this routine to
       * create the argument. You can override createArgument to return a custom argument.
       *
       * @param {string} name
       * @param {string} [description]
       * @return {Argument} new argument
       */
      createArgument(name, description) {
        return new Argument2(name, description);
      }
      /**
       * Define argument syntax for command.
       *
       * The default is that the argument is required, and you can explicitly
       * indicate this with <> around the name. Put [] around the name for an optional argument.
       *
       * @example
       * program.argument('<input-file>');
       * program.argument('[output-file]');
       *
       * @param {string} name
       * @param {string} [description]
       * @param {(Function|*)} [parseArg] - custom argument processing function or default value
       * @param {*} [defaultValue]
       * @return {Command} `this` command for chaining
       */
      argument(name, description, parseArg, defaultValue) {
        const argument = this.createArgument(name, description);
        if (typeof parseArg === "function") {
          argument.default(defaultValue).argParser(parseArg);
        } else {
          argument.default(parseArg);
        }
        this.addArgument(argument);
        return this;
      }
      /**
       * Define argument syntax for command, adding multiple at once (without descriptions).
       *
       * See also .argument().
       *
       * @example
       * program.arguments('<cmd> [env]');
       *
       * @param {string} names
       * @return {Command} `this` command for chaining
       */
      arguments(names) {
        names.trim().split(/ +/).forEach((detail) => {
          this.argument(detail);
        });
        return this;
      }
      /**
       * Define argument syntax for command, adding a prepared argument.
       *
       * @param {Argument} argument
       * @return {Command} `this` command for chaining
       */
      addArgument(argument) {
        const previousArgument = this.registeredArguments.slice(-1)[0];
        if (previousArgument?.variadic) {
          throw new Error(
            `only the last argument can be variadic '${previousArgument.name()}'`
          );
        }
        if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) {
          throw new Error(
            `a default value for a required argument is never used: '${argument.name()}'`
          );
        }
        this.registeredArguments.push(argument);
        return this;
      }
      /**
       * Customise or override default help command. By default a help command is automatically added if your command has subcommands.
       *
       * @example
       *    program.helpCommand('help [cmd]');
       *    program.helpCommand('help [cmd]', 'show help');
       *    program.helpCommand(false); // suppress default help command
       *    program.helpCommand(true); // add help command even if no subcommands
       *
       * @param {string|boolean} enableOrNameAndArgs - enable with custom name and/or arguments, or boolean to override whether added
       * @param {string} [description] - custom description
       * @return {Command} `this` command for chaining
       */
      helpCommand(enableOrNameAndArgs, description) {
        if (typeof enableOrNameAndArgs === "boolean") {
          this._addImplicitHelpCommand = enableOrNameAndArgs;
          if (enableOrNameAndArgs && this._defaultCommandGroup) {
            this._initCommandGroup(this._getHelpCommand());
          }
          return this;
        }
        const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
        const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
        const helpDescription = description ?? "display help for command";
        const helpCommand = this.createCommand(helpName);
        helpCommand.helpOption(false);
        if (helpArgs) helpCommand.arguments(helpArgs);
        if (helpDescription) helpCommand.description(helpDescription);
        this._addImplicitHelpCommand = true;
        this._helpCommand = helpCommand;
        if (enableOrNameAndArgs || description) this._initCommandGroup(helpCommand);
        return this;
      }
      /**
       * Add prepared custom help command.
       *
       * @param {(Command|string|boolean)} helpCommand - custom help command, or deprecated enableOrNameAndArgs as for `.helpCommand()`
       * @param {string} [deprecatedDescription] - deprecated custom description used with custom name only
       * @return {Command} `this` command for chaining
       */
      addHelpCommand(helpCommand, deprecatedDescription) {
        if (typeof helpCommand !== "object") {
          this.helpCommand(helpCommand, deprecatedDescription);
          return this;
        }
        this._addImplicitHelpCommand = true;
        this._helpCommand = helpCommand;
        this._initCommandGroup(helpCommand);
        return this;
      }
      /**
       * Lazy create help command.
       *
       * @return {(Command|null)}
       * @package
       */
      _getHelpCommand() {
        const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
        if (hasImplicitHelpCommand) {
          if (this._helpCommand === void 0) {
            this.helpCommand(void 0, void 0);
          }
          return this._helpCommand;
        }
        return null;
      }
      /**
       * Add hook for life cycle event.
       *
       * @param {string} event
       * @param {Function} listener
       * @return {Command} `this` command for chaining
       */
      hook(event, listener) {
        const allowedValues = ["preSubcommand", "preAction", "postAction"];
        if (!allowedValues.includes(event)) {
          throw new Error(`Unexpected value for event passed to hook : '${event}'.
Expecting one of '${allowedValues.join("', '")}'`);
        }
        if (this._lifeCycleHooks[event]) {
          this._lifeCycleHooks[event].push(listener);
        } else {
          this._lifeCycleHooks[event] = [listener];
        }
        return this;
      }
      /**
       * Register callback to use as replacement for calling process.exit.
       *
       * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
       * @return {Command} `this` command for chaining
       */
      exitOverride(fn) {
        if (fn) {
          this._exitCallback = fn;
        } else {
          this._exitCallback = (err) => {
            if (err.code !== "commander.executeSubCommandAsync") {
              throw err;
            } else {
            }
          };
        }
        return this;
      }
      /**
       * Call process.exit, and _exitCallback if defined.
       *
       * @param {number} exitCode exit code for using with process.exit
       * @param {string} code an id string representing the error
       * @param {string} message human-readable description of the error
       * @return never
       * @private
       */
      _exit(exitCode, code, message) {
        if (this._exitCallback) {
          this._exitCallback(new CommanderError2(exitCode, code, message));
        }
        process2.exit(exitCode);
      }
      /**
       * Register callback `fn` for the command.
       *
       * @example
       * program
       *   .command('serve')
       *   .description('start service')
       *   .action(function() {
       *      // do work here
       *   });
       *
       * @param {Function} fn
       * @return {Command} `this` command for chaining
       */
      action(fn) {
        const listener = (args) => {
          const expectedArgsCount = this.registeredArguments.length;
          const actionArgs = args.slice(0, expectedArgsCount);
          if (this._storeOptionsAsProperties) {
            actionArgs[expectedArgsCount] = this;
          } else {
            actionArgs[expectedArgsCount] = this.opts();
          }
          actionArgs.push(this);
          return fn.apply(this, actionArgs);
        };
        this._actionHandler = listener;
        return this;
      }
      /**
       * Factory routine to create a new unattached option.
       *
       * See .option() for creating an attached option, which uses this routine to
       * create the option. You can override createOption to return a custom option.
       *
       * @param {string} flags
       * @param {string} [description]
       * @return {Option} new option
       */
      createOption(flags, description) {
        return new Option2(flags, description);
      }
      /**
       * Wrap parseArgs to catch 'commander.invalidArgument'.
       *
       * @param {(Option | Argument)} target
       * @param {string} value
       * @param {*} previous
       * @param {string} invalidArgumentMessage
       * @private
       */
      _callParseArg(target, value, previous, invalidArgumentMessage) {
        try {
          return target.parseArg(value, previous);
        } catch (err) {
          if (err.code === "commander.invalidArgument") {
            const message = `${invalidArgumentMessage} ${err.message}`;
            this.error(message, { exitCode: err.exitCode, code: err.code });
          }
          throw err;
        }
      }
      /**
       * Check for option flag conflicts.
       * Register option if no conflicts found, or throw on conflict.
       *
       * @param {Option} option
       * @private
       */
      _registerOption(option) {
        const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
        if (matchingOption) {
          const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
          throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
-  already used by option '${matchingOption.flags}'`);
        }
        this._initOptionGroup(option);
        this.options.push(option);
      }
      /**
       * Check for command name and alias conflicts with existing commands.
       * Register command if no conflicts found, or throw on conflict.
       *
       * @param {Command} command
       * @private
       */
      _registerCommand(command) {
        const knownBy = (cmd) => {
          return [cmd.name()].concat(cmd.aliases());
        };
        const alreadyUsed = knownBy(command).find(
          (name) => this._findCommand(name)
        );
        if (alreadyUsed) {
          const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
          const newCmd = knownBy(command).join("|");
          throw new Error(
            `cannot add command '${newCmd}' as already have command '${existingCmd}'`
          );
        }
        this._initCommandGroup(command);
        this.commands.push(command);
      }
      /**
       * Add an option.
       *
       * @param {Option} option
       * @return {Command} `this` command for chaining
       */
      addOption(option) {
        this._registerOption(option);
        const oname = option.name();
        const name = option.attributeName();
        if (option.negate) {
          const positiveLongFlag = option.long.replace(/^--no-/, "--");
          if (!this._findOption(positiveLongFlag)) {
            this.setOptionValueWithSource(
              name,
              option.defaultValue === void 0 ? true : option.defaultValue,
              "default"
            );
          }
        } else if (option.defaultValue !== void 0) {
          this.setOptionValueWithSource(name, option.defaultValue, "default");
        }
        const handleOptionValue = (val, invalidValueMessage, valueSource) => {
          if (val == null && option.presetArg !== void 0) {
            val = option.presetArg;
          }
          const oldValue = this.getOptionValue(name);
          if (val !== null && option.parseArg) {
            val = this._callParseArg(option, val, oldValue, invalidValueMessage);
          } else if (val !== null && option.variadic) {
            val = option._collectValue(val, oldValue);
          }
          if (val == null) {
            if (option.negate) {
              val = false;
            } else if (option.isBoolean() || option.optional) {
              val = true;
            } else {
              val = "";
            }
          }
          this.setOptionValueWithSource(name, val, valueSource);
        };
        this.on("option:" + oname, (val) => {
          const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
          handleOptionValue(val, invalidValueMessage, "cli");
        });
        if (option.envVar) {
          this.on("optionEnv:" + oname, (val) => {
            const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
            handleOptionValue(val, invalidValueMessage, "env");
          });
        }
        return this;
      }
      /**
       * Internal implementation shared by .option() and .requiredOption()
       *
       * @return {Command} `this` command for chaining
       * @private
       */
      _optionEx(config2, flags, description, fn, defaultValue) {
        if (typeof flags === "object" && flags instanceof Option2) {
          throw new Error(
            "To add an Option object use addOption() instead of option() or requiredOption()"
          );
        }
        const option = this.createOption(flags, description);
        option.makeOptionMandatory(!!config2.mandatory);
        if (typeof fn === "function") {
          option.default(defaultValue).argParser(fn);
        } else if (fn instanceof RegExp) {
          const regex = fn;
          fn = (val, def) => {
            const m = regex.exec(val);
            return m ? m[0] : def;
          };
          option.default(defaultValue).argParser(fn);
        } else {
          option.default(fn);
        }
        return this.addOption(option);
      }
      /**
       * Define option with `flags`, `description`, and optional argument parsing function or `defaultValue` or both.
       *
       * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space. A required
       * option-argument is indicated by `<>` and an optional option-argument by `[]`.
       *
       * See the README for more details, and see also addOption() and requiredOption().
       *
       * @example
       * program
       *     .option('-p, --pepper', 'add pepper')
       *     .option('--pt, --pizza-type <TYPE>', 'type of pizza') // required option-argument
       *     .option('-c, --cheese [CHEESE]', 'add extra cheese', 'mozzarella') // optional option-argument with default
       *     .option('-t, --tip <VALUE>', 'add tip to purchase cost', parseFloat) // custom parse function
       *
       * @param {string} flags
       * @param {string} [description]
       * @param {(Function|*)} [parseArg] - custom option processing function or default value
       * @param {*} [defaultValue]
       * @return {Command} `this` command for chaining
       */
      option(flags, description, parseArg, defaultValue) {
        return this._optionEx({}, flags, description, parseArg, defaultValue);
      }
      /**
       * Add a required option which must have a value after parsing. This usually means
       * the option must be specified on the command line. (Otherwise the same as .option().)
       *
       * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
       *
       * @param {string} flags
       * @param {string} [description]
       * @param {(Function|*)} [parseArg] - custom option processing function or default value
       * @param {*} [defaultValue]
       * @return {Command} `this` command for chaining
       */
      requiredOption(flags, description, parseArg, defaultValue) {
        return this._optionEx(
          { mandatory: true },
          flags,
          description,
          parseArg,
          defaultValue
        );
      }
      /**
       * Alter parsing of short flags with optional values.
       *
       * @example
       * // for `.option('-f,--flag [value]'):
       * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour
       * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
       *
       * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.
       * @return {Command} `this` command for chaining
       */
      combineFlagAndOptionalValue(combine = true) {
        this._combineFlagAndOptionalValue = !!combine;
        return this;
      }
      /**
       * Allow unknown options on the command line.
       *
       * @param {boolean} [allowUnknown] - if `true` or omitted, no error will be thrown for unknown options.
       * @return {Command} `this` command for chaining
       */
      allowUnknownOption(allowUnknown = true) {
        this._allowUnknownOption = !!allowUnknown;
        return this;
      }
      /**
       * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
       *
       * @param {boolean} [allowExcess] - if `true` or omitted, no error will be thrown for excess arguments.
       * @return {Command} `this` command for chaining
       */
      allowExcessArguments(allowExcess = true) {
        this._allowExcessArguments = !!allowExcess;
        return this;
      }
      /**
       * Enable positional options. Positional means global options are specified before subcommands which lets
       * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
       * The default behaviour is non-positional and global options may appear anywhere on the command line.
       *
       * @param {boolean} [positional]
       * @return {Command} `this` command for chaining
       */
      enablePositionalOptions(positional = true) {
        this._enablePositionalOptions = !!positional;
        return this;
      }
      /**
       * Pass through options that come after command-arguments rather than treat them as command-options,
       * so actual command-options come before command-arguments. Turning this on for a subcommand requires
       * positional options to have been enabled on the program (parent commands).
       * The default behaviour is non-positional and options may appear before or after command-arguments.
       *
       * @param {boolean} [passThrough] for unknown options.
       * @return {Command} `this` command for chaining
       */
      passThroughOptions(passThrough = true) {
        this._passThroughOptions = !!passThrough;
        this._checkForBrokenPassThrough();
        return this;
      }
      /**
       * @private
       */
      _checkForBrokenPassThrough() {
        if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
          throw new Error(
            `passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`
          );
        }
      }
      /**
       * Whether to store option values as properties on command object,
       * or store separately (specify false). In both cases the option values can be accessed using .opts().
       *
       * @param {boolean} [storeAsProperties=true]
       * @return {Command} `this` command for chaining
       */
      storeOptionsAsProperties(storeAsProperties = true) {
        if (this.options.length) {
          throw new Error("call .storeOptionsAsProperties() before adding options");
        }
        if (Object.keys(this._optionValues).length) {
          throw new Error(
            "call .storeOptionsAsProperties() before setting option values"
          );
        }
        this._storeOptionsAsProperties = !!storeAsProperties;
        return this;
      }
      /**
       * Retrieve option value.
       *
       * @param {string} key
       * @return {object} value
       */
      getOptionValue(key) {
        if (this._storeOptionsAsProperties) {
          return this[key];
        }
        return this._optionValues[key];
      }
      /**
       * Store option value.
       *
       * @param {string} key
       * @param {object} value
       * @return {Command} `this` command for chaining
       */
      setOptionValue(key, value) {
        return this.setOptionValueWithSource(key, value, void 0);
      }
      /**
       * Store option value and where the value came from.
       *
       * @param {string} key
       * @param {object} value
       * @param {string} source - expected values are default/config/env/cli/implied
       * @return {Command} `this` command for chaining
       */
      setOptionValueWithSource(key, value, source) {
        if (this._storeOptionsAsProperties) {
          this[key] = value;
        } else {
          this._optionValues[key] = value;
        }
        this._optionValueSources[key] = source;
        return this;
      }
      /**
       * Get source of option value.
       * Expected values are default | config | env | cli | implied
       *
       * @param {string} key
       * @return {string}
       */
      getOptionValueSource(key) {
        return this._optionValueSources[key];
      }
      /**
       * Get source of option value. See also .optsWithGlobals().
       * Expected values are default | config | env | cli | implied
       *
       * @param {string} key
       * @return {string}
       */
      getOptionValueSourceWithGlobals(key) {
        let source;
        this._getCommandAndAncestors().forEach((cmd) => {
          if (cmd.getOptionValueSource(key) !== void 0) {
            source = cmd.getOptionValueSource(key);
          }
        });
        return source;
      }
      /**
       * Get user arguments from implied or explicit arguments.
       * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.
       *
       * @private
       */
      _prepareUserArgs(argv, parseOptions) {
        if (argv !== void 0 && !Array.isArray(argv)) {
          throw new Error("first parameter to parse must be array or undefined");
        }
        parseOptions = parseOptions || {};
        if (argv === void 0 && parseOptions.from === void 0) {
          if (process2.versions?.electron) {
            parseOptions.from = "electron";
          }
          const execArgv = process2.execArgv ?? [];
          if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
            parseOptions.from = "eval";
          }
        }
        if (argv === void 0) {
          argv = process2.argv;
        }
        this.rawArgs = argv.slice();
        let userArgs;
        switch (parseOptions.from) {
          case void 0:
          case "node":
            this._scriptPath = argv[1];
            userArgs = argv.slice(2);
            break;
          case "electron":
            if (process2.defaultApp) {
              this._scriptPath = argv[1];
              userArgs = argv.slice(2);
            } else {
              userArgs = argv.slice(1);
            }
            break;
          case "user":
            userArgs = argv.slice(0);
            break;
          case "eval":
            userArgs = argv.slice(1);
            break;
          default:
            throw new Error(
              `unexpected parse option { from: '${parseOptions.from}' }`
            );
        }
        if (!this._name && this._scriptPath)
          this.nameFromFilename(this._scriptPath);
        this._name = this._name || "program";
        return userArgs;
      }
      /**
       * Parse `argv`, setting options and invoking commands when defined.
       *
       * Use parseAsync instead of parse if any of your action handlers are async.
       *
       * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
       *
       * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
       * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
       * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
       * - `'user'`: just user arguments
       *
       * @example
       * program.parse(); // parse process.argv and auto-detect electron and special node flags
       * program.parse(process.argv); // assume argv[0] is app and argv[1] is script
       * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
       *
       * @param {string[]} [argv] - optional, defaults to process.argv
       * @param {object} [parseOptions] - optionally specify style of options with from: node/user/electron
       * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
       * @return {Command} `this` command for chaining
       */
      parse(argv, parseOptions) {
        this._prepareForParse();
        const userArgs = this._prepareUserArgs(argv, parseOptions);
        this._parseCommand([], userArgs);
        return this;
      }
      /**
       * Parse `argv`, setting options and invoking commands when defined.
       *
       * Call with no parameters to parse `process.argv`. Detects Electron and special node options like `node --eval`. Easy mode!
       *
       * Or call with an array of strings to parse, and optionally where the user arguments start by specifying where the arguments are `from`:
       * - `'node'`: default, `argv[0]` is the application and `argv[1]` is the script being run, with user arguments after that
       * - `'electron'`: `argv[0]` is the application and `argv[1]` varies depending on whether the electron application is packaged
       * - `'user'`: just user arguments
       *
       * @example
       * await program.parseAsync(); // parse process.argv and auto-detect electron and special node flags
       * await program.parseAsync(process.argv); // assume argv[0] is app and argv[1] is script
       * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
       *
       * @param {string[]} [argv]
       * @param {object} [parseOptions]
       * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
       * @return {Promise}
       */
      async parseAsync(argv, parseOptions) {
        this._prepareForParse();
        const userArgs = this._prepareUserArgs(argv, parseOptions);
        await this._parseCommand([], userArgs);
        return this;
      }
      _prepareForParse() {
        if (this._savedState === null) {
          this.saveStateBeforeParse();
        } else {
          this.restoreStateBeforeParse();
        }
      }
      /**
       * Called the first time parse is called to save state and allow a restore before subsequent calls to parse.
       * Not usually called directly, but available for subclasses to save their custom state.
       *
       * This is called in a lazy way. Only commands used in parsing chain will have state saved.
       */
      saveStateBeforeParse() {
        this._savedState = {
          // name is stable if supplied by author, but may be unspecified for root command and deduced during parsing
          _name: this._name,
          // option values before parse have default values (including false for negated options)
          // shallow clones
          _optionValues: { ...this._optionValues },
          _optionValueSources: { ...this._optionValueSources }
        };
      }
      /**
       * Restore state before parse for calls after the first.
       * Not usually called directly, but available for subclasses to save their custom state.
       *
       * This is called in a lazy way. Only commands used in parsing chain will have state restored.
       */
      restoreStateBeforeParse() {
        if (this._storeOptionsAsProperties)
          throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
- either make a new Command for each call to parse, or stop storing options as properties`);
        this._name = this._savedState._name;
        this._scriptPath = null;
        this.rawArgs = [];
        this._optionValues = { ...this._savedState._optionValues };
        this._optionValueSources = { ...this._savedState._optionValueSources };
        this.args = [];
        this.processedArgs = [];
      }
      /**
       * Throw if expected executable is missing. Add lots of help for author.
       *
       * @param {string} executableFile
       * @param {string} executableDir
       * @param {string} subcommandName
       */
      _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
        if (fs.existsSync(executableFile)) return;
        const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
        const executableMissing = `'${executableFile}' does not exist
 - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
 - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
 - ${executableDirMessage}`;
        throw new Error(executableMissing);
      }
      /**
       * Execute a sub-command executable.
       *
       * @private
       */
      _executeSubCommand(subcommand, args) {
        args = args.slice();
        let launchWithNode = false;
        const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
        function findFile(baseDir, baseName) {
          const localBin = path.resolve(baseDir, baseName);
          if (fs.existsSync(localBin)) return localBin;
          if (sourceExt.includes(path.extname(baseName))) return void 0;
          const foundExt = sourceExt.find(
            (ext) => fs.existsSync(`${localBin}${ext}`)
          );
          if (foundExt) return `${localBin}${foundExt}`;
          return void 0;
        }
        this._checkForMissingMandatoryOptions();
        this._checkForConflictingOptions();
        let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
        let executableDir = this._executableDir || "";
        if (this._scriptPath) {
          let resolvedScriptPath;
          try {
            resolvedScriptPath = fs.realpathSync(this._scriptPath);
          } catch {
            resolvedScriptPath = this._scriptPath;
          }
          executableDir = path.resolve(
            path.dirname(resolvedScriptPath),
            executableDir
          );
        }
        if (executableDir) {
          let localFile = findFile(executableDir, executableFile);
          if (!localFile && !subcommand._executableFile && this._scriptPath) {
            const legacyName = path.basename(
              this._scriptPath,
              path.extname(this._scriptPath)
            );
            if (legacyName !== this._name) {
              localFile = findFile(
                executableDir,
                `${legacyName}-${subcommand._name}`
              );
            }
          }
          executableFile = localFile || executableFile;
        }
        launchWithNode = sourceExt.includes(path.extname(executableFile));
        let proc;
        if (process2.platform !== "win32") {
          if (launchWithNode) {
            args.unshift(executableFile);
            args = incrementNodeInspectorPort(process2.execArgv).concat(args);
            proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
          } else {
            proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
          }
        } else {
          this._checkForMissingExecutable(
            executableFile,
            executableDir,
            subcommand._name
          );
          args.unshift(executableFile);
          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
          proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
        }
        if (!proc.killed) {
          const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
          signals.forEach((signal) => {
            process2.on(signal, () => {
              if (proc.killed === false && proc.exitCode === null) {
                proc.kill(signal);
              }
            });
          });
        }
        const exitCallback = this._exitCallback;
        proc.on("close", (code) => {
          code = code ?? 1;
          if (!exitCallback) {
            process2.exit(code);
          } else {
            exitCallback(
              new CommanderError2(
                code,
                "commander.executeSubCommandAsync",
                "(close)"
              )
            );
          }
        });
        proc.on("error", (err) => {
          if (err.code === "ENOENT") {
            this._checkForMissingExecutable(
              executableFile,
              executableDir,
              subcommand._name
            );
          } else if (err.code === "EACCES") {
            throw new Error(`'${executableFile}' not executable`);
          }
          if (!exitCallback) {
            process2.exit(1);
          } else {
            const wrappedError = new CommanderError2(
              1,
              "commander.executeSubCommandAsync",
              "(error)"
            );
            wrappedError.nestedError = err;
            exitCallback(wrappedError);
          }
        });
        this.runningCommand = proc;
      }
      /**
       * @private
       */
      _dispatchSubcommand(commandName, operands, unknown2) {
        const subCommand = this._findCommand(commandName);
        if (!subCommand) this.help({ error: true });
        subCommand._prepareForParse();
        let promiseChain;
        promiseChain = this._chainOrCallSubCommandHook(
          promiseChain,
          subCommand,
          "preSubcommand"
        );
        promiseChain = this._chainOrCall(promiseChain, () => {
          if (subCommand._executableHandler) {
            this._executeSubCommand(subCommand, operands.concat(unknown2));
          } else {
            return subCommand._parseCommand(operands, unknown2);
          }
        });
        return promiseChain;
      }
      /**
       * Invoke help directly if possible, or dispatch if necessary.
       * e.g. help foo
       *
       * @private
       */
      _dispatchHelpCommand(subcommandName) {
        if (!subcommandName) {
          this.help();
        }
        const subCommand = this._findCommand(subcommandName);
        if (subCommand && !subCommand._executableHandler) {
          subCommand.help();
        }
        return this._dispatchSubcommand(
          subcommandName,
          [],
          [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]
        );
      }
      /**
       * Check this.args against expected this.registeredArguments.
       *
       * @private
       */
      _checkNumberOfArguments() {
        this.registeredArguments.forEach((arg, i) => {
          if (arg.required && this.args[i] == null) {
            this.missingArgument(arg.name());
          }
        });
        if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
          return;
        }
        if (this.args.length > this.registeredArguments.length) {
          this._excessArguments(this.args);
        }
      }
      /**
       * Process this.args using this.registeredArguments and save as this.processedArgs!
       *
       * @private
       */
      _processArguments() {
        const myParseArg = (argument, value, previous) => {
          let parsedValue = value;
          if (value !== null && argument.parseArg) {
            const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
            parsedValue = this._callParseArg(
              argument,
              value,
              previous,
              invalidValueMessage
            );
          }
          return parsedValue;
        };
        this._checkNumberOfArguments();
        const processedArgs = [];
        this.registeredArguments.forEach((declaredArg, index) => {
          let value = declaredArg.defaultValue;
          if (declaredArg.variadic) {
            if (index < this.args.length) {
              value = this.args.slice(index);
              if (declaredArg.parseArg) {
                value = value.reduce((processed, v) => {
                  return myParseArg(declaredArg, v, processed);
                }, declaredArg.defaultValue);
              }
            } else if (value === void 0) {
              value = [];
            }
          } else if (index < this.args.length) {
            value = this.args[index];
            if (declaredArg.parseArg) {
              value = myParseArg(declaredArg, value, declaredArg.defaultValue);
            }
          }
          processedArgs[index] = value;
        });
        this.processedArgs = processedArgs;
      }
      /**
       * Once we have a promise we chain, but call synchronously until then.
       *
       * @param {(Promise|undefined)} promise
       * @param {Function} fn
       * @return {(Promise|undefined)}
       * @private
       */
      _chainOrCall(promise2, fn) {
        if (promise2?.then && typeof promise2.then === "function") {
          return promise2.then(() => fn());
        }
        return fn();
      }
      /**
       *
       * @param {(Promise|undefined)} promise
       * @param {string} event
       * @return {(Promise|undefined)}
       * @private
       */
      _chainOrCallHooks(promise2, event) {
        let result = promise2;
        const hooks = [];
        this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
          hookedCommand._lifeCycleHooks[event].forEach((callback) => {
            hooks.push({ hookedCommand, callback });
          });
        });
        if (event === "postAction") {
          hooks.reverse();
        }
        hooks.forEach((hookDetail) => {
          result = this._chainOrCall(result, () => {
            return hookDetail.callback(hookDetail.hookedCommand, this);
          });
        });
        return result;
      }
      /**
       *
       * @param {(Promise|undefined)} promise
       * @param {Command} subCommand
       * @param {string} event
       * @return {(Promise|undefined)}
       * @private
       */
      _chainOrCallSubCommandHook(promise2, subCommand, event) {
        let result = promise2;
        if (this._lifeCycleHooks[event] !== void 0) {
          this._lifeCycleHooks[event].forEach((hook) => {
            result = this._chainOrCall(result, () => {
              return hook(this, subCommand);
            });
          });
        }
        return result;
      }
      /**
       * Process arguments in context of this command.
       * Returns action result, in case it is a promise.
       *
       * @private
       */
      _parseCommand(operands, unknown2) {
        const parsed = this.parseOptions(unknown2);
        this._parseOptionsEnv();
        this._parseOptionsImplied();
        operands = operands.concat(parsed.operands);
        unknown2 = parsed.unknown;
        this.args = operands.concat(unknown2);
        if (operands && this._findCommand(operands[0])) {
          return this._dispatchSubcommand(operands[0], operands.slice(1), unknown2);
        }
        if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
          return this._dispatchHelpCommand(operands[1]);
        }
        if (this._defaultCommandName) {
          this._outputHelpIfRequested(unknown2);
          return this._dispatchSubcommand(
            this._defaultCommandName,
            operands,
            unknown2
          );
        }
        if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
          this.help({ error: true });
        }
        this._outputHelpIfRequested(parsed.unknown);
        this._checkForMissingMandatoryOptions();
        this._checkForConflictingOptions();
        const checkForUnknownOptions = () => {
          if (parsed.unknown.length > 0) {
            this.unknownOption(parsed.unknown[0]);
          }
        };
        const commandEvent = `command:${this.name()}`;
        if (this._actionHandler) {
          checkForUnknownOptions();
          this._processArguments();
          let promiseChain;
          promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
          promiseChain = this._chainOrCall(
            promiseChain,
            () => this._actionHandler(this.processedArgs)
          );
          if (this.parent) {
            promiseChain = this._chainOrCall(promiseChain, () => {
              this.parent.emit(commandEvent, operands, unknown2);
            });
          }
          promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
          return promiseChain;
        }
        if (this.parent?.listenerCount(commandEvent)) {
          checkForUnknownOptions();
          this._processArguments();
          this.parent.emit(commandEvent, operands, unknown2);
        } else if (operands.length) {
          if (this._findCommand("*")) {
            return this._dispatchSubcommand("*", operands, unknown2);
          }
          if (this.listenerCount("command:*")) {
            this.emit("command:*", operands, unknown2);
          } else if (this.commands.length) {
            this.unknownCommand();
          } else {
            checkForUnknownOptions();
            this._processArguments();
          }
        } else if (this.commands.length) {
          checkForUnknownOptions();
          this.help({ error: true });
        } else {
          checkForUnknownOptions();
          this._processArguments();
        }
      }
      /**
       * Find matching command.
       *
       * @private
       * @return {Command | undefined}
       */
      _findCommand(name) {
        if (!name) return void 0;
        return this.commands.find(
          (cmd) => cmd._name === name || cmd._aliases.includes(name)
        );
      }
      /**
       * Return an option matching `arg` if any.
       *
       * @param {string} arg
       * @return {Option}
       * @package
       */
      _findOption(arg) {
        return this.options.find((option) => option.is(arg));
      }
      /**
       * Display an error message if a mandatory option does not have a value.
       * Called after checking for help flags in leaf subcommand.
       *
       * @private
       */
      _checkForMissingMandatoryOptions() {
        this._getCommandAndAncestors().forEach((cmd) => {
          cmd.options.forEach((anOption) => {
            if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) {
              cmd.missingMandatoryOptionValue(anOption);
            }
          });
        });
      }
      /**
       * Display an error message if conflicting options are used together in this.
       *
       * @private
       */
      _checkForConflictingLocalOptions() {
        const definedNonDefaultOptions = this.options.filter((option) => {
          const optionKey = option.attributeName();
          if (this.getOptionValue(optionKey) === void 0) {
            return false;
          }
          return this.getOptionValueSource(optionKey) !== "default";
        });
        const optionsWithConflicting = definedNonDefaultOptions.filter(
          (option) => option.conflictsWith.length > 0
        );
        optionsWithConflicting.forEach((option) => {
          const conflictingAndDefined = definedNonDefaultOptions.find(
            (defined) => option.conflictsWith.includes(defined.attributeName())
          );
          if (conflictingAndDefined) {
            this._conflictingOption(option, conflictingAndDefined);
          }
        });
      }
      /**
       * Display an error message if conflicting options are used together.
       * Called after checking for help flags in leaf subcommand.
       *
       * @private
       */
      _checkForConflictingOptions() {
        this._getCommandAndAncestors().forEach((cmd) => {
          cmd._checkForConflictingLocalOptions();
        });
      }
      /**
       * Parse options from `argv` removing known options,
       * and return argv split into operands and unknown arguments.
       *
       * Side effects: modifies command by storing options. Does not reset state if called again.
       *
       * Examples:
       *
       *     argv => operands, unknown
       *     --known kkk op => [op], []
       *     op --known kkk => [op], []
       *     sub --unknown uuu op => [sub], [--unknown uuu op]
       *     sub -- --unknown uuu op => [sub --unknown uuu op], []
       *
       * @param {string[]} args
       * @return {{operands: string[], unknown: string[]}}
       */
      parseOptions(args) {
        const operands = [];
        const unknown2 = [];
        let dest = operands;
        function maybeOption(arg) {
          return arg.length > 1 && arg[0] === "-";
        }
        const negativeNumberArg = (arg) => {
          if (!/^-(\d+|\d*\.\d+)(e[+-]?\d+)?$/.test(arg)) return false;
          return !this._getCommandAndAncestors().some(
            (cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short))
          );
        };
        let activeVariadicOption = null;
        let activeGroup = null;
        let i = 0;
        while (i < args.length || activeGroup) {
          const arg = activeGroup ?? args[i++];
          activeGroup = null;
          if (arg === "--") {
            if (dest === unknown2) dest.push(arg);
            dest.push(...args.slice(i));
            break;
          }
          if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
            this.emit(`option:${activeVariadicOption.name()}`, arg);
            continue;
          }
          activeVariadicOption = null;
          if (maybeOption(arg)) {
            const option = this._findOption(arg);
            if (option) {
              if (option.required) {
                const value = args[i++];
                if (value === void 0) this.optionMissingArgument(option);
                this.emit(`option:${option.name()}`, value);
              } else if (option.optional) {
                let value = null;
                if (i < args.length && (!maybeOption(args[i]) || negativeNumberArg(args[i]))) {
                  value = args[i++];
                }
                this.emit(`option:${option.name()}`, value);
              } else {
                this.emit(`option:${option.name()}`);
              }
              activeVariadicOption = option.variadic ? option : null;
              continue;
            }
          }
          if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
            const option = this._findOption(`-${arg[1]}`);
            if (option) {
              if (option.required || option.optional && this._combineFlagAndOptionalValue) {
                this.emit(`option:${option.name()}`, arg.slice(2));
              } else {
                this.emit(`option:${option.name()}`);
                activeGroup = `-${arg.slice(2)}`;
              }
              continue;
            }
          }
          if (/^--[^=]+=/.test(arg)) {
            const index = arg.indexOf("=");
            const option = this._findOption(arg.slice(0, index));
            if (option && (option.required || option.optional)) {
              this.emit(`option:${option.name()}`, arg.slice(index + 1));
              continue;
            }
          }
          if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
            dest = unknown2;
          }
          if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown2.length === 0) {
            if (this._findCommand(arg)) {
              operands.push(arg);
              unknown2.push(...args.slice(i));
              break;
            } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
              operands.push(arg, ...args.slice(i));
              break;
            } else if (this._defaultCommandName) {
              unknown2.push(arg, ...args.slice(i));
              break;
            }
          }
          if (this._passThroughOptions) {
            dest.push(arg, ...args.slice(i));
            break;
          }
          dest.push(arg);
        }
        return { operands, unknown: unknown2 };
      }
      /**
       * Return an object containing local option values as key-value pairs.
       *
       * @return {object}
       */
      opts() {
        if (this._storeOptionsAsProperties) {
          const result = {};
          const len = this.options.length;
          for (let i = 0; i < len; i++) {
            const key = this.options[i].attributeName();
            result[key] = key === this._versionOptionName ? this._version : this[key];
          }
          return result;
        }
        return this._optionValues;
      }
      /**
       * Return an object containing merged local and global option values as key-value pairs.
       *
       * @return {object}
       */
      optsWithGlobals() {
        return this._getCommandAndAncestors().reduce(
          (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
          {}
        );
      }
      /**
       * Display error message and exit (or call exitOverride).
       *
       * @param {string} message
       * @param {object} [errorOptions]
       * @param {string} [errorOptions.code] - an id string representing the error
       * @param {number} [errorOptions.exitCode] - used with process.exit
       */
      error(message, errorOptions) {
        this._outputConfiguration.outputError(
          `${message}
`,
          this._outputConfiguration.writeErr
        );
        if (typeof this._showHelpAfterError === "string") {
          this._outputConfiguration.writeErr(`${this._showHelpAfterError}
`);
        } else if (this._showHelpAfterError) {
          this._outputConfiguration.writeErr("\n");
          this.outputHelp({ error: true });
        }
        const config2 = errorOptions || {};
        const exitCode = config2.exitCode || 1;
        const code = config2.code || "commander.error";
        this._exit(exitCode, code, message);
      }
      /**
       * Apply any option related environment variables, if option does
       * not have a value from cli or client code.
       *
       * @private
       */
      _parseOptionsEnv() {
        this.options.forEach((option) => {
          if (option.envVar && option.envVar in process2.env) {
            const optionKey = option.attributeName();
            if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
              this.getOptionValueSource(optionKey)
            )) {
              if (option.required || option.optional) {
                this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
              } else {
                this.emit(`optionEnv:${option.name()}`);
              }
            }
          }
        });
      }
      /**
       * Apply any implied option values, if option is undefined or default value.
       *
       * @private
       */
      _parseOptionsImplied() {
        const dualHelper = new DualOptions(this.options);
        const hasCustomOptionValue = (optionKey) => {
          return this.getOptionValue(optionKey) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
        };
        this.options.filter(
          (option) => option.implied !== void 0 && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(
            this.getOptionValue(option.attributeName()),
            option
          )
        ).forEach((option) => {
          Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
            this.setOptionValueWithSource(
              impliedKey,
              option.implied[impliedKey],
              "implied"
            );
          });
        });
      }
      /**
       * Argument `name` is missing.
       *
       * @param {string} name
       * @private
       */
      missingArgument(name) {
        const message = `error: missing required argument '${name}'`;
        this.error(message, { code: "commander.missingArgument" });
      }
      /**
       * `Option` is missing an argument.
       *
       * @param {Option} option
       * @private
       */
      optionMissingArgument(option) {
        const message = `error: option '${option.flags}' argument missing`;
        this.error(message, { code: "commander.optionMissingArgument" });
      }
      /**
       * `Option` does not have a value, and is a mandatory option.
       *
       * @param {Option} option
       * @private
       */
      missingMandatoryOptionValue(option) {
        const message = `error: required option '${option.flags}' not specified`;
        this.error(message, { code: "commander.missingMandatoryOptionValue" });
      }
      /**
       * `Option` conflicts with another option.
       *
       * @param {Option} option
       * @param {Option} conflictingOption
       * @private
       */
      _conflictingOption(option, conflictingOption) {
        const findBestOptionFromValue = (option2) => {
          const optionKey = option2.attributeName();
          const optionValue = this.getOptionValue(optionKey);
          const negativeOption = this.options.find(
            (target) => target.negate && optionKey === target.attributeName()
          );
          const positiveOption = this.options.find(
            (target) => !target.negate && optionKey === target.attributeName()
          );
          if (negativeOption && (negativeOption.presetArg === void 0 && optionValue === false || negativeOption.presetArg !== void 0 && optionValue === negativeOption.presetArg)) {
            return negativeOption;
          }
          return positiveOption || option2;
        };
        const getErrorMessage = (option2) => {
          const bestOption = findBestOptionFromValue(option2);
          const optionKey = bestOption.attributeName();
          const source = this.getOptionValueSource(optionKey);
          if (source === "env") {
            return `environment variable '${bestOption.envVar}'`;
          }
          return `option '${bestOption.flags}'`;
        };
        const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
        this.error(message, { code: "commander.conflictingOption" });
      }
      /**
       * Unknown option `flag`.
       *
       * @param {string} flag
       * @private
       */
      unknownOption(flag) {
        if (this._allowUnknownOption) return;
        let suggestion = "";
        if (flag.startsWith("--") && this._showSuggestionAfterError) {
          let candidateFlags = [];
          let command = this;
          do {
            const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
            candidateFlags = candidateFlags.concat(moreFlags);
            command = command.parent;
          } while (command && !command._enablePositionalOptions);
          suggestion = suggestSimilar(flag, candidateFlags);
        }
        const message = `error: unknown option '${flag}'${suggestion}`;
        this.error(message, { code: "commander.unknownOption" });
      }
      /**
       * Excess arguments, more than expected.
       *
       * @param {string[]} receivedArgs
       * @private
       */
      _excessArguments(receivedArgs) {
        if (this._allowExcessArguments) return;
        const expected = this.registeredArguments.length;
        const s = expected === 1 ? "" : "s";
        const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
        const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
        this.error(message, { code: "commander.excessArguments" });
      }
      /**
       * Unknown command.
       *
       * @private
       */
      unknownCommand() {
        const unknownName = this.args[0];
        let suggestion = "";
        if (this._showSuggestionAfterError) {
          const candidateNames = [];
          this.createHelp().visibleCommands(this).forEach((command) => {
            candidateNames.push(command.name());
            if (command.alias()) candidateNames.push(command.alias());
          });
          suggestion = suggestSimilar(unknownName, candidateNames);
        }
        const message = `error: unknown command '${unknownName}'${suggestion}`;
        this.error(message, { code: "commander.unknownCommand" });
      }
      /**
       * Get or set the program version.
       *
       * This method auto-registers the "-V, --version" option which will print the version number.
       *
       * You can optionally supply the flags and description to override the defaults.
       *
       * @param {string} [str]
       * @param {string} [flags]
       * @param {string} [description]
       * @return {(this | string | undefined)} `this` command for chaining, or version string if no arguments
       */
      version(str, flags, description) {
        if (str === void 0) return this._version;
        this._version = str;
        flags = flags || "-V, --version";
        description = description || "output the version number";
        const versionOption = this.createOption(flags, description);
        this._versionOptionName = versionOption.attributeName();
        this._registerOption(versionOption);
        this.on("option:" + versionOption.name(), () => {
          this._outputConfiguration.writeOut(`${str}
`);
          this._exit(0, "commander.version", str);
        });
        return this;
      }
      /**
       * Set the description.
       *
       * @param {string} [str]
       * @param {object} [argsDescription]
       * @return {(string|Command)}
       */
      description(str, argsDescription) {
        if (str === void 0 && argsDescription === void 0)
          return this._description;
        this._description = str;
        if (argsDescription) {
          this._argsDescription = argsDescription;
        }
        return this;
      }
      /**
       * Set the summary. Used when listed as subcommand of parent.
       *
       * @param {string} [str]
       * @return {(string|Command)}
       */
      summary(str) {
        if (str === void 0) return this._summary;
        this._summary = str;
        return this;
      }
      /**
       * Set an alias for the command.
       *
       * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
       *
       * @param {string} [alias]
       * @return {(string|Command)}
       */
      alias(alias) {
        if (alias === void 0) return this._aliases[0];
        let command = this;
        if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
          command = this.commands[this.commands.length - 1];
        }
        if (alias === command._name)
          throw new Error("Command alias can't be the same as its name");
        const matchingCommand = this.parent?._findCommand(alias);
        if (matchingCommand) {
          const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
          throw new Error(
            `cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`
          );
        }
        command._aliases.push(alias);
        return this;
      }
      /**
       * Set aliases for the command.
       *
       * Only the first alias is shown in the auto-generated help.
       *
       * @param {string[]} [aliases]
       * @return {(string[]|Command)}
       */
      aliases(aliases) {
        if (aliases === void 0) return this._aliases;
        aliases.forEach((alias) => this.alias(alias));
        return this;
      }
      /**
       * Set / get the command usage `str`.
       *
       * @param {string} [str]
       * @return {(string|Command)}
       */
      usage(str) {
        if (str === void 0) {
          if (this._usage) return this._usage;
          const args = this.registeredArguments.map((arg) => {
            return humanReadableArgName(arg);
          });
          return [].concat(
            this.options.length || this._helpOption !== null ? "[options]" : [],
            this.commands.length ? "[command]" : [],
            this.registeredArguments.length ? args : []
          ).join(" ");
        }
        this._usage = str;
        return this;
      }
      /**
       * Get or set the name of the command.
       *
       * @param {string} [str]
       * @return {(string|Command)}
       */
      name(str) {
        if (str === void 0) return this._name;
        this._name = str;
        return this;
      }
      /**
       * Set/get the help group heading for this subcommand in parent command's help.
       *
       * @param {string} [heading]
       * @return {Command | string}
       */
      helpGroup(heading) {
        if (heading === void 0) return this._helpGroupHeading ?? "";
        this._helpGroupHeading = heading;
        return this;
      }
      /**
       * Set/get the default help group heading for subcommands added to this command.
       * (This does not override a group set directly on the subcommand using .helpGroup().)
       *
       * @example
       * program.commandsGroup('Development Commands:);
       * program.command('watch')...
       * program.command('lint')...
       * ...
       *
       * @param {string} [heading]
       * @returns {Command | string}
       */
      commandsGroup(heading) {
        if (heading === void 0) return this._defaultCommandGroup ?? "";
        this._defaultCommandGroup = heading;
        return this;
      }
      /**
       * Set/get the default help group heading for options added to this command.
       * (This does not override a group set directly on the option using .helpGroup().)
       *
       * @example
       * program
       *   .optionsGroup('Development Options:')
       *   .option('-d, --debug', 'output extra debugging')
       *   .option('-p, --profile', 'output profiling information')
       *
       * @param {string} [heading]
       * @returns {Command | string}
       */
      optionsGroup(heading) {
        if (heading === void 0) return this._defaultOptionGroup ?? "";
        this._defaultOptionGroup = heading;
        return this;
      }
      /**
       * @param {Option} option
       * @private
       */
      _initOptionGroup(option) {
        if (this._defaultOptionGroup && !option.helpGroupHeading)
          option.helpGroup(this._defaultOptionGroup);
      }
      /**
       * @param {Command} cmd
       * @private
       */
      _initCommandGroup(cmd) {
        if (this._defaultCommandGroup && !cmd.helpGroup())
          cmd.helpGroup(this._defaultCommandGroup);
      }
      /**
       * Set the name of the command from script filename, such as process.argv[1],
       * or require.main.filename, or __filename.
       *
       * (Used internally and public although not documented in README.)
       *
       * @example
       * program.nameFromFilename(require.main.filename);
       *
       * @param {string} filename
       * @return {Command}
       */
      nameFromFilename(filename) {
        this._name = path.basename(filename, path.extname(filename));
        return this;
      }
      /**
       * Get or set the directory for searching for executable subcommands of this command.
       *
       * @example
       * program.executableDir(__dirname);
       * // or
       * program.executableDir('subcommands');
       *
       * @param {string} [path]
       * @return {(string|null|Command)}
       */
      executableDir(path2) {
        if (path2 === void 0) return this._executableDir;
        this._executableDir = path2;
        return this;
      }
      /**
       * Return program help documentation.
       *
       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
       * @return {string}
       */
      helpInformation(contextOptions) {
        const helper = this.createHelp();
        const context = this._getOutputContext(contextOptions);
        helper.prepareContext({
          error: context.error,
          helpWidth: context.helpWidth,
          outputHasColors: context.hasColors
        });
        const text = helper.formatHelp(this, helper);
        if (context.hasColors) return text;
        return this._outputConfiguration.stripColor(text);
      }
      /**
       * @typedef HelpContext
       * @type {object}
       * @property {boolean} error
       * @property {number} helpWidth
       * @property {boolean} hasColors
       * @property {function} write - includes stripColor if needed
       *
       * @returns {HelpContext}
       * @private
       */
      _getOutputContext(contextOptions) {
        contextOptions = contextOptions || {};
        const error48 = !!contextOptions.error;
        let baseWrite;
        let hasColors;
        let helpWidth;
        if (error48) {
          baseWrite = (str) => this._outputConfiguration.writeErr(str);
          hasColors = this._outputConfiguration.getErrHasColors();
          helpWidth = this._outputConfiguration.getErrHelpWidth();
        } else {
          baseWrite = (str) => this._outputConfiguration.writeOut(str);
          hasColors = this._outputConfiguration.getOutHasColors();
          helpWidth = this._outputConfiguration.getOutHelpWidth();
        }
        const write = (str) => {
          if (!hasColors) str = this._outputConfiguration.stripColor(str);
          return baseWrite(str);
        };
        return { error: error48, write, hasColors, helpWidth };
      }
      /**
       * Output help information for this command.
       *
       * Outputs built-in help, and custom text added using `.addHelpText()`.
       *
       * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout
       */
      outputHelp(contextOptions) {
        let deprecatedCallback;
        if (typeof contextOptions === "function") {
          deprecatedCallback = contextOptions;
          contextOptions = void 0;
        }
        const outputContext = this._getOutputContext(contextOptions);
        const eventContext = {
          error: outputContext.error,
          write: outputContext.write,
          command: this
        };
        this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
        this.emit("beforeHelp", eventContext);
        let helpInformation = this.helpInformation({ error: outputContext.error });
        if (deprecatedCallback) {
          helpInformation = deprecatedCallback(helpInformation);
          if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
            throw new Error("outputHelp callback must return a string or a Buffer");
          }
        }
        outputContext.write(helpInformation);
        if (this._getHelpOption()?.long) {
          this.emit(this._getHelpOption().long);
        }
        this.emit("afterHelp", eventContext);
        this._getCommandAndAncestors().forEach(
          (command) => command.emit("afterAllHelp", eventContext)
        );
      }
      /**
       * You can pass in flags and a description to customise the built-in help option.
       * Pass in false to disable the built-in help option.
       *
       * @example
       * program.helpOption('-?, --help' 'show help'); // customise
       * program.helpOption(false); // disable
       *
       * @param {(string | boolean)} flags
       * @param {string} [description]
       * @return {Command} `this` command for chaining
       */
      helpOption(flags, description) {
        if (typeof flags === "boolean") {
          if (flags) {
            if (this._helpOption === null) this._helpOption = void 0;
            if (this._defaultOptionGroup) {
              this._initOptionGroup(this._getHelpOption());
            }
          } else {
            this._helpOption = null;
          }
          return this;
        }
        this._helpOption = this.createOption(
          flags ?? "-h, --help",
          description ?? "display help for command"
        );
        if (flags || description) this._initOptionGroup(this._helpOption);
        return this;
      }
      /**
       * Lazy create help option.
       * Returns null if has been disabled with .helpOption(false).
       *
       * @returns {(Option | null)} the help option
       * @package
       */
      _getHelpOption() {
        if (this._helpOption === void 0) {
          this.helpOption(void 0, void 0);
        }
        return this._helpOption;
      }
      /**
       * Supply your own option to use for the built-in help option.
       * This is an alternative to using helpOption() to customise the flags and description etc.
       *
       * @param {Option} option
       * @return {Command} `this` command for chaining
       */
      addHelpOption(option) {
        this._helpOption = option;
        this._initOptionGroup(option);
        return this;
      }
      /**
       * Output help information and exit.
       *
       * Outputs built-in help, and custom text added using `.addHelpText()`.
       *
       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout
       */
      help(contextOptions) {
        this.outputHelp(contextOptions);
        let exitCode = Number(process2.exitCode ?? 0);
        if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
          exitCode = 1;
        }
        this._exit(exitCode, "commander.help", "(outputHelp)");
      }
      /**
       * // Do a little typing to coordinate emit and listener for the help text events.
       * @typedef HelpTextEventContext
       * @type {object}
       * @property {boolean} error
       * @property {Command} command
       * @property {function} write
       */
      /**
       * Add additional text to be displayed with the built-in help.
       *
       * Position is 'before' or 'after' to affect just this command,
       * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
       *
       * @param {string} position - before or after built-in help
       * @param {(string | Function)} text - string to add, or a function returning a string
       * @return {Command} `this` command for chaining
       */
      addHelpText(position, text) {
        const allowedValues = ["beforeAll", "before", "after", "afterAll"];
        if (!allowedValues.includes(position)) {
          throw new Error(`Unexpected value for position to addHelpText.
Expecting one of '${allowedValues.join("', '")}'`);
        }
        const helpEvent = `${position}Help`;
        this.on(helpEvent, (context) => {
          let helpStr;
          if (typeof text === "function") {
            helpStr = text({ error: context.error, command: context.command });
          } else {
            helpStr = text;
          }
          if (helpStr) {
            context.write(`${helpStr}
`);
          }
        });
        return this;
      }
      /**
       * Output help information if help flags specified
       *
       * @param {Array} args - array of options to search for help flags
       * @private
       */
      _outputHelpIfRequested(args) {
        const helpOption = this._getHelpOption();
        const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
        if (helpRequested) {
          this.outputHelp();
          this._exit(0, "commander.helpDisplayed", "(outputHelp)");
        }
      }
    };
    function incrementNodeInspectorPort(args) {
      return args.map((arg) => {
        if (!arg.startsWith("--inspect")) {
          return arg;
        }
        let debugOption;
        let debugHost = "127.0.0.1";
        let debugPort = "9229";
        let match;
        if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
          debugOption = match[1];
        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
          debugOption = match[1];
          if (/^\d+$/.test(match[3])) {
            debugPort = match[3];
          } else {
            debugHost = match[3];
          }
        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
          debugOption = match[1];
          debugHost = match[3];
          debugPort = match[4];
        }
        if (debugOption && debugPort !== "0") {
          return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
        }
        return arg;
      });
    }
    function useColor() {
      if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
        return false;
      if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== void 0)
        return true;
      return void 0;
    }
    exports2.Command = Command2;
    exports2.useColor = useColor;
  }
});

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/index.js
var require_commander = __commonJS({
  "node_modules/.pnpm/commander@14.0.2/node_modules/commander/index.js"(exports2) {
    var { Argument: Argument2 } = require_argument();
    var { Command: Command2 } = require_command();
    var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
    var { Help: Help2 } = require_help();
    var { Option: Option2 } = require_option();
    exports2.program = new Command2();
    exports2.createCommand = (name) => new Command2(name);
    exports2.createOption = (flags, description) => new Option2(flags, description);
    exports2.createArgument = (name, description) => new Argument2(name, description);
    exports2.Command = Command2;
    exports2.Option = Option2;
    exports2.Argument = Argument2;
    exports2.Help = Help2;
    exports2.CommanderError = CommanderError2;
    exports2.InvalidArgumentError = InvalidArgumentError2;
    exports2.InvalidOptionArgumentError = InvalidArgumentError2;
  }
});

// src/cli/index.ts
var import_node_fs = require("node:fs");
var import_node_path = require("node:path");

// node_modules/.pnpm/commander@14.0.2/node_modules/commander/esm.mjs
var import_index = __toESM(require_commander(), 1);
var {
  program,
  createCommand,
  createArgument,
  createOption,
  CommanderError,
  InvalidArgumentError,
  InvalidOptionArgumentError,
  // deprecated old name
  Command,
  Argument,
  Option,
  Help
} = import_index.default;

// src/core/defaults.ts
var defaults = {
  timeStep: 0.1,
  vehicleType: "triangle",
  wheelbase: 2.5,
  vehicleWidth: 1.2,
  title: "Simulation Visualization",
  confidenceScale: 2
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/external.js
var external_exports = {};
__export(external_exports, {
  $brand: () => $brand,
  $input: () => $input,
  $output: () => $output,
  NEVER: () => NEVER,
  TimePrecision: () => TimePrecision,
  ZodAny: () => ZodAny,
  ZodArray: () => ZodArray,
  ZodBase64: () => ZodBase64,
  ZodBase64URL: () => ZodBase64URL,
  ZodBigInt: () => ZodBigInt,
  ZodBigIntFormat: () => ZodBigIntFormat,
  ZodBoolean: () => ZodBoolean,
  ZodCIDRv4: () => ZodCIDRv4,
  ZodCIDRv6: () => ZodCIDRv6,
  ZodCUID: () => ZodCUID,
  ZodCUID2: () => ZodCUID2,
  ZodCatch: () => ZodCatch,
  ZodCodec: () => ZodCodec,
  ZodCustom: () => ZodCustom,
  ZodCustomStringFormat: () => ZodCustomStringFormat,
  ZodDate: () => ZodDate,
  ZodDefault: () => ZodDefault,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
  ZodE164: () => ZodE164,
  ZodEmail: () => ZodEmail,
  ZodEmoji: () => ZodEmoji,
  ZodEnum: () => ZodEnum,
  ZodError: () => ZodError,
  ZodExactOptional: () => ZodExactOptional,
  ZodFile: () => ZodFile,
  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
  ZodFunction: () => ZodFunction,
  ZodGUID: () => ZodGUID,
  ZodIPv4: () => ZodIPv4,
  ZodIPv6: () => ZodIPv6,
  ZodISODate: () => ZodISODate,
  ZodISODateTime: () => ZodISODateTime,
  ZodISODuration: () => ZodISODuration,
  ZodISOTime: () => ZodISOTime,
  ZodIntersection: () => ZodIntersection,
  ZodIssueCode: () => ZodIssueCode,
  ZodJWT: () => ZodJWT,
  ZodKSUID: () => ZodKSUID,
  ZodLazy: () => ZodLazy,
  ZodLiteral: () => ZodLiteral,
  ZodMAC: () => ZodMAC,
  ZodMap: () => ZodMap,
  ZodNaN: () => ZodNaN,
  ZodNanoID: () => ZodNanoID,
  ZodNever: () => ZodNever,
  ZodNonOptional: () => ZodNonOptional,
  ZodNull: () => ZodNull,
  ZodNullable: () => ZodNullable,
  ZodNumber: () => ZodNumber,
  ZodNumberFormat: () => ZodNumberFormat,
  ZodObject: () => ZodObject,
  ZodOptional: () => ZodOptional,
  ZodPipe: () => ZodPipe,
  ZodPrefault: () => ZodPrefault,
  ZodPromise: () => ZodPromise,
  ZodReadonly: () => ZodReadonly,
  ZodRealError: () => ZodRealError,
  ZodRecord: () => ZodRecord,
  ZodSet: () => ZodSet,
  ZodString: () => ZodString,
  ZodStringFormat: () => ZodStringFormat,
  ZodSuccess: () => ZodSuccess,
  ZodSymbol: () => ZodSymbol,
  ZodTemplateLiteral: () => ZodTemplateLiteral,
  ZodTransform: () => ZodTransform,
  ZodTuple: () => ZodTuple,
  ZodType: () => ZodType,
  ZodULID: () => ZodULID,
  ZodURL: () => ZodURL,
  ZodUUID: () => ZodUUID,
  ZodUndefined: () => ZodUndefined,
  ZodUnion: () => ZodUnion,
  ZodUnknown: () => ZodUnknown,
  ZodVoid: () => ZodVoid,
  ZodXID: () => ZodXID,
  ZodXor: () => ZodXor,
  _ZodString: () => _ZodString,
  _default: () => _default2,
  _function: () => _function,
  any: () => any,
  array: () => array,
  base64: () => base642,
  base64url: () => base64url2,
  bigint: () => bigint2,
  boolean: () => boolean2,
  catch: () => _catch2,
  check: () => check,
  cidrv4: () => cidrv42,
  cidrv6: () => cidrv62,
  clone: () => clone,
  codec: () => codec,
  coerce: () => coerce_exports,
  config: () => config,
  core: () => core_exports2,
  cuid: () => cuid3,
  cuid2: () => cuid22,
  custom: () => custom,
  date: () => date3,
  decode: () => decode2,
  decodeAsync: () => decodeAsync2,
  describe: () => describe2,
  discriminatedUnion: () => discriminatedUnion,
  e164: () => e1642,
  email: () => email2,
  emoji: () => emoji2,
  encode: () => encode2,
  encodeAsync: () => encodeAsync2,
  endsWith: () => _endsWith,
  enum: () => _enum2,
  exactOptional: () => exactOptional,
  file: () => file,
  flattenError: () => flattenError,
  float32: () => float32,
  float64: () => float64,
  formatError: () => formatError,
  fromJSONSchema: () => fromJSONSchema,
  function: () => _function,
  getErrorMap: () => getErrorMap,
  globalRegistry: () => globalRegistry,
  gt: () => _gt,
  gte: () => _gte,
  guid: () => guid2,
  hash: () => hash,
  hex: () => hex2,
  hostname: () => hostname2,
  httpUrl: () => httpUrl,
  includes: () => _includes,
  instanceof: () => _instanceof,
  int: () => int,
  int32: () => int32,
  int64: () => int64,
  intersection: () => intersection,
  ipv4: () => ipv42,
  ipv6: () => ipv62,
  iso: () => iso_exports,
  json: () => json,
  jwt: () => jwt,
  keyof: () => keyof,
  ksuid: () => ksuid2,
  lazy: () => lazy,
  length: () => _length,
  literal: () => literal,
  locales: () => locales_exports,
  looseObject: () => looseObject,
  looseRecord: () => looseRecord,
  lowercase: () => _lowercase,
  lt: () => _lt,
  lte: () => _lte,
  mac: () => mac2,
  map: () => map,
  maxLength: () => _maxLength,
  maxSize: () => _maxSize,
  meta: () => meta2,
  mime: () => _mime,
  minLength: () => _minLength,
  minSize: () => _minSize,
  multipleOf: () => _multipleOf,
  nan: () => nan,
  nanoid: () => nanoid2,
  nativeEnum: () => nativeEnum,
  negative: () => _negative,
  never: () => never,
  nonnegative: () => _nonnegative,
  nonoptional: () => nonoptional,
  nonpositive: () => _nonpositive,
  normalize: () => _normalize,
  null: () => _null3,
  nullable: () => nullable,
  nullish: () => nullish2,
  number: () => number2,
  object: () => object,
  optional: () => optional,
  overwrite: () => _overwrite,
  parse: () => parse2,
  parseAsync: () => parseAsync2,
  partialRecord: () => partialRecord,
  pipe: () => pipe,
  positive: () => _positive,
  prefault: () => prefault,
  preprocess: () => preprocess,
  prettifyError: () => prettifyError,
  promise: () => promise,
  property: () => _property,
  readonly: () => readonly,
  record: () => record,
  refine: () => refine,
  regex: () => _regex,
  regexes: () => regexes_exports,
  registry: () => registry,
  safeDecode: () => safeDecode2,
  safeDecodeAsync: () => safeDecodeAsync2,
  safeEncode: () => safeEncode2,
  safeEncodeAsync: () => safeEncodeAsync2,
  safeParse: () => safeParse2,
  safeParseAsync: () => safeParseAsync2,
  set: () => set,
  setErrorMap: () => setErrorMap,
  size: () => _size,
  slugify: () => _slugify,
  startsWith: () => _startsWith,
  strictObject: () => strictObject,
  string: () => string2,
  stringFormat: () => stringFormat,
  stringbool: () => stringbool,
  success: () => success,
  superRefine: () => superRefine,
  symbol: () => symbol,
  templateLiteral: () => templateLiteral,
  toJSONSchema: () => toJSONSchema,
  toLowerCase: () => _toLowerCase,
  toUpperCase: () => _toUpperCase,
  transform: () => transform,
  treeifyError: () => treeifyError,
  trim: () => _trim,
  tuple: () => tuple,
  uint32: () => uint32,
  uint64: () => uint64,
  ulid: () => ulid2,
  undefined: () => _undefined3,
  union: () => union,
  unknown: () => unknown,
  uppercase: () => _uppercase,
  url: () => url,
  util: () => util_exports,
  uuid: () => uuid2,
  uuidv4: () => uuidv4,
  uuidv6: () => uuidv6,
  uuidv7: () => uuidv7,
  void: () => _void2,
  xid: () => xid2,
  xor: () => xor
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/index.js
var core_exports2 = {};
__export(core_exports2, {
  $ZodAny: () => $ZodAny,
  $ZodArray: () => $ZodArray,
  $ZodAsyncError: () => $ZodAsyncError,
  $ZodBase64: () => $ZodBase64,
  $ZodBase64URL: () => $ZodBase64URL,
  $ZodBigInt: () => $ZodBigInt,
  $ZodBigIntFormat: () => $ZodBigIntFormat,
  $ZodBoolean: () => $ZodBoolean,
  $ZodCIDRv4: () => $ZodCIDRv4,
  $ZodCIDRv6: () => $ZodCIDRv6,
  $ZodCUID: () => $ZodCUID,
  $ZodCUID2: () => $ZodCUID2,
  $ZodCatch: () => $ZodCatch,
  $ZodCheck: () => $ZodCheck,
  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
  $ZodCheckIncludes: () => $ZodCheckIncludes,
  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
  $ZodCheckLessThan: () => $ZodCheckLessThan,
  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
  $ZodCheckMimeType: () => $ZodCheckMimeType,
  $ZodCheckMinLength: () => $ZodCheckMinLength,
  $ZodCheckMinSize: () => $ZodCheckMinSize,
  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
  $ZodCheckProperty: () => $ZodCheckProperty,
  $ZodCheckRegex: () => $ZodCheckRegex,
  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
  $ZodCodec: () => $ZodCodec,
  $ZodCustom: () => $ZodCustom,
  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
  $ZodDate: () => $ZodDate,
  $ZodDefault: () => $ZodDefault,
  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
  $ZodE164: () => $ZodE164,
  $ZodEmail: () => $ZodEmail,
  $ZodEmoji: () => $ZodEmoji,
  $ZodEncodeError: () => $ZodEncodeError,
  $ZodEnum: () => $ZodEnum,
  $ZodError: () => $ZodError,
  $ZodExactOptional: () => $ZodExactOptional,
  $ZodFile: () => $ZodFile,
  $ZodFunction: () => $ZodFunction,
  $ZodGUID: () => $ZodGUID,
  $ZodIPv4: () => $ZodIPv4,
  $ZodIPv6: () => $ZodIPv6,
  $ZodISODate: () => $ZodISODate,
  $ZodISODateTime: () => $ZodISODateTime,
  $ZodISODuration: () => $ZodISODuration,
  $ZodISOTime: () => $ZodISOTime,
  $ZodIntersection: () => $ZodIntersection,
  $ZodJWT: () => $ZodJWT,
  $ZodKSUID: () => $ZodKSUID,
  $ZodLazy: () => $ZodLazy,
  $ZodLiteral: () => $ZodLiteral,
  $ZodMAC: () => $ZodMAC,
  $ZodMap: () => $ZodMap,
  $ZodNaN: () => $ZodNaN,
  $ZodNanoID: () => $ZodNanoID,
  $ZodNever: () => $ZodNever,
  $ZodNonOptional: () => $ZodNonOptional,
  $ZodNull: () => $ZodNull,
  $ZodNullable: () => $ZodNullable,
  $ZodNumber: () => $ZodNumber,
  $ZodNumberFormat: () => $ZodNumberFormat,
  $ZodObject: () => $ZodObject,
  $ZodObjectJIT: () => $ZodObjectJIT,
  $ZodOptional: () => $ZodOptional,
  $ZodPipe: () => $ZodPipe,
  $ZodPrefault: () => $ZodPrefault,
  $ZodPromise: () => $ZodPromise,
  $ZodReadonly: () => $ZodReadonly,
  $ZodRealError: () => $ZodRealError,
  $ZodRecord: () => $ZodRecord,
  $ZodRegistry: () => $ZodRegistry,
  $ZodSet: () => $ZodSet,
  $ZodString: () => $ZodString,
  $ZodStringFormat: () => $ZodStringFormat,
  $ZodSuccess: () => $ZodSuccess,
  $ZodSymbol: () => $ZodSymbol,
  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
  $ZodTransform: () => $ZodTransform,
  $ZodTuple: () => $ZodTuple,
  $ZodType: () => $ZodType,
  $ZodULID: () => $ZodULID,
  $ZodURL: () => $ZodURL,
  $ZodUUID: () => $ZodUUID,
  $ZodUndefined: () => $ZodUndefined,
  $ZodUnion: () => $ZodUnion,
  $ZodUnknown: () => $ZodUnknown,
  $ZodVoid: () => $ZodVoid,
  $ZodXID: () => $ZodXID,
  $ZodXor: () => $ZodXor,
  $brand: () => $brand,
  $constructor: () => $constructor,
  $input: () => $input,
  $output: () => $output,
  Doc: () => Doc,
  JSONSchema: () => json_schema_exports,
  JSONSchemaGenerator: () => JSONSchemaGenerator,
  NEVER: () => NEVER,
  TimePrecision: () => TimePrecision,
  _any: () => _any,
  _array: () => _array,
  _base64: () => _base64,
  _base64url: () => _base64url,
  _bigint: () => _bigint,
  _boolean: () => _boolean,
  _catch: () => _catch,
  _check: () => _check,
  _cidrv4: () => _cidrv4,
  _cidrv6: () => _cidrv6,
  _coercedBigint: () => _coercedBigint,
  _coercedBoolean: () => _coercedBoolean,
  _coercedDate: () => _coercedDate,
  _coercedNumber: () => _coercedNumber,
  _coercedString: () => _coercedString,
  _cuid: () => _cuid,
  _cuid2: () => _cuid2,
  _custom: () => _custom,
  _date: () => _date,
  _decode: () => _decode,
  _decodeAsync: () => _decodeAsync,
  _default: () => _default,
  _discriminatedUnion: () => _discriminatedUnion,
  _e164: () => _e164,
  _email: () => _email,
  _emoji: () => _emoji2,
  _encode: () => _encode,
  _encodeAsync: () => _encodeAsync,
  _endsWith: () => _endsWith,
  _enum: () => _enum,
  _file: () => _file,
  _float32: () => _float32,
  _float64: () => _float64,
  _gt: () => _gt,
  _gte: () => _gte,
  _guid: () => _guid,
  _includes: () => _includes,
  _int: () => _int,
  _int32: () => _int32,
  _int64: () => _int64,
  _intersection: () => _intersection,
  _ipv4: () => _ipv4,
  _ipv6: () => _ipv6,
  _isoDate: () => _isoDate,
  _isoDateTime: () => _isoDateTime,
  _isoDuration: () => _isoDuration,
  _isoTime: () => _isoTime,
  _jwt: () => _jwt,
  _ksuid: () => _ksuid,
  _lazy: () => _lazy,
  _length: () => _length,
  _literal: () => _literal,
  _lowercase: () => _lowercase,
  _lt: () => _lt,
  _lte: () => _lte,
  _mac: () => _mac,
  _map: () => _map,
  _max: () => _lte,
  _maxLength: () => _maxLength,
  _maxSize: () => _maxSize,
  _mime: () => _mime,
  _min: () => _gte,
  _minLength: () => _minLength,
  _minSize: () => _minSize,
  _multipleOf: () => _multipleOf,
  _nan: () => _nan,
  _nanoid: () => _nanoid,
  _nativeEnum: () => _nativeEnum,
  _negative: () => _negative,
  _never: () => _never,
  _nonnegative: () => _nonnegative,
  _nonoptional: () => _nonoptional,
  _nonpositive: () => _nonpositive,
  _normalize: () => _normalize,
  _null: () => _null2,
  _nullable: () => _nullable,
  _number: () => _number,
  _optional: () => _optional,
  _overwrite: () => _overwrite,
  _parse: () => _parse,
  _parseAsync: () => _parseAsync,
  _pipe: () => _pipe,
  _positive: () => _positive,
  _promise: () => _promise,
  _property: () => _property,
  _readonly: () => _readonly,
  _record: () => _record,
  _refine: () => _refine,
  _regex: () => _regex,
  _safeDecode: () => _safeDecode,
  _safeDecodeAsync: () => _safeDecodeAsync,
  _safeEncode: () => _safeEncode,
  _safeEncodeAsync: () => _safeEncodeAsync,
  _safeParse: () => _safeParse,
  _safeParseAsync: () => _safeParseAsync,
  _set: () => _set,
  _size: () => _size,
  _slugify: () => _slugify,
  _startsWith: () => _startsWith,
  _string: () => _string,
  _stringFormat: () => _stringFormat,
  _stringbool: () => _stringbool,
  _success: () => _success,
  _superRefine: () => _superRefine,
  _symbol: () => _symbol,
  _templateLiteral: () => _templateLiteral,
  _toLowerCase: () => _toLowerCase,
  _toUpperCase: () => _toUpperCase,
  _transform: () => _transform,
  _trim: () => _trim,
  _tuple: () => _tuple,
  _uint32: () => _uint32,
  _uint64: () => _uint64,
  _ulid: () => _ulid,
  _undefined: () => _undefined2,
  _union: () => _union,
  _unknown: () => _unknown,
  _uppercase: () => _uppercase,
  _url: () => _url,
  _uuid: () => _uuid,
  _uuidv4: () => _uuidv4,
  _uuidv6: () => _uuidv6,
  _uuidv7: () => _uuidv7,
  _void: () => _void,
  _xid: () => _xid,
  _xor: () => _xor,
  clone: () => clone,
  config: () => config,
  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
  decode: () => decode,
  decodeAsync: () => decodeAsync,
  describe: () => describe,
  encode: () => encode,
  encodeAsync: () => encodeAsync,
  extractDefs: () => extractDefs,
  finalize: () => finalize,
  flattenError: () => flattenError,
  formatError: () => formatError,
  globalConfig: () => globalConfig,
  globalRegistry: () => globalRegistry,
  initializeContext: () => initializeContext,
  isValidBase64: () => isValidBase64,
  isValidBase64URL: () => isValidBase64URL,
  isValidJWT: () => isValidJWT,
  locales: () => locales_exports,
  meta: () => meta,
  parse: () => parse,
  parseAsync: () => parseAsync,
  prettifyError: () => prettifyError,
  process: () => process,
  regexes: () => regexes_exports,
  registry: () => registry,
  safeDecode: () => safeDecode,
  safeDecodeAsync: () => safeDecodeAsync,
  safeEncode: () => safeEncode,
  safeEncodeAsync: () => safeEncodeAsync,
  safeParse: () => safeParse,
  safeParseAsync: () => safeParseAsync,
  toDotPath: () => toDotPath,
  toJSONSchema: () => toJSONSchema,
  treeifyError: () => treeifyError,
  util: () => util_exports,
  version: () => version
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/core.js
var NEVER = Object.freeze({
  status: "aborted"
});
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, params) {
  function init(inst, def) {
    if (!inst._zod) {
      Object.defineProperty(inst, "_zod", {
        value: {
          def,
          constr: _,
          traits: /* @__PURE__ */ new Set()
        },
        enumerable: false
      });
    }
    if (inst._zod.traits.has(name)) {
      return;
    }
    inst._zod.traits.add(name);
    initializer3(inst, def);
    const proto = _.prototype;
    const keys = Object.keys(proto);
    for (let i = 0; i < keys.length; i++) {
      const k = keys[i];
      if (!(k in inst)) {
        inst[k] = proto[k].bind(inst);
      }
    }
  }
  const Parent = params?.Parent ?? Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name });
  function _(def) {
    var _a2;
    const inst = params?.Parent ? new Definition() : this;
    init(inst, def);
    (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      if (params?.Parent && inst instanceof params.Parent)
        return true;
      return inst?._zod?.traits?.has(name);
    }
  });
  Object.defineProperty(_, "name", { value: name });
  return _;
}
var $brand = /* @__PURE__ */ Symbol("zod_brand");
var $ZodAsyncError = class extends Error {
  constructor() {
    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
  }
};
var $ZodEncodeError = class extends Error {
  constructor(name) {
    super(`Encountered unidirectional transform during encode: ${name}`);
    this.name = "ZodEncodeError";
  }
};
var globalConfig = {};
function config(newConfig) {
  if (newConfig)
    Object.assign(globalConfig, newConfig);
  return globalConfig;
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
  Class: () => Class,
  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
  aborted: () => aborted,
  allowsEval: () => allowsEval,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertIs: () => assertIs,
  assertNever: () => assertNever,
  assertNotEqual: () => assertNotEqual,
  assignProp: () => assignProp,
  base64ToUint8Array: () => base64ToUint8Array,
  base64urlToUint8Array: () => base64urlToUint8Array,
  cached: () => cached,
  captureStackTrace: () => captureStackTrace,
  cleanEnum: () => cleanEnum,
  cleanRegex: () => cleanRegex,
  clone: () => clone,
  cloneDef: () => cloneDef,
  createTransparentProxy: () => createTransparentProxy,
  defineLazy: () => defineLazy,
  esc: () => esc,
  escapeRegex: () => escapeRegex,
  extend: () => extend,
  finalizeIssue: () => finalizeIssue,
  floatSafeRemainder: () => floatSafeRemainder,
  getElementAtPath: () => getElementAtPath,
  getEnumValues: () => getEnumValues,
  getLengthableOrigin: () => getLengthableOrigin,
  getParsedType: () => getParsedType,
  getSizableOrigin: () => getSizableOrigin,
  hexToUint8Array: () => hexToUint8Array,
  isObject: () => isObject,
  isPlainObject: () => isPlainObject,
  issue: () => issue,
  joinValues: () => joinValues,
  jsonStringifyReplacer: () => jsonStringifyReplacer,
  merge: () => merge,
  mergeDefs: () => mergeDefs,
  normalizeParams: () => normalizeParams,
  nullish: () => nullish,
  numKeys: () => numKeys,
  objectClone: () => objectClone,
  omit: () => omit,
  optionalKeys: () => optionalKeys,
  parsedType: () => parsedType,
  partial: () => partial,
  pick: () => pick,
  prefixIssues: () => prefixIssues,
  primitiveTypes: () => primitiveTypes,
  promiseAllObject: () => promiseAllObject,
  propertyKeyTypes: () => propertyKeyTypes,
  randomString: () => randomString,
  required: () => required,
  safeExtend: () => safeExtend,
  shallowClone: () => shallowClone,
  slugify: () => slugify,
  stringifyPrimitive: () => stringifyPrimitive,
  uint8ArrayToBase64: () => uint8ArrayToBase64,
  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
  uint8ArrayToHex: () => uint8ArrayToHex,
  unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
  return val;
}
function assertNotEqual(val) {
  return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
  throw new Error("Unexpected value in exhaustive check");
}
function assert(_) {
}
function getEnumValues(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues(array2, separator = "|") {
  return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached(getter) {
  const set2 = false;
  return {
    get value() {
      if (!set2) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish(input) {
  return input === null || input === void 0;
}
function cleanRegex(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
  const valDecCount = (val.toString().split(".")[1] || "").length;
  const stepString = step.toString();
  let stepDecCount = (stepString.split(".")[1] || "").length;
  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
    const match = stepString.match(/\d?e-(\d?)/);
    if (match?.[1]) {
      stepDecCount = Number.parseInt(match[1]);
    }
  }
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
function defineLazy(object2, key, getter) {
  let value = void 0;
  Object.defineProperty(object2, key, {
    get() {
      if (value === EVALUATING) {
        return void 0;
      }
      if (value === void 0) {
        value = EVALUATING;
        value = getter();
      }
      return value;
    },
    set(v) {
      Object.defineProperty(object2, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function objectClone(obj) {
  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function mergeDefs(...defs) {
  const mergedDescriptors = {};
  for (const def of defs) {
    const descriptors = Object.getOwnPropertyDescriptors(def);
    Object.assign(mergedDescriptors, descriptors);
  }
  return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef(schema) {
  return mergeDefs(schema._zod.def);
}
function getElementAtPath(obj, path) {
  if (!path)
    return obj;
  return path.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
  const keys = Object.keys(promisesObj);
  const promises = keys.map((key) => promisesObj[key]);
  return Promise.all(promises).then((results) => {
    const resolvedObj = {};
    for (let i = 0; i < keys.length; i++) {
      resolvedObj[keys[i]] = results[i];
    }
    return resolvedObj;
  });
}
function randomString(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc(str) {
  return JSON.stringify(str);
}
function slugify(input) {
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
};
function isObject(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = cached(() => {
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
    return false;
  }
  try {
    const F = Function;
    new F("");
    return true;
  } catch (_) {
    return false;
  }
});
function isPlainObject(o) {
  if (isObject(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  if (typeof ctor !== "function")
    return true;
  const prot = ctor.prototype;
  if (isObject(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function shallowClone(o) {
  if (isPlainObject(o))
    return { ...o };
  if (Array.isArray(o))
    return [...o];
  return o;
}
function numKeys(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
var getParsedType = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return "undefined";
    case "string":
      return "string";
    case "number":
      return Number.isNaN(data) ? "nan" : "number";
    case "boolean":
      return "boolean";
    case "function":
      return "function";
    case "bigint":
      return "bigint";
    case "symbol":
      return "symbol";
    case "object":
      if (Array.isArray(data)) {
        return "array";
      }
      if (data === null) {
        return "null";
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return "promise";
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return "map";
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return "set";
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return "date";
      }
      if (typeof File !== "undefined" && data instanceof File) {
        return "file";
      }
      return "object";
    default:
      throw new Error(`Unknown data type: ${t}`);
  }
};
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
  const cl = new inst._zod.constr(def ?? inst._zod.def);
  if (!def || params?.parent)
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if (params?.message !== void 0) {
    if (params?.error !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target ?? (target = getter());
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target ?? (target = getter());
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target ?? (target = getter());
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target ?? (target = getter());
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target ?? (target = getter());
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target ?? (target = getter());
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target ?? (target = getter());
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
var NUMBER_FORMAT_RANGES = {
  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
  int32: [-2147483648, 2147483647],
  uint32: [0, 4294967295],
  float32: [-34028234663852886e22, 34028234663852886e22],
  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
};
var BIGINT_FORMAT_RANGES = {
  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".pick() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = {};
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        newShape[key] = currDef.shape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function omit(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".omit() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = { ...schema._zod.def.shape };
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        delete newShape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function extend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const checks = schema._zod.def.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    const existingShape = schema._zod.def.shape;
    for (const key in shape) {
      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
      }
    }
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function safeExtend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to safeExtend: expected a plain object");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function merge(a, b) {
  const def = mergeDefs(a._zod.def, {
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    get catchall() {
      return b._zod.def.catchall;
    },
    checks: []
    // delete existing checks
  });
  return clone(a, def);
}
function partial(Class2, schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".partial() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in oldShape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      } else {
        for (const key in oldShape) {
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    },
    checks: []
  });
  return clone(schema, def);
}
function required(Class2, schema, mask) {
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in shape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      } else {
        for (const key in oldShape) {
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    }
  });
  return clone(schema, def);
}
function aborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue !== true) {
      return true;
    }
  }
  return false;
}
function prefixIssues(path, issues) {
  return issues.map((iss) => {
    var _a2;
    (_a2 = iss).path ?? (_a2.path = []);
    iss.path.unshift(path);
    return iss;
  });
}
function unwrapMessage(message) {
  return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
  const full = { ...iss, path: iss.path ?? [] };
  if (!iss.message) {
    const message = unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
    full.message = message;
  }
  delete full.inst;
  delete full.continue;
  if (!ctx?.reportInput) {
    delete full.input;
  }
  return full;
}
function getSizableOrigin(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function parsedType(data) {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "nan" : "number";
    }
    case "object": {
      if (data === null) {
        return "null";
      }
      if (Array.isArray(data)) {
        return "array";
      }
      const obj = data;
      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
        return obj.constructor.name;
      }
    }
  }
  return t;
}
function issue(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
function base64ToUint8Array(base643) {
  const binaryString = atob(base643);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
function uint8ArrayToBase64(bytes) {
  let binaryString = "";
  for (let i = 0; i < bytes.length; i++) {
    binaryString += String.fromCharCode(bytes[i]);
  }
  return btoa(binaryString);
}
function base64urlToUint8Array(base64url3) {
  const base643 = base64url3.replace(/-/g, "+").replace(/_/g, "/");
  const padding = "=".repeat((4 - base643.length % 4) % 4);
  return base64ToUint8Array(base643 + padding);
}
function uint8ArrayToBase64url(bytes) {
  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(hex3) {
  const cleanHex = hex3.replace(/^0x/, "");
  if (cleanHex.length % 2 !== 0) {
    throw new Error("Invalid hex string length");
  }
  const bytes = new Uint8Array(cleanHex.length / 2);
  for (let i = 0; i < cleanHex.length; i += 2) {
    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
  }
  return bytes;
}
function uint8ArrayToHex(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var Class = class {
  constructor(..._args) {
  }
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
  inst.name = "$ZodError";
  Object.defineProperty(inst, "_zod", {
    value: inst._zod,
    enumerable: false
  });
  Object.defineProperty(inst, "issues", {
    value: def,
    enumerable: false
  });
  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
  Object.defineProperty(inst, "toString", {
    value: () => inst.message,
    enumerable: false
  });
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error48, mapper = (issue2) => issue2.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error48.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError(error48, mapper = (issue2) => issue2.message) {
  const fieldErrors = { _errors: [] };
  const processError = (error49) => {
    for (const issue2 of error49.issues) {
      if (issue2.code === "invalid_union" && issue2.errors.length) {
        issue2.errors.map((issues) => processError({ issues }));
      } else if (issue2.code === "invalid_key") {
        processError({ issues: issue2.issues });
      } else if (issue2.code === "invalid_element") {
        processError({ issues: issue2.issues });
      } else if (issue2.path.length === 0) {
        fieldErrors._errors.push(mapper(issue2));
      } else {
        let curr = fieldErrors;
        let i = 0;
        while (i < issue2.path.length) {
          const el = issue2.path[i];
          const terminal = i === issue2.path.length - 1;
          if (!terminal) {
            curr[el] = curr[el] || { _errors: [] };
          } else {
            curr[el] = curr[el] || { _errors: [] };
            curr[el]._errors.push(mapper(issue2));
          }
          curr = curr[el];
          i++;
        }
      }
    }
  };
  processError(error48);
  return fieldErrors;
}
function treeifyError(error48, mapper = (issue2) => issue2.message) {
  const result = { errors: [] };
  const processError = (error49, path = []) => {
    var _a2, _b;
    for (const issue2 of error49.issues) {
      if (issue2.code === "invalid_union" && issue2.errors.length) {
        issue2.errors.map((issues) => processError({ issues }, issue2.path));
      } else if (issue2.code === "invalid_key") {
        processError({ issues: issue2.issues }, issue2.path);
      } else if (issue2.code === "invalid_element") {
        processError({ issues: issue2.issues }, issue2.path);
      } else {
        const fullpath = [...path, ...issue2.path];
        if (fullpath.length === 0) {
          result.errors.push(mapper(issue2));
          continue;
        }
        let curr = result;
        let i = 0;
        while (i < fullpath.length) {
          const el = fullpath[i];
          const terminal = i === fullpath.length - 1;
          if (typeof el === "string") {
            curr.properties ?? (curr.properties = {});
            (_a2 = curr.properties)[el] ?? (_a2[el] = { errors: [] });
            curr = curr.properties[el];
          } else {
            curr.items ?? (curr.items = []);
            (_b = curr.items)[el] ?? (_b[el] = { errors: [] });
            curr = curr.items[el];
          }
          if (terminal) {
            curr.errors.push(mapper(issue2));
          }
          i++;
        }
      }
    }
  };
  processError(error48);
  return result;
}
function toDotPath(_path) {
  const segs = [];
  const path = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
  for (const seg of path) {
    if (typeof seg === "number")
      segs.push(`[${seg}]`);
    else if (typeof seg === "symbol")
      segs.push(`[${JSON.stringify(String(seg))}]`);
    else if (/[^\w$]/.test(seg))
      segs.push(`[${JSON.stringify(seg)}]`);
    else {
      if (segs.length)
        segs.push(".");
      segs.push(seg);
    }
  }
  return segs.join("");
}
function prettifyError(error48) {
  const lines = [];
  const issues = [...error48.issues].sort((a, b) => (a.path ?? []).length - (b.path ?? []).length);
  for (const issue2 of issues) {
    lines.push(`\u2716 ${issue2.message}`);
    if (issue2.path?.length)
      lines.push(`  \u2192 at ${toDotPath(issue2.path)}`);
  }
  return lines.join("\n");
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  if (result.issues.length) {
    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, _params?.callee);
    throw e;
  }
  return result.value;
};
var parse = /* @__PURE__ */ _parse($ZodRealError);
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  if (result.issues.length) {
    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, params?.callee);
    throw e;
  }
  return result.value;
};
var parseAsync = /* @__PURE__ */ _parseAsync($ZodRealError);
var _safeParse = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  return result.issues.length ? {
    success: false,
    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  return result.issues.length ? {
    success: false,
    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
var _encode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
  return _parse(_Err)(schema, value, ctx);
};
var encode = /* @__PURE__ */ _encode($ZodRealError);
var _decode = (_Err) => (schema, value, _ctx) => {
  return _parse(_Err)(schema, value, _ctx);
};
var decode = /* @__PURE__ */ _decode($ZodRealError);
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
  return _parseAsync(_Err)(schema, value, ctx);
};
var encodeAsync = /* @__PURE__ */ _encodeAsync($ZodRealError);
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _parseAsync(_Err)(schema, value, _ctx);
};
var decodeAsync = /* @__PURE__ */ _decodeAsync($ZodRealError);
var _safeEncode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
  return _safeParse(_Err)(schema, value, ctx);
};
var safeEncode = /* @__PURE__ */ _safeEncode($ZodRealError);
var _safeDecode = (_Err) => (schema, value, _ctx) => {
  return _safeParse(_Err)(schema, value, _ctx);
};
var safeDecode = /* @__PURE__ */ _safeDecode($ZodRealError);
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? Object.assign(_ctx, { direction: "backward" }) : { direction: "backward" };
  return _safeParseAsync(_Err)(schema, value, ctx);
};
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync($ZodRealError);
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _safeParseAsync(_Err)(schema, value, _ctx);
};
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/regexes.js
var regexes_exports = {};
__export(regexes_exports, {
  base64: () => base64,
  base64url: () => base64url,
  bigint: () => bigint,
  boolean: () => boolean,
  browserEmail: () => browserEmail,
  cidrv4: () => cidrv4,
  cidrv6: () => cidrv6,
  cuid: () => cuid,
  cuid2: () => cuid2,
  date: () => date,
  datetime: () => datetime,
  domain: () => domain,
  duration: () => duration,
  e164: () => e164,
  email: () => email,
  emoji: () => emoji,
  extendedDuration: () => extendedDuration,
  guid: () => guid,
  hex: () => hex,
  hostname: () => hostname,
  html5Email: () => html5Email,
  idnEmail: () => idnEmail,
  integer: () => integer,
  ipv4: () => ipv4,
  ipv6: () => ipv6,
  ksuid: () => ksuid,
  lowercase: () => lowercase,
  mac: () => mac,
  md5_base64: () => md5_base64,
  md5_base64url: () => md5_base64url,
  md5_hex: () => md5_hex,
  nanoid: () => nanoid,
  null: () => _null,
  number: () => number,
  rfc5322Email: () => rfc5322Email,
  sha1_base64: () => sha1_base64,
  sha1_base64url: () => sha1_base64url,
  sha1_hex: () => sha1_hex,
  sha256_base64: () => sha256_base64,
  sha256_base64url: () => sha256_base64url,
  sha256_hex: () => sha256_hex,
  sha384_base64: () => sha384_base64,
  sha384_base64url: () => sha384_base64url,
  sha384_hex: () => sha384_hex,
  sha512_base64: () => sha512_base64,
  sha512_base64url: () => sha512_base64url,
  sha512_hex: () => sha512_hex,
  string: () => string,
  time: () => time,
  ulid: () => ulid,
  undefined: () => _undefined,
  unicodeEmail: () => unicodeEmail,
  uppercase: () => uppercase,
  uuid: () => uuid,
  uuid4: () => uuid4,
  uuid6: () => uuid6,
  uuid7: () => uuid7,
  xid: () => xid
});
var cuid = /^[cC][^\s-]{8,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var extendedDuration = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version2) => {
  if (!version2)
    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var uuid4 = /* @__PURE__ */ uuid(4);
var uuid6 = /* @__PURE__ */ uuid(6);
var uuid7 = /* @__PURE__ */ uuid(7);
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var html5Email = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
var rfc5322Email = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
var unicodeEmail = /^[^\s@"]{1,64}@[^\s@]{1,255}$/u;
var idnEmail = unicodeEmail;
var browserEmail = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
  return new RegExp(_emoji, "u");
}
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
var mac = (delimiter) => {
  const escapedDelim = escapeRegex(delimiter ?? ":");
  return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
};
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
var domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
var e164 = /^\+[1-9]\d{6,14}$/;
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
function timeSource(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time(args) {
  return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
  const time3 = timeSource({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
  const timeRegex = `${time3}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
var string = (params) => {
  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
  return new RegExp(`^${regex}$`);
};
var bigint = /^-?\d+n?$/;
var integer = /^-?\d+$/;
var number = /^-?\d+(?:\.\d+)?$/;
var boolean = /^(?:true|false)$/i;
var _null = /^null$/i;
var _undefined = /^undefined$/i;
var lowercase = /^[^A-Z]*$/;
var uppercase = /^[^a-z]*$/;
var hex = /^[0-9a-fA-F]*$/;
function fixedBase64(bodyLength, padding) {
  return new RegExp(`^[A-Za-z0-9+/]{${bodyLength}}${padding}$`);
}
function fixedBase64url(length) {
  return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
}
var md5_hex = /^[0-9a-fA-F]{32}$/;
var md5_base64 = /* @__PURE__ */ fixedBase64(22, "==");
var md5_base64url = /* @__PURE__ */ fixedBase64url(22);
var sha1_hex = /^[0-9a-fA-F]{40}$/;
var sha1_base64 = /* @__PURE__ */ fixedBase64(27, "=");
var sha1_base64url = /* @__PURE__ */ fixedBase64url(27);
var sha256_hex = /^[0-9a-fA-F]{64}$/;
var sha256_base64 = /* @__PURE__ */ fixedBase64(43, "=");
var sha256_base64url = /* @__PURE__ */ fixedBase64url(43);
var sha384_hex = /^[0-9a-fA-F]{96}$/;
var sha384_base64 = /* @__PURE__ */ fixedBase64(64, "");
var sha384_base64url = /* @__PURE__ */ fixedBase64url(64);
var sha512_hex = /^[0-9a-fA-F]{128}$/;
var sha512_base64 = /* @__PURE__ */ fixedBase64(86, "==");
var sha512_base64url = /* @__PURE__ */ fixedBase64url(86);

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
  var _a2;
  inst._zod ?? (inst._zod = {});
  inst._zod.def = def;
  (_a2 = inst._zod).onattach ?? (_a2.onattach = []);
});
var numericOriginMap = {
  number: "number",
  bigint: "bigint",
  object: "date"
};
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
    if (def.value < curr) {
      if (def.inclusive)
        bag.maximum = def.value;
      else
        bag.exclusiveMaximum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
    if (def.value > curr) {
      if (def.inclusive)
        bag.minimum = def.value;
      else
        bag.exclusiveMinimum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    var _a2;
    (_a2 = inst2._zod.bag).multipleOf ?? (_a2.multipleOf = def.value);
  });
  inst._zod.check = (payload) => {
    if (typeof payload.value !== typeof def.value)
      throw new Error("Cannot mix number and bigint in multiple_of check.");
    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
    if (isMultiple)
      return;
    payload.issues.push({
      origin: typeof payload.value,
      code: "not_multiple_of",
      divisor: def.value,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
  $ZodCheck.init(inst, def);
  def.format = def.format || "float64";
  const isInt = def.format?.includes("int");
  const origin = isInt ? "int" : "number";
  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    bag.minimum = minimum;
    bag.maximum = maximum;
    if (isInt)
      bag.pattern = integer;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    if (isInt) {
      if (!Number.isInteger(input)) {
        payload.issues.push({
          expected: origin,
          format: def.format,
          code: "invalid_type",
          continue: false,
          input,
          inst
        });
        return;
      }
      if (!Number.isSafeInteger(input)) {
        if (input > 0) {
          payload.issues.push({
            input,
            code: "too_big",
            maximum: Number.MAX_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        } else {
          payload.issues.push({
            input,
            code: "too_small",
            minimum: Number.MIN_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        }
        return;
      }
    }
    if (input < minimum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_small",
        minimum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
    if (input > maximum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_big",
        maximum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCheckBigIntFormat = /* @__PURE__ */ $constructor("$ZodCheckBigIntFormat", (inst, def) => {
  $ZodCheck.init(inst, def);
  const [minimum, maximum] = BIGINT_FORMAT_RANGES[def.format];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    bag.minimum = minimum;
    bag.maximum = maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    if (input < minimum) {
      payload.issues.push({
        origin: "bigint",
        input,
        code: "too_small",
        minimum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
    if (input > maximum) {
      payload.issues.push({
        origin: "bigint",
        input,
        code: "too_big",
        maximum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCheckMaxSize = /* @__PURE__ */ $constructor("$ZodCheckMaxSize", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.size !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
    if (def.maximum < curr)
      inst2._zod.bag.maximum = def.maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const size = input.size;
    if (size <= def.maximum)
      return;
    payload.issues.push({
      origin: getSizableOrigin(input),
      code: "too_big",
      maximum: def.maximum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMinSize = /* @__PURE__ */ $constructor("$ZodCheckMinSize", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.size !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
    if (def.minimum > curr)
      inst2._zod.bag.minimum = def.minimum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const size = input.size;
    if (size >= def.minimum)
      return;
    payload.issues.push({
      origin: getSizableOrigin(input),
      code: "too_small",
      minimum: def.minimum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckSizeEquals = /* @__PURE__ */ $constructor("$ZodCheckSizeEquals", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.size !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.minimum = def.size;
    bag.maximum = def.size;
    bag.size = def.size;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const size = input.size;
    if (size === def.size)
      return;
    const tooBig = size > def.size;
    payload.issues.push({
      origin: getSizableOrigin(input),
      ...tooBig ? { code: "too_big", maximum: def.size } : { code: "too_small", minimum: def.size },
      inclusive: true,
      exact: true,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
    if (def.maximum < curr)
      inst2._zod.bag.maximum = def.maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length <= def.maximum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: def.maximum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
    if (def.minimum > curr)
      inst2._zod.bag.minimum = def.minimum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length >= def.minimum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: def.minimum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
  var _a2;
  $ZodCheck.init(inst, def);
  (_a2 = inst._zod.def).when ?? (_a2.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.minimum = def.length;
    bag.maximum = def.length;
    bag.length = def.length;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length === def.length)
      return;
    const origin = getLengthableOrigin(input);
    const tooBig = length > def.length;
    payload.issues.push({
      origin,
      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
      inclusive: true,
      exact: true,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
  var _a2, _b;
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    if (def.pattern) {
      bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
      bag.patterns.add(def.pattern);
    }
  });
  if (def.pattern)
    (_a2 = inst._zod).check ?? (_a2.check = (payload) => {
      def.pattern.lastIndex = 0;
      if (def.pattern.test(payload.value))
        return;
      payload.issues.push({
        origin: "string",
        code: "invalid_format",
        format: def.format,
        input: payload.value,
        ...def.pattern ? { pattern: def.pattern.toString() } : {},
        inst,
        continue: !def.abort
      });
    });
  else
    (_b = inst._zod).check ?? (_b.check = () => {
    });
});
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    def.pattern.lastIndex = 0;
    if (def.pattern.test(payload.value))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "regex",
      input: payload.value,
      pattern: def.pattern.toString(),
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
  def.pattern ?? (def.pattern = lowercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
  def.pattern ?? (def.pattern = uppercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
  $ZodCheck.init(inst, def);
  const escapedRegex = escapeRegex(def.includes);
  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
  def.pattern = pattern;
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.includes(def.includes, def.position))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "includes",
      includes: def.includes,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.startsWith(def.prefix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "starts_with",
      prefix: def.prefix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.endsWith(def.suffix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "ends_with",
      suffix: def.suffix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
function handleCheckPropertyResult(result, payload, property) {
  if (result.issues.length) {
    payload.issues.push(...prefixIssues(property, result.issues));
  }
}
var $ZodCheckProperty = /* @__PURE__ */ $constructor("$ZodCheckProperty", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.check = (payload) => {
    const result = def.schema._zod.run({
      value: payload.value[def.property],
      issues: []
    }, {});
    if (result instanceof Promise) {
      return result.then((result2) => handleCheckPropertyResult(result2, payload, def.property));
    }
    handleCheckPropertyResult(result, payload, def.property);
    return;
  };
});
var $ZodCheckMimeType = /* @__PURE__ */ $constructor("$ZodCheckMimeType", (inst, def) => {
  $ZodCheck.init(inst, def);
  const mimeSet = new Set(def.mime);
  inst._zod.onattach.push((inst2) => {
    inst2._zod.bag.mime = def.mime;
  });
  inst._zod.check = (payload) => {
    if (mimeSet.has(payload.value.type))
      return;
    payload.issues.push({
      code: "invalid_value",
      values: def.mime,
      input: payload.value.type,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.check = (payload) => {
    payload.value = def.tx(payload.value);
  };
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/doc.js
var Doc = class {
  constructor(args = []) {
    this.content = [];
    this.indent = 0;
    if (this)
      this.args = args;
  }
  indented(fn) {
    this.indent += 1;
    fn(this);
    this.indent -= 1;
  }
  write(arg) {
    if (typeof arg === "function") {
      arg(this, { execution: "sync" });
      arg(this, { execution: "async" });
      return;
    }
    const content = arg;
    const lines = content.split("\n").filter((x) => x);
    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
    for (const line of dedented) {
      this.content.push(line);
    }
  }
  compile() {
    const F = Function;
    const args = this?.args;
    const content = this?.content ?? [``];
    const lines = [...content.map((x) => `  ${x}`)];
    return new F(...args, lines.join("\n"));
  }
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/versions.js
var version = {
  major: 4,
  minor: 3,
  patch: 4
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
  var _a2;
  inst ?? (inst = {});
  inst._zod.def = def;
  inst._zod.bag = inst._zod.bag || {};
  inst._zod.version = version;
  const checks = [...inst._zod.def.checks ?? []];
  if (inst._zod.traits.has("$ZodCheck")) {
    checks.unshift(inst);
  }
  for (const ch of checks) {
    for (const fn of ch._zod.onattach) {
      fn(inst);
    }
  }
  if (checks.length === 0) {
    (_a2 = inst._zod).deferred ?? (_a2.deferred = []);
    inst._zod.deferred?.push(() => {
      inst._zod.run = inst._zod.parse;
    });
  } else {
    const runChecks = (payload, checks2, ctx) => {
      let isAborted = aborted(payload);
      let asyncResult;
      for (const ch of checks2) {
        if (ch._zod.def.when) {
          const shouldRun = ch._zod.def.when(payload);
          if (!shouldRun)
            continue;
        } else if (isAborted) {
          continue;
        }
        const currLen = payload.issues.length;
        const _ = ch._zod.check(payload);
        if (_ instanceof Promise && ctx?.async === false) {
          throw new $ZodAsyncError();
        }
        if (asyncResult || _ instanceof Promise) {
          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
            await _;
            const nextLen = payload.issues.length;
            if (nextLen === currLen)
              return;
            if (!isAborted)
              isAborted = aborted(payload, currLen);
          });
        } else {
          const nextLen = payload.issues.length;
          if (nextLen === currLen)
            continue;
          if (!isAborted)
            isAborted = aborted(payload, currLen);
        }
      }
      if (asyncResult) {
        return asyncResult.then(() => {
          return payload;
        });
      }
      return payload;
    };
    const handleCanaryResult = (canary, payload, ctx) => {
      if (aborted(canary)) {
        canary.aborted = true;
        return canary;
      }
      const checkResult = runChecks(payload, checks, ctx);
      if (checkResult instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
      }
      return inst._zod.parse(checkResult, ctx);
    };
    inst._zod.run = (payload, ctx) => {
      if (ctx.skipChecks) {
        return inst._zod.parse(payload, ctx);
      }
      if (ctx.direction === "backward") {
        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
        if (canary instanceof Promise) {
          return canary.then((canary2) => {
            return handleCanaryResult(canary2, payload, ctx);
          });
        }
        return handleCanaryResult(canary, payload, ctx);
      }
      const result = inst._zod.parse(payload, ctx);
      if (result instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return result.then((result2) => runChecks(result2, checks, ctx));
      }
      return runChecks(result, checks, ctx);
    };
  }
  defineLazy(inst, "~standard", () => ({
    validate: (value) => {
      try {
        const r = safeParse(inst, value);
        return r.success ? { value: r.data } : { issues: r.error?.issues };
      } catch (_) {
        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
      }
    },
    vendor: "zod",
    version: 1
  }));
});
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
  inst._zod.parse = (payload, _) => {
    if (def.coerce)
      try {
        payload.value = String(payload.value);
      } catch (_2) {
      }
    if (typeof payload.value === "string")
      return payload;
    payload.issues.push({
      expected: "string",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  $ZodString.init(inst, def);
});
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
  def.pattern ?? (def.pattern = guid);
  $ZodStringFormat.init(inst, def);
});
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
  if (def.version) {
    const versionMap = {
      v1: 1,
      v2: 2,
      v3: 3,
      v4: 4,
      v5: 5,
      v6: 6,
      v7: 7,
      v8: 8
    };
    const v = versionMap[def.version];
    if (v === void 0)
      throw new Error(`Invalid UUID version: "${def.version}"`);
    def.pattern ?? (def.pattern = uuid(v));
  } else
    def.pattern ?? (def.pattern = uuid());
  $ZodStringFormat.init(inst, def);
});
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
  def.pattern ?? (def.pattern = email);
  $ZodStringFormat.init(inst, def);
});
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    try {
      const trimmed = payload.value.trim();
      const url2 = new URL(trimmed);
      if (def.hostname) {
        def.hostname.lastIndex = 0;
        if (!def.hostname.test(url2.hostname)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid hostname",
            pattern: def.hostname.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.protocol) {
        def.protocol.lastIndex = 0;
        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid protocol",
            pattern: def.protocol.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.normalize) {
        payload.value = url2.href;
      } else {
        payload.value = trimmed;
      }
      return;
    } catch (_) {
      payload.issues.push({
        code: "invalid_format",
        format: "url",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
  def.pattern ?? (def.pattern = emoji());
  $ZodStringFormat.init(inst, def);
});
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
  def.pattern ?? (def.pattern = nanoid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
  def.pattern ?? (def.pattern = cuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
  def.pattern ?? (def.pattern = cuid2);
  $ZodStringFormat.init(inst, def);
});
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
  def.pattern ?? (def.pattern = ulid);
  $ZodStringFormat.init(inst, def);
});
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
  def.pattern ?? (def.pattern = xid);
  $ZodStringFormat.init(inst, def);
});
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
  def.pattern ?? (def.pattern = ksuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
  def.pattern ?? (def.pattern = datetime(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
  def.pattern ?? (def.pattern = date);
  $ZodStringFormat.init(inst, def);
});
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
  def.pattern ?? (def.pattern = time(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
  def.pattern ?? (def.pattern = duration);
  $ZodStringFormat.init(inst, def);
});
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
  def.pattern ?? (def.pattern = ipv4);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv4`;
});
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
  def.pattern ?? (def.pattern = ipv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv6`;
  inst._zod.check = (payload) => {
    try {
      new URL(`http://[${payload.value}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "ipv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodMAC = /* @__PURE__ */ $constructor("$ZodMAC", (inst, def) => {
  def.pattern ?? (def.pattern = mac(def.delimiter));
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `mac`;
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv4);
  $ZodStringFormat.init(inst, def);
});
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    const parts = payload.value.split("/");
    try {
      if (parts.length !== 2)
        throw new Error();
      const [address, prefix] = parts;
      if (!prefix)
        throw new Error();
      const prefixNum = Number(prefix);
      if (`${prefixNum}` !== prefix)
        throw new Error();
      if (prefixNum < 0 || prefixNum > 128)
        throw new Error();
      new URL(`http://[${address}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "cidrv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
function isValidBase64(data) {
  if (data === "")
    return true;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch {
    return false;
  }
}
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
  def.pattern ?? (def.pattern = base64);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64";
  inst._zod.check = (payload) => {
    if (isValidBase64(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
function isValidBase64URL(data) {
  if (!base64url.test(data))
    return false;
  const base643 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "=");
  return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
  def.pattern ?? (def.pattern = base64url);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64url";
  inst._zod.check = (payload) => {
    if (isValidBase64URL(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64url",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
  def.pattern ?? (def.pattern = e164);
  $ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch {
    return false;
  }
}
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    if (isValidJWT(payload.value, def.alg))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "jwt",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCustomStringFormat = /* @__PURE__ */ $constructor("$ZodCustomStringFormat", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    if (def.fn(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: def.format,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = inst._zod.bag.pattern ?? number;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Number(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
      return payload;
    }
    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
    payload.issues.push({
      expected: "number",
      code: "invalid_type",
      input,
      inst,
      ...received ? { received } : {}
    });
    return payload;
  };
});
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
  $ZodCheckNumberFormat.init(inst, def);
  $ZodNumber.init(inst, def);
});
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = boolean;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Boolean(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "boolean")
      return payload;
    payload.issues.push({
      expected: "boolean",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = bigint;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = BigInt(payload.value);
      } catch (_) {
      }
    if (typeof payload.value === "bigint")
      return payload;
    payload.issues.push({
      expected: "bigint",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodBigIntFormat = /* @__PURE__ */ $constructor("$ZodBigIntFormat", (inst, def) => {
  $ZodCheckBigIntFormat.init(inst, def);
  $ZodBigInt.init(inst, def);
});
var $ZodSymbol = /* @__PURE__ */ $constructor("$ZodSymbol", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (typeof input === "symbol")
      return payload;
    payload.issues.push({
      expected: "symbol",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodUndefined = /* @__PURE__ */ $constructor("$ZodUndefined", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = _undefined;
  inst._zod.values = /* @__PURE__ */ new Set([void 0]);
  inst._zod.optin = "optional";
  inst._zod.optout = "optional";
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (typeof input === "undefined")
      return payload;
    payload.issues.push({
      expected: "undefined",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = _null;
  inst._zod.values = /* @__PURE__ */ new Set([null]);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (input === null)
      return payload;
    payload.issues.push({
      expected: "null",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload) => payload;
});
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload) => payload;
});
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    payload.issues.push({
      expected: "never",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodVoid = /* @__PURE__ */ $constructor("$ZodVoid", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (typeof input === "undefined")
      return payload;
    payload.issues.push({
      expected: "void",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce) {
      try {
        payload.value = new Date(payload.value);
      } catch (_err) {
      }
    }
    const input = payload.value;
    const isDate = input instanceof Date;
    const isValidDate = isDate && !Number.isNaN(input.getTime());
    if (isValidDate)
      return payload;
    payload.issues.push({
      expected: "date",
      code: "invalid_type",
      input,
      ...isDate ? { received: "Invalid Date" } : {},
      inst
    });
    return payload;
  };
});
function handleArrayResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!Array.isArray(input)) {
      payload.issues.push({
        expected: "array",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = Array(input.length);
    const proms = [];
    for (let i = 0; i < input.length; i++) {
      const item = input[i];
      const result = def.element._zod.run({
        value: item,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
      } else {
        handleArrayResult(result, payload, i);
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
function handlePropertyResult(result, final, key, input, isOptionalOut) {
  if (result.issues.length) {
    if (isOptionalOut && !(key in input)) {
      return;
    }
    final.issues.push(...prefixIssues(key, result.issues));
  }
  if (result.value === void 0) {
    if (key in input) {
      final.value[key] = void 0;
    }
  } else {
    final.value[key] = result.value;
  }
}
function normalizeDef(def) {
  const keys = Object.keys(def.shape);
  for (const k of keys) {
    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
    }
  }
  const okeys = optionalKeys(def.shape);
  return {
    ...def,
    keys,
    keySet: new Set(keys),
    numKeys: keys.length,
    optionalKeys: new Set(okeys)
  };
}
function handleCatchall(proms, input, payload, ctx, def, inst) {
  const unrecognized = [];
  const keySet = def.keySet;
  const _catchall = def.catchall._zod;
  const t = _catchall.def.type;
  const isOptionalOut = _catchall.optout === "optional";
  for (const key in input) {
    if (keySet.has(key))
      continue;
    if (t === "never") {
      unrecognized.push(key);
      continue;
    }
    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
    if (r instanceof Promise) {
      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
    } else {
      handlePropertyResult(r, payload, key, input, isOptionalOut);
    }
  }
  if (unrecognized.length) {
    payload.issues.push({
      code: "unrecognized_keys",
      keys: unrecognized,
      input,
      inst
    });
  }
  if (!proms.length)
    return payload;
  return Promise.all(proms).then(() => {
    return payload;
  });
}
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
  $ZodType.init(inst, def);
  const desc = Object.getOwnPropertyDescriptor(def, "shape");
  if (!desc?.get) {
    const sh = def.shape;
    Object.defineProperty(def, "shape", {
      get: () => {
        const newSh = { ...sh };
        Object.defineProperty(def, "shape", {
          value: newSh
        });
        return newSh;
      }
    });
  }
  const _normalized = cached(() => normalizeDef(def));
  defineLazy(inst._zod, "propValues", () => {
    const shape = def.shape;
    const propValues = {};
    for (const key in shape) {
      const field = shape[key]._zod;
      if (field.values) {
        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
        for (const v of field.values)
          propValues[key].add(v);
      }
    }
    return propValues;
  });
  const isObject2 = isObject;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = {};
    const proms = [];
    const shape = value.shape;
    for (const key of value.keys) {
      const el = shape[key];
      const isOptionalOut = el._zod.optout === "optional";
      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
      if (r instanceof Promise) {
        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalOut)));
      } else {
        handlePropertyResult(r, payload, key, input, isOptionalOut);
      }
    }
    if (!catchall) {
      return proms.length ? Promise.all(proms).then(() => payload) : payload;
    }
    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
  };
});
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
  $ZodObject.init(inst, def);
  const superParse = inst._zod.parse;
  const _normalized = cached(() => normalizeDef(def));
  const generateFastpass = (shape) => {
    const doc = new Doc(["shape", "payload", "ctx"]);
    const normalized = _normalized.value;
    const parseStr = (key) => {
      const k = esc(key);
      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
    };
    doc.write(`const input = payload.value;`);
    const ids = /* @__PURE__ */ Object.create(null);
    let counter = 0;
    for (const key of normalized.keys) {
      ids[key] = `key_${counter++}`;
    }
    doc.write(`const newResult = {};`);
    for (const key of normalized.keys) {
      const id = ids[key];
      const k = esc(key);
      const schema = shape[key];
      const isOptionalOut = schema?._zod?.optout === "optional";
      doc.write(`const ${id} = ${parseStr(key)};`);
      if (isOptionalOut) {
        doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
      } else {
        doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        
        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }
        
      `);
      }
    }
    doc.write(`payload.value = newResult;`);
    doc.write(`return payload;`);
    const fn = doc.compile();
    return (payload, ctx) => fn(shape, payload, ctx);
  };
  let fastpass;
  const isObject2 = isObject;
  const jit = !globalConfig.jitless;
  const allowsEval2 = allowsEval;
  const fastEnabled = jit && allowsEval2.value;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
      if (!fastpass)
        fastpass = generateFastpass(def.shape);
      payload = fastpass(payload, ctx);
      if (!catchall)
        return payload;
      return handleCatchall([], input, payload, ctx, value, inst);
    }
    return superParse(payload, ctx);
  };
});
function handleUnionResults(results, final, inst, ctx) {
  for (const result of results) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  const nonaborted = results.filter((r) => !aborted(r));
  if (nonaborted.length === 1) {
    final.value = nonaborted[0].value;
    return nonaborted[0];
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  });
  return final;
}
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "values", () => {
    if (def.options.every((o) => o._zod.values)) {
      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
    }
    return void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    if (def.options.every((o) => o._zod.pattern)) {
      const patterns = def.options.map((o) => o._zod.pattern);
      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
    }
    return void 0;
  });
  const single = def.options.length === 1;
  const first = def.options[0]._zod.run;
  inst._zod.parse = (payload, ctx) => {
    if (single) {
      return first(payload, ctx);
    }
    let async = false;
    const results = [];
    for (const option of def.options) {
      const result = option._zod.run({
        value: payload.value,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        results.push(result);
        async = true;
      } else {
        if (result.issues.length === 0)
          return result;
        results.push(result);
      }
    }
    if (!async)
      return handleUnionResults(results, payload, inst, ctx);
    return Promise.all(results).then((results2) => {
      return handleUnionResults(results2, payload, inst, ctx);
    });
  };
});
function handleExclusiveUnionResults(results, final, inst, ctx) {
  const successes = results.filter((r) => r.issues.length === 0);
  if (successes.length === 1) {
    final.value = successes[0].value;
    return final;
  }
  if (successes.length === 0) {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
    });
  } else {
    final.issues.push({
      code: "invalid_union",
      input: final.value,
      inst,
      errors: [],
      inclusive: false
    });
  }
  return final;
}
var $ZodXor = /* @__PURE__ */ $constructor("$ZodXor", (inst, def) => {
  $ZodUnion.init(inst, def);
  def.inclusive = false;
  const single = def.options.length === 1;
  const first = def.options[0]._zod.run;
  inst._zod.parse = (payload, ctx) => {
    if (single) {
      return first(payload, ctx);
    }
    let async = false;
    const results = [];
    for (const option of def.options) {
      const result = option._zod.run({
        value: payload.value,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        results.push(result);
        async = true;
      } else {
        results.push(result);
      }
    }
    if (!async)
      return handleExclusiveUnionResults(results, payload, inst, ctx);
    return Promise.all(results).then((results2) => {
      return handleExclusiveUnionResults(results2, payload, inst, ctx);
    });
  };
});
var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnion", (inst, def) => {
  def.inclusive = false;
  $ZodUnion.init(inst, def);
  const _super = inst._zod.parse;
  defineLazy(inst._zod, "propValues", () => {
    const propValues = {};
    for (const option of def.options) {
      const pv = option._zod.propValues;
      if (!pv || Object.keys(pv).length === 0)
        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option)}"`);
      for (const [k, v] of Object.entries(pv)) {
        if (!propValues[k])
          propValues[k] = /* @__PURE__ */ new Set();
        for (const val of v) {
          propValues[k].add(val);
        }
      }
    }
    return propValues;
  });
  const disc = cached(() => {
    const opts = def.options;
    const map2 = /* @__PURE__ */ new Map();
    for (const o of opts) {
      const values = o._zod.propValues?.[def.discriminator];
      if (!values || values.size === 0)
        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(o)}"`);
      for (const v of values) {
        if (map2.has(v)) {
          throw new Error(`Duplicate discriminator value "${String(v)}"`);
        }
        map2.set(v, o);
      }
    }
    return map2;
  });
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isObject(input)) {
      payload.issues.push({
        code: "invalid_type",
        expected: "object",
        input,
        inst
      });
      return payload;
    }
    const opt = disc.value.get(input?.[def.discriminator]);
    if (opt) {
      return opt._zod.run(payload, ctx);
    }
    if (def.unionFallback) {
      return _super(payload, ctx);
    }
    payload.issues.push({
      code: "invalid_union",
      errors: [],
      note: "No matching discriminator",
      discriminator: def.discriminator,
      input,
      path: [def.discriminator],
      inst
    });
    return payload;
  };
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
    const async = left instanceof Promise || right instanceof Promise;
    if (async) {
      return Promise.all([left, right]).then(([left2, right2]) => {
        return handleIntersectionResults(payload, left2, right2);
      });
    }
    return handleIntersectionResults(payload, left, right);
  };
});
function mergeValues(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject(a) && isPlainObject(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
  const unrecKeys = /* @__PURE__ */ new Map();
  let unrecIssue;
  for (const iss of left.issues) {
    if (iss.code === "unrecognized_keys") {
      unrecIssue ?? (unrecIssue = iss);
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).l = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  for (const iss of right.issues) {
    if (iss.code === "unrecognized_keys") {
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).r = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
  if (bothKeys.length && unrecIssue) {
    result.issues.push({ ...unrecIssue, keys: bothKeys });
  }
  if (aborted(result))
    return result;
  const merged = mergeValues(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
  $ZodType.init(inst, def);
  const items = def.items;
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!Array.isArray(input)) {
      payload.issues.push({
        input,
        inst,
        expected: "tuple",
        code: "invalid_type"
      });
      return payload;
    }
    payload.value = [];
    const proms = [];
    const reversedIndex = [...items].reverse().findIndex((item) => item._zod.optin !== "optional");
    const optStart = reversedIndex === -1 ? 0 : items.length - reversedIndex;
    if (!def.rest) {
      const tooBig = input.length > items.length;
      const tooSmall = input.length < optStart - 1;
      if (tooBig || tooSmall) {
        payload.issues.push({
          ...tooBig ? { code: "too_big", maximum: items.length, inclusive: true } : { code: "too_small", minimum: items.length },
          input,
          inst,
          origin: "array"
        });
        return payload;
      }
    }
    let i = -1;
    for (const item of items) {
      i++;
      if (i >= input.length) {
        if (i >= optStart)
          continue;
      }
      const result = item._zod.run({
        value: input[i],
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
      } else {
        handleTupleResult(result, payload, i);
      }
    }
    if (def.rest) {
      const rest = input.slice(items.length);
      for (const el of rest) {
        i++;
        const result = def.rest._zod.run({
          value: el,
          issues: []
        }, ctx);
        if (result instanceof Promise) {
          proms.push(result.then((result2) => handleTupleResult(result2, payload, i)));
        } else {
          handleTupleResult(result, payload, i);
        }
      }
    }
    if (proms.length)
      return Promise.all(proms).then(() => payload);
    return payload;
  };
});
function handleTupleResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isPlainObject(input)) {
      payload.issues.push({
        expected: "record",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    const values = def.keyType._zod.values;
    if (values) {
      payload.value = {};
      const recordKeys = /* @__PURE__ */ new Set();
      for (const key of values) {
        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
          recordKeys.add(typeof key === "number" ? key.toString() : key);
          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => {
              if (result2.issues.length) {
                payload.issues.push(...prefixIssues(key, result2.issues));
              }
              payload.value[key] = result2.value;
            }));
          } else {
            if (result.issues.length) {
              payload.issues.push(...prefixIssues(key, result.issues));
            }
            payload.value[key] = result.value;
          }
        }
      }
      let unrecognized;
      for (const key in input) {
        if (!recordKeys.has(key)) {
          unrecognized = unrecognized ?? [];
          unrecognized.push(key);
        }
      }
      if (unrecognized && unrecognized.length > 0) {
        payload.issues.push({
          code: "unrecognized_keys",
          input,
          inst,
          keys: unrecognized
        });
      }
    } else {
      payload.value = {};
      for (const key of Reflect.ownKeys(input)) {
        if (key === "__proto__")
          continue;
        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
        if (keyResult instanceof Promise) {
          throw new Error("Async schemas not supported in object keys currently");
        }
        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number");
        if (checkNumericKey) {
          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
          if (retryResult instanceof Promise) {
            throw new Error("Async schemas not supported in object keys currently");
          }
          if (retryResult.issues.length === 0) {
            keyResult = retryResult;
          }
        }
        if (keyResult.issues.length) {
          if (def.mode === "loose") {
            payload.value[key] = input[key];
          } else {
            payload.issues.push({
              code: "invalid_key",
              origin: "record",
              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
              input: key,
              path: [key],
              inst
            });
          }
          continue;
        }
        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
        if (result instanceof Promise) {
          proms.push(result.then((result2) => {
            if (result2.issues.length) {
              payload.issues.push(...prefixIssues(key, result2.issues));
            }
            payload.value[keyResult.value] = result2.value;
          }));
        } else {
          if (result.issues.length) {
            payload.issues.push(...prefixIssues(key, result.issues));
          }
          payload.value[keyResult.value] = result.value;
        }
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!(input instanceof Map)) {
      payload.issues.push({
        expected: "map",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    payload.value = /* @__PURE__ */ new Map();
    for (const [key, value] of input) {
      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
      const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
      if (keyResult instanceof Promise || valueResult instanceof Promise) {
        proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
        }));
      } else {
        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
      }
    }
    if (proms.length)
      return Promise.all(proms).then(() => payload);
    return payload;
  };
});
function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
  if (keyResult.issues.length) {
    if (propertyKeyTypes.has(typeof key)) {
      final.issues.push(...prefixIssues(key, keyResult.issues));
    } else {
      final.issues.push({
        code: "invalid_key",
        origin: "map",
        input,
        inst,
        issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
      });
    }
  }
  if (valueResult.issues.length) {
    if (propertyKeyTypes.has(typeof key)) {
      final.issues.push(...prefixIssues(key, valueResult.issues));
    } else {
      final.issues.push({
        origin: "map",
        code: "invalid_element",
        input,
        inst,
        key,
        issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
      });
    }
  }
  final.value.set(keyResult.value, valueResult.value);
}
var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!(input instanceof Set)) {
      payload.issues.push({
        input,
        inst,
        expected: "set",
        code: "invalid_type"
      });
      return payload;
    }
    const proms = [];
    payload.value = /* @__PURE__ */ new Set();
    for (const item of input) {
      const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleSetResult(result2, payload)));
      } else
        handleSetResult(result, payload);
    }
    if (proms.length)
      return Promise.all(proms).then(() => payload);
    return payload;
  };
});
function handleSetResult(result, final) {
  if (result.issues.length) {
    final.issues.push(...result.issues);
  }
  final.value.add(result.value);
}
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
  $ZodType.init(inst, def);
  const values = getEnumValues(def.entries);
  const valuesSet = new Set(values);
  inst._zod.values = valuesSet;
  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (valuesSet.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodLiteral = /* @__PURE__ */ $constructor("$ZodLiteral", (inst, def) => {
  $ZodType.init(inst, def);
  if (def.values.length === 0) {
    throw new Error("Cannot create literal schema with no valid values");
  }
  const values = new Set(def.values);
  inst._zod.values = values;
  inst._zod.pattern = new RegExp(`^(${def.values.map((o) => typeof o === "string" ? escapeRegex(o) : o ? escapeRegex(o.toString()) : String(o)).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (values.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values: def.values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodFile = /* @__PURE__ */ $constructor("$ZodFile", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (input instanceof File)
      return payload;
    payload.issues.push({
      expected: "file",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    const _out = def.transform(payload.value, payload);
    if (ctx.async) {
      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
      return output.then((output2) => {
        payload.value = output2;
        return payload;
      });
    }
    if (_out instanceof Promise) {
      throw new $ZodAsyncError();
    }
    payload.value = _out;
    return payload;
  };
});
function handleOptionalResult(result, input) {
  if (result.issues.length && input === void 0) {
    return { issues: [], value: void 0 };
  }
  return result;
}
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.optout = "optional";
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (def.innerType._zod.optin === "optional") {
      const result = def.innerType._zod.run(payload, ctx);
      if (result instanceof Promise)
        return result.then((r) => handleOptionalResult(r, payload.value));
      return handleOptionalResult(result, payload.value);
    }
    if (payload.value === void 0) {
      return payload;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
  inst._zod.parse = (payload, ctx) => {
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
  });
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === null)
      return payload;
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
      return payload;
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleDefaultResult(result2, def));
    }
    return handleDefaultResult(result, def);
  };
});
function handleDefaultResult(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => {
    const v = def.innerType._zod.values;
    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleNonOptionalResult(result2, inst));
    }
    return handleNonOptionalResult(result, inst);
  };
});
function handleNonOptionalResult(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
var $ZodSuccess = /* @__PURE__ */ $constructor("$ZodSuccess", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      throw new $ZodEncodeError("ZodSuccess");
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => {
        payload.value = result2.issues.length === 0;
        return payload;
      });
    }
    payload.value = result.issues.length === 0;
    return payload;
  };
});
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => {
        payload.value = result2.value;
        if (result2.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
            },
            input: payload.value
          });
          payload.issues = [];
        }
        return payload;
      });
    }
    payload.value = result.value;
    if (result.issues.length) {
      payload.value = def.catchValue({
        ...payload,
        error: {
          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
        },
        input: payload.value
      });
      payload.issues = [];
    }
    return payload;
  };
});
var $ZodNaN = /* @__PURE__ */ $constructor("$ZodNaN", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    if (typeof payload.value !== "number" || !Number.isNaN(payload.value)) {
      payload.issues.push({
        input: payload.value,
        inst,
        expected: "nan",
        code: "invalid_type"
      });
      return payload;
    }
    return payload;
  };
});
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => def.in._zod.values);
  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      const right = def.out._zod.run(payload, ctx);
      if (right instanceof Promise) {
        return right.then((right2) => handlePipeResult(right2, def.in, ctx));
      }
      return handlePipeResult(right, def.in, ctx);
    }
    const left = def.in._zod.run(payload, ctx);
    if (left instanceof Promise) {
      return left.then((left2) => handlePipeResult(left2, def.out, ctx));
    }
    return handlePipeResult(left, def.out, ctx);
  };
});
function handlePipeResult(left, next, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return next._zod.run({ value: left.value, issues: left.issues }, ctx);
}
var $ZodCodec = /* @__PURE__ */ $constructor("$ZodCodec", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => def.in._zod.values);
  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
  inst._zod.parse = (payload, ctx) => {
    const direction = ctx.direction || "forward";
    if (direction === "forward") {
      const left = def.in._zod.run(payload, ctx);
      if (left instanceof Promise) {
        return left.then((left2) => handleCodecAResult(left2, def, ctx));
      }
      return handleCodecAResult(left, def, ctx);
    } else {
      const right = def.out._zod.run(payload, ctx);
      if (right instanceof Promise) {
        return right.then((right2) => handleCodecAResult(right2, def, ctx));
      }
      return handleCodecAResult(right, def, ctx);
    }
  };
});
function handleCodecAResult(result, def, ctx) {
  if (result.issues.length) {
    result.aborted = true;
    return result;
  }
  const direction = ctx.direction || "forward";
  if (direction === "forward") {
    const transformed = def.transform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult(result, value, def.out, ctx));
    }
    return handleCodecTxResult(result, transformed, def.out, ctx);
  } else {
    const transformed = def.reverseTransform(result.value, result);
    if (transformed instanceof Promise) {
      return transformed.then((value) => handleCodecTxResult(result, value, def.in, ctx));
    }
    return handleCodecTxResult(result, transformed, def.in, ctx);
  }
}
function handleCodecTxResult(left, value, nextSchema, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return nextSchema._zod.run({ value, issues: left.issues }, ctx);
}
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
  defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then(handleReadonlyResult);
    }
    return handleReadonlyResult(result);
  };
});
function handleReadonlyResult(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
var $ZodTemplateLiteral = /* @__PURE__ */ $constructor("$ZodTemplateLiteral", (inst, def) => {
  $ZodType.init(inst, def);
  const regexParts = [];
  for (const part of def.parts) {
    if (typeof part === "object" && part !== null) {
      if (!part._zod.pattern) {
        throw new Error(`Invalid template literal part, no pattern found: ${[...part._zod.traits].shift()}`);
      }
      const source = part._zod.pattern instanceof RegExp ? part._zod.pattern.source : part._zod.pattern;
      if (!source)
        throw new Error(`Invalid template literal part: ${part._zod.traits}`);
      const start = source.startsWith("^") ? 1 : 0;
      const end = source.endsWith("$") ? source.length - 1 : source.length;
      regexParts.push(source.slice(start, end));
    } else if (part === null || primitiveTypes.has(typeof part)) {
      regexParts.push(escapeRegex(`${part}`));
    } else {
      throw new Error(`Invalid template literal part: ${part}`);
    }
  }
  inst._zod.pattern = new RegExp(`^${regexParts.join("")}$`);
  inst._zod.parse = (payload, _ctx) => {
    if (typeof payload.value !== "string") {
      payload.issues.push({
        input: payload.value,
        inst,
        expected: "string",
        code: "invalid_type"
      });
      return payload;
    }
    inst._zod.pattern.lastIndex = 0;
    if (!inst._zod.pattern.test(payload.value)) {
      payload.issues.push({
        input: payload.value,
        inst,
        code: "invalid_format",
        format: def.format ?? "template_literal",
        pattern: inst._zod.pattern.source
      });
      return payload;
    }
    return payload;
  };
});
var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
  $ZodType.init(inst, def);
  inst._def = def;
  inst._zod.def = def;
  inst.implement = (func) => {
    if (typeof func !== "function") {
      throw new Error("implement() must be called with a function");
    }
    return function(...args) {
      const parsedArgs = inst._def.input ? parse(inst._def.input, args) : args;
      const result = Reflect.apply(func, this, parsedArgs);
      if (inst._def.output) {
        return parse(inst._def.output, result);
      }
      return result;
    };
  };
  inst.implementAsync = (func) => {
    if (typeof func !== "function") {
      throw new Error("implementAsync() must be called with a function");
    }
    return async function(...args) {
      const parsedArgs = inst._def.input ? await parseAsync(inst._def.input, args) : args;
      const result = await Reflect.apply(func, this, parsedArgs);
      if (inst._def.output) {
        return await parseAsync(inst._def.output, result);
      }
      return result;
    };
  };
  inst._zod.parse = (payload, _ctx) => {
    if (typeof payload.value !== "function") {
      payload.issues.push({
        code: "invalid_type",
        expected: "function",
        input: payload.value,
        inst
      });
      return payload;
    }
    const hasPromiseOutput = inst._def.output && inst._def.output._zod.def.type === "promise";
    if (hasPromiseOutput) {
      payload.value = inst.implementAsync(payload.value);
    } else {
      payload.value = inst.implement(payload.value);
    }
    return payload;
  };
  inst.input = (...args) => {
    const F = inst.constructor;
    if (Array.isArray(args[0])) {
      return new F({
        type: "function",
        input: new $ZodTuple({
          type: "tuple",
          items: args[0],
          rest: args[1]
        }),
        output: inst._def.output
      });
    }
    return new F({
      type: "function",
      input: args[0],
      output: inst._def.output
    });
  };
  inst.output = (output) => {
    const F = inst.constructor;
    return new F({
      type: "function",
      input: inst._def.input,
      output
    });
  };
  return inst;
});
var $ZodPromise = /* @__PURE__ */ $constructor("$ZodPromise", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    return Promise.resolve(payload.value).then((inner) => def.innerType._zod.run({ value: inner, issues: [] }, ctx));
  };
});
var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "innerType", () => def.getter());
  defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
  defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
  defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
  defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
  inst._zod.parse = (payload, ctx) => {
    const inner = inst._zod.innerType;
    return inner._zod.run(payload, ctx);
  };
});
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
  $ZodCheck.init(inst, def);
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _) => {
    return payload;
  };
  inst._zod.check = (payload) => {
    const input = payload.value;
    const r = def.fn(input);
    if (r instanceof Promise) {
      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
    }
    handleRefineResult(r, payload, input, inst);
    return;
  };
});
function handleRefineResult(result, payload, input, inst) {
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...inst._zod.def.path ?? []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue(_iss));
  }
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/index.js
var locales_exports = {};
__export(locales_exports, {
  ar: () => ar_default,
  az: () => az_default,
  be: () => be_default,
  bg: () => bg_default,
  ca: () => ca_default,
  cs: () => cs_default,
  da: () => da_default,
  de: () => de_default,
  en: () => en_default,
  eo: () => eo_default,
  es: () => es_default,
  fa: () => fa_default,
  fi: () => fi_default,
  fr: () => fr_default,
  frCA: () => fr_CA_default,
  he: () => he_default,
  hu: () => hu_default,
  hy: () => hy_default,
  id: () => id_default,
  is: () => is_default,
  it: () => it_default,
  ja: () => ja_default,
  ka: () => ka_default,
  kh: () => kh_default,
  km: () => km_default,
  ko: () => ko_default,
  lt: () => lt_default,
  mk: () => mk_default,
  ms: () => ms_default,
  nl: () => nl_default,
  no: () => no_default,
  ota: () => ota_default,
  pl: () => pl_default,
  ps: () => ps_default,
  pt: () => pt_default,
  ru: () => ru_default,
  sl: () => sl_default,
  sv: () => sv_default,
  ta: () => ta_default,
  th: () => th_default,
  tr: () => tr_default,
  ua: () => ua_default,
  uk: () => uk_default,
  ur: () => ur_default,
  uz: () => uz_default,
  vi: () => vi_default,
  yo: () => yo_default,
  zhCN: () => zh_CN_default,
  zhTW: () => zh_TW_default
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ar.js
var error = () => {
  const Sizable = {
    string: { unit: "\u062D\u0631\u0641", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
    file: { unit: "\u0628\u0627\u064A\u062A", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
    array: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" },
    set: { unit: "\u0639\u0646\u0635\u0631", verb: "\u0623\u0646 \u064A\u062D\u0648\u064A" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0645\u062F\u062E\u0644",
    email: "\u0628\u0631\u064A\u062F \u0625\u0644\u0643\u062A\u0631\u0648\u0646\u064A",
    url: "\u0631\u0627\u0628\u0637",
    emoji: "\u0625\u064A\u0645\u0648\u062C\u064A",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u062A\u0627\u0631\u064A\u062E \u0648\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
    date: "\u062A\u0627\u0631\u064A\u062E \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
    time: "\u0648\u0642\u062A \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
    duration: "\u0645\u062F\u0629 \u0628\u0645\u0639\u064A\u0627\u0631 ISO",
    ipv4: "\u0639\u0646\u0648\u0627\u0646 IPv4",
    ipv6: "\u0639\u0646\u0648\u0627\u0646 IPv6",
    cidrv4: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv4",
    cidrv6: "\u0645\u062F\u0649 \u0639\u0646\u0627\u0648\u064A\u0646 \u0628\u0635\u064A\u063A\u0629 IPv6",
    base64: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64-encoded",
    base64url: "\u0646\u064E\u0635 \u0628\u062A\u0631\u0645\u064A\u0632 base64url-encoded",
    json_string: "\u0646\u064E\u0635 \u0639\u0644\u0649 \u0647\u064A\u0626\u0629 JSON",
    e164: "\u0631\u0642\u0645 \u0647\u0627\u062A\u0641 \u0628\u0645\u0639\u064A\u0627\u0631 E.164",
    jwt: "JWT",
    template_literal: "\u0645\u062F\u062E\u0644"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 instanceof ${issue2.expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
        }
        return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${expected}\u060C \u0648\u0644\u0643\u0646 \u062A\u0645 \u0625\u062F\u062E\u0627\u0644 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u0645\u062F\u062E\u0644\u0627\u062A \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644\u0629: \u064A\u0641\u062A\u0631\u0636 \u0625\u062F\u062E\u0627\u0644 ${stringifyPrimitive(issue2.values[0])}`;
        return `\u0627\u062E\u062A\u064A\u0627\u0631 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062A\u0648\u0642\u0639 \u0627\u0646\u062A\u0642\u0627\u0621 \u0623\u062D\u062F \u0647\u0630\u0647 \u0627\u0644\u062E\u064A\u0627\u0631\u0627\u062A: ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return ` \u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue2.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"}`;
        return `\u0623\u0643\u0628\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0623\u0646 \u062A\u0643\u0648\u0646 ${issue2.origin ?? "\u0627\u0644\u0642\u064A\u0645\u0629"} ${adj} ${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u0623\u0635\u063A\u0631 \u0645\u0646 \u0627\u0644\u0644\u0627\u0632\u0645: \u064A\u0641\u062A\u0631\u0636 \u0644\u0640 ${issue2.origin} \u0623\u0646 \u064A\u0643\u0648\u0646 ${adj} ${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0628\u062F\u0623 \u0628\u0640 "${issue2.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0646\u062A\u0647\u064A \u0628\u0640 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u062A\u0636\u0645\u0651\u064E\u0646 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u0646\u064E\u0635 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0637\u0627\u0628\u0642 \u0627\u0644\u0646\u0645\u0637 ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644`;
      }
      case "not_multiple_of":
        return `\u0631\u0642\u0645 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644: \u064A\u062C\u0628 \u0623\u0646 \u064A\u0643\u0648\u0646 \u0645\u0646 \u0645\u0636\u0627\u0639\u0641\u0627\u062A ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u0645\u0639\u0631\u0641${issue2.keys.length > 1 ? "\u0627\u062A" : ""} \u063A\u0631\u064A\u0628${issue2.keys.length > 1 ? "\u0629" : ""}: ${joinValues(issue2.keys, "\u060C ")}`;
      case "invalid_key":
        return `\u0645\u0639\u0631\u0641 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`;
      case "invalid_union":
        return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
      case "invalid_element":
        return `\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644 \u0641\u064A ${issue2.origin}`;
      default:
        return "\u0645\u062F\u062E\u0644 \u063A\u064A\u0631 \u0645\u0642\u0628\u0648\u0644";
    }
  };
};
function ar_default() {
  return {
    localeError: error()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/az.js
var error2 = () => {
  const Sizable = {
    string: { unit: "simvol", verb: "olmal\u0131d\u0131r" },
    file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
    array: { unit: "element", verb: "olmal\u0131d\u0131r" },
    set: { unit: "element", verb: "olmal\u0131d\u0131r" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "email address",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO datetime",
    date: "ISO date",
    time: "ISO time",
    duration: "ISO duration",
    ipv4: "IPv4 address",
    ipv6: "IPv6 address",
    cidrv4: "IPv4 range",
    cidrv6: "IPv6 range",
    base64: "base64-encoded string",
    base64url: "base64url-encoded string",
    json_string: "JSON string",
    e164: "E.164 number",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n instanceof ${issue2.expected}, daxil olan ${received}`;
        }
        return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${expected}, daxil olan ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Yanl\u0131\u015F d\u0259y\u0259r: g\xF6zl\u0259nil\u0259n ${stringifyPrimitive(issue2.values[0])}`;
        return `Yanl\u0131\u015F se\xE7im: a\u015Fa\u011F\u0131dak\u0131lardan biri olmal\u0131d\u0131r: ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue2.origin ?? "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
        return `\xC7ox b\xF6y\xFCk: g\xF6zl\u0259nil\u0259n ${issue2.origin ?? "d\u0259y\u0259r"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        return `\xC7ox ki\xE7ik: g\xF6zl\u0259nil\u0259n ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Yanl\u0131\u015F m\u0259tn: "${_issue.prefix}" il\u0259 ba\u015Flamal\u0131d\u0131r`;
        if (_issue.format === "ends_with")
          return `Yanl\u0131\u015F m\u0259tn: "${_issue.suffix}" il\u0259 bitm\u0259lidir`;
        if (_issue.format === "includes")
          return `Yanl\u0131\u015F m\u0259tn: "${_issue.includes}" daxil olmal\u0131d\u0131r`;
        if (_issue.format === "regex")
          return `Yanl\u0131\u015F m\u0259tn: ${_issue.pattern} \u015Fablonuna uy\u011Fun olmal\u0131d\u0131r`;
        return `Yanl\u0131\u015F ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Yanl\u0131\u015F \u0259d\u0259d: ${issue2.divisor} il\u0259 b\xF6l\xFCn\u0259 bil\u0259n olmal\u0131d\u0131r`;
      case "unrecognized_keys":
        return `Tan\u0131nmayan a\xE7ar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F a\xE7ar`;
      case "invalid_union":
        return "Yanl\u0131\u015F d\u0259y\u0259r";
      case "invalid_element":
        return `${issue2.origin} daxilind\u0259 yanl\u0131\u015F d\u0259y\u0259r`;
      default:
        return `Yanl\u0131\u015F d\u0259y\u0259r`;
    }
  };
};
function az_default() {
  return {
    localeError: error2()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/be.js
function getBelarusianPlural(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
var error3 = () => {
  const Sizable = {
    string: {
      unit: {
        one: "\u0441\u0456\u043C\u0432\u0430\u043B",
        few: "\u0441\u0456\u043C\u0432\u0430\u043B\u044B",
        many: "\u0441\u0456\u043C\u0432\u0430\u043B\u0430\u045E"
      },
      verb: "\u043C\u0435\u0446\u044C"
    },
    array: {
      unit: {
        one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
        few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
        many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
      },
      verb: "\u043C\u0435\u0446\u044C"
    },
    set: {
      unit: {
        one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
        few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u044B",
        many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430\u045E"
      },
      verb: "\u043C\u0435\u0446\u044C"
    },
    file: {
      unit: {
        one: "\u0431\u0430\u0439\u0442",
        few: "\u0431\u0430\u0439\u0442\u044B",
        many: "\u0431\u0430\u0439\u0442\u0430\u045E"
      },
      verb: "\u043C\u0435\u0446\u044C"
    }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0443\u0432\u043E\u0434",
    email: "email \u0430\u0434\u0440\u0430\u0441",
    url: "URL",
    emoji: "\u044D\u043C\u043E\u0434\u0437\u0456",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0434\u0430\u0442\u0430 \u0456 \u0447\u0430\u0441",
    date: "ISO \u0434\u0430\u0442\u0430",
    time: "ISO \u0447\u0430\u0441",
    duration: "ISO \u043F\u0440\u0430\u0446\u044F\u0433\u043B\u0430\u0441\u0446\u044C",
    ipv4: "IPv4 \u0430\u0434\u0440\u0430\u0441",
    ipv6: "IPv6 \u0430\u0434\u0440\u0430\u0441",
    cidrv4: "IPv4 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
    cidrv6: "IPv6 \u0434\u044B\u044F\u043F\u0430\u0437\u043E\u043D",
    base64: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64",
    base64url: "\u0440\u0430\u0434\u043E\u043A \u0443 \u0444\u0430\u0440\u043C\u0430\u0446\u0435 base64url",
    json_string: "JSON \u0440\u0430\u0434\u043E\u043A",
    e164: "\u043D\u0443\u043C\u0430\u0440 E.164",
    jwt: "JWT",
    template_literal: "\u0443\u0432\u043E\u0434"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u043B\u0456\u043A",
    array: "\u043C\u0430\u0441\u0456\u045E"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F instanceof ${issue2.expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
        }
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u045E\u0441\u044F ${expected}, \u0430\u0442\u0440\u044B\u043C\u0430\u043D\u0430 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0432\u0430\u0440\u044B\u044F\u043D\u0442: \u0447\u0430\u043A\u0430\u045E\u0441\u044F \u0430\u0434\u0437\u0456\u043D \u0437 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const maxValue = Number(issue2.maximum);
          const unit = getBelarusianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.maximum.toString()} ${unit}`;
        }
        return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u0432\u044F\u043B\u0456\u043A\u0456: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435"} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const minValue = Number(issue2.minimum);
          const unit = getBelarusianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
          return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 ${sizing.verb} ${adj}${issue2.minimum.toString()} ${unit}`;
        }
        return `\u0417\u0430\u043D\u0430\u0434\u0442\u0430 \u043C\u0430\u043B\u044B: \u0447\u0430\u043A\u0430\u043B\u0430\u0441\u044F, \u0448\u0442\u043E ${issue2.origin} \u043F\u0430\u0432\u0456\u043D\u043D\u0430 \u0431\u044B\u0446\u044C ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u043F\u0430\u0447\u044B\u043D\u0430\u0446\u0446\u0430 \u0437 "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u0430\u043A\u0430\u043D\u0447\u0432\u0430\u0446\u0446\u0430 \u043D\u0430 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0437\u043C\u044F\u0448\u0447\u0430\u0446\u044C "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u0440\u0430\u0434\u043E\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0430\u0434\u043F\u0430\u0432\u044F\u0434\u0430\u0446\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043B\u0456\u043A: \u043F\u0430\u0432\u0456\u043D\u0435\u043D \u0431\u044B\u0446\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u041D\u0435\u0440\u0430\u0441\u043F\u0430\u0437\u043D\u0430\u043D\u044B ${issue2.keys.length > 1 ? "\u043A\u043B\u044E\u0447\u044B" : "\u043A\u043B\u044E\u0447"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`;
      case "invalid_union":
        return "\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434";
      case "invalid_element":
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u0430\u0435 \u0437\u043D\u0430\u0447\u044D\u043D\u043D\u0435 \u045E ${issue2.origin}`;
      default:
        return `\u041D\u044F\u043F\u0440\u0430\u0432\u0456\u043B\u044C\u043D\u044B \u045E\u0432\u043E\u0434`;
    }
  };
};
function be_default() {
  return {
    localeError: error3()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/bg.js
var error4 = () => {
  const Sizable = {
    string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
    file: { unit: "\u0431\u0430\u0439\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
    array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" },
    set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430", verb: "\u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0432\u0445\u043E\u0434",
    email: "\u0438\u043C\u0435\u0439\u043B \u0430\u0434\u0440\u0435\u0441",
    url: "URL",
    emoji: "\u0435\u043C\u043E\u0434\u0436\u0438",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0432\u0440\u0435\u043C\u0435",
    date: "ISO \u0434\u0430\u0442\u0430",
    time: "ISO \u0432\u0440\u0435\u043C\u0435",
    duration: "ISO \u043F\u0440\u043E\u0434\u044A\u043B\u0436\u0438\u0442\u0435\u043B\u043D\u043E\u0441\u0442",
    ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
    ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
    cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
    cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
    base64: "base64-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
    base64url: "base64url-\u043A\u043E\u0434\u0438\u0440\u0430\u043D \u043D\u0438\u0437",
    json_string: "JSON \u043D\u0438\u0437",
    e164: "E.164 \u043D\u043E\u043C\u0435\u0440",
    jwt: "JWT",
    template_literal: "\u0432\u0445\u043E\u0434"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0447\u0438\u0441\u043B\u043E",
    array: "\u043C\u0430\u0441\u0438\u0432"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
        }
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434: \u043E\u0447\u0430\u043A\u0432\u0430\u043D ${stringifyPrimitive(issue2.values[0])}`;
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u043E\u043F\u0446\u0438\u044F: \u043E\u0447\u0430\u043A\u0432\u0430\u043D\u043E \u0435\u0434\u043D\u043E \u043E\u0442 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0430"}`;
        return `\u0422\u0432\u044A\u0440\u0434\u0435 \u0433\u043E\u043B\u044F\u043C\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin ?? "\u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442"} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0441\u044A\u0434\u044A\u0440\u0436\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u0422\u0432\u044A\u0440\u0434\u0435 \u043C\u0430\u043B\u043A\u043E: \u043E\u0447\u0430\u043A\u0432\u0430 \u0441\u0435 ${issue2.origin} \u0434\u0430 \u0431\u044A\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u0432\u0430 \u0441 "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0437\u0430\u0432\u044A\u0440\u0448\u0432\u0430 \u0441 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0432\u043A\u043B\u044E\u0447\u0432\u0430 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043D\u0438\u0437: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0441\u044A\u0432\u043F\u0430\u0434\u0430 \u0441 ${_issue.pattern}`;
        let invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D";
        if (_issue.format === "emoji")
          invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
        if (_issue.format === "datetime")
          invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
        if (_issue.format === "date")
          invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
        if (_issue.format === "time")
          invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E";
        if (_issue.format === "duration")
          invalid_adj = "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430";
        return `${invalid_adj} ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u043E \u0447\u0438\u0441\u043B\u043E: \u0442\u0440\u044F\u0431\u0432\u0430 \u0434\u0430 \u0431\u044A\u0434\u0435 \u043A\u0440\u0430\u0442\u043D\u043E \u043D\u0430 ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u041D\u0435\u0440\u0430\u0437\u043F\u043E\u0437\u043D\u0430\u0442${issue2.keys.length > 1 ? "\u0438" : ""} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u043E\u0432\u0435" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`;
      case "invalid_union":
        return "\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434";
      case "invalid_element":
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u043D\u0430 \u0441\u0442\u043E\u0439\u043D\u043E\u0441\u0442 \u0432 ${issue2.origin}`;
      default:
        return `\u041D\u0435\u0432\u0430\u043B\u0438\u0434\u0435\u043D \u0432\u0445\u043E\u0434`;
    }
  };
};
function bg_default() {
  return {
    localeError: error4()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ca.js
var error5 = () => {
  const Sizable = {
    string: { unit: "car\xE0cters", verb: "contenir" },
    file: { unit: "bytes", verb: "contenir" },
    array: { unit: "elements", verb: "contenir" },
    set: { unit: "elements", verb: "contenir" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "entrada",
    email: "adre\xE7a electr\xF2nica",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "data i hora ISO",
    date: "data ISO",
    time: "hora ISO",
    duration: "durada ISO",
    ipv4: "adre\xE7a IPv4",
    ipv6: "adre\xE7a IPv6",
    cidrv4: "rang IPv4",
    cidrv6: "rang IPv6",
    base64: "cadena codificada en base64",
    base64url: "cadena codificada en base64url",
    json_string: "cadena JSON",
    e164: "n\xFAmero E.164",
    jwt: "JWT",
    template_literal: "entrada"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Tipus inv\xE0lid: s'esperava instanceof ${issue2.expected}, s'ha rebut ${received}`;
        }
        return `Tipus inv\xE0lid: s'esperava ${expected}, s'ha rebut ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Valor inv\xE0lid: s'esperava ${stringifyPrimitive(issue2.values[0])}`;
        return `Opci\xF3 inv\xE0lida: s'esperava una de ${joinValues(issue2.values, " o ")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "com a m\xE0xim" : "menys de";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Massa gran: s'esperava que ${issue2.origin ?? "el valor"} contingu\xE9s ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
        return `Massa gran: s'esperava que ${issue2.origin ?? "el valor"} fos ${adj} ${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? "com a m\xEDnim" : "m\xE9s de";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Massa petit: s'esperava que ${issue2.origin} contingu\xE9s ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Massa petit: s'esperava que ${issue2.origin} fos ${adj} ${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Format inv\xE0lid: ha de comen\xE7ar amb "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Format inv\xE0lid: ha d'acabar amb "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Format inv\xE0lid: ha d'incloure "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Format inv\xE0lid: ha de coincidir amb el patr\xF3 ${_issue.pattern}`;
        return `Format inv\xE0lid per a ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `N\xFAmero inv\xE0lid: ha de ser m\xFAltiple de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Clau${issue2.keys.length > 1 ? "s" : ""} no reconeguda${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Clau inv\xE0lida a ${issue2.origin}`;
      case "invalid_union":
        return "Entrada inv\xE0lida";
      // Could also be "Tipus d'unió invàlid" but "Entrada invàlida" is more general
      case "invalid_element":
        return `Element inv\xE0lid a ${issue2.origin}`;
      default:
        return `Entrada inv\xE0lida`;
    }
  };
};
function ca_default() {
  return {
    localeError: error5()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/cs.js
var error6 = () => {
  const Sizable = {
    string: { unit: "znak\u016F", verb: "m\xEDt" },
    file: { unit: "bajt\u016F", verb: "m\xEDt" },
    array: { unit: "prvk\u016F", verb: "m\xEDt" },
    set: { unit: "prvk\u016F", verb: "m\xEDt" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "regul\xE1rn\xED v\xFDraz",
    email: "e-mailov\xE1 adresa",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "datum a \u010Das ve form\xE1tu ISO",
    date: "datum ve form\xE1tu ISO",
    time: "\u010Das ve form\xE1tu ISO",
    duration: "doba trv\xE1n\xED ISO",
    ipv4: "IPv4 adresa",
    ipv6: "IPv6 adresa",
    cidrv4: "rozsah IPv4",
    cidrv6: "rozsah IPv6",
    base64: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64",
    base64url: "\u0159et\u011Bzec zak\xF3dovan\xFD ve form\xE1tu base64url",
    json_string: "\u0159et\u011Bzec ve form\xE1tu JSON",
    e164: "\u010D\xEDslo E.164",
    jwt: "JWT",
    template_literal: "vstup"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u010D\xEDslo",
    string: "\u0159et\u011Bzec",
    function: "funkce",
    array: "pole"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no instanceof ${issue2.expected}, obdr\u017Eeno ${received}`;
        }
        return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${expected}, obdr\u017Eeno ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Neplatn\xFD vstup: o\u010Dek\xE1v\xE1no ${stringifyPrimitive(issue2.values[0])}`;
        return `Neplatn\xE1 mo\u017Enost: o\u010Dek\xE1v\xE1na jedna z hodnot ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue2.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
        }
        return `Hodnota je p\u0159\xEDli\u0161 velk\xE1: ${issue2.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED m\xEDt ${adj}${issue2.minimum.toString()} ${sizing.unit ?? "prvk\u016F"}`;
        }
        return `Hodnota je p\u0159\xEDli\u0161 mal\xE1: ${issue2.origin ?? "hodnota"} mus\xED b\xFDt ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Neplatn\xFD \u0159et\u011Bzec: mus\xED za\u010D\xEDnat na "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Neplatn\xFD \u0159et\u011Bzec: mus\xED kon\u010Dit na "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Neplatn\xFD \u0159et\u011Bzec: mus\xED obsahovat "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Neplatn\xFD \u0159et\u011Bzec: mus\xED odpov\xEDdat vzoru ${_issue.pattern}`;
        return `Neplatn\xFD form\xE1t ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Neplatn\xE9 \u010D\xEDslo: mus\xED b\xFDt n\xE1sobkem ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Nezn\xE1m\xE9 kl\xED\u010De: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Neplatn\xFD kl\xED\u010D v ${issue2.origin}`;
      case "invalid_union":
        return "Neplatn\xFD vstup";
      case "invalid_element":
        return `Neplatn\xE1 hodnota v ${issue2.origin}`;
      default:
        return `Neplatn\xFD vstup`;
    }
  };
};
function cs_default() {
  return {
    localeError: error6()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/da.js
var error7 = () => {
  const Sizable = {
    string: { unit: "tegn", verb: "havde" },
    file: { unit: "bytes", verb: "havde" },
    array: { unit: "elementer", verb: "indeholdt" },
    set: { unit: "elementer", verb: "indeholdt" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "e-mailadresse",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO dato- og klokkesl\xE6t",
    date: "ISO-dato",
    time: "ISO-klokkesl\xE6t",
    duration: "ISO-varighed",
    ipv4: "IPv4-omr\xE5de",
    ipv6: "IPv6-omr\xE5de",
    cidrv4: "IPv4-spektrum",
    cidrv6: "IPv6-spektrum",
    base64: "base64-kodet streng",
    base64url: "base64url-kodet streng",
    json_string: "JSON-streng",
    e164: "E.164-nummer",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN",
    string: "streng",
    number: "tal",
    boolean: "boolean",
    array: "liste",
    object: "objekt",
    set: "s\xE6t",
    file: "fil"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ugyldigt input: forventede instanceof ${issue2.expected}, fik ${received}`;
        }
        return `Ugyldigt input: forventede ${expected}, fik ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ugyldig v\xE6rdi: forventede ${stringifyPrimitive(issue2.values[0])}`;
        return `Ugyldigt valg: forventede en af f\xF8lgende ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        if (sizing)
          return `For stor: forventede ${origin ?? "value"} ${sizing.verb} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "elementer"}`;
        return `For stor: forventede ${origin ?? "value"} havde ${adj} ${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        if (sizing) {
          return `For lille: forventede ${origin} ${sizing.verb} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `For lille: forventede ${origin} havde ${adj} ${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Ugyldig streng: skal starte med "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Ugyldig streng: skal ende med "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Ugyldig streng: skal indeholde "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Ugyldig streng: skal matche m\xF8nsteret ${_issue.pattern}`;
        return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ugyldigt tal: skal v\xE6re deleligt med ${issue2.divisor}`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "Ukendte n\xF8gler" : "Ukendt n\xF8gle"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Ugyldig n\xF8gle i ${issue2.origin}`;
      case "invalid_union":
        return "Ugyldigt input: matcher ingen af de tilladte typer";
      case "invalid_element":
        return `Ugyldig v\xE6rdi i ${issue2.origin}`;
      default:
        return `Ugyldigt input`;
    }
  };
};
function da_default() {
  return {
    localeError: error7()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/de.js
var error8 = () => {
  const Sizable = {
    string: { unit: "Zeichen", verb: "zu haben" },
    file: { unit: "Bytes", verb: "zu haben" },
    array: { unit: "Elemente", verb: "zu haben" },
    set: { unit: "Elemente", verb: "zu haben" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "Eingabe",
    email: "E-Mail-Adresse",
    url: "URL",
    emoji: "Emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO-Datum und -Uhrzeit",
    date: "ISO-Datum",
    time: "ISO-Uhrzeit",
    duration: "ISO-Dauer",
    ipv4: "IPv4-Adresse",
    ipv6: "IPv6-Adresse",
    cidrv4: "IPv4-Bereich",
    cidrv6: "IPv6-Bereich",
    base64: "Base64-codierter String",
    base64url: "Base64-URL-codierter String",
    json_string: "JSON-String",
    e164: "E.164-Nummer",
    jwt: "JWT",
    template_literal: "Eingabe"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "Zahl",
    array: "Array"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ung\xFCltige Eingabe: erwartet instanceof ${issue2.expected}, erhalten ${received}`;
        }
        return `Ung\xFCltige Eingabe: erwartet ${expected}, erhalten ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ung\xFCltige Eingabe: erwartet ${stringifyPrimitive(issue2.values[0])}`;
        return `Ung\xFCltige Option: erwartet eine von ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Zu gro\xDF: erwartet, dass ${issue2.origin ?? "Wert"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "Elemente"} hat`;
        return `Zu gro\xDF: erwartet, dass ${issue2.origin ?? "Wert"} ${adj}${issue2.maximum.toString()} ist`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} hat`;
        }
        return `Zu klein: erwartet, dass ${issue2.origin} ${adj}${issue2.minimum.toString()} ist`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Ung\xFCltiger String: muss mit "${_issue.prefix}" beginnen`;
        if (_issue.format === "ends_with")
          return `Ung\xFCltiger String: muss mit "${_issue.suffix}" enden`;
        if (_issue.format === "includes")
          return `Ung\xFCltiger String: muss "${_issue.includes}" enthalten`;
        if (_issue.format === "regex")
          return `Ung\xFCltiger String: muss dem Muster ${_issue.pattern} entsprechen`;
        return `Ung\xFCltig: ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ung\xFCltige Zahl: muss ein Vielfaches von ${issue2.divisor} sein`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "Unbekannte Schl\xFCssel" : "Unbekannter Schl\xFCssel"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Ung\xFCltiger Schl\xFCssel in ${issue2.origin}`;
      case "invalid_union":
        return "Ung\xFCltige Eingabe";
      case "invalid_element":
        return `Ung\xFCltiger Wert in ${issue2.origin}`;
      default:
        return `Ung\xFCltige Eingabe`;
    }
  };
};
function de_default() {
  return {
    localeError: error8()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/en.js
var error9 = () => {
  const Sizable = {
    string: { unit: "characters", verb: "to have" },
    file: { unit: "bytes", verb: "to have" },
    array: { unit: "items", verb: "to have" },
    set: { unit: "items", verb: "to have" },
    map: { unit: "entries", verb: "to have" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "email address",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO datetime",
    date: "ISO date",
    time: "ISO time",
    duration: "ISO duration",
    ipv4: "IPv4 address",
    ipv6: "IPv6 address",
    mac: "MAC address",
    cidrv4: "IPv4 range",
    cidrv6: "IPv6 range",
    base64: "base64-encoded string",
    base64url: "base64url-encoded string",
    json_string: "JSON string",
    e164: "E.164 number",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    // Compatibility: "nan" -> "NaN" for display
    nan: "NaN"
    // All other type names omitted - they fall back to raw values via ?? operator
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        return `Invalid input: expected ${expected}, received ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
        return `Invalid option: expected one of ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Too big: expected ${issue2.origin ?? "value"} to have ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"}`;
        return `Too big: expected ${issue2.origin ?? "value"} to be ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Too small: expected ${issue2.origin} to have ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Too small: expected ${issue2.origin} to be ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Invalid string: must start with "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Invalid string: must end with "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Invalid string: must include "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Invalid string: must match pattern ${_issue.pattern}`;
        return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Invalid number: must be a multiple of ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Unrecognized key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Invalid key in ${issue2.origin}`;
      case "invalid_union":
        return "Invalid input";
      case "invalid_element":
        return `Invalid value in ${issue2.origin}`;
      default:
        return `Invalid input`;
    }
  };
};
function en_default() {
  return {
    localeError: error9()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/eo.js
var error10 = () => {
  const Sizable = {
    string: { unit: "karaktrojn", verb: "havi" },
    file: { unit: "bajtojn", verb: "havi" },
    array: { unit: "elementojn", verb: "havi" },
    set: { unit: "elementojn", verb: "havi" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "enigo",
    email: "retadreso",
    url: "URL",
    emoji: "emo\u011Dio",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO-datotempo",
    date: "ISO-dato",
    time: "ISO-tempo",
    duration: "ISO-da\u016Dro",
    ipv4: "IPv4-adreso",
    ipv6: "IPv6-adreso",
    cidrv4: "IPv4-rango",
    cidrv6: "IPv6-rango",
    base64: "64-ume kodita karaktraro",
    base64url: "URL-64-ume kodita karaktraro",
    json_string: "JSON-karaktraro",
    e164: "E.164-nombro",
    jwt: "JWT",
    template_literal: "enigo"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "nombro",
    array: "tabelo",
    null: "senvalora"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Nevalida enigo: atendi\u011Dis instanceof ${issue2.expected}, ricevi\u011Dis ${received}`;
        }
        return `Nevalida enigo: atendi\u011Dis ${expected}, ricevi\u011Dis ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Nevalida enigo: atendi\u011Dis ${stringifyPrimitive(issue2.values[0])}`;
        return `Nevalida opcio: atendi\u011Dis unu el ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Tro granda: atendi\u011Dis ke ${issue2.origin ?? "valoro"} havu ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementojn"}`;
        return `Tro granda: atendi\u011Dis ke ${issue2.origin ?? "valoro"} havu ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} havu ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Tro malgranda: atendi\u011Dis ke ${issue2.origin} estu ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Nevalida karaktraro: devas komenci\u011Di per "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Nevalida karaktraro: devas fini\u011Di per "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Nevalida karaktraro: devas inkluzivi "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Nevalida karaktraro: devas kongrui kun la modelo ${_issue.pattern}`;
        return `Nevalida ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Nevalida nombro: devas esti oblo de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Nekonata${issue2.keys.length > 1 ? "j" : ""} \u015Dlosilo${issue2.keys.length > 1 ? "j" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Nevalida \u015Dlosilo en ${issue2.origin}`;
      case "invalid_union":
        return "Nevalida enigo";
      case "invalid_element":
        return `Nevalida valoro en ${issue2.origin}`;
      default:
        return `Nevalida enigo`;
    }
  };
};
function eo_default() {
  return {
    localeError: error10()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/es.js
var error11 = () => {
  const Sizable = {
    string: { unit: "caracteres", verb: "tener" },
    file: { unit: "bytes", verb: "tener" },
    array: { unit: "elementos", verb: "tener" },
    set: { unit: "elementos", verb: "tener" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "entrada",
    email: "direcci\xF3n de correo electr\xF3nico",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "fecha y hora ISO",
    date: "fecha ISO",
    time: "hora ISO",
    duration: "duraci\xF3n ISO",
    ipv4: "direcci\xF3n IPv4",
    ipv6: "direcci\xF3n IPv6",
    cidrv4: "rango IPv4",
    cidrv6: "rango IPv6",
    base64: "cadena codificada en base64",
    base64url: "URL codificada en base64",
    json_string: "cadena JSON",
    e164: "n\xFAmero E.164",
    jwt: "JWT",
    template_literal: "entrada"
  };
  const TypeDictionary = {
    nan: "NaN",
    string: "texto",
    number: "n\xFAmero",
    boolean: "booleano",
    array: "arreglo",
    object: "objeto",
    set: "conjunto",
    file: "archivo",
    date: "fecha",
    bigint: "n\xFAmero grande",
    symbol: "s\xEDmbolo",
    undefined: "indefinido",
    null: "nulo",
    function: "funci\xF3n",
    map: "mapa",
    record: "registro",
    tuple: "tupla",
    enum: "enumeraci\xF3n",
    union: "uni\xF3n",
    literal: "literal",
    promise: "promesa",
    void: "vac\xEDo",
    never: "nunca",
    unknown: "desconocido",
    any: "cualquiera"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Entrada inv\xE1lida: se esperaba instanceof ${issue2.expected}, recibido ${received}`;
        }
        return `Entrada inv\xE1lida: se esperaba ${expected}, recibido ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Entrada inv\xE1lida: se esperaba ${stringifyPrimitive(issue2.values[0])}`;
        return `Opci\xF3n inv\xE1lida: se esperaba una de ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        if (sizing)
          return `Demasiado grande: se esperaba que ${origin ?? "valor"} tuviera ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
        return `Demasiado grande: se esperaba que ${origin ?? "valor"} fuera ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        if (sizing) {
          return `Demasiado peque\xF1o: se esperaba que ${origin} tuviera ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Demasiado peque\xF1o: se esperaba que ${origin} fuera ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Cadena inv\xE1lida: debe comenzar con "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Cadena inv\xE1lida: debe terminar en "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Cadena inv\xE1lida: debe incluir "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Cadena inv\xE1lida: debe coincidir con el patr\xF3n ${_issue.pattern}`;
        return `Inv\xE1lido ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `N\xFAmero inv\xE1lido: debe ser m\xFAltiplo de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Llave${issue2.keys.length > 1 ? "s" : ""} desconocida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Llave inv\xE1lida en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
      case "invalid_union":
        return "Entrada inv\xE1lida";
      case "invalid_element":
        return `Valor inv\xE1lido en ${TypeDictionary[issue2.origin] ?? issue2.origin}`;
      default:
        return `Entrada inv\xE1lida`;
    }
  };
};
function es_default() {
  return {
    localeError: error11()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/fa.js
var error12 = () => {
  const Sizable = {
    string: { unit: "\u06A9\u0627\u0631\u0627\u06A9\u062A\u0631", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
    file: { unit: "\u0628\u0627\u06CC\u062A", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
    array: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" },
    set: { unit: "\u0622\u06CC\u062A\u0645", verb: "\u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0648\u0631\u0648\u062F\u06CC",
    email: "\u0622\u062F\u0631\u0633 \u0627\u06CC\u0645\u06CC\u0644",
    url: "URL",
    emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u062A\u0627\u0631\u06CC\u062E \u0648 \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
    date: "\u062A\u0627\u0631\u06CC\u062E \u0627\u06CC\u0632\u0648",
    time: "\u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
    duration: "\u0645\u062F\u062A \u0632\u0645\u0627\u0646 \u0627\u06CC\u0632\u0648",
    ipv4: "IPv4 \u0622\u062F\u0631\u0633",
    ipv6: "IPv6 \u0622\u062F\u0631\u0633",
    cidrv4: "IPv4 \u062F\u0627\u0645\u0646\u0647",
    cidrv6: "IPv6 \u062F\u0627\u0645\u0646\u0647",
    base64: "base64-encoded \u0631\u0634\u062A\u0647",
    base64url: "base64url-encoded \u0631\u0634\u062A\u0647",
    json_string: "JSON \u0631\u0634\u062A\u0647",
    e164: "E.164 \u0639\u062F\u062F",
    jwt: "JWT",
    template_literal: "\u0648\u0631\u0648\u062F\u06CC"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0639\u062F\u062F",
    array: "\u0622\u0631\u0627\u06CC\u0647"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A instanceof ${issue2.expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
        }
        return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${expected} \u0645\u06CC\u200C\u0628\u0648\u062F\u060C ${received} \u062F\u0631\u06CC\u0627\u0641\u062A \u0634\u062F`;
      }
      case "invalid_value":
        if (issue2.values.length === 1) {
          return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A ${stringifyPrimitive(issue2.values[0])} \u0645\u06CC\u200C\u0628\u0648\u062F`;
        }
        return `\u06AF\u0632\u06CC\u0646\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0645\u06CC\u200C\u0628\u0627\u06CC\u0633\u062A \u06CC\u06A9\u06CC \u0627\u0632 ${joinValues(issue2.values, "|")} \u0645\u06CC\u200C\u0628\u0648\u062F`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue2.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631"} \u0628\u0627\u0634\u062F`;
        }
        return `\u062E\u06CC\u0644\u06CC \u0628\u0632\u0631\u06AF: ${issue2.origin ?? "\u0645\u0642\u062F\u0627\u0631"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0628\u0627\u0634\u062F`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0628\u0627\u0634\u062F`;
        }
        return `\u062E\u06CC\u0644\u06CC \u06A9\u0648\u0686\u06A9: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0628\u0627\u0634\u062F`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.prefix}" \u0634\u0631\u0648\u0639 \u0634\u0648\u062F`;
        }
        if (_issue.format === "ends_with") {
          return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 "${_issue.suffix}" \u062A\u0645\u0627\u0645 \u0634\u0648\u062F`;
        }
        if (_issue.format === "includes") {
          return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0634\u0627\u0645\u0644 "${_issue.includes}" \u0628\u0627\u0634\u062F`;
        }
        if (_issue.format === "regex") {
          return `\u0631\u0634\u062A\u0647 \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0628\u0627 \u0627\u0644\u06AF\u0648\u06CC ${_issue.pattern} \u0645\u0637\u0627\u0628\u0642\u062A \u062F\u0627\u0634\u062A\u0647 \u0628\u0627\u0634\u062F`;
        }
        return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
      }
      case "not_multiple_of":
        return `\u0639\u062F\u062F \u0646\u0627\u0645\u0639\u062A\u0628\u0631: \u0628\u0627\u06CC\u062F \u0645\u0636\u0631\u0628 ${issue2.divisor} \u0628\u0627\u0634\u062F`;
      case "unrecognized_keys":
        return `\u06A9\u0644\u06CC\u062F${issue2.keys.length > 1 ? "\u0647\u0627\u06CC" : ""} \u0646\u0627\u0634\u0646\u0627\u0633: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u06A9\u0644\u06CC\u062F \u0646\u0627\u0634\u0646\u0627\u0633 \u062F\u0631 ${issue2.origin}`;
      case "invalid_union":
        return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
      case "invalid_element":
        return `\u0645\u0642\u062F\u0627\u0631 \u0646\u0627\u0645\u0639\u062A\u0628\u0631 \u062F\u0631 ${issue2.origin}`;
      default:
        return `\u0648\u0631\u0648\u062F\u06CC \u0646\u0627\u0645\u0639\u062A\u0628\u0631`;
    }
  };
};
function fa_default() {
  return {
    localeError: error12()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/fi.js
var error13 = () => {
  const Sizable = {
    string: { unit: "merkki\xE4", subject: "merkkijonon" },
    file: { unit: "tavua", subject: "tiedoston" },
    array: { unit: "alkiota", subject: "listan" },
    set: { unit: "alkiota", subject: "joukon" },
    number: { unit: "", subject: "luvun" },
    bigint: { unit: "", subject: "suuren kokonaisluvun" },
    int: { unit: "", subject: "kokonaisluvun" },
    date: { unit: "", subject: "p\xE4iv\xE4m\xE4\xE4r\xE4n" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "s\xE4\xE4nn\xF6llinen lauseke",
    email: "s\xE4hk\xF6postiosoite",
    url: "URL-osoite",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO-aikaleima",
    date: "ISO-p\xE4iv\xE4m\xE4\xE4r\xE4",
    time: "ISO-aika",
    duration: "ISO-kesto",
    ipv4: "IPv4-osoite",
    ipv6: "IPv6-osoite",
    cidrv4: "IPv4-alue",
    cidrv6: "IPv6-alue",
    base64: "base64-koodattu merkkijono",
    base64url: "base64url-koodattu merkkijono",
    json_string: "JSON-merkkijono",
    e164: "E.164-luku",
    jwt: "JWT",
    template_literal: "templaattimerkkijono"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Virheellinen tyyppi: odotettiin instanceof ${issue2.expected}, oli ${received}`;
        }
        return `Virheellinen tyyppi: odotettiin ${expected}, oli ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Virheellinen sy\xF6te: t\xE4ytyy olla ${stringifyPrimitive(issue2.values[0])}`;
        return `Virheellinen valinta: t\xE4ytyy olla yksi seuraavista: ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Liian suuri: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.maximum.toString()} ${sizing.unit}`.trim();
        }
        return `Liian suuri: arvon t\xE4ytyy olla ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Liian pieni: ${sizing.subject} t\xE4ytyy olla ${adj}${issue2.minimum.toString()} ${sizing.unit}`.trim();
        }
        return `Liian pieni: arvon t\xE4ytyy olla ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Virheellinen sy\xF6te: t\xE4ytyy alkaa "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Virheellinen sy\xF6te: t\xE4ytyy loppua "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Virheellinen sy\xF6te: t\xE4ytyy sis\xE4lt\xE4\xE4 "${_issue.includes}"`;
        if (_issue.format === "regex") {
          return `Virheellinen sy\xF6te: t\xE4ytyy vastata s\xE4\xE4nn\xF6llist\xE4 lauseketta ${_issue.pattern}`;
        }
        return `Virheellinen ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Virheellinen luku: t\xE4ytyy olla luvun ${issue2.divisor} monikerta`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "Tuntemattomat avaimet" : "Tuntematon avain"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return "Virheellinen avain tietueessa";
      case "invalid_union":
        return "Virheellinen unioni";
      case "invalid_element":
        return "Virheellinen arvo joukossa";
      default:
        return `Virheellinen sy\xF6te`;
    }
  };
};
function fi_default() {
  return {
    localeError: error13()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/fr.js
var error14 = () => {
  const Sizable = {
    string: { unit: "caract\xE8res", verb: "avoir" },
    file: { unit: "octets", verb: "avoir" },
    array: { unit: "\xE9l\xE9ments", verb: "avoir" },
    set: { unit: "\xE9l\xE9ments", verb: "avoir" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "entr\xE9e",
    email: "adresse e-mail",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "date et heure ISO",
    date: "date ISO",
    time: "heure ISO",
    duration: "dur\xE9e ISO",
    ipv4: "adresse IPv4",
    ipv6: "adresse IPv6",
    cidrv4: "plage IPv4",
    cidrv6: "plage IPv6",
    base64: "cha\xEEne encod\xE9e en base64",
    base64url: "cha\xEEne encod\xE9e en base64url",
    json_string: "cha\xEEne JSON",
    e164: "num\xE9ro E.164",
    jwt: "JWT",
    template_literal: "entr\xE9e"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "nombre",
    array: "tableau"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Entr\xE9e invalide : instanceof ${issue2.expected} attendu, ${received} re\xE7u`;
        }
        return `Entr\xE9e invalide : ${expected} attendu, ${received} re\xE7u`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Entr\xE9e invalide : ${stringifyPrimitive(issue2.values[0])} attendu`;
        return `Option invalide : une valeur parmi ${joinValues(issue2.values, "|")} attendue`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Trop grand : ${issue2.origin ?? "valeur"} doit ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xE9l\xE9ment(s)"}`;
        return `Trop grand : ${issue2.origin ?? "valeur"} doit \xEAtre ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Trop petit : ${issue2.origin} doit ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Trop petit : ${issue2.origin} doit \xEAtre ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Cha\xEEne invalide : doit correspondre au mod\xE8le ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
      }
      case "not_multiple_of":
        return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Cl\xE9 invalide dans ${issue2.origin}`;
      case "invalid_union":
        return "Entr\xE9e invalide";
      case "invalid_element":
        return `Valeur invalide dans ${issue2.origin}`;
      default:
        return `Entr\xE9e invalide`;
    }
  };
};
function fr_default() {
  return {
    localeError: error14()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/fr-CA.js
var error15 = () => {
  const Sizable = {
    string: { unit: "caract\xE8res", verb: "avoir" },
    file: { unit: "octets", verb: "avoir" },
    array: { unit: "\xE9l\xE9ments", verb: "avoir" },
    set: { unit: "\xE9l\xE9ments", verb: "avoir" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "entr\xE9e",
    email: "adresse courriel",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "date-heure ISO",
    date: "date ISO",
    time: "heure ISO",
    duration: "dur\xE9e ISO",
    ipv4: "adresse IPv4",
    ipv6: "adresse IPv6",
    cidrv4: "plage IPv4",
    cidrv6: "plage IPv6",
    base64: "cha\xEEne encod\xE9e en base64",
    base64url: "cha\xEEne encod\xE9e en base64url",
    json_string: "cha\xEEne JSON",
    e164: "num\xE9ro E.164",
    jwt: "JWT",
    template_literal: "entr\xE9e"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Entr\xE9e invalide : attendu instanceof ${issue2.expected}, re\xE7u ${received}`;
        }
        return `Entr\xE9e invalide : attendu ${expected}, re\xE7u ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Entr\xE9e invalide : attendu ${stringifyPrimitive(issue2.values[0])}`;
        return `Option invalide : attendu l'une des valeurs suivantes ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "\u2264" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Trop grand : attendu que ${issue2.origin ?? "la valeur"} ait ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
        return `Trop grand : attendu que ${issue2.origin ?? "la valeur"} soit ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? "\u2265" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Trop petit : attendu que ${issue2.origin} ait ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Trop petit : attendu que ${issue2.origin} soit ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Cha\xEEne invalide : doit commencer par "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Cha\xEEne invalide : doit se terminer par "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Cha\xEEne invalide : doit inclure "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Cha\xEEne invalide : doit correspondre au motif ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} invalide`;
      }
      case "not_multiple_of":
        return `Nombre invalide : doit \xEAtre un multiple de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Cl\xE9${issue2.keys.length > 1 ? "s" : ""} non reconnue${issue2.keys.length > 1 ? "s" : ""} : ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Cl\xE9 invalide dans ${issue2.origin}`;
      case "invalid_union":
        return "Entr\xE9e invalide";
      case "invalid_element":
        return `Valeur invalide dans ${issue2.origin}`;
      default:
        return `Entr\xE9e invalide`;
    }
  };
};
function fr_CA_default() {
  return {
    localeError: error15()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/he.js
var error16 = () => {
  const TypeNames = {
    string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA", gender: "f" },
    number: { label: "\u05DE\u05E1\u05E4\u05E8", gender: "m" },
    boolean: { label: "\u05E2\u05E8\u05DA \u05D1\u05D5\u05DC\u05D9\u05D0\u05E0\u05D9", gender: "m" },
    bigint: { label: "BigInt", gender: "m" },
    date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA", gender: "m" },
    array: { label: "\u05DE\u05E2\u05E8\u05DA", gender: "m" },
    object: { label: "\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8", gender: "m" },
    null: { label: "\u05E2\u05E8\u05DA \u05E8\u05D9\u05E7 (null)", gender: "m" },
    undefined: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05DE\u05D5\u05D2\u05D3\u05E8 (undefined)", gender: "m" },
    symbol: { label: "\u05E1\u05D9\u05DE\u05D1\u05D5\u05DC (Symbol)", gender: "m" },
    function: { label: "\u05E4\u05D5\u05E0\u05E7\u05E6\u05D9\u05D4", gender: "f" },
    map: { label: "\u05DE\u05E4\u05D4 (Map)", gender: "f" },
    set: { label: "\u05E7\u05D1\u05D5\u05E6\u05D4 (Set)", gender: "f" },
    file: { label: "\u05E7\u05D5\u05D1\u05E5", gender: "m" },
    promise: { label: "Promise", gender: "m" },
    NaN: { label: "NaN", gender: "m" },
    unknown: { label: "\u05E2\u05E8\u05DA \u05DC\u05D0 \u05D9\u05D3\u05D5\u05E2", gender: "m" },
    value: { label: "\u05E2\u05E8\u05DA", gender: "m" }
  };
  const Sizable = {
    string: { unit: "\u05EA\u05D5\u05D5\u05D9\u05DD", shortLabel: "\u05E7\u05E6\u05E8", longLabel: "\u05D0\u05E8\u05D5\u05DA" },
    file: { unit: "\u05D1\u05D9\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
    array: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
    set: { unit: "\u05E4\u05E8\u05D9\u05D8\u05D9\u05DD", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" },
    number: { unit: "", shortLabel: "\u05E7\u05D8\u05DF", longLabel: "\u05D2\u05D3\u05D5\u05DC" }
    // no unit
  };
  const typeEntry = (t) => t ? TypeNames[t] : void 0;
  const typeLabel = (t) => {
    const e = typeEntry(t);
    if (e)
      return e.label;
    return t ?? TypeNames.unknown.label;
  };
  const withDefinite = (t) => `\u05D4${typeLabel(t)}`;
  const verbFor = (t) => {
    const e = typeEntry(t);
    const gender = e?.gender ?? "m";
    return gender === "f" ? "\u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05D9\u05D5\u05EA" : "\u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA";
  };
  const getSizing = (origin) => {
    if (!origin)
      return null;
    return Sizable[origin] ?? null;
  };
  const FormatDictionary = {
    regex: { label: "\u05E7\u05DC\u05D8", gender: "m" },
    email: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05D0\u05D9\u05DE\u05D9\u05D9\u05DC", gender: "f" },
    url: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA \u05E8\u05E9\u05EA", gender: "f" },
    emoji: { label: "\u05D0\u05D9\u05DE\u05D5\u05D2'\u05D9", gender: "m" },
    uuid: { label: "UUID", gender: "m" },
    nanoid: { label: "nanoid", gender: "m" },
    guid: { label: "GUID", gender: "m" },
    cuid: { label: "cuid", gender: "m" },
    cuid2: { label: "cuid2", gender: "m" },
    ulid: { label: "ULID", gender: "m" },
    xid: { label: "XID", gender: "m" },
    ksuid: { label: "KSUID", gender: "m" },
    datetime: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA \u05D5\u05D6\u05DE\u05DF ISO", gender: "m" },
    date: { label: "\u05EA\u05D0\u05E8\u05D9\u05DA ISO", gender: "m" },
    time: { label: "\u05D6\u05DE\u05DF ISO", gender: "m" },
    duration: { label: "\u05DE\u05E9\u05DA \u05D6\u05DE\u05DF ISO", gender: "m" },
    ipv4: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv4", gender: "f" },
    ipv6: { label: "\u05DB\u05EA\u05D5\u05D1\u05EA IPv6", gender: "f" },
    cidrv4: { label: "\u05D8\u05D5\u05D5\u05D7 IPv4", gender: "m" },
    cidrv6: { label: "\u05D8\u05D5\u05D5\u05D7 IPv6", gender: "m" },
    base64: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64", gender: "f" },
    base64url: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D1\u05D1\u05E1\u05D9\u05E1 64 \u05DC\u05DB\u05EA\u05D5\u05D1\u05D5\u05EA \u05E8\u05E9\u05EA", gender: "f" },
    json_string: { label: "\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA JSON", gender: "f" },
    e164: { label: "\u05DE\u05E1\u05E4\u05E8 E.164", gender: "m" },
    jwt: { label: "JWT", gender: "m" },
    ends_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
    includes: { label: "\u05E7\u05DC\u05D8", gender: "m" },
    lowercase: { label: "\u05E7\u05DC\u05D8", gender: "m" },
    starts_with: { label: "\u05E7\u05DC\u05D8", gender: "m" },
    uppercase: { label: "\u05E7\u05DC\u05D8", gender: "m" }
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expectedKey = issue2.expected;
        const expected = TypeDictionary[expectedKey ?? ""] ?? typeLabel(expectedKey);
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? TypeNames[receivedType]?.label ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA instanceof ${issue2.expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
        }
        return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${expected}, \u05D4\u05EA\u05E7\u05D1\u05DC ${received}`;
      }
      case "invalid_value": {
        if (issue2.values.length === 1) {
          return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05E2\u05E8\u05DA \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA ${stringifyPrimitive(issue2.values[0])}`;
        }
        const stringified = issue2.values.map((v) => stringifyPrimitive(v));
        if (issue2.values.length === 2) {
          return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${stringified[0]} \u05D0\u05D5 ${stringified[1]}`;
        }
        const lastValue = stringified[stringified.length - 1];
        const restValues = stringified.slice(0, -1).join(", ");
        return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D4\u05D0\u05E4\u05E9\u05E8\u05D5\u05D9\u05D5\u05EA \u05D4\u05DE\u05EA\u05D0\u05D9\u05DE\u05D5\u05EA \u05D4\u05DF ${restValues} \u05D0\u05D5 ${lastValue}`;
      }
      case "too_big": {
        const sizing = getSizing(issue2.origin);
        const subject = withDefinite(issue2.origin ?? "value");
        if (issue2.origin === "string") {
          return `${sizing?.longLabel ?? "\u05D0\u05E8\u05D5\u05DA"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.maximum.toString()} ${sizing?.unit ?? ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA" : "\u05DC\u05DB\u05DC \u05D4\u05D9\u05D5\u05EA\u05E8"}`.trim();
        }
        if (issue2.origin === "number") {
          const comparison = issue2.inclusive ? `\u05E7\u05D8\u05DF \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.maximum}` : `\u05E7\u05D8\u05DF \u05DE-${issue2.maximum}`;
          return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
        }
        if (issue2.origin === "array" || issue2.origin === "set") {
          const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
          const comparison = issue2.inclusive ? `${issue2.maximum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05E4\u05D7\u05D5\u05EA` : `\u05E4\u05D7\u05D5\u05EA \u05DE-${issue2.maximum} ${sizing?.unit ?? ""}`;
          return `\u05D2\u05D3\u05D5\u05DC \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
        }
        const adj = issue2.inclusive ? "<=" : "<";
        const be = verbFor(issue2.origin ?? "value");
        if (sizing?.unit) {
          return `${sizing.longLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
        }
        return `${sizing?.longLabel ?? "\u05D2\u05D3\u05D5\u05DC"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const sizing = getSizing(issue2.origin);
        const subject = withDefinite(issue2.origin ?? "value");
        if (issue2.origin === "string") {
          return `${sizing?.shortLabel ?? "\u05E7\u05E6\u05E8"} \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DB\u05D4 \u05DC\u05D4\u05DB\u05D9\u05DC ${issue2.minimum.toString()} ${sizing?.unit ?? ""} ${issue2.inclusive ? "\u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8" : "\u05DC\u05E4\u05D7\u05D5\u05EA"}`.trim();
        }
        if (issue2.origin === "number") {
          const comparison = issue2.inclusive ? `\u05D2\u05D3\u05D5\u05DC \u05D0\u05D5 \u05E9\u05D5\u05D5\u05D4 \u05DC-${issue2.minimum}` : `\u05D2\u05D3\u05D5\u05DC \u05DE-${issue2.minimum}`;
          return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} \u05E6\u05E8\u05D9\u05DA \u05DC\u05D4\u05D9\u05D5\u05EA ${comparison}`;
        }
        if (issue2.origin === "array" || issue2.origin === "set") {
          const verb = issue2.origin === "set" ? "\u05E6\u05E8\u05D9\u05DB\u05D4" : "\u05E6\u05E8\u05D9\u05DA";
          if (issue2.minimum === 1 && issue2.inclusive) {
            const singularPhrase = issue2.origin === "set" ? "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3" : "\u05DC\u05E4\u05D7\u05D5\u05EA \u05E4\u05E8\u05D9\u05D8 \u05D0\u05D7\u05D3";
            return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${singularPhrase}`;
          }
          const comparison = issue2.inclusive ? `${issue2.minimum} ${sizing?.unit ?? ""} \u05D0\u05D5 \u05D9\u05D5\u05EA\u05E8` : `\u05D9\u05D5\u05EA\u05E8 \u05DE-${issue2.minimum} ${sizing?.unit ?? ""}`;
          return `\u05E7\u05D8\u05DF \u05DE\u05D3\u05D9: ${subject} ${verb} \u05DC\u05D4\u05DB\u05D9\u05DC ${comparison}`.trim();
        }
        const adj = issue2.inclusive ? ">=" : ">";
        const be = verbFor(issue2.origin ?? "value");
        if (sizing?.unit) {
          return `${sizing.shortLabel} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `${sizing?.shortLabel ?? "\u05E7\u05D8\u05DF"} \u05DE\u05D3\u05D9: ${subject} ${be} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D7\u05D9\u05DC \u05D1 "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05E1\u05EA\u05D9\u05D9\u05DD \u05D1 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05DB\u05DC\u05D5\u05DC "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u05D4\u05DE\u05D7\u05E8\u05D5\u05D6\u05EA \u05D7\u05D9\u05D9\u05D1\u05EA \u05DC\u05D4\u05EA\u05D0\u05D9\u05DD \u05DC\u05EA\u05D1\u05E0\u05D9\u05EA ${_issue.pattern}`;
        const nounEntry = FormatDictionary[_issue.format];
        const noun = nounEntry?.label ?? _issue.format;
        const gender = nounEntry?.gender ?? "m";
        const adjective = gender === "f" ? "\u05EA\u05E7\u05D9\u05E0\u05D4" : "\u05EA\u05E7\u05D9\u05DF";
        return `${noun} \u05DC\u05D0 ${adjective}`;
      }
      case "not_multiple_of":
        return `\u05DE\u05E1\u05E4\u05E8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF: \u05D7\u05D9\u05D9\u05D1 \u05DC\u05D4\u05D9\u05D5\u05EA \u05DE\u05DB\u05E4\u05DC\u05D4 \u05E9\u05DC ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u05DE\u05E4\u05EA\u05D7${issue2.keys.length > 1 ? "\u05D5\u05EA" : ""} \u05DC\u05D0 \u05DE\u05D6\u05D5\u05D4${issue2.keys.length > 1 ? "\u05D9\u05DD" : "\u05D4"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key": {
        return `\u05E9\u05D3\u05D4 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1\u05D0\u05D5\u05D1\u05D9\u05D9\u05E7\u05D8`;
      }
      case "invalid_union":
        return "\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF";
      case "invalid_element": {
        const place = withDefinite(issue2.origin ?? "array");
        return `\u05E2\u05E8\u05DA \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF \u05D1${place}`;
      }
      default:
        return `\u05E7\u05DC\u05D8 \u05DC\u05D0 \u05EA\u05E7\u05D9\u05DF`;
    }
  };
};
function he_default() {
  return {
    localeError: error16()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/hu.js
var error17 = () => {
  const Sizable = {
    string: { unit: "karakter", verb: "legyen" },
    file: { unit: "byte", verb: "legyen" },
    array: { unit: "elem", verb: "legyen" },
    set: { unit: "elem", verb: "legyen" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "bemenet",
    email: "email c\xEDm",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO id\u0151b\xE9lyeg",
    date: "ISO d\xE1tum",
    time: "ISO id\u0151",
    duration: "ISO id\u0151intervallum",
    ipv4: "IPv4 c\xEDm",
    ipv6: "IPv6 c\xEDm",
    cidrv4: "IPv4 tartom\xE1ny",
    cidrv6: "IPv6 tartom\xE1ny",
    base64: "base64-k\xF3dolt string",
    base64url: "base64url-k\xF3dolt string",
    json_string: "JSON string",
    e164: "E.164 sz\xE1m",
    jwt: "JWT",
    template_literal: "bemenet"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "sz\xE1m",
    array: "t\xF6mb"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k instanceof ${issue2.expected}, a kapott \xE9rt\xE9k ${received}`;
        }
        return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${expected}, a kapott \xE9rt\xE9k ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\xC9rv\xE9nytelen bemenet: a v\xE1rt \xE9rt\xE9k ${stringifyPrimitive(issue2.values[0])}`;
        return `\xC9rv\xE9nytelen opci\xF3: valamelyik \xE9rt\xE9k v\xE1rt ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `T\xFAl nagy: ${issue2.origin ?? "\xE9rt\xE9k"} m\xE9rete t\xFAl nagy ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elem"}`;
        return `T\xFAl nagy: a bemeneti \xE9rt\xE9k ${issue2.origin ?? "\xE9rt\xE9k"} t\xFAl nagy: ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} m\xE9rete t\xFAl kicsi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `T\xFAl kicsi: a bemeneti \xE9rt\xE9k ${issue2.origin} t\xFAl kicsi ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\xC9rv\xE9nytelen string: "${_issue.prefix}" \xE9rt\xE9kkel kell kezd\u0151dnie`;
        if (_issue.format === "ends_with")
          return `\xC9rv\xE9nytelen string: "${_issue.suffix}" \xE9rt\xE9kkel kell v\xE9gz\u0151dnie`;
        if (_issue.format === "includes")
          return `\xC9rv\xE9nytelen string: "${_issue.includes}" \xE9rt\xE9ket kell tartalmaznia`;
        if (_issue.format === "regex")
          return `\xC9rv\xE9nytelen string: ${_issue.pattern} mint\xE1nak kell megfelelnie`;
        return `\xC9rv\xE9nytelen ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\xC9rv\xE9nytelen sz\xE1m: ${issue2.divisor} t\xF6bbsz\xF6r\xF6s\xE9nek kell lennie`;
      case "unrecognized_keys":
        return `Ismeretlen kulcs${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\xC9rv\xE9nytelen kulcs ${issue2.origin}`;
      case "invalid_union":
        return "\xC9rv\xE9nytelen bemenet";
      case "invalid_element":
        return `\xC9rv\xE9nytelen \xE9rt\xE9k: ${issue2.origin}`;
      default:
        return `\xC9rv\xE9nytelen bemenet`;
    }
  };
};
function hu_default() {
  return {
    localeError: error17()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/hy.js
function getArmenianPlural(count, one, many) {
  return Math.abs(count) === 1 ? one : many;
}
function withDefiniteArticle(word) {
  if (!word)
    return "";
  const vowels = ["\u0561", "\u0565", "\u0568", "\u056B", "\u0578", "\u0578\u0582", "\u0585"];
  const lastChar = word[word.length - 1];
  return word + (vowels.includes(lastChar) ? "\u0576" : "\u0568");
}
var error18 = () => {
  const Sizable = {
    string: {
      unit: {
        one: "\u0576\u0577\u0561\u0576",
        many: "\u0576\u0577\u0561\u0576\u0576\u0565\u0580"
      },
      verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
    },
    file: {
      unit: {
        one: "\u0562\u0561\u0575\u0569",
        many: "\u0562\u0561\u0575\u0569\u0565\u0580"
      },
      verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
    },
    array: {
      unit: {
        one: "\u057F\u0561\u0580\u0580",
        many: "\u057F\u0561\u0580\u0580\u0565\u0580"
      },
      verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
    },
    set: {
      unit: {
        one: "\u057F\u0561\u0580\u0580",
        many: "\u057F\u0561\u0580\u0580\u0565\u0580"
      },
      verb: "\u0578\u0582\u0576\u0565\u0576\u0561\u056C"
    }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0574\u0578\u0582\u057F\u0584",
    email: "\u0567\u056C. \u0570\u0561\u057D\u0581\u0565",
    url: "URL",
    emoji: "\u0567\u0574\u0578\u057B\u056B",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E \u0587 \u056A\u0561\u0574",
    date: "ISO \u0561\u0574\u057D\u0561\u0569\u056B\u057E",
    time: "ISO \u056A\u0561\u0574",
    duration: "ISO \u057F\u0587\u0578\u0572\u0578\u0582\u0569\u0575\u0578\u0582\u0576",
    ipv4: "IPv4 \u0570\u0561\u057D\u0581\u0565",
    ipv6: "IPv6 \u0570\u0561\u057D\u0581\u0565",
    cidrv4: "IPv4 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
    cidrv6: "IPv6 \u0574\u056B\u057B\u0561\u056F\u0561\u0575\u0584",
    base64: "base64 \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
    base64url: "base64url \u0571\u0587\u0561\u0579\u0561\u0583\u0578\u057E \u057F\u0578\u0572",
    json_string: "JSON \u057F\u0578\u0572",
    e164: "E.164 \u0570\u0561\u0574\u0561\u0580",
    jwt: "JWT",
    template_literal: "\u0574\u0578\u0582\u057F\u0584"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0569\u056B\u057E",
    array: "\u0566\u0561\u0576\u0563\u057E\u0561\u056E"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 instanceof ${issue2.expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
        }
        return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${expected}, \u057D\u057F\u0561\u0581\u057E\u0565\u056C \u0567 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 ${stringifyPrimitive(issue2.values[1])}`;
        return `\u054D\u056D\u0561\u056C \u057F\u0561\u0580\u0562\u0565\u0580\u0561\u056F\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567\u0580 \u0570\u0565\u057F\u0587\u0575\u0561\u056C\u0576\u0565\u0580\u056B\u0581 \u0574\u0565\u056F\u0568\u055D ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const maxValue = Number(issue2.maximum);
          const unit = getArmenianPlural(maxValue, sizing.unit.one, sizing.unit.many);
          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.maximum.toString()} ${unit}`;
        }
        return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0574\u0565\u056E \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin ?? "\u0561\u0580\u056A\u0565\u0584")} \u056C\u056B\u0576\u056B ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const minValue = Number(issue2.minimum);
          const unit = getArmenianPlural(minValue, sizing.unit.one, sizing.unit.many);
          return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056F\u0578\u0582\u0576\u0565\u0576\u0561 ${adj}${issue2.minimum.toString()} ${unit}`;
        }
        return `\u0549\u0561\u0583\u0561\u0566\u0561\u0576\u0581 \u0583\u0578\u0584\u0580 \u0561\u0580\u056A\u0565\u0584\u2024 \u057D\u057A\u0561\u057D\u057E\u0578\u0582\u0574 \u0567, \u0578\u0580 ${withDefiniteArticle(issue2.origin)} \u056C\u056B\u0576\u056B ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057D\u056F\u057D\u057E\u056B "${_issue.prefix}"-\u0578\u057E`;
        if (_issue.format === "ends_with")
          return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0561\u057E\u0561\u0580\u057F\u057E\u056B "${_issue.suffix}"-\u0578\u057E`;
        if (_issue.format === "includes")
          return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u057A\u0561\u0580\u0578\u0582\u0576\u0561\u056F\u056B "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u054D\u056D\u0561\u056C \u057F\u0578\u0572\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0570\u0561\u0574\u0561\u057A\u0561\u057F\u0561\u057D\u056D\u0561\u0576\u056B ${_issue.pattern} \u0571\u0587\u0561\u0579\u0561\u0583\u056B\u0576`;
        return `\u054D\u056D\u0561\u056C ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u054D\u056D\u0561\u056C \u0569\u056B\u057E\u2024 \u057A\u0565\u057F\u0584 \u0567 \u0562\u0561\u0566\u0574\u0561\u057A\u0561\u057F\u056B\u056F \u056C\u056B\u0576\u056B ${issue2.divisor}-\u056B`;
      case "unrecognized_keys":
        return `\u0549\u0573\u0561\u0576\u0561\u0579\u057E\u0561\u056E \u0562\u0561\u0576\u0561\u056C\u056B${issue2.keys.length > 1 ? "\u0576\u0565\u0580" : ""}. ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u054D\u056D\u0561\u056C \u0562\u0561\u0576\u0561\u056C\u056B ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
      case "invalid_union":
        return "\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574";
      case "invalid_element":
        return `\u054D\u056D\u0561\u056C \u0561\u0580\u056A\u0565\u0584 ${withDefiniteArticle(issue2.origin)}-\u0578\u0582\u0574`;
      default:
        return `\u054D\u056D\u0561\u056C \u0574\u0578\u0582\u057F\u0584\u0561\u0563\u0580\u0578\u0582\u0574`;
    }
  };
};
function hy_default() {
  return {
    localeError: error18()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/id.js
var error19 = () => {
  const Sizable = {
    string: { unit: "karakter", verb: "memiliki" },
    file: { unit: "byte", verb: "memiliki" },
    array: { unit: "item", verb: "memiliki" },
    set: { unit: "item", verb: "memiliki" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "alamat email",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "tanggal dan waktu format ISO",
    date: "tanggal format ISO",
    time: "jam format ISO",
    duration: "durasi format ISO",
    ipv4: "alamat IPv4",
    ipv6: "alamat IPv6",
    cidrv4: "rentang alamat IPv4",
    cidrv6: "rentang alamat IPv6",
    base64: "string dengan enkode base64",
    base64url: "string dengan enkode base64url",
    json_string: "string JSON",
    e164: "angka E.164",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Input tidak valid: diharapkan instanceof ${issue2.expected}, diterima ${received}`;
        }
        return `Input tidak valid: diharapkan ${expected}, diterima ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Input tidak valid: diharapkan ${stringifyPrimitive(issue2.values[0])}`;
        return `Pilihan tidak valid: diharapkan salah satu dari ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Terlalu besar: diharapkan ${issue2.origin ?? "value"} memiliki ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemen"}`;
        return `Terlalu besar: diharapkan ${issue2.origin ?? "value"} menjadi ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Terlalu kecil: diharapkan ${issue2.origin} memiliki ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Terlalu kecil: diharapkan ${issue2.origin} menjadi ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `String tidak valid: harus dimulai dengan "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `String tidak valid: harus berakhir dengan "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `String tidak valid: harus menyertakan "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `String tidak valid: harus sesuai pola ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} tidak valid`;
      }
      case "not_multiple_of":
        return `Angka tidak valid: harus kelipatan dari ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Kunci tidak dikenali ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Kunci tidak valid di ${issue2.origin}`;
      case "invalid_union":
        return "Input tidak valid";
      case "invalid_element":
        return `Nilai tidak valid di ${issue2.origin}`;
      default:
        return `Input tidak valid`;
    }
  };
};
function id_default() {
  return {
    localeError: error19()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/is.js
var error20 = () => {
  const Sizable = {
    string: { unit: "stafi", verb: "a\xF0 hafa" },
    file: { unit: "b\xE6ti", verb: "a\xF0 hafa" },
    array: { unit: "hluti", verb: "a\xF0 hafa" },
    set: { unit: "hluti", verb: "a\xF0 hafa" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "gildi",
    email: "netfang",
    url: "vefsl\xF3\xF0",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO dagsetning og t\xEDmi",
    date: "ISO dagsetning",
    time: "ISO t\xEDmi",
    duration: "ISO t\xEDmalengd",
    ipv4: "IPv4 address",
    ipv6: "IPv6 address",
    cidrv4: "IPv4 range",
    cidrv6: "IPv6 range",
    base64: "base64-encoded strengur",
    base64url: "base64url-encoded strengur",
    json_string: "JSON strengur",
    e164: "E.164 t\xF6lugildi",
    jwt: "JWT",
    template_literal: "gildi"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "n\xFAmer",
    array: "fylki"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera instanceof ${issue2.expected}`;
        }
        return `Rangt gildi: \xDE\xFA sl\xF3st inn ${received} \xFEar sem \xE1 a\xF0 vera ${expected}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Rangt gildi: gert r\xE1\xF0 fyrir ${stringifyPrimitive(issue2.values[0])}`;
        return `\xD3gilt val: m\xE1 vera eitt af eftirfarandi ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin ?? "gildi"} hafi ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "hluti"}`;
        return `Of st\xF3rt: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin ?? "gildi"} s\xE9 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} hafi ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Of l\xEDti\xF0: gert er r\xE1\xF0 fyrir a\xF0 ${issue2.origin} s\xE9 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\xD3gildur strengur: ver\xF0ur a\xF0 byrja \xE1 "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `\xD3gildur strengur: ver\xF0ur a\xF0 enda \xE1 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\xD3gildur strengur: ver\xF0ur a\xF0 innihalda "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\xD3gildur strengur: ver\xF0ur a\xF0 fylgja mynstri ${_issue.pattern}`;
        return `Rangt ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `R\xF6ng tala: ver\xF0ur a\xF0 vera margfeldi af ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\xD3\xFEekkt ${issue2.keys.length > 1 ? "ir lyklar" : "ur lykill"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Rangur lykill \xED ${issue2.origin}`;
      case "invalid_union":
        return "Rangt gildi";
      case "invalid_element":
        return `Rangt gildi \xED ${issue2.origin}`;
      default:
        return `Rangt gildi`;
    }
  };
};
function is_default() {
  return {
    localeError: error20()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/it.js
var error21 = () => {
  const Sizable = {
    string: { unit: "caratteri", verb: "avere" },
    file: { unit: "byte", verb: "avere" },
    array: { unit: "elementi", verb: "avere" },
    set: { unit: "elementi", verb: "avere" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "indirizzo email",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "data e ora ISO",
    date: "data ISO",
    time: "ora ISO",
    duration: "durata ISO",
    ipv4: "indirizzo IPv4",
    ipv6: "indirizzo IPv6",
    cidrv4: "intervallo IPv4",
    cidrv6: "intervallo IPv6",
    base64: "stringa codificata in base64",
    base64url: "URL codificata in base64",
    json_string: "stringa JSON",
    e164: "numero E.164",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "numero",
    array: "vettore"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Input non valido: atteso instanceof ${issue2.expected}, ricevuto ${received}`;
        }
        return `Input non valido: atteso ${expected}, ricevuto ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Input non valido: atteso ${stringifyPrimitive(issue2.values[0])}`;
        return `Opzione non valida: atteso uno tra ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Troppo grande: ${issue2.origin ?? "valore"} deve avere ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementi"}`;
        return `Troppo grande: ${issue2.origin ?? "valore"} deve essere ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Troppo piccolo: ${issue2.origin} deve avere ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Troppo piccolo: ${issue2.origin} deve essere ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Stringa non valida: deve iniziare con "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Stringa non valida: deve terminare con "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Stringa non valida: deve includere "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Stringa non valida: deve corrispondere al pattern ${_issue.pattern}`;
        return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Numero non valido: deve essere un multiplo di ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Chiav${issue2.keys.length > 1 ? "i" : "e"} non riconosciut${issue2.keys.length > 1 ? "e" : "a"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Chiave non valida in ${issue2.origin}`;
      case "invalid_union":
        return "Input non valido";
      case "invalid_element":
        return `Valore non valido in ${issue2.origin}`;
      default:
        return `Input non valido`;
    }
  };
};
function it_default() {
  return {
    localeError: error21()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ja.js
var error22 = () => {
  const Sizable = {
    string: { unit: "\u6587\u5B57", verb: "\u3067\u3042\u308B" },
    file: { unit: "\u30D0\u30A4\u30C8", verb: "\u3067\u3042\u308B" },
    array: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" },
    set: { unit: "\u8981\u7D20", verb: "\u3067\u3042\u308B" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u5165\u529B\u5024",
    email: "\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9",
    url: "URL",
    emoji: "\u7D75\u6587\u5B57",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO\u65E5\u6642",
    date: "ISO\u65E5\u4ED8",
    time: "ISO\u6642\u523B",
    duration: "ISO\u671F\u9593",
    ipv4: "IPv4\u30A2\u30C9\u30EC\u30B9",
    ipv6: "IPv6\u30A2\u30C9\u30EC\u30B9",
    cidrv4: "IPv4\u7BC4\u56F2",
    cidrv6: "IPv6\u7BC4\u56F2",
    base64: "base64\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
    base64url: "base64url\u30A8\u30F3\u30B3\u30FC\u30C9\u6587\u5B57\u5217",
    json_string: "JSON\u6587\u5B57\u5217",
    e164: "E.164\u756A\u53F7",
    jwt: "JWT",
    template_literal: "\u5165\u529B\u5024"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u6570\u5024",
    array: "\u914D\u5217"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u7121\u52B9\u306A\u5165\u529B: instanceof ${issue2.expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
        }
        return `\u7121\u52B9\u306A\u5165\u529B: ${expected}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F\u304C\u3001${received}\u304C\u5165\u529B\u3055\u308C\u307E\u3057\u305F`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u7121\u52B9\u306A\u5165\u529B: ${stringifyPrimitive(issue2.values[0])}\u304C\u671F\u5F85\u3055\u308C\u307E\u3057\u305F`;
        return `\u7121\u52B9\u306A\u9078\u629E: ${joinValues(issue2.values, "\u3001")}\u306E\u3044\u305A\u308C\u304B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
      case "too_big": {
        const adj = issue2.inclusive ? "\u4EE5\u4E0B\u3067\u3042\u308B" : "\u3088\u308A\u5C0F\u3055\u3044";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue2.origin ?? "\u5024"}\u306F${issue2.maximum.toString()}${sizing.unit ?? "\u8981\u7D20"}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        return `\u5927\u304D\u3059\u304E\u308B\u5024: ${issue2.origin ?? "\u5024"}\u306F${issue2.maximum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? "\u4EE5\u4E0A\u3067\u3042\u308B" : "\u3088\u308A\u5927\u304D\u3044";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${sizing.unit}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        return `\u5C0F\u3055\u3059\u304E\u308B\u5024: ${issue2.origin}\u306F${issue2.minimum.toString()}${adj}\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.prefix}"\u3067\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        if (_issue.format === "ends_with")
          return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.suffix}"\u3067\u7D42\u308F\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        if (_issue.format === "includes")
          return `\u7121\u52B9\u306A\u6587\u5B57\u5217: "${_issue.includes}"\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        if (_issue.format === "regex")
          return `\u7121\u52B9\u306A\u6587\u5B57\u5217: \u30D1\u30BF\u30FC\u30F3${_issue.pattern}\u306B\u4E00\u81F4\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
        return `\u7121\u52B9\u306A${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u7121\u52B9\u306A\u6570\u5024: ${issue2.divisor}\u306E\u500D\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059`;
      case "unrecognized_keys":
        return `\u8A8D\u8B58\u3055\u308C\u3066\u3044\u306A\u3044\u30AD\u30FC${issue2.keys.length > 1 ? "\u7FA4" : ""}: ${joinValues(issue2.keys, "\u3001")}`;
      case "invalid_key":
        return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u30AD\u30FC`;
      case "invalid_union":
        return "\u7121\u52B9\u306A\u5165\u529B";
      case "invalid_element":
        return `${issue2.origin}\u5185\u306E\u7121\u52B9\u306A\u5024`;
      default:
        return `\u7121\u52B9\u306A\u5165\u529B`;
    }
  };
};
function ja_default() {
  return {
    localeError: error22()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ka.js
var error23 = () => {
  const Sizable = {
    string: { unit: "\u10E1\u10D8\u10DB\u10D1\u10DD\u10DA\u10DD", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
    file: { unit: "\u10D1\u10D0\u10D8\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
    array: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" },
    set: { unit: "\u10D4\u10DA\u10D4\u10DB\u10D4\u10DC\u10E2\u10D8", verb: "\u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0",
    email: "\u10D4\u10DA-\u10E4\u10DD\u10E1\u10E2\u10D8\u10E1 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
    url: "URL",
    emoji: "\u10D4\u10DB\u10DD\u10EF\u10D8",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8-\u10D3\u10E0\u10DD",
    date: "\u10D7\u10D0\u10E0\u10D8\u10E6\u10D8",
    time: "\u10D3\u10E0\u10DD",
    duration: "\u10EE\u10D0\u10DC\u10D2\u10E0\u10EB\u10DA\u10D8\u10D5\u10DD\u10D1\u10D0",
    ipv4: "IPv4 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
    ipv6: "IPv6 \u10DB\u10D8\u10E1\u10D0\u10DB\u10D0\u10E0\u10D7\u10D8",
    cidrv4: "IPv4 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
    cidrv6: "IPv6 \u10D3\u10D8\u10D0\u10DE\u10D0\u10D6\u10DD\u10DC\u10D8",
    base64: "base64-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
    base64url: "base64url-\u10D9\u10DD\u10D3\u10D8\u10E0\u10D4\u10D1\u10E3\u10DA\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
    json_string: "JSON \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
    e164: "E.164 \u10DC\u10DD\u10DB\u10D4\u10E0\u10D8",
    jwt: "JWT",
    template_literal: "\u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u10E0\u10D8\u10EA\u10EE\u10D5\u10D8",
    string: "\u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8",
    boolean: "\u10D1\u10E3\u10DA\u10D4\u10D0\u10DC\u10D8",
    function: "\u10E4\u10E3\u10DC\u10E5\u10EA\u10D8\u10D0",
    array: "\u10DB\u10D0\u10E1\u10D8\u10D5\u10D8"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 instanceof ${issue2.expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
        }
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${expected}, \u10DB\u10D8\u10E6\u10D4\u10D1\u10E3\u10DA\u10D8 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${stringifyPrimitive(issue2.values[0])}`;
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D5\u10D0\u10E0\u10D8\u10D0\u10DC\u10E2\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8\u10D0 \u10D4\u10E0\u10D7-\u10D4\u10E0\u10D7\u10D8 ${joinValues(issue2.values, "|")}-\u10D3\u10D0\u10DC`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit}`;
        return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10D3\u10D8\u10D3\u10D8: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin ?? "\u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0"} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u10D6\u10D4\u10D3\u10DB\u10D4\u10E2\u10D0\u10D3 \u10DE\u10D0\u10E2\u10D0\u10E0\u10D0: \u10DB\u10DD\u10E1\u10D0\u10DA\u10DD\u10D3\u10DC\u10D4\u10DA\u10D8 ${issue2.origin} \u10D8\u10E7\u10DD\u10E1 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10EC\u10E7\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.prefix}"-\u10D8\u10D7`;
        }
        if (_issue.format === "ends_with")
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10DB\u10D7\u10D0\u10D5\u10E0\u10D3\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 "${_issue.suffix}"-\u10D8\u10D7`;
        if (_issue.format === "includes")
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D8\u10EA\u10D0\u10D5\u10D3\u10D4\u10E1 "${_issue.includes}"-\u10E1`;
        if (_issue.format === "regex")
          return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E1\u10E2\u10E0\u10D8\u10DC\u10D2\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10E8\u10D4\u10D4\u10E1\u10D0\u10D1\u10D0\u10DB\u10D4\u10D1\u10DD\u10D3\u10D4\u10E1 \u10E8\u10D0\u10D1\u10DA\u10DD\u10DC\u10E1 ${_issue.pattern}`;
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E0\u10D8\u10EA\u10EE\u10D5\u10D8: \u10E3\u10DC\u10D3\u10D0 \u10D8\u10E7\u10DD\u10E1 ${issue2.divisor}-\u10D8\u10E1 \u10EF\u10D4\u10E0\u10D0\u10D3\u10D8`;
      case "unrecognized_keys":
        return `\u10E3\u10EA\u10DC\u10DD\u10D1\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1${issue2.keys.length > 1 ? "\u10D4\u10D1\u10D8" : "\u10D8"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10D2\u10D0\u10E1\u10D0\u10E6\u10D4\u10D1\u10D8 ${issue2.origin}-\u10E8\u10D8`;
      case "invalid_union":
        return "\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0";
      case "invalid_element":
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10DB\u10DC\u10D8\u10E8\u10D5\u10DC\u10D4\u10DA\u10DD\u10D1\u10D0 ${issue2.origin}-\u10E8\u10D8`;
      default:
        return `\u10D0\u10E0\u10D0\u10E1\u10EC\u10DD\u10E0\u10D8 \u10E8\u10D4\u10E7\u10D5\u10D0\u10DC\u10D0`;
    }
  };
};
function ka_default() {
  return {
    localeError: error23()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/km.js
var error24 = () => {
  const Sizable = {
    string: { unit: "\u178F\u17BD\u17A2\u1780\u17D2\u179F\u179A", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
    file: { unit: "\u1794\u17C3", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
    array: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" },
    set: { unit: "\u1792\u17B6\u178F\u17BB", verb: "\u1782\u17BD\u179A\u1798\u17B6\u1793" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B",
    email: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793\u17A2\u17CA\u17B8\u1798\u17C2\u179B",
    url: "URL",
    emoji: "\u179F\u1789\u17D2\u1789\u17B6\u17A2\u17B6\u179A\u1798\u17D2\u1798\u178E\u17CD",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 \u1793\u17B7\u1784\u1798\u17C9\u17C4\u1784 ISO",
    date: "\u1780\u17B6\u179B\u1794\u179A\u17B7\u1785\u17D2\u1786\u17C1\u1791 ISO",
    time: "\u1798\u17C9\u17C4\u1784 ISO",
    duration: "\u179A\u1799\u17C8\u1796\u17C1\u179B ISO",
    ipv4: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
    ipv6: "\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
    cidrv4: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv4",
    cidrv6: "\u178A\u17C2\u1793\u17A2\u17B6\u179F\u1799\u178A\u17D2\u178B\u17B6\u1793 IPv6",
    base64: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64",
    base64url: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u17A2\u17CA\u17B7\u1780\u17BC\u178A base64url",
    json_string: "\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A JSON",
    e164: "\u179B\u17C1\u1781 E.164",
    jwt: "JWT",
    template_literal: "\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u179B\u17C1\u1781",
    array: "\u17A2\u17B6\u179A\u17C1 (Array)",
    null: "\u1782\u17D2\u1798\u17B6\u1793\u178F\u1798\u17D2\u179B\u17C3 (null)"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A instanceof ${issue2.expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
        }
        return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${expected} \u1794\u17C9\u17BB\u1793\u17D2\u178F\u17C2\u1791\u1791\u17BD\u179B\u1794\u17B6\u1793 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1794\u1789\u17D2\u1785\u17BC\u179B\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${stringifyPrimitive(issue2.values[0])}`;
        return `\u1787\u1798\u17D2\u179A\u17BE\u179F\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1787\u17B6\u1798\u17BD\u1799\u1780\u17D2\u1793\u17BB\u1784\u1785\u17C6\u178E\u17C4\u1798 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u1792\u17B6\u178F\u17BB"}`;
        return `\u1792\u17C6\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin ?? "\u178F\u1798\u17D2\u179B\u17C3"} ${adj} ${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u178F\u17BC\u1785\u1796\u17C1\u1780\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1780\u17B6\u179A ${issue2.origin} ${adj} ${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1785\u17B6\u1794\u17CB\u1795\u17D2\u178F\u17BE\u1798\u178A\u17C4\u1799 "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1794\u1789\u17D2\u1785\u1794\u17CB\u178A\u17C4\u1799 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u1798\u17B6\u1793 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u1781\u17D2\u179F\u17C2\u17A2\u1780\u17D2\u179F\u179A\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1795\u17D2\u1782\u17BC\u1795\u17D2\u1782\u1784\u1793\u17B9\u1784\u1791\u1798\u17D2\u179A\u1784\u17CB\u178A\u17C2\u179B\u1794\u17B6\u1793\u1780\u17C6\u178E\u178F\u17CB ${_issue.pattern}`;
        return `\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u179B\u17C1\u1781\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u17D6 \u178F\u17D2\u179A\u17BC\u179C\u178F\u17C2\u1787\u17B6\u1796\u17A0\u17BB\u1782\u17BB\u178E\u1793\u17C3 ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u179A\u1780\u1783\u17BE\u1789\u179F\u17C4\u1798\u17B7\u1793\u179F\u17D2\u1782\u17B6\u179B\u17CB\u17D6 ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u179F\u17C4\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
      case "invalid_union":
        return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
      case "invalid_element":
        return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C\u1793\u17C5\u1780\u17D2\u1793\u17BB\u1784 ${issue2.origin}`;
      default:
        return `\u1791\u17B7\u1793\u17D2\u1793\u1793\u17D0\u1799\u1798\u17B7\u1793\u178F\u17D2\u179A\u17B9\u1798\u178F\u17D2\u179A\u17BC\u179C`;
    }
  };
};
function km_default() {
  return {
    localeError: error24()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/kh.js
function kh_default() {
  return km_default();
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ko.js
var error25 = () => {
  const Sizable = {
    string: { unit: "\uBB38\uC790", verb: "to have" },
    file: { unit: "\uBC14\uC774\uD2B8", verb: "to have" },
    array: { unit: "\uAC1C", verb: "to have" },
    set: { unit: "\uAC1C", verb: "to have" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\uC785\uB825",
    email: "\uC774\uBA54\uC77C \uC8FC\uC18C",
    url: "URL",
    emoji: "\uC774\uBAA8\uC9C0",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \uB0A0\uC9DC\uC2DC\uAC04",
    date: "ISO \uB0A0\uC9DC",
    time: "ISO \uC2DC\uAC04",
    duration: "ISO \uAE30\uAC04",
    ipv4: "IPv4 \uC8FC\uC18C",
    ipv6: "IPv6 \uC8FC\uC18C",
    cidrv4: "IPv4 \uBC94\uC704",
    cidrv6: "IPv6 \uBC94\uC704",
    base64: "base64 \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
    base64url: "base64url \uC778\uCF54\uB529 \uBB38\uC790\uC5F4",
    json_string: "JSON \uBB38\uC790\uC5F4",
    e164: "E.164 \uBC88\uD638",
    jwt: "JWT",
    template_literal: "\uC785\uB825"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 instanceof ${issue2.expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
        }
        return `\uC798\uBABB\uB41C \uC785\uB825: \uC608\uC0C1 \uD0C0\uC785\uC740 ${expected}, \uBC1B\uC740 \uD0C0\uC785\uC740 ${received}\uC785\uB2C8\uB2E4`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\uC798\uBABB\uB41C \uC785\uB825: \uAC12\uC740 ${stringifyPrimitive(issue2.values[0])} \uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4`;
        return `\uC798\uBABB\uB41C \uC635\uC158: ${joinValues(issue2.values, "\uB610\uB294 ")} \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
      case "too_big": {
        const adj = issue2.inclusive ? "\uC774\uD558" : "\uBBF8\uB9CC";
        const suffix = adj === "\uBBF8\uB9CC" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
        const sizing = getSizing(issue2.origin);
        const unit = sizing?.unit ?? "\uC694\uC18C";
        if (sizing)
          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()}${unit} ${adj}${suffix}`;
        return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uD07D\uB2C8\uB2E4: ${issue2.maximum.toString()} ${adj}${suffix}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? "\uC774\uC0C1" : "\uCD08\uACFC";
        const suffix = adj === "\uC774\uC0C1" ? "\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4" : "\uC5EC\uC57C \uD569\uB2C8\uB2E4";
        const sizing = getSizing(issue2.origin);
        const unit = sizing?.unit ?? "\uC694\uC18C";
        if (sizing) {
          return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()}${unit} ${adj}${suffix}`;
        }
        return `${issue2.origin ?? "\uAC12"}\uC774 \uB108\uBB34 \uC791\uC2B5\uB2C8\uB2E4: ${issue2.minimum.toString()} ${adj}${suffix}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.prefix}"(\uC73C)\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4`;
        }
        if (_issue.format === "ends_with")
          return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.suffix}"(\uC73C)\uB85C \uB05D\uB098\uC57C \uD569\uB2C8\uB2E4`;
        if (_issue.format === "includes")
          return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: "${_issue.includes}"\uC744(\uB97C) \uD3EC\uD568\uD574\uC57C \uD569\uB2C8\uB2E4`;
        if (_issue.format === "regex")
          return `\uC798\uBABB\uB41C \uBB38\uC790\uC5F4: \uC815\uADDC\uC2DD ${_issue.pattern} \uD328\uD134\uACFC \uC77C\uCE58\uD574\uC57C \uD569\uB2C8\uB2E4`;
        return `\uC798\uBABB\uB41C ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\uC798\uBABB\uB41C \uC22B\uC790: ${issue2.divisor}\uC758 \uBC30\uC218\uC5EC\uC57C \uD569\uB2C8\uB2E4`;
      case "unrecognized_keys":
        return `\uC778\uC2DD\uD560 \uC218 \uC5C6\uB294 \uD0A4: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\uC798\uBABB\uB41C \uD0A4: ${issue2.origin}`;
      case "invalid_union":
        return `\uC798\uBABB\uB41C \uC785\uB825`;
      case "invalid_element":
        return `\uC798\uBABB\uB41C \uAC12: ${issue2.origin}`;
      default:
        return `\uC798\uBABB\uB41C \uC785\uB825`;
    }
  };
};
function ko_default() {
  return {
    localeError: error25()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/lt.js
var capitalizeFirstCharacter = (text) => {
  return text.charAt(0).toUpperCase() + text.slice(1);
};
function getUnitTypeFromNumber(number4) {
  const abs = Math.abs(number4);
  const last = abs % 10;
  const last2 = abs % 100;
  if (last2 >= 11 && last2 <= 19 || last === 0)
    return "many";
  if (last === 1)
    return "one";
  return "few";
}
var error26 = () => {
  const Sizable = {
    string: {
      unit: {
        one: "simbolis",
        few: "simboliai",
        many: "simboli\u0173"
      },
      verb: {
        smaller: {
          inclusive: "turi b\u016Bti ne ilgesn\u0117 kaip",
          notInclusive: "turi b\u016Bti trumpesn\u0117 kaip"
        },
        bigger: {
          inclusive: "turi b\u016Bti ne trumpesn\u0117 kaip",
          notInclusive: "turi b\u016Bti ilgesn\u0117 kaip"
        }
      }
    },
    file: {
      unit: {
        one: "baitas",
        few: "baitai",
        many: "bait\u0173"
      },
      verb: {
        smaller: {
          inclusive: "turi b\u016Bti ne didesnis kaip",
          notInclusive: "turi b\u016Bti ma\u017Eesnis kaip"
        },
        bigger: {
          inclusive: "turi b\u016Bti ne ma\u017Eesnis kaip",
          notInclusive: "turi b\u016Bti didesnis kaip"
        }
      }
    },
    array: {
      unit: {
        one: "element\u0105",
        few: "elementus",
        many: "element\u0173"
      },
      verb: {
        smaller: {
          inclusive: "turi tur\u0117ti ne daugiau kaip",
          notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
        },
        bigger: {
          inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
          notInclusive: "turi tur\u0117ti daugiau kaip"
        }
      }
    },
    set: {
      unit: {
        one: "element\u0105",
        few: "elementus",
        many: "element\u0173"
      },
      verb: {
        smaller: {
          inclusive: "turi tur\u0117ti ne daugiau kaip",
          notInclusive: "turi tur\u0117ti ma\u017Eiau kaip"
        },
        bigger: {
          inclusive: "turi tur\u0117ti ne ma\u017Eiau kaip",
          notInclusive: "turi tur\u0117ti daugiau kaip"
        }
      }
    }
  };
  function getSizing(origin, unitType, inclusive, targetShouldBe) {
    const result = Sizable[origin] ?? null;
    if (result === null)
      return result;
    return {
      unit: result.unit[unitType],
      verb: result.verb[targetShouldBe][inclusive ? "inclusive" : "notInclusive"]
    };
  }
  const FormatDictionary = {
    regex: "\u012Fvestis",
    email: "el. pa\u0161to adresas",
    url: "URL",
    emoji: "jaustukas",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO data ir laikas",
    date: "ISO data",
    time: "ISO laikas",
    duration: "ISO trukm\u0117",
    ipv4: "IPv4 adresas",
    ipv6: "IPv6 adresas",
    cidrv4: "IPv4 tinklo prefiksas (CIDR)",
    cidrv6: "IPv6 tinklo prefiksas (CIDR)",
    base64: "base64 u\u017Ekoduota eilut\u0117",
    base64url: "base64url u\u017Ekoduota eilut\u0117",
    json_string: "JSON eilut\u0117",
    e164: "E.164 numeris",
    jwt: "JWT",
    template_literal: "\u012Fvestis"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "skai\u010Dius",
    bigint: "sveikasis skai\u010Dius",
    string: "eilut\u0117",
    boolean: "login\u0117 reik\u0161m\u0117",
    undefined: "neapibr\u0117\u017Eta reik\u0161m\u0117",
    function: "funkcija",
    symbol: "simbolis",
    array: "masyvas",
    object: "objektas",
    null: "nulin\u0117 reik\u0161m\u0117"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Gautas tipas ${received}, o tik\u0117tasi - instanceof ${issue2.expected}`;
        }
        return `Gautas tipas ${received}, o tik\u0117tasi - ${expected}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Privalo b\u016Bti ${stringifyPrimitive(issue2.values[0])}`;
        return `Privalo b\u016Bti vienas i\u0161 ${joinValues(issue2.values, "|")} pasirinkim\u0173`;
      case "too_big": {
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.maximum)), issue2.inclusive ?? false, "smaller");
        if (sizing?.verb)
          return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.maximum.toString()} ${sizing.unit ?? "element\u0173"}`;
        const adj = issue2.inclusive ? "ne didesnis kaip" : "ma\u017Eesnis kaip";
        return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.maximum.toString()} ${sizing?.unit}`;
      }
      case "too_small": {
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        const sizing = getSizing(issue2.origin, getUnitTypeFromNumber(Number(issue2.minimum)), issue2.inclusive ?? false, "bigger");
        if (sizing?.verb)
          return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} ${sizing.verb} ${issue2.minimum.toString()} ${sizing.unit ?? "element\u0173"}`;
        const adj = issue2.inclusive ? "ne ma\u017Eesnis kaip" : "didesnis kaip";
        return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi b\u016Bti ${adj} ${issue2.minimum.toString()} ${sizing?.unit}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Eilut\u0117 privalo prasid\u0117ti "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Eilut\u0117 privalo pasibaigti "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Eilut\u0117 privalo \u012Ftraukti "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Eilut\u0117 privalo atitikti ${_issue.pattern}`;
        return `Neteisingas ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Skai\u010Dius privalo b\u016Bti ${issue2.divisor} kartotinis.`;
      case "unrecognized_keys":
        return `Neatpa\u017Eint${issue2.keys.length > 1 ? "i" : "as"} rakt${issue2.keys.length > 1 ? "ai" : "as"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return "Rastas klaidingas raktas";
      case "invalid_union":
        return "Klaidinga \u012Fvestis";
      case "invalid_element": {
        const origin = TypeDictionary[issue2.origin] ?? issue2.origin;
        return `${capitalizeFirstCharacter(origin ?? issue2.origin ?? "reik\u0161m\u0117")} turi klaiding\u0105 \u012Fvest\u012F`;
      }
      default:
        return "Klaidinga \u012Fvestis";
    }
  };
};
function lt_default() {
  return {
    localeError: error26()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/mk.js
var error27 = () => {
  const Sizable = {
    string: { unit: "\u0437\u043D\u0430\u0446\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
    file: { unit: "\u0431\u0430\u0458\u0442\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
    array: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" },
    set: { unit: "\u0441\u0442\u0430\u0432\u043A\u0438", verb: "\u0434\u0430 \u0438\u043C\u0430\u0430\u0442" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0432\u043D\u0435\u0441",
    email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u043D\u0430 \u0435-\u043F\u043E\u0448\u0442\u0430",
    url: "URL",
    emoji: "\u0435\u043C\u043E\u045F\u0438",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0434\u0430\u0442\u0443\u043C \u0438 \u0432\u0440\u0435\u043C\u0435",
    date: "ISO \u0434\u0430\u0442\u0443\u043C",
    time: "ISO \u0432\u0440\u0435\u043C\u0435",
    duration: "ISO \u0432\u0440\u0435\u043C\u0435\u0442\u0440\u0430\u0435\u045A\u0435",
    ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441\u0430",
    ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441\u0430",
    cidrv4: "IPv4 \u043E\u043F\u0441\u0435\u0433",
    cidrv6: "IPv6 \u043E\u043F\u0441\u0435\u0433",
    base64: "base64-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
    base64url: "base64url-\u0435\u043D\u043A\u043E\u0434\u0438\u0440\u0430\u043D\u0430 \u043D\u0438\u0437\u0430",
    json_string: "JSON \u043D\u0438\u0437\u0430",
    e164: "E.164 \u0431\u0440\u043E\u0458",
    jwt: "JWT",
    template_literal: "\u0432\u043D\u0435\u0441"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0431\u0440\u043E\u0458",
    array: "\u043D\u0438\u0437\u0430"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 instanceof ${issue2.expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
        }
        return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${expected}, \u043F\u0440\u0438\u043C\u0435\u043D\u043E ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Invalid input: expected ${stringifyPrimitive(issue2.values[0])}`;
        return `\u0413\u0440\u0435\u0448\u0430\u043D\u0430 \u043E\u043F\u0446\u0438\u0458\u0430: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 \u0435\u0434\u043D\u0430 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0438"}`;
        return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u0433\u043E\u043B\u0435\u043C: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin ?? "\u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442\u0430"} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0438\u043C\u0430 ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u041F\u0440\u0435\u043C\u043D\u043E\u0433\u0443 \u043C\u0430\u043B: \u0441\u0435 \u043E\u0447\u0435\u043A\u0443\u0432\u0430 ${issue2.origin} \u0434\u0430 \u0431\u0438\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u043F\u043E\u0447\u043D\u0443\u0432\u0430 \u0441\u043E "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0437\u0430\u0432\u0440\u0448\u0443\u0432\u0430 \u0441\u043E "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0432\u043A\u043B\u0443\u0447\u0443\u0432\u0430 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u041D\u0435\u0432\u0430\u0436\u0435\u0447\u043A\u0430 \u043D\u0438\u0437\u0430: \u043C\u043E\u0440\u0430 \u0434\u0430 \u043E\u0434\u0433\u043E\u0430\u0440\u0430 \u043D\u0430 \u043F\u0430\u0442\u0435\u0440\u043D\u043E\u0442 ${_issue.pattern}`;
        return `Invalid ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u0413\u0440\u0435\u0448\u0435\u043D \u0431\u0440\u043E\u0458: \u043C\u043E\u0440\u0430 \u0434\u0430 \u0431\u0438\u0434\u0435 \u0434\u0435\u043B\u0438\u0432 \u0441\u043E ${issue2.divisor}`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D\u0438 \u043A\u043B\u0443\u0447\u0435\u0432\u0438" : "\u041D\u0435\u043F\u0440\u0435\u043F\u043E\u0437\u043D\u0430\u0435\u043D \u043A\u043B\u0443\u0447"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u0413\u0440\u0435\u0448\u0435\u043D \u043A\u043B\u0443\u0447 \u0432\u043E ${issue2.origin}`;
      case "invalid_union":
        return "\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441";
      case "invalid_element":
        return `\u0413\u0440\u0435\u0448\u043D\u0430 \u0432\u0440\u0435\u0434\u043D\u043E\u0441\u0442 \u0432\u043E ${issue2.origin}`;
      default:
        return `\u0413\u0440\u0435\u0448\u0435\u043D \u0432\u043D\u0435\u0441`;
    }
  };
};
function mk_default() {
  return {
    localeError: error27()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ms.js
var error28 = () => {
  const Sizable = {
    string: { unit: "aksara", verb: "mempunyai" },
    file: { unit: "bait", verb: "mempunyai" },
    array: { unit: "elemen", verb: "mempunyai" },
    set: { unit: "elemen", verb: "mempunyai" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "alamat e-mel",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "tarikh masa ISO",
    date: "tarikh ISO",
    time: "masa ISO",
    duration: "tempoh ISO",
    ipv4: "alamat IPv4",
    ipv6: "alamat IPv6",
    cidrv4: "julat IPv4",
    cidrv6: "julat IPv6",
    base64: "string dikodkan base64",
    base64url: "string dikodkan base64url",
    json_string: "string JSON",
    e164: "nombor E.164",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "nombor"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Input tidak sah: dijangka instanceof ${issue2.expected}, diterima ${received}`;
        }
        return `Input tidak sah: dijangka ${expected}, diterima ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Input tidak sah: dijangka ${stringifyPrimitive(issue2.values[0])}`;
        return `Pilihan tidak sah: dijangka salah satu daripada ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Terlalu besar: dijangka ${issue2.origin ?? "nilai"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elemen"}`;
        return `Terlalu besar: dijangka ${issue2.origin ?? "nilai"} adalah ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Terlalu kecil: dijangka ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Terlalu kecil: dijangka ${issue2.origin} adalah ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `String tidak sah: mesti bermula dengan "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `String tidak sah: mesti berakhir dengan "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `String tidak sah: mesti mengandungi "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `String tidak sah: mesti sepadan dengan corak ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} tidak sah`;
      }
      case "not_multiple_of":
        return `Nombor tidak sah: perlu gandaan ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Kunci tidak dikenali: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Kunci tidak sah dalam ${issue2.origin}`;
      case "invalid_union":
        return "Input tidak sah";
      case "invalid_element":
        return `Nilai tidak sah dalam ${issue2.origin}`;
      default:
        return `Input tidak sah`;
    }
  };
};
function ms_default() {
  return {
    localeError: error28()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/nl.js
var error29 = () => {
  const Sizable = {
    string: { unit: "tekens", verb: "heeft" },
    file: { unit: "bytes", verb: "heeft" },
    array: { unit: "elementen", verb: "heeft" },
    set: { unit: "elementen", verb: "heeft" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "invoer",
    email: "emailadres",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO datum en tijd",
    date: "ISO datum",
    time: "ISO tijd",
    duration: "ISO duur",
    ipv4: "IPv4-adres",
    ipv6: "IPv6-adres",
    cidrv4: "IPv4-bereik",
    cidrv6: "IPv6-bereik",
    base64: "base64-gecodeerde tekst",
    base64url: "base64 URL-gecodeerde tekst",
    json_string: "JSON string",
    e164: "E.164-nummer",
    jwt: "JWT",
    template_literal: "invoer"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "getal"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ongeldige invoer: verwacht instanceof ${issue2.expected}, ontving ${received}`;
        }
        return `Ongeldige invoer: verwacht ${expected}, ontving ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ongeldige invoer: verwacht ${stringifyPrimitive(issue2.values[0])}`;
        return `Ongeldige optie: verwacht \xE9\xE9n van ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        const longName = issue2.origin === "date" ? "laat" : issue2.origin === "string" ? "lang" : "groot";
        if (sizing)
          return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementen"} ${sizing.verb}`;
        return `Te ${longName}: verwacht dat ${issue2.origin ?? "waarde"} ${adj}${issue2.maximum.toString()} is`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        const shortName = issue2.origin === "date" ? "vroeg" : issue2.origin === "string" ? "kort" : "klein";
        if (sizing) {
          return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
        }
        return `Te ${shortName}: verwacht dat ${issue2.origin} ${adj}${issue2.minimum.toString()} is`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Ongeldige tekst: moet met "${_issue.prefix}" beginnen`;
        }
        if (_issue.format === "ends_with")
          return `Ongeldige tekst: moet op "${_issue.suffix}" eindigen`;
        if (_issue.format === "includes")
          return `Ongeldige tekst: moet "${_issue.includes}" bevatten`;
        if (_issue.format === "regex")
          return `Ongeldige tekst: moet overeenkomen met patroon ${_issue.pattern}`;
        return `Ongeldig: ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ongeldig getal: moet een veelvoud van ${issue2.divisor} zijn`;
      case "unrecognized_keys":
        return `Onbekende key${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Ongeldige key in ${issue2.origin}`;
      case "invalid_union":
        return "Ongeldige invoer";
      case "invalid_element":
        return `Ongeldige waarde in ${issue2.origin}`;
      default:
        return `Ongeldige invoer`;
    }
  };
};
function nl_default() {
  return {
    localeError: error29()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/no.js
var error30 = () => {
  const Sizable = {
    string: { unit: "tegn", verb: "\xE5 ha" },
    file: { unit: "bytes", verb: "\xE5 ha" },
    array: { unit: "elementer", verb: "\xE5 inneholde" },
    set: { unit: "elementer", verb: "\xE5 inneholde" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "input",
    email: "e-postadresse",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO dato- og klokkeslett",
    date: "ISO-dato",
    time: "ISO-klokkeslett",
    duration: "ISO-varighet",
    ipv4: "IPv4-omr\xE5de",
    ipv6: "IPv6-omr\xE5de",
    cidrv4: "IPv4-spekter",
    cidrv6: "IPv6-spekter",
    base64: "base64-enkodet streng",
    base64url: "base64url-enkodet streng",
    json_string: "JSON-streng",
    e164: "E.164-nummer",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "tall",
    array: "liste"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ugyldig input: forventet instanceof ${issue2.expected}, fikk ${received}`;
        }
        return `Ugyldig input: forventet ${expected}, fikk ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ugyldig verdi: forventet ${stringifyPrimitive(issue2.values[0])}`;
        return `Ugyldig valg: forventet en av ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `For stor(t): forventet ${issue2.origin ?? "value"} til \xE5 ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementer"}`;
        return `For stor(t): forventet ${issue2.origin ?? "value"} til \xE5 ha ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `For lite(n): forventet ${issue2.origin} til \xE5 ha ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Ugyldig streng: m\xE5 starte med "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Ugyldig streng: m\xE5 ende med "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Ugyldig streng: m\xE5 inneholde "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Ugyldig streng: m\xE5 matche m\xF8nsteret ${_issue.pattern}`;
        return `Ugyldig ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ugyldig tall: m\xE5 v\xE6re et multiplum av ${issue2.divisor}`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "Ukjente n\xF8kler" : "Ukjent n\xF8kkel"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Ugyldig n\xF8kkel i ${issue2.origin}`;
      case "invalid_union":
        return "Ugyldig input";
      case "invalid_element":
        return `Ugyldig verdi i ${issue2.origin}`;
      default:
        return `Ugyldig input`;
    }
  };
};
function no_default() {
  return {
    localeError: error30()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ota.js
var error31 = () => {
  const Sizable = {
    string: { unit: "harf", verb: "olmal\u0131d\u0131r" },
    file: { unit: "bayt", verb: "olmal\u0131d\u0131r" },
    array: { unit: "unsur", verb: "olmal\u0131d\u0131r" },
    set: { unit: "unsur", verb: "olmal\u0131d\u0131r" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "giren",
    email: "epostag\xE2h",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO heng\xE2m\u0131",
    date: "ISO tarihi",
    time: "ISO zaman\u0131",
    duration: "ISO m\xFCddeti",
    ipv4: "IPv4 ni\u015F\xE2n\u0131",
    ipv6: "IPv6 ni\u015F\xE2n\u0131",
    cidrv4: "IPv4 menzili",
    cidrv6: "IPv6 menzili",
    base64: "base64-\u015Fifreli metin",
    base64url: "base64url-\u015Fifreli metin",
    json_string: "JSON metin",
    e164: "E.164 say\u0131s\u0131",
    jwt: "JWT",
    template_literal: "giren"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "numara",
    array: "saf",
    null: "gayb"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `F\xE2sit giren: umulan instanceof ${issue2.expected}, al\u0131nan ${received}`;
        }
        return `F\xE2sit giren: umulan ${expected}, al\u0131nan ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `F\xE2sit giren: umulan ${stringifyPrimitive(issue2.values[0])}`;
        return `F\xE2sit tercih: m\xFBteberler ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Fazla b\xFCy\xFCk: ${issue2.origin ?? "value"}, ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elements"} sahip olmal\u0131yd\u0131.`;
        return `Fazla b\xFCy\xFCk: ${issue2.origin ?? "value"}, ${adj}${issue2.maximum.toString()} olmal\u0131yd\u0131.`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} ${sizing.unit} sahip olmal\u0131yd\u0131.`;
        }
        return `Fazla k\xFC\xE7\xFCk: ${issue2.origin}, ${adj}${issue2.minimum.toString()} olmal\u0131yd\u0131.`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `F\xE2sit metin: "${_issue.prefix}" ile ba\u015Flamal\u0131.`;
        if (_issue.format === "ends_with")
          return `F\xE2sit metin: "${_issue.suffix}" ile bitmeli.`;
        if (_issue.format === "includes")
          return `F\xE2sit metin: "${_issue.includes}" ihtiv\xE2 etmeli.`;
        if (_issue.format === "regex")
          return `F\xE2sit metin: ${_issue.pattern} nak\u015F\u0131na uymal\u0131.`;
        return `F\xE2sit ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `F\xE2sit say\u0131: ${issue2.divisor} kat\u0131 olmal\u0131yd\u0131.`;
      case "unrecognized_keys":
        return `Tan\u0131nmayan anahtar ${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} i\xE7in tan\u0131nmayan anahtar var.`;
      case "invalid_union":
        return "Giren tan\u0131namad\u0131.";
      case "invalid_element":
        return `${issue2.origin} i\xE7in tan\u0131nmayan k\u0131ymet var.`;
      default:
        return `K\u0131ymet tan\u0131namad\u0131.`;
    }
  };
};
function ota_default() {
  return {
    localeError: error31()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ps.js
var error32 = () => {
  const Sizable = {
    string: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
    file: { unit: "\u0628\u0627\u06CC\u067C\u0633", verb: "\u0648\u0644\u0631\u064A" },
    array: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" },
    set: { unit: "\u062A\u0648\u06A9\u064A", verb: "\u0648\u0644\u0631\u064A" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0648\u0631\u0648\u062F\u064A",
    email: "\u0628\u0631\u06CC\u069A\u0646\u0627\u0644\u06CC\u06A9",
    url: "\u06CC\u0648 \u0622\u0631 \u0627\u0644",
    emoji: "\u0627\u06CC\u0645\u0648\u062C\u064A",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u0646\u06CC\u067C\u0647 \u0627\u0648 \u0648\u062E\u062A",
    date: "\u0646\u06D0\u067C\u0647",
    time: "\u0648\u062E\u062A",
    duration: "\u0645\u0648\u062F\u0647",
    ipv4: "\u062F IPv4 \u067E\u062A\u0647",
    ipv6: "\u062F IPv6 \u067E\u062A\u0647",
    cidrv4: "\u062F IPv4 \u0633\u0627\u062D\u0647",
    cidrv6: "\u062F IPv6 \u0633\u0627\u062D\u0647",
    base64: "base64-encoded \u0645\u062A\u0646",
    base64url: "base64url-encoded \u0645\u062A\u0646",
    json_string: "JSON \u0645\u062A\u0646",
    e164: "\u062F E.164 \u0634\u0645\u06D0\u0631\u0647",
    jwt: "JWT",
    template_literal: "\u0648\u0631\u0648\u062F\u064A"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0639\u062F\u062F",
    array: "\u0627\u0631\u06D0"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F instanceof ${issue2.expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
        }
        return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${expected} \u0648\u0627\u06CC, \u0645\u06AB\u0631 ${received} \u062A\u0631\u0644\u0627\u0633\u0647 \u0634\u0648`;
      }
      case "invalid_value":
        if (issue2.values.length === 1) {
          return `\u0646\u0627\u0633\u0645 \u0648\u0631\u0648\u062F\u064A: \u0628\u0627\u06CC\u062F ${stringifyPrimitive(issue2.values[0])} \u0648\u0627\u06CC`;
        }
        return `\u0646\u0627\u0633\u0645 \u0627\u0646\u062A\u062E\u0627\u0628: \u0628\u0627\u06CC\u062F \u06CC\u0648 \u0644\u0647 ${joinValues(issue2.values, "|")} \u0685\u062E\u0647 \u0648\u0627\u06CC`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue2.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0635\u0631\u0648\u0646\u0647"} \u0648\u0644\u0631\u064A`;
        }
        return `\u0689\u06CC\u0631 \u0644\u0648\u06CC: ${issue2.origin ?? "\u0627\u0631\u0632\u069A\u062A"} \u0628\u0627\u06CC\u062F ${adj}${issue2.maximum.toString()} \u0648\u064A`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0648\u0644\u0631\u064A`;
        }
        return `\u0689\u06CC\u0631 \u06A9\u0648\u0686\u0646\u06CC: ${issue2.origin} \u0628\u0627\u06CC\u062F ${adj}${issue2.minimum.toString()} \u0648\u064A`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.prefix}" \u0633\u0631\u0647 \u067E\u06CC\u0644 \u0634\u064A`;
        }
        if (_issue.format === "ends_with") {
          return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F "${_issue.suffix}" \u0633\u0631\u0647 \u067E\u0627\u06CC \u062A\u0647 \u0648\u0631\u0633\u064A\u0696\u064A`;
        }
        if (_issue.format === "includes") {
          return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F "${_issue.includes}" \u0648\u0644\u0631\u064A`;
        }
        if (_issue.format === "regex") {
          return `\u0646\u0627\u0633\u0645 \u0645\u062A\u0646: \u0628\u0627\u06CC\u062F \u062F ${_issue.pattern} \u0633\u0631\u0647 \u0645\u0637\u0627\u0628\u0642\u062A \u0648\u0644\u0631\u064A`;
        }
        return `${FormatDictionary[_issue.format] ?? issue2.format} \u0646\u0627\u0633\u0645 \u062F\u06CC`;
      }
      case "not_multiple_of":
        return `\u0646\u0627\u0633\u0645 \u0639\u062F\u062F: \u0628\u0627\u06CC\u062F \u062F ${issue2.divisor} \u0645\u0636\u0631\u0628 \u0648\u064A`;
      case "unrecognized_keys":
        return `\u0646\u0627\u0633\u0645 ${issue2.keys.length > 1 ? "\u06A9\u0644\u06CC\u0689\u0648\u0646\u0647" : "\u06A9\u0644\u06CC\u0689"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u0646\u0627\u0633\u0645 \u06A9\u0644\u06CC\u0689 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`;
      case "invalid_union":
        return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
      case "invalid_element":
        return `\u0646\u0627\u0633\u0645 \u0639\u0646\u0635\u0631 \u067E\u0647 ${issue2.origin} \u06A9\u06D0`;
      default:
        return `\u0646\u0627\u0633\u0645\u0647 \u0648\u0631\u0648\u062F\u064A`;
    }
  };
};
function ps_default() {
  return {
    localeError: error32()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/pl.js
var error33 = () => {
  const Sizable = {
    string: { unit: "znak\xF3w", verb: "mie\u0107" },
    file: { unit: "bajt\xF3w", verb: "mie\u0107" },
    array: { unit: "element\xF3w", verb: "mie\u0107" },
    set: { unit: "element\xF3w", verb: "mie\u0107" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "wyra\u017Cenie",
    email: "adres email",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "data i godzina w formacie ISO",
    date: "data w formacie ISO",
    time: "godzina w formacie ISO",
    duration: "czas trwania ISO",
    ipv4: "adres IPv4",
    ipv6: "adres IPv6",
    cidrv4: "zakres IPv4",
    cidrv6: "zakres IPv6",
    base64: "ci\u0105g znak\xF3w zakodowany w formacie base64",
    base64url: "ci\u0105g znak\xF3w zakodowany w formacie base64url",
    json_string: "ci\u0105g znak\xF3w w formacie JSON",
    e164: "liczba E.164",
    jwt: "JWT",
    template_literal: "wej\u015Bcie"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "liczba",
    array: "tablica"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano instanceof ${issue2.expected}, otrzymano ${received}`;
        }
        return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${expected}, otrzymano ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Nieprawid\u0142owe dane wej\u015Bciowe: oczekiwano ${stringifyPrimitive(issue2.values[0])}`;
        return `Nieprawid\u0142owa opcja: oczekiwano jednej z warto\u015Bci ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Za du\u017Ca warto\u015B\u0107: oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element\xF3w"}`;
        }
        return `Zbyt du\u017C(y/a/e): oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Za ma\u0142a warto\u015B\u0107: oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie mie\u0107 ${adj}${issue2.minimum.toString()} ${sizing.unit ?? "element\xF3w"}`;
        }
        return `Zbyt ma\u0142(y/a/e): oczekiwano, \u017Ce ${issue2.origin ?? "warto\u015B\u0107"} b\u0119dzie wynosi\u0107 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zaczyna\u0107 si\u0119 od "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi ko\u0144czy\u0107 si\u0119 na "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi zawiera\u0107 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Nieprawid\u0142owy ci\u0105g znak\xF3w: musi odpowiada\u0107 wzorcowi ${_issue.pattern}`;
        return `Nieprawid\u0142ow(y/a/e) ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Nieprawid\u0142owa liczba: musi by\u0107 wielokrotno\u015Bci\u0105 ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Nierozpoznane klucze${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Nieprawid\u0142owy klucz w ${issue2.origin}`;
      case "invalid_union":
        return "Nieprawid\u0142owe dane wej\u015Bciowe";
      case "invalid_element":
        return `Nieprawid\u0142owa warto\u015B\u0107 w ${issue2.origin}`;
      default:
        return `Nieprawid\u0142owe dane wej\u015Bciowe`;
    }
  };
};
function pl_default() {
  return {
    localeError: error33()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/pt.js
var error34 = () => {
  const Sizable = {
    string: { unit: "caracteres", verb: "ter" },
    file: { unit: "bytes", verb: "ter" },
    array: { unit: "itens", verb: "ter" },
    set: { unit: "itens", verb: "ter" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "padr\xE3o",
    email: "endere\xE7o de e-mail",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "data e hora ISO",
    date: "data ISO",
    time: "hora ISO",
    duration: "dura\xE7\xE3o ISO",
    ipv4: "endere\xE7o IPv4",
    ipv6: "endere\xE7o IPv6",
    cidrv4: "faixa de IPv4",
    cidrv6: "faixa de IPv6",
    base64: "texto codificado em base64",
    base64url: "URL codificada em base64",
    json_string: "texto JSON",
    e164: "n\xFAmero E.164",
    jwt: "JWT",
    template_literal: "entrada"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "n\xFAmero",
    null: "nulo"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Tipo inv\xE1lido: esperado instanceof ${issue2.expected}, recebido ${received}`;
        }
        return `Tipo inv\xE1lido: esperado ${expected}, recebido ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Entrada inv\xE1lida: esperado ${stringifyPrimitive(issue2.values[0])}`;
        return `Op\xE7\xE3o inv\xE1lida: esperada uma das ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Muito grande: esperado que ${issue2.origin ?? "valor"} tivesse ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementos"}`;
        return `Muito grande: esperado que ${issue2.origin ?? "valor"} fosse ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Muito pequeno: esperado que ${issue2.origin} tivesse ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Muito pequeno: esperado que ${issue2.origin} fosse ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Texto inv\xE1lido: deve come\xE7ar com "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Texto inv\xE1lido: deve terminar com "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Texto inv\xE1lido: deve incluir "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Texto inv\xE1lido: deve corresponder ao padr\xE3o ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} inv\xE1lido`;
      }
      case "not_multiple_of":
        return `N\xFAmero inv\xE1lido: deve ser m\xFAltiplo de ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Chave${issue2.keys.length > 1 ? "s" : ""} desconhecida${issue2.keys.length > 1 ? "s" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Chave inv\xE1lida em ${issue2.origin}`;
      case "invalid_union":
        return "Entrada inv\xE1lida";
      case "invalid_element":
        return `Valor inv\xE1lido em ${issue2.origin}`;
      default:
        return `Campo inv\xE1lido`;
    }
  };
};
function pt_default() {
  return {
    localeError: error34()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ru.js
function getRussianPlural(count, one, few, many) {
  const absCount = Math.abs(count);
  const lastDigit = absCount % 10;
  const lastTwoDigits = absCount % 100;
  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
    return many;
  }
  if (lastDigit === 1) {
    return one;
  }
  if (lastDigit >= 2 && lastDigit <= 4) {
    return few;
  }
  return many;
}
var error35 = () => {
  const Sizable = {
    string: {
      unit: {
        one: "\u0441\u0438\u043C\u0432\u043E\u043B",
        few: "\u0441\u0438\u043C\u0432\u043E\u043B\u0430",
        many: "\u0441\u0438\u043C\u0432\u043E\u043B\u043E\u0432"
      },
      verb: "\u0438\u043C\u0435\u0442\u044C"
    },
    file: {
      unit: {
        one: "\u0431\u0430\u0439\u0442",
        few: "\u0431\u0430\u0439\u0442\u0430",
        many: "\u0431\u0430\u0439\u0442"
      },
      verb: "\u0438\u043C\u0435\u0442\u044C"
    },
    array: {
      unit: {
        one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
        few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
        many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
      },
      verb: "\u0438\u043C\u0435\u0442\u044C"
    },
    set: {
      unit: {
        one: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442",
        few: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u0430",
        many: "\u044D\u043B\u0435\u043C\u0435\u043D\u0442\u043E\u0432"
      },
      verb: "\u0438\u043C\u0435\u0442\u044C"
    }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0432\u0432\u043E\u0434",
    email: "email \u0430\u0434\u0440\u0435\u0441",
    url: "URL",
    emoji: "\u044D\u043C\u043E\u0434\u0437\u0438",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0434\u0430\u0442\u0430 \u0438 \u0432\u0440\u0435\u043C\u044F",
    date: "ISO \u0434\u0430\u0442\u0430",
    time: "ISO \u0432\u0440\u0435\u043C\u044F",
    duration: "ISO \u0434\u043B\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C",
    ipv4: "IPv4 \u0430\u0434\u0440\u0435\u0441",
    ipv6: "IPv6 \u0430\u0434\u0440\u0435\u0441",
    cidrv4: "IPv4 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
    cidrv6: "IPv6 \u0434\u0438\u0430\u043F\u0430\u0437\u043E\u043D",
    base64: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64",
    base64url: "\u0441\u0442\u0440\u043E\u043A\u0430 \u0432 \u0444\u043E\u0440\u043C\u0430\u0442\u0435 base64url",
    json_string: "JSON \u0441\u0442\u0440\u043E\u043A\u0430",
    e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
    jwt: "JWT",
    template_literal: "\u0432\u0432\u043E\u0434"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0447\u0438\u0441\u043B\u043E",
    array: "\u043C\u0430\u0441\u0441\u0438\u0432"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C instanceof ${issue2.expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
        }
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${expected}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0432\u043E\u0434: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${stringifyPrimitive(issue2.values[0])}`;
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u0432\u0430\u0440\u0438\u0430\u043D\u0442: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C \u043E\u0434\u043D\u043E \u0438\u0437 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const maxValue = Number(issue2.maximum);
          const unit = getRussianPlural(maxValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.maximum.toString()} ${unit}`;
        }
        return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u0431\u043E\u043B\u044C\u0448\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435"} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          const minValue = Number(issue2.minimum);
          const unit = getRussianPlural(minValue, sizing.unit.one, sizing.unit.few, sizing.unit.many);
          return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 \u0438\u043C\u0435\u0442\u044C ${adj}${issue2.minimum.toString()} ${unit}`;
        }
        return `\u0421\u043B\u0438\u0448\u043A\u043E\u043C \u043C\u0430\u043B\u0435\u043D\u044C\u043A\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435: \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C, \u0447\u0442\u043E ${issue2.origin} \u0431\u0443\u0434\u0435\u0442 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u043D\u0430\u0447\u0438\u043D\u0430\u0442\u044C\u0441\u044F \u0441 "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0437\u0430\u043A\u0430\u043D\u0447\u0438\u0432\u0430\u0442\u044C\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u0434\u0435\u0440\u0436\u0430\u0442\u044C "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u041D\u0435\u0432\u0435\u0440\u043D\u0430\u044F \u0441\u0442\u0440\u043E\u043A\u0430: \u0434\u043E\u043B\u0436\u043D\u0430 \u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043E\u0432\u0430\u0442\u044C \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0447\u0438\u0441\u043B\u043E: \u0434\u043E\u043B\u0436\u043D\u043E \u0431\u044B\u0442\u044C \u043A\u0440\u0430\u0442\u043D\u044B\u043C ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u041D\u0435\u0440\u0430\u0441\u043F\u043E\u0437\u043D\u0430\u043D\u043D${issue2.keys.length > 1 ? "\u044B\u0435" : "\u044B\u0439"} \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0438" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0439 \u043A\u043B\u044E\u0447 \u0432 ${issue2.origin}`;
      case "invalid_union":
        return "\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435";
      case "invalid_element":
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u043E\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u0438\u0435 \u0432 ${issue2.origin}`;
      default:
        return `\u041D\u0435\u0432\u0435\u0440\u043D\u044B\u0435 \u0432\u0445\u043E\u0434\u043D\u044B\u0435 \u0434\u0430\u043D\u043D\u044B\u0435`;
    }
  };
};
function ru_default() {
  return {
    localeError: error35()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/sl.js
var error36 = () => {
  const Sizable = {
    string: { unit: "znakov", verb: "imeti" },
    file: { unit: "bajtov", verb: "imeti" },
    array: { unit: "elementov", verb: "imeti" },
    set: { unit: "elementov", verb: "imeti" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "vnos",
    email: "e-po\u0161tni naslov",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO datum in \u010Das",
    date: "ISO datum",
    time: "ISO \u010Das",
    duration: "ISO trajanje",
    ipv4: "IPv4 naslov",
    ipv6: "IPv6 naslov",
    cidrv4: "obseg IPv4",
    cidrv6: "obseg IPv6",
    base64: "base64 kodiran niz",
    base64url: "base64url kodiran niz",
    json_string: "JSON niz",
    e164: "E.164 \u0161tevilka",
    jwt: "JWT",
    template_literal: "vnos"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0161tevilo",
    array: "tabela"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Neveljaven vnos: pri\u010Dakovano instanceof ${issue2.expected}, prejeto ${received}`;
        }
        return `Neveljaven vnos: pri\u010Dakovano ${expected}, prejeto ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Neveljaven vnos: pri\u010Dakovano ${stringifyPrimitive(issue2.values[0])}`;
        return `Neveljavna mo\u017Enost: pri\u010Dakovano eno izmed ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Preveliko: pri\u010Dakovano, da bo ${issue2.origin ?? "vrednost"} imelo ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "elementov"}`;
        return `Preveliko: pri\u010Dakovano, da bo ${issue2.origin ?? "vrednost"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} imelo ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Premajhno: pri\u010Dakovano, da bo ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Neveljaven niz: mora se za\u010Deti z "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Neveljaven niz: mora se kon\u010Dati z "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Neveljaven niz: mora vsebovati "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Neveljaven niz: mora ustrezati vzorcu ${_issue.pattern}`;
        return `Neveljaven ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Neveljavno \u0161tevilo: mora biti ve\u010Dkratnik ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Neprepoznan${issue2.keys.length > 1 ? "i klju\u010Di" : " klju\u010D"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Neveljaven klju\u010D v ${issue2.origin}`;
      case "invalid_union":
        return "Neveljaven vnos";
      case "invalid_element":
        return `Neveljavna vrednost v ${issue2.origin}`;
      default:
        return "Neveljaven vnos";
    }
  };
};
function sl_default() {
  return {
    localeError: error36()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/sv.js
var error37 = () => {
  const Sizable = {
    string: { unit: "tecken", verb: "att ha" },
    file: { unit: "bytes", verb: "att ha" },
    array: { unit: "objekt", verb: "att inneh\xE5lla" },
    set: { unit: "objekt", verb: "att inneh\xE5lla" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "regulj\xE4rt uttryck",
    email: "e-postadress",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO-datum och tid",
    date: "ISO-datum",
    time: "ISO-tid",
    duration: "ISO-varaktighet",
    ipv4: "IPv4-intervall",
    ipv6: "IPv6-intervall",
    cidrv4: "IPv4-spektrum",
    cidrv6: "IPv6-spektrum",
    base64: "base64-kodad str\xE4ng",
    base64url: "base64url-kodad str\xE4ng",
    json_string: "JSON-str\xE4ng",
    e164: "E.164-nummer",
    jwt: "JWT",
    template_literal: "mall-literal"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "antal",
    array: "lista"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ogiltig inmatning: f\xF6rv\xE4ntat instanceof ${issue2.expected}, fick ${received}`;
        }
        return `Ogiltig inmatning: f\xF6rv\xE4ntat ${expected}, fick ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ogiltig inmatning: f\xF6rv\xE4ntat ${stringifyPrimitive(issue2.values[0])}`;
        return `Ogiltigt val: f\xF6rv\xE4ntade en av ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `F\xF6r stor(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "element"}`;
        }
        return `F\xF6r stor(t): f\xF6rv\xE4ntat ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `F\xF6r lite(t): f\xF6rv\xE4ntade ${issue2.origin ?? "v\xE4rdet"} att ha ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `Ogiltig str\xE4ng: m\xE5ste b\xF6rja med "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `Ogiltig str\xE4ng: m\xE5ste sluta med "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Ogiltig str\xE4ng: m\xE5ste inneh\xE5lla "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Ogiltig str\xE4ng: m\xE5ste matcha m\xF6nstret "${_issue.pattern}"`;
        return `Ogiltig(t) ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ogiltigt tal: m\xE5ste vara en multipel av ${issue2.divisor}`;
      case "unrecognized_keys":
        return `${issue2.keys.length > 1 ? "Ok\xE4nda nycklar" : "Ok\xE4nd nyckel"}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Ogiltig nyckel i ${issue2.origin ?? "v\xE4rdet"}`;
      case "invalid_union":
        return "Ogiltig input";
      case "invalid_element":
        return `Ogiltigt v\xE4rde i ${issue2.origin ?? "v\xE4rdet"}`;
      default:
        return `Ogiltig input`;
    }
  };
};
function sv_default() {
  return {
    localeError: error37()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ta.js
var error38 = () => {
  const Sizable = {
    string: { unit: "\u0B8E\u0BB4\u0BC1\u0BA4\u0BCD\u0BA4\u0BC1\u0B95\u0BCD\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
    file: { unit: "\u0BAA\u0BC8\u0B9F\u0BCD\u0B9F\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
    array: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" },
    set: { unit: "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD", verb: "\u0B95\u0BCA\u0BA3\u0BCD\u0B9F\u0BBF\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1",
    email: "\u0BAE\u0BBF\u0BA9\u0BCD\u0BA9\u0B9E\u0BCD\u0B9A\u0BB2\u0BCD \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u0BA4\u0BC7\u0BA4\u0BBF \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
    date: "ISO \u0BA4\u0BC7\u0BA4\u0BBF",
    time: "ISO \u0BA8\u0BC7\u0BB0\u0BAE\u0BCD",
    duration: "ISO \u0B95\u0BBE\u0BB2 \u0B85\u0BB3\u0BB5\u0BC1",
    ipv4: "IPv4 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
    ipv6: "IPv6 \u0BAE\u0BC1\u0B95\u0BB5\u0BB0\u0BBF",
    cidrv4: "IPv4 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
    cidrv6: "IPv6 \u0BB5\u0BB0\u0BAE\u0BCD\u0BAA\u0BC1",
    base64: "base64-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
    base64url: "base64url-encoded \u0B9A\u0BB0\u0BAE\u0BCD",
    json_string: "JSON \u0B9A\u0BB0\u0BAE\u0BCD",
    e164: "E.164 \u0B8E\u0BA3\u0BCD",
    jwt: "JWT",
    template_literal: "input"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0B8E\u0BA3\u0BCD",
    array: "\u0B85\u0BA3\u0BBF",
    null: "\u0BB5\u0BC6\u0BB1\u0BC1\u0BAE\u0BC8"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 instanceof ${issue2.expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
        }
        return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${expected}, \u0BAA\u0BC6\u0BB1\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${stringifyPrimitive(issue2.values[0])}`;
        return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0BB0\u0BC1\u0BAA\u0BCD\u0BAA\u0BAE\u0BCD: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${joinValues(issue2.values, "|")} \u0B87\u0BB2\u0BCD \u0B92\u0BA9\u0BCD\u0BB1\u0BC1`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0B89\u0BB1\u0BC1\u0BAA\u0BCD\u0BAA\u0BC1\u0B95\u0BB3\u0BCD"} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        }
        return `\u0BAE\u0BBF\u0B95 \u0BAA\u0BC6\u0BB0\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin ?? "\u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1"} ${adj}${issue2.maximum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        }
        return `\u0BAE\u0BBF\u0B95\u0B9A\u0BCD \u0B9A\u0BBF\u0BB1\u0BBF\u0BAF\u0BA4\u0BC1: \u0B8E\u0BA4\u0BBF\u0BB0\u0BCD\u0BAA\u0BBE\u0BB0\u0BCD\u0B95\u0BCD\u0B95\u0BAA\u0BCD\u0BAA\u0B9F\u0BCD\u0B9F\u0BA4\u0BC1 ${issue2.origin} ${adj}${issue2.minimum.toString()} \u0B86\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.prefix}" \u0B87\u0BB2\u0BCD \u0BA4\u0BCA\u0B9F\u0B99\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        if (_issue.format === "ends_with")
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.suffix}" \u0B87\u0BB2\u0BCD \u0BAE\u0BC1\u0B9F\u0BBF\u0BB5\u0B9F\u0BC8\u0BAF \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        if (_issue.format === "includes")
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: "${_issue.includes}" \u0B90 \u0B89\u0BB3\u0BCD\u0BB3\u0B9F\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        if (_issue.format === "regex")
          return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B9A\u0BB0\u0BAE\u0BCD: ${_issue.pattern} \u0BAE\u0BC1\u0BB1\u0BC8\u0BAA\u0BBE\u0B9F\u0BCD\u0B9F\u0BC1\u0B9F\u0BA9\u0BCD \u0BAA\u0BCA\u0BB0\u0BC1\u0BA8\u0BCD\u0BA4 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
        return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B8E\u0BA3\u0BCD: ${issue2.divisor} \u0B87\u0BA9\u0BCD \u0BAA\u0BB2\u0BAE\u0BBE\u0B95 \u0B87\u0BB0\u0BC1\u0B95\u0BCD\u0B95 \u0BB5\u0BC7\u0BA3\u0BCD\u0B9F\u0BC1\u0BAE\u0BCD`;
      case "unrecognized_keys":
        return `\u0B85\u0B9F\u0BC8\u0BAF\u0BBE\u0BB3\u0BAE\u0BCD \u0BA4\u0BC6\u0BB0\u0BBF\u0BAF\u0BBE\u0BA4 \u0BB5\u0BBF\u0B9A\u0BC8${issue2.keys.length > 1 ? "\u0B95\u0BB3\u0BCD" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BB5\u0BBF\u0B9A\u0BC8`;
      case "invalid_union":
        return "\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1";
      case "invalid_element":
        return `${issue2.origin} \u0B87\u0BB2\u0BCD \u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0BAE\u0BA4\u0BBF\u0BAA\u0BCD\u0BAA\u0BC1`;
      default:
        return `\u0BA4\u0BB5\u0BB1\u0BBE\u0BA9 \u0B89\u0BB3\u0BCD\u0BB3\u0BC0\u0B9F\u0BC1`;
    }
  };
};
function ta_default() {
  return {
    localeError: error38()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/th.js
var error39 = () => {
  const Sizable = {
    string: { unit: "\u0E15\u0E31\u0E27\u0E2D\u0E31\u0E01\u0E29\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
    file: { unit: "\u0E44\u0E1A\u0E15\u0E4C", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
    array: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" },
    set: { unit: "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23", verb: "\u0E04\u0E27\u0E23\u0E21\u0E35" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19",
    email: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48\u0E2D\u0E35\u0E40\u0E21\u0E25",
    url: "URL",
    emoji: "\u0E2D\u0E34\u0E42\u0E21\u0E08\u0E34",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
    date: "\u0E27\u0E31\u0E19\u0E17\u0E35\u0E48\u0E41\u0E1A\u0E1A ISO",
    time: "\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
    duration: "\u0E0A\u0E48\u0E27\u0E07\u0E40\u0E27\u0E25\u0E32\u0E41\u0E1A\u0E1A ISO",
    ipv4: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv4",
    ipv6: "\u0E17\u0E35\u0E48\u0E2D\u0E22\u0E39\u0E48 IPv6",
    cidrv4: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv4",
    cidrv6: "\u0E0A\u0E48\u0E27\u0E07 IP \u0E41\u0E1A\u0E1A IPv6",
    base64: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64",
    base64url: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A Base64 \u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A URL",
    json_string: "\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E41\u0E1A\u0E1A JSON",
    e164: "\u0E40\u0E1A\u0E2D\u0E23\u0E4C\u0E42\u0E17\u0E23\u0E28\u0E31\u0E1E\u0E17\u0E4C\u0E23\u0E30\u0E2B\u0E27\u0E48\u0E32\u0E07\u0E1B\u0E23\u0E30\u0E40\u0E17\u0E28 (E.164)",
    jwt: "\u0E42\u0E17\u0E40\u0E04\u0E19 JWT",
    template_literal: "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E17\u0E35\u0E48\u0E1B\u0E49\u0E2D\u0E19"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02",
    array: "\u0E2D\u0E32\u0E23\u0E4C\u0E40\u0E23\u0E22\u0E4C (Array)",
    null: "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E04\u0E48\u0E32 (null)"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 instanceof ${issue2.expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
        }
        return `\u0E1B\u0E23\u0E30\u0E40\u0E20\u0E17\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${expected} \u0E41\u0E15\u0E48\u0E44\u0E14\u0E49\u0E23\u0E31\u0E1A ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u0E04\u0E48\u0E32\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19 ${stringifyPrimitive(issue2.values[0])}`;
        return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E37\u0E2D\u0E01\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E04\u0E27\u0E23\u0E40\u0E1B\u0E47\u0E19\u0E2B\u0E19\u0E36\u0E48\u0E07\u0E43\u0E19 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "\u0E44\u0E21\u0E48\u0E40\u0E01\u0E34\u0E19" : "\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()} ${sizing.unit ?? "\u0E23\u0E32\u0E22\u0E01\u0E32\u0E23"}`;
        return `\u0E40\u0E01\u0E34\u0E19\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin ?? "\u0E04\u0E48\u0E32"} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? "\u0E2D\u0E22\u0E48\u0E32\u0E07\u0E19\u0E49\u0E2D\u0E22" : "\u0E21\u0E32\u0E01\u0E01\u0E27\u0E48\u0E32";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u0E19\u0E49\u0E2D\u0E22\u0E01\u0E27\u0E48\u0E32\u0E01\u0E33\u0E2B\u0E19\u0E14: ${issue2.origin} \u0E04\u0E27\u0E23\u0E21\u0E35${adj} ${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E02\u0E36\u0E49\u0E19\u0E15\u0E49\u0E19\u0E14\u0E49\u0E27\u0E22 "${_issue.prefix}"`;
        }
        if (_issue.format === "ends_with")
          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E25\u0E07\u0E17\u0E49\u0E32\u0E22\u0E14\u0E49\u0E27\u0E22 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21\u0E15\u0E49\u0E2D\u0E07\u0E21\u0E35 "${_issue.includes}" \u0E2D\u0E22\u0E39\u0E48\u0E43\u0E19\u0E02\u0E49\u0E2D\u0E04\u0E27\u0E32\u0E21`;
        if (_issue.format === "regex")
          return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14 ${_issue.pattern}`;
        return `\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u0E15\u0E31\u0E27\u0E40\u0E25\u0E02\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E08\u0E33\u0E19\u0E27\u0E19\u0E17\u0E35\u0E48\u0E2B\u0E32\u0E23\u0E14\u0E49\u0E27\u0E22 ${issue2.divisor} \u0E44\u0E14\u0E49\u0E25\u0E07\u0E15\u0E31\u0E27`;
      case "unrecognized_keys":
        return `\u0E1E\u0E1A\u0E04\u0E35\u0E22\u0E4C\u0E17\u0E35\u0E48\u0E44\u0E21\u0E48\u0E23\u0E39\u0E49\u0E08\u0E31\u0E01: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u0E04\u0E35\u0E22\u0E4C\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`;
      case "invalid_union":
        return "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07: \u0E44\u0E21\u0E48\u0E15\u0E23\u0E07\u0E01\u0E31\u0E1A\u0E23\u0E39\u0E1B\u0E41\u0E1A\u0E1A\u0E22\u0E39\u0E40\u0E19\u0E35\u0E22\u0E19\u0E17\u0E35\u0E48\u0E01\u0E33\u0E2B\u0E19\u0E14\u0E44\u0E27\u0E49";
      case "invalid_element":
        return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07\u0E43\u0E19 ${issue2.origin}`;
      default:
        return `\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25\u0E44\u0E21\u0E48\u0E16\u0E39\u0E01\u0E15\u0E49\u0E2D\u0E07`;
    }
  };
};
function th_default() {
  return {
    localeError: error39()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/tr.js
var error40 = () => {
  const Sizable = {
    string: { unit: "karakter", verb: "olmal\u0131" },
    file: { unit: "bayt", verb: "olmal\u0131" },
    array: { unit: "\xF6\u011Fe", verb: "olmal\u0131" },
    set: { unit: "\xF6\u011Fe", verb: "olmal\u0131" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "girdi",
    email: "e-posta adresi",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO tarih ve saat",
    date: "ISO tarih",
    time: "ISO saat",
    duration: "ISO s\xFCre",
    ipv4: "IPv4 adresi",
    ipv6: "IPv6 adresi",
    cidrv4: "IPv4 aral\u0131\u011F\u0131",
    cidrv6: "IPv6 aral\u0131\u011F\u0131",
    base64: "base64 ile \u015Fifrelenmi\u015F metin",
    base64url: "base64url ile \u015Fifrelenmi\u015F metin",
    json_string: "JSON dizesi",
    e164: "E.164 say\u0131s\u0131",
    jwt: "JWT",
    template_literal: "\u015Eablon dizesi"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Ge\xE7ersiz de\u011Fer: beklenen instanceof ${issue2.expected}, al\u0131nan ${received}`;
        }
        return `Ge\xE7ersiz de\u011Fer: beklenen ${expected}, al\u0131nan ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Ge\xE7ersiz de\u011Fer: beklenen ${stringifyPrimitive(issue2.values[0])}`;
        return `Ge\xE7ersiz se\xE7enek: a\u015Fa\u011F\u0131dakilerden biri olmal\u0131: ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\xC7ok b\xFCy\xFCk: beklenen ${issue2.origin ?? "de\u011Fer"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\xF6\u011Fe"}`;
        return `\xC7ok b\xFCy\xFCk: beklenen ${issue2.origin ?? "de\u011Fer"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        return `\xC7ok k\xFC\xE7\xFCk: beklenen ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Ge\xE7ersiz metin: "${_issue.prefix}" ile ba\u015Flamal\u0131`;
        if (_issue.format === "ends_with")
          return `Ge\xE7ersiz metin: "${_issue.suffix}" ile bitmeli`;
        if (_issue.format === "includes")
          return `Ge\xE7ersiz metin: "${_issue.includes}" i\xE7ermeli`;
        if (_issue.format === "regex")
          return `Ge\xE7ersiz metin: ${_issue.pattern} desenine uymal\u0131`;
        return `Ge\xE7ersiz ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Ge\xE7ersiz say\u0131: ${issue2.divisor} ile tam b\xF6l\xFCnebilmeli`;
      case "unrecognized_keys":
        return `Tan\u0131nmayan anahtar${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} i\xE7inde ge\xE7ersiz anahtar`;
      case "invalid_union":
        return "Ge\xE7ersiz de\u011Fer";
      case "invalid_element":
        return `${issue2.origin} i\xE7inde ge\xE7ersiz de\u011Fer`;
      default:
        return `Ge\xE7ersiz de\u011Fer`;
    }
  };
};
function tr_default() {
  return {
    localeError: error40()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/uk.js
var error41 = () => {
  const Sizable = {
    string: { unit: "\u0441\u0438\u043C\u0432\u043E\u043B\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
    file: { unit: "\u0431\u0430\u0439\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
    array: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" },
    set: { unit: "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432", verb: "\u043C\u0430\u0442\u0438\u043C\u0435" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456",
    email: "\u0430\u0434\u0440\u0435\u0441\u0430 \u0435\u043B\u0435\u043A\u0442\u0440\u043E\u043D\u043D\u043E\u0457 \u043F\u043E\u0448\u0442\u0438",
    url: "URL",
    emoji: "\u0435\u043C\u043E\u0434\u0437\u0456",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\u0434\u0430\u0442\u0430 \u0442\u0430 \u0447\u0430\u0441 ISO",
    date: "\u0434\u0430\u0442\u0430 ISO",
    time: "\u0447\u0430\u0441 ISO",
    duration: "\u0442\u0440\u0438\u0432\u0430\u043B\u0456\u0441\u0442\u044C ISO",
    ipv4: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv4",
    ipv6: "\u0430\u0434\u0440\u0435\u0441\u0430 IPv6",
    cidrv4: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv4",
    cidrv6: "\u0434\u0456\u0430\u043F\u0430\u0437\u043E\u043D IPv6",
    base64: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64",
    base64url: "\u0440\u044F\u0434\u043E\u043A \u0443 \u043A\u043E\u0434\u0443\u0432\u0430\u043D\u043D\u0456 base64url",
    json_string: "\u0440\u044F\u0434\u043E\u043A JSON",
    e164: "\u043D\u043E\u043C\u0435\u0440 E.164",
    jwt: "JWT",
    template_literal: "\u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0447\u0438\u0441\u043B\u043E",
    array: "\u043C\u0430\u0441\u0438\u0432"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F instanceof ${issue2.expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
        }
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${expected}, \u043E\u0442\u0440\u0438\u043C\u0430\u043D\u043E ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F ${stringifyPrimitive(issue2.values[0])}`;
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0430 \u043E\u043F\u0446\u0456\u044F: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F \u043E\u0434\u043D\u0435 \u0437 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0435\u043B\u0435\u043C\u0435\u043D\u0442\u0456\u0432"}`;
        return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u0432\u0435\u043B\u0438\u043A\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin ?? "\u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F"} \u0431\u0443\u0434\u0435 ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u0417\u0430\u043D\u0430\u0434\u0442\u043E \u043C\u0430\u043B\u0435: \u043E\u0447\u0456\u043A\u0443\u0454\u0442\u044C\u0441\u044F, \u0449\u043E ${issue2.origin} \u0431\u0443\u0434\u0435 ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043F\u043E\u0447\u0438\u043D\u0430\u0442\u0438\u0441\u044F \u0437 "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0437\u0430\u043A\u0456\u043D\u0447\u0443\u0432\u0430\u0442\u0438\u0441\u044F \u043D\u0430 "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u043C\u0456\u0441\u0442\u0438\u0442\u0438 "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u0440\u044F\u0434\u043E\u043A: \u043F\u043E\u0432\u0438\u043D\u0435\u043D \u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0442\u0438 \u0448\u0430\u0431\u043B\u043E\u043D\u0443 ${_issue.pattern}`;
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0447\u0438\u0441\u043B\u043E: \u043F\u043E\u0432\u0438\u043D\u043D\u043E \u0431\u0443\u0442\u0438 \u043A\u0440\u0430\u0442\u043D\u0438\u043C ${issue2.divisor}`;
      case "unrecognized_keys":
        return `\u041D\u0435\u0440\u043E\u0437\u043F\u0456\u0437\u043D\u0430\u043D\u0438\u0439 \u043A\u043B\u044E\u0447${issue2.keys.length > 1 ? "\u0456" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0438\u0439 \u043A\u043B\u044E\u0447 \u0443 ${issue2.origin}`;
      case "invalid_union":
        return "\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456";
      case "invalid_element":
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0435 \u0437\u043D\u0430\u0447\u0435\u043D\u043D\u044F \u0443 ${issue2.origin}`;
      default:
        return `\u041D\u0435\u043F\u0440\u0430\u0432\u0438\u043B\u044C\u043D\u0456 \u0432\u0445\u0456\u0434\u043D\u0456 \u0434\u0430\u043D\u0456`;
    }
  };
};
function uk_default() {
  return {
    localeError: error41()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ua.js
function ua_default() {
  return uk_default();
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/ur.js
var error42 = () => {
  const Sizable = {
    string: { unit: "\u062D\u0631\u0648\u0641", verb: "\u06C1\u0648\u0646\u0627" },
    file: { unit: "\u0628\u0627\u0626\u0679\u0633", verb: "\u06C1\u0648\u0646\u0627" },
    array: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" },
    set: { unit: "\u0622\u0626\u0679\u0645\u0632", verb: "\u06C1\u0648\u0646\u0627" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0627\u0646 \u067E\u0679",
    email: "\u0627\u06CC \u0645\u06CC\u0644 \u0627\u06CC\u0688\u0631\u06CC\u0633",
    url: "\u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644",
    emoji: "\u0627\u06CC\u0645\u0648\u062C\u06CC",
    uuid: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
    uuidv4: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 4",
    uuidv6: "\u06CC\u0648 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC \u0648\u06CC 6",
    nanoid: "\u0646\u06CC\u0646\u0648 \u0622\u0626\u06CC \u0688\u06CC",
    guid: "\u062C\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
    cuid: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
    cuid2: "\u0633\u06CC \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC 2",
    ulid: "\u06CC\u0648 \u0627\u06CC\u0644 \u0622\u0626\u06CC \u0688\u06CC",
    xid: "\u0627\u06CC\u06A9\u0633 \u0622\u0626\u06CC \u0688\u06CC",
    ksuid: "\u06A9\u06D2 \u0627\u06CC\u0633 \u06CC\u0648 \u0622\u0626\u06CC \u0688\u06CC",
    datetime: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0688\u06CC\u0679 \u0679\u0627\u0626\u0645",
    date: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u062A\u0627\u0631\u06CC\u062E",
    time: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0648\u0642\u062A",
    duration: "\u0622\u0626\u06CC \u0627\u06CC\u0633 \u0627\u0648 \u0645\u062F\u062A",
    ipv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0627\u06CC\u0688\u0631\u06CC\u0633",
    ipv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0627\u06CC\u0688\u0631\u06CC\u0633",
    cidrv4: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 4 \u0631\u06CC\u0646\u062C",
    cidrv6: "\u0622\u0626\u06CC \u067E\u06CC \u0648\u06CC 6 \u0631\u06CC\u0646\u062C",
    base64: "\u0628\u06CC\u0633 64 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
    base64url: "\u0628\u06CC\u0633 64 \u06CC\u0648 \u0622\u0631 \u0627\u06CC\u0644 \u0627\u0646 \u06A9\u0648\u0688\u0688 \u0633\u0679\u0631\u0646\u06AF",
    json_string: "\u062C\u06D2 \u0627\u06CC\u0633 \u0627\u0648 \u0627\u06CC\u0646 \u0633\u0679\u0631\u0646\u06AF",
    e164: "\u0627\u06CC 164 \u0646\u0645\u0628\u0631",
    jwt: "\u062C\u06D2 \u0688\u0628\u0644\u06CC\u0648 \u0679\u06CC",
    template_literal: "\u0627\u0646 \u067E\u0679"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u0646\u0645\u0628\u0631",
    array: "\u0622\u0631\u06D2",
    null: "\u0646\u0644"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: instanceof ${issue2.expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
        }
        return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${expected} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627\u060C ${received} \u0645\u0648\u0635\u0648\u0644 \u06C1\u0648\u0627`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679: ${stringifyPrimitive(issue2.values[0])} \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
        return `\u063A\u0644\u0637 \u0622\u067E\u0634\u0646: ${joinValues(issue2.values, "|")} \u0645\u06CC\u06BA \u0633\u06D2 \u0627\u06CC\u06A9 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue2.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u06D2 ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u0639\u0646\u0627\u0635\u0631"} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
        return `\u0628\u06C1\u062A \u0628\u0691\u0627: ${issue2.origin ?? "\u0648\u06CC\u0644\u06CC\u0648"} \u06A9\u0627 ${adj}${issue2.maximum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u06D2 ${adj}${issue2.minimum.toString()} ${sizing.unit} \u06C1\u0648\u0646\u06D2 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u06D2`;
        }
        return `\u0628\u06C1\u062A \u0686\u06BE\u0648\u0679\u0627: ${issue2.origin} \u06A9\u0627 ${adj}${issue2.minimum.toString()} \u06C1\u0648\u0646\u0627 \u0645\u062A\u0648\u0642\u0639 \u062A\u06BE\u0627`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.prefix}" \u0633\u06D2 \u0634\u0631\u0648\u0639 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
        }
        if (_issue.format === "ends_with")
          return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.suffix}" \u067E\u0631 \u062E\u062A\u0645 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
        if (_issue.format === "includes")
          return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: "${_issue.includes}" \u0634\u0627\u0645\u0644 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
        if (_issue.format === "regex")
          return `\u063A\u0644\u0637 \u0633\u0679\u0631\u0646\u06AF: \u067E\u06CC\u0679\u0631\u0646 ${_issue.pattern} \u0633\u06D2 \u0645\u06CC\u0686 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
        return `\u063A\u0644\u0637 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u063A\u0644\u0637 \u0646\u0645\u0628\u0631: ${issue2.divisor} \u06A9\u0627 \u0645\u0636\u0627\u0639\u0641 \u06C1\u0648\u0646\u0627 \u0686\u0627\u06C1\u06CC\u06D2`;
      case "unrecognized_keys":
        return `\u063A\u06CC\u0631 \u062A\u0633\u0644\u06CC\u0645 \u0634\u062F\u06C1 \u06A9\u06CC${issue2.keys.length > 1 ? "\u0632" : ""}: ${joinValues(issue2.keys, "\u060C ")}`;
      case "invalid_key":
        return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u06A9\u06CC`;
      case "invalid_union":
        return "\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679";
      case "invalid_element":
        return `${issue2.origin} \u0645\u06CC\u06BA \u063A\u0644\u0637 \u0648\u06CC\u0644\u06CC\u0648`;
      default:
        return `\u063A\u0644\u0637 \u0627\u0646 \u067E\u0679`;
    }
  };
};
function ur_default() {
  return {
    localeError: error42()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/uz.js
var error43 = () => {
  const Sizable = {
    string: { unit: "belgi", verb: "bo\u2018lishi kerak" },
    file: { unit: "bayt", verb: "bo\u2018lishi kerak" },
    array: { unit: "element", verb: "bo\u2018lishi kerak" },
    set: { unit: "element", verb: "bo\u2018lishi kerak" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "kirish",
    email: "elektron pochta manzili",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO sana va vaqti",
    date: "ISO sana",
    time: "ISO vaqt",
    duration: "ISO davomiylik",
    ipv4: "IPv4 manzil",
    ipv6: "IPv6 manzil",
    mac: "MAC manzil",
    cidrv4: "IPv4 diapazon",
    cidrv6: "IPv6 diapazon",
    base64: "base64 kodlangan satr",
    base64url: "base64url kodlangan satr",
    json_string: "JSON satr",
    e164: "E.164 raqam",
    jwt: "JWT",
    template_literal: "kirish"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "raqam",
    array: "massiv"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `Noto\u2018g\u2018ri kirish: kutilgan instanceof ${issue2.expected}, qabul qilingan ${received}`;
        }
        return `Noto\u2018g\u2018ri kirish: kutilgan ${expected}, qabul qilingan ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `Noto\u2018g\u2018ri kirish: kutilgan ${stringifyPrimitive(issue2.values[0])}`;
        return `Noto\u2018g\u2018ri variant: quyidagilardan biri kutilgan ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()} ${sizing.unit} ${sizing.verb}`;
        return `Juda katta: kutilgan ${issue2.origin ?? "qiymat"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit} ${sizing.verb}`;
        }
        return `Juda kichik: kutilgan ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Noto\u2018g\u2018ri satr: "${_issue.prefix}" bilan boshlanishi kerak`;
        if (_issue.format === "ends_with")
          return `Noto\u2018g\u2018ri satr: "${_issue.suffix}" bilan tugashi kerak`;
        if (_issue.format === "includes")
          return `Noto\u2018g\u2018ri satr: "${_issue.includes}" ni o\u2018z ichiga olishi kerak`;
        if (_issue.format === "regex")
          return `Noto\u2018g\u2018ri satr: ${_issue.pattern} shabloniga mos kelishi kerak`;
        return `Noto\u2018g\u2018ri ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `Noto\u2018g\u2018ri raqam: ${issue2.divisor} ning karralisi bo\u2018lishi kerak`;
      case "unrecognized_keys":
        return `Noma\u2019lum kalit${issue2.keys.length > 1 ? "lar" : ""}: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} dagi kalit noto\u2018g\u2018ri`;
      case "invalid_union":
        return "Noto\u2018g\u2018ri kirish";
      case "invalid_element":
        return `${issue2.origin} da noto\u2018g\u2018ri qiymat`;
      default:
        return `Noto\u2018g\u2018ri kirish`;
    }
  };
};
function uz_default() {
  return {
    localeError: error43()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/vi.js
var error44 = () => {
  const Sizable = {
    string: { unit: "k\xFD t\u1EF1", verb: "c\xF3" },
    file: { unit: "byte", verb: "c\xF3" },
    array: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" },
    set: { unit: "ph\u1EA7n t\u1EED", verb: "c\xF3" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u0111\u1EA7u v\xE0o",
    email: "\u0111\u1ECBa ch\u1EC9 email",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ng\xE0y gi\u1EDD ISO",
    date: "ng\xE0y ISO",
    time: "gi\u1EDD ISO",
    duration: "kho\u1EA3ng th\u1EDDi gian ISO",
    ipv4: "\u0111\u1ECBa ch\u1EC9 IPv4",
    ipv6: "\u0111\u1ECBa ch\u1EC9 IPv6",
    cidrv4: "d\u1EA3i IPv4",
    cidrv6: "d\u1EA3i IPv6",
    base64: "chu\u1ED7i m\xE3 h\xF3a base64",
    base64url: "chu\u1ED7i m\xE3 h\xF3a base64url",
    json_string: "chu\u1ED7i JSON",
    e164: "s\u1ED1 E.164",
    jwt: "JWT",
    template_literal: "\u0111\u1EA7u v\xE0o"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "s\u1ED1",
    array: "m\u1EA3ng"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i instanceof ${issue2.expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
        }
        return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${expected}, nh\u1EADn \u0111\u01B0\u1EE3c ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i ${stringifyPrimitive(issue2.values[0])}`;
        return `T\xF9y ch\u1ECDn kh\xF4ng h\u1EE3p l\u1EC7: mong \u0111\u1EE3i m\u1ED9t trong c\xE1c gi\xE1 tr\u1ECB ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue2.origin ?? "gi\xE1 tr\u1ECB"} ${sizing.verb} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "ph\u1EA7n t\u1EED"}`;
        return `Qu\xE1 l\u1EDBn: mong \u0111\u1EE3i ${issue2.origin ?? "gi\xE1 tr\u1ECB"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `Qu\xE1 nh\u1ECF: mong \u0111\u1EE3i ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i b\u1EAFt \u0111\u1EA7u b\u1EB1ng "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i k\u1EBFt th\xFAc b\u1EB1ng "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i bao g\u1ED3m "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `Chu\u1ED7i kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i kh\u1EDBp v\u1EDBi m\u1EABu ${_issue.pattern}`;
        return `${FormatDictionary[_issue.format] ?? issue2.format} kh\xF4ng h\u1EE3p l\u1EC7`;
      }
      case "not_multiple_of":
        return `S\u1ED1 kh\xF4ng h\u1EE3p l\u1EC7: ph\u1EA3i l\xE0 b\u1ED9i s\u1ED1 c\u1EE7a ${issue2.divisor}`;
      case "unrecognized_keys":
        return `Kh\xF3a kh\xF4ng \u0111\u01B0\u1EE3c nh\u1EADn d\u1EA1ng: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `Kh\xF3a kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`;
      case "invalid_union":
        return "\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7";
      case "invalid_element":
        return `Gi\xE1 tr\u1ECB kh\xF4ng h\u1EE3p l\u1EC7 trong ${issue2.origin}`;
      default:
        return `\u0110\u1EA7u v\xE0o kh\xF4ng h\u1EE3p l\u1EC7`;
    }
  };
};
function vi_default() {
  return {
    localeError: error44()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/zh-CN.js
var error45 = () => {
  const Sizable = {
    string: { unit: "\u5B57\u7B26", verb: "\u5305\u542B" },
    file: { unit: "\u5B57\u8282", verb: "\u5305\u542B" },
    array: { unit: "\u9879", verb: "\u5305\u542B" },
    set: { unit: "\u9879", verb: "\u5305\u542B" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u8F93\u5165",
    email: "\u7535\u5B50\u90AE\u4EF6",
    url: "URL",
    emoji: "\u8868\u60C5\u7B26\u53F7",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO\u65E5\u671F\u65F6\u95F4",
    date: "ISO\u65E5\u671F",
    time: "ISO\u65F6\u95F4",
    duration: "ISO\u65F6\u957F",
    ipv4: "IPv4\u5730\u5740",
    ipv6: "IPv6\u5730\u5740",
    cidrv4: "IPv4\u7F51\u6BB5",
    cidrv6: "IPv6\u7F51\u6BB5",
    base64: "base64\u7F16\u7801\u5B57\u7B26\u4E32",
    base64url: "base64url\u7F16\u7801\u5B57\u7B26\u4E32",
    json_string: "JSON\u5B57\u7B26\u4E32",
    e164: "E.164\u53F7\u7801",
    jwt: "JWT",
    template_literal: "\u8F93\u5165"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "\u6570\u5B57",
    array: "\u6570\u7EC4",
    null: "\u7A7A\u503C(null)"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B instanceof ${issue2.expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
        }
        return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${expected}\uFF0C\u5B9E\u9645\u63A5\u6536 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u65E0\u6548\u8F93\u5165\uFF1A\u671F\u671B ${stringifyPrimitive(issue2.values[0])}`;
        return `\u65E0\u6548\u9009\u9879\uFF1A\u671F\u671B\u4EE5\u4E0B\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue2.origin ?? "\u503C"} ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u4E2A\u5143\u7D20"}`;
        return `\u6570\u503C\u8FC7\u5927\uFF1A\u671F\u671B ${issue2.origin ?? "\u503C"} ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u6570\u503C\u8FC7\u5C0F\uFF1A\u671F\u671B ${issue2.origin} ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.prefix}" \u5F00\u5934`;
        if (_issue.format === "ends_with")
          return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u4EE5 "${_issue.suffix}" \u7ED3\u5C3E`;
        if (_issue.format === "includes")
          return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u5305\u542B "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u65E0\u6548\u5B57\u7B26\u4E32\uFF1A\u5FC5\u987B\u6EE1\u8DB3\u6B63\u5219\u8868\u8FBE\u5F0F ${_issue.pattern}`;
        return `\u65E0\u6548${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u65E0\u6548\u6570\u5B57\uFF1A\u5FC5\u987B\u662F ${issue2.divisor} \u7684\u500D\u6570`;
      case "unrecognized_keys":
        return `\u51FA\u73B0\u672A\u77E5\u7684\u952E(key): ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `${issue2.origin} \u4E2D\u7684\u952E(key)\u65E0\u6548`;
      case "invalid_union":
        return "\u65E0\u6548\u8F93\u5165";
      case "invalid_element":
        return `${issue2.origin} \u4E2D\u5305\u542B\u65E0\u6548\u503C(value)`;
      default:
        return `\u65E0\u6548\u8F93\u5165`;
    }
  };
};
function zh_CN_default() {
  return {
    localeError: error45()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/zh-TW.js
var error46 = () => {
  const Sizable = {
    string: { unit: "\u5B57\u5143", verb: "\u64C1\u6709" },
    file: { unit: "\u4F4D\u5143\u7D44", verb: "\u64C1\u6709" },
    array: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" },
    set: { unit: "\u9805\u76EE", verb: "\u64C1\u6709" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u8F38\u5165",
    email: "\u90F5\u4EF6\u5730\u5740",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "ISO \u65E5\u671F\u6642\u9593",
    date: "ISO \u65E5\u671F",
    time: "ISO \u6642\u9593",
    duration: "ISO \u671F\u9593",
    ipv4: "IPv4 \u4F4D\u5740",
    ipv6: "IPv6 \u4F4D\u5740",
    cidrv4: "IPv4 \u7BC4\u570D",
    cidrv6: "IPv6 \u7BC4\u570D",
    base64: "base64 \u7DE8\u78BC\u5B57\u4E32",
    base64url: "base64url \u7DE8\u78BC\u5B57\u4E32",
    json_string: "JSON \u5B57\u4E32",
    e164: "E.164 \u6578\u503C",
    jwt: "JWT",
    template_literal: "\u8F38\u5165"
  };
  const TypeDictionary = {
    nan: "NaN"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA instanceof ${issue2.expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
        }
        return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${expected}\uFF0C\u4F46\u6536\u5230 ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\u7121\u6548\u7684\u8F38\u5165\u503C\uFF1A\u9810\u671F\u70BA ${stringifyPrimitive(issue2.values[0])}`;
        return `\u7121\u6548\u7684\u9078\u9805\uFF1A\u9810\u671F\u70BA\u4EE5\u4E0B\u5176\u4E2D\u4E4B\u4E00 ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue2.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()} ${sizing.unit ?? "\u500B\u5143\u7D20"}`;
        return `\u6578\u503C\u904E\u5927\uFF1A\u9810\u671F ${issue2.origin ?? "\u503C"} \u61C9\u70BA ${adj}${issue2.maximum.toString()}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing) {
          return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()} ${sizing.unit}`;
        }
        return `\u6578\u503C\u904E\u5C0F\uFF1A\u9810\u671F ${issue2.origin} \u61C9\u70BA ${adj}${issue2.minimum.toString()}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with") {
          return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.prefix}" \u958B\u982D`;
        }
        if (_issue.format === "ends_with")
          return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u4EE5 "${_issue.suffix}" \u7D50\u5C3E`;
        if (_issue.format === "includes")
          return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u5305\u542B "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u7121\u6548\u7684\u5B57\u4E32\uFF1A\u5FC5\u9808\u7B26\u5408\u683C\u5F0F ${_issue.pattern}`;
        return `\u7121\u6548\u7684 ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `\u7121\u6548\u7684\u6578\u5B57\uFF1A\u5FC5\u9808\u70BA ${issue2.divisor} \u7684\u500D\u6578`;
      case "unrecognized_keys":
        return `\u7121\u6CD5\u8B58\u5225\u7684\u9375\u503C${issue2.keys.length > 1 ? "\u5011" : ""}\uFF1A${joinValues(issue2.keys, "\u3001")}`;
      case "invalid_key":
        return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u9375\u503C`;
      case "invalid_union":
        return "\u7121\u6548\u7684\u8F38\u5165\u503C";
      case "invalid_element":
        return `${issue2.origin} \u4E2D\u6709\u7121\u6548\u7684\u503C`;
      default:
        return `\u7121\u6548\u7684\u8F38\u5165\u503C`;
    }
  };
};
function zh_TW_default() {
  return {
    localeError: error46()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/locales/yo.js
var error47 = () => {
  const Sizable = {
    string: { unit: "\xE0mi", verb: "n\xED" },
    file: { unit: "bytes", verb: "n\xED" },
    array: { unit: "nkan", verb: "n\xED" },
    set: { unit: "nkan", verb: "n\xED" }
  };
  function getSizing(origin) {
    return Sizable[origin] ?? null;
  }
  const FormatDictionary = {
    regex: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9",
    email: "\xE0d\xEDr\u1EB9\u0301s\xEC \xECm\u1EB9\u0301l\xEC",
    url: "URL",
    emoji: "emoji",
    uuid: "UUID",
    uuidv4: "UUIDv4",
    uuidv6: "UUIDv6",
    nanoid: "nanoid",
    guid: "GUID",
    cuid: "cuid",
    cuid2: "cuid2",
    ulid: "ULID",
    xid: "XID",
    ksuid: "KSUID",
    datetime: "\xE0k\xF3k\xF2 ISO",
    date: "\u1ECDj\u1ECD\u0301 ISO",
    time: "\xE0k\xF3k\xF2 ISO",
    duration: "\xE0k\xF3k\xF2 t\xF3 p\xE9 ISO",
    ipv4: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv4",
    ipv6: "\xE0d\xEDr\u1EB9\u0301s\xEC IPv6",
    cidrv4: "\xE0gb\xE8gb\xE8 IPv4",
    cidrv6: "\xE0gb\xE8gb\xE8 IPv6",
    base64: "\u1ECD\u0300r\u1ECD\u0300 t\xED a k\u1ECD\u0301 n\xED base64",
    base64url: "\u1ECD\u0300r\u1ECD\u0300 base64url",
    json_string: "\u1ECD\u0300r\u1ECD\u0300 JSON",
    e164: "n\u1ECD\u0301mb\xE0 E.164",
    jwt: "JWT",
    template_literal: "\u1EB9\u0300r\u1ECD \xECb\xE1w\u1ECDl\xE9"
  };
  const TypeDictionary = {
    nan: "NaN",
    number: "n\u1ECD\u0301mb\xE0",
    array: "akop\u1ECD"
  };
  return (issue2) => {
    switch (issue2.code) {
      case "invalid_type": {
        const expected = TypeDictionary[issue2.expected] ?? issue2.expected;
        const receivedType = parsedType(issue2.input);
        const received = TypeDictionary[receivedType] ?? receivedType;
        if (/^[A-Z]/.test(issue2.expected)) {
          return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi instanceof ${issue2.expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
        }
        return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${expected}, \xE0m\u1ECD\u0300 a r\xED ${received}`;
      }
      case "invalid_value":
        if (issue2.values.length === 1)
          return `\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e: a n\xED l\xE1ti fi ${stringifyPrimitive(issue2.values[0])}`;
        return `\xC0\u1E63\xE0y\xE0n a\u1E63\xEC\u1E63e: yan \u1ECD\u0300kan l\xE1ra ${joinValues(issue2.values, "|")}`;
      case "too_big": {
        const adj = issue2.inclusive ? "<=" : "<";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue2.origin ?? "iye"} ${sizing.verb} ${adj}${issue2.maximum} ${sizing.unit}`;
        return `T\xF3 p\u1ECD\u0300 j\xF9: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.maximum}`;
      }
      case "too_small": {
        const adj = issue2.inclusive ? ">=" : ">";
        const sizing = getSizing(issue2.origin);
        if (sizing)
          return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 p\xE9 ${issue2.origin} ${sizing.verb} ${adj}${issue2.minimum} ${sizing.unit}`;
        return `K\xE9r\xE9 ju: a n\xED l\xE1ti j\u1EB9\u0301 ${adj}${issue2.minimum}`;
      }
      case "invalid_format": {
        const _issue = issue2;
        if (_issue.format === "starts_with")
          return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\u1EB9\u0300r\u1EB9\u0300 p\u1EB9\u0300l\xFA "${_issue.prefix}"`;
        if (_issue.format === "ends_with")
          return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 par\xED p\u1EB9\u0300l\xFA "${_issue.suffix}"`;
        if (_issue.format === "includes")
          return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 n\xED "${_issue.includes}"`;
        if (_issue.format === "regex")
          return `\u1ECC\u0300r\u1ECD\u0300 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 b\xE1 \xE0p\u1EB9\u1EB9r\u1EB9 mu ${_issue.pattern}`;
        return `A\u1E63\xEC\u1E63e: ${FormatDictionary[_issue.format] ?? issue2.format}`;
      }
      case "not_multiple_of":
        return `N\u1ECD\u0301mb\xE0 a\u1E63\xEC\u1E63e: gb\u1ECD\u0301d\u1ECD\u0300 j\u1EB9\u0301 \xE8y\xE0 p\xEDp\xEDn ti ${issue2.divisor}`;
      case "unrecognized_keys":
        return `B\u1ECDt\xECn\xEC \xE0\xECm\u1ECD\u0300: ${joinValues(issue2.keys, ", ")}`;
      case "invalid_key":
        return `B\u1ECDt\xECn\xEC a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`;
      case "invalid_union":
        return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
      case "invalid_element":
        return `Iye a\u1E63\xEC\u1E63e n\xEDn\xFA ${issue2.origin}`;
      default:
        return "\xCCb\xE1w\u1ECDl\xE9 a\u1E63\xEC\u1E63e";
    }
  };
};
function yo_default() {
  return {
    localeError: error47()
  };
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/registries.js
var _a;
var $output = /* @__PURE__ */ Symbol("ZodOutput");
var $input = /* @__PURE__ */ Symbol("ZodInput");
var $ZodRegistry = class {
  constructor() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
  }
  add(schema, ..._meta) {
    const meta3 = _meta[0];
    this._map.set(schema, meta3);
    if (meta3 && typeof meta3 === "object" && "id" in meta3) {
      this._idmap.set(meta3.id, schema);
    }
    return this;
  }
  clear() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
    return this;
  }
  remove(schema) {
    const meta3 = this._map.get(schema);
    if (meta3 && typeof meta3 === "object" && "id" in meta3) {
      this._idmap.delete(meta3.id);
    }
    this._map.delete(schema);
    return this;
  }
  get(schema) {
    const p = schema._zod.parent;
    if (p) {
      const pm = { ...this.get(p) ?? {} };
      delete pm.id;
      const f = { ...pm, ...this._map.get(schema) };
      return Object.keys(f).length ? f : void 0;
    }
    return this._map.get(schema);
  }
  has(schema) {
    return this._map.has(schema);
  }
};
function registry() {
  return new $ZodRegistry();
}
(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
var globalRegistry = globalThis.__zod_globalRegistry;

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/api.js
// @__NO_SIDE_EFFECTS__
function _string(Class2, params) {
  return new Class2({
    type: "string",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedString(Class2, params) {
  return new Class2({
    type: "string",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _email(Class2, params) {
  return new Class2({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _guid(Class2, params) {
  return new Class2({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _url(Class2, params) {
  return new Class2({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _emoji2(Class2, params) {
  return new Class2({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class2, params) {
  return new Class2({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _xid(Class2, params) {
  return new Class2({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mac(Class2, params) {
  return new Class2({
    type: "string",
    format: "mac",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _e164(Class2, params) {
  return new Class2({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _jwt(Class2, params) {
  return new Class2({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
var TimePrecision = {
  Any: null,
  Minute: -1,
  Second: 0,
  Millisecond: 3,
  Microsecond: 6
};
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class2, params) {
  return new Class2({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class2, params) {
  return new Class2({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _number(Class2, params) {
  return new Class2({
    type: "number",
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedNumber(Class2, params) {
  return new Class2({
    type: "number",
    coerce: true,
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float32(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _float64(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "float64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int32(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "int32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint32(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "uint32",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _boolean(Class2, params) {
  return new Class2({
    type: "boolean",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBoolean(Class2, params) {
  return new Class2({
    type: "boolean",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _bigint(Class2, params) {
  return new Class2({
    type: "bigint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedBigint(Class2, params) {
  return new Class2({
    type: "bigint",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int64(Class2, params) {
  return new Class2({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "int64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uint64(Class2, params) {
  return new Class2({
    type: "bigint",
    check: "bigint_format",
    abort: false,
    format: "uint64",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _symbol(Class2, params) {
  return new Class2({
    type: "symbol",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _undefined2(Class2, params) {
  return new Class2({
    type: "undefined",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _null2(Class2, params) {
  return new Class2({
    type: "null",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _any(Class2) {
  return new Class2({
    type: "any"
  });
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class2) {
  return new Class2({
    type: "unknown"
  });
}
// @__NO_SIDE_EFFECTS__
function _never(Class2, params) {
  return new Class2({
    type: "never",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _void(Class2, params) {
  return new Class2({
    type: "void",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _date(Class2, params) {
  return new Class2({
    type: "date",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _coercedDate(Class2, params) {
  return new Class2({
    type: "date",
    coerce: true,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nan(Class2, params) {
  return new Class2({
    type: "nan",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _positive(params) {
  return /* @__PURE__ */ _gt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _negative(params) {
  return /* @__PURE__ */ _lt(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonpositive(params) {
  return /* @__PURE__ */ _lte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _nonnegative(params) {
  return /* @__PURE__ */ _gte(0, params);
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
  return new $ZodCheckMultipleOf({
    check: "multiple_of",
    ...normalizeParams(params),
    value
  });
}
// @__NO_SIDE_EFFECTS__
function _maxSize(maximum, params) {
  return new $ZodCheckMaxSize({
    check: "max_size",
    ...normalizeParams(params),
    maximum
  });
}
// @__NO_SIDE_EFFECTS__
function _minSize(minimum, params) {
  return new $ZodCheckMinSize({
    check: "min_size",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _size(size, params) {
  return new $ZodCheckSizeEquals({
    check: "size_equals",
    ...normalizeParams(params),
    size
  });
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
  const ch = new $ZodCheckMaxLength({
    check: "max_length",
    ...normalizeParams(params),
    maximum
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
  return new $ZodCheckMinLength({
    check: "min_length",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
  return new $ZodCheckLengthEquals({
    check: "length_equals",
    ...normalizeParams(params),
    length
  });
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
  return new $ZodCheckRegex({
    check: "string_format",
    format: "regex",
    ...normalizeParams(params),
    pattern
  });
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
  return new $ZodCheckLowerCase({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
  return new $ZodCheckUpperCase({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
  return new $ZodCheckIncludes({
    check: "string_format",
    format: "includes",
    ...normalizeParams(params),
    includes
  });
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
  return new $ZodCheckStartsWith({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams(params),
    prefix
  });
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
  return new $ZodCheckEndsWith({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams(params),
    suffix
  });
}
// @__NO_SIDE_EFFECTS__
function _property(property, schema, params) {
  return new $ZodCheckProperty({
    check: "property",
    property,
    schema,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _mime(types, params) {
  return new $ZodCheckMimeType({
    check: "mime_type",
    mime: types,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
  return new $ZodCheckOverwrite({
    check: "overwrite",
    tx
  });
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
  return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
  return /* @__PURE__ */ _overwrite((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
  return /* @__PURE__ */ _overwrite((input) => slugify(input));
}
// @__NO_SIDE_EFFECTS__
function _array(Class2, element, params) {
  return new Class2({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _union(Class2, options, params) {
  return new Class2({
    type: "union",
    options,
    ...normalizeParams(params)
  });
}
function _xor(Class2, options, params) {
  return new Class2({
    type: "union",
    options,
    inclusive: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _discriminatedUnion(Class2, discriminator, options, params) {
  return new Class2({
    type: "union",
    options,
    discriminator,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _intersection(Class2, left, right) {
  return new Class2({
    type: "intersection",
    left,
    right
  });
}
// @__NO_SIDE_EFFECTS__
function _tuple(Class2, items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new Class2({
    type: "tuple",
    items,
    rest,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _record(Class2, keyType, valueType, params) {
  return new Class2({
    type: "record",
    keyType,
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _map(Class2, keyType, valueType, params) {
  return new Class2({
    type: "map",
    keyType,
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _set(Class2, valueType, params) {
  return new Class2({
    type: "set",
    valueType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _enum(Class2, values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new Class2({
    type: "enum",
    entries,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nativeEnum(Class2, entries, params) {
  return new Class2({
    type: "enum",
    entries,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _literal(Class2, value, params) {
  return new Class2({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _file(Class2, params) {
  return new Class2({
    type: "file",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _transform(Class2, fn) {
  return new Class2({
    type: "transform",
    transform: fn
  });
}
// @__NO_SIDE_EFFECTS__
function _optional(Class2, innerType) {
  return new Class2({
    type: "optional",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _nullable(Class2, innerType) {
  return new Class2({
    type: "nullable",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _default(Class2, innerType, defaultValue) {
  return new Class2({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : shallowClone(defaultValue);
    }
  });
}
// @__NO_SIDE_EFFECTS__
function _nonoptional(Class2, innerType, params) {
  return new Class2({
    type: "nonoptional",
    innerType,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _success(Class2, innerType) {
  return new Class2({
    type: "success",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _catch(Class2, innerType, catchValue) {
  return new Class2({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
// @__NO_SIDE_EFFECTS__
function _pipe(Class2, in_, out) {
  return new Class2({
    type: "pipe",
    in: in_,
    out
  });
}
// @__NO_SIDE_EFFECTS__
function _readonly(Class2, innerType) {
  return new Class2({
    type: "readonly",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _templateLiteral(Class2, parts, params) {
  return new Class2({
    type: "template_literal",
    parts,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lazy(Class2, getter) {
  return new Class2({
    type: "lazy",
    getter
  });
}
// @__NO_SIDE_EFFECTS__
function _promise(Class2, innerType) {
  return new Class2({
    type: "promise",
    innerType
  });
}
// @__NO_SIDE_EFFECTS__
function _custom(Class2, fn, _params) {
  const norm = normalizeParams(_params);
  norm.abort ?? (norm.abort = true);
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...norm
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _refine(Class2, fn, _params) {
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams(_params)
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn) {
  const ch = /* @__PURE__ */ _check((payload) => {
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = ch);
        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
        payload.issues.push(issue(_issue));
      }
    };
    return fn(payload.value, payload);
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
  const ch = new $ZodCheck({
    check: "custom",
    ...normalizeParams(params)
  });
  ch._zod.check = fn;
  return ch;
}
// @__NO_SIDE_EFFECTS__
function describe(description) {
  const ch = new $ZodCheck({ check: "describe" });
  ch._zod.onattach = [
    (inst) => {
      const existing = globalRegistry.get(inst) ?? {};
      globalRegistry.add(inst, { ...existing, description });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function meta(metadata) {
  const ch = new $ZodCheck({ check: "meta" });
  ch._zod.onattach = [
    (inst) => {
      const existing = globalRegistry.get(inst) ?? {};
      globalRegistry.add(inst, { ...existing, ...metadata });
    }
  ];
  ch._zod.check = () => {
  };
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _stringbool(Classes, _params) {
  const params = normalizeParams(_params);
  let truthyArray = params.truthy ?? ["true", "1", "yes", "on", "y", "enabled"];
  let falsyArray = params.falsy ?? ["false", "0", "no", "off", "n", "disabled"];
  if (params.case !== "sensitive") {
    truthyArray = truthyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
    falsyArray = falsyArray.map((v) => typeof v === "string" ? v.toLowerCase() : v);
  }
  const truthySet = new Set(truthyArray);
  const falsySet = new Set(falsyArray);
  const _Codec = Classes.Codec ?? $ZodCodec;
  const _Boolean = Classes.Boolean ?? $ZodBoolean;
  const _String = Classes.String ?? $ZodString;
  const stringSchema = new _String({ type: "string", error: params.error });
  const booleanSchema = new _Boolean({ type: "boolean", error: params.error });
  const codec2 = new _Codec({
    type: "pipe",
    in: stringSchema,
    out: booleanSchema,
    transform: ((input, payload) => {
      let data = input;
      if (params.case !== "sensitive")
        data = data.toLowerCase();
      if (truthySet.has(data)) {
        return true;
      } else if (falsySet.has(data)) {
        return false;
      } else {
        payload.issues.push({
          code: "invalid_value",
          expected: "stringbool",
          values: [...truthySet, ...falsySet],
          input: payload.value,
          inst: codec2,
          continue: false
        });
        return {};
      }
    }),
    reverseTransform: ((input, _payload) => {
      if (input === true) {
        return truthyArray[0] || "true";
      } else {
        return falsyArray[0] || "false";
      }
    }),
    error: params.error
  });
  return codec2;
}
// @__NO_SIDE_EFFECTS__
function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
  const params = normalizeParams(_params);
  const def = {
    ...normalizeParams(_params),
    check: "string_format",
    type: "string",
    format,
    fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
    ...params
  };
  if (fnOrRegex instanceof RegExp) {
    def.pattern = fnOrRegex;
  }
  const inst = new Class2(def);
  return inst;
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/to-json-schema.js
function initializeContext(params) {
  let target = params?.target ?? "draft-2020-12";
  if (target === "draft-4")
    target = "draft-04";
  if (target === "draft-7")
    target = "draft-07";
  return {
    processors: params.processors ?? {},
    metadataRegistry: params?.metadata ?? globalRegistry,
    target,
    unrepresentable: params?.unrepresentable ?? "throw",
    override: params?.override ?? (() => {
    }),
    io: params?.io ?? "output",
    counter: 0,
    seen: /* @__PURE__ */ new Map(),
    cycles: params?.cycles ?? "ref",
    reused: params?.reused ?? "inline",
    external: params?.external ?? void 0
  };
}
function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
  var _a2;
  const def = schema._zod.def;
  const seen = ctx.seen.get(schema);
  if (seen) {
    seen.count++;
    const isCycle = _params.schemaPath.includes(schema);
    if (isCycle) {
      seen.cycle = _params.path;
    }
    return seen.schema;
  }
  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
  ctx.seen.set(schema, result);
  const overrideSchema = schema._zod.toJSONSchema?.();
  if (overrideSchema) {
    result.schema = overrideSchema;
  } else {
    const params = {
      ..._params,
      schemaPath: [..._params.schemaPath, schema],
      path: _params.path
    };
    if (schema._zod.processJSONSchema) {
      schema._zod.processJSONSchema(ctx, result.schema, params);
    } else {
      const _json = result.schema;
      const processor = ctx.processors[def.type];
      if (!processor) {
        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
      }
      processor(schema, ctx, _json, params);
    }
    const parent = schema._zod.parent;
    if (parent) {
      if (!result.ref)
        result.ref = parent;
      process(parent, ctx, params);
      ctx.seen.get(parent).isParent = true;
    }
  }
  const meta3 = ctx.metadataRegistry.get(schema);
  if (meta3)
    Object.assign(result.schema, meta3);
  if (ctx.io === "input" && isTransforming(schema)) {
    delete result.schema.examples;
    delete result.schema.default;
  }
  if (ctx.io === "input" && result.schema._prefault)
    (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
  delete result.schema._prefault;
  const _result = ctx.seen.get(schema);
  return _result.schema;
}
function extractDefs(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const idToSchema = /* @__PURE__ */ new Map();
  for (const entry of ctx.seen.entries()) {
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      const existing = idToSchema.get(id);
      if (existing && existing !== entry[0]) {
        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
      }
      idToSchema.set(id, entry[0]);
    }
  }
  const makeURI = (entry) => {
    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
    if (ctx.external) {
      const externalId = ctx.external.registry.get(entry[0])?.id;
      const uriGenerator = ctx.external.uri ?? ((id2) => id2);
      if (externalId) {
        return { ref: uriGenerator(externalId) };
      }
      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
      entry[1].defId = id;
      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
    }
    if (entry[1] === root) {
      return { ref: "#" };
    }
    const uriPrefix = `#`;
    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
    return { defId, ref: defUriPrefix + defId };
  };
  const extractToDef = (entry) => {
    if (entry[1].schema.$ref) {
      return;
    }
    const seen = entry[1];
    const { ref, defId } = makeURI(entry);
    seen.def = { ...seen.schema };
    if (defId)
      seen.defId = defId;
    const schema2 = seen.schema;
    for (const key in schema2) {
      delete schema2[key];
    }
    schema2.$ref = ref;
  };
  if (ctx.cycles === "throw") {
    for (const entry of ctx.seen.entries()) {
      const seen = entry[1];
      if (seen.cycle) {
        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
      }
    }
  }
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (schema === entry[0]) {
      extractToDef(entry);
      continue;
    }
    if (ctx.external) {
      const ext = ctx.external.registry.get(entry[0])?.id;
      if (schema !== entry[0] && ext) {
        extractToDef(entry);
        continue;
      }
    }
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      extractToDef(entry);
      continue;
    }
    if (seen.cycle) {
      extractToDef(entry);
      continue;
    }
    if (seen.count > 1) {
      if (ctx.reused === "ref") {
        extractToDef(entry);
        continue;
      }
    }
  }
}
function finalize(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const flattenRef = (zodSchema) => {
    const seen = ctx.seen.get(zodSchema);
    if (seen.ref === null)
      return;
    const schema2 = seen.def ?? seen.schema;
    const _cached = { ...schema2 };
    const ref = seen.ref;
    seen.ref = null;
    if (ref) {
      flattenRef(ref);
      const refSeen = ctx.seen.get(ref);
      const refSchema = refSeen.schema;
      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
        schema2.allOf = schema2.allOf ?? [];
        schema2.allOf.push(refSchema);
      } else {
        Object.assign(schema2, refSchema);
      }
      Object.assign(schema2, _cached);
      const isParentRef = zodSchema._zod.parent === ref;
      if (isParentRef) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (!(key in _cached)) {
            delete schema2[key];
          }
        }
      }
      if (refSchema.$ref) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
            delete schema2[key];
          }
        }
      }
    }
    const parent = zodSchema._zod.parent;
    if (parent && parent !== ref) {
      flattenRef(parent);
      const parentSeen = ctx.seen.get(parent);
      if (parentSeen?.schema.$ref) {
        schema2.$ref = parentSeen.schema.$ref;
        if (parentSeen.def) {
          for (const key in schema2) {
            if (key === "$ref" || key === "allOf")
              continue;
            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
              delete schema2[key];
            }
          }
        }
      }
    }
    ctx.override({
      zodSchema,
      jsonSchema: schema2,
      path: seen.path ?? []
    });
  };
  for (const entry of [...ctx.seen.entries()].reverse()) {
    flattenRef(entry[0]);
  }
  const result = {};
  if (ctx.target === "draft-2020-12") {
    result.$schema = "https://json-schema.org/draft/2020-12/schema";
  } else if (ctx.target === "draft-07") {
    result.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (ctx.target === "draft-04") {
    result.$schema = "http://json-schema.org/draft-04/schema#";
  } else if (ctx.target === "openapi-3.0") {
  } else {
  }
  if (ctx.external?.uri) {
    const id = ctx.external.registry.get(schema)?.id;
    if (!id)
      throw new Error("Schema is missing an `id` property");
    result.$id = ctx.external.uri(id);
  }
  Object.assign(result, root.def ?? root.schema);
  const defs = ctx.external?.defs ?? {};
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (seen.def && seen.defId) {
      defs[seen.defId] = seen.def;
    }
  }
  if (ctx.external) {
  } else {
    if (Object.keys(defs).length > 0) {
      if (ctx.target === "draft-2020-12") {
        result.$defs = defs;
      } else {
        result.definitions = defs;
      }
    }
  }
  try {
    const finalized = JSON.parse(JSON.stringify(result));
    Object.defineProperty(finalized, "~standard", {
      value: {
        ...schema["~standard"],
        jsonSchema: {
          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
        }
      },
      enumerable: false,
      writable: false
    });
    return finalized;
  } catch (_err) {
    throw new Error("Error converting schema to JSON.");
  }
}
function isTransforming(_schema, _ctx) {
  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const def = _schema._zod.def;
  if (def.type === "transform")
    return true;
  if (def.type === "array")
    return isTransforming(def.element, ctx);
  if (def.type === "set")
    return isTransforming(def.valueType, ctx);
  if (def.type === "lazy")
    return isTransforming(def.getter(), ctx);
  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
    return isTransforming(def.innerType, ctx);
  }
  if (def.type === "intersection") {
    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
  }
  if (def.type === "record" || def.type === "map") {
    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
  }
  if (def.type === "pipe") {
    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
  }
  if (def.type === "object") {
    for (const key in def.shape) {
      if (isTransforming(def.shape[key], ctx))
        return true;
    }
    return false;
  }
  if (def.type === "union") {
    for (const option of def.options) {
      if (isTransforming(option, ctx))
        return true;
    }
    return false;
  }
  if (def.type === "tuple") {
    for (const item of def.items) {
      if (isTransforming(item, ctx))
        return true;
    }
    if (def.rest && isTransforming(def.rest, ctx))
      return true;
    return false;
  }
  return false;
}
var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
  const ctx = initializeContext({ ...params, processors });
  process(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};
var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
  const { libraryOptions, target } = params ?? {};
  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
  process(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/json-schema-processors.js
var formatMap = {
  guid: "uuid",
  url: "uri",
  datetime: "date-time",
  json_string: "json-string",
  regex: ""
  // do not set
};
var stringProcessor = (schema, ctx, _json, _params) => {
  const json2 = _json;
  json2.type = "string";
  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
  if (typeof minimum === "number")
    json2.minLength = minimum;
  if (typeof maximum === "number")
    json2.maxLength = maximum;
  if (format) {
    json2.format = formatMap[format] ?? format;
    if (json2.format === "")
      delete json2.format;
    if (format === "time") {
      delete json2.format;
    }
  }
  if (contentEncoding)
    json2.contentEncoding = contentEncoding;
  if (patterns && patterns.size > 0) {
    const regexes = [...patterns];
    if (regexes.length === 1)
      json2.pattern = regexes[0].source;
    else if (regexes.length > 1) {
      json2.allOf = [
        ...regexes.map((regex) => ({
          ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
          pattern: regex.source
        }))
      ];
    }
  }
};
var numberProcessor = (schema, ctx, _json, _params) => {
  const json2 = _json;
  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
  if (typeof format === "string" && format.includes("int"))
    json2.type = "integer";
  else
    json2.type = "number";
  if (typeof exclusiveMinimum === "number") {
    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
      json2.minimum = exclusiveMinimum;
      json2.exclusiveMinimum = true;
    } else {
      json2.exclusiveMinimum = exclusiveMinimum;
    }
  }
  if (typeof minimum === "number") {
    json2.minimum = minimum;
    if (typeof exclusiveMinimum === "number" && ctx.target !== "draft-04") {
      if (exclusiveMinimum >= minimum)
        delete json2.minimum;
      else
        delete json2.exclusiveMinimum;
    }
  }
  if (typeof exclusiveMaximum === "number") {
    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
      json2.maximum = exclusiveMaximum;
      json2.exclusiveMaximum = true;
    } else {
      json2.exclusiveMaximum = exclusiveMaximum;
    }
  }
  if (typeof maximum === "number") {
    json2.maximum = maximum;
    if (typeof exclusiveMaximum === "number" && ctx.target !== "draft-04") {
      if (exclusiveMaximum <= maximum)
        delete json2.maximum;
      else
        delete json2.exclusiveMaximum;
    }
  }
  if (typeof multipleOf === "number")
    json2.multipleOf = multipleOf;
};
var booleanProcessor = (_schema, _ctx, json2, _params) => {
  json2.type = "boolean";
};
var bigintProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("BigInt cannot be represented in JSON Schema");
  }
};
var symbolProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Symbols cannot be represented in JSON Schema");
  }
};
var nullProcessor = (_schema, ctx, json2, _params) => {
  if (ctx.target === "openapi-3.0") {
    json2.type = "string";
    json2.nullable = true;
    json2.enum = [null];
  } else {
    json2.type = "null";
  }
};
var undefinedProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Undefined cannot be represented in JSON Schema");
  }
};
var voidProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Void cannot be represented in JSON Schema");
  }
};
var neverProcessor = (_schema, _ctx, json2, _params) => {
  json2.not = {};
};
var anyProcessor = (_schema, _ctx, _json, _params) => {
};
var unknownProcessor = (_schema, _ctx, _json, _params) => {
};
var dateProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Date cannot be represented in JSON Schema");
  }
};
var enumProcessor = (schema, _ctx, json2, _params) => {
  const def = schema._zod.def;
  const values = getEnumValues(def.entries);
  if (values.every((v) => typeof v === "number"))
    json2.type = "number";
  if (values.every((v) => typeof v === "string"))
    json2.type = "string";
  json2.enum = values;
};
var literalProcessor = (schema, ctx, json2, _params) => {
  const def = schema._zod.def;
  const vals = [];
  for (const val of def.values) {
    if (val === void 0) {
      if (ctx.unrepresentable === "throw") {
        throw new Error("Literal `undefined` cannot be represented in JSON Schema");
      } else {
      }
    } else if (typeof val === "bigint") {
      if (ctx.unrepresentable === "throw") {
        throw new Error("BigInt literals cannot be represented in JSON Schema");
      } else {
        vals.push(Number(val));
      }
    } else {
      vals.push(val);
    }
  }
  if (vals.length === 0) {
  } else if (vals.length === 1) {
    const val = vals[0];
    json2.type = val === null ? "null" : typeof val;
    if (ctx.target === "draft-04" || ctx.target === "openapi-3.0") {
      json2.enum = [val];
    } else {
      json2.const = val;
    }
  } else {
    if (vals.every((v) => typeof v === "number"))
      json2.type = "number";
    if (vals.every((v) => typeof v === "string"))
      json2.type = "string";
    if (vals.every((v) => typeof v === "boolean"))
      json2.type = "boolean";
    if (vals.every((v) => v === null))
      json2.type = "null";
    json2.enum = vals;
  }
};
var nanProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("NaN cannot be represented in JSON Schema");
  }
};
var templateLiteralProcessor = (schema, _ctx, json2, _params) => {
  const _json = json2;
  const pattern = schema._zod.pattern;
  if (!pattern)
    throw new Error("Pattern not found in template literal");
  _json.type = "string";
  _json.pattern = pattern.source;
};
var fileProcessor = (schema, _ctx, json2, _params) => {
  const _json = json2;
  const file2 = {
    type: "string",
    format: "binary",
    contentEncoding: "binary"
  };
  const { minimum, maximum, mime } = schema._zod.bag;
  if (minimum !== void 0)
    file2.minLength = minimum;
  if (maximum !== void 0)
    file2.maxLength = maximum;
  if (mime) {
    if (mime.length === 1) {
      file2.contentMediaType = mime[0];
      Object.assign(_json, file2);
    } else {
      Object.assign(_json, file2);
      _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
    }
  } else {
    Object.assign(_json, file2);
  }
};
var successProcessor = (_schema, _ctx, json2, _params) => {
  json2.type = "boolean";
};
var customProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Custom types cannot be represented in JSON Schema");
  }
};
var functionProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Function types cannot be represented in JSON Schema");
  }
};
var transformProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Transforms cannot be represented in JSON Schema");
  }
};
var mapProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Map cannot be represented in JSON Schema");
  }
};
var setProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Set cannot be represented in JSON Schema");
  }
};
var arrayProcessor = (schema, ctx, _json, params) => {
  const json2 = _json;
  const def = schema._zod.def;
  const { minimum, maximum } = schema._zod.bag;
  if (typeof minimum === "number")
    json2.minItems = minimum;
  if (typeof maximum === "number")
    json2.maxItems = maximum;
  json2.type = "array";
  json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
};
var objectProcessor = (schema, ctx, _json, params) => {
  const json2 = _json;
  const def = schema._zod.def;
  json2.type = "object";
  json2.properties = {};
  const shape = def.shape;
  for (const key in shape) {
    json2.properties[key] = process(shape[key], ctx, {
      ...params,
      path: [...params.path, "properties", key]
    });
  }
  const allKeys = new Set(Object.keys(shape));
  const requiredKeys = new Set([...allKeys].filter((key) => {
    const v = def.shape[key]._zod;
    if (ctx.io === "input") {
      return v.optin === void 0;
    } else {
      return v.optout === void 0;
    }
  }));
  if (requiredKeys.size > 0) {
    json2.required = Array.from(requiredKeys);
  }
  if (def.catchall?._zod.def.type === "never") {
    json2.additionalProperties = false;
  } else if (!def.catchall) {
    if (ctx.io === "output")
      json2.additionalProperties = false;
  } else if (def.catchall) {
    json2.additionalProperties = process(def.catchall, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
};
var unionProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  const isExclusive = def.inclusive === false;
  const options = def.options.map((x, i) => process(x, ctx, {
    ...params,
    path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
  }));
  if (isExclusive) {
    json2.oneOf = options;
  } else {
    json2.anyOf = options;
  }
};
var intersectionProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  const a = process(def.left, ctx, {
    ...params,
    path: [...params.path, "allOf", 0]
  });
  const b = process(def.right, ctx, {
    ...params,
    path: [...params.path, "allOf", 1]
  });
  const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
  const allOf = [
    ...isSimpleIntersection(a) ? a.allOf : [a],
    ...isSimpleIntersection(b) ? b.allOf : [b]
  ];
  json2.allOf = allOf;
};
var tupleProcessor = (schema, ctx, _json, params) => {
  const json2 = _json;
  const def = schema._zod.def;
  json2.type = "array";
  const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
  const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
  const prefixItems = def.items.map((x, i) => process(x, ctx, {
    ...params,
    path: [...params.path, prefixPath, i]
  }));
  const rest = def.rest ? process(def.rest, ctx, {
    ...params,
    path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
  }) : null;
  if (ctx.target === "draft-2020-12") {
    json2.prefixItems = prefixItems;
    if (rest) {
      json2.items = rest;
    }
  } else if (ctx.target === "openapi-3.0") {
    json2.items = {
      anyOf: prefixItems
    };
    if (rest) {
      json2.items.anyOf.push(rest);
    }
    json2.minItems = prefixItems.length;
    if (!rest) {
      json2.maxItems = prefixItems.length;
    }
  } else {
    json2.items = prefixItems;
    if (rest) {
      json2.additionalItems = rest;
    }
  }
  const { minimum, maximum } = schema._zod.bag;
  if (typeof minimum === "number")
    json2.minItems = minimum;
  if (typeof maximum === "number")
    json2.maxItems = maximum;
};
var recordProcessor = (schema, ctx, _json, params) => {
  const json2 = _json;
  const def = schema._zod.def;
  json2.type = "object";
  const keyType = def.keyType;
  const keyBag = keyType._zod.bag;
  const patterns = keyBag?.patterns;
  if (def.mode === "loose" && patterns && patterns.size > 0) {
    const valueSchema = process(def.valueType, ctx, {
      ...params,
      path: [...params.path, "patternProperties", "*"]
    });
    json2.patternProperties = {};
    for (const pattern of patterns) {
      json2.patternProperties[pattern.source] = valueSchema;
    }
  } else {
    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
      json2.propertyNames = process(def.keyType, ctx, {
        ...params,
        path: [...params.path, "propertyNames"]
      });
    }
    json2.additionalProperties = process(def.valueType, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
  const keyValues = keyType._zod.values;
  if (keyValues) {
    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
    if (validKeyValues.length > 0) {
      json2.required = validKeyValues;
    }
  }
};
var nullableProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  const inner = process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  if (ctx.target === "openapi-3.0") {
    seen.ref = def.innerType;
    json2.nullable = true;
  } else {
    json2.anyOf = [inner, { type: "null" }];
  }
};
var nonoptionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};
var defaultProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json2.default = JSON.parse(JSON.stringify(def.defaultValue));
};
var prefaultProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  if (ctx.io === "input")
    json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
};
var catchProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  let catchValue;
  try {
    catchValue = def.catchValue(void 0);
  } catch {
    throw new Error("Dynamic catch values are not supported in JSON Schema");
  }
  json2.default = catchValue;
};
var pipeProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
  process(innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = innerType;
};
var readonlyProcessor = (schema, ctx, json2, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json2.readOnly = true;
};
var promiseProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};
var optionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};
var lazyProcessor = (schema, ctx, _json, params) => {
  const innerType = schema._zod.innerType;
  process(innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = innerType;
};
var allProcessors = {
  string: stringProcessor,
  number: numberProcessor,
  boolean: booleanProcessor,
  bigint: bigintProcessor,
  symbol: symbolProcessor,
  null: nullProcessor,
  undefined: undefinedProcessor,
  void: voidProcessor,
  never: neverProcessor,
  any: anyProcessor,
  unknown: unknownProcessor,
  date: dateProcessor,
  enum: enumProcessor,
  literal: literalProcessor,
  nan: nanProcessor,
  template_literal: templateLiteralProcessor,
  file: fileProcessor,
  success: successProcessor,
  custom: customProcessor,
  function: functionProcessor,
  transform: transformProcessor,
  map: mapProcessor,
  set: setProcessor,
  array: arrayProcessor,
  object: objectProcessor,
  union: unionProcessor,
  intersection: intersectionProcessor,
  tuple: tupleProcessor,
  record: recordProcessor,
  nullable: nullableProcessor,
  nonoptional: nonoptionalProcessor,
  default: defaultProcessor,
  prefault: prefaultProcessor,
  catch: catchProcessor,
  pipe: pipeProcessor,
  readonly: readonlyProcessor,
  promise: promiseProcessor,
  optional: optionalProcessor,
  lazy: lazyProcessor
};
function toJSONSchema(input, params) {
  if ("_idmap" in input) {
    const registry2 = input;
    const ctx2 = initializeContext({ ...params, processors: allProcessors });
    const defs = {};
    for (const entry of registry2._idmap.entries()) {
      const [_, schema] = entry;
      process(schema, ctx2);
    }
    const schemas = {};
    const external = {
      registry: registry2,
      uri: params?.uri,
      defs
    };
    ctx2.external = external;
    for (const entry of registry2._idmap.entries()) {
      const [key, schema] = entry;
      extractDefs(ctx2, schema);
      schemas[key] = finalize(ctx2, schema);
    }
    if (Object.keys(defs).length > 0) {
      const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
      schemas.__shared = {
        [defsSegment]: defs
      };
    }
    return { schemas };
  }
  const ctx = initializeContext({ ...params, processors: allProcessors });
  process(input, ctx);
  extractDefs(ctx, input);
  return finalize(ctx, input);
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/json-schema-generator.js
var JSONSchemaGenerator = class {
  /** @deprecated Access via ctx instead */
  get metadataRegistry() {
    return this.ctx.metadataRegistry;
  }
  /** @deprecated Access via ctx instead */
  get target() {
    return this.ctx.target;
  }
  /** @deprecated Access via ctx instead */
  get unrepresentable() {
    return this.ctx.unrepresentable;
  }
  /** @deprecated Access via ctx instead */
  get override() {
    return this.ctx.override;
  }
  /** @deprecated Access via ctx instead */
  get io() {
    return this.ctx.io;
  }
  /** @deprecated Access via ctx instead */
  get counter() {
    return this.ctx.counter;
  }
  set counter(value) {
    this.ctx.counter = value;
  }
  /** @deprecated Access via ctx instead */
  get seen() {
    return this.ctx.seen;
  }
  constructor(params) {
    let normalizedTarget = params?.target ?? "draft-2020-12";
    if (normalizedTarget === "draft-4")
      normalizedTarget = "draft-04";
    if (normalizedTarget === "draft-7")
      normalizedTarget = "draft-07";
    this.ctx = initializeContext({
      processors: allProcessors,
      target: normalizedTarget,
      ...params?.metadata && { metadata: params.metadata },
      ...params?.unrepresentable && { unrepresentable: params.unrepresentable },
      ...params?.override && { override: params.override },
      ...params?.io && { io: params.io }
    });
  }
  /**
   * Process a schema to prepare it for JSON Schema generation.
   * This must be called before emit().
   */
  process(schema, _params = { path: [], schemaPath: [] }) {
    return process(schema, this.ctx, _params);
  }
  /**
   * Emit the final JSON Schema after processing.
   * Must call process() first.
   */
  emit(schema, _params) {
    if (_params) {
      if (_params.cycles)
        this.ctx.cycles = _params.cycles;
      if (_params.reused)
        this.ctx.reused = _params.reused;
      if (_params.external)
        this.ctx.external = _params.external;
    }
    extractDefs(this.ctx, schema);
    const result = finalize(this.ctx, schema);
    const { "~standard": _, ...plainResult } = result;
    return plainResult;
  }
};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/core/json-schema.js
var json_schema_exports = {};

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/schemas.js
var schemas_exports2 = {};
__export(schemas_exports2, {
  ZodAny: () => ZodAny,
  ZodArray: () => ZodArray,
  ZodBase64: () => ZodBase64,
  ZodBase64URL: () => ZodBase64URL,
  ZodBigInt: () => ZodBigInt,
  ZodBigIntFormat: () => ZodBigIntFormat,
  ZodBoolean: () => ZodBoolean,
  ZodCIDRv4: () => ZodCIDRv4,
  ZodCIDRv6: () => ZodCIDRv6,
  ZodCUID: () => ZodCUID,
  ZodCUID2: () => ZodCUID2,
  ZodCatch: () => ZodCatch,
  ZodCodec: () => ZodCodec,
  ZodCustom: () => ZodCustom,
  ZodCustomStringFormat: () => ZodCustomStringFormat,
  ZodDate: () => ZodDate,
  ZodDefault: () => ZodDefault,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
  ZodE164: () => ZodE164,
  ZodEmail: () => ZodEmail,
  ZodEmoji: () => ZodEmoji,
  ZodEnum: () => ZodEnum,
  ZodExactOptional: () => ZodExactOptional,
  ZodFile: () => ZodFile,
  ZodFunction: () => ZodFunction,
  ZodGUID: () => ZodGUID,
  ZodIPv4: () => ZodIPv4,
  ZodIPv6: () => ZodIPv6,
  ZodIntersection: () => ZodIntersection,
  ZodJWT: () => ZodJWT,
  ZodKSUID: () => ZodKSUID,
  ZodLazy: () => ZodLazy,
  ZodLiteral: () => ZodLiteral,
  ZodMAC: () => ZodMAC,
  ZodMap: () => ZodMap,
  ZodNaN: () => ZodNaN,
  ZodNanoID: () => ZodNanoID,
  ZodNever: () => ZodNever,
  ZodNonOptional: () => ZodNonOptional,
  ZodNull: () => ZodNull,
  ZodNullable: () => ZodNullable,
  ZodNumber: () => ZodNumber,
  ZodNumberFormat: () => ZodNumberFormat,
  ZodObject: () => ZodObject,
  ZodOptional: () => ZodOptional,
  ZodPipe: () => ZodPipe,
  ZodPrefault: () => ZodPrefault,
  ZodPromise: () => ZodPromise,
  ZodReadonly: () => ZodReadonly,
  ZodRecord: () => ZodRecord,
  ZodSet: () => ZodSet,
  ZodString: () => ZodString,
  ZodStringFormat: () => ZodStringFormat,
  ZodSuccess: () => ZodSuccess,
  ZodSymbol: () => ZodSymbol,
  ZodTemplateLiteral: () => ZodTemplateLiteral,
  ZodTransform: () => ZodTransform,
  ZodTuple: () => ZodTuple,
  ZodType: () => ZodType,
  ZodULID: () => ZodULID,
  ZodURL: () => ZodURL,
  ZodUUID: () => ZodUUID,
  ZodUndefined: () => ZodUndefined,
  ZodUnion: () => ZodUnion,
  ZodUnknown: () => ZodUnknown,
  ZodVoid: () => ZodVoid,
  ZodXID: () => ZodXID,
  ZodXor: () => ZodXor,
  _ZodString: () => _ZodString,
  _default: () => _default2,
  _function: () => _function,
  any: () => any,
  array: () => array,
  base64: () => base642,
  base64url: () => base64url2,
  bigint: () => bigint2,
  boolean: () => boolean2,
  catch: () => _catch2,
  check: () => check,
  cidrv4: () => cidrv42,
  cidrv6: () => cidrv62,
  codec: () => codec,
  cuid: () => cuid3,
  cuid2: () => cuid22,
  custom: () => custom,
  date: () => date3,
  describe: () => describe2,
  discriminatedUnion: () => discriminatedUnion,
  e164: () => e1642,
  email: () => email2,
  emoji: () => emoji2,
  enum: () => _enum2,
  exactOptional: () => exactOptional,
  file: () => file,
  float32: () => float32,
  float64: () => float64,
  function: () => _function,
  guid: () => guid2,
  hash: () => hash,
  hex: () => hex2,
  hostname: () => hostname2,
  httpUrl: () => httpUrl,
  instanceof: () => _instanceof,
  int: () => int,
  int32: () => int32,
  int64: () => int64,
  intersection: () => intersection,
  ipv4: () => ipv42,
  ipv6: () => ipv62,
  json: () => json,
  jwt: () => jwt,
  keyof: () => keyof,
  ksuid: () => ksuid2,
  lazy: () => lazy,
  literal: () => literal,
  looseObject: () => looseObject,
  looseRecord: () => looseRecord,
  mac: () => mac2,
  map: () => map,
  meta: () => meta2,
  nan: () => nan,
  nanoid: () => nanoid2,
  nativeEnum: () => nativeEnum,
  never: () => never,
  nonoptional: () => nonoptional,
  null: () => _null3,
  nullable: () => nullable,
  nullish: () => nullish2,
  number: () => number2,
  object: () => object,
  optional: () => optional,
  partialRecord: () => partialRecord,
  pipe: () => pipe,
  prefault: () => prefault,
  preprocess: () => preprocess,
  promise: () => promise,
  readonly: () => readonly,
  record: () => record,
  refine: () => refine,
  set: () => set,
  strictObject: () => strictObject,
  string: () => string2,
  stringFormat: () => stringFormat,
  stringbool: () => stringbool,
  success: () => success,
  superRefine: () => superRefine,
  symbol: () => symbol,
  templateLiteral: () => templateLiteral,
  transform: () => transform,
  tuple: () => tuple,
  uint32: () => uint32,
  uint64: () => uint64,
  ulid: () => ulid2,
  undefined: () => _undefined3,
  union: () => union,
  unknown: () => unknown,
  url: () => url,
  uuid: () => uuid2,
  uuidv4: () => uuidv4,
  uuidv6: () => uuidv6,
  uuidv7: () => uuidv7,
  void: () => _void2,
  xid: () => xid2,
  xor: () => xor
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/checks.js
var checks_exports2 = {};
__export(checks_exports2, {
  endsWith: () => _endsWith,
  gt: () => _gt,
  gte: () => _gte,
  includes: () => _includes,
  length: () => _length,
  lowercase: () => _lowercase,
  lt: () => _lt,
  lte: () => _lte,
  maxLength: () => _maxLength,
  maxSize: () => _maxSize,
  mime: () => _mime,
  minLength: () => _minLength,
  minSize: () => _minSize,
  multipleOf: () => _multipleOf,
  negative: () => _negative,
  nonnegative: () => _nonnegative,
  nonpositive: () => _nonpositive,
  normalize: () => _normalize,
  overwrite: () => _overwrite,
  positive: () => _positive,
  property: () => _property,
  regex: () => _regex,
  size: () => _size,
  slugify: () => _slugify,
  startsWith: () => _startsWith,
  toLowerCase: () => _toLowerCase,
  toUpperCase: () => _toUpperCase,
  trim: () => _trim,
  uppercase: () => _uppercase
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/iso.js
var iso_exports = {};
__export(iso_exports, {
  ZodISODate: () => ZodISODate,
  ZodISODateTime: () => ZodISODateTime,
  ZodISODuration: () => ZodISODuration,
  ZodISOTime: () => ZodISOTime,
  date: () => date2,
  datetime: () => datetime2,
  duration: () => duration2,
  time: () => time2
});
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
  $ZodISODateTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function datetime2(params) {
  return _isoDateTime(ZodISODateTime, params);
}
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
  $ZodISODate.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function date2(params) {
  return _isoDate(ZodISODate, params);
}
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
  $ZodISOTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function time2(params) {
  return _isoTime(ZodISOTime, params);
}
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
  $ZodISODuration.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function duration2(params) {
  return _isoDuration(ZodISODuration, params);
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/errors.js
var initializer2 = (inst, issues) => {
  $ZodError.init(inst, issues);
  inst.name = "ZodError";
  Object.defineProperties(inst, {
    format: {
      value: (mapper) => formatError(inst, mapper)
      // enumerable: false,
    },
    flatten: {
      value: (mapper) => flattenError(inst, mapper)
      // enumerable: false,
    },
    addIssue: {
      value: (issue2) => {
        inst.issues.push(issue2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    addIssues: {
      value: (issues2) => {
        inst.issues.push(...issues2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    isEmpty: {
      get() {
        return inst.issues.length === 0;
      }
      // enumerable: false,
    }
  });
};
var ZodError = $constructor("ZodError", initializer2);
var ZodRealError = $constructor("ZodError", initializer2, {
  Parent: Error
});

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/parse.js
var parse2 = /* @__PURE__ */ _parse(ZodRealError);
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
var encode2 = /* @__PURE__ */ _encode(ZodRealError);
var decode2 = /* @__PURE__ */ _decode(ZodRealError);
var encodeAsync2 = /* @__PURE__ */ _encodeAsync(ZodRealError);
var decodeAsync2 = /* @__PURE__ */ _decodeAsync(ZodRealError);
var safeEncode2 = /* @__PURE__ */ _safeEncode(ZodRealError);
var safeDecode2 = /* @__PURE__ */ _safeDecode(ZodRealError);
var safeEncodeAsync2 = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
var safeDecodeAsync2 = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/schemas.js
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
  $ZodType.init(inst, def);
  Object.assign(inst["~standard"], {
    jsonSchema: {
      input: createStandardJSONSchemaMethod(inst, "input"),
      output: createStandardJSONSchemaMethod(inst, "output")
    }
  });
  inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
  inst.def = def;
  inst.type = def.type;
  Object.defineProperty(inst, "_def", { value: def });
  inst.check = (...checks) => {
    return inst.clone(util_exports.mergeDefs(def, {
      checks: [
        ...def.checks ?? [],
        ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
      ]
    }), {
      parent: true
    });
  };
  inst.with = inst.check;
  inst.clone = (def2, params) => clone(inst, def2, params);
  inst.brand = () => inst;
  inst.register = ((reg, meta3) => {
    reg.add(inst, meta3);
    return inst;
  });
  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
  inst.safeParse = (data, params) => safeParse2(inst, data, params);
  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
  inst.spa = inst.safeParseAsync;
  inst.encode = (data, params) => encode2(inst, data, params);
  inst.decode = (data, params) => decode2(inst, data, params);
  inst.encodeAsync = async (data, params) => encodeAsync2(inst, data, params);
  inst.decodeAsync = async (data, params) => decodeAsync2(inst, data, params);
  inst.safeEncode = (data, params) => safeEncode2(inst, data, params);
  inst.safeDecode = (data, params) => safeDecode2(inst, data, params);
  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync2(inst, data, params);
  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync2(inst, data, params);
  inst.refine = (check2, params) => inst.check(refine(check2, params));
  inst.superRefine = (refinement) => inst.check(superRefine(refinement));
  inst.overwrite = (fn) => inst.check(_overwrite(fn));
  inst.optional = () => optional(inst);
  inst.exactOptional = () => exactOptional(inst);
  inst.nullable = () => nullable(inst);
  inst.nullish = () => optional(nullable(inst));
  inst.nonoptional = (params) => nonoptional(inst, params);
  inst.array = () => array(inst);
  inst.or = (arg) => union([inst, arg]);
  inst.and = (arg) => intersection(inst, arg);
  inst.transform = (tx) => pipe(inst, transform(tx));
  inst.default = (def2) => _default2(inst, def2);
  inst.prefault = (def2) => prefault(inst, def2);
  inst.catch = (params) => _catch2(inst, params);
  inst.pipe = (target) => pipe(inst, target);
  inst.readonly = () => readonly(inst);
  inst.describe = (description) => {
    const cl = inst.clone();
    globalRegistry.add(cl, { description });
    return cl;
  };
  Object.defineProperty(inst, "description", {
    get() {
      return globalRegistry.get(inst)?.description;
    },
    configurable: true
  });
  inst.meta = (...args) => {
    if (args.length === 0) {
      return globalRegistry.get(inst);
    }
    const cl = inst.clone();
    globalRegistry.add(cl, args[0]);
    return cl;
  };
  inst.isOptional = () => inst.safeParse(void 0).success;
  inst.isNullable = () => inst.safeParse(null).success;
  inst.apply = (fn) => fn(inst);
  return inst;
});
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => stringProcessor(inst, ctx, json2, params);
  const bag = inst._zod.bag;
  inst.format = bag.format ?? null;
  inst.minLength = bag.minimum ?? null;
  inst.maxLength = bag.maximum ?? null;
  inst.regex = (...args) => inst.check(_regex(...args));
  inst.includes = (...args) => inst.check(_includes(...args));
  inst.startsWith = (...args) => inst.check(_startsWith(...args));
  inst.endsWith = (...args) => inst.check(_endsWith(...args));
  inst.min = (...args) => inst.check(_minLength(...args));
  inst.max = (...args) => inst.check(_maxLength(...args));
  inst.length = (...args) => inst.check(_length(...args));
  inst.nonempty = (...args) => inst.check(_minLength(1, ...args));
  inst.lowercase = (params) => inst.check(_lowercase(params));
  inst.uppercase = (params) => inst.check(_uppercase(params));
  inst.trim = () => inst.check(_trim());
  inst.normalize = (...args) => inst.check(_normalize(...args));
  inst.toLowerCase = () => inst.check(_toLowerCase());
  inst.toUpperCase = () => inst.check(_toUpperCase());
  inst.slugify = () => inst.check(_slugify());
});
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  _ZodString.init(inst, def);
  inst.email = (params) => inst.check(_email(ZodEmail, params));
  inst.url = (params) => inst.check(_url(ZodURL, params));
  inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
  inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
  inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
  inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
  inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
  inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
  inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
  inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
  inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
  inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
  inst.xid = (params) => inst.check(_xid(ZodXID, params));
  inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
  inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
  inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
  inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
  inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
  inst.e164 = (params) => inst.check(_e164(ZodE164, params));
  inst.datetime = (params) => inst.check(datetime2(params));
  inst.date = (params) => inst.check(date2(params));
  inst.time = (params) => inst.check(time2(params));
  inst.duration = (params) => inst.check(duration2(params));
});
function string2(params) {
  return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  _ZodString.init(inst, def);
});
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
  $ZodEmail.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function email2(params) {
  return _email(ZodEmail, params);
}
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
  $ZodGUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function guid2(params) {
  return _guid(ZodGUID, params);
}
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
  $ZodUUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function uuid2(params) {
  return _uuid(ZodUUID, params);
}
function uuidv4(params) {
  return _uuidv4(ZodUUID, params);
}
function uuidv6(params) {
  return _uuidv6(ZodUUID, params);
}
function uuidv7(params) {
  return _uuidv7(ZodUUID, params);
}
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
  $ZodURL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function url(params) {
  return _url(ZodURL, params);
}
function httpUrl(params) {
  return _url(ZodURL, {
    protocol: /^https?$/,
    hostname: regexes_exports.domain,
    ...util_exports.normalizeParams(params)
  });
}
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
  $ZodEmoji.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function emoji2(params) {
  return _emoji2(ZodEmoji, params);
}
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
  $ZodNanoID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function nanoid2(params) {
  return _nanoid(ZodNanoID, params);
}
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
  $ZodCUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function cuid3(params) {
  return _cuid(ZodCUID, params);
}
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
  $ZodCUID2.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function cuid22(params) {
  return _cuid2(ZodCUID2, params);
}
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
  $ZodULID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function ulid2(params) {
  return _ulid(ZodULID, params);
}
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
  $ZodXID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function xid2(params) {
  return _xid(ZodXID, params);
}
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
  $ZodKSUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function ksuid2(params) {
  return _ksuid(ZodKSUID, params);
}
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
  $ZodIPv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function ipv42(params) {
  return _ipv4(ZodIPv4, params);
}
var ZodMAC = /* @__PURE__ */ $constructor("ZodMAC", (inst, def) => {
  $ZodMAC.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function mac2(params) {
  return _mac(ZodMAC, params);
}
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
  $ZodIPv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function ipv62(params) {
  return _ipv6(ZodIPv6, params);
}
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
  $ZodCIDRv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function cidrv42(params) {
  return _cidrv4(ZodCIDRv4, params);
}
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
  $ZodCIDRv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function cidrv62(params) {
  return _cidrv6(ZodCIDRv6, params);
}
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
  $ZodBase64.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function base642(params) {
  return _base64(ZodBase64, params);
}
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
  $ZodBase64URL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function base64url2(params) {
  return _base64url(ZodBase64URL, params);
}
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
  $ZodE164.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function e1642(params) {
  return _e164(ZodE164, params);
}
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
  $ZodJWT.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function jwt(params) {
  return _jwt(ZodJWT, params);
}
var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat", (inst, def) => {
  $ZodCustomStringFormat.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function stringFormat(format, fnOrRegex, _params = {}) {
  return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
}
function hostname2(_params) {
  return _stringFormat(ZodCustomStringFormat, "hostname", regexes_exports.hostname, _params);
}
function hex2(_params) {
  return _stringFormat(ZodCustomStringFormat, "hex", regexes_exports.hex, _params);
}
function hash(alg, params) {
  const enc = params?.enc ?? "hex";
  const format = `${alg}_${enc}`;
  const regex = regexes_exports[format];
  if (!regex)
    throw new Error(`Unrecognized hash format: ${format}`);
  return _stringFormat(ZodCustomStringFormat, format, regex, params);
}
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
  $ZodNumber.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => numberProcessor(inst, ctx, json2, params);
  inst.gt = (value, params) => inst.check(_gt(value, params));
  inst.gte = (value, params) => inst.check(_gte(value, params));
  inst.min = (value, params) => inst.check(_gte(value, params));
  inst.lt = (value, params) => inst.check(_lt(value, params));
  inst.lte = (value, params) => inst.check(_lte(value, params));
  inst.max = (value, params) => inst.check(_lte(value, params));
  inst.int = (params) => inst.check(int(params));
  inst.safe = (params) => inst.check(int(params));
  inst.positive = (params) => inst.check(_gt(0, params));
  inst.nonnegative = (params) => inst.check(_gte(0, params));
  inst.negative = (params) => inst.check(_lt(0, params));
  inst.nonpositive = (params) => inst.check(_lte(0, params));
  inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
  inst.step = (value, params) => inst.check(_multipleOf(value, params));
  inst.finite = () => inst;
  const bag = inst._zod.bag;
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
  inst.isFinite = true;
  inst.format = bag.format ?? null;
});
function number2(params) {
  return _number(ZodNumber, params);
}
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
  $ZodNumberFormat.init(inst, def);
  ZodNumber.init(inst, def);
});
function int(params) {
  return _int(ZodNumberFormat, params);
}
function float32(params) {
  return _float32(ZodNumberFormat, params);
}
function float64(params) {
  return _float64(ZodNumberFormat, params);
}
function int32(params) {
  return _int32(ZodNumberFormat, params);
}
function uint32(params) {
  return _uint32(ZodNumberFormat, params);
}
var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
  $ZodBoolean.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor(inst, ctx, json2, params);
});
function boolean2(params) {
  return _boolean(ZodBoolean, params);
}
var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
  $ZodBigInt.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => bigintProcessor(inst, ctx, json2, params);
  inst.gte = (value, params) => inst.check(_gte(value, params));
  inst.min = (value, params) => inst.check(_gte(value, params));
  inst.gt = (value, params) => inst.check(_gt(value, params));
  inst.gte = (value, params) => inst.check(_gte(value, params));
  inst.min = (value, params) => inst.check(_gte(value, params));
  inst.lt = (value, params) => inst.check(_lt(value, params));
  inst.lte = (value, params) => inst.check(_lte(value, params));
  inst.max = (value, params) => inst.check(_lte(value, params));
  inst.positive = (params) => inst.check(_gt(BigInt(0), params));
  inst.negative = (params) => inst.check(_lt(BigInt(0), params));
  inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
  inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
  inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
  const bag = inst._zod.bag;
  inst.minValue = bag.minimum ?? null;
  inst.maxValue = bag.maximum ?? null;
  inst.format = bag.format ?? null;
});
function bigint2(params) {
  return _bigint(ZodBigInt, params);
}
var ZodBigIntFormat = /* @__PURE__ */ $constructor("ZodBigIntFormat", (inst, def) => {
  $ZodBigIntFormat.init(inst, def);
  ZodBigInt.init(inst, def);
});
function int64(params) {
  return _int64(ZodBigIntFormat, params);
}
function uint64(params) {
  return _uint64(ZodBigIntFormat, params);
}
var ZodSymbol = /* @__PURE__ */ $constructor("ZodSymbol", (inst, def) => {
  $ZodSymbol.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => symbolProcessor(inst, ctx, json2, params);
});
function symbol(params) {
  return _symbol(ZodSymbol, params);
}
var ZodUndefined = /* @__PURE__ */ $constructor("ZodUndefined", (inst, def) => {
  $ZodUndefined.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => undefinedProcessor(inst, ctx, json2, params);
});
function _undefined3(params) {
  return _undefined2(ZodUndefined, params);
}
var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
  $ZodNull.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => nullProcessor(inst, ctx, json2, params);
});
function _null3(params) {
  return _null2(ZodNull, params);
}
var ZodAny = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
  $ZodAny.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => anyProcessor(inst, ctx, json2, params);
});
function any() {
  return _any(ZodAny);
}
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
  $ZodUnknown.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => unknownProcessor(inst, ctx, json2, params);
});
function unknown() {
  return _unknown(ZodUnknown);
}
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
  $ZodNever.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => neverProcessor(inst, ctx, json2, params);
});
function never(params) {
  return _never(ZodNever, params);
}
var ZodVoid = /* @__PURE__ */ $constructor("ZodVoid", (inst, def) => {
  $ZodVoid.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => voidProcessor(inst, ctx, json2, params);
});
function _void2(params) {
  return _void(ZodVoid, params);
}
var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
  $ZodDate.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => dateProcessor(inst, ctx, json2, params);
  inst.min = (value, params) => inst.check(_gte(value, params));
  inst.max = (value, params) => inst.check(_lte(value, params));
  const c = inst._zod.bag;
  inst.minDate = c.minimum ? new Date(c.minimum) : null;
  inst.maxDate = c.maximum ? new Date(c.maximum) : null;
});
function date3(params) {
  return _date(ZodDate, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
  $ZodArray.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => arrayProcessor(inst, ctx, json2, params);
  inst.element = def.element;
  inst.min = (minLength, params) => inst.check(_minLength(minLength, params));
  inst.nonempty = (params) => inst.check(_minLength(1, params));
  inst.max = (maxLength, params) => inst.check(_maxLength(maxLength, params));
  inst.length = (len, params) => inst.check(_length(len, params));
  inst.unwrap = () => inst.element;
});
function array(element, params) {
  return _array(ZodArray, element, params);
}
function keyof(schema) {
  const shape = schema._zod.def.shape;
  return _enum2(Object.keys(shape));
}
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
  $ZodObjectJIT.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => objectProcessor(inst, ctx, json2, params);
  util_exports.defineLazy(inst, "shape", () => {
    return def.shape;
  });
  inst.keyof = () => _enum2(Object.keys(inst._zod.def.shape));
  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
  inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
  inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
  inst.strict = () => inst.clone({ ...inst._zod.def, catchall: never() });
  inst.strip = () => inst.clone({ ...inst._zod.def, catchall: void 0 });
  inst.extend = (incoming) => {
    return util_exports.extend(inst, incoming);
  };
  inst.safeExtend = (incoming) => {
    return util_exports.safeExtend(inst, incoming);
  };
  inst.merge = (other) => util_exports.merge(inst, other);
  inst.pick = (mask) => util_exports.pick(inst, mask);
  inst.omit = (mask) => util_exports.omit(inst, mask);
  inst.partial = (...args) => util_exports.partial(ZodOptional, inst, args[0]);
  inst.required = (...args) => util_exports.required(ZodNonOptional, inst, args[0]);
});
function object(shape, params) {
  const def = {
    type: "object",
    shape: shape ?? {},
    ...util_exports.normalizeParams(params)
  };
  return new ZodObject(def);
}
function strictObject(shape, params) {
  return new ZodObject({
    type: "object",
    shape,
    catchall: never(),
    ...util_exports.normalizeParams(params)
  });
}
function looseObject(shape, params) {
  return new ZodObject({
    type: "object",
    shape,
    catchall: unknown(),
    ...util_exports.normalizeParams(params)
  });
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
  $ZodUnion.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
  inst.options = def.options;
});
function union(options, params) {
  return new ZodUnion({
    type: "union",
    options,
    ...util_exports.normalizeParams(params)
  });
}
var ZodXor = /* @__PURE__ */ $constructor("ZodXor", (inst, def) => {
  ZodUnion.init(inst, def);
  $ZodXor.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => unionProcessor(inst, ctx, json2, params);
  inst.options = def.options;
});
function xor(options, params) {
  return new ZodXor({
    type: "union",
    options,
    inclusive: false,
    ...util_exports.normalizeParams(params)
  });
}
var ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("ZodDiscriminatedUnion", (inst, def) => {
  ZodUnion.init(inst, def);
  $ZodDiscriminatedUnion.init(inst, def);
});
function discriminatedUnion(discriminator, options, params) {
  return new ZodDiscriminatedUnion({
    type: "union",
    options,
    discriminator,
    ...util_exports.normalizeParams(params)
  });
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
  $ZodIntersection.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => intersectionProcessor(inst, ctx, json2, params);
});
function intersection(left, right) {
  return new ZodIntersection({
    type: "intersection",
    left,
    right
  });
}
var ZodTuple = /* @__PURE__ */ $constructor("ZodTuple", (inst, def) => {
  $ZodTuple.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => tupleProcessor(inst, ctx, json2, params);
  inst.rest = (rest) => inst.clone({
    ...inst._zod.def,
    rest
  });
});
function tuple(items, _paramsOrRest, _params) {
  const hasRest = _paramsOrRest instanceof $ZodType;
  const params = hasRest ? _params : _paramsOrRest;
  const rest = hasRest ? _paramsOrRest : null;
  return new ZodTuple({
    type: "tuple",
    items,
    rest,
    ...util_exports.normalizeParams(params)
  });
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
  $ZodRecord.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => recordProcessor(inst, ctx, json2, params);
  inst.keyType = def.keyType;
  inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function partialRecord(keyType, valueType, params) {
  const k = clone(keyType);
  k._zod.values = void 0;
  return new ZodRecord({
    type: "record",
    keyType: k,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
function looseRecord(keyType, valueType, params) {
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    mode: "loose",
    ...util_exports.normalizeParams(params)
  });
}
var ZodMap = /* @__PURE__ */ $constructor("ZodMap", (inst, def) => {
  $ZodMap.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => mapProcessor(inst, ctx, json2, params);
  inst.keyType = def.keyType;
  inst.valueType = def.valueType;
  inst.min = (...args) => inst.check(_minSize(...args));
  inst.nonempty = (params) => inst.check(_minSize(1, params));
  inst.max = (...args) => inst.check(_maxSize(...args));
  inst.size = (...args) => inst.check(_size(...args));
});
function map(keyType, valueType, params) {
  return new ZodMap({
    type: "map",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodSet = /* @__PURE__ */ $constructor("ZodSet", (inst, def) => {
  $ZodSet.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => setProcessor(inst, ctx, json2, params);
  inst.min = (...args) => inst.check(_minSize(...args));
  inst.nonempty = (params) => inst.check(_minSize(1, params));
  inst.max = (...args) => inst.check(_maxSize(...args));
  inst.size = (...args) => inst.check(_size(...args));
});
function set(valueType, params) {
  return new ZodSet({
    type: "set",
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
  $ZodEnum.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => enumProcessor(inst, ctx, json2, params);
  inst.enum = def.entries;
  inst.options = Object.values(def.entries);
  const keys = new Set(Object.keys(def.entries));
  inst.extract = (values, params) => {
    const newEntries = {};
    for (const value of values) {
      if (keys.has(value)) {
        newEntries[value] = def.entries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
  inst.exclude = (values, params) => {
    const newEntries = { ...def.entries };
    for (const value of values) {
      if (keys.has(value)) {
        delete newEntries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
});
function _enum2(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
function nativeEnum(entries, params) {
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
var ZodLiteral = /* @__PURE__ */ $constructor("ZodLiteral", (inst, def) => {
  $ZodLiteral.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => literalProcessor(inst, ctx, json2, params);
  inst.values = new Set(def.values);
  Object.defineProperty(inst, "value", {
    get() {
      if (def.values.length > 1) {
        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
      }
      return def.values[0];
    }
  });
});
function literal(value, params) {
  return new ZodLiteral({
    type: "literal",
    values: Array.isArray(value) ? value : [value],
    ...util_exports.normalizeParams(params)
  });
}
var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
  $ZodFile.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
  inst.min = (size, params) => inst.check(_minSize(size, params));
  inst.max = (size, params) => inst.check(_maxSize(size, params));
  inst.mime = (types, params) => inst.check(_mime(Array.isArray(types) ? types : [types], params));
});
function file(params) {
  return _file(ZodFile, params);
}
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
  $ZodTransform.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => transformProcessor(inst, ctx, json2, params);
  inst._zod.parse = (payload, _ctx) => {
    if (_ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(util_exports.issue(issue2, payload.value, def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = inst);
        payload.issues.push(util_exports.issue(_issue));
      }
    };
    const output = def.transform(payload.value, payload);
    if (output instanceof Promise) {
      return output.then((output2) => {
        payload.value = output2;
        return payload;
      });
    }
    payload.value = output;
    return payload;
  };
});
function transform(fn) {
  return new ZodTransform({
    type: "transform",
    transform: fn
  });
}
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
  return new ZodOptional({
    type: "optional",
    innerType
  });
}
var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
  $ZodExactOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => optionalProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function exactOptional(innerType) {
  return new ZodExactOptional({
    type: "optional",
    innerType
  });
}
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
  $ZodNullable.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => nullableProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
  return new ZodNullable({
    type: "nullable",
    innerType
  });
}
function nullish2(innerType) {
  return optional(nullable(innerType));
}
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
  $ZodDefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => defaultProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeDefault = inst.unwrap;
});
function _default2(innerType, defaultValue) {
  return new ZodDefault({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
  $ZodPrefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => prefaultProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
  return new ZodPrefault({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
  $ZodNonOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => nonoptionalProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
  return new ZodNonOptional({
    type: "nonoptional",
    innerType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodSuccess = /* @__PURE__ */ $constructor("ZodSuccess", (inst, def) => {
  $ZodSuccess.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => successProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function success(innerType) {
  return new ZodSuccess({
    type: "success",
    innerType
  });
}
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
  $ZodCatch.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => catchProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeCatch = inst.unwrap;
});
function _catch2(innerType, catchValue) {
  return new ZodCatch({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
var ZodNaN = /* @__PURE__ */ $constructor("ZodNaN", (inst, def) => {
  $ZodNaN.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => nanProcessor(inst, ctx, json2, params);
});
function nan(params) {
  return _nan(ZodNaN, params);
}
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
  $ZodPipe.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => pipeProcessor(inst, ctx, json2, params);
  inst.in = def.in;
  inst.out = def.out;
});
function pipe(in_, out) {
  return new ZodPipe({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
var ZodCodec = /* @__PURE__ */ $constructor("ZodCodec", (inst, def) => {
  ZodPipe.init(inst, def);
  $ZodCodec.init(inst, def);
});
function codec(in_, out, params) {
  return new ZodCodec({
    type: "pipe",
    in: in_,
    out,
    transform: params.decode,
    reverseTransform: params.encode
  });
}
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
  $ZodReadonly.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => readonlyProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function readonly(innerType) {
  return new ZodReadonly({
    type: "readonly",
    innerType
  });
}
var ZodTemplateLiteral = /* @__PURE__ */ $constructor("ZodTemplateLiteral", (inst, def) => {
  $ZodTemplateLiteral.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => templateLiteralProcessor(inst, ctx, json2, params);
});
function templateLiteral(parts, params) {
  return new ZodTemplateLiteral({
    type: "template_literal",
    parts,
    ...util_exports.normalizeParams(params)
  });
}
var ZodLazy = /* @__PURE__ */ $constructor("ZodLazy", (inst, def) => {
  $ZodLazy.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => lazyProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.getter();
});
function lazy(getter) {
  return new ZodLazy({
    type: "lazy",
    getter
  });
}
var ZodPromise = /* @__PURE__ */ $constructor("ZodPromise", (inst, def) => {
  $ZodPromise.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => promiseProcessor(inst, ctx, json2, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function promise(innerType) {
  return new ZodPromise({
    type: "promise",
    innerType
  });
}
var ZodFunction = /* @__PURE__ */ $constructor("ZodFunction", (inst, def) => {
  $ZodFunction.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => functionProcessor(inst, ctx, json2, params);
});
function _function(params) {
  return new ZodFunction({
    type: "function",
    input: Array.isArray(params?.input) ? tuple(params?.input) : params?.input ?? array(unknown()),
    output: params?.output ?? unknown()
  });
}
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
  $ZodCustom.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json2, params) => customProcessor(inst, ctx, json2, params);
});
function check(fn) {
  const ch = new $ZodCheck({
    check: "custom"
    // ...util.normalizeParams(params),
  });
  ch._zod.check = fn;
  return ch;
}
function custom(fn, _params) {
  return _custom(ZodCustom, fn ?? (() => true), _params);
}
function refine(fn, _params = {}) {
  return _refine(ZodCustom, fn, _params);
}
function superRefine(fn) {
  return _superRefine(fn);
}
var describe2 = describe;
var meta2 = meta;
function _instanceof(cls, params = {}) {
  const inst = new ZodCustom({
    type: "custom",
    check: "custom",
    fn: (data) => data instanceof cls,
    abort: true,
    ...util_exports.normalizeParams(params)
  });
  inst._zod.bag.Class = cls;
  inst._zod.check = (payload) => {
    if (!(payload.value instanceof cls)) {
      payload.issues.push({
        code: "invalid_type",
        expected: cls.name,
        input: payload.value,
        inst,
        path: [...inst._zod.def.path ?? []]
      });
    }
  };
  return inst;
}
var stringbool = (...args) => _stringbool({
  Codec: ZodCodec,
  Boolean: ZodBoolean,
  String: ZodString
}, ...args);
function json(params) {
  const jsonSchema = lazy(() => {
    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema), record(string2(), jsonSchema)]);
  });
  return jsonSchema;
}
function preprocess(fn, schema) {
  return pipe(transform(fn), schema);
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/compat.js
var ZodIssueCode = {
  invalid_type: "invalid_type",
  too_big: "too_big",
  too_small: "too_small",
  invalid_format: "invalid_format",
  not_multiple_of: "not_multiple_of",
  unrecognized_keys: "unrecognized_keys",
  invalid_union: "invalid_union",
  invalid_key: "invalid_key",
  invalid_element: "invalid_element",
  invalid_value: "invalid_value",
  custom: "custom"
};
function setErrorMap(map2) {
  config({
    customError: map2
  });
}
function getErrorMap() {
  return config().customError;
}
var ZodFirstPartyTypeKind;
/* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/from-json-schema.js
var z = {
  ...schemas_exports2,
  ...checks_exports2,
  iso: iso_exports
};
var RECOGNIZED_KEYS = /* @__PURE__ */ new Set([
  // Schema identification
  "$schema",
  "$ref",
  "$defs",
  "definitions",
  // Core schema keywords
  "$id",
  "id",
  "$comment",
  "$anchor",
  "$vocabulary",
  "$dynamicRef",
  "$dynamicAnchor",
  // Type
  "type",
  "enum",
  "const",
  // Composition
  "anyOf",
  "oneOf",
  "allOf",
  "not",
  // Object
  "properties",
  "required",
  "additionalProperties",
  "patternProperties",
  "propertyNames",
  "minProperties",
  "maxProperties",
  // Array
  "items",
  "prefixItems",
  "additionalItems",
  "minItems",
  "maxItems",
  "uniqueItems",
  "contains",
  "minContains",
  "maxContains",
  // String
  "minLength",
  "maxLength",
  "pattern",
  "format",
  // Number
  "minimum",
  "maximum",
  "exclusiveMinimum",
  "exclusiveMaximum",
  "multipleOf",
  // Already handled metadata
  "description",
  "default",
  // Content
  "contentEncoding",
  "contentMediaType",
  "contentSchema",
  // Unsupported (error-throwing)
  "unevaluatedItems",
  "unevaluatedProperties",
  "if",
  "then",
  "else",
  "dependentSchemas",
  "dependentRequired",
  // OpenAPI
  "nullable",
  "readOnly"
]);
function detectVersion(schema, defaultTarget) {
  const $schema = schema.$schema;
  if ($schema === "https://json-schema.org/draft/2020-12/schema") {
    return "draft-2020-12";
  }
  if ($schema === "http://json-schema.org/draft-07/schema#") {
    return "draft-7";
  }
  if ($schema === "http://json-schema.org/draft-04/schema#") {
    return "draft-4";
  }
  return defaultTarget ?? "draft-2020-12";
}
function resolveRef(ref, ctx) {
  if (!ref.startsWith("#")) {
    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
  }
  const path = ref.slice(1).split("/").filter(Boolean);
  if (path.length === 0) {
    return ctx.rootSchema;
  }
  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
  if (path[0] === defsKey) {
    const key = path[1];
    if (!key || !ctx.defs[key]) {
      throw new Error(`Reference not found: ${ref}`);
    }
    return ctx.defs[key];
  }
  throw new Error(`Reference not found: ${ref}`);
}
function convertBaseSchema(schema, ctx) {
  if (schema.not !== void 0) {
    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
      return z.never();
    }
    throw new Error("not is not supported in Zod (except { not: {} } for never)");
  }
  if (schema.unevaluatedItems !== void 0) {
    throw new Error("unevaluatedItems is not supported");
  }
  if (schema.unevaluatedProperties !== void 0) {
    throw new Error("unevaluatedProperties is not supported");
  }
  if (schema.if !== void 0 || schema.then !== void 0 || schema.else !== void 0) {
    throw new Error("Conditional schemas (if/then/else) are not supported");
  }
  if (schema.dependentSchemas !== void 0 || schema.dependentRequired !== void 0) {
    throw new Error("dependentSchemas and dependentRequired are not supported");
  }
  if (schema.$ref) {
    const refPath = schema.$ref;
    if (ctx.refs.has(refPath)) {
      return ctx.refs.get(refPath);
    }
    if (ctx.processing.has(refPath)) {
      return z.lazy(() => {
        if (!ctx.refs.has(refPath)) {
          throw new Error(`Circular reference not resolved: ${refPath}`);
        }
        return ctx.refs.get(refPath);
      });
    }
    ctx.processing.add(refPath);
    const resolved = resolveRef(refPath, ctx);
    const zodSchema2 = convertSchema(resolved, ctx);
    ctx.refs.set(refPath, zodSchema2);
    ctx.processing.delete(refPath);
    return zodSchema2;
  }
  if (schema.enum !== void 0) {
    const enumValues = schema.enum;
    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
      return z.null();
    }
    if (enumValues.length === 0) {
      return z.never();
    }
    if (enumValues.length === 1) {
      return z.literal(enumValues[0]);
    }
    if (enumValues.every((v) => typeof v === "string")) {
      return z.enum(enumValues);
    }
    const literalSchemas = enumValues.map((v) => z.literal(v));
    if (literalSchemas.length < 2) {
      return literalSchemas[0];
    }
    return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
  }
  if (schema.const !== void 0) {
    return z.literal(schema.const);
  }
  const type = schema.type;
  if (Array.isArray(type)) {
    const typeSchemas = type.map((t) => {
      const typeSchema = { ...schema, type: t };
      return convertBaseSchema(typeSchema, ctx);
    });
    if (typeSchemas.length === 0) {
      return z.never();
    }
    if (typeSchemas.length === 1) {
      return typeSchemas[0];
    }
    return z.union(typeSchemas);
  }
  if (!type) {
    return z.any();
  }
  let zodSchema;
  switch (type) {
    case "string": {
      let stringSchema = z.string();
      if (schema.format) {
        const format = schema.format;
        if (format === "email") {
          stringSchema = stringSchema.check(z.email());
        } else if (format === "uri" || format === "uri-reference") {
          stringSchema = stringSchema.check(z.url());
        } else if (format === "uuid" || format === "guid") {
          stringSchema = stringSchema.check(z.uuid());
        } else if (format === "date-time") {
          stringSchema = stringSchema.check(z.iso.datetime());
        } else if (format === "date") {
          stringSchema = stringSchema.check(z.iso.date());
        } else if (format === "time") {
          stringSchema = stringSchema.check(z.iso.time());
        } else if (format === "duration") {
          stringSchema = stringSchema.check(z.iso.duration());
        } else if (format === "ipv4") {
          stringSchema = stringSchema.check(z.ipv4());
        } else if (format === "ipv6") {
          stringSchema = stringSchema.check(z.ipv6());
        } else if (format === "mac") {
          stringSchema = stringSchema.check(z.mac());
        } else if (format === "cidr") {
          stringSchema = stringSchema.check(z.cidrv4());
        } else if (format === "cidr-v6") {
          stringSchema = stringSchema.check(z.cidrv6());
        } else if (format === "base64") {
          stringSchema = stringSchema.check(z.base64());
        } else if (format === "base64url") {
          stringSchema = stringSchema.check(z.base64url());
        } else if (format === "e164") {
          stringSchema = stringSchema.check(z.e164());
        } else if (format === "jwt") {
          stringSchema = stringSchema.check(z.jwt());
        } else if (format === "emoji") {
          stringSchema = stringSchema.check(z.emoji());
        } else if (format === "nanoid") {
          stringSchema = stringSchema.check(z.nanoid());
        } else if (format === "cuid") {
          stringSchema = stringSchema.check(z.cuid());
        } else if (format === "cuid2") {
          stringSchema = stringSchema.check(z.cuid2());
        } else if (format === "ulid") {
          stringSchema = stringSchema.check(z.ulid());
        } else if (format === "xid") {
          stringSchema = stringSchema.check(z.xid());
        } else if (format === "ksuid") {
          stringSchema = stringSchema.check(z.ksuid());
        }
      }
      if (typeof schema.minLength === "number") {
        stringSchema = stringSchema.min(schema.minLength);
      }
      if (typeof schema.maxLength === "number") {
        stringSchema = stringSchema.max(schema.maxLength);
      }
      if (schema.pattern) {
        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
      }
      zodSchema = stringSchema;
      break;
    }
    case "number":
    case "integer": {
      let numberSchema = type === "integer" ? z.number().int() : z.number();
      if (typeof schema.minimum === "number") {
        numberSchema = numberSchema.min(schema.minimum);
      }
      if (typeof schema.maximum === "number") {
        numberSchema = numberSchema.max(schema.maximum);
      }
      if (typeof schema.exclusiveMinimum === "number") {
        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
        numberSchema = numberSchema.gt(schema.minimum);
      }
      if (typeof schema.exclusiveMaximum === "number") {
        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
        numberSchema = numberSchema.lt(schema.maximum);
      }
      if (typeof schema.multipleOf === "number") {
        numberSchema = numberSchema.multipleOf(schema.multipleOf);
      }
      zodSchema = numberSchema;
      break;
    }
    case "boolean": {
      zodSchema = z.boolean();
      break;
    }
    case "null": {
      zodSchema = z.null();
      break;
    }
    case "object": {
      const shape = {};
      const properties = schema.properties || {};
      const requiredSet = new Set(schema.required || []);
      for (const [key, propSchema] of Object.entries(properties)) {
        const propZodSchema = convertSchema(propSchema, ctx);
        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
      }
      if (schema.propertyNames) {
        const keySchema = convertSchema(schema.propertyNames, ctx);
        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
        if (Object.keys(shape).length === 0) {
          zodSchema = z.record(keySchema, valueSchema);
          break;
        }
        const objectSchema2 = z.object(shape).passthrough();
        const recordSchema = z.looseRecord(keySchema, valueSchema);
        zodSchema = z.intersection(objectSchema2, recordSchema);
        break;
      }
      if (schema.patternProperties) {
        const patternProps = schema.patternProperties;
        const patternKeys = Object.keys(patternProps);
        const looseRecords = [];
        for (const pattern of patternKeys) {
          const patternValue = convertSchema(patternProps[pattern], ctx);
          const keySchema = z.string().regex(new RegExp(pattern));
          looseRecords.push(z.looseRecord(keySchema, patternValue));
        }
        const schemasToIntersect = [];
        if (Object.keys(shape).length > 0) {
          schemasToIntersect.push(z.object(shape).passthrough());
        }
        schemasToIntersect.push(...looseRecords);
        if (schemasToIntersect.length === 0) {
          zodSchema = z.object({}).passthrough();
        } else if (schemasToIntersect.length === 1) {
          zodSchema = schemasToIntersect[0];
        } else {
          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
          for (let i = 2; i < schemasToIntersect.length; i++) {
            result = z.intersection(result, schemasToIntersect[i]);
          }
          zodSchema = result;
        }
        break;
      }
      const objectSchema = z.object(shape);
      if (schema.additionalProperties === false) {
        zodSchema = objectSchema.strict();
      } else if (typeof schema.additionalProperties === "object") {
        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
      } else {
        zodSchema = objectSchema.passthrough();
      }
      break;
    }
    case "array": {
      const prefixItems = schema.prefixItems;
      const items = schema.items;
      if (prefixItems && Array.isArray(prefixItems)) {
        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
        if (rest) {
          zodSchema = z.tuple(tupleItems).rest(rest);
        } else {
          zodSchema = z.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema = zodSchema.check(z.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
        }
      } else if (Array.isArray(items)) {
        const tupleItems = items.map((item) => convertSchema(item, ctx));
        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
        if (rest) {
          zodSchema = z.tuple(tupleItems).rest(rest);
        } else {
          zodSchema = z.tuple(tupleItems);
        }
        if (typeof schema.minItems === "number") {
          zodSchema = zodSchema.check(z.minLength(schema.minItems));
        }
        if (typeof schema.maxItems === "number") {
          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
        }
      } else if (items !== void 0) {
        const element = convertSchema(items, ctx);
        let arraySchema = z.array(element);
        if (typeof schema.minItems === "number") {
          arraySchema = arraySchema.min(schema.minItems);
        }
        if (typeof schema.maxItems === "number") {
          arraySchema = arraySchema.max(schema.maxItems);
        }
        zodSchema = arraySchema;
      } else {
        zodSchema = z.array(z.any());
      }
      break;
    }
    default:
      throw new Error(`Unsupported type: ${type}`);
  }
  if (schema.description) {
    zodSchema = zodSchema.describe(schema.description);
  }
  if (schema.default !== void 0) {
    zodSchema = zodSchema.default(schema.default);
  }
  return zodSchema;
}
function convertSchema(schema, ctx) {
  if (typeof schema === "boolean") {
    return schema ? z.any() : z.never();
  }
  let baseSchema = convertBaseSchema(schema, ctx);
  const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
  if (schema.anyOf && Array.isArray(schema.anyOf)) {
    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
    const anyOfUnion = z.union(options);
    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
  }
  if (schema.oneOf && Array.isArray(schema.oneOf)) {
    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
    const oneOfUnion = z.xor(options);
    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
  }
  if (schema.allOf && Array.isArray(schema.allOf)) {
    if (schema.allOf.length === 0) {
      baseSchema = hasExplicitType ? baseSchema : z.any();
    } else {
      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
      const startIdx = hasExplicitType ? 0 : 1;
      for (let i = startIdx; i < schema.allOf.length; i++) {
        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
      }
      baseSchema = result;
    }
  }
  if (schema.nullable === true && ctx.version === "openapi-3.0") {
    baseSchema = z.nullable(baseSchema);
  }
  if (schema.readOnly === true) {
    baseSchema = z.readonly(baseSchema);
  }
  const extraMeta = {};
  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
  for (const key of coreMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
  for (const key of contentMetadataKeys) {
    if (key in schema) {
      extraMeta[key] = schema[key];
    }
  }
  for (const key of Object.keys(schema)) {
    if (!RECOGNIZED_KEYS.has(key)) {
      extraMeta[key] = schema[key];
    }
  }
  if (Object.keys(extraMeta).length > 0) {
    ctx.registry.add(baseSchema, extraMeta);
  }
  return baseSchema;
}
function fromJSONSchema(schema, params) {
  if (typeof schema === "boolean") {
    return schema ? z.any() : z.never();
  }
  const version2 = detectVersion(schema, params?.defaultTarget);
  const defs = schema.$defs || schema.definitions || {};
  const ctx = {
    version: version2,
    defs,
    refs: /* @__PURE__ */ new Map(),
    processing: /* @__PURE__ */ new Set(),
    rootSchema: schema,
    registry: params?.registry ?? globalRegistry
  };
  return convertSchema(schema, ctx);
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/coerce.js
var coerce_exports = {};
__export(coerce_exports, {
  bigint: () => bigint3,
  boolean: () => boolean3,
  date: () => date4,
  number: () => number3,
  string: () => string3
});
function string3(params) {
  return _coercedString(ZodString, params);
}
function number3(params) {
  return _coercedNumber(ZodNumber, params);
}
function boolean3(params) {
  return _coercedBoolean(ZodBoolean, params);
}
function bigint3(params) {
  return _coercedBigint(ZodBigInt, params);
}
function date4(params) {
  return _coercedDate(ZodDate, params);
}

// node_modules/.pnpm/zod@4.3.4/node_modules/zod/v4/classic/external.js
config(en_default());

// src/core/schema.ts
var ReferenceTrajectorySchema = external_exports.object({
  x: external_exports.array(external_exports.number()),
  y: external_exports.array(external_exports.number())
});
var PlotSeriesSchema = external_exports.object({
  label: external_exports.string(),
  values: external_exports.array(external_exports.number()),
  color: external_exports.string().optional()
});
var PlotBoundSchema = external_exports.object({
  values: external_exports.union([external_exports.array(external_exports.number()), external_exports.number()]),
  label: external_exports.string().optional()
});
var PlotBandSchema = external_exports.object({
  lower: external_exports.array(external_exports.number()),
  upper: external_exports.array(external_exports.number()),
  color: external_exports.string().optional(),
  label: external_exports.string().optional()
});
var AdditionalPlotSchema = external_exports.object({
  id: external_exports.string(),
  name: external_exports.string(),
  series: external_exports.array(PlotSeriesSchema),
  upperBound: PlotBoundSchema.optional(),
  lowerBound: PlotBoundSchema.optional(),
  bands: external_exports.array(PlotBandSchema).optional(),
  yAxisLabel: external_exports.string(),
  yAxisScale: external_exports.enum(["linear", "log"]).optional(),
  group: external_exports.string().optional()
});
var SimulationDataSchema = external_exports.object({
  reference: ReferenceTrajectorySchema,
  positionsX: external_exports.array(external_exports.number()),
  positionsY: external_exports.array(external_exports.number()),
  headings: external_exports.array(external_exports.number()),
  pathParameters: external_exports.array(external_exports.number()),
  pathLength: external_exports.number(),
  timeStep: external_exports.number().default(0.1),
  ghostX: external_exports.array(external_exports.number()).optional(),
  ghostY: external_exports.array(external_exports.number()).optional(),
  optimalTrajectoryX: external_exports.array(external_exports.array(external_exports.number())).optional(),
  optimalTrajectoryY: external_exports.array(external_exports.array(external_exports.number())).optional(),
  nominalTrajectoryX: external_exports.array(external_exports.array(external_exports.number())).optional(),
  nominalTrajectoryY: external_exports.array(external_exports.array(external_exports.number())).optional(),
  vehicleType: external_exports.enum(["triangle", "car"]).default("triangle"),
  wheelbase: external_exports.number().default(2.5),
  vehicleWidth: external_exports.number().default(1.2),
  obstaclePositionsX: external_exports.array(external_exports.array(external_exports.number())).optional(),
  obstaclePositionsY: external_exports.array(external_exports.array(external_exports.number())).optional(),
  obstacleHeadings: external_exports.array(external_exports.array(external_exports.number())).optional(),
  obstacleForecastX: external_exports.array(external_exports.array(external_exports.array(external_exports.number()))).optional(),
  obstacleForecastY: external_exports.array(external_exports.array(external_exports.array(external_exports.number()))).optional(),
  obstacleForecastHeading: external_exports.array(external_exports.array(external_exports.array(external_exports.number()))).optional(),
  obstacleForecastCovariance: external_exports.array(external_exports.array(external_exports.array(external_exports.array(external_exports.array(external_exports.number()))))).optional(),
  additionalPlots: external_exports.array(AdditionalPlotSchema).optional()
});
function parseSimulationData(data) {
  return SimulationDataSchema.parse(data);
}

// src/styles/main.css
var main_default = '* {\n    box-sizing: border-box;\n    margin: 0;\n    padding: 0;\n}\n\nhtml,\nbody {\n    height: 100%;\n    overflow: hidden;\n}\n\nbody {\n    font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;\n    background: #fafafa;\n    color: #2c3e50;\n}\n\n.container {\n    display: flex;\n    flex-direction: column;\n    height: 100vh;\n    padding: 10px;\n    gap: 10px;\n}\n\n.header {\n    flex-shrink: 0;\n}\n\n.title {\n    font-size: 20px;\n    font-weight: 600;\n}\n\n.main-content {\n    display: flex;\n    flex: 1;\n    gap: 15px;\n    min-height: 0;\n}\n\n.trajectory-container {\n    flex: 1;\n    min-width: 0;\n}\n\n.trajectory-wrapper {\n    height: 100%;\n    background: #fff;\n    border-radius: 6px;\n    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);\n    overflow: hidden;\n}\n\n#trajectory-plot {\n    width: 100%;\n    height: 100%;\n}\n\n.right-panel {\n    width: 350px;\n    flex-shrink: 0;\n    display: flex;\n    flex-direction: column;\n    gap: 8px;\n    min-height: 0;\n}\n\n.plot-container {\n    flex: 1;\n    min-height: 0;\n    display: flex;\n    flex-direction: column;\n    background: #fff;\n    border-radius: 6px;\n    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);\n    overflow: hidden;\n}\n\n.info-panel {\n    background: #f8f9fa;\n    border: 1px solid #dee2e6;\n    border-radius: 6px;\n    padding: 12px;\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);\n    flex-shrink: 0;\n}\n\n.info-panel h3 {\n    margin-bottom: 10px;\n    font-size: 13px;\n}\n\n.info-table {\n    width: 100%;\n    font-size: 12px;\n    border-collapse: collapse;\n}\n\n.info-table td {\n    padding: 3px 0;\n}\n\n.info-table td:first-child {\n    color: #666;\n}\n\n.info-table td:last-child {\n    text-align: right;\n    font-weight: 500;\n}\n\n.controls {\n    display: flex;\n    align-items: center;\n    gap: 10px;\n    padding: 10px 12px;\n    background: #ecf0f1;\n    border-radius: 6px;\n    flex-shrink: 0;\n}\n\n.control-btn {\n    border: none;\n    border-radius: 4px;\n    padding: 8px 14px;\n    font-size: 13px;\n    cursor: pointer;\n    transition: filter 0.2s;\n}\n\n.control-btn:hover {\n    filter: brightness(1.1);\n}\n\n.play-btn {\n    background: #2ecc71;\n    color: white;\n    min-width: 85px;\n}\n\n.play-btn.paused {\n    background: #f39c12;\n}\n\n.reset-btn,\n.speed-btn {\n    background: #ecf0f1;\n    border: 1px solid #bdc3c7;\n    color: #2c3e50;\n}\n\n.reset-btn:hover,\n.speed-btn:hover {\n    background: #bdc3c7;\n}\n\n.speed-btn {\n    min-width: 50px;\n}\n\n.slider-container {\n    flex: 1;\n    margin-left: 10px;\n}\n\n.time-slider {\n    width: 100%;\n    height: 6px;\n    border-radius: 3px;\n    background: #bdc3c7;\n    outline: none;\n    cursor: pointer;\n    appearance: none;\n}\n\n.time-slider::-webkit-slider-thumb {\n    appearance: none;\n    width: 16px;\n    height: 16px;\n    border-radius: 50%;\n    background: #3498db;\n    border: 2px solid white;\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);\n    cursor: pointer;\n}\n\n.time-slider::-moz-range-thumb {\n    width: 16px;\n    height: 16px;\n    border-radius: 50%;\n    background: #3498db;\n    border: 2px solid white;\n    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);\n    cursor: pointer;\n}\n\n#additional-plots-root {\n    display: contents;\n}\n\n.additional-plots-container {\n    display: flex;\n    flex-direction: column;\n    flex: 1;\n    min-height: 0;\n    gap: 8px;\n}\n\n.additional-plots-content {\n    display: flex;\n    flex-direction: column;\n    flex: 1;\n    min-height: 0;\n    gap: 8px;\n}\n\n.additional-plots-content .plot-container {\n    flex: 1;\n    min-height: 0;\n    display: flex;\n    flex-direction: column;\n}\n\n.additional-plot-content {\n    flex: 1;\n    min-height: 0;\n    width: 100%;\n}\n\n.plot-tabs-header {\n    display: flex;\n    gap: 4px;\n    background: #ecf0f1;\n    border-radius: 6px;\n    padding: 4px;\n    flex-shrink: 0;\n}\n\n.plot-tab {\n    flex: 1;\n    padding: 6px 10px;\n    border: none;\n    border-radius: 4px;\n    background: transparent;\n    color: #7f8c8d;\n    font-size: 11px;\n    font-weight: 500;\n    cursor: pointer;\n    transition: all 0.2s;\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n}\n\n.plot-tab:hover {\n    background: rgba(255, 255, 255, 0.5);\n    color: #2c3e50;\n}\n\n.plot-tab.active {\n    background: #fff;\n    color: #2c3e50;\n    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);\n}\n\n@media (max-width: 1000px) {\n    .main-content {\n        flex-direction: column;\n    }\n\n    .right-panel {\n        width: 100%;\n        flex-direction: row;\n        flex-wrap: wrap;\n        flex: 1;\n        min-height: 0;\n    }\n\n    .info-panel {\n        flex: 1;\n        min-width: 180px;\n    }\n\n    .plot-container {\n        flex: 1;\n        min-width: 280px;\n        min-height: 150px;\n    }\n\n    .additional-plots-container {\n        flex: 1;\n        min-width: 280px;\n    }\n}\n';

// src/templates/body.html
var body_default = '<div class="container">\r\n  <header class="header">\r\n    <h1 class="title">Simulation</h1>\r\n  </header>\r\n  <div class="main-content">\r\n    <div class="trajectory-container">\r\n      <div class="trajectory-wrapper">\r\n        <div id="trajectory-plot"></div>\r\n      </div>\r\n    </div>\r\n    <div class="right-panel">\r\n      <div id="app-root"></div>\r\n      <div id="additional-plots-root"></div>\r\n    </div>\r\n  </div>\r\n  <div id="controls-root"></div>\r\n</div>\r\n';

// src/templates/base.ts
var visualizerTemplate = (options) => template(options, `<script type="module">
${options.script}
</script>`);
var template = (options, scriptTag) => `<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>${options.title}</title>
    <style>
    ${options.styles}
    </style>
  </head>
  <body>
    ${body_default}
    <script>
    window.SIMULATION_DATA = ${options.data};
    </script>
    ${scriptTag}
  </body>
</html>`;

// src/visualization/browser.bundle.js
var browser_bundle_default = '"use strict";\n(() => {\n  var __create = Object.create;\n  var __defProp = Object.defineProperty;\n  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;\n  var __getOwnPropNames = Object.getOwnPropertyNames;\n  var __getProtoOf = Object.getPrototypeOf;\n  var __hasOwnProp = Object.prototype.hasOwnProperty;\n  var __commonJS = (cb, mod) => function __require() {\n    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;\n  };\n  var __copyProps = (to, from, except, desc) => {\n    if (from && typeof from === "object" || typeof from === "function") {\n      for (let key of __getOwnPropNames(from))\n        if (!__hasOwnProp.call(to, key) && key !== except)\n          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n    }\n    return to;\n  };\n  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n    // If the importer is in node compatibility mode or this is not an ESM\n    // file that has been converted to a CommonJS file using a Babel-\n    // compatible transform (i.e. "__esModule" has not been set), then set\n    // "default" to the CommonJS "module.exports" for node compatibility.\n    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,\n    mod\n  ));\n\n  // node_modules/.pnpm/plotly.js-dist-min@3.3.1/node_modules/plotly.js-dist-min/plotly.min.js\n  var require_plotly_min = __commonJS({\n    "node_modules/.pnpm/plotly.js-dist-min@3.3.1/node_modules/plotly.js-dist-min/plotly.min.js"(exports, module) {\n      (function(root, factory) {\n        if (typeof module === "object" && module.exports) {\n          module.exports = factory();\n        } else {\n          root.moduleName = factory();\n        }\n      })(typeof self !== "undefined" ? self : exports, () => {\n        "use strict";\n        var Plotly3 = (() => {\n          var ctt = Object.create;\n          var LS = Object.defineProperty, ftt = Object.defineProperties, htt = Object.getOwnPropertyDescriptor, dtt = Object.getOwnPropertyDescriptors, vtt = Object.getOwnPropertyNames, s6 = Object.getOwnPropertySymbols, ptt = Object.getPrototypeOf, xO = Object.prototype.hasOwnProperty, lee = Object.prototype.propertyIsEnumerable;\n          var see = (e3, t3, r4) => t3 in e3 ? LS(e3, t3, { enumerable: true, configurable: true, writable: true, value: r4 }) : e3[t3] = r4, mg = (e3, t3) => {\n            for (var r4 in t3 || (t3 = {})) xO.call(t3, r4) && see(e3, r4, t3[r4]);\n            if (s6) for (var r4 of s6(t3)) lee.call(t3, r4) && see(e3, r4, t3[r4]);\n            return e3;\n          }, q1 = (e3, t3) => ftt(e3, dtt(t3));\n          var uee = (e3, t3) => {\n            var r4 = {};\n            for (var n4 in e3) xO.call(e3, n4) && t3.indexOf(n4) < 0 && (r4[n4] = e3[n4]);\n            if (e3 != null && s6) for (var n4 of s6(e3)) t3.indexOf(n4) < 0 && lee.call(e3, n4) && (r4[n4] = e3[n4]);\n            return r4;\n          };\n          var gu = (e3, t3) => () => (e3 && (t3 = e3(e3 = 0)), t3);\n          var ye = (e3, t3) => () => (t3 || e3((t3 = { exports: {} }).exports, t3), t3.exports), cee = (e3, t3) => {\n            for (var r4 in t3) LS(e3, r4, { get: t3[r4], enumerable: true });\n          }, fee = (e3, t3, r4, n4) => {\n            if (t3 && typeof t3 == "object" || typeof t3 == "function") for (let i3 of vtt(t3)) !xO.call(e3, i3) && i3 !== r4 && LS(e3, i3, { get: () => t3[i3], enumerable: !(n4 = htt(t3, i3)) || n4.enumerable });\n            return e3;\n          };\n          var gtt = (e3, t3, r4) => (r4 = e3 != null ? ctt(ptt(e3)) : {}, fee(t3 || !e3 || !e3.__esModule ? LS(r4, "default", { value: e3, enumerable: true }) : r4, e3)), ob = (e3) => fee(LS({}, "__esModule", { value: true }), e3);\n          var l6 = ye((hee) => {\n            "use strict";\n            hee.version = "3.3.1";\n          });\n          var vee = ye((dee, u6) => {\n            (function(t3, r4, n4) {\n              r4[t3] = r4[t3] || n4(), typeof u6 != "undefined" && u6.exports && (u6.exports = r4[t3]);\n            })("Promise", typeof window != "undefined" ? window : dee, function() {\n              "use strict";\n              var t3, r4, n4, i3 = Object.prototype.toString, a4 = typeof setImmediate != "undefined" ? function(k4) {\n                return setImmediate(k4);\n              } : setTimeout;\n              try {\n                Object.defineProperty({}, "x", {}), t3 = function(k4, E3, S2, L3) {\n                  return Object.defineProperty(k4, E3, { value: S2, writable: true, configurable: L3 !== false });\n                };\n              } catch (p3) {\n                t3 = function(E3, S2, L3) {\n                  return E3[S2] = L3, E3;\n                };\n              }\n              n4 = /* @__PURE__ */ (function() {\n                var k4, E3, S2;\n                function L3(x2, C3) {\n                  this.fn = x2, this.self = C3, this.next = void 0;\n                }\n                return { add: function(C3, M4) {\n                  S2 = new L3(C3, M4), E3 ? E3.next = S2 : k4 = S2, E3 = S2, S2 = void 0;\n                }, drain: function() {\n                  var C3 = k4;\n                  for (k4 = E3 = r4 = void 0; C3; ) C3.fn.call(C3.self), C3 = C3.next;\n                } };\n              })();\n              function o4(p3, k4) {\n                n4.add(p3, k4), r4 || (r4 = a4(n4.drain));\n              }\n              function s3(p3) {\n                var k4, E3 = typeof p3;\n                return p3 != null && (E3 == "object" || E3 == "function") && (k4 = p3.then), typeof k4 == "function" ? k4 : false;\n              }\n              function l3() {\n                for (var p3 = 0; p3 < this.chain.length; p3++) u4(this, this.state === 1 ? this.chain[p3].success : this.chain[p3].failure, this.chain[p3]);\n                this.chain.length = 0;\n              }\n              function u4(p3, k4, E3) {\n                var S2, L3;\n                try {\n                  k4 === false ? E3.reject(p3.msg) : (k4 === true ? S2 = p3.msg : S2 = k4.call(void 0, p3.msg), S2 === E3.promise ? E3.reject(TypeError("Promise-chain cycle")) : (L3 = s3(S2)) ? L3.call(S2, E3.resolve, E3.reject) : E3.resolve(S2));\n                } catch (x2) {\n                  E3.reject(x2);\n                }\n              }\n              function c5(p3) {\n                var k4, E3 = this;\n                if (!E3.triggered) {\n                  E3.triggered = true, E3.def && (E3 = E3.def);\n                  try {\n                    (k4 = s3(p3)) ? o4(function() {\n                      var S2 = new d3(E3);\n                      try {\n                        k4.call(p3, function() {\n                          c5.apply(S2, arguments);\n                        }, function() {\n                          f4.apply(S2, arguments);\n                        });\n                      } catch (L3) {\n                        f4.call(S2, L3);\n                      }\n                    }) : (E3.msg = p3, E3.state = 1, E3.chain.length > 0 && o4(l3, E3));\n                  } catch (S2) {\n                    f4.call(new d3(E3), S2);\n                  }\n                }\n              }\n              function f4(p3) {\n                var k4 = this;\n                k4.triggered || (k4.triggered = true, k4.def && (k4 = k4.def), k4.msg = p3, k4.state = 2, k4.chain.length > 0 && o4(l3, k4));\n              }\n              function h3(p3, k4, E3, S2) {\n                for (var L3 = 0; L3 < k4.length; L3++) (function(C3) {\n                  p3.resolve(k4[C3]).then(function(g3) {\n                    E3(C3, g3);\n                  }, S2);\n                })(L3);\n              }\n              function d3(p3) {\n                this.def = p3, this.triggered = false;\n              }\n              function v3(p3) {\n                this.promise = p3, this.state = 0, this.triggered = false, this.chain = [], this.msg = void 0;\n              }\n              function _2(p3) {\n                if (typeof p3 != "function") throw TypeError("Not a function");\n                if (this.__NPO__ !== 0) throw TypeError("Not a promise");\n                this.__NPO__ = 1;\n                var k4 = new v3(this);\n                this.then = function(S2, L3) {\n                  var x2 = { success: typeof S2 == "function" ? S2 : true, failure: typeof L3 == "function" ? L3 : false };\n                  return x2.promise = new this.constructor(function(M4, g3) {\n                    if (typeof M4 != "function" || typeof g3 != "function") throw TypeError("Not a function");\n                    x2.resolve = M4, x2.reject = g3;\n                  }), k4.chain.push(x2), k4.state !== 0 && o4(l3, k4), x2.promise;\n                }, this.catch = function(S2) {\n                  return this.then(void 0, S2);\n                };\n                try {\n                  p3.call(void 0, function(S2) {\n                    c5.call(k4, S2);\n                  }, function(S2) {\n                    f4.call(k4, S2);\n                  });\n                } catch (E3) {\n                  f4.call(k4, E3);\n                }\n              }\n              var b = t3({}, "constructor", _2, false);\n              return _2.prototype = b, t3(b, "__NPO__", 0, false), t3(_2, "resolve", function(k4) {\n                var E3 = this;\n                return k4 && typeof k4 == "object" && k4.__NPO__ === 1 ? k4 : new E3(function(L3, x2) {\n                  if (typeof L3 != "function" || typeof x2 != "function") throw TypeError("Not a function");\n                  L3(k4);\n                });\n              }), t3(_2, "reject", function(k4) {\n                return new this(function(S2, L3) {\n                  if (typeof S2 != "function" || typeof L3 != "function") throw TypeError("Not a function");\n                  L3(k4);\n                });\n              }), t3(_2, "all", function(k4) {\n                var E3 = this;\n                return i3.call(k4) != "[object Array]" ? E3.reject(TypeError("Not an array")) : k4.length === 0 ? E3.resolve([]) : new E3(function(L3, x2) {\n                  if (typeof L3 != "function" || typeof x2 != "function") throw TypeError("Not a function");\n                  var C3 = k4.length, M4 = Array(C3), g3 = 0;\n                  h3(E3, k4, function(T3, z3) {\n                    M4[T3] = z3, ++g3 === C3 && L3(M4);\n                  }, x2);\n                });\n              }), t3(_2, "race", function(k4) {\n                var E3 = this;\n                return i3.call(k4) != "[object Array]" ? E3.reject(TypeError("Not an array")) : new E3(function(L3, x2) {\n                  if (typeof L3 != "function" || typeof x2 != "function") throw TypeError("Not a function");\n                  h3(E3, k4, function(M4, g3) {\n                    L3(g3);\n                  }, x2);\n                });\n              }), _2;\n            });\n          });\n          var Oa = ye((arr, c6) => {\n            (function() {\n              var e3 = { version: "3.8.2" }, t3 = [].slice, r4 = function(X) {\n                return t3.call(X);\n              }, n4 = self.document;\n              function i3(X) {\n                return X && (X.ownerDocument || X.document || X).documentElement;\n              }\n              function a4(X) {\n                return X && (X.ownerDocument && X.ownerDocument.defaultView || X.document && X || X.defaultView);\n              }\n              if (n4) try {\n                r4(n4.documentElement.childNodes)[0].nodeType;\n              } catch (X) {\n                r4 = function(se) {\n                  for (var Te = se.length, Ne = new Array(Te); Te--; ) Ne[Te] = se[Te];\n                  return Ne;\n                };\n              }\n              if (Date.now || (Date.now = function() {\n                return +/* @__PURE__ */ new Date();\n              }), n4) try {\n                n4.createElement("DIV").style.setProperty("opacity", 0, "");\n              } catch (X) {\n                var o4 = this.Element.prototype, s3 = o4.setAttribute, l3 = o4.setAttributeNS, u4 = this.CSSStyleDeclaration.prototype, c5 = u4.setProperty;\n                o4.setAttribute = function(se, Te) {\n                  s3.call(this, se, Te + "");\n                }, o4.setAttributeNS = function(se, Te, Ne) {\n                  l3.call(this, se, Te, Ne + "");\n                }, u4.setProperty = function(se, Te, Ne) {\n                  c5.call(this, se, Te + "", Ne);\n                };\n              }\n              e3.ascending = f4;\n              function f4(X, se) {\n                return X < se ? -1 : X > se ? 1 : X >= se ? 0 : NaN;\n              }\n              e3.descending = function(X, se) {\n                return se < X ? -1 : se > X ? 1 : se >= X ? 0 : NaN;\n              }, e3.min = function(X, se) {\n                var Te = -1, Ne = X.length, He, Ye;\n                if (arguments.length === 1) {\n                  for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {\n                    He = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = X[Te]) != null && He > Ye && (He = Ye);\n                } else {\n                  for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {\n                    He = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && He > Ye && (He = Ye);\n                }\n                return He;\n              }, e3.max = function(X, se) {\n                var Te = -1, Ne = X.length, He, Ye;\n                if (arguments.length === 1) {\n                  for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {\n                    He = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = X[Te]) != null && Ye > He && (He = Ye);\n                } else {\n                  for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {\n                    He = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && Ye > He && (He = Ye);\n                }\n                return He;\n              }, e3.extent = function(X, se) {\n                var Te = -1, Ne = X.length, He, Ye, kt;\n                if (arguments.length === 1) {\n                  for (; ++Te < Ne; ) if ((Ye = X[Te]) != null && Ye >= Ye) {\n                    He = kt = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = X[Te]) != null && (He > Ye && (He = Ye), kt < Ye && (kt = Ye));\n                } else {\n                  for (; ++Te < Ne; ) if ((Ye = se.call(X, X[Te], Te)) != null && Ye >= Ye) {\n                    He = kt = Ye;\n                    break;\n                  }\n                  for (; ++Te < Ne; ) (Ye = se.call(X, X[Te], Te)) != null && (He > Ye && (He = Ye), kt < Ye && (kt = Ye));\n                }\n                return [He, kt];\n              };\n              function h3(X) {\n                return X === null ? NaN : +X;\n              }\n              function d3(X) {\n                return !isNaN(X);\n              }\n              e3.sum = function(X, se) {\n                var Te = 0, Ne = X.length, He, Ye = -1;\n                if (arguments.length === 1) for (; ++Ye < Ne; ) d3(He = +X[Ye]) && (Te += He);\n                else for (; ++Ye < Ne; ) d3(He = +se.call(X, X[Ye], Ye)) && (Te += He);\n                return Te;\n              }, e3.mean = function(X, se) {\n                var Te = 0, Ne = X.length, He, Ye = -1, kt = Ne;\n                if (arguments.length === 1) for (; ++Ye < Ne; ) d3(He = h3(X[Ye])) ? Te += He : --kt;\n                else for (; ++Ye < Ne; ) d3(He = h3(se.call(X, X[Ye], Ye))) ? Te += He : --kt;\n                if (kt) return Te / kt;\n              }, e3.quantile = function(X, se) {\n                var Te = (X.length - 1) * se + 1, Ne = Math.floor(Te), He = +X[Ne - 1], Ye = Te - Ne;\n                return Ye ? He + Ye * (X[Ne] - He) : He;\n              }, e3.median = function(X, se) {\n                var Te = [], Ne = X.length, He, Ye = -1;\n                if (arguments.length === 1) for (; ++Ye < Ne; ) d3(He = h3(X[Ye])) && Te.push(He);\n                else for (; ++Ye < Ne; ) d3(He = h3(se.call(X, X[Ye], Ye))) && Te.push(He);\n                if (Te.length) return e3.quantile(Te.sort(f4), 0.5);\n              }, e3.variance = function(X, se) {\n                var Te = X.length, Ne = 0, He, Ye, kt = 0, nt = -1, jt = 0;\n                if (arguments.length === 1) for (; ++nt < Te; ) d3(He = h3(X[nt])) && (Ye = He - Ne, Ne += Ye / ++jt, kt += Ye * (He - Ne));\n                else for (; ++nt < Te; ) d3(He = h3(se.call(X, X[nt], nt))) && (Ye = He - Ne, Ne += Ye / ++jt, kt += Ye * (He - Ne));\n                if (jt > 1) return kt / (jt - 1);\n              }, e3.deviation = function() {\n                var X = e3.variance.apply(this, arguments);\n                return X && Math.sqrt(X);\n              };\n              function v3(X) {\n                return { left: function(se, Te, Ne, He) {\n                  for (arguments.length < 3 && (Ne = 0), arguments.length < 4 && (He = se.length); Ne < He; ) {\n                    var Ye = Ne + He >>> 1;\n                    X(se[Ye], Te) < 0 ? Ne = Ye + 1 : He = Ye;\n                  }\n                  return Ne;\n                }, right: function(se, Te, Ne, He) {\n                  for (arguments.length < 3 && (Ne = 0), arguments.length < 4 && (He = se.length); Ne < He; ) {\n                    var Ye = Ne + He >>> 1;\n                    X(se[Ye], Te) > 0 ? He = Ye : Ne = Ye + 1;\n                  }\n                  return Ne;\n                } };\n              }\n              var _2 = v3(f4);\n              e3.bisectLeft = _2.left, e3.bisect = e3.bisectRight = _2.right, e3.bisector = function(X) {\n                return v3(X.length === 1 ? function(se, Te) {\n                  return f4(X(se), Te);\n                } : X);\n              }, e3.shuffle = function(X, se, Te) {\n                (Ne = arguments.length) < 3 && (Te = X.length, Ne < 2 && (se = 0));\n                for (var Ne = Te - se, He, Ye; Ne; ) Ye = Math.random() * Ne-- | 0, He = X[Ne + se], X[Ne + se] = X[Ye + se], X[Ye + se] = He;\n                return X;\n              }, e3.permute = function(X, se) {\n                for (var Te = se.length, Ne = new Array(Te); Te--; ) Ne[Te] = X[se[Te]];\n                return Ne;\n              }, e3.pairs = function(X) {\n                for (var se = 0, Te = X.length - 1, Ne, He = X[0], Ye = new Array(Te < 0 ? 0 : Te); se < Te; ) Ye[se] = [Ne = He, He = X[++se]];\n                return Ye;\n              }, e3.transpose = function(X) {\n                if (!(Ye = X.length)) return [];\n                for (var se = -1, Te = e3.min(X, b), Ne = new Array(Te); ++se < Te; ) for (var He = -1, Ye, kt = Ne[se] = new Array(Ye); ++He < Ye; ) kt[He] = X[He][se];\n                return Ne;\n              };\n              function b(X) {\n                return X.length;\n              }\n              e3.zip = function() {\n                return e3.transpose(arguments);\n              }, e3.keys = function(X) {\n                var se = [];\n                for (var Te in X) se.push(Te);\n                return se;\n              }, e3.values = function(X) {\n                var se = [];\n                for (var Te in X) se.push(X[Te]);\n                return se;\n              }, e3.entries = function(X) {\n                var se = [];\n                for (var Te in X) se.push({ key: Te, value: X[Te] });\n                return se;\n              }, e3.merge = function(X) {\n                for (var se = X.length, Te, Ne = -1, He = 0, Ye, kt; ++Ne < se; ) He += X[Ne].length;\n                for (Ye = new Array(He); --se >= 0; ) for (kt = X[se], Te = kt.length; --Te >= 0; ) Ye[--He] = kt[Te];\n                return Ye;\n              };\n              var p3 = Math.abs;\n              e3.range = function(X, se, Te) {\n                if (arguments.length < 3 && (Te = 1, arguments.length < 2 && (se = X, X = 0)), (se - X) / Te === 1 / 0) throw new Error("infinite range");\n                var Ne = [], He = k4(p3(Te)), Ye = -1, kt;\n                if (X *= He, se *= He, Te *= He, Te < 0) for (; (kt = X + Te * ++Ye) > se; ) Ne.push(kt / He);\n                else for (; (kt = X + Te * ++Ye) < se; ) Ne.push(kt / He);\n                return Ne;\n              };\n              function k4(X) {\n                for (var se = 1; X * se % 1; ) se *= 10;\n                return se;\n              }\n              function E3(X, se) {\n                for (var Te in se) Object.defineProperty(X.prototype, Te, { value: se[Te], enumerable: false });\n              }\n              e3.map = function(X, se) {\n                var Te = new S2();\n                if (X instanceof S2) X.forEach(function(nt, jt) {\n                  Te.set(nt, jt);\n                });\n                else if (Array.isArray(X)) {\n                  var Ne = -1, He = X.length, Ye;\n                  if (arguments.length === 1) for (; ++Ne < He; ) Te.set(Ne, X[Ne]);\n                  else for (; ++Ne < He; ) Te.set(se.call(X, Ye = X[Ne], Ne), Ye);\n                } else for (var kt in X) Te.set(kt, X[kt]);\n                return Te;\n              };\n              function S2() {\n                this._ = /* @__PURE__ */ Object.create(null);\n              }\n              var L3 = "__proto__", x2 = "\\0";\n              E3(S2, { has: g3, get: function(X) {\n                return this._[C3(X)];\n              }, set: function(X, se) {\n                return this._[C3(X)] = se;\n              }, remove: P3, keys: T3, values: function() {\n                var X = [];\n                for (var se in this._) X.push(this._[se]);\n                return X;\n              }, entries: function() {\n                var X = [];\n                for (var se in this._) X.push({ key: M4(se), value: this._[se] });\n                return X;\n              }, size: z3, empty: O3, forEach: function(X) {\n                for (var se in this._) X.call(this, M4(se), this._[se]);\n              } });\n              function C3(X) {\n                return (X += "") === L3 || X[0] === x2 ? x2 + X : X;\n              }\n              function M4(X) {\n                return (X += "")[0] === x2 ? X.slice(1) : X;\n              }\n              function g3(X) {\n                return C3(X) in this._;\n              }\n              function P3(X) {\n                return (X = C3(X)) in this._ && delete this._[X];\n              }\n              function T3() {\n                var X = [];\n                for (var se in this._) X.push(M4(se));\n                return X;\n              }\n              function z3() {\n                var X = 0;\n                for (var se in this._) ++X;\n                return X;\n              }\n              function O3() {\n                for (var X in this._) return false;\n                return true;\n              }\n              e3.nest = function() {\n                var X = {}, se = [], Te = [], Ne, He;\n                function Ye(nt, jt, gr) {\n                  if (gr >= se.length) return He ? He.call(X, jt) : Ne ? jt.sort(Ne) : jt;\n                  for (var yr = -1, Hr = jt.length, qr = se[gr++], _i, bi, Zr, ai = new S2(), gi; ++yr < Hr; ) (gi = ai.get(_i = qr(bi = jt[yr]))) ? gi.push(bi) : ai.set(_i, [bi]);\n                  return nt ? (bi = nt(), Zr = function(Ii, Si) {\n                    bi.set(Ii, Ye(nt, Si, gr));\n                  }) : (bi = {}, Zr = function(Ii, Si) {\n                    bi[Ii] = Ye(nt, Si, gr);\n                  }), ai.forEach(Zr), bi;\n                }\n                function kt(nt, jt) {\n                  if (jt >= se.length) return nt;\n                  var gr = [], yr = Te[jt++];\n                  return nt.forEach(function(Hr, qr) {\n                    gr.push({ key: Hr, values: kt(qr, jt) });\n                  }), yr ? gr.sort(function(Hr, qr) {\n                    return yr(Hr.key, qr.key);\n                  }) : gr;\n                }\n                return X.map = function(nt, jt) {\n                  return Ye(jt, nt, 0);\n                }, X.entries = function(nt) {\n                  return kt(Ye(e3.map, nt, 0), 0);\n                }, X.key = function(nt) {\n                  return se.push(nt), X;\n                }, X.sortKeys = function(nt) {\n                  return Te[se.length - 1] = nt, X;\n                }, X.sortValues = function(nt) {\n                  return Ne = nt, X;\n                }, X.rollup = function(nt) {\n                  return He = nt, X;\n                }, X;\n              }, e3.set = function(X) {\n                var se = new V2();\n                if (X) for (var Te = 0, Ne = X.length; Te < Ne; ++Te) se.add(X[Te]);\n                return se;\n              };\n              function V2() {\n                this._ = /* @__PURE__ */ Object.create(null);\n              }\n              E3(V2, { has: g3, add: function(X) {\n                return this._[C3(X += "")] = true, X;\n              }, remove: P3, values: T3, size: z3, empty: O3, forEach: function(X) {\n                for (var se in this._) X.call(this, M4(se));\n              } }), e3.behavior = {};\n              function G2(X) {\n                return X;\n              }\n              e3.rebind = function(X, se) {\n                for (var Te = 1, Ne = arguments.length, He; ++Te < Ne; ) X[He = arguments[Te]] = Z(X, se, se[He]);\n                return X;\n              };\n              function Z(X, se, Te) {\n                return function() {\n                  var Ne = Te.apply(se, arguments);\n                  return Ne === se ? X : Ne;\n                };\n              }\n              function j3(X, se) {\n                if (se in X) return se;\n                se = se.charAt(0).toUpperCase() + se.slice(1);\n                for (var Te = 0, Ne = N2.length; Te < Ne; ++Te) {\n                  var He = N2[Te] + se;\n                  if (He in X) return He;\n                }\n              }\n              var N2 = ["webkit", "ms", "moz", "Moz", "o", "O"];\n              function H() {\n              }\n              e3.dispatch = function() {\n                for (var X = new te(), se = -1, Te = arguments.length; ++se < Te; ) X[arguments[se]] = oe(X);\n                return X;\n              };\n              function te() {\n              }\n              te.prototype.on = function(X, se) {\n                var Te = X.indexOf("."), Ne = "";\n                if (Te >= 0 && (Ne = X.slice(Te + 1), X = X.slice(0, Te)), X) return arguments.length < 2 ? this[X].on(Ne) : this[X].on(Ne, se);\n                if (arguments.length === 2) {\n                  if (se == null) for (X in this) this.hasOwnProperty(X) && this[X].on(Ne, null);\n                  return this;\n                }\n              };\n              function oe(X) {\n                var se = [], Te = new S2();\n                function Ne() {\n                  for (var He = se, Ye = -1, kt = He.length, nt; ++Ye < kt; ) (nt = He[Ye].on) && nt.apply(this, arguments);\n                  return X;\n                }\n                return Ne.on = function(He, Ye) {\n                  var kt = Te.get(He), nt;\n                  return arguments.length < 2 ? kt && kt.on : (kt && (kt.on = null, se = se.slice(0, nt = se.indexOf(kt)).concat(se.slice(nt + 1)), Te.remove(He)), Ye && se.push(Te.set(He, { on: Ye })), X);\n                }, Ne;\n              }\n              e3.event = null;\n              function _e() {\n                e3.event.preventDefault();\n              }\n              function Ee() {\n                for (var X = e3.event, se; se = X.sourceEvent; ) X = se;\n                return X;\n              }\n              function Ce(X) {\n                for (var se = new te(), Te = 0, Ne = arguments.length; ++Te < Ne; ) se[arguments[Te]] = oe(se);\n                return se.of = function(He, Ye) {\n                  return function(kt) {\n                    try {\n                      var nt = kt.sourceEvent = e3.event;\n                      kt.target = X, e3.event = kt, se[kt.type].apply(He, Ye);\n                    } finally {\n                      e3.event = nt;\n                    }\n                  };\n                }, se;\n              }\n              e3.requote = function(X) {\n                return X.replace(me, "\\\\$&");\n              };\n              var me = /[\\\\\\^\\$\\*\\+\\?\\|\\[\\]\\(\\)\\.\\{\\}]/g, ie = {}.__proto__ ? function(X, se) {\n                X.__proto__ = se;\n              } : function(X, se) {\n                for (var Te in se) X[Te] = se[Te];\n              };\n              function Se(X) {\n                return ie(X, Pe), X;\n              }\n              var Le = function(X, se) {\n                return se.querySelector(X);\n              }, Ae = function(X, se) {\n                return se.querySelectorAll(X);\n              }, Fe = function(X, se) {\n                var Te = X.matches || X[j3(X, "matchesSelector")];\n                return Fe = function(Ne, He) {\n                  return Te.call(Ne, He);\n                }, Fe(X, se);\n              };\n              typeof Sizzle == "function" && (Le = function(X, se) {\n                return Sizzle(X, se)[0] || null;\n              }, Ae = Sizzle, Fe = Sizzle.matchesSelector), e3.selection = function() {\n                return e3.select(n4.documentElement);\n              };\n              var Pe = e3.selection.prototype = [];\n              Pe.select = function(X) {\n                var se = [], Te, Ne, He, Ye;\n                X = ge(X);\n                for (var kt = -1, nt = this.length; ++kt < nt; ) {\n                  se.push(Te = []), Te.parentNode = (He = this[kt]).parentNode;\n                  for (var jt = -1, gr = He.length; ++jt < gr; ) (Ye = He[jt]) ? (Te.push(Ne = X.call(Ye, Ye.__data__, jt, kt)), Ne && "__data__" in Ye && (Ne.__data__ = Ye.__data__)) : Te.push(null);\n                }\n                return Se(se);\n              };\n              function ge(X) {\n                return typeof X == "function" ? X : function() {\n                  return Le(X, this);\n                };\n              }\n              Pe.selectAll = function(X) {\n                var se = [], Te, Ne;\n                X = Re(X);\n                for (var He = -1, Ye = this.length; ++He < Ye; ) for (var kt = this[He], nt = -1, jt = kt.length; ++nt < jt; ) (Ne = kt[nt]) && (se.push(Te = r4(X.call(Ne, Ne.__data__, nt, He))), Te.parentNode = Ne);\n                return Se(se);\n              };\n              function Re(X) {\n                return typeof X == "function" ? X : function() {\n                  return Ae(X, this);\n                };\n              }\n              var ce = "http://www.w3.org/1999/xhtml", Ze = { svg: "http://www.w3.org/2000/svg", xhtml: ce, xlink: "http://www.w3.org/1999/xlink", xml: "http://www.w3.org/XML/1998/namespace", xmlns: "http://www.w3.org/2000/xmlns/" };\n              e3.ns = { prefix: Ze, qualify: function(X) {\n                var se = X.indexOf(":"), Te = X;\n                return se >= 0 && (Te = X.slice(0, se)) !== "xmlns" && (X = X.slice(se + 1)), Ze.hasOwnProperty(Te) ? { space: Ze[Te], local: X } : X;\n              } }, Pe.attr = function(X, se) {\n                if (arguments.length < 2) {\n                  if (typeof X == "string") {\n                    var Te = this.node();\n                    return X = e3.ns.qualify(X), X.local ? Te.getAttributeNS(X.space, X.local) : Te.getAttribute(X);\n                  }\n                  for (se in X) this.each(ut(se, X[se]));\n                  return this;\n                }\n                return this.each(ut(X, se));\n              };\n              function ut(X, se) {\n                X = e3.ns.qualify(X);\n                function Te() {\n                  this.removeAttribute(X);\n                }\n                function Ne() {\n                  this.removeAttributeNS(X.space, X.local);\n                }\n                function He() {\n                  this.setAttribute(X, se);\n                }\n                function Ye() {\n                  this.setAttributeNS(X.space, X.local, se);\n                }\n                function kt() {\n                  var jt = se.apply(this, arguments);\n                  jt == null ? this.removeAttribute(X) : this.setAttribute(X, jt);\n                }\n                function nt() {\n                  var jt = se.apply(this, arguments);\n                  jt == null ? this.removeAttributeNS(X.space, X.local) : this.setAttributeNS(X.space, X.local, jt);\n                }\n                return se == null ? X.local ? Ne : Te : typeof se == "function" ? X.local ? nt : kt : X.local ? Ye : He;\n              }\n              function pt(X) {\n                return X.trim().replace(/\\s+/g, " ");\n              }\n              Pe.classed = function(X, se) {\n                if (arguments.length < 2) {\n                  if (typeof X == "string") {\n                    var Te = this.node(), Ne = (X = st(X)).length, He = -1;\n                    if (se = Te.classList) {\n                      for (; ++He < Ne; ) if (!se.contains(X[He])) return false;\n                    } else for (se = Te.getAttribute("class"); ++He < Ne; ) if (!Zt(X[He]).test(se)) return false;\n                    return true;\n                  }\n                  for (se in X) this.each(lt(se, X[se]));\n                  return this;\n                }\n                return this.each(lt(X, se));\n              };\n              function Zt(X) {\n                return new RegExp("(?:^|\\\\s+)" + e3.requote(X) + "(?:\\\\s+|$)", "g");\n              }\n              function st(X) {\n                return (X + "").trim().split(/^|\\s+/);\n              }\n              function lt(X, se) {\n                X = st(X).map(Gt);\n                var Te = X.length;\n                function Ne() {\n                  for (var Ye = -1; ++Ye < Te; ) X[Ye](this, se);\n                }\n                function He() {\n                  for (var Ye = -1, kt = se.apply(this, arguments); ++Ye < Te; ) X[Ye](this, kt);\n                }\n                return typeof se == "function" ? He : Ne;\n              }\n              function Gt(X) {\n                var se = Zt(X);\n                return function(Te, Ne) {\n                  if (He = Te.classList) return Ne ? He.add(X) : He.remove(X);\n                  var He = Te.getAttribute("class") || "";\n                  Ne ? (se.lastIndex = 0, se.test(He) || Te.setAttribute("class", pt(He + " " + X))) : Te.setAttribute("class", pt(He.replace(se, " ")));\n                };\n              }\n              Pe.style = function(X, se, Te) {\n                var Ne = arguments.length;\n                if (Ne < 3) {\n                  if (typeof X != "string") {\n                    Ne < 2 && (se = "");\n                    for (Te in X) this.each(Nt(Te, X[Te], se));\n                    return this;\n                  }\n                  if (Ne < 2) {\n                    var He = this.node();\n                    return a4(He).getComputedStyle(He, null).getPropertyValue(X);\n                  }\n                  Te = "";\n                }\n                return this.each(Nt(X, se, Te));\n              };\n              function Nt(X, se, Te) {\n                function Ne() {\n                  this.style.removeProperty(X);\n                }\n                function He() {\n                  this.style.setProperty(X, se, Te);\n                }\n                function Ye() {\n                  var kt = se.apply(this, arguments);\n                  kt == null ? this.style.removeProperty(X) : this.style.setProperty(X, kt, Te);\n                }\n                return se == null ? Ne : typeof se == "function" ? Ye : He;\n              }\n              Pe.property = function(X, se) {\n                if (arguments.length < 2) {\n                  if (typeof X == "string") return this.node()[X];\n                  for (se in X) this.each(Jt(se, X[se]));\n                  return this;\n                }\n                return this.each(Jt(X, se));\n              };\n              function Jt(X, se) {\n                function Te() {\n                  delete this[X];\n                }\n                function Ne() {\n                  this[X] = se;\n                }\n                function He() {\n                  var Ye = se.apply(this, arguments);\n                  Ye == null ? delete this[X] : this[X] = Ye;\n                }\n                return se == null ? Te : typeof se == "function" ? He : Ne;\n              }\n              Pe.text = function(X) {\n                return arguments.length ? this.each(typeof X == "function" ? function() {\n                  var se = X.apply(this, arguments);\n                  this.textContent = se == null ? "" : se;\n                } : X == null ? function() {\n                  this.textContent = "";\n                } : function() {\n                  this.textContent = X;\n                }) : this.node().textContent;\n              }, Pe.html = function(X) {\n                return arguments.length ? this.each(typeof X == "function" ? function() {\n                  var se = X.apply(this, arguments);\n                  this.innerHTML = se == null ? "" : se;\n                } : X == null ? function() {\n                  this.innerHTML = "";\n                } : function() {\n                  this.innerHTML = X;\n                }) : this.node().innerHTML;\n              }, Pe.append = function(X) {\n                return X = sr(X), this.select(function() {\n                  return this.appendChild(X.apply(this, arguments));\n                });\n              };\n              function sr(X) {\n                function se() {\n                  var Ne = this.ownerDocument, He = this.namespaceURI;\n                  return He === ce && Ne.documentElement.namespaceURI === ce ? Ne.createElement(X) : Ne.createElementNS(He, X);\n                }\n                function Te() {\n                  return this.ownerDocument.createElementNS(X.space, X.local);\n                }\n                return typeof X == "function" ? X : (X = e3.ns.qualify(X)).local ? Te : se;\n              }\n              Pe.insert = function(X, se) {\n                return X = sr(X), se = ge(se), this.select(function() {\n                  return this.insertBefore(X.apply(this, arguments), se.apply(this, arguments) || null);\n                });\n              }, Pe.remove = function() {\n                return this.each(wr);\n              };\n              function wr() {\n                var X = this.parentNode;\n                X && X.removeChild(this);\n              }\n              Pe.data = function(X, se) {\n                var Te = -1, Ne = this.length, He, Ye;\n                if (!arguments.length) {\n                  for (X = new Array(Ne = (He = this[0]).length); ++Te < Ne; ) (Ye = He[Te]) && (X[Te] = Ye.__data__);\n                  return X;\n                }\n                function kt(yr, Hr) {\n                  var qr, _i = yr.length, bi = Hr.length, Zr = Math.min(_i, bi), ai = new Array(bi), gi = new Array(bi), Ii = new Array(_i), Si, ei;\n                  if (se) {\n                    var Ln = new S2(), En = new Array(_i), Un;\n                    for (qr = -1; ++qr < _i; ) (Si = yr[qr]) && (Ln.has(Un = se.call(Si, Si.__data__, qr)) ? Ii[qr] = Si : Ln.set(Un, Si), En[qr] = Un);\n                    for (qr = -1; ++qr < bi; ) (Si = Ln.get(Un = se.call(Hr, ei = Hr[qr], qr))) ? Si !== true && (ai[qr] = Si, Si.__data__ = ei) : gi[qr] = cr(ei), Ln.set(Un, true);\n                    for (qr = -1; ++qr < _i; ) qr in En && Ln.get(En[qr]) !== true && (Ii[qr] = yr[qr]);\n                  } else {\n                    for (qr = -1; ++qr < Zr; ) Si = yr[qr], ei = Hr[qr], Si ? (Si.__data__ = ei, ai[qr] = Si) : gi[qr] = cr(ei);\n                    for (; qr < bi; ++qr) gi[qr] = cr(Hr[qr]);\n                    for (; qr < _i; ++qr) Ii[qr] = yr[qr];\n                  }\n                  gi.update = ai, gi.parentNode = ai.parentNode = Ii.parentNode = yr.parentNode, nt.push(gi), jt.push(ai), gr.push(Ii);\n                }\n                var nt = Vt([]), jt = Se([]), gr = Se([]);\n                if (typeof X == "function") for (; ++Te < Ne; ) kt(He = this[Te], X.call(He, He.parentNode.__data__, Te));\n                else for (; ++Te < Ne; ) kt(He = this[Te], X);\n                return jt.enter = function() {\n                  return nt;\n                }, jt.exit = function() {\n                  return gr;\n                }, jt;\n              };\n              function cr(X) {\n                return { __data__: X };\n              }\n              Pe.datum = function(X) {\n                return arguments.length ? this.property("__data__", X) : this.property("__data__");\n              }, Pe.filter = function(X) {\n                var se = [], Te, Ne, He;\n                typeof X != "function" && (X = $e(X));\n                for (var Ye = 0, kt = this.length; Ye < kt; Ye++) {\n                  se.push(Te = []), Te.parentNode = (Ne = this[Ye]).parentNode;\n                  for (var nt = 0, jt = Ne.length; nt < jt; nt++) (He = Ne[nt]) && X.call(He, He.__data__, nt, Ye) && Te.push(He);\n                }\n                return Se(se);\n              };\n              function $e(X) {\n                return function() {\n                  return Fe(this, X);\n                };\n              }\n              Pe.order = function() {\n                for (var X = -1, se = this.length; ++X < se; ) for (var Te = this[X], Ne = Te.length - 1, He = Te[Ne], Ye; --Ne >= 0; ) (Ye = Te[Ne]) && (He && He !== Ye.nextSibling && He.parentNode.insertBefore(Ye, He), He = Ye);\n                return this;\n              }, Pe.sort = function(X) {\n                X = St.apply(this, arguments);\n                for (var se = -1, Te = this.length; ++se < Te; ) this[se].sort(X);\n                return this.order();\n              };\n              function St(X) {\n                return arguments.length || (X = f4), function(se, Te) {\n                  return se && Te ? X(se.__data__, Te.__data__) : !se - !Te;\n                };\n              }\n              Pe.each = function(X) {\n                return Qt(this, function(se, Te, Ne) {\n                  X.call(se, se.__data__, Te, Ne);\n                });\n              };\n              function Qt(X, se) {\n                for (var Te = 0, Ne = X.length; Te < Ne; Te++) for (var He = X[Te], Ye = 0, kt = He.length, nt; Ye < kt; Ye++) (nt = He[Ye]) && se(nt, Ye, Te);\n                return X;\n              }\n              Pe.call = function(X) {\n                var se = r4(arguments);\n                return X.apply(se[0] = this, se), this;\n              }, Pe.empty = function() {\n                return !this.node();\n              }, Pe.node = function() {\n                for (var X = 0, se = this.length; X < se; X++) for (var Te = this[X], Ne = 0, He = Te.length; Ne < He; Ne++) {\n                  var Ye = Te[Ne];\n                  if (Ye) return Ye;\n                }\n                return null;\n              }, Pe.size = function() {\n                var X = 0;\n                return Qt(this, function() {\n                  ++X;\n                }), X;\n              };\n              function Vt(X) {\n                return ie(X, _t), X;\n              }\n              var _t = [];\n              e3.selection.enter = Vt, e3.selection.enter.prototype = _t, _t.append = Pe.append, _t.empty = Pe.empty, _t.node = Pe.node, _t.call = Pe.call, _t.size = Pe.size, _t.select = function(X) {\n                for (var se = [], Te, Ne, He, Ye, kt, nt = -1, jt = this.length; ++nt < jt; ) {\n                  He = (Ye = this[nt]).update, se.push(Te = []), Te.parentNode = Ye.parentNode;\n                  for (var gr = -1, yr = Ye.length; ++gr < yr; ) (kt = Ye[gr]) ? (Te.push(He[gr] = Ne = X.call(Ye.parentNode, kt.__data__, gr, nt)), Ne.__data__ = kt.__data__) : Te.push(null);\n                }\n                return Se(se);\n              }, _t.insert = function(X, se) {\n                return arguments.length < 2 && (se = It(this)), Pe.insert.call(this, X, se);\n              };\n              function It(X) {\n                var se, Te;\n                return function(Ne, He, Ye) {\n                  var kt = X[Ye].update, nt = kt.length, jt;\n                  for (Ye != Te && (Te = Ye, se = 0), He >= se && (se = He + 1); !(jt = kt[se]) && ++se < nt; ) ;\n                  return jt;\n                };\n              }\n              e3.select = function(X) {\n                var se;\n                return typeof X == "string" ? (se = [Le(X, n4)], se.parentNode = n4.documentElement) : (se = [X], se.parentNode = i3(X)), Se([se]);\n              }, e3.selectAll = function(X) {\n                var se;\n                return typeof X == "string" ? (se = r4(Ae(X, n4)), se.parentNode = n4.documentElement) : (se = r4(X), se.parentNode = null), Se([se]);\n              }, Pe.on = function(X, se, Te) {\n                var Ne = arguments.length;\n                if (Ne < 3) {\n                  if (typeof X != "string") {\n                    Ne < 2 && (se = false);\n                    for (Te in X) this.each(mt(Te, X[Te], se));\n                    return this;\n                  }\n                  if (Ne < 2) return (Ne = this.node()["__on" + X]) && Ne._;\n                  Te = false;\n                }\n                return this.each(mt(X, se, Te));\n              };\n              function mt(X, se, Te) {\n                var Ne = "__on" + X, He = X.indexOf("."), Ye = lr;\n                He > 0 && (X = X.slice(0, He));\n                var kt = er.get(X);\n                kt && (X = kt, Ye = Tr);\n                function nt() {\n                  var yr = this[Ne];\n                  yr && (this.removeEventListener(X, yr, yr.$), delete this[Ne]);\n                }\n                function jt() {\n                  var yr = Ye(se, r4(arguments));\n                  nt.call(this), this.addEventListener(X, this[Ne] = yr, yr.$ = Te), yr._ = se;\n                }\n                function gr() {\n                  var yr = new RegExp("^__on([^.]+)" + e3.requote(X) + "$"), Hr;\n                  for (var qr in this) if (Hr = qr.match(yr)) {\n                    var _i = this[qr];\n                    this.removeEventListener(Hr[1], _i, _i.$), delete this[qr];\n                  }\n                }\n                return He ? se ? jt : nt : se ? H : gr;\n              }\n              var er = e3.map({ mouseenter: "mouseover", mouseleave: "mouseout" });\n              n4 && er.forEach(function(X) {\n                "on" + X in n4 && er.remove(X);\n              });\n              function lr(X, se) {\n                return function(Te) {\n                  var Ne = e3.event;\n                  e3.event = Te, se[0] = this.__data__;\n                  try {\n                    X.apply(this, se);\n                  } finally {\n                    e3.event = Ne;\n                  }\n                };\n              }\n              function Tr(X, se) {\n                var Te = lr(X, se);\n                return function(Ne) {\n                  var He = this, Ye = Ne.relatedTarget;\n                  (!Ye || Ye !== He && !(Ye.compareDocumentPosition(He) & 8)) && Te.call(He, Ne);\n                };\n              }\n              var Lr, ti = 0;\n              function Br(X) {\n                var se = ".dragsuppress-" + ++ti, Te = "click" + se, Ne = e3.select(a4(X)).on("touchmove" + se, _e).on("dragstart" + se, _e).on("selectstart" + se, _e);\n                if (Lr == null && (Lr = "onselectstart" in X ? false : j3(X.style, "userSelect")), Lr) {\n                  var He = i3(X).style, Ye = He[Lr];\n                  He[Lr] = "none";\n                }\n                return function(kt) {\n                  if (Ne.on(se, null), Lr && (He[Lr] = Ye), kt) {\n                    var nt = function() {\n                      Ne.on(Te, null);\n                    };\n                    Ne.on(Te, function() {\n                      _e(), nt();\n                    }, true), setTimeout(nt, 0);\n                  }\n                };\n              }\n              e3.mouse = function(X) {\n                return dt(X, Ee());\n              };\n              var Vr = this.navigator && /WebKit/.test(this.navigator.userAgent) ? -1 : 0;\n              function dt(X, se) {\n                se.changedTouches && (se = se.changedTouches[0]);\n                var Te = X.ownerSVGElement || X;\n                if (Te.createSVGPoint) {\n                  var Ne = Te.createSVGPoint();\n                  if (Vr < 0) {\n                    var He = a4(X);\n                    if (He.scrollX || He.scrollY) {\n                      Te = e3.select("body").append("svg").style({ position: "absolute", top: 0, left: 0, margin: 0, padding: 0, border: "none" }, "important");\n                      var Ye = Te[0][0].getScreenCTM();\n                      Vr = !(Ye.f || Ye.e), Te.remove();\n                    }\n                  }\n                  return Vr ? (Ne.x = se.pageX, Ne.y = se.pageY) : (Ne.x = se.clientX, Ne.y = se.clientY), Ne = Ne.matrixTransform(X.getScreenCTM().inverse()), [Ne.x, Ne.y];\n                }\n                var kt = X.getBoundingClientRect();\n                return [se.clientX - kt.left - X.clientLeft, se.clientY - kt.top - X.clientTop];\n              }\n              e3.touch = function(X, se, Te) {\n                if (arguments.length < 3 && (Te = se, se = Ee().changedTouches), se) {\n                  for (var Ne = 0, He = se.length, Ye; Ne < He; ++Ne) if ((Ye = se[Ne]).identifier === Te) return dt(X, Ye);\n                }\n              }, e3.behavior.drag = function() {\n                var X = Ce(He, "drag", "dragstart", "dragend"), se = null, Te = Ye(H, e3.mouse, a4, "mousemove", "mouseup"), Ne = Ye(Ge, e3.touch, G2, "touchmove", "touchend");\n                function He() {\n                  this.on("mousedown.drag", Te).on("touchstart.drag", Ne);\n                }\n                function Ye(kt, nt, jt, gr, yr) {\n                  return function() {\n                    var Hr = this, qr = e3.event.target.correspondingElement || e3.event.target, _i = Hr.parentNode, bi = X.of(Hr, arguments), Zr = 0, ai = kt(), gi = ".drag" + (ai == null ? "" : "-" + ai), Ii, Si = e3.select(jt(qr)).on(gr + gi, En).on(yr + gi, Un), ei = Br(qr), Ln = nt(_i, ai);\n                    se ? (Ii = se.apply(Hr, arguments), Ii = [Ii.x - Ln[0], Ii.y - Ln[1]]) : Ii = [0, 0], bi({ type: "dragstart" });\n                    function En() {\n                      var ia = nt(_i, ai), Ea, Ia;\n                      ia && (Ea = ia[0] - Ln[0], Ia = ia[1] - Ln[1], Zr |= Ea | Ia, Ln = ia, bi({ type: "drag", x: ia[0] + Ii[0], y: ia[1] + Ii[1], dx: Ea, dy: Ia }));\n                    }\n                    function Un() {\n                      nt(_i, ai) && (Si.on(gr + gi, null).on(yr + gi, null), ei(Zr), bi({ type: "dragend" }));\n                    }\n                  };\n                }\n                return He.origin = function(kt) {\n                  return arguments.length ? (se = kt, He) : se;\n                }, e3.rebind(He, X, "on");\n              };\n              function Ge() {\n                return e3.event.changedTouches[0].identifier;\n              }\n              e3.touches = function(X, se) {\n                return arguments.length < 2 && (se = Ee().touches), se ? r4(se).map(function(Te) {\n                  var Ne = dt(X, Te);\n                  return Ne.identifier = Te.identifier, Ne;\n                }) : [];\n              };\n              var Je = 1e-6, je = Je * Je, tt = Math.PI, xt = 2 * tt, Ie = xt - Je, xe = tt / 2, ke = tt / 180, vt = 180 / tt;\n              function ir(X) {\n                return X > 0 ? 1 : X < 0 ? -1 : 0;\n              }\n              function ar(X, se, Te) {\n                return (se[0] - X[0]) * (Te[1] - X[1]) - (se[1] - X[1]) * (Te[0] - X[0]);\n              }\n              function vr(X) {\n                return X > 1 ? 0 : X < -1 ? tt : Math.acos(X);\n              }\n              function ii(X) {\n                return X > 1 ? xe : X < -1 ? -xe : Math.asin(X);\n              }\n              function pi(X) {\n                return ((X = Math.exp(X)) - 1 / X) / 2;\n              }\n              function $r(X) {\n                return ((X = Math.exp(X)) + 1 / X) / 2;\n              }\n              function di(X) {\n                return ((X = Math.exp(2 * X)) - 1) / (X + 1);\n              }\n              function ji(X) {\n                return (X = Math.sin(X / 2)) * X;\n              }\n              var In = Math.SQRT2, wi = 2, On = 4;\n              e3.interpolateZoom = function(X, se) {\n                var Te = X[0], Ne = X[1], He = X[2], Ye = se[0], kt = se[1], nt = se[2], jt = Ye - Te, gr = kt - Ne, yr = jt * jt + gr * gr, Hr, qr;\n                if (yr < je) qr = Math.log(nt / He) / In, Hr = function(Ii) {\n                  return [Te + Ii * jt, Ne + Ii * gr, He * Math.exp(In * Ii * qr)];\n                };\n                else {\n                  var _i = Math.sqrt(yr), bi = (nt * nt - He * He + On * yr) / (2 * He * wi * _i), Zr = (nt * nt - He * He - On * yr) / (2 * nt * wi * _i), ai = Math.log(Math.sqrt(bi * bi + 1) - bi), gi = Math.log(Math.sqrt(Zr * Zr + 1) - Zr);\n                  qr = (gi - ai) / In, Hr = function(Ii) {\n                    var Si = Ii * qr, ei = $r(ai), Ln = He / (wi * _i) * (ei * di(In * Si + ai) - pi(ai));\n                    return [Te + Ln * jt, Ne + Ln * gr, He * ei / $r(In * Si + ai)];\n                  };\n                }\n                return Hr.duration = qr * 1e3, Hr;\n              }, e3.behavior.zoom = function() {\n                var X = { x: 0, y: 0, k: 1 }, se, Te, Ne, He = [960, 500], Ye = qn, kt = 250, nt = 0, jt = "mousedown.zoom", gr = "mousemove.zoom", yr = "mouseup.zoom", Hr, qr = "touchstart.zoom", _i, bi = Ce(Si, "zoomstart", "zoom", "zoomend"), Zr, ai, gi, Ii;\n                ra || (ra = "onwheel" in n4 ? (Fn = function() {\n                  return -e3.event.deltaY * (e3.event.deltaMode ? 120 : 1);\n                }, "wheel") : "onmousewheel" in n4 ? (Fn = function() {\n                  return e3.event.wheelDelta;\n                }, "mousewheel") : (Fn = function() {\n                  return -e3.event.detail;\n                }, "MozMousePixelScroll"));\n                function Si(Gn) {\n                  Gn.on(jt, go).on(ra + ".zoom", Ms).on("dblclick.zoom", Xs).on(qr, Is);\n                }\n                Si.event = function(Gn) {\n                  Gn.each(function() {\n                    var ja = bi.of(this, arguments), Fo = X;\n                    Bo ? e3.select(this).transition().each("start.zoom", function() {\n                      X = this.__chart__ || { x: 0, y: 0, k: 1 }, Ia(ja);\n                    }).tween("zoom:zoom", function() {\n                      var Uo = He[0], $s = He[1], Sl = Te ? Te[0] : Uo / 2, bu = Te ? Te[1] : $s / 2, dl = e3.interpolateZoom([(Sl - X.x) / X.k, (bu - X.y) / X.k, Uo / X.k], [(Sl - Fo.x) / Fo.k, (bu - Fo.y) / Fo.k, Uo / Fo.k]);\n                      return function(Sc) {\n                        var Me = dl(Sc), bt = Uo / Me[2];\n                        this.__chart__ = X = { x: Sl - Me[0] * bt, y: bu - Me[1] * bt, k: bt }, yo(ja);\n                      };\n                    }).each("interrupt.zoom", function() {\n                      Da(ja);\n                    }).each("end.zoom", function() {\n                      Da(ja);\n                    }) : (this.__chart__ = X, Ia(ja), yo(ja), Da(ja));\n                  });\n                }, Si.translate = function(Gn) {\n                  return arguments.length ? (X = { x: +Gn[0], y: +Gn[1], k: X.k }, Ea(), Si) : [X.x, X.y];\n                }, Si.scale = function(Gn) {\n                  return arguments.length ? (X = { x: X.x, y: X.y, k: null }, En(+Gn), Ea(), Si) : X.k;\n                }, Si.scaleExtent = function(Gn) {\n                  return arguments.length ? (Ye = Gn == null ? qn : [+Gn[0], +Gn[1]], Si) : Ye;\n                }, Si.center = function(Gn) {\n                  return arguments.length ? (Ne = Gn && [+Gn[0], +Gn[1]], Si) : Ne;\n                }, Si.size = function(Gn) {\n                  return arguments.length ? (He = Gn && [+Gn[0], +Gn[1]], Si) : He;\n                }, Si.duration = function(Gn) {\n                  return arguments.length ? (kt = +Gn, Si) : kt;\n                }, Si.x = function(Gn) {\n                  return arguments.length ? (ai = Gn, Zr = Gn.copy(), X = { x: 0, y: 0, k: 1 }, Si) : ai;\n                }, Si.y = function(Gn) {\n                  return arguments.length ? (Ii = Gn, gi = Gn.copy(), X = { x: 0, y: 0, k: 1 }, Si) : Ii;\n                };\n                function ei(Gn) {\n                  return [(Gn[0] - X.x) / X.k, (Gn[1] - X.y) / X.k];\n                }\n                function Ln(Gn) {\n                  return [Gn[0] * X.k + X.x, Gn[1] * X.k + X.y];\n                }\n                function En(Gn) {\n                  X.k = Math.max(Ye[0], Math.min(Ye[1], Gn));\n                }\n                function Un(Gn, ja) {\n                  ja = Ln(ja), X.x += Gn[0] - ja[0], X.y += Gn[1] - ja[1];\n                }\n                function ia(Gn, ja, Fo, Uo) {\n                  Gn.__chart__ = { x: X.x, y: X.y, k: X.k }, En(Math.pow(2, Uo)), Un(Te = ja, Fo), Gn = e3.select(Gn), kt > 0 && (Gn = Gn.transition().duration(kt)), Gn.call(Si.event);\n                }\n                function Ea() {\n                  ai && ai.domain(Zr.range().map(function(Gn) {\n                    return (Gn - X.x) / X.k;\n                  }).map(Zr.invert)), Ii && Ii.domain(gi.range().map(function(Gn) {\n                    return (Gn - X.y) / X.k;\n                  }).map(gi.invert));\n                }\n                function Ia(Gn) {\n                  nt++ || Gn({ type: "zoomstart" });\n                }\n                function yo(Gn) {\n                  Ea(), Gn({ type: "zoom", scale: X.k, translate: [X.x, X.y] });\n                }\n                function Da(Gn) {\n                  --nt || (Gn({ type: "zoomend" }), Te = null);\n                }\n                function go() {\n                  var Gn = this, ja = bi.of(Gn, arguments), Fo = 0, Uo = e3.select(a4(Gn)).on(gr, bu).on(yr, dl), $s = ei(e3.mouse(Gn)), Sl = Br(Gn);\n                  fa.call(Gn), Ia(ja);\n                  function bu() {\n                    Fo = 1, Un(e3.mouse(Gn), $s), yo(ja);\n                  }\n                  function dl() {\n                    Uo.on(gr, null).on(yr, null), Sl(Fo), Da(ja);\n                  }\n                }\n                function Is() {\n                  var Gn = this, ja = bi.of(Gn, arguments), Fo = {}, Uo = 0, $s, Sl = ".zoom-" + e3.event.changedTouches[0].identifier, bu = "touchmove" + Sl, dl = "touchend" + Sl, Sc = [], Me = e3.select(Gn), bt = Br(Gn);\n                  Rr(), Ia(ja), Me.on(jt, null).on(qr, Rr);\n                  function zt() {\n                    var Gr = e3.touches(Gn);\n                    return $s = X.k, Gr.forEach(function(mi) {\n                      mi.identifier in Fo && (Fo[mi.identifier] = ei(mi));\n                    }), Gr;\n                  }\n                  function Rr() {\n                    var Gr = e3.event.target;\n                    e3.select(Gr).on(bu, jr).on(dl, Nr), Sc.push(Gr);\n                    for (var mi = e3.event.changedTouches, Ui = 0, qi = mi.length; Ui < qi; ++Ui) Fo[mi[Ui].identifier] = null;\n                    var Ei = zt(), Hn = Date.now();\n                    if (Ei.length === 1) {\n                      if (Hn - _i < 500) {\n                        var en = Ei[0];\n                        ia(Gn, en, Fo[en.identifier], Math.floor(Math.log(X.k) / Math.LN2) + 1), _e();\n                      }\n                      _i = Hn;\n                    } else if (Ei.length > 1) {\n                      var en = Ei[0], Wi = Ei[1], si = en[0] - Wi[0], Mr = en[1] - Wi[1];\n                      Uo = si * si + Mr * Mr;\n                    }\n                  }\n                  function jr() {\n                    var Gr = e3.touches(Gn), mi, Ui, qi, Ei;\n                    fa.call(Gn);\n                    for (var Hn = 0, en = Gr.length; Hn < en; ++Hn, Ei = null) if (qi = Gr[Hn], Ei = Fo[qi.identifier]) {\n                      if (Ui) break;\n                      mi = qi, Ui = Ei;\n                    }\n                    if (Ei) {\n                      var Wi = (Wi = qi[0] - mi[0]) * Wi + (Wi = qi[1] - mi[1]) * Wi, si = Uo && Math.sqrt(Wi / Uo);\n                      mi = [(mi[0] + qi[0]) / 2, (mi[1] + qi[1]) / 2], Ui = [(Ui[0] + Ei[0]) / 2, (Ui[1] + Ei[1]) / 2], En(si * $s);\n                    }\n                    _i = null, Un(mi, Ui), yo(ja);\n                  }\n                  function Nr() {\n                    if (e3.event.touches.length) {\n                      for (var Gr = e3.event.changedTouches, mi = 0, Ui = Gr.length; mi < Ui; ++mi) delete Fo[Gr[mi].identifier];\n                      for (var qi in Fo) return void zt();\n                    }\n                    e3.selectAll(Sc).on(Sl, null), Me.on(jt, go).on(qr, Is), bt(), Da(ja);\n                  }\n                }\n                function Ms() {\n                  var Gn = bi.of(this, arguments);\n                  Hr ? clearTimeout(Hr) : (fa.call(this), se = ei(Te = Ne || e3.mouse(this)), Ia(Gn)), Hr = setTimeout(function() {\n                    Hr = null, Da(Gn);\n                  }, 50), _e(), En(Math.pow(2, Fn() * 2e-3) * X.k), Un(Te, se), yo(Gn);\n                }\n                function Xs() {\n                  var Gn = e3.mouse(this), ja = Math.log(X.k) / Math.LN2;\n                  ia(this, Gn, ei(Gn), e3.event.shiftKey ? Math.ceil(ja) - 1 : Math.floor(ja) + 1);\n                }\n                return e3.rebind(Si, bi, "on");\n              };\n              var qn = [0, 1 / 0], Fn, ra;\n              e3.color = la;\n              function la() {\n              }\n              la.prototype.toString = function() {\n                return this.rgb() + "";\n              }, e3.hsl = Ut;\n              function Ut(X, se, Te) {\n                return this instanceof Ut ? (this.h = +X, this.s = +se, void (this.l = +Te)) : arguments.length < 2 ? X instanceof Ut ? new Ut(X.h, X.s, X.l) : Ha("" + X, vo, Ut) : new Ut(X, se, Te);\n              }\n              var wt = Ut.prototype = new la();\n              wt.brighter = function(X) {\n                return X = Math.pow(0.7, arguments.length ? X : 1), new Ut(this.h, this.s, this.l / X);\n              }, wt.darker = function(X) {\n                return X = Math.pow(0.7, arguments.length ? X : 1), new Ut(this.h, this.s, X * this.l);\n              }, wt.rgb = function() {\n                return rr(this.h, this.s, this.l);\n              };\n              function rr(X, se, Te) {\n                var Ne, He;\n                X = isNaN(X) ? 0 : (X %= 360) < 0 ? X + 360 : X, se = isNaN(se) || se < 0 ? 0 : se > 1 ? 1 : se, Te = Te < 0 ? 0 : Te > 1 ? 1 : Te, He = Te <= 0.5 ? Te * (1 + se) : Te + se - Te * se, Ne = 2 * Te - He;\n                function Ye(nt) {\n                  return nt > 360 ? nt -= 360 : nt < 0 && (nt += 360), nt < 60 ? Ne + (He - Ne) * nt / 60 : nt < 180 ? He : nt < 240 ? Ne + (He - Ne) * (240 - nt) / 60 : Ne;\n                }\n                function kt(nt) {\n                  return Math.round(Ye(nt) * 255);\n                }\n                return new Wa(kt(X + 120), kt(X), kt(X - 120));\n              }\n              e3.hcl = nr;\n              function nr(X, se, Te) {\n                return this instanceof nr ? (this.h = +X, this.c = +se, void (this.l = +Te)) : arguments.length < 2 ? X instanceof nr ? new nr(X.h, X.c, X.l) : X instanceof ri ? Sn(X.l, X.a, X.b) : Sn((X = jn((X = e3.rgb(X)).r, X.g, X.b)).l, X.a, X.b) : new nr(X, se, Te);\n              }\n              var Er = nr.prototype = new la();\n              Er.brighter = function(X) {\n                return new nr(this.h, this.c, Math.min(100, this.l + Qr * (arguments.length ? X : 1)));\n              }, Er.darker = function(X) {\n                return new nr(this.h, this.c, Math.max(0, this.l - Qr * (arguments.length ? X : 1)));\n              }, Er.rgb = function() {\n                return Xr(this.h, this.c, this.l).rgb();\n              };\n              function Xr(X, se, Te) {\n                return isNaN(X) && (X = 0), isNaN(se) && (se = 0), new ri(Te, Math.cos(X *= ke) * se, Math.sin(X) * se);\n              }\n              e3.lab = ri;\n              function ri(X, se, Te) {\n                return this instanceof ri ? (this.l = +X, this.a = +se, void (this.b = +Te)) : arguments.length < 2 ? X instanceof ri ? new ri(X.l, X.a, X.b) : X instanceof nr ? Xr(X.h, X.c, X.l) : jn((X = Wa(X)).r, X.g, X.b) : new ri(X, se, Te);\n              }\n              var Qr = 18, Oi = 0.95047, $i = 1, tn = 1.08883, fn = ri.prototype = new la();\n              fn.brighter = function(X) {\n                return new ri(Math.min(100, this.l + Qr * (arguments.length ? X : 1)), this.a, this.b);\n              }, fn.darker = function(X) {\n                return new ri(Math.max(0, this.l - Qr * (arguments.length ? X : 1)), this.a, this.b);\n              }, fn.rgb = function() {\n                return yn(this.l, this.a, this.b);\n              };\n              function yn(X, se, Te) {\n                var Ne = (X + 16) / 116, He = Ne + se / 500, Ye = Ne - Te / 200;\n                return He = Ba(He) * Oi, Ne = Ba(Ne) * $i, Ye = Ba(Ye) * tn, new Wa(ma(3.2404542 * He - 1.5371385 * Ne - 0.4985314 * Ye), ma(-0.969266 * He + 1.8760108 * Ne + 0.041556 * Ye), ma(0.0556434 * He - 0.2040259 * Ne + 1.0572252 * Ye));\n              }\n              function Sn(X, se, Te) {\n                return X > 0 ? new nr(Math.atan2(Te, se) * vt, Math.sqrt(se * se + Te * Te), X) : new nr(NaN, NaN, X);\n              }\n              function Ba(X) {\n                return X > 0.206893034 ? X * X * X : (X - 4 / 29) / 7.787037;\n              }\n              function ua(X) {\n                return X > 8856e-6 ? Math.pow(X, 1 / 3) : 7.787037 * X + 4 / 29;\n              }\n              function ma(X) {\n                return Math.round(255 * (X <= 304e-5 ? 12.92 * X : 1.055 * Math.pow(X, 1 / 2.4) - 0.055));\n              }\n              e3.rgb = Wa;\n              function Wa(X, se, Te) {\n                return this instanceof Wa ? (this.r = ~~X, this.g = ~~se, void (this.b = ~~Te)) : arguments.length < 2 ? X instanceof Wa ? new Wa(X.r, X.g, X.b) : Ha("" + X, Wa, rr) : new Wa(X, se, Te);\n              }\n              function Fa(X) {\n                return new Wa(X >> 16, X >> 8 & 255, X & 255);\n              }\n              function Wo(X) {\n                return Fa(X) + "";\n              }\n              var da = Wa.prototype = new la();\n              da.brighter = function(X) {\n                X = Math.pow(0.7, arguments.length ? X : 1);\n                var se = this.r, Te = this.g, Ne = this.b, He = 30;\n                return !se && !Te && !Ne ? new Wa(He, He, He) : (se && se < He && (se = He), Te && Te < He && (Te = He), Ne && Ne < He && (Ne = He), new Wa(Math.min(255, se / X), Math.min(255, Te / X), Math.min(255, Ne / X)));\n              }, da.darker = function(X) {\n                return X = Math.pow(0.7, arguments.length ? X : 1), new Wa(X * this.r, X * this.g, X * this.b);\n              }, da.hsl = function() {\n                return vo(this.r, this.g, this.b);\n              }, da.toString = function() {\n                return "#" + Wn(this.r) + Wn(this.g) + Wn(this.b);\n              };\n              function Wn(X) {\n                return X < 16 ? "0" + Math.max(0, X).toString(16) : Math.min(255, X).toString(16);\n              }\n              function Ha(X, se, Te) {\n                var Ne = 0, He = 0, Ye = 0, kt, nt, jt;\n                if (kt = /([a-z]+)\\((.*)\\)/.exec(X = X.toLowerCase()), kt) switch (nt = kt[2].split(","), kt[1]) {\n                  case "hsl":\n                    return Te(parseFloat(nt[0]), parseFloat(nt[1]) / 100, parseFloat(nt[2]) / 100);\n                  case "rgb":\n                    return se(kr(nt[0]), kr(nt[1]), kr(nt[2]));\n                }\n                return (jt = Jr.get(X)) ? se(jt.r, jt.g, jt.b) : (X != null && X.charAt(0) === "#" && !isNaN(jt = parseInt(X.slice(1), 16)) && (X.length === 4 ? (Ne = (jt & 3840) >> 4, Ne = Ne >> 4 | Ne, He = jt & 240, He = He >> 4 | He, Ye = jt & 15, Ye = Ye << 4 | Ye) : X.length === 7 && (Ne = (jt & 16711680) >> 16, He = (jt & 65280) >> 8, Ye = jt & 255)), se(Ne, He, Ye));\n              }\n              function vo(X, se, Te) {\n                var Ne = Math.min(X /= 255, se /= 255, Te /= 255), He = Math.max(X, se, Te), Ye = He - Ne, kt, nt, jt = (He + Ne) / 2;\n                return Ye ? (nt = jt < 0.5 ? Ye / (He + Ne) : Ye / (2 - He - Ne), X == He ? kt = (se - Te) / Ye + (se < Te ? 6 : 0) : se == He ? kt = (Te - X) / Ye + 2 : kt = (X - se) / Ye + 4, kt *= 60) : (kt = NaN, nt = jt > 0 && jt < 1 ? 0 : kt), new Ut(kt, nt, jt);\n              }\n              function jn(X, se, Te) {\n                X = Mt(X), se = Mt(se), Te = Mt(Te);\n                var Ne = ua((0.4124564 * X + 0.3575761 * se + 0.1804375 * Te) / Oi), He = ua((0.2126729 * X + 0.7151522 * se + 0.072175 * Te) / $i), Ye = ua((0.0193339 * X + 0.119192 * se + 0.9503041 * Te) / tn);\n                return ri(116 * He - 16, 500 * (Ne - He), 200 * (He - Ye));\n              }\n              function Mt(X) {\n                return (X /= 255) <= 0.04045 ? X / 12.92 : Math.pow((X + 0.055) / 1.055, 2.4);\n              }\n              function kr(X) {\n                var se = parseFloat(X);\n                return X.charAt(X.length - 1) === "%" ? Math.round(se * 2.55) : se;\n              }\n              var Jr = e3.map({ aliceblue: 15792383, antiquewhite: 16444375, aqua: 65535, aquamarine: 8388564, azure: 15794175, beige: 16119260, bisque: 16770244, black: 0, blanchedalmond: 16772045, blue: 255, blueviolet: 9055202, brown: 10824234, burlywood: 14596231, cadetblue: 6266528, chartreuse: 8388352, chocolate: 13789470, coral: 16744272, cornflowerblue: 6591981, cornsilk: 16775388, crimson: 14423100, cyan: 65535, darkblue: 139, darkcyan: 35723, darkgoldenrod: 12092939, darkgray: 11119017, darkgreen: 25600, darkgrey: 11119017, darkkhaki: 12433259, darkmagenta: 9109643, darkolivegreen: 5597999, darkorange: 16747520, darkorchid: 10040012, darkred: 9109504, darksalmon: 15308410, darkseagreen: 9419919, darkslateblue: 4734347, darkslategray: 3100495, darkslategrey: 3100495, darkturquoise: 52945, darkviolet: 9699539, deeppink: 16716947, deepskyblue: 49151, dimgray: 6908265, dimgrey: 6908265, dodgerblue: 2003199, firebrick: 11674146, floralwhite: 16775920, forestgreen: 2263842, fuchsia: 16711935, gainsboro: 14474460, ghostwhite: 16316671, gold: 16766720, goldenrod: 14329120, gray: 8421504, green: 32768, greenyellow: 11403055, grey: 8421504, honeydew: 15794160, hotpink: 16738740, indianred: 13458524, indigo: 4915330, ivory: 16777200, khaki: 15787660, lavender: 15132410, lavenderblush: 16773365, lawngreen: 8190976, lemonchiffon: 16775885, lightblue: 11393254, lightcoral: 15761536, lightcyan: 14745599, lightgoldenrodyellow: 16448210, lightgray: 13882323, lightgreen: 9498256, lightgrey: 13882323, lightpink: 16758465, lightsalmon: 16752762, lightseagreen: 2142890, lightskyblue: 8900346, lightslategray: 7833753, lightslategrey: 7833753, lightsteelblue: 11584734, lightyellow: 16777184, lime: 65280, limegreen: 3329330, linen: 16445670, magenta: 16711935, maroon: 8388608, mediumaquamarine: 6737322, mediumblue: 205, mediumorchid: 12211667, mediumpurple: 9662683, mediumseagreen: 3978097, mediumslateblue: 8087790, mediumspringgreen: 64154, mediumturquoise: 4772300, mediumvioletred: 13047173, midnightblue: 1644912, mintcream: 16121850, mistyrose: 16770273, moccasin: 16770229, navajowhite: 16768685, navy: 128, oldlace: 16643558, olive: 8421376, olivedrab: 7048739, orange: 16753920, orangered: 16729344, orchid: 14315734, palegoldenrod: 15657130, palegreen: 10025880, paleturquoise: 11529966, palevioletred: 14381203, papayawhip: 16773077, peachpuff: 16767673, peru: 13468991, pink: 16761035, plum: 14524637, powderblue: 11591910, purple: 8388736, rebeccapurple: 6697881, red: 16711680, rosybrown: 12357519, royalblue: 4286945, saddlebrown: 9127187, salmon: 16416882, sandybrown: 16032864, seagreen: 3050327, seashell: 16774638, sienna: 10506797, silver: 12632256, skyblue: 8900331, slateblue: 6970061, slategray: 7372944, slategrey: 7372944, snow: 16775930, springgreen: 65407, steelblue: 4620980, tan: 13808780, teal: 32896, thistle: 14204888, tomato: 16737095, turquoise: 4251856, violet: 15631086, wheat: 16113331, white: 16777215, whitesmoke: 16119285, yellow: 16776960, yellowgreen: 10145074 });\n              Jr.forEach(function(X, se) {\n                Jr.set(X, Fa(se));\n              });\n              function vi(X) {\n                return typeof X == "function" ? X : function() {\n                  return X;\n                };\n              }\n              e3.functor = vi, e3.xhr = hn(G2);\n              function hn(X) {\n                return function(se, Te, Ne) {\n                  return arguments.length === 2 && typeof Te == "function" && (Ne = Te, Te = null), An(se, Te, X, Ne);\n                };\n              }\n              function An(X, se, Te, Ne) {\n                var He = {}, Ye = e3.dispatch("beforesend", "progress", "load", "error"), kt = {}, nt = new XMLHttpRequest(), jt = null;\n                self.XDomainRequest && !("withCredentials" in nt) && /^(http(s)?:)?\\/\\//.test(X) && (nt = new XDomainRequest()), "onload" in nt ? nt.onload = nt.onerror = gr : nt.onreadystatechange = function() {\n                  nt.readyState > 3 && gr();\n                };\n                function gr() {\n                  var yr = nt.status, Hr;\n                  if (!yr && Li(nt) || yr >= 200 && yr < 300 || yr === 304) {\n                    try {\n                      Hr = Te.call(He, nt);\n                    } catch (qr) {\n                      Ye.error.call(He, qr);\n                      return;\n                    }\n                    Ye.load.call(He, Hr);\n                  } else Ye.error.call(He, nt);\n                }\n                return nt.onprogress = function(yr) {\n                  var Hr = e3.event;\n                  e3.event = yr;\n                  try {\n                    Ye.progress.call(He, nt);\n                  } finally {\n                    e3.event = Hr;\n                  }\n                }, He.header = function(yr, Hr) {\n                  return yr = (yr + "").toLowerCase(), arguments.length < 2 ? kt[yr] : (Hr == null ? delete kt[yr] : kt[yr] = Hr + "", He);\n                }, He.mimeType = function(yr) {\n                  return arguments.length ? (se = yr == null ? null : yr + "", He) : se;\n                }, He.responseType = function(yr) {\n                  return arguments.length ? (jt = yr, He) : jt;\n                }, He.response = function(yr) {\n                  return Te = yr, He;\n                }, ["get", "post"].forEach(function(yr) {\n                  He[yr] = function() {\n                    return He.send.apply(He, [yr].concat(r4(arguments)));\n                  };\n                }), He.send = function(yr, Hr, qr) {\n                  if (arguments.length === 2 && typeof Hr == "function" && (qr = Hr, Hr = null), nt.open(yr, X, true), se != null && !("accept" in kt) && (kt.accept = se + ",*/*"), nt.setRequestHeader) for (var _i in kt) nt.setRequestHeader(_i, kt[_i]);\n                  return se != null && nt.overrideMimeType && nt.overrideMimeType(se), jt != null && (nt.responseType = jt), qr != null && He.on("error", qr).on("load", function(bi) {\n                    qr(null, bi);\n                  }), Ye.beforesend.call(He, nt), nt.send(Hr == null ? null : Hr), He;\n                }, He.abort = function() {\n                  return nt.abort(), He;\n                }, e3.rebind(He, Ye, "on"), Ne == null ? He : He.get(Mn(Ne));\n              }\n              function Mn(X) {\n                return X.length === 1 ? function(se, Te) {\n                  X(se == null ? Te : null);\n                } : X;\n              }\n              function Li(X) {\n                var se = X.responseType;\n                return se && se !== "text" ? X.response : X.responseText;\n              }\n              e3.dsv = function(X, se) {\n                var Te = new RegExp(\'["\' + X + `\n]`), Ne = X.charCodeAt(0);\n                function He(gr, yr, Hr) {\n                  arguments.length < 3 && (Hr = yr, yr = null);\n                  var qr = An(gr, se, yr == null ? Ye : kt(yr), Hr);\n                  return qr.row = function(_i) {\n                    return arguments.length ? qr.response((yr = _i) == null ? Ye : kt(_i)) : yr;\n                  }, qr;\n                }\n                function Ye(gr) {\n                  return He.parse(gr.responseText);\n                }\n                function kt(gr) {\n                  return function(yr) {\n                    return He.parse(yr.responseText, gr);\n                  };\n                }\n                He.parse = function(gr, yr) {\n                  var Hr;\n                  return He.parseRows(gr, function(qr, _i) {\n                    if (Hr) return Hr(qr, _i - 1);\n                    var bi = function(Zr) {\n                      for (var ai = {}, gi = qr.length, Ii = 0; Ii < gi; ++Ii) ai[qr[Ii]] = Zr[Ii];\n                      return ai;\n                    };\n                    Hr = yr ? function(Zr, ai) {\n                      return yr(bi(Zr), ai);\n                    } : bi;\n                  });\n                }, He.parseRows = function(gr, yr) {\n                  var Hr = {}, qr = {}, _i = [], bi = gr.length, Zr = 0, ai = 0, gi, Ii;\n                  function Si() {\n                    if (Zr >= bi) return qr;\n                    if (Ii) return Ii = false, Hr;\n                    var Ln = Zr;\n                    if (gr.charCodeAt(Ln) === 34) {\n                      for (var En = Ln; En++ < bi; ) if (gr.charCodeAt(En) === 34) {\n                        if (gr.charCodeAt(En + 1) !== 34) break;\n                        ++En;\n                      }\n                      Zr = En + 2;\n                      var Un = gr.charCodeAt(En + 1);\n                      return Un === 13 ? (Ii = true, gr.charCodeAt(En + 2) === 10 && ++Zr) : Un === 10 && (Ii = true), gr.slice(Ln + 1, En).replace(/""/g, \'"\');\n                    }\n                    for (; Zr < bi; ) {\n                      var Un = gr.charCodeAt(Zr++), ia = 1;\n                      if (Un === 10) Ii = true;\n                      else if (Un === 13) Ii = true, gr.charCodeAt(Zr) === 10 && (++Zr, ++ia);\n                      else if (Un !== Ne) continue;\n                      return gr.slice(Ln, Zr - ia);\n                    }\n                    return gr.slice(Ln);\n                  }\n                  for (; (gi = Si()) !== qr; ) {\n                    for (var ei = []; gi !== Hr && gi !== qr; ) ei.push(gi), gi = Si();\n                    yr && (ei = yr(ei, ai++)) == null || _i.push(ei);\n                  }\n                  return _i;\n                }, He.format = function(gr) {\n                  if (Array.isArray(gr[0])) return He.formatRows(gr);\n                  var yr = new V2(), Hr = [];\n                  return gr.forEach(function(qr) {\n                    for (var _i in qr) yr.has(_i) || Hr.push(yr.add(_i));\n                  }), [Hr.map(jt).join(X)].concat(gr.map(function(qr) {\n                    return Hr.map(function(_i) {\n                      return jt(qr[_i]);\n                    }).join(X);\n                  })).join(`\n`);\n                }, He.formatRows = function(gr) {\n                  return gr.map(nt).join(`\n`);\n                };\n                function nt(gr) {\n                  return gr.map(jt).join(X);\n                }\n                function jt(gr) {\n                  return Te.test(gr) ? \'"\' + gr.replace(/\\"/g, \'""\') + \'"\' : gr;\n                }\n                return He;\n              }, e3.csv = e3.dsv(",", "text/csv"), e3.tsv = e3.dsv("	", "text/tab-separated-values");\n              var _n, ya, Jn, Ma, _o = this[j3(this, "requestAnimationFrame")] || function(X) {\n                setTimeout(X, 17);\n              };\n              e3.timer = function() {\n                No.apply(this, arguments);\n              };\n              function No(X, se, Te) {\n                var Ne = arguments.length;\n                Ne < 2 && (se = 0), Ne < 3 && (Te = Date.now());\n                var He = Te + se, Ye = { c: X, t: He, n: null };\n                return ya ? ya.n = Ye : _n = Ye, ya = Ye, Jn || (Ma = clearTimeout(Ma), Jn = 1, _o(po)), Ye;\n              }\n              function po() {\n                var X = Lo(), se = ko() - X;\n                se > 24 ? (isFinite(se) && (clearTimeout(Ma), Ma = setTimeout(po, se)), Jn = 0) : (Jn = 1, _o(po));\n              }\n              e3.timer.flush = function() {\n                Lo(), ko();\n              };\n              function Lo() {\n                for (var X = Date.now(), se = _n; se; ) X >= se.t && se.c(X - se.t) && (se.c = null), se = se.n;\n                return X;\n              }\n              function ko() {\n                for (var X, se = _n, Te = 1 / 0; se; ) se.c ? (se.t < Te && (Te = se.t), se = (X = se).n) : se = X ? X.n = se.n : _n = se.n;\n                return ya = X, Te;\n              }\n              e3.round = function(X, se) {\n                return se ? Math.round(X * (se = Math.pow(10, se))) / se : Math.round(X);\n              }, e3.geom = {};\n              function Ds(X) {\n                return X[0];\n              }\n              function Fs(X) {\n                return X[1];\n              }\n              e3.geom.hull = function(X) {\n                var se = Ds, Te = Fs;\n                if (arguments.length) return Ne(X);\n                function Ne(He) {\n                  if (He.length < 3) return [];\n                  var Ye = vi(se), kt = vi(Te), nt, jt = He.length, gr = [], yr = [];\n                  for (nt = 0; nt < jt; nt++) gr.push([+Ye.call(this, He[nt], nt), +kt.call(this, He[nt], nt), nt]);\n                  for (gr.sort(ul), nt = 0; nt < jt; nt++) yr.push([gr[nt][0], -gr[nt][1]]);\n                  var Hr = ll(gr), qr = ll(yr), _i = qr[0] === Hr[0], bi = qr[qr.length - 1] === Hr[Hr.length - 1], Zr = [];\n                  for (nt = Hr.length - 1; nt >= 0; --nt) Zr.push(He[gr[Hr[nt]][2]]);\n                  for (nt = +_i; nt < qr.length - bi; ++nt) Zr.push(He[gr[qr[nt]][2]]);\n                  return Zr;\n                }\n                return Ne.x = function(He) {\n                  return arguments.length ? (se = He, Ne) : se;\n                }, Ne.y = function(He) {\n                  return arguments.length ? (Te = He, Ne) : Te;\n                }, Ne;\n              };\n              function ll(X) {\n                for (var se = X.length, Te = [0, 1], Ne = 2, He = 2; He < se; He++) {\n                  for (; Ne > 1 && ar(X[Te[Ne - 2]], X[Te[Ne - 1]], X[He]) <= 0; ) --Ne;\n                  Te[Ne++] = He;\n                }\n                return Te.slice(0, Ne);\n              }\n              function ul(X, se) {\n                return X[0] - se[0] || X[1] - se[1];\n              }\n              e3.geom.polygon = function(X) {\n                return ie(X, zl), X;\n              };\n              var zl = e3.geom.polygon.prototype = [];\n              zl.area = function() {\n                for (var X = -1, se = this.length, Te, Ne = this[se - 1], He = 0; ++X < se; ) Te = Ne, Ne = this[X], He += Te[1] * Ne[0] - Te[0] * Ne[1];\n                return He * 0.5;\n              }, zl.centroid = function(X) {\n                var se = -1, Te = this.length, Ne = 0, He = 0, Ye, kt = this[Te - 1], nt;\n                for (arguments.length || (X = -1 / (6 * this.area())); ++se < Te; ) Ye = kt, kt = this[se], nt = Ye[0] * kt[1] - kt[0] * Ye[1], Ne += (Ye[0] + kt[0]) * nt, He += (Ye[1] + kt[1]) * nt;\n                return [Ne * X, He * X];\n              }, zl.clip = function(X) {\n                for (var se, Te = As(X), Ne = -1, He = this.length - As(this), Ye, kt, nt = this[He - 1], jt, gr, yr; ++Ne < He; ) {\n                  for (se = X.slice(), X.length = 0, jt = this[Ne], gr = se[(kt = se.length - Te) - 1], Ye = -1; ++Ye < kt; ) yr = se[Ye], us(yr, nt, jt) ? (us(gr, nt, jt) || X.push(il(gr, yr, nt, jt)), X.push(yr)) : us(gr, nt, jt) && X.push(il(gr, yr, nt, jt)), gr = yr;\n                  Te && X.push(X[0]), nt = jt;\n                }\n                return X;\n              };\n              function us(X, se, Te) {\n                return (Te[0] - se[0]) * (X[1] - se[1]) < (Te[1] - se[1]) * (X[0] - se[0]);\n              }\n              function il(X, se, Te, Ne) {\n                var He = X[0], Ye = Te[0], kt = se[0] - He, nt = Ne[0] - Ye, jt = X[1], gr = Te[1], yr = se[1] - jt, Hr = Ne[1] - gr, qr = (nt * (jt - gr) - Hr * (He - Ye)) / (Hr * kt - nt * yr);\n                return [He + qr * kt, jt + qr * yr];\n              }\n              function As(X) {\n                var se = X[0], Te = X[X.length - 1];\n                return !(se[0] - Te[0] || se[1] - Te[1]);\n              }\n              var cl, Ks, zs, Io = [], ls, Zl, Su = [];\n              function nc() {\n                Os(this), this.edge = this.site = this.circle = null;\n              }\n              function bs(X) {\n                var se = Io.pop() || new nc();\n                return se.site = X, se;\n              }\n              function Rn(X) {\n                Oo(X), zs.remove(X), Io.push(X), Os(X);\n              }\n              function _a(X) {\n                var se = X.circle, Te = se.x, Ne = se.cy, He = { x: Te, y: Ne }, Ye = X.P, kt = X.N, nt = [X];\n                Rn(X);\n                for (var jt = Ye; jt.circle && p3(Te - jt.circle.x) < Je && p3(Ne - jt.circle.cy) < Je; ) Ye = jt.P, nt.unshift(jt), Rn(jt), jt = Ye;\n                nt.unshift(jt), Oo(jt);\n                for (var gr = kt; gr.circle && p3(Te - gr.circle.x) < Je && p3(Ne - gr.circle.cy) < Je; ) kt = gr.N, nt.push(gr), Rn(gr), gr = kt;\n                nt.push(gr), Oo(gr);\n                var yr = nt.length, Hr;\n                for (Hr = 1; Hr < yr; ++Hr) gr = nt[Hr], jt = nt[Hr - 1], pl(gr.edge, jt.site, gr.site, He);\n                jt = nt[0], gr = nt[yr - 1], gr.edge = rf(jt.site, gr.site, null, He), aa(jt), aa(gr);\n              }\n              function Vu(X) {\n                for (var se = X.x, Te = X.y, Ne, He, Ye, kt, nt = zs._; nt; ) if (Ye = Ol(nt, Te) - se, Ye > Je) nt = nt.L;\n                else if (kt = se - xo(nt, Te), kt > Je) {\n                  if (!nt.R) {\n                    Ne = nt;\n                    break;\n                  }\n                  nt = nt.R;\n                } else {\n                  Ye > -Je ? (Ne = nt.P, He = nt) : kt > -Je ? (Ne = nt, He = nt.N) : Ne = He = nt;\n                  break;\n                }\n                var jt = bs(X);\n                if (zs.insert(Ne, jt), !(!Ne && !He)) {\n                  if (Ne === He) {\n                    Oo(Ne), He = bs(Ne.site), zs.insert(jt, He), jt.edge = He.edge = rf(Ne.site, jt.site), aa(Ne), aa(He);\n                    return;\n                  }\n                  if (!He) {\n                    jt.edge = rf(Ne.site, jt.site);\n                    return;\n                  }\n                  Oo(Ne), Oo(He);\n                  var gr = Ne.site, yr = gr.x, Hr = gr.y, qr = X.x - yr, _i = X.y - Hr, bi = He.site, Zr = bi.x - yr, ai = bi.y - Hr, gi = 2 * (qr * ai - _i * Zr), Ii = qr * qr + _i * _i, Si = Zr * Zr + ai * ai, ei = { x: (ai * Ii - _i * Si) / gi + yr, y: (qr * Si - Zr * Ii) / gi + Hr };\n                  pl(He.edge, gr, bi, ei), jt.edge = rf(gr, X, null, ei), He.edge = rf(X, bi, null, ei), aa(Ne), aa(He);\n                }\n              }\n              function Ol(X, se) {\n                var Te = X.site, Ne = Te.x, He = Te.y, Ye = He - se;\n                if (!Ye) return Ne;\n                var kt = X.P;\n                if (!kt) return -1 / 0;\n                Te = kt.site;\n                var nt = Te.x, jt = Te.y, gr = jt - se;\n                if (!gr) return nt;\n                var yr = nt - Ne, Hr = 1 / Ye - 1 / gr, qr = yr / gr;\n                return Hr ? (-qr + Math.sqrt(qr * qr - 2 * Hr * (yr * yr / (-2 * gr) - jt + gr / 2 + He - Ye / 2))) / Hr + Ne : (Ne + nt) / 2;\n              }\n              function xo(X, se) {\n                var Te = X.N;\n                if (Te) return Ol(Te, se);\n                var Ne = X.site;\n                return Ne.y === se ? Ne.x : 1 / 0;\n              }\n              function Yl(X) {\n                this.site = X, this.edges = [];\n              }\n              Yl.prototype.prepare = function() {\n                for (var X = this.edges, se = X.length, Te; se--; ) Te = X[se].edge, (!Te.b || !Te.a) && X.splice(se, 1);\n                return X.sort(Hl), X.length;\n              };\n              function Ns(X) {\n                for (var se = X[0][0], Te = X[1][0], Ne = X[0][1], He = X[1][1], Ye, kt, nt, jt, gr = Ks, yr = gr.length, Hr, qr, _i, bi, Zr, ai; yr--; ) if (Hr = gr[yr], !(!Hr || !Hr.prepare())) for (_i = Hr.edges, bi = _i.length, qr = 0; qr < bi; ) ai = _i[qr].end(), nt = ai.x, jt = ai.y, Zr = _i[++qr % bi].start(), Ye = Zr.x, kt = Zr.y, (p3(nt - Ye) > Je || p3(jt - kt) > Je) && (_i.splice(qr, 0, new Zc(Uf(Hr.site, ai, p3(nt - se) < Je && He - jt > Je ? { x: se, y: p3(Ye - se) < Je ? kt : He } : p3(jt - He) < Je && Te - nt > Je ? { x: p3(kt - He) < Je ? Ye : Te, y: He } : p3(nt - Te) < Je && jt - Ne > Je ? { x: Te, y: p3(Ye - Te) < Je ? kt : Ne } : p3(jt - Ne) < Je && nt - se > Je ? { x: p3(kt - Ne) < Je ? Ye : se, y: Ne } : null), Hr.site, null)), ++bi);\n              }\n              function Hl(X, se) {\n                return se.angle - X.angle;\n              }\n              function ac() {\n                Os(this), this.x = this.y = this.arc = this.site = this.cy = null;\n              }\n              function aa(X) {\n                var se = X.P, Te = X.N;\n                if (!(!se || !Te)) {\n                  var Ne = se.site, He = X.site, Ye = Te.site;\n                  if (Ne !== Ye) {\n                    var kt = He.x, nt = He.y, jt = Ne.x - kt, gr = Ne.y - nt, yr = Ye.x - kt, ai = Ye.y - nt, Hr = 2 * (jt * ai - gr * yr);\n                    if (!(Hr >= -je)) {\n                      var qr = jt * jt + gr * gr, _i = yr * yr + ai * ai, bi = (ai * qr - gr * _i) / Hr, Zr = (jt * _i - yr * qr) / Hr, ai = Zr + nt, gi = Su.pop() || new ac();\n                      gi.arc = X, gi.site = He, gi.x = bi + kt, gi.y = ai + Math.sqrt(bi * bi + Zr * Zr), gi.cy = ai, X.circle = gi;\n                      for (var Ii = null, Si = Zl._; Si; ) if (gi.y < Si.y || gi.y === Si.y && gi.x <= Si.x) if (Si.L) Si = Si.L;\n                      else {\n                        Ii = Si.P;\n                        break;\n                      }\n                      else if (Si.R) Si = Si.R;\n                      else {\n                        Ii = Si;\n                        break;\n                      }\n                      Zl.insert(Ii, gi), Ii || (ls = gi);\n                    }\n                  }\n                }\n              }\n              function Oo(X) {\n                var se = X.circle;\n                se && (se.P || (ls = se.N), Zl.remove(se), Su.push(se), Os(se), X.circle = null);\n              }\n              function qo(X, se, Te, Ne) {\n                return function(He) {\n                  var Ye = He.a, kt = He.b, nt = Ye.x, jt = Ye.y, gr = kt.x, yr = kt.y, Hr = 0, qr = 1, _i = gr - nt, bi = yr - jt, Zr;\n                  if (Zr = X - nt, !(!_i && Zr > 0)) {\n                    if (Zr /= _i, _i < 0) {\n                      if (Zr < Hr) return;\n                      Zr < qr && (qr = Zr);\n                    } else if (_i > 0) {\n                      if (Zr > qr) return;\n                      Zr > Hr && (Hr = Zr);\n                    }\n                    if (Zr = Te - nt, !(!_i && Zr < 0)) {\n                      if (Zr /= _i, _i < 0) {\n                        if (Zr > qr) return;\n                        Zr > Hr && (Hr = Zr);\n                      } else if (_i > 0) {\n                        if (Zr < Hr) return;\n                        Zr < qr && (qr = Zr);\n                      }\n                      if (Zr = se - jt, !(!bi && Zr > 0)) {\n                        if (Zr /= bi, bi < 0) {\n                          if (Zr < Hr) return;\n                          Zr < qr && (qr = Zr);\n                        } else if (bi > 0) {\n                          if (Zr > qr) return;\n                          Zr > Hr && (Hr = Zr);\n                        }\n                        if (Zr = Ne - jt, !(!bi && Zr < 0)) {\n                          if (Zr /= bi, bi < 0) {\n                            if (Zr > qr) return;\n                            Zr > Hr && (Hr = Zr);\n                          } else if (bi > 0) {\n                            if (Zr < Hr) return;\n                            Zr < qr && (qr = Zr);\n                          }\n                          return Hr > 0 && (He.a = { x: nt + Hr * _i, y: jt + Hr * bi }), qr < 1 && (He.b = { x: nt + qr * _i, y: jt + qr * bi }), He;\n                        }\n                      }\n                    }\n                  }\n                };\n              }\n              function ql(X) {\n                for (var se = cl, Te = qo(X[0][0], X[0][1], X[1][0], X[1][1]), Ne = se.length, He; Ne--; ) He = se[Ne], (!Pc(He, X) || !Te(He) || p3(He.a.x - He.b.x) < Je && p3(He.a.y - He.b.y) < Je) && (He.a = He.b = null, se.splice(Ne, 1));\n              }\n              function Pc(X, se) {\n                var Te = X.b;\n                if (Te) return true;\n                var Ne = X.a, He = se[0][0], Ye = se[1][0], kt = se[0][1], nt = se[1][1], jt = X.l, gr = X.r, yr = jt.x, Hr = jt.y, qr = gr.x, _i = gr.y, bi = (yr + qr) / 2, Zr = (Hr + _i) / 2, ai, gi;\n                if (_i === Hr) {\n                  if (bi < He || bi >= Ye) return;\n                  if (yr > qr) {\n                    if (!Ne) Ne = { x: bi, y: kt };\n                    else if (Ne.y >= nt) return;\n                    Te = { x: bi, y: nt };\n                  } else {\n                    if (!Ne) Ne = { x: bi, y: nt };\n                    else if (Ne.y < kt) return;\n                    Te = { x: bi, y: kt };\n                  }\n                } else if (ai = (yr - qr) / (_i - Hr), gi = Zr - ai * bi, ai < -1 || ai > 1) if (yr > qr) {\n                  if (!Ne) Ne = { x: (kt - gi) / ai, y: kt };\n                  else if (Ne.y >= nt) return;\n                  Te = { x: (nt - gi) / ai, y: nt };\n                } else {\n                  if (!Ne) Ne = { x: (nt - gi) / ai, y: nt };\n                  else if (Ne.y < kt) return;\n                  Te = { x: (kt - gi) / ai, y: kt };\n                }\n                else if (Hr < _i) {\n                  if (!Ne) Ne = { x: He, y: ai * He + gi };\n                  else if (Ne.x >= Ye) return;\n                  Te = { x: Ye, y: ai * Ye + gi };\n                } else {\n                  if (!Ne) Ne = { x: Ye, y: ai * Ye + gi };\n                  else if (Ne.x < He) return;\n                  Te = { x: He, y: ai * He + gi };\n                }\n                return X.a = Ne, X.b = Te, true;\n              }\n              function Do(X, se) {\n                this.l = X, this.r = se, this.a = this.b = null;\n              }\n              function rf(X, se, Te, Ne) {\n                var He = new Do(X, se);\n                return cl.push(He), Te && pl(He, X, se, Te), Ne && pl(He, se, X, Ne), Ks[X.i].edges.push(new Zc(He, X, se)), Ks[se.i].edges.push(new Zc(He, se, X)), He;\n              }\n              function Uf(X, se, Te) {\n                var Ne = new Do(X, null);\n                return Ne.a = se, Ne.b = Te, cl.push(Ne), Ne;\n              }\n              function pl(X, se, Te, Ne) {\n                !X.a && !X.b ? (X.a = Ne, X.l = se, X.r = Te) : X.l === Te ? X.b = Ne : X.a = Ne;\n              }\n              function Zc(X, se, Te) {\n                var Ne = X.a, He = X.b;\n                this.edge = X, this.site = se, this.angle = Te ? Math.atan2(Te.y - se.y, Te.x - se.x) : X.l === se ? Math.atan2(He.x - Ne.x, Ne.y - He.y) : Math.atan2(Ne.x - He.x, He.y - Ne.y);\n              }\n              Zc.prototype = { start: function() {\n                return this.edge.l === this.site ? this.edge.a : this.edge.b;\n              }, end: function() {\n                return this.edge.l === this.site ? this.edge.b : this.edge.a;\n              } };\n              function Kl() {\n                this._ = null;\n              }\n              function Os(X) {\n                X.U = X.C = X.L = X.R = X.P = X.N = null;\n              }\n              Kl.prototype = { insert: function(X, se) {\n                var Te, Ne, He;\n                if (X) {\n                  if (se.P = X, se.N = X.N, X.N && (X.N.P = se), X.N = se, X.R) {\n                    for (X = X.R; X.L; ) X = X.L;\n                    X.L = se;\n                  } else X.R = se;\n                  Te = X;\n                } else this._ ? (X = Cf(this._), se.P = null, se.N = X, X.P = X.L = se, Te = X) : (se.P = se.N = null, this._ = se, Te = null);\n                for (se.L = se.R = null, se.U = Te, se.C = true, X = se; Te && Te.C; ) Ne = Te.U, Te === Ne.L ? (He = Ne.R, He && He.C ? (Te.C = He.C = false, Ne.C = true, X = Ne) : (X === Te.R && (yu(this, Te), X = Te, Te = X.U), Te.C = false, Ne.C = true, oc(this, Ne))) : (He = Ne.L, He && He.C ? (Te.C = He.C = false, Ne.C = true, X = Ne) : (X === Te.L && (oc(this, Te), X = Te, Te = X.U), Te.C = false, Ne.C = true, yu(this, Ne))), Te = X.U;\n                this._.C = false;\n              }, remove: function(X) {\n                X.N && (X.N.P = X.P), X.P && (X.P.N = X.N), X.N = X.P = null;\n                var se = X.U, Te, Ne = X.L, He = X.R, Ye, kt;\n                if (Ne ? He ? Ye = Cf(He) : Ye = Ne : Ye = He, se ? se.L === X ? se.L = Ye : se.R = Ye : this._ = Ye, Ne && He ? (kt = Ye.C, Ye.C = X.C, Ye.L = Ne, Ne.U = Ye, Ye !== He ? (se = Ye.U, Ye.U = X.U, X = Ye.R, se.L = X, Ye.R = He, He.U = Ye) : (Ye.U = se, se = Ye, X = Ye.R)) : (kt = X.C, X = Ye), X && (X.U = se), !kt) {\n                  if (X && X.C) {\n                    X.C = false;\n                    return;\n                  }\n                  do {\n                    if (X === this._) break;\n                    if (X === se.L) {\n                      if (Te = se.R, Te.C && (Te.C = false, se.C = true, yu(this, se), Te = se.R), Te.L && Te.L.C || Te.R && Te.R.C) {\n                        (!Te.R || !Te.R.C) && (Te.L.C = false, Te.C = true, oc(this, Te), Te = se.R), Te.C = se.C, se.C = Te.R.C = false, yu(this, se), X = this._;\n                        break;\n                      }\n                    } else if (Te = se.L, Te.C && (Te.C = false, se.C = true, oc(this, se), Te = se.L), Te.L && Te.L.C || Te.R && Te.R.C) {\n                      (!Te.L || !Te.L.C) && (Te.R.C = false, Te.C = true, yu(this, Te), Te = se.L), Te.C = se.C, se.C = Te.L.C = false, oc(this, se), X = this._;\n                      break;\n                    }\n                    Te.C = true, X = se, se = se.U;\n                  } while (!X.C);\n                  X && (X.C = false);\n                }\n              } };\n              function yu(X, se) {\n                var Te = se, Ne = se.R, He = Te.U;\n                He ? He.L === Te ? He.L = Ne : He.R = Ne : X._ = Ne, Ne.U = He, Te.U = Ne, Te.R = Ne.L, Te.R && (Te.R.U = Te), Ne.L = Te;\n              }\n              function oc(X, se) {\n                var Te = se, Ne = se.L, He = Te.U;\n                He ? He.L === Te ? He.L = Ne : He.R = Ne : X._ = Ne, Ne.U = He, Te.U = Ne, Te.L = Ne.R, Te.L && (Te.L.U = Te), Ne.R = Te;\n              }\n              function Cf(X) {\n                for (; X.L; ) X = X.L;\n                return X;\n              }\n              function sc(X, se) {\n                var Te = X.sort(Vh).pop(), Ne, He, Ye;\n                for (cl = [], Ks = new Array(X.length), zs = new Kl(), Zl = new Kl(); ; ) if (Ye = ls, Te && (!Ye || Te.y < Ye.y || Te.y === Ye.y && Te.x < Ye.x)) (Te.x !== Ne || Te.y !== He) && (Ks[Te.i] = new Yl(Te), Vu(Te), Ne = Te.x, He = Te.y), Te = X.pop();\n                else if (Ye) _a(Ye.arc);\n                else break;\n                se && (ql(se), Ns(se));\n                var kt = { cells: Ks, edges: cl };\n                return zs = Zl = cl = Ks = null, kt;\n              }\n              function Vh(X, se) {\n                return se.y - X.y || se.x - X.x;\n              }\n              e3.geom.voronoi = function(X) {\n                var se = Ds, Te = Fs, Ne = se, He = Te, Ye = Lf;\n                if (X) return kt(X);\n                function kt(jt) {\n                  var gr = new Array(jt.length), yr = Ye[0][0], Hr = Ye[0][1], qr = Ye[1][0], _i = Ye[1][1];\n                  return sc(nt(jt), Ye).cells.forEach(function(bi, Zr) {\n                    var ai = bi.edges, gi = bi.site, Ii = gr[Zr] = ai.length ? ai.map(function(Si) {\n                      var ei = Si.start();\n                      return [ei.x, ei.y];\n                    }) : gi.x >= yr && gi.x <= qr && gi.y >= Hr && gi.y <= _i ? [[yr, _i], [qr, _i], [qr, Hr], [yr, Hr]] : [];\n                    Ii.point = jt[Zr];\n                  }), gr;\n                }\n                function nt(jt) {\n                  return jt.map(function(gr, yr) {\n                    return { x: Math.round(Ne(gr, yr) / Je) * Je, y: Math.round(He(gr, yr) / Je) * Je, i: yr };\n                  });\n                }\n                return kt.links = function(jt) {\n                  return sc(nt(jt)).edges.filter(function(gr) {\n                    return gr.l && gr.r;\n                  }).map(function(gr) {\n                    return { source: jt[gr.l.i], target: jt[gr.r.i] };\n                  });\n                }, kt.triangles = function(jt) {\n                  var gr = [];\n                  return sc(nt(jt)).cells.forEach(function(yr, Hr) {\n                    for (var qr = yr.site, _i = yr.edges.sort(Hl), bi = -1, Zr = _i.length, ai, gi, Ii = _i[Zr - 1].edge, Si = Ii.l === qr ? Ii.r : Ii.l; ++bi < Zr; ) ai = Ii, gi = Si, Ii = _i[bi].edge, Si = Ii.l === qr ? Ii.r : Ii.l, Hr < gi.i && Hr < Si.i && cs(qr, gi, Si) < 0 && gr.push([jt[Hr], jt[gi.i], jt[Si.i]]);\n                  }), gr;\n                }, kt.x = function(jt) {\n                  return arguments.length ? (Ne = vi(se = jt), kt) : se;\n                }, kt.y = function(jt) {\n                  return arguments.length ? (He = vi(Te = jt), kt) : Te;\n                }, kt.clipExtent = function(jt) {\n                  return arguments.length ? (Ye = jt == null ? Lf : jt, kt) : Ye === Lf ? null : Ye;\n                }, kt.size = function(jt) {\n                  return arguments.length ? kt.clipExtent(jt && [[0, 0], jt]) : Ye === Lf ? null : Ye && Ye[1];\n                }, kt;\n              };\n              var Lf = [[-1e6, -1e6], [1e6, 1e6]];\n              function cs(X, se, Te) {\n                return (X.x - Te.x) * (se.y - X.y) - (X.x - se.x) * (Te.y - X.y);\n              }\n              e3.geom.delaunay = function(X) {\n                return e3.geom.voronoi().triangles(X);\n              }, e3.geom.quadtree = function(X, se, Te, Ne, He) {\n                var Ye = Ds, kt = Fs, nt;\n                if (nt = arguments.length) return Ye = nf, kt = Vf, nt === 3 && (He = Te, Ne = se, Te = se = 0), jt(X);\n                function jt(gr) {\n                  var yr, Hr = vi(Ye), qr = vi(kt), _i, bi, Zr, ai, gi, Ii, Si, ei;\n                  if (se != null) gi = se, Ii = Te, Si = Ne, ei = He;\n                  else if (Si = ei = -(gi = Ii = 1 / 0), _i = [], bi = [], ai = gr.length, nt) for (Zr = 0; Zr < ai; ++Zr) yr = gr[Zr], yr.x < gi && (gi = yr.x), yr.y < Ii && (Ii = yr.y), yr.x > Si && (Si = yr.x), yr.y > ei && (ei = yr.y), _i.push(yr.x), bi.push(yr.y);\n                  else for (Zr = 0; Zr < ai; ++Zr) {\n                    var Ln = +Hr(yr = gr[Zr], Zr), En = +qr(yr, Zr);\n                    Ln < gi && (gi = Ln), En < Ii && (Ii = En), Ln > Si && (Si = Ln), En > ei && (ei = En), _i.push(Ln), bi.push(En);\n                  }\n                  var Un = Si - gi, ia = ei - Ii;\n                  Un > ia ? ei = Ii + Un : Si = gi + ia;\n                  function Ea(Da, go, Is, Ms, Xs, Gn, ja, Fo) {\n                    if (!(isNaN(Is) || isNaN(Ms))) if (Da.leaf) {\n                      var Uo = Da.x, $s = Da.y;\n                      if (Uo != null) if (p3(Uo - Is) + p3($s - Ms) < 0.01) Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);\n                      else {\n                        var Sl = Da.point;\n                        Da.x = Da.y = Da.point = null, Ia(Da, Sl, Uo, $s, Xs, Gn, ja, Fo), Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);\n                      }\n                      else Da.x = Is, Da.y = Ms, Da.point = go;\n                    } else Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo);\n                  }\n                  function Ia(Da, go, Is, Ms, Xs, Gn, ja, Fo) {\n                    var Uo = (Xs + ja) * 0.5, $s = (Gn + Fo) * 0.5, Sl = Is >= Uo, bu = Ms >= $s, dl = bu << 1 | Sl;\n                    Da.leaf = false, Da = Da.nodes[dl] || (Da.nodes[dl] = Jl()), Sl ? Xs = Uo : ja = Uo, bu ? Gn = $s : Fo = $s, Ea(Da, go, Is, Ms, Xs, Gn, ja, Fo);\n                  }\n                  var yo = Jl();\n                  if (yo.add = function(Da) {\n                    Ea(yo, Da, +Hr(Da, ++Zr), +qr(Da, Zr), gi, Ii, Si, ei);\n                  }, yo.visit = function(Da) {\n                    fl(Da, yo, gi, Ii, Si, ei);\n                  }, yo.find = function(Da) {\n                    return lc(yo, Da[0], Da[1], gi, Ii, Si, ei);\n                  }, Zr = -1, se == null) {\n                    for (; ++Zr < ai; ) Ea(yo, gr[Zr], _i[Zr], bi[Zr], gi, Ii, Si, ei);\n                    --Zr;\n                  } else gr.forEach(yo.add);\n                  return _i = bi = gr = yr = null, yo;\n                }\n                return jt.x = function(gr) {\n                  return arguments.length ? (Ye = gr, jt) : Ye;\n                }, jt.y = function(gr) {\n                  return arguments.length ? (kt = gr, jt) : kt;\n                }, jt.extent = function(gr) {\n                  return arguments.length ? (gr == null ? se = Te = Ne = He = null : (se = +gr[0][0], Te = +gr[0][1], Ne = +gr[1][0], He = +gr[1][1]), jt) : se == null ? null : [[se, Te], [Ne, He]];\n                }, jt.size = function(gr) {\n                  return arguments.length ? (gr == null ? se = Te = Ne = He = null : (se = Te = 0, Ne = +gr[0], He = +gr[1]), jt) : se == null ? null : [Ne - se, He - Te];\n                }, jt;\n              };\n              function nf(X) {\n                return X.x;\n              }\n              function Vf(X) {\n                return X.y;\n              }\n              function Jl() {\n                return { leaf: true, nodes: [], point: null, x: null, y: null };\n              }\n              function fl(X, se, Te, Ne, He, Ye) {\n                if (!X(se, Te, Ne, He, Ye)) {\n                  var kt = (Te + He) * 0.5, nt = (Ne + Ye) * 0.5, jt = se.nodes;\n                  jt[0] && fl(X, jt[0], Te, Ne, kt, nt), jt[1] && fl(X, jt[1], kt, Ne, He, nt), jt[2] && fl(X, jt[2], Te, nt, kt, Ye), jt[3] && fl(X, jt[3], kt, nt, He, Ye);\n                }\n              }\n              function lc(X, se, Te, Ne, He, Ye, kt) {\n                var nt = 1 / 0, jt;\n                return (function gr(yr, Hr, qr, _i, bi) {\n                  if (!(Hr > Ye || qr > kt || _i < Ne || bi < He)) {\n                    if (Zr = yr.point) {\n                      var Zr, ai = se - yr.x, gi = Te - yr.y, Ii = ai * ai + gi * gi;\n                      if (Ii < nt) {\n                        var Si = Math.sqrt(nt = Ii);\n                        Ne = se - Si, He = Te - Si, Ye = se + Si, kt = Te + Si, jt = Zr;\n                      }\n                    }\n                    for (var ei = yr.nodes, Ln = (Hr + _i) * 0.5, En = (qr + bi) * 0.5, Un = se >= Ln, ia = Te >= En, Ea = ia << 1 | Un, Ia = Ea + 4; Ea < Ia; ++Ea) if (yr = ei[Ea & 3]) switch (Ea & 3) {\n                      case 0:\n                        gr(yr, Hr, qr, Ln, En);\n                        break;\n                      case 1:\n                        gr(yr, Ln, qr, _i, En);\n                        break;\n                      case 2:\n                        gr(yr, Hr, En, Ln, bi);\n                        break;\n                      case 3:\n                        gr(yr, Ln, En, _i, bi);\n                        break;\n                    }\n                  }\n                })(X, Ne, He, Ye, kt), jt;\n              }\n              e3.interpolateRgb = Fu;\n              function Fu(X, se) {\n                X = e3.rgb(X), se = e3.rgb(se);\n                var Te = X.r, Ne = X.g, He = X.b, Ye = se.r - Te, kt = se.g - Ne, nt = se.b - He;\n                return function(jt) {\n                  return "#" + Wn(Math.round(Te + Ye * jt)) + Wn(Math.round(Ne + kt * jt)) + Wn(Math.round(He + nt * jt));\n                };\n              }\n              e3.interpolateObject = Es;\n              function Es(X, se) {\n                var Te = {}, Ne = {}, He;\n                for (He in X) He in se ? Te[He] = xl(X[He], se[He]) : Ne[He] = X[He];\n                for (He in se) He in X || (Ne[He] = se[He]);\n                return function(Ye) {\n                  for (He in Te) Ne[He] = Te[He](Ye);\n                  return Ne;\n                };\n              }\n              e3.interpolateNumber = Hs;\n              function Hs(X, se) {\n                return X = +X, se = +se, function(Te) {\n                  return X * (1 - Te) + se * Te;\n                };\n              }\n              e3.interpolateString = Go;\n              function Go(X, se) {\n                var Te = ps.lastIndex = uc.lastIndex = 0, Ne, He, Ye, kt = -1, nt = [], jt = [];\n                for (X = X + "", se = se + ""; (Ne = ps.exec(X)) && (He = uc.exec(se)); ) (Ye = He.index) > Te && (Ye = se.slice(Te, Ye), nt[kt] ? nt[kt] += Ye : nt[++kt] = Ye), (Ne = Ne[0]) === (He = He[0]) ? nt[kt] ? nt[kt] += He : nt[++kt] = He : (nt[++kt] = null, jt.push({ i: kt, x: Hs(Ne, He) })), Te = uc.lastIndex;\n                return Te < se.length && (Ye = se.slice(Te), nt[kt] ? nt[kt] += Ye : nt[++kt] = Ye), nt.length < 2 ? jt[0] ? (se = jt[0].x, function(gr) {\n                  return se(gr) + "";\n                }) : function() {\n                  return se;\n                } : (se = jt.length, function(gr) {\n                  for (var yr = 0, Hr; yr < se; ++yr) nt[(Hr = jt[yr]).i] = Hr.x(gr);\n                  return nt.join("");\n                });\n              }\n              var ps = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g, uc = new RegExp(ps.source, "g");\n              e3.interpolate = xl;\n              function xl(X, se) {\n                for (var Te = e3.interpolators.length, Ne; --Te >= 0 && !(Ne = e3.interpolators[Te](X, se)); ) ;\n                return Ne;\n              }\n              e3.interpolators = [function(X, se) {\n                var Te = typeof se;\n                return (Te === "string" ? Jr.has(se.toLowerCase()) || /^(#|rgb\\(|hsl\\()/i.test(se) ? Fu : Go : se instanceof la ? Fu : Array.isArray(se) ? Gu : Te === "object" && isNaN(se) ? Es : Hs)(X, se);\n              }], e3.interpolateArray = Gu;\n              function Gu(X, se) {\n                var Te = [], Ne = [], He = X.length, Ye = se.length, kt = Math.min(X.length, se.length), nt;\n                for (nt = 0; nt < kt; ++nt) Te.push(xl(X[nt], se[nt]));\n                for (; nt < He; ++nt) Ne[nt] = X[nt];\n                for (; nt < Ye; ++nt) Ne[nt] = se[nt];\n                return function(jt) {\n                  for (nt = 0; nt < kt; ++nt) Ne[nt] = Te[nt](jt);\n                  return Ne;\n                };\n              }\n              var qs = function() {\n                return G2;\n              }, ad = e3.map({ linear: qs, poly: Gf, quad: function() {\n                return af;\n              }, cubic: function() {\n                return Hu;\n              }, sin: function() {\n                return Ic;\n              }, exp: function() {\n                return yf;\n              }, circle: function() {\n                return Bl;\n              }, elastic: wh, back: Qf, bounce: function() {\n                return _f;\n              } }), Po = e3.map({ in: G2, out: Yo, "in-out": Pa, "out-in": function(X) {\n                return Pa(Yo(X));\n              } });\n              e3.ease = function(X) {\n                var se = X.indexOf("-"), Te = se >= 0 ? X.slice(0, se) : X, Ne = se >= 0 ? X.slice(se + 1) : "in";\n                return Te = ad.get(Te) || qs, Ne = Po.get(Ne) || G2, od(Ne(Te.apply(null, t3.call(arguments, 1))));\n              };\n              function od(X) {\n                return function(se) {\n                  return se <= 0 ? 0 : se >= 1 ? 1 : X(se);\n                };\n              }\n              function Yo(X) {\n                return function(se) {\n                  return 1 - X(1 - se);\n                };\n              }\n              function Pa(X) {\n                return function(se) {\n                  return 0.5 * (se < 0.5 ? X(2 * se) : 2 - X(2 - 2 * se));\n                };\n              }\n              function af(X) {\n                return X * X;\n              }\n              function Hu(X) {\n                return X * X * X;\n              }\n              function bl(X) {\n                if (X <= 0) return 0;\n                if (X >= 1) return 1;\n                var se = X * X, Te = se * X;\n                return 4 * (X < 0.5 ? Te : 3 * (X - se) + Te - 0.75);\n              }\n              function Gf(X) {\n                return function(se) {\n                  return Math.pow(se, X);\n                };\n              }\n              function Ic(X) {\n                return 1 - Math.cos(X * xe);\n              }\n              function yf(X) {\n                return Math.pow(2, 10 * (X - 1));\n              }\n              function Bl(X) {\n                return 1 - Math.sqrt(1 - X * X);\n              }\n              function wh(X, se) {\n                var Te;\n                return arguments.length < 2 && (se = 0.45), arguments.length ? Te = se / xt * Math.asin(1 / X) : (X = 1, Te = se / 4), function(Ne) {\n                  return 1 + X * Math.pow(2, -10 * Ne) * Math.sin((Ne - Te) * xt / se);\n                };\n              }\n              function Qf(X) {\n                return X || (X = 1.70158), function(se) {\n                  return se * se * ((X + 1) * se - X);\n                };\n              }\n              function _f(X) {\n                return X < 1 / 2.75 ? 7.5625 * X * X : X < 2 / 2.75 ? 7.5625 * (X -= 1.5 / 2.75) * X + 0.75 : X < 2.5 / 2.75 ? 7.5625 * (X -= 2.25 / 2.75) * X + 0.9375 : 7.5625 * (X -= 2.625 / 2.75) * X + 0.984375;\n              }\n              e3.interpolateHcl = Yc;\n              function Yc(X, se) {\n                X = e3.hcl(X), se = e3.hcl(se);\n                var Te = X.h, Ne = X.c, He = X.l, Ye = se.h - Te, kt = se.c - Ne, nt = se.l - He;\n                return isNaN(kt) && (kt = 0, Ne = isNaN(Ne) ? se.c : Ne), isNaN(Ye) ? (Ye = 0, Te = isNaN(Te) ? se.h : Te) : Ye > 180 ? Ye -= 360 : Ye < -180 && (Ye += 360), function(jt) {\n                  return Xr(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";\n                };\n              }\n              e3.interpolateHsl = eh;\n              function eh(X, se) {\n                X = e3.hsl(X), se = e3.hsl(se);\n                var Te = X.h, Ne = X.s, He = X.l, Ye = se.h - Te, kt = se.s - Ne, nt = se.l - He;\n                return isNaN(kt) && (kt = 0, Ne = isNaN(Ne) ? se.s : Ne), isNaN(Ye) ? (Ye = 0, Te = isNaN(Te) ? se.h : Te) : Ye > 180 ? Ye -= 360 : Ye < -180 && (Ye += 360), function(jt) {\n                  return rr(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";\n                };\n              }\n              e3.interpolateLab = th;\n              function th(X, se) {\n                X = e3.lab(X), se = e3.lab(se);\n                var Te = X.l, Ne = X.a, He = X.b, Ye = se.l - Te, kt = se.a - Ne, nt = se.b - He;\n                return function(jt) {\n                  return yn(Te + Ye * jt, Ne + kt * jt, He + nt * jt) + "";\n                };\n              }\n              e3.interpolateRound = ju;\n              function ju(X, se) {\n                return se -= X, function(Te) {\n                  return Math.round(X + se * Te);\n                };\n              }\n              e3.transform = function(X) {\n                var se = n4.createElementNS(e3.ns.prefix.svg, "g");\n                return (e3.transform = function(Te) {\n                  if (Te != null) {\n                    se.setAttribute("transform", Te);\n                    var Ne = se.transform.baseVal.consolidate();\n                  }\n                  return new Hf(Ne ? Ne.matrix : Kc);\n                })(X);\n              };\n              function Hf(X) {\n                var se = [X.a, X.b], Te = [X.c, X.d], Ne = of(se), He = cc(se, Te), Ye = of(Nl(Te, se, -He)) || 0;\n                se[0] * Te[1] < Te[0] * se[1] && (se[0] *= -1, se[1] *= -1, Ne *= -1, He *= -1), this.rotate = (Ne ? Math.atan2(se[1], se[0]) : Math.atan2(-Te[0], Te[1])) * vt, this.translate = [X.e, X.f], this.scale = [Ne, Ye], this.skew = Ye ? Math.atan2(He, Ye) * vt : 0;\n              }\n              Hf.prototype.toString = function() {\n                return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")";\n              };\n              function cc(X, se) {\n                return X[0] * se[0] + X[1] * se[1];\n              }\n              function of(X) {\n                var se = Math.sqrt(cc(X, X));\n                return se && (X[0] /= se, X[1] /= se), se;\n              }\n              function Nl(X, se, Te) {\n                return X[0] += Te * se[0], X[1] += Te * se[1], X;\n              }\n              var Kc = { a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 };\n              e3.interpolateTransform = sf;\n              function Rc(X) {\n                return X.length ? X.pop() + "," : "";\n              }\n              function gs(X, se, Te, Ne) {\n                if (X[0] !== se[0] || X[1] !== se[1]) {\n                  var He = Te.push("translate(", null, ",", null, ")");\n                  Ne.push({ i: He - 4, x: Hs(X[0], se[0]) }, { i: He - 2, x: Hs(X[1], se[1]) });\n                } else (se[0] || se[1]) && Te.push("translate(" + se + ")");\n              }\n              function jf(X, se, Te, Ne) {\n                X !== se ? (X - se > 180 ? se += 360 : se - X > 180 && (X += 360), Ne.push({ i: Te.push(Rc(Te) + "rotate(", null, ")") - 2, x: Hs(X, se) })) : se && Te.push(Rc(Te) + "rotate(" + se + ")");\n              }\n              function Gh(X, se, Te, Ne) {\n                X !== se ? Ne.push({ i: Te.push(Rc(Te) + "skewX(", null, ")") - 2, x: Hs(X, se) }) : se && Te.push(Rc(Te) + "skewX(" + se + ")");\n              }\n              function rh(X, se, Te, Ne) {\n                if (X[0] !== se[0] || X[1] !== se[1]) {\n                  var He = Te.push(Rc(Te) + "scale(", null, ",", null, ")");\n                  Ne.push({ i: He - 4, x: Hs(X[0], se[0]) }, { i: He - 2, x: Hs(X[1], se[1]) });\n                } else (se[0] !== 1 || se[1] !== 1) && Te.push(Rc(Te) + "scale(" + se + ")");\n              }\n              function sf(X, se) {\n                var Te = [], Ne = [];\n                return X = e3.transform(X), se = e3.transform(se), gs(X.translate, se.translate, Te, Ne), jf(X.rotate, se.rotate, Te, Ne), Gh(X.skew, se.skew, Te, Ne), rh(X.scale, se.scale, Te, Ne), X = se = null, function(He) {\n                  for (var Ye = -1, kt = Ne.length, nt; ++Ye < kt; ) Te[(nt = Ne[Ye]).i] = nt.x(He);\n                  return Te.join("");\n                };\n              }\n              function Th(X, se) {\n                return se = (se -= X = +X) || 1 / se, function(Te) {\n                  return (Te - X) / se;\n                };\n              }\n              function Mu(X, se) {\n                return se = (se -= X = +X) || 1 / se, function(Te) {\n                  return Math.max(0, Math.min(1, (Te - X) / se));\n                };\n              }\n              e3.layout = {}, e3.layout.bundle = function() {\n                return function(X) {\n                  for (var se = [], Te = -1, Ne = X.length; ++Te < Ne; ) se.push(ih(X[Te]));\n                  return se;\n                };\n              };\n              function ih(X) {\n                for (var se = X.source, Te = X.target, Ne = Eu(se, Te), He = [se]; se !== Ne; ) se = se.parent, He.push(se);\n                for (var Ye = He.length; Te !== Ne; ) He.splice(Ye, 0, Te), Te = Te.parent;\n                return He;\n              }\n              function js(X) {\n                for (var se = [], Te = X.parent; Te != null; ) se.push(X), X = Te, Te = Te.parent;\n                return se.push(X), se;\n              }\n              function Eu(X, se) {\n                if (X === se) return X;\n                for (var Te = js(X), Ne = js(se), He = Te.pop(), Ye = Ne.pop(), kt = null; He === Ye; ) kt = He, He = Te.pop(), Ye = Ne.pop();\n                return kt;\n              }\n              e3.layout.chord = function() {\n                var X = {}, se, Te, Ne, He, Ye = 0, kt, nt, jt;\n                function gr() {\n                  var Hr = {}, qr = [], _i = e3.range(He), bi = [], Zr, ai, gi, Ii, Si;\n                  for (se = [], Te = [], Zr = 0, Ii = -1; ++Ii < He; ) {\n                    for (ai = 0, Si = -1; ++Si < He; ) ai += Ne[Ii][Si];\n                    qr.push(ai), bi.push(e3.range(He)), Zr += ai;\n                  }\n                  for (kt && _i.sort(function(yo, Da) {\n                    return kt(qr[yo], qr[Da]);\n                  }), nt && bi.forEach(function(yo, Da) {\n                    yo.sort(function(go, Is) {\n                      return nt(Ne[Da][go], Ne[Da][Is]);\n                    });\n                  }), Zr = (xt - Ye * He) / Zr, ai = 0, Ii = -1; ++Ii < He; ) {\n                    for (gi = ai, Si = -1; ++Si < He; ) {\n                      var ei = _i[Ii], Ln = bi[ei][Si], En = Ne[ei][Ln], Un = ai, ia = ai += En * Zr;\n                      Hr[ei + "-" + Ln] = { index: ei, subindex: Ln, startAngle: Un, endAngle: ia, value: En };\n                    }\n                    Te[ei] = { index: ei, startAngle: gi, endAngle: ai, value: qr[ei] }, ai += Ye;\n                  }\n                  for (Ii = -1; ++Ii < He; ) for (Si = Ii - 1; ++Si < He; ) {\n                    var Ea = Hr[Ii + "-" + Si], Ia = Hr[Si + "-" + Ii];\n                    (Ea.value || Ia.value) && se.push(Ea.value < Ia.value ? { source: Ia, target: Ea } : { source: Ea, target: Ia });\n                  }\n                  jt && yr();\n                }\n                function yr() {\n                  se.sort(function(Hr, qr) {\n                    return jt((Hr.source.value + Hr.target.value) / 2, (qr.source.value + qr.target.value) / 2);\n                  });\n                }\n                return X.matrix = function(Hr) {\n                  return arguments.length ? (He = (Ne = Hr) && Ne.length, se = Te = null, X) : Ne;\n                }, X.padding = function(Hr) {\n                  return arguments.length ? (Ye = Hr, se = Te = null, X) : Ye;\n                }, X.sortGroups = function(Hr) {\n                  return arguments.length ? (kt = Hr, se = Te = null, X) : kt;\n                }, X.sortSubgroups = function(Hr) {\n                  return arguments.length ? (nt = Hr, se = null, X) : nt;\n                }, X.sortChords = function(Hr) {\n                  return arguments.length ? (jt = Hr, se && yr(), X) : jt;\n                }, X.chords = function() {\n                  return se || gr(), se;\n                }, X.groups = function() {\n                  return Te || gr(), Te;\n                }, X;\n              }, e3.layout.force = function() {\n                var X = {}, se = e3.dispatch("start", "tick", "end"), Te, Ne = [1, 1], He, Ye, kt = 0.9, nt = nl, jt = nh, gr = -30, yr = Ah, Hr = 0.1, qr = 0.64, _i = [], bi = [], Zr, ai, gi;\n                function Ii(ei) {\n                  return function(Ln, En, Un, ia) {\n                    if (Ln.point !== ei) {\n                      var Ea = Ln.cx - ei.x, Ia = Ln.cy - ei.y, yo = ia - En, Da = Ea * Ea + Ia * Ia;\n                      if (yo * yo / qr < Da) {\n                        if (Da < yr) {\n                          var go = Ln.charge / Da;\n                          ei.px -= Ea * go, ei.py -= Ia * go;\n                        }\n                        return true;\n                      }\n                      if (Ln.point && Da && Da < yr) {\n                        var go = Ln.pointCharge / Da;\n                        ei.px -= Ea * go, ei.py -= Ia * go;\n                      }\n                    }\n                    return !Ln.charge;\n                  };\n                }\n                X.tick = function() {\n                  if ((Ye *= 0.99) < 5e-3) return Te = null, se.end({ type: "end", alpha: Ye = 0 }), true;\n                  var ei = _i.length, Ln = bi.length, En, Un, ia, Ea, Ia, yo, Da, go, Is;\n                  for (Un = 0; Un < Ln; ++Un) ia = bi[Un], Ea = ia.source, Ia = ia.target, go = Ia.x - Ea.x, Is = Ia.y - Ea.y, (yo = go * go + Is * Is) && (yo = Ye * ai[Un] * ((yo = Math.sqrt(yo)) - Zr[Un]) / yo, go *= yo, Is *= yo, Ia.x -= go * (Da = Ea.weight + Ia.weight ? Ea.weight / (Ea.weight + Ia.weight) : 0.5), Ia.y -= Is * Da, Ea.x += go * (Da = 1 - Da), Ea.y += Is * Da);\n                  if ((Da = Ye * Hr) && (go = Ne[0] / 2, Is = Ne[1] / 2, Un = -1, Da)) for (; ++Un < ei; ) ia = _i[Un], ia.x += (go - ia.x) * Da, ia.y += (Is - ia.y) * Da;\n                  if (gr) for (_u(En = e3.geom.quadtree(_i), Ye, gi), Un = -1; ++Un < ei; ) (ia = _i[Un]).fixed || En.visit(Ii(ia));\n                  for (Un = -1; ++Un < ei; ) ia = _i[Un], ia.fixed ? (ia.x = ia.px, ia.y = ia.py) : (ia.x -= (ia.px - (ia.px = ia.x)) * kt, ia.y -= (ia.py - (ia.py = ia.y)) * kt);\n                  se.tick({ type: "tick", alpha: Ye });\n                }, X.nodes = function(ei) {\n                  return arguments.length ? (_i = ei, X) : _i;\n                }, X.links = function(ei) {\n                  return arguments.length ? (bi = ei, X) : bi;\n                }, X.size = function(ei) {\n                  return arguments.length ? (Ne = ei, X) : Ne;\n                }, X.linkDistance = function(ei) {\n                  return arguments.length ? (nt = typeof ei == "function" ? ei : +ei, X) : nt;\n                }, X.distance = X.linkDistance, X.linkStrength = function(ei) {\n                  return arguments.length ? (jt = typeof ei == "function" ? ei : +ei, X) : jt;\n                }, X.friction = function(ei) {\n                  return arguments.length ? (kt = +ei, X) : kt;\n                }, X.charge = function(ei) {\n                  return arguments.length ? (gr = typeof ei == "function" ? ei : +ei, X) : gr;\n                }, X.chargeDistance = function(ei) {\n                  return arguments.length ? (yr = ei * ei, X) : Math.sqrt(yr);\n                }, X.gravity = function(ei) {\n                  return arguments.length ? (Hr = +ei, X) : Hr;\n                }, X.theta = function(ei) {\n                  return arguments.length ? (qr = ei * ei, X) : Math.sqrt(qr);\n                }, X.alpha = function(ei) {\n                  return arguments.length ? (ei = +ei, Ye ? ei > 0 ? Ye = ei : (Te.c = null, Te.t = NaN, Te = null, se.end({ type: "end", alpha: Ye = 0 })) : ei > 0 && (se.start({ type: "start", alpha: Ye = ei }), Te = No(X.tick)), X) : Ye;\n                }, X.start = function() {\n                  var ei, Ln = _i.length, En = bi.length, Un = Ne[0], ia = Ne[1], Ea, Ia;\n                  for (ei = 0; ei < Ln; ++ei) (Ia = _i[ei]).index = ei, Ia.weight = 0;\n                  for (ei = 0; ei < En; ++ei) Ia = bi[ei], typeof Ia.source == "number" && (Ia.source = _i[Ia.source]), typeof Ia.target == "number" && (Ia.target = _i[Ia.target]), ++Ia.source.weight, ++Ia.target.weight;\n                  for (ei = 0; ei < Ln; ++ei) Ia = _i[ei], isNaN(Ia.x) && (Ia.x = yo("x", Un)), isNaN(Ia.y) && (Ia.y = yo("y", ia)), isNaN(Ia.px) && (Ia.px = Ia.x), isNaN(Ia.py) && (Ia.py = Ia.y);\n                  if (Zr = [], typeof nt == "function") for (ei = 0; ei < En; ++ei) Zr[ei] = +nt.call(this, bi[ei], ei);\n                  else for (ei = 0; ei < En; ++ei) Zr[ei] = nt;\n                  if (ai = [], typeof jt == "function") for (ei = 0; ei < En; ++ei) ai[ei] = +jt.call(this, bi[ei], ei);\n                  else for (ei = 0; ei < En; ++ei) ai[ei] = jt;\n                  if (gi = [], typeof gr == "function") for (ei = 0; ei < Ln; ++ei) gi[ei] = +gr.call(this, _i[ei], ei);\n                  else for (ei = 0; ei < Ln; ++ei) gi[ei] = gr;\n                  function yo(Da, go) {\n                    if (!Ea) {\n                      for (Ea = new Array(Ln), Xs = 0; Xs < Ln; ++Xs) Ea[Xs] = [];\n                      for (Xs = 0; Xs < En; ++Xs) {\n                        var Is = bi[Xs];\n                        Ea[Is.source.index].push(Is.target), Ea[Is.target.index].push(Is.source);\n                      }\n                    }\n                    for (var Ms = Ea[ei], Xs = -1, Gn = Ms.length, ja; ++Xs < Gn; ) if (!isNaN(ja = Ms[Xs][Da])) return ja;\n                    return Math.random() * go;\n                  }\n                  return X.resume();\n                }, X.resume = function() {\n                  return X.alpha(0.1);\n                }, X.stop = function() {\n                  return X.alpha(0);\n                }, X.drag = function() {\n                  if (He || (He = e3.behavior.drag().origin(G2).on("dragstart.force", Dc).on("drag.force", Si).on("dragend.force", ks)), !arguments.length) return He;\n                  this.on("mouseover.force", bc).on("mouseout.force", hu).call(He);\n                };\n                function Si(ei) {\n                  ei.px = e3.event.x, ei.py = e3.event.y, X.resume();\n                }\n                return e3.rebind(X, se, "on");\n              };\n              function Dc(X) {\n                X.fixed |= 2;\n              }\n              function ks(X) {\n                X.fixed &= -7;\n              }\n              function bc(X) {\n                X.fixed |= 4, X.px = X.x, X.py = X.y;\n              }\n              function hu(X) {\n                X.fixed &= -5;\n              }\n              function _u(X, se, Te) {\n                var Ne = 0, He = 0;\n                if (X.charge = 0, !X.leaf) for (var Ye = X.nodes, kt = Ye.length, nt = -1, jt; ++nt < kt; ) jt = Ye[nt], jt != null && (_u(jt, se, Te), X.charge += jt.charge, Ne += jt.charge * jt.cx, He += jt.charge * jt.cy);\n                if (X.point) {\n                  X.leaf || (X.point.x += Math.random() - 0.5, X.point.y += Math.random() - 0.5);\n                  var gr = se * Te[X.point.index];\n                  X.charge += X.pointCharge = gr, Ne += gr * X.point.x, He += gr * X.point.y;\n                }\n                X.cx = Ne / X.charge, X.cy = He / X.charge;\n              }\n              var nl = 20, nh = 1, Ah = 1 / 0;\n              e3.layout.hierarchy = function() {\n                var X = Pf, se = bd, Te = xf;\n                function Ne(He) {\n                  var Ye = [He], kt = [], nt;\n                  for (He.depth = 0; (nt = Ye.pop()) != null; ) if (kt.push(nt), (gr = se.call(Ne, nt, nt.depth)) && (jt = gr.length)) {\n                    for (var jt, gr, yr; --jt >= 0; ) Ye.push(yr = gr[jt]), yr.parent = nt, yr.depth = nt.depth + 1;\n                    Te && (nt.value = 0), nt.children = gr;\n                  } else Te && (nt.value = +Te.call(Ne, nt, nt.depth) || 0), delete nt.children;\n                  return wc(He, function(Hr) {\n                    var qr, _i;\n                    X && (qr = Hr.children) && qr.sort(X), Te && (_i = Hr.parent) && (_i.value += Hr.value);\n                  }), kt;\n                }\n                return Ne.sort = function(He) {\n                  return arguments.length ? (X = He, Ne) : X;\n                }, Ne.children = function(He) {\n                  return arguments.length ? (se = He, Ne) : se;\n                }, Ne.value = function(He) {\n                  return arguments.length ? (Te = He, Ne) : Te;\n                }, Ne.revalue = function(He) {\n                  return Te && (Fc(He, function(Ye) {\n                    Ye.children && (Ye.value = 0);\n                  }), wc(He, function(Ye) {\n                    var kt;\n                    Ye.children || (Ye.value = +Te.call(Ne, Ye, Ye.depth) || 0), (kt = Ye.parent) && (kt.value += Ye.value);\n                  })), He;\n                }, Ne;\n              };\n              function zu(X, se) {\n                return e3.rebind(X, se, "sort", "children", "value"), X.nodes = X, X.links = Ou, X;\n              }\n              function Fc(X, se) {\n                for (var Te = [X]; (X = Te.pop()) != null; ) if (se(X), (He = X.children) && (Ne = He.length)) for (var Ne, He; --Ne >= 0; ) Te.push(He[Ne]);\n              }\n              function wc(X, se) {\n                for (var Te = [X], Ne = []; (X = Te.pop()) != null; ) if (Ne.push(X), (kt = X.children) && (Ye = kt.length)) for (var He = -1, Ye, kt; ++He < Ye; ) Te.push(kt[He]);\n                for (; (X = Ne.pop()) != null; ) se(X);\n              }\n              function bd(X) {\n                return X.children;\n              }\n              function xf(X) {\n                return X.value;\n              }\n              function Pf(X, se) {\n                return se.value - X.value;\n              }\n              function Ou(X) {\n                return e3.merge(X.map(function(se) {\n                  return (se.children || []).map(function(Te) {\n                    return { source: se, target: Te };\n                  });\n                }));\n              }\n              e3.layout.partition = function() {\n                var X = e3.layout.hierarchy(), se = [1, 1];\n                function Te(Ye, kt, nt, jt) {\n                  var gr = Ye.children;\n                  if (Ye.x = kt, Ye.y = Ye.depth * jt, Ye.dx = nt, Ye.dy = jt, gr && (Hr = gr.length)) {\n                    var yr = -1, Hr, qr, _i;\n                    for (nt = Ye.value ? nt / Ye.value : 0; ++yr < Hr; ) Te(qr = gr[yr], kt, _i = qr.value * nt, jt), kt += _i;\n                  }\n                }\n                function Ne(Ye) {\n                  var kt = Ye.children, nt = 0;\n                  if (kt && (gr = kt.length)) for (var jt = -1, gr; ++jt < gr; ) nt = Math.max(nt, Ne(kt[jt]));\n                  return 1 + nt;\n                }\n                function He(Ye, kt) {\n                  var nt = X.call(this, Ye, kt);\n                  return Te(nt[0], 0, se[0], se[1] / Ne(nt[0])), nt;\n                }\n                return He.size = function(Ye) {\n                  return arguments.length ? (se = Ye, He) : se;\n                }, zu(He, X);\n              }, e3.layout.pie = function() {\n                var X = Number, se = bf, Te = 0, Ne = xt, He = 0;\n                function Ye(kt) {\n                  var nt = kt.length, jt = kt.map(function(Ii, Si) {\n                    return +X.call(Ye, Ii, Si);\n                  }), gr = +(typeof Te == "function" ? Te.apply(this, arguments) : Te), yr = (typeof Ne == "function" ? Ne.apply(this, arguments) : Ne) - gr, Hr = Math.min(Math.abs(yr) / nt, +(typeof He == "function" ? He.apply(this, arguments) : He)), qr = Hr * (yr < 0 ? -1 : 1), _i = e3.sum(jt), bi = _i ? (yr - nt * qr) / _i : 0, Zr = e3.range(nt), ai = [], gi;\n                  return se != null && Zr.sort(se === bf ? function(Ii, Si) {\n                    return jt[Si] - jt[Ii];\n                  } : function(Ii, Si) {\n                    return se(kt[Ii], kt[Si]);\n                  }), Zr.forEach(function(Ii) {\n                    ai[Ii] = { data: kt[Ii], value: gi = jt[Ii], startAngle: gr, endAngle: gr += gi * bi + qr, padAngle: Hr };\n                  }), ai;\n                }\n                return Ye.value = function(kt) {\n                  return arguments.length ? (X = kt, Ye) : X;\n                }, Ye.sort = function(kt) {\n                  return arguments.length ? (se = kt, Ye) : se;\n                }, Ye.startAngle = function(kt) {\n                  return arguments.length ? (Te = kt, Ye) : Te;\n                }, Ye.endAngle = function(kt) {\n                  return arguments.length ? (Ne = kt, Ye) : Ne;\n                }, Ye.padAngle = function(kt) {\n                  return arguments.length ? (He = kt, Ye) : He;\n                }, Ye;\n              };\n              var bf = {};\n              e3.layout.stack = function() {\n                var X = G2, se = du, Te = ku, Ne = Hh, He = jl, Ye = lf;\n                function kt(nt, jt) {\n                  if (!(bi = nt.length)) return nt;\n                  var gr = nt.map(function(Ii, Si) {\n                    return X.call(kt, Ii, Si);\n                  }), yr = gr.map(function(Ii) {\n                    return Ii.map(function(Si, ei) {\n                      return [He.call(kt, Si, ei), Ye.call(kt, Si, ei)];\n                    });\n                  }), Hr = se.call(kt, yr, jt);\n                  gr = e3.permute(gr, Hr), yr = e3.permute(yr, Hr);\n                  var qr = Te.call(kt, yr, jt), _i = gr[0].length, bi, Zr, ai, gi;\n                  for (ai = 0; ai < _i; ++ai) for (Ne.call(kt, gr[0][ai], gi = qr[ai], yr[0][ai][1]), Zr = 1; Zr < bi; ++Zr) Ne.call(kt, gr[Zr][ai], gi += yr[Zr - 1][ai][1], yr[Zr][ai][1]);\n                  return nt;\n                }\n                return kt.values = function(nt) {\n                  return arguments.length ? (X = nt, kt) : X;\n                }, kt.order = function(nt) {\n                  return arguments.length ? (se = typeof nt == "function" ? nt : If.get(nt) || du, kt) : se;\n                }, kt.offset = function(nt) {\n                  return arguments.length ? (Te = typeof nt == "function" ? nt : Cs.get(nt) || ku, kt) : Te;\n                }, kt.x = function(nt) {\n                  return arguments.length ? (He = nt, kt) : He;\n                }, kt.y = function(nt) {\n                  return arguments.length ? (Ye = nt, kt) : Ye;\n                }, kt.out = function(nt) {\n                  return arguments.length ? (Ne = nt, kt) : Ne;\n                }, kt;\n              };\n              function jl(X) {\n                return X.x;\n              }\n              function lf(X) {\n                return X.y;\n              }\n              function Hh(X, se, Te) {\n                X.y0 = se, X.y = Te;\n              }\n              var If = e3.map({ "inside-out": function(X) {\n                var se = X.length, Te, Ne, He = X.map(Wf), Ye = X.map(Us), kt = e3.range(se).sort(function(Hr, qr) {\n                  return He[Hr] - He[qr];\n                }), nt = 0, jt = 0, gr = [], yr = [];\n                for (Te = 0; Te < se; ++Te) Ne = kt[Te], nt < jt ? (nt += Ye[Ne], gr.push(Ne)) : (jt += Ye[Ne], yr.push(Ne));\n                return yr.reverse().concat(gr);\n              }, reverse: function(X) {\n                return e3.range(X.length).reverse();\n              }, default: du }), Cs = e3.map({ silhouette: function(X) {\n                var se = X.length, Te = X[0].length, Ne = [], He = 0, Ye, kt, nt, jt = [];\n                for (kt = 0; kt < Te; ++kt) {\n                  for (Ye = 0, nt = 0; Ye < se; Ye++) nt += X[Ye][kt][1];\n                  nt > He && (He = nt), Ne.push(nt);\n                }\n                for (kt = 0; kt < Te; ++kt) jt[kt] = (He - Ne[kt]) / 2;\n                return jt;\n              }, wiggle: function(X) {\n                var se = X.length, Te = X[0], Ne = Te.length, He, Ye, kt, nt, jt, gr, yr, Hr, qr, _i = [];\n                for (_i[0] = Hr = qr = 0, Ye = 1; Ye < Ne; ++Ye) {\n                  for (He = 0, nt = 0; He < se; ++He) nt += X[He][Ye][1];\n                  for (He = 0, jt = 0, yr = Te[Ye][0] - Te[Ye - 1][0]; He < se; ++He) {\n                    for (kt = 0, gr = (X[He][Ye][1] - X[He][Ye - 1][1]) / (2 * yr); kt < He; ++kt) gr += (X[kt][Ye][1] - X[kt][Ye - 1][1]) / yr;\n                    jt += gr * X[He][Ye][1];\n                  }\n                  _i[Ye] = Hr -= nt ? jt / nt * yr : 0, Hr < qr && (qr = Hr);\n                }\n                for (Ye = 0; Ye < Ne; ++Ye) _i[Ye] -= qr;\n                return _i;\n              }, expand: function(X) {\n                var se = X.length, Te = X[0].length, Ne = 1 / se, He, Ye, kt, nt = [];\n                for (Ye = 0; Ye < Te; ++Ye) {\n                  for (He = 0, kt = 0; He < se; He++) kt += X[He][Ye][1];\n                  if (kt) for (He = 0; He < se; He++) X[He][Ye][1] /= kt;\n                  else for (He = 0; He < se; He++) X[He][Ye][1] = Ne;\n                }\n                for (Ye = 0; Ye < Te; ++Ye) nt[Ye] = 0;\n                return nt;\n              }, zero: ku });\n              function du(X) {\n                return e3.range(X.length);\n              }\n              function ku(X) {\n                for (var se = -1, Te = X[0].length, Ne = []; ++se < Te; ) Ne[se] = 0;\n                return Ne;\n              }\n              function Wf(X) {\n                for (var se = 1, Te = 0, Ne = X[0][1], He, Ye = X.length; se < Ye; ++se) (He = X[se][1]) > Ne && (Te = se, Ne = He);\n                return Te;\n              }\n              function Us(X) {\n                return X.reduce(wf, 0);\n              }\n              function wf(X, se) {\n                return X + se[1];\n              }\n              e3.layout.histogram = function() {\n                var X = true, se = Number, Te = Rf, Ne = zc;\n                function He(Ye, qr) {\n                  for (var nt = [], jt = Ye.map(se, this), gr = Te.call(this, jt, qr), yr = Ne.call(this, gr, jt, qr), Hr, qr = -1, _i = jt.length, bi = yr.length - 1, Zr = X ? 1 : 1 / _i, ai; ++qr < bi; ) Hr = nt[qr] = [], Hr.dx = yr[qr + 1] - (Hr.x = yr[qr]), Hr.y = 0;\n                  if (bi > 0) for (qr = -1; ++qr < _i; ) ai = jt[qr], ai >= gr[0] && ai <= gr[1] && (Hr = nt[e3.bisect(yr, ai, 1, bi) - 1], Hr.y += Zr, Hr.push(Ye[qr]));\n                  return nt;\n                }\n                return He.value = function(Ye) {\n                  return arguments.length ? (se = Ye, He) : se;\n                }, He.range = function(Ye) {\n                  return arguments.length ? (Te = vi(Ye), He) : Te;\n                }, He.bins = function(Ye) {\n                  return arguments.length ? (Ne = typeof Ye == "number" ? function(kt) {\n                    return Wu(kt, Ye);\n                  } : vi(Ye), He) : Ne;\n                }, He.frequency = function(Ye) {\n                  return arguments.length ? (X = !!Ye, He) : X;\n                }, He;\n              };\n              function zc(X, se) {\n                return Wu(X, Math.ceil(Math.log(se.length) / Math.LN2 + 1));\n              }\n              function Wu(X, se) {\n                for (var Te = -1, Ne = +X[0], He = (X[1] - Ne) / se, Ye = []; ++Te <= se; ) Ye[Te] = He * Te + Ne;\n                return Ye;\n              }\n              function Rf(X) {\n                return [e3.min(X), e3.max(X)];\n              }\n              e3.layout.pack = function() {\n                var X = e3.layout.hierarchy().sort(Xu), se = 0, Te = [1, 1], Ne;\n                function He(Ye, kt) {\n                  var nt = X.call(this, Ye, kt), jt = nt[0], gr = Te[0], yr = Te[1], Hr = Ne == null ? Math.sqrt : typeof Ne == "function" ? Ne : function() {\n                    return Ne;\n                  };\n                  if (jt.x = jt.y = 0, wc(jt, function(_i) {\n                    _i.r = +Hr(_i.value);\n                  }), wc(jt, ah), se) {\n                    var qr = se * (Ne ? 1 : Math.max(2 * jt.r / gr, 2 * jt.r / yr)) / 2;\n                    wc(jt, function(_i) {\n                      _i.r += qr;\n                    }), wc(jt, ah), wc(jt, function(_i) {\n                      _i.r -= qr;\n                    });\n                  }\n                  return Tc(jt, gr / 2, yr / 2, Ne ? 1 : 1 / Math.max(2 * jt.r / gr, 2 * jt.r / yr)), nt;\n                }\n                return He.size = function(Ye) {\n                  return arguments.length ? (Te = Ye, He) : Te;\n                }, He.radius = function(Ye) {\n                  return arguments.length ? (Ne = Ye == null || typeof Ye == "function" ? Ye : +Ye, He) : Ne;\n                }, He.padding = function(Ye) {\n                  return arguments.length ? (se = +Ye, He) : se;\n                }, zu(He, X);\n              };\n              function Xu(X, se) {\n                return X.value - se.value;\n              }\n              function uf(X, se) {\n                var Te = X._pack_next;\n                X._pack_next = se, se._pack_prev = X, se._pack_next = Te, Te._pack_prev = se;\n              }\n              function Xf(X, se) {\n                X._pack_next = se, se._pack_prev = X;\n              }\n              function Wl(X, se) {\n                var Te = se.x - X.x, Ne = se.y - X.y, He = X.r + se.r;\n                return 0.999 * He * He > Te * Te + Ne * Ne;\n              }\n              function ah(X) {\n                if (!(se = X.children) || !(qr = se.length)) return;\n                var se, Te = 1 / 0, Ne = -1 / 0, He = 1 / 0, Ye = -1 / 0, kt, nt, jt, gr, yr, Hr, qr;\n                function _i(ei) {\n                  Te = Math.min(ei.x - ei.r, Te), Ne = Math.max(ei.x + ei.r, Ne), He = Math.min(ei.y - ei.r, He), Ye = Math.max(ei.y + ei.r, Ye);\n                }\n                if (se.forEach(Zu), kt = se[0], kt.x = -kt.r, kt.y = 0, _i(kt), qr > 1 && (nt = se[1], nt.x = nt.r, nt.y = 0, _i(nt), qr > 2)) for (jt = se[2], wl(kt, nt, jt), _i(jt), uf(kt, jt), kt._pack_prev = jt, uf(jt, nt), nt = kt._pack_next, gr = 3; gr < qr; gr++) {\n                  wl(kt, nt, jt = se[gr]);\n                  var bi = 0, Zr = 1, ai = 1;\n                  for (yr = nt._pack_next; yr !== nt; yr = yr._pack_next, Zr++) if (Wl(yr, jt)) {\n                    bi = 1;\n                    break;\n                  }\n                  if (bi == 1) for (Hr = kt._pack_prev; Hr !== yr._pack_prev && !Wl(Hr, jt); Hr = Hr._pack_prev, ai++) ;\n                  bi ? (Zr < ai || Zr == ai && nt.r < kt.r ? Xf(kt, nt = yr) : Xf(kt = Hr, nt), gr--) : (uf(kt, jt), nt = jt, _i(jt));\n                }\n                var gi = (Te + Ne) / 2, Ii = (He + Ye) / 2, Si = 0;\n                for (gr = 0; gr < qr; gr++) jt = se[gr], jt.x -= gi, jt.y -= Ii, Si = Math.max(Si, jt.r + Math.sqrt(jt.x * jt.x + jt.y * jt.y));\n                X.r = Si, se.forEach(Oc);\n              }\n              function Zu(X) {\n                X._pack_next = X._pack_prev = X;\n              }\n              function Oc(X) {\n                delete X._pack_next, delete X._pack_prev;\n              }\n              function Tc(X, se, Te, Ne) {\n                var He = X.children;\n                if (X.x = se += Ne * X.x, X.y = Te += Ne * X.y, X.r *= Ne, He) for (var Ye = -1, kt = He.length; ++Ye < kt; ) Tc(He[Ye], se, Te, Ne);\n              }\n              function wl(X, se, Te) {\n                var Ne = X.r + Te.r, He = se.x - X.x, Ye = se.y - X.y;\n                if (Ne && (He || Ye)) {\n                  var kt = se.r + Te.r, nt = He * He + Ye * Ye;\n                  kt *= kt, Ne *= Ne;\n                  var jt = 0.5 + (Ne - kt) / (2 * nt), gr = Math.sqrt(Math.max(0, 2 * kt * (Ne + nt) - (Ne -= nt) * Ne - kt * kt)) / (2 * nt);\n                  Te.x = X.x + jt * He + gr * Ye, Te.y = X.y + jt * Ye - gr * He;\n                } else Te.x = X.x + Ne, Te.y = X.y;\n              }\n              e3.layout.tree = function() {\n                var X = e3.layout.hierarchy().sort(null).value(null), se = vu, Te = [1, 1], Ne = null;\n                function He(yr, Hr) {\n                  var qr = X.call(this, yr, Hr), _i = qr[0], bi = Ye(_i);\n                  if (wc(bi, kt), bi.parent.m = -bi.z, Fc(bi, nt), Ne) Fc(_i, gr);\n                  else {\n                    var Zr = _i, ai = _i, gi = _i;\n                    Fc(_i, function(Ln) {\n                      Ln.x < Zr.x && (Zr = Ln), Ln.x > ai.x && (ai = Ln), Ln.depth > gi.depth && (gi = Ln);\n                    });\n                    var Ii = se(Zr, ai) / 2 - Zr.x, Si = Te[0] / (ai.x + se(ai, Zr) / 2 + Ii), ei = Te[1] / (gi.depth || 1);\n                    Fc(_i, function(Ln) {\n                      Ln.x = (Ln.x + Ii) * Si, Ln.y = Ln.depth * ei;\n                    });\n                  }\n                  return qr;\n                }\n                function Ye(yr) {\n                  for (var Hr = { A: null, children: [yr] }, qr = [Hr], _i; (_i = qr.pop()) != null; ) for (var bi = _i.children, Zr, ai = 0, gi = bi.length; ai < gi; ++ai) qr.push((bi[ai] = Zr = { _: bi[ai], parent: _i, children: (Zr = bi[ai].children) && Zr.slice() || [], A: null, a: null, z: 0, m: 0, c: 0, s: 0, t: null, i: ai }).a = Zr);\n                  return Hr.children[0];\n                }\n                function kt(yr) {\n                  var Hr = yr.children, qr = yr.parent.children, _i = yr.i ? qr[yr.i - 1] : null;\n                  if (Hr.length) {\n                    Bc(yr);\n                    var bi = (Hr[0].z + Hr[Hr.length - 1].z) / 2;\n                    _i ? (yr.z = _i.z + se(yr._, _i._), yr.m = yr.z - bi) : yr.z = bi;\n                  } else _i && (yr.z = _i.z + se(yr._, _i._));\n                  yr.parent.A = jt(yr, _i, yr.parent.A || qr[0]);\n                }\n                function nt(yr) {\n                  yr._.x = yr.z + yr.parent.m, yr.m += yr.parent.m;\n                }\n                function jt(yr, Hr, qr) {\n                  if (Hr) {\n                    for (var _i = yr, bi = yr, Zr = Hr, ai = _i.parent.children[0], gi = _i.m, Ii = bi.m, Si = Zr.m, ei = ai.m, Ln; Zr = cf(Zr), _i = qc(_i), Zr && _i; ) ai = qc(ai), bi = cf(bi), bi.a = yr, Ln = Zr.z + Si - _i.z - gi + se(Zr._, _i._), Ln > 0 && (fc(At(Zr, yr, qr), yr, Ln), gi += Ln, Ii += Ln), Si += Zr.m, gi += _i.m, ei += ai.m, Ii += bi.m;\n                    Zr && !cf(bi) && (bi.t = Zr, bi.m += Si - Ii), _i && !qc(ai) && (ai.t = _i, ai.m += gi - ei, qr = yr);\n                  }\n                  return qr;\n                }\n                function gr(yr) {\n                  yr.x *= Te[0], yr.y = yr.depth * Te[1];\n                }\n                return He.separation = function(yr) {\n                  return arguments.length ? (se = yr, He) : se;\n                }, He.size = function(yr) {\n                  return arguments.length ? (Ne = (Te = yr) == null ? gr : null, He) : Ne ? null : Te;\n                }, He.nodeSize = function(yr) {\n                  return arguments.length ? (Ne = (Te = yr) == null ? null : gr, He) : Ne ? Te : null;\n                }, zu(He, X);\n              };\n              function vu(X, se) {\n                return X.parent == se.parent ? 1 : 2;\n              }\n              function qc(X) {\n                var se = X.children;\n                return se.length ? se[0] : X.t;\n              }\n              function cf(X) {\n                var se = X.children, Te;\n                return (Te = se.length) ? se[Te - 1] : X.t;\n              }\n              function fc(X, se, Te) {\n                var Ne = Te / (se.i - X.i);\n                se.c -= Ne, se.s += Te, X.c += Ne, se.z += Te, se.m += Te;\n              }\n              function Bc(X) {\n                for (var se = 0, Te = 0, Ne = X.children, He = Ne.length, Ye; --He >= 0; ) Ye = Ne[He], Ye.z += se, Ye.m += se, se += Ye.s + (Te += Ye.c);\n              }\n              function At(X, se, Te) {\n                return X.a.parent === se.parent ? X.a : Te;\n              }\n              e3.layout.cluster = function() {\n                var X = e3.layout.hierarchy().sort(null).value(null), se = vu, Te = [1, 1], Ne = false;\n                function He(Ye, kt) {\n                  var nt = X.call(this, Ye, kt), jt = nt[0], gr, yr = 0;\n                  wc(jt, function(Zr) {\n                    var ai = Zr.children;\n                    ai && ai.length ? (Zr.x = Cr(ai), Zr.y = Wt(ai)) : (Zr.x = gr ? yr += se(Zr, gr) : 0, Zr.y = 0, gr = Zr);\n                  });\n                  var Hr = Ar(jt), qr = Kr(jt), _i = Hr.x - se(Hr, qr) / 2, bi = qr.x + se(qr, Hr) / 2;\n                  return wc(jt, Ne ? function(Zr) {\n                    Zr.x = (Zr.x - jt.x) * Te[0], Zr.y = (jt.y - Zr.y) * Te[1];\n                  } : function(Zr) {\n                    Zr.x = (Zr.x - _i) / (bi - _i) * Te[0], Zr.y = (1 - (jt.y ? Zr.y / jt.y : 1)) * Te[1];\n                  }), nt;\n                }\n                return He.separation = function(Ye) {\n                  return arguments.length ? (se = Ye, He) : se;\n                }, He.size = function(Ye) {\n                  return arguments.length ? (Ne = (Te = Ye) == null, He) : Ne ? null : Te;\n                }, He.nodeSize = function(Ye) {\n                  return arguments.length ? (Ne = (Te = Ye) != null, He) : Ne ? Te : null;\n                }, zu(He, X);\n              };\n              function Wt(X) {\n                return 1 + e3.max(X, function(se) {\n                  return se.y;\n                });\n              }\n              function Cr(X) {\n                return X.reduce(function(se, Te) {\n                  return se + Te.x;\n                }, 0) / X.length;\n              }\n              function Ar(X) {\n                var se = X.children;\n                return se && se.length ? Ar(se[0]) : X;\n              }\n              function Kr(X) {\n                var se = X.children, Te;\n                return se && (Te = se.length) ? Kr(se[Te - 1]) : X;\n              }\n              e3.layout.treemap = function() {\n                var X = e3.layout.hierarchy(), se = Math.round, Te = [1, 1], Ne = null, He = ki, Ye = false, kt, nt = "squarify", jt = 0.5 * (1 + Math.sqrt(5));\n                function gr(Zr, ai) {\n                  for (var gi = -1, Ii = Zr.length, Si, ei; ++gi < Ii; ) ei = (Si = Zr[gi]).value * (ai < 0 ? 0 : ai), Si.area = isNaN(ei) || ei <= 0 ? 0 : ei;\n                }\n                function yr(Zr) {\n                  var ai = Zr.children;\n                  if (ai && ai.length) {\n                    var gi = He(Zr), Ii = [], Si = ai.slice(), ei, Ln = 1 / 0, En, Un = nt === "slice" ? gi.dx : nt === "dice" ? gi.dy : nt === "slice-dice" ? Zr.depth & 1 ? gi.dy : gi.dx : Math.min(gi.dx, gi.dy), ia;\n                    for (gr(Si, gi.dx * gi.dy / Zr.value), Ii.area = 0; (ia = Si.length) > 0; ) Ii.push(ei = Si[ia - 1]), Ii.area += ei.area, nt !== "squarify" || (En = qr(Ii, Un)) <= Ln ? (Si.pop(), Ln = En) : (Ii.area -= Ii.pop().area, _i(Ii, Un, gi, false), Un = Math.min(gi.dx, gi.dy), Ii.length = Ii.area = 0, Ln = 1 / 0);\n                    Ii.length && (_i(Ii, Un, gi, true), Ii.length = Ii.area = 0), ai.forEach(yr);\n                  }\n                }\n                function Hr(Zr) {\n                  var ai = Zr.children;\n                  if (ai && ai.length) {\n                    var gi = He(Zr), Ii = ai.slice(), Si, ei = [];\n                    for (gr(Ii, gi.dx * gi.dy / Zr.value), ei.area = 0; Si = Ii.pop(); ) ei.push(Si), ei.area += Si.area, Si.z != null && (_i(ei, Si.z ? gi.dx : gi.dy, gi, !Ii.length), ei.length = ei.area = 0);\n                    ai.forEach(Hr);\n                  }\n                }\n                function qr(Zr, ai) {\n                  for (var gi = Zr.area, Ii, Si = 0, ei = 1 / 0, Ln = -1, En = Zr.length; ++Ln < En; ) (Ii = Zr[Ln].area) && (Ii < ei && (ei = Ii), Ii > Si && (Si = Ii));\n                  return gi *= gi, ai *= ai, gi ? Math.max(ai * Si * jt / gi, gi / (ai * ei * jt)) : 1 / 0;\n                }\n                function _i(Zr, ai, gi, Ii) {\n                  var Si = -1, ei = Zr.length, Ln = gi.x, En = gi.y, Un = ai ? se(Zr.area / ai) : 0, ia;\n                  if (ai == gi.dx) {\n                    for ((Ii || Un > gi.dy) && (Un = gi.dy); ++Si < ei; ) ia = Zr[Si], ia.x = Ln, ia.y = En, ia.dy = Un, Ln += ia.dx = Math.min(gi.x + gi.dx - Ln, Un ? se(ia.area / Un) : 0);\n                    ia.z = true, ia.dx += gi.x + gi.dx - Ln, gi.y += Un, gi.dy -= Un;\n                  } else {\n                    for ((Ii || Un > gi.dx) && (Un = gi.dx); ++Si < ei; ) ia = Zr[Si], ia.x = Ln, ia.y = En, ia.dx = Un, En += ia.dy = Math.min(gi.y + gi.dy - En, Un ? se(ia.area / Un) : 0);\n                    ia.z = false, ia.dy += gi.y + gi.dy - En, gi.x += Un, gi.dx -= Un;\n                  }\n                }\n                function bi(Zr) {\n                  var ai = kt || X(Zr), gi = ai[0];\n                  return gi.x = gi.y = 0, gi.value ? (gi.dx = Te[0], gi.dy = Te[1]) : gi.dx = gi.dy = 0, kt && X.revalue(gi), gr([gi], gi.dx * gi.dy / gi.value), (kt ? Hr : yr)(gi), Ye && (kt = ai), ai;\n                }\n                return bi.size = function(Zr) {\n                  return arguments.length ? (Te = Zr, bi) : Te;\n                }, bi.padding = function(Zr) {\n                  if (!arguments.length) return Ne;\n                  function ai(Si) {\n                    var ei = Zr.call(bi, Si, Si.depth);\n                    return ei == null ? ki(Si) : Xi(Si, typeof ei == "number" ? [ei, ei, ei, ei] : ei);\n                  }\n                  function gi(Si) {\n                    return Xi(Si, Zr);\n                  }\n                  var Ii;\n                  return He = (Ne = Zr) == null ? ki : (Ii = typeof Zr) == "function" ? ai : (Ii === "number" && (Zr = [Zr, Zr, Zr, Zr]), gi), bi;\n                }, bi.round = function(Zr) {\n                  return arguments.length ? (se = Zr ? Math.round : Number, bi) : se != Number;\n                }, bi.sticky = function(Zr) {\n                  return arguments.length ? (Ye = Zr, kt = null, bi) : Ye;\n                }, bi.ratio = function(Zr) {\n                  return arguments.length ? (jt = Zr, bi) : jt;\n                }, bi.mode = function(Zr) {\n                  return arguments.length ? (nt = Zr + "", bi) : nt;\n                }, zu(bi, X);\n              };\n              function ki(X) {\n                return { x: X.x, y: X.y, dx: X.dx, dy: X.dy };\n              }\n              function Xi(X, se) {\n                var Te = X.x + se[3], Ne = X.y + se[0], He = X.dx - se[1] - se[3], Ye = X.dy - se[0] - se[2];\n                return He < 0 && (Te += He / 2, He = 0), Ye < 0 && (Ne += Ye / 2, Ye = 0), { x: Te, y: Ne, dx: He, dy: Ye };\n              }\n              e3.random = { normal: function(X, se) {\n                var Te = arguments.length;\n                return Te < 2 && (se = 1), Te < 1 && (X = 0), function() {\n                  var Ne, He, Ye;\n                  do\n                    Ne = Math.random() * 2 - 1, He = Math.random() * 2 - 1, Ye = Ne * Ne + He * He;\n                  while (!Ye || Ye > 1);\n                  return X + se * Ne * Math.sqrt(-2 * Math.log(Ye) / Ye);\n                };\n              }, logNormal: function() {\n                var X = e3.random.normal.apply(e3, arguments);\n                return function() {\n                  return Math.exp(X());\n                };\n              }, bates: function(X) {\n                var se = e3.random.irwinHall(X);\n                return function() {\n                  return se() / X;\n                };\n              }, irwinHall: function(X) {\n                return function() {\n                  for (var se = 0, Te = 0; Te < X; Te++) se += Math.random();\n                  return se;\n                };\n              } }, e3.scale = {};\n              function dn(X) {\n                var se = X[0], Te = X[X.length - 1];\n                return se < Te ? [se, Te] : [Te, se];\n              }\n              function wn(X) {\n                return X.rangeExtent ? X.rangeExtent() : dn(X.range());\n              }\n              function Nn(X, se, Te, Ne) {\n                var He = Te(X[0], X[1]), Ye = Ne(se[0], se[1]);\n                return function(kt) {\n                  return Ye(He(kt));\n                };\n              }\n              function Yi(X, se) {\n                var Te = 0, Ne = X.length - 1, He = X[Te], Ye = X[Ne], kt;\n                return Ye < He && (kt = Te, Te = Ne, Ne = kt, kt = He, He = Ye, Ye = kt), X[Te] = se.floor(He), X[Ne] = se.ceil(Ye), X;\n              }\n              function Qi(X) {\n                return X ? { floor: function(se) {\n                  return Math.floor(se / X) * X;\n                }, ceil: function(se) {\n                  return Math.ceil(se / X) * X;\n                } } : on;\n              }\n              var on = { floor: G2, ceil: G2 };\n              function Fi(X, se, Te, Ne) {\n                var He = [], Ye = [], kt = 0, nt = Math.min(X.length, se.length) - 1;\n                for (X[nt] < X[0] && (X = X.slice().reverse(), se = se.slice().reverse()); ++kt <= nt; ) He.push(Te(X[kt - 1], X[kt])), Ye.push(Ne(se[kt - 1], se[kt]));\n                return function(jt) {\n                  var gr = e3.bisect(X, jt, 1, nt) - 1;\n                  return Ye[gr](He[gr](jt));\n                };\n              }\n              e3.scale.linear = function() {\n                return $n([0, 1], [0, 1], xl, false);\n              };\n              function $n(X, se, Te, Ne) {\n                var He, Ye;\n                function kt() {\n                  var jt = Math.min(X.length, se.length) > 2 ? Fi : Nn, gr = Ne ? Mu : Th;\n                  return He = jt(X, se, gr, Te), Ye = jt(se, X, gr, xl), nt;\n                }\n                function nt(jt) {\n                  return He(jt);\n                }\n                return nt.invert = function(jt) {\n                  return Ye(jt);\n                }, nt.domain = function(jt) {\n                  return arguments.length ? (X = jt.map(Number), kt()) : X;\n                }, nt.range = function(jt) {\n                  return arguments.length ? (se = jt, kt()) : se;\n                }, nt.rangeRound = function(jt) {\n                  return nt.range(jt).interpolate(ju);\n                }, nt.clamp = function(jt) {\n                  return arguments.length ? (Ne = jt, kt()) : Ne;\n                }, nt.interpolate = function(jt) {\n                  return arguments.length ? (Te = jt, kt()) : Te;\n                }, nt.ticks = function(jt) {\n                  return Na(X, jt);\n                }, nt.tickFormat = function(jt, gr) {\n                  return d3_scale_linearTickFormat(X, jt, gr);\n                }, nt.nice = function(jt) {\n                  return Ra(X, jt), kt();\n                }, nt.copy = function() {\n                  return $n(X, se, Te, Ne);\n                }, kt();\n              }\n              function Ca(X, se) {\n                return e3.rebind(X, se, "range", "rangeRound", "interpolate", "clamp");\n              }\n              function Ra(X, se) {\n                return Yi(X, Qi(La(X, se)[2])), Yi(X, Qi(La(X, se)[2])), X;\n              }\n              function La(X, se) {\n                se == null && (se = 10);\n                var Te = dn(X), Ne = Te[1] - Te[0], He = Math.pow(10, Math.floor(Math.log(Ne / se) / Math.LN10)), Ye = se / Ne * He;\n                return Ye <= 0.15 ? He *= 10 : Ye <= 0.35 ? He *= 5 : Ye <= 0.75 && (He *= 2), Te[0] = Math.ceil(Te[0] / He) * He, Te[1] = Math.floor(Te[1] / He) * He + He * 0.5, Te[2] = He, Te;\n              }\n              function Na(X, se) {\n                return e3.range.apply(e3, La(X, se));\n              }\n              var Yn = { s: 1, g: 1, p: 1, r: 1, e: 1 };\n              function Dn(X) {\n                return -Math.floor(Math.log(X) / Math.LN10 + 0.01);\n              }\n              function Ka(X, se) {\n                var Te = Dn(se[2]);\n                return X in Yn ? Math.abs(Te - Dn(Math.max(p3(se[0]), p3(se[1])))) + +(X !== "e") : Te - (X === "%") * 2;\n              }\n              e3.scale.log = function() {\n                return bo(e3.scale.linear().domain([0, 1]), 10, true, [1, 10]);\n              };\n              function bo(X, se, Te, Ne) {\n                function He(nt) {\n                  return (Te ? Math.log(nt < 0 ? 0 : nt) : -Math.log(nt > 0 ? 0 : -nt)) / Math.log(se);\n                }\n                function Ye(nt) {\n                  return Te ? Math.pow(se, nt) : -Math.pow(se, -nt);\n                }\n                function kt(nt) {\n                  return X(He(nt));\n                }\n                return kt.invert = function(nt) {\n                  return Ye(X.invert(nt));\n                }, kt.domain = function(nt) {\n                  return arguments.length ? (Te = nt[0] >= 0, X.domain((Ne = nt.map(Number)).map(He)), kt) : Ne;\n                }, kt.base = function(nt) {\n                  return arguments.length ? (se = +nt, X.domain(Ne.map(He)), kt) : se;\n                }, kt.nice = function() {\n                  var nt = Yi(Ne.map(He), Te ? Math : Xo);\n                  return X.domain(nt), Ne = nt.map(Ye), kt;\n                }, kt.ticks = function() {\n                  var nt = dn(Ne), jt = [], gr = nt[0], yr = nt[1], Hr = Math.floor(He(gr)), qr = Math.ceil(He(yr)), _i = se % 1 ? 2 : se;\n                  if (isFinite(qr - Hr)) {\n                    if (Te) {\n                      for (; Hr < qr; Hr++) for (var bi = 1; bi < _i; bi++) jt.push(Ye(Hr) * bi);\n                      jt.push(Ye(Hr));\n                    } else for (jt.push(Ye(Hr)); Hr++ < qr; ) for (var bi = _i - 1; bi > 0; bi--) jt.push(Ye(Hr) * bi);\n                    for (Hr = 0; jt[Hr] < gr; Hr++) ;\n                    for (qr = jt.length; jt[qr - 1] > yr; qr--) ;\n                    jt = jt.slice(Hr, qr);\n                  }\n                  return jt;\n                }, kt.copy = function() {\n                  return bo(X.copy(), se, Te, Ne);\n                }, Ca(kt, X);\n              }\n              var Xo = { floor: function(X) {\n                return -Math.ceil(-X);\n              }, ceil: function(X) {\n                return -Math.floor(-X);\n              } };\n              e3.scale.pow = function() {\n                return Ss(e3.scale.linear(), 1, [0, 1]);\n              };\n              function Ss(X, se, Te) {\n                var Ne = as(se), He = as(1 / se);\n                function Ye(kt) {\n                  return X(Ne(kt));\n                }\n                return Ye.invert = function(kt) {\n                  return He(X.invert(kt));\n                }, Ye.domain = function(kt) {\n                  return arguments.length ? (X.domain((Te = kt.map(Number)).map(Ne)), Ye) : Te;\n                }, Ye.ticks = function(kt) {\n                  return Na(Te, kt);\n                }, Ye.tickFormat = function(kt, nt) {\n                  return d3_scale_linearTickFormat(Te, kt, nt);\n                }, Ye.nice = function(kt) {\n                  return Ye.domain(Ra(Te, kt));\n                }, Ye.exponent = function(kt) {\n                  return arguments.length ? (Ne = as(se = kt), He = as(1 / se), X.domain(Te.map(Ne)), Ye) : se;\n                }, Ye.copy = function() {\n                  return Ss(X.copy(), se, Te);\n                }, Ca(Ye, X);\n              }\n              function as(X) {\n                return function(se) {\n                  return se < 0 ? -Math.pow(-se, X) : Math.pow(se, X);\n                };\n              }\n              e3.scale.sqrt = function() {\n                return e3.scale.pow().exponent(0.5);\n              }, e3.scale.ordinal = function() {\n                return ws([], { t: "range", a: [[]] });\n              };\n              function ws(X, se) {\n                var Te, Ne, He;\n                function Ye(nt) {\n                  return Ne[((Te.get(nt) || (se.t === "range" ? Te.set(nt, X.push(nt)) : NaN)) - 1) % Ne.length];\n                }\n                function kt(nt, jt) {\n                  return e3.range(X.length).map(function(gr) {\n                    return nt + jt * gr;\n                  });\n                }\n                return Ye.domain = function(nt) {\n                  if (!arguments.length) return X;\n                  X = [], Te = new S2();\n                  for (var jt = -1, gr = nt.length, yr; ++jt < gr; ) Te.has(yr = nt[jt]) || Te.set(yr, X.push(yr));\n                  return Ye[se.t].apply(Ye, se.a);\n                }, Ye.range = function(nt) {\n                  return arguments.length ? (Ne = nt, He = 0, se = { t: "range", a: arguments }, Ye) : Ne;\n                }, Ye.rangePoints = function(nt, jt) {\n                  arguments.length < 2 && (jt = 0);\n                  var gr = nt[0], yr = nt[1], Hr = X.length < 2 ? (gr = (gr + yr) / 2, 0) : (yr - gr) / (X.length - 1 + jt);\n                  return Ne = kt(gr + Hr * jt / 2, Hr), He = 0, se = { t: "rangePoints", a: arguments }, Ye;\n                }, Ye.rangeRoundPoints = function(nt, jt) {\n                  arguments.length < 2 && (jt = 0);\n                  var gr = nt[0], yr = nt[1], Hr = X.length < 2 ? (gr = yr = Math.round((gr + yr) / 2), 0) : (yr - gr) / (X.length - 1 + jt) | 0;\n                  return Ne = kt(gr + Math.round(Hr * jt / 2 + (yr - gr - (X.length - 1 + jt) * Hr) / 2), Hr), He = 0, se = { t: "rangeRoundPoints", a: arguments }, Ye;\n                }, Ye.rangeBands = function(nt, jt, gr) {\n                  arguments.length < 2 && (jt = 0), arguments.length < 3 && (gr = jt);\n                  var yr = nt[1] < nt[0], Hr = nt[yr - 0], qr = nt[1 - yr], _i = (qr - Hr) / (X.length - jt + 2 * gr);\n                  return Ne = kt(Hr + _i * gr, _i), yr && Ne.reverse(), He = _i * (1 - jt), se = { t: "rangeBands", a: arguments }, Ye;\n                }, Ye.rangeRoundBands = function(nt, jt, gr) {\n                  arguments.length < 2 && (jt = 0), arguments.length < 3 && (gr = jt);\n                  var yr = nt[1] < nt[0], Hr = nt[yr - 0], qr = nt[1 - yr], _i = Math.floor((qr - Hr) / (X.length - jt + 2 * gr));\n                  return Ne = kt(Hr + Math.round((qr - Hr - (X.length - jt) * _i) / 2), _i), yr && Ne.reverse(), He = Math.round(_i * (1 - jt)), se = { t: "rangeRoundBands", a: arguments }, Ye;\n                }, Ye.rangeBand = function() {\n                  return He;\n                }, Ye.rangeExtent = function() {\n                  return dn(se.a[0]);\n                }, Ye.copy = function() {\n                  return ws(X, se);\n                }, Ye.domain(X);\n              }\n              e3.scale.category10 = function() {\n                return e3.scale.ordinal().range(Ho);\n              }, e3.scale.category20 = function() {\n                return e3.scale.ordinal().range(ml);\n              }, e3.scale.category20b = function() {\n                return e3.scale.ordinal().range(Ws);\n              }, e3.scale.category20c = function() {\n                return e3.scale.ordinal().range(Ls);\n              };\n              var Ho = [2062260, 16744206, 2924588, 14034728, 9725885, 9197131, 14907330, 8355711, 12369186, 1556175].map(Wo), ml = [2062260, 11454440, 16744206, 16759672, 2924588, 10018698, 14034728, 16750742, 9725885, 12955861, 9197131, 12885140, 14907330, 16234194, 8355711, 13092807, 12369186, 14408589, 1556175, 10410725].map(Wo), Ws = [3750777, 5395619, 7040719, 10264286, 6519097, 9216594, 11915115, 13556636, 9202993, 12426809, 15186514, 15190932, 8666169, 11356490, 14049643, 15177372, 8077683, 10834324, 13528509, 14589654].map(Wo), Ls = [3244733, 7057110, 10406625, 13032431, 15095053, 16616764, 16625259, 16634018, 3253076, 7652470, 10607003, 13101504, 7695281, 10394312, 12369372, 14342891, 6513507, 9868950, 12434877, 14277081].map(Wo);\n              e3.scale.quantile = function() {\n                return va([], []);\n              };\n              function va(X, se) {\n                var Te;\n                function Ne() {\n                  var Ye = 0, kt = se.length;\n                  for (Te = []; ++Ye < kt; ) Te[Ye - 1] = e3.quantile(X, Ye / kt);\n                  return He;\n                }\n                function He(Ye) {\n                  if (!isNaN(Ye = +Ye)) return se[e3.bisect(Te, Ye)];\n                }\n                return He.domain = function(Ye) {\n                  return arguments.length ? (X = Ye.map(h3).filter(d3).sort(f4), Ne()) : X;\n                }, He.range = function(Ye) {\n                  return arguments.length ? (se = Ye, Ne()) : se;\n                }, He.quantiles = function() {\n                  return Te;\n                }, He.invertExtent = function(Ye) {\n                  return Ye = se.indexOf(Ye), Ye < 0 ? [NaN, NaN] : [Ye > 0 ? Te[Ye - 1] : X[0], Ye < Te.length ? Te[Ye] : X[X.length - 1]];\n                }, He.copy = function() {\n                  return va(X, se);\n                }, Ne();\n              }\n              e3.scale.quantize = function() {\n                return no(0, 1, [0, 1]);\n              };\n              function no(X, se, Te) {\n                var Ne, He;\n                function Ye(nt) {\n                  return Te[Math.max(0, Math.min(He, Math.floor(Ne * (nt - X))))];\n                }\n                function kt() {\n                  return Ne = Te.length / (se - X), He = Te.length - 1, Ye;\n                }\n                return Ye.domain = function(nt) {\n                  return arguments.length ? (X = +nt[0], se = +nt[nt.length - 1], kt()) : [X, se];\n                }, Ye.range = function(nt) {\n                  return arguments.length ? (Te = nt, kt()) : Te;\n                }, Ye.invertExtent = function(nt) {\n                  return nt = Te.indexOf(nt), nt = nt < 0 ? NaN : nt / Ne + X, [nt, nt + 1 / Ne];\n                }, Ye.copy = function() {\n                  return no(X, se, Te);\n                }, kt();\n              }\n              e3.scale.threshold = function() {\n                return ys([0.5], [0, 1]);\n              };\n              function ys(X, se) {\n                function Te(Ne) {\n                  if (Ne <= Ne) return se[e3.bisect(X, Ne)];\n                }\n                return Te.domain = function(Ne) {\n                  return arguments.length ? (X = Ne, Te) : X;\n                }, Te.range = function(Ne) {\n                  return arguments.length ? (se = Ne, Te) : se;\n                }, Te.invertExtent = function(Ne) {\n                  return Ne = se.indexOf(Ne), [X[Ne - 1], X[Ne]];\n                }, Te.copy = function() {\n                  return ys(X, se);\n                }, Te;\n              }\n              e3.scale.identity = function() {\n                return rs([0, 1]);\n              };\n              function rs(X) {\n                function se(Te) {\n                  return +Te;\n                }\n                return se.invert = se, se.domain = se.range = function(Te) {\n                  return arguments.length ? (X = Te.map(se), se) : X;\n                }, se.ticks = function(Te) {\n                  return Na(X, Te);\n                }, se.tickFormat = function(Te, Ne) {\n                  return d3_scale_linearTickFormat(X, Te, Ne);\n                }, se.copy = function() {\n                  return rs(X);\n                }, se;\n              }\n              e3.svg = {};\n              function $l() {\n                return 0;\n              }\n              e3.svg.arc = function() {\n                var X = Yu, se = Nc, Te = $l, Ne = Cu, He = pu, Ye = Uc, kt = xu;\n                function nt() {\n                  var gr = Math.max(0, +X.apply(this, arguments)), yr = Math.max(0, +se.apply(this, arguments)), Hr = He.apply(this, arguments) - xe, qr = Ye.apply(this, arguments) - xe, _i = Math.abs(qr - Hr), bi = Hr > qr ? 0 : 1;\n                  if (yr < gr && (Zr = yr, yr = gr, gr = Zr), _i >= Ie) return jt(yr, bi) + (gr ? jt(gr, 1 - bi) : "") + "Z";\n                  var Zr, ai, gi, Ii, Si = 0, ei = 0, Ln, En, Un, ia, Ea, Ia, yo, Da, go = [];\n                  if ((Ii = (+kt.apply(this, arguments) || 0) / 2) && (gi = Ne === Cu ? Math.sqrt(gr * gr + yr * yr) : +Ne.apply(this, arguments), bi || (ei *= -1), yr && (ei = ii(gi / yr * Math.sin(Ii))), gr && (Si = ii(gi / gr * Math.sin(Ii)))), yr) {\n                    Ln = yr * Math.cos(Hr + ei), En = yr * Math.sin(Hr + ei), Un = yr * Math.cos(qr - ei), ia = yr * Math.sin(qr - ei);\n                    var Is = Math.abs(qr - Hr - 2 * ei) <= tt ? 0 : 1;\n                    if (ei && Ac(Ln, En, Un, ia) === bi ^ Is) {\n                      var Ms = (Hr + qr) / 2;\n                      Ln = yr * Math.cos(Ms), En = yr * Math.sin(Ms), Un = ia = null;\n                    }\n                  } else Ln = En = 0;\n                  if (gr) {\n                    Ea = gr * Math.cos(qr - Si), Ia = gr * Math.sin(qr - Si), yo = gr * Math.cos(Hr + Si), Da = gr * Math.sin(Hr + Si);\n                    var Xs = Math.abs(Hr - qr + 2 * Si) <= tt ? 0 : 1;\n                    if (Si && Ac(Ea, Ia, yo, Da) === 1 - bi ^ Xs) {\n                      var Gn = (Hr + qr) / 2;\n                      Ea = gr * Math.cos(Gn), Ia = gr * Math.sin(Gn), yo = Da = null;\n                    }\n                  } else Ea = Ia = 0;\n                  if (_i > Je && (Zr = Math.min(Math.abs(yr - gr) / 2, +Te.apply(this, arguments))) > 1e-3) {\n                    ai = gr < yr ^ bi ? 0 : 1;\n                    var ja = Zr, Fo = Zr;\n                    if (_i < tt) {\n                      var Uo = yo == null ? [Ea, Ia] : Un == null ? [Ln, En] : il([Ln, En], [yo, Da], [Un, ia], [Ea, Ia]), $s = Ln - Uo[0], Sl = En - Uo[1], bu = Un - Uo[0], dl = ia - Uo[1], Sc = 1 / Math.sin(Math.acos(($s * bu + Sl * dl) / (Math.sqrt($s * $s + Sl * Sl) * Math.sqrt(bu * bu + dl * dl))) / 2), Me = Math.sqrt(Uo[0] * Uo[0] + Uo[1] * Uo[1]);\n                      Fo = Math.min(Zr, (gr - Me) / (Sc - 1)), ja = Math.min(Zr, (yr - Me) / (Sc + 1));\n                    }\n                    if (Un != null) {\n                      var bt = Ua(yo == null ? [Ea, Ia] : [yo, Da], [Ln, En], yr, ja, bi), zt = Ua([Un, ia], [Ea, Ia], yr, ja, bi);\n                      Zr === ja ? go.push("M", bt[0], "A", ja, ",", ja, " 0 0,", ai, " ", bt[1], "A", yr, ",", yr, " 0 ", 1 - bi ^ Ac(bt[1][0], bt[1][1], zt[1][0], zt[1][1]), ",", bi, " ", zt[1], "A", ja, ",", ja, " 0 0,", ai, " ", zt[0]) : go.push("M", bt[0], "A", ja, ",", ja, " 0 1,", ai, " ", zt[0]);\n                    } else go.push("M", Ln, ",", En);\n                    if (yo != null) {\n                      var Rr = Ua([Ln, En], [yo, Da], gr, -Fo, bi), jr = Ua([Ea, Ia], Un == null ? [Ln, En] : [Un, ia], gr, -Fo, bi);\n                      Zr === Fo ? go.push("L", jr[0], "A", Fo, ",", Fo, " 0 0,", ai, " ", jr[1], "A", gr, ",", gr, " 0 ", bi ^ Ac(jr[1][0], jr[1][1], Rr[1][0], Rr[1][1]), ",", 1 - bi, " ", Rr[1], "A", Fo, ",", Fo, " 0 0,", ai, " ", Rr[0]) : go.push("L", jr[0], "A", Fo, ",", Fo, " 0 0,", ai, " ", Rr[0]);\n                    } else go.push("L", Ea, ",", Ia);\n                  } else go.push("M", Ln, ",", En), Un != null && go.push("A", yr, ",", yr, " 0 ", Is, ",", bi, " ", Un, ",", ia), go.push("L", Ea, ",", Ia), yo != null && go.push("A", gr, ",", gr, " 0 ", Xs, ",", 1 - bi, " ", yo, ",", Da);\n                  return go.push("Z"), go.join("");\n                }\n                function jt(gr, yr) {\n                  return "M0," + gr + "A" + gr + "," + gr + " 0 1," + yr + " 0," + -gr + "A" + gr + "," + gr + " 0 1," + yr + " 0," + gr;\n                }\n                return nt.innerRadius = function(gr) {\n                  return arguments.length ? (X = vi(gr), nt) : X;\n                }, nt.outerRadius = function(gr) {\n                  return arguments.length ? (se = vi(gr), nt) : se;\n                }, nt.cornerRadius = function(gr) {\n                  return arguments.length ? (Te = vi(gr), nt) : Te;\n                }, nt.padRadius = function(gr) {\n                  return arguments.length ? (Ne = gr == Cu ? Cu : vi(gr), nt) : Ne;\n                }, nt.startAngle = function(gr) {\n                  return arguments.length ? (He = vi(gr), nt) : He;\n                }, nt.endAngle = function(gr) {\n                  return arguments.length ? (Ye = vi(gr), nt) : Ye;\n                }, nt.padAngle = function(gr) {\n                  return arguments.length ? (kt = vi(gr), nt) : kt;\n                }, nt.centroid = function() {\n                  var gr = (+X.apply(this, arguments) + +se.apply(this, arguments)) / 2, yr = (+He.apply(this, arguments) + +Ye.apply(this, arguments)) / 2 - xe;\n                  return [Math.cos(yr) * gr, Math.sin(yr) * gr];\n                }, nt;\n              };\n              var Cu = "auto";\n              function Yu(X) {\n                return X.innerRadius;\n              }\n              function Nc(X) {\n                return X.outerRadius;\n              }\n              function pu(X) {\n                return X.startAngle;\n              }\n              function Uc(X) {\n                return X.endAngle;\n              }\n              function xu(X) {\n                return X && X.padAngle;\n              }\n              function Ac(X, se, Te, Ne) {\n                return (X - Te) * se - (se - Ne) * X > 0 ? 0 : 1;\n              }\n              function Ua(X, se, Te, Ne, He) {\n                var Ye = X[0] - se[0], kt = X[1] - se[1], nt = (He ? Ne : -Ne) / Math.sqrt(Ye * Ye + kt * kt), jt = nt * kt, gr = -nt * Ye, yr = X[0] + jt, Hr = X[1] + gr, qr = se[0] + jt, _i = se[1] + gr, bi = (yr + qr) / 2, Zr = (Hr + _i) / 2, ai = qr - yr, gi = _i - Hr, Ii = ai * ai + gi * gi, Si = Te - Ne, ei = yr * _i - qr * Hr, Ln = (gi < 0 ? -1 : 1) * Math.sqrt(Math.max(0, Si * Si * Ii - ei * ei)), En = (ei * gi - ai * Ln) / Ii, Un = (-ei * ai - gi * Ln) / Ii, ia = (ei * gi + ai * Ln) / Ii, Ea = (-ei * ai + gi * Ln) / Ii, Ia = En - bi, yo = Un - Zr, Da = ia - bi, go = Ea - Zr;\n                return Ia * Ia + yo * yo > Da * Da + go * go && (En = ia, Un = Ea), [[En - jt, Un - gr], [En * Te / Si, Un * Te / Si]];\n              }\n              function oo() {\n                return true;\n              }\n              function Vc(X) {\n                var se = Ds, Te = Fs, Ne = oo, He = Ku, Ye = He.key, kt = 0.7;\n                function nt(jt) {\n                  var gr = [], yr = [], Hr = -1, qr = jt.length, _i, bi = vi(se), Zr = vi(Te);\n                  function ai() {\n                    gr.push("M", He(X(yr), kt));\n                  }\n                  for (; ++Hr < qr; ) Ne.call(this, _i = jt[Hr], Hr) ? yr.push([+bi.call(this, _i, Hr), +Zr.call(this, _i, Hr)]) : yr.length && (ai(), yr = []);\n                  return yr.length && ai(), gr.length ? gr.join("") : null;\n                }\n                return nt.x = function(jt) {\n                  return arguments.length ? (se = jt, nt) : se;\n                }, nt.y = function(jt) {\n                  return arguments.length ? (Te = jt, nt) : Te;\n                }, nt.defined = function(jt) {\n                  return arguments.length ? (Ne = jt, nt) : Ne;\n                }, nt.interpolate = function(jt) {\n                  return arguments.length ? (typeof jt == "function" ? Ye = He = jt : Ye = (He = hc.get(jt) || Ku).key, nt) : Ye;\n                }, nt.tension = function(jt) {\n                  return arguments.length ? (kt = jt, nt) : kt;\n                }, nt;\n              }\n              e3.svg.line = function() {\n                return Vc(G2);\n              };\n              var hc = e3.map({ linear: Ku, "linear-closed": ue, step: w4, "step-before": B4, "step-after": Q, basis: Tt, "basis-open": Yt, "basis-closed": Kt, bundle: xr, cardinal: qe, "cardinal-open": ee, "cardinal-closed": le, monotone: Ft });\n              hc.forEach(function(X, se) {\n                se.key = X, se.closed = /-closed$/.test(X);\n              });\n              function Ku(X) {\n                return X.length > 1 ? X.join("L") : X + "Z";\n              }\n              function ue(X) {\n                return X.join("L") + "Z";\n              }\n              function w4(X) {\n                for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("H", (Ne[0] + (Ne = X[se])[0]) / 2, "V", Ne[1]);\n                return Te > 1 && He.push("H", Ne[0]), He.join("");\n              }\n              function B4(X) {\n                for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("V", (Ne = X[se])[1], "H", Ne[0]);\n                return He.join("");\n              }\n              function Q(X) {\n                for (var se = 0, Te = X.length, Ne = X[0], He = [Ne[0], ",", Ne[1]]; ++se < Te; ) He.push("H", (Ne = X[se])[0], "V", Ne[1]);\n                return He.join("");\n              }\n              function ee(X, se) {\n                return X.length < 4 ? Ku(X) : X[1] + Xe(X.slice(1, -1), ot(X, se));\n              }\n              function le(X, se) {\n                return X.length < 3 ? ue(X) : X[0] + Xe((X.push(X[0]), X), ot([X[X.length - 2]].concat(X, [X[1]]), se));\n              }\n              function qe(X, se) {\n                return X.length < 3 ? Ku(X) : X[0] + Xe(X, ot(X, se));\n              }\n              function Xe(X, se) {\n                if (se.length < 1 || X.length != se.length && X.length != se.length + 2) return Ku(X);\n                var Te = X.length != se.length, Ne = "", He = X[0], Ye = X[1], kt = se[0], nt = kt, jt = 1;\n                if (Te && (Ne += "Q" + (Ye[0] - kt[0] * 2 / 3) + "," + (Ye[1] - kt[1] * 2 / 3) + "," + Ye[0] + "," + Ye[1], He = X[1], jt = 2), se.length > 1) {\n                  nt = se[1], Ye = X[jt], jt++, Ne += "C" + (He[0] + kt[0]) + "," + (He[1] + kt[1]) + "," + (Ye[0] - nt[0]) + "," + (Ye[1] - nt[1]) + "," + Ye[0] + "," + Ye[1];\n                  for (var gr = 2; gr < se.length; gr++, jt++) Ye = X[jt], nt = se[gr], Ne += "S" + (Ye[0] - nt[0]) + "," + (Ye[1] - nt[1]) + "," + Ye[0] + "," + Ye[1];\n                }\n                if (Te) {\n                  var yr = X[jt];\n                  Ne += "Q" + (Ye[0] + nt[0] * 2 / 3) + "," + (Ye[1] + nt[1] * 2 / 3) + "," + yr[0] + "," + yr[1];\n                }\n                return Ne;\n              }\n              function ot(X, se) {\n                for (var Te = [], Ne = (1 - se) / 2, He, Ye = X[0], kt = X[1], nt = 1, jt = X.length; ++nt < jt; ) He = Ye, Ye = kt, kt = X[nt], Te.push([Ne * (kt[0] - He[0]), Ne * (kt[1] - He[1])]);\n                return Te;\n              }\n              function Tt(X) {\n                if (X.length < 3) return Ku(X);\n                var se = 1, Te = X.length, Ne = X[0], He = Ne[0], Ye = Ne[1], kt = [He, He, He, (Ne = X[1])[0]], nt = [Ye, Ye, Ye, Ne[1]], jt = [He, ",", Ye, "L", Ir(De, kt), ",", Ir(De, nt)];\n                for (X.push(X[Te - 1]); ++se <= Te; ) Ne = X[se], kt.shift(), kt.push(Ne[0]), nt.shift(), nt.push(Ne[1]), Be(jt, kt, nt);\n                return X.pop(), jt.push("L", Ne), jt.join("");\n              }\n              function Yt(X) {\n                if (X.length < 4) return Ku(X);\n                for (var se = [], Te = -1, Ne = X.length, He, Ye = [0], kt = [0]; ++Te < 3; ) He = X[Te], Ye.push(He[0]), kt.push(He[1]);\n                for (se.push(Ir(De, Ye) + "," + Ir(De, kt)), --Te; ++Te < Ne; ) He = X[Te], Ye.shift(), Ye.push(He[0]), kt.shift(), kt.push(He[1]), Be(se, Ye, kt);\n                return se.join("");\n              }\n              function Kt(X) {\n                for (var se, Te = -1, Ne = X.length, He = Ne + 4, Ye, kt = [], nt = []; ++Te < 4; ) Ye = X[Te % Ne], kt.push(Ye[0]), nt.push(Ye[1]);\n                for (se = [Ir(De, kt), ",", Ir(De, nt)], --Te; ++Te < He; ) Ye = X[Te % Ne], kt.shift(), kt.push(Ye[0]), nt.shift(), nt.push(Ye[1]), Be(se, kt, nt);\n                return se.join("");\n              }\n              function xr(X, se) {\n                var Te = X.length - 1;\n                if (Te) for (var Ne = X[0][0], He = X[0][1], Ye = X[Te][0] - Ne, kt = X[Te][1] - He, nt = -1, jt, gr; ++nt <= Te; ) jt = X[nt], gr = nt / Te, jt[0] = se * jt[0] + (1 - se) * (Ne + gr * Ye), jt[1] = se * jt[1] + (1 - se) * (He + gr * kt);\n                return Tt(X);\n              }\n              function Ir(X, se) {\n                return X[0] * se[0] + X[1] * se[1] + X[2] * se[2] + X[3] * se[3];\n              }\n              var ve = [0, 2 / 3, 1 / 3, 0], be = [0, 1 / 3, 2 / 3, 0], De = [0, 1 / 6, 2 / 3, 1 / 6];\n              function Be(X, se, Te) {\n                X.push("C", Ir(ve, se), ",", Ir(ve, Te), ",", Ir(be, se), ",", Ir(be, Te), ",", Ir(De, se), ",", Ir(De, Te));\n              }\n              function et(X, se) {\n                return (se[1] - X[1]) / (se[0] - X[0]);\n              }\n              function We(X) {\n                for (var se = 0, Te = X.length - 1, Ne = [], He = X[0], Ye = X[1], kt = Ne[0] = et(He, Ye); ++se < Te; ) Ne[se] = (kt + (kt = et(He = Ye, Ye = X[se + 1]))) / 2;\n                return Ne[se] = kt, Ne;\n              }\n              function it(X) {\n                for (var se = [], Te, Ne, He, Ye, kt = We(X), nt = -1, jt = X.length - 1; ++nt < jt; ) Te = et(X[nt], X[nt + 1]), p3(Te) < Je ? kt[nt] = kt[nt + 1] = 0 : (Ne = kt[nt] / Te, He = kt[nt + 1] / Te, Ye = Ne * Ne + He * He, Ye > 9 && (Ye = Te * 3 / Math.sqrt(Ye), kt[nt] = Ye * Ne, kt[nt + 1] = Ye * He));\n                for (nt = -1; ++nt <= jt; ) Ye = (X[Math.min(jt, nt + 1)][0] - X[Math.max(0, nt - 1)][0]) / (6 * (1 + kt[nt] * kt[nt])), se.push([Ye || 0, kt[nt] * Ye || 0]);\n                return se;\n              }\n              function Ft(X) {\n                return X.length < 3 ? Ku(X) : X[0] + Xe(X, it(X));\n              }\n              e3.svg.line.radial = function() {\n                var X = Vc(Ht);\n                return X.radius = X.x, delete X.x, X.angle = X.y, delete X.y, X;\n              };\n              function Ht(X) {\n                for (var se, Te = -1, Ne = X.length, He, Ye; ++Te < Ne; ) se = X[Te], He = se[0], Ye = se[1] - xe, se[0] = He * Math.cos(Ye), se[1] = He * Math.sin(Ye);\n                return X;\n              }\n              function tr(X) {\n                var se = Ds, Te = Ds, Ne = 0, He = Fs, Ye = oo, kt = Ku, nt = kt.key, jt = kt, gr = "L", yr = 0.7;\n                function Hr(qr) {\n                  var _i = [], bi = [], Zr = [], ai = -1, gi = qr.length, Ii, Si = vi(se), ei = vi(Ne), Ln = se === Te ? function() {\n                    return Un;\n                  } : vi(Te), En = Ne === He ? function() {\n                    return ia;\n                  } : vi(He), Un, ia;\n                  function Ea() {\n                    _i.push("M", kt(X(Zr), yr), gr, jt(X(bi.reverse()), yr), "Z");\n                  }\n                  for (; ++ai < gi; ) Ye.call(this, Ii = qr[ai], ai) ? (bi.push([Un = +Si.call(this, Ii, ai), ia = +ei.call(this, Ii, ai)]), Zr.push([+Ln.call(this, Ii, ai), +En.call(this, Ii, ai)])) : bi.length && (Ea(), bi = [], Zr = []);\n                  return bi.length && Ea(), _i.length ? _i.join("") : null;\n                }\n                return Hr.x = function(qr) {\n                  return arguments.length ? (se = Te = qr, Hr) : Te;\n                }, Hr.x0 = function(qr) {\n                  return arguments.length ? (se = qr, Hr) : se;\n                }, Hr.x1 = function(qr) {\n                  return arguments.length ? (Te = qr, Hr) : Te;\n                }, Hr.y = function(qr) {\n                  return arguments.length ? (Ne = He = qr, Hr) : He;\n                }, Hr.y0 = function(qr) {\n                  return arguments.length ? (Ne = qr, Hr) : Ne;\n                }, Hr.y1 = function(qr) {\n                  return arguments.length ? (He = qr, Hr) : He;\n                }, Hr.defined = function(qr) {\n                  return arguments.length ? (Ye = qr, Hr) : Ye;\n                }, Hr.interpolate = function(qr) {\n                  return arguments.length ? (typeof qr == "function" ? nt = kt = qr : nt = (kt = hc.get(qr) || Ku).key, jt = kt.reverse || kt, gr = kt.closed ? "M" : "L", Hr) : nt;\n                }, Hr.tension = function(qr) {\n                  return arguments.length ? (yr = qr, Hr) : yr;\n                }, Hr;\n              }\n              B4.reverse = Q, Q.reverse = B4, e3.svg.area = function() {\n                return tr(G2);\n              }, e3.svg.area.radial = function() {\n                var X = tr(Ht);\n                return X.radius = X.x, delete X.x, X.innerRadius = X.x0, delete X.x0, X.outerRadius = X.x1, delete X.x1, X.angle = X.y, delete X.y, X.startAngle = X.y0, delete X.y0, X.endAngle = X.y1, delete X.y1, X;\n              };\n              function dr(X) {\n                return X.source;\n              }\n              function Sr(X) {\n                return X.target;\n              }\n              e3.svg.chord = function() {\n                var X = dr, se = Sr, Te = Or, Ne = pu, He = Uc;\n                function Ye(yr, Hr) {\n                  var qr = kt(this, X, yr, Hr), _i = kt(this, se, yr, Hr);\n                  return "M" + qr.p0 + jt(qr.r, qr.p1, qr.a1 - qr.a0) + (nt(qr, _i) ? gr(qr.r, qr.p1, qr.r, qr.p0) : gr(qr.r, qr.p1, _i.r, _i.p0) + jt(_i.r, _i.p1, _i.a1 - _i.a0) + gr(_i.r, _i.p1, qr.r, qr.p0)) + "Z";\n                }\n                function kt(yr, Hr, qr, _i) {\n                  var bi = Hr.call(yr, qr, _i), Zr = Te.call(yr, bi, _i), ai = Ne.call(yr, bi, _i) - xe, gi = He.call(yr, bi, _i) - xe;\n                  return { r: Zr, a0: ai, a1: gi, p0: [Zr * Math.cos(ai), Zr * Math.sin(ai)], p1: [Zr * Math.cos(gi), Zr * Math.sin(gi)] };\n                }\n                function nt(yr, Hr) {\n                  return yr.a0 == Hr.a0 && yr.a1 == Hr.a1;\n                }\n                function jt(yr, Hr, qr) {\n                  return "A" + yr + "," + yr + " 0 " + +(qr > tt) + ",1 " + Hr;\n                }\n                function gr(yr, Hr, qr, _i) {\n                  return "Q 0,0 " + _i;\n                }\n                return Ye.radius = function(yr) {\n                  return arguments.length ? (Te = vi(yr), Ye) : Te;\n                }, Ye.source = function(yr) {\n                  return arguments.length ? (X = vi(yr), Ye) : X;\n                }, Ye.target = function(yr) {\n                  return arguments.length ? (se = vi(yr), Ye) : se;\n                }, Ye.startAngle = function(yr) {\n                  return arguments.length ? (Ne = vi(yr), Ye) : Ne;\n                }, Ye.endAngle = function(yr) {\n                  return arguments.length ? (He = vi(yr), Ye) : He;\n                }, Ye;\n              };\n              function Or(X) {\n                return X.radius;\n              }\n              e3.svg.diagonal = function() {\n                var X = dr, se = Sr, Te = Wr;\n                function Ne(He, Ye) {\n                  var kt = X.call(this, He, Ye), nt = se.call(this, He, Ye), jt = (kt.y + nt.y) / 2, gr = [kt, { x: kt.x, y: jt }, { x: nt.x, y: jt }, nt];\n                  return gr = gr.map(Te), "M" + gr[0] + "C" + gr[1] + " " + gr[2] + " " + gr[3];\n                }\n                return Ne.source = function(He) {\n                  return arguments.length ? (X = vi(He), Ne) : X;\n                }, Ne.target = function(He) {\n                  return arguments.length ? (se = vi(He), Ne) : se;\n                }, Ne.projection = function(He) {\n                  return arguments.length ? (Te = He, Ne) : Te;\n                }, Ne;\n              };\n              function Wr(X) {\n                return [X.x, X.y];\n              }\n              e3.svg.diagonal.radial = function() {\n                var X = e3.svg.diagonal(), se = Wr, Te = X.projection;\n                return X.projection = function(Ne) {\n                  return arguments.length ? Te(ni(se = Ne)) : se;\n                }, X;\n              };\n              function ni(X) {\n                return function() {\n                  var se = X.apply(this, arguments), Te = se[0], Ne = se[1] - xe;\n                  return [Te * Math.cos(Ne), Te * Math.sin(Ne)];\n                };\n              }\n              e3.svg.symbol = function() {\n                var X = cn, se = Pi;\n                function Te(Ne, He) {\n                  return (Cn.get(X.call(this, Ne, He)) || ln)(se.call(this, Ne, He));\n                }\n                return Te.type = function(Ne) {\n                  return arguments.length ? (X = vi(Ne), Te) : X;\n                }, Te.size = function(Ne) {\n                  return arguments.length ? (se = vi(Ne), Te) : se;\n                }, Te;\n              };\n              function Pi() {\n                return 64;\n              }\n              function cn() {\n                return "circle";\n              }\n              function ln(X) {\n                var se = Math.sqrt(X / tt);\n                return "M0," + se + "A" + se + "," + se + " 0 1,1 0," + -se + "A" + se + "," + se + " 0 1,1 0," + se + "Z";\n              }\n              var Cn = e3.map({ circle: ln, cross: function(X) {\n                var se = Math.sqrt(X / 5) / 2;\n                return "M" + -3 * se + "," + -se + "H" + -se + "V" + -3 * se + "H" + se + "V" + -se + "H" + 3 * se + "V" + se + "H" + se + "V" + 3 * se + "H" + -se + "V" + se + "H" + -3 * se + "Z";\n              }, diamond: function(X) {\n                var se = Math.sqrt(X / (2 * Ta)), Te = se * Ta;\n                return "M0," + -se + "L" + Te + ",0 0," + se + " " + -Te + ",0Z";\n              }, square: function(X) {\n                var se = Math.sqrt(X) / 2;\n                return "M" + -se + "," + -se + "L" + se + "," + -se + " " + se + "," + se + " " + -se + "," + se + "Z";\n              }, "triangle-down": function(X) {\n                var se = Math.sqrt(X / Kn), Te = se * Kn / 2;\n                return "M0," + Te + "L" + se + "," + -Te + " " + -se + "," + -Te + "Z";\n              }, "triangle-up": function(X) {\n                var se = Math.sqrt(X / Kn), Te = se * Kn / 2;\n                return "M0," + -Te + "L" + se + "," + Te + " " + -se + "," + Te + "Z";\n              } });\n              e3.svg.symbolTypes = Cn.keys();\n              var Kn = Math.sqrt(3), Ta = Math.tan(30 * ke);\n              Pe.transition = function(X) {\n                for (var se = Bo || ++mo, Te = To(X), Ne = [], He, Ye, kt = Ps || { time: Date.now(), ease: bl, delay: 0, duration: 250 }, nt = -1, jt = this.length; ++nt < jt; ) {\n                  Ne.push(He = []);\n                  for (var gr = this[nt], yr = -1, Hr = gr.length; ++yr < Hr; ) (Ye = gr[yr]) && hl(Ye, yr, Te, se, kt), He.push(Ye);\n                }\n                return Co(Ne, Te, se);\n              }, Pe.interrupt = function(X) {\n                return this.each(X == null ? fa : $a(To(X)));\n              };\n              var fa = $a(To());\n              function $a(X) {\n                return function() {\n                  var se, Te, Ne;\n                  (se = this[X]) && (Ne = se[Te = se.active]) && (Ne.timer.c = null, Ne.timer.t = NaN, --se.count ? delete se[Te] : delete this[X], se.active += 0.5, Ne.event && Ne.event.interrupt.call(this, this.__data__, Ne.index));\n                };\n              }\n              function Co(X, se, Te) {\n                return ie(X, Qa), X.namespace = se, X.id = Te, X;\n              }\n              var Qa = [], mo = 0, Bo, Ps;\n              Qa.call = Pe.call, Qa.empty = Pe.empty, Qa.node = Pe.node, Qa.size = Pe.size, e3.transition = function(X, se) {\n                return X && X.transition ? Bo ? X.transition(se) : X : e3.selection().transition(X);\n              }, e3.transition.prototype = Qa, Qa.select = function(X) {\n                var se = this.id, Te = this.namespace, Ne = [], He, Ye, kt;\n                X = ge(X);\n                for (var nt = -1, jt = this.length; ++nt < jt; ) {\n                  Ne.push(He = []);\n                  for (var gr = this[nt], yr = -1, Hr = gr.length; ++yr < Hr; ) (kt = gr[yr]) && (Ye = X.call(kt, kt.__data__, yr, nt)) ? ("__data__" in kt && (Ye.__data__ = kt.__data__), hl(Ye, yr, Te, se, kt[Te][se]), He.push(Ye)) : He.push(null);\n                }\n                return Co(Ne, Te, se);\n              }, Qa.selectAll = function(X) {\n                var se = this.id, Te = this.namespace, Ne = [], He, Ye, kt, nt, jt;\n                X = Re(X);\n                for (var gr = -1, yr = this.length; ++gr < yr; ) for (var Hr = this[gr], qr = -1, _i = Hr.length; ++qr < _i; ) if (kt = Hr[qr]) {\n                  jt = kt[Te][se], Ye = X.call(kt, kt.__data__, qr, gr), Ne.push(He = []);\n                  for (var bi = -1, Zr = Ye.length; ++bi < Zr; ) (nt = Ye[bi]) && hl(nt, bi, Te, se, jt), He.push(nt);\n                }\n                return Co(Ne, Te, se);\n              }, Qa.filter = function(X) {\n                var se = [], Te, Ne, He;\n                typeof X != "function" && (X = $e(X));\n                for (var Ye = 0, kt = this.length; Ye < kt; Ye++) {\n                  se.push(Te = []);\n                  for (var Ne = this[Ye], nt = 0, jt = Ne.length; nt < jt; nt++) (He = Ne[nt]) && X.call(He, He.__data__, nt, Ye) && Te.push(He);\n                }\n                return Co(se, this.namespace, this.id);\n              }, Qa.tween = function(X, se) {\n                var Te = this.id, Ne = this.namespace;\n                return arguments.length < 2 ? this.node()[Ne][Te].tween.get(X) : Qt(this, se == null ? function(He) {\n                  He[Ne][Te].tween.remove(X);\n                } : function(He) {\n                  He[Ne][Te].tween.set(X, se);\n                });\n              };\n              function Ts(X, se, Te, Ne) {\n                var He = X.id, Ye = X.namespace;\n                return Qt(X, typeof Te == "function" ? function(kt, nt, jt) {\n                  kt[Ye][He].tween.set(se, Ne(Te.call(kt, kt.__data__, nt, jt)));\n                } : (Te = Ne(Te), function(kt) {\n                  kt[Ye][He].tween.set(se, Te);\n                }));\n              }\n              Qa.attr = function(X, se) {\n                if (arguments.length < 2) {\n                  for (se in X) this.attr(se, X[se]);\n                  return this;\n                }\n                var Te = X == "transform" ? sf : xl, Ne = e3.ns.qualify(X);\n                function He() {\n                  this.removeAttribute(Ne);\n                }\n                function Ye() {\n                  this.removeAttributeNS(Ne.space, Ne.local);\n                }\n                function kt(jt) {\n                  return jt == null ? He : (jt += "", function() {\n                    var gr = this.getAttribute(Ne), yr;\n                    return gr !== jt && (yr = Te(gr, jt), function(Hr) {\n                      this.setAttribute(Ne, yr(Hr));\n                    });\n                  });\n                }\n                function nt(jt) {\n                  return jt == null ? Ye : (jt += "", function() {\n                    var gr = this.getAttributeNS(Ne.space, Ne.local), yr;\n                    return gr !== jt && (yr = Te(gr, jt), function(Hr) {\n                      this.setAttributeNS(Ne.space, Ne.local, yr(Hr));\n                    });\n                  });\n                }\n                return Ts(this, "attr." + X, se, Ne.local ? nt : kt);\n              }, Qa.attrTween = function(X, se) {\n                var Te = e3.ns.qualify(X);\n                function Ne(Ye, kt) {\n                  var nt = se.call(this, Ye, kt, this.getAttribute(Te));\n                  return nt && function(jt) {\n                    this.setAttribute(Te, nt(jt));\n                  };\n                }\n                function He(Ye, kt) {\n                  var nt = se.call(this, Ye, kt, this.getAttributeNS(Te.space, Te.local));\n                  return nt && function(jt) {\n                    this.setAttributeNS(Te.space, Te.local, nt(jt));\n                  };\n                }\n                return this.tween("attr." + X, Te.local ? He : Ne);\n              }, Qa.style = function(X, se, Te) {\n                var Ne = arguments.length;\n                if (Ne < 3) {\n                  if (typeof X != "string") {\n                    Ne < 2 && (se = "");\n                    for (Te in X) this.style(Te, X[Te], se);\n                    return this;\n                  }\n                  Te = "";\n                }\n                function He() {\n                  this.style.removeProperty(X);\n                }\n                function Ye(kt) {\n                  return kt == null ? He : (kt += "", function() {\n                    var nt = a4(this).getComputedStyle(this, null).getPropertyValue(X), jt;\n                    return nt !== kt && (jt = xl(nt, kt), function(gr) {\n                      this.style.setProperty(X, jt(gr), Te);\n                    });\n                  });\n                }\n                return Ts(this, "style." + X, se, Ye);\n              }, Qa.styleTween = function(X, se, Te) {\n                arguments.length < 3 && (Te = "");\n                function Ne(He, Ye) {\n                  var kt = se.call(this, He, Ye, a4(this).getComputedStyle(this, null).getPropertyValue(X));\n                  return kt && function(nt) {\n                    this.style.setProperty(X, kt(nt), Te);\n                  };\n                }\n                return this.tween("style." + X, Ne);\n              }, Qa.text = function(X) {\n                return Ts(this, "text", X, wo);\n              };\n              function wo(X) {\n                return X == null && (X = ""), function() {\n                  this.textContent = X;\n                };\n              }\n              Qa.remove = function() {\n                var X = this.namespace;\n                return this.each("end.transition", function() {\n                  var se;\n                  this[X].count < 2 && (se = this.parentNode) && se.removeChild(this);\n                });\n              }, Qa.ease = function(X) {\n                var se = this.id, Te = this.namespace;\n                return arguments.length < 1 ? this.node()[Te][se].ease : (typeof X != "function" && (X = e3.ease.apply(e3, arguments)), Qt(this, function(Ne) {\n                  Ne[Te][se].ease = X;\n                }));\n              }, Qa.delay = function(X) {\n                var se = this.id, Te = this.namespace;\n                return arguments.length < 1 ? this.node()[Te][se].delay : Qt(this, typeof X == "function" ? function(Ne, He, Ye) {\n                  Ne[Te][se].delay = +X.call(Ne, Ne.__data__, He, Ye);\n                } : (X = +X, function(Ne) {\n                  Ne[Te][se].delay = X;\n                }));\n              }, Qa.duration = function(X) {\n                var se = this.id, Te = this.namespace;\n                return arguments.length < 1 ? this.node()[Te][se].duration : Qt(this, typeof X == "function" ? function(Ne, He, Ye) {\n                  Ne[Te][se].duration = Math.max(1, X.call(Ne, Ne.__data__, He, Ye));\n                } : (X = Math.max(1, X), function(Ne) {\n                  Ne[Te][se].duration = X;\n                }));\n              }, Qa.each = function(X, se) {\n                var Te = this.id, Ne = this.namespace;\n                if (arguments.length < 2) {\n                  var He = Ps, Ye = Bo;\n                  try {\n                    Bo = Te, Qt(this, function(kt, nt, jt) {\n                      Ps = kt[Ne][Te], X.call(kt, kt.__data__, nt, jt);\n                    });\n                  } finally {\n                    Ps = He, Bo = Ye;\n                  }\n                } else Qt(this, function(kt) {\n                  var nt = kt[Ne][Te];\n                  (nt.event || (nt.event = e3.dispatch("start", "end", "interrupt"))).on(X, se);\n                });\n                return this;\n              }, Qa.transition = function() {\n                for (var X = this.id, se = ++mo, Te = this.namespace, Ne = [], He, Ye, kt, nt, jt = 0, gr = this.length; jt < gr; jt++) {\n                  Ne.push(He = []);\n                  for (var Ye = this[jt], yr = 0, Hr = Ye.length; yr < Hr; yr++) (kt = Ye[yr]) && (nt = kt[Te][X], hl(kt, yr, Te, se, { time: nt.time, ease: nt.ease, delay: nt.delay + nt.duration, duration: nt.duration })), He.push(kt);\n                }\n                return Co(Ne, Te, se);\n              };\n              function To(X) {\n                return X == null ? "__transition__" : "__transition_" + X + "__";\n              }\n              function hl(X, se, Te, Ne, He) {\n                var Ye = X[Te] || (X[Te] = { active: 0, count: 0 }), kt = Ye[Ne], nt, jt, gr, yr, Hr;\n                function qr(Zr) {\n                  var ai = kt.delay;\n                  if (jt.t = ai + nt, ai <= Zr) return _i(Zr - ai);\n                  jt.c = _i;\n                }\n                function _i(Zr) {\n                  var ai = Ye.active, gi = Ye[ai];\n                  gi && (gi.timer.c = null, gi.timer.t = NaN, --Ye.count, delete Ye[ai], gi.event && gi.event.interrupt.call(X, X.__data__, gi.index));\n                  for (var Ii in Ye) if (+Ii < Ne) {\n                    var Si = Ye[Ii];\n                    Si.timer.c = null, Si.timer.t = NaN, --Ye.count, delete Ye[Ii];\n                  }\n                  jt.c = bi, No(function() {\n                    return jt.c && bi(Zr || 1) && (jt.c = null, jt.t = NaN), 1;\n                  }, 0, nt), Ye.active = Ne, kt.event && kt.event.start.call(X, X.__data__, se), Hr = [], kt.tween.forEach(function(ei, Ln) {\n                    (Ln = Ln.call(X, X.__data__, se)) && Hr.push(Ln);\n                  }), yr = kt.ease, gr = kt.duration;\n                }\n                function bi(Zr) {\n                  for (var ai = Zr / gr, gi = yr(ai), Ii = Hr.length; Ii > 0; ) Hr[--Ii].call(X, gi);\n                  if (ai >= 1) return kt.event && kt.event.end.call(X, X.__data__, se), --Ye.count ? delete Ye[Ne] : delete X[Te], 1;\n                }\n                kt || (nt = He.time, jt = No(qr, 0, nt), kt = Ye[Ne] = { tween: new S2(), time: nt, timer: jt, delay: He.delay, duration: He.duration, ease: He.ease, index: se }, He = null, ++Ye.count);\n              }\n              e3.svg.axis = function() {\n                var X = e3.scale.linear(), se = Ul, Te = 6, Ne = 6, He = 3, Ye = [10], kt = null, nt;\n                function jt(gr) {\n                  gr.each(function() {\n                    var yr = e3.select(this), Hr = this.__chart__ || X, qr = this.__chart__ = X.copy(), _i = kt == null ? qr.ticks ? qr.ticks.apply(qr, Ye) : qr.domain() : kt, bi = nt == null ? qr.tickFormat ? qr.tickFormat.apply(qr, Ye) : G2 : nt, Zr = yr.selectAll(".tick").data(_i, qr), ai = Zr.enter().insert("g", ".domain").attr("class", "tick").style("opacity", Je), gi = e3.transition(Zr.exit()).style("opacity", Je).remove(), Ii = e3.transition(Zr.order()).style("opacity", 1), Si = Math.max(Te, 0) + He, ei, Ln = wn(qr), En = yr.selectAll(".domain").data([0]), Un = (En.enter().append("path").attr("class", "domain"), e3.transition(En));\n                    ai.append("line"), ai.append("text");\n                    var ia = ai.select("line"), Ea = Ii.select("line"), Ia = Zr.select("text").text(bi), yo = ai.select("text"), Da = Ii.select("text"), go = se === "top" || se === "left" ? -1 : 1, Is, Ms, Xs, Gn;\n                    if (se === "bottom" || se === "top" ? (ei = au, Is = "x", Xs = "y", Ms = "x2", Gn = "y2", Ia.attr("dy", go < 0 ? "0em" : ".71em").style("text-anchor", "middle"), Un.attr("d", "M" + Ln[0] + "," + go * Ne + "V0H" + Ln[1] + "V" + go * Ne)) : (ei = Js, Is = "y", Xs = "x", Ms = "y2", Gn = "x2", Ia.attr("dy", ".32em").style("text-anchor", go < 0 ? "end" : "start"), Un.attr("d", "M" + go * Ne + "," + Ln[0] + "H0V" + Ln[1] + "H" + go * Ne)), ia.attr(Gn, go * Te), yo.attr(Xs, go * Si), Ea.attr(Ms, 0).attr(Gn, go * Te), Da.attr(Is, 0).attr(Xs, go * Si), qr.rangeBand) {\n                      var ja = qr, Fo = ja.rangeBand() / 2;\n                      Hr = qr = function(Uo) {\n                        return ja(Uo) + Fo;\n                      };\n                    } else Hr.rangeBand ? Hr = qr : gi.call(ei, qr, Hr);\n                    ai.call(ei, Hr, qr), Ii.call(ei, qr, qr);\n                  });\n                }\n                return jt.scale = function(gr) {\n                  return arguments.length ? (X = gr, jt) : X;\n                }, jt.orient = function(gr) {\n                  return arguments.length ? (se = gr in Lu ? gr + "" : Ul, jt) : se;\n                }, jt.ticks = function() {\n                  return arguments.length ? (Ye = r4(arguments), jt) : Ye;\n                }, jt.tickValues = function(gr) {\n                  return arguments.length ? (kt = gr, jt) : kt;\n                }, jt.tickFormat = function(gr) {\n                  return arguments.length ? (nt = gr, jt) : nt;\n                }, jt.tickSize = function(gr) {\n                  var yr = arguments.length;\n                  return yr ? (Te = +gr, Ne = +arguments[yr - 1], jt) : Te;\n                }, jt.innerTickSize = function(gr) {\n                  return arguments.length ? (Te = +gr, jt) : Te;\n                }, jt.outerTickSize = function(gr) {\n                  return arguments.length ? (Ne = +gr, jt) : Ne;\n                }, jt.tickPadding = function(gr) {\n                  return arguments.length ? (He = +gr, jt) : He;\n                }, jt.tickSubdivide = function() {\n                  return arguments.length && jt;\n                }, jt;\n              };\n              var Ul = "bottom", Lu = { top: 1, right: 1, bottom: 1, left: 1 };\n              function au(X, se, Te) {\n                X.attr("transform", function(Ne) {\n                  var He = se(Ne);\n                  return "translate(" + (isFinite(He) ? He : Te(Ne)) + ",0)";\n                });\n              }\n              function Js(X, se, Te) {\n                X.attr("transform", function(Ne) {\n                  var He = se(Ne);\n                  return "translate(0," + (isFinite(He) ? He : Te(Ne)) + ")";\n                });\n              }\n              e3.svg.brush = function() {\n                var X = Ce(yr, "brushstart", "brush", "brushend"), se = null, Te = null, Ne = [0, 0], He = [0, 0], Ye, kt, nt = true, jt = true, gr = dc[0];\n                function yr(Zr) {\n                  Zr.each(function() {\n                    var ai = e3.select(this).style("pointer-events", "all").style("-webkit-tap-highlight-color", "rgba(0,0,0,0)").on("mousedown.brush", bi).on("touchstart.brush", bi), gi = ai.selectAll(".background").data([0]);\n                    gi.enter().append("rect").attr("class", "background").style("visibility", "hidden").style("cursor", "crosshair"), ai.selectAll(".extent").data([0]).enter().append("rect").attr("class", "extent").style("cursor", "move");\n                    var Ii = ai.selectAll(".resize").data(gr, G2);\n                    Ii.exit().remove(), Ii.enter().append("g").attr("class", function(En) {\n                      return "resize " + En;\n                    }).style("cursor", function(En) {\n                      return Ql[En];\n                    }).append("rect").attr("x", function(En) {\n                      return /[ew]$/.test(En) ? -3 : null;\n                    }).attr("y", function(En) {\n                      return /^[ns]/.test(En) ? -3 : null;\n                    }).attr("width", 6).attr("height", 6).style("visibility", "hidden"), Ii.style("display", yr.empty() ? "none" : null);\n                    var Si = e3.transition(ai), ei = e3.transition(gi), Ln;\n                    se && (Ln = wn(se), ei.attr("x", Ln[0]).attr("width", Ln[1] - Ln[0]), qr(Si)), Te && (Ln = wn(Te), ei.attr("y", Ln[0]).attr("height", Ln[1] - Ln[0]), _i(Si)), Hr(Si);\n                  });\n                }\n                yr.event = function(Zr) {\n                  Zr.each(function() {\n                    var ai = X.of(this, arguments), gi = { x: Ne, y: He, i: Ye, j: kt }, Ii = this.__chart__ || gi;\n                    this.__chart__ = gi, Bo ? e3.select(this).transition().each("start.brush", function() {\n                      Ye = Ii.i, kt = Ii.j, Ne = Ii.x, He = Ii.y, ai({ type: "brushstart" });\n                    }).tween("brush:brush", function() {\n                      var Si = Gu(Ne, gi.x), ei = Gu(He, gi.y);\n                      return Ye = kt = null, function(Ln) {\n                        Ne = gi.x = Si(Ln), He = gi.y = ei(Ln), ai({ type: "brush", mode: "resize" });\n                      };\n                    }).each("end.brush", function() {\n                      Ye = gi.i, kt = gi.j, ai({ type: "brush", mode: "resize" }), ai({ type: "brushend" });\n                    }) : (ai({ type: "brushstart" }), ai({ type: "brush", mode: "resize" }), ai({ type: "brushend" }));\n                  });\n                };\n                function Hr(Zr) {\n                  Zr.selectAll(".resize").attr("transform", function(ai) {\n                    return "translate(" + Ne[+/e$/.test(ai)] + "," + He[+/^s/.test(ai)] + ")";\n                  });\n                }\n                function qr(Zr) {\n                  Zr.select(".extent").attr("x", Ne[0]), Zr.selectAll(".extent,.n>rect,.s>rect").attr("width", Ne[1] - Ne[0]);\n                }\n                function _i(Zr) {\n                  Zr.select(".extent").attr("y", He[0]), Zr.selectAll(".extent,.e>rect,.w>rect").attr("height", He[1] - He[0]);\n                }\n                function bi() {\n                  var Zr = this, ai = e3.select(e3.event.target), gi = X.of(Zr, arguments), Ii = e3.select(Zr), Si = ai.datum(), ei = !/^(n|s)$/.test(Si) && se, Ln = !/^(e|w)$/.test(Si) && Te, En = ai.classed("extent"), Un = Br(Zr), ia, Ea = e3.mouse(Zr), Ia, yo = e3.select(a4(Zr)).on("keydown.brush", Is).on("keyup.brush", Ms);\n                  if (e3.event.changedTouches ? yo.on("touchmove.brush", Xs).on("touchend.brush", ja) : yo.on("mousemove.brush", Xs).on("mouseup.brush", ja), Ii.interrupt().selectAll("*").interrupt(), En) Ea[0] = Ne[0] - Ea[0], Ea[1] = He[0] - Ea[1];\n                  else if (Si) {\n                    var Da = +/w$/.test(Si), go = +/^n/.test(Si);\n                    Ia = [Ne[1 - Da] - Ea[0], He[1 - go] - Ea[1]], Ea[0] = Ne[Da], Ea[1] = He[go];\n                  } else e3.event.altKey && (ia = Ea.slice());\n                  Ii.style("pointer-events", "none").selectAll(".resize").style("display", null), e3.select("body").style("cursor", ai.style("cursor")), gi({ type: "brushstart" }), Xs();\n                  function Is() {\n                    e3.event.keyCode == 32 && (En || (ia = null, Ea[0] -= Ne[1], Ea[1] -= He[1], En = 2), _e());\n                  }\n                  function Ms() {\n                    e3.event.keyCode == 32 && En == 2 && (Ea[0] += Ne[1], Ea[1] += He[1], En = 0, _e());\n                  }\n                  function Xs() {\n                    var Fo = e3.mouse(Zr), Uo = false;\n                    Ia && (Fo[0] += Ia[0], Fo[1] += Ia[1]), En || (e3.event.altKey ? (ia || (ia = [(Ne[0] + Ne[1]) / 2, (He[0] + He[1]) / 2]), Ea[0] = Ne[+(Fo[0] < ia[0])], Ea[1] = He[+(Fo[1] < ia[1])]) : ia = null), ei && Gn(Fo, se, 0) && (qr(Ii), Uo = true), Ln && Gn(Fo, Te, 1) && (_i(Ii), Uo = true), Uo && (Hr(Ii), gi({ type: "brush", mode: En ? "move" : "resize" }));\n                  }\n                  function Gn(Fo, Uo, $s) {\n                    var Sl = wn(Uo), bu = Sl[0], dl = Sl[1], Sc = Ea[$s], Me = $s ? He : Ne, bt = Me[1] - Me[0], zt, Rr;\n                    if (En && (bu -= Sc, dl -= bt + Sc), zt = ($s ? jt : nt) ? Math.max(bu, Math.min(dl, Fo[$s])) : Fo[$s], En ? Rr = (zt += Sc) + bt : (ia && (Sc = Math.max(bu, Math.min(dl, 2 * ia[$s] - zt))), Sc < zt ? (Rr = zt, zt = Sc) : Rr = Sc), Me[0] != zt || Me[1] != Rr) return $s ? kt = null : Ye = null, Me[0] = zt, Me[1] = Rr, true;\n                  }\n                  function ja() {\n                    Xs(), Ii.style("pointer-events", "all").selectAll(".resize").style("display", yr.empty() ? "none" : null), e3.select("body").style("cursor", null), yo.on("mousemove.brush", null).on("mouseup.brush", null).on("touchmove.brush", null).on("touchend.brush", null).on("keydown.brush", null).on("keyup.brush", null), Un(), gi({ type: "brushend" });\n                  }\n                }\n                return yr.x = function(Zr) {\n                  return arguments.length ? (se = Zr, gr = dc[!se << 1 | !Te], yr) : se;\n                }, yr.y = function(Zr) {\n                  return arguments.length ? (Te = Zr, gr = dc[!se << 1 | !Te], yr) : Te;\n                }, yr.clamp = function(Zr) {\n                  return arguments.length ? (se && Te ? (nt = !!Zr[0], jt = !!Zr[1]) : se ? nt = !!Zr : Te && (jt = !!Zr), yr) : se && Te ? [nt, jt] : se ? nt : Te ? jt : null;\n                }, yr.extent = function(Zr) {\n                  var ai, gi, Ii, Si, ei;\n                  return arguments.length ? (se && (ai = Zr[0], gi = Zr[1], Te && (ai = ai[0], gi = gi[0]), Ye = [ai, gi], se.invert && (ai = se(ai), gi = se(gi)), gi < ai && (ei = ai, ai = gi, gi = ei), (ai != Ne[0] || gi != Ne[1]) && (Ne = [ai, gi])), Te && (Ii = Zr[0], Si = Zr[1], se && (Ii = Ii[1], Si = Si[1]), kt = [Ii, Si], Te.invert && (Ii = Te(Ii), Si = Te(Si)), Si < Ii && (ei = Ii, Ii = Si, Si = ei), (Ii != He[0] || Si != He[1]) && (He = [Ii, Si])), yr) : (se && (Ye ? (ai = Ye[0], gi = Ye[1]) : (ai = Ne[0], gi = Ne[1], se.invert && (ai = se.invert(ai), gi = se.invert(gi)), gi < ai && (ei = ai, ai = gi, gi = ei))), Te && (kt ? (Ii = kt[0], Si = kt[1]) : (Ii = He[0], Si = He[1], Te.invert && (Ii = Te.invert(Ii), Si = Te.invert(Si)), Si < Ii && (ei = Ii, Ii = Si, Si = ei))), se && Te ? [[ai, Ii], [gi, Si]] : se ? [ai, gi] : Te && [Ii, Si]);\n                }, yr.clear = function() {\n                  return yr.empty() || (Ne = [0, 0], He = [0, 0], Ye = kt = null), yr;\n                }, yr.empty = function() {\n                  return !!se && Ne[0] == Ne[1] || !!Te && He[0] == He[1];\n                }, e3.rebind(yr, X, "on");\n              };\n              var Ql = { n: "ns-resize", e: "ew-resize", s: "ns-resize", w: "ew-resize", nw: "nwse-resize", ne: "nesw-resize", se: "nwse-resize", sw: "nesw-resize" }, dc = [["n", "e", "s", "w", "nw", "ne", "se", "sw"], ["e", "w"], ["n", "s"], []];\n              e3.text = hn(function(X) {\n                return X.responseText;\n              }), e3.json = function(X, se) {\n                return An(X, "application/json", Tl, se);\n              };\n              function Tl(X) {\n                return JSON.parse(X.responseText);\n              }\n              e3.html = function(X, se) {\n                return An(X, "text/html", Al, se);\n              };\n              function Al(X) {\n                var se = n4.createRange();\n                return se.selectNode(n4.body), se.createContextualFragment(X.responseText);\n              }\n              e3.xml = hn(function(X) {\n                return X.responseXML;\n              }), typeof c6 == "object" && c6.exports ? c6.exports = e3 : this.d3 = e3;\n            }).apply(self);\n          });\n          var bO = ye((f6, pee) => {\n            (function(e3, t3) {\n              typeof f6 == "object" && typeof pee != "undefined" ? t3(f6) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(f6, function(e3) {\n              "use strict";\n              var t3 = /* @__PURE__ */ new Date(), r4 = /* @__PURE__ */ new Date();\n              function n4($e, St, Qt, Vt) {\n                function _t(It) {\n                  return $e(It = arguments.length === 0 ? /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date(+It)), It;\n                }\n                return _t.floor = function(It) {\n                  return $e(It = /* @__PURE__ */ new Date(+It)), It;\n                }, _t.ceil = function(It) {\n                  return $e(It = new Date(It - 1)), St(It, 1), $e(It), It;\n                }, _t.round = function(It) {\n                  var mt = _t(It), er = _t.ceil(It);\n                  return It - mt < er - It ? mt : er;\n                }, _t.offset = function(It, mt) {\n                  return St(It = /* @__PURE__ */ new Date(+It), mt == null ? 1 : Math.floor(mt)), It;\n                }, _t.range = function(It, mt, er) {\n                  var lr = [], Tr;\n                  if (It = _t.ceil(It), er = er == null ? 1 : Math.floor(er), !(It < mt) || !(er > 0)) return lr;\n                  do\n                    lr.push(Tr = /* @__PURE__ */ new Date(+It)), St(It, er), $e(It);\n                  while (Tr < It && It < mt);\n                  return lr;\n                }, _t.filter = function(It) {\n                  return n4(function(mt) {\n                    if (mt >= mt) for (; $e(mt), !It(mt); ) mt.setTime(mt - 1);\n                  }, function(mt, er) {\n                    if (mt >= mt) if (er < 0) for (; ++er <= 0; ) for (; St(mt, -1), !It(mt); ) ;\n                    else for (; --er >= 0; ) for (; St(mt, 1), !It(mt); ) ;\n                  });\n                }, Qt && (_t.count = function(It, mt) {\n                  return t3.setTime(+It), r4.setTime(+mt), $e(t3), $e(r4), Math.floor(Qt(t3, r4));\n                }, _t.every = function(It) {\n                  return It = Math.floor(It), !isFinite(It) || !(It > 0) ? null : It > 1 ? _t.filter(Vt ? function(mt) {\n                    return Vt(mt) % It === 0;\n                  } : function(mt) {\n                    return _t.count(0, mt) % It === 0;\n                  }) : _t;\n                }), _t;\n              }\n              var i3 = n4(function() {\n              }, function($e, St) {\n                $e.setTime(+$e + St);\n              }, function($e, St) {\n                return St - $e;\n              });\n              i3.every = function($e) {\n                return $e = Math.floor($e), !isFinite($e) || !($e > 0) ? null : $e > 1 ? n4(function(St) {\n                  St.setTime(Math.floor(St / $e) * $e);\n                }, function(St, Qt) {\n                  St.setTime(+St + Qt * $e);\n                }, function(St, Qt) {\n                  return (Qt - St) / $e;\n                }) : i3;\n              };\n              var a4 = i3.range, o4 = 1e3, s3 = 6e4, l3 = 36e5, u4 = 864e5, c5 = 6048e5, f4 = n4(function($e) {\n                $e.setTime($e - $e.getMilliseconds());\n              }, function($e, St) {\n                $e.setTime(+$e + St * o4);\n              }, function($e, St) {\n                return (St - $e) / o4;\n              }, function($e) {\n                return $e.getUTCSeconds();\n              }), h3 = f4.range, d3 = n4(function($e) {\n                $e.setTime($e - $e.getMilliseconds() - $e.getSeconds() * o4);\n              }, function($e, St) {\n                $e.setTime(+$e + St * s3);\n              }, function($e, St) {\n                return (St - $e) / s3;\n              }, function($e) {\n                return $e.getMinutes();\n              }), v3 = d3.range, _2 = n4(function($e) {\n                $e.setTime($e - $e.getMilliseconds() - $e.getSeconds() * o4 - $e.getMinutes() * s3);\n              }, function($e, St) {\n                $e.setTime(+$e + St * l3);\n              }, function($e, St) {\n                return (St - $e) / l3;\n              }, function($e) {\n                return $e.getHours();\n              }), b = _2.range, p3 = n4(function($e) {\n                $e.setHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setDate($e.getDate() + St);\n              }, function($e, St) {\n                return (St - $e - (St.getTimezoneOffset() - $e.getTimezoneOffset()) * s3) / u4;\n              }, function($e) {\n                return $e.getDate() - 1;\n              }), k4 = p3.range;\n              function E3($e) {\n                return n4(function(St) {\n                  St.setDate(St.getDate() - (St.getDay() + 7 - $e) % 7), St.setHours(0, 0, 0, 0);\n                }, function(St, Qt) {\n                  St.setDate(St.getDate() + Qt * 7);\n                }, function(St, Qt) {\n                  return (Qt - St - (Qt.getTimezoneOffset() - St.getTimezoneOffset()) * s3) / c5;\n                });\n              }\n              var S2 = E3(0), L3 = E3(1), x2 = E3(2), C3 = E3(3), M4 = E3(4), g3 = E3(5), P3 = E3(6), T3 = S2.range, z3 = L3.range, O3 = x2.range, V2 = C3.range, G2 = M4.range, Z = g3.range, j3 = P3.range, N2 = n4(function($e) {\n                $e.setDate(1), $e.setHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setMonth($e.getMonth() + St);\n              }, function($e, St) {\n                return St.getMonth() - $e.getMonth() + (St.getFullYear() - $e.getFullYear()) * 12;\n              }, function($e) {\n                return $e.getMonth();\n              }), H = N2.range, te = n4(function($e) {\n                $e.setMonth(0, 1), $e.setHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setFullYear($e.getFullYear() + St);\n              }, function($e, St) {\n                return St.getFullYear() - $e.getFullYear();\n              }, function($e) {\n                return $e.getFullYear();\n              });\n              te.every = function($e) {\n                return !isFinite($e = Math.floor($e)) || !($e > 0) ? null : n4(function(St) {\n                  St.setFullYear(Math.floor(St.getFullYear() / $e) * $e), St.setMonth(0, 1), St.setHours(0, 0, 0, 0);\n                }, function(St, Qt) {\n                  St.setFullYear(St.getFullYear() + Qt * $e);\n                });\n              };\n              var oe = te.range, _e = n4(function($e) {\n                $e.setUTCSeconds(0, 0);\n              }, function($e, St) {\n                $e.setTime(+$e + St * s3);\n              }, function($e, St) {\n                return (St - $e) / s3;\n              }, function($e) {\n                return $e.getUTCMinutes();\n              }), Ee = _e.range, Ce = n4(function($e) {\n                $e.setUTCMinutes(0, 0, 0);\n              }, function($e, St) {\n                $e.setTime(+$e + St * l3);\n              }, function($e, St) {\n                return (St - $e) / l3;\n              }, function($e) {\n                return $e.getUTCHours();\n              }), me = Ce.range, ie = n4(function($e) {\n                $e.setUTCHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setUTCDate($e.getUTCDate() + St);\n              }, function($e, St) {\n                return (St - $e) / u4;\n              }, function($e) {\n                return $e.getUTCDate() - 1;\n              }), Se = ie.range;\n              function Le($e) {\n                return n4(function(St) {\n                  St.setUTCDate(St.getUTCDate() - (St.getUTCDay() + 7 - $e) % 7), St.setUTCHours(0, 0, 0, 0);\n                }, function(St, Qt) {\n                  St.setUTCDate(St.getUTCDate() + Qt * 7);\n                }, function(St, Qt) {\n                  return (Qt - St) / c5;\n                });\n              }\n              var Ae = Le(0), Fe = Le(1), Pe = Le(2), ge = Le(3), Re = Le(4), ce = Le(5), Ze = Le(6), ut = Ae.range, pt = Fe.range, Zt = Pe.range, st = ge.range, lt = Re.range, Gt = ce.range, Nt = Ze.range, Jt = n4(function($e) {\n                $e.setUTCDate(1), $e.setUTCHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setUTCMonth($e.getUTCMonth() + St);\n              }, function($e, St) {\n                return St.getUTCMonth() - $e.getUTCMonth() + (St.getUTCFullYear() - $e.getUTCFullYear()) * 12;\n              }, function($e) {\n                return $e.getUTCMonth();\n              }), sr = Jt.range, wr = n4(function($e) {\n                $e.setUTCMonth(0, 1), $e.setUTCHours(0, 0, 0, 0);\n              }, function($e, St) {\n                $e.setUTCFullYear($e.getUTCFullYear() + St);\n              }, function($e, St) {\n                return St.getUTCFullYear() - $e.getUTCFullYear();\n              }, function($e) {\n                return $e.getUTCFullYear();\n              });\n              wr.every = function($e) {\n                return !isFinite($e = Math.floor($e)) || !($e > 0) ? null : n4(function(St) {\n                  St.setUTCFullYear(Math.floor(St.getUTCFullYear() / $e) * $e), St.setUTCMonth(0, 1), St.setUTCHours(0, 0, 0, 0);\n                }, function(St, Qt) {\n                  St.setUTCFullYear(St.getUTCFullYear() + Qt * $e);\n                });\n              };\n              var cr = wr.range;\n              e3.timeDay = p3, e3.timeDays = k4, e3.timeFriday = g3, e3.timeFridays = Z, e3.timeHour = _2, e3.timeHours = b, e3.timeInterval = n4, e3.timeMillisecond = i3, e3.timeMilliseconds = a4, e3.timeMinute = d3, e3.timeMinutes = v3, e3.timeMonday = L3, e3.timeMondays = z3, e3.timeMonth = N2, e3.timeMonths = H, e3.timeSaturday = P3, e3.timeSaturdays = j3, e3.timeSecond = f4, e3.timeSeconds = h3, e3.timeSunday = S2, e3.timeSundays = T3, e3.timeThursday = M4, e3.timeThursdays = G2, e3.timeTuesday = x2, e3.timeTuesdays = O3, e3.timeWednesday = C3, e3.timeWednesdays = V2, e3.timeWeek = S2, e3.timeWeeks = T3, e3.timeYear = te, e3.timeYears = oe, e3.utcDay = ie, e3.utcDays = Se, e3.utcFriday = ce, e3.utcFridays = Gt, e3.utcHour = Ce, e3.utcHours = me, e3.utcMillisecond = i3, e3.utcMilliseconds = a4, e3.utcMinute = _e, e3.utcMinutes = Ee, e3.utcMonday = Fe, e3.utcMondays = pt, e3.utcMonth = Jt, e3.utcMonths = sr, e3.utcSaturday = Ze, e3.utcSaturdays = Nt, e3.utcSecond = f4, e3.utcSeconds = h3, e3.utcSunday = Ae, e3.utcSundays = ut, e3.utcThursday = Re, e3.utcThursdays = lt, e3.utcTuesday = Pe, e3.utcTuesdays = Zt, e3.utcWednesday = ge, e3.utcWednesdays = st, e3.utcWeek = Ae, e3.utcWeeks = ut, e3.utcYear = wr, e3.utcYears = cr, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var r3 = ye((h6, gee) => {\n            (function(e3, t3) {\n              typeof h6 == "object" && typeof gee != "undefined" ? t3(h6, bO()) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}, e3.d3));\n            })(h6, function(e3, t3) {\n              "use strict";\n              function r4(Ge) {\n                if (0 <= Ge.y && Ge.y < 100) {\n                  var Je = new Date(-1, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L);\n                  return Je.setFullYear(Ge.y), Je;\n                }\n                return new Date(Ge.y, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L);\n              }\n              function n4(Ge) {\n                if (0 <= Ge.y && Ge.y < 100) {\n                  var Je = new Date(Date.UTC(-1, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L));\n                  return Je.setUTCFullYear(Ge.y), Je;\n                }\n                return new Date(Date.UTC(Ge.y, Ge.m, Ge.d, Ge.H, Ge.M, Ge.S, Ge.L));\n              }\n              function i3(Ge, Je, je) {\n                return { y: Ge, m: Je, d: je, H: 0, M: 0, S: 0, L: 0 };\n              }\n              function a4(Ge) {\n                var Je = Ge.dateTime, je = Ge.date, tt = Ge.time, xt = Ge.periods, Ie = Ge.days, xe = Ge.shortDays, ke = Ge.months, vt = Ge.shortMonths, ir = h3(xt), ar = d3(xt), vr = h3(Ie), ii = d3(Ie), pi = h3(xe), $r = d3(xe), di = h3(ke), ji = d3(ke), In = h3(vt), wi = d3(vt), On = { a: $i, A: tn, b: fn, B: yn, c: null, d: N2, e: N2, f: Ee, H, I: te, j: oe, L: _e, m: Ce, M: me, p: Sn, q: Ba, Q: mt, s: er, S: ie, u: Se, U: Le, V: Ae, w: Fe, W: Pe, x: null, X: null, y: ge, Y: Re, Z: ce, "%": It }, qn = { a: ua, A: ma, b: Wa, B: Fa, c: null, d: Ze, e: Ze, f: lt, H: ut, I: pt, j: Zt, L: st, m: Gt, M: Nt, p: Wo, q: da, Q: mt, s: er, S: Jt, u: sr, U: wr, V: cr, w: $e, W: St, x: null, X: null, y: Qt, Y: Vt, Z: _t, "%": It }, Fn = { a: rr, A: nr, b: Er, B: Xr, c: ri, d: M4, e: M4, f: V2, H: P3, I: P3, j: g3, L: O3, m: C3, M: T3, p: wt, q: x2, Q: Z, s: j3, S: z3, u: _2, U: b, V: p3, w: v3, W: k4, x: Qr, X: Oi, y: S2, Y: E3, Z: L3, "%": G2 };\n                On.x = ra(je, On), On.X = ra(tt, On), On.c = ra(Je, On), qn.x = ra(je, qn), qn.X = ra(tt, qn), qn.c = ra(Je, qn);\n                function ra(Wn, Ha) {\n                  return function(vo) {\n                    var jn = [], Mt = -1, kr = 0, Jr = Wn.length, vi, hn, An;\n                    for (vo instanceof Date || (vo = /* @__PURE__ */ new Date(+vo)); ++Mt < Jr; ) Wn.charCodeAt(Mt) === 37 && (jn.push(Wn.slice(kr, Mt)), (hn = o4[vi = Wn.charAt(++Mt)]) != null ? vi = Wn.charAt(++Mt) : hn = vi === "e" ? " " : "0", (An = Ha[vi]) && (vi = An(vo, hn)), jn.push(vi), kr = Mt + 1);\n                    return jn.push(Wn.slice(kr, Mt)), jn.join("");\n                  };\n                }\n                function la(Wn, Ha) {\n                  return function(vo) {\n                    var jn = i3(1900, void 0, 1), Mt = Ut(jn, Wn, vo += "", 0), kr, Jr;\n                    if (Mt != vo.length) return null;\n                    if ("Q" in jn) return new Date(jn.Q);\n                    if ("s" in jn) return new Date(jn.s * 1e3 + ("L" in jn ? jn.L : 0));\n                    if (Ha && !("Z" in jn) && (jn.Z = 0), "p" in jn && (jn.H = jn.H % 12 + jn.p * 12), jn.m === void 0 && (jn.m = "q" in jn ? jn.q : 0), "V" in jn) {\n                      if (jn.V < 1 || jn.V > 53) return null;\n                      "w" in jn || (jn.w = 1), "Z" in jn ? (kr = n4(i3(jn.y, 0, 1)), Jr = kr.getUTCDay(), kr = Jr > 4 || Jr === 0 ? t3.utcMonday.ceil(kr) : t3.utcMonday(kr), kr = t3.utcDay.offset(kr, (jn.V - 1) * 7), jn.y = kr.getUTCFullYear(), jn.m = kr.getUTCMonth(), jn.d = kr.getUTCDate() + (jn.w + 6) % 7) : (kr = r4(i3(jn.y, 0, 1)), Jr = kr.getDay(), kr = Jr > 4 || Jr === 0 ? t3.timeMonday.ceil(kr) : t3.timeMonday(kr), kr = t3.timeDay.offset(kr, (jn.V - 1) * 7), jn.y = kr.getFullYear(), jn.m = kr.getMonth(), jn.d = kr.getDate() + (jn.w + 6) % 7);\n                    } else ("W" in jn || "U" in jn) && ("w" in jn || (jn.w = "u" in jn ? jn.u % 7 : "W" in jn ? 1 : 0), Jr = "Z" in jn ? n4(i3(jn.y, 0, 1)).getUTCDay() : r4(i3(jn.y, 0, 1)).getDay(), jn.m = 0, jn.d = "W" in jn ? (jn.w + 6) % 7 + jn.W * 7 - (Jr + 5) % 7 : jn.w + jn.U * 7 - (Jr + 6) % 7);\n                    return "Z" in jn ? (jn.H += jn.Z / 100 | 0, jn.M += jn.Z % 100, n4(jn)) : r4(jn);\n                  };\n                }\n                function Ut(Wn, Ha, vo, jn) {\n                  for (var Mt = 0, kr = Ha.length, Jr = vo.length, vi, hn; Mt < kr; ) {\n                    if (jn >= Jr) return -1;\n                    if (vi = Ha.charCodeAt(Mt++), vi === 37) {\n                      if (vi = Ha.charAt(Mt++), hn = Fn[vi in o4 ? Ha.charAt(Mt++) : vi], !hn || (jn = hn(Wn, vo, jn)) < 0) return -1;\n                    } else if (vi != vo.charCodeAt(jn++)) return -1;\n                  }\n                  return jn;\n                }\n                function wt(Wn, Ha, vo) {\n                  var jn = ir.exec(Ha.slice(vo));\n                  return jn ? (Wn.p = ar[jn[0].toLowerCase()], vo + jn[0].length) : -1;\n                }\n                function rr(Wn, Ha, vo) {\n                  var jn = pi.exec(Ha.slice(vo));\n                  return jn ? (Wn.w = $r[jn[0].toLowerCase()], vo + jn[0].length) : -1;\n                }\n                function nr(Wn, Ha, vo) {\n                  var jn = vr.exec(Ha.slice(vo));\n                  return jn ? (Wn.w = ii[jn[0].toLowerCase()], vo + jn[0].length) : -1;\n                }\n                function Er(Wn, Ha, vo) {\n                  var jn = In.exec(Ha.slice(vo));\n                  return jn ? (Wn.m = wi[jn[0].toLowerCase()], vo + jn[0].length) : -1;\n                }\n                function Xr(Wn, Ha, vo) {\n                  var jn = di.exec(Ha.slice(vo));\n                  return jn ? (Wn.m = ji[jn[0].toLowerCase()], vo + jn[0].length) : -1;\n                }\n                function ri(Wn, Ha, vo) {\n                  return Ut(Wn, Je, Ha, vo);\n                }\n                function Qr(Wn, Ha, vo) {\n                  return Ut(Wn, je, Ha, vo);\n                }\n                function Oi(Wn, Ha, vo) {\n                  return Ut(Wn, tt, Ha, vo);\n                }\n                function $i(Wn) {\n                  return xe[Wn.getDay()];\n                }\n                function tn(Wn) {\n                  return Ie[Wn.getDay()];\n                }\n                function fn(Wn) {\n                  return vt[Wn.getMonth()];\n                }\n                function yn(Wn) {\n                  return ke[Wn.getMonth()];\n                }\n                function Sn(Wn) {\n                  return xt[+(Wn.getHours() >= 12)];\n                }\n                function Ba(Wn) {\n                  return 1 + ~~(Wn.getMonth() / 3);\n                }\n                function ua(Wn) {\n                  return xe[Wn.getUTCDay()];\n                }\n                function ma(Wn) {\n                  return Ie[Wn.getUTCDay()];\n                }\n                function Wa(Wn) {\n                  return vt[Wn.getUTCMonth()];\n                }\n                function Fa(Wn) {\n                  return ke[Wn.getUTCMonth()];\n                }\n                function Wo(Wn) {\n                  return xt[+(Wn.getUTCHours() >= 12)];\n                }\n                function da(Wn) {\n                  return 1 + ~~(Wn.getUTCMonth() / 3);\n                }\n                return { format: function(Wn) {\n                  var Ha = ra(Wn += "", On);\n                  return Ha.toString = function() {\n                    return Wn;\n                  }, Ha;\n                }, parse: function(Wn) {\n                  var Ha = la(Wn += "", false);\n                  return Ha.toString = function() {\n                    return Wn;\n                  }, Ha;\n                }, utcFormat: function(Wn) {\n                  var Ha = ra(Wn += "", qn);\n                  return Ha.toString = function() {\n                    return Wn;\n                  }, Ha;\n                }, utcParse: function(Wn) {\n                  var Ha = la(Wn += "", true);\n                  return Ha.toString = function() {\n                    return Wn;\n                  }, Ha;\n                } };\n              }\n              var o4 = { "-": "", _: " ", 0: "0" }, s3 = /^\\s*\\d+/, l3 = /^%/, u4 = /[\\\\^$*+?|[\\]().{}]/g;\n              function c5(Ge, Je, je) {\n                var tt = Ge < 0 ? "-" : "", xt = (tt ? -Ge : Ge) + "", Ie = xt.length;\n                return tt + (Ie < je ? new Array(je - Ie + 1).join(Je) + xt : xt);\n              }\n              function f4(Ge) {\n                return Ge.replace(u4, "\\\\$&");\n              }\n              function h3(Ge) {\n                return new RegExp("^(?:" + Ge.map(f4).join("|") + ")", "i");\n              }\n              function d3(Ge) {\n                for (var Je = {}, je = -1, tt = Ge.length; ++je < tt; ) Je[Ge[je].toLowerCase()] = je;\n                return Je;\n              }\n              function v3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 1));\n                return tt ? (Ge.w = +tt[0], je + tt[0].length) : -1;\n              }\n              function _2(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 1));\n                return tt ? (Ge.u = +tt[0], je + tt[0].length) : -1;\n              }\n              function b(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.U = +tt[0], je + tt[0].length) : -1;\n              }\n              function p3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.V = +tt[0], je + tt[0].length) : -1;\n              }\n              function k4(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.W = +tt[0], je + tt[0].length) : -1;\n              }\n              function E3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 4));\n                return tt ? (Ge.y = +tt[0], je + tt[0].length) : -1;\n              }\n              function S2(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.y = +tt[0] + (+tt[0] > 68 ? 1900 : 2e3), je + tt[0].length) : -1;\n              }\n              function L3(Ge, Je, je) {\n                var tt = /^(Z)|([+-]\\d\\d)(?::?(\\d\\d))?/.exec(Je.slice(je, je + 6));\n                return tt ? (Ge.Z = tt[1] ? 0 : -(tt[2] + (tt[3] || "00")), je + tt[0].length) : -1;\n              }\n              function x2(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 1));\n                return tt ? (Ge.q = tt[0] * 3 - 3, je + tt[0].length) : -1;\n              }\n              function C3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.m = tt[0] - 1, je + tt[0].length) : -1;\n              }\n              function M4(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.d = +tt[0], je + tt[0].length) : -1;\n              }\n              function g3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 3));\n                return tt ? (Ge.m = 0, Ge.d = +tt[0], je + tt[0].length) : -1;\n              }\n              function P3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.H = +tt[0], je + tt[0].length) : -1;\n              }\n              function T3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.M = +tt[0], je + tt[0].length) : -1;\n              }\n              function z3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 2));\n                return tt ? (Ge.S = +tt[0], je + tt[0].length) : -1;\n              }\n              function O3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 3));\n                return tt ? (Ge.L = +tt[0], je + tt[0].length) : -1;\n              }\n              function V2(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je, je + 6));\n                return tt ? (Ge.L = Math.floor(tt[0] / 1e3), je + tt[0].length) : -1;\n              }\n              function G2(Ge, Je, je) {\n                var tt = l3.exec(Je.slice(je, je + 1));\n                return tt ? je + tt[0].length : -1;\n              }\n              function Z(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je));\n                return tt ? (Ge.Q = +tt[0], je + tt[0].length) : -1;\n              }\n              function j3(Ge, Je, je) {\n                var tt = s3.exec(Je.slice(je));\n                return tt ? (Ge.s = +tt[0], je + tt[0].length) : -1;\n              }\n              function N2(Ge, Je) {\n                return c5(Ge.getDate(), Je, 2);\n              }\n              function H(Ge, Je) {\n                return c5(Ge.getHours(), Je, 2);\n              }\n              function te(Ge, Je) {\n                return c5(Ge.getHours() % 12 || 12, Je, 2);\n              }\n              function oe(Ge, Je) {\n                return c5(1 + t3.timeDay.count(t3.timeYear(Ge), Ge), Je, 3);\n              }\n              function _e(Ge, Je) {\n                return c5(Ge.getMilliseconds(), Je, 3);\n              }\n              function Ee(Ge, Je) {\n                return _e(Ge, Je) + "000";\n              }\n              function Ce(Ge, Je) {\n                return c5(Ge.getMonth() + 1, Je, 2);\n              }\n              function me(Ge, Je) {\n                return c5(Ge.getMinutes(), Je, 2);\n              }\n              function ie(Ge, Je) {\n                return c5(Ge.getSeconds(), Je, 2);\n              }\n              function Se(Ge) {\n                var Je = Ge.getDay();\n                return Je === 0 ? 7 : Je;\n              }\n              function Le(Ge, Je) {\n                return c5(t3.timeSunday.count(t3.timeYear(Ge) - 1, Ge), Je, 2);\n              }\n              function Ae(Ge, Je) {\n                var je = Ge.getDay();\n                return Ge = je >= 4 || je === 0 ? t3.timeThursday(Ge) : t3.timeThursday.ceil(Ge), c5(t3.timeThursday.count(t3.timeYear(Ge), Ge) + (t3.timeYear(Ge).getDay() === 4), Je, 2);\n              }\n              function Fe(Ge) {\n                return Ge.getDay();\n              }\n              function Pe(Ge, Je) {\n                return c5(t3.timeMonday.count(t3.timeYear(Ge) - 1, Ge), Je, 2);\n              }\n              function ge(Ge, Je) {\n                return c5(Ge.getFullYear() % 100, Je, 2);\n              }\n              function Re(Ge, Je) {\n                return c5(Ge.getFullYear() % 1e4, Je, 4);\n              }\n              function ce(Ge) {\n                var Je = Ge.getTimezoneOffset();\n                return (Je > 0 ? "-" : (Je *= -1, "+")) + c5(Je / 60 | 0, "0", 2) + c5(Je % 60, "0", 2);\n              }\n              function Ze(Ge, Je) {\n                return c5(Ge.getUTCDate(), Je, 2);\n              }\n              function ut(Ge, Je) {\n                return c5(Ge.getUTCHours(), Je, 2);\n              }\n              function pt(Ge, Je) {\n                return c5(Ge.getUTCHours() % 12 || 12, Je, 2);\n              }\n              function Zt(Ge, Je) {\n                return c5(1 + t3.utcDay.count(t3.utcYear(Ge), Ge), Je, 3);\n              }\n              function st(Ge, Je) {\n                return c5(Ge.getUTCMilliseconds(), Je, 3);\n              }\n              function lt(Ge, Je) {\n                return st(Ge, Je) + "000";\n              }\n              function Gt(Ge, Je) {\n                return c5(Ge.getUTCMonth() + 1, Je, 2);\n              }\n              function Nt(Ge, Je) {\n                return c5(Ge.getUTCMinutes(), Je, 2);\n              }\n              function Jt(Ge, Je) {\n                return c5(Ge.getUTCSeconds(), Je, 2);\n              }\n              function sr(Ge) {\n                var Je = Ge.getUTCDay();\n                return Je === 0 ? 7 : Je;\n              }\n              function wr(Ge, Je) {\n                return c5(t3.utcSunday.count(t3.utcYear(Ge) - 1, Ge), Je, 2);\n              }\n              function cr(Ge, Je) {\n                var je = Ge.getUTCDay();\n                return Ge = je >= 4 || je === 0 ? t3.utcThursday(Ge) : t3.utcThursday.ceil(Ge), c5(t3.utcThursday.count(t3.utcYear(Ge), Ge) + (t3.utcYear(Ge).getUTCDay() === 4), Je, 2);\n              }\n              function $e(Ge) {\n                return Ge.getUTCDay();\n              }\n              function St(Ge, Je) {\n                return c5(t3.utcMonday.count(t3.utcYear(Ge) - 1, Ge), Je, 2);\n              }\n              function Qt(Ge, Je) {\n                return c5(Ge.getUTCFullYear() % 100, Je, 2);\n              }\n              function Vt(Ge, Je) {\n                return c5(Ge.getUTCFullYear() % 1e4, Je, 4);\n              }\n              function _t() {\n                return "+0000";\n              }\n              function It() {\n                return "%";\n              }\n              function mt(Ge) {\n                return +Ge;\n              }\n              function er(Ge) {\n                return Math.floor(+Ge / 1e3);\n              }\n              var lr;\n              Tr({ dateTime: "%x, %X", date: "%-m/%-d/%Y", time: "%-I:%M:%S %p", periods: ["AM", "PM"], days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] });\n              function Tr(Ge) {\n                return lr = a4(Ge), e3.timeFormat = lr.format, e3.timeParse = lr.parse, e3.utcFormat = lr.utcFormat, e3.utcParse = lr.utcParse, lr;\n              }\n              var Lr = "%Y-%m-%dT%H:%M:%S.%LZ";\n              function ti(Ge) {\n                return Ge.toISOString();\n              }\n              var Br = Date.prototype.toISOString ? ti : e3.utcFormat(Lr);\n              function Vr(Ge) {\n                var Je = new Date(Ge);\n                return isNaN(Je) ? null : Je;\n              }\n              var dt = +/* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z") ? Vr : e3.utcParse(Lr);\n              e3.isoFormat = Br, e3.isoParse = dt, e3.timeFormatDefaultLocale = Tr, e3.timeFormatLocale = a4, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var wO = ye((d6, mee) => {\n            (function(e3, t3) {\n              typeof d6 == "object" && typeof mee != "undefined" ? t3(d6) : (e3 = typeof globalThis != "undefined" ? globalThis : e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(d6, function(e3) {\n              "use strict";\n              function t3(C3) {\n                return Math.abs(C3 = Math.round(C3)) >= 1e21 ? C3.toLocaleString("en").replace(/,/g, "") : C3.toString(10);\n              }\n              function r4(C3, M4) {\n                if ((g3 = (C3 = M4 ? C3.toExponential(M4 - 1) : C3.toExponential()).indexOf("e")) < 0) return null;\n                var g3, P3 = C3.slice(0, g3);\n                return [P3.length > 1 ? P3[0] + P3.slice(2) : P3, +C3.slice(g3 + 1)];\n              }\n              function n4(C3) {\n                return C3 = r4(Math.abs(C3)), C3 ? C3[1] : NaN;\n              }\n              function i3(C3, M4) {\n                return function(g3, P3) {\n                  for (var T3 = g3.length, z3 = [], O3 = 0, V2 = C3[0], G2 = 0; T3 > 0 && V2 > 0 && (G2 + V2 + 1 > P3 && (V2 = Math.max(1, P3 - G2)), z3.push(g3.substring(T3 -= V2, T3 + V2)), !((G2 += V2 + 1) > P3)); ) V2 = C3[O3 = (O3 + 1) % C3.length];\n                  return z3.reverse().join(M4);\n                };\n              }\n              function a4(C3) {\n                return function(M4) {\n                  return M4.replace(/[0-9]/g, function(g3) {\n                    return C3[+g3];\n                  });\n                };\n              }\n              var o4 = /^(?:(.)?([<>=^]))?([+\\-( ])?([$#])?(0)?(\\d+)?(,)?(\\.\\d+)?(~)?([a-z%])?$/i;\n              function s3(C3) {\n                if (!(M4 = o4.exec(C3))) throw new Error("invalid format: " + C3);\n                var M4;\n                return new l3({ fill: M4[1], align: M4[2], sign: M4[3], symbol: M4[4], zero: M4[5], width: M4[6], comma: M4[7], precision: M4[8] && M4[8].slice(1), trim: M4[9], type: M4[10] });\n              }\n              s3.prototype = l3.prototype;\n              function l3(C3) {\n                this.fill = C3.fill === void 0 ? " " : C3.fill + "", this.align = C3.align === void 0 ? ">" : C3.align + "", this.sign = C3.sign === void 0 ? "-" : C3.sign + "", this.symbol = C3.symbol === void 0 ? "" : C3.symbol + "", this.zero = !!C3.zero, this.width = C3.width === void 0 ? void 0 : +C3.width, this.comma = !!C3.comma, this.precision = C3.precision === void 0 ? void 0 : +C3.precision, this.trim = !!C3.trim, this.type = C3.type === void 0 ? "" : C3.type + "";\n              }\n              l3.prototype.toString = function() {\n                return this.fill + this.align + this.sign + this.symbol + (this.zero ? "0" : "") + (this.width === void 0 ? "" : Math.max(1, this.width | 0)) + (this.comma ? "," : "") + (this.precision === void 0 ? "" : "." + Math.max(0, this.precision | 0)) + (this.trim ? "~" : "") + this.type;\n              };\n              function u4(C3) {\n                e: for (var M4 = C3.length, g3 = 1, P3 = -1, T3; g3 < M4; ++g3) switch (C3[g3]) {\n                  case ".":\n                    P3 = T3 = g3;\n                    break;\n                  case "0":\n                    P3 === 0 && (P3 = g3), T3 = g3;\n                    break;\n                  default:\n                    if (!+C3[g3]) break e;\n                    P3 > 0 && (P3 = 0);\n                    break;\n                }\n                return P3 > 0 ? C3.slice(0, P3) + C3.slice(T3 + 1) : C3;\n              }\n              var c5;\n              function f4(C3, M4) {\n                var g3 = r4(C3, M4);\n                if (!g3) return C3 + "";\n                var P3 = g3[0], T3 = g3[1], z3 = T3 - (c5 = Math.max(-8, Math.min(8, Math.floor(T3 / 3))) * 3) + 1, O3 = P3.length;\n                return z3 === O3 ? P3 : z3 > O3 ? P3 + new Array(z3 - O3 + 1).join("0") : z3 > 0 ? P3.slice(0, z3) + "." + P3.slice(z3) : "0." + new Array(1 - z3).join("0") + r4(C3, Math.max(0, M4 + z3 - 1))[0];\n              }\n              function h3(C3, M4) {\n                var g3 = r4(C3, M4);\n                if (!g3) return C3 + "";\n                var P3 = g3[0], T3 = g3[1];\n                return T3 < 0 ? "0." + new Array(-T3).join("0") + P3 : P3.length > T3 + 1 ? P3.slice(0, T3 + 1) + "." + P3.slice(T3 + 1) : P3 + new Array(T3 - P3.length + 2).join("0");\n              }\n              var d3 = { "%": function(C3, M4) {\n                return (C3 * 100).toFixed(M4);\n              }, b: function(C3) {\n                return Math.round(C3).toString(2);\n              }, c: function(C3) {\n                return C3 + "";\n              }, d: t3, e: function(C3, M4) {\n                return C3.toExponential(M4);\n              }, f: function(C3, M4) {\n                return C3.toFixed(M4);\n              }, g: function(C3, M4) {\n                return C3.toPrecision(M4);\n              }, o: function(C3) {\n                return Math.round(C3).toString(8);\n              }, p: function(C3, M4) {\n                return h3(C3 * 100, M4);\n              }, r: h3, s: f4, X: function(C3) {\n                return Math.round(C3).toString(16).toUpperCase();\n              }, x: function(C3) {\n                return Math.round(C3).toString(16);\n              } };\n              function v3(C3) {\n                return C3;\n              }\n              var _2 = Array.prototype.map, b = ["y", "z", "a", "f", "p", "n", "\\xB5", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"];\n              function p3(C3) {\n                var M4 = C3.grouping === void 0 || C3.thousands === void 0 ? v3 : i3(_2.call(C3.grouping, Number), C3.thousands + ""), g3 = C3.currency === void 0 ? "" : C3.currency[0] + "", P3 = C3.currency === void 0 ? "" : C3.currency[1] + "", T3 = C3.decimal === void 0 ? "." : C3.decimal + "", z3 = C3.numerals === void 0 ? v3 : a4(_2.call(C3.numerals, String)), O3 = C3.percent === void 0 ? "%" : C3.percent + "", V2 = C3.minus === void 0 ? "-" : C3.minus + "", G2 = C3.nan === void 0 ? "NaN" : C3.nan + "";\n                function Z(N2) {\n                  N2 = s3(N2);\n                  var H = N2.fill, te = N2.align, oe = N2.sign, _e = N2.symbol, Ee = N2.zero, Ce = N2.width, me = N2.comma, ie = N2.precision, Se = N2.trim, Le = N2.type;\n                  Le === "n" ? (me = true, Le = "g") : d3[Le] || (ie === void 0 && (ie = 12), Se = true, Le = "g"), (Ee || H === "0" && te === "=") && (Ee = true, H = "0", te = "=");\n                  var Ae = _e === "$" ? g3 : _e === "#" && /[boxX]/.test(Le) ? "0" + Le.toLowerCase() : "", Fe = _e === "$" ? P3 : /[%p]/.test(Le) ? O3 : "", Pe = d3[Le], ge = /[defgprs%]/.test(Le);\n                  ie = ie === void 0 ? 6 : /[gprs]/.test(Le) ? Math.max(1, Math.min(21, ie)) : Math.max(0, Math.min(20, ie));\n                  function Re(ce) {\n                    var Ze = Ae, ut = Fe, pt, Zt, st;\n                    if (Le === "c") ut = Pe(ce) + ut, ce = "";\n                    else {\n                      ce = +ce;\n                      var lt = ce < 0 || 1 / ce < 0;\n                      if (ce = isNaN(ce) ? G2 : Pe(Math.abs(ce), ie), Se && (ce = u4(ce)), lt && +ce == 0 && oe !== "+" && (lt = false), Ze = (lt ? oe === "(" ? oe : V2 : oe === "-" || oe === "(" ? "" : oe) + Ze, ut = (Le === "s" ? b[8 + c5 / 3] : "") + ut + (lt && oe === "(" ? ")" : ""), ge) {\n                        for (pt = -1, Zt = ce.length; ++pt < Zt; ) if (st = ce.charCodeAt(pt), 48 > st || st > 57) {\n                          ut = (st === 46 ? T3 + ce.slice(pt + 1) : ce.slice(pt)) + ut, ce = ce.slice(0, pt);\n                          break;\n                        }\n                      }\n                    }\n                    me && !Ee && (ce = M4(ce, 1 / 0));\n                    var Gt = Ze.length + ce.length + ut.length, Nt = Gt < Ce ? new Array(Ce - Gt + 1).join(H) : "";\n                    switch (me && Ee && (ce = M4(Nt + ce, Nt.length ? Ce - ut.length : 1 / 0), Nt = ""), te) {\n                      case "<":\n                        ce = Ze + ce + ut + Nt;\n                        break;\n                      case "=":\n                        ce = Ze + Nt + ce + ut;\n                        break;\n                      case "^":\n                        ce = Nt.slice(0, Gt = Nt.length >> 1) + Ze + ce + ut + Nt.slice(Gt);\n                        break;\n                      default:\n                        ce = Nt + Ze + ce + ut;\n                        break;\n                    }\n                    return z3(ce);\n                  }\n                  return Re.toString = function() {\n                    return N2 + "";\n                  }, Re;\n                }\n                function j3(N2, H) {\n                  var te = Z((N2 = s3(N2), N2.type = "f", N2)), oe = Math.max(-8, Math.min(8, Math.floor(n4(H) / 3))) * 3, _e = Math.pow(10, -oe), Ee = b[8 + oe / 3];\n                  return function(Ce) {\n                    return te(_e * Ce) + Ee;\n                  };\n                }\n                return { format: Z, formatPrefix: j3 };\n              }\n              var k4;\n              E3({ decimal: ".", thousands: ",", grouping: [3], currency: ["$", ""], minus: "-" });\n              function E3(C3) {\n                return k4 = p3(C3), e3.format = k4.format, e3.formatPrefix = k4.formatPrefix, k4;\n              }\n              function S2(C3) {\n                return Math.max(0, -n4(Math.abs(C3)));\n              }\n              function L3(C3, M4) {\n                return Math.max(0, Math.max(-8, Math.min(8, Math.floor(n4(M4) / 3))) * 3 - n4(Math.abs(C3)));\n              }\n              function x2(C3, M4) {\n                return C3 = Math.abs(C3), M4 = Math.abs(M4) - C3, Math.max(0, n4(M4) - n4(C3)) + 1;\n              }\n              e3.FormatSpecifier = l3, e3.formatDefaultLocale = E3, e3.formatLocale = p3, e3.formatSpecifier = s3, e3.precisionFixed = S2, e3.precisionPrefix = L3, e3.precisionRound = x2, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var _ee = ye((orr, yee) => {\n            "use strict";\n            yee.exports = function(e3) {\n              for (var t3 = e3.length, r4, n4 = 0; n4 < t3; n4++) if (r4 = e3.charCodeAt(n4), (r4 < 9 || r4 > 13) && r4 !== 32 && r4 !== 133 && r4 !== 160 && r4 !== 5760 && r4 !== 6158 && (r4 < 8192 || r4 > 8205) && r4 !== 8232 && r4 !== 8233 && r4 !== 8239 && r4 !== 8287 && r4 !== 8288 && r4 !== 12288 && r4 !== 65279) return false;\n              return true;\n            };\n          });\n          var Eo = ye((srr, xee) => {\n            "use strict";\n            var mtt = _ee();\n            xee.exports = function(e3) {\n              var t3 = typeof e3;\n              if (t3 === "string") {\n                var r4 = e3;\n                if (e3 = +e3, e3 === 0 && mtt(r4)) return false;\n              } else if (t3 !== "number") return false;\n              return e3 - e3 < 1;\n            };\n          });\n          var fs = ye((lrr, bee) => {\n            "use strict";\n            bee.exports = { BADNUM: void 0, FP_SAFE: Number.MAX_VALUE * 1e-4, ONEMAXYEAR: 316224e5, ONEAVGYEAR: 315576e5, ONEMINYEAR: 31536e6, ONEMAXQUARTER: 79488e5, ONEAVGQUARTER: 78894e5, ONEMINQUARTER: 76896e5, ONEMAXMONTH: 26784e5, ONEAVGMONTH: 26298e5, ONEMINMONTH: 24192e5, ONEWEEK: 6048e5, ONEDAY: 864e5, ONEHOUR: 36e5, ONEMIN: 6e4, ONESEC: 1e3, ONEMILLI: 1, ONEMICROSEC: 1e-3, EPOCHJD: 24405875e-1, ALMOST_EQUAL: 1 - 1e-6, LOG_CLIP: 10, MINUS_SIGN: "\\u2212" };\n          });\n          var TO = ye((v6, wee) => {\n            (function(e3, t3) {\n              typeof v6 == "object" && typeof wee != "undefined" ? t3(v6) : (e3 = typeof globalThis != "undefined" ? globalThis : e3 || self, t3(e3["base64-arraybuffer"] = {}));\n            })(v6, function(e3) {\n              "use strict";\n              for (var t3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r4 = typeof Uint8Array == "undefined" ? [] : new Uint8Array(256), n4 = 0; n4 < t3.length; n4++) r4[t3.charCodeAt(n4)] = n4;\n              var i3 = function(o4) {\n                var s3 = new Uint8Array(o4), l3, u4 = s3.length, c5 = "";\n                for (l3 = 0; l3 < u4; l3 += 3) c5 += t3[s3[l3] >> 2], c5 += t3[(s3[l3] & 3) << 4 | s3[l3 + 1] >> 4], c5 += t3[(s3[l3 + 1] & 15) << 2 | s3[l3 + 2] >> 6], c5 += t3[s3[l3 + 2] & 63];\n                return u4 % 3 === 2 ? c5 = c5.substring(0, c5.length - 1) + "=" : u4 % 3 === 1 && (c5 = c5.substring(0, c5.length - 2) + "=="), c5;\n              }, a4 = function(o4) {\n                var s3 = o4.length * 0.75, l3 = o4.length, u4, c5 = 0, f4, h3, d3, v3;\n                o4[o4.length - 1] === "=" && (s3--, o4[o4.length - 2] === "=" && s3--);\n                var _2 = new ArrayBuffer(s3), b = new Uint8Array(_2);\n                for (u4 = 0; u4 < l3; u4 += 4) f4 = r4[o4.charCodeAt(u4)], h3 = r4[o4.charCodeAt(u4 + 1)], d3 = r4[o4.charCodeAt(u4 + 2)], v3 = r4[o4.charCodeAt(u4 + 3)], b[c5++] = f4 << 2 | h3 >> 4, b[c5++] = (h3 & 15) << 4 | d3 >> 2, b[c5++] = (d3 & 3) << 6 | v3 & 63;\n                return _2;\n              };\n              e3.decode = a4, e3.encode = i3, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var my = ye((urr, Tee) => {\n            "use strict";\n            Tee.exports = function(t3) {\n              return window && window.process && window.process.versions ? Object.prototype.toString.call(t3) === "[object Object]" : Object.prototype.toString.call(t3) === "[object Object]" && Object.getPrototypeOf(t3).hasOwnProperty("hasOwnProperty");\n            };\n          });\n          var vv = ye((yg) => {\n            "use strict";\n            var ytt = TO().decode, _tt = my(), AO = Array.isArray, xtt = ArrayBuffer, btt = DataView;\n            function Aee(e3) {\n              return xtt.isView(e3) && !(e3 instanceof btt);\n            }\n            yg.isTypedArray = Aee;\n            function p6(e3) {\n              return AO(e3) || Aee(e3);\n            }\n            yg.isArrayOrTypedArray = p6;\n            function wtt(e3) {\n              return !p6(e3[0]);\n            }\n            yg.isArray1D = wtt;\n            yg.ensureArray = function(e3, t3) {\n              return AO(e3) || (e3 = []), e3.length = t3, e3;\n            };\n            var Ld = { u1c: typeof Uint8ClampedArray == "undefined" ? void 0 : Uint8ClampedArray, i1: typeof Int8Array == "undefined" ? void 0 : Int8Array, u1: typeof Uint8Array == "undefined" ? void 0 : Uint8Array, i2: typeof Int16Array == "undefined" ? void 0 : Int16Array, u2: typeof Uint16Array == "undefined" ? void 0 : Uint16Array, i4: typeof Int32Array == "undefined" ? void 0 : Int32Array, u4: typeof Uint32Array == "undefined" ? void 0 : Uint32Array, f4: typeof Float32Array == "undefined" ? void 0 : Float32Array, f8: typeof Float64Array == "undefined" ? void 0 : Float64Array };\n            Ld.uint8c = Ld.u1c;\n            Ld.uint8 = Ld.u1;\n            Ld.int8 = Ld.i1;\n            Ld.uint16 = Ld.u2;\n            Ld.int16 = Ld.i2;\n            Ld.uint32 = Ld.u4;\n            Ld.int32 = Ld.i4;\n            Ld.float32 = Ld.f4;\n            Ld.float64 = Ld.f8;\n            function SO(e3) {\n              return e3.constructor === ArrayBuffer;\n            }\n            yg.isArrayBuffer = SO;\n            yg.decodeTypedArraySpec = function(e3) {\n              var t3 = [], r4 = Ttt(e3), n4 = r4.dtype, i3 = Ld[n4];\n              if (!i3) throw new Error(\'Error in dtype: "\' + n4 + \'"\');\n              var a4 = i3.BYTES_PER_ELEMENT, o4 = r4.bdata;\n              SO(o4) || (o4 = ytt(o4));\n              var s3 = r4.shape === void 0 ? [o4.byteLength / a4] : ("" + r4.shape).split(",");\n              s3.reverse();\n              var l3 = s3.length, u4, c5, f4 = +s3[0], h3 = a4 * f4, d3 = 0;\n              if (l3 === 1) t3 = new i3(o4);\n              else if (l3 === 2) for (u4 = +s3[1], c5 = 0; c5 < u4; c5++) t3[c5] = new i3(o4, d3, f4), d3 += h3;\n              else if (l3 === 3) {\n                u4 = +s3[1];\n                for (var v3 = +s3[2], _2 = 0; _2 < v3; _2++) for (t3[_2] = [], c5 = 0; c5 < u4; c5++) t3[_2][c5] = new i3(o4, d3, f4), d3 += h3;\n              } else throw new Error("ndim: " + l3 + \'is not supported with the shape:"\' + r4.shape + \'"\');\n              return t3.bdata = r4.bdata, t3.dtype = r4.dtype, t3.shape = s3.reverse().join(","), e3._inputArray = t3, t3;\n            };\n            yg.isTypedArraySpec = function(e3) {\n              return _tt(e3) && e3.hasOwnProperty("dtype") && typeof e3.dtype == "string" && e3.hasOwnProperty("bdata") && (typeof e3.bdata == "string" || SO(e3.bdata)) && (e3.shape === void 0 || e3.hasOwnProperty("shape") && (typeof e3.shape == "string" || typeof e3.shape == "number"));\n            };\n            function Ttt(e3) {\n              return { bdata: e3.bdata, dtype: e3.dtype, shape: e3.shape };\n            }\n            yg.concat = function() {\n              var e3 = [], t3 = true, r4 = 0, n4, i3, a4, o4, s3, l3, u4, c5;\n              for (a4 = 0; a4 < arguments.length; a4++) o4 = arguments[a4], l3 = o4.length, l3 && (i3 ? e3.push(o4) : (i3 = o4, s3 = l3), AO(o4) ? n4 = false : (t3 = false, r4 ? n4 !== o4.constructor && (n4 = false) : n4 = o4.constructor), r4 += l3);\n              if (!r4) return [];\n              if (!e3.length) return i3;\n              if (t3) return i3.concat.apply(i3, e3);\n              if (n4) {\n                for (u4 = new n4(r4), u4.set(i3), a4 = 0; a4 < e3.length; a4++) o4 = e3[a4], u4.set(o4, s3), s3 += o4.length;\n                return u4;\n              }\n              for (u4 = new Array(r4), c5 = 0; c5 < i3.length; c5++) u4[c5] = i3[c5];\n              for (a4 = 0; a4 < e3.length; a4++) {\n                for (o4 = e3[a4], c5 = 0; c5 < o4.length; c5++) u4[s3 + c5] = o4[c5];\n                s3 += c5;\n              }\n              return u4;\n            };\n            yg.maxRowLength = function(e3) {\n              return See(e3, Math.max, 0);\n            };\n            yg.minRowLength = function(e3) {\n              return See(e3, Math.min, 1 / 0);\n            };\n            function See(e3, t3, r4) {\n              if (p6(e3)) if (p6(e3[0])) {\n                for (var n4 = r4, i3 = 0; i3 < e3.length; i3++) n4 = t3(n4, e3[i3].length);\n                return n4;\n              } else return e3.length;\n              return 0;\n            }\n          });\n          var PS = ye((frr, Lee) => {\n            "use strict";\n            var Mee = Eo(), EO = vv().isArrayOrTypedArray;\n            Lee.exports = function(t3, r4) {\n              if (Mee(r4)) r4 = String(r4);\n              else if (typeof r4 != "string" || r4.slice(-4) === "[-1]") throw "bad property string";\n              var n4 = r4.split("."), i3, a4, o4, s3;\n              for (s3 = 0; s3 < n4.length; s3++) if (String(n4[s3]).slice(0, 2) === "__") throw "bad property string";\n              for (s3 = 0; s3 < n4.length; ) {\n                if (i3 = String(n4[s3]).match(/^([^\\[\\]]*)((\\[\\-?[0-9]*\\])+)$/), i3) {\n                  if (i3[1]) n4[s3] = i3[1];\n                  else if (s3 === 0) n4.splice(0, 1);\n                  else throw "bad property string";\n                  for (a4 = i3[2].slice(1, -1).split("]["), o4 = 0; o4 < a4.length; o4++) s3++, n4.splice(s3, 0, Number(a4[o4]));\n                }\n                s3++;\n              }\n              return typeof t3 != "object" ? Ett(t3, r4, n4) : { set: kee(t3, n4, r4), get: Eee(t3, n4), astr: r4, parts: n4, obj: t3 };\n            };\n            function Eee(e3, t3) {\n              return function(r4) {\n                var n4 = e3, i3, a4, o4, s3, l3;\n                for (s3 = 0; s3 < t3.length - 1; s3++) {\n                  if (i3 = t3[s3], i3 === -1) {\n                    for (a4 = true, o4 = [], l3 = 0; l3 < n4.length; l3++) o4[l3] = Eee(n4[l3], t3.slice(s3 + 1))(r4), o4[l3] !== o4[0] && (a4 = false);\n                    return a4 ? o4[0] : o4;\n                  }\n                  if (typeof i3 == "number" && !EO(n4) || (n4 = n4[i3], typeof n4 != "object" || n4 === null)) return;\n                }\n                if (!(typeof n4 != "object" || n4 === null) && (o4 = n4[t3[s3]], !(!r4 && o4 === null))) return o4;\n              };\n            }\n            var Att = /(^|\\.)args\\[/;\n            function MO(e3, t3) {\n              return e3 === void 0 || e3 === null && !t3.match(Att);\n            }\n            function kee(e3, t3, r4) {\n              return function(n4) {\n                var i3 = e3, a4 = "", o4 = [[e3, a4]], s3 = MO(n4, r4), l3, u4;\n                for (u4 = 0; u4 < t3.length - 1; u4++) {\n                  if (l3 = t3[u4], typeof l3 == "number" && !EO(i3)) throw "array index but container is not an array";\n                  if (l3 === -1) {\n                    if (s3 = !Mtt(i3, t3.slice(u4 + 1), n4, r4), s3) break;\n                    return;\n                  }\n                  if (!Cee(i3, l3, t3[u4 + 1], s3)) break;\n                  if (i3 = i3[l3], typeof i3 != "object" || i3 === null) throw "container is not an object";\n                  a4 = Stt(a4, l3), o4.push([i3, a4]);\n                }\n                if (s3) {\n                  if (u4 === t3.length - 1 && (delete i3[t3[u4]], Array.isArray(i3) && +t3[u4] === i3.length - 1)) for (; i3.length && i3[i3.length - 1] === void 0; ) i3.pop();\n                } else i3[t3[u4]] = n4;\n              };\n            }\n            function Stt(e3, t3) {\n              var r4 = t3;\n              return Mee(t3) ? r4 = "[" + t3 + "]" : e3 && (r4 = "." + t3), e3 + r4;\n            }\n            function Mtt(e3, t3, r4, n4) {\n              var i3 = EO(r4), a4 = true, o4 = r4, s3 = n4.replace("-1", 0), l3 = i3 ? false : MO(r4, s3), u4 = t3[0], c5;\n              for (c5 = 0; c5 < e3.length; c5++) s3 = n4.replace("-1", c5), i3 && (o4 = r4[c5 % r4.length], l3 = MO(o4, s3)), l3 && (a4 = false), Cee(e3, c5, u4, l3) && kee(e3[c5], t3, n4.replace("-1", c5))(o4);\n              return a4;\n            }\n            function Cee(e3, t3, r4, n4) {\n              if (e3[t3] === void 0) {\n                if (n4) return false;\n                typeof r4 == "number" ? e3[t3] = [] : e3[t3] = {};\n              }\n              return true;\n            }\n            function Ett(e3, t3, r4) {\n              return { set: function() {\n                throw "bad container";\n              }, get: function() {\n              }, astr: t3, parts: r4, obj: e3 };\n            }\n          });\n          var Dee = ye((hrr, Ree) => {\n            "use strict";\n            var i3 = PS(), ktt = /^\\w*$/, Ctt = 0, Pee = 1, g6 = 2, Iee = 3, sb = 4;\n            Ree.exports = function(t3, r4, n4, i6) {\n              n4 = n4 || "name", i6 = i6 || "value";\n              var a4, o4, s3, l3 = {};\n              r4 && r4.length ? (s3 = i3(t3, r4), o4 = s3.get()) : o4 = t3, r4 = r4 || "";\n              var u4 = {};\n              if (o4) for (a4 = 0; a4 < o4.length; a4++) u4[o4[a4][n4]] = a4;\n              var c5 = ktt.test(i6), f4 = { set: function(h3, d3) {\n                var v3 = d3 === null ? sb : Ctt;\n                if (!o4) {\n                  if (!s3 || v3 === sb) return;\n                  o4 = [], s3.set(o4);\n                }\n                var _2 = u4[h3];\n                if (_2 === void 0) {\n                  if (v3 === sb) return;\n                  v3 = v3 | Iee, _2 = o4.length, u4[h3] = _2;\n                } else d3 !== (c5 ? o4[_2][i6] : i3(o4[_2], i6).get()) && (v3 = v3 | g6);\n                var b = o4[_2] = o4[_2] || {};\n                return b[n4] = h3, c5 ? b[i6] = d3 : i3(b, i6).set(d3), d3 !== null && (v3 = v3 & ~sb), l3[_2] = l3[_2] | v3, f4;\n              }, get: function(h3) {\n                if (o4) {\n                  var d3 = u4[h3];\n                  if (d3 !== void 0) return c5 ? o4[d3][i6] : i3(o4[d3], i6).get();\n                }\n              }, rename: function(h3, d3) {\n                var v3 = u4[h3];\n                return v3 === void 0 || (l3[v3] = l3[v3] | Pee, u4[d3] = v3, delete u4[h3], o4[v3][n4] = d3), f4;\n              }, remove: function(h3) {\n                var d3 = u4[h3];\n                if (d3 === void 0) return f4;\n                var v3 = o4[d3];\n                if (Object.keys(v3).length > 2) return l3[d3] = l3[d3] | g6, f4.set(h3, null);\n                if (c5) {\n                  for (a4 = d3; a4 < o4.length; a4++) l3[a4] = l3[a4] | Iee;\n                  for (a4 = d3; a4 < o4.length; a4++) u4[o4[a4][n4]]--;\n                  o4.splice(d3, 1), delete u4[h3];\n                } else i3(v3, i6).set(null), l3[d3] = l3[d3] | g6 | sb;\n                return f4;\n              }, constructUpdate: function() {\n                for (var h3, d3, v3 = {}, _2 = Object.keys(l3), b = 0; b < _2.length; b++) d3 = _2[b], h3 = r4 + "[" + d3 + "]", o4[d3] ? (l3[d3] & Pee && (v3[h3 + "." + n4] = o4[d3][n4]), l3[d3] & g6 && (c5 ? v3[h3 + "." + i6] = l3[d3] & sb ? null : o4[d3][i6] : v3[h3 + "." + i6] = l3[d3] & sb ? null : i3(o4[d3], i6).get())) : v3[h3] = null;\n                return v3;\n              } };\n              return f4;\n            };\n          });\n          var zee = ye((drr, Fee) => {\n            "use strict";\n            var Ltt = /^(.*)(\\.[^\\.\\[\\]]+|\\[\\d\\])$/, Ptt = /^[^\\.\\[\\]]+$/;\n            Fee.exports = function(e3, t3) {\n              for (; t3; ) {\n                var r4 = e3.match(Ltt);\n                if (r4) e3 = r4[1];\n                else if (e3.match(Ptt)) e3 = "";\n                else throw new Error("bad relativeAttr call:" + [e3, t3]);\n                if (t3.charAt(0) === "^") t3 = t3.slice(1);\n                else break;\n              }\n              return e3 && t3.charAt(0) !== "[" ? e3 + "." + t3 : e3 + t3;\n            };\n          });\n          var m6 = ye((vrr, Oee) => {\n            "use strict";\n            var Itt = Eo();\n            Oee.exports = function(t3, r4) {\n              if (t3 > 0) return Math.log(t3) / Math.LN10;\n              var n4 = Math.log(Math.min(r4[0], r4[1])) / Math.LN10;\n              return Itt(n4) || (n4 = Math.log(Math.max(r4[0], r4[1])) / Math.LN10 - 6), n4;\n            };\n          });\n          var Nee = ye((prr, Bee) => {\n            "use strict";\n            var qee = vv().isArrayOrTypedArray, IS = my();\n            Bee.exports = function e3(t3, r4) {\n              for (var n4 in r4) {\n                var i3 = r4[n4], a4 = t3[n4];\n                if (a4 !== i3) if (n4.charAt(0) === "_" || typeof i3 == "function") {\n                  if (n4 in t3) continue;\n                  t3[n4] = i3;\n                } else if (qee(i3) && qee(a4) && IS(i3[0])) {\n                  if (n4 === "customdata" || n4 === "ids") continue;\n                  for (var o4 = Math.min(i3.length, a4.length), s3 = 0; s3 < o4; s3++) a4[s3] !== i3[s3] && IS(i3[s3]) && IS(a4[s3]) && e3(a4[s3], i3[s3]);\n                } else IS(i3) && IS(a4) && (e3(a4, i3), Object.keys(a4).length || delete t3[n4]);\n              }\n            };\n          });\n          var n3 = ye((grr, Uee) => {\n            "use strict";\n            function Rtt(e3, t3) {\n              var r4 = e3 % t3;\n              return r4 < 0 ? r4 + t3 : r4;\n            }\n            function Dtt(e3, t3) {\n              return Math.abs(e3) > t3 / 2 ? e3 - Math.round(e3 / t3) * t3 : e3;\n            }\n            Uee.exports = { mod: Rtt, modHalf: Dtt };\n          });\n          var cd = ye((mrr, y6) => {\n            (function(e3) {\n              var t3 = /^\\s+/, r4 = /\\s+$/, n4 = 0, i3 = e3.round, a4 = e3.min, o4 = e3.max, s3 = e3.random;\n              function l3(ge, Re) {\n                if (ge = ge || "", Re = Re || {}, ge instanceof l3) return ge;\n                if (!(this instanceof l3)) return new l3(ge, Re);\n                var ce = u4(ge);\n                this._originalInput = ge, this._r = ce.r, this._g = ce.g, this._b = ce.b, this._a = ce.a, this._roundA = i3(100 * this._a) / 100, this._format = Re.format || ce.format, this._gradientType = Re.gradientType, this._r < 1 && (this._r = i3(this._r)), this._g < 1 && (this._g = i3(this._g)), this._b < 1 && (this._b = i3(this._b)), this._ok = ce.ok, this._tc_id = n4++;\n              }\n              l3.prototype = { isDark: function() {\n                return this.getBrightness() < 128;\n              }, isLight: function() {\n                return !this.isDark();\n              }, isValid: function() {\n                return this._ok;\n              }, getOriginalInput: function() {\n                return this._originalInput;\n              }, getFormat: function() {\n                return this._format;\n              }, getAlpha: function() {\n                return this._a;\n              }, getBrightness: function() {\n                var ge = this.toRgb();\n                return (ge.r * 299 + ge.g * 587 + ge.b * 114) / 1e3;\n              }, getLuminance: function() {\n                var ge = this.toRgb(), Re, ce, Ze, ut, pt, Zt;\n                return Re = ge.r / 255, ce = ge.g / 255, Ze = ge.b / 255, Re <= 0.03928 ? ut = Re / 12.92 : ut = e3.pow((Re + 0.055) / 1.055, 2.4), ce <= 0.03928 ? pt = ce / 12.92 : pt = e3.pow((ce + 0.055) / 1.055, 2.4), Ze <= 0.03928 ? Zt = Ze / 12.92 : Zt = e3.pow((Ze + 0.055) / 1.055, 2.4), 0.2126 * ut + 0.7152 * pt + 0.0722 * Zt;\n              }, setAlpha: function(ge) {\n                return this._a = N2(ge), this._roundA = i3(100 * this._a) / 100, this;\n              }, toHsv: function() {\n                var ge = d3(this._r, this._g, this._b);\n                return { h: ge.h * 360, s: ge.s, v: ge.v, a: this._a };\n              }, toHsvString: function() {\n                var ge = d3(this._r, this._g, this._b), Re = i3(ge.h * 360), ce = i3(ge.s * 100), Ze = i3(ge.v * 100);\n                return this._a == 1 ? "hsv(" + Re + ", " + ce + "%, " + Ze + "%)" : "hsva(" + Re + ", " + ce + "%, " + Ze + "%, " + this._roundA + ")";\n              }, toHsl: function() {\n                var ge = f4(this._r, this._g, this._b);\n                return { h: ge.h * 360, s: ge.s, l: ge.l, a: this._a };\n              }, toHslString: function() {\n                var ge = f4(this._r, this._g, this._b), Re = i3(ge.h * 360), ce = i3(ge.s * 100), Ze = i3(ge.l * 100);\n                return this._a == 1 ? "hsl(" + Re + ", " + ce + "%, " + Ze + "%)" : "hsla(" + Re + ", " + ce + "%, " + Ze + "%, " + this._roundA + ")";\n              }, toHex: function(ge) {\n                return _2(this._r, this._g, this._b, ge);\n              }, toHexString: function(ge) {\n                return "#" + this.toHex(ge);\n              }, toHex8: function(ge) {\n                return b(this._r, this._g, this._b, this._a, ge);\n              }, toHex8String: function(ge) {\n                return "#" + this.toHex8(ge);\n              }, toRgb: function() {\n                return { r: i3(this._r), g: i3(this._g), b: i3(this._b), a: this._a };\n              }, toRgbString: function() {\n                return this._a == 1 ? "rgb(" + i3(this._r) + ", " + i3(this._g) + ", " + i3(this._b) + ")" : "rgba(" + i3(this._r) + ", " + i3(this._g) + ", " + i3(this._b) + ", " + this._roundA + ")";\n              }, toPercentageRgb: function() {\n                return { r: i3(H(this._r, 255) * 100) + "%", g: i3(H(this._g, 255) * 100) + "%", b: i3(H(this._b, 255) * 100) + "%", a: this._a };\n              }, toPercentageRgbString: function() {\n                return this._a == 1 ? "rgb(" + i3(H(this._r, 255) * 100) + "%, " + i3(H(this._g, 255) * 100) + "%, " + i3(H(this._b, 255) * 100) + "%)" : "rgba(" + i3(H(this._r, 255) * 100) + "%, " + i3(H(this._g, 255) * 100) + "%, " + i3(H(this._b, 255) * 100) + "%, " + this._roundA + ")";\n              }, toName: function() {\n                return this._a === 0 ? "transparent" : this._a < 1 ? false : Z[_2(this._r, this._g, this._b, true)] || false;\n              }, toFilter: function(ge) {\n                var Re = "#" + p3(this._r, this._g, this._b, this._a), ce = Re, Ze = this._gradientType ? "GradientType = 1, " : "";\n                if (ge) {\n                  var ut = l3(ge);\n                  ce = "#" + p3(ut._r, ut._g, ut._b, ut._a);\n                }\n                return "progid:DXImageTransform.Microsoft.gradient(" + Ze + "startColorstr=" + Re + ",endColorstr=" + ce + ")";\n              }, toString: function(ge) {\n                var Re = !!ge;\n                ge = ge || this._format;\n                var ce = false, Ze = this._a < 1 && this._a >= 0, ut = !Re && Ze && (ge === "hex" || ge === "hex6" || ge === "hex3" || ge === "hex4" || ge === "hex8" || ge === "name");\n                return ut ? ge === "name" && this._a === 0 ? this.toName() : this.toRgbString() : (ge === "rgb" && (ce = this.toRgbString()), ge === "prgb" && (ce = this.toPercentageRgbString()), (ge === "hex" || ge === "hex6") && (ce = this.toHexString()), ge === "hex3" && (ce = this.toHexString(true)), ge === "hex4" && (ce = this.toHex8String(true)), ge === "hex8" && (ce = this.toHex8String()), ge === "name" && (ce = this.toName()), ge === "hsl" && (ce = this.toHslString()), ge === "hsv" && (ce = this.toHsvString()), ce || this.toHexString());\n              }, clone: function() {\n                return l3(this.toString());\n              }, _applyModification: function(ge, Re) {\n                var ce = ge.apply(null, [this].concat([].slice.call(Re)));\n                return this._r = ce._r, this._g = ce._g, this._b = ce._b, this.setAlpha(ce._a), this;\n              }, lighten: function() {\n                return this._applyModification(L3, arguments);\n              }, brighten: function() {\n                return this._applyModification(x2, arguments);\n              }, darken: function() {\n                return this._applyModification(C3, arguments);\n              }, desaturate: function() {\n                return this._applyModification(k4, arguments);\n              }, saturate: function() {\n                return this._applyModification(E3, arguments);\n              }, greyscale: function() {\n                return this._applyModification(S2, arguments);\n              }, spin: function() {\n                return this._applyModification(M4, arguments);\n              }, _applyCombination: function(ge, Re) {\n                return ge.apply(null, [this].concat([].slice.call(Re)));\n              }, analogous: function() {\n                return this._applyCombination(O3, arguments);\n              }, complement: function() {\n                return this._applyCombination(g3, arguments);\n              }, monochromatic: function() {\n                return this._applyCombination(V2, arguments);\n              }, splitcomplement: function() {\n                return this._applyCombination(z3, arguments);\n              }, triad: function() {\n                return this._applyCombination(P3, arguments);\n              }, tetrad: function() {\n                return this._applyCombination(T3, arguments);\n              } }, l3.fromRatio = function(ge, Re) {\n                if (typeof ge == "object") {\n                  var ce = {};\n                  for (var Ze in ge) ge.hasOwnProperty(Ze) && (Ze === "a" ? ce[Ze] = ge[Ze] : ce[Ze] = me(ge[Ze]));\n                  ge = ce;\n                }\n                return l3(ge, Re);\n              };\n              function u4(ge) {\n                var Re = { r: 0, g: 0, b: 0 }, ce = 1, Ze = null, ut = null, pt = null, Zt = false, st = false;\n                return typeof ge == "string" && (ge = Fe(ge)), typeof ge == "object" && (Ae(ge.r) && Ae(ge.g) && Ae(ge.b) ? (Re = c5(ge.r, ge.g, ge.b), Zt = true, st = String(ge.r).substr(-1) === "%" ? "prgb" : "rgb") : Ae(ge.h) && Ae(ge.s) && Ae(ge.v) ? (Ze = me(ge.s), ut = me(ge.v), Re = v3(ge.h, Ze, ut), Zt = true, st = "hsv") : Ae(ge.h) && Ae(ge.s) && Ae(ge.l) && (Ze = me(ge.s), pt = me(ge.l), Re = h3(ge.h, Ze, pt), Zt = true, st = "hsl"), ge.hasOwnProperty("a") && (ce = ge.a)), ce = N2(ce), { ok: Zt, format: ge.format || st, r: a4(255, o4(Re.r, 0)), g: a4(255, o4(Re.g, 0)), b: a4(255, o4(Re.b, 0)), a: ce };\n              }\n              function c5(ge, Re, ce) {\n                return { r: H(ge, 255) * 255, g: H(Re, 255) * 255, b: H(ce, 255) * 255 };\n              }\n              function f4(ge, Re, ce) {\n                ge = H(ge, 255), Re = H(Re, 255), ce = H(ce, 255);\n                var Ze = o4(ge, Re, ce), ut = a4(ge, Re, ce), pt, Zt, st = (Ze + ut) / 2;\n                if (Ze == ut) pt = Zt = 0;\n                else {\n                  var lt = Ze - ut;\n                  switch (Zt = st > 0.5 ? lt / (2 - Ze - ut) : lt / (Ze + ut), Ze) {\n                    case ge:\n                      pt = (Re - ce) / lt + (Re < ce ? 6 : 0);\n                      break;\n                    case Re:\n                      pt = (ce - ge) / lt + 2;\n                      break;\n                    case ce:\n                      pt = (ge - Re) / lt + 4;\n                      break;\n                  }\n                  pt /= 6;\n                }\n                return { h: pt, s: Zt, l: st };\n              }\n              function h3(ge, Re, ce) {\n                var Ze, ut, pt;\n                ge = H(ge, 360), Re = H(Re, 100), ce = H(ce, 100);\n                function Zt(Gt, Nt, Jt) {\n                  return Jt < 0 && (Jt += 1), Jt > 1 && (Jt -= 1), Jt < 1 / 6 ? Gt + (Nt - Gt) * 6 * Jt : Jt < 1 / 2 ? Nt : Jt < 2 / 3 ? Gt + (Nt - Gt) * (2 / 3 - Jt) * 6 : Gt;\n                }\n                if (Re === 0) Ze = ut = pt = ce;\n                else {\n                  var st = ce < 0.5 ? ce * (1 + Re) : ce + Re - ce * Re, lt = 2 * ce - st;\n                  Ze = Zt(lt, st, ge + 1 / 3), ut = Zt(lt, st, ge), pt = Zt(lt, st, ge - 1 / 3);\n                }\n                return { r: Ze * 255, g: ut * 255, b: pt * 255 };\n              }\n              function d3(ge, Re, ce) {\n                ge = H(ge, 255), Re = H(Re, 255), ce = H(ce, 255);\n                var Ze = o4(ge, Re, ce), ut = a4(ge, Re, ce), pt, Zt, st = Ze, lt = Ze - ut;\n                if (Zt = Ze === 0 ? 0 : lt / Ze, Ze == ut) pt = 0;\n                else {\n                  switch (Ze) {\n                    case ge:\n                      pt = (Re - ce) / lt + (Re < ce ? 6 : 0);\n                      break;\n                    case Re:\n                      pt = (ce - ge) / lt + 2;\n                      break;\n                    case ce:\n                      pt = (ge - Re) / lt + 4;\n                      break;\n                  }\n                  pt /= 6;\n                }\n                return { h: pt, s: Zt, v: st };\n              }\n              function v3(ge, Re, ce) {\n                ge = H(ge, 360) * 6, Re = H(Re, 100), ce = H(ce, 100);\n                var Ze = e3.floor(ge), ut = ge - Ze, pt = ce * (1 - Re), Zt = ce * (1 - ut * Re), st = ce * (1 - (1 - ut) * Re), lt = Ze % 6, Gt = [ce, Zt, pt, pt, st, ce][lt], Nt = [st, ce, ce, Zt, pt, pt][lt], Jt = [pt, pt, st, ce, ce, Zt][lt];\n                return { r: Gt * 255, g: Nt * 255, b: Jt * 255 };\n              }\n              function _2(ge, Re, ce, Ze) {\n                var ut = [Ce(i3(ge).toString(16)), Ce(i3(Re).toString(16)), Ce(i3(ce).toString(16))];\n                return Ze && ut[0].charAt(0) == ut[0].charAt(1) && ut[1].charAt(0) == ut[1].charAt(1) && ut[2].charAt(0) == ut[2].charAt(1) ? ut[0].charAt(0) + ut[1].charAt(0) + ut[2].charAt(0) : ut.join("");\n              }\n              function b(ge, Re, ce, Ze, ut) {\n                var pt = [Ce(i3(ge).toString(16)), Ce(i3(Re).toString(16)), Ce(i3(ce).toString(16)), Ce(ie(Ze))];\n                return ut && pt[0].charAt(0) == pt[0].charAt(1) && pt[1].charAt(0) == pt[1].charAt(1) && pt[2].charAt(0) == pt[2].charAt(1) && pt[3].charAt(0) == pt[3].charAt(1) ? pt[0].charAt(0) + pt[1].charAt(0) + pt[2].charAt(0) + pt[3].charAt(0) : pt.join("");\n              }\n              function p3(ge, Re, ce, Ze) {\n                var ut = [Ce(ie(Ze)), Ce(i3(ge).toString(16)), Ce(i3(Re).toString(16)), Ce(i3(ce).toString(16))];\n                return ut.join("");\n              }\n              l3.equals = function(ge, Re) {\n                return !ge || !Re ? false : l3(ge).toRgbString() == l3(Re).toRgbString();\n              }, l3.random = function() {\n                return l3.fromRatio({ r: s3(), g: s3(), b: s3() });\n              };\n              function k4(ge, Re) {\n                Re = Re === 0 ? 0 : Re || 10;\n                var ce = l3(ge).toHsl();\n                return ce.s -= Re / 100, ce.s = te(ce.s), l3(ce);\n              }\n              function E3(ge, Re) {\n                Re = Re === 0 ? 0 : Re || 10;\n                var ce = l3(ge).toHsl();\n                return ce.s += Re / 100, ce.s = te(ce.s), l3(ce);\n              }\n              function S2(ge) {\n                return l3(ge).desaturate(100);\n              }\n              function L3(ge, Re) {\n                Re = Re === 0 ? 0 : Re || 10;\n                var ce = l3(ge).toHsl();\n                return ce.l += Re / 100, ce.l = te(ce.l), l3(ce);\n              }\n              function x2(ge, Re) {\n                Re = Re === 0 ? 0 : Re || 10;\n                var ce = l3(ge).toRgb();\n                return ce.r = o4(0, a4(255, ce.r - i3(255 * -(Re / 100)))), ce.g = o4(0, a4(255, ce.g - i3(255 * -(Re / 100)))), ce.b = o4(0, a4(255, ce.b - i3(255 * -(Re / 100)))), l3(ce);\n              }\n              function C3(ge, Re) {\n                Re = Re === 0 ? 0 : Re || 10;\n                var ce = l3(ge).toHsl();\n                return ce.l -= Re / 100, ce.l = te(ce.l), l3(ce);\n              }\n              function M4(ge, Re) {\n                var ce = l3(ge).toHsl(), Ze = (ce.h + Re) % 360;\n                return ce.h = Ze < 0 ? 360 + Ze : Ze, l3(ce);\n              }\n              function g3(ge) {\n                var Re = l3(ge).toHsl();\n                return Re.h = (Re.h + 180) % 360, l3(Re);\n              }\n              function P3(ge) {\n                var Re = l3(ge).toHsl(), ce = Re.h;\n                return [l3(ge), l3({ h: (ce + 120) % 360, s: Re.s, l: Re.l }), l3({ h: (ce + 240) % 360, s: Re.s, l: Re.l })];\n              }\n              function T3(ge) {\n                var Re = l3(ge).toHsl(), ce = Re.h;\n                return [l3(ge), l3({ h: (ce + 90) % 360, s: Re.s, l: Re.l }), l3({ h: (ce + 180) % 360, s: Re.s, l: Re.l }), l3({ h: (ce + 270) % 360, s: Re.s, l: Re.l })];\n              }\n              function z3(ge) {\n                var Re = l3(ge).toHsl(), ce = Re.h;\n                return [l3(ge), l3({ h: (ce + 72) % 360, s: Re.s, l: Re.l }), l3({ h: (ce + 216) % 360, s: Re.s, l: Re.l })];\n              }\n              function O3(ge, Re, ce) {\n                Re = Re || 6, ce = ce || 30;\n                var Ze = l3(ge).toHsl(), ut = 360 / ce, pt = [l3(ge)];\n                for (Ze.h = (Ze.h - (ut * Re >> 1) + 720) % 360; --Re; ) Ze.h = (Ze.h + ut) % 360, pt.push(l3(Ze));\n                return pt;\n              }\n              function V2(ge, Re) {\n                Re = Re || 6;\n                for (var ce = l3(ge).toHsv(), Ze = ce.h, ut = ce.s, pt = ce.v, Zt = [], st = 1 / Re; Re--; ) Zt.push(l3({ h: Ze, s: ut, v: pt })), pt = (pt + st) % 1;\n                return Zt;\n              }\n              l3.mix = function(ge, Re, ce) {\n                ce = ce === 0 ? 0 : ce || 50;\n                var Ze = l3(ge).toRgb(), ut = l3(Re).toRgb(), pt = ce / 100, Zt = { r: (ut.r - Ze.r) * pt + Ze.r, g: (ut.g - Ze.g) * pt + Ze.g, b: (ut.b - Ze.b) * pt + Ze.b, a: (ut.a - Ze.a) * pt + Ze.a };\n                return l3(Zt);\n              }, l3.readability = function(ge, Re) {\n                var ce = l3(ge), Ze = l3(Re);\n                return (e3.max(ce.getLuminance(), Ze.getLuminance()) + 0.05) / (e3.min(ce.getLuminance(), Ze.getLuminance()) + 0.05);\n              }, l3.isReadable = function(ge, Re, ce) {\n                var Ze = l3.readability(ge, Re), ut, pt;\n                switch (pt = false, ut = Pe(ce), ut.level + ut.size) {\n                  case "AAsmall":\n                  case "AAAlarge":\n                    pt = Ze >= 4.5;\n                    break;\n                  case "AAlarge":\n                    pt = Ze >= 3;\n                    break;\n                  case "AAAsmall":\n                    pt = Ze >= 7;\n                    break;\n                }\n                return pt;\n              }, l3.mostReadable = function(ge, Re, ce) {\n                var Ze = null, ut = 0, pt, Zt, st, lt;\n                ce = ce || {}, Zt = ce.includeFallbackColors, st = ce.level, lt = ce.size;\n                for (var Gt = 0; Gt < Re.length; Gt++) pt = l3.readability(ge, Re[Gt]), pt > ut && (ut = pt, Ze = l3(Re[Gt]));\n                return l3.isReadable(ge, Ze, { level: st, size: lt }) || !Zt ? Ze : (ce.includeFallbackColors = false, l3.mostReadable(ge, ["#fff", "#000"], ce));\n              };\n              var G2 = l3.names = { aliceblue: "f0f8ff", antiquewhite: "faebd7", aqua: "0ff", aquamarine: "7fffd4", azure: "f0ffff", beige: "f5f5dc", bisque: "ffe4c4", black: "000", blanchedalmond: "ffebcd", blue: "00f", blueviolet: "8a2be2", brown: "a52a2a", burlywood: "deb887", burntsienna: "ea7e5d", cadetblue: "5f9ea0", chartreuse: "7fff00", chocolate: "d2691e", coral: "ff7f50", cornflowerblue: "6495ed", cornsilk: "fff8dc", crimson: "dc143c", cyan: "0ff", darkblue: "00008b", darkcyan: "008b8b", darkgoldenrod: "b8860b", darkgray: "a9a9a9", darkgreen: "006400", darkgrey: "a9a9a9", darkkhaki: "bdb76b", darkmagenta: "8b008b", darkolivegreen: "556b2f", darkorange: "ff8c00", darkorchid: "9932cc", darkred: "8b0000", darksalmon: "e9967a", darkseagreen: "8fbc8f", darkslateblue: "483d8b", darkslategray: "2f4f4f", darkslategrey: "2f4f4f", darkturquoise: "00ced1", darkviolet: "9400d3", deeppink: "ff1493", deepskyblue: "00bfff", dimgray: "696969", dimgrey: "696969", dodgerblue: "1e90ff", firebrick: "b22222", floralwhite: "fffaf0", forestgreen: "228b22", fuchsia: "f0f", gainsboro: "dcdcdc", ghostwhite: "f8f8ff", gold: "ffd700", goldenrod: "daa520", gray: "808080", green: "008000", greenyellow: "adff2f", grey: "808080", honeydew: "f0fff0", hotpink: "ff69b4", indianred: "cd5c5c", indigo: "4b0082", ivory: "fffff0", khaki: "f0e68c", lavender: "e6e6fa", lavenderblush: "fff0f5", lawngreen: "7cfc00", lemonchiffon: "fffacd", lightblue: "add8e6", lightcoral: "f08080", lightcyan: "e0ffff", lightgoldenrodyellow: "fafad2", lightgray: "d3d3d3", lightgreen: "90ee90", lightgrey: "d3d3d3", lightpink: "ffb6c1", lightsalmon: "ffa07a", lightseagreen: "20b2aa", lightskyblue: "87cefa", lightslategray: "789", lightslategrey: "789", lightsteelblue: "b0c4de", lightyellow: "ffffe0", lime: "0f0", limegreen: "32cd32", linen: "faf0e6", magenta: "f0f", maroon: "800000", mediumaquamarine: "66cdaa", mediumblue: "0000cd", mediumorchid: "ba55d3", mediumpurple: "9370db", mediumseagreen: "3cb371", mediumslateblue: "7b68ee", mediumspringgreen: "00fa9a", mediumturquoise: "48d1cc", mediumvioletred: "c71585", midnightblue: "191970", mintcream: "f5fffa", mistyrose: "ffe4e1", moccasin: "ffe4b5", navajowhite: "ffdead", navy: "000080", oldlace: "fdf5e6", olive: "808000", olivedrab: "6b8e23", orange: "ffa500", orangered: "ff4500", orchid: "da70d6", palegoldenrod: "eee8aa", palegreen: "98fb98", paleturquoise: "afeeee", palevioletred: "db7093", papayawhip: "ffefd5", peachpuff: "ffdab9", peru: "cd853f", pink: "ffc0cb", plum: "dda0dd", powderblue: "b0e0e6", purple: "800080", rebeccapurple: "663399", red: "f00", rosybrown: "bc8f8f", royalblue: "4169e1", saddlebrown: "8b4513", salmon: "fa8072", sandybrown: "f4a460", seagreen: "2e8b57", seashell: "fff5ee", sienna: "a0522d", silver: "c0c0c0", skyblue: "87ceeb", slateblue: "6a5acd", slategray: "708090", slategrey: "708090", snow: "fffafa", springgreen: "00ff7f", steelblue: "4682b4", tan: "d2b48c", teal: "008080", thistle: "d8bfd8", tomato: "ff6347", turquoise: "40e0d0", violet: "ee82ee", wheat: "f5deb3", white: "fff", whitesmoke: "f5f5f5", yellow: "ff0", yellowgreen: "9acd32" }, Z = l3.hexNames = j3(G2);\n              function j3(ge) {\n                var Re = {};\n                for (var ce in ge) ge.hasOwnProperty(ce) && (Re[ge[ce]] = ce);\n                return Re;\n              }\n              function N2(ge) {\n                return ge = parseFloat(ge), (isNaN(ge) || ge < 0 || ge > 1) && (ge = 1), ge;\n              }\n              function H(ge, Re) {\n                _e(ge) && (ge = "100%");\n                var ce = Ee(ge);\n                return ge = a4(Re, o4(0, parseFloat(ge))), ce && (ge = parseInt(ge * Re, 10) / 100), e3.abs(ge - Re) < 1e-6 ? 1 : ge % Re / parseFloat(Re);\n              }\n              function te(ge) {\n                return a4(1, o4(0, ge));\n              }\n              function oe(ge) {\n                return parseInt(ge, 16);\n              }\n              function _e(ge) {\n                return typeof ge == "string" && ge.indexOf(".") != -1 && parseFloat(ge) === 1;\n              }\n              function Ee(ge) {\n                return typeof ge == "string" && ge.indexOf("%") != -1;\n              }\n              function Ce(ge) {\n                return ge.length == 1 ? "0" + ge : "" + ge;\n              }\n              function me(ge) {\n                return ge <= 1 && (ge = ge * 100 + "%"), ge;\n              }\n              function ie(ge) {\n                return e3.round(parseFloat(ge) * 255).toString(16);\n              }\n              function Se(ge) {\n                return oe(ge) / 255;\n              }\n              var Le = (function() {\n                var ge = "[-\\\\+]?\\\\d+%?", Re = "[-\\\\+]?\\\\d*\\\\.\\\\d+%?", ce = "(?:" + Re + ")|(?:" + ge + ")", Ze = "[\\\\s|\\\\(]+(" + ce + ")[,|\\\\s]+(" + ce + ")[,|\\\\s]+(" + ce + ")\\\\s*\\\\)?", ut = "[\\\\s|\\\\(]+(" + ce + ")[,|\\\\s]+(" + ce + ")[,|\\\\s]+(" + ce + ")[,|\\\\s]+(" + ce + ")\\\\s*\\\\)?";\n                return { CSS_UNIT: new RegExp(ce), rgb: new RegExp("rgb" + Ze), rgba: new RegExp("rgba" + ut), hsl: new RegExp("hsl" + Ze), hsla: new RegExp("hsla" + ut), hsv: new RegExp("hsv" + Ze), hsva: new RegExp("hsva" + ut), hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/, hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/ };\n              })();\n              function Ae(ge) {\n                return !!Le.CSS_UNIT.exec(ge);\n              }\n              function Fe(ge) {\n                ge = ge.replace(t3, "").replace(r4, "").toLowerCase();\n                var Re = false;\n                if (G2[ge]) ge = G2[ge], Re = true;\n                else if (ge == "transparent") return { r: 0, g: 0, b: 0, a: 0, format: "name" };\n                var ce;\n                return (ce = Le.rgb.exec(ge)) ? { r: ce[1], g: ce[2], b: ce[3] } : (ce = Le.rgba.exec(ge)) ? { r: ce[1], g: ce[2], b: ce[3], a: ce[4] } : (ce = Le.hsl.exec(ge)) ? { h: ce[1], s: ce[2], l: ce[3] } : (ce = Le.hsla.exec(ge)) ? { h: ce[1], s: ce[2], l: ce[3], a: ce[4] } : (ce = Le.hsv.exec(ge)) ? { h: ce[1], s: ce[2], v: ce[3] } : (ce = Le.hsva.exec(ge)) ? { h: ce[1], s: ce[2], v: ce[3], a: ce[4] } : (ce = Le.hex8.exec(ge)) ? { r: oe(ce[1]), g: oe(ce[2]), b: oe(ce[3]), a: Se(ce[4]), format: Re ? "name" : "hex8" } : (ce = Le.hex6.exec(ge)) ? { r: oe(ce[1]), g: oe(ce[2]), b: oe(ce[3]), format: Re ? "name" : "hex" } : (ce = Le.hex4.exec(ge)) ? { r: oe(ce[1] + "" + ce[1]), g: oe(ce[2] + "" + ce[2]), b: oe(ce[3] + "" + ce[3]), a: Se(ce[4] + "" + ce[4]), format: Re ? "name" : "hex8" } : (ce = Le.hex3.exec(ge)) ? { r: oe(ce[1] + "" + ce[1]), g: oe(ce[2] + "" + ce[2]), b: oe(ce[3] + "" + ce[3]), format: Re ? "name" : "hex" } : false;\n              }\n              function Pe(ge) {\n                var Re, ce;\n                return ge = ge || { level: "AA", size: "small" }, Re = (ge.level || "AA").toUpperCase(), ce = (ge.size || "small").toLowerCase(), Re !== "AA" && Re !== "AAA" && (Re = "AA"), ce !== "small" && ce !== "large" && (ce = "small"), { level: Re, size: ce };\n              }\n              typeof y6 != "undefined" && y6.exports ? y6.exports = l3 : window.tinycolor = l3;\n            })(Math);\n          });\n          var Ao = ye((FS) => {\n            "use strict";\n            var Vee = my(), RS = Array.isArray;\n            function Ftt(e3, t3) {\n              var r4, n4;\n              for (r4 = 0; r4 < e3.length; r4++) {\n                if (n4 = e3[r4], n4 !== null && typeof n4 == "object") return false;\n                n4 !== void 0 && (t3[r4] = n4);\n              }\n              return true;\n            }\n            FS.extendFlat = function() {\n              return DS(arguments, false, false, false);\n            };\n            FS.extendDeep = function() {\n              return DS(arguments, true, false, false);\n            };\n            FS.extendDeepAll = function() {\n              return DS(arguments, true, true, false);\n            };\n            FS.extendDeepNoArrays = function() {\n              return DS(arguments, true, false, true);\n            };\n            function DS(e3, t3, r4, n4) {\n              var i3 = e3[0], a4 = e3.length, o4, s3, l3, u4, c5, f4, h3;\n              if (a4 === 2 && RS(i3) && RS(e3[1]) && i3.length === 0) {\n                if (h3 = Ftt(e3[1], i3), h3) return i3;\n                i3.splice(0, i3.length);\n              }\n              for (var d3 = 1; d3 < a4; d3++) {\n                o4 = e3[d3];\n                for (s3 in o4) l3 = i3[s3], u4 = o4[s3], n4 && RS(u4) ? i3[s3] = u4 : t3 && u4 && (Vee(u4) || (c5 = RS(u4))) ? (c5 ? (c5 = false, f4 = l3 && RS(l3) ? l3 : []) : f4 = l3 && Vee(l3) ? l3 : {}, i3[s3] = DS([f4, u4], t3, r4, n4)) : (typeof u4 != "undefined" || r4) && (i3[s3] = u4);\n              }\n              return i3;\n            }\n          });\n          var ec = ye((_rr, Gee) => {\n            "use strict";\n            Gee.exports = function(e3) {\n              var t3 = e3.variantValues, r4 = e3.editType, n4 = e3.colorEditType;\n              n4 === void 0 && (n4 = r4);\n              var i3 = { editType: r4, valType: "integer", min: 1, max: 1e3, extras: ["normal", "bold"], dflt: "normal" };\n              e3.noNumericWeightValues && (i3.valType = "enumerated", i3.values = i3.extras, i3.extras = void 0, i3.min = void 0, i3.max = void 0);\n              var a4 = { family: { valType: "string", noBlank: true, strict: true, editType: r4 }, size: { valType: "number", min: 1, editType: r4 }, color: { valType: "color", editType: n4 }, weight: i3, style: { editType: r4, valType: "enumerated", values: ["normal", "italic"], dflt: "normal" }, variant: e3.noFontVariant ? void 0 : { editType: r4, valType: "enumerated", values: t3 || ["normal", "small-caps", "all-small-caps", "all-petite-caps", "petite-caps", "unicase"], dflt: "normal" }, textcase: e3.noFontTextcase ? void 0 : { editType: r4, valType: "enumerated", values: ["normal", "word caps", "upper", "lower"], dflt: "normal" }, lineposition: e3.noFontLineposition ? void 0 : { editType: r4, valType: "flaglist", flags: ["under", "over", "through"], extras: ["none"], dflt: "none" }, shadow: e3.noFontShadow ? void 0 : { editType: r4, valType: "string", dflt: e3.autoShadowDflt ? "auto" : "none" }, editType: r4 };\n              return e3.autoSize && (a4.size.dflt = "auto"), e3.autoColor && (a4.color.dflt = "auto"), e3.arrayOk && (a4.family.arrayOk = true, a4.weight.arrayOk = true, a4.style.arrayOk = true, e3.noFontVariant || (a4.variant.arrayOk = true), e3.noFontTextcase || (a4.textcase.arrayOk = true), e3.noFontLineposition || (a4.lineposition.arrayOk = true), e3.noFontShadow || (a4.shadow.arrayOk = true), a4.size.arrayOk = true, a4.color.arrayOk = true), a4;\n            };\n          });\n          var zS = ye((xrr, Hee) => {\n            "use strict";\n            Hee.exports = { YANGLE: 60, HOVERARROWSIZE: 6, HOVERTEXTPAD: 3, HOVERFONTSIZE: 13, HOVERFONT: "Arial, sans-serif", HOVERMINTIME: 50, HOVERID: "-hover" };\n          });\n          var B1 = ye((brr, Xee) => {\n            "use strict";\n            var jee = zS(), Wee = ec(), kO = Wee({ editType: "none" });\n            kO.family.dflt = jee.HOVERFONT;\n            kO.size.dflt = jee.HOVERFONTSIZE;\n            Xee.exports = { clickmode: { valType: "flaglist", flags: ["event", "select"], dflt: "event", editType: "plot", extras: ["none"] }, dragmode: { valType: "enumerated", values: ["zoom", "pan", "select", "lasso", "drawclosedpath", "drawopenpath", "drawline", "drawrect", "drawcircle", "orbit", "turntable", false], dflt: "zoom", editType: "modebar" }, hovermode: { valType: "enumerated", values: ["x", "y", "closest", false, "x unified", "y unified"], dflt: "closest", editType: "modebar" }, hoversubplots: { valType: "enumerated", values: ["single", "overlaying", "axis"], dflt: "overlaying", editType: "none" }, hoverdistance: { valType: "integer", min: -1, dflt: 20, editType: "none" }, spikedistance: { valType: "integer", min: -1, dflt: -1, editType: "none" }, hoverlabel: { bgcolor: { valType: "color", editType: "none" }, bordercolor: { valType: "color", editType: "none" }, font: kO, grouptitlefont: Wee({ editType: "none" }), align: { valType: "enumerated", values: ["left", "right", "auto"], dflt: "auto", editType: "none" }, namelength: { valType: "integer", min: -1, dflt: 15, editType: "none" }, showarrow: { valType: "boolean", dflt: true, editType: "none" }, editType: "none" }, selectdirection: { valType: "enumerated", values: ["h", "v", "d", "any"], dflt: "any", editType: "none" } };\n          });\n          var a3 = ye((wrr, Zee) => {\n            "use strict";\n            var ztt = ec(), OS = B1().hoverlabel, qS = Ao().extendFlat;\n            Zee.exports = { hoverlabel: { bgcolor: qS({}, OS.bgcolor, { arrayOk: true }), bordercolor: qS({}, OS.bordercolor, { arrayOk: true }), font: ztt({ arrayOk: true, editType: "none" }), align: qS({}, OS.align, { arrayOk: true }), namelength: qS({}, OS.namelength, { arrayOk: true }), showarrow: qS({}, OS.showarrow), editType: "none" } };\n          });\n          var Gl = ye((Trr, Yee) => {\n            "use strict";\n            var Ott = ec(), qtt = a3();\n            Yee.exports = { type: { valType: "enumerated", values: [], dflt: "scatter", editType: "calc+clearAxisTypes", _noTemplating: true }, visible: { valType: "enumerated", values: [true, false, "legendonly"], dflt: true, editType: "calc" }, showlegend: { valType: "boolean", dflt: true, editType: "style" }, legend: { valType: "subplotid", dflt: "legend", editType: "style" }, legendgroup: { valType: "string", dflt: "", editType: "style" }, legendgrouptitle: { text: { valType: "string", dflt: "", editType: "style" }, font: Ott({ editType: "style" }), editType: "style" }, legendrank: { valType: "number", dflt: 1e3, editType: "style" }, legendwidth: { valType: "number", min: 0, editType: "style" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "style" }, name: { valType: "string", editType: "style" }, uid: { valType: "string", editType: "plot", anim: true }, ids: { valType: "data_array", editType: "calc", anim: true }, customdata: { valType: "data_array", editType: "calc" }, meta: { valType: "any", arrayOk: true, editType: "plot" }, selectedpoints: { valType: "any", editType: "calc" }, hoverinfo: { valType: "flaglist", flags: ["x", "y", "z", "text", "name"], extras: ["all", "none", "skip"], arrayOk: true, dflt: "all", editType: "none" }, hoverlabel: qtt.hoverlabel, stream: { token: { valType: "string", noBlank: true, strict: true, editType: "calc" }, maxpoints: { valType: "number", min: 0, max: 1e4, dflt: 500, editType: "calc" }, editType: "calc" }, uirevision: { valType: "any", editType: "none" } };\n          });\n          var lb = ye((Arr, $ee) => {\n            "use strict";\n            var Btt = cd(), _6 = { Greys: [[0, "rgb(0,0,0)"], [1, "rgb(255,255,255)"]], YlGnBu: [[0, "rgb(8,29,88)"], [0.125, "rgb(37,52,148)"], [0.25, "rgb(34,94,168)"], [0.375, "rgb(29,145,192)"], [0.5, "rgb(65,182,196)"], [0.625, "rgb(127,205,187)"], [0.75, "rgb(199,233,180)"], [0.875, "rgb(237,248,217)"], [1, "rgb(255,255,217)"]], Greens: [[0, "rgb(0,68,27)"], [0.125, "rgb(0,109,44)"], [0.25, "rgb(35,139,69)"], [0.375, "rgb(65,171,93)"], [0.5, "rgb(116,196,118)"], [0.625, "rgb(161,217,155)"], [0.75, "rgb(199,233,192)"], [0.875, "rgb(229,245,224)"], [1, "rgb(247,252,245)"]], YlOrRd: [[0, "rgb(128,0,38)"], [0.125, "rgb(189,0,38)"], [0.25, "rgb(227,26,28)"], [0.375, "rgb(252,78,42)"], [0.5, "rgb(253,141,60)"], [0.625, "rgb(254,178,76)"], [0.75, "rgb(254,217,118)"], [0.875, "rgb(255,237,160)"], [1, "rgb(255,255,204)"]], Bluered: [[0, "rgb(0,0,255)"], [1, "rgb(255,0,0)"]], RdBu: [[0, "rgb(5,10,172)"], [0.35, "rgb(106,137,247)"], [0.5, "rgb(190,190,190)"], [0.6, "rgb(220,170,132)"], [0.7, "rgb(230,145,90)"], [1, "rgb(178,10,28)"]], Reds: [[0, "rgb(220,220,220)"], [0.2, "rgb(245,195,157)"], [0.4, "rgb(245,160,105)"], [1, "rgb(178,10,28)"]], Blues: [[0, "rgb(5,10,172)"], [0.35, "rgb(40,60,190)"], [0.5, "rgb(70,100,245)"], [0.6, "rgb(90,120,245)"], [0.7, "rgb(106,137,247)"], [1, "rgb(220,220,220)"]], Picnic: [[0, "rgb(0,0,255)"], [0.1, "rgb(51,153,255)"], [0.2, "rgb(102,204,255)"], [0.3, "rgb(153,204,255)"], [0.4, "rgb(204,204,255)"], [0.5, "rgb(255,255,255)"], [0.6, "rgb(255,204,255)"], [0.7, "rgb(255,153,255)"], [0.8, "rgb(255,102,204)"], [0.9, "rgb(255,102,102)"], [1, "rgb(255,0,0)"]], Rainbow: [[0, "rgb(150,0,90)"], [0.125, "rgb(0,0,200)"], [0.25, "rgb(0,25,255)"], [0.375, "rgb(0,152,255)"], [0.5, "rgb(44,255,150)"], [0.625, "rgb(151,255,0)"], [0.75, "rgb(255,234,0)"], [0.875, "rgb(255,111,0)"], [1, "rgb(255,0,0)"]], Portland: [[0, "rgb(12,51,131)"], [0.25, "rgb(10,136,186)"], [0.5, "rgb(242,211,56)"], [0.75, "rgb(242,143,56)"], [1, "rgb(217,30,30)"]], Jet: [[0, "rgb(0,0,131)"], [0.125, "rgb(0,60,170)"], [0.375, "rgb(5,255,255)"], [0.625, "rgb(255,255,0)"], [0.875, "rgb(250,0,0)"], [1, "rgb(128,0,0)"]], Hot: [[0, "rgb(0,0,0)"], [0.3, "rgb(230,0,0)"], [0.6, "rgb(255,210,0)"], [1, "rgb(255,255,255)"]], Blackbody: [[0, "rgb(0,0,0)"], [0.2, "rgb(230,0,0)"], [0.4, "rgb(230,210,0)"], [0.7, "rgb(255,255,255)"], [1, "rgb(160,200,255)"]], Earth: [[0, "rgb(0,0,130)"], [0.1, "rgb(0,180,180)"], [0.2, "rgb(40,210,40)"], [0.4, "rgb(230,230,50)"], [0.6, "rgb(120,70,20)"], [1, "rgb(255,255,255)"]], Electric: [[0, "rgb(0,0,0)"], [0.15, "rgb(30,0,100)"], [0.4, "rgb(120,0,100)"], [0.6, "rgb(160,90,0)"], [0.8, "rgb(230,200,0)"], [1, "rgb(255,250,220)"]], Viridis: [[0, "#440154"], [0.06274509803921569, "#48186a"], [0.12549019607843137, "#472d7b"], [0.18823529411764706, "#424086"], [0.25098039215686274, "#3b528b"], [0.3137254901960784, "#33638d"], [0.3764705882352941, "#2c728e"], [0.4392156862745098, "#26828e"], [0.5019607843137255, "#21918c"], [0.5647058823529412, "#1fa088"], [0.6274509803921569, "#28ae80"], [0.6901960784313725, "#3fbc73"], [0.7529411764705882, "#5ec962"], [0.8156862745098039, "#84d44b"], [0.8784313725490196, "#addc30"], [0.9411764705882353, "#d8e219"], [1, "#fde725"]], Cividis: [[0, "rgb(0,32,76)"], [0.058824, "rgb(0,42,102)"], [0.117647, "rgb(0,52,110)"], [0.176471, "rgb(39,63,108)"], [0.235294, "rgb(60,74,107)"], [0.294118, "rgb(76,85,107)"], [0.352941, "rgb(91,95,109)"], [0.411765, "rgb(104,106,112)"], [0.470588, "rgb(117,117,117)"], [0.529412, "rgb(131,129,120)"], [0.588235, "rgb(146,140,120)"], [0.647059, "rgb(161,152,118)"], [0.705882, "rgb(176,165,114)"], [0.764706, "rgb(192,177,109)"], [0.823529, "rgb(209,191,102)"], [0.882353, "rgb(225,204,92)"], [0.941176, "rgb(243,219,79)"], [1, "rgb(255,233,69)"]] }, Kee = _6.RdBu;\n            function Ntt(e3, t3) {\n              if (t3 || (t3 = Kee), !e3) return t3;\n              function r4() {\n                try {\n                  e3 = _6[e3] || JSON.parse(e3);\n                } catch (n4) {\n                  e3 = t3;\n                }\n              }\n              return typeof e3 == "string" && (r4(), typeof e3 == "string" && r4()), Jee(e3) ? e3 : t3;\n            }\n            function Jee(e3) {\n              var t3 = 0;\n              if (!Array.isArray(e3) || e3.length < 2 || !e3[0] || !e3[e3.length - 1] || +e3[0][0] != 0 || +e3[e3.length - 1][0] != 1) return false;\n              for (var r4 = 0; r4 < e3.length; r4++) {\n                var n4 = e3[r4];\n                if (n4.length !== 2 || +n4[0] < t3 || !Btt(n4[1]).isValid()) return false;\n                t3 = +n4[0];\n              }\n              return true;\n            }\n            function Utt(e3) {\n              return _6[e3] !== void 0 ? true : Jee(e3);\n            }\n            $ee.exports = { scales: _6, defaultScale: Kee, get: Ntt, isValid: Utt };\n          });\n          var Lh = ye((ub) => {\n            "use strict";\n            ub.defaults = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"];\n            ub.defaultLine = "#444";\n            ub.lightLine = "#eee";\n            ub.background = "#fff";\n            ub.borderLine = "#BEC8D9";\n            ub.lightFraction = 100 * 10 / 11;\n          });\n          var ka = ye((Mrr, Qee) => {\n            "use strict";\n            var bp = cd(), Vtt = Eo(), Gtt = vv().isTypedArray, fd = Qee.exports = {}, x6 = Lh();\n            fd.defaults = x6.defaults;\n            var Htt = fd.defaultLine = x6.defaultLine;\n            fd.lightLine = x6.lightLine;\n            var LO = fd.background = x6.background;\n            fd.tinyRGB = function(e3) {\n              var t3 = e3.toRgb();\n              return "rgb(" + Math.round(t3.r) + ", " + Math.round(t3.g) + ", " + Math.round(t3.b) + ")";\n            };\n            fd.rgb = function(e3) {\n              return fd.tinyRGB(bp(e3));\n            };\n            fd.opacity = function(e3) {\n              return e3 ? bp(e3).getAlpha() : 0;\n            };\n            fd.addOpacity = function(e3, t3) {\n              var r4 = bp(e3).toRgb();\n              return "rgba(" + Math.round(r4.r) + ", " + Math.round(r4.g) + ", " + Math.round(r4.b) + ", " + t3 + ")";\n            };\n            fd.combine = function(e3, t3) {\n              var r4 = bp(e3).toRgb();\n              if (r4.a === 1) return bp(e3).toRgbString();\n              var n4 = bp(t3 || LO).toRgb(), i3 = n4.a === 1 ? n4 : { r: 255 * (1 - n4.a) + n4.r * n4.a, g: 255 * (1 - n4.a) + n4.g * n4.a, b: 255 * (1 - n4.a) + n4.b * n4.a }, a4 = { r: i3.r * (1 - r4.a) + r4.r * r4.a, g: i3.g * (1 - r4.a) + r4.g * r4.a, b: i3.b * (1 - r4.a) + r4.b * r4.a };\n              return bp(a4).toRgbString();\n            };\n            fd.interpolate = function(e3, t3, r4) {\n              var n4 = bp(e3).toRgb(), i3 = bp(t3).toRgb(), a4 = { r: r4 * n4.r + (1 - r4) * i3.r, g: r4 * n4.g + (1 - r4) * i3.g, b: r4 * n4.b + (1 - r4) * i3.b };\n              return bp(a4).toRgbString();\n            };\n            fd.contrast = function(e3, t3, r4) {\n              var n4 = bp(e3);\n              n4.getAlpha() !== 1 && (n4 = bp(fd.combine(e3, LO)));\n              var i3 = n4.isDark() ? t3 ? n4.lighten(t3) : LO : r4 ? n4.darken(r4) : Htt;\n              return i3.toString();\n            };\n            fd.stroke = function(e3, t3) {\n              var r4 = bp(t3);\n              e3.style({ stroke: fd.tinyRGB(r4), "stroke-opacity": r4.getAlpha() });\n            };\n            fd.fill = function(e3, t3) {\n              var r4 = bp(t3);\n              e3.style({ fill: fd.tinyRGB(r4), "fill-opacity": r4.getAlpha() });\n            };\n            fd.clean = function(e3) {\n              if (!(!e3 || typeof e3 != "object")) {\n                var t3 = Object.keys(e3), r4, n4, i3, a4;\n                for (r4 = 0; r4 < t3.length; r4++) if (i3 = t3[r4], a4 = e3[i3], i3.slice(-5) === "color") if (Array.isArray(a4)) for (n4 = 0; n4 < a4.length; n4++) a4[n4] = CO(a4[n4]);\n                else e3[i3] = CO(a4);\n                else if (i3.slice(-10) === "colorscale" && Array.isArray(a4)) for (n4 = 0; n4 < a4.length; n4++) Array.isArray(a4[n4]) && (a4[n4][1] = CO(a4[n4][1]));\n                else if (Array.isArray(a4)) {\n                  var o4 = a4[0];\n                  if (!Array.isArray(o4) && o4 && typeof o4 == "object") for (n4 = 0; n4 < a4.length; n4++) fd.clean(a4[n4]);\n                } else a4 && typeof a4 == "object" && !Gtt(a4) && fd.clean(a4);\n              }\n            };\n            function CO(e3) {\n              if (Vtt(e3) || typeof e3 != "string") return e3;\n              var t3 = e3.trim();\n              if (t3.slice(0, 3) !== "rgb") return e3;\n              var r4 = t3.match(/^rgba?\\s*\\(([^()]*)\\)$/);\n              if (!r4) return e3;\n              var n4 = r4[1].trim().split(/\\s*[\\s,]\\s*/), i3 = t3.charAt(3) === "a" && n4.length === 4;\n              if (!i3 && n4.length !== 3) return e3;\n              for (var a4 = 0; a4 < n4.length; a4++) {\n                if (!n4[a4].length || (n4[a4] = Number(n4[a4]), !(n4[a4] >= 0))) return e3;\n                if (a4 === 3) n4[a4] > 1 && (n4[a4] = 1);\n                else if (n4[a4] >= 1) return e3;\n              }\n              var o4 = Math.round(n4[0] * 255) + ", " + Math.round(n4[1] * 255) + ", " + Math.round(n4[2] * 255);\n              return i3 ? "rgba(" + o4 + ", " + n4[3] + ")" : "rgb(" + o4 + ")";\n            }\n          });\n          var N1 = ye((Err, ete) => {\n            "use strict";\n            ete.exports = { SHOW_PLACEHOLDER: 100, HIDE_PLACEHOLDER: 1e3, DESELECTDIM: 0.2 };\n          });\n          var o3 = ye((tte) => {\n            "use strict";\n            tte.counter = function(e3, t3, r4, n4) {\n              var i3 = (t3 || "") + (r4 ? "" : "$"), a4 = n4 === false ? "" : "^";\n              return e3 === "xy" ? new RegExp(a4 + "x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?" + i3) : new RegExp(a4 + e3 + "([2-9]|[1-9][0-9]+)?" + i3);\n            };\n          });\n          var ate = ye((wp) => {\n            "use strict";\n            var PO = Eo(), rte = cd(), ite = Ao().extendFlat, jtt = Gl(), Wtt = lb(), Xtt = ka(), Ztt = N1().DESELECTDIM, s3 = PS(), nte = o3().counter, Ytt = n3().modHalf, _g = vv().isArrayOrTypedArray, U1 = vv().isTypedArraySpec, V1 = vv().decodeTypedArraySpec;\n            wp.valObjectMeta = { data_array: { coerceFunction: function(e3, t3, r4) {\n              t3.set(_g(e3) ? e3 : U1(e3) ? V1(e3) : r4);\n            } }, enumerated: { coerceFunction: function(e3, t3, r4, n4) {\n              n4.coerceNumber && (e3 = +e3), n4.values.indexOf(e3) === -1 ? t3.set(r4) : t3.set(e3);\n            }, validateFunction: function(e3, t3) {\n              t3.coerceNumber && (e3 = +e3);\n              for (var r4 = t3.values, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = String(r4[n4]);\n                if (i3.charAt(0) === "/" && i3.charAt(i3.length - 1) === "/") {\n                  var a4 = new RegExp(i3.slice(1, -1));\n                  if (a4.test(e3)) return true;\n                } else if (e3 === r4[n4]) return true;\n              }\n              return false;\n            } }, boolean: { coerceFunction: function(e3, t3, r4, n4) {\n              let i3 = (a4) => a4 === true || a4 === false;\n              i3(e3) || n4.arrayOk && Array.isArray(e3) && e3.length > 0 && e3.every(i3) ? t3.set(e3) : t3.set(r4);\n            } }, number: { coerceFunction: function(e3, t3, r4, n4) {\n              U1(e3) && (e3 = V1(e3)), !PO(e3) || n4.min !== void 0 && e3 < n4.min || n4.max !== void 0 && e3 > n4.max ? t3.set(r4) : t3.set(+e3);\n            } }, integer: { coerceFunction: function(e3, t3, r4, n4) {\n              if ((n4.extras || []).indexOf(e3) !== -1) {\n                t3.set(e3);\n                return;\n              }\n              U1(e3) && (e3 = V1(e3)), e3 % 1 || !PO(e3) || n4.min !== void 0 && e3 < n4.min || n4.max !== void 0 && e3 > n4.max ? t3.set(r4) : t3.set(+e3);\n            } }, string: { coerceFunction: function(e3, t3, r4, n4) {\n              if (typeof e3 != "string") {\n                var i3 = typeof e3 == "number";\n                n4.strict === true || !i3 ? t3.set(r4) : t3.set(String(e3));\n              } else n4.noBlank && !e3 ? t3.set(r4) : t3.set(e3);\n            } }, color: { coerceFunction: function(e3, t3, r4) {\n              U1(e3) && (e3 = V1(e3)), rte(e3).isValid() ? t3.set(e3) : t3.set(r4);\n            } }, colorlist: { coerceFunction: function(e3, t3, r4) {\n              function n4(i3) {\n                return rte(i3).isValid();\n              }\n              !Array.isArray(e3) || !e3.length ? t3.set(r4) : e3.every(n4) ? t3.set(e3) : t3.set(r4);\n            } }, colorscale: { coerceFunction: function(e3, t3, r4) {\n              t3.set(Wtt.get(e3, r4));\n            } }, angle: { coerceFunction: function(e3, t3, r4) {\n              U1(e3) && (e3 = V1(e3)), e3 === "auto" ? t3.set("auto") : PO(e3) ? t3.set(Ytt(+e3, 360)) : t3.set(r4);\n            } }, subplotid: { coerceFunction: function(e3, t3, r4, n4) {\n              var i3 = n4.regex || nte(r4);\n              let a4 = (o4) => typeof o4 == "string" && i3.test(o4);\n              a4(e3) || n4.arrayOk && _g(e3) && e3.length > 0 && e3.every(a4) ? t3.set(e3) : t3.set(r4);\n            }, validateFunction: function(e3, t3) {\n              var r4 = t3.dflt;\n              return e3 === r4 ? true : typeof e3 != "string" ? false : !!nte(r4).test(e3);\n            } }, flaglist: { coerceFunction: function(e3, t3, r4, n4) {\n              if ((n4.extras || []).indexOf(e3) !== -1) {\n                t3.set(e3);\n                return;\n              }\n              if (typeof e3 != "string") {\n                t3.set(r4);\n                return;\n              }\n              for (var i3 = e3.split("+"), a4 = 0; a4 < i3.length; ) {\n                var o4 = i3[a4];\n                n4.flags.indexOf(o4) === -1 || i3.indexOf(o4) < a4 ? i3.splice(a4, 1) : a4++;\n              }\n              i3.length ? t3.set(i3.join("+")) : t3.set(r4);\n            } }, any: { coerceFunction: function(e3, t3, r4) {\n              e3 === void 0 ? t3.set(r4) : t3.set(U1(e3) ? V1(e3) : e3);\n            } }, info_array: { coerceFunction: function(e3, t3, r4, n4) {\n              function i3(k4, E3, S2) {\n                var L3, x2 = { set: function(C3) {\n                  L3 = C3;\n                } };\n                return S2 === void 0 && (S2 = E3.dflt), wp.valObjectMeta[E3.valType].coerceFunction(k4, x2, S2, E3), L3;\n              }\n              if (U1(e3) && (e3 = V1(e3)), !_g(e3)) {\n                t3.set(r4);\n                return;\n              }\n              var a4 = n4.dimensions === 2 || n4.dimensions === "1-2" && Array.isArray(e3) && _g(e3[0]), o4 = n4.items, s4 = [], l3 = Array.isArray(o4), u4 = l3 && a4 && _g(o4[0]), c5 = a4 && l3 && !u4, f4 = l3 && !c5 ? o4.length : e3.length, h3, d3, v3, _2, b, p3;\n              if (r4 = Array.isArray(r4) ? r4 : [], a4) for (h3 = 0; h3 < f4; h3++) for (s4[h3] = [], v3 = _g(e3[h3]) ? e3[h3] : [], c5 ? b = o4.length : l3 ? b = o4[h3].length : b = v3.length, d3 = 0; d3 < b; d3++) c5 ? _2 = o4[d3] : l3 ? _2 = o4[h3][d3] : _2 = o4, p3 = i3(v3[d3], _2, (r4[h3] || [])[d3]), p3 !== void 0 && (s4[h3][d3] = p3);\n              else for (h3 = 0; h3 < f4; h3++) p3 = i3(e3[h3], l3 ? o4[h3] : o4, r4[h3]), p3 !== void 0 && (s4[h3] = p3);\n              t3.set(s4);\n            }, validateFunction: function(e3, t3) {\n              if (!_g(e3)) return false;\n              var r4 = t3.items, n4 = Array.isArray(r4), i3 = t3.dimensions === 2;\n              if (!t3.freeLength && e3.length !== r4.length) return false;\n              for (var a4 = 0; a4 < e3.length; a4++) if (i3) {\n                if (!_g(e3[a4]) || !t3.freeLength && e3[a4].length !== r4[a4].length) return false;\n                for (var o4 = 0; o4 < e3[a4].length; o4++) if (!b6(e3[a4][o4], n4 ? r4[a4][o4] : r4)) return false;\n              } else if (!b6(e3[a4], n4 ? r4[a4] : r4)) return false;\n              return true;\n            } } };\n            wp.coerce = function(e3, t3, r4, n4, i3) {\n              var a4 = s3(r4, n4).get(), o4 = s3(e3, n4), s4 = s3(t3, n4), l3 = o4.get(), u4 = t3._template;\n              if (l3 === void 0 && u4 && (l3 = s3(u4, n4).get(), u4 = 0), i3 === void 0 && (i3 = a4.dflt), a4.arrayOk) {\n                if (_g(l3)) return s4.set(l3), l3;\n                if (U1(l3)) return l3 = V1(l3), s4.set(l3), l3;\n              }\n              var c5 = wp.valObjectMeta[a4.valType].coerceFunction;\n              c5(l3, s4, i3, a4);\n              var f4 = s4.get();\n              return u4 && f4 === i3 && !b6(l3, a4) && (l3 = s3(u4, n4).get(), c5(l3, s4, i3, a4), f4 = s4.get()), f4;\n            };\n            wp.coerce2 = function(e3, t3, r4, n4, i3) {\n              var a4 = s3(e3, n4), o4 = wp.coerce(e3, t3, r4, n4, i3), s4 = a4.get();\n              return s4 != null ? o4 : false;\n            };\n            wp.coerceFont = function(e3, t3, r4, n4) {\n              n4 || (n4 = {}), r4 = ite({}, r4), r4 = ite(r4, n4.overrideDflt || {});\n              var i3 = { family: e3(t3 + ".family", r4.family), size: e3(t3 + ".size", r4.size), color: e3(t3 + ".color", r4.color), weight: e3(t3 + ".weight", r4.weight), style: e3(t3 + ".style", r4.style) };\n              if (n4.noFontVariant || (i3.variant = e3(t3 + ".variant", r4.variant)), n4.noFontLineposition || (i3.lineposition = e3(t3 + ".lineposition", r4.lineposition)), n4.noFontTextcase || (i3.textcase = e3(t3 + ".textcase", r4.textcase)), !n4.noFontShadow) {\n                var a4 = r4.shadow;\n                a4 === "none" && n4.autoShadowDflt && (a4 = "auto"), i3.shadow = e3(t3 + ".shadow", a4);\n              }\n              return i3;\n            };\n            wp.coercePattern = function(e3, t3, r4, n4) {\n              var i3 = e3(t3 + ".shape"), a4;\n              if (i3 || (a4 = e3(t3 + ".path")), i3 || a4) {\n                i3 && e3(t3 + ".solidity"), e3(t3 + ".size");\n                var o4 = e3(t3 + ".fillmode"), s4 = o4 === "overlay";\n                if (!n4) {\n                  var l3 = e3(t3 + ".bgcolor", s4 ? r4 : void 0);\n                  e3(t3 + ".fgcolor", s4 ? Xtt.contrast(l3) : r4);\n                }\n                e3(t3 + ".fgopacity", s4 ? 0.5 : 1);\n              }\n            };\n            wp.coerceHoverinfo = function(e3, t3, r4) {\n              var n4 = t3._module.attributes, i3 = n4.hoverinfo ? n4 : jtt, a4 = i3.hoverinfo, o4;\n              if (r4._dataLength === 1) {\n                var s4 = a4.dflt === "all" ? a4.flags.slice() : a4.dflt.split("+");\n                s4.splice(s4.indexOf("name"), 1), o4 = s4.join("+");\n              }\n              return wp.coerce(e3, t3, i3, "hoverinfo", o4);\n            };\n            wp.coerceSelectionMarkerOpacity = function(e3, t3) {\n              if (e3.marker) {\n                var r4 = e3.marker.opacity;\n                if (r4 !== void 0) {\n                  var n4, i3;\n                  !_g(r4) && !e3.selected && !e3.unselected && (n4 = r4, i3 = Ztt * r4), t3("selected.marker.opacity", n4), t3("unselected.marker.opacity", i3);\n                }\n              }\n            };\n            function b6(e3, t3) {\n              var r4 = wp.valObjectMeta[t3.valType];\n              if (t3.arrayOk && _g(e3)) return true;\n              if (r4.validateFunction) return r4.validateFunction(e3, t3);\n              var n4 = {}, i3 = n4, a4 = { set: function(o4) {\n                i3 = o4;\n              } };\n              return r4.coerceFunction(e3, a4, n4, t3), i3 !== n4;\n            }\n            wp.validate = b6;\n          });\n          var cb = ye((Lrr, ute) => {\n            "use strict";\n            var ote = { staticPlot: { valType: "boolean", dflt: false }, typesetMath: { valType: "boolean", dflt: true }, plotlyServerURL: { valType: "string", dflt: "" }, editable: { valType: "boolean", dflt: false }, edits: { annotationPosition: { valType: "boolean", dflt: false }, annotationTail: { valType: "boolean", dflt: false }, annotationText: { valType: "boolean", dflt: false }, axisTitleText: { valType: "boolean", dflt: false }, colorbarPosition: { valType: "boolean", dflt: false }, colorbarTitleText: { valType: "boolean", dflt: false }, legendPosition: { valType: "boolean", dflt: false }, legendText: { valType: "boolean", dflt: false }, shapePosition: { valType: "boolean", dflt: false }, titleText: { valType: "boolean", dflt: false } }, editSelection: { valType: "boolean", dflt: true }, autosizable: { valType: "boolean", dflt: false }, responsive: { valType: "boolean", dflt: false }, fillFrame: { valType: "boolean", dflt: false }, frameMargins: { valType: "number", dflt: 0, min: 0, max: 0.5 }, scrollZoom: { valType: "flaglist", flags: ["cartesian", "gl3d", "geo", "mapbox", "map"], extras: [true, false], dflt: "gl3d+geo+map" }, doubleClick: { valType: "enumerated", values: [false, "reset", "autosize", "reset+autosize"], dflt: "reset+autosize" }, doubleClickDelay: { valType: "number", dflt: 300, min: 0 }, showAxisDragHandles: { valType: "boolean", dflt: true }, showAxisRangeEntryBoxes: { valType: "boolean", dflt: true }, showTips: { valType: "boolean", dflt: true }, showLink: { valType: "boolean", dflt: false }, linkText: { valType: "string", dflt: "Edit chart", noBlank: true }, sendData: { valType: "boolean", dflt: true }, showSources: { valType: "any", dflt: false }, displayModeBar: { valType: "enumerated", values: ["hover", true, false], dflt: "hover" }, showSendToCloud: { valType: "boolean", dflt: false }, showEditInChartStudio: { valType: "boolean", dflt: false }, modeBarButtonsToRemove: { valType: "any", dflt: [] }, modeBarButtonsToAdd: { valType: "any", dflt: [] }, modeBarButtons: { valType: "any", dflt: false }, toImageButtonOptions: { valType: "any", dflt: {} }, displaylogo: { valType: "boolean", dflt: true }, watermark: { valType: "boolean", dflt: false }, plotGlPixelRatio: { valType: "number", dflt: 2, min: 1, max: 4 }, setBackground: { valType: "any", dflt: "transparent" }, topojsonURL: { valType: "string", noBlank: true, dflt: "https://cdn.plot.ly/un/" }, mapboxAccessToken: { valType: "string", dflt: null }, logging: { valType: "integer", min: 0, max: 2, dflt: 1 }, notifyOnLogging: { valType: "integer", min: 0, max: 2, dflt: 0 }, queueLength: { valType: "integer", min: 0, dflt: 0 }, locale: { valType: "string", dflt: "en-US" }, locales: { valType: "any", dflt: {} } }, ste = {};\n            function lte(e3, t3) {\n              for (var r4 in e3) {\n                var n4 = e3[r4];\n                n4.valType ? t3[r4] = n4.dflt : (t3[r4] || (t3[r4] = {}), lte(n4, t3[r4]));\n              }\n            }\n            lte(ote, ste);\n            ute.exports = { configAttributes: ote, dfltConfig: ste };\n          });\n          var RO = ye((Prr, cte) => {\n            "use strict";\n            var IO = Oa(), Ktt = Eo(), BS = [];\n            cte.exports = function(e3, t3) {\n              if (BS.indexOf(e3) !== -1) return;\n              BS.push(e3);\n              var r4 = 1e3;\n              Ktt(t3) ? r4 = t3 : t3 === "long" && (r4 = 3e3);\n              var n4 = IO.select("body").selectAll(".plotly-notifier").data([0]);\n              n4.enter().append("div").classed("plotly-notifier", true);\n              var i3 = n4.selectAll(".notifier-note").data(BS);\n              function a4(o4) {\n                o4.duration(700).style("opacity", 0).each("end", function(s3) {\n                  var l3 = BS.indexOf(s3);\n                  l3 !== -1 && BS.splice(l3, 1), IO.select(this).remove();\n                });\n              }\n              i3.enter().append("div").classed("notifier-note", true).style("opacity", 0).each(function(o4) {\n                var s3 = IO.select(this);\n                s3.append("button").classed("notifier-close", true).html("&times;").on("click", function() {\n                  s3.transition().call(a4);\n                });\n                for (var l3 = s3.append("p"), u4 = o4.split(/<br\\s*\\/?>/g), c5 = 0; c5 < u4.length; c5++) c5 && l3.append("br"), l3.append("span").text(u4[c5]);\n                t3 === "stick" ? s3.transition().duration(350).style("opacity", 1) : s3.transition().duration(700).style("opacity", 1).transition().delay(r4).call(a4);\n              });\n            };\n          });\n          var G1 = ye((Irr, fte) => {\n            "use strict";\n            var l3 = cb().dfltConfig, DO = RO(), FO = fte.exports = {};\n            FO.log = function() {\n              var e3;\n              if (l3.logging > 1) {\n                var t3 = ["LOG:"];\n                for (e3 = 0; e3 < arguments.length; e3++) t3.push(arguments[e3]);\n                console.trace.apply(console, t3);\n              }\n              if (l3.notifyOnLogging > 1) {\n                var r4 = [];\n                for (e3 = 0; e3 < arguments.length; e3++) r4.push(arguments[e3]);\n                DO(r4.join("<br>"), "long");\n              }\n            };\n            FO.warn = function() {\n              var e3;\n              if (l3.logging > 0) {\n                var t3 = ["WARN:"];\n                for (e3 = 0; e3 < arguments.length; e3++) t3.push(arguments[e3]);\n                console.trace.apply(console, t3);\n              }\n              if (l3.notifyOnLogging > 0) {\n                var r4 = [];\n                for (e3 = 0; e3 < arguments.length; e3++) r4.push(arguments[e3]);\n                DO(r4.join("<br>"), "stick");\n              }\n            };\n            FO.error = function() {\n              var e3;\n              if (l3.logging > 0) {\n                var t3 = ["ERROR:"];\n                for (e3 = 0; e3 < arguments.length; e3++) t3.push(arguments[e3]);\n                console.error.apply(console, t3);\n              }\n              if (l3.notifyOnLogging > 0) {\n                var r4 = [];\n                for (e3 = 0; e3 < arguments.length; e3++) r4.push(arguments[e3]);\n                DO(r4.join("<br>"), "stick");\n              }\n            };\n          });\n          var w6 = ye((Rrr, hte) => {\n            "use strict";\n            hte.exports = function() {\n            };\n          });\n          var zO = ye((Drr, dte) => {\n            "use strict";\n            dte.exports = function(t3, r4) {\n              if (r4 instanceof RegExp) {\n                for (var n4 = r4.toString(), i3 = 0; i3 < t3.length; i3++) if (t3[i3] instanceof RegExp && t3[i3].toString() === n4) return t3;\n                t3.push(r4);\n              } else (r4 || r4 === 0) && t3.indexOf(r4) === -1 && t3.push(r4);\n              return t3;\n            };\n          });\n          var pte = ye((Frr, vte) => {\n            vte.exports = Jtt;\n            function Jtt() {\n              var e3 = new Float32Array(16);\n              return e3[0] = 1, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = 1, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = 1, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var mte = ye((zrr, gte) => {\n            gte.exports = $tt;\n            function $tt(e3) {\n              var t3 = new Float32Array(16);\n              return t3[0] = e3[0], t3[1] = e3[1], t3[2] = e3[2], t3[3] = e3[3], t3[4] = e3[4], t3[5] = e3[5], t3[6] = e3[6], t3[7] = e3[7], t3[8] = e3[8], t3[9] = e3[9], t3[10] = e3[10], t3[11] = e3[11], t3[12] = e3[12], t3[13] = e3[13], t3[14] = e3[14], t3[15] = e3[15], t3;\n            }\n          });\n          var _te = ye((Orr, yte) => {\n            yte.exports = Qtt;\n            function Qtt(e3, t3) {\n              return e3[0] = t3[0], e3[1] = t3[1], e3[2] = t3[2], e3[3] = t3[3], e3[4] = t3[4], e3[5] = t3[5], e3[6] = t3[6], e3[7] = t3[7], e3[8] = t3[8], e3[9] = t3[9], e3[10] = t3[10], e3[11] = t3[11], e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15], e3;\n            }\n          });\n          var OO = ye((qrr, xte) => {\n            xte.exports = ert;\n            function ert(e3) {\n              return e3[0] = 1, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = 1, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = 1, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var wte = ye((Brr, bte) => {\n            bte.exports = trt;\n            function trt(e3, t3) {\n              if (e3 === t3) {\n                var r4 = t3[1], n4 = t3[2], i3 = t3[3], a4 = t3[6], o4 = t3[7], s3 = t3[11];\n                e3[1] = t3[4], e3[2] = t3[8], e3[3] = t3[12], e3[4] = r4, e3[6] = t3[9], e3[7] = t3[13], e3[8] = n4, e3[9] = a4, e3[11] = t3[14], e3[12] = i3, e3[13] = o4, e3[14] = s3;\n              } else e3[0] = t3[0], e3[1] = t3[4], e3[2] = t3[8], e3[3] = t3[12], e3[4] = t3[1], e3[5] = t3[5], e3[6] = t3[9], e3[7] = t3[13], e3[8] = t3[2], e3[9] = t3[6], e3[10] = t3[10], e3[11] = t3[14], e3[12] = t3[3], e3[13] = t3[7], e3[14] = t3[11], e3[15] = t3[15];\n              return e3;\n            }\n          });\n          var Ate = ye((Nrr, Tte) => {\n            Tte.exports = rrt;\n            function rrt(e3, t3) {\n              var r4 = t3[0], n4 = t3[1], i3 = t3[2], a4 = t3[3], o4 = t3[4], s3 = t3[5], l3 = t3[6], u4 = t3[7], c5 = t3[8], f4 = t3[9], h3 = t3[10], d3 = t3[11], v3 = t3[12], _2 = t3[13], b = t3[14], p3 = t3[15], k4 = r4 * s3 - n4 * o4, E3 = r4 * l3 - i3 * o4, S2 = r4 * u4 - a4 * o4, L3 = n4 * l3 - i3 * s3, x2 = n4 * u4 - a4 * s3, C3 = i3 * u4 - a4 * l3, M4 = c5 * _2 - f4 * v3, g3 = c5 * b - h3 * v3, P3 = c5 * p3 - d3 * v3, T3 = f4 * b - h3 * _2, z3 = f4 * p3 - d3 * _2, O3 = h3 * p3 - d3 * b, V2 = k4 * O3 - E3 * z3 + S2 * T3 + L3 * P3 - x2 * g3 + C3 * M4;\n              return V2 ? (V2 = 1 / V2, e3[0] = (s3 * O3 - l3 * z3 + u4 * T3) * V2, e3[1] = (i3 * z3 - n4 * O3 - a4 * T3) * V2, e3[2] = (_2 * C3 - b * x2 + p3 * L3) * V2, e3[3] = (h3 * x2 - f4 * C3 - d3 * L3) * V2, e3[4] = (l3 * P3 - o4 * O3 - u4 * g3) * V2, e3[5] = (r4 * O3 - i3 * P3 + a4 * g3) * V2, e3[6] = (b * S2 - v3 * C3 - p3 * E3) * V2, e3[7] = (c5 * C3 - h3 * S2 + d3 * E3) * V2, e3[8] = (o4 * z3 - s3 * P3 + u4 * M4) * V2, e3[9] = (n4 * P3 - r4 * z3 - a4 * M4) * V2, e3[10] = (v3 * x2 - _2 * S2 + p3 * k4) * V2, e3[11] = (f4 * S2 - c5 * x2 - d3 * k4) * V2, e3[12] = (s3 * g3 - o4 * T3 - l3 * M4) * V2, e3[13] = (r4 * T3 - n4 * g3 + i3 * M4) * V2, e3[14] = (_2 * E3 - v3 * L3 - b * k4) * V2, e3[15] = (c5 * L3 - f4 * E3 + h3 * k4) * V2, e3) : null;\n            }\n          });\n          var Mte = ye((Urr, Ste) => {\n            Ste.exports = irt;\n            function irt(e3, t3) {\n              var r4 = t3[0], n4 = t3[1], i3 = t3[2], a4 = t3[3], o4 = t3[4], s3 = t3[5], l3 = t3[6], u4 = t3[7], c5 = t3[8], f4 = t3[9], h3 = t3[10], d3 = t3[11], v3 = t3[12], _2 = t3[13], b = t3[14], p3 = t3[15];\n              return e3[0] = s3 * (h3 * p3 - d3 * b) - f4 * (l3 * p3 - u4 * b) + _2 * (l3 * d3 - u4 * h3), e3[1] = -(n4 * (h3 * p3 - d3 * b) - f4 * (i3 * p3 - a4 * b) + _2 * (i3 * d3 - a4 * h3)), e3[2] = n4 * (l3 * p3 - u4 * b) - s3 * (i3 * p3 - a4 * b) + _2 * (i3 * u4 - a4 * l3), e3[3] = -(n4 * (l3 * d3 - u4 * h3) - s3 * (i3 * d3 - a4 * h3) + f4 * (i3 * u4 - a4 * l3)), e3[4] = -(o4 * (h3 * p3 - d3 * b) - c5 * (l3 * p3 - u4 * b) + v3 * (l3 * d3 - u4 * h3)), e3[5] = r4 * (h3 * p3 - d3 * b) - c5 * (i3 * p3 - a4 * b) + v3 * (i3 * d3 - a4 * h3), e3[6] = -(r4 * (l3 * p3 - u4 * b) - o4 * (i3 * p3 - a4 * b) + v3 * (i3 * u4 - a4 * l3)), e3[7] = r4 * (l3 * d3 - u4 * h3) - o4 * (i3 * d3 - a4 * h3) + c5 * (i3 * u4 - a4 * l3), e3[8] = o4 * (f4 * p3 - d3 * _2) - c5 * (s3 * p3 - u4 * _2) + v3 * (s3 * d3 - u4 * f4), e3[9] = -(r4 * (f4 * p3 - d3 * _2) - c5 * (n4 * p3 - a4 * _2) + v3 * (n4 * d3 - a4 * f4)), e3[10] = r4 * (s3 * p3 - u4 * _2) - o4 * (n4 * p3 - a4 * _2) + v3 * (n4 * u4 - a4 * s3), e3[11] = -(r4 * (s3 * d3 - u4 * f4) - o4 * (n4 * d3 - a4 * f4) + c5 * (n4 * u4 - a4 * s3)), e3[12] = -(o4 * (f4 * b - h3 * _2) - c5 * (s3 * b - l3 * _2) + v3 * (s3 * h3 - l3 * f4)), e3[13] = r4 * (f4 * b - h3 * _2) - c5 * (n4 * b - i3 * _2) + v3 * (n4 * h3 - i3 * f4), e3[14] = -(r4 * (s3 * b - l3 * _2) - o4 * (n4 * b - i3 * _2) + v3 * (n4 * l3 - i3 * s3)), e3[15] = r4 * (s3 * h3 - l3 * f4) - o4 * (n4 * h3 - i3 * f4) + c5 * (n4 * l3 - i3 * s3), e3;\n            }\n          });\n          var kte = ye((Vrr, Ete) => {\n            Ete.exports = nrt;\n            function nrt(e3) {\n              var t3 = e3[0], r4 = e3[1], n4 = e3[2], i3 = e3[3], a4 = e3[4], o4 = e3[5], s3 = e3[6], l3 = e3[7], u4 = e3[8], c5 = e3[9], f4 = e3[10], h3 = e3[11], d3 = e3[12], v3 = e3[13], _2 = e3[14], b = e3[15], p3 = t3 * o4 - r4 * a4, k4 = t3 * s3 - n4 * a4, E3 = t3 * l3 - i3 * a4, S2 = r4 * s3 - n4 * o4, L3 = r4 * l3 - i3 * o4, x2 = n4 * l3 - i3 * s3, C3 = u4 * v3 - c5 * d3, M4 = u4 * _2 - f4 * d3, g3 = u4 * b - h3 * d3, P3 = c5 * _2 - f4 * v3, T3 = c5 * b - h3 * v3, z3 = f4 * b - h3 * _2;\n              return p3 * z3 - k4 * T3 + E3 * P3 + S2 * g3 - L3 * M4 + x2 * C3;\n            }\n          });\n          var Lte = ye((Grr, Cte) => {\n            Cte.exports = art;\n            function art(e3, t3, r4) {\n              var n4 = t3[0], i3 = t3[1], a4 = t3[2], o4 = t3[3], s3 = t3[4], l3 = t3[5], u4 = t3[6], c5 = t3[7], f4 = t3[8], h3 = t3[9], d3 = t3[10], v3 = t3[11], _2 = t3[12], b = t3[13], p3 = t3[14], k4 = t3[15], E3 = r4[0], S2 = r4[1], L3 = r4[2], x2 = r4[3];\n              return e3[0] = E3 * n4 + S2 * s3 + L3 * f4 + x2 * _2, e3[1] = E3 * i3 + S2 * l3 + L3 * h3 + x2 * b, e3[2] = E3 * a4 + S2 * u4 + L3 * d3 + x2 * p3, e3[3] = E3 * o4 + S2 * c5 + L3 * v3 + x2 * k4, E3 = r4[4], S2 = r4[5], L3 = r4[6], x2 = r4[7], e3[4] = E3 * n4 + S2 * s3 + L3 * f4 + x2 * _2, e3[5] = E3 * i3 + S2 * l3 + L3 * h3 + x2 * b, e3[6] = E3 * a4 + S2 * u4 + L3 * d3 + x2 * p3, e3[7] = E3 * o4 + S2 * c5 + L3 * v3 + x2 * k4, E3 = r4[8], S2 = r4[9], L3 = r4[10], x2 = r4[11], e3[8] = E3 * n4 + S2 * s3 + L3 * f4 + x2 * _2, e3[9] = E3 * i3 + S2 * l3 + L3 * h3 + x2 * b, e3[10] = E3 * a4 + S2 * u4 + L3 * d3 + x2 * p3, e3[11] = E3 * o4 + S2 * c5 + L3 * v3 + x2 * k4, E3 = r4[12], S2 = r4[13], L3 = r4[14], x2 = r4[15], e3[12] = E3 * n4 + S2 * s3 + L3 * f4 + x2 * _2, e3[13] = E3 * i3 + S2 * l3 + L3 * h3 + x2 * b, e3[14] = E3 * a4 + S2 * u4 + L3 * d3 + x2 * p3, e3[15] = E3 * o4 + S2 * c5 + L3 * v3 + x2 * k4, e3;\n            }\n          });\n          var Ite = ye((Hrr, Pte) => {\n            Pte.exports = ort;\n            function ort(e3, t3, r4) {\n              var n4 = r4[0], i3 = r4[1], a4 = r4[2], o4, s3, l3, u4, c5, f4, h3, d3, v3, _2, b, p3;\n              return t3 === e3 ? (e3[12] = t3[0] * n4 + t3[4] * i3 + t3[8] * a4 + t3[12], e3[13] = t3[1] * n4 + t3[5] * i3 + t3[9] * a4 + t3[13], e3[14] = t3[2] * n4 + t3[6] * i3 + t3[10] * a4 + t3[14], e3[15] = t3[3] * n4 + t3[7] * i3 + t3[11] * a4 + t3[15]) : (o4 = t3[0], s3 = t3[1], l3 = t3[2], u4 = t3[3], c5 = t3[4], f4 = t3[5], h3 = t3[6], d3 = t3[7], v3 = t3[8], _2 = t3[9], b = t3[10], p3 = t3[11], e3[0] = o4, e3[1] = s3, e3[2] = l3, e3[3] = u4, e3[4] = c5, e3[5] = f4, e3[6] = h3, e3[7] = d3, e3[8] = v3, e3[9] = _2, e3[10] = b, e3[11] = p3, e3[12] = o4 * n4 + c5 * i3 + v3 * a4 + t3[12], e3[13] = s3 * n4 + f4 * i3 + _2 * a4 + t3[13], e3[14] = l3 * n4 + h3 * i3 + b * a4 + t3[14], e3[15] = u4 * n4 + d3 * i3 + p3 * a4 + t3[15]), e3;\n            }\n          });\n          var Dte = ye((jrr, Rte) => {\n            Rte.exports = srt;\n            function srt(e3, t3, r4) {\n              var n4 = r4[0], i3 = r4[1], a4 = r4[2];\n              return e3[0] = t3[0] * n4, e3[1] = t3[1] * n4, e3[2] = t3[2] * n4, e3[3] = t3[3] * n4, e3[4] = t3[4] * i3, e3[5] = t3[5] * i3, e3[6] = t3[6] * i3, e3[7] = t3[7] * i3, e3[8] = t3[8] * a4, e3[9] = t3[9] * a4, e3[10] = t3[10] * a4, e3[11] = t3[11] * a4, e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15], e3;\n            }\n          });\n          var zte = ye((Wrr, Fte) => {\n            Fte.exports = lrt;\n            function lrt(e3, t3, r4, n4) {\n              var i3 = n4[0], a4 = n4[1], o4 = n4[2], s3 = Math.sqrt(i3 * i3 + a4 * a4 + o4 * o4), l3, u4, c5, f4, h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2;\n              return Math.abs(s3) < 1e-6 ? null : (s3 = 1 / s3, i3 *= s3, a4 *= s3, o4 *= s3, l3 = Math.sin(r4), u4 = Math.cos(r4), c5 = 1 - u4, f4 = t3[0], h3 = t3[1], d3 = t3[2], v3 = t3[3], _2 = t3[4], b = t3[5], p3 = t3[6], k4 = t3[7], E3 = t3[8], S2 = t3[9], L3 = t3[10], x2 = t3[11], C3 = i3 * i3 * c5 + u4, M4 = a4 * i3 * c5 + o4 * l3, g3 = o4 * i3 * c5 - a4 * l3, P3 = i3 * a4 * c5 - o4 * l3, T3 = a4 * a4 * c5 + u4, z3 = o4 * a4 * c5 + i3 * l3, O3 = i3 * o4 * c5 + a4 * l3, V2 = a4 * o4 * c5 - i3 * l3, G2 = o4 * o4 * c5 + u4, e3[0] = f4 * C3 + _2 * M4 + E3 * g3, e3[1] = h3 * C3 + b * M4 + S2 * g3, e3[2] = d3 * C3 + p3 * M4 + L3 * g3, e3[3] = v3 * C3 + k4 * M4 + x2 * g3, e3[4] = f4 * P3 + _2 * T3 + E3 * z3, e3[5] = h3 * P3 + b * T3 + S2 * z3, e3[6] = d3 * P3 + p3 * T3 + L3 * z3, e3[7] = v3 * P3 + k4 * T3 + x2 * z3, e3[8] = f4 * O3 + _2 * V2 + E3 * G2, e3[9] = h3 * O3 + b * V2 + S2 * G2, e3[10] = d3 * O3 + p3 * V2 + L3 * G2, e3[11] = v3 * O3 + k4 * V2 + x2 * G2, t3 !== e3 && (e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15]), e3);\n            }\n          });\n          var qte = ye((Xrr, Ote) => {\n            Ote.exports = urt;\n            function urt(e3, t3, r4) {\n              var n4 = Math.sin(r4), i3 = Math.cos(r4), a4 = t3[4], o4 = t3[5], s3 = t3[6], l3 = t3[7], u4 = t3[8], c5 = t3[9], f4 = t3[10], h3 = t3[11];\n              return t3 !== e3 && (e3[0] = t3[0], e3[1] = t3[1], e3[2] = t3[2], e3[3] = t3[3], e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15]), e3[4] = a4 * i3 + u4 * n4, e3[5] = o4 * i3 + c5 * n4, e3[6] = s3 * i3 + f4 * n4, e3[7] = l3 * i3 + h3 * n4, e3[8] = u4 * i3 - a4 * n4, e3[9] = c5 * i3 - o4 * n4, e3[10] = f4 * i3 - s3 * n4, e3[11] = h3 * i3 - l3 * n4, e3;\n            }\n          });\n          var Nte = ye((Zrr, Bte) => {\n            Bte.exports = crt;\n            function crt(e3, t3, r4) {\n              var n4 = Math.sin(r4), i3 = Math.cos(r4), a4 = t3[0], o4 = t3[1], s3 = t3[2], l3 = t3[3], u4 = t3[8], c5 = t3[9], f4 = t3[10], h3 = t3[11];\n              return t3 !== e3 && (e3[4] = t3[4], e3[5] = t3[5], e3[6] = t3[6], e3[7] = t3[7], e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15]), e3[0] = a4 * i3 - u4 * n4, e3[1] = o4 * i3 - c5 * n4, e3[2] = s3 * i3 - f4 * n4, e3[3] = l3 * i3 - h3 * n4, e3[8] = a4 * n4 + u4 * i3, e3[9] = o4 * n4 + c5 * i3, e3[10] = s3 * n4 + f4 * i3, e3[11] = l3 * n4 + h3 * i3, e3;\n            }\n          });\n          var Vte = ye((Yrr, Ute) => {\n            Ute.exports = frt;\n            function frt(e3, t3, r4) {\n              var n4 = Math.sin(r4), i3 = Math.cos(r4), a4 = t3[0], o4 = t3[1], s3 = t3[2], l3 = t3[3], u4 = t3[4], c5 = t3[5], f4 = t3[6], h3 = t3[7];\n              return t3 !== e3 && (e3[8] = t3[8], e3[9] = t3[9], e3[10] = t3[10], e3[11] = t3[11], e3[12] = t3[12], e3[13] = t3[13], e3[14] = t3[14], e3[15] = t3[15]), e3[0] = a4 * i3 + u4 * n4, e3[1] = o4 * i3 + c5 * n4, e3[2] = s3 * i3 + f4 * n4, e3[3] = l3 * i3 + h3 * n4, e3[4] = u4 * i3 - a4 * n4, e3[5] = c5 * i3 - o4 * n4, e3[6] = f4 * i3 - s3 * n4, e3[7] = h3 * i3 - l3 * n4, e3;\n            }\n          });\n          var Hte = ye((Krr, Gte) => {\n            Gte.exports = hrt;\n            function hrt(e3, t3, r4) {\n              var n4, i3, a4, o4 = r4[0], s3 = r4[1], l3 = r4[2], u4 = Math.sqrt(o4 * o4 + s3 * s3 + l3 * l3);\n              return Math.abs(u4) < 1e-6 ? null : (u4 = 1 / u4, o4 *= u4, s3 *= u4, l3 *= u4, n4 = Math.sin(t3), i3 = Math.cos(t3), a4 = 1 - i3, e3[0] = o4 * o4 * a4 + i3, e3[1] = s3 * o4 * a4 + l3 * n4, e3[2] = l3 * o4 * a4 - s3 * n4, e3[3] = 0, e3[4] = o4 * s3 * a4 - l3 * n4, e3[5] = s3 * s3 * a4 + i3, e3[6] = l3 * s3 * a4 + o4 * n4, e3[7] = 0, e3[8] = o4 * l3 * a4 + s3 * n4, e3[9] = s3 * l3 * a4 - o4 * n4, e3[10] = l3 * l3 * a4 + i3, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3);\n            }\n          });\n          var Wte = ye((Jrr, jte) => {\n            jte.exports = drt;\n            function drt(e3, t3, r4) {\n              var n4 = t3[0], i3 = t3[1], a4 = t3[2], o4 = t3[3], s3 = n4 + n4, l3 = i3 + i3, u4 = a4 + a4, c5 = n4 * s3, f4 = n4 * l3, h3 = n4 * u4, d3 = i3 * l3, v3 = i3 * u4, _2 = a4 * u4, b = o4 * s3, p3 = o4 * l3, k4 = o4 * u4;\n              return e3[0] = 1 - (d3 + _2), e3[1] = f4 + k4, e3[2] = h3 - p3, e3[3] = 0, e3[4] = f4 - k4, e3[5] = 1 - (c5 + _2), e3[6] = v3 + b, e3[7] = 0, e3[8] = h3 + p3, e3[9] = v3 - b, e3[10] = 1 - (c5 + d3), e3[11] = 0, e3[12] = r4[0], e3[13] = r4[1], e3[14] = r4[2], e3[15] = 1, e3;\n            }\n          });\n          var Zte = ye(($rr, Xte) => {\n            Xte.exports = vrt;\n            function vrt(e3, t3) {\n              return e3[0] = t3[0], e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = t3[1], e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = t3[2], e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var Kte = ye((Qrr, Yte) => {\n            Yte.exports = prt;\n            function prt(e3, t3) {\n              return e3[0] = 1, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = 1, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = 1, e3[11] = 0, e3[12] = t3[0], e3[13] = t3[1], e3[14] = t3[2], e3[15] = 1, e3;\n            }\n          });\n          var $te = ye((eir, Jte) => {\n            Jte.exports = grt;\n            function grt(e3, t3) {\n              var r4 = Math.sin(t3), n4 = Math.cos(t3);\n              return e3[0] = 1, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = n4, e3[6] = r4, e3[7] = 0, e3[8] = 0, e3[9] = -r4, e3[10] = n4, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var ere = ye((tir, Qte) => {\n            Qte.exports = mrt;\n            function mrt(e3, t3) {\n              var r4 = Math.sin(t3), n4 = Math.cos(t3);\n              return e3[0] = n4, e3[1] = 0, e3[2] = -r4, e3[3] = 0, e3[4] = 0, e3[5] = 1, e3[6] = 0, e3[7] = 0, e3[8] = r4, e3[9] = 0, e3[10] = n4, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var rre = ye((rir, tre) => {\n            tre.exports = yrt;\n            function yrt(e3, t3) {\n              var r4 = Math.sin(t3), n4 = Math.cos(t3);\n              return e3[0] = n4, e3[1] = r4, e3[2] = 0, e3[3] = 0, e3[4] = -r4, e3[5] = n4, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = 1, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var nre = ye((iir, ire) => {\n            ire.exports = _rt;\n            function _rt(e3, t3) {\n              var r4 = t3[0], n4 = t3[1], i3 = t3[2], a4 = t3[3], o4 = r4 + r4, s3 = n4 + n4, l3 = i3 + i3, u4 = r4 * o4, c5 = n4 * o4, f4 = n4 * s3, h3 = i3 * o4, d3 = i3 * s3, v3 = i3 * l3, _2 = a4 * o4, b = a4 * s3, p3 = a4 * l3;\n              return e3[0] = 1 - f4 - v3, e3[1] = c5 + p3, e3[2] = h3 - b, e3[3] = 0, e3[4] = c5 - p3, e3[5] = 1 - u4 - v3, e3[6] = d3 + _2, e3[7] = 0, e3[8] = h3 + b, e3[9] = d3 - _2, e3[10] = 1 - u4 - f4, e3[11] = 0, e3[12] = 0, e3[13] = 0, e3[14] = 0, e3[15] = 1, e3;\n            }\n          });\n          var ore = ye((nir, are) => {\n            are.exports = xrt;\n            function xrt(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = 1 / (r4 - t3), l3 = 1 / (i3 - n4), u4 = 1 / (a4 - o4);\n              return e3[0] = a4 * 2 * s3, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = a4 * 2 * l3, e3[6] = 0, e3[7] = 0, e3[8] = (r4 + t3) * s3, e3[9] = (i3 + n4) * l3, e3[10] = (o4 + a4) * u4, e3[11] = -1, e3[12] = 0, e3[13] = 0, e3[14] = o4 * a4 * 2 * u4, e3[15] = 0, e3;\n            }\n          });\n          var lre = ye((air, sre) => {\n            sre.exports = brt;\n            function brt(e3, t3, r4, n4, i3) {\n              var a4 = 1 / Math.tan(t3 / 2), o4 = 1 / (n4 - i3);\n              return e3[0] = a4 / r4, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = a4, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = (i3 + n4) * o4, e3[11] = -1, e3[12] = 0, e3[13] = 0, e3[14] = 2 * i3 * n4 * o4, e3[15] = 0, e3;\n            }\n          });\n          var cre = ye((oir, ure) => {\n            ure.exports = wrt;\n            function wrt(e3, t3, r4, n4) {\n              var i3 = Math.tan(t3.upDegrees * Math.PI / 180), a4 = Math.tan(t3.downDegrees * Math.PI / 180), o4 = Math.tan(t3.leftDegrees * Math.PI / 180), s3 = Math.tan(t3.rightDegrees * Math.PI / 180), l3 = 2 / (o4 + s3), u4 = 2 / (i3 + a4);\n              return e3[0] = l3, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = u4, e3[6] = 0, e3[7] = 0, e3[8] = -((o4 - s3) * l3 * 0.5), e3[9] = (i3 - a4) * u4 * 0.5, e3[10] = n4 / (r4 - n4), e3[11] = -1, e3[12] = 0, e3[13] = 0, e3[14] = n4 * r4 / (r4 - n4), e3[15] = 0, e3;\n            }\n          });\n          var hre = ye((sir, fre) => {\n            fre.exports = Trt;\n            function Trt(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = 1 / (t3 - r4), l3 = 1 / (n4 - i3), u4 = 1 / (a4 - o4);\n              return e3[0] = -2 * s3, e3[1] = 0, e3[2] = 0, e3[3] = 0, e3[4] = 0, e3[5] = -2 * l3, e3[6] = 0, e3[7] = 0, e3[8] = 0, e3[9] = 0, e3[10] = 2 * u4, e3[11] = 0, e3[12] = (t3 + r4) * s3, e3[13] = (i3 + n4) * l3, e3[14] = (o4 + a4) * u4, e3[15] = 1, e3;\n            }\n          });\n          var vre = ye((lir, dre) => {\n            var Art = OO();\n            dre.exports = Srt;\n            function Srt(e3, t3, r4, n4) {\n              var i3, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3 = t3[0], _2 = t3[1], b = t3[2], p3 = n4[0], k4 = n4[1], E3 = n4[2], S2 = r4[0], L3 = r4[1], x2 = r4[2];\n              return Math.abs(v3 - S2) < 1e-6 && Math.abs(_2 - L3) < 1e-6 && Math.abs(b - x2) < 1e-6 ? Art(e3) : (c5 = v3 - S2, f4 = _2 - L3, h3 = b - x2, d3 = 1 / Math.sqrt(c5 * c5 + f4 * f4 + h3 * h3), c5 *= d3, f4 *= d3, h3 *= d3, i3 = k4 * h3 - E3 * f4, a4 = E3 * c5 - p3 * h3, o4 = p3 * f4 - k4 * c5, d3 = Math.sqrt(i3 * i3 + a4 * a4 + o4 * o4), d3 ? (d3 = 1 / d3, i3 *= d3, a4 *= d3, o4 *= d3) : (i3 = 0, a4 = 0, o4 = 0), s3 = f4 * o4 - h3 * a4, l3 = h3 * i3 - c5 * o4, u4 = c5 * a4 - f4 * i3, d3 = Math.sqrt(s3 * s3 + l3 * l3 + u4 * u4), d3 ? (d3 = 1 / d3, s3 *= d3, l3 *= d3, u4 *= d3) : (s3 = 0, l3 = 0, u4 = 0), e3[0] = i3, e3[1] = s3, e3[2] = c5, e3[3] = 0, e3[4] = a4, e3[5] = l3, e3[6] = f4, e3[7] = 0, e3[8] = o4, e3[9] = u4, e3[10] = h3, e3[11] = 0, e3[12] = -(i3 * v3 + a4 * _2 + o4 * b), e3[13] = -(s3 * v3 + l3 * _2 + u4 * b), e3[14] = -(c5 * v3 + f4 * _2 + h3 * b), e3[15] = 1, e3);\n            }\n          });\n          var gre = ye((uir, pre) => {\n            pre.exports = Mrt;\n            function Mrt(e3) {\n              return "mat4(" + e3[0] + ", " + e3[1] + ", " + e3[2] + ", " + e3[3] + ", " + e3[4] + ", " + e3[5] + ", " + e3[6] + ", " + e3[7] + ", " + e3[8] + ", " + e3[9] + ", " + e3[10] + ", " + e3[11] + ", " + e3[12] + ", " + e3[13] + ", " + e3[14] + ", " + e3[15] + ")";\n            }\n          });\n          var qO = ye((cir, mre) => {\n            mre.exports = { create: pte(), clone: mte(), copy: _te(), identity: OO(), transpose: wte(), invert: Ate(), adjoint: Mte(), determinant: kte(), multiply: Lte(), translate: Ite(), scale: Dte(), rotate: zte(), rotateX: qte(), rotateY: Nte(), rotateZ: Vte(), fromRotation: Hte(), fromRotationTranslation: Wte(), fromScaling: Zte(), fromTranslation: Kte(), fromXRotation: $te(), fromYRotation: ere(), fromZRotation: rre(), fromQuat: nre(), frustum: ore(), perspective: lre(), perspectiveFromFieldOfView: cre(), ortho: hre(), lookAt: vre(), str: gre() };\n          });\n          var T6 = ye((fh) => {\n            "use strict";\n            var Ert = qO();\n            fh.init2dArray = function(e3, t3) {\n              for (var r4 = new Array(e3), n4 = 0; n4 < e3; n4++) r4[n4] = new Array(t3);\n              return r4;\n            };\n            fh.transposeRagged = function(e3) {\n              var t3 = 0, r4 = e3.length, n4, i3;\n              for (n4 = 0; n4 < r4; n4++) t3 = Math.max(t3, e3[n4].length);\n              var a4 = new Array(t3);\n              for (n4 = 0; n4 < t3; n4++) for (a4[n4] = new Array(r4), i3 = 0; i3 < r4; i3++) a4[n4][i3] = e3[i3][n4];\n              return a4;\n            };\n            fh.dot = function(e3, t3) {\n              if (!(e3.length && t3.length) || e3.length !== t3.length) return null;\n              var r4 = e3.length, n4, i3;\n              if (e3[0].length) for (n4 = new Array(r4), i3 = 0; i3 < r4; i3++) n4[i3] = fh.dot(e3[i3], t3);\n              else if (t3[0].length) {\n                var a4 = fh.transposeRagged(t3);\n                for (n4 = new Array(a4.length), i3 = 0; i3 < a4.length; i3++) n4[i3] = fh.dot(e3, a4[i3]);\n              } else for (n4 = 0, i3 = 0; i3 < r4; i3++) n4 += e3[i3] * t3[i3];\n              return n4;\n            };\n            fh.translationMatrix = function(e3, t3) {\n              return [[1, 0, e3], [0, 1, t3], [0, 0, 1]];\n            };\n            fh.rotationMatrix = function(e3) {\n              var t3 = e3 * Math.PI / 180;\n              return [[Math.cos(t3), -Math.sin(t3), 0], [Math.sin(t3), Math.cos(t3), 0], [0, 0, 1]];\n            };\n            fh.rotationXYMatrix = function(e3, t3, r4) {\n              return fh.dot(fh.dot(fh.translationMatrix(t3, r4), fh.rotationMatrix(e3)), fh.translationMatrix(-t3, -r4));\n            };\n            fh.apply3DTransform = function(e3) {\n              return function() {\n                var t3 = arguments, r4 = arguments.length === 1 ? t3[0] : [t3[0], t3[1], t3[2] || 0];\n                return fh.dot(e3, [r4[0], r4[1], r4[2], 1]).slice(0, 3);\n              };\n            };\n            fh.apply2DTransform = function(e3) {\n              return function() {\n                var t3 = arguments;\n                t3.length === 3 && (t3 = t3[0]);\n                var r4 = arguments.length === 1 ? t3[0] : [t3[0], t3[1]];\n                return fh.dot(e3, [r4[0], r4[1], 1]).slice(0, 2);\n              };\n            };\n            fh.apply2DTransform2 = function(e3) {\n              var t3 = fh.apply2DTransform(e3);\n              return function(r4) {\n                return t3(r4.slice(0, 2)).concat(t3(r4.slice(2, 4)));\n              };\n            };\n            fh.convertCssMatrix = function(e3) {\n              if (e3) {\n                var t3 = e3.length;\n                if (t3 === 16) return e3;\n                if (t3 === 6) return [e3[0], e3[1], 0, 0, e3[2], e3[3], 0, 0, 0, 0, 1, 0, e3[4], e3[5], 0, 1];\n              }\n              return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n            };\n            fh.inverseTransformMatrix = function(e3) {\n              var t3 = [];\n              return Ert.invert(t3, e3), [[t3[0], t3[1], t3[2], t3[3]], [t3[4], t3[5], t3[6], t3[7]], [t3[8], t3[9], t3[10], t3[11]], [t3[12], t3[13], t3[14], t3[15]]];\n            };\n          });\n          var NS = ye((hir, Tre) => {\n            "use strict";\n            var krt = Oa(), yre = G1(), Crt = T6(), Lrt = qO();\n            function Prt(e3) {\n              var t3;\n              if (typeof e3 == "string") {\n                if (t3 = document.getElementById(e3), t3 === null) throw new Error("No DOM element with id \'" + e3 + "\' exists on the page.");\n                return t3;\n              } else if (e3 == null) throw new Error("DOM element provided is null or undefined");\n              return e3;\n            }\n            function Irt(e3) {\n              var t3 = krt.select(e3);\n              return t3.node() instanceof HTMLElement && t3.size() && t3.classed("js-plotly-plot");\n            }\n            function _re(e3) {\n              var t3 = e3 && e3.parentNode;\n              t3 && t3.removeChild(e3);\n            }\n            function Rrt(e3, t3) {\n              xre("global", e3, t3);\n            }\n            function xre(e3, t3, r4) {\n              var n4 = "plotly.js-style-" + e3, i3 = document.getElementById(n4);\n              if (!(i3 && i3.matches(".no-inline-styles"))) {\n                i3 || (i3 = document.createElement("style"), i3.setAttribute("id", n4), i3.appendChild(document.createTextNode("")), document.head.appendChild(i3));\n                var a4 = i3.sheet;\n                a4 ? a4.insertRule ? a4.insertRule(t3 + "{" + r4 + "}", 0) : a4.addRule ? a4.addRule(t3, r4, 0) : yre.warn("addStyleRule failed") : yre.warn("Cannot addRelatedStyleRule, probably due to strict CSP...");\n              }\n            }\n            function Drt(e3) {\n              var t3 = "plotly.js-style-" + e3, r4 = document.getElementById(t3);\n              r4 && _re(r4);\n            }\n            function Frt(e3, t3, r4, n4, i3, a4) {\n              var o4 = n4.split(":"), s3 = i3.split(":"), l3 = "data-btn-style-event-added";\n              a4 || (a4 = document), a4.querySelectorAll(e3).forEach(function(u4) {\n                u4.getAttribute(l3) || (u4.addEventListener("mouseenter", function() {\n                  var c5 = this.querySelector(r4);\n                  c5 && (c5.style[o4[0]] = o4[1]);\n                }), u4.addEventListener("mouseleave", function() {\n                  var c5 = this.querySelector(r4);\n                  c5 && (t3 && this.matches(t3) ? c5.style[o4[0]] = o4[1] : c5.style[s3[0]] = s3[1]);\n                }), u4.setAttribute(l3, true));\n              });\n            }\n            function zrt(e3) {\n              var t3 = wre(e3), r4 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n              return t3.forEach(function(n4) {\n                var i3 = bre(n4);\n                if (i3) {\n                  var a4 = Crt.convertCssMatrix(i3);\n                  r4 = Lrt.multiply(r4, r4, a4);\n                }\n              }), r4;\n            }\n            function bre(e3) {\n              var t3 = window.getComputedStyle(e3, null), r4 = t3.getPropertyValue("-webkit-transform") || t3.getPropertyValue("-moz-transform") || t3.getPropertyValue("-ms-transform") || t3.getPropertyValue("-o-transform") || t3.getPropertyValue("transform");\n              return r4 === "none" ? null : r4.replace("matrix", "").replace("3d", "").slice(1, -1).split(",").map(function(n4) {\n                return +n4;\n              });\n            }\n            function wre(e3) {\n              for (var t3 = []; Ort(e3); ) t3.push(e3), e3 = e3.parentNode, typeof ShadowRoot == "function" && e3 instanceof ShadowRoot && (e3 = e3.host);\n              return t3;\n            }\n            function Ort(e3) {\n              return e3 && (e3 instanceof Element || e3 instanceof HTMLElement);\n            }\n            function qrt(e3, t3) {\n              return e3 && t3 && e3.top === t3.top && e3.left === t3.left && e3.right === t3.right && e3.bottom === t3.bottom;\n            }\n            Tre.exports = { getGraphDiv: Prt, isPlotDiv: Irt, removeElement: _re, addStyleRule: Rrt, addRelatedStyleRule: xre, deleteRelatedStyleRule: Drt, setStyleOnHover: Frt, getFullTransformMatrix: zrt, getElementTransformMatrix: bre, getElementAndAncestors: wre, equalDomRects: qrt };\n          });\n          var US = ye((dir, Are) => {\n            "use strict";\n            Are.exports = { mode: { valType: "enumerated", dflt: "afterall", values: ["immediate", "next", "afterall"] }, direction: { valType: "enumerated", values: ["forward", "reverse"], dflt: "forward" }, fromcurrent: { valType: "boolean", dflt: false }, frame: { duration: { valType: "number", min: 0, dflt: 500 }, redraw: { valType: "boolean", dflt: true } }, transition: { duration: { valType: "number", min: 0, dflt: 500, editType: "none" }, easing: { valType: "enumerated", dflt: "cubic-in-out", values: ["linear", "quad", "cubic", "sin", "exp", "circle", "elastic", "back", "bounce", "linear-in", "quad-in", "cubic-in", "sin-in", "exp-in", "circle-in", "elastic-in", "back-in", "bounce-in", "linear-out", "quad-out", "cubic-out", "sin-out", "exp-out", "circle-out", "elastic-out", "back-out", "bounce-out", "linear-in-out", "quad-in-out", "cubic-in-out", "sin-in-out", "exp-in-out", "circle-in-out", "elastic-in-out", "back-in-out", "bounce-in-out"], editType: "none" }, ordering: { valType: "enumerated", values: ["layout first", "traces first"], dflt: "layout first", editType: "none" } } };\n          });\n          var mc = ye((vir, Pre) => {\n            "use strict";\n            var Mre = Ao().extendFlat, Brt = my(), Ere = { valType: "flaglist", extras: ["none"], flags: ["calc", "clearAxisTypes", "plot", "style", "markerSize", "colorbars"] }, kre = { valType: "flaglist", extras: ["none"], flags: ["calc", "plot", "legend", "ticks", "axrange", "layoutstyle", "modebar", "camera", "arraydraw", "colorbars"] }, Nrt = Ere.flags.slice().concat(["fullReplot"]), Urt = kre.flags.slice().concat("layoutReplot");\n            Pre.exports = { traces: Ere, layout: kre, traceFlags: function() {\n              return Sre(Nrt);\n            }, layoutFlags: function() {\n              return Sre(Urt);\n            }, update: function(e3, t3) {\n              var r4 = t3.editType;\n              if (r4 && r4 !== "none") for (var n4 = r4.split("+"), i3 = 0; i3 < n4.length; i3++) e3[n4[i3]] = true;\n            }, overrideAll: Cre };\n            function Sre(e3) {\n              for (var t3 = {}, r4 = 0; r4 < e3.length; r4++) t3[e3[r4]] = false;\n              return t3;\n            }\n            function Cre(e3, t3, r4) {\n              var n4 = Mre({}, e3);\n              for (var i3 in n4) {\n                var a4 = n4[i3];\n                Brt(a4) && (n4[i3] = Lre(a4, t3, r4, i3));\n              }\n              return r4 === "from-root" && (n4.editType = t3), n4;\n            }\n            function Lre(e3, t3, r4, n4) {\n              if (e3.valType) {\n                var i3 = Mre({}, e3);\n                if (i3.editType = t3, Array.isArray(e3.items)) {\n                  i3.items = new Array(e3.items.length);\n                  for (var a4 = 0; a4 < e3.items.length; a4++) i3.items[a4] = Lre(e3.items[a4], t3, "from-root");\n                }\n                return i3;\n              } else return Cre(e3, t3, n4.charAt(0) === "_" ? "nested" : "from-root");\n            }\n          });\n          var Pd = ye((BO) => {\n            "use strict";\n            BO.dash = { valType: "string", values: ["solid", "dot", "dash", "longdash", "dashdot", "longdashdot"], dflt: "solid", editType: "style" };\n            BO.pattern = { shape: { valType: "enumerated", values: ["", "/", "\\\\", "x", "-", "|", "+", "."], dflt: "", arrayOk: true, editType: "style" }, path: { valType: "string", arrayOk: true, editType: "style" }, fillmode: { valType: "enumerated", values: ["replace", "overlay"], dflt: "replace", editType: "style" }, bgcolor: { valType: "color", arrayOk: true, editType: "style" }, fgcolor: { valType: "color", arrayOk: true, editType: "style" }, fgopacity: { valType: "number", editType: "style", min: 0, max: 1 }, size: { valType: "number", min: 0, dflt: 8, arrayOk: true, editType: "style" }, solidity: { valType: "number", min: 0, max: 1, dflt: 0.3, arrayOk: true, editType: "style" }, editType: "style" };\n          });\n          var NO = ye((gir, Ire) => {\n            "use strict";\n            Ire.exports = { FORMAT_LINK: "https://github.com/d3/d3-format/tree/v1.4.5#d3-format", DATE_FORMAT_LINK: "https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format" };\n          });\n          var Ll = ye((u32) => {\n            "use strict";\n            var { DATE_FORMAT_LINK: Vrt, FORMAT_LINK: Grt } = NO(), Hrt = ["Variables that can\'t be found will be replaced with the specifier.", \'For example, a template of "data: %{x}, %{y}" will result in a value of "data: 1, %{y}" if x is 1 and y is missing.\', "Variables with an undefined value will be replaced with the fallback value."].join(" ");\n            function jrt({ supportOther: e3 } = {}) {\n              return ["Variables are inserted using %{variable},", \'for example "y: %{y}"\' + (e3 ? " as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown." : "."), `Numbers are formatted using d3-format\'s syntax %{variable:d3-format}, for example "Price: %{y:$.2f}".`, Grt, "for details on the formatting syntax.", `Dates are formatted using d3-time-format\'s syntax %{variable|d3-time-format}, for example "Day: %{2019-01-01|%A}".`, Vrt, "for details on the date formatting syntax.", Hrt].join(" ");\n            }\n            u32.templateFormatStringDescription = jrt;\n            u32.hovertemplateAttrs = ({ editType: e3 = "none", arrayOk: t3 } = {}, r4 = {}) => mg({ valType: "string", dflt: "", editType: e3 }, t3 !== false ? { arrayOk: true } : {});\n            u32.texttemplateAttrs = ({ editType: e3 = "calc", arrayOk: t3 } = {}, r4 = {}) => mg({ valType: "string", dflt: "", editType: e3 }, t3 !== false ? { arrayOk: true } : {});\n            u32.shapeTexttemplateAttrs = ({ editType: e3 = "arraydraw", newshape: t3 } = {}, r4 = {}) => ({ valType: "string", dflt: "", editType: e3 });\n            u32.templatefallbackAttrs = ({ editType: e3 = "none" } = {}) => ({ valType: "any", dflt: "-", editType: e3 });\n          });\n          var M6 = ye((_ir, qre) => {\n            "use strict";\n            function H1(e3, t3) {\n              return t3 ? t3.d2l(e3) : e3;\n            }\n            function Rre(e3, t3) {\n              return t3 ? t3.l2d(e3) : e3;\n            }\n            function Wrt(e3) {\n              return e3.x0;\n            }\n            function Xrt(e3) {\n              return e3.x1;\n            }\n            function Zrt(e3) {\n              return e3.y0;\n            }\n            function Yrt(e3) {\n              return e3.y1;\n            }\n            function Dre(e3) {\n              return e3.x0shift || 0;\n            }\n            function Fre(e3) {\n              return e3.x1shift || 0;\n            }\n            function zre(e3) {\n              return e3.y0shift || 0;\n            }\n            function Ore(e3) {\n              return e3.y1shift || 0;\n            }\n            function A6(e3, t3) {\n              return H1(e3.x1, t3) + Fre(e3) - H1(e3.x0, t3) - Dre(e3);\n            }\n            function S6(e3, t3, r4) {\n              return H1(e3.y1, r4) + Ore(e3) - H1(e3.y0, r4) - zre(e3);\n            }\n            function Krt(e3, t3) {\n              return Math.abs(A6(e3, t3));\n            }\n            function Jrt(e3, t3, r4) {\n              return Math.abs(S6(e3, t3, r4));\n            }\n            function $rt(e3, t3, r4) {\n              return e3.type !== "line" ? void 0 : Math.sqrt(Math.pow(A6(e3, t3), 2) + Math.pow(S6(e3, t3, r4), 2));\n            }\n            function Qrt(e3, t3) {\n              return Rre((H1(e3.x1, t3) + Fre(e3) + H1(e3.x0, t3) + Dre(e3)) / 2, t3);\n            }\n            function eit(e3, t3, r4) {\n              return Rre((H1(e3.y1, r4) + Ore(e3) + H1(e3.y0, r4) + zre(e3)) / 2, r4);\n            }\n            function tit(e3, t3, r4) {\n              return e3.type !== "line" ? void 0 : S6(e3, t3, r4) / A6(e3, t3);\n            }\n            qre.exports = { x0: Wrt, x1: Xrt, y0: Zrt, y1: Yrt, slope: tit, dx: A6, dy: S6, width: Krt, height: Jrt, length: $rt, xcenter: Qrt, ycenter: eit };\n          });\n          var Ure = ye((xir, Nre) => {\n            "use strict";\n            var rit = mc().overrideAll, fb = Gl(), Bre = ec(), iit = Pd().dash, j1 = Ao().extendFlat, { shapeTexttemplateAttrs: nit, templatefallbackAttrs: ait } = Ll(), oit = M6();\n            Nre.exports = rit({ newshape: { visible: j1({}, fb.visible, {}), showlegend: { valType: "boolean", dflt: false }, legend: j1({}, fb.legend, {}), legendgroup: j1({}, fb.legendgroup, {}), legendgrouptitle: { text: j1({}, fb.legendgrouptitle.text, {}), font: Bre({}) }, legendrank: j1({}, fb.legendrank, {}), legendwidth: j1({}, fb.legendwidth, {}), line: { color: { valType: "color" }, width: { valType: "number", min: 0, dflt: 4 }, dash: j1({}, iit, { dflt: "solid" }) }, fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)" }, fillrule: { valType: "enumerated", values: ["evenodd", "nonzero"], dflt: "evenodd" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, layer: { valType: "enumerated", values: ["below", "above", "between"], dflt: "above" }, drawdirection: { valType: "enumerated", values: ["ortho", "horizontal", "vertical", "diagonal"], dflt: "diagonal" }, name: j1({}, fb.name, {}), label: { text: { valType: "string", dflt: "" }, texttemplate: nit({ newshape: true }, { keys: Object.keys(oit) }), texttemplatefallback: ait({ editType: "arraydraw" }), font: Bre({}), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right", "start", "middle", "end"] }, textangle: { valType: "angle", dflt: "auto" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"] }, padding: { valType: "number", dflt: 3, min: 0 } } }, activeshape: { fillcolor: { valType: "color", dflt: "rgb(255,0,255)", description: "Sets the color filling the active shape\' interior." }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.5 } } }, "none", "from-root");\n          });\n          var Gre = ye((bir, Vre) => {\n            "use strict";\n            var sit = Pd().dash, lit = Ao().extendFlat;\n            Vre.exports = { newselection: { mode: { valType: "enumerated", values: ["immediate", "gradual"], dflt: "immediate", editType: "none" }, line: { color: { valType: "color", editType: "none" }, width: { valType: "number", min: 1, dflt: 1, editType: "none" }, dash: lit({}, sit, { dflt: "dot", editType: "none" }), editType: "none" }, editType: "none" }, activeselection: { fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "none" }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "none" }, editType: "none" } };\n          });\n          var E6 = ye((wir, Hre) => {\n            "use strict";\n            Hre.exports = function(e3) {\n              var t3 = e3.editType;\n              return { t: { valType: "number", dflt: 0, editType: t3 }, r: { valType: "number", dflt: 0, editType: t3 }, b: { valType: "number", dflt: 0, editType: t3 }, l: { valType: "number", dflt: 0, editType: t3 }, editType: t3 };\n            };\n          });\n          var c3 = ye((Tir, Zre) => {\n            "use strict";\n            var UO = ec(), uit = US(), k6 = Lh(), jre = Ure(), Wre = Gre(), cit = E6(), Xre = Ao().extendFlat, C6 = UO({ editType: "calc" });\n            C6.family.dflt = \'"Open Sans", verdana, arial, sans-serif\';\n            C6.size.dflt = 12;\n            C6.color.dflt = k6.defaultLine;\n            Zre.exports = { font: C6, title: { text: { valType: "string", editType: "layoutstyle" }, font: UO({ editType: "layoutstyle" }), subtitle: { text: { valType: "string", editType: "layoutstyle" }, font: UO({ editType: "layoutstyle" }), editType: "layoutstyle" }, xref: { valType: "enumerated", dflt: "container", values: ["container", "paper"], editType: "layoutstyle" }, yref: { valType: "enumerated", dflt: "container", values: ["container", "paper"], editType: "layoutstyle" }, x: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "layoutstyle" }, y: { valType: "number", min: 0, max: 1, dflt: "auto", editType: "layoutstyle" }, xanchor: { valType: "enumerated", dflt: "auto", values: ["auto", "left", "center", "right"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", dflt: "auto", values: ["auto", "top", "middle", "bottom"], editType: "layoutstyle" }, pad: Xre(cit({ editType: "layoutstyle" }), {}), automargin: { valType: "boolean", dflt: false, editType: "plot" }, editType: "layoutstyle" }, uniformtext: { mode: { valType: "enumerated", values: [false, "hide", "show"], dflt: false, editType: "plot" }, minsize: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "plot" }, autosize: { valType: "boolean", dflt: false, editType: "none" }, width: { valType: "number", min: 10, dflt: 700, editType: "plot" }, height: { valType: "number", min: 10, dflt: 450, editType: "plot" }, minreducedwidth: { valType: "number", min: 2, dflt: 64, editType: "plot" }, minreducedheight: { valType: "number", min: 2, dflt: 64, editType: "plot" }, margin: { l: { valType: "number", min: 0, dflt: 80, editType: "plot" }, r: { valType: "number", min: 0, dflt: 80, editType: "plot" }, t: { valType: "number", min: 0, dflt: 100, editType: "plot" }, b: { valType: "number", min: 0, dflt: 80, editType: "plot" }, pad: { valType: "number", min: 0, dflt: 0, editType: "plot" }, autoexpand: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, computed: { valType: "any", editType: "none" }, paper_bgcolor: { valType: "color", dflt: k6.background, editType: "plot" }, plot_bgcolor: { valType: "color", dflt: k6.background, editType: "layoutstyle" }, autotypenumbers: { valType: "enumerated", values: ["convert types", "strict"], dflt: "convert types", editType: "calc" }, separators: { valType: "string", editType: "plot" }, hidesources: { valType: "boolean", dflt: false, editType: "plot" }, showlegend: { valType: "boolean", editType: "legend" }, colorway: { valType: "colorlist", dflt: k6.defaults, editType: "calc" }, datarevision: { valType: "any", editType: "calc" }, uirevision: { valType: "any", editType: "none" }, editrevision: { valType: "any", editType: "none" }, selectionrevision: { valType: "any", editType: "none" }, template: { valType: "any", editType: "calc" }, newshape: jre.newshape, activeshape: jre.activeshape, newselection: Wre.newselection, activeselection: Wre.activeselection, meta: { valType: "any", arrayOk: true, editType: "plot" }, transition: Xre({}, uit.transition, { editType: "none" }) };\n          });\n          var Yre = ye(() => {\n            (function() {\n              if (!document.getElementById("696e55e75aaafa12d45b3ff634eadc8348f9c3015fc94984dac1ff824773eb97")) {\n                var e3 = document.createElement("style");\n                e3.id = "696e55e75aaafa12d45b3ff634eadc8348f9c3015fc94984dac1ff824773eb97", e3.textContent = `.maplibregl-map{font:12px/20px Helvetica Neue,Arial,Helvetica,sans-serif;overflow:hidden;position:relative;-webkit-tap-highlight-color:rgb(0 0 0/0)}.maplibregl-canvas{left:0;position:absolute;top:0}.maplibregl-map:fullscreen{height:100%;width:100%}.maplibregl-ctrl-group button.maplibregl-ctrl-compass{touch-action:none}.maplibregl-canvas-container.maplibregl-interactive,.maplibregl-ctrl-group button.maplibregl-ctrl-compass{cursor:grab;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-canvas-container.maplibregl-interactive.maplibregl-track-pointer{cursor:pointer}.maplibregl-canvas-container.maplibregl-interactive:active,.maplibregl-ctrl-group button.maplibregl-ctrl-compass:active{cursor:grabbing}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-canvas-container.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:pinch-zoom}.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan,.maplibregl-canvas-container.maplibregl-touch-zoom-rotate.maplibregl-touch-drag-pan .maplibregl-canvas{touch-action:none}.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures,.maplibregl-canvas-container.maplibregl-touch-drag-pan.maplibregl-cooperative-gestures .maplibregl-canvas{touch-action:pan-x pan-y}.maplibregl-ctrl-bottom-left,.maplibregl-ctrl-bottom-right,.maplibregl-ctrl-top-left,.maplibregl-ctrl-top-right{pointer-events:none;position:absolute;z-index:2}.maplibregl-ctrl-top-left{left:0;top:0}.maplibregl-ctrl-top-right{right:0;top:0}.maplibregl-ctrl-bottom-left{bottom:0;left:0}.maplibregl-ctrl-bottom-right{bottom:0;right:0}.maplibregl-ctrl{clear:both;pointer-events:auto;transform:translate(0)}.maplibregl-ctrl-top-left .maplibregl-ctrl{float:left;margin:10px 0 0 10px}.maplibregl-ctrl-top-right .maplibregl-ctrl{float:right;margin:10px 10px 0 0}.maplibregl-ctrl-bottom-left .maplibregl-ctrl{float:left;margin:0 0 10px 10px}.maplibregl-ctrl-bottom-right .maplibregl-ctrl{float:right;margin:0 10px 10px 0}.maplibregl-ctrl-group{background:#fff;border-radius:4px}.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px rgba(0,0,0,.1)}@media (forced-colors:active){.maplibregl-ctrl-group:not(:empty){box-shadow:0 0 0 2px ButtonText}}.maplibregl-ctrl-group button{background-color:transparent;border:0;box-sizing:border-box;cursor:pointer;display:block;height:29px;outline:none;padding:0;width:29px}.maplibregl-ctrl-group button+button{border-top:1px solid #ddd}.maplibregl-ctrl button .maplibregl-ctrl-icon{background-position:50%;background-repeat:no-repeat;display:block;height:100%;width:100%}@media (forced-colors:active){.maplibregl-ctrl-icon{background-color:transparent}.maplibregl-ctrl-group button+button{border-top:1px solid ButtonText}}.maplibregl-ctrl button::-moz-focus-inner{border:0;padding:0}.maplibregl-ctrl-attrib-button:focus,.maplibregl-ctrl-group button:focus{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl button:disabled{cursor:not-allowed}.maplibregl-ctrl button:disabled .maplibregl-ctrl-icon{opacity:.25}.maplibregl-ctrl button:not(:disabled):hover{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-group button:focus:focus-visible{box-shadow:0 0 2px 2px #0096ff}.maplibregl-ctrl-group button:focus:not(:focus-visible){box-shadow:none}.maplibregl-ctrl-group button:focus:first-child{border-radius:4px 4px 0 0}.maplibregl-ctrl-group button:focus:last-child{border-radius:0 0 4px 4px}.maplibregl-ctrl-group button:focus:only-child{border-radius:inherit}.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23333\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23333\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5\'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5\'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-zoom-out .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M10 13c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h9c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-zoom-in .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M14.5 8.5c-.75 0-1.5.75-1.5 1.5v3h-3c-.75 0-1.5.75-1.5 1.5S9.25 16 10 16h3v3c0 .75.75 1.5 1.5 1.5S16 19.75 16 19v-3h3c.75 0 1.5-.75 1.5-1.5S19.75 13 19 13h-3v-3c0-.75-.75-1.5-1.5-1.5\'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23333\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z\'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z\'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-fullscreen .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M24 16v5.5c0 1.75-.75 2.5-2.5 2.5H16v-1l3-1.5-4-5.5 1-1 5.5 4 1.5-3zM6 16l1.5 3 5.5-4 1 1-4 5.5 3 1.5v1H7.5C5.75 24 5 23.25 5 21.5V16zm7-11v1l-3 1.5 4 5.5-1 1-5.5-4L6 13H5V7.5C5 5.75 5.75 5 7.5 5zm11 2.5c0-1.75-.75-2.5-2.5-2.5H16v1l3 1.5-4 5.5 1 1 5.5-4 1.5 3h1z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-shrink .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'M18.5 16c-1.75 0-2.5.75-2.5 2.5V24h1l1.5-3 5.5 4 1-1-4-5.5 3-1.5v-1zM13 18.5c0-1.75-.75-2.5-2.5-2.5H5v1l3 1.5L4 24l1 1 5.5-4 1.5 3h1zm3-8c0 1.75.75 2.5 2.5 2.5H24v-1l-3-1.5L25 5l-1-1-5.5 4L17 5h-1zM10.5 13c1.75 0 2.5-.75 2.5-2.5V5h-1l-1.5 3L5 4 4 5l4 5.5L5 12v1z\'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23333\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'m10.5 14 4-8 4 8z\'/%3E%3Cpath fill=\'%23ccc\' d=\'m10.5 16 4 8 4-8z\'/%3E%3C/svg%3E")}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'m10.5 14 4-8 4 8z\'/%3E%3Cpath fill=\'%23ccc\' d=\'m10.5 16 4 8 4-8z\'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-compass .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 29 29\'%3E%3Cpath d=\'m10.5 14 4-8 4 8z\'/%3E%3Cpath fill=\'%23ccc\' d=\'m10.5 16 4 8 4-8z\'/%3E%3C/svg%3E")}}.maplibregl-ctrl button.maplibregl-ctrl-terrain .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'22\' height=\'22\' fill=\'%23333\' viewBox=\'0 0 22 22\'%3E%3Cpath d=\'m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-terrain-enabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'22\' height=\'22\' fill=\'%2333b5e5\' viewBox=\'0 0 22 22\'%3E%3Cpath d=\'m1.754 13.406 4.453-4.851 3.09 3.09 3.281 3.277.969-.969-3.309-3.312 3.844-4.121 6.148 6.886h1.082v-.855l-7.207-8.07-4.84 5.187L6.169 6.57l-5.48 5.965v.871ZM.688 16.844h20.625v1.375H.688Zm0 0\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23333\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23aaa\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3Cpath fill=\'red\' d=\'m14 5 1 1-9 9-1-1z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%2333b5e5\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23e58978\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%2333b5e5\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23e54e33\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-waiting .maplibregl-ctrl-icon{animation:maplibregl-spin 2s linear infinite}@media (forced-colors:active){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23fff\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23999\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3Cpath fill=\'red\' d=\'m14 5 1 1-9 9-1-1z\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%2333b5e5\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-active-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23e58978\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%2333b5e5\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate.maplibregl-ctrl-geolocate-background-error .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23e54e33\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl button.maplibregl-ctrl-geolocate .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3C/svg%3E")}.maplibregl-ctrl button.maplibregl-ctrl-geolocate:disabled .maplibregl-ctrl-icon{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'29\' height=\'29\' fill=\'%23666\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M10 4C9 4 9 5 9 5v.1A5 5 0 0 0 5.1 9H5s-1 0-1 1 1 1 1 1h.1A5 5 0 0 0 9 14.9v.1s0 1 1 1 1-1 1-1v-.1a5 5 0 0 0 3.9-3.9h.1s1 0 1-1-1-1-1-1h-.1A5 5 0 0 0 11 5.1V5s0-1-1-1m0 2.5a3.5 3.5 0 1 1 0 7 3.5 3.5 0 1 1 0-7\'/%3E%3Ccircle cx=\'10\' cy=\'10\' r=\'2\'/%3E%3Cpath fill=\'red\' d=\'m14 5 1 1-9 9-1-1z\'/%3E%3C/svg%3E")}}@keyframes maplibregl-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'88\' height=\'23\' fill=\'none\'%3E%3Cpath fill=\'%23000\' fill-opacity=\'.4\' fill-rule=\'evenodd\' d=\'M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z\'/%3E%3Cpath fill=\'%23fff\' d=\'m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z\'/%3E%3Cpath fill=\'%23e1e3e9\' d=\'M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z\'/%3E%3Cpath d=\'M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z\' style=\'fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001\'/%3E%3Cg style=\'stroke-width:1.12603545\'%3E%3Cpath d=\'M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668\' style=\'color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3\' style=\'clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z\' style=\'clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3C/g%3E%3C/svg%3E");background-repeat:no-repeat;cursor:pointer;display:block;height:23px;margin:0 0 -4px -4px;overflow:hidden;width:88px}a.maplibregl-ctrl-logo.maplibregl-compact{width:14px}@media (forced-colors:active){a.maplibregl-ctrl-logo{background-color:transparent;background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'88\' height=\'23\' fill=\'none\'%3E%3Cpath fill=\'%23000\' fill-opacity=\'.4\' fill-rule=\'evenodd\' d=\'M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z\'/%3E%3Cpath fill=\'%23fff\' d=\'m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z\'/%3E%3Cpath fill=\'%23e1e3e9\' d=\'M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z\'/%3E%3Cpath d=\'M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z\' style=\'fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001\'/%3E%3Cg style=\'stroke-width:1.12603545\'%3E%3Cpath d=\'M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668\' style=\'color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3\' style=\'clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z\' style=\'clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3C/g%3E%3C/svg%3E")}}@media (forced-colors:active) and (prefers-color-scheme:light){a.maplibregl-ctrl-logo{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'88\' height=\'23\' fill=\'none\'%3E%3Cpath fill=\'%23000\' fill-opacity=\'.4\' fill-rule=\'evenodd\' d=\'M17.408 16.796h-1.827l2.501-12.095h.198l3.324 6.533.988 2.19.988-2.19 3.258-6.533h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.929 5.644h-.098l-2.914-5.644-.757-1.71-.345 1.71zm1.958-3.42-.726 3.663a1.255 1.255 0 0 1-1.232 1.011h-1.827a1.255 1.255 0 0 1-1.229-1.509l2.501-12.095a1.255 1.255 0 0 1 1.23-1.001h.197a1.25 1.25 0 0 1 1.12.685l3.19 6.273 3.125-6.263a1.25 1.25 0 0 1 1.123-.695h.181a1.255 1.255 0 0 1 1.227.991l1.443 6.71a5 5 0 0 1 .314-.787l.009-.016a4.6 4.6 0 0 1 1.777-1.887c.782-.46 1.668-.667 2.611-.667a4.6 4.6 0 0 1 1.7.32l.306.134c.21-.16.474-.256.759-.256h1.694a1.255 1.255 0 0 1 1.212.925 1.255 1.255 0 0 1 1.212-.925h1.711c.284 0 .545.094.755.252.613-.3 1.312-.45 2.075-.45 1.356 0 2.557.445 3.482 1.4q.47.48.763 1.064V4.701a1.255 1.255 0 0 1 1.255-1.255h1.86A1.255 1.255 0 0 1 54.44 4.7v9.194h2.217c.19 0 .37.043.532.118v-4.77c0-.356.147-.678.385-.906a2.42 2.42 0 0 1-.682-1.71c0-.665.267-1.253.735-1.7a2.45 2.45 0 0 1 1.722-.674 2.43 2.43 0 0 1 1.705.675q.318.302.504.683V4.7a1.255 1.255 0 0 1 1.255-1.255h1.744A1.255 1.255 0 0 1 65.812 4.7v3.335a4.8 4.8 0 0 1 1.526-.246c.938 0 1.817.214 2.59.69a4.47 4.47 0 0 1 1.67 1.743v-.98a1.255 1.255 0 0 1 1.256-1.256h1.777c.233 0 .451.064.639.174a3.4 3.4 0 0 1 1.567-.372c.346 0 .861.02 1.285.232a1.25 1.25 0 0 1 .689 1.004 4.7 4.7 0 0 1 .853-.588c.795-.44 1.675-.647 2.61-.647 1.385 0 2.65.39 3.525 1.396.836.938 1.168 2.173 1.168 3.528q-.001.515-.056 1.051a1.255 1.255 0 0 1-.947 1.09l.408.952a1.255 1.255 0 0 1-.477 1.552c-.418.268-.92.463-1.458.612-.613.171-1.304.244-2.049.244-1.06 0-2.043-.207-2.886-.698l-.015-.008c-.798-.48-1.419-1.135-1.818-1.963l-.004-.008a5.8 5.8 0 0 1-.548-2.512q0-.429.053-.843a1.3 1.3 0 0 1-.333-.086l-.166-.004c-.223 0-.426.062-.643.228-.03.024-.142.139-.142.59v3.883a1.255 1.255 0 0 1-1.256 1.256h-1.777a1.255 1.255 0 0 1-1.256-1.256V15.69l-.032.057a4.8 4.8 0 0 1-1.86 1.833 5.04 5.04 0 0 1-2.484.634 4.5 4.5 0 0 1-1.935-.424 1.25 1.25 0 0 1-.764.258h-1.71a1.255 1.255 0 0 1-1.256-1.255V7.687a2.4 2.4 0 0 1-.428.625c.253.23.412.561.412.93v7.553a1.255 1.255 0 0 1-1.256 1.255h-1.843a1.25 1.25 0 0 1-.894-.373c-.228.23-.544.373-.894.373H51.32a1.255 1.255 0 0 1-1.256-1.255v-1.251l-.061.117a4.7 4.7 0 0 1-1.782 1.884 4.77 4.77 0 0 1-2.485.67 5.6 5.6 0 0 1-1.485-.188l.009 2.764a1.255 1.255 0 0 1-1.255 1.259h-1.729a1.255 1.255 0 0 1-1.255-1.255v-3.537a1.255 1.255 0 0 1-1.167.793h-1.679a1.25 1.25 0 0 1-.77-.263 4.5 4.5 0 0 1-1.945.429c-.885 0-1.724-.21-2.495-.632l-.017-.01a5 5 0 0 1-1.081-.836 1.255 1.255 0 0 1-1.254 1.312h-1.81a1.255 1.255 0 0 1-1.228-.99l-.782-3.625-2.044 3.939a1.25 1.25 0 0 1-1.115.676h-.098a1.25 1.25 0 0 1-1.116-.68l-2.061-3.994zM35.92 16.63l.207-.114.223-.15q.493-.356.735-.785l.061-.118.033 1.332h1.678V9.242h-1.694l-.033 1.267q-.133-.329-.526-.658l-.032-.028a3.2 3.2 0 0 0-.668-.428l-.27-.12a3.3 3.3 0 0 0-1.235-.23q-1.136-.001-1.974.493a3.36 3.36 0 0 0-1.3 1.382q-.445.89-.444 2.074 0 1.2.51 2.107a3.8 3.8 0 0 0 1.382 1.381 3.9 3.9 0 0 0 1.893.477q.795 0 1.455-.33zm-2.789-5.38q-.576.675-.575 1.762 0 1.102.559 1.794.576.675 1.645.675a2.25 2.25 0 0 0 .934-.19 2.2 2.2 0 0 0 .468-.29l.178-.161a2.2 2.2 0 0 0 .397-.561q.244-.5.244-1.15v-.115q0-.708-.296-1.267l-.043-.077a2.2 2.2 0 0 0-.633-.709l-.13-.086-.047-.028a2.1 2.1 0 0 0-1.073-.285q-1.052 0-1.629.692zm2.316 2.706c.163-.17.28-.407.28-.83v-.114c0-.292-.06-.508-.15-.68a.96.96 0 0 0-.353-.389.85.85 0 0 0-.464-.127c-.4 0-.56.114-.664.239l-.01.012c-.148.174-.275.45-.275.945 0 .506.122.801.27.99.097.11.266.224.68.224.303 0 .504-.09.687-.269zm7.545 1.705a2.6 2.6 0 0 0 .331.423q.319.33.755.548l.173.074q.65.255 1.49.255 1.02 0 1.844-.493a3.45 3.45 0 0 0 1.316-1.4q.493-.904.493-2.089 0-1.909-.988-2.913-.988-1.02-2.584-1.02-.898 0-1.575.347a3 3 0 0 0-.415.262l-.199.166a3.4 3.4 0 0 0-.64.82V9.242h-1.712v11.553h1.729l-.017-5.134zm.53-1.138q.206.29.48.5l.155.11.053.034q.51.296 1.119.297 1.07 0 1.645-.675.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.435 0-.835.16a2 2 0 0 0-.284.136 2 2 0 0 0-.363.254 2.2 2.2 0 0 0-.46.569l-.082.162a2.6 2.6 0 0 0-.213 1.072v.115q0 .707.296 1.267l.135.211zm.964-.818a1.1 1.1 0 0 0 .367.385.94.94 0 0 0 .476.118c.423 0 .59-.117.687-.23.159-.194.28-.478.28-.95 0-.53-.133-.8-.266-.952l-.021-.025c-.078-.094-.231-.221-.68-.221a1 1 0 0 0-.503.135l-.012.007a.86.86 0 0 0-.335.343c-.073.133-.132.324-.132.614v.115a1.4 1.4 0 0 0 .14.66zm15.7-6.222q.347-.346.346-.856a1.05 1.05 0 0 0-.345-.79 1.18 1.18 0 0 0-.84-.329q-.51 0-.855.33a1.05 1.05 0 0 0-.346.79q0 .51.346.855.345.346.856.346.51 0 .839-.346zm4.337 9.314.033-1.332q.191.403.59.747l.098.081a4 4 0 0 0 .316.224l.223.122a3.2 3.2 0 0 0 1.44.322 3.8 3.8 0 0 0 1.875-.477 3.5 3.5 0 0 0 1.382-1.366q.527-.89.526-2.09 0-1.184-.444-2.073a3.24 3.24 0 0 0-1.283-1.399q-.823-.51-1.942-.51a3.5 3.5 0 0 0-1.527.344l-.086.043-.165.09a3 3 0 0 0-.33.214q-.432.315-.656.707a2 2 0 0 0-.099.198l.082-1.283V4.701h-1.744v12.095zm.473-2.509a2.5 2.5 0 0 0 .566.7q.117.098.245.18l.144.08a2.1 2.1 0 0 0 .975.232q1.07 0 1.645-.675.576-.69.576-1.778 0-1.102-.576-1.777-.56-.691-1.645-.692a2.2 2.2 0 0 0-1.015.235q-.22.113-.415.282l-.15.142a2.1 2.1 0 0 0-.42.594q-.223.479-.223 1.1v.115q0 .705.293 1.26zm2.616-.293c.157-.191.28-.479.28-.967 0-.51-.13-.79-.276-.961l-.021-.026c-.082-.1-.232-.225-.67-.225a.87.87 0 0 0-.681.279l-.012.011c-.154.155-.274.38-.274.807v.115c0 .285.057.499.144.669a1.1 1.1 0 0 0 .367.405c.137.082.28.123.455.123.423 0 .59-.118.686-.23zm8.266-3.013q.345-.13.724-.14l.069-.002q.493 0 .642.099l.247-1.794q-.196-.099-.717-.099a2.3 2.3 0 0 0-.545.063 2 2 0 0 0-.411.148 2.2 2.2 0 0 0-.4.249 2.5 2.5 0 0 0-.485.499 2.7 2.7 0 0 0-.32.581l-.05.137v-1.48h-1.778v7.553h1.777v-3.884q0-.546.159-.943a1.5 1.5 0 0 1 .466-.636 2.5 2.5 0 0 1 .399-.253 2 2 0 0 1 .224-.099zm9.784 2.656.05-.922q0-1.743-.856-2.698-.838-.97-2.584-.97-1.119-.001-2.007.493a3.46 3.46 0 0 0-1.4 1.382q-.493.906-.493 2.106 0 1.07.428 1.975.428.89 1.332 1.432.906.526 2.255.526.973 0 1.668-.185l.044-.012.135-.04q.613-.184.984-.421l-.542-1.267q-.3.162-.642.274l-.297.087q-.51.131-1.3.131-.954 0-1.497-.444a1.6 1.6 0 0 1-.192-.193q-.366-.44-.512-1.234l-.004-.021zm-5.427-1.256-.003.022h3.752v-.138q-.011-.727-.288-1.118a1 1 0 0 0-.156-.176q-.46-.428-1.316-.428-.986 0-1.494.604-.379.45-.494 1.234zm-27.053 2.77V4.7h-1.86v12.095h5.333V15.15zm7.103-5.908v7.553h-1.843V9.242h1.843z\'/%3E%3Cpath fill=\'%23fff\' d=\'m19.63 11.151-.757-1.71-.345 1.71-1.12 5.644h-1.827L18.083 4.7h.197l3.325 6.533.988 2.19.988-2.19L26.839 4.7h.181l2.6 12.095h-1.81l-1.218-5.644-.362-1.71-.658 1.71-2.93 5.644h-.098l-2.913-5.644zm14.836 5.81q-1.02 0-1.893-.478a3.8 3.8 0 0 1-1.381-1.382q-.51-.906-.51-2.106 0-1.185.444-2.074a3.36 3.36 0 0 1 1.3-1.382q.839-.494 1.974-.494a3.3 3.3 0 0 1 1.234.231 3.3 3.3 0 0 1 .97.575q.396.33.527.659l.033-1.267h1.694v7.553H37.18l-.033-1.332q-.279.593-1.02 1.053a3.17 3.17 0 0 1-1.662.444zm.296-1.482q.938 0 1.58-.642.642-.66.642-1.711v-.115q0-.708-.296-1.267a2.2 2.2 0 0 0-.807-.872 2.1 2.1 0 0 0-1.119-.313q-1.053 0-1.629.692-.575.675-.575 1.76 0 1.103.559 1.795.577.675 1.645.675zm6.521-6.237h1.711v1.4q.906-1.597 2.83-1.597 1.596 0 2.584 1.02.988 1.005.988 2.914 0 1.185-.493 2.09a3.46 3.46 0 0 1-1.316 1.399 3.5 3.5 0 0 1-1.844.493q-.954 0-1.662-.329a2.67 2.67 0 0 1-1.086-.97l.017 5.134h-1.728zm4.048 6.22q1.07 0 1.645-.674.577-.69.576-1.762 0-1.119-.576-1.777-.558-.675-1.645-.675-.592 0-1.12.296-.51.28-.822.823-.296.527-.296 1.234v.115q0 .708.296 1.267.313.543.823.855.51.296 1.119.297z\'/%3E%3Cpath fill=\'%23e1e3e9\' d=\'M51.325 4.7h1.86v10.45h3.473v1.646h-5.333zm7.12 4.542h1.843v7.553h-1.843zm.905-1.415a1.16 1.16 0 0 1-.856-.346 1.17 1.17 0 0 1-.346-.856 1.05 1.05 0 0 1 .346-.79q.346-.329.856-.329.494 0 .839.33a1.05 1.05 0 0 1 .345.79 1.16 1.16 0 0 1-.345.855q-.33.346-.84.346zm7.875 9.133a3.17 3.17 0 0 1-1.662-.444q-.723-.46-1.004-1.053l-.033 1.332h-1.71V4.701h1.743v4.657l-.082 1.283q.279-.658 1.086-1.119a3.5 3.5 0 0 1 1.778-.477q1.119 0 1.942.51a3.24 3.24 0 0 1 1.283 1.4q.445.888.444 2.072 0 1.201-.526 2.09a3.5 3.5 0 0 1-1.382 1.366 3.8 3.8 0 0 1-1.876.477zm-.296-1.481q1.069 0 1.645-.675.577-.69.577-1.778 0-1.102-.577-1.776-.56-.691-1.645-.692a2.12 2.12 0 0 0-1.58.659q-.642.641-.642 1.694v.115q0 .71.296 1.267a2.4 2.4 0 0 0 .807.872 2.1 2.1 0 0 0 1.119.313zm5.927-6.237h1.777v1.481q.263-.757.856-1.217a2.14 2.14 0 0 1 1.349-.46q.527 0 .724.098l-.247 1.794q-.149-.099-.642-.099-.774 0-1.416.494-.626.493-.626 1.58v3.883h-1.777V9.242zm9.534 7.718q-1.35 0-2.255-.526-.904-.543-1.332-1.432a4.6 4.6 0 0 1-.428-1.975q0-1.2.493-2.106a3.46 3.46 0 0 1 1.4-1.382q.889-.495 2.007-.494 1.744 0 2.584.97.855.956.856 2.7 0 .444-.05.92h-5.43q.18 1.005.708 1.45.542.443 1.497.443.79 0 1.3-.131a4 4 0 0 0 .938-.362l.542 1.267q-.411.263-1.119.46-.708.198-1.711.197zm1.596-4.558q.016-1.02-.444-1.432-.46-.428-1.316-.428-1.728 0-1.991 1.86z\'/%3E%3Cpath d=\'M5.074 15.948a.484.657 0 0 0-.486.659v1.84a.484.657 0 0 0 .486.659h4.101a.484.657 0 0 0 .486-.659v-1.84a.484.657 0 0 0-.486-.659zm3.56 1.16H5.617v.838h3.017z\' style=\'fill:%23fff;fill-rule:evenodd;stroke-width:1.03600001\'/%3E%3Cg style=\'stroke-width:1.12603545\'%3E%3Cpath d=\'M-9.408-1.416c-3.833-.025-7.056 2.912-7.08 6.615-.02 3.08 1.653 4.832 3.107 6.268.903.892 1.721 1.74 2.32 2.902l-.525-.004c-.543-.003-.992.304-1.24.639a1.87 1.87 0 0 0-.362 1.121l-.011 1.877c-.003.402.104.787.347 1.125.244.338.688.653 1.23.656l4.142.028c.542.003.99-.306 1.238-.641a1.87 1.87 0 0 0 .363-1.121l.012-1.875a1.87 1.87 0 0 0-.348-1.127c-.243-.338-.688-.653-1.23-.656l-.518-.004c.597-1.145 1.425-1.983 2.348-2.87 1.473-1.414 3.18-3.149 3.2-6.226-.016-3.59-2.923-6.684-6.993-6.707m-.006 1.1v.002c3.274.02 5.92 2.532 5.9 5.6-.017 2.706-1.39 4.026-2.863 5.44-1.034.994-2.118 2.033-2.814 3.633-.018.041-.052.055-.075.065q-.013.004-.02.01a.34.34 0 0 1-.226.084.34.34 0 0 1-.224-.086l-.092-.077c-.699-1.615-1.768-2.669-2.781-3.67-1.454-1.435-2.797-2.762-2.78-5.478.02-3.067 2.7-5.545 5.975-5.523m-.02 2.826c-1.62-.01-2.944 1.315-2.955 2.96-.01 1.646 1.295 2.988 2.916 2.999h.002c1.621.01 2.943-1.316 2.953-2.961.011-1.646-1.294-2.988-2.916-2.998m-.005 1.1c1.017.006 1.829.83 1.822 1.89s-.83 1.874-1.848 1.867c-1.018-.006-1.829-.83-1.822-1.89s.83-1.874 1.848-1.868m-2.155 11.857 4.14.025c.271.002.49.305.487.676l-.013 1.875c-.003.37-.224.67-.495.668l-4.14-.025c-.27-.002-.487-.306-.485-.676l.012-1.875c.003-.37.224-.67.494-.668\' style=\'color:%23000;font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:medium;line-height:normal;font-family:sans-serif;font-variant-ligatures:normal;font-variant-position:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-alternates:normal;font-feature-settings:normal;text-indent:0;text-align:start;text-decoration:none;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:%23000;letter-spacing:normal;word-spacing:normal;text-transform:none;writing-mode:lr-tb;direction:ltr;text-orientation:mixed;dominant-baseline:auto;baseline-shift:baseline;text-anchor:start;white-space:normal;shape-padding:0;clip-rule:evenodd;display:inline;overflow:visible;visibility:visible;opacity:1;isolation:auto;mix-blend-mode:normal;color-interpolation:sRGB;color-interpolation-filters:linearRGB;solid-color:%23000;solid-opacity:1;vector-effect:none;fill:%23000;fill-opacity:.4;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;color-rendering:auto;image-rendering:auto;shape-rendering:auto;text-rendering:auto\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-9.415-.316C-12.69-.338-15.37 2.14-15.39 5.207c-.017 2.716 1.326 4.041 2.78 5.477 1.013 1 2.081 2.055 2.78 3.67l.092.076a.34.34 0 0 0 .225.086.34.34 0 0 0 .227-.083l.019-.01c.022-.009.057-.024.074-.064.697-1.6 1.78-2.64 2.814-3.634 1.473-1.414 2.847-2.733 2.864-5.44.02-3.067-2.627-5.58-5.901-5.601m-.057 8.784c1.621.011 2.944-1.315 2.955-2.96.01-1.646-1.295-2.988-2.916-2.999-1.622-.01-2.945 1.315-2.955 2.96s1.295 2.989 2.916 3\' style=\'clip-rule:evenodd;fill:%23e1e3e9;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3Cpath d=\'M-11.594 15.465c-.27-.002-.492.297-.494.668l-.012 1.876c-.003.371.214.673.485.675l4.14.027c.271.002.492-.298.495-.668l.012-1.877c.003-.37-.215-.672-.485-.674z\' style=\'clip-rule:evenodd;fill:%23fff;fill-opacity:1;fill-rule:evenodd;stroke:none;stroke-width:2.47727823;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:.4\' transform=\'translate(15.553 2.85)scale(.88807)\'/%3E%3C/g%3E%3C/svg%3E")}}.maplibregl-ctrl.maplibregl-ctrl-attrib{background-color:hsla(0,0%,100%,.5);margin:0;padding:0 5px}@media screen{.maplibregl-ctrl-attrib.maplibregl-compact{background-color:#fff;border-radius:12px;box-sizing:content-box;color:#000;margin:10px;min-height:20px;padding:2px 24px 2px 0;position:relative}.maplibregl-ctrl-attrib.maplibregl-compact-show{padding:2px 28px 2px 8px;visibility:visible}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact-show,.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact-show{border-radius:12px;padding:2px 8px 2px 28px}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-inner{display:none}.maplibregl-ctrl-attrib-button{background-color:hsla(0,0%,100%,.5);background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'24\' height=\'24\' fill-rule=\'evenodd\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0\'/%3E%3C/svg%3E");border:0;border-radius:12px;box-sizing:border-box;cursor:pointer;display:none;height:24px;outline:none;position:absolute;right:0;top:0;width:24px}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button{-webkit-appearance:none;-moz-appearance:none;appearance:none;list-style:none}.maplibregl-ctrl-attrib summary.maplibregl-ctrl-attrib-button::-webkit-details-marker{display:none}.maplibregl-ctrl-bottom-left .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-top-left .maplibregl-ctrl-attrib-button{left:0}.maplibregl-ctrl-attrib.maplibregl-compact .maplibregl-ctrl-attrib-button,.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-inner{display:block}.maplibregl-ctrl-attrib.maplibregl-compact-show .maplibregl-ctrl-attrib-button{background-color:rgb(0 0 0/5%)}.maplibregl-ctrl-bottom-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;right:0}.maplibregl-ctrl-top-right>.maplibregl-ctrl-attrib.maplibregl-compact:after{right:0;top:0}.maplibregl-ctrl-top-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{left:0;top:0}.maplibregl-ctrl-bottom-left>.maplibregl-ctrl-attrib.maplibregl-compact:after{bottom:0;left:0}}@media screen and (forced-colors:active){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'24\' height=\'24\' fill=\'%23fff\' fill-rule=\'evenodd\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0\'/%3E%3C/svg%3E")}}@media screen and (forced-colors:active) and (prefers-color-scheme:light){.maplibregl-ctrl-attrib.maplibregl-compact:after{background-image:url("data:image/svg+xml;charset=utf-8,%3Csvg xmlns=\'http://www.w3.org/2000/svg\' width=\'24\' height=\'24\' fill-rule=\'evenodd\' viewBox=\'0 0 20 20\'%3E%3Cpath d=\'M4 10a6 6 0 1 0 12 0 6 6 0 1 0-12 0m5-3a1 1 0 1 0 2 0 1 1 0 1 0-2 0m0 3a1 1 0 1 1 2 0v3a1 1 0 1 1-2 0\'/%3E%3C/svg%3E")}}.maplibregl-ctrl-attrib a{color:rgba(0,0,0,.75);text-decoration:none}.maplibregl-ctrl-attrib a:hover{color:inherit;text-decoration:underline}.maplibregl-attrib-empty{display:none}.maplibregl-ctrl-scale{background-color:hsla(0,0%,100%,.75);border:2px solid #333;border-top:#333;box-sizing:border-box;color:#333;font-size:10px;padding:0 5px}.maplibregl-popup{display:flex;left:0;pointer-events:none;position:absolute;top:0;will-change:transform}.maplibregl-popup-anchor-top,.maplibregl-popup-anchor-top-left,.maplibregl-popup-anchor-top-right{flex-direction:column}.maplibregl-popup-anchor-bottom,.maplibregl-popup-anchor-bottom-left,.maplibregl-popup-anchor-bottom-right{flex-direction:column-reverse}.maplibregl-popup-anchor-left{flex-direction:row}.maplibregl-popup-anchor-right{flex-direction:row-reverse}.maplibregl-popup-tip{border:10px solid transparent;height:0;width:0;z-index:1}.maplibregl-popup-anchor-top .maplibregl-popup-tip{align-self:center;border-bottom-color:#fff;border-top:none}.maplibregl-popup-anchor-top-left .maplibregl-popup-tip{align-self:flex-start;border-bottom-color:#fff;border-left:none;border-top:none}.maplibregl-popup-anchor-top-right .maplibregl-popup-tip{align-self:flex-end;border-bottom-color:#fff;border-right:none;border-top:none}.maplibregl-popup-anchor-bottom .maplibregl-popup-tip{align-self:center;border-bottom:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-tip{align-self:flex-start;border-bottom:none;border-left:none;border-top-color:#fff}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-tip{align-self:flex-end;border-bottom:none;border-right:none;border-top-color:#fff}.maplibregl-popup-anchor-left .maplibregl-popup-tip{align-self:center;border-left:none;border-right-color:#fff}.maplibregl-popup-anchor-right .maplibregl-popup-tip{align-self:center;border-left-color:#fff;border-right:none}.maplibregl-popup-close-button{background-color:transparent;border:0;border-radius:0 3px 0 0;cursor:pointer;position:absolute;right:0;top:0}.maplibregl-popup-close-button:hover{background-color:rgb(0 0 0/5%)}.maplibregl-popup-content{background:#fff;border-radius:3px;box-shadow:0 1px 2px rgba(0,0,0,.1);padding:15px 10px;pointer-events:auto;position:relative}.maplibregl-popup-anchor-top-left .maplibregl-popup-content{border-top-left-radius:0}.maplibregl-popup-anchor-top-right .maplibregl-popup-content{border-top-right-radius:0}.maplibregl-popup-anchor-bottom-left .maplibregl-popup-content{border-bottom-left-radius:0}.maplibregl-popup-anchor-bottom-right .maplibregl-popup-content{border-bottom-right-radius:0}.maplibregl-popup-track-pointer{display:none}.maplibregl-popup-track-pointer *{pointer-events:none;-webkit-user-select:none;-moz-user-select:none;user-select:none}.maplibregl-map:hover .maplibregl-popup-track-pointer{display:flex}.maplibregl-map:active .maplibregl-popup-track-pointer{display:none}.maplibregl-marker{left:0;position:absolute;top:0;transition:opacity .2s;will-change:transform}.maplibregl-user-location-dot,.maplibregl-user-location-dot:before{background-color:#1da1f2;border-radius:50%;height:15px;width:15px}.maplibregl-user-location-dot:before{animation:maplibregl-user-location-dot-pulse 2s infinite;content:"";position:absolute}.maplibregl-user-location-dot:after{border:2px solid #fff;border-radius:50%;box-shadow:0 0 3px rgba(0,0,0,.35);box-sizing:border-box;content:"";height:19px;left:-2px;position:absolute;top:-2px;width:19px}@keyframes maplibregl-user-location-dot-pulse{0%{opacity:1;transform:scale(1)}70%{opacity:0;transform:scale(3)}to{opacity:0;transform:scale(1)}}.maplibregl-user-location-dot-stale{background-color:#aaa}.maplibregl-user-location-dot-stale:after{display:none}.maplibregl-user-location-accuracy-circle{background-color:#1da1f233;border-radius:100%;height:1px;width:1px}.maplibregl-crosshair,.maplibregl-crosshair .maplibregl-interactive,.maplibregl-crosshair .maplibregl-interactive:active{cursor:crosshair}.maplibregl-boxzoom{background:#fff;border:2px dotted #202020;height:0;left:0;opacity:.5;position:absolute;top:0;width:0}.maplibregl-cooperative-gesture-screen{align-items:center;background:rgba(0,0,0,.4);color:#fff;display:flex;font-size:1.4em;inset:0;justify-content:center;line-height:1.2;opacity:0;padding:1rem;pointer-events:none;position:absolute;transition:opacity 1s ease 1s;z-index:99999}.maplibregl-cooperative-gesture-screen.maplibregl-show{opacity:1;transition:opacity .05s}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:none}@media (hover:none),(width <= 480px){.maplibregl-cooperative-gesture-screen .maplibregl-desktop-message{display:none}.maplibregl-cooperative-gesture-screen .maplibregl-mobile-message{display:block}}.maplibregl-pseudo-fullscreen{height:100%!important;left:0!important;position:fixed!important;top:0!important;width:100%!important;z-index:99999}`, document.head.appendChild(e3);\n              }\n            })();\n          });\n          var qa = ye((el) => {\n            "use strict";\n            var f32 = G1(), Kre = w6(), Jre = zO(), fit = my(), hit = NS().addStyleRule, $re = Ao(), dit = Gl(), vit = c3(), pit = $re.extendFlat, VO = $re.extendDeepAll;\n            el.modules = {};\n            el.allCategories = {};\n            el.allTypes = [];\n            el.subplotsRegistry = {};\n            el.componentsRegistry = {};\n            el.layoutArrayContainers = [];\n            el.layoutArrayRegexes = [];\n            el.traceLayoutAttributes = {};\n            el.localeRegistry = {};\n            el.apiMethodRegistry = {};\n            el.collectableSubplotTypes = null;\n            el.register = function(t3) {\n              if (el.collectableSubplotTypes = null, t3) t3 && !Array.isArray(t3) && (t3 = [t3]);\n              else throw new Error("No argument passed to Plotly.register.");\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                if (!n4) throw new Error("Invalid module was attempted to be registered!");\n                switch (n4.moduleType) {\n                  case "trace":\n                    git(n4);\n                    break;\n                  case "transform":\n                    _it(n4);\n                    break;\n                  case "component":\n                    yit(n4);\n                    break;\n                  case "locale":\n                    xit(n4);\n                    break;\n                  case "apiMethod":\n                    var i3 = n4.name;\n                    el.apiMethodRegistry[i3] = n4.fn;\n                    break;\n                  default:\n                    throw new Error("Invalid module was attempted to be registered!");\n                }\n              }\n            };\n            el.getModule = function(e3) {\n              var t3 = el.modules[rie(e3)];\n              return t3 ? t3._module : false;\n            };\n            el.traceIs = function(e3, t3) {\n              if (e3 = rie(e3), e3 === "various") return false;\n              var r4 = el.modules[e3];\n              return r4 || (e3 && f32.log("Unrecognized trace type " + e3 + "."), r4 = el.modules[dit.type.dflt]), !!r4.categories[t3];\n            };\n            el.getComponentMethod = function(e3, t3) {\n              var r4 = el.componentsRegistry[e3];\n              return r4 && r4[t3] || Kre;\n            };\n            el.call = function() {\n              var e3 = arguments[0], t3 = [].slice.call(arguments, 1);\n              return el.apiMethodRegistry[e3].apply(null, t3);\n            };\n            function git(e3) {\n              var t3 = e3.name, r4 = e3.categories, n4 = e3.meta;\n              if (el.modules[t3]) {\n                f32.log("Type " + t3 + " already registered");\n                return;\n              }\n              el.subplotsRegistry[e3.basePlotModule.name] || mit(e3.basePlotModule);\n              for (var i3 = {}, a4 = 0; a4 < r4.length; a4++) i3[r4[a4]] = true, el.allCategories[r4[a4]] = true;\n              el.modules[t3] = { _module: e3, categories: i3 }, n4 && Object.keys(n4).length && (el.modules[t3].meta = n4), el.allTypes.push(t3);\n              for (var o4 in el.componentsRegistry) eie(o4, t3);\n              e3.layoutAttributes && pit(el.traceLayoutAttributes, e3.layoutAttributes);\n              var s3 = e3.basePlotModule, l3 = s3.name;\n              if (l3 === "mapbox") {\n                var u4 = s3.constants.styleRules;\n                for (var c5 in u4) hit(".js-plotly-plot .plotly .mapboxgl-" + c5, u4[c5]);\n              }\n              l3 === "map" && Yre(), (l3 === "geo" || l3 === "mapbox" || l3 === "map") && window.PlotlyGeoAssets === void 0 && (window.PlotlyGeoAssets = { topojson: {} });\n            }\n            function mit(e3) {\n              var t3 = e3.name;\n              if (el.subplotsRegistry[t3]) {\n                f32.log("Plot type " + t3 + " already registered.");\n                return;\n              }\n              Qre(e3), el.subplotsRegistry[t3] = e3;\n              for (var r4 in el.componentsRegistry) tie(r4, e3.name);\n            }\n            function yit(e3) {\n              if (typeof e3.name != "string") throw new Error("Component module *name* must be a string.");\n              var t3 = e3.name;\n              el.componentsRegistry[t3] = e3, e3.layoutAttributes && (e3.layoutAttributes._isLinkedToArray && Jre(el.layoutArrayContainers, t3), Qre(e3));\n              for (var r4 in el.modules) eie(t3, r4);\n              for (var n4 in el.subplotsRegistry) tie(t3, n4);\n              e3.schema && e3.schema.layout && VO(vit, e3.schema.layout);\n            }\n            function _it(e3) {\n              if (typeof e3.name != "string") throw new Error("Transform module *name* must be a string.");\n              var t3 = "Transform module " + e3.name, r4 = typeof e3.transform == "function", n4 = typeof e3.calcTransform == "function";\n              if (!r4 && !n4) throw new Error(t3 + " is missing a *transform* or *calcTransform* method.");\n              r4 && n4 && f32.log([t3 + " has both a *transform* and *calcTransform* methods.", "Please note that all *transform* methods are executed", "before all *calcTransform* methods."].join(" ")), fit(e3.attributes) || f32.log(t3 + " registered without an *attributes* object."), typeof e3.supplyDefaults != "function" && f32.log(t3 + " registered without a *supplyDefaults* method.");\n            }\n            function xit(e3) {\n              var t3 = e3.name, r4 = t3.split("-")[0], n4 = e3.dictionary, i3 = e3.format, a4 = n4 && Object.keys(n4).length, o4 = i3 && Object.keys(i3).length, s3 = el.localeRegistry, l3 = s3[t3];\n              if (l3 || (s3[t3] = l3 = {}), r4 !== t3) {\n                var u4 = s3[r4];\n                u4 || (s3[r4] = u4 = {}), a4 && u4.dictionary === l3.dictionary && (u4.dictionary = n4), o4 && u4.format === l3.format && (u4.format = i3);\n              }\n              a4 && (l3.dictionary = n4), o4 && (l3.format = i3);\n            }\n            function Qre(e3) {\n              if (e3.layoutAttributes) {\n                var t3 = e3.layoutAttributes._arrayAttrRegexps;\n                if (t3) for (var r4 = 0; r4 < t3.length; r4++) Jre(el.layoutArrayRegexes, t3[r4]);\n              }\n            }\n            function eie(e3, t3) {\n              var r4 = el.componentsRegistry[e3].schema;\n              if (!(!r4 || !r4.traces)) {\n                var n4 = r4.traces[t3];\n                n4 && VO(el.modules[t3]._module.attributes, n4);\n              }\n            }\n            function tie(e3, t3) {\n              var r4 = el.componentsRegistry[e3].schema;\n              if (!(!r4 || !r4.subplots)) {\n                var n4 = el.subplotsRegistry[t3], i3 = n4.layoutAttributes, a4 = n4.attr === "subplot" ? n4.name : n4.attr;\n                Array.isArray(a4) && (a4 = a4[0]);\n                var o4 = r4.subplots[a4];\n                i3 && o4 && VO(i3, o4);\n              }\n            }\n            function rie(e3) {\n              return typeof e3 == "object" && (e3 = e3.type), e3;\n            }\n          });\n          var fie = ye((hh) => {\n            "use strict";\n            var bit = r3().timeFormat, uie = Eo(), GO = G1(), X1 = n3().mod, v3 = fs(), y0 = v3.BADNUM, Tp = v3.ONEDAY, VS = v3.ONEHOUR, W1 = v3.ONEMIN, d3 = v3.ONESEC, GS = v3.EPOCHJD, yy = qa(), iie = r3().utcFormat, wit = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\d)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m, Tit = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)(-(\\d?\\di?)(-(\\d?\\d)([ Tt]([01]?\\d|2[0-3])(:([0-5]\\d)(:([0-5]\\d(\\.\\d+)?))?(Z|z|[+\\-]\\d\\d(:?\\d\\d)?)?)?)?)?)?\\s*$/m, nie = (/* @__PURE__ */ new Date()).getFullYear() - 70;\n            function _y(e3) {\n              return e3 && yy.componentsRegistry.calendars && typeof e3 == "string" && e3 !== "gregorian";\n            }\n            hh.dateTick0 = function(e3, t3) {\n              var r4 = Ait(e3, !!t3);\n              if (t3 < 2) return r4;\n              var n4 = hh.dateTime2ms(r4, e3);\n              return n4 += Tp * (t3 - 1), hh.ms2DateTime(n4, 0, e3);\n            };\n            function Ait(e3, t3) {\n              return _y(e3) ? t3 ? yy.getComponentMethod("calendars", "CANONICAL_SUNDAY")[e3] : yy.getComponentMethod("calendars", "CANONICAL_TICK")[e3] : t3 ? "2000-01-02" : "2000-01-01";\n            }\n            hh.dfltRange = function(e3) {\n              return _y(e3) ? yy.getComponentMethod("calendars", "DFLTRANGE")[e3] : ["2000-01-01", "2001-01-01"];\n            };\n            hh.isJSDate = function(e3) {\n              return typeof e3 == "object" && e3 !== null && typeof e3.getTime == "function";\n            };\n            var P6, I6;\n            hh.dateTime2ms = function(e3, t3) {\n              if (hh.isJSDate(e3)) {\n                var r4 = e3.getTimezoneOffset() * W1, n4 = (e3.getUTCMinutes() - e3.getMinutes()) * W1 + (e3.getUTCSeconds() - e3.getSeconds()) * d3 + (e3.getUTCMilliseconds() - e3.getMilliseconds());\n                if (n4) {\n                  var i3 = 3 * W1;\n                  r4 = r4 - i3 / 2 + X1(n4 - r4 + i3 / 2, i3);\n                }\n                return e3 = Number(e3) - r4, e3 >= P6 && e3 <= I6 ? e3 : y0;\n              }\n              if (typeof e3 != "string" && typeof e3 != "number") return y0;\n              e3 = String(e3);\n              var a4 = _y(t3), o4 = e3.charAt(0);\n              a4 && (o4 === "G" || o4 === "g") && (e3 = e3.slice(1), t3 = "");\n              var s3 = a4 && t3.slice(0, 7) === "chinese", l3 = e3.match(s3 ? Tit : wit);\n              if (!l3) return y0;\n              var u4 = l3[1], c5 = l3[3] || "1", f4 = Number(l3[5] || 1), h4 = Number(l3[7] || 0), d4 = Number(l3[9] || 0), v4 = Number(l3[11] || 0);\n              if (a4) {\n                if (u4.length === 2) return y0;\n                u4 = Number(u4);\n                var _2;\n                try {\n                  var b = yy.getComponentMethod("calendars", "getCal")(t3);\n                  if (s3) {\n                    var p3 = c5.charAt(c5.length - 1) === "i";\n                    c5 = parseInt(c5, 10), _2 = b.newDate(u4, b.toMonthIndex(u4, c5, p3), f4);\n                  } else _2 = b.newDate(u4, Number(c5), f4);\n                } catch (E3) {\n                  return y0;\n                }\n                return _2 ? (_2.toJD() - GS) * Tp + h4 * VS + d4 * W1 + v4 * d3 : y0;\n              }\n              u4.length === 2 ? u4 = (Number(u4) + 2e3 - nie) % 100 + nie : u4 = Number(u4), c5 -= 1;\n              var k4 = new Date(Date.UTC(2e3, c5, f4, h4, d4));\n              return k4.setUTCFullYear(u4), k4.getUTCMonth() !== c5 || k4.getUTCDate() !== f4 ? y0 : k4.getTime() + v4 * d3;\n            };\n            P6 = hh.MIN_MS = hh.dateTime2ms("-9999");\n            I6 = hh.MAX_MS = hh.dateTime2ms("9999-12-31 23:59:59.9999");\n            hh.isDateTime = function(e3, t3) {\n              return hh.dateTime2ms(e3, t3) !== y0;\n            };\n            function h3(e3, t3) {\n              return String(e3 + Math.pow(10, t3)).slice(1);\n            }\n            var L6 = 90 * Tp, aie = 3 * VS, oie = 5 * W1;\n            hh.ms2DateTime = function(e3, t3, r4) {\n              if (typeof e3 != "number" || !(e3 >= P6 && e3 <= I6)) return y0;\n              t3 || (t3 = 0);\n              var n4 = Math.floor(X1(e3 + 0.05, 1) * 10), i3 = Math.round(e3 - n4 / 10), a4, o4, s3, l3, u4, c5;\n              if (_y(r4)) {\n                var f4 = Math.floor(i3 / Tp) + GS, h4 = Math.floor(X1(e3, Tp));\n                try {\n                  a4 = yy.getComponentMethod("calendars", "getCal")(r4).fromJD(f4).formatDate("yyyy-mm-dd");\n                } catch (d4) {\n                  a4 = iie("G%Y-%m-%d")(new Date(i3));\n                }\n                if (a4.charAt(0) === "-") for (; a4.length < 11; ) a4 = "-0" + a4.slice(1);\n                else for (; a4.length < 10; ) a4 = "0" + a4;\n                o4 = t3 < L6 ? Math.floor(h4 / VS) : 0, s3 = t3 < L6 ? Math.floor(h4 % VS / W1) : 0, l3 = t3 < aie ? Math.floor(h4 % W1 / d3) : 0, u4 = t3 < oie ? h4 % d3 * 10 + n4 : 0;\n              } else c5 = new Date(i3), a4 = iie("%Y-%m-%d")(c5), o4 = t3 < L6 ? c5.getUTCHours() : 0, s3 = t3 < L6 ? c5.getUTCMinutes() : 0, l3 = t3 < aie ? c5.getUTCSeconds() : 0, u4 = t3 < oie ? c5.getUTCMilliseconds() * 10 + n4 : 0;\n              return cie(a4, o4, s3, l3, u4);\n            };\n            hh.ms2DateTimeLocal = function(e3) {\n              if (!(e3 >= P6 + Tp && e3 <= I6 - Tp)) return y0;\n              var t3 = Math.floor(X1(e3 + 0.05, 1) * 10), r4 = new Date(Math.round(e3 - t3 / 10)), n4 = bit("%Y-%m-%d")(r4), i3 = r4.getHours(), a4 = r4.getMinutes(), o4 = r4.getSeconds(), s3 = r4.getUTCMilliseconds() * 10 + t3;\n              return cie(n4, i3, a4, o4, s3);\n            };\n            function cie(e3, t3, r4, n4, i3) {\n              if ((t3 || r4 || n4 || i3) && (e3 += " " + h3(t3, 2) + ":" + h3(r4, 2), (n4 || i3) && (e3 += ":" + h3(n4, 2), i3))) {\n                for (var a4 = 4; i3 % 10 === 0; ) a4 -= 1, i3 /= 10;\n                e3 += "." + h3(i3, a4);\n              }\n              return e3;\n            }\n            hh.cleanDate = function(e3, t3, r4) {\n              if (e3 === y0) return t3;\n              if (hh.isJSDate(e3) || typeof e3 == "number" && isFinite(e3)) {\n                if (_y(r4)) return GO.error("JS Dates and milliseconds are incompatible with world calendars", e3), t3;\n                if (e3 = hh.ms2DateTimeLocal(+e3), !e3 && t3 !== void 0) return t3;\n              } else if (!hh.isDateTime(e3, r4)) return GO.error("unrecognized date", e3), t3;\n              return e3;\n            };\n            var Sit = /%\\d?f/g, Mit = /%h/g, Eit = { 1: "1", 2: "1", 3: "2", 4: "2" };\n            function sie(e3, t3, r4, n4) {\n              e3 = e3.replace(Sit, function(a4) {\n                var o4 = Math.min(+a4.charAt(1) || 6, 6), s3 = (t3 / 1e3 % 1 + 2).toFixed(o4).slice(2).replace(/0+$/, "") || "0";\n                return s3;\n              });\n              var i3 = new Date(Math.floor(t3 + 0.05));\n              if (e3 = e3.replace(Mit, function() {\n                return Eit[r4("%q")(i3)];\n              }), _y(n4)) try {\n                e3 = yy.getComponentMethod("calendars", "worldCalFmt")(e3, t3, n4);\n              } catch (a4) {\n                return "Invalid";\n              }\n              return r4(e3)(i3);\n            }\n            var kit = [59, 59.9, 59.99, 59.999, 59.9999];\n            function Cit(e3, t3) {\n              var r4 = X1(e3 + 0.05, Tp), n4 = h3(Math.floor(r4 / VS), 2) + ":" + h3(X1(Math.floor(r4 / W1), 60), 2);\n              if (t3 !== "M") {\n                uie(t3) || (t3 = 0);\n                var i3 = Math.min(X1(e3 / d3, 60), kit[t3]), a4 = (100 + i3).toFixed(t3).slice(1);\n                t3 > 0 && (a4 = a4.replace(/0+$/, "").replace(/[\\.]$/, "")), n4 += ":" + a4;\n              }\n              return n4;\n            }\n            hh.formatDate = function(e3, t3, r4, n4, i3, a4) {\n              if (i3 = _y(i3) && i3, !t3) if (r4 === "y") t3 = a4.year;\n              else if (r4 === "m") t3 = a4.month;\n              else if (r4 === "d") t3 = a4.dayMonth + `\n` + a4.year;\n              else return Cit(e3, r4) + `\n` + sie(a4.dayMonthYear, e3, n4, i3);\n              return sie(t3, e3, n4, i3);\n            };\n            var lie = 3 * Tp;\n            hh.incrementMonth = function(e3, t3, r4) {\n              r4 = _y(r4) && r4;\n              var n4 = X1(e3, Tp);\n              if (e3 = Math.round(e3 - n4), r4) try {\n                var i3 = Math.round(e3 / Tp) + GS, a4 = yy.getComponentMethod("calendars", "getCal")(r4), o4 = a4.fromJD(i3);\n                return t3 % 12 ? a4.add(o4, t3, "m") : a4.add(o4, t3 / 12, "y"), (o4.toJD() - GS) * Tp + n4;\n              } catch (l3) {\n                GO.error("invalid ms " + e3 + " in calendar " + r4);\n              }\n              var s3 = new Date(e3 + lie);\n              return s3.setUTCMonth(s3.getUTCMonth() + t3) + n4 - lie;\n            };\n            hh.findExactDates = function(e3, t3) {\n              for (var r4 = 0, n4 = 0, i3 = 0, a4 = 0, o4, s3, l3 = _y(t3) && yy.getComponentMethod("calendars", "getCal")(t3), u4 = 0; u4 < e3.length; u4++) {\n                if (s3 = e3[u4], !uie(s3)) {\n                  a4++;\n                  continue;\n                }\n                if (!(s3 % Tp)) if (l3) try {\n                  o4 = l3.fromJD(s3 / Tp + GS), o4.day() === 1 ? o4.month() === 1 ? r4++ : n4++ : i3++;\n                } catch (f4) {\n                }\n                else o4 = new Date(s3), o4.getUTCDate() === 1 ? o4.getUTCMonth() === 0 ? r4++ : n4++ : i3++;\n              }\n              n4 += r4, i3 += n4;\n              var c5 = e3.length - a4;\n              return { exactYears: r4 / c5, exactMonths: n4 / c5, exactDays: i3 / c5 };\n            };\n          });\n          var HS = ye((kir, hie) => {\n            "use strict";\n            hie.exports = function(t3) {\n              return t3;\n            };\n          });\n          var R6 = ye((xy) => {\n            "use strict";\n            var Lit = Eo(), Pit = G1(), Iit = HS(), Rit = fs().BADNUM, HO = 1e-9;\n            xy.findBin = function(e3, t3, r4) {\n              if (Lit(t3.start)) return r4 ? Math.ceil((e3 - t3.start) / t3.size - HO) - 1 : Math.floor((e3 - t3.start) / t3.size + HO);\n              var n4 = 0, i3 = t3.length, a4 = 0, o4 = i3 > 1 ? (t3[i3 - 1] - t3[0]) / (i3 - 1) : 1, s3, l3;\n              for (o4 >= 0 ? l3 = r4 ? Dit : Fit : l3 = r4 ? Oit : zit, e3 += o4 * HO * (r4 ? -1 : 1) * (o4 >= 0 ? 1 : -1); n4 < i3 && a4++ < 100; ) s3 = Math.floor((n4 + i3) / 2), l3(t3[s3], e3) ? n4 = s3 + 1 : i3 = s3;\n              return a4 > 90 && Pit.log("Long binary search..."), n4 - 1;\n            };\n            function Dit(e3, t3) {\n              return e3 < t3;\n            }\n            function Fit(e3, t3) {\n              return e3 <= t3;\n            }\n            function zit(e3, t3) {\n              return e3 > t3;\n            }\n            function Oit(e3, t3) {\n              return e3 >= t3;\n            }\n            xy.sorterAsc = function(e3, t3) {\n              return e3 - t3;\n            };\n            xy.sorterDes = function(e3, t3) {\n              return t3 - e3;\n            };\n            xy.distinctVals = function(e3) {\n              var t3 = e3.slice();\n              t3.sort(xy.sorterAsc);\n              var r4;\n              for (r4 = t3.length - 1; r4 > -1 && t3[r4] === Rit; r4--) ;\n              for (var n4 = t3[r4] - t3[0] || 1, i3 = n4 / (r4 || 1) / 1e4, a4 = [], o4, s3 = 0; s3 <= r4; s3++) {\n                var l3 = t3[s3], u4 = l3 - o4;\n                o4 === void 0 ? (a4.push(l3), o4 = l3) : u4 > i3 && (n4 = Math.min(n4, u4), a4.push(l3), o4 = l3);\n              }\n              return { vals: a4, minDiff: n4 };\n            };\n            xy.roundUp = function(e3, t3, r4) {\n              for (var n4 = 0, i3 = t3.length - 1, a4, o4 = 0, s3 = r4 ? 0 : 1, l3 = r4 ? 1 : 0, u4 = r4 ? Math.ceil : Math.floor; n4 < i3 && o4++ < 100; ) a4 = u4((n4 + i3) / 2), t3[a4] <= e3 ? n4 = a4 + s3 : i3 = a4 - l3;\n              return t3[n4];\n            };\n            xy.sort = function(e3, t3) {\n              for (var r4 = 0, n4 = 0, i3 = 1; i3 < e3.length; i3++) {\n                var a4 = t3(e3[i3], e3[i3 - 1]);\n                if (a4 < 0 ? r4 = 1 : a4 > 0 && (n4 = 1), r4 && n4) return e3.sort(t3);\n              }\n              return n4 ? e3 : e3.reverse();\n            };\n            xy.findIndexOfMin = function(e3, t3) {\n              t3 = t3 || Iit;\n              for (var r4 = 1 / 0, n4, i3 = 0; i3 < e3.length; i3++) {\n                var a4 = t3(e3[i3]);\n                a4 < r4 && (r4 = a4, n4 = i3);\n              }\n              return n4;\n            };\n          });\n          var Z1 = ye((Lir, die) => {\n            "use strict";\n            die.exports = function(t3) {\n              return Object.keys(t3).sort();\n            };\n          });\n          var vie = ye((dh) => {\n            "use strict";\n            var jS = Eo(), qit = vv().isArrayOrTypedArray;\n            dh.aggNums = function(e3, t3, r4, n4) {\n              var i3, a4;\n              if ((!n4 || n4 > r4.length) && (n4 = r4.length), jS(t3) || (t3 = false), qit(r4[0])) {\n                for (a4 = new Array(n4), i3 = 0; i3 < n4; i3++) a4[i3] = dh.aggNums(e3, t3, r4[i3]);\n                r4 = a4;\n              }\n              for (i3 = 0; i3 < n4; i3++) jS(t3) ? jS(r4[i3]) && (t3 = e3(+t3, +r4[i3])) : t3 = r4[i3];\n              return t3;\n            };\n            dh.len = function(e3) {\n              return dh.aggNums(function(t3) {\n                return t3 + 1;\n              }, 0, e3);\n            };\n            dh.mean = function(e3, t3) {\n              return t3 || (t3 = dh.len(e3)), dh.aggNums(function(r4, n4) {\n                return r4 + n4;\n              }, 0, e3) / t3;\n            };\n            dh.geometricMean = function(e3, t3) {\n              return t3 || (t3 = dh.len(e3)), Math.pow(dh.aggNums(function(r4, n4) {\n                return r4 * n4;\n              }, 1, e3), 1 / t3);\n            };\n            dh.midRange = function(e3) {\n              if (!(e3 === void 0 || e3.length === 0)) return (dh.aggNums(Math.max, null, e3) + dh.aggNums(Math.min, null, e3)) / 2;\n            };\n            dh.variance = function(e3, t3, r4) {\n              return t3 || (t3 = dh.len(e3)), jS(r4) || (r4 = dh.mean(e3, t3)), dh.aggNums(function(n4, i3) {\n                return n4 + Math.pow(i3 - r4, 2);\n              }, 0, e3) / t3;\n            };\n            dh.stdev = function(e3, t3, r4) {\n              return Math.sqrt(dh.variance(e3, t3, r4));\n            };\n            dh.median = function(e3) {\n              var t3 = e3.slice().sort();\n              return dh.interp(t3, 0.5);\n            };\n            dh.interp = function(e3, t3) {\n              if (!jS(t3)) throw "n should be a finite number";\n              if (t3 = t3 * e3.length - 0.5, t3 < 0) return e3[0];\n              if (t3 > e3.length - 1) return e3[e3.length - 1];\n              var r4 = t3 % 1;\n              return r4 * e3[Math.ceil(t3)] + (1 - r4) * e3[Math.floor(t3)];\n            };\n          });\n          var _ie = ye((Iir, yie) => {\n            "use strict";\n            var pie = n3(), jO = pie.mod, Bit = pie.modHalf, WS = Math.PI, Y1 = 2 * WS;\n            function Nit(e3) {\n              return e3 / 180 * WS;\n            }\n            function Uit(e3) {\n              return e3 / WS * 180;\n            }\n            function WO(e3) {\n              return Math.abs(e3[1] - e3[0]) > Y1 - 1e-14;\n            }\n            function gie(e3, t3) {\n              return Bit(t3 - e3, Y1);\n            }\n            function Vit(e3, t3) {\n              return Math.abs(gie(e3, t3));\n            }\n            function mie(e3, t3) {\n              if (WO(t3)) return true;\n              var r4, n4;\n              t3[0] < t3[1] ? (r4 = t3[0], n4 = t3[1]) : (r4 = t3[1], n4 = t3[0]), r4 = jO(r4, Y1), n4 = jO(n4, Y1), r4 > n4 && (n4 += Y1);\n              var i3 = jO(e3, Y1), a4 = i3 + Y1;\n              return i3 >= r4 && i3 <= n4 || a4 >= r4 && a4 <= n4;\n            }\n            function Git(e3, t3, r4, n4) {\n              if (!mie(t3, n4)) return false;\n              var i3, a4;\n              return r4[0] < r4[1] ? (i3 = r4[0], a4 = r4[1]) : (i3 = r4[1], a4 = r4[0]), e3 >= i3 && e3 <= a4;\n            }\n            function XO(e3, t3, r4, n4, i3, a4, o4) {\n              i3 = i3 || 0, a4 = a4 || 0;\n              var s3 = WO([r4, n4]), l3, u4, c5, f4, h3;\n              s3 ? (l3 = 0, u4 = WS, c5 = Y1) : r4 < n4 ? (l3 = r4, c5 = n4) : (l3 = n4, c5 = r4), e3 < t3 ? (f4 = e3, h3 = t3) : (f4 = t3, h3 = e3);\n              function d3(p3, k4) {\n                return [p3 * Math.cos(k4) + i3, a4 - p3 * Math.sin(k4)];\n              }\n              var v3 = Math.abs(c5 - l3) <= WS ? 0 : 1;\n              function _2(p3, k4, E3) {\n                return "A" + [p3, p3] + " " + [0, v3, E3] + " " + d3(p3, k4);\n              }\n              var b;\n              return s3 ? f4 === null ? b = "M" + d3(h3, l3) + _2(h3, u4, 0) + _2(h3, c5, 0) + "Z" : b = "M" + d3(f4, l3) + _2(f4, u4, 0) + _2(f4, c5, 0) + "ZM" + d3(h3, l3) + _2(h3, u4, 1) + _2(h3, c5, 1) + "Z" : f4 === null ? (b = "M" + d3(h3, l3) + _2(h3, c5, 0), o4 && (b += "L0,0Z")) : b = "M" + d3(f4, l3) + "L" + d3(h3, l3) + _2(h3, c5, 0) + "L" + d3(f4, c5) + _2(f4, l3, 1) + "Z", b;\n            }\n            function Hit(e3, t3, r4, n4, i3) {\n              return XO(null, e3, t3, r4, n4, i3, 0);\n            }\n            function jit(e3, t3, r4, n4, i3) {\n              return XO(null, e3, t3, r4, n4, i3, 1);\n            }\n            function Wit(e3, t3, r4, n4, i3, a4) {\n              return XO(e3, t3, r4, n4, i3, a4, 1);\n            }\n            yie.exports = { deg2rad: Nit, rad2deg: Uit, angleDelta: gie, angleDist: Vit, isFullCircle: WO, isAngleInsideSector: mie, isPtInsideSector: Git, pathArc: Hit, pathSector: jit, pathAnnulus: Wit };\n          });\n          var xie = ye((hb) => {\n            "use strict";\n            hb.isLeftAnchor = function(t3) {\n              return t3.xanchor === "left" || t3.xanchor === "auto" && t3.x <= 1 / 3;\n            };\n            hb.isCenterAnchor = function(t3) {\n              return t3.xanchor === "center" || t3.xanchor === "auto" && t3.x > 1 / 3 && t3.x < 2 / 3;\n            };\n            hb.isRightAnchor = function(t3) {\n              return t3.xanchor === "right" || t3.xanchor === "auto" && t3.x >= 2 / 3;\n            };\n            hb.isTopAnchor = function(t3) {\n              return t3.yanchor === "top" || t3.yanchor === "auto" && t3.y >= 2 / 3;\n            };\n            hb.isMiddleAnchor = function(t3) {\n              return t3.yanchor === "middle" || t3.yanchor === "auto" && t3.y > 1 / 3 && t3.y < 2 / 3;\n            };\n            hb.isBottomAnchor = function(t3) {\n              return t3.yanchor === "bottom" || t3.yanchor === "auto" && t3.y <= 1 / 3;\n            };\n          });\n          var Tie = ye((db) => {\n            "use strict";\n            var ZO = n3().mod;\n            db.segmentsIntersect = wie;\n            function wie(e3, t3, r4, n4, i3, a4, o4, s3) {\n              var l3 = r4 - e3, u4 = i3 - e3, c5 = o4 - i3, f4 = n4 - t3, h3 = a4 - t3, d3 = s3 - a4, v3 = l3 * d3 - c5 * f4;\n              if (v3 === 0) return null;\n              var _2 = (u4 * d3 - c5 * h3) / v3, b = (u4 * f4 - l3 * h3) / v3;\n              return b < 0 || b > 1 || _2 < 0 || _2 > 1 ? null : { x: e3 + l3 * _2, y: t3 + f4 * _2 };\n            }\n            db.segmentDistance = function(t3, r4, n4, i3, a4, o4, s3, l3) {\n              if (wie(t3, r4, n4, i3, a4, o4, s3, l3)) return 0;\n              var u4 = n4 - t3, c5 = i3 - r4, f4 = s3 - a4, h3 = l3 - o4, d3 = u4 * u4 + c5 * c5, v3 = f4 * f4 + h3 * h3, _2 = Math.min(D6(u4, c5, d3, a4 - t3, o4 - r4), D6(u4, c5, d3, s3 - t3, l3 - r4), D6(f4, h3, v3, t3 - a4, r4 - o4), D6(f4, h3, v3, n4 - a4, i3 - o4));\n              return Math.sqrt(_2);\n            };\n            function D6(e3, t3, r4, n4, i3) {\n              var a4 = n4 * e3 + i3 * t3;\n              if (a4 < 0) return n4 * n4 + i3 * i3;\n              if (a4 > r4) {\n                var o4 = n4 - e3, s3 = i3 - t3;\n                return o4 * o4 + s3 * s3;\n              } else {\n                var l3 = n4 * t3 - i3 * e3;\n                return l3 * l3 / r4;\n              }\n            }\n            var F6, YO, bie;\n            db.getTextLocation = function(t3, r4, n4, i3) {\n              if ((t3 !== YO || i3 !== bie) && (F6 = {}, YO = t3, bie = i3), F6[n4]) return F6[n4];\n              var a4 = t3.getPointAtLength(ZO(n4 - i3 / 2, r4)), o4 = t3.getPointAtLength(ZO(n4 + i3 / 2, r4)), s3 = Math.atan((o4.y - a4.y) / (o4.x - a4.x)), l3 = t3.getPointAtLength(ZO(n4, r4)), u4 = (l3.x * 4 + a4.x + o4.x) / 6, c5 = (l3.y * 4 + a4.y + o4.y) / 6, f4 = { x: u4, y: c5, theta: s3 };\n              return F6[n4] = f4, f4;\n            };\n            db.clearLocationCache = function() {\n              YO = null;\n            };\n            db.getVisibleSegment = function(t3, r4, n4) {\n              var i3 = r4.left, a4 = r4.right, o4 = r4.top, s3 = r4.bottom, l3 = 0, u4 = t3.getTotalLength(), c5 = u4, f4, h3;\n              function d3(_2) {\n                var b = t3.getPointAtLength(_2);\n                _2 === 0 ? f4 = b : _2 === u4 && (h3 = b);\n                var p3 = b.x < i3 ? i3 - b.x : b.x > a4 ? b.x - a4 : 0, k4 = b.y < o4 ? o4 - b.y : b.y > s3 ? b.y - s3 : 0;\n                return Math.sqrt(p3 * p3 + k4 * k4);\n              }\n              for (var v3 = d3(l3); v3; ) {\n                if (l3 += v3 + n4, l3 > c5) return;\n                v3 = d3(l3);\n              }\n              for (v3 = d3(c5); v3; ) {\n                if (c5 -= v3 + n4, l3 > c5) return;\n                v3 = d3(c5);\n              }\n              return { min: l3, max: c5, len: c5 - l3, total: u4, isClosed: l3 === 0 && c5 === u4 && Math.abs(f4.x - h3.x) < 0.1 && Math.abs(f4.y - h3.y) < 0.1 };\n            };\n            db.findPointOnPath = function(t3, r4, n4, i3) {\n              i3 = i3 || {};\n              for (var a4 = i3.pathLength || t3.getTotalLength(), o4 = i3.tolerance || 1e-3, s3 = i3.iterationLimit || 30, l3 = t3.getPointAtLength(0)[n4] > t3.getPointAtLength(a4)[n4] ? -1 : 1, u4 = 0, c5 = 0, f4 = a4, h3, d3, v3; u4 < s3; ) {\n                if (h3 = (c5 + f4) / 2, d3 = t3.getPointAtLength(h3), v3 = d3[n4] - r4, Math.abs(v3) < o4) return d3;\n                l3 * v3 > 0 ? f4 = h3 : c5 = h3, u4++;\n              }\n              return d3;\n            };\n          });\n          var z6 = ye((XS) => {\n            "use strict";\n            var by = {};\n            XS.throttle = function(t3, r4, n4) {\n              var i3 = by[t3], a4 = Date.now();\n              if (!i3) {\n                for (var o4 in by) by[o4].ts < a4 - 6e4 && delete by[o4];\n                i3 = by[t3] = { ts: 0, timer: null };\n              }\n              Aie(i3);\n              function s3() {\n                n4(), i3.ts = Date.now(), i3.onDone && (i3.onDone(), i3.onDone = null);\n              }\n              if (a4 > i3.ts + r4) {\n                s3();\n                return;\n              }\n              i3.timer = setTimeout(function() {\n                s3(), i3.timer = null;\n              }, r4);\n            };\n            XS.done = function(e3) {\n              var t3 = by[e3];\n              return !t3 || !t3.timer ? Promise.resolve() : new Promise(function(r4) {\n                var n4 = t3.onDone;\n                t3.onDone = function() {\n                  n4 && n4(), r4(), t3.onDone = null;\n                };\n              });\n            };\n            XS.clear = function(e3) {\n              if (e3) Aie(by[e3]), delete by[e3];\n              else for (var t3 in by) XS.clear(t3);\n            };\n            function Aie(e3) {\n              e3 && e3.timer !== null && (clearTimeout(e3.timer), e3.timer = null);\n            }\n          });\n          var Mie = ye((zir, Sie) => {\n            "use strict";\n            Sie.exports = function(t3) {\n              t3._responsiveChartHandler && (window.removeEventListener("resize", t3._responsiveChartHandler), delete t3._responsiveChartHandler);\n            };\n          });\n          var Eie = ye((Oir, O6) => {\n            "use strict";\n            O6.exports = KO;\n            O6.exports.isMobile = KO;\n            O6.exports.default = KO;\n            var Xit = /(android|bb\\d+|meego).+mobile|armv7l|avantgo|bada\\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i, Zit = /CrOS/, Yit = /android|ipad|playbook|silk/i;\n            function KO(e3) {\n              e3 || (e3 = {});\n              let t3 = e3.ua;\n              if (!t3 && typeof navigator != "undefined" && (t3 = navigator.userAgent), t3 && t3.headers && typeof t3.headers["user-agent"] == "string" && (t3 = t3.headers["user-agent"]), typeof t3 != "string") return false;\n              let r4 = Xit.test(t3) && !Zit.test(t3) || !!e3.tablet && Yit.test(t3);\n              return !r4 && e3.tablet && e3.featureDetect && navigator && navigator.maxTouchPoints > 1 && t3.indexOf("Macintosh") !== -1 && t3.indexOf("Safari") !== -1 && (r4 = true), r4;\n            }\n          });\n          var Cie = ye((qir, kie) => {\n            "use strict";\n            var Kit = Eo(), Jit = Eie();\n            kie.exports = function(t3) {\n              var r4;\n              if (t3 && t3.hasOwnProperty("userAgent") ? r4 = t3.userAgent : r4 = $it(), typeof r4 != "string") return true;\n              var n4 = Jit({ ua: { headers: { "user-agent": r4 } }, tablet: true, featureDetect: false });\n              if (!n4) for (var i3 = r4.split(" "), a4 = 1; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                if (o4.indexOf("Safari") !== -1) for (var s3 = a4 - 1; s3 > -1; s3--) {\n                  var l3 = i3[s3];\n                  if (l3.slice(0, 8) === "Version/") {\n                    var u4 = l3.slice(8).split(".")[0];\n                    if (Kit(u4) && (u4 = +u4), u4 >= 13) return true;\n                  }\n                }\n              }\n              return n4;\n            };\n            function $it() {\n              var e3;\n              return typeof navigator != "undefined" && (e3 = navigator.userAgent), e3 && e3.headers && typeof e3.headers["user-agent"] == "string" && (e3 = e3.headers["user-agent"]), e3;\n            }\n          });\n          var Pie = ye((Bir, Lie) => {\n            "use strict";\n            var Qit = Oa();\n            Lie.exports = function(t3, r4, n4) {\n              var i3 = t3.selectAll("g." + n4.replace(/\\s/g, ".")).data(r4, function(o4) {\n                return o4[0].trace.uid;\n              });\n              i3.exit().remove(), i3.enter().append("g").attr("class", n4), i3.order();\n              var a4 = t3.classed("rangeplot") ? "nodeRangePlot3" : "node3";\n              return i3.each(function(o4) {\n                o4[0][a4] = Qit.select(this);\n              }), i3;\n            };\n          });\n          var Rie = ye((Nir, Iie) => {\n            "use strict";\n            var ent = qa();\n            Iie.exports = function(t3, r4) {\n              for (var n4 = t3._context.locale, i3 = 0; i3 < 2; i3++) {\n                for (var a4 = t3._context.locales, o4 = 0; o4 < 2; o4++) {\n                  var s3 = (a4[n4] || {}).dictionary;\n                  if (s3) {\n                    var l3 = s3[r4];\n                    if (l3) return l3;\n                  }\n                  a4 = ent.localeRegistry;\n                }\n                var u4 = n4.split("-")[0];\n                if (u4 === n4) break;\n                n4 = u4;\n              }\n              return r4;\n            };\n          });\n          var JO = ye((Uir, Die) => {\n            "use strict";\n            Die.exports = function(t3) {\n              for (var r4 = {}, n4 = [], i3 = 0, a4 = 0; a4 < t3.length; a4++) {\n                var o4 = t3[a4];\n                r4[o4] !== 1 && (r4[o4] = 1, n4[i3++] = o4);\n              }\n              return n4;\n            };\n          });\n          var zie = ye((Vir, Fie) => {\n            "use strict";\n            Fie.exports = function(t3) {\n              for (var r4 = int(t3) ? rnt : tnt, n4 = [], i3 = 0; i3 < t3.length; i3++) {\n                var a4 = t3[i3];\n                r4(a4) && n4.push(a4);\n              }\n              return n4;\n            };\n            function tnt(e3) {\n              return e3.visible === true;\n            }\n            function rnt(e3) {\n              var t3 = e3[0].trace;\n              return t3.visible === true && t3._length !== 0;\n            }\n            function int(e3) {\n              return Array.isArray(e3) && Array.isArray(e3[0]) && e3[0][0] && e3[0][0].trace;\n            }\n          });\n          var qie = ye((Gir, Oie) => {\n            "use strict";\n            Oie.exports = function(t3, r4) {\n              if (!r4) return t3;\n              var n4 = 1 / Math.abs(r4), i3 = n4 > 1 ? (n4 * t3 + n4 * r4) / n4 : t3 + r4, a4 = String(i3).length;\n              if (a4 > 16) {\n                var o4 = String(r4).length, s3 = String(t3).length;\n                if (a4 >= s3 + o4) {\n                  var l3 = parseFloat(i3).toPrecision(12);\n                  l3.indexOf("e+") === -1 && (i3 = +l3);\n                }\n              }\n              return i3;\n            };\n          });\n          var Nie = ye((Hir, Bie) => {\n            "use strict";\n            var nnt = Eo(), ant = fs().BADNUM, ont = /^[\'"%,$#\\s\']+|[, ]|[\'"%,$#\\s\']+$/g;\n            Bie.exports = function(t3) {\n              return typeof t3 == "string" && (t3 = t3.replace(ont, "")), nnt(t3) ? Number(t3) : ant;\n            };\n          });\n          var Dr = ye((jir, Qie) => {\n            "use strict";\n            var ZS = Oa(), snt = r3().utcFormat, lnt = wO().format, Wie = Eo(), Xie = fs(), Zie = Xie.FP_SAFE, unt = -Zie, Uie = Xie.BADNUM, Mi = Qie.exports = {};\n            Mi.adjustFormat = function(t3) {\n              return !t3 || /^\\d[.]\\df/.test(t3) || /[.]\\d%/.test(t3) ? t3 : t3 === "0.f" ? "~f" : /^\\d%/.test(t3) ? "~%" : /^\\ds/.test(t3) ? "~s" : !/^[~,.0$]/.test(t3) && /[&fps]/.test(t3) ? "~" + t3 : t3;\n            };\n            var Vie = {};\n            Mi.warnBadFormat = function(e3) {\n              var t3 = String(e3);\n              Vie[t3] || (Vie[t3] = 1, Mi.warn(\'encountered bad format: "\' + t3 + \'"\'));\n            };\n            Mi.noFormat = function(e3) {\n              return String(e3);\n            };\n            Mi.numberFormat = function(e3) {\n              var t3;\n              try {\n                t3 = lnt(Mi.adjustFormat(e3));\n              } catch (r4) {\n                return Mi.warnBadFormat(e3), Mi.noFormat;\n              }\n              return t3;\n            };\n            Mi.nestedProperty = PS();\n            Mi.keyedContainer = Dee();\n            Mi.relativeAttr = zee();\n            Mi.isPlainObject = my();\n            Mi.toLogRange = m6();\n            Mi.relinkPrivateKeys = Nee();\n            var K1 = vv();\n            Mi.isArrayBuffer = K1.isArrayBuffer;\n            Mi.isTypedArray = K1.isTypedArray;\n            Mi.isArrayOrTypedArray = K1.isArrayOrTypedArray;\n            Mi.isArray1D = K1.isArray1D;\n            Mi.ensureArray = K1.ensureArray;\n            Mi.concat = K1.concat;\n            Mi.maxRowLength = K1.maxRowLength;\n            Mi.minRowLength = K1.minRowLength;\n            var Yie = n3();\n            Mi.mod = Yie.mod;\n            Mi.modHalf = Yie.modHalf;\n            var J1 = ate();\n            Mi.valObjectMeta = J1.valObjectMeta;\n            Mi.coerce = J1.coerce;\n            Mi.coerce2 = J1.coerce2;\n            Mi.coerceFont = J1.coerceFont;\n            Mi.coercePattern = J1.coercePattern;\n            Mi.coerceHoverinfo = J1.coerceHoverinfo;\n            Mi.coerceSelectionMarkerOpacity = J1.coerceSelectionMarkerOpacity;\n            Mi.validate = J1.validate;\n            var jp = fie();\n            Mi.dateTime2ms = jp.dateTime2ms;\n            Mi.isDateTime = jp.isDateTime;\n            Mi.ms2DateTime = jp.ms2DateTime;\n            Mi.ms2DateTimeLocal = jp.ms2DateTimeLocal;\n            Mi.cleanDate = jp.cleanDate;\n            Mi.isJSDate = jp.isJSDate;\n            Mi.formatDate = jp.formatDate;\n            Mi.incrementMonth = jp.incrementMonth;\n            Mi.dateTick0 = jp.dateTick0;\n            Mi.dfltRange = jp.dfltRange;\n            Mi.findExactDates = jp.findExactDates;\n            Mi.MIN_MS = jp.MIN_MS;\n            Mi.MAX_MS = jp.MAX_MS;\n            var vb = R6();\n            Mi.findBin = vb.findBin;\n            Mi.sorterAsc = vb.sorterAsc;\n            Mi.sorterDes = vb.sorterDes;\n            Mi.distinctVals = vb.distinctVals;\n            Mi.roundUp = vb.roundUp;\n            Mi.sort = vb.sort;\n            Mi.findIndexOfMin = vb.findIndexOfMin;\n            Mi.sortObjectKeys = Z1();\n            var wy = vie();\n            Mi.aggNums = wy.aggNums;\n            Mi.len = wy.len;\n            Mi.mean = wy.mean;\n            Mi.geometricMean = wy.geometricMean;\n            Mi.median = wy.median;\n            Mi.midRange = wy.midRange;\n            Mi.variance = wy.variance;\n            Mi.stdev = wy.stdev;\n            Mi.interp = wy.interp;\n            var xg = T6();\n            Mi.init2dArray = xg.init2dArray;\n            Mi.transposeRagged = xg.transposeRagged;\n            Mi.dot = xg.dot;\n            Mi.translationMatrix = xg.translationMatrix;\n            Mi.rotationMatrix = xg.rotationMatrix;\n            Mi.rotationXYMatrix = xg.rotationXYMatrix;\n            Mi.apply3DTransform = xg.apply3DTransform;\n            Mi.apply2DTransform = xg.apply2DTransform;\n            Mi.apply2DTransform2 = xg.apply2DTransform2;\n            Mi.convertCssMatrix = xg.convertCssMatrix;\n            Mi.inverseTransformMatrix = xg.inverseTransformMatrix;\n            var vm = _ie();\n            Mi.deg2rad = vm.deg2rad;\n            Mi.rad2deg = vm.rad2deg;\n            Mi.angleDelta = vm.angleDelta;\n            Mi.angleDist = vm.angleDist;\n            Mi.isFullCircle = vm.isFullCircle;\n            Mi.isAngleInsideSector = vm.isAngleInsideSector;\n            Mi.isPtInsideSector = vm.isPtInsideSector;\n            Mi.pathArc = vm.pathArc;\n            Mi.pathSector = vm.pathSector;\n            Mi.pathAnnulus = vm.pathAnnulus;\n            var g3 = xie();\n            Mi.isLeftAnchor = g3.isLeftAnchor;\n            Mi.isCenterAnchor = g3.isCenterAnchor;\n            Mi.isRightAnchor = g3.isRightAnchor;\n            Mi.isTopAnchor = g3.isTopAnchor;\n            Mi.isMiddleAnchor = g3.isMiddleAnchor;\n            Mi.isBottomAnchor = g3.isBottomAnchor;\n            var m3 = Tie();\n            Mi.segmentsIntersect = m3.segmentsIntersect;\n            Mi.segmentDistance = m3.segmentDistance;\n            Mi.getTextLocation = m3.getTextLocation;\n            Mi.clearLocationCache = m3.clearLocationCache;\n            Mi.getVisibleSegment = m3.getVisibleSegment;\n            Mi.findPointOnPath = m3.findPointOnPath;\n            var N6 = Ao();\n            Mi.extendFlat = N6.extendFlat;\n            Mi.extendDeep = N6.extendDeep;\n            Mi.extendDeepAll = N6.extendDeepAll;\n            Mi.extendDeepNoArrays = N6.extendDeepNoArrays;\n            var $O = G1();\n            Mi.log = $O.log;\n            Mi.warn = $O.warn;\n            Mi.error = $O.error;\n            var cnt = o3();\n            Mi.counterRegex = cnt.counter;\n            var QO = z6();\n            Mi.throttle = QO.throttle;\n            Mi.throttleDone = QO.done;\n            Mi.clearThrottle = QO.clear;\n            var bg = NS();\n            Mi.getGraphDiv = bg.getGraphDiv;\n            Mi.isPlotDiv = bg.isPlotDiv;\n            Mi.removeElement = bg.removeElement;\n            Mi.addStyleRule = bg.addStyleRule;\n            Mi.addRelatedStyleRule = bg.addRelatedStyleRule;\n            Mi.deleteRelatedStyleRule = bg.deleteRelatedStyleRule;\n            Mi.setStyleOnHover = bg.setStyleOnHover;\n            Mi.getFullTransformMatrix = bg.getFullTransformMatrix;\n            Mi.getElementTransformMatrix = bg.getElementTransformMatrix;\n            Mi.getElementAndAncestors = bg.getElementAndAncestors;\n            Mi.equalDomRects = bg.equalDomRects;\n            Mi.clearResponsive = Mie();\n            Mi.preserveDrawingBuffer = Cie();\n            Mi.makeTraceGroups = Pie();\n            Mi._ = Rie();\n            Mi.notifier = RO();\n            Mi.filterUnique = JO();\n            Mi.filterVisible = zie();\n            Mi.pushUnique = zO();\n            Mi.increment = qie();\n            Mi.cleanNumber = Nie();\n            Mi.ensureNumber = function(t3) {\n              return Wie(t3) ? (t3 = Number(t3), t3 > Zie || t3 < unt ? Uie : t3) : Uie;\n            };\n            Mi.isIndex = function(e3, t3) {\n              return t3 !== void 0 && e3 >= t3 ? false : Wie(e3) && e3 >= 0 && e3 % 1 === 0;\n            };\n            Mi.noop = w6();\n            Mi.identity = HS();\n            Mi.repeat = function(e3, t3) {\n              for (var r4 = new Array(t3), n4 = 0; n4 < t3; n4++) r4[n4] = e3;\n              return r4;\n            };\n            Mi.swapAttrs = function(e3, t3, r4, n4) {\n              r4 || (r4 = "x"), n4 || (n4 = "y");\n              for (var i3 = 0; i3 < t3.length; i3++) {\n                var a4 = t3[i3], o4 = Mi.nestedProperty(e3, a4.replace("?", r4)), s3 = Mi.nestedProperty(e3, a4.replace("?", n4)), l3 = o4.get();\n                o4.set(s3.get()), s3.set(l3);\n              }\n            };\n            Mi.raiseToTop = function(t3) {\n              t3.parentNode.appendChild(t3);\n            };\n            Mi.cancelTransition = function(e3) {\n              return e3.transition().duration(0);\n            };\n            Mi.constrain = function(e3, t3, r4) {\n              return t3 > r4 ? Math.max(r4, Math.min(t3, e3)) : Math.max(t3, Math.min(r4, e3));\n            };\n            Mi.bBoxIntersect = function(e3, t3, r4) {\n              return r4 = r4 || 0, e3.left <= t3.right + r4 && t3.left <= e3.right + r4 && e3.top <= t3.bottom + r4 && t3.top <= e3.bottom + r4;\n            };\n            Mi.simpleMap = function(e3, t3, r4, n4, i3) {\n              for (var a4 = e3.length, o4 = new Array(a4), s3 = 0; s3 < a4; s3++) o4[s3] = t3(e3[s3], r4, n4, i3);\n              return o4;\n            };\n            Mi.randstr = function e3(t3, r4, n4, i3) {\n              if (n4 || (n4 = 16), r4 === void 0 && (r4 = 24), r4 <= 0) return "0";\n              var a4 = Math.log(Math.pow(2, r4)) / Math.log(n4), o4 = "", s3, l3, u4;\n              for (s3 = 2; a4 === 1 / 0; s3 *= 2) a4 = Math.log(Math.pow(2, r4 / s3)) / Math.log(n4) * s3;\n              var c5 = a4 - Math.floor(a4);\n              for (s3 = 0; s3 < Math.floor(a4); s3++) u4 = Math.floor(Math.random() * n4).toString(n4), o4 = u4 + o4;\n              c5 && (l3 = Math.pow(n4, c5), u4 = Math.floor(Math.random() * l3).toString(n4), o4 = u4 + o4);\n              var f4 = parseInt(o4, n4);\n              return t3 && t3[o4] || f4 !== 1 / 0 && f4 >= Math.pow(2, r4) ? i3 > 10 ? (Mi.warn("randstr failed uniqueness"), o4) : e3(t3, r4, n4, (i3 || 0) + 1) : o4;\n            };\n            Mi.OptionControl = function(e3, t3) {\n              e3 || (e3 = {}), t3 || (t3 = "opt");\n              var r4 = {};\n              return r4.optionList = [], r4._newoption = function(n4) {\n                n4[t3] = e3, r4[n4.name] = n4, r4.optionList.push(n4);\n              }, r4["_" + t3] = e3, r4;\n            };\n            Mi.smooth = function(e3, t3) {\n              if (t3 = Math.round(t3) || 0, t3 < 2) return e3;\n              var r4 = e3.length, n4 = 2 * r4, i3 = 2 * t3 - 1, a4 = new Array(i3), o4 = new Array(r4), s3, l3, u4, c5;\n              for (s3 = 0; s3 < i3; s3++) a4[s3] = (1 - Math.cos(Math.PI * (s3 + 1) / t3)) / (2 * t3);\n              for (s3 = 0; s3 < r4; s3++) {\n                for (c5 = 0, l3 = 0; l3 < i3; l3++) u4 = s3 + l3 + 1 - t3, u4 < -r4 ? u4 -= n4 * Math.round(u4 / n4) : u4 >= n4 && (u4 -= n4 * Math.floor(u4 / n4)), u4 < 0 ? u4 = -1 - u4 : u4 >= r4 && (u4 = n4 - 1 - u4), c5 += e3[u4] * a4[l3];\n                o4[s3] = c5;\n              }\n              return o4;\n            };\n            Mi.syncOrAsync = function(e3, t3, r4) {\n              var n4, i3;\n              function a4() {\n                return Mi.syncOrAsync(e3, t3, r4);\n              }\n              for (; e3.length; ) if (i3 = e3.splice(0, 1)[0], n4 = i3(t3), n4 && n4.then) return n4.then(a4);\n              return r4 && r4(t3);\n            };\n            Mi.stripTrailingSlash = function(e3) {\n              return e3.slice(-1) === "/" ? e3.slice(0, -1) : e3;\n            };\n            Mi.noneOrAll = function(e3, t3, r4) {\n              if (e3) {\n                var n4 = false, i3 = true, a4, o4;\n                for (a4 = 0; a4 < r4.length; a4++) o4 = e3[r4[a4]], o4 != null ? n4 = true : i3 = false;\n                if (n4 && !i3) for (a4 = 0; a4 < r4.length; a4++) e3[r4[a4]] = t3[r4[a4]];\n              }\n            };\n            Mi.mergeArray = function(e3, t3, r4, n4) {\n              var i3 = typeof n4 == "function";\n              if (Mi.isArrayOrTypedArray(e3)) for (var a4 = Math.min(e3.length, t3.length), o4 = 0; o4 < a4; o4++) {\n                var s3 = e3[o4];\n                t3[o4][r4] = i3 ? n4(s3) : s3;\n              }\n            };\n            Mi.mergeArrayCastPositive = function(e3, t3, r4) {\n              return Mi.mergeArray(e3, t3, r4, function(n4) {\n                var i3 = +n4;\n                return isFinite(i3) && i3 > 0 ? i3 : 0;\n              });\n            };\n            Mi.fillArray = function(e3, t3, r4, n4) {\n              if (n4 = n4 || Mi.identity, Mi.isArrayOrTypedArray(e3)) for (var i3 = 0; i3 < t3.length; i3++) t3[i3][r4] = n4(e3[i3]);\n            };\n            Mi.castOption = function(e3, t3, r4, n4) {\n              n4 = n4 || Mi.identity;\n              var i3 = Mi.nestedProperty(e3, r4).get();\n              return Mi.isArrayOrTypedArray(i3) ? Array.isArray(t3) && Mi.isArrayOrTypedArray(i3[t3[0]]) ? n4(i3[t3[0]][t3[1]]) : n4(i3[t3]) : i3;\n            };\n            Mi.extractOption = function(e3, t3, r4, n4) {\n              if (r4 in e3) return e3[r4];\n              var i3 = Mi.nestedProperty(t3, n4).get();\n              if (!Array.isArray(i3)) return i3;\n            };\n            function Kie(e3) {\n              var t3 = {};\n              for (var r4 in e3) for (var n4 = e3[r4], i3 = 0; i3 < n4.length; i3++) t3[n4[i3]] = +r4;\n              return t3;\n            }\n            Mi.tagSelected = function(e3, t3, r4) {\n              var n4 = t3.selectedpoints, i3 = t3._indexToPoints, a4;\n              i3 && (a4 = Kie(i3));\n              function o4(f4) {\n                return f4 !== void 0 && f4 < e3.length;\n              }\n              for (var s3 = 0; s3 < n4.length; s3++) {\n                var l3 = n4[s3];\n                if (Mi.isIndex(l3) || Mi.isArrayOrTypedArray(l3) && Mi.isIndex(l3[0]) && Mi.isIndex(l3[1])) {\n                  var u4 = a4 ? a4[l3] : l3, c5 = r4 ? r4[u4] : u4;\n                  o4(c5) && (e3[c5].selected = 1);\n                }\n              }\n            };\n            Mi.selIndices2selPoints = function(e3) {\n              var t3 = e3.selectedpoints, r4 = e3._indexToPoints;\n              if (r4) {\n                for (var n4 = Kie(r4), i3 = [], a4 = 0; a4 < t3.length; a4++) {\n                  var o4 = t3[a4];\n                  if (Mi.isIndex(o4)) {\n                    var s3 = n4[o4];\n                    Mi.isIndex(s3) && i3.push(s3);\n                  }\n                }\n                return i3;\n              } else return t3;\n            };\n            Mi.getTargetArray = function(e3, t3) {\n              var r4 = t3.target;\n              if (typeof r4 == "string" && r4) {\n                var n4 = Mi.nestedProperty(e3, r4).get();\n                return Mi.isArrayOrTypedArray(n4) ? n4 : false;\n              } else if (Mi.isArrayOrTypedArray(r4)) return r4;\n              return false;\n            };\n            function Jie(e3, t3, r4) {\n              var n4 = {};\n              typeof t3 != "object" && (t3 = {});\n              var i3 = r4 === "pieLike" ? -1 : 3, a4 = Object.keys(e3), o4, s3, l3;\n              for (o4 = 0; o4 < a4.length; o4++) s3 = a4[o4], l3 = e3[s3], !(s3.charAt(0) === "_" || typeof l3 == "function") && (s3 === "module" ? n4[s3] = l3 : Array.isArray(l3) ? s3 === "colorscale" || i3 === -1 ? n4[s3] = l3.slice() : n4[s3] = l3.slice(0, i3) : Mi.isTypedArray(l3) ? i3 === -1 ? n4[s3] = l3.subarray() : n4[s3] = l3.subarray(0, i3) : l3 && typeof l3 == "object" ? n4[s3] = Jie(e3[s3], t3[s3], r4) : n4[s3] = l3);\n              for (a4 = Object.keys(t3), o4 = 0; o4 < a4.length; o4++) s3 = a4[o4], l3 = t3[s3], (typeof l3 != "object" || !(s3 in n4) || typeof n4[s3] != "object") && (n4[s3] = l3);\n              return n4;\n            }\n            Mi.minExtend = Jie;\n            Mi.titleCase = function(e3) {\n              return e3.charAt(0).toUpperCase() + e3.slice(1);\n            };\n            Mi.containsAny = function(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) if (e3.indexOf(t3[r4]) !== -1) return true;\n              return false;\n            };\n            var fnt = /Version\\/[\\d\\.]+.*Safari/;\n            Mi.isSafari = function() {\n              return fnt.test(window.navigator.userAgent);\n            };\n            var hnt = /iPad|iPhone|iPod/;\n            Mi.isIOS = function() {\n              return hnt.test(window.navigator.userAgent);\n            };\n            var dnt = /Macintosh.+AppleWebKit.+Gecko\\)$/;\n            Mi.isMacWKWebView = () => dnt.test(window.navigator.userAgent);\n            var vnt = /Firefox\\/(\\d+)\\.\\d+/;\n            Mi.getFirefoxVersion = function() {\n              var e3 = vnt.exec(window.navigator.userAgent);\n              if (e3 && e3.length === 2) {\n                var t3 = parseInt(e3[1]);\n                if (!isNaN(t3)) return t3;\n              }\n              return null;\n            };\n            Mi.isD3Selection = function(e3) {\n              return e3 instanceof ZS.selection;\n            };\n            Mi.ensureSingle = function(e3, t3, r4, n4) {\n              var i3 = e3.select(t3 + (r4 ? "." + r4 : ""));\n              if (i3.size()) return i3;\n              var a4 = e3.append(t3);\n              return r4 && a4.classed(r4, true), n4 && a4.call(n4), a4;\n            };\n            Mi.ensureSingleById = function(e3, t3, r4, n4) {\n              var i3 = e3.select(t3 + "#" + r4);\n              if (i3.size()) return i3;\n              var a4 = e3.append(t3).attr("id", r4);\n              return n4 && a4.call(n4), a4;\n            };\n            Mi.objectFromPath = function(e3, t3) {\n              for (var r4 = e3.split("."), n4, i3 = n4 = {}, a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4], s3 = null, l3 = r4[a4].match(/(.*)\\[([0-9]+)\\]/);\n                l3 ? (o4 = l3[1], s3 = l3[2], n4 = n4[o4] = [], a4 === r4.length - 1 ? n4[s3] = t3 : n4[s3] = {}, n4 = n4[s3]) : (a4 === r4.length - 1 ? n4[o4] = t3 : n4[o4] = {}, n4 = n4[o4]);\n              }\n              return i3;\n            };\n            var pnt = /^([^\\[\\.]+)\\.(.+)?/, gnt = /^([^\\.]+)\\[([0-9]+)\\](\\.)?(.+)?/;\n            function q6(e3) {\n              return e3.slice(0, 2) === "__";\n            }\n            Mi.expandObjectPaths = function(e3) {\n              var t3, r4, n4, i3, a4, o4, s3;\n              if (typeof e3 == "object" && !Array.isArray(e3)) {\n                for (r4 in e3) if (e3.hasOwnProperty(r4)) if (t3 = r4.match(pnt)) {\n                  if (i3 = e3[r4], n4 = t3[1], q6(n4)) continue;\n                  delete e3[r4], e3[n4] = Mi.extendDeepNoArrays(e3[n4] || {}, Mi.objectFromPath(r4, Mi.expandObjectPaths(i3))[n4]);\n                } else if (t3 = r4.match(gnt)) {\n                  if (i3 = e3[r4], n4 = t3[1], q6(n4)) continue;\n                  if (a4 = parseInt(t3[2]), delete e3[r4], e3[n4] = e3[n4] || [], t3[3] === ".") s3 = t3[4], o4 = e3[n4][a4] = e3[n4][a4] || {}, Mi.extendDeepNoArrays(o4, Mi.objectFromPath(s3, Mi.expandObjectPaths(i3)));\n                  else {\n                    if (q6(n4)) continue;\n                    e3[n4][a4] = Mi.expandObjectPaths(i3);\n                  }\n                } else {\n                  if (q6(r4)) continue;\n                  e3[r4] = Mi.expandObjectPaths(e3[r4]);\n                }\n              }\n              return e3;\n            };\n            Mi.numSeparate = function(e3, t3, r4) {\n              if (r4 || (r4 = false), typeof t3 != "string" || t3.length === 0) throw new Error("Separator string required for formatting!");\n              typeof e3 == "number" && (e3 = String(e3));\n              var n4 = /(\\d+)(\\d{3})/, i3 = t3.charAt(0), a4 = t3.charAt(1), o4 = e3.split("."), s3 = o4[0], l3 = o4.length > 1 ? i3 + o4[1] : "";\n              if (a4 && (o4.length > 1 || s3.length > 4 || r4)) for (; n4.test(s3); ) s3 = s3.replace(n4, "$1" + a4 + "$2");\n              return s3 + l3;\n            };\n            Mi.TEMPLATE_STRING_REGEX = /%{([^\\s%{}:]*)([:|\\|][^}]*)?}/g;\n            var $ie = /^\\w*$/;\n            Mi.templateString = function(e3, t3) {\n              var r4 = {};\n              return e3.replace(Mi.TEMPLATE_STRING_REGEX, function(n4, i3) {\n                var a4;\n                return $ie.test(i3) ? a4 = t3[i3] : (r4[i3] = r4[i3] || Mi.nestedProperty(t3, i3).get, a4 = r4[i3](true)), a4 !== void 0 ? a4 : "";\n              });\n            };\n            var mnt = { max: 10, count: 0, name: "hovertemplate" };\n            Mi.hovertemplateString = (e3) => eq(q1(mg({}, e3), { opts: mnt }));\n            var ynt = { max: 10, count: 0, name: "texttemplate" };\n            Mi.texttemplateString = (e3) => eq(q1(mg({}, e3), { opts: ynt }));\n            var _nt = /^(\\S+)([\\*\\/])(-?\\d+(\\.\\d+)?)$/;\n            function xnt(e3) {\n              var t3 = e3.match(_nt);\n              return t3 ? { key: t3[1], op: t3[2], number: Number(t3[3]) } : { key: e3, op: null, number: null };\n            }\n            var bnt = { max: 10, count: 0, name: "texttemplate", parseMultDiv: true };\n            Mi.texttemplateStringForShapes = (e3) => eq(q1(mg({}, e3), { opts: bnt }));\n            var Gie = /^[:|\\|]/;\n            function eq({ data: e3 = [], locale: t3, fallback: r4, labels: n4 = {}, opts: i3, template: a4 }) {\n              return a4.replace(Mi.TEMPLATE_STRING_REGEX, (o4, s3, l3) => {\n                let u4 = ["xother", "yother"].includes(s3), c5 = ["_xother", "_yother"].includes(s3), f4 = ["_xother_", "_yother_"].includes(s3), h3 = ["xother_", "yother_"].includes(s3), d3 = u4 || c5 || h3 || f4;\n                (c5 || f4) && (s3 = s3.substring(1)), (h3 || f4) && (s3 = s3.substring(0, s3.length - 1));\n                let v3 = null, _2 = null;\n                if (i3.parseMultDiv) {\n                  var b = xnt(s3);\n                  s3 = b.key, v3 = b.op, _2 = b.number;\n                }\n                let p4;\n                if (d3) {\n                  if (n4[s3] === void 0) return "";\n                  p4 = n4[s3];\n                } else for (let L3 of e3) if (L3) {\n                  if (L3.hasOwnProperty(s3)) {\n                    p4 = L3[s3];\n                    break;\n                  }\n                  if ($ie.test(s3) || (p4 = Mi.nestedProperty(L3, s3).get(true)), p4 !== void 0) break;\n                }\n                if (p4 === void 0) {\n                  let { count: L3, max: x2, name: C3 } = i3, M4 = r4 === false ? o4 : r4;\n                  return L3 < x2 && Mi.warn([`Variable \'${s3}\' in ${C3} could not be found!`, "Please verify that the template is correct.", `Using value: \'${M4}\'.`].join(" ")), L3 === x2 && Mi.warn(`Too many \'${C3}\' warnings - additional warnings will be suppressed.`), i3.count++, M4;\n                }\n                if (v3 === "*" && (p4 *= _2), v3 === "/" && (p4 /= _2), l3) {\n                  var k4;\n                  if (l3[0] === ":" && (k4 = t3 ? t3.numberFormat : Mi.numberFormat, p4 !== "" && (p4 = k4(l3.replace(Gie, ""))(p4))), l3[0] === "|") {\n                    k4 = t3 ? t3.timeFormat : snt;\n                    var E3 = Mi.dateTime2ms(p4);\n                    p4 = Mi.formatDate(E3, l3.replace(Gie, ""), false, k4);\n                  }\n                } else {\n                  var S2 = s3 + "Label";\n                  n4.hasOwnProperty(S2) && (p4 = n4[S2]);\n                }\n                return d3 && (p4 = "(" + p4 + ")", (c5 || f4) && (p4 = " " + p4), (h3 || f4) && (p4 = p4 + " ")), p4;\n              });\n            }\n            var B6 = 48, Hie = 57;\n            Mi.subplotSort = function(e3, t3) {\n              for (var r4 = Math.min(e3.length, t3.length) + 1, n4 = 0, i3 = 0, a4 = 0; a4 < r4; a4++) {\n                var o4 = e3.charCodeAt(a4) || 0, s3 = t3.charCodeAt(a4) || 0, l3 = o4 >= B6 && o4 <= Hie, u4 = s3 >= B6 && s3 <= Hie;\n                if (l3 && (n4 = 10 * n4 + o4 - B6), u4 && (i3 = 10 * i3 + s3 - B6), !l3 || !u4) {\n                  if (n4 !== i3) return n4 - i3;\n                  if (o4 !== s3) return o4 - s3;\n                }\n              }\n              return i3 - n4;\n            };\n            var p3 = 2e9;\n            Mi.seedPseudoRandom = function() {\n              p3 = 2e9;\n            };\n            Mi.pseudoRandom = function() {\n              var e3 = p3;\n              return p3 = (69069 * p3 + 1) % 4294967296, Math.abs(p3 - e3) < 429496729 ? Mi.pseudoRandom() : p3 / 4294967296;\n            };\n            Mi.fillText = function(e3, t3, r4) {\n              var n4 = Array.isArray(r4) ? function(o4) {\n                r4.push(o4);\n              } : function(o4) {\n                r4.text = o4;\n              }, i3 = Mi.extractOption(e3, t3, "htx", "hovertext");\n              if (Mi.isValidTextValue(i3)) return n4(i3);\n              var a4 = Mi.extractOption(e3, t3, "tx", "text");\n              if (Mi.isValidTextValue(a4)) return n4(a4);\n            };\n            Mi.isValidTextValue = function(e3) {\n              return e3 || e3 === 0;\n            };\n            Mi.formatPercent = function(e3, t3) {\n              t3 = t3 || 0;\n              for (var r4 = (Math.round(100 * e3 * Math.pow(10, t3)) * Math.pow(0.1, t3)).toFixed(t3) + "%", n4 = 0; n4 < t3; n4++) r4.indexOf(".") !== -1 && (r4 = r4.replace("0%", "%"), r4 = r4.replace(".%", "%"));\n              return r4;\n            };\n            Mi.isHidden = function(e3) {\n              var t3 = window.getComputedStyle(e3).display;\n              return !t3 || t3 === "none";\n            };\n            Mi.strTranslate = function(e3, t3) {\n              return e3 || t3 ? "translate(" + e3 + "," + t3 + ")" : "";\n            };\n            Mi.strRotate = function(e3) {\n              return e3 ? "rotate(" + e3 + ")" : "";\n            };\n            Mi.strScale = function(e3) {\n              return e3 !== 1 ? "scale(" + e3 + ")" : "";\n            };\n            Mi.getTextTransform = function(e3) {\n              var t3 = e3.noCenter, r4 = e3.textX, n4 = e3.textY, i3 = e3.targetX, a4 = e3.targetY, o4 = e3.anchorX || 0, s3 = e3.anchorY || 0, l3 = e3.rotate, u4 = e3.scale;\n              return u4 ? u4 > 1 && (u4 = 1) : u4 = 0, Mi.strTranslate(i3 - u4 * (r4 + o4), a4 - u4 * (n4 + s3)) + Mi.strScale(u4) + (l3 ? "rotate(" + l3 + (t3 ? "" : " " + r4 + " " + n4) + ")" : "");\n            };\n            Mi.setTransormAndDisplay = function(e3, t3) {\n              e3.attr("transform", Mi.getTextTransform(t3)), e3.style("display", t3.scale ? null : "none");\n            };\n            Mi.ensureUniformFontSize = function(e3, t3) {\n              var r4 = Mi.extendFlat({}, t3);\n              return r4.size = Math.max(t3.size, e3._fullLayout.uniformtext.minsize || 0), r4;\n            };\n            Mi.join2 = function(e3, t3, r4) {\n              var n4 = e3.length;\n              return n4 > 1 ? e3.slice(0, -1).join(t3) + r4 + e3[n4 - 1] : e3.join(t3);\n            };\n            Mi.bigFont = function(e3) {\n              return Math.round(1.2 * e3);\n            };\n            var jie = Mi.getFirefoxVersion(), wnt = jie !== null && jie < 86;\n            Mi.getPositionFromD3Event = function() {\n              return wnt ? [ZS.event.layerX, ZS.event.layerY] : [ZS.event.offsetX, ZS.event.offsetY];\n            };\n          });\n          var rne = ye(() => {\n            "use strict";\n            var Tnt = Dr(), ene = { "X,X div": \'direction:ltr;font-family:"Open Sans",verdana,arial,sans-serif;margin:0;padding:0;border:0;\', "X input,X button": \'font-family:"Open Sans",verdana,arial,sans-serif;\', "X input:focus,X button:focus": "outline:none;", "X a": "text-decoration:none;", "X a:hover": "text-decoration:none;", "X .crisp": "shape-rendering:crispEdges;", "X .user-select-none": "-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;-o-user-select:none;user-select:none;", "X svg a": "fill:#447adb;", "X svg a:hover": "fill:#3c6dc5;", "X .main-svg": "position:absolute;top:0;left:0;pointer-events:none;", "X .main-svg .draglayer": "pointer-events:all;", "X .cursor-default": "cursor:default;", "X .cursor-pointer": "cursor:pointer;", "X .cursor-crosshair": "cursor:crosshair;", "X .cursor-move": "cursor:move;", "X .cursor-col-resize": "cursor:col-resize;", "X .cursor-row-resize": "cursor:row-resize;", "X .cursor-ns-resize": "cursor:ns-resize;", "X .cursor-ew-resize": "cursor:ew-resize;", "X .cursor-sw-resize": "cursor:sw-resize;", "X .cursor-s-resize": "cursor:s-resize;", "X .cursor-se-resize": "cursor:se-resize;", "X .cursor-w-resize": "cursor:w-resize;", "X .cursor-e-resize": "cursor:e-resize;", "X .cursor-nw-resize": "cursor:nw-resize;", "X .cursor-n-resize": "cursor:n-resize;", "X .cursor-ne-resize": "cursor:ne-resize;", "X .cursor-grab": "cursor:-webkit-grab;cursor:grab;", "X .modebar": "position:absolute;top:2px;right:2px;", "X .ease-bg": "-webkit-transition:background-color .3s ease 0s;-moz-transition:background-color .3s ease 0s;-ms-transition:background-color .3s ease 0s;-o-transition:background-color .3s ease 0s;transition:background-color .3s ease 0s;", "X .modebar--hover>:not(.watermark)": "opacity:0;-webkit-transition:opacity .3s ease 0s;-moz-transition:opacity .3s ease 0s;-ms-transition:opacity .3s ease 0s;-o-transition:opacity .3s ease 0s;transition:opacity .3s ease 0s;", "X:hover .modebar--hover .modebar-group": "opacity:1;", "X:focus-within .modebar--hover .modebar-group": "opacity:1;", "X .modebar-group": "float:left;display:inline-block;box-sizing:border-box;padding-left:8px;position:relative;vertical-align:middle;white-space:nowrap;", "X .modebar-group a": "display:grid;place-content:center;", "X .modebar-btn": "position:relative;font-size:16px;padding:3px 4px;height:22px;cursor:pointer;line-height:normal;box-sizing:border-box;border:none;background:rgba(0,0,0,0);", "X .modebar-btn svg": "position:relative;", "X .modebar-btn:focus-visible": "outline:1px solid #000;outline-offset:1px;border-radius:3px;", "X .modebar.vertical": "display:flex;flex-direction:column;flex-wrap:wrap;align-content:flex-end;max-height:100%;", "X .modebar.vertical svg": "top:-1px;", "X .modebar.vertical .modebar-group": "display:block;float:none;padding-left:0px;padding-bottom:8px;", "X .modebar.vertical .modebar-group .modebar-btn": "display:block;text-align:center;", "X [data-title]:before,X [data-title]:after": "position:absolute;-webkit-transform:translate3d(0, 0, 0);-moz-transform:translate3d(0, 0, 0);-ms-transform:translate3d(0, 0, 0);-o-transform:translate3d(0, 0, 0);transform:translate3d(0, 0, 0);display:none;opacity:0;z-index:1001;pointer-events:none;top:110%;right:50%;", "X [data-title]:hover:before,X [data-title]:hover:after": "display:block;opacity:1;", "X [data-title]:before": \'content:"";position:absolute;background:rgba(0,0,0,0);border:6px solid rgba(0,0,0,0);z-index:1002;margin-top:-12px;border-bottom-color:#69738a;margin-right:-6px;\', "X [data-title]:after": "content:attr(data-title);background:#69738a;color:#fff;padding:8px 10px;font-size:12px;line-height:12px;white-space:nowrap;margin-right:-18px;border-radius:2px;", "X .vertical [data-title]:before,X .vertical [data-title]:after": "top:0%;right:200%;", "X .vertical [data-title]:before": "border:6px solid rgba(0,0,0,0);border-left-color:#69738a;margin-top:8px;margin-right:-30px;", Y: \'font-family:"Open Sans",verdana,arial,sans-serif;position:fixed;top:50px;right:20px;z-index:10000;font-size:10pt;max-width:180px;\', "Y p": "margin:0;", "Y .notifier-note": "min-width:180px;max-width:250px;border:1px solid #fff;z-index:3000;margin:0;background-color:#8c97af;background-color:rgba(140,151,175,.9);color:#fff;padding:10px;overflow-wrap:break-word;word-wrap:break-word;-ms-hyphens:auto;-webkit-hyphens:auto;hyphens:auto;", "Y .notifier-close": "color:#fff;opacity:.8;float:right;padding:0 5px;background:none;border:none;font-size:20px;font-weight:bold;line-height:20px;", "Y .notifier-close:hover": "color:#444;text-decoration:none;cursor:pointer;" };\n            for (tq in ene) tne = tq.replace(/^,/, " ,").replace(/X/g, ".js-plotly-plot .plotly").replace(/Y/g, ".plotly-notifier"), Tnt.addStyleRule(tne, ene[tq]);\n            var tne, tq;\n          });\n          var rq = ye((Yir, ine) => {\n            ine.exports = true;\n          });\n          var nq = ye((Kir, nne) => {\n            "use strict";\n            var Ant = rq(), iq;\n            typeof window.matchMedia == "function" ? iq = !window.matchMedia("(hover: none)").matches : iq = Ant;\n            nne.exports = iq;\n          });\n          var pb = ye((Jir, aq) => {\n            "use strict";\n            var y3 = typeof Reflect == "object" ? Reflect : null, ane = y3 && typeof y3.apply == "function" ? y3.apply : function(t3, r4, n4) {\n              return Function.prototype.apply.call(t3, r4, n4);\n            }, U6;\n            y3 && typeof y3.ownKeys == "function" ? U6 = y3.ownKeys : Object.getOwnPropertySymbols ? U6 = function(t3) {\n              return Object.getOwnPropertyNames(t3).concat(Object.getOwnPropertySymbols(t3));\n            } : U6 = function(t3) {\n              return Object.getOwnPropertyNames(t3);\n            };\n            function Snt(e3) {\n              console && console.warn && console.warn(e3);\n            }\n            var sne = Number.isNaN || function(t3) {\n              return t3 !== t3;\n            };\n            function Jc() {\n              Jc.init.call(this);\n            }\n            aq.exports = Jc;\n            aq.exports.once = Cnt;\n            Jc.EventEmitter = Jc;\n            Jc.prototype._events = void 0;\n            Jc.prototype._eventsCount = 0;\n            Jc.prototype._maxListeners = void 0;\n            var one = 10;\n            function V6(e3) {\n              if (typeof e3 != "function") throw new TypeError(\'The "listener" argument must be of type Function. Received type \' + typeof e3);\n            }\n            Object.defineProperty(Jc, "defaultMaxListeners", { enumerable: true, get: function() {\n              return one;\n            }, set: function(e3) {\n              if (typeof e3 != "number" || e3 < 0 || sne(e3)) throw new RangeError(\'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received \' + e3 + ".");\n              one = e3;\n            } });\n            Jc.init = function() {\n              (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;\n            };\n            Jc.prototype.setMaxListeners = function(t3) {\n              if (typeof t3 != "number" || t3 < 0 || sne(t3)) throw new RangeError(\'The value of "n" is out of range. It must be a non-negative number. Received \' + t3 + ".");\n              return this._maxListeners = t3, this;\n            };\n            function lne(e3) {\n              return e3._maxListeners === void 0 ? Jc.defaultMaxListeners : e3._maxListeners;\n            }\n            Jc.prototype.getMaxListeners = function() {\n              return lne(this);\n            };\n            Jc.prototype.emit = function(t3) {\n              for (var r4 = [], n4 = 1; n4 < arguments.length; n4++) r4.push(arguments[n4]);\n              var i3 = t3 === "error", a4 = this._events;\n              if (a4 !== void 0) i3 = i3 && a4.error === void 0;\n              else if (!i3) return false;\n              if (i3) {\n                var o4;\n                if (r4.length > 0 && (o4 = r4[0]), o4 instanceof Error) throw o4;\n                var s3 = new Error("Unhandled error." + (o4 ? " (" + o4.message + ")" : ""));\n                throw s3.context = o4, s3;\n              }\n              var l3 = a4[t3];\n              if (l3 === void 0) return false;\n              if (typeof l3 == "function") ane(l3, this, r4);\n              else for (var u4 = l3.length, c5 = dne(l3, u4), n4 = 0; n4 < u4; ++n4) ane(c5[n4], this, r4);\n              return true;\n            };\n            function une(e3, t3, r4, n4) {\n              var i3, a4, o4;\n              if (V6(r4), a4 = e3._events, a4 === void 0 ? (a4 = e3._events = /* @__PURE__ */ Object.create(null), e3._eventsCount = 0) : (a4.newListener !== void 0 && (e3.emit("newListener", t3, r4.listener ? r4.listener : r4), a4 = e3._events), o4 = a4[t3]), o4 === void 0) o4 = a4[t3] = r4, ++e3._eventsCount;\n              else if (typeof o4 == "function" ? o4 = a4[t3] = n4 ? [r4, o4] : [o4, r4] : n4 ? o4.unshift(r4) : o4.push(r4), i3 = lne(e3), i3 > 0 && o4.length > i3 && !o4.warned) {\n                o4.warned = true;\n                var s3 = new Error("Possible EventEmitter memory leak detected. " + o4.length + " " + String(t3) + " listeners added. Use emitter.setMaxListeners() to increase limit");\n                s3.name = "MaxListenersExceededWarning", s3.emitter = e3, s3.type = t3, s3.count = o4.length, Snt(s3);\n              }\n              return e3;\n            }\n            Jc.prototype.addListener = function(t3, r4) {\n              return une(this, t3, r4, false);\n            };\n            Jc.prototype.on = Jc.prototype.addListener;\n            Jc.prototype.prependListener = function(t3, r4) {\n              return une(this, t3, r4, true);\n            };\n            function Mnt() {\n              if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = true, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);\n            }\n            function cne(e3, t3, r4) {\n              var n4 = { fired: false, wrapFn: void 0, target: e3, type: t3, listener: r4 }, i3 = Mnt.bind(n4);\n              return i3.listener = r4, n4.wrapFn = i3, i3;\n            }\n            Jc.prototype.once = function(t3, r4) {\n              return V6(r4), this.on(t3, cne(this, t3, r4)), this;\n            };\n            Jc.prototype.prependOnceListener = function(t3, r4) {\n              return V6(r4), this.prependListener(t3, cne(this, t3, r4)), this;\n            };\n            Jc.prototype.removeListener = function(t3, r4) {\n              var n4, i3, a4, o4, s3;\n              if (V6(r4), i3 = this._events, i3 === void 0) return this;\n              if (n4 = i3[t3], n4 === void 0) return this;\n              if (n4 === r4 || n4.listener === r4) --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i3[t3], i3.removeListener && this.emit("removeListener", t3, n4.listener || r4));\n              else if (typeof n4 != "function") {\n                for (a4 = -1, o4 = n4.length - 1; o4 >= 0; o4--) if (n4[o4] === r4 || n4[o4].listener === r4) {\n                  s3 = n4[o4].listener, a4 = o4;\n                  break;\n                }\n                if (a4 < 0) return this;\n                a4 === 0 ? n4.shift() : Ent(n4, a4), n4.length === 1 && (i3[t3] = n4[0]), i3.removeListener !== void 0 && this.emit("removeListener", t3, s3 || r4);\n              }\n              return this;\n            };\n            Jc.prototype.off = Jc.prototype.removeListener;\n            Jc.prototype.removeAllListeners = function(t3) {\n              var r4, n4, i3;\n              if (n4 = this._events, n4 === void 0) return this;\n              if (n4.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : n4[t3] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete n4[t3]), this;\n              if (arguments.length === 0) {\n                var a4 = Object.keys(n4), o4;\n                for (i3 = 0; i3 < a4.length; ++i3) o4 = a4[i3], o4 !== "removeListener" && this.removeAllListeners(o4);\n                return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;\n              }\n              if (r4 = n4[t3], typeof r4 == "function") this.removeListener(t3, r4);\n              else if (r4 !== void 0) for (i3 = r4.length - 1; i3 >= 0; i3--) this.removeListener(t3, r4[i3]);\n              return this;\n            };\n            function fne(e3, t3, r4) {\n              var n4 = e3._events;\n              if (n4 === void 0) return [];\n              var i3 = n4[t3];\n              return i3 === void 0 ? [] : typeof i3 == "function" ? r4 ? [i3.listener || i3] : [i3] : r4 ? knt(i3) : dne(i3, i3.length);\n            }\n            Jc.prototype.listeners = function(t3) {\n              return fne(this, t3, true);\n            };\n            Jc.prototype.rawListeners = function(t3) {\n              return fne(this, t3, false);\n            };\n            Jc.listenerCount = function(e3, t3) {\n              return typeof e3.listenerCount == "function" ? e3.listenerCount(t3) : hne.call(e3, t3);\n            };\n            Jc.prototype.listenerCount = hne;\n            function hne(e3) {\n              var t3 = this._events;\n              if (t3 !== void 0) {\n                var r4 = t3[e3];\n                if (typeof r4 == "function") return 1;\n                if (r4 !== void 0) return r4.length;\n              }\n              return 0;\n            }\n            Jc.prototype.eventNames = function() {\n              return this._eventsCount > 0 ? U6(this._events) : [];\n            };\n            function dne(e3, t3) {\n              for (var r4 = new Array(t3), n4 = 0; n4 < t3; ++n4) r4[n4] = e3[n4];\n              return r4;\n            }\n            function Ent(e3, t3) {\n              for (; t3 + 1 < e3.length; t3++) e3[t3] = e3[t3 + 1];\n              e3.pop();\n            }\n            function knt(e3) {\n              for (var t3 = new Array(e3.length), r4 = 0; r4 < t3.length; ++r4) t3[r4] = e3[r4].listener || e3[r4];\n              return t3;\n            }\n            function Cnt(e3, t3) {\n              return new Promise(function(r4, n4) {\n                function i3(o4) {\n                  e3.removeListener(t3, a4), n4(o4);\n                }\n                function a4() {\n                  typeof e3.removeListener == "function" && e3.removeListener("error", i3), r4([].slice.call(arguments));\n                }\n                vne(e3, t3, a4, { once: true }), t3 !== "error" && Lnt(e3, i3, { once: true });\n              });\n            }\n            function Lnt(e3, t3, r4) {\n              typeof e3.on == "function" && vne(e3, "error", t3, r4);\n            }\n            function vne(e3, t3, r4, n4) {\n              if (typeof e3.on == "function") n4.once ? e3.once(t3, r4) : e3.on(t3, r4);\n              else if (typeof e3.addEventListener == "function") e3.addEventListener(t3, function i3(a4) {\n                n4.once && e3.removeEventListener(t3, i3), r4(a4);\n              });\n              else throw new TypeError(\'The "emitter" argument must be of type EventEmitter. Received type \' + typeof e3);\n            }\n          });\n          var _3 = ye(($ir, pne) => {\n            "use strict";\n            var oq = pb().EventEmitter, Pnt = { init: function(e3) {\n              if (e3._ev instanceof oq) return e3;\n              var t3 = new oq(), r4 = new oq();\n              return e3._ev = t3, e3._internalEv = r4, e3.on = t3.on.bind(t3), e3.once = t3.once.bind(t3), e3.removeListener = t3.removeListener.bind(t3), e3.removeAllListeners = t3.removeAllListeners.bind(t3), e3._internalOn = r4.on.bind(r4), e3._internalOnce = r4.once.bind(r4), e3._removeInternalListener = r4.removeListener.bind(r4), e3._removeAllInternalListeners = r4.removeAllListeners.bind(r4), e3.emit = function(n4, i3) {\n                t3.emit(n4, i3), r4.emit(n4, i3);\n              }, typeof e3.addEventListener == "function" && e3.addEventListener("wheel", () => {\n              }, { passive: true }), e3;\n            }, triggerHandler: function(e3, t3, r4) {\n              var n4, i3 = e3._ev;\n              if (!i3) return;\n              var a4 = i3._events[t3];\n              if (!a4) return;\n              function o4(l3) {\n                if (l3.listener) {\n                  if (i3.removeListener(t3, l3.listener), !l3.fired) return l3.fired = true, l3.listener.apply(i3, [r4]);\n                } else return l3.apply(i3, [r4]);\n              }\n              a4 = Array.isArray(a4) ? a4 : [a4];\n              var s3;\n              for (s3 = 0; s3 < a4.length - 1; s3++) o4(a4[s3]);\n              return n4 = o4(a4[s3]), n4;\n            }, purge: function(e3) {\n              return delete e3._ev, delete e3.on, delete e3.once, delete e3.removeListener, delete e3.removeAllListeners, delete e3.emit, delete e3._ev, delete e3._internalEv, delete e3._internalOn, delete e3._internalOnce, delete e3._removeInternalListener, delete e3._removeAllInternalListeners, e3;\n            } };\n            pne.exports = Pnt;\n          });\n          var yne = ye((Qir, mne) => {\n            "use strict";\n            var gne = Dr(), Int = cb().dfltConfig;\n            function Rnt(e3, t3) {\n              for (var r4 = [], n4, i3 = 0; i3 < t3.length; i3++) n4 = t3[i3], n4 === e3 ? r4[i3] = n4 : typeof n4 == "object" ? r4[i3] = Array.isArray(n4) ? gne.extendDeep([], n4) : gne.extendDeepAll({}, n4) : r4[i3] = n4;\n              return r4;\n            }\n            var Ty = {};\n            Ty.add = function(e3, t3, r4, n4, i3) {\n              var a4, o4;\n              if (e3.undoQueue = e3.undoQueue || { index: 0, queue: [], sequence: false }, o4 = e3.undoQueue.index, e3.autoplay) {\n                e3.undoQueue.inSequence || (e3.autoplay = false);\n                return;\n              }\n              !e3.undoQueue.sequence || e3.undoQueue.beginSequence ? (a4 = { undo: { calls: [], args: [] }, redo: { calls: [], args: [] } }, e3.undoQueue.queue.splice(o4, e3.undoQueue.queue.length - o4, a4), e3.undoQueue.index += 1) : a4 = e3.undoQueue.queue[o4 - 1], e3.undoQueue.beginSequence = false, a4 && (a4.undo.calls.unshift(t3), a4.undo.args.unshift(r4), a4.redo.calls.push(n4), a4.redo.args.push(i3)), e3.undoQueue.queue.length > Int.queueLength && (e3.undoQueue.queue.shift(), e3.undoQueue.index--);\n            };\n            Ty.startSequence = function(e3) {\n              e3.undoQueue = e3.undoQueue || { index: 0, queue: [], sequence: false }, e3.undoQueue.sequence = true, e3.undoQueue.beginSequence = true;\n            };\n            Ty.stopSequence = function(e3) {\n              e3.undoQueue = e3.undoQueue || { index: 0, queue: [], sequence: false }, e3.undoQueue.sequence = false, e3.undoQueue.beginSequence = false;\n            };\n            Ty.undo = function(t3) {\n              var r4, n4;\n              if (!(t3.undoQueue === void 0 || isNaN(t3.undoQueue.index) || t3.undoQueue.index <= 0)) {\n                for (t3.undoQueue.index--, r4 = t3.undoQueue.queue[t3.undoQueue.index], t3.undoQueue.inSequence = true, n4 = 0; n4 < r4.undo.calls.length; n4++) Ty.plotDo(t3, r4.undo.calls[n4], r4.undo.args[n4]);\n                t3.undoQueue.inSequence = false, t3.autoplay = false;\n              }\n            };\n            Ty.redo = function(t3) {\n              var r4, n4;\n              if (!(t3.undoQueue === void 0 || isNaN(t3.undoQueue.index) || t3.undoQueue.index >= t3.undoQueue.queue.length)) {\n                for (r4 = t3.undoQueue.queue[t3.undoQueue.index], t3.undoQueue.inSequence = true, n4 = 0; n4 < r4.redo.calls.length; n4++) Ty.plotDo(t3, r4.redo.calls[n4], r4.redo.args[n4]);\n                t3.undoQueue.inSequence = false, t3.autoplay = false, t3.undoQueue.index++;\n              }\n            };\n            Ty.plotDo = function(e3, t3, r4) {\n              e3.autoplay = true, r4 = Rnt(e3, r4), t3.apply(null, r4);\n            };\n            mne.exports = Ty;\n          });\n          var sq = ye((enr, _ne) => {\n            "use strict";\n            _ne.exports = { _isLinkedToArray: "frames_entry", group: { valType: "string" }, name: { valType: "string" }, traces: { valType: "any" }, baseframe: { valType: "string" }, data: { valType: "any" }, layout: { valType: "any" } };\n          });\n          var w3 = ye((Jh) => {\n            "use strict";\n            var _0 = qa(), YS = Dr(), H6 = Gl(), lq = c3(), Dnt = sq(), Fnt = US(), znt = cb().configAttributes, xne = mc(), wg = YS.extendDeepAll, x3 = YS.isPlainObject, Ont = YS.isArrayOrTypedArray, j6 = YS.nestedProperty, qnt = YS.valObjectMeta, uq = "_isSubplotObj", W6 = "_isLinkedToArray", Bnt = "_arrayAttrRegexps", wne = "_deprecated", cq = [uq, W6, Bnt, wne];\n            Jh.IS_SUBPLOT_OBJ = uq;\n            Jh.IS_LINKED_TO_ARRAY = W6;\n            Jh.DEPRECATED = wne;\n            Jh.UNDERSCORE_ATTRS = cq;\n            Jh.get = function() {\n              var e3 = {};\n              return _0.allTypes.forEach(function(t3) {\n                e3[t3] = Unt(t3);\n              }), { defs: { valObjects: qnt, metaKeys: cq.concat(["description", "role", "editType", "impliedEdits"]), editType: { traces: xne.traces, layout: xne.layout }, impliedEdits: {} }, traces: e3, layout: Vnt(), frames: Gnt(), animation: b3(Fnt), config: b3(znt) };\n            };\n            Jh.crawl = function(e3, t3, r4, n4) {\n              var i3 = r4 || 0;\n              n4 = n4 || "", Object.keys(e3).forEach(function(a4) {\n                var o4 = e3[a4];\n                if (cq.indexOf(a4) === -1) {\n                  var s3 = (n4 ? n4 + "." : "") + a4;\n                  t3(o4, a4, e3, i3, s3), !Jh.isValObject(o4) && x3(o4) && a4 !== "impliedEdits" && Jh.crawl(o4, t3, i3 + 1, s3);\n                }\n              });\n            };\n            Jh.isValObject = function(e3) {\n              return e3 && e3.valType !== void 0;\n            };\n            Jh.findArrayAttributes = function(e3) {\n              var t3 = [], r4 = [], n4 = [], i3, a4;\n              function o4(l3, u4, c5, f4) {\n                r4 = r4.slice(0, f4).concat([u4]), n4 = n4.slice(0, f4).concat([l3 && l3._isLinkedToArray]);\n                var h3 = l3 && (l3.valType === "data_array" || l3.arrayOk === true) && !(r4[f4 - 1] === "colorbar" && (u4 === "ticktext" || u4 === "tickvals"));\n                h3 && s3(i3, 0, "");\n              }\n              function s3(l3, u4, c5) {\n                var f4 = l3[r4[u4]], h3 = c5 + r4[u4];\n                if (u4 === r4.length - 1) Ont(f4) && t3.push(a4 + h3);\n                else if (n4[u4]) {\n                  if (Array.isArray(f4)) for (var d3 = 0; d3 < f4.length; d3++) x3(f4[d3]) && s3(f4[d3], u4 + 1, h3 + "[" + d3 + "].");\n                } else x3(f4) && s3(f4, u4 + 1, h3 + ".");\n              }\n              return i3 = e3, a4 = "", Jh.crawl(H6, o4), e3._module && e3._module.attributes && Jh.crawl(e3._module.attributes, o4), t3;\n            };\n            Jh.getTraceValObject = function(e3, t3) {\n              var r4 = t3[0], n4 = 1, i3, a4, o4 = e3._module;\n              if (o4 || (o4 = (_0.modules[e3.type || H6.type.dflt] || {})._module), !o4) return false;\n              if (i3 = o4.attributes, a4 = i3 && i3[r4], !a4) {\n                var s3 = o4.basePlotModule;\n                s3 && s3.attributes && (a4 = s3.attributes[r4]);\n              }\n              return a4 || (a4 = H6[r4]), Tne(a4, t3, n4);\n            };\n            Jh.getLayoutValObject = function(e3, t3) {\n              var r4 = Nnt(e3, t3[0]);\n              return Tne(r4, t3, 1);\n            };\n            function Nnt(e3, t3) {\n              var r4, n4, i3, a4, o4 = e3._basePlotModules;\n              if (o4) {\n                var s3;\n                for (r4 = 0; r4 < o4.length; r4++) {\n                  if (i3 = o4[r4], i3.attrRegex && i3.attrRegex.test(t3)) {\n                    if (i3.layoutAttrOverrides) return i3.layoutAttrOverrides;\n                    !s3 && i3.layoutAttributes && (s3 = i3.layoutAttributes);\n                  }\n                  var l3 = i3.baseLayoutAttrOverrides;\n                  if (l3 && t3 in l3) return l3[t3];\n                }\n                if (s3) return s3;\n              }\n              var u4 = e3._modules;\n              if (u4) {\n                for (r4 = 0; r4 < u4.length; r4++) if (a4 = u4[r4].layoutAttributes, a4 && t3 in a4) return a4[t3];\n              }\n              for (n4 in _0.componentsRegistry) {\n                if (i3 = _0.componentsRegistry[n4], i3.name === "colorscale" && t3.indexOf("coloraxis") === 0) return i3.layoutAttributes[t3];\n                if (!i3.schema && t3 === i3.name) return i3.layoutAttributes;\n              }\n              return t3 in lq ? lq[t3] : false;\n            }\n            function Tne(e3, t3, r4) {\n              if (!e3) return false;\n              if (e3._isLinkedToArray) {\n                if (G6(t3[r4])) r4++;\n                else if (r4 < t3.length) return false;\n              }\n              for (; r4 < t3.length; r4++) {\n                var n4 = e3[t3[r4]];\n                if (x3(n4)) e3 = n4;\n                else break;\n                if (r4 === t3.length - 1) break;\n                if (e3._isLinkedToArray) {\n                  if (r4++, !G6(t3[r4])) return false;\n                } else if (e3.valType === "info_array") {\n                  r4++;\n                  var i3 = t3[r4];\n                  if (!G6(i3)) return false;\n                  var a4 = e3.items;\n                  if (Array.isArray(a4)) {\n                    if (i3 >= a4.length) return false;\n                    if (e3.dimensions === 2) {\n                      if (r4++, t3.length === r4) return e3;\n                      var o4 = t3[r4];\n                      if (!G6(o4)) return false;\n                      e3 = a4[i3][o4];\n                    } else e3 = a4[i3];\n                  } else e3 = a4;\n                }\n              }\n              return e3;\n            }\n            function G6(e3) {\n              return e3 === Math.round(e3) && e3 >= 0;\n            }\n            function Unt(e3) {\n              var t3, r4;\n              t3 = _0.modules[e3]._module, r4 = t3.basePlotModule;\n              var n4 = {};\n              n4.type = null;\n              var i3 = wg({}, H6), a4 = wg({}, t3.attributes);\n              Jh.crawl(a4, function(l3, u4, c5, f4, h3) {\n                j6(i3, h3).set(void 0), l3 === void 0 && j6(a4, h3).set(void 0);\n              }), wg(n4, i3), _0.traceIs(e3, "noOpacity") && delete n4.opacity, _0.traceIs(e3, "showLegend") || (delete n4.showlegend, delete n4.legendgroup), _0.traceIs(e3, "noHover") && (delete n4.hoverinfo, delete n4.hoverlabel), t3.selectPoints || delete n4.selectedpoints, wg(n4, a4), r4.attributes && wg(n4, r4.attributes), n4.type = e3;\n              var o4 = { meta: t3.meta || {}, categories: t3.categories || {}, animatable: !!t3.animatable, type: e3, attributes: b3(n4) };\n              if (t3.layoutAttributes) {\n                var s3 = {};\n                wg(s3, t3.layoutAttributes), o4.layoutAttributes = b3(s3);\n              }\n              return t3.animatable || Jh.crawl(o4, function(l3) {\n                Jh.isValObject(l3) && "anim" in l3 && delete l3.anim;\n              }), o4;\n            }\n            function Vnt() {\n              var e3 = {}, t3, r4;\n              wg(e3, lq);\n              for (t3 in _0.subplotsRegistry) if (r4 = _0.subplotsRegistry[t3], !!r4.layoutAttributes) if (Array.isArray(r4.attr)) for (var n4 = 0; n4 < r4.attr.length; n4++) bne(e3, r4, r4.attr[n4]);\n              else {\n                var i3 = r4.attr === "subplot" ? r4.name : r4.attr;\n                bne(e3, r4, i3);\n              }\n              for (t3 in _0.componentsRegistry) {\n                r4 = _0.componentsRegistry[t3];\n                var a4 = r4.schema;\n                if (a4 && (a4.subplots || a4.layout)) {\n                  var o4 = a4.subplots;\n                  if (o4 && o4.xaxis && !o4.yaxis) for (var s3 in o4.xaxis) delete e3.yaxis[s3];\n                  delete e3.xaxis.shift, delete e3.xaxis.autoshift;\n                } else r4.name === "colorscale" ? wg(e3, r4.layoutAttributes) : r4.layoutAttributes && Xnt(e3, r4.layoutAttributes, r4.name);\n              }\n              return { layoutAttributes: b3(e3) };\n            }\n            function Gnt() {\n              var e3 = { frames: wg({}, Dnt) };\n              return b3(e3), e3.frames;\n            }\n            function b3(e3) {\n              return Hnt(e3), jnt(e3), Wnt(e3), e3;\n            }\n            function Hnt(e3) {\n              function t3(n4) {\n                return { valType: "string", editType: "none" };\n              }\n              function r4(n4, i3, a4) {\n                Jh.isValObject(n4) ? (n4.arrayOk === true || n4.valType === "data_array") && (a4[i3 + "src"] = t3(i3)) : x3(n4) && (n4.role = "object");\n              }\n              Jh.crawl(e3, r4);\n            }\n            function jnt(e3) {\n              function t3(r4, n4, i3) {\n                if (r4) {\n                  var a4 = r4[W6];\n                  a4 && (delete r4[W6], i3[n4] = { items: {} }, i3[n4].items[a4] = r4, i3[n4].role = "object");\n                }\n              }\n              Jh.crawl(e3, t3);\n            }\n            function Wnt(e3) {\n              function t3(r4) {\n                for (var n4 in r4) if (x3(r4[n4])) t3(r4[n4]);\n                else if (Array.isArray(r4[n4])) for (var i3 = 0; i3 < r4[n4].length; i3++) t3(r4[n4][i3]);\n                else r4[n4] instanceof RegExp && (r4[n4] = r4[n4].toString());\n              }\n              t3(e3);\n            }\n            function bne(e3, t3, r4) {\n              var n4 = j6(e3, r4), i3 = wg({}, t3.layoutAttributes);\n              i3[uq] = true, n4.set(i3);\n            }\n            function Xnt(e3, t3, r4) {\n              var n4 = j6(e3, r4);\n              n4.set(wg(n4.get() || {}, t3));\n            }\n          });\n          var vl = ye((gb) => {\n            "use strict";\n            var T3 = Dr(), Znt = Gl(), $1 = "templateitemname", fq = { name: { valType: "string", editType: "none" } };\n            fq[$1] = { valType: "string", editType: "calc" };\n            gb.templatedArray = function(e3, t3) {\n              return t3._isLinkedToArray = e3, t3.name = fq.name, t3[$1] = fq[$1], t3;\n            };\n            gb.traceTemplater = function(e3) {\n              var t3 = {}, r4, n4;\n              for (r4 in e3) n4 = e3[r4], Array.isArray(n4) && n4.length && (t3[r4] = 0);\n              function i3(a4) {\n                r4 = T3.coerce(a4, {}, Znt, "type");\n                var o4 = { type: r4, _template: null };\n                if (r4 in t3) {\n                  n4 = e3[r4];\n                  var s3 = t3[r4] % n4.length;\n                  t3[r4]++, o4._template = n4[s3];\n                }\n                return o4;\n              }\n              return { newTrace: i3 };\n            };\n            gb.newContainer = function(e3, t3, r4) {\n              var n4 = e3._template, i3 = n4 && (n4[t3] || r4 && n4[r4]);\n              T3.isPlainObject(i3) || (i3 = null);\n              var a4 = e3[t3] = { _template: i3 };\n              return a4;\n            };\n            gb.arrayTemplater = function(e3, t3, r4) {\n              var n4 = e3._template, i3 = n4 && n4[Sne(t3)], a4 = n4 && n4[t3];\n              (!Array.isArray(a4) || !a4.length) && (a4 = []);\n              var o4 = {};\n              function s3(u4) {\n                var c5 = { name: u4.name, _input: u4 }, f4 = c5[$1] = u4[$1];\n                if (!Ane(f4)) return c5._template = i3, c5;\n                for (var h3 = 0; h3 < a4.length; h3++) {\n                  var d3 = a4[h3];\n                  if (d3.name === f4) return o4[f4] = 1, c5._template = d3, c5;\n                }\n                return c5[r4] = u4[r4] || false, c5._template = false, c5;\n              }\n              function l3() {\n                for (var u4 = [], c5 = 0; c5 < a4.length; c5++) {\n                  var f4 = a4[c5], h3 = f4.name;\n                  if (Ane(h3) && !o4[h3]) {\n                    var d3 = { _template: f4, name: h3, _input: { _templateitemname: h3 } };\n                    d3[$1] = f4[$1], u4.push(d3), o4[h3] = 1;\n                  }\n                }\n                return u4;\n              }\n              return { newItem: s3, defaultItems: l3 };\n            };\n            function Ane(e3) {\n              return e3 && typeof e3 == "string";\n            }\n            function Sne(e3) {\n              var t3 = e3.length - 1;\n              return e3.charAt(t3) !== "s" && T3.warn("bad argument to arrayDefaultKey: " + e3), e3.slice(0, -1) + "defaults";\n            }\n            gb.arrayDefaultKey = Sne;\n            gb.arrayEditor = function(e3, t3, r4) {\n              var n4 = (T3.nestedProperty(e3, t3).get() || []).length, i3 = r4._index, a4 = i3 >= n4 && (r4._input || {})._templateitemname;\n              a4 && (i3 = n4);\n              var o4 = t3 + "[" + i3 + "]", s3;\n              function l3() {\n                s3 = {}, a4 && (s3[o4] = {}, s3[o4][$1] = a4);\n              }\n              l3();\n              function u4(d3, v3) {\n                s3[d3] = v3;\n              }\n              function c5(d3, v3) {\n                a4 ? T3.nestedProperty(s3[o4], d3).set(v3) : s3[o4 + "." + d3] = v3;\n              }\n              function f4() {\n                var d3 = s3;\n                return l3(), d3;\n              }\n              function h3(d3, v3) {\n                d3 && c5(d3, v3);\n                var _2 = f4();\n                for (var b in _2) T3.nestedProperty(e3, b).set(_2[b]);\n              }\n              return { modifyBase: u4, modifyItem: c5, getUpdateObj: f4, applyUpdate: h3 };\n            };\n          });\n          var hd = ye((inr, Mne) => {\n            "use strict";\n            var KS = o3().counter;\n            Mne.exports = { idRegex: { x: KS("x", "( domain)?"), y: KS("y", "( domain)?") }, attrRegex: KS("[xy]axis"), xAxisMatch: KS("xaxis"), yAxisMatch: KS("yaxis"), AX_ID_PATTERN: /^[xyz][0-9]*( domain)?$/, AX_NAME_PATTERN: /^[xyz]axis[0-9]*$/, SUBPLOT_PATTERN: /^x([0-9]*)y([0-9]*)$/, HOUR_PATTERN: "hour", WEEKDAY_PATTERN: "day of week", MINDRAG: 8, MINZOOM: 20, DRAGGERSIZE: 20, REDRAWDELAY: 50, DFLTRANGEX: [-1, 6], DFLTRANGEY: [-1, 4], traceLayerClasses: ["imagelayer", "heatmaplayer", "contourcarpetlayer", "contourlayer", "funnellayer", "waterfalllayer", "barlayer", "carpetlayer", "violinlayer", "boxlayer", "ohlclayer", "scattercarpetlayer", "scatterlayer"], clipOnAxisFalseQuery: [".scatterlayer", ".barlayer", ".funnellayer", ".waterfalllayer"], layerValue2layerClass: { "above traces": "above", "below traces": "below" }, zindexSeparator: "z" };\n          });\n          var hf = ye((Ap) => {\n            "use strict";\n            var Ynt = qa(), hq = hd();\n            Ap.id2name = function(t3) {\n              if (!(typeof t3 != "string" || !t3.match(hq.AX_ID_PATTERN))) {\n                var r4 = t3.split(" ")[0].slice(1);\n                return r4 === "1" && (r4 = ""), t3.charAt(0) + "axis" + r4;\n              }\n            };\n            Ap.name2id = function(t3) {\n              if (t3.match(hq.AX_NAME_PATTERN)) {\n                var r4 = t3.slice(5);\n                return r4 === "1" && (r4 = ""), t3.charAt(0) + r4;\n              }\n            };\n            Ap.cleanId = function(t3, r4, n4) {\n              var i3 = /( domain)$/.test(t3);\n              if (!(typeof t3 != "string" || !t3.match(hq.AX_ID_PATTERN)) && !(r4 && t3.charAt(0) !== r4) && !(i3 && !n4)) {\n                var a4 = t3.split(" ")[0].slice(1).replace(/^0+/, "");\n                return a4 === "1" && (a4 = ""), t3.charAt(0) + a4 + (i3 && n4 ? " domain" : "");\n              }\n            };\n            Ap.list = function(e3, t3, r4) {\n              var n4 = e3._fullLayout;\n              if (!n4) return [];\n              var i3 = Ap.listIds(e3, t3), a4 = new Array(i3.length), o4;\n              for (o4 = 0; o4 < i3.length; o4++) {\n                var s3 = i3[o4];\n                a4[o4] = n4[s3.charAt(0) + "axis" + s3.slice(1)];\n              }\n              if (!r4) {\n                var l3 = n4._subplots.gl3d || [];\n                for (o4 = 0; o4 < l3.length; o4++) {\n                  var u4 = n4[l3[o4]];\n                  t3 ? a4.push(u4[t3 + "axis"]) : a4.push(u4.xaxis, u4.yaxis, u4.zaxis);\n                }\n              }\n              return a4;\n            };\n            Ap.listIds = function(e3, t3) {\n              var r4 = e3._fullLayout;\n              if (!r4) return [];\n              var n4 = r4._subplots;\n              return t3 ? n4[t3 + "axis"] : n4.xaxis.concat(n4.yaxis);\n            };\n            Ap.getFromId = function(e3, t3, r4) {\n              var n4 = e3._fullLayout;\n              return t3 = t3 === void 0 || typeof t3 != "string" ? t3 : t3.replace(" domain", ""), r4 === "x" ? t3 = t3.replace(/y[0-9]*/, "") : r4 === "y" && (t3 = t3.replace(/x[0-9]*/, "")), n4[Ap.id2name(t3)];\n            };\n            Ap.getFromTrace = function(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = null;\n              if (Ynt.traceIs(t3, "gl3d")) {\n                var a4 = t3.scene;\n                a4.slice(0, 5) === "scene" && (i3 = n4[a4][r4 + "axis"]);\n              } else i3 = Ap.getFromId(e3, t3[r4 + "axis"] || r4);\n              return i3;\n            };\n            Ap.idSort = function(e3, t3) {\n              var r4 = e3.charAt(0), n4 = t3.charAt(0);\n              return r4 !== n4 ? r4 > n4 ? 1 : -1 : +(e3.slice(1) || 1) - +(t3.slice(1) || 1);\n            };\n            Ap.ref2id = function(e3) {\n              return /^[xyz]/.test(e3) ? e3.split(" ")[0] : false;\n            };\n            function Ene(e3, t3) {\n              if (t3 && t3.length) {\n                for (var r4 = 0; r4 < t3.length; r4++) if (t3[r4][e3]) return true;\n              }\n              return false;\n            }\n            Ap.isLinked = function(e3, t3) {\n              return Ene(t3, e3._axisMatchGroups) || Ene(t3, e3._axisConstraintGroups);\n            };\n          });\n          var Q1 = ye((anr, kne) => {\n            "use strict";\n            function Knt(e3) {\n              var t3 = e3._fullLayout._zoomlayer;\n              t3 && t3.selectAll(".outline-controllers").remove();\n            }\n            function Jnt(e3) {\n              var t3 = e3._fullLayout._zoomlayer;\n              t3 && t3.selectAll(".select-outline").remove(), e3._fullLayout._outlining = false;\n            }\n            kne.exports = { clearOutlineControllers: Knt, clearOutline: Jnt };\n          });\n          var X6 = ye((onr, Cne) => {\n            "use strict";\n            Cne.exports = { scattermode: { valType: "enumerated", values: ["group", "overlay"], dflt: "overlay", editType: "calc" }, scattergap: { valType: "number", min: 0, max: 1, editType: "calc" } };\n          });\n          var Id = ye((Y6) => {\n            "use strict";\n            var Z6 = qa(), snr = hd().SUBPLOT_PATTERN;\n            Y6.getSubplotCalcData = function(e3, t3, r4) {\n              var n4 = Z6.subplotsRegistry[t3];\n              if (!n4) return [];\n              for (var i3 = n4.attr, a4 = [], o4 = 0; o4 < e3.length; o4++) {\n                var s3 = e3[o4], l3 = s3[0].trace;\n                l3[i3] === r4 && a4.push(s3);\n              }\n              return a4;\n            };\n            Y6.getModuleCalcData = function(e3, t3, r4) {\n              var n4 = [], i3 = [], a4;\n              if (typeof t3 == "string" ? a4 = Z6.getModule(t3).plot : typeof t3 == "function" ? a4 = t3 : a4 = t3.plot, !a4) return [n4, e3];\n              for (var o4 = r4, s3 = 0; s3 < e3.length; s3++) {\n                var l3 = e3[s3], u4 = l3[0].trace, c5 = u4.zorder !== void 0;\n                u4.visible !== true || u4._length === 0 || (u4._module && u4._module.plot === a4 && (!c5 || u4.zorder === o4) ? n4.push(l3) : i3.push(l3));\n              }\n              return [n4, i3];\n            };\n            Y6.getSubplotData = function(t3, r4, n4) {\n              if (!Z6.subplotsRegistry[r4]) return [];\n              for (var i3 = Z6.subplotsRegistry[r4].attr, a4 = [], o4, s3, l3, u4 = 0; u4 < t3.length; u4++) o4 = t3[u4], o4[i3] === n4 && a4.push(o4);\n              return a4;\n            };\n          });\n          var Rne = ye((mb) => {\n            "use strict";\n            var $nt = qa(), A3 = Dr();\n            mb.manageCommandObserver = function(e3, t3, r4, n4) {\n              var i3 = {}, a4 = true;\n              t3 && t3._commandObserver && (i3 = t3._commandObserver), i3.cache || (i3.cache = {}), i3.lookupTable = {};\n              var o4 = mb.hasSimpleAPICommandBindings(e3, r4, i3.lookupTable);\n              if (t3 && t3._commandObserver) {\n                if (o4) return i3;\n                if (t3._commandObserver.remove) return t3._commandObserver.remove(), t3._commandObserver = null, i3;\n              }\n              if (o4) {\n                Lne(e3, o4, i3.cache), i3.check = function() {\n                  if (a4) {\n                    var c5 = Lne(e3, o4, i3.cache);\n                    return c5.changed && n4 && i3.lookupTable[c5.value] !== void 0 && (i3.disable(), Promise.resolve(n4({ value: c5.value, type: o4.type, prop: o4.prop, traces: o4.traces, index: i3.lookupTable[c5.value] })).then(i3.enable, i3.enable)), c5.changed;\n                  }\n                };\n                for (var s3 = ["plotly_relayout", "plotly_redraw", "plotly_restyle", "plotly_update", "plotly_animatingframe", "plotly_afterplot"], l3 = 0; l3 < s3.length; l3++) e3._internalOn(s3[l3], i3.check);\n                i3.remove = function() {\n                  for (var u4 = 0; u4 < s3.length; u4++) e3._removeInternalListener(s3[u4], i3.check);\n                };\n              } else A3.log("Unable to automatically bind plot updates to API command"), i3.lookupTable = {}, i3.remove = function() {\n              };\n              return i3.disable = function() {\n                a4 = false;\n              }, i3.enable = function() {\n                a4 = true;\n              }, t3 && (t3._commandObserver = i3), i3;\n            };\n            mb.hasSimpleAPICommandBindings = function(e3, t3, r4) {\n              var n4, i3 = t3.length, a4;\n              for (n4 = 0; n4 < i3; n4++) {\n                var o4, s3 = t3[n4], l3 = s3.method, u4 = s3.args;\n                if (Array.isArray(u4) || (u4 = []), !l3) return false;\n                var c5 = mb.computeAPICommandBindings(e3, l3, u4);\n                if (c5.length !== 1) return false;\n                if (!a4) a4 = c5[0], Array.isArray(a4.traces) && a4.traces.sort();\n                else {\n                  if (o4 = c5[0], o4.type !== a4.type || o4.prop !== a4.prop) return false;\n                  if (Array.isArray(a4.traces)) if (Array.isArray(o4.traces)) {\n                    o4.traces.sort();\n                    for (var f4 = 0; f4 < a4.traces.length; f4++) if (a4.traces[f4] !== o4.traces[f4]) return false;\n                  } else return false;\n                  else if (o4.prop !== a4.prop) return false;\n                }\n                o4 = c5[0];\n                var h3 = o4.value;\n                if (Array.isArray(h3)) if (h3.length === 1) h3 = h3[0];\n                else return false;\n                r4 && (r4[h3] = n4);\n              }\n              return a4;\n            };\n            function Lne(e3, t3, r4) {\n              var n4, i3, a4, o4 = false;\n              if (t3.type === "data") n4 = e3._fullData[t3.traces !== null ? t3.traces[0] : 0];\n              else if (t3.type === "layout") n4 = e3._fullLayout;\n              else return false;\n              return i3 = A3.nestedProperty(n4, t3.prop).get(), a4 = r4[t3.type] = r4[t3.type] || {}, a4.hasOwnProperty(t3.prop) && a4[t3.prop] !== i3 && (o4 = true), a4[t3.prop] = i3, { changed: o4, value: i3 };\n            }\n            mb.executeAPICommand = function(e3, t3, r4) {\n              if (t3 === "skip") return Promise.resolve();\n              var n4 = $nt.apiMethodRegistry[t3], i3 = [e3];\n              Array.isArray(r4) || (r4 = []);\n              for (var a4 = 0; a4 < r4.length; a4++) i3.push(r4[a4]);\n              return n4.apply(null, i3).catch(function(o4) {\n                return A3.warn("API call to Plotly." + t3 + " rejected.", o4), Promise.reject(o4);\n              });\n            };\n            mb.computeAPICommandBindings = function(e3, t3, r4) {\n              var n4;\n              switch (Array.isArray(r4) || (r4 = []), t3) {\n                case "restyle":\n                  n4 = Ine(e3, r4);\n                  break;\n                case "relayout":\n                  n4 = Pne(e3, r4);\n                  break;\n                case "update":\n                  n4 = Ine(e3, [r4[0], r4[2]]).concat(Pne(e3, [r4[1]]));\n                  break;\n                case "animate":\n                  n4 = Qnt(e3, r4);\n                  break;\n                default:\n                  n4 = [];\n              }\n              return n4;\n            };\n            function Qnt(e3, t3) {\n              return Array.isArray(t3[0]) && t3[0].length === 1 && ["string", "number"].indexOf(typeof t3[0][0]) !== -1 ? [{ type: "layout", prop: "_currentFrame", value: t3[0][0].toString() }] : [];\n            }\n            function Pne(e3, t3) {\n              var r4 = [], n4 = t3[0], i3 = {};\n              if (typeof n4 == "string") i3[n4] = t3[1];\n              else if (A3.isPlainObject(n4)) i3 = n4;\n              else return r4;\n              return dq(i3, function(a4, o4, s3) {\n                r4.push({ type: "layout", prop: a4, value: s3 });\n              }, "", 0), r4;\n            }\n            function Ine(e3, t3) {\n              var r4, n4, i3, a4, o4 = [];\n              if (n4 = t3[0], i3 = t3[1], r4 = t3[2], a4 = {}, typeof n4 == "string") a4[n4] = i3;\n              else if (A3.isPlainObject(n4)) a4 = n4, r4 === void 0 && (r4 = i3);\n              else return o4;\n              return r4 === void 0 && (r4 = null), dq(a4, function(s3, l3, u4) {\n                var c5, f4;\n                if (Array.isArray(u4)) {\n                  f4 = u4.slice();\n                  var h3 = Math.min(f4.length, e3.data.length);\n                  r4 && (h3 = Math.min(h3, r4.length)), c5 = [];\n                  for (var d3 = 0; d3 < h3; d3++) c5[d3] = r4 ? r4[d3] : d3;\n                } else f4 = u4, c5 = r4 ? r4.slice() : null;\n                if (c5 === null) Array.isArray(f4) && (f4 = f4[0]);\n                else if (Array.isArray(c5)) {\n                  if (!Array.isArray(f4)) {\n                    var v3 = f4;\n                    f4 = [];\n                    for (var _2 = 0; _2 < c5.length; _2++) f4[_2] = v3;\n                  }\n                  f4.length = Math.min(c5.length, f4.length);\n                }\n                o4.push({ type: "data", prop: s3, traces: c5, value: f4 });\n              }, "", 0), o4;\n            }\n            function dq(e3, t3, r4, n4) {\n              Object.keys(e3).forEach(function(i3) {\n                var a4 = e3[i3];\n                if (i3[0] !== "_") {\n                  var o4 = r4 + (n4 > 0 ? "." : "") + i3;\n                  A3.isPlainObject(a4) ? dq(a4, t3, o4, n4 + 1) : t3(o4, i3, a4);\n                }\n              });\n            }\n          });\n          var Mc = ye((cnr, Xne) => {\n            "use strict";\n            var Nne = Oa(), eat = r3().timeFormatLocale, tat = wO().formatLocale, JS = Eo(), rat = TO(), Xl = qa(), Une = w3(), iat = vl(), Ga = Dr(), Vne = ka(), Dne = fs().BADNUM, Sp = hf(), nat = Q1().clearOutline, aat = X6(), vq = US(), oat = sq(), sat = Id().getModuleCalcData, Fne = Ga.relinkPrivateKeys, yb = Ga._, xa = Xne.exports = {};\n            Ga.extendFlat(xa, Xl);\n            xa.attributes = Gl();\n            xa.attributes.type.values = xa.allTypes;\n            xa.fontAttrs = ec();\n            xa.layoutAttributes = c3();\n            var J6 = Rne();\n            xa.executeAPICommand = J6.executeAPICommand;\n            xa.computeAPICommandBindings = J6.computeAPICommandBindings;\n            xa.manageCommandObserver = J6.manageCommandObserver;\n            xa.hasSimpleAPICommandBindings = J6.hasSimpleAPICommandBindings;\n            xa.redrawText = function(e3) {\n              return e3 = Ga.getGraphDiv(e3), new Promise(function(t3) {\n                setTimeout(function() {\n                  e3._fullLayout && (Xl.getComponentMethod("annotations", "draw")(e3), Xl.getComponentMethod("legend", "draw")(e3), Xl.getComponentMethod("colorbar", "draw")(e3), t3(xa.previousPromises(e3)));\n                }, 300);\n              });\n            };\n            xa.resize = function(e3) {\n              e3 = Ga.getGraphDiv(e3);\n              var t3, r4 = new Promise(function(n4, i3) {\n                (!e3 || Ga.isHidden(e3)) && i3(new Error("Resize must be passed a displayed plot div element.")), e3._redrawTimer && clearTimeout(e3._redrawTimer), e3._resolveResize && (t3 = e3._resolveResize), e3._resolveResize = n4, e3._redrawTimer = setTimeout(function() {\n                  if (!e3.layout || e3.layout.width && e3.layout.height || Ga.isHidden(e3)) {\n                    n4(e3);\n                    return;\n                  }\n                  delete e3.layout.width, delete e3.layout.height;\n                  var a4 = e3.changed;\n                  e3.autoplay = true, Xl.call("relayout", e3, { autosize: true }).then(function() {\n                    e3.changed = a4, e3._resolveResize === n4 && (delete e3._resolveResize, n4(e3));\n                  });\n                }, 100);\n              });\n              return t3 && t3(r4), r4;\n            };\n            xa.previousPromises = function(e3) {\n              if ((e3._promises || []).length) return Promise.all(e3._promises).then(function() {\n                e3._promises = [];\n              });\n            };\n            xa.addLinks = function(e3) {\n              if (!(!e3._context.showLink && !e3._context.showSources)) {\n                var t3 = e3._fullLayout, r4 = Ga.ensureSingle(t3._paper, "text", "js-plot-link-container", function(l3) {\n                  l3.style({ "font-family": \'"Open Sans", Arial, sans-serif\', "font-size": "12px", fill: Vne.defaultLine, "pointer-events": "all" }).each(function() {\n                    var u4 = Nne.select(this);\n                    u4.append("tspan").classed("js-link-to-tool", true), u4.append("tspan").classed("js-link-spacer", true), u4.append("tspan").classed("js-sourcelinks", true);\n                  });\n                }), n4 = r4.node(), i3 = { y: t3._paper.attr("height") - 9 };\n                document.body.contains(n4) && n4.getComputedTextLength() >= t3.width - 20 ? (i3["text-anchor"] = "start", i3.x = 5) : (i3["text-anchor"] = "end", i3.x = t3._paper.attr("width") - 7), r4.attr(i3);\n                var a4 = r4.select(".js-link-to-tool"), o4 = r4.select(".js-link-spacer"), s3 = r4.select(".js-sourcelinks");\n                e3._context.showSources && e3._context.showSources(e3), e3._context.showLink && lat(e3, a4), o4.text(a4.text() && s3.text() ? " - " : "");\n              }\n            };\n            function lat(e3, t3) {\n              t3.text("");\n              var r4 = t3.append("a").attr({ "xlink:xlink:href": "#", class: "link--impt link--embedview", "font-weight": "bold" }).text(e3._context.linkText + " \\xBB");\n              if (e3._context.sendData) r4.on("click", function() {\n                xa.sendDataToCloud(e3);\n              });\n              else {\n                var n4 = window.location.pathname.split("/"), i3 = window.location.search;\n                r4.attr({ "xlink:xlink:show": "new", "xlink:xlink:href": "/" + n4[2].split(".")[0] + "/" + n4[1] + i3 });\n              }\n            }\n            xa.sendDataToCloud = function(e3) {\n              var t3 = (window.PLOTLYENV || {}).BASE_URL || e3._context.plotlyServerURL;\n              if (t3) {\n                e3.emit("plotly_beforeexport");\n                var r4 = Nne.select(e3).append("div").attr("id", "hiddenform").style("display", "none"), n4 = r4.append("form").attr({ action: t3 + "/external", method: "post", target: "_blank" }), i3 = n4.append("input").attr({ type: "text", name: "data" });\n                return i3.node().value = xa.graphJson(e3, false, "keepdata"), n4.node().submit(), r4.remove(), e3.emit("plotly_afterexport"), false;\n              }\n            };\n            var uat = ["days", "shortDays", "months", "shortMonths", "periods", "dateTime", "date", "time", "decimal", "thousands", "grouping", "currency"], cat = ["year", "month", "dayMonth", "dayMonthYear"];\n            xa.supplyDefaults = function(e3, t3) {\n              var r4 = t3 && t3.skipUpdateCalc, n4 = e3._fullLayout || {};\n              if (n4._skipDefaults) {\n                delete n4._skipDefaults;\n                return;\n              }\n              var i3 = e3._fullLayout = {}, a4 = e3.layout || {}, o4 = e3._fullData || [], s3 = e3._fullData = [], l3 = e3.data || [], u4 = e3.calcdata || [], c5 = e3._context || {}, f4;\n              e3._transitionData || xa.createTransitionData(e3), i3._dfltTitle = { plot: yb(e3, "Click to enter Plot title"), subtitle: yb(e3, "Click to enter Plot subtitle"), x: yb(e3, "Click to enter X axis title"), y: yb(e3, "Click to enter Y axis title"), colorbar: yb(e3, "Click to enter Colorscale title"), annotation: yb(e3, "new text") }, i3._traceWord = yb(e3, "trace");\n              var h3 = zne(e3, uat);\n              if (i3._mapboxAccessToken = c5.mapboxAccessToken, n4._initialAutoSizeIsDone) {\n                var d3 = n4.width, v3 = n4.height;\n                xa.supplyLayoutGlobalDefaults(a4, i3, h3), a4.width || (i3.width = d3), a4.height || (i3.height = v3), xa.sanitizeMargins(i3);\n              } else {\n                xa.supplyLayoutGlobalDefaults(a4, i3, h3);\n                var _2 = !a4.width || !a4.height, b = i3.autosize, p3 = c5.autosizable, k4 = _2 && (b || p3);\n                k4 ? xa.plotAutoSize(e3, a4, i3) : _2 && xa.sanitizeMargins(i3), !b && _2 && (a4.width = i3.width, a4.height = i3.height);\n              }\n              i3._d3locale = dat(h3, i3.separators), i3._extraFormat = zne(e3, cat), i3._initialAutoSizeIsDone = true, i3._dataLength = l3.length, i3._modules = [], i3._visibleModules = [], i3._basePlotModules = [];\n              var E3 = i3._subplots = hat(), S2 = i3._splomAxes = { x: {}, y: {} }, L3 = i3._splomSubplots = {};\n              i3._splomGridDflt = {}, i3._scatterStackOpts = {}, i3._firstScatter = {}, i3._alignmentOpts = {}, i3._colorAxes = {}, i3._requestRangeslider = {}, i3._traceUids = fat(o4, l3), xa.supplyDataDefaults(l3, s3, a4, i3);\n              var x2 = Object.keys(S2.x), C3 = Object.keys(S2.y);\n              if (x2.length > 1 && C3.length > 1) {\n                for (Xl.getComponentMethod("grid", "sizeDefaults")(a4, i3), f4 = 0; f4 < x2.length; f4++) Ga.pushUnique(E3.xaxis, x2[f4]);\n                for (f4 = 0; f4 < C3.length; f4++) Ga.pushUnique(E3.yaxis, C3[f4]);\n                for (var M4 in L3) Ga.pushUnique(E3.cartesian, M4);\n              }\n              if (i3._has = xa._hasPlotType.bind(i3), o4.length === s3.length) for (f4 = 0; f4 < s3.length; f4++) Fne(s3[f4], o4[f4]);\n              xa.supplyLayoutModuleDefaults(a4, i3, s3, e3._transitionData);\n              var g3 = i3._visibleModules, P3 = [];\n              for (f4 = 0; f4 < g3.length; f4++) {\n                var T3 = g3[f4].crossTraceDefaults;\n                T3 && Ga.pushUnique(P3, T3);\n              }\n              for (f4 = 0; f4 < P3.length; f4++) P3[f4](s3, i3);\n              i3._hasOnlyLargeSploms = i3._basePlotModules.length === 1 && i3._basePlotModules[0].name === "splom" && x2.length > 15 && C3.length > 15 && i3.shapes.length === 0 && i3.images.length === 0, xa.linkSubplots(s3, i3, o4, n4), xa.cleanPlot(s3, i3, o4, n4);\n              var z3 = !!(n4._has && n4._has("cartesian")), O3 = !!(i3._has && i3._has("cartesian")), V2 = z3, G2 = O3;\n              V2 && !G2 ? n4._bgLayer.remove() : G2 && !V2 && (i3._shouldCreateBgLayer = true), n4._zoomlayer && !e3._dragging && nat({ _fullLayout: n4 }), vat(s3, i3), Fne(i3, n4), Xl.getComponentMethod("colorscale", "crossTraceDefaults")(s3, i3), i3._preGUI || (i3._preGUI = {}), i3._tracePreGUI || (i3._tracePreGUI = {});\n              var Z = i3._tracePreGUI, j3 = {}, N2;\n              for (N2 in Z) j3[N2] = "old";\n              for (f4 = 0; f4 < s3.length; f4++) N2 = s3[f4]._fullInput.uid, j3[N2] || (Z[N2] = {}), j3[N2] = "new";\n              for (N2 in j3) j3[N2] === "old" && delete Z[N2];\n              Gne(i3), Xl.getComponentMethod("rangeslider", "makeData")(i3), !r4 && u4.length === s3.length && xa.supplyDefaultsUpdateCalc(u4, s3);\n            };\n            xa.supplyDefaultsUpdateCalc = function(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4], i3 = (e3[r4] || [])[0];\n                if (i3 && i3.trace) {\n                  var a4 = i3.trace;\n                  if (a4._hasCalcTransform) {\n                    var o4 = a4._arrayAttrs, s3, l3, u4;\n                    for (s3 = 0; s3 < o4.length; s3++) l3 = o4[s3], u4 = Ga.nestedProperty(a4, l3).get().slice(), Ga.nestedProperty(n4, l3).set(u4);\n                  }\n                  i3.trace = n4;\n                }\n              }\n            };\n            function fat(e3, t3) {\n              var r4 = t3.length, n4 = [], i3, a4;\n              for (i3 = 0; i3 < e3.length; i3++) {\n                var o4 = e3[i3]._fullInput;\n                o4 !== a4 && n4.push(o4), a4 = o4;\n              }\n              var s3 = n4.length, l3 = new Array(r4), u4 = {};\n              function c5(d3, v3) {\n                l3[v3] = d3, u4[d3] = 1;\n              }\n              function f4(d3, v3) {\n                if (d3 && typeof d3 == "string" && !u4[d3]) return c5(d3, v3), true;\n              }\n              for (i3 = 0; i3 < r4; i3++) {\n                var h3 = t3[i3].uid;\n                typeof h3 == "number" && (h3 = String(h3)), !f4(h3, i3) && (i3 < s3 && f4(n4[i3].uid, i3) || c5(Ga.randstr(u4), i3));\n              }\n              return l3;\n            }\n            function hat() {\n              var e3 = Xl.collectableSubplotTypes, t3 = {}, r4, n4;\n              if (!e3) {\n                e3 = [];\n                var i3 = Xl.subplotsRegistry;\n                for (var a4 in i3) {\n                  var o4 = i3[a4], s3 = o4.attr;\n                  if (s3 && (e3.push(a4), Array.isArray(s3))) for (n4 = 0; n4 < s3.length; n4++) Ga.pushUnique(e3, s3[n4]);\n                }\n              }\n              for (r4 = 0; r4 < e3.length; r4++) t3[e3[r4]] = [];\n              return t3;\n            }\n            function zne(e3, t3) {\n              var r4 = e3._context.locale;\n              r4 || (r4 = "en-US");\n              var n4 = false, i3 = {};\n              function a4(f4) {\n                for (var h3 = true, d3 = 0; d3 < t3.length; d3++) {\n                  var v3 = t3[d3];\n                  i3[v3] || (f4[v3] ? i3[v3] = f4[v3] : h3 = false);\n                }\n                h3 && (n4 = true);\n              }\n              for (var o4 = 0; o4 < 2; o4++) {\n                for (var s3 = e3._context.locales, l3 = 0; l3 < 2; l3++) {\n                  var u4 = (s3[r4] || {}).format;\n                  if (u4 && (a4(u4), n4)) break;\n                  s3 = Xl.localeRegistry;\n                }\n                var c5 = r4.split("-")[0];\n                if (n4 || c5 === r4) break;\n                r4 = c5;\n              }\n              return n4 || a4(Xl.localeRegistry.en.format), i3;\n            }\n            function dat(e3, t3) {\n              return e3.decimal = t3.charAt(0), e3.thousands = t3.charAt(1), { numberFormat: function(r4) {\n                try {\n                  r4 = tat(e3).format(Ga.adjustFormat(r4));\n                } catch (n4) {\n                  return Ga.warnBadFormat(r4), Ga.noFormat;\n                }\n                return r4;\n              }, timeFormat: eat(e3).utcFormat };\n            }\n            function vat(e3, t3) {\n              var r4, n4 = [];\n              t3.meta && (r4 = t3._meta = { meta: t3.meta, layout: { meta: t3.meta } });\n              for (var i3 = 0; i3 < e3.length; i3++) {\n                var a4 = e3[i3];\n                a4.meta ? n4[a4.index] = a4._meta = { meta: a4.meta } : t3.meta && (a4._meta = { meta: t3.meta }), t3.meta && (a4._meta.layout = { meta: t3.meta });\n              }\n              n4.length && (r4 || (r4 = t3._meta = {}), r4.data = n4);\n            }\n            xa.createTransitionData = function(e3) {\n              e3._transitionData || (e3._transitionData = {}), e3._transitionData._frames || (e3._transitionData._frames = []), e3._transitionData._frameHash || (e3._transitionData._frameHash = {}), e3._transitionData._counter || (e3._transitionData._counter = 0), e3._transitionData._interruptCallbacks || (e3._transitionData._interruptCallbacks = []);\n            };\n            xa._hasPlotType = function(e3) {\n              var t3, r4 = this._basePlotModules || [];\n              for (t3 = 0; t3 < r4.length; t3++) if (r4[t3].name === e3) return true;\n              var n4 = this._modules || [];\n              for (t3 = 0; t3 < n4.length; t3++) {\n                var i3 = n4[t3].name;\n                if (i3 === e3) return true;\n                var a4 = Xl.modules[i3];\n                if (a4 && a4.categories[e3]) return true;\n              }\n              return false;\n            };\n            xa.cleanPlot = function(e3, t3, r4, n4) {\n              var i3, a4, o4 = n4._basePlotModules || [];\n              for (i3 = 0; i3 < o4.length; i3++) {\n                var s3 = o4[i3];\n                s3.clean && s3.clean(e3, t3, r4, n4);\n              }\n              var l3 = n4._has && n4._has("gl"), u4 = t3._has && t3._has("gl");\n              l3 && !u4 && n4._glcontainer !== void 0 && (n4._glcontainer.selectAll(".gl-canvas").remove(), n4._glcontainer.selectAll(".no-webgl").remove(), n4._glcanvas = null);\n              var c5 = !!n4._infolayer;\n              e: for (i3 = 0; i3 < r4.length; i3++) {\n                var f4 = r4[i3], h3 = f4.uid;\n                for (a4 = 0; a4 < e3.length; a4++) {\n                  var d3 = e3[a4];\n                  if (h3 === d3.uid) continue e;\n                }\n                c5 && n4._infolayer.select(".cb" + h3).remove();\n              }\n            };\n            xa.linkSubplots = function(e3, t3, r4, n4) {\n              var i3, a4, o4 = n4._plots || {}, s3 = t3._plots = {}, l3 = t3._subplots, u4 = { _fullData: e3, _fullLayout: t3 }, c5 = l3.cartesian || [];\n              for (i3 = 0; i3 < c5.length; i3++) {\n                var f4 = c5[i3], h3 = o4[f4], d3 = Sp.getFromId(u4, f4, "x"), v3 = Sp.getFromId(u4, f4, "y"), _2;\n                for (h3 ? _2 = s3[f4] = h3 : (_2 = s3[f4] = {}, _2.id = f4), d3._counterAxes.push(v3._id), v3._counterAxes.push(d3._id), d3._subplotsWith.push(f4), v3._subplotsWith.push(f4), _2.xaxis = d3, _2.yaxis = v3, _2._hasClipOnAxisFalse = false, a4 = 0; a4 < e3.length; a4++) {\n                  var b = e3[a4];\n                  if (b.xaxis === _2.xaxis._id && b.yaxis === _2.yaxis._id && b.cliponaxis === false) {\n                    _2._hasClipOnAxisFalse = true;\n                    break;\n                  }\n                }\n              }\n              var p3 = Sp.list(u4, null, true), k4;\n              for (i3 = 0; i3 < p3.length; i3++) {\n                k4 = p3[i3];\n                var E3 = null;\n                k4.overlaying && (E3 = Sp.getFromId(u4, k4.overlaying), E3 && E3.overlaying && (k4.overlaying = false, E3 = null)), k4._mainAxis = E3 || k4, E3 && (k4.domain = E3.domain.slice()), k4._anchorAxis = k4.anchor === "free" ? null : Sp.getFromId(u4, k4.anchor);\n              }\n              for (i3 = 0; i3 < p3.length; i3++) if (k4 = p3[i3], k4._counterAxes.sort(Sp.idSort), k4._subplotsWith.sort(Ga.subplotSort), k4._mainSubplot = pat(k4, t3), k4._counterAxes.length && (k4.spikemode && k4.spikemode.indexOf("across") !== -1 || k4.automargin && k4.mirror && k4.anchor !== "free" || Xl.getComponentMethod("rangeslider", "isVisible")(k4))) {\n                var S2 = 1, L3 = 0;\n                for (a4 = 0; a4 < k4._counterAxes.length; a4++) {\n                  var x2 = Sp.getFromId(u4, k4._counterAxes[a4]);\n                  S2 = Math.min(S2, x2.domain[0]), L3 = Math.max(L3, x2.domain[1]);\n                }\n                S2 < L3 && (k4._counterDomainMin = S2, k4._counterDomainMax = L3);\n              }\n            };\n            function pat(e3, t3) {\n              var r4 = { _fullLayout: t3 }, n4 = e3._id.charAt(0) === "x", i3 = e3._mainAxis._anchorAxis, a4 = "", o4 = "", s3 = "";\n              if (i3 && (s3 = i3._mainAxis._id, a4 = n4 ? e3._id + s3 : s3 + e3._id), !a4 || !t3._plots[a4]) {\n                a4 = "";\n                for (var l3 = e3._counterAxes, u4 = 0; u4 < l3.length; u4++) {\n                  var c5 = l3[u4], f4 = n4 ? e3._id + c5 : c5 + e3._id;\n                  o4 || (o4 = f4);\n                  var h3 = Sp.getFromId(r4, c5);\n                  if (s3 && h3.overlaying === s3) {\n                    a4 = f4;\n                    break;\n                  }\n                }\n              }\n              return a4 || o4;\n            }\n            xa.clearExpandedTraceDefaultColors = function(e3) {\n              var t3, r4, n4;\n              function i3(o4, s3, l3, u4) {\n                r4[u4] = s3, r4.length = u4 + 1, o4.valType === "color" && o4.dflt === void 0 && t3.push(r4.join("."));\n              }\n              for (r4 = [], t3 = e3._module._colorAttrs, t3 || (e3._module._colorAttrs = t3 = [], Une.crawl(e3._module.attributes, i3)), n4 = 0; n4 < t3.length; n4++) {\n                var a4 = Ga.nestedProperty(e3, "_input." + t3[n4]);\n                a4.get() || Ga.nestedProperty(e3, t3[n4]).set(null);\n              }\n            };\n            xa.supplyDataDefaults = function(e3, t3, r4, n4) {\n              var i3 = n4._modules, a4 = n4._visibleModules, o4 = n4._basePlotModules, s3 = 0, l3 = 0, u4, c5, f4;\n              n4._transformModules = [];\n              function h3(k4) {\n                t3.push(k4);\n                var E3 = k4._module;\n                E3 && (Ga.pushUnique(i3, E3), k4.visible === true && Ga.pushUnique(a4, E3), Ga.pushUnique(o4, k4._module.basePlotModule), s3++, k4._input.visible !== false && l3++);\n              }\n              var d3 = {}, v3 = [], _2 = (r4.template || {}).data || {}, b = iat.traceTemplater(_2);\n              for (u4 = 0; u4 < e3.length; u4++) f4 = e3[u4], c5 = b.newTrace(f4), c5.uid = n4._traceUids[u4], xa.supplyTraceDefaults(f4, c5, l3, n4, u4), c5.index = u4, c5._input = f4, c5._fullInput = c5, h3(c5), Xl.traceIs(c5, "carpetAxis") && (d3[c5.carpet] = c5), Xl.traceIs(c5, "carpetDependent") && v3.push(u4);\n              for (u4 = 0; u4 < v3.length; u4++) if (c5 = t3[v3[u4]], !!c5.visible) {\n                var p3 = d3[c5.carpet];\n                if (c5._carpet = p3, !p3 || !p3.visible) {\n                  c5.visible = false;\n                  continue;\n                }\n                c5.xaxis = p3.xaxis, c5.yaxis = p3.yaxis;\n              }\n            };\n            xa.supplyAnimationDefaults = function(e3) {\n              e3 = e3 || {};\n              var t3, r4 = {};\n              function n4(i3, a4) {\n                return Ga.coerce(e3 || {}, r4, vq, i3, a4);\n              }\n              if (n4("mode"), n4("direction"), n4("fromcurrent"), Array.isArray(e3.frame)) for (r4.frame = [], t3 = 0; t3 < e3.frame.length; t3++) r4.frame[t3] = xa.supplyAnimationFrameDefaults(e3.frame[t3] || {});\n              else r4.frame = xa.supplyAnimationFrameDefaults(e3.frame || {});\n              if (Array.isArray(e3.transition)) for (r4.transition = [], t3 = 0; t3 < e3.transition.length; t3++) r4.transition[t3] = xa.supplyAnimationTransitionDefaults(e3.transition[t3] || {});\n              else r4.transition = xa.supplyAnimationTransitionDefaults(e3.transition || {});\n              return r4;\n            };\n            xa.supplyAnimationFrameDefaults = function(e3) {\n              var t3 = {};\n              function r4(n4, i3) {\n                return Ga.coerce(e3 || {}, t3, vq.frame, n4, i3);\n              }\n              return r4("duration"), r4("redraw"), t3;\n            };\n            xa.supplyAnimationTransitionDefaults = function(e3) {\n              var t3 = {};\n              function r4(n4, i3) {\n                return Ga.coerce(e3 || {}, t3, vq.transition, n4, i3);\n              }\n              return r4("duration"), r4("easing"), t3;\n            };\n            xa.supplyFrameDefaults = function(e3) {\n              var t3 = {};\n              function r4(n4, i3) {\n                return Ga.coerce(e3, t3, oat, n4, i3);\n              }\n              return r4("group"), r4("name"), r4("traces"), r4("baseframe"), r4("data"), r4("layout"), t3;\n            };\n            xa.supplyTraceDefaults = function(e3, t3, r4, n4, i3) {\n              var a4 = n4.colorway || Vne.defaults, o4 = a4[r4 % a4.length], s3;\n              function l3(E3, S2) {\n                return Ga.coerce(e3, t3, xa.attributes, E3, S2);\n              }\n              var u4 = l3("visible");\n              l3("type"), l3("name", n4._traceWord + " " + i3), l3("uirevision", n4.uirevision);\n              var c5 = xa.getModule(t3);\n              if (t3._module = c5, c5) {\n                var f4 = c5.basePlotModule, h3 = f4.attr, d3 = f4.attributes;\n                if (h3 && d3) {\n                  var v3 = n4._subplots, _2 = "";\n                  if (Array.isArray(h3)) for (s3 = 0; s3 < h3.length; s3++) {\n                    var b = h3[s3], p3 = Ga.coerce(e3, t3, d3, b);\n                    v3[b] && Ga.pushUnique(v3[b], p3), _2 += p3;\n                  }\n                  else _2 = Ga.coerce(e3, t3, d3, h3);\n                  v3[f4.name] && Ga.pushUnique(v3[f4.name], _2);\n                }\n              }\n              if (u4 && (l3("customdata"), l3("ids"), l3("meta"), Xl.traceIs(t3, "showLegend") ? (Ga.coerce(e3, t3, c5.attributes.showlegend ? c5.attributes : xa.attributes, "showlegend"), Ga.coerce(e3, t3, c5.attributes.legend ? c5.attributes : xa.attributes, "legend"), l3("legendwidth"), l3("legendgroup"), l3("legendgrouptitle.text"), l3("legendrank"), t3._dfltShowLegend = true) : t3._dfltShowLegend = false, c5 && c5.supplyDefaults(e3, t3, o4, n4), Xl.traceIs(t3, "noOpacity") || l3("opacity"), Xl.traceIs(t3, "notLegendIsolatable") && (t3.visible = !!t3.visible), Xl.traceIs(t3, "noHover") || (t3.hovertemplate || Ga.coerceHoverinfo(e3, t3, n4), t3.type !== "parcats" && Xl.getComponentMethod("fx", "supplyDefaults")(e3, t3, o4, n4)), c5 && c5.selectPoints)) {\n                var k4 = l3("selectedpoints");\n                Ga.isTypedArray(k4) && (t3.selectedpoints = Array.from(k4));\n              }\n              return t3;\n            };\n            xa.supplyLayoutGlobalDefaults = function(e3, t3, r4) {\n              function n4(f4, h3) {\n                return Ga.coerce(e3, t3, xa.layoutAttributes, f4, h3);\n              }\n              var i3 = e3.template;\n              Ga.isPlainObject(i3) && (t3.template = i3, t3._template = i3.layout, t3._dataTemplate = i3.data), n4("autotypenumbers");\n              var a4 = Ga.coerceFont(n4, "font"), o4 = a4.size;\n              Ga.coerceFont(n4, "title.font", a4, { overrideDflt: { size: Math.round(o4 * 1.4) } }), n4("title.text", t3._dfltTitle.plot), n4("title.xref");\n              var s3 = n4("title.yref");\n              n4("title.pad.t"), n4("title.pad.r"), n4("title.pad.b"), n4("title.pad.l");\n              var l3 = n4("title.automargin");\n              n4("title.x"), n4("title.xanchor"), n4("title.y"), n4("title.yanchor"), n4("title.subtitle.text", t3._dfltTitle.subtitle), Ga.coerceFont(n4, "title.subtitle.font", a4, { overrideDflt: { size: Math.round(t3.title.font.size * 0.7) } }), l3 && (s3 === "paper" && (t3.title.y !== 0 && (t3.title.y = 1), t3.title.yanchor === "auto" && (t3.title.yanchor = t3.title.y === 0 ? "top" : "bottom")), s3 === "container" && (t3.title.y === "auto" && (t3.title.y = 1), t3.title.yanchor === "auto" && (t3.title.yanchor = t3.title.y < 0.5 ? "bottom" : "top")));\n              var u4 = n4("uniformtext.mode");\n              u4 && n4("uniformtext.minsize"), n4("autosize", !(e3.width && e3.height)), n4("width"), n4("height"), n4("minreducedwidth"), n4("minreducedheight"), n4("margin.l"), n4("margin.r"), n4("margin.t"), n4("margin.b"), n4("margin.pad"), n4("margin.autoexpand"), e3.width && e3.height && xa.sanitizeMargins(t3), Xl.getComponentMethod("grid", "sizeDefaults")(e3, t3), n4("paper_bgcolor"), n4("separators", r4.decimal + r4.thousands), n4("hidesources"), n4("colorway"), n4("datarevision");\n              var c5 = n4("uirevision");\n              n4("editrevision", c5), n4("selectionrevision", c5), Xl.getComponentMethod("modebar", "supplyLayoutDefaults")(e3, t3), Xl.getComponentMethod("shapes", "supplyDrawNewShapeDefaults")(e3, t3, n4), Xl.getComponentMethod("selections", "supplyDrawNewSelectionDefaults")(e3, t3, n4), n4("meta"), Ga.isPlainObject(e3.transition) && (n4("transition.duration"), n4("transition.easing"), n4("transition.ordering")), Xl.getComponentMethod("calendars", "handleDefaults")(e3, t3, "calendar"), Xl.getComponentMethod("fx", "supplyLayoutGlobalDefaults")(e3, t3, n4), Ga.coerce(e3, t3, aat, "scattermode");\n            };\n            function K6(e3) {\n              return typeof e3 == "string" && e3.slice(-2) === "px" && parseFloat(e3);\n            }\n            xa.plotAutoSize = function(t3, r4, n4) {\n              var i3 = t3._context || {}, a4 = i3.frameMargins, o4, s3, l3 = Ga.isPlotDiv(t3);\n              if (l3 && t3.emit("plotly_autosize"), i3.fillFrame) o4 = window.innerWidth, s3 = window.innerHeight, document.body.style.overflow = "hidden";\n              else {\n                var u4 = l3 ? window.getComputedStyle(t3) : {};\n                if (o4 = K6(u4.width) || K6(u4.maxWidth) || n4.width, s3 = K6(u4.height) || K6(u4.maxHeight) || n4.height, JS(a4) && a4 > 0) {\n                  var c5 = 1 - 2 * a4;\n                  o4 = Math.round(c5 * o4), s3 = Math.round(c5 * s3);\n                }\n              }\n              var f4 = xa.layoutAttributes.width.min, h3 = xa.layoutAttributes.height.min;\n              o4 < f4 && (o4 = f4), s3 < h3 && (s3 = h3);\n              var d3 = !r4.width && Math.abs(n4.width - o4) > 1, v3 = !r4.height && Math.abs(n4.height - s3) > 1;\n              (v3 || d3) && (d3 && (n4.width = o4), v3 && (n4.height = s3)), t3._initialAutoSize || (t3._initialAutoSize = { width: o4, height: s3 }), xa.sanitizeMargins(n4);\n            };\n            xa.supplyLayoutModuleDefaults = function(e3, t3, r4, n4) {\n              var i3 = Xl.componentsRegistry, a4 = t3._basePlotModules, o4, s3, l3, u4 = Xl.subplotsRegistry.cartesian;\n              for (o4 in i3) l3 = i3[o4], l3.includeBasePlot && l3.includeBasePlot(e3, t3);\n              a4.length || a4.push(u4), t3._has("cartesian") && (Xl.getComponentMethod("grid", "contentDefaults")(e3, t3), u4.finalizeSubplots(e3, t3));\n              for (var c5 in t3._subplots) t3._subplots[c5].sort(Ga.subplotSort);\n              for (s3 = 0; s3 < a4.length; s3++) l3 = a4[s3], l3.supplyLayoutDefaults && l3.supplyLayoutDefaults(e3, t3, r4);\n              var f4 = t3._modules;\n              for (s3 = 0; s3 < f4.length; s3++) l3 = f4[s3], l3.supplyLayoutDefaults && l3.supplyLayoutDefaults(e3, t3, r4);\n              var h3 = t3._transformModules;\n              for (s3 = 0; s3 < h3.length; s3++) l3 = h3[s3], l3.supplyLayoutDefaults && l3.supplyLayoutDefaults(e3, t3, r4, n4);\n              for (o4 in i3) l3 = i3[o4], l3.supplyLayoutDefaults && l3.supplyLayoutDefaults(e3, t3, r4);\n            };\n            xa.purge = function(e3) {\n              var t3 = e3._fullLayout || {};\n              t3._glcontainer !== void 0 && (t3._glcontainer.selectAll(".gl-canvas").remove(), t3._glcontainer.remove(), t3._glcanvas = null), t3._modeBar && t3._modeBar.destroy(), e3._transitionData && (e3._transitionData._interruptCallbacks && (e3._transitionData._interruptCallbacks.length = 0), e3._transitionData._animationRaf && window.cancelAnimationFrame(e3._transitionData._animationRaf)), Ga.clearThrottle(), Ga.clearResponsive(e3), delete e3.data, delete e3.layout, delete e3._fullData, delete e3._fullLayout, delete e3.calcdata, delete e3.empty, delete e3.fid, delete e3.undoqueue, delete e3.undonum, delete e3.autoplay, delete e3.changed, delete e3._promises, delete e3._redrawTimer, delete e3._hmlumcount, delete e3._hmpixcount, delete e3._transitionData, delete e3._transitioning, delete e3._initialAutoSize, delete e3._transitioningWithDuration, delete e3._dragging, delete e3._dragged, delete e3._dragdata, delete e3._hoverdata, delete e3._snapshotInProgress, delete e3._editing, delete e3._mouseDownTime, delete e3._legendMouseDownTime, e3.removeAllListeners && e3.removeAllListeners();\n            };\n            xa.style = function(e3) {\n              var t3 = e3._fullLayout._visibleModules, r4 = [], n4;\n              for (n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4];\n                i3.style && Ga.pushUnique(r4, i3.style);\n              }\n              for (n4 = 0; n4 < r4.length; n4++) r4[n4](e3);\n            };\n            xa.sanitizeMargins = function(e3) {\n              if (!(!e3 || !e3.margin)) {\n                var t3 = e3.width, r4 = e3.height, n4 = e3.margin, i3 = t3 - (n4.l + n4.r), a4 = r4 - (n4.t + n4.b), o4;\n                i3 < 0 && (o4 = (t3 - 1) / (n4.l + n4.r), n4.l = Math.floor(o4 * n4.l), n4.r = Math.floor(o4 * n4.r)), a4 < 0 && (o4 = (r4 - 1) / (n4.t + n4.b), n4.t = Math.floor(o4 * n4.t), n4.b = Math.floor(o4 * n4.b));\n              }\n            };\n            xa.clearAutoMarginIds = function(e3) {\n              e3._fullLayout._pushmarginIds = {};\n            };\n            xa.allowAutoMargin = function(e3, t3) {\n              e3._fullLayout._pushmarginIds[t3] = 1;\n            };\n            function Gne(e3) {\n              var t3 = e3.margin;\n              if (!e3._size) {\n                var r4 = e3._size = { l: Math.round(t3.l), r: Math.round(t3.r), t: Math.round(t3.t), b: Math.round(t3.b), p: Math.round(t3.pad) };\n                r4.w = Math.round(e3.width) - r4.l - r4.r, r4.h = Math.round(e3.height) - r4.t - r4.b;\n              }\n              e3._pushmargin || (e3._pushmargin = {}), e3._pushmarginIds || (e3._pushmarginIds = {}), e3._reservedMargin || (e3._reservedMargin = {});\n            }\n            var Hne = 2, jne = 2;\n            xa.autoMargin = function(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = n4.width, a4 = n4.height, o4 = n4.margin, s3 = n4.minreducedwidth, l3 = n4.minreducedheight, u4 = Ga.constrain(i3 - o4.l - o4.r, Hne, s3), c5 = Ga.constrain(a4 - o4.t - o4.b, jne, l3), f4 = Math.max(0, i3 - u4), h3 = Math.max(0, a4 - c5), d3 = n4._pushmargin, v3 = n4._pushmarginIds;\n              if (o4.autoexpand !== false) {\n                if (!r4) delete d3[t3], delete v3[t3];\n                else {\n                  var _2 = r4.pad;\n                  if (_2 === void 0 && (_2 = Math.min(12, o4.l, o4.r, o4.t, o4.b)), f4) {\n                    var b = (r4.l + r4.r) / f4;\n                    b > 1 && (r4.l /= b, r4.r /= b);\n                  }\n                  if (h3) {\n                    var p3 = (r4.t + r4.b) / h3;\n                    p3 > 1 && (r4.t /= p3, r4.b /= p3);\n                  }\n                  var k4 = r4.xl !== void 0 ? r4.xl : r4.x, E3 = r4.xr !== void 0 ? r4.xr : r4.x, S2 = r4.yt !== void 0 ? r4.yt : r4.y, L3 = r4.yb !== void 0 ? r4.yb : r4.y;\n                  d3[t3] = { l: { val: k4, size: r4.l + _2 }, r: { val: E3, size: r4.r + _2 }, b: { val: L3, size: r4.b + _2 }, t: { val: S2, size: r4.t + _2 } }, v3[t3] = 1;\n                }\n                if (!n4._replotting) return xa.doAutoMargin(e3);\n              }\n            };\n            function gat(e3) {\n              if ("_redrawFromAutoMarginCount" in e3._fullLayout) return false;\n              var t3 = Sp.list(e3, "", true);\n              for (var r4 in t3) if (t3[r4].autoshift || t3[r4].shift) return true;\n              return false;\n            }\n            xa.doAutoMargin = function(e3) {\n              var t3 = e3._fullLayout, r4 = t3.width, n4 = t3.height;\n              t3._size || (t3._size = {}), Gne(t3);\n              var i3 = t3._size, a4 = t3.margin, o4 = { t: 0, b: 0, l: 0, r: 0 }, s3 = Ga.extendFlat({}, i3), l3 = a4.l, u4 = a4.r, c5 = a4.t, f4 = a4.b, h3 = t3._pushmargin, d3 = t3._pushmarginIds, v3 = t3.minreducedwidth, _2 = t3.minreducedheight;\n              if (a4.autoexpand !== false) {\n                for (var b in h3) d3[b] || delete h3[b];\n                var p3 = e3._fullLayout._reservedMargin;\n                for (var k4 in p3) for (var E3 in p3[k4]) {\n                  var S2 = p3[k4][E3];\n                  o4[E3] = Math.max(o4[E3], S2);\n                }\n                h3.base = { l: { val: 0, size: l3 }, r: { val: 1, size: u4 }, t: { val: 1, size: c5 }, b: { val: 0, size: f4 } };\n                for (var L3 in o4) {\n                  var x2 = 0;\n                  for (var C3 in h3) C3 !== "base" && JS(h3[C3][L3].size) && (x2 = h3[C3][L3].size > x2 ? h3[C3][L3].size : x2);\n                  var M4 = Math.max(0, a4[L3] - x2);\n                  o4[L3] = Math.max(0, o4[L3] - M4);\n                }\n                for (var g3 in h3) {\n                  var P3 = h3[g3].l || {}, T3 = h3[g3].b || {}, z3 = P3.val, O3 = P3.size, V2 = T3.val, G2 = T3.size, Z = r4 - o4.r - o4.l, j3 = n4 - o4.t - o4.b;\n                  for (var N2 in h3) {\n                    if (JS(O3) && h3[N2].r) {\n                      var H = h3[N2].r.val, te = h3[N2].r.size;\n                      if (H > z3) {\n                        var oe = (O3 * H + (te - Z) * z3) / (H - z3), _e = (te * (1 - z3) + (O3 - Z) * (1 - H)) / (H - z3);\n                        oe + _e > l3 + u4 && (l3 = oe, u4 = _e);\n                      }\n                    }\n                    if (JS(G2) && h3[N2].t) {\n                      var Ee = h3[N2].t.val, Ce = h3[N2].t.size;\n                      if (Ee > V2) {\n                        var me = (G2 * Ee + (Ce - j3) * V2) / (Ee - V2), ie = (Ce * (1 - V2) + (G2 - j3) * (1 - Ee)) / (Ee - V2);\n                        me + ie > f4 + c5 && (f4 = me, c5 = ie);\n                      }\n                    }\n                  }\n                }\n              }\n              var Se = Ga.constrain(r4 - a4.l - a4.r, Hne, v3), Le = Ga.constrain(n4 - a4.t - a4.b, jne, _2), Ae = Math.max(0, r4 - Se), Fe = Math.max(0, n4 - Le);\n              if (Ae) {\n                var Pe = (l3 + u4) / Ae;\n                Pe > 1 && (l3 /= Pe, u4 /= Pe);\n              }\n              if (Fe) {\n                var ge = (f4 + c5) / Fe;\n                ge > 1 && (f4 /= ge, c5 /= ge);\n              }\n              if (i3.l = Math.round(l3) + o4.l, i3.r = Math.round(u4) + o4.r, i3.t = Math.round(c5) + o4.t, i3.b = Math.round(f4) + o4.b, i3.p = Math.round(a4.pad), i3.w = Math.round(r4) - i3.l - i3.r, i3.h = Math.round(n4) - i3.t - i3.b, !t3._replotting && (xa.didMarginChange(s3, i3) || gat(e3))) {\n                "_redrawFromAutoMarginCount" in t3 ? t3._redrawFromAutoMarginCount++ : t3._redrawFromAutoMarginCount = 1;\n                var Re = 3 * (1 + Object.keys(d3).length);\n                if (t3._redrawFromAutoMarginCount < Re) return Xl.call("_doPlot", e3);\n                t3._size = s3, Ga.warn("Too many auto-margin redraws.");\n              }\n              mat(e3);\n            };\n            function mat(e3) {\n              var t3 = Sp.list(e3, "", true);\n              ["_adjustTickLabelsOverflow", "_hideCounterAxisInsideTickLabels"].forEach(function(r4) {\n                for (var n4 = 0; n4 < t3.length; n4++) {\n                  var i3 = t3[n4][r4];\n                  i3 && i3();\n                }\n              });\n            }\n            var One = ["l", "r", "t", "b", "p", "w", "h"];\n            xa.didMarginChange = function(e3, t3) {\n              for (var r4 = 0; r4 < One.length; r4++) {\n                var n4 = One[r4], i3 = e3[n4], a4 = t3[n4];\n                if (!JS(i3) || Math.abs(a4 - i3) > 1) return true;\n              }\n              return false;\n            };\n            xa.graphJson = function(e3, t3, r4, n4, i3, a4) {\n              (i3 && t3 && !e3._fullData || i3 && !t3 && !e3._fullLayout) && xa.supplyDefaults(e3);\n              var o4 = i3 ? e3._fullData : e3.data, s3 = i3 ? e3._fullLayout : e3.layout, l3 = (e3._transitionData || {})._frames;\n              function u4(h3, d3) {\n                if (typeof h3 == "function") return d3 ? "_function_" : null;\n                if (Ga.isPlainObject(h3)) {\n                  var v3 = {}, _2;\n                  return Object.keys(h3).sort().forEach(function(E3) {\n                    if (["_", "["].indexOf(E3.charAt(0)) === -1) {\n                      if (typeof h3[E3] == "function") {\n                        d3 && (v3[E3] = "_function");\n                        return;\n                      }\n                      if (r4 === "keepdata") {\n                        if (E3.slice(-3) === "src") return;\n                      } else if (r4 === "keepstream") {\n                        if (_2 = h3[E3 + "src"], typeof _2 == "string" && _2.indexOf(":") > 0 && !Ga.isPlainObject(h3.stream)) return;\n                      } else if (r4 !== "keepall" && (_2 = h3[E3 + "src"], typeof _2 == "string" && _2.indexOf(":") > 0)) return;\n                      v3[E3] = u4(h3[E3], d3);\n                    }\n                  }), v3;\n                }\n                var b = Array.isArray(h3), p3 = Ga.isTypedArray(h3);\n                if ((b || p3) && h3.dtype && h3.shape) {\n                  var k4 = h3.bdata;\n                  return u4({ dtype: h3.dtype, shape: h3.shape, bdata: Ga.isArrayBuffer(k4) ? rat.encode(k4) : k4 }, d3);\n                }\n                return b ? h3.map(function(E3) {\n                  return u4(E3, d3);\n                }) : p3 ? Ga.simpleMap(h3, Ga.identity) : Ga.isJSDate(h3) ? Ga.ms2DateTimeLocal(+h3) : h3;\n              }\n              var c5 = { data: (o4 || []).map(function(h3) {\n                var d3 = u4(h3);\n                return t3 && delete d3.fit, d3;\n              }) };\n              if (!t3 && (c5.layout = u4(s3), i3)) {\n                var f4 = s3._size;\n                c5.layout.computed = { margin: { b: f4.b, l: f4.l, r: f4.r, t: f4.t } };\n              }\n              return l3 && (c5.frames = u4(l3)), a4 && (c5.config = u4(e3._context, true)), n4 === "object" ? c5 : JSON.stringify(c5);\n            };\n            xa.modifyFrames = function(e3, t3) {\n              var r4, n4, i3, a4 = e3._transitionData._frames, o4 = e3._transitionData._frameHash;\n              for (r4 = 0; r4 < t3.length; r4++) switch (n4 = t3[r4], n4.type) {\n                case "replace":\n                  i3 = n4.value;\n                  var s3 = (a4[n4.index] || {}).name, l3 = i3.name;\n                  a4[n4.index] = o4[l3] = i3, l3 !== s3 && (delete o4[s3], o4[l3] = i3);\n                  break;\n                case "insert":\n                  i3 = n4.value, o4[i3.name] = i3, a4.splice(n4.index, 0, i3);\n                  break;\n                case "delete":\n                  i3 = a4[n4.index], delete o4[i3.name], a4.splice(n4.index, 1);\n                  break;\n              }\n              return Promise.resolve();\n            };\n            xa.computeFrame = function(e3, t3) {\n              var r4 = e3._transitionData._frameHash, n4, i3, a4, o4;\n              if (!t3) throw new Error("computeFrame must be given a string frame name");\n              var s3 = r4[t3.toString()];\n              if (!s3) return false;\n              for (var l3 = [s3], u4 = [s3.name]; s3.baseframe && (s3 = r4[s3.baseframe.toString()]) && u4.indexOf(s3.name) === -1; ) l3.push(s3), u4.push(s3.name);\n              for (var c5 = {}; s3 = l3.pop(); ) if (s3.layout && (c5.layout = xa.extendLayout(c5.layout, s3.layout)), s3.data) {\n                if (c5.data || (c5.data = []), i3 = s3.traces, !i3) for (i3 = [], n4 = 0; n4 < s3.data.length; n4++) i3[n4] = n4;\n                for (c5.traces || (c5.traces = []), n4 = 0; n4 < s3.data.length; n4++) a4 = i3[n4], a4 != null && (o4 = c5.traces.indexOf(a4), o4 === -1 && (o4 = c5.data.length, c5.traces[o4] = a4), c5.data[o4] = xa.extendTrace(c5.data[o4], s3.data[n4]));\n              }\n              return c5;\n            };\n            xa.recomputeFrameHash = function(e3) {\n              for (var t3 = e3._transitionData._frameHash = {}, r4 = e3._transitionData._frames, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4];\n                i3 && i3.name && (t3[i3.name] = i3);\n              }\n            };\n            xa.extendObjectWithContainers = function(e3, t3, r4) {\n              var n4, i3, a4, o4, s3, l3, u4, c5, f4 = Ga.extendDeepNoArrays({}, t3 || {}), h3 = Ga.expandObjectPaths(f4), d3 = {};\n              if (r4 && r4.length) for (a4 = 0; a4 < r4.length; a4++) n4 = Ga.nestedProperty(h3, r4[a4]), i3 = n4.get(), i3 === void 0 ? Ga.nestedProperty(d3, r4[a4]).set(null) : (n4.set(null), Ga.nestedProperty(d3, r4[a4]).set(i3));\n              if (e3 = Ga.extendDeepNoArrays(e3 || {}, h3), r4 && r4.length) {\n                for (a4 = 0; a4 < r4.length; a4++) if (s3 = Ga.nestedProperty(d3, r4[a4]), u4 = s3.get(), !!u4) {\n                  for (l3 = Ga.nestedProperty(e3, r4[a4]), c5 = l3.get(), Array.isArray(c5) || (c5 = [], l3.set(c5)), o4 = 0; o4 < u4.length; o4++) {\n                    var v3 = u4[o4];\n                    v3 === null ? c5[o4] = null : c5[o4] = xa.extendObjectWithContainers(c5[o4], v3);\n                  }\n                  l3.set(c5);\n                }\n              }\n              return e3;\n            };\n            xa.dataArrayContainers = ["transforms", "dimensions"];\n            xa.layoutArrayContainers = Xl.layoutArrayContainers;\n            xa.extendTrace = function(e3, t3) {\n              return xa.extendObjectWithContainers(e3, t3, xa.dataArrayContainers);\n            };\n            xa.extendLayout = function(e3, t3) {\n              return xa.extendObjectWithContainers(e3, t3, xa.layoutArrayContainers);\n            };\n            xa.transition = function(e3, t3, r4, n4, i3, a4) {\n              var o4 = { redraw: i3.redraw }, s3 = {}, l3 = [];\n              return o4.prepareFn = function() {\n                for (var u4 = Array.isArray(t3) ? t3.length : 0, c5 = n4.slice(0, u4), f4 = 0; f4 < c5.length; f4++) {\n                  var h3 = c5[f4], d3 = e3._fullData[h3], v3 = d3._module;\n                  if (v3) {\n                    if (v3.animatable) {\n                      var _2 = v3.basePlotModule.name;\n                      s3[_2] || (s3[_2] = []), s3[_2].push(h3);\n                    }\n                    e3.data[c5[f4]] = xa.extendTrace(e3.data[c5[f4]], t3[f4]);\n                  }\n                }\n                var b = Ga.expandObjectPaths(Ga.extendDeepNoArrays({}, r4)), p3 = /^[xy]axis[0-9]*$/;\n                for (var k4 in b) p3.test(k4) && delete b[k4].range;\n                xa.extendLayout(e3.layout, b), delete e3.calcdata, xa.supplyDefaults(e3), xa.doCalcdata(e3);\n                var E3 = Ga.expandObjectPaths(r4);\n                if (E3) {\n                  var S2 = e3._fullLayout._plots;\n                  for (var L3 in S2) {\n                    var x2 = S2[L3], C3 = x2.xaxis, M4 = x2.yaxis, g3 = C3.range.slice(), P3 = M4.range.slice(), T3 = null, z3 = null, O3 = null, V2 = null;\n                    Array.isArray(E3[C3._name + ".range"]) ? T3 = E3[C3._name + ".range"].slice() : Array.isArray((E3[C3._name] || {}).range) && (T3 = E3[C3._name].range.slice()), Array.isArray(E3[M4._name + ".range"]) ? z3 = E3[M4._name + ".range"].slice() : Array.isArray((E3[M4._name] || {}).range) && (z3 = E3[M4._name].range.slice()), g3 && T3 && (C3.r2l(g3[0]) !== C3.r2l(T3[0]) || C3.r2l(g3[1]) !== C3.r2l(T3[1])) && (O3 = { xr0: g3, xr1: T3 }), P3 && z3 && (M4.r2l(P3[0]) !== M4.r2l(z3[0]) || M4.r2l(P3[1]) !== M4.r2l(z3[1])) && (V2 = { yr0: P3, yr1: z3 }), (O3 || V2) && l3.push(Ga.extendFlat({ plotinfo: x2 }, O3, V2));\n                  }\n                }\n                return Promise.resolve();\n              }, o4.runFn = function(u4) {\n                var c5, f4 = e3._fullLayout._basePlotModules, h3 = l3.length, d3;\n                if (r4) for (d3 = 0; d3 < f4.length; d3++) f4[d3].transitionAxes && f4[d3].transitionAxes(e3, l3, a4, u4);\n                h3 ? (c5 = Ga.extendFlat({}, a4), c5.duration = 0, delete s3.cartesian) : c5 = a4;\n                for (var v3 in s3) {\n                  var _2 = s3[v3], b = e3._fullData[_2[0]]._module;\n                  b.basePlotModule.plot(e3, _2, c5, u4);\n                }\n              }, Wne(e3, a4, o4);\n            };\n            xa.transitionFromReact = function(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = i3.transition, o4 = {}, s3 = [];\n              return o4.prepareFn = function() {\n                var l3 = i3._plots;\n                o4.redraw = false, t3.anim === "some" && (o4.redraw = true), r4.anim === "some" && (o4.redraw = true);\n                for (var u4 in l3) {\n                  var c5 = l3[u4], f4 = c5.xaxis, h3 = c5.yaxis, d3 = n4[f4._name].range.slice(), v3 = n4[h3._name].range.slice(), _2 = f4.range.slice(), b = h3.range.slice();\n                  f4.setScale(), h3.setScale();\n                  var p3 = null, k4 = null;\n                  (f4.r2l(d3[0]) !== f4.r2l(_2[0]) || f4.r2l(d3[1]) !== f4.r2l(_2[1])) && (p3 = { xr0: d3, xr1: _2 }), (h3.r2l(v3[0]) !== h3.r2l(b[0]) || h3.r2l(v3[1]) !== h3.r2l(b[1])) && (k4 = { yr0: v3, yr1: b }), (p3 || k4) && s3.push(Ga.extendFlat({ plotinfo: c5 }, p3, k4));\n                }\n                return Promise.resolve();\n              }, o4.runFn = function(l3) {\n                for (var u4 = e3._fullData, c5 = e3._fullLayout, f4 = c5._basePlotModules, h3, d3, v3, _2 = [], b = 0; b < u4.length; b++) _2.push(b);\n                function p3() {\n                  if (e3._fullLayout) for (var E3 = 0; E3 < f4.length; E3++) f4[E3].transitionAxes && f4[E3].transitionAxes(e3, s3, h3, l3);\n                }\n                function k4() {\n                  if (e3._fullLayout) for (var E3 = 0; E3 < f4.length; E3++) f4[E3].plot(e3, v3, d3, l3);\n                }\n                s3.length && t3.anim ? a4.ordering === "traces first" ? (h3 = Ga.extendFlat({}, a4, { duration: 0 }), v3 = _2, d3 = a4, setTimeout(p3, a4.duration), k4()) : (h3 = a4, v3 = null, d3 = Ga.extendFlat({}, a4, { duration: 0 }), setTimeout(k4, h3.duration), p3()) : s3.length ? (h3 = a4, p3()) : t3.anim && (v3 = _2, d3 = a4, k4());\n              }, Wne(e3, a4, o4);\n            };\n            function Wne(e3, t3, r4) {\n              var n4 = false;\n              function i3(f4) {\n                var h3 = Promise.resolve();\n                if (!f4) return h3;\n                for (; f4.length; ) h3 = h3.then(f4.shift());\n                return h3;\n              }\n              function a4(f4) {\n                if (f4) for (; f4.length; ) f4.shift();\n              }\n              function o4() {\n                return e3.emit("plotly_transitioning", []), new Promise(function(f4) {\n                  e3._transitioning = true, t3.duration > 0 && (e3._transitioningWithDuration = true), e3._transitionData._interruptCallbacks.push(function() {\n                    n4 = true;\n                  }), r4.redraw && e3._transitionData._interruptCallbacks.push(function() {\n                    return Xl.call("redraw", e3);\n                  }), e3._transitionData._interruptCallbacks.push(function() {\n                    e3.emit("plotly_transitioninterrupted", []);\n                  });\n                  var h3 = 0, d3 = 0;\n                  function v3() {\n                    return h3++, function() {\n                      d3++, !n4 && d3 === h3 && s3(f4);\n                    };\n                  }\n                  r4.runFn(v3), setTimeout(v3());\n                });\n              }\n              function s3(f4) {\n                if (e3._transitionData) return a4(e3._transitionData._interruptCallbacks), Promise.resolve().then(function() {\n                  if (r4.redraw) return Xl.call("redraw", e3);\n                }).then(function() {\n                  e3._transitioning = false, e3._transitioningWithDuration = false, e3.emit("plotly_transitioned", []);\n                }).then(f4);\n              }\n              function l3() {\n                if (e3._transitionData) return e3._transitioning = false, i3(e3._transitionData._interruptCallbacks);\n              }\n              var u4 = [xa.previousPromises, l3, r4.prepareFn, xa.rehover, xa.reselect, o4], c5 = Ga.syncOrAsync(u4, e3);\n              return (!c5 || !c5.then) && (c5 = Promise.resolve()), c5.then(function() {\n                return e3;\n              });\n            }\n            xa.doCalcdata = function(e3, t3) {\n              var r4 = Sp.list(e3), n4 = e3._fullData, i3 = e3._fullLayout, a4, o4, s3, l3, u4 = new Array(n4.length), c5 = (e3.calcdata || []).slice();\n              for (e3.calcdata = u4, i3._numBoxes = 0, i3._numViolins = 0, i3._violinScaleGroupStats = {}, e3._hmpixcount = 0, e3._hmlumcount = 0, i3._piecolormap = {}, i3._sunburstcolormap = {}, i3._treemapcolormap = {}, i3._iciclecolormap = {}, i3._funnelareacolormap = {}, s3 = 0; s3 < n4.length; s3++) if (Array.isArray(t3) && t3.indexOf(s3) === -1) {\n                u4[s3] = c5[s3];\n                continue;\n              }\n              for (s3 = 0; s3 < n4.length; s3++) a4 = n4[s3], a4._arrayAttrs = Une.findArrayAttributes(a4), a4._extremes = {};\n              var f4 = i3._subplots.polar || [];\n              for (s3 = 0; s3 < f4.length; s3++) r4.push(i3[f4[s3]].radialaxis, i3[f4[s3]].angularaxis);\n              for (var h3 in i3._colorAxes) {\n                var d3 = i3[h3];\n                d3.cauto !== false && (delete d3.cmin, delete d3.cmax);\n              }\n              var v3 = false;\n              function _2(k4) {\n                if (a4 = n4[k4], o4 = a4._module, a4.visible === true && a4.transforms) {\n                  if (o4 && o4.calc) {\n                    var E3 = o4.calc(e3, a4);\n                    E3[0] && E3[0].t && E3[0].t._scene && delete E3[0].t._scene.dirty;\n                  }\n                  for (l3 = 0; l3 < a4.transforms.length; l3++) {\n                    var S2 = a4.transforms[l3];\n                    o4 = transformsRegistry[S2.type], o4 && o4.calcTransform && (a4._hasCalcTransform = true, v3 = true, o4.calcTransform(e3, a4, S2));\n                  }\n                }\n              }\n              function b(k4, E3) {\n                if (a4 = n4[k4], o4 = a4._module, !!o4.isContainer === E3) {\n                  var S2 = [];\n                  if (a4.visible === true && a4._length !== 0) {\n                    delete a4._indexToPoints;\n                    var L3 = a4.transforms || [];\n                    for (l3 = L3.length - 1; l3 >= 0; l3--) if (L3[l3].enabled) {\n                      a4._indexToPoints = L3[l3]._indexToPoints;\n                      break;\n                    }\n                    o4 && o4.calc && (S2 = o4.calc(e3, a4));\n                  }\n                  (!Array.isArray(S2) || !S2[0]) && (S2 = [{ x: Dne, y: Dne }]), S2[0].t || (S2[0].t = {}), S2[0].trace = a4, u4[k4] = S2;\n                }\n              }\n              for (qne(r4, n4, i3), s3 = 0; s3 < n4.length; s3++) b(s3, true);\n              for (s3 = 0; s3 < n4.length; s3++) _2(s3);\n              for (v3 && qne(r4, n4, i3), s3 = 0; s3 < n4.length; s3++) b(s3, true);\n              for (s3 = 0; s3 < n4.length; s3++) b(s3, false);\n              Bne(e3);\n              var p3 = _at(r4, e3);\n              if (p3.length) {\n                for (i3._numBoxes = 0, i3._numViolins = 0, s3 = 0; s3 < p3.length; s3++) b(p3[s3], true);\n                for (s3 = 0; s3 < p3.length; s3++) b(p3[s3], false);\n                Bne(e3);\n              }\n              Xl.getComponentMethod("fx", "calc")(e3), Xl.getComponentMethod("errorbars", "calc")(e3);\n            };\n            var yat = /(total|sum|min|max|mean|geometric mean|median) (ascending|descending)/;\n            function _at(e3, t3) {\n              var r4 = [], n4, i3, a4, o4, s3;\n              function l3(N2, H, te) {\n                var oe = H._id.charAt(0);\n                if (N2 === "histogram2dcontour") {\n                  var _e = H._counterAxes[0], Ee = Sp.getFromId(t3, _e), Ce = oe === "x" || _e === "x" && Ee.type === "category", me = oe === "y" || _e === "y" && Ee.type === "category";\n                  return function(ie, Se) {\n                    return ie === 0 || Se === 0 || Ce && ie === te[Se].length - 1 || me && Se === te.length - 1 ? -1 : (oe === "y" ? Se : ie) - 1;\n                  };\n                } else return function(ie, Se) {\n                  return oe === "y" ? Se : ie;\n                };\n              }\n              var u4 = { min: function(N2) {\n                return Ga.aggNums(Math.min, null, N2);\n              }, max: function(N2) {\n                return Ga.aggNums(Math.max, null, N2);\n              }, sum: function(N2) {\n                return Ga.aggNums(function(H, te) {\n                  return H + te;\n                }, null, N2);\n              }, total: function(N2) {\n                return Ga.aggNums(function(H, te) {\n                  return H + te;\n                }, null, N2);\n              }, mean: function(N2) {\n                return Ga.mean(N2);\n              }, "geometric mean": function(N2) {\n                return Ga.geometricMean(N2);\n              }, median: function(N2) {\n                return Ga.median(N2);\n              } };\n              function c5(N2, H) {\n                return N2[1] - H[1];\n              }\n              function f4(N2, H) {\n                return H[1] - N2[1];\n              }\n              for (n4 = 0; n4 < e3.length; n4++) {\n                var h3 = e3[n4];\n                if (h3.type === "category") {\n                  var d3 = h3.categoryorder.match(yat);\n                  if (d3) {\n                    var v3 = d3[1], _2 = d3[2], b = h3._id.charAt(0), p3 = b === "x", k4 = [];\n                    for (i3 = 0; i3 < h3._categories.length; i3++) k4.push([h3._categories[i3], []]);\n                    for (i3 = 0; i3 < h3._traceIndices.length; i3++) {\n                      var E3 = h3._traceIndices[i3], S2 = t3._fullData[E3];\n                      if (S2.visible === true) {\n                        var L3 = S2.type;\n                        Xl.traceIs(S2, "histogram") && (delete S2._xautoBinFinished, delete S2._yautoBinFinished);\n                        var x2 = L3 === "splom", C3 = L3 === "scattergl", M4 = t3.calcdata[E3];\n                        for (a4 = 0; a4 < M4.length; a4++) {\n                          var g3 = M4[a4], P3, T3;\n                          if (x2) {\n                            var z3 = S2._axesDim[h3._id];\n                            if (!p3) {\n                              var O3 = S2._diag[z3][0];\n                              O3 && (h3 = t3._fullLayout[Sp.id2name(O3)]);\n                            }\n                            var V2 = g3.trace.dimensions[z3].values;\n                            for (o4 = 0; o4 < V2.length; o4++) for (P3 = h3._categoriesMap[V2[o4]], s3 = 0; s3 < g3.trace.dimensions.length; s3++) if (s3 !== z3) {\n                              var G2 = g3.trace.dimensions[s3];\n                              k4[P3][1].push(G2.values[o4]);\n                            }\n                          } else if (C3) {\n                            for (o4 = 0; o4 < g3.t.x.length; o4++) p3 ? (P3 = g3.t.x[o4], T3 = g3.t.y[o4]) : (P3 = g3.t.y[o4], T3 = g3.t.x[o4]), k4[P3][1].push(T3);\n                            g3.t && g3.t._scene && delete g3.t._scene.dirty;\n                          } else if (g3.hasOwnProperty("z")) {\n                            T3 = g3.z;\n                            var Z = l3(S2.type, h3, T3);\n                            for (o4 = 0; o4 < T3.length; o4++) for (s3 = 0; s3 < T3[o4].length; s3++) P3 = Z(s3, o4), P3 + 1 && k4[P3][1].push(T3[o4][s3]);\n                          } else for (P3 = g3.p, P3 === void 0 && (P3 = g3[b]), T3 = g3.s, T3 === void 0 && (T3 = g3.v), T3 === void 0 && (T3 = p3 ? g3.y : g3.x), Array.isArray(T3) || (T3 === void 0 ? T3 = [] : T3 = [T3]), o4 = 0; o4 < T3.length; o4++) k4[P3][1].push(T3[o4]);\n                        }\n                      }\n                    }\n                    h3._categoriesValue = k4;\n                    var j3 = [];\n                    for (i3 = 0; i3 < k4.length; i3++) j3.push([k4[i3][0], u4[v3](k4[i3][1])]);\n                    j3.sort(_2 === "descending" ? f4 : c5), h3._categoriesAggregatedValue = j3, h3._initialCategories = j3.map(function(N2) {\n                      return N2[0];\n                    }), r4 = r4.concat(h3.sortByInitialCategories());\n                  }\n                }\n              }\n              return r4;\n            }\n            function qne(e3, t3, r4) {\n              var n4 = {};\n              function i3(l3) {\n                l3.clearCalc(), l3.type === "multicategory" && l3.setupMultiCategory(t3), n4[l3._id] = 1;\n              }\n              Ga.simpleMap(e3, i3);\n              for (var a4 = r4._axisMatchGroups || [], o4 = 0; o4 < a4.length; o4++) for (var s3 in a4[o4]) n4[s3] || i3(r4[Sp.id2name(s3)]);\n            }\n            function Bne(e3) {\n              var t3 = e3._fullLayout, r4 = t3._visibleModules, n4 = {}, i3, a4, o4;\n              for (a4 = 0; a4 < r4.length; a4++) {\n                var s3 = r4[a4], l3 = s3.crossTraceCalc;\n                if (l3) {\n                  var u4 = s3.basePlotModule.name;\n                  n4[u4] ? Ga.pushUnique(n4[u4], l3) : n4[u4] = [l3];\n                }\n              }\n              for (o4 in n4) {\n                var c5 = n4[o4], f4 = t3._subplots[o4];\n                if (Array.isArray(f4)) for (i3 = 0; i3 < f4.length; i3++) {\n                  var h3 = f4[i3], d3 = o4 === "cartesian" ? t3._plots[h3] : t3[h3];\n                  for (a4 = 0; a4 < c5.length; a4++) c5[a4](e3, d3, h3);\n                }\n                else for (a4 = 0; a4 < c5.length; a4++) c5[a4](e3);\n              }\n            }\n            xa.rehover = function(e3) {\n              e3._fullLayout._rehover && e3._fullLayout._rehover();\n            };\n            xa.redrag = function(e3) {\n              e3._fullLayout._redrag && e3._fullLayout._redrag();\n            };\n            xa.reselect = function(e3) {\n              var t3 = e3._fullLayout, r4 = (e3.layout || {}).selections, n4 = t3._previousSelections;\n              t3._previousSelections = r4;\n              var i3 = t3._reselect || JSON.stringify(r4) !== JSON.stringify(n4);\n              Xl.getComponentMethod("selections", "reselect")(e3, i3);\n            };\n            xa.generalUpdatePerTraceModule = function(e3, t3, r4, n4) {\n              var i3 = t3.traceHash, a4 = {}, o4;\n              for (o4 = 0; o4 < r4.length; o4++) {\n                var s3 = r4[o4], l3 = s3[0].trace;\n                l3.visible && (a4[l3.type] = a4[l3.type] || [], a4[l3.type].push(s3));\n              }\n              for (var u4 in i3) if (!a4[u4]) {\n                var c5 = i3[u4][0], f4 = c5[0].trace;\n                f4.visible = false, a4[u4] = [c5];\n              }\n              for (var h3 in a4) {\n                var d3 = a4[h3], v3 = d3[0][0].trace._module;\n                v3.plot(e3, t3, Ga.filterVisible(d3), n4);\n              }\n              t3.traceHash = a4;\n            };\n            xa.plotBasePlot = function(e3, t3, r4, n4, i3) {\n              var a4 = Xl.getModule(e3), o4 = sat(t3.calcdata, a4)[0];\n              a4.plot(t3, o4, n4, i3);\n            };\n            xa.cleanBasePlot = function(e3, t3, r4, n4, i3) {\n              var a4 = i3._has && i3._has(e3), o4 = r4._has && r4._has(e3);\n              a4 && !o4 && i3["_" + e3 + "layer"].selectAll("g.trace").remove();\n            };\n          });\n          var Wp = ye((_b) => {\n            "use strict";\n            _b.xmlns = "http://www.w3.org/2000/xmlns/";\n            _b.svg = "http://www.w3.org/2000/svg";\n            _b.xlink = "http://www.w3.org/1999/xlink";\n            _b.svgAttrs = { xmlns: _b.svg, "xmlns:xlink": _b.xlink };\n          });\n          var $h = ye((hnr, Zne) => {\n            "use strict";\n            Zne.exports = { FROM_BL: { left: 0, center: 0.5, right: 1, bottom: 0, middle: 0.5, top: 1 }, FROM_TL: { left: 0, center: 0.5, right: 1, bottom: 1, middle: 0.5, top: 0 }, FROM_BR: { left: 1, center: 0.5, right: 0, bottom: 0, middle: 0.5, top: 1 }, LINE_SPACING: 1.3, CAP_SHIFT: 0.7, MID_SHIFT: 0.35, OPPOSITE_SIDE: { left: "right", right: "left", top: "bottom", bottom: "top" } };\n          });\n          var ru = ye((x0) => {\n            "use strict";\n            var Ph = Oa(), Ay = Dr(), xat = Ay.strTranslate, pq = Wp(), bat = $h().LINE_SPACING, wat = /([^$]*)([$]+[^$]*[$]+)([^$]*)/;\n            x0.convertToTspans = function(e3, t3, r4) {\n              var n4 = e3.text(), i3 = !e3.attr("data-notex") && t3 && t3._context.typesetMath && typeof MathJax != "undefined" && n4.match(wat), a4 = Ph.select(e3.node().parentNode);\n              if (a4.empty()) return;\n              var o4 = e3.attr("class") ? e3.attr("class").split(" ")[0] : "text";\n              o4 += "-math", a4.selectAll("svg." + o4).remove(), a4.selectAll("g." + o4 + "-group").remove(), e3.style("display", null).attr({ "data-unformatted": n4, "data-math": "N" });\n              function s3() {\n                a4.empty() || (o4 = e3.attr("class") + "-math", a4.select("svg." + o4).remove()), e3.text("").style("white-space", "pre");\n                var l3 = Fat(e3.node(), n4);\n                l3 && e3.style("pointer-events", "all"), x0.positionText(e3), r4 && r4.call(e3);\n              }\n              return i3 ? (t3 && t3._promises || []).push(new Promise(function(l3) {\n                e3.style("display", "none");\n                var u4 = parseInt(e3.node().style.fontSize, 10), c5 = { fontSize: u4 };\n                Mat(i3[2], c5, function(f4, h3, d3) {\n                  a4.selectAll("svg." + o4).remove(), a4.selectAll("g." + o4 + "-group").remove();\n                  var v3 = f4 && f4.select("svg");\n                  if (!v3 || !v3.node()) {\n                    s3(), l3();\n                    return;\n                  }\n                  var _2 = a4.append("g").classed(o4 + "-group", true).attr({ "pointer-events": "none", "data-unformatted": n4, "data-math": "Y" });\n                  _2.node().appendChild(v3.node()), h3 && h3.node() && v3.node().insertBefore(h3.node().cloneNode(true), v3.node().firstChild);\n                  var b = d3.width, p3 = d3.height;\n                  v3.attr({ class: o4, height: p3, preserveAspectRatio: "xMinYMin meet" }).style({ overflow: "visible", "pointer-events": "none" });\n                  var k4 = e3.node().style.fill || "black", E3 = v3.select("g");\n                  E3.attr({ fill: k4, stroke: k4 });\n                  var S2 = E3.node().getBoundingClientRect(), L3 = S2.width, x2 = S2.height;\n                  (L3 > b || x2 > p3) && (v3.style("overflow", "hidden"), S2 = v3.node().getBoundingClientRect(), L3 = S2.width, x2 = S2.height);\n                  var C3 = +e3.attr("x"), M4 = +e3.attr("y"), g3 = u4 || e3.node().getBoundingClientRect().height, P3 = -g3 / 4;\n                  if (o4[0] === "y") _2.attr({ transform: "rotate(" + [-90, C3, M4] + ")" + xat(-L3 / 2, P3 - x2 / 2) });\n                  else if (o4[0] === "l") M4 = P3 - x2 / 2;\n                  else if (o4[0] === "a" && o4.indexOf("atitle") !== 0) C3 = 0, M4 = P3;\n                  else {\n                    var T3 = e3.attr("text-anchor");\n                    C3 = C3 - L3 * (T3 === "middle" ? 0.5 : T3 === "end" ? 1 : 0), M4 = M4 + P3 - x2 / 2;\n                  }\n                  v3.attr({ x: C3, y: M4 }), r4 && r4.call(e3, _2), l3(_2);\n                });\n              })) : s3(), e3;\n            };\n            var Tat = /(<|&lt;|&#60;)/g, Aat = /(>|&gt;|&#62;)/g;\n            function Sat(e3) {\n              return e3.replace(Tat, "\\\\lt ").replace(Aat, "\\\\gt ");\n            }\n            var Yne = [["$", "$"], ["\\\\(", "\\\\)"]];\n            function Mat(e3, t3, r4) {\n              var n4 = parseInt((MathJax.version || "").split(".")[0]);\n              if (n4 !== 2 && n4 !== 3) {\n                Ay.warn("No MathJax version:", MathJax.version);\n                return;\n              }\n              var i3, a4, o4, s3, l3 = function() {\n                return a4 = Ay.extendDeepAll({}, MathJax.Hub.config), o4 = MathJax.Hub.processSectionDelay, MathJax.Hub.processSectionDelay !== void 0 && (MathJax.Hub.processSectionDelay = 0), MathJax.Hub.Config({ messageStyle: "none", tex2jax: { inlineMath: Yne }, displayAlign: "left" });\n              }, u4 = function() {\n                a4 = Ay.extendDeepAll({}, MathJax.config), MathJax.config.tex || (MathJax.config.tex = {}), MathJax.config.tex.inlineMath = Yne;\n              }, c5 = function() {\n                if (i3 = MathJax.Hub.config.menuSettings.renderer, i3 !== "SVG") return MathJax.Hub.setRenderer("SVG");\n              }, f4 = function() {\n                i3 = MathJax.config.startup.output, i3 !== "svg" && (MathJax.config.startup.output = "svg");\n              }, h3 = function() {\n                var k4 = "math-output-" + Ay.randstr({}, 64);\n                s3 = Ph.select("body").append("div").attr({ id: k4 }).style({ visibility: "hidden", position: "absolute", "font-size": t3.fontSize + "px" }).text(Sat(e3));\n                var E3 = s3.node();\n                return n4 === 2 ? MathJax.Hub.Typeset(E3) : MathJax.typeset([E3]);\n              }, d3 = function() {\n                var k4 = s3.select(n4 === 2 ? ".MathJax_SVG" : ".MathJax"), E3 = !k4.empty() && s3.select("svg").node();\n                if (!E3) Ay.log("There was an error in the tex syntax.", e3), r4();\n                else {\n                  var S2 = E3.getBoundingClientRect(), L3;\n                  n4 === 2 ? L3 = Ph.select("body").select("#MathJax_SVG_glyphs") : L3 = k4.select("defs"), r4(k4, L3, S2);\n                }\n                s3.remove();\n              }, v3 = function() {\n                if (i3 !== "SVG") return MathJax.Hub.setRenderer(i3);\n              }, _2 = function() {\n                i3 !== "svg" && (MathJax.config.startup.output = i3);\n              }, b = function() {\n                return o4 !== void 0 && (MathJax.Hub.processSectionDelay = o4), MathJax.Hub.Config(a4);\n              }, p3 = function() {\n                MathJax.config = a4;\n              };\n              n4 === 2 ? MathJax.Hub.Queue(l3, c5, h3, d3, v3, b) : n4 === 3 && (u4(), f4(), MathJax.startup.defaultReady(), MathJax.startup.promise.then(function() {\n                h3(), d3(), _2(), p3();\n              }));\n            }\n            var Qne = { sup: "font-size:70%", sub: "font-size:70%", s: "text-decoration:line-through", u: "text-decoration:underline", b: "font-weight:bold", i: "font-style:italic", a: "cursor:pointer", span: "", em: "font-style:italic;font-weight:bold" }, Eat = { sub: "0.3em", sup: "-0.6em" }, kat = { sub: "-0.21em", sup: "0.42em" }, Kne = "\\u200B", Jne = ["http:", "https:", "mailto:", "", void 0, ":"], eae = x0.NEWLINES = /(\\r\\n?|\\n)/g, mq = /(<[^<>]*>)/, yq = /<(\\/?)([^ >]*)(\\s+(.*))?>/i, Cat = /<br(\\s+.*)?>/i;\n            x0.BR_TAG_ALL = /<br(\\s+.*)?>/gi;\n            var tae = /(^|[\\s"\'])style\\s*=\\s*("([^"]*);?"|\'([^\']*);?\')/i, rae = /(^|[\\s"\'])href\\s*=\\s*("([^"]*)"|\'([^\']*)\')/i, iae = /(^|[\\s"\'])target\\s*=\\s*("([^"\\s]*)"|\'([^\'\\s]*)\')/i, Lat = /(^|[\\s"\'])popup\\s*=\\s*("([\\w=,]*)"|\'([\\w=,]*)\')/i;\n            function xb(e3, t3) {\n              if (!e3) return null;\n              var r4 = e3.match(t3), n4 = r4 && (r4[3] || r4[4]);\n              return n4 && $6(n4);\n            }\n            var Pat = /(^|;)\\s*color:/;\n            x0.plainText = function(e3, t3) {\n              t3 = t3 || {};\n              for (var r4 = t3.len !== void 0 && t3.len !== -1 ? t3.len : 1 / 0, n4 = t3.allowedTags !== void 0 ? t3.allowedTags : ["br"], i3 = "...", a4 = i3.length, o4 = e3.split(mq), s3 = [], l3 = "", u4 = 0, c5 = 0; c5 < o4.length; c5++) {\n                var f4 = o4[c5], h3 = f4.match(yq), d3 = h3 && h3[2].toLowerCase();\n                if (d3) n4.indexOf(d3) !== -1 && (s3.push(f4), l3 = d3);\n                else {\n                  var v3 = f4.length;\n                  if (u4 + v3 < r4) s3.push(f4), u4 += v3;\n                  else if (u4 < r4) {\n                    var _2 = r4 - u4;\n                    l3 && (l3 !== "br" || _2 <= a4 || v3 <= a4) && s3.pop(), r4 > a4 ? s3.push(f4.slice(0, Math.max(0, _2 - a4)) + i3) : s3.push(f4.slice(0, _2));\n                    break;\n                  }\n                  l3 = "";\n                }\n              }\n              return s3.join("");\n            };\n            var Iat = { mu: "\\u03BC", amp: "&", lt: "<", gt: ">", nbsp: "\\xA0", times: "\\xD7", plusmn: "\\xB1", deg: "\\xB0" }, Rat = /&(#\\d+|#x[\\da-fA-F]+|[a-z]+);/g;\n            function $6(e3) {\n              return e3.replace(Rat, function(t3, r4) {\n                var n4;\n                return r4.charAt(0) === "#" ? n4 = Dat(r4.charAt(1) === "x" ? parseInt(r4.slice(2), 16) : parseInt(r4.slice(1), 10)) : n4 = Iat[r4], n4 || t3;\n              });\n            }\n            x0.convertEntities = $6;\n            function Dat(e3) {\n              if (!(e3 > 1114111)) {\n                var t3 = String.fromCodePoint;\n                if (t3) return t3(e3);\n                var r4 = String.fromCharCode;\n                return e3 <= 65535 ? r4(e3) : r4((e3 >> 10) + 55232, e3 % 1024 + 56320);\n              }\n            }\n            function Fat(e3, t3) {\n              t3 = t3.replace(eae, " ");\n              var r4 = false, n4 = [], i3, a4 = -1;\n              function o4() {\n                a4++;\n                var x2 = document.createElementNS(pq.svg, "tspan");\n                Ph.select(x2).attr({ class: "line", dy: a4 * bat + "em" }), e3.appendChild(x2), i3 = x2;\n                var C3 = n4;\n                if (n4 = [{ node: x2 }], C3.length > 1) for (var M4 = 1; M4 < C3.length; M4++) s3(C3[M4]);\n              }\n              function s3(x2) {\n                var C3 = x2.type, M4 = {}, g3;\n                if (C3 === "a") {\n                  g3 = "a";\n                  var P3 = x2.target, T3 = x2.href, z3 = x2.popup;\n                  T3 && (M4 = { "xlink:xlink:show": P3 === "_blank" || P3.charAt(0) !== "_" ? "new" : "replace", target: P3, "xlink:xlink:href": T3 }, z3 && (M4.onclick = \'window.open(this.href.baseVal,this.target.baseVal,"\' + z3 + \'");return false;\'));\n                } else g3 = "tspan";\n                x2.style && (M4.style = x2.style);\n                var O3 = document.createElementNS(pq.svg, g3);\n                if (C3 === "sup" || C3 === "sub") {\n                  l3(i3, Kne), i3.appendChild(O3);\n                  var V2 = document.createElementNS(pq.svg, "tspan");\n                  l3(V2, Kne), Ph.select(V2).attr("dy", kat[C3]), M4.dy = Eat[C3], i3.appendChild(O3), i3.appendChild(V2);\n                } else i3.appendChild(O3);\n                Ph.select(O3).attr(M4), i3 = x2.node = O3, n4.push(x2);\n              }\n              function l3(x2, C3) {\n                x2.appendChild(document.createTextNode(C3));\n              }\n              function u4(x2) {\n                if (n4.length === 1) {\n                  Ay.log("Ignoring unexpected end tag </" + x2 + ">.", t3);\n                  return;\n                }\n                var C3 = n4.pop();\n                x2 !== C3.type && Ay.log("Start tag <" + C3.type + "> doesnt match end tag <" + x2 + ">. Pretending it did match.", t3), i3 = n4[n4.length - 1].node;\n              }\n              var c5 = Cat.test(t3);\n              c5 ? o4() : (i3 = e3, n4 = [{ node: e3 }]);\n              for (var f4 = t3.split(mq), h3 = 0; h3 < f4.length; h3++) {\n                var d3 = f4[h3], v3 = d3.match(yq), _2 = v3 && v3[2].toLowerCase(), b = Qne[_2];\n                if (_2 === "br") o4();\n                else if (b === void 0) l3(i3, $6(d3));\n                else if (v3[1]) u4(_2);\n                else {\n                  var p3 = v3[4], k4 = { type: _2 }, E3 = xb(p3, tae);\n                  if (E3 ? (E3 = E3.replace(Pat, "$1 fill:"), b && (E3 += ";" + b)) : b && (E3 = b), E3 && (k4.style = E3), _2 === "a") {\n                    r4 = true;\n                    var S2 = xb(p3, rae);\n                    if (S2) {\n                      var L3 = nae(S2);\n                      L3 && (k4.href = L3, k4.target = xb(p3, iae) || "_blank", k4.popup = xb(p3, Lat));\n                    }\n                  }\n                  s3(k4);\n                }\n              }\n              return r4;\n            }\n            function nae(e3) {\n              var t3 = encodeURI(decodeURI(e3)), r4 = document.createElement("a"), n4 = document.createElement("a");\n              r4.href = e3, n4.href = t3;\n              var i3 = r4.protocol, a4 = n4.protocol;\n              return Jne.indexOf(i3) !== -1 && Jne.indexOf(a4) !== -1 ? t3 : "";\n            }\n            x0.sanitizeHTML = function(t3) {\n              t3 = t3.replace(eae, " ");\n              for (var r4 = document.createElement("p"), n4 = r4, i3 = [], a4 = t3.split(mq), o4 = 0; o4 < a4.length; o4++) {\n                var s3 = a4[o4], l3 = s3.match(yq), u4 = l3 && l3[2].toLowerCase();\n                if (u4 in Qne) if (l3[1]) i3.length && (n4 = i3.pop());\n                else {\n                  var c5 = l3[4], f4 = xb(c5, tae), h3 = f4 ? { style: f4 } : {};\n                  if (u4 === "a") {\n                    var d3 = xb(c5, rae);\n                    if (d3) {\n                      var v3 = nae(d3);\n                      if (v3) {\n                        h3.href = v3;\n                        var _2 = xb(c5, iae);\n                        _2 && (h3.target = _2);\n                      }\n                    }\n                  }\n                  var b = document.createElement(u4);\n                  n4.appendChild(b), Ph.select(b).attr(h3), n4 = b, i3.push(b);\n                }\n                else n4.appendChild(document.createTextNode($6(s3)));\n              }\n              var p3 = "innerHTML";\n              return r4[p3];\n            };\n            x0.lineCount = function(t3) {\n              return t3.selectAll("tspan.line").size() || 1;\n            };\n            x0.positionText = function(t3, r4, n4) {\n              return t3.each(function() {\n                var i3 = Ph.select(this);\n                function a4(l3, u4) {\n                  return u4 === void 0 ? (u4 = i3.attr(l3), u4 === null && (i3.attr(l3, 0), u4 = 0)) : i3.attr(l3, u4), u4;\n                }\n                var o4 = a4("x", r4), s3 = a4("y", n4);\n                this.nodeName === "text" && i3.selectAll("tspan.line").attr({ x: o4, y: s3 });\n              });\n            };\n            function $ne(e3, t3, r4) {\n              var n4 = r4.horizontalAlign, i3 = r4.verticalAlign || "top", a4 = e3.node().getBoundingClientRect(), o4 = t3.node().getBoundingClientRect(), s3, l3, u4;\n              return i3 === "bottom" ? l3 = function() {\n                return a4.bottom - s3.height;\n              } : i3 === "middle" ? l3 = function() {\n                return a4.top + (a4.height - s3.height) / 2;\n              } : l3 = function() {\n                return a4.top;\n              }, n4 === "right" ? u4 = function() {\n                return a4.right - s3.width;\n              } : n4 === "center" ? u4 = function() {\n                return a4.left + (a4.width - s3.width) / 2;\n              } : u4 = function() {\n                return a4.left;\n              }, function() {\n                s3 = this.node().getBoundingClientRect();\n                var c5 = u4() - o4.left, f4 = l3() - o4.top, h3 = r4.gd || {};\n                if (r4.gd) {\n                  h3._fullLayout._calcInverseTransform(h3);\n                  var d3 = Ay.apply3DTransform(h3._fullLayout._invTransform)(c5, f4);\n                  c5 = d3[0], f4 = d3[1];\n                }\n                return this.style({ top: f4 + "px", left: c5 + "px", "z-index": 1e3 }), this;\n              };\n            }\n            var gq = "1px ";\n            x0.makeTextShadow = function(e3) {\n              var t3 = gq, r4 = gq, n4 = gq;\n              return t3 + r4 + n4 + e3 + ", -" + t3 + "-" + r4 + n4 + e3 + ", " + t3 + "-" + r4 + n4 + e3 + ", -" + t3 + r4 + n4 + e3;\n            };\n            x0.makeEditable = function(e3, t3) {\n              var r4 = t3.gd, n4 = t3.delegate, i3 = Ph.dispatch("edit", "input", "cancel"), a4 = n4 || e3;\n              if (e3.style({ "pointer-events": n4 ? "none" : "all" }), e3.size() !== 1) throw new Error("boo");\n              function o4() {\n                l3(), e3.style({ opacity: 0 });\n                var u4 = a4.attr("class"), c5;\n                u4 ? c5 = "." + u4.split(" ")[0] + "-math-group" : c5 = "[class*=-math-group]", c5 && Ph.select(e3.node().parentNode).select(c5).style({ opacity: 0 });\n              }\n              function s3(u4) {\n                var c5 = u4.node(), f4 = document.createRange();\n                f4.selectNodeContents(c5);\n                var h3 = window.getSelection();\n                h3.removeAllRanges(), h3.addRange(f4), c5.focus();\n              }\n              function l3() {\n                var u4 = Ph.select(r4), c5 = u4.select(".svg-container"), f4 = c5.append("div"), h3 = e3.node().style, d3 = parseFloat(h3.fontSize || 12), v3 = t3.text;\n                v3 === void 0 && (v3 = e3.attr("data-unformatted")), f4.classed("plugin-editable editable", true).style({ position: "absolute", "font-family": h3.fontFamily || "Arial", "font-size": d3, color: t3.fill || h3.fill || "black", opacity: 1, "background-color": t3.background || "transparent", outline: "#ffffff33 1px solid", margin: [-d3 / 8 + 1, 0, 0, -1].join("px ") + "px", padding: "0", "box-sizing": "border-box" }).attr({ contenteditable: true }).text(v3).call($ne(e3, c5, t3)).on("blur", function() {\n                  r4._editing = false, e3.text(this.textContent).style({ opacity: 1 });\n                  var _2 = Ph.select(this).attr("class"), b;\n                  _2 ? b = "." + _2.split(" ")[0] + "-math-group" : b = "[class*=-math-group]", b && Ph.select(e3.node().parentNode).select(b).style({ opacity: 0 });\n                  var p3 = this.textContent;\n                  Ph.select(this).transition().duration(0).remove(), Ph.select(document).on("mouseup", null), i3.edit.call(e3, p3);\n                }).on("focus", function() {\n                  var _2 = this;\n                  r4._editing = true, Ph.select(document).on("mouseup", function() {\n                    if (Ph.event.target === _2) return false;\n                    document.activeElement === f4.node() && f4.node().blur();\n                  });\n                }).on("keyup", function() {\n                  Ph.event.which === 27 ? (r4._editing = false, e3.style({ opacity: 1 }), Ph.select(this).style({ opacity: 0 }).on("blur", function() {\n                    return false;\n                  }).transition().remove(), i3.cancel.call(e3, this.textContent)) : (i3.input.call(e3, this.textContent), Ph.select(this).call($ne(e3, c5, t3)));\n                }).on("keydown", function() {\n                  Ph.event.which === 13 && this.blur();\n                }).call(s3);\n              }\n              return t3.immediate ? o4() : a4.on("click", o4), Ph.rebind(e3, i3, "on");\n            };\n          });\n          var pv = ye((vnr, hae) => {\n            "use strict";\n            var zat = Oa(), eL = cd(), QS = Eo(), Q6 = Dr(), aae = ka(), Oat = lb().isValid;\n            function qat(e3, t3, r4) {\n              var n4 = t3 ? Q6.nestedProperty(e3, t3).get() || {} : e3, i3 = n4[r4 || "color"];\n              i3 && i3._inputArray && (i3 = i3._inputArray);\n              var a4 = false;\n              if (Q6.isArrayOrTypedArray(i3)) {\n                for (var o4 = 0; o4 < i3.length; o4++) if (QS(i3[o4])) {\n                  a4 = true;\n                  break;\n                }\n              }\n              return Q6.isPlainObject(n4) && (a4 || n4.showscale === true || QS(n4.cmin) && QS(n4.cmax) || Oat(n4.colorscale) || Q6.isPlainObject(n4.colorbar));\n            }\n            var oae = ["showscale", "autocolorscale", "colorscale", "reversescale", "colorbar"], $S = ["min", "max", "mid", "auto"];\n            function lae(e3) {\n              var t3 = e3._colorAx, r4 = t3 || e3, n4 = {}, i3, a4, o4;\n              for (a4 = 0; a4 < oae.length; a4++) o4 = oae[a4], n4[o4] = r4[o4];\n              if (t3) for (i3 = "c", a4 = 0; a4 < $S.length; a4++) o4 = $S[a4], n4[o4] = r4["c" + o4];\n              else {\n                var s3;\n                for (a4 = 0; a4 < $S.length; a4++) {\n                  if (o4 = $S[a4], s3 = "c" + o4, s3 in r4) {\n                    n4[o4] = r4[s3];\n                    continue;\n                  }\n                  s3 = "z" + o4, s3 in r4 && (n4[o4] = r4[s3]);\n                }\n                i3 = s3.charAt(0);\n              }\n              return n4._sync = function(l3, u4) {\n                var c5 = $S.indexOf(l3) !== -1 ? i3 + l3 : l3;\n                r4[c5] = r4["_" + c5] = u4;\n              }, n4;\n            }\n            function uae(e3) {\n              for (var t3 = lae(e3), r4 = t3.min, n4 = t3.max, i3 = t3.reversescale ? cae(t3.colorscale) : t3.colorscale, a4 = i3.length, o4 = new Array(a4), s3 = new Array(a4), l3 = 0; l3 < a4; l3++) {\n                var u4 = i3[l3];\n                o4[l3] = r4 + u4[0] * (n4 - r4), s3[l3] = u4[1];\n              }\n              return { domain: o4, range: s3 };\n            }\n            function cae(e3) {\n              for (var t3 = e3.length, r4 = new Array(t3), n4 = t3 - 1, i3 = 0; n4 >= 0; n4--, i3++) {\n                var a4 = e3[n4];\n                r4[i3] = [1 - a4[0], a4[1]];\n              }\n              return r4;\n            }\n            function fae(e3, t3) {\n              t3 = t3 || {};\n              for (var r4 = e3.domain, n4 = e3.range, i3 = n4.length, a4 = new Array(i3), o4 = 0; o4 < i3; o4++) {\n                var s3 = eL(n4[o4]).toRgb();\n                a4[o4] = [s3.r, s3.g, s3.b, s3.a];\n              }\n              var l3 = zat.scale.linear().domain(r4).range(a4).clamp(true), u4 = t3.noNumericCheck, c5 = t3.returnArray, f4;\n              return u4 && c5 ? f4 = l3 : u4 ? f4 = function(h3) {\n                return sae(l3(h3));\n              } : c5 ? f4 = function(h3) {\n                return QS(h3) ? l3(h3) : eL(h3).isValid() ? h3 : aae.defaultLine;\n              } : f4 = function(h3) {\n                return QS(h3) ? sae(l3(h3)) : eL(h3).isValid() ? h3 : aae.defaultLine;\n              }, f4.domain = l3.domain, f4.range = function() {\n                return n4;\n              }, f4;\n            }\n            function Bat(e3, t3) {\n              return fae(uae(e3), t3);\n            }\n            function sae(e3) {\n              var t3 = { r: e3[0], g: e3[1], b: e3[2], a: e3[3] };\n              return eL(t3).toRgbString();\n            }\n            hae.exports = { hasColorscale: qat, extractOpts: lae, extractScale: uae, flipScale: cae, makeColorScaleFunc: fae, makeColorScaleFuncFromTrace: Bat };\n          });\n          var df = ye((pnr, pae) => {\n            "use strict";\n            var dae = NO(), Nat = dae.FORMAT_LINK, Uat = dae.DATE_FORMAT_LINK;\n            function Vat(e3, t3) {\n              return { valType: "string", dflt: "", editType: "none", description: (t3 ? _q : vae)("hover text", e3) + ["By default the values are formatted using " + (t3 ? "generic number format" : "`" + e3 + "axis.hoverformat`") + "."].join(" ") };\n            }\n            function _q(e3, t3) {\n              return ["Sets the " + e3 + " formatting rule" + (t3 ? "for `" + t3 + "` " : ""), "using d3 formatting mini-languages", "which are very similar to those in Python. For numbers, see: " + Nat + "."].join(" ");\n            }\n            function vae(e3, t3) {\n              return _q(e3, t3) + [" And for dates see: " + Uat + ".", "We add two items to d3\'s date formatter:", "*%h* for half of the year as a decimal number as well as", "*%{n}f* for fractional seconds", "with n digits. For example, *2016-10-13 09:15:23.456* with tickformat", "*%H~%M~%S.%2f* would display *09~15~23.46*"].join(" ");\n            }\n            pae.exports = { axisHoverFormat: Vat, descriptionOnlyNumbers: _q, descriptionWithDates: vae };\n          });\n          var Rd = ye((mnr, Iae) => {\n            "use strict";\n            var gae = ec(), S3 = Lh(), Pae = Pd().dash, bq = Ao().extendFlat, mae = vl().templatedArray, gnr = Ll().templateFormatStringDescription, yae = df().descriptionWithDates, Gat = fs().ONEDAY, pm = hd(), Hat = pm.HOUR_PATTERN, jat = pm.WEEKDAY_PATTERN, xq = { valType: "enumerated", values: ["auto", "linear", "array"], editType: "ticks", impliedEdits: { tick0: void 0, dtick: void 0 } }, Wat = bq({}, xq, { values: xq.values.slice().concat(["sync"]) });\n            function _ae(e3) {\n              return { valType: "integer", min: 0, dflt: e3 ? 5 : 0, editType: "ticks" };\n            }\n            var xae = { valType: "any", editType: "ticks", impliedEdits: { tickmode: "linear" } }, bae = { valType: "any", editType: "ticks", impliedEdits: { tickmode: "linear" } }, wae = { valType: "data_array", editType: "ticks" }, Tae = { valType: "enumerated", values: ["outside", "inside", ""], editType: "ticks" };\n            function Aae(e3) {\n              var t3 = { valType: "number", min: 0, editType: "ticks" };\n              return e3 || (t3.dflt = 5), t3;\n            }\n            function Sae(e3) {\n              var t3 = { valType: "number", min: 0, editType: "ticks" };\n              return e3 || (t3.dflt = 1), t3;\n            }\n            var Mae = { valType: "color", dflt: S3.defaultLine, editType: "ticks" }, Eae = { valType: "color", dflt: S3.lightLine, editType: "ticks" };\n            function kae(e3) {\n              var t3 = { valType: "number", min: 0, editType: "ticks" };\n              return e3 || (t3.dflt = 1), t3;\n            }\n            var Cae = bq({}, Pae, { editType: "ticks" }), Lae = { valType: "boolean", editType: "ticks" };\n            Iae.exports = { visible: { valType: "boolean", editType: "plot" }, color: { valType: "color", dflt: S3.defaultLine, editType: "ticks" }, title: { text: { valType: "string", editType: "ticks" }, font: gae({ editType: "ticks" }), standoff: { valType: "number", min: 0, editType: "ticks" }, editType: "ticks" }, type: { valType: "enumerated", values: ["-", "linear", "log", "date", "category", "multicategory"], dflt: "-", editType: "calc", _noTemplating: true }, autotypenumbers: { valType: "enumerated", values: ["convert types", "strict"], dflt: "convert types", editType: "calc" }, autorange: { valType: "enumerated", values: [true, false, "reversed", "min reversed", "max reversed", "min", "max"], dflt: true, editType: "axrange", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, autorangeoptions: { minallowed: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, maxallowed: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, clipmin: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, clipmax: { valType: "any", editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, include: { valType: "any", arrayOk: true, editType: "plot", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, editType: "plot" }, rangemode: { valType: "enumerated", values: ["normal", "tozero", "nonnegative"], dflt: "normal", editType: "plot" }, range: { valType: "info_array", items: [{ valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true }, { valType: "any", editType: "axrange", impliedEdits: { "^autorange": false }, anim: true }], editType: "axrange", impliedEdits: { autorange: false }, anim: true }, minallowed: { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, maxallowed: { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, fixedrange: { valType: "boolean", dflt: false, editType: "calc" }, modebardisable: { valType: "flaglist", flags: ["autoscale", "zoominout"], extras: ["none"], dflt: "none", editType: "modebar" }, insiderange: { valType: "info_array", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, scaleanchor: { valType: "enumerated", values: [pm.idRegex.x.toString(), pm.idRegex.y.toString(), false], editType: "plot" }, scaleratio: { valType: "number", min: 0, dflt: 1, editType: "plot" }, constrain: { valType: "enumerated", values: ["range", "domain"], editType: "plot" }, constraintoward: { valType: "enumerated", values: ["left", "center", "right", "top", "middle", "bottom"], editType: "plot" }, matches: { valType: "enumerated", values: [pm.idRegex.x.toString(), pm.idRegex.y.toString()], editType: "calc" }, rangebreaks: mae("rangebreak", { enabled: { valType: "boolean", dflt: true, editType: "calc" }, bounds: { valType: "info_array", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }], editType: "calc" }, pattern: { valType: "enumerated", values: [jat, Hat, ""], editType: "calc" }, values: { valType: "info_array", freeLength: true, editType: "calc", items: { valType: "any", editType: "calc" } }, dvalue: { valType: "number", editType: "calc", min: 0, dflt: Gat }, editType: "calc" }), tickmode: Wat, nticks: _ae(), tick0: xae, dtick: bae, ticklabelstep: { valType: "integer", min: 1, dflt: 1, editType: "ticks" }, tickvals: wae, ticktext: { valType: "data_array", editType: "ticks" }, ticks: Tae, tickson: { valType: "enumerated", values: ["labels", "boundaries"], dflt: "labels", editType: "ticks" }, ticklabelmode: { valType: "enumerated", values: ["instant", "period"], dflt: "instant", editType: "ticks" }, ticklabelposition: { valType: "enumerated", values: ["outside", "inside", "outside top", "inside top", "outside left", "inside left", "outside right", "inside right", "outside bottom", "inside bottom"], dflt: "outside", editType: "calc" }, ticklabeloverflow: { valType: "enumerated", values: ["allow", "hide past div", "hide past domain"], editType: "calc" }, ticklabelshift: { valType: "integer", dflt: 0, editType: "ticks" }, ticklabelstandoff: { valType: "integer", dflt: 0, editType: "ticks" }, ticklabelindex: { valType: "integer", arrayOk: true, editType: "calc" }, mirror: { valType: "enumerated", values: [true, "ticks", false, "all", "allticks"], dflt: false, editType: "ticks+layoutstyle" }, ticklen: Aae(), tickwidth: Sae(), tickcolor: Mae, showticklabels: { valType: "boolean", dflt: true, editType: "ticks" }, labelalias: { valType: "any", dflt: false, editType: "ticks" }, automargin: { valType: "flaglist", flags: ["height", "width", "left", "right", "top", "bottom"], extras: [true, false], dflt: false, editType: "ticks" }, showspikes: { valType: "boolean", dflt: false, editType: "modebar" }, spikecolor: { valType: "color", dflt: null, editType: "none" }, spikethickness: { valType: "number", dflt: 3, editType: "none" }, spikedash: bq({}, Pae, { dflt: "dash", editType: "none" }), spikemode: { valType: "flaglist", flags: ["toaxis", "across", "marker"], dflt: "toaxis", editType: "none" }, spikesnap: { valType: "enumerated", values: ["data", "cursor", "hovered data"], dflt: "hovered data", editType: "none" }, tickfont: gae({ editType: "ticks" }), tickangle: { valType: "angle", dflt: "auto", editType: "ticks" }, autotickangles: { valType: "info_array", freeLength: true, items: { valType: "angle" }, dflt: [0, 30, 90], editType: "ticks" }, tickprefix: { valType: "string", dflt: "", editType: "ticks" }, showtickprefix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, ticksuffix: { valType: "string", dflt: "", editType: "ticks" }, showticksuffix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, showexponent: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "ticks" }, exponentformat: { valType: "enumerated", values: ["none", "e", "E", "power", "SI", "B", "SI extended"], dflt: "B", editType: "ticks" }, minexponent: { valType: "number", dflt: 3, min: 0, editType: "ticks" }, separatethousands: { valType: "boolean", dflt: false, editType: "ticks" }, tickformat: { valType: "string", dflt: "", editType: "ticks", description: yae("tick label") }, tickformatstops: mae("tickformatstop", { enabled: { valType: "boolean", dflt: true, editType: "ticks" }, dtickrange: { valType: "info_array", items: [{ valType: "any", editType: "ticks" }, { valType: "any", editType: "ticks" }], editType: "ticks" }, value: { valType: "string", dflt: "", editType: "ticks" }, editType: "ticks" }), hoverformat: { valType: "string", dflt: "", editType: "none", description: yae("hover text") }, unifiedhovertitle: { text: { valType: "string", dflt: "", editType: "none" }, editType: "none" }, showline: { valType: "boolean", dflt: false, editType: "ticks+layoutstyle" }, linecolor: { valType: "color", dflt: S3.defaultLine, editType: "layoutstyle" }, linewidth: { valType: "number", min: 0, dflt: 1, editType: "ticks+layoutstyle" }, showgrid: Lae, gridcolor: Eae, gridwidth: kae(), griddash: Cae, zeroline: { valType: "boolean", editType: "ticks" }, zerolinecolor: { valType: "color", dflt: S3.defaultLine, editType: "ticks" }, zerolinelayer: { valType: "enumerated", values: ["above traces", "below traces"], dflt: "below traces", editType: "plot" }, zerolinewidth: { valType: "number", dflt: 1, editType: "ticks" }, showdividers: { valType: "boolean", dflt: true, editType: "ticks" }, dividercolor: { valType: "color", dflt: S3.defaultLine, editType: "ticks" }, dividerwidth: { valType: "number", dflt: 1, editType: "ticks" }, anchor: { valType: "enumerated", values: ["free", pm.idRegex.x.toString(), pm.idRegex.y.toString()], editType: "plot" }, side: { valType: "enumerated", values: ["top", "bottom", "left", "right"], editType: "plot" }, overlaying: { valType: "enumerated", values: ["free", pm.idRegex.x.toString(), pm.idRegex.y.toString()], editType: "plot" }, minor: { tickmode: xq, nticks: _ae("minor"), tick0: xae, dtick: bae, tickvals: wae, ticks: Tae, ticklen: Aae("minor"), tickwidth: Sae("minor"), tickcolor: Mae, gridcolor: Eae, gridwidth: kae("minor"), griddash: Cae, showgrid: Lae, editType: "ticks" }, minorloglabels: { valType: "enumerated", values: ["small digits", "complete", "none"], dflt: "small digits", editType: "calc" }, layer: { valType: "enumerated", values: ["above traces", "below traces"], dflt: "above traces", editType: "plot" }, domain: { valType: "info_array", items: [{ valType: "number", min: 0, max: 1, editType: "plot" }, { valType: "number", min: 0, max: 1, editType: "plot" }], dflt: [0, 1], editType: "plot" }, position: { valType: "number", min: 0, max: 1, dflt: 0, editType: "plot" }, autoshift: { valType: "boolean", dflt: false, editType: "plot" }, shift: { valType: "number", editType: "plot" }, categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array", "total ascending", "total descending", "min ascending", "min descending", "max ascending", "max descending", "sum ascending", "sum descending", "mean ascending", "mean descending", "geometric mean ascending", "geometric mean descending", "median ascending", "median descending"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, uirevision: { valType: "any", editType: "none" }, editType: "calc" };\n          });\n          var tL = ye((ynr, Fae) => {\n            "use strict";\n            var $c = Rd(), Rae = ec(), Dae = Ao().extendFlat, Xat = mc().overrideAll;\n            Fae.exports = Xat({ orientation: { valType: "enumerated", values: ["h", "v"], dflt: "v" }, thicknessmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "pixels" }, thickness: { valType: "number", min: 0, dflt: 30 }, lenmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "fraction" }, len: { valType: "number", min: 0, dflt: 1 }, x: { valType: "number" }, xref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, xanchor: { valType: "enumerated", values: ["left", "center", "right"] }, xpad: { valType: "number", min: 0, dflt: 10 }, y: { valType: "number" }, yref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"] }, ypad: { valType: "number", min: 0, dflt: 10 }, outlinecolor: $c.linecolor, outlinewidth: $c.linewidth, bordercolor: $c.linecolor, borderwidth: { valType: "number", min: 0, dflt: 0 }, bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)" }, tickmode: $c.minor.tickmode, nticks: $c.nticks, tick0: $c.tick0, dtick: $c.dtick, tickvals: $c.tickvals, ticktext: $c.ticktext, ticks: Dae({}, $c.ticks, { dflt: "" }), ticklabeloverflow: Dae({}, $c.ticklabeloverflow, {}), ticklabelposition: { valType: "enumerated", values: ["outside", "inside", "outside top", "inside top", "outside left", "inside left", "outside right", "inside right", "outside bottom", "inside bottom"], dflt: "outside" }, ticklen: $c.ticklen, tickwidth: $c.tickwidth, tickcolor: $c.tickcolor, ticklabelstep: $c.ticklabelstep, showticklabels: $c.showticklabels, labelalias: $c.labelalias, tickfont: Rae({}), tickangle: $c.tickangle, tickformat: $c.tickformat, tickformatstops: $c.tickformatstops, tickprefix: $c.tickprefix, showtickprefix: $c.showtickprefix, ticksuffix: $c.ticksuffix, showticksuffix: $c.showticksuffix, separatethousands: $c.separatethousands, exponentformat: $c.exponentformat, minexponent: $c.minexponent, showexponent: $c.showexponent, title: { text: { valType: "string" }, font: Rae({}), side: { valType: "enumerated", values: ["right", "top", "bottom"] } } }, "colorbars", "from-root");\n          });\n          var Tu = ye((xnr, Oae) => {\n            "use strict";\n            var Zat = tL(), Yat = o3().counter, Kat = Z1(), zae = lb().scales, _nr = Kat(zae);\n            function rL(e3) {\n              return "`" + e3 + "`";\n            }\n            Oae.exports = function(t3, r4) {\n              t3 = t3 || "", r4 = r4 || {};\n              var n4 = r4.cLetter || "c", i3 = "onlyIfNumerical" in r4 ? r4.onlyIfNumerical : !!t3, a4 = "noScale" in r4 ? r4.noScale : t3 === "marker.line", o4 = "showScaleDflt" in r4 ? r4.showScaleDflt : n4 === "z", s3 = typeof r4.colorscaleDflt == "string" ? zae[r4.colorscaleDflt] : null, l3 = r4.editTypeOverride || "", u4 = t3 ? t3 + "." : "", c5, f4;\n              "colorAttr" in r4 ? (c5 = r4.colorAttr, f4 = r4.colorAttr) : (c5 = { z: "z", c: "color" }[n4], f4 = "in " + rL(u4 + c5));\n              var h3 = i3 ? " Has an effect only if " + f4 + " is set to a numerical array." : "", d3 = n4 + "auto", v3 = n4 + "min", _2 = n4 + "max", b = n4 + "mid", p3 = rL(u4 + d3), k4 = rL(u4 + v3), E3 = rL(u4 + _2), S2 = k4 + " and " + E3, L3 = {};\n              L3[v3] = L3[_2] = void 0;\n              var x2 = {};\n              x2[d3] = false;\n              var C3 = {};\n              return c5 === "color" && (C3.color = { valType: "color", arrayOk: true, editType: l3 || "style" }, r4.anim && (C3.color.anim = true)), C3[d3] = { valType: "boolean", dflt: true, editType: "calc", impliedEdits: L3 }, C3[v3] = { valType: "number", dflt: null, editType: l3 || "plot", impliedEdits: x2 }, C3[_2] = { valType: "number", dflt: null, editType: l3 || "plot", impliedEdits: x2 }, C3[b] = { valType: "number", dflt: null, editType: "calc", impliedEdits: L3 }, C3.colorscale = { valType: "colorscale", editType: "calc", dflt: s3, impliedEdits: { autocolorscale: false } }, C3.autocolorscale = { valType: "boolean", dflt: r4.autoColorDflt !== false, editType: "calc", impliedEdits: { colorscale: void 0 } }, C3.reversescale = { valType: "boolean", dflt: false, editType: "plot" }, a4 || (C3.showscale = { valType: "boolean", dflt: o4, editType: "calc" }, C3.colorbar = Zat), r4.noColorAxis || (C3.coloraxis = { valType: "subplotid", regex: Yat("coloraxis"), dflt: null, editType: "calc" }), C3;\n            };\n          });\n          var Tq = ye((bnr, qae) => {\n            "use strict";\n            var Jat = Ao().extendFlat, $at = Tu(), wq = lb().scales;\n            qae.exports = { editType: "calc", colorscale: { editType: "calc", sequential: { valType: "colorscale", dflt: wq.Reds, editType: "calc" }, sequentialminus: { valType: "colorscale", dflt: wq.Blues, editType: "calc" }, diverging: { valType: "colorscale", dflt: wq.RdBu, editType: "calc" } }, coloraxis: Jat({ _isSubplotObj: true, editType: "calc" }, $at("", { colorAttr: "corresponding trace color array(s)", noColorAxis: true, showScaleDflt: true })) };\n          });\n          var Aq = ye((wnr, Bae) => {\n            "use strict";\n            var Qat = Dr();\n            Bae.exports = function(t3) {\n              return Qat.isPlainObject(t3.colorbar);\n            };\n          });\n          var Eq = ye((Mq) => {\n            "use strict";\n            var Sq = Eo(), Nae = Dr(), Uae = fs(), eot = Uae.ONEDAY, tot = Uae.ONEWEEK;\n            Mq.dtick = function(e3, t3) {\n              var r4 = t3 === "log", n4 = t3 === "date", i3 = t3 === "category", a4 = n4 ? eot : 1;\n              if (!e3) return a4;\n              if (Sq(e3)) return e3 = Number(e3), e3 <= 0 ? a4 : i3 ? Math.max(1, Math.round(e3)) : n4 ? Math.max(0.1, e3) : e3;\n              if (typeof e3 != "string" || !(n4 || r4)) return a4;\n              var o4 = e3.charAt(0), s3 = e3.slice(1);\n              return s3 = Sq(s3) ? Number(s3) : 0, s3 <= 0 || !(n4 && o4 === "M" && s3 === Math.round(s3) || r4 && o4 === "L" || r4 && o4 === "D" && (s3 === 1 || s3 === 2)) ? a4 : e3;\n            };\n            Mq.tick0 = function(e3, t3, r4, n4) {\n              if (t3 === "date") return Nae.cleanDate(e3, Nae.dateTick0(r4, n4 % tot === 0 ? 1 : 0));\n              if (!(n4 === "D1" || n4 === "D2")) return Sq(e3) ? Number(e3) : 0;\n            };\n          });\n          var bb = ye((Anr, Gae) => {\n            "use strict";\n            var Vae = Eq(), rot = Dr().isArrayOrTypedArray, iot = vv().isTypedArraySpec, not = vv().decodeTypedArraySpec;\n            Gae.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = a4.isMinor, s3 = o4 ? t3.minor || {} : t3, l3 = o4 ? r4.minor : r4, u4 = o4 ? "minor." : "";\n              function c5(k4) {\n                var E3 = s3[k4];\n                return iot(E3) && (E3 = not(E3)), E3 !== void 0 ? E3 : (l3._template || {})[k4];\n              }\n              var f4 = c5("tick0"), h3 = c5("dtick"), d3 = c5("tickvals"), v3 = rot(d3) ? "array" : h3 ? "linear" : "auto", _2 = n4(u4 + "tickmode", v3);\n              if (_2 === "auto" || _2 === "sync") n4(u4 + "nticks");\n              else if (_2 === "linear") {\n                var b = l3.dtick = Vae.dtick(h3, i3);\n                l3.tick0 = Vae.tick0(f4, i3, r4.calendar, b);\n              } else if (i3 !== "multicategory") {\n                var p3 = n4(u4 + "tickvals");\n                p3 === void 0 ? l3.tickmode = "auto" : o4 || n4("ticktext");\n              }\n            };\n          });\n          var M3 = ye((Snr, jae) => {\n            "use strict";\n            var kq = Dr(), Hae = Rd();\n            jae.exports = function(t3, r4, n4, i3) {\n              var a4 = i3.isMinor, o4 = a4 ? t3.minor || {} : t3, s3 = a4 ? r4.minor : r4, l3 = a4 ? Hae.minor : Hae, u4 = a4 ? "minor." : "", c5 = kq.coerce2(o4, s3, l3, "ticklen", a4 ? (r4.ticklen || 5) * 0.6 : void 0), f4 = kq.coerce2(o4, s3, l3, "tickwidth", a4 ? r4.tickwidth || 1 : void 0), h3 = kq.coerce2(o4, s3, l3, "tickcolor", (a4 ? r4.tickcolor : void 0) || s3.color), d3 = n4(u4 + "ticks", !a4 && i3.outerTicks || c5 || f4 || h3 ? "outside" : "");\n              d3 || (delete s3.ticklen, delete s3.tickwidth, delete s3.tickcolor);\n            };\n          });\n          var Cq = ye((Mnr, Wae) => {\n            "use strict";\n            Wae.exports = function(t3) {\n              var r4 = ["showexponent", "showtickprefix", "showticksuffix"], n4 = r4.filter(function(a4) {\n                return t3[a4] !== void 0;\n              }), i3 = function(a4) {\n                return t3[a4] === t3[n4[0]];\n              };\n              if (n4.every(i3) || n4.length === 1) return t3[n4[0]];\n            };\n          });\n          var Yd = ye((Enr, Xae) => {\n            "use strict";\n            var iL = Dr(), aot = vl();\n            Xae.exports = function(t3, r4, n4) {\n              var i3 = n4.name, a4 = n4.inclusionAttr || "visible", o4 = r4[i3], s3 = iL.isArrayOrTypedArray(t3[i3]) ? t3[i3] : [], l3 = r4[i3] = [], u4 = aot.arrayTemplater(r4, i3, a4), c5, f4;\n              for (c5 = 0; c5 < s3.length; c5++) {\n                var h3 = s3[c5];\n                iL.isPlainObject(h3) ? f4 = u4.newItem(h3) : (f4 = u4.newItem({}), f4[a4] = false), f4._index = c5, f4[a4] !== false && n4.handleItemDefaults(h3, f4, r4, n4), l3.push(f4);\n              }\n              var d3 = u4.defaultItems();\n              for (c5 = 0; c5 < d3.length; c5++) f4 = d3[c5], f4._index = l3.length, n4.handleItemDefaults({}, f4, r4, n4, {}), l3.push(f4);\n              if (iL.isArrayOrTypedArray(o4)) {\n                var v3 = Math.min(o4.length, l3.length);\n                for (c5 = 0; c5 < v3; c5++) iL.relinkPrivateKeys(l3[c5], o4[c5]);\n              }\n              return l3;\n            };\n          });\n          var e_ = ye((knr, Yae) => {\n            "use strict";\n            var Lq = Dr(), oot = ka().contrast, Zae = Rd(), sot = Cq(), lot = Yd();\n            Yae.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = n4("labelalias");\n              Lq.isPlainObject(o4) || delete r4.labelalias;\n              var s3 = sot(t3), l3 = n4("showticklabels");\n              if (l3) {\n                a4.noTicklabelshift || n4("ticklabelshift"), a4.noTicklabelstandoff || n4("ticklabelstandoff");\n                var u4 = a4.font || {}, c5 = r4.color, f4 = r4.ticklabelposition || "", h3 = f4.indexOf("inside") !== -1 ? oot(a4.bgColor) : c5 && c5 !== Zae.color.dflt ? c5 : u4.color;\n                if (Lq.coerceFont(n4, "tickfont", u4, { overrideDflt: { color: h3 } }), !a4.noTicklabelstep && i3 !== "multicategory" && i3 !== "log" && n4("ticklabelstep"), !a4.noAng) {\n                  var d3 = n4("tickangle");\n                  !a4.noAutotickangles && d3 === "auto" && n4("autotickangles");\n                }\n                if (i3 !== "category") {\n                  var v3 = n4("tickformat");\n                  lot(t3, r4, { name: "tickformatstops", inclusionAttr: "enabled", handleItemDefaults: uot }), r4.tickformatstops.length || delete r4.tickformatstops, !a4.noExp && !v3 && i3 !== "date" && (n4("showexponent", s3), n4("exponentformat"), n4("minexponent"), n4("separatethousands"));\n                }\n                !a4.noMinorloglabels && i3 === "log" && n4("minorloglabels");\n              }\n            };\n            function uot(e3, t3) {\n              function r4(i3, a4) {\n                return Lq.coerce(e3, t3, Zae.tickformatstops, i3, a4);\n              }\n              var n4 = r4("enabled");\n              n4 && (r4("dtickrange"), r4("value"));\n            }\n          });\n          var t_ = ye((Cnr, Kae) => {\n            "use strict";\n            var cot = Cq();\n            Kae.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = a4.tickSuffixDflt, s3 = cot(t3), l3 = n4("tickprefix");\n              l3 && n4("showtickprefix", s3);\n              var u4 = n4("ticksuffix", o4);\n              u4 && n4("showticksuffix", s3);\n            };\n          });\n          var Pq = ye((Lnr, Jae) => {\n            "use strict";\n            var r_ = Dr(), fot = vl(), hot = bb(), dot = M3(), vot = e_(), pot = t_(), got = tL();\n            Jae.exports = function(t3, r4, n4) {\n              var i3 = fot.newContainer(r4, "colorbar"), a4 = t3.colorbar || {};\n              function o4(T3, z3) {\n                return r_.coerce(a4, i3, got, T3, z3);\n              }\n              var s3 = n4.margin || { t: 0, b: 0, l: 0, r: 0 }, l3 = n4.width - s3.l - s3.r, u4 = n4.height - s3.t - s3.b, c5 = o4("orientation"), f4 = c5 === "v", h3 = o4("thicknessmode");\n              o4("thickness", h3 === "fraction" ? 30 / (f4 ? l3 : u4) : 30);\n              var d3 = o4("lenmode");\n              o4("len", d3 === "fraction" ? 1 : f4 ? u4 : l3);\n              var v3 = o4("yref"), _2 = o4("xref"), b = v3 === "paper", p3 = _2 === "paper", k4, E3, S2, L3 = "left";\n              f4 ? (S2 = "middle", L3 = p3 ? "left" : "right", k4 = p3 ? 1.02 : 1, E3 = 0.5) : (S2 = b ? "bottom" : "top", L3 = "center", k4 = 0.5, E3 = b ? 1.02 : 1), r_.coerce(a4, i3, { x: { valType: "number", min: p3 ? -2 : 0, max: p3 ? 3 : 1, dflt: k4 } }, "x"), r_.coerce(a4, i3, { y: { valType: "number", min: b ? -2 : 0, max: b ? 3 : 1, dflt: E3 } }, "y"), o4("xanchor", L3), o4("xpad"), o4("yanchor", S2), o4("ypad"), r_.noneOrAll(a4, i3, ["x", "y"]), o4("outlinecolor"), o4("outlinewidth"), o4("bordercolor"), o4("borderwidth"), o4("bgcolor");\n              var x2 = r_.coerce(a4, i3, { ticklabelposition: { valType: "enumerated", dflt: "outside", values: f4 ? ["outside", "inside", "outside top", "inside top", "outside bottom", "inside bottom"] : ["outside", "inside", "outside left", "inside left", "outside right", "inside right"] } }, "ticklabelposition");\n              o4("ticklabeloverflow", x2.indexOf("inside") !== -1 ? "hide past domain" : "hide past div"), hot(a4, i3, o4, "linear");\n              var C3 = n4.font, M4 = { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, outerTicks: false, font: C3 };\n              x2.indexOf("inside") !== -1 && (M4.bgColor = "black"), pot(a4, i3, o4, "linear", M4), vot(a4, i3, o4, "linear", M4), dot(a4, i3, o4, "linear", M4), o4("title.text", n4._dfltTitle.colorbar);\n              var g3 = i3.showticklabels ? i3.tickfont : C3, P3 = r_.extendFlat({}, C3, { family: g3.family, size: r_.bigFont(g3.size) });\n              r_.coerceFont(o4, "title.font", P3), o4("title.side", f4 ? "top" : "right");\n            };\n          });\n          var Qh = ye((Pnr, eoe) => {\n            "use strict";\n            var $ae = Eo(), Rq = Dr(), mot = Aq(), yot = Pq(), Qae = lb().isValid, _ot = qa().traceIs;\n            function Iq(e3, t3) {\n              var r4 = t3.slice(0, t3.length - 1);\n              return t3 ? Rq.nestedProperty(e3, r4).get() || {} : e3;\n            }\n            eoe.exports = function e3(t3, r4, n4, i3, a4) {\n              var o4 = a4.prefix, s3 = a4.cLetter, l3 = "_module" in r4, u4 = Iq(t3, o4), c5 = Iq(r4, o4), f4 = Iq(r4._template || {}, o4) || {}, h3 = function() {\n                return delete t3.coloraxis, delete r4.coloraxis, e3(t3, r4, n4, i3, a4);\n              };\n              if (l3) {\n                var d3 = n4._colorAxes || {}, v3 = i3(o4 + "coloraxis");\n                if (v3) {\n                  var _2 = _ot(r4, "contour") && Rq.nestedProperty(r4, "contours.coloring").get() || "heatmap", b = d3[v3];\n                  b ? (b[2].push(h3), b[0] !== _2 && (b[0] = false, Rq.warn(["Ignoring coloraxis:", v3, "setting", "as it is linked to incompatible colorscales."].join(" ")))) : d3[v3] = [_2, r4, [h3]];\n                  return;\n                }\n              }\n              var p3 = u4[s3 + "min"], k4 = u4[s3 + "max"], E3 = $ae(p3) && $ae(k4) && p3 < k4, S2 = i3(o4 + s3 + "auto", !E3);\n              S2 ? i3(o4 + s3 + "mid") : (i3(o4 + s3 + "min"), i3(o4 + s3 + "max"));\n              var L3 = u4.colorscale, x2 = f4.colorscale, C3;\n              if (L3 !== void 0 && (C3 = !Qae(L3)), x2 !== void 0 && (C3 = !Qae(x2)), i3(o4 + "autocolorscale", C3), i3(o4 + "colorscale"), i3(o4 + "reversescale"), o4 !== "marker.line.") {\n                var M4;\n                o4 && l3 && (M4 = mot(u4));\n                var g3 = i3(o4 + "showscale", M4);\n                g3 && (o4 && f4 && (c5._template = f4), yot(u4, c5, n4));\n              }\n            };\n          });\n          var noe = ye((Inr, ioe) => {\n            "use strict";\n            var toe = Dr(), xot = vl(), roe = Tq(), bot = Qh();\n            ioe.exports = function(t3, r4) {\n              function n4(f4, h3) {\n                return toe.coerce(t3, r4, roe, f4, h3);\n              }\n              n4("colorscale.sequential"), n4("colorscale.sequentialminus"), n4("colorscale.diverging");\n              var i3 = r4._colorAxes, a4, o4;\n              function s3(f4, h3) {\n                return toe.coerce(a4, o4, roe.coloraxis, f4, h3);\n              }\n              for (var l3 in i3) {\n                var u4 = i3[l3];\n                if (u4[0]) a4 = t3[l3] || {}, o4 = xot.newContainer(r4, l3, "coloraxis"), o4._name = l3, bot(a4, o4, r4, s3, { prefix: "", cLetter: "c" });\n                else {\n                  for (var c5 = 0; c5 < u4[2].length; c5++) u4[2][c5]();\n                  delete r4._colorAxes[l3];\n                }\n              }\n            };\n          });\n          var ooe = ye((Rnr, aoe) => {\n            "use strict";\n            var wot = Dr(), Tot = pv().hasColorscale, Aot = pv().extractOpts;\n            aoe.exports = function(t3, r4) {\n              function n4(c5, f4) {\n                var h3 = c5["_" + f4];\n                h3 !== void 0 && (c5[f4] = h3);\n              }\n              function i3(c5, f4) {\n                var h3 = f4.container ? wot.nestedProperty(c5, f4.container).get() : c5;\n                if (h3) if (h3.coloraxis) h3._colorAx = r4[h3.coloraxis];\n                else {\n                  var d3 = Aot(h3), v3 = d3.auto;\n                  (v3 || d3.min === void 0) && n4(h3, f4.min), (v3 || d3.max === void 0) && n4(h3, f4.max), d3.autocolorscale && n4(h3, "colorscale");\n                }\n              }\n              for (var a4 = 0; a4 < t3.length; a4++) {\n                var o4 = t3[a4], s3 = o4._module.colorbar;\n                if (s3) if (Array.isArray(s3)) for (var l3 = 0; l3 < s3.length; l3++) i3(o4, s3[l3]);\n                else i3(o4, s3);\n                Tot(o4, "marker.line") && i3(o4, { container: "marker.line", min: "cmin", max: "cmax" });\n              }\n              for (var u4 in r4._colorAxes) i3(r4[u4], { min: "cmin", max: "cmax" });\n            };\n          });\n          var gv = ye((Dnr, loe) => {\n            "use strict";\n            var soe = Eo(), Dq = Dr(), Sot = pv().extractOpts;\n            loe.exports = function(t3, r4, n4) {\n              var i3 = t3._fullLayout, a4 = n4.vals, o4 = n4.containerStr, s3 = o4 ? Dq.nestedProperty(r4, o4).get() : r4, l3 = Sot(s3), u4 = l3.auto !== false, c5 = l3.min, f4 = l3.max, h3 = l3.mid, d3 = function() {\n                return Dq.aggNums(Math.min, null, a4);\n              }, v3 = function() {\n                return Dq.aggNums(Math.max, null, a4);\n              };\n              if (c5 === void 0 ? c5 = d3() : u4 && (s3._colorAx && soe(c5) ? c5 = Math.min(c5, d3()) : c5 = d3()), f4 === void 0 ? f4 = v3() : u4 && (s3._colorAx && soe(f4) ? f4 = Math.max(f4, v3()) : f4 = v3()), u4 && h3 !== void 0 && (f4 - h3 > h3 - c5 ? c5 = h3 - (f4 - h3) : f4 - h3 < h3 - c5 && (f4 = h3 + (h3 - c5))), c5 === f4 && (c5 -= 0.5, f4 += 0.5), l3._sync("min", c5), l3._sync("max", f4), l3.autocolorscale) {\n                var _2;\n                c5 * f4 < 0 ? _2 = i3.colorscale.diverging : c5 >= 0 ? _2 = i3.colorscale.sequential : _2 = i3.colorscale.sequentialminus, l3._sync("colorscale", _2);\n              }\n            };\n          });\n          var tc = ye((Fnr, uoe) => {\n            "use strict";\n            var nL = lb(), E3 = pv();\n            uoe.exports = { moduleType: "component", name: "colorscale", attributes: Tu(), layoutAttributes: Tq(), supplyLayoutDefaults: noe(), handleDefaults: Qh(), crossTraceDefaults: ooe(), calc: gv(), scales: nL.scales, defaultScale: nL.defaultScale, getScale: nL.get, isValidScale: nL.isValid, hasColorscale: E3.hasColorscale, extractOpts: E3.extractOpts, extractScale: E3.extractScale, flipScale: E3.flipScale, makeColorScaleFunc: E3.makeColorScaleFunc, makeColorScaleFuncFromTrace: E3.makeColorScaleFuncFromTrace };\n          });\n          var Ru = ye((znr, foe) => {\n            "use strict";\n            var coe = Dr(), Mot = vv().isTypedArraySpec;\n            foe.exports = { hasLines: function(e3) {\n              return e3.visible && e3.mode && e3.mode.indexOf("lines") !== -1;\n            }, hasMarkers: function(e3) {\n              return e3.visible && (e3.mode && e3.mode.indexOf("markers") !== -1 || e3.type === "splom");\n            }, hasText: function(e3) {\n              return e3.visible && e3.mode && e3.mode.indexOf("text") !== -1;\n            }, isBubble: function(e3) {\n              var t3 = e3.marker;\n              return coe.isPlainObject(t3) && (coe.isArrayOrTypedArray(t3.size) || Mot(t3.size));\n            } };\n          });\n          var k3 = ye((Onr, hoe) => {\n            "use strict";\n            var Eot = Eo();\n            hoe.exports = function(t3, r4) {\n              r4 || (r4 = 2);\n              var n4 = t3.marker, i3 = n4.sizeref || 1, a4 = n4.sizemin || 0, o4 = n4.sizemode === "area" ? function(s3) {\n                return Math.sqrt(s3 / i3);\n              } : function(s3) {\n                return s3 / i3;\n              };\n              return function(s3) {\n                var l3 = o4(s3 / r4);\n                return Eot(l3) && l3 > 0 ? Math.max(l3, a4) : 0;\n              };\n            };\n          });\n          var ip = ye((mv) => {\n            "use strict";\n            var aL = Dr();\n            mv.getSubplot = function(e3) {\n              return e3.subplot || e3.xaxis + e3.yaxis || e3.geo;\n            };\n            mv.isTraceInSubplots = function(e3, t3) {\n              if (e3.type === "splom") {\n                for (var r4 = e3.xaxes || [], n4 = e3.yaxes || [], i3 = 0; i3 < r4.length; i3++) for (var a4 = 0; a4 < n4.length; a4++) if (t3.indexOf(r4[i3] + n4[a4]) !== -1) return true;\n                return false;\n              }\n              return t3.indexOf(mv.getSubplot(e3)) !== -1;\n            };\n            mv.flat = function(e3, t3) {\n              for (var r4 = new Array(e3.length), n4 = 0; n4 < e3.length; n4++) r4[n4] = t3;\n              return r4;\n            };\n            mv.p2c = function(e3, t3) {\n              for (var r4 = new Array(e3.length), n4 = 0; n4 < e3.length; n4++) r4[n4] = e3[n4].p2c(t3);\n              return r4;\n            };\n            mv.getDistanceFunction = function(e3, t3, r4, n4) {\n              return e3 === "closest" ? n4 || mv.quadrature(t3, r4) : e3.charAt(0) === "x" ? t3 : r4;\n            };\n            mv.getClosest = function(e3, t3, r4) {\n              if (r4.index !== false) r4.index >= 0 && r4.index < e3.length ? r4.distance = 0 : r4.index = false;\n              else for (var n4 = 1 / 0, i3 = e3.length, a4 = 0; a4 < i3; a4++) n4 = t3(e3[a4]), n4 <= r4.distance && (r4.index = a4, r4.distance = n4);\n              return r4;\n            };\n            mv.inbox = function(e3, t3, r4) {\n              return e3 * t3 < 0 || e3 === 0 ? r4 : 1 / 0;\n            };\n            mv.quadrature = function(e3, t3) {\n              return function(r4) {\n                var n4 = e3(r4), i3 = t3(r4);\n                return Math.sqrt(n4 * n4 + i3 * i3);\n              };\n            };\n            mv.makeEventData = function(e3, t3, r4) {\n              var n4 = "index" in e3 ? e3.index : e3.pointNumber, i3 = { data: t3._input, fullData: t3, curveNumber: t3.index, pointNumber: n4 };\n              if (t3._indexToPoints) {\n                var a4 = t3._indexToPoints[n4];\n                a4.length === 1 ? i3.pointIndex = a4[0] : i3.pointIndices = a4;\n              } else i3.pointIndex = n4;\n              return t3._module.eventData ? i3 = t3._module.eventData(i3, e3, t3, r4, n4) : ("xVal" in e3 ? i3.x = e3.xVal : "x" in e3 && (i3.x = e3.x), "yVal" in e3 ? i3.y = e3.yVal : "y" in e3 && (i3.y = e3.y), e3.xa && (i3.xaxis = e3.xa), e3.ya && (i3.yaxis = e3.ya), e3.zLabelVal !== void 0 && (i3.z = e3.zLabelVal)), mv.appendArrayPointValue(i3, t3, n4), i3;\n            };\n            mv.appendArrayPointValue = function(e3, t3, r4) {\n              var n4 = t3._arrayAttrs;\n              if (n4) for (var i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3], o4 = doe(a4);\n                if (e3[o4] === void 0) {\n                  var s3 = aL.nestedProperty(t3, a4).get(), l3 = voe(s3, r4);\n                  l3 !== void 0 && (e3[o4] = l3);\n                }\n              }\n            };\n            mv.appendArrayMultiPointValues = function(e3, t3, r4) {\n              var n4 = t3._arrayAttrs;\n              if (n4) for (var i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3], o4 = doe(a4);\n                if (e3[o4] === void 0) {\n                  for (var s3 = aL.nestedProperty(t3, a4).get(), l3 = new Array(r4.length), u4 = 0; u4 < r4.length; u4++) l3[u4] = voe(s3, r4[u4]);\n                  e3[o4] = l3;\n                }\n              }\n            };\n            var kot = { ids: "id", locations: "location", labels: "label", values: "value", "marker.colors": "color", parents: "parent" };\n            function doe(e3) {\n              return kot[e3] || e3;\n            }\n            function voe(e3, t3) {\n              if (Array.isArray(t3)) {\n                if (aL.isArrayOrTypedArray(e3) && aL.isArrayOrTypedArray(e3[t3[0]])) return e3[t3[0]][t3[1]];\n              } else return e3[t3];\n            }\n            var Cot = { x: true, y: true }, Lot = { "x unified": true, "y unified": true };\n            mv.isUnifiedHover = function(e3) {\n              return typeof e3 != "string" ? false : !!Lot[e3];\n            };\n            mv.isXYhover = function(e3) {\n              return typeof e3 != "string" ? false : !!Cot[e3];\n            };\n          });\n          var eM = ye((Bnr, poe) => {\n            poe.exports = Iot;\n            var Fq = { a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0 }, Pot = /([astvzqmhlc])([^astvzqmhlc]*)/ig;\n            function Iot(e3) {\n              var t3 = [];\n              return e3.replace(Pot, function(r4, n4, i3) {\n                var a4 = n4.toLowerCase();\n                for (i3 = Dot(i3), a4 == "m" && i3.length > 2 && (t3.push([n4].concat(i3.splice(0, 2))), a4 = "l", n4 = n4 == "m" ? "l" : "L"); ; ) {\n                  if (i3.length == Fq[a4]) return i3.unshift(n4), t3.push(i3);\n                  if (i3.length < Fq[a4]) throw new Error("malformed path data");\n                  t3.push([n4].concat(i3.splice(0, Fq[a4])));\n                }\n              }), t3;\n            }\n            var Rot = /-?[0-9]*\\.?[0-9]+(?:e[-+]?\\d+)?/ig;\n            function Dot(e3) {\n              var t3 = e3.match(Rot);\n              return t3 ? t3.map(Number) : [];\n            }\n          });\n          var woe = ye((Nnr, boe) => {\n            "use strict";\n            var Fot = eM(), ca = function(e3, t3) {\n              return t3 ? Math.round(e3 * (t3 = Math.pow(10, t3))) / t3 : Math.round(e3);\n            }, hs = "M0,0Z", goe = Math.sqrt(2), i_ = Math.sqrt(3), zq = Math.PI, Oq = Math.cos, qq = Math.sin;\n            boe.exports = { circle: { n: 0, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = "M" + n4 + ",0A" + n4 + "," + n4 + " 0 1,1 0,-" + n4 + "A" + n4 + "," + n4 + " 0 0,1 " + n4 + ",0Z";\n              return r4 ? vs(t3, r4, i3) : i3;\n            } }, square: { n: 1, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "H-" + n4 + "V-" + n4 + "H" + n4 + "Z");\n            } }, diamond: { n: 2, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.3, 2);\n              return vs(t3, r4, "M" + n4 + ",0L0," + n4 + "L-" + n4 + ",0L0,-" + n4 + "Z");\n            } }, cross: { n: 3, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.4, 2), i3 = ca(e3 * 1.2, 2);\n              return vs(t3, r4, "M" + i3 + "," + n4 + "H" + n4 + "V" + i3 + "H-" + n4 + "V" + n4 + "H-" + i3 + "V-" + n4 + "H-" + n4 + "V-" + i3 + "H" + n4 + "V-" + n4 + "H" + i3 + "Z");\n            } }, x: { n: 4, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.8 / goe, 2), i3 = "l" + n4 + "," + n4, a4 = "l" + n4 + ",-" + n4, o4 = "l-" + n4 + ",-" + n4, s3 = "l-" + n4 + "," + n4;\n              return vs(t3, r4, "M0," + n4 + i3 + a4 + o4 + a4 + o4 + s3 + o4 + s3 + i3 + s3 + i3 + "Z");\n            } }, "triangle-up": { n: 5, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2 / i_, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3, 2);\n              return vs(t3, r4, "M-" + n4 + "," + i3 + "H" + n4 + "L0,-" + a4 + "Z");\n            } }, "triangle-down": { n: 6, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2 / i_, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3, 2);\n              return vs(t3, r4, "M-" + n4 + ",-" + i3 + "H" + n4 + "L0," + a4 + "Z");\n            } }, "triangle-left": { n: 7, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2 / i_, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3, 2);\n              return vs(t3, r4, "M" + i3 + ",-" + n4 + "V" + n4 + "L-" + a4 + ",0Z");\n            } }, "triangle-right": { n: 8, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2 / i_, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3, 2);\n              return vs(t3, r4, "M-" + i3 + ",-" + n4 + "V" + n4 + "L" + a4 + ",0Z");\n            } }, "triangle-ne": { n: 9, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.6, 2), i3 = ca(e3 * 1.2, 2);\n              return vs(t3, r4, "M-" + i3 + ",-" + n4 + "H" + n4 + "V" + i3 + "Z");\n            } }, "triangle-se": { n: 10, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.6, 2), i3 = ca(e3 * 1.2, 2);\n              return vs(t3, r4, "M" + n4 + ",-" + i3 + "V" + n4 + "H-" + i3 + "Z");\n            } }, "triangle-sw": { n: 11, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.6, 2), i3 = ca(e3 * 1.2, 2);\n              return vs(t3, r4, "M" + i3 + "," + n4 + "H-" + n4 + "V-" + i3 + "Z");\n            } }, "triangle-nw": { n: 12, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.6, 2), i3 = ca(e3 * 1.2, 2);\n              return vs(t3, r4, "M-" + n4 + "," + i3 + "V-" + n4 + "H" + i3 + "Z");\n            } }, pentagon: { n: 13, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.951, 2), i3 = ca(e3 * 0.588, 2), a4 = ca(-e3, 2), o4 = ca(e3 * -0.309, 2), s3 = ca(e3 * 0.809, 2);\n              return vs(t3, r4, "M" + n4 + "," + o4 + "L" + i3 + "," + s3 + "H-" + i3 + "L-" + n4 + "," + o4 + "L0," + a4 + "Z");\n            } }, hexagon: { n: 14, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3 * i_ / 2, 2);\n              return vs(t3, r4, "M" + a4 + ",-" + i3 + "V" + i3 + "L0," + n4 + "L-" + a4 + "," + i3 + "V-" + i3 + "L0,-" + n4 + "Z");\n            } }, hexagon2: { n: 15, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 / 2, 2), a4 = ca(e3 * i_ / 2, 2);\n              return vs(t3, r4, "M-" + i3 + "," + a4 + "H" + i3 + "L" + n4 + ",0L" + i3 + ",-" + a4 + "H-" + i3 + "L-" + n4 + ",0Z");\n            } }, octagon: { n: 16, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.924, 2), i3 = ca(e3 * 0.383, 2);\n              return vs(t3, r4, "M-" + i3 + ",-" + n4 + "H" + i3 + "L" + n4 + ",-" + i3 + "V" + i3 + "L" + i3 + "," + n4 + "H-" + i3 + "L-" + n4 + "," + i3 + "V-" + i3 + "Z");\n            } }, star: { n: 17, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = e3 * 1.4, i3 = ca(n4 * 0.225, 2), a4 = ca(n4 * 0.951, 2), o4 = ca(n4 * 0.363, 2), s3 = ca(n4 * 0.588, 2), l3 = ca(-n4, 2), u4 = ca(n4 * -0.309, 2), c5 = ca(n4 * 0.118, 2), f4 = ca(n4 * 0.809, 2), h3 = ca(n4 * 0.382, 2);\n              return vs(t3, r4, "M" + i3 + "," + u4 + "H" + a4 + "L" + o4 + "," + c5 + "L" + s3 + "," + f4 + "L0," + h3 + "L-" + s3 + "," + f4 + "L-" + o4 + "," + c5 + "L-" + a4 + "," + u4 + "H-" + i3 + "L0," + l3 + "Z");\n            } }, hexagram: { n: 18, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.66, 2), i3 = ca(e3 * 0.38, 2), a4 = ca(e3 * 0.76, 2);\n              return vs(t3, r4, "M-" + a4 + ",0l-" + i3 + ",-" + n4 + "h" + a4 + "l" + i3 + ",-" + n4 + "l" + i3 + "," + n4 + "h" + a4 + "l-" + i3 + "," + n4 + "l" + i3 + "," + n4 + "h-" + a4 + "l-" + i3 + "," + n4 + "l-" + i3 + ",-" + n4 + "h-" + a4 + "Z");\n            } }, "star-triangle-up": { n: 19, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * i_ * 0.8, 2), i3 = ca(e3 * 0.8, 2), a4 = ca(e3 * 1.6, 2), o4 = ca(e3 * 4, 2), s3 = "A " + o4 + "," + o4 + " 0 0 1 ";\n              return vs(t3, r4, "M-" + n4 + "," + i3 + s3 + n4 + "," + i3 + s3 + "0,-" + a4 + s3 + "-" + n4 + "," + i3 + "Z");\n            } }, "star-triangle-down": { n: 20, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * i_ * 0.8, 2), i3 = ca(e3 * 0.8, 2), a4 = ca(e3 * 1.6, 2), o4 = ca(e3 * 4, 2), s3 = "A " + o4 + "," + o4 + " 0 0 1 ";\n              return vs(t3, r4, "M" + n4 + ",-" + i3 + s3 + "-" + n4 + ",-" + i3 + s3 + "0," + a4 + s3 + n4 + ",-" + i3 + "Z");\n            } }, "star-square": { n: 21, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.1, 2), i3 = ca(e3 * 2, 2), a4 = "A " + i3 + "," + i3 + " 0 0 1 ";\n              return vs(t3, r4, "M-" + n4 + ",-" + n4 + a4 + "-" + n4 + "," + n4 + a4 + n4 + "," + n4 + a4 + n4 + ",-" + n4 + a4 + "-" + n4 + ",-" + n4 + "Z");\n            } }, "star-diamond": { n: 22, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.4, 2), i3 = ca(e3 * 1.9, 2), a4 = "A " + i3 + "," + i3 + " 0 0 1 ";\n              return vs(t3, r4, "M-" + n4 + ",0" + a4 + "0," + n4 + a4 + n4 + ",0" + a4 + "0,-" + n4 + a4 + "-" + n4 + ",0Z");\n            } }, "diamond-tall": { n: 23, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 0.7, 2), i3 = ca(e3 * 1.4, 2);\n              return vs(t3, r4, "M0," + i3 + "L" + n4 + ",0L0,-" + i3 + "L-" + n4 + ",0Z");\n            } }, "diamond-wide": { n: 24, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.4, 2), i3 = ca(e3 * 0.7, 2);\n              return vs(t3, r4, "M0," + i3 + "L" + n4 + ",0L0,-" + i3 + "L-" + n4 + ",0Z");\n            } }, hourglass: { n: 25, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "H-" + n4 + "L" + n4 + ",-" + n4 + "H-" + n4 + "Z");\n            }, noDot: true }, bowtie: { n: 26, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "V-" + n4 + "L-" + n4 + "," + n4 + "V-" + n4 + "Z");\n            }, noDot: true }, "circle-cross": { n: 27, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M0," + n4 + "V-" + n4 + "M" + n4 + ",0H-" + n4 + "M" + n4 + ",0A" + n4 + "," + n4 + " 0 1,1 0,-" + n4 + "A" + n4 + "," + n4 + " 0 0,1 " + n4 + ",0Z");\n            }, needLine: true, noDot: true }, "circle-x": { n: 28, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 / goe, 2);\n              return vs(t3, r4, "M" + i3 + "," + i3 + "L-" + i3 + ",-" + i3 + "M" + i3 + ",-" + i3 + "L-" + i3 + "," + i3 + "M" + n4 + ",0A" + n4 + "," + n4 + " 0 1,1 0,-" + n4 + "A" + n4 + "," + n4 + " 0 0,1 " + n4 + ",0Z");\n            }, needLine: true, noDot: true }, "square-cross": { n: 29, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M0," + n4 + "V-" + n4 + "M" + n4 + ",0H-" + n4 + "M" + n4 + "," + n4 + "H-" + n4 + "V-" + n4 + "H" + n4 + "Z");\n            }, needLine: true, noDot: true }, "square-x": { n: 30, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "L-" + n4 + ",-" + n4 + "M" + n4 + ",-" + n4 + "L-" + n4 + "," + n4 + "M" + n4 + "," + n4 + "H-" + n4 + "V-" + n4 + "H" + n4 + "Z");\n            }, needLine: true, noDot: true }, "diamond-cross": { n: 31, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.3, 2);\n              return vs(t3, r4, "M" + n4 + ",0L0," + n4 + "L-" + n4 + ",0L0,-" + n4 + "ZM0,-" + n4 + "V" + n4 + "M-" + n4 + ",0H" + n4);\n            }, needLine: true, noDot: true }, "diamond-x": { n: 32, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.3, 2), i3 = ca(e3 * 0.65, 2);\n              return vs(t3, r4, "M" + n4 + ",0L0," + n4 + "L-" + n4 + ",0L0,-" + n4 + "ZM-" + i3 + ",-" + i3 + "L" + i3 + "," + i3 + "M-" + i3 + "," + i3 + "L" + i3 + ",-" + i3);\n            }, needLine: true, noDot: true }, "cross-thin": { n: 33, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.4, 2);\n              return vs(t3, r4, "M0," + n4 + "V-" + n4 + "M" + n4 + ",0H-" + n4);\n            }, needLine: true, noDot: true, noFill: true }, "x-thin": { n: 34, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "L-" + n4 + ",-" + n4 + "M" + n4 + ",-" + n4 + "L-" + n4 + "," + n4);\n            }, needLine: true, noDot: true, noFill: true }, asterisk: { n: 35, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.2, 2), i3 = ca(e3 * 0.85, 2);\n              return vs(t3, r4, "M0," + n4 + "V-" + n4 + "M" + n4 + ",0H-" + n4 + "M" + i3 + "," + i3 + "L-" + i3 + ",-" + i3 + "M" + i3 + ",-" + i3 + "L-" + i3 + "," + i3);\n            }, needLine: true, noDot: true, noFill: true }, hash: { n: 36, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 / 2, 2), i3 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + i3 + "V-" + i3 + "M" + (n4 - i3) + ",-" + i3 + "V" + i3 + "M" + i3 + "," + n4 + "H-" + i3 + "M-" + i3 + "," + (n4 - i3) + "H" + i3);\n            }, needLine: true, noFill: true }, "y-up": { n: 37, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.2, 2), i3 = ca(e3 * 1.6, 2), a4 = ca(e3 * 0.8, 2);\n              return vs(t3, r4, "M-" + n4 + "," + a4 + "L0,0M" + n4 + "," + a4 + "L0,0M0,-" + i3 + "L0,0");\n            }, needLine: true, noDot: true, noFill: true }, "y-down": { n: 38, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.2, 2), i3 = ca(e3 * 1.6, 2), a4 = ca(e3 * 0.8, 2);\n              return vs(t3, r4, "M-" + n4 + ",-" + a4 + "L0,0M" + n4 + ",-" + a4 + "L0,0M0," + i3 + "L0,0");\n            }, needLine: true, noDot: true, noFill: true }, "y-left": { n: 39, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.2, 2), i3 = ca(e3 * 1.6, 2), a4 = ca(e3 * 0.8, 2);\n              return vs(t3, r4, "M" + a4 + "," + n4 + "L0,0M" + a4 + ",-" + n4 + "L0,0M-" + i3 + ",0L0,0");\n            }, needLine: true, noDot: true, noFill: true }, "y-right": { n: 40, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.2, 2), i3 = ca(e3 * 1.6, 2), a4 = ca(e3 * 0.8, 2);\n              return vs(t3, r4, "M-" + a4 + "," + n4 + "L0,0M-" + a4 + ",-" + n4 + "L0,0M" + i3 + ",0L0,0");\n            }, needLine: true, noDot: true, noFill: true }, "line-ew": { n: 41, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.4, 2);\n              return vs(t3, r4, "M" + n4 + ",0H-" + n4);\n            }, needLine: true, noDot: true, noFill: true }, "line-ns": { n: 42, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 1.4, 2);\n              return vs(t3, r4, "M0," + n4 + "V-" + n4);\n            }, needLine: true, noDot: true, noFill: true }, "line-ne": { n: 43, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + ",-" + n4 + "L-" + n4 + "," + n4);\n            }, needLine: true, noDot: true, noFill: true }, "line-nw": { n: 44, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2);\n              return vs(t3, r4, "M" + n4 + "," + n4 + "L-" + n4 + ",-" + n4);\n            }, needLine: true, noDot: true, noFill: true }, "arrow-up": { n: 45, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 * 2, 2);\n              return vs(t3, r4, "M0,0L-" + n4 + "," + i3 + "H" + n4 + "Z");\n            }, backoff: 1, noDot: true }, "arrow-down": { n: 46, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 * 2, 2);\n              return vs(t3, r4, "M0,0L-" + n4 + ",-" + i3 + "H" + n4 + "Z");\n            }, noDot: true }, "arrow-left": { n: 47, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2, 2), i3 = ca(e3, 2);\n              return vs(t3, r4, "M0,0L" + n4 + ",-" + i3 + "V" + i3 + "Z");\n            }, noDot: true }, "arrow-right": { n: 48, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2, 2), i3 = ca(e3, 2);\n              return vs(t3, r4, "M0,0L-" + n4 + ",-" + i3 + "V" + i3 + "Z");\n            }, noDot: true }, "arrow-bar-up": { n: 49, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 * 2, 2);\n              return vs(t3, r4, "M-" + n4 + ",0H" + n4 + "M0,0L-" + n4 + "," + i3 + "H" + n4 + "Z");\n            }, backoff: 1, needLine: true, noDot: true }, "arrow-bar-down": { n: 50, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3, 2), i3 = ca(e3 * 2, 2);\n              return vs(t3, r4, "M-" + n4 + ",0H" + n4 + "M0,0L-" + n4 + ",-" + i3 + "H" + n4 + "Z");\n            }, needLine: true, noDot: true }, "arrow-bar-left": { n: 51, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2, 2), i3 = ca(e3, 2);\n              return vs(t3, r4, "M0,-" + i3 + "V" + i3 + "M0,0L" + n4 + ",-" + i3 + "V" + i3 + "Z");\n            }, needLine: true, noDot: true }, "arrow-bar-right": { n: 52, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = ca(e3 * 2, 2), i3 = ca(e3, 2);\n              return vs(t3, r4, "M0,-" + i3 + "V" + i3 + "M0,0L-" + n4 + ",-" + i3 + "V" + i3 + "Z");\n            }, needLine: true, noDot: true }, arrow: { n: 53, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = zq / 2.5, i3 = 2 * e3 * Oq(n4), a4 = 2 * e3 * qq(n4);\n              return vs(t3, r4, "M0,0L" + -i3 + "," + a4 + "L" + i3 + "," + a4 + "Z");\n            }, backoff: 0.9, noDot: true }, "arrow-wide": { n: 54, f: function(e3, t3, r4) {\n              if (ds(t3)) return hs;\n              var n4 = zq / 4, i3 = 2 * e3 * Oq(n4), a4 = 2 * e3 * qq(n4);\n              return vs(t3, r4, "M0,0L" + -i3 + "," + a4 + "A " + 2 * e3 + "," + 2 * e3 + " 0 0 1 " + i3 + "," + a4 + "Z");\n            }, backoff: 0.4, noDot: true } };\n            function ds(e3) {\n              return e3 === null;\n            }\n            var moe, yoe, _oe, xoe;\n            function vs(e3, t3, r4) {\n              if ((!e3 || e3 % 360 === 0) && !t3) return r4;\n              if (_oe === e3 && xoe === t3 && moe === r4) return yoe;\n              _oe = e3, xoe = t3, moe = r4;\n              function n4(b, p3) {\n                var k4 = Oq(b), E3 = qq(b), S2 = p3[0], L3 = p3[1] + (t3 || 0);\n                return [S2 * k4 - L3 * E3, S2 * E3 + L3 * k4];\n              }\n              for (var i3 = e3 / 180 * zq, a4 = 0, o4 = 0, s3 = Fot(r4), l3 = "", u4 = 0; u4 < s3.length; u4++) {\n                var c5 = s3[u4], f4 = c5[0], h3 = a4, d3 = o4;\n                if (f4 === "M" || f4 === "L") a4 = +c5[1], o4 = +c5[2];\n                else if (f4 === "m" || f4 === "l") a4 += +c5[1], o4 += +c5[2];\n                else if (f4 === "H") a4 = +c5[1];\n                else if (f4 === "h") a4 += +c5[1];\n                else if (f4 === "V") o4 = +c5[1];\n                else if (f4 === "v") o4 += +c5[1];\n                else if (f4 === "A") {\n                  a4 = +c5[1], o4 = +c5[2];\n                  var v3 = n4(i3, [+c5[6], +c5[7]]);\n                  c5[6] = v3[0], c5[7] = v3[1], c5[3] = +c5[3] + e3;\n                }\n                (f4 === "H" || f4 === "V") && (f4 = "L"), (f4 === "h" || f4 === "v") && (f4 = "l"), (f4 === "m" || f4 === "l") && (a4 -= h3, o4 -= d3);\n                var _2 = n4(i3, [a4, o4]);\n                (f4 === "H" || f4 === "V") && (f4 = "L"), (f4 === "M" || f4 === "L" || f4 === "m" || f4 === "l") && (c5[1] = _2[0], c5[2] = _2[1]), c5[0] = f4, l3 += c5[0] + c5.slice(1).join(",");\n              }\n              return yoe = l3, l3;\n            }\n          });\n          var So = ye((Unr, Voe) => {\n            "use strict";\n            var dd = Oa(), Du = Dr(), zot = Du.numberFormat, Sb = Eo(), Hq = cd(), sL = qa(), Kd = ka(), Oot = tc(), rM = Du.strTranslate, lL = ru(), qot = Wp(), Bot = $h(), Not = Bot.LINE_SPACING, Ioe = N1().DESELECTDIM, Uot = Ru(), Vot = k3(), Got = ip().appendArrayPointValue, Aa = Voe.exports = {};\n            Aa.font = function(e3, t3) {\n              var r4 = t3.variant, n4 = t3.style, i3 = t3.weight, a4 = t3.color, o4 = t3.size, s3 = t3.family, l3 = t3.shadow, u4 = t3.lineposition, c5 = t3.textcase;\n              s3 && e3.style("font-family", s3), o4 + 1 && e3.style("font-size", o4 + "px"), a4 && e3.call(Kd.fill, a4), i3 && e3.style("font-weight", i3), n4 && e3.style("font-style", n4), r4 && e3.style("font-variant", r4), c5 && e3.style("text-transform", Bq(jot(c5))), l3 && e3.style("text-shadow", l3 === "auto" ? lL.makeTextShadow(Kd.contrast(a4)) : Bq(l3)), u4 && e3.style("text-decoration-line", Bq(Wot(u4)));\n            };\n            function Bq(e3) {\n              return e3 === "none" ? void 0 : e3;\n            }\n            var Hot = { normal: "none", lower: "lowercase", upper: "uppercase", "word caps": "capitalize" };\n            function jot(e3) {\n              return Hot[e3];\n            }\n            function Wot(e3) {\n              return e3.replace("under", "underline").replace("over", "overline").replace("through", "line-through").split("+").join(" ");\n            }\n            Aa.setPosition = function(e3, t3, r4) {\n              e3.attr("x", t3).attr("y", r4);\n            };\n            Aa.setSize = function(e3, t3, r4) {\n              e3.attr("width", t3).attr("height", r4);\n            };\n            Aa.setRect = function(e3, t3, r4, n4, i3) {\n              e3.call(Aa.setPosition, t3, r4).call(Aa.setSize, n4, i3);\n            };\n            Aa.translatePoint = function(e3, t3, r4, n4) {\n              var i3 = r4.c2p(e3.x), a4 = n4.c2p(e3.y);\n              if (Sb(i3) && Sb(a4) && t3.node()) t3.node().nodeName === "text" ? t3.attr("x", i3).attr("y", a4) : t3.attr("transform", rM(i3, a4));\n              else return false;\n              return true;\n            };\n            Aa.translatePoints = function(e3, t3, r4) {\n              e3.each(function(n4) {\n                var i3 = dd.select(this);\n                Aa.translatePoint(n4, i3, t3, r4);\n              });\n            };\n            Aa.hideOutsideRangePoint = function(e3, t3, r4, n4, i3, a4) {\n              t3.attr("display", r4.isPtWithinRange(e3, i3) && n4.isPtWithinRange(e3, a4) ? null : "none");\n            };\n            Aa.hideOutsideRangePoints = function(e3, t3) {\n              if (t3._hasClipOnAxisFalse) {\n                var r4 = t3.xaxis, n4 = t3.yaxis;\n                e3.each(function(i3) {\n                  var a4 = i3[0].trace, o4 = a4.xcalendar, s3 = a4.ycalendar, l3 = sL.traceIs(a4, "bar-like") ? ".bartext" : ".point,.textpoint";\n                  e3.selectAll(l3).each(function(u4) {\n                    Aa.hideOutsideRangePoint(u4, dd.select(this), r4, n4, o4, s3);\n                  });\n                });\n              }\n            };\n            Aa.crispRound = function(e3, t3, r4) {\n              return !t3 || !Sb(t3) ? r4 || 0 : e3._context.staticPlot ? t3 : t3 < 1 ? 1 : Math.round(t3);\n            };\n            Aa.singleLineStyle = function(e3, t3, r4, n4, i3) {\n              t3.style("fill", "none");\n              var a4 = (((e3 || [])[0] || {}).trace || {}).line || {}, o4 = r4 || a4.width || 0, s3 = i3 || a4.dash || "";\n              Kd.stroke(t3, n4 || a4.color), Aa.dashLine(t3, s3, o4);\n            };\n            Aa.lineGroupStyle = function(e3, t3, r4, n4) {\n              e3.style("fill", "none").each(function(i3) {\n                var a4 = (((i3 || [])[0] || {}).trace || {}).line || {}, o4 = t3 || a4.width || 0, s3 = n4 || a4.dash || "";\n                dd.select(this).call(Kd.stroke, r4 || a4.color).call(Aa.dashLine, s3, o4);\n              });\n            };\n            Aa.dashLine = function(e3, t3, r4) {\n              r4 = +r4 || 0, t3 = Aa.dashStyle(t3, r4), e3.style({ "stroke-dasharray": t3, "stroke-width": r4 + "px" });\n            };\n            Aa.dashStyle = function(e3, t3) {\n              t3 = +t3 || 1;\n              var r4 = Math.max(t3, 3);\n              return e3 === "solid" ? e3 = "" : e3 === "dot" ? e3 = r4 + "px," + r4 + "px" : e3 === "dash" ? e3 = 3 * r4 + "px," + 3 * r4 + "px" : e3 === "longdash" ? e3 = 5 * r4 + "px," + 5 * r4 + "px" : e3 === "dashdot" ? e3 = 3 * r4 + "px," + r4 + "px," + r4 + "px," + r4 + "px" : e3 === "longdashdot" && (e3 = 5 * r4 + "px," + 2 * r4 + "px," + r4 + "px," + 2 * r4 + "px"), e3;\n            };\n            function Roe(e3, t3, r4, n4) {\n              var i3 = t3.fillpattern, a4 = t3.fillgradient, o4 = Aa.getPatternAttr, s3 = i3 && (o4(i3.shape, 0, "") || o4(i3.path, 0, ""));\n              if (s3) {\n                var l3 = o4(i3.bgcolor, 0, null), u4 = o4(i3.fgcolor, 0, null), c5 = i3.fgopacity, f4 = o4(i3.size, 0, 8), h3 = o4(i3.solidity, 0, 0.3), d3 = t3.uid;\n                Aa.pattern(e3, "point", r4, d3, s3, f4, h3, void 0, i3.fillmode, l3, u4, c5);\n              } else if (a4 && a4.type !== "none") {\n                var v3 = a4.type, _2 = "scatterfill-" + t3.uid;\n                if (n4 && (_2 = "legendfill-" + t3.uid), !n4 && (a4.start !== void 0 || a4.stop !== void 0)) {\n                  var b, p3;\n                  v3 === "horizontal" ? (b = { x: a4.start, y: 0 }, p3 = { x: a4.stop, y: 0 }) : v3 === "vertical" && (b = { x: 0, y: a4.start }, p3 = { x: 0, y: a4.stop }), b.x = t3._xA.c2p(b.x === void 0 ? t3._extremes.x.min[0].val : b.x, true), b.y = t3._yA.c2p(b.y === void 0 ? t3._extremes.y.min[0].val : b.y, true), p3.x = t3._xA.c2p(p3.x === void 0 ? t3._extremes.x.max[0].val : p3.x, true), p3.y = t3._yA.c2p(p3.y === void 0 ? t3._extremes.y.max[0].val : p3.y, true), e3.call(zoe, r4, _2, "linear", a4.colorscale, "fill", b, p3, true, false);\n                } else v3 === "horizontal" && (v3 = v3 + "reversed"), e3.call(Aa.gradient, r4, _2, v3, a4.colorscale, "fill");\n              } else t3.fillcolor && e3.call(Kd.fill, t3.fillcolor);\n            }\n            Aa.singleFillStyle = function(e3, t3) {\n              var r4 = dd.select(e3.node()), n4 = r4.data(), i3 = ((n4[0] || [])[0] || {}).trace || {};\n              Roe(e3, i3, t3, false);\n            };\n            Aa.fillGroupStyle = function(e3, t3, r4) {\n              e3.style("stroke-width", 0).each(function(n4) {\n                var i3 = dd.select(this);\n                n4[0].trace && Roe(i3, n4[0].trace, t3, r4);\n              });\n            };\n            var Toe = woe();\n            Aa.symbolNames = [];\n            Aa.symbolFuncs = [];\n            Aa.symbolBackOffs = [];\n            Aa.symbolNeedLines = {};\n            Aa.symbolNoDot = {};\n            Aa.symbolNoFill = {};\n            Aa.symbolList = [];\n            Object.keys(Toe).forEach(function(e3) {\n              var t3 = Toe[e3], r4 = t3.n;\n              Aa.symbolList.push(r4, String(r4), e3, r4 + 100, String(r4 + 100), e3 + "-open"), Aa.symbolNames[r4] = e3, Aa.symbolFuncs[r4] = t3.f, Aa.symbolBackOffs[r4] = t3.backoff || 0, t3.needLine && (Aa.symbolNeedLines[r4] = true), t3.noDot ? Aa.symbolNoDot[r4] = true : Aa.symbolList.push(r4 + 200, String(r4 + 200), e3 + "-dot", r4 + 300, String(r4 + 300), e3 + "-open-dot"), t3.noFill && (Aa.symbolNoFill[r4] = true);\n            });\n            var Xot = Aa.symbolNames.length, Zot = "M0,0.5L0.5,0L0,-0.5L-0.5,0Z";\n            Aa.symbolNumber = function(e3) {\n              if (Sb(e3)) e3 = +e3;\n              else if (typeof e3 == "string") {\n                var t3 = 0;\n                e3.indexOf("-open") > 0 && (t3 = 100, e3 = e3.replace("-open", "")), e3.indexOf("-dot") > 0 && (t3 += 200, e3 = e3.replace("-dot", "")), e3 = Aa.symbolNames.indexOf(e3), e3 >= 0 && (e3 += t3);\n              }\n              return e3 % 100 >= Xot || e3 >= 400 ? 0 : Math.floor(Math.max(e3, 0));\n            };\n            function Doe(e3, t3, r4, n4) {\n              var i3 = e3 % 100;\n              return Aa.symbolFuncs[i3](t3, r4, n4) + (e3 >= 200 ? Zot : "");\n            }\n            var Aoe = zot("~f"), Foe = { radial: { type: "radial" }, radialreversed: { type: "radial", reversed: true }, horizontal: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 } }, horizontalreversed: { type: "linear", start: { x: 1, y: 0 }, stop: { x: 0, y: 0 }, reversed: true }, vertical: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 } }, verticalreversed: { type: "linear", start: { x: 0, y: 1 }, stop: { x: 0, y: 0 }, reversed: true } };\n            Aa.gradient = function(e3, t3, r4, n4, i3, a4) {\n              var o4 = Foe[n4];\n              return zoe(e3, t3, r4, o4.type, i3, a4, o4.start, o4.stop, false, o4.reversed);\n            };\n            function zoe(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4) {\n              var c5 = i3.length, f4;\n              n4 === "linear" ? f4 = { node: "linearGradient", attrs: { x1: o4.x, y1: o4.y, x2: s3.x, y2: s3.y, gradientUnits: l3 ? "userSpaceOnUse" : "objectBoundingBox" }, reversed: u4 } : n4 === "radial" && (f4 = { node: "radialGradient", reversed: u4 });\n              for (var h3 = new Array(c5), d3 = 0; d3 < c5; d3++) f4.reversed ? h3[c5 - 1 - d3] = [Aoe((1 - i3[d3][0]) * 100), i3[d3][1]] : h3[d3] = [Aoe(i3[d3][0] * 100), i3[d3][1]];\n              var v3 = t3._fullLayout, _2 = "g" + v3._uid + "-" + r4, b = v3._defs.select(".gradients").selectAll("#" + _2).data([n4 + h3.join(";")], Du.identity);\n              b.exit().remove(), b.enter().append(f4.node).each(function() {\n                var p3 = dd.select(this);\n                f4.attrs && p3.attr(f4.attrs), p3.attr("id", _2);\n                var k4 = p3.selectAll("stop").data(h3);\n                k4.exit().remove(), k4.enter().append("stop"), k4.each(function(E3) {\n                  var S2 = Hq(E3[1]);\n                  dd.select(this).attr({ offset: E3[0] + "%", "stop-color": Kd.tinyRGB(S2), "stop-opacity": S2.getAlpha() });\n                });\n              }), e3.style(a4, jq(_2, t3)).style(a4 + "-opacity", null), e3.classed("gradient_filled", true);\n            }\n            Aa.pattern = function(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4, c5, f4) {\n              var h3 = t3 === "legend";\n              s3 && (l3 === "overlay" ? (u4 = s3, c5 = Kd.contrast(u4)) : (u4 = void 0, c5 = s3));\n              var d3 = r4._fullLayout, v3 = "p" + d3._uid + "-" + n4, _2, b, p3 = function(O3, V2, G2, Z, j3) {\n                return Z + (j3 - Z) * (O3 - V2) / (G2 - V2);\n              }, k4, E3, S2, L5, x2 = {}, C5 = Hq(c5), M4 = Kd.tinyRGB(C5), g3 = C5.getAlpha(), P3 = f4 * g3;\n              switch (i3) {\n                case "/":\n                  _2 = a4 * Math.sqrt(2), b = a4 * Math.sqrt(2), k4 = "M-" + _2 / 4 + "," + b / 4 + "l" + _2 / 2 + ",-" + b / 2 + "M0," + b + "L" + _2 + ",0M" + _2 / 4 * 3 + "," + b / 4 * 5 + "l" + _2 / 2 + ",-" + b / 2, E3 = o4 * a4, L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case "\\\\":\n                  _2 = a4 * Math.sqrt(2), b = a4 * Math.sqrt(2), k4 = "M" + _2 / 4 * 3 + ",-" + b / 4 + "l" + _2 / 2 + "," + b / 2 + "M0,0L" + _2 + "," + b + "M-" + _2 / 4 + "," + b / 4 * 3 + "l" + _2 / 2 + "," + b / 2, E3 = o4 * a4, L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case "x":\n                  _2 = a4 * Math.sqrt(2), b = a4 * Math.sqrt(2), k4 = "M-" + _2 / 4 + "," + b / 4 + "l" + _2 / 2 + ",-" + b / 2 + "M0," + b + "L" + _2 + ",0M" + _2 / 4 * 3 + "," + b / 4 * 5 + "l" + _2 / 2 + ",-" + b / 2 + "M" + _2 / 4 * 3 + ",-" + b / 4 + "l" + _2 / 2 + "," + b / 2 + "M0,0L" + _2 + "," + b + "M-" + _2 / 4 + "," + b / 4 * 3 + "l" + _2 / 2 + "," + b / 2, E3 = a4 - a4 * Math.sqrt(1 - o4), L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case "|":\n                  _2 = a4, b = a4, L5 = "path", k4 = "M" + _2 / 2 + ",0L" + _2 / 2 + "," + b, E3 = o4 * a4, L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case "-":\n                  _2 = a4, b = a4, L5 = "path", k4 = "M0," + b / 2 + "L" + _2 + "," + b / 2, E3 = o4 * a4, L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case "+":\n                  _2 = a4, b = a4, L5 = "path", k4 = "M" + _2 / 2 + ",0L" + _2 / 2 + "," + b + "M0," + b / 2 + "L" + _2 + "," + b / 2, E3 = a4 - a4 * Math.sqrt(1 - o4), L5 = "path", x2 = { d: k4, opacity: P3, stroke: M4, "stroke-width": E3 + "px" };\n                  break;\n                case ".":\n                  _2 = a4, b = a4, o4 < Math.PI / 4 ? S2 = Math.sqrt(o4 * a4 * a4 / Math.PI) : S2 = p3(o4, Math.PI / 4, 1, a4 / 2, a4 / Math.sqrt(2)), L5 = "circle", x2 = { cx: _2 / 2, cy: b / 2, r: S2, opacity: P3, fill: M4 };\n                  break;\n                default:\n                  _2 = a4, b = a4, L5 = "path", x2 = { d: i3, opacity: P3, fill: M4 };\n                  break;\n              }\n              var T3 = [i3 || "noSh", u4 || "noBg", c5 || "noFg", a4, o4].join(";"), z3 = d3._defs.select(".patterns").selectAll("#" + v3).data([T3], Du.identity);\n              z3.exit().remove(), z3.enter().append("pattern").each(function() {\n                var O3 = dd.select(this);\n                if (O3.attr({ id: v3, width: _2 + "px", height: b + "px", patternUnits: "userSpaceOnUse", patternTransform: h3 ? "scale(0.8)" : "" }), u4) {\n                  var V2 = Hq(u4), G2 = Kd.tinyRGB(V2), Z = V2.getAlpha(), j3 = O3.selectAll("rect").data([0]);\n                  j3.exit().remove(), j3.enter().append("rect").attr({ width: _2 + "px", height: b + "px", fill: G2, "fill-opacity": Z });\n                }\n                var N2 = O3.selectAll(L5).data([0]);\n                N2.exit().remove(), N2.enter().append(L5).attr(x2);\n              }), e3.style("fill", jq(v3, r4)).style("fill-opacity", null), e3.classed("pattern_filled", true);\n            };\n            Aa.initGradients = function(e3) {\n              var t3 = e3._fullLayout, r4 = Du.ensureSingle(t3._defs, "g", "gradients");\n              r4.selectAll("linearGradient,radialGradient").remove(), dd.select(e3).selectAll(".gradient_filled").classed("gradient_filled", false);\n            };\n            Aa.initPatterns = function(e3) {\n              var t3 = e3._fullLayout, r4 = Du.ensureSingle(t3._defs, "g", "patterns");\n              r4.selectAll("pattern").remove(), dd.select(e3).selectAll(".pattern_filled").classed("pattern_filled", false);\n            };\n            Aa.getPatternAttr = function(e3, t3, r4) {\n              return e3 && Du.isArrayOrTypedArray(e3) ? t3 < e3.length ? e3[t3] : r4 : e3;\n            };\n            Aa.pointStyle = function(e3, t3, r4, n4) {\n              if (e3.size()) {\n                var i3 = Aa.makePointStyleFns(t3);\n                e3.each(function(a4) {\n                  Aa.singlePointStyle(a4, dd.select(this), t3, i3, r4, n4);\n                });\n              }\n            };\n            Aa.singlePointStyle = function(e3, t3, r4, n4, i3, a4) {\n              var o4 = r4.marker, s3 = o4.line;\n              if (a4 && a4.i >= 0 && e3.i === void 0 && (e3.i = a4.i), t3.style("opacity", n4.selectedOpacityFn ? n4.selectedOpacityFn(e3) : e3.mo === void 0 ? o4.opacity : e3.mo), n4.ms2mrc) {\n                var l3;\n                e3.ms === "various" || o4.size === "various" ? l3 = 3 : l3 = n4.ms2mrc(e3.ms), e3.mrc = l3, n4.selectedSizeFn && (l3 = e3.mrc = n4.selectedSizeFn(e3));\n                var u4 = Aa.symbolNumber(e3.mx || o4.symbol) || 0;\n                e3.om = u4 % 200 >= 100;\n                var c5 = Xq(e3, r4), f4 = Wq(e3, r4);\n                t3.attr("d", Doe(u4, l3, c5, f4));\n              }\n              var h3 = false, d3, v3, _2;\n              if (e3.so) _2 = s3.outlierwidth, v3 = s3.outliercolor, d3 = o4.outliercolor;\n              else {\n                var b = (s3 || {}).width;\n                _2 = (e3.mlw + 1 || b + 1 || (e3.trace ? (e3.trace.marker.line || {}).width : 0) + 1) - 1 || 0, "mlc" in e3 ? v3 = e3.mlcc = n4.lineScale(e3.mlc) : Du.isArrayOrTypedArray(s3.color) ? v3 = Kd.defaultLine : v3 = s3.color, Du.isArrayOrTypedArray(o4.color) && (d3 = Kd.defaultLine, h3 = true), "mc" in e3 ? d3 = e3.mcc = n4.markerScale(e3.mc) : d3 = o4.color || o4.colors || "rgba(0,0,0,0)", n4.selectedColorFn && (d3 = n4.selectedColorFn(e3));\n              }\n              if (e3.om) t3.call(Kd.stroke, d3).style({ "stroke-width": (_2 || 1) + "px", fill: "none" });\n              else {\n                t3.style("stroke-width", (e3.isBlank ? 0 : _2) + "px");\n                var p3 = o4.gradient, k4 = e3.mgt;\n                k4 ? h3 = true : k4 = p3 && p3.type, Du.isArrayOrTypedArray(k4) && (k4 = k4[0], Foe[k4] || (k4 = 0));\n                var E3 = o4.pattern, S2 = Aa.getPatternAttr, L5 = E3 && (S2(E3.shape, e3.i, "") || S2(E3.path, e3.i, ""));\n                if (k4 && k4 !== "none") {\n                  var x2 = e3.mgc;\n                  x2 ? h3 = true : x2 = p3.color;\n                  var C5 = r4.uid;\n                  h3 && (C5 += "-" + e3.i), Aa.gradient(t3, i3, C5, k4, [[0, x2], [1, d3]], "fill");\n                } else if (L5) {\n                  var M4 = false, g3 = E3.fgcolor;\n                  !g3 && a4 && a4.color && (g3 = a4.color, M4 = true);\n                  var P3 = S2(g3, e3.i, a4 && a4.color || null), T3 = S2(E3.bgcolor, e3.i, null), z3 = E3.fgopacity, O3 = S2(E3.size, e3.i, 8), V2 = S2(E3.solidity, e3.i, 0.3);\n                  M4 = M4 || e3.mcc || Du.isArrayOrTypedArray(E3.shape) || Du.isArrayOrTypedArray(E3.path) || Du.isArrayOrTypedArray(E3.bgcolor) || Du.isArrayOrTypedArray(E3.fgcolor) || Du.isArrayOrTypedArray(E3.size) || Du.isArrayOrTypedArray(E3.solidity);\n                  var G2 = r4.uid;\n                  M4 && (G2 += "-" + e3.i), Aa.pattern(t3, "point", i3, G2, L5, O3, V2, e3.mcc, E3.fillmode, T3, P3, z3);\n                } else Du.isArrayOrTypedArray(d3) ? Kd.fill(t3, d3[e3.i]) : Kd.fill(t3, d3);\n                _2 && Kd.stroke(t3, v3);\n              }\n            };\n            Aa.makePointStyleFns = function(e3) {\n              var t3 = {}, r4 = e3.marker;\n              return t3.markerScale = Aa.tryColorscale(r4, ""), t3.lineScale = Aa.tryColorscale(r4, "line"), sL.traceIs(e3, "symbols") && (t3.ms2mrc = Uot.isBubble(e3) ? Vot(e3) : function() {\n                return (r4.size || 6) / 2;\n              }), e3.selectedpoints && Du.extendFlat(t3, Aa.makeSelectedPointStyleFns(e3)), t3;\n            };\n            Aa.makeSelectedPointStyleFns = function(e3) {\n              var t3 = {}, r4 = e3.selected || {}, n4 = e3.unselected || {}, i3 = e3.marker || {}, a4 = r4.marker || {}, o4 = n4.marker || {}, s3 = i3.opacity, l3 = a4.opacity, u4 = o4.opacity, c5 = l3 !== void 0, f4 = u4 !== void 0;\n              (Du.isArrayOrTypedArray(s3) || c5 || f4) && (t3.selectedOpacityFn = function(S2) {\n                var L5 = S2.mo === void 0 ? i3.opacity : S2.mo;\n                return S2.selected ? c5 ? l3 : L5 : f4 ? u4 : Ioe * L5;\n              });\n              var h3 = i3.color, d3 = a4.color, v3 = o4.color;\n              (d3 || v3) && (t3.selectedColorFn = function(S2) {\n                var L5 = S2.mcc || h3;\n                return S2.selected ? d3 || L5 : v3 || L5;\n              });\n              var _2 = i3.size, b = a4.size, p3 = o4.size, k4 = b !== void 0, E3 = p3 !== void 0;\n              return sL.traceIs(e3, "symbols") && (k4 || E3) && (t3.selectedSizeFn = function(S2) {\n                var L5 = S2.mrc || _2 / 2;\n                return S2.selected ? k4 ? b / 2 : L5 : E3 ? p3 / 2 : L5;\n              }), t3;\n            };\n            Aa.makeSelectedTextStyleFns = function(e3) {\n              var t3 = {}, r4 = e3.selected || {}, n4 = e3.unselected || {}, i3 = e3.textfont || {}, a4 = r4.textfont || {}, o4 = n4.textfont || {}, s3 = i3.color, l3 = a4.color, u4 = o4.color;\n              return t3.selectedTextColorFn = function(c5) {\n                var f4 = c5.tc || s3;\n                return c5.selected ? l3 || f4 : u4 || (l3 ? f4 : Kd.addOpacity(f4, Ioe));\n              }, t3;\n            };\n            Aa.selectedPointStyle = function(e3, t3) {\n              if (!(!e3.size() || !t3.selectedpoints)) {\n                var r4 = Aa.makeSelectedPointStyleFns(t3), n4 = t3.marker || {}, i3 = [];\n                r4.selectedOpacityFn && i3.push(function(a4, o4) {\n                  a4.style("opacity", r4.selectedOpacityFn(o4));\n                }), r4.selectedColorFn && i3.push(function(a4, o4) {\n                  Kd.fill(a4, r4.selectedColorFn(o4));\n                }), r4.selectedSizeFn && i3.push(function(a4, o4) {\n                  var s3 = o4.mx || n4.symbol || 0, l3 = r4.selectedSizeFn(o4);\n                  a4.attr("d", Doe(Aa.symbolNumber(s3), l3, Xq(o4, t3), Wq(o4, t3))), o4.mrc2 = l3;\n                }), i3.length && e3.each(function(a4) {\n                  for (var o4 = dd.select(this), s3 = 0; s3 < i3.length; s3++) i3[s3](o4, a4);\n                });\n              }\n            };\n            Aa.tryColorscale = function(e3, t3) {\n              var r4 = t3 ? Du.nestedProperty(e3, t3).get() : e3;\n              if (r4) {\n                var n4 = r4.color;\n                if ((r4.colorscale || r4._colorAx) && Du.isArrayOrTypedArray(n4)) return Oot.makeColorScaleFuncFromTrace(r4);\n              }\n              return Du.identity;\n            };\n            var Nq = { start: 1, end: -1, middle: 0, bottom: 1, top: -1 };\n            function Ooe(e3, t3, r4, n4, i3) {\n              var a4 = dd.select(e3.node().parentNode), o4 = t3.indexOf("top") !== -1 ? "top" : t3.indexOf("bottom") !== -1 ? "bottom" : "middle", s3 = t3.indexOf("left") !== -1 ? "end" : t3.indexOf("right") !== -1 ? "start" : "middle", l3 = n4 ? n4 / 0.8 + 1 : 0, u4 = (lL.lineCount(e3) - 1) * Not + 1, c5 = Nq[s3] * l3, f4 = r4 * 0.75 + Nq[o4] * l3 + (Nq[o4] - 1) * u4 * r4 / 2;\n              e3.attr("text-anchor", s3), i3 || a4.attr("transform", rM(c5, f4));\n            }\n            function qoe(e3, t3) {\n              var r4 = e3.ts || t3.textfont.size;\n              return Sb(r4) && r4 > 0 ? r4 : 0;\n            }\n            Aa.textPointStyle = function(e3, t3, r4) {\n              if (e3.size()) {\n                var n4;\n                if (t3.selectedpoints) {\n                  var i3 = Aa.makeSelectedTextStyleFns(t3);\n                  n4 = i3.selectedTextColorFn;\n                }\n                var a4 = t3.texttemplate, o4 = r4._fullLayout;\n                e3.each(function(s3) {\n                  var l3 = dd.select(this), u4 = a4 ? Du.extractOption(s3, t3, "txt", "texttemplate") : Du.extractOption(s3, t3, "tx", "text");\n                  if (!u4 && u4 !== 0) {\n                    l3.remove();\n                    return;\n                  }\n                  if (a4) {\n                    var c5 = t3._module.formatLabels, f4 = c5 ? c5(s3, t3, o4) : {}, h3 = {};\n                    Got(h3, t3, s3.i), u4 = Du.texttemplateString({ data: [h3, s3, t3._meta], fallback: t3.texttemplatefallback, labels: f4, locale: o4._d3locale, template: u4 });\n                  }\n                  var d3 = s3.tp || t3.textposition, v3 = qoe(s3, t3), _2 = n4 ? n4(s3) : s3.tc || t3.textfont.color;\n                  l3.call(Aa.font, { family: s3.tf || t3.textfont.family, weight: s3.tw || t3.textfont.weight, style: s3.ty || t3.textfont.style, variant: s3.tv || t3.textfont.variant, textcase: s3.tC || t3.textfont.textcase, lineposition: s3.tE || t3.textfont.lineposition, shadow: s3.tS || t3.textfont.shadow, size: v3, color: _2 }).text(u4).call(lL.convertToTspans, r4).call(Ooe, d3, v3, s3.mrc);\n                });\n              }\n            };\n            Aa.selectedTextStyle = function(e3, t3) {\n              if (!(!e3.size() || !t3.selectedpoints)) {\n                var r4 = Aa.makeSelectedTextStyleFns(t3);\n                e3.each(function(n4) {\n                  var i3 = dd.select(this), a4 = r4.selectedTextColorFn(n4), o4 = n4.tp || t3.textposition, s3 = qoe(n4, t3);\n                  Kd.fill(i3, a4);\n                  var l3 = sL.traceIs(t3, "bar-like");\n                  Ooe(i3, o4, s3, n4.mrc2 || n4.mrc, l3);\n                });\n              }\n            };\n            var Soe = 0.5;\n            Aa.smoothopen = function(e3, t3) {\n              if (e3.length < 3) return "M" + e3.join("L");\n              var r4 = "M" + e3[0], n4 = [], i3;\n              for (i3 = 1; i3 < e3.length - 1; i3++) n4.push(oL(e3[i3 - 1], e3[i3], e3[i3 + 1], t3));\n              for (r4 += "Q" + n4[0][0] + " " + e3[1], i3 = 2; i3 < e3.length - 1; i3++) r4 += "C" + n4[i3 - 2][1] + " " + n4[i3 - 1][0] + " " + e3[i3];\n              return r4 += "Q" + n4[e3.length - 3][1] + " " + e3[e3.length - 1], r4;\n            };\n            Aa.smoothclosed = function(e3, t3) {\n              if (e3.length < 3) return "M" + e3.join("L") + "Z";\n              var r4 = "M" + e3[0], n4 = e3.length - 1, i3 = [oL(e3[n4], e3[0], e3[1], t3)], a4;\n              for (a4 = 1; a4 < n4; a4++) i3.push(oL(e3[a4 - 1], e3[a4], e3[a4 + 1], t3));\n              for (i3.push(oL(e3[n4 - 1], e3[n4], e3[0], t3)), a4 = 1; a4 <= n4; a4++) r4 += "C" + i3[a4 - 1][1] + " " + i3[a4][0] + " " + e3[a4];\n              return r4 += "C" + i3[n4][1] + " " + i3[0][0] + " " + e3[0] + "Z", r4;\n            };\n            var Boe, Noe;\n            function C3(e3, t3, r4) {\n              return r4 && (e3 = Uoe(e3)), t3 ? Ab(e3[1]) : Tb(e3[0]);\n            }\n            function Tb(e3) {\n              var t3 = dd.round(e3, 2);\n              return Boe = t3, t3;\n            }\n            function Ab(e3) {\n              var t3 = dd.round(e3, 2);\n              return Noe = t3, t3;\n            }\n            function oL(e3, t3, r4, n4) {\n              var i3 = e3[0] - t3[0], a4 = e3[1] - t3[1], o4 = r4[0] - t3[0], s3 = r4[1] - t3[1], l3 = Math.pow(i3 * i3 + a4 * a4, Soe / 2), u4 = Math.pow(o4 * o4 + s3 * s3, Soe / 2), c5 = (u4 * u4 * i3 - l3 * l3 * o4) * n4, f4 = (u4 * u4 * a4 - l3 * l3 * s3) * n4, h3 = 3 * u4 * (l3 + u4), d3 = 3 * l3 * (l3 + u4);\n              return [[Tb(t3[0] + (h3 && c5 / h3)), Ab(t3[1] + (h3 && f4 / h3))], [Tb(t3[0] - (d3 && c5 / d3)), Ab(t3[1] - (d3 && f4 / d3))]];\n            }\n            var Yot = { hv: function(e3, t3, r4) {\n              return "H" + Tb(t3[0]) + "V" + C3(t3, 1, r4);\n            }, vh: function(e3, t3, r4) {\n              return "V" + Ab(t3[1]) + "H" + C3(t3, 0, r4);\n            }, hvh: function(e3, t3, r4) {\n              return "H" + Tb((e3[0] + t3[0]) / 2) + "V" + Ab(t3[1]) + "H" + C3(t3, 0, r4);\n            }, vhv: function(e3, t3, r4) {\n              return "V" + Ab((e3[1] + t3[1]) / 2) + "H" + Tb(t3[0]) + "V" + C3(t3, 1, r4);\n            } }, Kot = function(e3, t3, r4) {\n              return "L" + C3(t3, 0, r4) + "," + C3(t3, 1, r4);\n            };\n            Aa.steps = function(e3) {\n              var t3 = Yot[e3] || Kot;\n              return function(r4) {\n                for (var n4 = "M" + Tb(r4[0][0]) + "," + Ab(r4[0][1]), i3 = r4.length, a4 = 1; a4 < i3; a4++) n4 += t3(r4[a4 - 1], r4[a4], a4 === i3 - 1);\n                return n4;\n              };\n            };\n            function Uoe(e3, t3) {\n              var r4 = e3.backoff, n4 = e3.trace, i3 = e3.d, a4 = e3.i;\n              if (r4 && n4 && n4.marker && n4.marker.angle % 360 === 0 && n4.line && n4.line.shape !== "spline") {\n                var o4 = Du.isArrayOrTypedArray(r4), s3 = e3, l3 = t3 ? t3[0] : Boe || 0, u4 = t3 ? t3[1] : Noe || 0, c5 = s3[0], f4 = s3[1], h3 = c5 - l3, d3 = f4 - u4, v3 = Math.atan2(d3, h3), _2 = o4 ? r4[a4] : r4;\n                if (_2 === "auto") {\n                  var b = s3.i;\n                  n4.type === "scatter" && b--;\n                  var p3 = s3.marker, k4 = p3.symbol;\n                  Du.isArrayOrTypedArray(k4) && (k4 = k4[b]);\n                  var E3 = p3.size;\n                  Du.isArrayOrTypedArray(E3) && (E3 = E3[b]), _2 = p3 ? Aa.symbolBackOffs[Aa.symbolNumber(k4)] * E3 : 0, _2 += Aa.getMarkerStandoff(i3[b], n4) || 0;\n                }\n                var S2 = c5 - _2 * Math.cos(v3), L5 = f4 - _2 * Math.sin(v3);\n                (S2 <= c5 && S2 >= l3 || S2 >= c5 && S2 <= l3) && (L5 <= f4 && L5 >= u4 || L5 >= f4 && L5 <= u4) && (e3 = [S2, L5]);\n              }\n              return e3;\n            }\n            Aa.applyBackoff = Uoe;\n            Aa.makeTester = function() {\n              var e3 = Du.ensureSingleById(dd.select("body"), "svg", "js-plotly-tester", function(r4) {\n                r4.attr(qot.svgAttrs).style({ position: "absolute", left: "-10000px", top: "-10000px", width: "9000px", height: "9000px", "z-index": "1" });\n              }), t3 = Du.ensureSingle(e3, "path", "js-reference-point", function(r4) {\n                r4.attr("d", "M0,0H1V1H0Z").style({ "stroke-width": 0, fill: "black" });\n              });\n              Aa.tester = e3, Aa.testref = t3;\n            };\n            Aa.savedBBoxes = {};\n            var Uq = 0, Jot = 1e4;\n            Aa.bBox = function(e3, t3, r4) {\n              r4 || (r4 = Moe(e3));\n              var n4;\n              if (r4) {\n                if (n4 = Aa.savedBBoxes[r4], n4) return Du.extendFlat({}, n4);\n              } else if (e3.childNodes.length === 1) {\n                var i3 = e3.childNodes[0];\n                if (r4 = Moe(i3), r4) {\n                  var a4 = +i3.getAttribute("x") || 0, o4 = +i3.getAttribute("y") || 0, s3 = i3.getAttribute("transform");\n                  if (!s3) {\n                    var l3 = Aa.bBox(i3, false, r4);\n                    return a4 && (l3.left += a4, l3.right += a4), o4 && (l3.top += o4, l3.bottom += o4), l3;\n                  }\n                  if (r4 += "~" + a4 + "~" + o4 + "~" + s3, n4 = Aa.savedBBoxes[r4], n4) return Du.extendFlat({}, n4);\n                }\n              }\n              var u4, c5;\n              t3 ? u4 = e3 : (c5 = Aa.tester.node(), u4 = e3.cloneNode(true), c5.appendChild(u4)), dd.select(u4).attr("transform", null).call(lL.positionText, 0, 0);\n              var f4 = u4.getBoundingClientRect(), h3 = Aa.testref.node().getBoundingClientRect();\n              t3 || c5.removeChild(u4);\n              var d3 = { height: f4.height, width: f4.width, left: f4.left - h3.left, top: f4.top - h3.top, right: f4.right - h3.left, bottom: f4.bottom - h3.top };\n              return Uq >= Jot && (Aa.savedBBoxes = {}, Uq = 0), r4 && (Aa.savedBBoxes[r4] = d3), Uq++, Du.extendFlat({}, d3);\n            };\n            function Moe(e3) {\n              var t3 = e3.getAttribute("data-unformatted");\n              if (t3 !== null) return t3 + e3.getAttribute("data-math") + e3.getAttribute("text-anchor") + e3.getAttribute("style");\n            }\n            Aa.setClipUrl = function(e3, t3, r4) {\n              e3.attr("clip-path", jq(t3, r4));\n            };\n            function jq(e3, t3) {\n              if (!e3) return null;\n              var r4 = t3._context, n4 = r4._exportedPlot ? "" : r4._baseUrl || "";\n              return n4 ? "url(\'" + n4 + "#" + e3 + "\')" : "url(#" + e3 + ")";\n            }\n            Aa.getTranslate = function(e3) {\n              var t3 = /.*\\btranslate\\((-?\\d*\\.?\\d*)[^-\\d]*(-?\\d*\\.?\\d*)[^\\d].*/, r4 = e3.attr ? "attr" : "getAttribute", n4 = e3[r4]("transform") || "", i3 = n4.replace(t3, function(a4, o4, s3) {\n                return [o4, s3].join(" ");\n              }).split(" ");\n              return { x: +i3[0] || 0, y: +i3[1] || 0 };\n            };\n            Aa.setTranslate = function(e3, t3, r4) {\n              var n4 = /(\\btranslate\\(.*?\\);?)/, i3 = e3.attr ? "attr" : "getAttribute", a4 = e3.attr ? "attr" : "setAttribute", o4 = e3[i3]("transform") || "";\n              return t3 = t3 || 0, r4 = r4 || 0, o4 = o4.replace(n4, "").trim(), o4 += rM(t3, r4), o4 = o4.trim(), e3[a4]("transform", o4), o4;\n            };\n            Aa.getScale = function(e3) {\n              var t3 = /.*\\bscale\\((\\d*\\.?\\d*)[^\\d]*(\\d*\\.?\\d*)[^\\d].*/, r4 = e3.attr ? "attr" : "getAttribute", n4 = e3[r4]("transform") || "", i3 = n4.replace(t3, function(a4, o4, s3) {\n                return [o4, s3].join(" ");\n              }).split(" ");\n              return { x: +i3[0] || 1, y: +i3[1] || 1 };\n            };\n            Aa.setScale = function(e3, t3, r4) {\n              var n4 = /(\\bscale\\(.*?\\);?)/, i3 = e3.attr ? "attr" : "getAttribute", a4 = e3.attr ? "attr" : "setAttribute", o4 = e3[i3]("transform") || "";\n              return t3 = t3 || 1, r4 = r4 || 1, o4 = o4.replace(n4, "").trim(), o4 += "scale(" + t3 + "," + r4 + ")", o4 = o4.trim(), e3[a4]("transform", o4), o4;\n            };\n            var $ot = /\\s*sc.*/;\n            Aa.setPointGroupScale = function(e3, t3, r4) {\n              if (t3 = t3 || 1, r4 = r4 || 1, !!e3) {\n                var n4 = t3 === 1 && r4 === 1 ? "" : "scale(" + t3 + "," + r4 + ")";\n                e3.each(function() {\n                  var i3 = (this.getAttribute("transform") || "").replace($ot, "");\n                  i3 += n4, i3 = i3.trim(), this.setAttribute("transform", i3);\n                });\n              }\n            };\n            var Qot = /translate\\([^)]*\\)\\s*$/;\n            Aa.setTextPointsScale = function(e3, t3, r4) {\n              e3 && e3.each(function() {\n                var n4, i3 = dd.select(this), a4 = i3.select("text");\n                if (a4.node()) {\n                  var o4 = parseFloat(a4.attr("x") || 0), s3 = parseFloat(a4.attr("y") || 0), l3 = (i3.attr("transform") || "").match(Qot);\n                  t3 === 1 && r4 === 1 ? n4 = [] : n4 = [rM(o4, s3), "scale(" + t3 + "," + r4 + ")", rM(-o4, -s3)], l3 && n4.push(l3), i3.attr("transform", n4.join(""));\n                }\n              });\n            };\n            function Wq(e3, t3) {\n              var r4;\n              return e3 && (r4 = e3.mf), r4 === void 0 && (r4 = t3.marker && t3.marker.standoff || 0), !t3._geo && !t3._xA ? -r4 : r4;\n            }\n            Aa.getMarkerStandoff = Wq;\n            var tM = Math.atan2, wb = Math.cos, L3 = Math.sin;\n            function Eoe(e3, t3) {\n              var r4 = t3[0], n4 = t3[1];\n              return [r4 * wb(e3) - n4 * L3(e3), r4 * L3(e3) + n4 * wb(e3)];\n            }\n            var koe, Coe, Loe, Poe, Vq, Gq;\n            function Xq(e3, t3) {\n              var r4 = e3.ma;\n              r4 === void 0 && (r4 = t3.marker.angle, (!r4 || Du.isArrayOrTypedArray(r4)) && (r4 = 0));\n              var n4, i3, a4 = t3.marker.angleref;\n              if (a4 === "previous" || a4 === "north") {\n                if (t3._geo) {\n                  var o4 = t3._geo.project(e3.lonlat);\n                  n4 = o4[0], i3 = o4[1];\n                } else {\n                  var s3 = t3._xA, l3 = t3._yA;\n                  if (s3 && l3) n4 = s3.c2p(e3.x), i3 = l3.c2p(e3.y);\n                  else return 90;\n                }\n                if (t3._geo) {\n                  var u4 = e3.lonlat[0], c5 = e3.lonlat[1], f4 = t3._geo.project([u4, c5 + 1e-5]), h3 = t3._geo.project([u4 + 1e-5, c5]), d3 = tM(h3[1] - i3, h3[0] - n4), v3 = tM(f4[1] - i3, f4[0] - n4), _2;\n                  if (a4 === "north") _2 = r4 / 180 * Math.PI;\n                  else if (a4 === "previous") {\n                    var b = u4 / 180 * Math.PI, p3 = c5 / 180 * Math.PI, k4 = koe / 180 * Math.PI, E3 = Coe / 180 * Math.PI, S2 = k4 - b, L5 = wb(E3) * L3(S2), x2 = L3(E3) * wb(p3) - wb(E3) * L3(p3) * wb(S2);\n                    _2 = -tM(L5, x2) - Math.PI, koe = u4, Coe = c5;\n                  }\n                  var C5 = Eoe(d3, [wb(_2), 0]), M4 = Eoe(v3, [L3(_2), 0]);\n                  r4 = tM(C5[1] + M4[1], C5[0] + M4[0]) / Math.PI * 180, a4 === "previous" && !(Gq === t3.uid && e3.i === Vq + 1) && (r4 = null);\n                }\n                if (a4 === "previous" && !t3._geo) if (Gq === t3.uid && e3.i === Vq + 1 && Sb(n4) && Sb(i3)) {\n                  var g3 = n4 - Loe, P3 = i3 - Poe, T3 = t3.line && t3.line.shape || "", z3 = T3.slice(T3.length - 1);\n                  z3 === "h" && (P3 = 0), z3 === "v" && (g3 = 0), r4 += tM(P3, g3) / Math.PI * 180 + 90;\n                } else r4 = null;\n              }\n              return Loe = n4, Poe = i3, Vq = e3.i, Gq = t3.uid, r4;\n            }\n            Aa.getMarkerAngle = Xq;\n          });\n          var Eb = ye((Vnr, Woe) => {\n            "use strict";\n            var P3 = Oa(), est = Eo(), tst = Mc(), Zq = qa(), Mb = Dr(), Goe = Mb.strTranslate, uL = So(), cL = ka(), I3 = ru(), Hoe = N1(), rst = $h().OPPOSITE_SIDE, joe = / [XY][0-9]* /, Yq = 1.6, Kq = 1.6;\n            function ist(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = r4.propContainer, a4 = r4.propName, o4 = r4.placeholder, s3 = r4.traceIndex, l3 = r4.avoid || {}, u4 = r4.attributes, c5 = r4.transform, f4 = r4.containerGroup, h3 = 1, d3 = i3.title, v3 = (d3 && d3.text ? d3.text : "").trim(), _2 = false, b = d3 && d3.font ? d3.font : {}, p3 = b.family, k4 = b.size, E3 = b.color, S2 = b.weight, L3 = b.style, x2 = b.variant, C3 = b.textcase, M4 = b.lineposition, g3 = b.shadow, P5 = r4.subtitlePropName, T3 = !!P5, z3 = r4.subtitlePlaceholder, O3 = (i3.title || {}).subtitle || { text: "", font: {} }, V2 = (O3.text || "").trim(), G2 = false, Z = 1, j3 = O3.font, N2 = j3.family, H = j3.size, te = j3.color, oe = j3.weight, _e = j3.style, Ee = j3.variant, Ce = j3.textcase, me = j3.lineposition, ie = j3.shadow, Se;\n              a4 === "title.text" ? Se = "titleText" : a4.indexOf("axis") !== -1 ? Se = "axisTitleText" : a4.indexOf("colorbar") !== -1 && (Se = "colorbarTitleText");\n              var Le = e3._context.edits[Se];\n              function Ae(Nt, Jt) {\n                return Nt === void 0 || Jt === void 0 ? false : Nt.replace(joe, " % ") === Jt.replace(joe, " % ");\n              }\n              v3 === "" ? h3 = 0 : Ae(v3, o4) && (Le || (v3 = ""), h3 = 0.2, _2 = true), T3 && (V2 === "" ? Z = 0 : Ae(V2, z3) && (Le || (V2 = ""), Z = 0.2, G2 = true)), r4._meta ? v3 = Mb.templateString(v3, r4._meta) : n4._meta && (v3 = Mb.templateString(v3, n4._meta));\n              var Fe = v3 || V2 || Le, Pe;\n              f4 || (f4 = Mb.ensureSingle(n4._infolayer, "g", "g-" + t3), Pe = n4._hColorbarMoveTitle);\n              var ge = f4.selectAll("text." + t3).data(Fe ? [0] : []);\n              ge.enter().append("text"), ge.text(v3).attr("class", t3), ge.exit().remove();\n              var Re = null, ce = t3 + "-subtitle", Ze = V2 || Le;\n              if (T3 && (Re = f4.selectAll("text." + ce).data(Ze ? [0] : []), Re.enter().append("text"), Re.text(V2).attr("class", ce), Re.exit().remove()), !Fe) return f4;\n              function ut(Nt, Jt) {\n                Mb.syncOrAsync([pt, Zt], { title: Nt, subtitle: Jt });\n              }\n              function pt(Nt) {\n                var Jt = Nt.title, sr = Nt.subtitle, wr;\n                !c5 && Pe && (c5 = {}), c5 ? (wr = "", c5.rotate && (wr += "rotate(" + [c5.rotate, u4.x, u4.y] + ")"), (c5.offset || Pe) && (wr += Goe(0, (c5.offset || 0) - (Pe || 0)))) : wr = null, Jt.attr("transform", wr);\n                function cr(It) {\n                  if (It) {\n                    var mt = P3.select(It.node().parentNode).select("." + ce);\n                    if (!mt.empty()) {\n                      var er = It.node().getBBox();\n                      if (er.height) {\n                        var lr = er.y + er.height + Yq * H;\n                        mt.attr("y", lr);\n                      }\n                    }\n                  }\n                }\n                if (Jt.style("opacity", h3 * cL.opacity(E3)).call(uL.font, { color: cL.rgb(E3), size: P3.round(k4, 2), family: p3, weight: S2, style: L3, variant: x2, textcase: C3, shadow: g3, lineposition: M4 }).attr(u4).call(I3.convertToTspans, e3, cr), sr && !sr.empty()) {\n                  var $e = f4.select("." + t3 + "-math-group"), St = Jt.node().getBBox(), Qt = $e.node() ? $e.node().getBBox() : void 0, Vt = Qt ? Qt.y + Qt.height + Yq * H : St.y + St.height + Kq * H, _t = Mb.extendFlat({}, u4, { y: Vt });\n                  sr.attr("transform", wr), sr.style("opacity", Z * cL.opacity(te)).call(uL.font, { color: cL.rgb(te), size: P3.round(H, 2), family: N2, weight: oe, style: _e, variant: Ee, textcase: Ce, shadow: ie, lineposition: me }).attr(_t).call(I3.convertToTspans, e3);\n                }\n                return tst.previousPromises(e3);\n              }\n              function Zt(Nt) {\n                var Jt = Nt.title, sr = P3.select(Jt.node().parentNode);\n                if (l3 && l3.selection && l3.side && v3) {\n                  sr.attr("transform", null);\n                  var wr = rst[l3.side], cr = l3.side === "left" || l3.side === "top" ? -1 : 1, $e = est(l3.pad) ? l3.pad : 2, St = uL.bBox(sr.node()), Qt = { t: 0, b: 0, l: 0, r: 0 }, Vt = e3._fullLayout._reservedMargin;\n                  for (var _t in Vt) for (var It in Vt[_t]) {\n                    var mt = Vt[_t][It];\n                    Qt[It] = Math.max(Qt[It], mt);\n                  }\n                  var er = { left: Qt.l, top: Qt.t, right: n4.width - Qt.r, bottom: n4.height - Qt.b }, lr = l3.maxShift || cr * (er[l3.side] - St[l3.side]), Tr = 0;\n                  if (lr < 0) Tr = lr;\n                  else {\n                    var Lr = l3.offsetLeft || 0, ti = l3.offsetTop || 0;\n                    St.left -= Lr, St.right -= Lr, St.top -= ti, St.bottom -= ti, l3.selection.each(function() {\n                      var Vr = uL.bBox(this);\n                      Mb.bBoxIntersect(St, Vr, $e) && (Tr = Math.max(Tr, cr * (Vr[l3.side] - St[wr]) + $e));\n                    }), Tr = Math.min(lr, Tr), i3._titleScoot = Math.abs(Tr);\n                  }\n                  if (Tr > 0 || lr < 0) {\n                    var Br = { left: [-Tr, 0], right: [Tr, 0], top: [0, -Tr], bottom: [0, Tr] }[l3.side];\n                    sr.attr("transform", Goe(Br[0], Br[1]));\n                  }\n                }\n              }\n              ge.call(ut, Re);\n              function st(Nt, Jt) {\n                Nt.text(Jt).on("mouseover.opacity", function() {\n                  P3.select(this).transition().duration(Hoe.SHOW_PLACEHOLDER).style("opacity", 1);\n                }).on("mouseout.opacity", function() {\n                  P3.select(this).transition().duration(Hoe.HIDE_PLACEHOLDER).style("opacity", 0);\n                });\n              }\n              if (Le && (v3 ? ge.on(".opacity", null) : (st(ge, o4), _2 = true), ge.call(I3.makeEditable, { gd: e3 }).on("edit", function(Nt) {\n                s3 !== void 0 ? Zq.call("_guiRestyle", e3, a4, Nt, s3) : Zq.call("_guiRelayout", e3, a4, Nt);\n              }).on("cancel", function() {\n                this.text(this.attr("data-unformatted")).call(ut);\n              }).on("input", function(Nt) {\n                this.text(Nt || " ").call(I3.positionText, u4.x, u4.y);\n              }), T3)) {\n                if (T3 && !v3) {\n                  var lt = ge.node().getBBox(), Gt = lt.y + lt.height + Kq * H;\n                  Re.attr("y", Gt);\n                }\n                V2 ? Re.on(".opacity", null) : (st(Re, z3), G2 = true), Re.call(I3.makeEditable, { gd: e3 }).on("edit", function(Nt) {\n                  Zq.call("_guiRelayout", e3, "title.subtitle.text", Nt);\n                }).on("cancel", function() {\n                  this.text(this.attr("data-unformatted")).call(ut);\n                }).on("input", function(Nt) {\n                  this.text(Nt || " ").call(I3.positionText, Re.attr("x"), Re.attr("y"));\n                });\n              }\n              return ge.classed("js-placeholder", _2), Re && !Re.empty() && Re.classed("js-placeholder", G2), f4;\n            }\n            Woe.exports = { draw: ist, SUBTITLE_PADDING_EM: Kq, SUBTITLE_PADDING_MATHJAX_EM: Yq };\n          });\n          var ym = ye((Gnr, Joe) => {\n            "use strict";\n            var nst = Oa(), ast = r3().utcFormat, yc = Dr(), ost = yc.numberFormat, gm = Eo(), n_ = yc.cleanNumber, sst = yc.ms2DateTime, Xoe = yc.dateTime2ms, mm = yc.ensureNumber, Zoe = yc.isArrayOrTypedArray, a_ = fs(), fL = a_.FP_SAFE, Tg = a_.BADNUM, lst = a_.LOG_CLIP, ust = a_.ONEWEEK, hL = a_.ONEDAY, dL = a_.ONEHOUR, Yoe = a_.ONEMIN, Koe = a_.ONESEC, vL = hf(), mL = hd(), pL = mL.HOUR_PATTERN, gL = mL.WEEKDAY_PATTERN;\n            function iM(e3) {\n              return Math.pow(10, e3);\n            }\n            function Jq(e3) {\n              return e3 != null;\n            }\n            Joe.exports = function(t3, r4) {\n              r4 = r4 || {};\n              var n4 = t3._id || "x", i3 = n4.charAt(0);\n              function a4(S2, L3) {\n                if (S2 > 0) return Math.log(S2) / Math.LN10;\n                if (S2 <= 0 && L3 && t3.range && t3.range.length === 2) {\n                  var x2 = t3.range[0], C3 = t3.range[1];\n                  return 0.5 * (x2 + C3 - 2 * lst * Math.abs(x2 - C3));\n                } else return Tg;\n              }\n              function o4(S2, L3, x2, C3) {\n                if ((C3 || {}).msUTC && gm(S2)) return +S2;\n                var M4 = Xoe(S2, x2 || t3.calendar);\n                if (M4 === Tg) if (gm(S2)) {\n                  S2 = +S2;\n                  var g3 = Math.floor(yc.mod(S2 + 0.05, 1) * 10), P3 = Math.round(S2 - g3 / 10);\n                  M4 = Xoe(new Date(P3)) + g3 / 10;\n                } else return Tg;\n                return M4;\n              }\n              function s3(S2, L3, x2) {\n                return sst(S2, L3, x2 || t3.calendar);\n              }\n              function l3(S2) {\n                return t3._categories[Math.round(S2)];\n              }\n              function u4(S2) {\n                if (Jq(S2)) {\n                  if (t3._categoriesMap === void 0 && (t3._categoriesMap = {}), t3._categoriesMap[S2] !== void 0) return t3._categoriesMap[S2];\n                  t3._categories.push(typeof S2 == "number" ? String(S2) : S2);\n                  var L3 = t3._categories.length - 1;\n                  return t3._categoriesMap[S2] = L3, L3;\n                }\n                return Tg;\n              }\n              function c5(S2, L3) {\n                for (var x2 = new Array(L3), C3 = 0; C3 < L3; C3++) {\n                  var M4 = (S2[0] || [])[C3], g3 = (S2[1] || [])[C3];\n                  x2[C3] = f4([M4, g3]);\n                }\n                return x2;\n              }\n              function f4(S2) {\n                if (t3._categoriesMap) return t3._categoriesMap[S2];\n              }\n              function h3(S2) {\n                var L3 = f4(S2);\n                if (L3 !== void 0) return L3;\n                if (gm(S2)) return +S2;\n              }\n              function d3(S2) {\n                return gm(S2) ? +S2 : f4(S2);\n              }\n              function v3(S2, L3, x2) {\n                return nst.round(x2 + L3 * S2, 2);\n              }\n              function _2(S2, L3, x2) {\n                return (S2 - x2) / L3;\n              }\n              var b = function(L3) {\n                return gm(L3) ? v3(L3, t3._m, t3._b) : Tg;\n              }, p3 = function(S2) {\n                return _2(S2, t3._m, t3._b);\n              };\n              if (t3.rangebreaks) {\n                var k4 = i3 === "y";\n                b = function(S2) {\n                  if (!gm(S2)) return Tg;\n                  var L3 = t3._rangebreaks.length;\n                  if (!L3) return v3(S2, t3._m, t3._b);\n                  var x2 = k4;\n                  t3.range[0] > t3.range[1] && (x2 = !x2);\n                  for (var C3 = x2 ? -1 : 1, M4 = C3 * S2, g3 = 0, P3 = 0; P3 < L3; P3++) {\n                    var T3 = C3 * t3._rangebreaks[P3].min, z3 = C3 * t3._rangebreaks[P3].max;\n                    if (M4 < T3) break;\n                    if (M4 > z3) g3 = P3 + 1;\n                    else {\n                      g3 = M4 < (T3 + z3) / 2 ? P3 : P3 + 1;\n                      break;\n                    }\n                  }\n                  var O3 = t3._B[g3] || 0;\n                  return isFinite(O3) ? v3(S2, t3._m2, O3) : 0;\n                }, p3 = function(S2) {\n                  var L3 = t3._rangebreaks.length;\n                  if (!L3) return _2(S2, t3._m, t3._b);\n                  for (var x2 = 0, C3 = 0; C3 < L3 && !(S2 < t3._rangebreaks[C3].pmin); C3++) S2 > t3._rangebreaks[C3].pmax && (x2 = C3 + 1);\n                  return _2(S2, t3._m2, t3._B[x2]);\n                };\n              }\n              t3.c2l = t3.type === "log" ? a4 : mm, t3.l2c = t3.type === "log" ? iM : mm, t3.l2p = b, t3.p2l = p3, t3.c2p = t3.type === "log" ? function(S2, L3) {\n                return b(a4(S2, L3));\n              } : b, t3.p2c = t3.type === "log" ? function(S2) {\n                return iM(p3(S2));\n              } : p3, ["linear", "-"].indexOf(t3.type) !== -1 ? (t3.d2r = t3.r2d = t3.d2c = t3.r2c = t3.d2l = t3.r2l = n_, t3.c2d = t3.c2r = t3.l2d = t3.l2r = mm, t3.d2p = t3.r2p = function(S2) {\n                return t3.l2p(n_(S2));\n              }, t3.p2d = t3.p2r = p3, t3.cleanPos = mm) : t3.type === "log" ? (t3.d2r = t3.d2l = function(S2, L3) {\n                return a4(n_(S2), L3);\n              }, t3.r2d = t3.r2c = function(S2) {\n                return iM(n_(S2));\n              }, t3.d2c = t3.r2l = n_, t3.c2d = t3.l2r = mm, t3.c2r = a4, t3.l2d = iM, t3.d2p = function(S2, L3) {\n                return t3.l2p(t3.d2r(S2, L3));\n              }, t3.p2d = function(S2) {\n                return iM(p3(S2));\n              }, t3.r2p = function(S2) {\n                return t3.l2p(n_(S2));\n              }, t3.p2r = p3, t3.cleanPos = mm) : t3.type === "date" ? (t3.d2r = t3.r2d = yc.identity, t3.d2c = t3.r2c = t3.d2l = t3.r2l = o4, t3.c2d = t3.c2r = t3.l2d = t3.l2r = s3, t3.d2p = t3.r2p = function(S2, L3, x2) {\n                return t3.l2p(o4(S2, 0, x2));\n              }, t3.p2d = t3.p2r = function(S2, L3, x2) {\n                return s3(p3(S2), L3, x2);\n              }, t3.cleanPos = function(S2) {\n                return yc.cleanDate(S2, Tg, t3.calendar);\n              }) : t3.type === "category" ? (t3.d2c = t3.d2l = u4, t3.r2d = t3.c2d = t3.l2d = l3, t3.d2r = t3.d2l_noadd = h3, t3.r2c = function(S2) {\n                var L3 = d3(S2);\n                return L3 !== void 0 ? L3 : t3.fraction2r(0.5);\n              }, t3.l2r = t3.c2r = mm, t3.r2l = d3, t3.d2p = function(S2) {\n                return t3.l2p(t3.r2c(S2));\n              }, t3.p2d = function(S2) {\n                return l3(p3(S2));\n              }, t3.r2p = t3.d2p, t3.p2r = p3, t3.cleanPos = function(S2) {\n                return typeof S2 == "string" && S2 !== "" ? S2 : mm(S2);\n              }) : t3.type === "multicategory" && (t3.r2d = t3.c2d = t3.l2d = l3, t3.d2r = t3.d2l_noadd = h3, t3.r2c = function(S2) {\n                var L3 = h3(S2);\n                return L3 !== void 0 ? L3 : t3.fraction2r(0.5);\n              }, t3.r2c_just_indices = f4, t3.l2r = t3.c2r = mm, t3.r2l = h3, t3.d2p = function(S2) {\n                return t3.l2p(t3.r2c(S2));\n              }, t3.p2d = function(S2) {\n                return l3(p3(S2));\n              }, t3.r2p = t3.d2p, t3.p2r = p3, t3.cleanPos = function(S2) {\n                return Array.isArray(S2) || typeof S2 == "string" && S2 !== "" ? S2 : mm(S2);\n              }, t3.setupMultiCategory = function(S2) {\n                var L3 = t3._traceIndices, x2, C3, M4 = t3._matchGroup;\n                if (M4 && t3._categories.length === 0) {\n                  for (var g3 in M4) if (g3 !== n4) {\n                    var P3 = r4[vL.id2name(g3)];\n                    L3 = L3.concat(P3._traceIndices);\n                  }\n                }\n                var T3 = [[0, {}], [0, {}]], z3 = [];\n                for (x2 = 0; x2 < L3.length; x2++) {\n                  var O3 = S2[L3[x2]];\n                  if (i3 in O3) {\n                    var V2 = O3[i3], G2 = O3._length || yc.minRowLength(V2);\n                    if (Zoe(V2[0]) && Zoe(V2[1])) for (C3 = 0; C3 < G2; C3++) {\n                      var Z = V2[0][C3], j3 = V2[1][C3];\n                      Jq(Z) && Jq(j3) && (z3.push([Z, j3]), Z in T3[0][1] || (T3[0][1][Z] = T3[0][0]++), j3 in T3[1][1] || (T3[1][1][j3] = T3[1][0]++));\n                    }\n                  }\n                }\n                for (z3.sort(function(N2, H) {\n                  var te = T3[0][1], oe = te[N2[0]] - te[H[0]];\n                  if (oe) return oe;\n                  var _e = T3[1][1];\n                  return _e[N2[1]] - _e[H[1]];\n                }), x2 = 0; x2 < z3.length; x2++) u4(z3[x2]);\n              }), t3.fraction2r = function(S2) {\n                var L3 = t3.r2l(t3.range[0]), x2 = t3.r2l(t3.range[1]);\n                return t3.l2r(L3 + S2 * (x2 - L3));\n              }, t3.r2fraction = function(S2) {\n                var L3 = t3.r2l(t3.range[0]), x2 = t3.r2l(t3.range[1]);\n                return (t3.r2l(S2) - L3) / (x2 - L3);\n              }, t3.limitRange = function(S2) {\n                var L3 = t3.minallowed, x2 = t3.maxallowed;\n                if (!(L3 === void 0 && x2 === void 0)) {\n                  S2 || (S2 = "range");\n                  var C3 = yc.nestedProperty(t3, S2).get(), M4 = yc.simpleMap(C3, t3.r2l), g3 = M4[1] < M4[0];\n                  g3 && M4.reverse();\n                  var P3 = yc.simpleMap([L3, x2], t3.r2l);\n                  if (L3 !== void 0 && M4[0] < P3[0] && (C3[g3 ? 1 : 0] = L3), x2 !== void 0 && M4[1] > P3[1] && (C3[g3 ? 0 : 1] = x2), C3[0] === C3[1]) {\n                    var T3 = t3.l2r(L3), z3 = t3.l2r(x2);\n                    if (L3 !== void 0) {\n                      var O3 = T3 + 1;\n                      x2 !== void 0 && (O3 = Math.min(O3, z3)), C3[g3 ? 1 : 0] = O3;\n                    }\n                    if (x2 !== void 0) {\n                      var V2 = z3 + 1;\n                      L3 !== void 0 && (V2 = Math.max(V2, T3)), C3[g3 ? 0 : 1] = V2;\n                    }\n                  }\n                }\n              }, t3.cleanRange = function(S2, L3) {\n                t3._cleanRange(S2, L3), t3.limitRange(S2);\n              }, t3._cleanRange = function(S2, L3) {\n                L3 || (L3 = {}), S2 || (S2 = "range");\n                var x2 = yc.nestedProperty(t3, S2).get(), C3, M4;\n                if (t3.type === "date" ? M4 = yc.dfltRange(t3.calendar) : i3 === "y" ? M4 = mL.DFLTRANGEY : t3._name === "realaxis" ? M4 = [0, 1] : M4 = L3.dfltRange || mL.DFLTRANGEX, M4 = M4.slice(), (t3.rangemode === "tozero" || t3.rangemode === "nonnegative") && (M4[0] = 0), !x2 || x2.length !== 2) {\n                  yc.nestedProperty(t3, S2).set(M4);\n                  return;\n                }\n                var g3 = x2[0] === null, P3 = x2[1] === null;\n                for (t3.type === "date" && !t3.autorange && (x2[0] = yc.cleanDate(x2[0], Tg, t3.calendar), x2[1] = yc.cleanDate(x2[1], Tg, t3.calendar)), C3 = 0; C3 < 2; C3++) if (t3.type === "date") {\n                  if (!yc.isDateTime(x2[C3], t3.calendar)) {\n                    t3[S2] = M4;\n                    break;\n                  }\n                  if (t3.r2l(x2[0]) === t3.r2l(x2[1])) {\n                    var T3 = yc.constrain(t3.r2l(x2[0]), yc.MIN_MS + 1e3, yc.MAX_MS - 1e3);\n                    x2[0] = t3.l2r(T3 - 1e3), x2[1] = t3.l2r(T3 + 1e3);\n                    break;\n                  }\n                } else {\n                  if (!gm(x2[C3])) if (!(g3 || P3) && gm(x2[1 - C3])) x2[C3] = x2[1 - C3] * (C3 ? 10 : 0.1);\n                  else {\n                    t3[S2] = M4;\n                    break;\n                  }\n                  if (x2[C3] < -fL ? x2[C3] = -fL : x2[C3] > fL && (x2[C3] = fL), x2[0] === x2[1]) {\n                    var z3 = Math.max(1, Math.abs(x2[0] * 1e-6));\n                    x2[0] -= z3, x2[1] += z3;\n                  }\n                }\n              }, t3.setScale = function(S2) {\n                var L3 = r4._size;\n                if (t3.overlaying) {\n                  var x2 = vL.getFromId({ _fullLayout: r4 }, t3.overlaying);\n                  t3.domain = x2.domain;\n                }\n                var C3 = S2 && t3._r ? "_r" : "range", M4 = t3.calendar;\n                t3.cleanRange(C3);\n                var g3 = t3.r2l(t3[C3][0], M4), P3 = t3.r2l(t3[C3][1], M4), T3 = i3 === "y";\n                if (T3 ? (t3._offset = L3.t + (1 - t3.domain[1]) * L3.h, t3._length = L3.h * (t3.domain[1] - t3.domain[0]), t3._m = t3._length / (g3 - P3), t3._b = -t3._m * P3) : (t3._offset = L3.l + t3.domain[0] * L3.w, t3._length = L3.w * (t3.domain[1] - t3.domain[0]), t3._m = t3._length / (P3 - g3), t3._b = -t3._m * g3), t3._rangebreaks = [], t3._lBreaks = 0, t3._m2 = 0, t3._B = [], t3.rangebreaks) {\n                  var z3, O3;\n                  if (t3._rangebreaks = t3.locateBreaks(Math.min(g3, P3), Math.max(g3, P3)), t3._rangebreaks.length) {\n                    for (z3 = 0; z3 < t3._rangebreaks.length; z3++) O3 = t3._rangebreaks[z3], t3._lBreaks += Math.abs(O3.max - O3.min);\n                    var V2 = T3;\n                    g3 > P3 && (V2 = !V2), V2 && t3._rangebreaks.reverse();\n                    var G2 = V2 ? -1 : 1;\n                    for (t3._m2 = G2 * t3._length / (Math.abs(P3 - g3) - t3._lBreaks), t3._B.push(-t3._m2 * (T3 ? P3 : g3)), z3 = 0; z3 < t3._rangebreaks.length; z3++) O3 = t3._rangebreaks[z3], t3._B.push(t3._B[t3._B.length - 1] - G2 * t3._m2 * (O3.max - O3.min));\n                    for (z3 = 0; z3 < t3._rangebreaks.length; z3++) O3 = t3._rangebreaks[z3], O3.pmin = b(O3.min), O3.pmax = b(O3.max);\n                  }\n                }\n                if (!isFinite(t3._m) || !isFinite(t3._b) || t3._length < 0) throw r4._replotting = false, new Error("Something went wrong with axis scaling");\n              }, t3.maskBreaks = function(S2) {\n                var L3 = t3.rangebreaks || [], x2, C3, M4, g3, P3;\n                L3._cachedPatterns || (L3._cachedPatterns = L3.map(function(te) {\n                  return te.enabled && te.bounds ? yc.simpleMap(te.bounds, te.pattern ? n_ : t3.d2c) : null;\n                })), L3._cachedValues || (L3._cachedValues = L3.map(function(te) {\n                  return te.enabled && te.values ? yc.simpleMap(te.values, t3.d2c).sort(yc.sorterAsc) : null;\n                }));\n                for (var T3 = 0; T3 < L3.length; T3++) {\n                  var z3 = L3[T3];\n                  if (z3.enabled) {\n                    if (z3.bounds) {\n                      var O3 = z3.pattern;\n                      switch (x2 = L3._cachedPatterns[T3], C3 = x2[0], M4 = x2[1], O3) {\n                        case gL:\n                          P3 = new Date(S2), g3 = P3.getUTCDay(), C3 > M4 && (M4 += 7, g3 < C3 && (g3 += 7));\n                          break;\n                        case pL:\n                          P3 = new Date(S2);\n                          var V2 = P3.getUTCHours(), G2 = P3.getUTCMinutes(), Z = P3.getUTCSeconds(), j3 = P3.getUTCMilliseconds();\n                          g3 = V2 + (G2 / 60 + Z / 3600 + j3 / 36e5), C3 > M4 && (M4 += 24, g3 < C3 && (g3 += 24));\n                          break;\n                        case "":\n                          g3 = S2;\n                          break;\n                      }\n                      if (g3 >= C3 && g3 < M4) return Tg;\n                    } else for (var N2 = L3._cachedValues[T3], H = 0; H < N2.length; H++) if (C3 = N2[H], M4 = C3 + z3.dvalue, S2 >= C3 && S2 < M4) return Tg;\n                  }\n                }\n                return S2;\n              }, t3.locateBreaks = function(S2, L3) {\n                var x2, C3, M4, g3, P3 = [];\n                if (!t3.rangebreaks) return P3;\n                var T3 = t3.rangebreaks.slice().sort(function(_e, Ee) {\n                  return _e.pattern === gL && Ee.pattern === pL ? -1 : Ee.pattern === gL && _e.pattern === pL ? 1 : 0;\n                }), z3 = function(_e, Ee) {\n                  if (_e = yc.constrain(_e, S2, L3), Ee = yc.constrain(Ee, S2, L3), _e !== Ee) {\n                    for (var Ce = true, me = 0; me < P3.length; me++) {\n                      var ie = P3[me];\n                      _e < ie.max && Ee >= ie.min && (_e < ie.min && (ie.min = _e), Ee > ie.max && (ie.max = Ee), Ce = false);\n                    }\n                    Ce && P3.push({ min: _e, max: Ee });\n                  }\n                };\n                for (x2 = 0; x2 < T3.length; x2++) {\n                  var O3 = T3[x2];\n                  if (O3.enabled) if (O3.bounds) {\n                    var V2 = S2, G2 = L3;\n                    O3.pattern && (V2 = Math.floor(V2)), C3 = yc.simpleMap(O3.bounds, O3.pattern ? n_ : t3.r2l), M4 = C3[0], g3 = C3[1];\n                    var Z = new Date(V2), j3, N2;\n                    switch (O3.pattern) {\n                      case gL:\n                        N2 = ust, j3 = ((g3 < M4 ? 7 : 0) + (g3 - M4)) * hL, V2 += M4 * hL - (Z.getUTCDay() * hL + Z.getUTCHours() * dL + Z.getUTCMinutes() * Yoe + Z.getUTCSeconds() * Koe + Z.getUTCMilliseconds());\n                        break;\n                      case pL:\n                        N2 = hL, j3 = ((g3 < M4 ? 24 : 0) + (g3 - M4)) * dL, V2 += M4 * dL - (Z.getUTCHours() * dL + Z.getUTCMinutes() * Yoe + Z.getUTCSeconds() * Koe + Z.getUTCMilliseconds());\n                        break;\n                      default:\n                        V2 = Math.min(C3[0], C3[1]), G2 = Math.max(C3[0], C3[1]), N2 = G2 - V2, j3 = N2;\n                    }\n                    for (var H = V2; H < G2; H += N2) z3(H, H + j3);\n                  } else for (var te = yc.simpleMap(O3.values, t3.d2c), oe = 0; oe < te.length; oe++) M4 = te[oe], g3 = M4 + O3.dvalue, z3(M4, g3);\n                }\n                return P3.sort(function(_e, Ee) {\n                  return _e.min - Ee.min;\n                }), P3;\n              }, t3.makeCalcdata = function(S2, L3, x2) {\n                var C3, M4, g3, P3, T3 = t3.type, z3 = T3 === "date" && S2[L3 + "calendar"];\n                if (L3 in S2) {\n                  if (C3 = S2[L3], P3 = S2._length || yc.minRowLength(C3), yc.isTypedArray(C3) && (T3 === "linear" || T3 === "log")) {\n                    if (P3 === C3.length) return C3;\n                    if (C3.subarray) return C3.subarray(0, P3);\n                  }\n                  if (T3 === "multicategory") return c5(C3, P3);\n                  for (M4 = new Array(P3), g3 = 0; g3 < P3; g3++) M4[g3] = t3.d2c(C3[g3], 0, z3, x2);\n                } else {\n                  var O3 = L3 + "0" in S2 ? t3.d2c(S2[L3 + "0"], 0, z3) : 0, V2 = S2["d" + L3] ? Number(S2["d" + L3]) : 1;\n                  for (C3 = S2[{ x: "y", y: "x" }[L3]], P3 = S2._length || C3.length, M4 = new Array(P3), g3 = 0; g3 < P3; g3++) M4[g3] = O3 + g3 * V2;\n                }\n                if (t3.rangebreaks) for (g3 = 0; g3 < P3; g3++) M4[g3] = t3.maskBreaks(M4[g3]);\n                return M4;\n              }, t3.isValidRange = function(S2, L3) {\n                return Array.isArray(S2) && S2.length === 2 && (L3 && S2[0] === null || gm(t3.r2l(S2[0]))) && (L3 && S2[1] === null || gm(t3.r2l(S2[1])));\n              }, t3.getAutorangeDflt = function(S2, L3) {\n                var x2 = !t3.isValidRange(S2, "nullOk");\n                return x2 && L3 && L3.reverseDflt ? x2 = "reversed" : S2 && (S2[0] === null && S2[1] === null ? x2 = true : S2[0] === null && S2[1] !== null ? x2 = "min" : S2[0] !== null && S2[1] === null && (x2 = "max")), x2;\n              }, t3.isReversed = function() {\n                var S2 = t3.autorange;\n                return S2 === "reversed" || S2 === "min reversed" || S2 === "max reversed";\n              }, t3.isPtWithinRange = function(S2, L3) {\n                var x2 = t3.c2l(S2[i3], null, L3), C3 = t3.r2l(t3.range[0]), M4 = t3.r2l(t3.range[1]);\n                return C3 < M4 ? C3 <= x2 && x2 <= M4 : M4 <= x2 && x2 <= C3;\n              }, t3._emptyCategories = function() {\n                t3._categories = [], t3._categoriesMap = {};\n              }, t3.clearCalc = function() {\n                var S2 = t3._matchGroup;\n                if (S2) {\n                  var L3 = null, x2 = null;\n                  for (var C3 in S2) {\n                    var M4 = r4[vL.id2name(C3)];\n                    if (M4._categories) {\n                      L3 = M4._categories, x2 = M4._categoriesMap;\n                      break;\n                    }\n                  }\n                  L3 && x2 ? (t3._categories = L3, t3._categoriesMap = x2) : t3._emptyCategories();\n                } else t3._emptyCategories();\n                if (t3._initialCategories) for (var g3 = 0; g3 < t3._initialCategories.length; g3++) u4(t3._initialCategories[g3]);\n              }, t3.sortByInitialCategories = function() {\n                var S2 = [];\n                if (t3._emptyCategories(), t3._initialCategories) for (var L3 = 0; L3 < t3._initialCategories.length; L3++) u4(t3._initialCategories[L3]);\n                S2 = S2.concat(t3._traceIndices);\n                var x2 = t3._matchGroup;\n                for (var C3 in x2) if (n4 !== C3) {\n                  var M4 = r4[vL.id2name(C3)];\n                  M4._categories = t3._categories, M4._categoriesMap = t3._categoriesMap, S2 = S2.concat(M4._traceIndices);\n                }\n                return S2;\n              };\n              var E3 = r4._d3locale;\n              t3.type === "date" && (t3._dateFormat = E3 ? E3.timeFormat : ast, t3._extraFormat = r4._extraFormat), t3._separators = r4.separators, t3._numFormat = E3 ? E3.numberFormat : ost, delete t3._minDtick, delete t3._forceTick0;\n            };\n          });\n          var R3 = ye((Hnr, tse) => {\n            "use strict";\n            var $oe = Eo(), $q = Dr(), cst = fs().BADNUM, yL = $q.isArrayOrTypedArray, fst = $q.isDateTime, hst = $q.cleanNumber, Qoe = Math.round;\n            tse.exports = function(t3, r4, n4) {\n              var i3 = t3, a4 = n4.noMultiCategory;\n              if (yL(i3) && !i3.length) return "-";\n              if (!a4 && mst(i3)) return "multicategory";\n              if (a4 && Array.isArray(i3[0])) {\n                for (var o4 = [], s3 = 0; s3 < i3.length; s3++) if (yL(i3[s3])) for (var l3 = 0; l3 < i3[s3].length; l3++) o4.push(i3[s3][l3]);\n                i3 = o4;\n              }\n              if (pst(i3, r4)) return "date";\n              var u4 = n4.autotypenumbers !== "strict";\n              return gst(i3, u4) ? "category" : vst(i3, u4) ? "linear" : "-";\n            };\n            function dst(e3, t3) {\n              return t3 ? $oe(e3) : typeof e3 == "number";\n            }\n            function vst(e3, t3) {\n              for (var r4 = e3.length, n4 = 0; n4 < r4; n4++) if (dst(e3[n4], t3)) return true;\n              return false;\n            }\n            function pst(e3, t3) {\n              for (var r4 = e3.length, n4 = ese(r4), i3 = 0, a4 = 0, o4 = {}, s3 = 0; s3 < r4; s3 += n4) {\n                var l3 = Qoe(s3), u4 = e3[l3], c5 = String(u4);\n                o4[c5] || (o4[c5] = 1, fst(u4, t3) && i3++, $oe(u4) && a4++);\n              }\n              return i3 > a4 * 2;\n            }\n            function ese(e3) {\n              return Math.max(1, (e3 - 1) / 1e3);\n            }\n            function gst(e3, t3) {\n              for (var r4 = e3.length, n4 = ese(r4), i3 = 0, a4 = 0, o4 = {}, s3 = 0; s3 < r4; s3 += n4) {\n                var l3 = Qoe(s3), u4 = e3[l3], c5 = String(u4);\n                if (!o4[c5]) {\n                  o4[c5] = 1;\n                  var f4 = typeof u4;\n                  f4 === "boolean" ? a4++ : (t3 ? hst(u4) !== cst : f4 === "number") ? i3++ : f4 === "string" && a4++;\n                }\n              }\n              return a4 > i3 * 2;\n            }\n            function mst(e3) {\n              return yL(e3[0]) && yL(e3[1]);\n            }\n          });\n          var Ag = ye((jnr, use) => {\n            "use strict";\n            var yst = Oa(), ase = Eo(), o_ = Dr(), _L = fs().FP_SAFE, _st = qa(), xst = So(), ose = hf(), bst = ose.getFromId, wst = ose.isLinked;\n            use.exports = { applyAutorangeOptions: lse, getAutoRange: Qq, makePadFn: eB, doAutoRange: Ast, findExtremes: Sst, concatExtremes: iB };\n            function Qq(e3, t3) {\n              var r4, n4, i3 = [], a4 = e3._fullLayout, o4 = eB(a4, t3, 0), s3 = eB(a4, t3, 1), l3 = iB(e3, t3), u4 = l3.min, c5 = l3.max;\n              if (u4.length === 0 || c5.length === 0) return o_.simpleMap(t3.range, t3.r2l);\n              var f4 = u4[0].val, h3 = c5[0].val;\n              for (r4 = 1; r4 < u4.length && f4 === h3; r4++) f4 = Math.min(f4, u4[r4].val);\n              for (r4 = 1; r4 < c5.length && f4 === h3; r4++) h3 = Math.max(h3, c5[r4].val);\n              var d3 = t3.autorange, v3 = d3 === "reversed" || d3 === "min reversed" || d3 === "max reversed";\n              if (!v3 && t3.range) {\n                var _2 = o_.simpleMap(t3.range, t3.r2l);\n                v3 = _2[1] < _2[0];\n              }\n              t3.autorange === "reversed" && (t3.autorange = true);\n              var b = t3.rangemode, p3 = b === "tozero", k4 = b === "nonnegative", E3 = t3._length, S2 = E3 / 10, L3 = 0, x2, C3, M4, g3, P3, T3;\n              for (r4 = 0; r4 < u4.length; r4++) for (x2 = u4[r4], n4 = 0; n4 < c5.length; n4++) C3 = c5[n4], T3 = C3.val - x2.val - rse(t3, x2.val, C3.val), T3 > 0 && (P3 = E3 - o4(x2) - s3(C3), P3 > S2 ? T3 / P3 > L3 && (M4 = x2, g3 = C3, L3 = T3 / P3) : T3 / E3 > L3 && (M4 = { val: x2.val, nopad: 1 }, g3 = { val: C3.val, nopad: 1 }, L3 = T3 / E3));\n              function z3(j3, N2) {\n                return Math.max(j3, s3(N2));\n              }\n              if (f4 === h3) {\n                var O3 = f4 - 1, V2 = f4 + 1;\n                if (p3) if (f4 === 0) i3 = [0, 1];\n                else {\n                  var G2 = (f4 > 0 ? c5 : u4).reduce(z3, 0), Z = f4 / (1 - Math.min(0.5, G2 / E3));\n                  i3 = f4 > 0 ? [0, Z] : [Z, 0];\n                }\n                else k4 ? i3 = [Math.max(0, O3), Math.max(1, V2)] : i3 = [O3, V2];\n              } else p3 ? (M4.val >= 0 && (M4 = { val: 0, nopad: 1 }), g3.val <= 0 && (g3 = { val: 0, nopad: 1 })) : k4 && (M4.val - L3 * o4(M4) < 0 && (M4 = { val: 0, nopad: 1 }), g3.val <= 0 && (g3 = { val: 1, nopad: 1 })), L3 = (g3.val - M4.val - rse(t3, x2.val, C3.val)) / (E3 - o4(M4) - s3(g3)), i3 = [M4.val - L3 * o4(M4), g3.val + L3 * s3(g3)];\n              return i3 = lse(i3, t3), t3.limitRange && t3.limitRange(), v3 && i3.reverse(), o_.simpleMap(i3, t3.l2r || Number);\n            }\n            function rse(e3, t3, r4) {\n              var n4 = 0;\n              if (e3.rangebreaks) for (var i3 = e3.locateBreaks(t3, r4), a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                n4 += o4.max - o4.min;\n              }\n              return n4;\n            }\n            function eB(e3, t3, r4) {\n              var n4 = 0.05 * t3._length, i3 = t3._anchorAxis || {};\n              if ((t3.ticklabelposition || "").indexOf("inside") !== -1 || (i3.ticklabelposition || "").indexOf("inside") !== -1) {\n                var a4 = t3.isReversed();\n                if (!a4) {\n                  var o4 = o_.simpleMap(t3.range, t3.r2l);\n                  a4 = o4[1] < o4[0];\n                }\n                a4 && (r4 = !r4);\n              }\n              var s3 = 0;\n              return wst(e3, t3._id) || (s3 = Tst(e3, t3, r4)), n4 = Math.max(s3, n4), t3.constrain === "domain" && t3._inputDomain && (n4 *= (t3._inputDomain[1] - t3._inputDomain[0]) / (t3.domain[1] - t3.domain[0])), function(u4) {\n                return u4.nopad ? 0 : u4.pad + (u4.extrapad ? n4 : s3);\n              };\n            }\n            var ise = 3;\n            function Tst(e3, t3, r4) {\n              var n4 = 0, i3 = t3._id.charAt(0) === "x";\n              for (var a4 in e3._plots) {\n                var o4 = e3._plots[a4];\n                if (!(t3._id !== o4.xaxis._id && t3._id !== o4.yaxis._id)) {\n                  var s3 = (i3 ? o4.yaxis : o4.xaxis) || {};\n                  if ((s3.ticklabelposition || "").indexOf("inside") !== -1 && (!r4 && (s3.side === "left" || s3.side === "bottom") || r4 && (s3.side === "top" || s3.side === "right"))) {\n                    if (s3._vals) {\n                      var l3 = o_.deg2rad(s3._tickAngles[s3._id + "tick"] || 0), u4 = Math.abs(Math.cos(l3)), c5 = Math.abs(Math.sin(l3));\n                      if (!s3._vals[0].bb) {\n                        var f4 = s3._id + "tick", h3 = s3._selections[f4];\n                        h3.each(function(k4) {\n                          var E3 = yst.select(this), S2 = E3.select(".text-math-group");\n                          S2.empty() && (k4.bb = xst.bBox(E3.node()));\n                        });\n                      }\n                      for (var d3 = 0; d3 < s3._vals.length; d3++) {\n                        var v3 = s3._vals[d3], _2 = v3.bb;\n                        if (_2) {\n                          var b = 2 * ise + _2.width, p3 = 2 * ise + _2.height;\n                          n4 = Math.max(n4, i3 ? Math.max(b * u4, p3 * c5) : Math.max(p3 * u4, b * c5));\n                        }\n                      }\n                    }\n                    s3.ticks === "inside" && s3.ticklabelposition === "inside" && (n4 += s3.ticklen || 0);\n                  }\n                }\n              }\n              return n4;\n            }\n            function iB(e3, t3, r4) {\n              var n4 = t3._id, i3 = e3._fullData, a4 = e3._fullLayout, o4 = [], s3 = [], l3, u4, c5;\n              function f4(b, p3) {\n                for (l3 = 0; l3 < p3.length; l3++) {\n                  var k4 = b[p3[l3]], E3 = (k4._extremes || {})[n4];\n                  if (k4.visible === true && E3) {\n                    for (u4 = 0; u4 < E3.min.length; u4++) c5 = E3.min[u4], tB(o4, c5.val, c5.pad, { extrapad: c5.extrapad });\n                    for (u4 = 0; u4 < E3.max.length; u4++) c5 = E3.max[u4], rB(s3, c5.val, c5.pad, { extrapad: c5.extrapad });\n                  }\n                }\n              }\n              if (f4(i3, t3._traceIndices), f4(a4.annotations || [], t3._annIndices || []), f4(a4.shapes || [], t3._shapeIndices || []), t3._matchGroup && !r4) {\n                for (var h3 in t3._matchGroup) if (h3 !== t3._id) {\n                  var d3 = bst(e3, h3), v3 = iB(e3, d3, true), _2 = t3._length / d3._length;\n                  for (u4 = 0; u4 < v3.min.length; u4++) c5 = v3.min[u4], tB(o4, c5.val, c5.pad * _2, { extrapad: c5.extrapad });\n                  for (u4 = 0; u4 < v3.max.length; u4++) c5 = v3.max[u4], rB(s3, c5.val, c5.pad * _2, { extrapad: c5.extrapad });\n                }\n              }\n              return { min: o4, max: s3 };\n            }\n            function Ast(e3, t3, r4) {\n              if (t3.setScale(), t3.autorange) {\n                t3.range = r4 ? r4.slice() : Qq(e3, t3), t3._r = t3.range.slice(), t3._rl = o_.simpleMap(t3._r, t3.r2l);\n                var n4 = t3._input, i3 = {};\n                i3[t3._attr + ".range"] = t3.range, i3[t3._attr + ".autorange"] = t3.autorange, _st.call("_storeDirectGUIEdit", e3.layout, e3._fullLayout._preGUI, i3), n4.range = t3.range.slice(), n4.autorange = t3.autorange;\n              }\n              var a4 = t3._anchorAxis;\n              if (a4 && a4.rangeslider) {\n                var o4 = a4.rangeslider[t3._name];\n                o4 && o4.rangemode === "auto" && (o4.range = Qq(e3, t3)), a4._input.rangeslider[t3._name] = o_.extendFlat({}, o4);\n              }\n            }\n            function Sst(e3, t3, r4) {\n              r4 || (r4 = {}), e3._m || e3.setScale();\n              var n4 = [], i3 = [], a4 = t3.length, o4 = r4.padded || false, s3 = r4.tozero && (e3.type === "linear" || e3.type === "-"), l3 = e3.type === "log", u4 = false, c5 = r4.vpadLinearized || false, f4, h3, d3, v3, _2, b, p3, k4, E3;\n              function S2(z3) {\n                if (Array.isArray(z3)) return u4 = true, function(V2) {\n                  return Math.max(Number(z3[V2] || 0), 0);\n                };\n                var O3 = Math.max(Number(z3 || 0), 0);\n                return function() {\n                  return O3;\n                };\n              }\n              var L3 = S2((e3._m > 0 ? r4.ppadplus : r4.ppadminus) || r4.ppad || 0), x2 = S2((e3._m > 0 ? r4.ppadminus : r4.ppadplus) || r4.ppad || 0), C3 = S2(r4.vpadplus || r4.vpad), M4 = S2(r4.vpadminus || r4.vpad);\n              if (!u4) {\n                if (k4 = 1 / 0, E3 = -1 / 0, l3) for (f4 = 0; f4 < a4; f4++) h3 = t3[f4], h3 < k4 && h3 > 0 && (k4 = h3), h3 > E3 && h3 < _L && (E3 = h3);\n                else for (f4 = 0; f4 < a4; f4++) h3 = t3[f4], h3 < k4 && h3 > -_L && (k4 = h3), h3 > E3 && h3 < _L && (E3 = h3);\n                t3 = [k4, E3], a4 = 2;\n              }\n              var g3 = { tozero: s3, extrapad: o4 };\n              function P3(z3) {\n                d3 = t3[z3], ase(d3) && (b = L3(z3), p3 = x2(z3), c5 ? (v3 = e3.c2l(d3) - M4(z3), _2 = e3.c2l(d3) + C3(z3)) : (k4 = d3 - M4(z3), E3 = d3 + C3(z3), l3 && k4 < E3 / 10 && (k4 = E3 / 10), v3 = e3.c2l(k4), _2 = e3.c2l(E3)), s3 && (v3 = Math.min(0, v3), _2 = Math.max(0, _2)), nse(v3) && tB(n4, v3, p3, g3), nse(_2) && rB(i3, _2, b, g3));\n              }\n              var T3 = Math.min(6, a4);\n              for (f4 = 0; f4 < T3; f4++) P3(f4);\n              for (f4 = a4 - 1; f4 >= T3; f4--) P3(f4);\n              return { min: n4, max: i3, opts: r4 };\n            }\n            function tB(e3, t3, r4, n4) {\n              sse(e3, t3, r4, n4, Mst);\n            }\n            function rB(e3, t3, r4, n4) {\n              sse(e3, t3, r4, n4, Est);\n            }\n            function sse(e3, t3, r4, n4, i3) {\n              for (var a4 = n4.tozero, o4 = n4.extrapad, s3 = true, l3 = 0; l3 < e3.length && s3; l3++) {\n                var u4 = e3[l3];\n                if (i3(u4.val, t3) && u4.pad >= r4 && (u4.extrapad || !o4)) {\n                  s3 = false;\n                  break;\n                } else i3(t3, u4.val) && u4.pad <= r4 && (o4 || !u4.extrapad) && (e3.splice(l3, 1), l3--);\n              }\n              if (s3) {\n                var c5 = a4 && t3 === 0;\n                e3.push({ val: t3, pad: c5 ? 0 : r4, extrapad: c5 ? false : o4 });\n              }\n            }\n            function nse(e3) {\n              return ase(e3) && Math.abs(e3) < _L;\n            }\n            function Mst(e3, t3) {\n              return e3 <= t3;\n            }\n            function Est(e3, t3) {\n              return e3 >= t3;\n            }\n            function kst(e3, t3) {\n              var r4 = t3.autorangeoptions;\n              return r4 && r4.minallowed !== void 0 && xL(t3, r4.minallowed, r4.maxallowed) ? r4.minallowed : r4 && r4.clipmin !== void 0 && xL(t3, r4.clipmin, r4.clipmax) ? Math.max(e3, t3.d2l(r4.clipmin)) : e3;\n            }\n            function Cst(e3, t3) {\n              var r4 = t3.autorangeoptions;\n              return r4 && r4.maxallowed !== void 0 && xL(t3, r4.minallowed, r4.maxallowed) ? r4.maxallowed : r4 && r4.clipmax !== void 0 && xL(t3, r4.clipmin, r4.clipmax) ? Math.min(e3, t3.d2l(r4.clipmax)) : e3;\n            }\n            function xL(e3, t3, r4) {\n              return t3 !== void 0 && r4 !== void 0 ? (t3 = e3.d2l(t3), r4 = e3.d2l(r4), t3 < r4) : true;\n            }\n            function lse(e3, t3) {\n              if (!t3 || !t3.autorangeoptions) return e3;\n              var r4 = e3[0], n4 = e3[1], i3 = t3.autorangeoptions.include;\n              if (i3 !== void 0) {\n                var a4 = t3.d2l(r4), o4 = t3.d2l(n4);\n                o_.isArrayOrTypedArray(i3) || (i3 = [i3]);\n                for (var s3 = 0; s3 < i3.length; s3++) {\n                  var l3 = t3.d2l(i3[s3]);\n                  a4 >= l3 && (a4 = l3, r4 = l3), o4 <= l3 && (o4 = l3, n4 = l3);\n                }\n              }\n              return r4 = kst(r4, t3), n4 = Cst(n4, t3), [r4, n4];\n            }\n          });\n          var ho = ye((Wnr, Ise) => {\n            "use strict";\n            var b0 = Oa(), Ih = Eo(), D3 = Mc(), aM = qa(), Jo = Dr(), F3 = Jo.strTranslate, kb = ru(), Lst = Eb(), oM = ka(), Xp = So(), Pst = Rd(), cse = Eq(), Jd = fs(), Ist = Jd.ONEMAXYEAR, TL = Jd.ONEAVGYEAR, AL = Jd.ONEMINYEAR, Rst = Jd.ONEMAXQUARTER, sB = Jd.ONEAVGQUARTER, SL = Jd.ONEMINQUARTER, Dst = Jd.ONEMAXMONTH, z3 = Jd.ONEAVGMONTH, ML = Jd.ONEMINMONTH, Zp = Jd.ONEWEEK, Ov = Jd.ONEDAY, s_ = Ov / 2, xm = Jd.ONEHOUR, sM = Jd.ONEMIN, EL = Jd.ONESEC, Fst = Jd.ONEMILLI, zst = Jd.ONEMICROSEC, Cb = Jd.MINUS_SIGN, CL = Jd.BADNUM, lB = { K: "zeroline" }, uB = { K: "gridline", L: "path" }, cB = { K: "minor-gridline", L: "path" }, bse = { K: "tick", L: "path" }, fse = { K: "tick", L: "text" }, hse = { width: ["x", "r", "l", "xl", "xr"], height: ["y", "t", "b", "yt", "yb"], right: ["r", "xr"], left: ["l", "xl"], top: ["t", "yt"], bottom: ["b", "yb"] }, LL = $h(), nM = LL.MID_SHIFT, Lb = LL.CAP_SHIFT, lM = LL.LINE_SPACING, Ost = LL.OPPOSITE_SIDE, kL = 3, Qn = Ise.exports = {};\n            Qn.setConvert = ym();\n            var qst = R3(), Sy = hf(), Bst = Sy.idSort, Nst = Sy.isLinked;\n            Qn.id2name = Sy.id2name;\n            Qn.name2id = Sy.name2id;\n            Qn.cleanId = Sy.cleanId;\n            Qn.list = Sy.list;\n            Qn.listIds = Sy.listIds;\n            Qn.getFromId = Sy.getFromId;\n            Qn.getFromTrace = Sy.getFromTrace;\n            var wse = Ag();\n            Qn.getAutoRange = wse.getAutoRange;\n            Qn.findExtremes = wse.findExtremes;\n            var Ust = 1e-4;\n            function vB(e3) {\n              var t3 = (e3[1] - e3[0]) * Ust;\n              return [e3[0] - t3, e3[1] + t3];\n            }\n            Qn.coerceRef = function(e3, t3, r4, n4, i3, a4) {\n              var o4 = n4.charAt(n4.length - 1), s3 = r4._fullLayout._subplots[o4 + "axis"], l3 = n4 + "ref", u4 = {};\n              return i3 || (i3 = s3[0] || (typeof a4 == "string" ? a4 : a4[0])), a4 || (a4 = i3), s3 = s3.concat(s3.map(function(c5) {\n                return c5 + " domain";\n              })), u4[l3] = { valType: "enumerated", values: s3.concat(a4 ? typeof a4 == "string" ? [a4] : a4 : []), dflt: i3 }, Jo.coerce(e3, t3, u4, l3);\n            };\n            Qn.getRefType = function(e3) {\n              return e3 === void 0 ? e3 : e3 === "paper" ? "paper" : e3 === "pixel" ? "pixel" : /( domain)$/.test(e3) ? "domain" : "range";\n            };\n            Qn.coercePosition = function(e3, t3, r4, n4, i3, a4) {\n              var o4, s3, l3 = Qn.getRefType(n4);\n              if (l3 !== "range") o4 = Jo.ensureNumber, s3 = r4(i3, a4);\n              else {\n                var u4 = Qn.getFromId(t3, n4);\n                a4 = u4.fraction2r(a4), s3 = r4(i3, a4), o4 = u4.cleanPos;\n              }\n              e3[i3] = o4(s3);\n            };\n            Qn.cleanPosition = function(e3, t3, r4) {\n              var n4 = r4 === "paper" || r4 === "pixel" ? Jo.ensureNumber : Qn.getFromId(t3, r4).cleanPos;\n              return n4(e3);\n            };\n            Qn.redrawComponents = function(e3, t3) {\n              t3 = t3 || Qn.listIds(e3);\n              var r4 = e3._fullLayout;\n              function n4(i3, a4, o4, s3) {\n                for (var l3 = aM.getComponentMethod(i3, a4), u4 = {}, c5 = 0; c5 < t3.length; c5++) for (var f4 = r4[Qn.id2name(t3[c5])], h3 = f4[o4], d3 = 0; d3 < h3.length; d3++) {\n                  var v3 = h3[d3];\n                  if (!u4[v3] && (l3(e3, v3), u4[v3] = 1, s3)) return;\n                }\n              }\n              n4("annotations", "drawOne", "_annIndices"), n4("shapes", "drawOne", "_shapeIndices"), n4("images", "draw", "_imgIndices", true), n4("selections", "drawOne", "_selectionIndices");\n            };\n            var Vst = Qn.getDataConversions = function(e3, t3, r4, n4) {\n              var i3, a4 = r4 === "x" || r4 === "y" || r4 === "z" ? r4 : n4;\n              if (Jo.isArrayOrTypedArray(a4)) {\n                if (i3 = { type: qst(n4, void 0, { autotypenumbers: e3._fullLayout.autotypenumbers }), _categories: [] }, Qn.setConvert(i3), i3.type === "category") for (var o4 = 0; o4 < n4.length; o4++) i3.d2c(n4[o4]);\n              } else i3 = Qn.getFromTrace(e3, t3, a4);\n              return i3 ? { d2c: i3.d2c, c2d: i3.c2d } : a4 === "ids" ? { d2c: vse, c2d: vse } : { d2c: dse, c2d: dse };\n            };\n            function dse(e3) {\n              return +e3;\n            }\n            function vse(e3) {\n              return String(e3);\n            }\n            Qn.getDataToCoordFunc = function(e3, t3, r4, n4) {\n              return Vst(e3, t3, r4, n4).d2c;\n            };\n            Qn.counterLetter = function(e3) {\n              var t3 = e3.charAt(0);\n              if (t3 === "x") return "y";\n              if (t3 === "y") return "x";\n            };\n            Qn.minDtick = function(e3, t3, r4, n4) {\n              ["log", "category", "multicategory"].indexOf(e3.type) !== -1 || !n4 ? e3._minDtick = 0 : e3._minDtick === void 0 ? (e3._minDtick = t3, e3._forceTick0 = r4) : e3._minDtick && ((e3._minDtick / t3 + 1e-6) % 1 < 2e-6 && ((r4 - e3._forceTick0) / t3 % 1 + 1.000001) % 1 < 2e-6 ? (e3._minDtick = t3, e3._forceTick0 = r4) : ((t3 / e3._minDtick + 1e-6) % 1 > 2e-6 || ((r4 - e3._forceTick0) / e3._minDtick % 1 + 1.000001) % 1 > 2e-6) && (e3._minDtick = 0));\n            };\n            Qn.saveRangeInitial = function(e3, t3) {\n              for (var r4 = Qn.list(e3, "", true), n4 = false, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3], o4 = a4._rangeInitial0 === void 0 && a4._rangeInitial1 === void 0, s3 = o4 || a4.range[0] !== a4._rangeInitial0 || a4.range[1] !== a4._rangeInitial1, l3 = a4.autorange;\n                (o4 && l3 !== true || t3 && s3) && (a4._rangeInitial0 = l3 === "min" || l3 === "max reversed" ? void 0 : a4.range[0], a4._rangeInitial1 = l3 === "max" || l3 === "min reversed" ? void 0 : a4.range[1], a4._autorangeInitial = l3, n4 = true);\n              }\n              return n4;\n            };\n            Qn.saveShowSpikeInitial = function(e3, t3) {\n              for (var r4 = Qn.list(e3, "", true), n4 = false, i3 = "on", a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4], s3 = o4._showSpikeInitial === void 0, l3 = s3 || o4.showspikes !== o4._showspikes;\n                (s3 || t3 && l3) && (o4._showSpikeInitial = o4.showspikes, n4 = true), i3 === "on" && !o4.showspikes && (i3 = "off");\n              }\n              return e3._fullLayout._cartesianSpikesEnabled = i3, n4;\n            };\n            Qn.autoBin = function(e3, t3, r4, n4, i3, a4) {\n              var o4 = Jo.aggNums(Math.min, null, e3), s3 = Jo.aggNums(Math.max, null, e3);\n              if (t3.type === "category" || t3.type === "multicategory") return { start: o4 - 0.5, end: s3 + 0.5, size: Math.max(1, Math.round(a4) || 1), _dataSpan: s3 - o4 };\n              i3 || (i3 = t3.calendar);\n              var l3;\n              if (t3.type === "log" ? l3 = { type: "linear", range: [o4, s3] } : l3 = { type: t3.type, range: Jo.simpleMap([o4, s3], t3.c2r, 0, i3), calendar: i3 }, Qn.setConvert(l3), a4 = a4 && cse.dtick(a4, l3.type), a4) l3.dtick = a4, l3.tick0 = cse.tick0(void 0, l3.type, i3);\n              else {\n                var u4;\n                if (r4) u4 = (s3 - o4) / r4;\n                else {\n                  var c5 = Jo.distinctVals(e3), f4 = Math.pow(10, Math.floor(Math.log(c5.minDiff) / Math.LN10)), h3 = f4 * Jo.roundUp(c5.minDiff / f4, [0.9, 1.9, 4.9, 9.9], true);\n                  u4 = Math.max(h3, 2 * Jo.stdev(e3) / Math.pow(e3.length, n4 ? 0.25 : 0.4)), Ih(u4) || (u4 = 1);\n                }\n                Qn.autoTicks(l3, u4);\n              }\n              var d3 = l3.dtick, v3 = Qn.tickIncrement(Qn.tickFirst(l3), d3, "reverse", i3), _2, b;\n              if (typeof d3 == "number") v3 = Gst(v3, e3, l3, o4, s3), b = 1 + Math.floor((s3 - v3) / d3), _2 = v3 + b * d3;\n              else for (l3.dtick.charAt(0) === "M" && (v3 = Hst(v3, e3, d3, o4, i3)), _2 = v3, b = 0; _2 <= s3; ) _2 = Qn.tickIncrement(_2, d3, false, i3), b++;\n              return { start: t3.c2r(v3, 0, i3), end: t3.c2r(_2, 0, i3), size: d3, _dataSpan: s3 - o4 };\n            };\n            function Gst(e3, t3, r4, n4, i3) {\n              var a4 = 0, o4 = 0, s3 = 0, l3 = 0;\n              function u4(d3) {\n                return (1 + (d3 - e3) * 100 / r4.dtick) % 100 < 2;\n              }\n              for (var c5 = 0; c5 < t3.length; c5++) t3[c5] % 1 === 0 ? s3++ : Ih(t3[c5]) || l3++, u4(t3[c5]) && a4++, u4(t3[c5] + r4.dtick / 2) && o4++;\n              var f4 = t3.length - l3;\n              if (s3 === f4 && r4.type !== "date") r4.dtick < 1 ? e3 = n4 - 0.5 * r4.dtick : (e3 -= 0.5, e3 + r4.dtick < n4 && (e3 += r4.dtick));\n              else if (o4 < f4 * 0.1 && (a4 > f4 * 0.3 || u4(n4) || u4(i3))) {\n                var h3 = r4.dtick / 2;\n                e3 += e3 + h3 < n4 ? h3 : -h3;\n              }\n              return e3;\n            }\n            function Hst(e3, t3, r4, n4, i3) {\n              var a4 = Jo.findExactDates(t3, i3), o4 = 0.8;\n              if (a4.exactDays > o4) {\n                var s3 = Number(r4.slice(1));\n                a4.exactYears > o4 && s3 % 12 === 0 ? e3 = Qn.tickIncrement(e3, "M6", "reverse") + Ov * 1.5 : a4.exactMonths > o4 ? e3 = Qn.tickIncrement(e3, "M1", "reverse") + Ov * 15.5 : e3 -= s_;\n                var l3 = Qn.tickIncrement(e3, r4);\n                if (l3 <= n4) return l3;\n              }\n              return e3;\n            }\n            Qn.prepMinorTicks = function(e3, t3, r4) {\n              if (!t3.minor.dtick) {\n                delete e3.dtick;\n                var n4 = t3.dtick && Ih(t3._tmin), i3;\n                if (n4) {\n                  var a4 = Qn.tickIncrement(t3._tmin, t3.dtick, true);\n                  i3 = [t3._tmin, a4 * 0.99 + t3._tmin * 0.01];\n                } else {\n                  var o4 = Jo.simpleMap(t3.range, t3.r2l);\n                  i3 = [o4[0], 0.8 * o4[0] + 0.2 * o4[1]];\n                }\n                if (e3.range = Jo.simpleMap(i3, t3.l2r), e3._isMinor = true, Qn.prepTicks(e3, r4), n4) {\n                  var s3 = Ih(t3.dtick), l3 = Ih(e3.dtick), u4 = s3 ? t3.dtick : +t3.dtick.substring(1), c5 = l3 ? e3.dtick : +e3.dtick.substring(1);\n                  s3 && l3 ? nB(u4, c5) ? u4 === 2 * Zp && c5 === 2 * Ov && (e3.dtick = Zp) : u4 === 2 * Zp && c5 === 3 * Ov ? e3.dtick = Zp : u4 === Zp && !(t3._input.minor || {}).nticks ? e3.dtick = Ov : pse(u4 / c5, 2.5) ? e3.dtick = u4 / 2 : e3.dtick = u4 : String(t3.dtick).charAt(0) === "M" ? l3 ? e3.dtick = "M1" : nB(u4, c5) ? u4 >= 12 && c5 === 2 && (e3.dtick = "M3") : e3.dtick = t3.dtick : String(e3.dtick).charAt(0) === "L" ? String(t3.dtick).charAt(0) === "L" ? nB(u4, c5) || (e3.dtick = pse(u4 / c5, 2.5) ? t3.dtick / 2 : t3.dtick) : e3.dtick = "D1" : e3.dtick === "D2" && +t3.dtick > 1 && (e3.dtick = 1);\n                }\n                e3.range = t3.range;\n              }\n              t3.minor._tick0Init === void 0 && (e3.tick0 = t3.tick0);\n            };\n            function nB(e3, t3) {\n              return Math.abs((e3 / t3 + 0.5) % 1 - 0.5) < 1e-3;\n            }\n            function pse(e3, t3) {\n              return Math.abs(e3 / t3 - 1) < 1e-3;\n            }\n            Qn.prepTicks = function(e3, t3) {\n              var r4 = Jo.simpleMap(e3.range, e3.r2l, void 0, void 0, t3);\n              if (e3.tickmode === "auto" || !e3.dtick) {\n                var n4 = e3.nticks, i3;\n                n4 || (e3.type === "category" || e3.type === "multicategory" ? (i3 = e3.tickfont ? Jo.bigFont(e3.tickfont.size || 12) : 15, n4 = e3._length / i3) : (i3 = e3._id.charAt(0) === "y" ? 40 : 80, n4 = Jo.constrain(e3._length / i3, 4, 9) + 1), e3._name === "radialaxis" && (n4 *= 2)), e3.minor && e3.minor.tickmode !== "array" || e3.tickmode === "array" && (n4 *= 100), e3._roughDTick = Math.abs(r4[1] - r4[0]) / n4, Qn.autoTicks(e3, e3._roughDTick), e3._minDtick > 0 && e3.dtick < e3._minDtick * 2 && (e3.dtick = e3._minDtick, e3.tick0 = e3.l2r(e3._forceTick0));\n              }\n              e3.ticklabelmode === "period" && jst(e3), e3.tick0 || (e3.tick0 = e3.type === "date" ? "2000-01-01" : 0), e3.type === "date" && e3.dtick < 0.1 && (e3.dtick = 0.1), Mse(e3);\n            };\n            function aB(e3) {\n              return +e3.substring(1);\n            }\n            function jst(e3) {\n              var t3;\n              function r4() {\n                return !(Ih(e3.dtick) || e3.dtick.charAt(0) !== "M");\n              }\n              var n4 = r4(), i3 = Qn.getTickFormat(e3);\n              if (i3) {\n                var a4 = e3._dtickInit !== e3.dtick;\n                /%[fLQsSMX]/.test(i3) || (/%[HI]/.test(i3) ? (t3 = xm, a4 && !n4 && e3.dtick < xm && (e3.dtick = xm)) : /%p/.test(i3) ? (t3 = s_, a4 && !n4 && e3.dtick < s_ && (e3.dtick = s_)) : /%[Aadejuwx]/.test(i3) ? (t3 = Ov, a4 && !n4 && e3.dtick < Ov && (e3.dtick = Ov)) : /%[UVW]/.test(i3) ? (t3 = Zp, a4 && !n4 && e3.dtick < Zp && (e3.dtick = Zp)) : /%[Bbm]/.test(i3) ? (t3 = z3, a4 && (n4 ? aB(e3.dtick) < 1 : e3.dtick < ML) && (e3.dtick = "M1")) : /%[q]/.test(i3) ? (t3 = sB, a4 && (n4 ? aB(e3.dtick) < 3 : e3.dtick < SL) && (e3.dtick = "M3")) : /%[Yy]/.test(i3) && (t3 = TL, a4 && (n4 ? aB(e3.dtick) < 12 : e3.dtick < AL) && (e3.dtick = "M12")));\n              }\n              n4 = r4(), n4 && e3.tick0 === e3._dowTick0 && (e3.tick0 = e3._rawTick0), e3._definedDelta = t3;\n            }\n            function Wst(e3, t3, r4) {\n              for (var n4 = 0; n4 < e3.length; n4++) {\n                var i3 = e3[n4].value, a4 = n4, o4 = n4 + 1;\n                n4 < e3.length - 1 ? (a4 = n4, o4 = n4 + 1) : n4 > 0 ? (a4 = n4 - 1, o4 = n4) : (a4 = n4, o4 = n4);\n                var s3 = e3[a4].value, l3 = e3[o4].value, u4 = Math.abs(l3 - s3), c5 = r4 || u4, f4 = 0;\n                c5 >= AL ? u4 >= AL && u4 <= Ist ? f4 = u4 : f4 = TL : r4 === sB && c5 >= SL ? u4 >= SL && u4 <= Rst ? f4 = u4 : f4 = sB : c5 >= ML ? u4 >= ML && u4 <= Dst ? f4 = u4 : f4 = z3 : r4 === Zp && c5 >= Zp ? f4 = Zp : c5 >= Ov ? f4 = Ov : r4 === s_ && c5 >= s_ ? f4 = s_ : r4 === xm && c5 >= xm && (f4 = xm);\n                var h3;\n                f4 >= u4 && (f4 = u4, h3 = true);\n                var d3 = i3 + f4;\n                if (t3.rangebreaks && f4 > 0) {\n                  for (var v3 = 84, _2 = 0, b = 0; b < v3; b++) {\n                    var p3 = (b + 0.5) / v3;\n                    t3.maskBreaks(i3 * (1 - p3) + p3 * d3) !== CL && _2++;\n                  }\n                  f4 *= _2 / v3, f4 || (e3[n4].drop = true), h3 && u4 > Zp && (f4 = u4);\n                }\n                (f4 > 0 || n4 === 0) && (e3[n4].periodX = i3 + f4 / 2);\n              }\n            }\n            Qn.calcTicks = function(t3, r4) {\n              for (var n4 = t3.type, i3 = t3.calendar, a4 = t3.ticklabelstep, o4 = t3.ticklabelmode === "period", s3 = t3.range[0] > t3.range[1], l3 = !t3.ticklabelindex || Jo.isArrayOrTypedArray(t3.ticklabelindex) ? t3.ticklabelindex : [t3.ticklabelindex], u4 = Jo.simpleMap(t3.range, t3.r2l, void 0, void 0, r4), c5 = u4[1] < u4[0], f4 = Math.min(u4[0], u4[1]), h3 = Math.max(u4[0], u4[1]), d3 = Math.max(1e3, t3._length || 0), v3 = [], _2 = [], b = [], p3 = [], k4 = [], E3 = t3.minor && (t3.minor.ticks || t3.minor.showgrid), S2 = 1; S2 >= (E3 ? 0 : 1); S2--) {\n                var L3 = !S2;\n                S2 ? (t3._dtickInit = t3.dtick, t3._tick0Init = t3.tick0) : (t3.minor._dtickInit = t3.minor.dtick, t3.minor._tick0Init = t3.minor.tick0);\n                var x2 = S2 ? t3 : Jo.extendFlat({}, t3, t3.minor);\n                if (L3 ? Qn.prepMinorTicks(x2, t3, r4) : Qn.prepTicks(x2, r4), x2.tickmode === "array") {\n                  S2 ? (b = [], v3 = gse(t3, !L3)) : (p3 = [], _2 = gse(t3, !L3));\n                  continue;\n                }\n                if (x2.tickmode === "sync") {\n                  b = [], v3 = Xst(t3);\n                  continue;\n                }\n                var C3 = vB(u4), M4 = C3[0], g3 = C3[1], P3 = Ih(x2.dtick), T3 = n4 === "log" && !(P3 || x2.dtick.charAt(0) === "L"), z4 = Qn.tickFirst(x2, r4);\n                if (S2) {\n                  if (t3._tmin = z4, z4 < M4 !== c5) break;\n                  (n4 === "category" || n4 === "multicategory") && (g3 = c5 ? Math.max(-0.5, g3) : Math.min(t3._categories.length - 0.5, g3));\n                }\n                var O4 = null, V2 = z4, G2;\n                if (S2) {\n                  var Z;\n                  P3 ? Z = t3.dtick : n4 === "date" ? typeof t3.dtick == "string" && t3.dtick.charAt(0) === "M" && (Z = z3 * t3.dtick.substring(1)) : Z = t3._roughDTick, G2 = Math.round((t3.r2l(V2) - t3.r2l(t3.tick0)) / Z) - 1;\n                }\n                var j3 = x2.dtick;\n                for (x2.rangebreaks && x2._tick0Init !== x2.tick0 && (V2 = oB(V2, t3), c5 || (V2 = Qn.tickIncrement(V2, j3, !c5, i3))), S2 && o4 && (V2 = Qn.tickIncrement(V2, j3, !c5, i3), G2--); c5 ? V2 >= g3 : V2 <= g3; V2 = Qn.tickIncrement(V2, j3, c5, i3)) {\n                  if (S2 && G2++, x2.rangebreaks && !c5) {\n                    if (V2 < M4) continue;\n                    if (x2.maskBreaks(V2) === CL && oB(V2, x2) >= h3) break;\n                  }\n                  if (b.length > d3 || V2 === O4) break;\n                  O4 = V2;\n                  var N2 = { value: V2 };\n                  S2 ? (T3 && V2 !== (V2 | 0) && (N2.simpleLabel = true), a4 > 1 && G2 % a4 && (N2.skipLabel = true), b.push(N2)) : (N2.minor = true, p3.push(N2));\n                }\n              }\n              if (!p3 || p3.length < 2) l3 = false;\n              else {\n                var H = (p3[1].value - p3[0].value) * (s3 ? -1 : 1);\n                ylt(H, t3.tickformat) || (l3 = false);\n              }\n              if (!l3) k4 = b;\n              else {\n                var te = b.concat(p3);\n                o4 && b.length && (te = te.slice(1)), te = te.sort(function(Gt, Nt) {\n                  return Gt.value - Nt.value;\n                }).filter(function(Gt, Nt, Jt) {\n                  return Nt === 0 || Gt.value !== Jt[Nt - 1].value;\n                });\n                var oe = te.map(function(Gt, Nt) {\n                  return Gt.minor === void 0 && !Gt.skipLabel ? Nt : null;\n                }).filter(function(Gt) {\n                  return Gt !== null;\n                });\n                oe.forEach(function(Gt) {\n                  l3.map(function(Nt) {\n                    var Jt = Gt + Nt;\n                    Jt >= 0 && Jt < te.length && Jo.pushUnique(k4, te[Jt]);\n                  });\n                });\n              }\n              if (E3) {\n                var _e = t3.minor.ticks === "inside" && t3.ticks === "outside" || t3.minor.ticks === "outside" && t3.ticks === "inside";\n                if (!_e) {\n                  for (var Ee = b.map(function(Gt) {\n                    return Gt.value;\n                  }), Ce = [], me = 0; me < p3.length; me++) {\n                    var ie = p3[me], Se = ie.value;\n                    if (Ee.indexOf(Se) === -1) {\n                      for (var Le = false, Ae = 0; !Le && Ae < b.length; Ae++) 1e7 + b[Ae].value === 1e7 + Se && (Le = true);\n                      Le || Ce.push(ie);\n                    }\n                  }\n                  p3 = Ce;\n                }\n              }\n              o4 && Wst(k4, t3, t3._definedDelta);\n              var Fe;\n              if (t3.rangebreaks) {\n                var Pe = t3._id.charAt(0) === "y", ge = 1;\n                t3.tickmode === "auto" && (ge = t3.tickfont ? t3.tickfont.size : 12);\n                var Re = NaN;\n                for (Fe = b.length - 1; Fe > -1; Fe--) {\n                  if (b[Fe].drop) {\n                    b.splice(Fe, 1);\n                    continue;\n                  }\n                  b[Fe].value = oB(b[Fe].value, t3);\n                  var ce = t3.c2p(b[Fe].value);\n                  (Pe ? Re > ce - ge : Re < ce + ge) ? b.splice(c5 ? Fe + 1 : Fe, 1) : Re = ce;\n                }\n              }\n              yB(t3) && Math.abs(u4[1] - u4[0]) === 360 && b.pop(), t3._tmax = (b[b.length - 1] || {}).value, t3._prevDateHead = "", t3._inCalcTicks = true;\n              var Ze, ut = function(Gt) {\n                Gt.text = "", t3._prevDateHead = Ze;\n              };\n              b = b.concat(p3);\n              function pt(Gt, Nt) {\n                var Jt = Qn.tickText(Gt, Nt.value, false, Nt.simpleLabel), sr = Nt.periodX;\n                return sr !== void 0 && (Jt.periodX = sr, (sr > h3 || sr < f4) && (sr > h3 && (Jt.periodX = h3), sr < f4 && (Jt.periodX = f4), ut(Jt))), Jt;\n              }\n              var Zt;\n              for (Fe = 0; Fe < b.length; Fe++) {\n                var st = b[Fe].minor, lt = b[Fe].value;\n                st ? (l3 && k4.indexOf(b[Fe]) !== -1 ? Zt = pt(t3, b[Fe]) : Zt = { x: lt }, Zt.minor = true, _2.push(Zt)) : (Ze = t3._prevDateHead, Zt = pt(t3, b[Fe]), (b[Fe].skipLabel || l3 && k4.indexOf(b[Fe]) === -1) && ut(Zt), v3.push(Zt));\n              }\n              return v3 = v3.concat(_2), t3._inCalcTicks = false, o4 && v3.length && (v3[0].noTick = true), v3;\n            };\n            function Tse(e3, t3) {\n              return e3.rangebreaks && (t3 = t3.filter(function(r4) {\n                return e3.maskBreaks(r4.x) !== CL;\n              })), t3;\n            }\n            function Xst(e3) {\n              var t3 = e3._mainAxis, r4 = [];\n              if (t3._vals) {\n                for (var n4 = 0; n4 < t3._vals.length; n4++) if (!t3._vals[n4].noTick) {\n                  var i3 = t3.l2p(t3._vals[n4].x), a4 = e3.p2l(i3), o4 = Qn.tickText(e3, a4);\n                  t3._vals[n4].minor && (o4.minor = true, o4.text = ""), r4.push(o4);\n                }\n              }\n              return r4 = Tse(e3, r4), r4;\n            }\n            function gse(e3, t3) {\n              var r4 = Jo.simpleMap(e3.range, e3.r2l), n4 = vB(r4), i3 = Math.min(n4[0], n4[1]), a4 = Math.max(n4[0], n4[1]), o4 = e3.type === "category" ? e3.d2l_noadd : e3.d2l;\n              e3.type === "log" && String(e3.dtick).charAt(0) !== "L" && (e3.dtick = "L" + Math.pow(10, Math.floor(Math.min(e3.range[0], e3.range[1])) - 1));\n              for (var s3 = [], l3 = 0; l3 <= 1; l3++) if (!(t3 !== void 0 && (t3 && l3 || t3 === false && !l3)) && !(l3 && !e3.minor)) {\n                var u4 = l3 ? e3.minor.tickvals : e3.tickvals, c5 = l3 ? [] : e3.ticktext;\n                if (u4) {\n                  Jo.isArrayOrTypedArray(c5) || (c5 = []);\n                  for (var f4 = 0; f4 < u4.length; f4++) {\n                    var h3 = o4(u4[f4]);\n                    if (h3 > i3 && h3 < a4) {\n                      var d3 = Qn.tickText(e3, h3, false, String(c5[f4]));\n                      l3 && (d3.minor = true, d3.text = ""), s3.push(d3);\n                    }\n                  }\n                }\n              }\n              return s3 = Tse(e3, s3), s3;\n            }\n            var bL = [2, 5, 10], mse = [1, 2, 3, 6, 12], yse = [1, 2, 5, 10, 15, 30], Zst = [1, 2, 3, 7, 14], Ase = [-0.046, 0, 0.301, 0.477, 0.602, 0.699, 0.778, 0.845, 0.903, 0.954, 1], Sse = [-0.301, 0, 0.301, 0.699, 1], Yst = [15, 30, 45, 90, 180];\n            function _m(e3, t3, r4) {\n              return t3 * Jo.roundUp(e3 / t3, r4);\n            }\n            Qn.autoTicks = function(e3, t3, r4) {\n              var n4;\n              function i3(f4) {\n                return Math.pow(f4, Math.floor(Math.log(t3) / Math.LN10));\n              }\n              if (e3.type === "date") {\n                e3.tick0 = Jo.dateTick0(e3.calendar, 0);\n                var a4 = 2 * t3;\n                if (a4 > TL) t3 /= TL, n4 = i3(10), e3.dtick = "M" + 12 * _m(t3, n4, bL);\n                else if (a4 > z3) t3 /= z3, e3.dtick = "M" + _m(t3, 1, mse);\n                else if (a4 > Ov) {\n                  if (e3.dtick = _m(t3, Ov, e3._hasDayOfWeekBreaks ? [1, 2, 7, 14] : Zst), !r4) {\n                    var o4 = Qn.getTickFormat(e3), s3 = e3.ticklabelmode === "period";\n                    s3 && (e3._rawTick0 = e3.tick0), /%[uVW]/.test(o4) ? e3.tick0 = Jo.dateTick0(e3.calendar, 2) : e3.tick0 = Jo.dateTick0(e3.calendar, 1), s3 && (e3._dowTick0 = e3.tick0);\n                  }\n                } else a4 > xm ? e3.dtick = _m(t3, xm, mse) : a4 > sM ? e3.dtick = _m(t3, sM, yse) : a4 > EL ? e3.dtick = _m(t3, EL, yse) : (n4 = i3(10), e3.dtick = _m(t3, n4, bL));\n              } else if (e3.type === "log") {\n                e3.tick0 = 0;\n                var l3 = Jo.simpleMap(e3.range, e3.r2l);\n                if (e3._isMinor && (t3 *= 1.5), t3 > 0.7) e3.dtick = Math.ceil(t3);\n                else if (Math.abs(l3[1] - l3[0]) < 1) {\n                  var u4 = 1.5 * Math.abs((l3[1] - l3[0]) / t3);\n                  t3 = Math.abs(Math.pow(10, l3[1]) - Math.pow(10, l3[0])) / u4, n4 = i3(10), e3.dtick = "L" + _m(t3, n4, bL);\n                } else e3.dtick = t3 > 0.3 ? "D2" : "D1";\n              } else e3.type === "category" || e3.type === "multicategory" ? (e3.tick0 = 0, e3.dtick = Math.ceil(Math.max(t3, 1))) : yB(e3) ? (e3.tick0 = 0, n4 = 1, e3.dtick = _m(t3, n4, Yst)) : (e3.tick0 = 0, n4 = i3(10), e3.dtick = _m(t3, n4, bL));\n              if (e3.dtick === 0 && (e3.dtick = 1), !Ih(e3.dtick) && typeof e3.dtick != "string") {\n                var c5 = e3.dtick;\n                throw e3.dtick = 1, "ax.dtick error: " + String(c5);\n              }\n            };\n            function Mse(e3) {\n              var t3 = e3.dtick;\n              if (e3._tickexponent = 0, !Ih(t3) && typeof t3 != "string" && (t3 = 1), (e3.type === "category" || e3.type === "multicategory") && (e3._tickround = null), e3.type === "date") {\n                var r4 = e3.r2l(e3.tick0), n4 = e3.l2r(r4).replace(/(^-|i)/g, ""), i3 = n4.length;\n                if (String(t3).charAt(0) === "M") i3 > 10 || n4.slice(5) !== "01-01" ? e3._tickround = "d" : e3._tickround = +t3.slice(1) % 12 === 0 ? "y" : "m";\n                else if (t3 >= Ov && i3 <= 10 || t3 >= Ov * 15) e3._tickround = "d";\n                else if (t3 >= sM && i3 <= 16 || t3 >= xm) e3._tickround = "M";\n                else if (t3 >= EL && i3 <= 19 || t3 >= sM) e3._tickround = "S";\n                else {\n                  var a4 = e3.l2r(r4 + t3).replace(/^-/, "").length;\n                  e3._tickround = Math.max(i3, a4) - 20, e3._tickround < 0 && (e3._tickround = 4);\n                }\n              } else if (Ih(t3) || t3.charAt(0) === "L") {\n                var o4 = e3.range.map(e3.r2d || Number);\n                Ih(t3) || (t3 = Number(t3.slice(1))), e3._tickround = 2 - Math.floor(Math.log(t3) / Math.LN10 + 0.01);\n                var s3 = Math.max(Math.abs(o4[0]), Math.abs(o4[1])), l3 = Math.floor(Math.log(s3) / Math.LN10 + 0.01), u4 = e3.minexponent === void 0 ? 3 : e3.minexponent;\n                Math.abs(l3) > u4 && (O3(e3.exponentformat) && e3.exponentformat !== "SI extended" && !pB(l3) || O3(e3.exponentformat) && e3.exponentformat === "SI extended" && !gB(l3) ? e3._tickexponent = 3 * Math.round((l3 - 1) / 3) : e3._tickexponent = l3);\n              } else e3._tickround = null;\n            }\n            Qn.tickIncrement = function(e3, t3, r4, n4) {\n              var i3 = r4 ? -1 : 1;\n              if (Ih(t3)) return Jo.increment(e3, i3 * t3);\n              var a4 = t3.charAt(0), o4 = i3 * Number(t3.slice(1));\n              if (a4 === "M") return Jo.incrementMonth(e3, o4, n4);\n              if (a4 === "L") return Math.log(Math.pow(10, e3) + o4) / Math.LN10;\n              if (a4 === "D") {\n                var s3 = t3 === "D2" ? Sse : Ase, l3 = e3 + i3 * 0.01, u4 = Jo.roundUp(Jo.mod(l3, 1), s3, r4);\n                return Math.floor(l3) + Math.log(b0.round(Math.pow(10, u4), 1)) / Math.LN10;\n              }\n              throw "unrecognized dtick " + String(t3);\n            };\n            Qn.tickFirst = function(e3, t3) {\n              var r4 = e3.r2l || Number, n4 = Jo.simpleMap(e3.range, r4, void 0, void 0, t3), i3 = n4[1] < n4[0], a4 = i3 ? Math.floor : Math.ceil, o4 = vB(n4)[0], s3 = e3.dtick, l3 = r4(e3.tick0);\n              if (Ih(s3)) {\n                var u4 = a4((o4 - l3) / s3) * s3 + l3;\n                return (e3.type === "category" || e3.type === "multicategory") && (u4 = Jo.constrain(u4, 0, e3._categories.length - 1)), u4;\n              }\n              var c5 = s3.charAt(0), f4 = Number(s3.slice(1));\n              if (c5 === "M") {\n                for (var h3 = 0, d3 = l3, v3, _2, b; h3 < 10; ) {\n                  if (v3 = Qn.tickIncrement(d3, s3, i3, e3.calendar), (v3 - o4) * (d3 - o4) <= 0) return i3 ? Math.min(d3, v3) : Math.max(d3, v3);\n                  _2 = (o4 - (d3 + v3) / 2) / (v3 - d3), b = c5 + (Math.abs(Math.round(_2)) || 1) * f4, d3 = Qn.tickIncrement(d3, b, _2 < 0 ? !i3 : i3, e3.calendar), h3++;\n                }\n                return Jo.error("tickFirst did not converge", e3), d3;\n              } else {\n                if (c5 === "L") return Math.log(a4((Math.pow(10, o4) - l3) / f4) * f4 + l3) / Math.LN10;\n                if (c5 === "D") {\n                  var p3 = s3 === "D2" ? Sse : Ase, k4 = Jo.roundUp(Jo.mod(o4, 1), p3, i3);\n                  return Math.floor(o4) + Math.log(b0.round(Math.pow(10, k4), 1)) / Math.LN10;\n                } else throw "unrecognized dtick " + String(s3);\n              }\n            };\n            Qn.tickText = function(e3, t3, r4, n4) {\n              var i3 = Ese(e3, t3), a4 = e3.tickmode === "array", o4 = r4 || a4, s3 = e3.type, l3 = s3 === "category" ? e3.d2l_noadd : e3.d2l, u4, c5 = function(b) {\n                var p3 = e3.l2p(b);\n                return p3 >= 0 && p3 <= e3._length ? b : null;\n              };\n              if (a4 && Jo.isArrayOrTypedArray(e3.ticktext)) {\n                var f4 = Jo.simpleMap(e3.range, e3.r2l), h3 = (Math.abs(f4[1] - f4[0]) - (e3._lBreaks || 0)) / 1e4;\n                for (u4 = 0; u4 < e3.ticktext.length && !(Math.abs(t3 - l3(e3.tickvals[u4])) < h3); u4++) ;\n                if (u4 < e3.ticktext.length) return i3.text = String(e3.ticktext[u4]), i3.xbnd = [c5(i3.x - 0.5), c5(i3.x + e3.dtick - 0.5)], i3;\n              }\n              function d3(b) {\n                if (b === void 0) return true;\n                if (r4) return b === "none";\n                var p3 = { first: e3._tmin, last: e3._tmax }[b];\n                return b !== "all" && t3 !== p3;\n              }\n              var v3 = r4 ? "never" : e3.exponentformat !== "none" && d3(e3.showexponent) ? "hide" : "";\n              if (s3 === "date" ? Kst(e3, i3, r4, o4) : s3 === "log" ? Jst(e3, i3, r4, o4, v3) : s3 === "category" ? $st(e3, i3) : s3 === "multicategory" ? Qst(e3, i3, r4) : yB(e3) ? tlt(e3, i3, r4, o4, v3) : elt(e3, i3, r4, o4, v3), n4 || (e3.tickprefix && !d3(e3.showtickprefix) && (i3.text = e3.tickprefix + i3.text), e3.ticksuffix && !d3(e3.showticksuffix) && (i3.text += e3.ticksuffix)), e3.labelalias && e3.labelalias.hasOwnProperty(i3.text)) {\n                var _2 = e3.labelalias[i3.text];\n                typeof _2 == "string" && (i3.text = _2);\n              }\n              return (e3.tickson === "boundaries" || e3.showdividers) && (i3.xbnd = [c5(i3.x - 0.5), c5(i3.x + e3.dtick - 0.5)]), i3;\n            };\n            Qn.hoverLabelText = function(e3, t3, r4) {\n              r4 && (e3 = Jo.extendFlat({}, e3, { hoverformat: r4 }));\n              var n4 = Jo.isArrayOrTypedArray(t3) ? t3[0] : t3, i3 = Jo.isArrayOrTypedArray(t3) ? t3[1] : void 0;\n              if (i3 !== void 0 && i3 !== n4) return Qn.hoverLabelText(e3, n4, r4) + " - " + Qn.hoverLabelText(e3, i3, r4);\n              var a4 = e3.type === "log" && n4 <= 0, o4 = Qn.tickText(e3, e3.c2l(a4 ? -n4 : n4), "hover").text;\n              return a4 ? n4 === 0 ? "0" : Cb + o4 : o4;\n            };\n            function Ese(e3, t3, r4) {\n              var n4 = e3.tickfont || {};\n              return { x: t3, dx: 0, dy: 0, text: r4 || "", fontSize: n4.size, font: n4.family, fontWeight: n4.weight, fontStyle: n4.style, fontVariant: n4.variant, fontTextcase: n4.textcase, fontLineposition: n4.lineposition, fontShadow: n4.shadow, fontColor: n4.color };\n            }\n            function Kst(e3, t3, r4, n4) {\n              var i3 = e3._tickround, a4 = r4 && e3.hoverformat || Qn.getTickFormat(e3);\n              n4 = !a4 && n4, n4 && (Ih(i3) ? i3 = 4 : i3 = { y: "m", m: "d", d: "M", M: "S", S: 4 }[i3]);\n              var o4 = Jo.formatDate(t3.x, a4, i3, e3._dateFormat, e3.calendar, e3._extraFormat), s3, l3 = o4.indexOf(`\n`);\n              if (l3 !== -1 && (s3 = o4.slice(l3 + 1), o4 = o4.slice(0, l3)), n4 && (s3 !== void 0 && (o4 === "00:00:00" || o4 === "00:00") ? (o4 = s3, s3 = "") : o4.length === 8 && (o4 = o4.replace(/:00$/, ""))), s3) if (r4) i3 === "d" ? o4 += ", " + s3 : o4 = s3 + (o4 ? ", " + o4 : "");\n              else if (!e3._inCalcTicks || e3._prevDateHead !== s3) e3._prevDateHead = s3, o4 += "<br>" + s3;\n              else {\n                var u4 = cM(e3), c5 = e3._trueSide || e3.side;\n                (!u4 && c5 === "top" || u4 && c5 === "bottom") && (o4 += "<br> ");\n              }\n              t3.text = o4;\n            }\n            function Jst(e3, t3, r4, n4, i3) {\n              var a4 = e3.dtick, o4 = t3.x, s3 = e3.tickformat, l3 = typeof a4 == "string" && a4.charAt(0);\n              if (i3 === "never" && (i3 = ""), n4 && l3 !== "L" && (a4 = "L3", l3 = "L"), s3 || l3 === "L") t3.text = uM(Math.pow(10, o4), e3, i3, n4);\n              else if (Ih(a4) || l3 === "D" && (e3.minorloglabels === "complete" || Jo.mod(o4 + 0.01, 1) < 0.1)) {\n                var u4;\n                e3.minorloglabels === "complete" && !(Jo.mod(o4 + 0.01, 1) < 0.1) && (u4 = true, t3.fontSize *= 0.75);\n                var c5 = Math.pow(10, o4).toExponential(0), f4 = c5.split("e"), h3 = +f4[1], d3 = Math.abs(h3), v3 = e3.exponentformat;\n                v3 === "power" || O3(v3) && v3 !== "SI extended" && pB(h3) || O3(v3) && v3 === "SI extended" && gB(h3) ? (t3.text = f4[0], d3 > 0 && (t3.text += "x10"), t3.text === "1x10" && (t3.text = "10"), h3 !== 0 && h3 !== 1 && (t3.text += "<sup>" + (h3 > 0 ? "" : Cb) + d3 + "</sup>"), t3.fontSize *= 1.25) : (v3 === "e" || v3 === "E") && d3 > 2 ? t3.text = f4[0] + v3 + (h3 > 0 ? "+" : Cb) + d3 : (t3.text = uM(Math.pow(10, o4), e3, "", "fakehover"), a4 === "D1" && e3._id.charAt(0) === "y" && (t3.dy -= t3.fontSize / 6));\n              } else if (l3 === "D") t3.text = e3.minorloglabels === "none" ? "" : String(Math.round(Math.pow(10, Jo.mod(o4, 1)))), t3.fontSize *= 0.75;\n              else throw "unrecognized dtick " + String(a4);\n              if (e3.dtick === "D1") {\n                var _2 = String(t3.text).charAt(0);\n                (_2 === "0" || _2 === "1") && (e3._id.charAt(0) === "y" ? t3.dx -= t3.fontSize / 4 : (t3.dy += t3.fontSize / 2, t3.dx += (e3.range[1] > e3.range[0] ? 1 : -1) * t3.fontSize * (o4 < 0 ? 0.5 : 0.25)));\n              }\n            }\n            function $st(e3, t3) {\n              var r4 = e3._categories[Math.round(t3.x)];\n              r4 === void 0 && (r4 = ""), t3.text = String(r4);\n            }\n            function Qst(e3, t3, r4) {\n              var n4 = Math.round(t3.x), i3 = e3._categories[n4] || [], a4 = i3[1] === void 0 ? "" : String(i3[1]), o4 = i3[0] === void 0 ? "" : String(i3[0]);\n              r4 ? t3.text = o4 + " - " + a4 : (t3.text = a4, t3.text2 = o4);\n            }\n            function elt(e3, t3, r4, n4, i3) {\n              i3 === "never" ? i3 = "" : e3.showexponent === "all" && Math.abs(t3.x / e3.dtick) < 1e-6 && (i3 = "hide"), t3.text = uM(t3.x, e3, i3, n4);\n            }\n            function tlt(e3, t3, r4, n4, i3) {\n              if (e3.thetaunit === "radians" && !r4) {\n                var a4 = t3.x / 180;\n                if (a4 === 0) t3.text = "0";\n                else {\n                  var o4 = rlt(a4);\n                  if (o4[1] >= 100) t3.text = uM(Jo.deg2rad(t3.x), e3, i3, n4);\n                  else {\n                    var s3 = t3.x < 0;\n                    o4[1] === 1 ? o4[0] === 1 ? t3.text = "\\u03C0" : t3.text = o4[0] + "\\u03C0" : t3.text = ["<sup>", o4[0], "</sup>", "\\u2044", "<sub>", o4[1], "</sub>", "\\u03C0"].join(""), s3 && (t3.text = Cb + t3.text);\n                  }\n                }\n              } else t3.text = uM(t3.x, e3, i3, n4);\n            }\n            function rlt(e3) {\n              function t3(s3, l3) {\n                return Math.abs(s3 - l3) <= 1e-6;\n              }\n              function r4(s3, l3) {\n                return t3(l3, 0) ? s3 : r4(l3, s3 % l3);\n              }\n              function n4(s3) {\n                for (var l3 = 1; !t3(Math.round(s3 * l3) / l3, s3); ) l3 *= 10;\n                return l3;\n              }\n              var i3 = n4(e3), a4 = e3 * i3, o4 = Math.abs(r4(a4, i3));\n              return [Math.round(a4 / o4), Math.round(i3 / o4)];\n            }\n            var kse = ["f", "p", "n", "\\u03BC", "m", "", "k", "M", "G", "T"], ilt = ["q", "r", "y", "z", "a", ...kse, "P", "E", "Z", "Y", "R", "Q"], O3 = (e3) => ["SI", "SI extended", "B"].includes(e3);\n            function pB(e3) {\n              return e3 > 14 || e3 < -15;\n            }\n            function gB(e3) {\n              return e3 > 32 || e3 < -30;\n            }\n            function nlt(e3, t3) {\n              return O3(t3) ? !!(t3 === "SI extended" && gB(e3) || t3 !== "SI extended" && pB(e3)) : false;\n            }\n            function uM(e3, t3, r4, n4) {\n              var i3 = e3 < 0, a4 = t3._tickround, o4 = r4 || t3.exponentformat || "B", s3 = t3._tickexponent, l3 = Qn.getTickFormat(t3), u4 = t3.separatethousands;\n              if (n4) {\n                var c5 = { exponentformat: o4, minexponent: t3.minexponent, dtick: t3.showexponent === "none" ? t3.dtick : Ih(e3) && Math.abs(e3) || 1, range: t3.showexponent === "none" ? t3.range.map(t3.r2d) : [0, e3 || 1] };\n                Mse(c5), a4 = (Number(c5._tickround) || 0) + 4, s3 = c5._tickexponent, t3.hoverformat && (l3 = t3.hoverformat);\n              }\n              if (l3) return t3._numFormat(l3)(e3).replace(/-/g, Cb);\n              var f4 = Math.pow(10, -a4) / 2;\n              if (o4 === "none" && (s3 = 0), e3 = Math.abs(e3), e3 < f4) e3 = "0", i3 = false;\n              else {\n                if (e3 += f4, s3 && (e3 *= Math.pow(10, -s3), a4 += s3), a4 === 0) e3 = String(Math.floor(e3));\n                else if (a4 < 0) {\n                  e3 = String(Math.round(e3)), e3 = e3.slice(0, Math.max(0, e3.length + a4));\n                  for (var h3 = a4; h3 < 0; h3++) e3 += "0";\n                } else {\n                  e3 = String(e3);\n                  var d3 = e3.indexOf(".") + 1;\n                  d3 && (e3 = e3.slice(0, d3 + a4).replace(/\\.?0+$/, ""));\n                }\n                e3 = Jo.numSeparate(e3, t3._separators, u4);\n              }\n              if (s3 && o4 !== "hide") {\n                nlt(s3, o4) && (o4 = "power");\n                var v3;\n                s3 < 0 ? v3 = Cb + -s3 : o4 !== "power" ? v3 = "+" + s3 : v3 = String(s3), o4 === "e" || o4 === "E" ? e3 += o4 + v3 : o4 === "power" ? e3 += "\\xD710<sup>" + v3 + "</sup>" : o4 === "B" && s3 === 9 ? e3 += "B" : O3(o4) && (e3 += o4 === "SI extended" ? ilt[s3 / 3 + 10] : kse[s3 / 3 + 5]);\n              }\n              return i3 ? Cb + e3 : e3;\n            }\n            Qn.getTickFormat = function(e3) {\n              var t3;\n              function r4(l3) {\n                return typeof l3 != "string" ? l3 : Number(l3.replace("M", "")) * z3;\n              }\n              function n4(l3, u4) {\n                var c5 = ["L", "D"];\n                if (typeof l3 == typeof u4) {\n                  if (typeof l3 == "number") return l3 - u4;\n                  var f4 = c5.indexOf(l3.charAt(0)), h3 = c5.indexOf(u4.charAt(0));\n                  return f4 === h3 ? Number(l3.replace(/(L|D)/g, "")) - Number(u4.replace(/(L|D)/g, "")) : f4 - h3;\n                } else return typeof l3 == "number" ? 1 : -1;\n              }\n              function i3(l3, u4, c5) {\n                var f4 = c5 || function(v3) {\n                  return v3;\n                }, h3 = u4[0], d3 = u4[1];\n                return (!h3 && typeof h3 != "number" || f4(h3) <= f4(l3)) && (!d3 && typeof d3 != "number" || f4(d3) >= f4(l3));\n              }\n              function a4(l3, u4) {\n                var c5 = u4[0] === null, f4 = u4[1] === null, h3 = n4(l3, u4[0]) >= 0, d3 = n4(l3, u4[1]) <= 0;\n                return (c5 || h3) && (f4 || d3);\n              }\n              var o4, s3;\n              if (e3.tickformatstops && e3.tickformatstops.length > 0) switch (e3.type) {\n                case "date":\n                case "linear": {\n                  for (t3 = 0; t3 < e3.tickformatstops.length; t3++) if (s3 = e3.tickformatstops[t3], s3.enabled && i3(e3.dtick, s3.dtickrange, r4)) {\n                    o4 = s3;\n                    break;\n                  }\n                  break;\n                }\n                case "log": {\n                  for (t3 = 0; t3 < e3.tickformatstops.length; t3++) if (s3 = e3.tickformatstops[t3], s3.enabled && a4(e3.dtick, s3.dtickrange)) {\n                    o4 = s3;\n                    break;\n                  }\n                  break;\n                }\n                default:\n              }\n              return o4 ? o4.value : e3.tickformat;\n            };\n            Qn.getSubplots = function(e3, t3) {\n              var r4 = e3._fullLayout._subplots, n4 = r4.cartesian.concat(r4.gl2d || []), i3 = t3 ? Qn.findSubplotsWithAxis(n4, t3) : n4;\n              return i3.sort(function(a4, o4) {\n                var s3 = a4.slice(1).split("y"), l3 = o4.slice(1).split("y");\n                return s3[0] === l3[0] ? +s3[1] - +l3[1] : +s3[0] - +l3[0];\n              }), i3;\n            };\n            Qn.findSubplotsWithAxis = function(e3, t3) {\n              for (var r4 = new RegExp(t3._id.charAt(0) === "x" ? "^" + t3._id + "y" : t3._id + "$"), n4 = [], i3 = 0; i3 < e3.length; i3++) {\n                var a4 = e3[i3];\n                r4.test(a4) && n4.push(a4);\n              }\n              return n4;\n            };\n            Qn.makeClipPaths = function(e3) {\n              var t3 = e3._fullLayout;\n              if (!t3._hasOnlyLargeSploms) {\n                var r4 = { _offset: 0, _length: t3.width, _id: "" }, n4 = { _offset: 0, _length: t3.height, _id: "" }, i3 = Qn.list(e3, "x", true), a4 = Qn.list(e3, "y", true), o4 = [], s3, l3;\n                for (s3 = 0; s3 < i3.length; s3++) for (o4.push({ x: i3[s3], y: n4 }), l3 = 0; l3 < a4.length; l3++) s3 === 0 && o4.push({ x: r4, y: a4[l3] }), o4.push({ x: i3[s3], y: a4[l3] });\n                var u4 = t3._clips.selectAll(".axesclip").data(o4, function(c5) {\n                  return c5.x._id + c5.y._id;\n                });\n                u4.enter().append("clipPath").classed("axesclip", true).attr("id", function(c5) {\n                  return "clip" + t3._uid + c5.x._id + c5.y._id;\n                }).append("rect"), u4.exit().remove(), u4.each(function(c5) {\n                  b0.select(this).select("rect").attr({ x: c5.x._offset || 0, y: c5.y._offset || 0, width: c5.x._length || 1, height: c5.y._length || 1 });\n                });\n              }\n            };\n            Qn.draw = function(e3, t3, r4) {\n              var n4 = e3._fullLayout;\n              t3 === "redraw" && n4._paper.selectAll("g.subplot").each(function(l3) {\n                var u4 = l3[0], c5 = n4._plots[u4];\n                if (c5) {\n                  var f4 = c5.xaxis, h3 = c5.yaxis;\n                  c5.xaxislayer.selectAll("." + f4._id + "tick").remove(), c5.yaxislayer.selectAll("." + h3._id + "tick").remove(), c5.xaxislayer.selectAll("." + f4._id + "tick2").remove(), c5.yaxislayer.selectAll("." + h3._id + "tick2").remove(), c5.xaxislayer.selectAll("." + f4._id + "divider").remove(), c5.yaxislayer.selectAll("." + h3._id + "divider").remove(), c5.minorGridlayer && c5.minorGridlayer.selectAll("path").remove(), c5.gridlayer && c5.gridlayer.selectAll("path").remove(), c5.zerolinelayer && c5.zerolinelayer.selectAll("path").remove(), c5.zerolinelayerAbove && c5.zerolinelayerAbove.selectAll("path").remove(), n4._infolayer.select(".g-" + f4._id + "title").remove(), n4._infolayer.select(".g-" + h3._id + "title").remove();\n                }\n              });\n              var i3 = !t3 || t3 === "redraw" ? Qn.listIds(e3) : t3, a4 = Qn.list(e3), o4 = a4.filter(function(l3) {\n                return l3.autoshift;\n              }).map(function(l3) {\n                return l3.overlaying;\n              });\n              i3.map(function(l3) {\n                var u4 = Qn.getFromId(e3, l3);\n                if (u4.tickmode === "sync" && u4.overlaying) {\n                  var c5 = i3.findIndex(function(f4) {\n                    return f4 === u4.overlaying;\n                  });\n                  c5 >= 0 && i3.unshift(i3.splice(c5, 1).shift());\n                }\n              });\n              var s3 = { false: { left: 0, right: 0 } };\n              return Jo.syncOrAsync(i3.map(function(l3) {\n                return function() {\n                  if (l3) {\n                    var u4 = Qn.getFromId(e3, l3);\n                    r4 || (r4 = {}), r4.axShifts = s3, r4.overlayingShiftedAx = o4;\n                    var c5 = Qn.drawOne(e3, u4, r4);\n                    return u4._shiftPusher && dB(u4, u4._fullDepth || 0, s3, true), u4._r = u4.range.slice(), u4._rl = Jo.simpleMap(u4._r, u4.r2l), c5;\n                  }\n                };\n              }));\n            };\n            Qn.drawOne = function(e3, t3, r4) {\n              r4 = r4 || {};\n              var n4 = r4.axShifts || {}, i3 = r4.overlayingShiftedAx || [], a4, o4, s3;\n              t3.setScale();\n              var l3 = e3._fullLayout, u4 = t3._id, c5 = u4.charAt(0), f4 = Qn.counterLetter(u4), h3 = l3._plots[t3._mainSubplot], d3 = t3.zerolinelayer === "above traces";\n              if (!h3) return;\n              if (t3._shiftPusher = t3.autoshift || i3.indexOf(t3._id) !== -1 || i3.indexOf(t3.overlaying) !== -1, t3._shiftPusher & t3.anchor === "free") {\n                var v3 = t3.linewidth / 2 || 0;\n                t3.ticks === "inside" && (v3 += t3.ticklen), dB(t3, v3, n4, true), dB(t3, t3.shift || 0, n4, false);\n              }\n              (r4.skipTitle !== true || t3._shift === void 0) && (t3._shift = mlt(t3, n4));\n              var _2 = h3[c5 + "axislayer"], b = t3._mainLinePosition, p3 = b += t3._shift, k4 = t3._mainMirrorPosition, E3 = t3._vals = Qn.calcTicks(t3), S2 = [t3.mirror, p3, k4].join("_");\n              for (a4 = 0; a4 < E3.length; a4++) E3[a4].axInfo = S2;\n              t3._selections = {}, t3._tickAngles && (t3._prevTickAngles = t3._tickAngles), t3._tickAngles = {}, t3._depth = null;\n              var L3 = {};\n              function x2(lt) {\n                var Gt = u4 + (lt || "tick");\n                return L3[Gt] || (L3[Gt] = llt(t3, Gt, p3)), L3[Gt];\n              }\n              if (t3.visible) {\n                var C3 = Qn.makeTransTickFn(t3), M4 = Qn.makeTransTickLabelFn(t3), g3, P3, T3 = t3.ticks === "inside", z4 = t3.ticks === "outside";\n                if (t3.tickson === "boundaries") {\n                  var O4 = alt(t3, E3);\n                  P3 = Qn.clipEnds(t3, O4), g3 = T3 ? P3 : O4;\n                } else P3 = Qn.clipEnds(t3, E3), g3 = T3 && t3.ticklabelmode !== "period" ? P3 : E3;\n                var V2 = t3._gridVals = P3, G2 = slt(t3, E3);\n                if (!l3._hasOnlyLargeSploms) {\n                  var Z = t3._subplotsWith, j3 = {};\n                  for (a4 = 0; a4 < Z.length; a4++) {\n                    o4 = Z[a4], s3 = l3._plots[o4];\n                    var N2 = s3[f4 + "axis"], H = N2._mainAxis._id;\n                    if (!j3[H]) {\n                      j3[H] = 1;\n                      var te = c5 === "x" ? "M0," + N2._offset + "v" + N2._length : "M" + N2._offset + ",0h" + N2._length;\n                      Qn.drawGrid(e3, t3, { vals: V2, counterAxis: N2, layer: s3.gridlayer.select("." + u4), minorLayer: s3.minorGridlayer.select("." + u4), path: te, transFn: C3 }), Qn.drawZeroLine(e3, t3, { counterAxis: N2, layer: d3 ? s3.zerolinelayerAbove : s3.zerolinelayer, path: te, transFn: C3 });\n                    }\n                  }\n                }\n                var oe, _e = Qn.getTickSigns(t3), Ee = Qn.getTickSigns(t3, "minor");\n                if (t3.ticks || t3.minor && t3.minor.ticks) {\n                  var Ce = Qn.makeTickPath(t3, p3, _e[2]), me = Qn.makeTickPath(t3, p3, Ee[2], { minor: true }), ie, Se, Le, Ae;\n                  if (t3._anchorAxis && t3.mirror && t3.mirror !== true ? (ie = Qn.makeTickPath(t3, k4, _e[3]), Se = Qn.makeTickPath(t3, k4, Ee[3], { minor: true }), Le = Ce + ie, Ae = me + Se) : (ie = "", Se = "", Le = Ce, Ae = me), t3.showdividers && z4 && t3.tickson === "boundaries") {\n                    var Fe = {};\n                    for (a4 = 0; a4 < G2.length; a4++) Fe[G2[a4].x] = 1;\n                    oe = function(lt) {\n                      return Fe[lt.x] ? ie : Le;\n                    };\n                  } else oe = function(lt) {\n                    return lt.minor ? Ae : Le;\n                  };\n                }\n                if (Qn.drawTicks(e3, t3, { vals: g3, layer: _2, path: oe, transFn: C3 }), t3.mirror === "allticks") {\n                  var Pe = Object.keys(t3._linepositions || {});\n                  for (a4 = 0; a4 < Pe.length; a4++) {\n                    o4 = Pe[a4], s3 = l3._plots[o4];\n                    var ge = t3._linepositions[o4] || [], Re = ge[0], ce = ge[1], Ze = ge[2], ut = Qn.makeTickPath(t3, Re, Ze ? _e[0] : Ee[0], { minor: Ze }) + Qn.makeTickPath(t3, ce, Ze ? _e[1] : Ee[1], { minor: Ze });\n                    Qn.drawTicks(e3, t3, { vals: g3, layer: s3[c5 + "axislayer"], path: ut, transFn: C3 });\n                  }\n                }\n                var pt = [];\n                if (pt.push(function() {\n                  return Qn.drawLabels(e3, t3, { vals: E3, layer: _2, plotinfo: s3, transFn: M4, labelFns: Qn.makeLabelFns(t3, p3) });\n                }), t3.type === "multicategory") {\n                  var Zt = { x: 2, y: 10 }[c5];\n                  pt.push(function() {\n                    var lt = { x: "height", y: "width" }[c5], Gt = x2()[lt] + Zt + (t3._tickAngles[u4 + "tick"] ? t3.tickfont.size * lM : 0);\n                    return Qn.drawLabels(e3, t3, { vals: olt(t3, E3), layer: _2, cls: u4 + "tick2", repositionOnUpdate: true, secondary: true, transFn: C3, labelFns: Qn.makeLabelFns(t3, p3 + Gt * _e[4]) });\n                  }), pt.push(function() {\n                    return t3._depth = _e[4] * (x2("tick2")[t3.side] - p3), clt(e3, t3, { vals: G2, layer: _2, path: Qn.makeTickPath(t3, p3, _e[4], { len: t3._depth }), transFn: C3 });\n                  });\n                } else t3.title.hasOwnProperty("standoff") && pt.push(function() {\n                  t3._depth = _e[4] * (x2()[t3.side] - p3);\n                });\n                var st = aM.getComponentMethod("rangeslider", "isVisible")(t3);\n                return !r4.skipTitle && !(st && t3.side === "bottom") && pt.push(function() {\n                  return flt(e3, t3);\n                }), pt.push(function() {\n                  var lt = t3.side.charAt(0), Gt = Ost[t3.side].charAt(0), Nt = Qn.getPxPosition(e3, t3), Jt = z4 ? t3.ticklen : 0, sr, wr, cr, $e;\n                  (t3.automargin || st || t3._shiftPusher) && (t3.type === "multicategory" ? sr = x2("tick2") : (sr = x2(), c5 === "x" && lt === "b" && (t3._depth = Math.max(sr.width > 0 ? sr.bottom - Nt : 0, Jt))));\n                  var St = 0, Qt = 0;\n                  if (t3._shiftPusher && (St = Math.max(Jt, sr.height > 0 ? lt === "l" ? Nt - sr.left : sr.right - Nt : 0), t3.title.text !== l3._dfltTitle[c5] && (Qt = (t3._titleStandoff || 0) + (t3._titleScoot || 0), lt === "l" && (Qt += xse(t3))), t3._fullDepth = Math.max(St, Qt)), t3.automargin) {\n                    wr = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 };\n                    var Vt = [0, 1], _t = typeof t3._shift == "number" ? t3._shift : 0;\n                    if (c5 === "x") {\n                      if (lt === "b" ? wr[lt] = t3._depth : (wr[lt] = t3._depth = Math.max(sr.width > 0 ? Nt - sr.top : 0, Jt), Vt.reverse()), sr.width > 0) {\n                        var It = sr.right - (t3._offset + t3._length);\n                        It > 0 && (wr.xr = 1, wr.r = It);\n                        var mt = t3._offset - sr.left;\n                        mt > 0 && (wr.xl = 0, wr.l = mt);\n                      }\n                    } else if (lt === "l" ? (t3._depth = Math.max(sr.height > 0 ? Nt - sr.left : 0, Jt), wr[lt] = t3._depth - _t) : (t3._depth = Math.max(sr.height > 0 ? sr.right - Nt : 0, Jt), wr[lt] = t3._depth + _t, Vt.reverse()), sr.height > 0) {\n                      var er = sr.bottom - (t3._offset + t3._length);\n                      er > 0 && (wr.yb = 0, wr.b = er);\n                      var lr = t3._offset - sr.top;\n                      lr > 0 && (wr.yt = 1, wr.t = lr);\n                    }\n                    wr[f4] = t3.anchor === "free" ? t3.position : t3._anchorAxis.domain[Vt[0]], t3.title.text !== l3._dfltTitle[c5] && (wr[lt] += xse(t3) + (t3.title.standoff || 0)), t3.mirror && t3.anchor !== "free" && (cr = { x: 0, y: 0, r: 0, l: 0, t: 0, b: 0 }, cr[Gt] = t3.linewidth, t3.mirror && t3.mirror !== true && (cr[Gt] += Jt), t3.mirror === true || t3.mirror === "ticks" ? cr[f4] = t3._anchorAxis.domain[Vt[1]] : (t3.mirror === "all" || t3.mirror === "allticks") && (cr[f4] = [t3._counterDomainMin, t3._counterDomainMax][Vt[1]]));\n                  }\n                  st && ($e = aM.getComponentMethod("rangeslider", "autoMarginOpts")(e3, t3)), typeof t3.automargin == "string" && (_se(wr, t3.automargin), _se(cr, t3.automargin)), D3.autoMargin(e3, mB(t3), wr), D3.autoMargin(e3, Lse(t3), cr), D3.autoMargin(e3, Pse(t3), $e);\n                }), Jo.syncOrAsync(pt);\n              }\n            };\n            function _se(e3, t3) {\n              if (e3) {\n                var r4 = Object.keys(hse).reduce(function(n4, i3) {\n                  return t3.indexOf(i3) !== -1 && hse[i3].forEach(function(a4) {\n                    n4[a4] = 1;\n                  }), n4;\n                }, {});\n                Object.keys(e3).forEach(function(n4) {\n                  r4[n4] || (n4.length === 1 ? e3[n4] = 0 : delete e3[n4]);\n                });\n              }\n            }\n            function alt(e3, t3) {\n              var r4 = [], n4, i3 = function(a4, o4) {\n                var s3 = a4.xbnd[o4];\n                s3 !== null && r4.push(Jo.extendFlat({}, a4, { x: s3 }));\n              };\n              if (t3.length) {\n                for (n4 = 0; n4 < t3.length; n4++) i3(t3[n4], 0);\n                i3(t3[n4 - 1], 1);\n              }\n              return r4;\n            }\n            function olt(e3, t3) {\n              for (var r4 = [], n4 = {}, i3 = 0; i3 < t3.length; i3++) {\n                var a4 = t3[i3];\n                n4[a4.text2] ? n4[a4.text2].push(a4.x) : n4[a4.text2] = [a4.x];\n              }\n              for (var o4 in n4) r4.push(Ese(e3, Jo.interp(n4[o4], 0.5), o4));\n              return r4;\n            }\n            function slt(e3, t3) {\n              var r4 = [], n4, i3, a4 = t3.length && t3[t3.length - 1].x < t3[0].x, o4 = function(l3, u4) {\n                var c5 = l3.xbnd[u4];\n                c5 !== null && r4.push(Jo.extendFlat({}, l3, { x: c5 }));\n              };\n              if (e3.showdividers && t3.length) {\n                for (n4 = 0; n4 < t3.length; n4++) {\n                  var s3 = t3[n4];\n                  s3.text2 !== i3 && o4(s3, a4 ? 1 : 0), i3 = s3.text2;\n                }\n                o4(t3[n4 - 1], a4 ? 0 : 1);\n              }\n              return r4;\n            }\n            function llt(e3, t3, r4) {\n              var n4, i3, a4, o4;\n              if (e3._selections[t3].size()) n4 = 1 / 0, i3 = -1 / 0, a4 = 1 / 0, o4 = -1 / 0, e3._selections[t3].each(function() {\n                var l3 = hB(this);\n                if (l3.node().style.display !== "none") {\n                  var u4 = Xp.bBox(l3.node().parentNode);\n                  n4 = Math.min(n4, u4.top), i3 = Math.max(i3, u4.bottom), a4 = Math.min(a4, u4.left), o4 = Math.max(o4, u4.right);\n                }\n              });\n              else {\n                var s3 = Qn.makeLabelFns(e3, r4);\n                n4 = i3 = s3.yFn({ dx: 0, dy: 0, fontSize: 0 }), a4 = o4 = s3.xFn({ dx: 0, dy: 0, fontSize: 0 });\n              }\n              return { top: n4, bottom: i3, left: a4, right: o4, height: i3 - n4, width: o4 - a4 };\n            }\n            Qn.getTickSigns = function(e3, t3) {\n              var r4 = e3._id.charAt(0), n4 = { x: "top", y: "right" }[r4], i3 = e3.side === n4 ? 1 : -1, a4 = [-1, 1, i3, -i3], o4 = t3 ? (e3.minor || {}).ticks : e3.ticks;\n              return o4 !== "inside" == (r4 === "x") && (a4 = a4.map(function(s3) {\n                return -s3;\n              })), e3.side && a4.push({ l: -1, t: -1, r: 1, b: 1 }[e3.side.charAt(0)]), a4;\n            };\n            Qn.makeTransTickFn = function(e3) {\n              return e3._id.charAt(0) === "x" ? function(t3) {\n                return F3(e3._offset + e3.l2p(t3.x), 0);\n              } : function(t3) {\n                return F3(0, e3._offset + e3.l2p(t3.x));\n              };\n            };\n            Qn.makeTransTickLabelFn = function(e3) {\n              var t3 = ult(e3), r4 = e3.ticklabelshift || 0, n4 = e3.ticklabelstandoff || 0, i3 = t3[0], a4 = t3[1], o4 = e3.range[0] > e3.range[1], s3 = e3.ticklabelposition && e3.ticklabelposition.indexOf("inside") !== -1, l3 = !s3;\n              if (r4) {\n                var u4 = o4 ? -1 : 1;\n                r4 = r4 * u4;\n              }\n              if (n4) {\n                var c5 = e3.side, f4 = s3 && (c5 === "top" || c5 === "left") || l3 && (c5 === "bottom" || c5 === "right") ? 1 : -1;\n                n4 = n4 * f4;\n              }\n              return e3._id.charAt(0) === "x" ? function(h3) {\n                return F3(i3 + e3._offset + e3.l2p(fB(h3)) + r4, a4 + n4);\n              } : function(h3) {\n                return F3(a4 + n4, i3 + e3._offset + e3.l2p(fB(h3)) + r4);\n              };\n            };\n            function fB(e3) {\n              return e3.periodX !== void 0 ? e3.periodX : e3.x;\n            }\n            function ult(e3) {\n              var t3 = e3.ticklabelposition || "", r4 = e3.tickson || "", n4 = function(v3) {\n                return t3.indexOf(v3) !== -1;\n              }, i3 = n4("top"), a4 = n4("left"), o4 = n4("right"), s3 = n4("bottom"), l3 = n4("inside"), u4 = r4 !== "boundaries" && (s3 || a4 || i3 || o4);\n              if (!u4 && !l3) return [0, 0];\n              var c5 = e3.side, f4 = u4 ? (e3.tickwidth || 0) / 2 : 0, h3 = kL, d3 = e3.tickfont ? e3.tickfont.size : 12;\n              return (s3 || i3) && (f4 += d3 * Lb, h3 += (e3.linewidth || 0) / 2), (a4 || o4) && (f4 += (e3.linewidth || 0) / 2, h3 += kL), l3 && c5 === "top" && (h3 -= d3 * (1 - Lb)), (a4 || i3) && (f4 = -f4), (c5 === "bottom" || c5 === "right") && (h3 = -h3), [u4 ? f4 : 0, l3 ? h3 : 0];\n            }\n            Qn.makeTickPath = function(e3, t3, r4, n4) {\n              n4 || (n4 = {});\n              var i3 = n4.minor;\n              if (i3 && !e3.minor) return "";\n              var a4 = n4.len !== void 0 ? n4.len : i3 ? e3.minor.ticklen : e3.ticklen, o4 = e3._id.charAt(0), s3 = (e3.linewidth || 1) / 2;\n              return o4 === "x" ? "M0," + (t3 + s3 * r4) + "v" + a4 * r4 : "M" + (t3 + s3 * r4) + ",0h" + a4 * r4;\n            };\n            Qn.makeLabelFns = function(e3, t3, r4) {\n              var n4 = e3.ticklabelposition || "", i3 = e3.tickson || "", a4 = function(O4) {\n                return n4.indexOf(O4) !== -1;\n              }, o4 = a4("top"), s3 = a4("left"), l3 = a4("right"), u4 = a4("bottom"), c5 = i3 !== "boundaries" && (u4 || s3 || o4 || l3), f4 = a4("inside"), h3 = n4 === "inside" && e3.ticks === "inside" || !f4 && e3.ticks === "outside" && i3 !== "boundaries", d3 = 0, v3 = 0, _2 = h3 ? e3.ticklen : 0;\n              if (f4 ? _2 *= -1 : c5 && (_2 = 0), h3 && (d3 += _2, r4)) {\n                var b = Jo.deg2rad(r4);\n                d3 = _2 * Math.cos(b) + 1, v3 = _2 * Math.sin(b);\n              }\n              e3.showticklabels && (h3 || e3.showline) && (d3 += 0.2 * e3.tickfont.size), d3 += (e3.linewidth || 1) / 2 * (f4 ? -1 : 1);\n              var p3 = { labelStandoff: d3, labelShift: v3 }, k4, E3, S2, L3, x2 = 0, C3 = e3.side, M4 = e3._id.charAt(0), g3 = e3.tickangle, P3;\n              if (M4 === "x") P3 = !f4 && C3 === "bottom" || f4 && C3 === "top", L3 = P3 ? 1 : -1, f4 && (L3 *= -1), k4 = v3 * L3, E3 = t3 + d3 * L3, S2 = P3 ? 1 : -0.2, Math.abs(g3) === 90 && (f4 ? S2 += nM : g3 === -90 && C3 === "bottom" ? S2 = Lb : g3 === 90 && C3 === "top" ? S2 = nM : S2 = 0.5, x2 = nM / 2 * (g3 / 90)), p3.xFn = function(O4) {\n                return O4.dx + k4 + x2 * O4.fontSize;\n              }, p3.yFn = function(O4) {\n                return O4.dy + E3 + O4.fontSize * S2;\n              }, p3.anchorFn = function(O4, V2) {\n                if (c5) {\n                  if (s3) return "end";\n                  if (l3) return "start";\n                }\n                return !Ih(V2) || V2 === 0 || V2 === 180 ? "middle" : V2 * L3 < 0 !== f4 ? "end" : "start";\n              }, p3.heightFn = function(O4, V2, G2) {\n                return V2 < -60 || V2 > 60 ? -0.5 * G2 : e3.side === "top" !== f4 ? -G2 : 0;\n              };\n              else if (M4 === "y") {\n                if (P3 = !f4 && C3 === "left" || f4 && C3 === "right", L3 = P3 ? 1 : -1, f4 && (L3 *= -1), k4 = d3, E3 = v3 * L3, S2 = 0, !f4 && Math.abs(g3) === 90 && (g3 === -90 && C3 === "left" || g3 === 90 && C3 === "right" ? S2 = Lb : S2 = 0.5), f4) {\n                  var T3 = Ih(g3) ? +g3 : 0;\n                  if (T3 !== 0) {\n                    var z4 = Jo.deg2rad(T3);\n                    x2 = Math.abs(Math.sin(z4)) * Lb * L3, S2 = 0;\n                  }\n                }\n                p3.xFn = function(O4) {\n                  return O4.dx + t3 - (k4 + O4.fontSize * S2) * L3 + x2 * O4.fontSize;\n                }, p3.yFn = function(O4) {\n                  return O4.dy + E3 + O4.fontSize * nM;\n                }, p3.anchorFn = function(O4, V2) {\n                  return Ih(V2) && Math.abs(V2) === 90 ? "middle" : P3 ? "end" : "start";\n                }, p3.heightFn = function(O4, V2, G2) {\n                  return e3.side === "right" && (V2 *= -1), V2 < -30 ? -G2 : V2 < 30 ? -0.5 * G2 : 0;\n                };\n              }\n              return p3;\n            };\n            function PL(e3) {\n              return [e3.text, e3.x, e3.axInfo, e3.font, e3.fontSize, e3.fontColor].join("_");\n            }\n            Qn.drawTicks = function(e3, t3, r4) {\n              r4 = r4 || {};\n              var n4 = t3._id + "tick", i3 = [].concat(t3.minor && t3.minor.ticks ? r4.vals.filter(function(o4) {\n                return o4.minor && !o4.noTick;\n              }) : []).concat(t3.ticks ? r4.vals.filter(function(o4) {\n                return !o4.minor && !o4.noTick;\n              }) : []), a4 = r4.layer.selectAll("path." + n4).data(i3, PL);\n              a4.exit().remove(), a4.enter().append("path").classed(n4, 1).classed("ticks", 1).classed("crisp", r4.crisp !== false).each(function(o4) {\n                return oM.stroke(b0.select(this), o4.minor ? t3.minor.tickcolor : t3.tickcolor);\n              }).style("stroke-width", function(o4) {\n                return Xp.crispRound(e3, o4.minor ? t3.minor.tickwidth : t3.tickwidth, 1) + "px";\n              }).attr("d", r4.path).style("display", null), IL(t3, [bse]), a4.attr("transform", r4.transFn);\n            };\n            Qn.drawGrid = function(e3, t3, r4) {\n              if (r4 = r4 || {}, t3.tickmode !== "sync") {\n                var n4 = t3._id + "grid", i3 = t3.minor && t3.minor.showgrid, a4 = i3 ? r4.vals.filter(function(p3) {\n                  return p3.minor;\n                }) : [], o4 = t3.showgrid ? r4.vals.filter(function(p3) {\n                  return !p3.minor;\n                }) : [], s3 = r4.counterAxis;\n                if (s3 && Qn.shouldShowZeroLine(e3, t3, s3)) for (var l3 = t3.tickmode === "array", u4 = 0; u4 < o4.length; u4++) {\n                  var c5 = o4[u4].x;\n                  if (l3 ? !c5 : Math.abs(c5) < t3.dtick / 100) if (o4 = o4.slice(0, u4).concat(o4.slice(u4 + 1)), l3) u4--;\n                  else break;\n                }\n                t3._gw = Xp.crispRound(e3, t3.gridwidth, 1);\n                for (var f4 = i3 ? Xp.crispRound(e3, t3.minor.gridwidth, 1) : 0, h3 = r4.layer, d3 = r4.minorLayer, v3 = 1; v3 >= 0; v3--) {\n                  var _2 = v3 ? h3 : d3;\n                  if (_2) {\n                    var b = _2.selectAll("path." + n4).data(v3 ? o4 : a4, PL);\n                    b.exit().remove(), b.enter().append("path").classed(n4, 1).classed("crisp", r4.crisp !== false), b.attr("transform", r4.transFn).attr("d", r4.path).each(function(p3) {\n                      return oM.stroke(b0.select(this), p3.minor ? t3.minor.gridcolor : t3.gridcolor || "#ddd");\n                    }).style("stroke-dasharray", function(p3) {\n                      return Xp.dashStyle(p3.minor ? t3.minor.griddash : t3.griddash, p3.minor ? t3.minor.gridwidth : t3.gridwidth);\n                    }).style("stroke-width", function(p3) {\n                      return (p3.minor ? f4 : t3._gw) + "px";\n                    }).style("display", null), typeof r4.path == "function" && b.attr("d", r4.path);\n                  }\n                }\n                IL(t3, [uB, cB]);\n              }\n            };\n            Qn.drawZeroLine = function(e3, t3, r4) {\n              r4 = r4 || r4;\n              var n4 = t3._id + "zl", i3 = Qn.shouldShowZeroLine(e3, t3, r4.counterAxis), a4 = r4.layer.selectAll("path." + n4).data(i3 ? [{ x: 0, id: t3._id }] : []);\n              a4.exit().remove(), a4.enter().append("path").classed(n4, 1).classed("zl", 1).classed("crisp", r4.crisp !== false).each(function() {\n                r4.layer.selectAll("path").sort(function(o4, s3) {\n                  return Bst(o4.id, s3.id);\n                });\n              }), a4.attr("transform", r4.transFn).attr("d", r4.path).call(oM.stroke, t3.zerolinecolor || oM.defaultLine).style("stroke-width", Xp.crispRound(e3, t3.zerolinewidth, t3._gw || 1) + "px").style("display", null), IL(t3, [lB]);\n            };\n            Qn.drawLabels = function(e3, t3, r4) {\n              r4 = r4 || {};\n              var n4 = e3._fullLayout, i3 = t3._id, a4 = t3.zerolinelayer === "above traces", o4 = r4.cls || i3 + "tick", s3 = r4.vals.filter(function(H) {\n                return H.text;\n              }), l3 = r4.labelFns, u4 = r4.secondary ? 0 : t3.tickangle, c5 = (t3._prevTickAngles || {})[o4], f4 = r4.layer.selectAll("g." + o4).data(t3.showticklabels ? s3 : [], PL), h3 = [];\n              f4.enter().append("g").classed(o4, 1).append("text").attr("text-anchor", "middle").each(function(H) {\n                var te = b0.select(this), oe = e3._promises.length;\n                te.call(kb.positionText, l3.xFn(H), l3.yFn(H)).call(Xp.font, { family: H.font, size: H.fontSize, color: H.fontColor, weight: H.fontWeight, style: H.fontStyle, variant: H.fontVariant, textcase: H.fontTextcase, lineposition: H.fontLineposition, shadow: H.fontShadow }).text(H.text).call(kb.convertToTspans, e3), e3._promises[oe] ? h3.push(e3._promises.pop().then(function() {\n                  d3(te, u4);\n                })) : d3(te, u4);\n              }), IL(t3, [fse]), f4.exit().remove(), r4.repositionOnUpdate && f4.each(function(H) {\n                b0.select(this).select("text").call(kb.positionText, l3.xFn(H), l3.yFn(H));\n              });\n              function d3(H, te) {\n                H.each(function(oe) {\n                  var _e = b0.select(this), Ee = _e.select(".text-math-group"), Ce = l3.anchorFn(oe, te), me = r4.transFn.call(_e.node(), oe) + (Ih(te) && +te != 0 ? " rotate(" + te + "," + l3.xFn(oe) + "," + (l3.yFn(oe) - oe.fontSize / 2) + ")" : ""), ie = kb.lineCount(_e), Se = lM * oe.fontSize, Le = l3.heightFn(oe, Ih(te) ? +te : 0, (ie - 1) * Se);\n                  if (Le && (me += F3(0, Le)), Ee.empty()) {\n                    var Ae = _e.select("text");\n                    Ae.attr({ transform: me, "text-anchor": Ce }), Ae.style("display", null), t3._adjustTickLabelsOverflow && t3._adjustTickLabelsOverflow();\n                  } else {\n                    var Fe = Xp.bBox(Ee.node()).width, Pe = Fe * { end: -0.5, start: 0.5 }[Ce];\n                    Ee.attr("transform", me + F3(Pe, 0));\n                  }\n                });\n              }\n              t3._adjustTickLabelsOverflow = function() {\n                var H = t3.ticklabeloverflow;\n                if (!(!H || H === "allow")) {\n                  var te = H.indexOf("hide") !== -1, oe = t3._id.charAt(0) === "x", _e = 0, Ee = oe ? e3._fullLayout.width : e3._fullLayout.height;\n                  if (H.indexOf("domain") !== -1) {\n                    var Ce = Jo.simpleMap(t3.range, t3.r2l);\n                    _e = t3.l2p(Ce[0]) + t3._offset, Ee = t3.l2p(Ce[1]) + t3._offset;\n                  }\n                  var me = Math.min(_e, Ee), ie = Math.max(_e, Ee), Se = t3.side, Le = 1 / 0, Ae = -1 / 0;\n                  f4.each(function(Re) {\n                    var ce = b0.select(this), Ze = ce.select(".text-math-group");\n                    if (Ze.empty()) {\n                      var ut = Xp.bBox(ce.node()), pt = 0;\n                      oe ? (ut.right > ie || ut.left < me) && (pt = 1) : (ut.bottom > ie || ut.top + (t3.tickangle ? 0 : Re.fontSize / 4) < me) && (pt = 1);\n                      var Zt = ce.select("text");\n                      pt ? te && Zt.style("display", "none") : Zt.node().style.display !== "none" && (Zt.style("display", null), Se === "bottom" || Se === "right" ? Le = Math.min(Le, oe ? ut.top : ut.left) : Le = -1 / 0, Se === "top" || Se === "left" ? Ae = Math.max(Ae, oe ? ut.bottom : ut.right) : Ae = 1 / 0);\n                    }\n                  });\n                  for (var Fe in n4._plots) {\n                    var Pe = n4._plots[Fe];\n                    if (!(t3._id !== Pe.xaxis._id && t3._id !== Pe.yaxis._id)) {\n                      var ge = oe ? Pe.yaxis : Pe.xaxis;\n                      ge && (ge["_visibleLabelMin_" + t3._id] = Le, ge["_visibleLabelMax_" + t3._id] = Ae);\n                    }\n                  }\n                }\n              }, t3._hideCounterAxisInsideTickLabels = function(H) {\n                var te = t3._id.charAt(0) === "x", oe = [];\n                for (var _e in n4._plots) {\n                  var Ee = n4._plots[_e];\n                  t3._id !== Ee.xaxis._id && t3._id !== Ee.yaxis._id || oe.push(te ? Ee.yaxis : Ee.xaxis);\n                }\n                oe.forEach(function(Ce, me) {\n                  Ce && cM(Ce) && (H || [lB, cB, uB, bse, fse]).forEach(function(ie) {\n                    var Se = ie.K === "tick" && ie.L === "text" && t3.ticklabelmode === "period", Le = n4._plots[t3._mainSubplot], Ae;\n                    if (ie.K === lB.K) {\n                      var Fe = a4 ? Le.zerolinelayerAbove : Le.zerolinelayer;\n                      Ae = Fe.selectAll("." + t3._id + "zl");\n                    } else ie.K === cB.K ? Ae = Le.minorGridlayer.selectAll("." + t3._id) : ie.K === uB.K ? Ae = Le.gridlayer.selectAll("." + t3._id) : Ae = Le[t3._id.charAt(0) + "axislayer"];\n                    Ae.each(function() {\n                      var Pe = b0.select(this);\n                      ie.L && (Pe = Pe.selectAll(ie.L)), Pe.each(function(ge) {\n                        var Re = t3.l2p(Se ? fB(ge) : ge.x) + t3._offset, ce = b0.select(this);\n                        Re < t3["_visibleLabelMax_" + Ce._id] && Re > t3["_visibleLabelMin_" + Ce._id] ? ce.style("display", "none") : ie.K === "tick" && !me && ce.node().style.display !== "none" && ce.style("display", null);\n                      });\n                    });\n                  });\n                });\n              }, d3(f4, c5 + 1 ? c5 : u4);\n              function v3() {\n                return h3.length && Promise.all(h3);\n              }\n              var _2 = null;\n              function b() {\n                if (d3(f4, u4), s3.length && t3.autotickangles && (t3.type !== "log" || String(t3.dtick).charAt(0) !== "D")) {\n                  _2 = t3.autotickangles[0];\n                  var H = 0, te = [], oe, _e = 1;\n                  f4.each(function(wr) {\n                    H = Math.max(H, wr.fontSize);\n                    var cr = t3.l2p(wr.x), $e = hB(this), St = Xp.bBox($e.node());\n                    _e = Math.max(_e, kb.lineCount($e)), te.push({ top: 0, bottom: 10, height: 10, left: cr - St.width / 2, right: cr + St.width / 2 + 2, width: St.width + 2 });\n                  });\n                  var Ee = (t3.tickson === "boundaries" || t3.showdividers) && !r4.secondary, Ce = s3.length, me = Math.abs((s3[Ce - 1].x - s3[0].x) * t3._m) / (Ce - 1), ie = Ee ? me / 2 : me, Se = Ee ? t3.ticklen : H * 1.25 * _e, Le = Math.sqrt(Math.pow(ie, 2) + Math.pow(Se, 2)), Ae = ie / Le, Fe = t3.autotickangles.map(function(wr) {\n                    return wr * Math.PI / 180;\n                  }), Pe = Fe.find(function(wr) {\n                    return Math.abs(Math.cos(wr)) <= Ae;\n                  });\n                  Pe === void 0 && (Pe = Fe.reduce(function(wr, cr) {\n                    return Math.abs(Math.cos(wr)) < Math.abs(Math.cos(cr)) ? wr : cr;\n                  }, Fe[0]));\n                  var ge = Pe * (180 / Math.PI);\n                  if (Ee) {\n                    var Re = 2;\n                    for (t3.ticks && (Re += t3.tickwidth / 2), oe = 0; oe < te.length; oe++) {\n                      var ce = s3[oe].xbnd, Ze = te[oe];\n                      if (ce[0] !== null && Ze.left - t3.l2p(ce[0]) < Re || ce[1] !== null && t3.l2p(ce[1]) - Ze.right < Re) {\n                        _2 = ge;\n                        break;\n                      }\n                    }\n                  } else {\n                    var ut = t3.ticklabelposition || "", pt = t3.tickson || "", Zt = function(wr) {\n                      return ut.indexOf(wr) !== -1;\n                    }, st = Zt("top"), lt = Zt("left"), Gt = Zt("right"), Nt = Zt("bottom"), Jt = pt !== "boundaries" && (Nt || lt || st || Gt), sr = Jt ? (t3.tickwidth || 0) + 2 * kL : 0;\n                    for (oe = 0; oe < te.length - 1; oe++) if (Jo.bBoxIntersect(te[oe], te[oe + 1], sr)) {\n                      _2 = ge;\n                      break;\n                    }\n                  }\n                  _2 && d3(f4, _2);\n                }\n              }\n              t3._selections && (t3._selections[o4] = f4);\n              var p3 = [v3];\n              t3.automargin && n4._redrawFromAutoMarginCount && c5 === 90 ? (_2 = c5, p3.push(function() {\n                d3(f4, c5);\n              })) : p3.push(b), t3._tickAngles && p3.push(function() {\n                t3._tickAngles[o4] = _2 === null ? Ih(u4) ? u4 : 0 : _2;\n              });\n              var k4 = function() {\n                var H = 0, te = 0;\n                return f4.each(function(oe, _e) {\n                  var Ee = hB(this), Ce = Ee.select(".text-math-group");\n                  if (Ce.empty()) {\n                    var me;\n                    t3._vals[_e] && (me = t3._vals[_e].bb || Xp.bBox(Ee.node()), t3._vals[_e].bb = me), H = Math.max(H, me.width), te = Math.max(te, me.height);\n                  }\n                }), { labelsMaxW: H, labelsMaxH: te };\n              }, E3 = t3._anchorAxis;\n              if (E3 && (E3.autorange || E3.insiderange) && cM(t3) && !Nst(n4, t3._id) && (n4._insideTickLabelsUpdaterange || (n4._insideTickLabelsUpdaterange = {}), E3.autorange && (n4._insideTickLabelsUpdaterange[E3._name + ".autorange"] = E3.autorange, p3.push(k4)), E3.insiderange)) {\n                var S2 = k4(), L3 = t3._id.charAt(0) === "y" ? S2.labelsMaxW : S2.labelsMaxH;\n                L3 += 2 * kL, t3.ticklabelposition === "inside" && (L3 += t3.ticklen || 0);\n                var x2 = t3.side === "right" || t3.side === "top" ? 1 : -1, C3 = x2 === 1 ? 1 : 0, M4 = x2 === 1 ? 0 : 1, g3 = [];\n                g3[M4] = E3.range[M4];\n                var P3 = E3.range, T3 = E3.r2p(P3[C3]), z4 = E3.r2p(P3[M4]), O4 = n4._insideTickLabelsUpdaterange[E3._name + ".range"];\n                if (O4) {\n                  var V2 = E3.r2p(O4[C3]), G2 = E3.r2p(O4[M4]), Z = x2 * (t3._id.charAt(0) === "y" ? 1 : -1);\n                  Z * T3 < Z * V2 && (T3 = V2, g3[C3] = P3[C3] = O4[C3]), Z * z4 > Z * G2 && (z4 = G2, g3[M4] = P3[M4] = O4[M4]);\n                }\n                var j3 = Math.abs(z4 - T3);\n                j3 - L3 > 0 ? (j3 -= L3, L3 *= 1 + L3 / j3) : L3 = 0, t3._id.charAt(0) !== "y" && (L3 = -L3), g3[C3] = E3.p2r(E3.r2p(P3[C3]) + x2 * L3), E3.autorange === "min" || E3.autorange === "max reversed" ? (g3[0] = null, E3._rangeInitial0 = void 0, E3._rangeInitial1 = void 0) : (E3.autorange === "max" || E3.autorange === "min reversed") && (g3[1] = null, E3._rangeInitial0 = void 0, E3._rangeInitial1 = void 0), n4._insideTickLabelsUpdaterange[E3._name + ".range"] = g3;\n              }\n              var N2 = Jo.syncOrAsync(p3);\n              return N2 && N2.then && e3._promises.push(N2), N2;\n            };\n            function clt(e3, t3, r4) {\n              var n4 = t3._id + "divider", i3 = r4.vals, a4 = r4.layer.selectAll("path." + n4).data(i3, PL);\n              a4.exit().remove(), a4.enter().insert("path", ":first-child").classed(n4, 1).classed("crisp", 1).call(oM.stroke, t3.dividercolor).style("stroke-width", Xp.crispRound(e3, t3.dividerwidth, 1) + "px"), a4.attr("transform", r4.transFn).attr("d", r4.path);\n            }\n            Qn.getPxPosition = function(e3, t3) {\n              var r4 = e3._fullLayout._size, n4 = t3._id.charAt(0), i3 = t3.side, a4;\n              if (t3.anchor !== "free" ? a4 = t3._anchorAxis : n4 === "x" ? a4 = { _offset: r4.t + (1 - (t3.position || 0)) * r4.h, _length: 0 } : n4 === "y" && (a4 = { _offset: r4.l + (t3.position || 0) * r4.w + t3._shift, _length: 0 }), i3 === "top" || i3 === "left") return a4._offset;\n              if (i3 === "bottom" || i3 === "right") return a4._offset + a4._length;\n            };\n            function xse(e3) {\n              var t3 = e3.title.font.size, r4 = (e3.title.text.match(kb.BR_TAG_ALL) || []).length;\n              return e3.title.hasOwnProperty("standoff") ? t3 * (Lb + r4 * lM) : r4 ? t3 * (r4 + 1) * lM : t3;\n            }\n            function flt(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3._id, i3 = n4.charAt(0), a4 = t3.title.font.size, o4, s3 = (t3.title.text.match(kb.BR_TAG_ALL) || []).length;\n              if (t3.title.hasOwnProperty("standoff")) t3.side === "bottom" || t3.side === "right" ? o4 = t3._depth + t3.title.standoff + a4 * Lb : (t3.side === "top" || t3.side === "left") && (o4 = t3._depth + t3.title.standoff + a4 * (nM + s3 * lM));\n              else {\n                var l3 = cM(t3);\n                if (t3.type === "multicategory") o4 = t3._depth;\n                else {\n                  var u4 = 1.5 * a4;\n                  l3 && (u4 = 0.5 * a4, t3.ticks === "outside" && (u4 += t3.ticklen)), o4 = 10 + u4 + (t3.linewidth ? t3.linewidth - 1 : 0);\n                }\n                l3 || (i3 === "x" ? o4 += t3.side === "top" ? a4 * (t3.showticklabels ? 1 : 0) : a4 * (t3.showticklabels ? 1.5 : 0.5) : o4 += t3.side === "right" ? a4 * (t3.showticklabels ? 1 : 0.5) : a4 * (t3.showticklabels ? 0.5 : 0));\n              }\n              var c5 = Qn.getPxPosition(e3, t3), f4, h3, d3;\n              i3 === "x" ? (h3 = t3._offset + t3._length / 2, d3 = t3.side === "top" ? c5 - o4 : c5 + o4) : (d3 = t3._offset + t3._length / 2, h3 = t3.side === "right" ? c5 + o4 : c5 - o4, f4 = { rotate: "-90", offset: 0 });\n              var v3;\n              if (t3.type !== "multicategory") {\n                var _2 = t3._selections[t3._id + "tick"];\n                if (v3 = { selection: _2, side: t3.side }, _2 && _2.node() && _2.node().parentNode) {\n                  var b = Xp.getTranslate(_2.node().parentNode);\n                  v3.offsetLeft = b.x, v3.offsetTop = b.y;\n                }\n                t3.title.hasOwnProperty("standoff") && (v3.pad = 0);\n              }\n              return t3._titleStandoff = o4, Lst.draw(e3, n4 + "title", { propContainer: t3, propName: t3._name + ".title.text", placeholder: r4._dfltTitle[i3], avoid: v3, transform: f4, attributes: { x: h3, y: d3, "text-anchor": "middle" } });\n            }\n            Qn.shouldShowZeroLine = function(e3, t3, r4) {\n              var n4 = Jo.simpleMap(t3.range, t3.r2l);\n              return n4[0] * n4[1] <= 0 && t3.zeroline && (t3.type === "linear" || t3.type === "-") && !(t3.rangebreaks && t3.maskBreaks(0) === CL) && (Cse(t3, 0) || !hlt(e3, t3, r4, n4) || dlt(e3, t3));\n            };\n            Qn.clipEnds = function(e3, t3) {\n              return t3.filter(function(r4) {\n                return Cse(e3, r4.x);\n              });\n            };\n            function Cse(e3, t3) {\n              var r4 = e3.l2p(t3);\n              return r4 > 1 && r4 < e3._length - 1;\n            }\n            function hlt(e3, t3, r4, n4) {\n              var i3 = r4._mainAxis;\n              if (!i3) return;\n              var a4 = e3._fullLayout, o4 = t3._id.charAt(0), s3 = Qn.counterLetter(t3._id), l3 = t3._offset + (Math.abs(n4[0]) < Math.abs(n4[1]) == (o4 === "x") ? 0 : t3._length);\n              function u4(v3) {\n                if (!v3.showline || !v3.linewidth) return false;\n                var _2 = Math.max((v3.linewidth + t3.zerolinewidth) / 2, 1);\n                function b(E3) {\n                  return typeof E3 == "number" && Math.abs(E3 - l3) < _2;\n                }\n                if (b(v3._mainLinePosition) || b(v3._mainMirrorPosition)) return true;\n                var p3 = v3._linepositions || {};\n                for (var k4 in p3) if (b(p3[k4][0]) || b(p3[k4][1])) return true;\n              }\n              var c5 = a4._plots[r4._mainSubplot];\n              if (!(c5.mainplotinfo || c5).overlays.length) return u4(r4, l3);\n              for (var f4 = Qn.list(e3, s3), h3 = 0; h3 < f4.length; h3++) {\n                var d3 = f4[h3];\n                if (d3._mainAxis === i3 && u4(d3, l3)) return true;\n              }\n            }\n            function dlt(e3, t3) {\n              for (var r4 = e3._fullData, n4 = t3._mainSubplot, i3 = t3._id.charAt(0), a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4];\n                if (o4.visible === true && o4.xaxis + o4.yaxis === n4 && (aM.traceIs(o4, "bar-like") && o4.orientation === { x: "h", y: "v" }[i3] || o4.fill && o4.fill.charAt(o4.fill.length - 1) === i3)) return true;\n              }\n              return false;\n            }\n            function hB(e3) {\n              var t3 = b0.select(e3), r4 = t3.select(".text-math-group");\n              return r4.empty() ? t3.select("text") : r4;\n            }\n            Qn.allowAutoMargin = function(e3) {\n              for (var t3 = Qn.list(e3, "", true), r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                n4.automargin && (D3.allowAutoMargin(e3, mB(n4)), n4.mirror && D3.allowAutoMargin(e3, Lse(n4))), aM.getComponentMethod("rangeslider", "isVisible")(n4) && D3.allowAutoMargin(e3, Pse(n4));\n              }\n            };\n            function mB(e3) {\n              return e3._id + ".automargin";\n            }\n            function Lse(e3) {\n              return mB(e3) + ".mirror";\n            }\n            function Pse(e3) {\n              return e3._id + ".rangeslider";\n            }\n            Qn.swap = function(e3, t3) {\n              for (var r4 = vlt(e3, t3), n4 = 0; n4 < r4.length; n4++) plt(e3, r4[n4].x, r4[n4].y);\n            };\n            function vlt(e3, t3) {\n              var r4 = [], n4, i3;\n              for (n4 = 0; n4 < t3.length; n4++) {\n                var a4 = [], o4 = e3._fullData[t3[n4]].xaxis, s3 = e3._fullData[t3[n4]].yaxis;\n                if (!(!o4 || !s3)) {\n                  for (i3 = 0; i3 < r4.length; i3++) (r4[i3].x.indexOf(o4) !== -1 || r4[i3].y.indexOf(s3) !== -1) && a4.push(i3);\n                  if (!a4.length) {\n                    r4.push({ x: [o4], y: [s3] });\n                    continue;\n                  }\n                  var l3 = r4[a4[0]], u4;\n                  if (a4.length > 1) for (i3 = 1; i3 < a4.length; i3++) u4 = r4[a4[i3]], wL(l3.x, u4.x), wL(l3.y, u4.y);\n                  wL(l3.x, [o4]), wL(l3.y, [s3]);\n                }\n              }\n              return r4;\n            }\n            function wL(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) e3.indexOf(t3[r4]) === -1 && e3.push(t3[r4]);\n            }\n            function plt(e3, t3, r4) {\n              var n4 = [], i3 = [], a4 = e3.layout, o4, s3;\n              for (o4 = 0; o4 < t3.length; o4++) n4.push(Qn.getFromId(e3, t3[o4]));\n              for (o4 = 0; o4 < r4.length; o4++) i3.push(Qn.getFromId(e3, r4[o4]));\n              var l3 = Object.keys(Pst), u4 = ["anchor", "domain", "overlaying", "position", "side", "tickangle", "editType"], c5 = ["linear", "log"];\n              for (o4 = 0; o4 < l3.length; o4++) {\n                var f4 = l3[o4], h3 = n4[0][f4], d3 = i3[0][f4], v3 = true, _2 = false, b = false;\n                if (!(f4.charAt(0) === "_" || typeof h3 == "function" || u4.indexOf(f4) !== -1)) {\n                  for (s3 = 1; s3 < n4.length && v3; s3++) {\n                    var p3 = n4[s3][f4];\n                    f4 === "type" && c5.indexOf(h3) !== -1 && c5.indexOf(p3) !== -1 && h3 !== p3 ? _2 = true : p3 !== h3 && (v3 = false);\n                  }\n                  for (s3 = 1; s3 < i3.length && v3; s3++) {\n                    var k4 = i3[s3][f4];\n                    f4 === "type" && c5.indexOf(d3) !== -1 && c5.indexOf(k4) !== -1 && d3 !== k4 ? b = true : i3[s3][f4] !== d3 && (v3 = false);\n                  }\n                  v3 && (_2 && (a4[n4[0]._name].type = "linear"), b && (a4[i3[0]._name].type = "linear"), glt(a4, f4, n4, i3, e3._fullLayout._dfltTitle));\n                }\n              }\n              for (o4 = 0; o4 < e3._fullLayout.annotations.length; o4++) {\n                var E3 = e3._fullLayout.annotations[o4];\n                t3.indexOf(E3.xref) !== -1 && r4.indexOf(E3.yref) !== -1 && Jo.swapAttrs(a4.annotations[o4], ["?"]);\n              }\n            }\n            function glt(e3, t3, r4, n4, i3) {\n              var a4 = Jo.nestedProperty, o4 = a4(e3[r4[0]._name], t3).get(), s3 = a4(e3[n4[0]._name], t3).get(), l3;\n              for (t3 === "title" && (o4 && o4.text === i3.x && (o4.text = i3.y), s3 && s3.text === i3.y && (s3.text = i3.x)), l3 = 0; l3 < r4.length; l3++) a4(e3, r4[l3]._name + "." + t3).set(s3);\n              for (l3 = 0; l3 < n4.length; l3++) a4(e3, n4[l3]._name + "." + t3).set(o4);\n            }\n            function yB(e3) {\n              return e3._id === "angularaxis";\n            }\n            function oB(e3, t3) {\n              for (var r4 = t3._rangebreaks.length, n4 = 0; n4 < r4; n4++) {\n                var i3 = t3._rangebreaks[n4];\n                if (e3 >= i3.min && e3 < i3.max) return i3.max;\n              }\n              return e3;\n            }\n            function cM(e3) {\n              return (e3.ticklabelposition || "").indexOf("inside") !== -1;\n            }\n            function IL(e3, t3) {\n              cM(e3._anchorAxis || {}) && e3._hideCounterAxisInsideTickLabels && e3._hideCounterAxisInsideTickLabels(t3);\n            }\n            function dB(e3, t3, r4, n4) {\n              var i3 = e3.anchor !== "free" && (e3.overlaying === void 0 || e3.overlaying === false) ? e3._id : e3.overlaying, a4;\n              n4 ? a4 = e3.side === "right" ? t3 : -t3 : a4 = t3, i3 in r4 || (r4[i3] = {}), e3.side in r4[i3] || (r4[i3][e3.side] = 0), r4[i3][e3.side] += a4;\n            }\n            function mlt(e3, t3) {\n              return e3.autoshift ? t3[e3.overlaying][e3.side] : e3.shift || 0;\n            }\n            function ylt(e3, t3) {\n              return /%f/.test(t3) ? e3 >= zst : /%L/.test(t3) ? e3 >= Fst : /%[SX]/.test(t3) ? e3 >= EL : /%M/.test(t3) ? e3 >= sM : /%[HI]/.test(t3) ? e3 >= xm : /%p/.test(t3) ? e3 >= s_ : /%[Aadejuwx]/.test(t3) ? e3 >= Ov : /%[UVW]/.test(t3) ? e3 >= Zp : /%[Bbm]/.test(t3) ? e3 >= ML : /%[q]/.test(t3) ? e3 >= SL : /%[Yy]/.test(t3) ? e3 >= AL : true;\n            }\n          });\n          var _B = ye((Xnr, Rse) => {\n            "use strict";\n            Rse.exports = function(t3, r4, n4) {\n              var i3, a4;\n              if (n4) {\n                var o4 = r4 === "reversed" || r4 === "min reversed" || r4 === "max reversed";\n                i3 = n4[o4 ? 1 : 0], a4 = n4[o4 ? 0 : 1];\n              }\n              var s3 = t3("autorangeoptions.minallowed", a4 === null ? i3 : void 0), l3 = t3("autorangeoptions.maxallowed", i3 === null ? a4 : void 0);\n              s3 === void 0 && t3("autorangeoptions.clipmin"), l3 === void 0 && t3("autorangeoptions.clipmax"), t3("autorangeoptions.include");\n            };\n          });\n          var xB = ye((Znr, Dse) => {\n            "use strict";\n            var _lt = _B();\n            Dse.exports = function(t3, r4, n4, i3) {\n              var a4 = r4._template || {}, o4 = r4.type || a4.type || "-";\n              n4("minallowed"), n4("maxallowed");\n              var s3 = n4("range");\n              if (!s3) {\n                var l3;\n                !i3.noInsiderange && o4 !== "log" && (l3 = n4("insiderange"), l3 && (l3[0] === null || l3[1] === null) && (r4.insiderange = false, l3 = void 0), l3 && (s3 = n4("range", l3)));\n              }\n              var u4 = r4.getAutorangeDflt(s3, i3), c5 = n4("autorange", u4), f4;\n              s3 && (s3[0] === null && s3[1] === null || (s3[0] === null || s3[1] === null) && (c5 === "reversed" || c5 === true) || s3[0] !== null && (c5 === "min" || c5 === "max reversed") || s3[1] !== null && (c5 === "max" || c5 === "min reversed")) && (s3 = void 0, delete r4.range, r4.autorange = true, f4 = true), f4 || (u4 = r4.getAutorangeDflt(s3, i3), c5 = n4("autorange", u4)), c5 && (_lt(n4, c5, s3), (o4 === "linear" || o4 === "-") && n4("rangemode")), r4.cleanRange();\n            };\n          });\n          var zse = ye((Ynr, Fse) => {\n            var xlt = { left: 0, top: 0 };\n            Fse.exports = blt;\n            function blt(e3, t3, r4) {\n              t3 = t3 || e3.currentTarget || e3.srcElement, Array.isArray(r4) || (r4 = [0, 0]);\n              var n4 = e3.clientX || 0, i3 = e3.clientY || 0, a4 = wlt(t3);\n              return r4[0] = n4 - a4.left, r4[1] = i3 - a4.top, r4;\n            }\n            function wlt(e3) {\n              return e3 === window || e3 === document || e3 === document.body ? xlt : e3.getBoundingClientRect();\n            }\n          });\n          var RL = ye((Knr, Ose) => {\n            "use strict";\n            var Tlt = rq();\n            function Alt() {\n              var e3 = false;\n              try {\n                var t3 = Object.defineProperty({}, "passive", { get: function() {\n                  e3 = true;\n                } });\n                window.addEventListener("test", null, t3), window.removeEventListener("test", null, t3);\n              } catch (r4) {\n                e3 = false;\n              }\n              return e3;\n            }\n            Ose.exports = Tlt && Alt();\n          });\n          var Bse = ye((Jnr, qse) => {\n            "use strict";\n            qse.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = (t3 - n4) / (i3 - n4), s3 = o4 + r4 / (i3 - n4), l3 = (o4 + s3) / 2;\n              return a4 === "left" || a4 === "bottom" ? o4 : a4 === "center" || a4 === "middle" ? l3 : a4 === "right" || a4 === "top" ? s3 : o4 < 2 / 3 - l3 ? o4 : s3 > 4 / 3 - l3 ? s3 : l3;\n            };\n          });\n          var Vse = ye(($nr, Use) => {\n            "use strict";\n            var Nse = Dr(), Slt = [["sw-resize", "s-resize", "se-resize"], ["w-resize", "move", "e-resize"], ["nw-resize", "n-resize", "ne-resize"]];\n            Use.exports = function(t3, r4, n4, i3) {\n              return n4 === "left" ? t3 = 0 : n4 === "center" ? t3 = 1 : n4 === "right" ? t3 = 2 : t3 = Nse.constrain(Math.floor(t3 * 3), 0, 2), i3 === "bottom" ? r4 = 0 : i3 === "middle" ? r4 = 1 : i3 === "top" ? r4 = 2 : r4 = Nse.constrain(Math.floor(r4 * 3), 0, 2), Slt[r4][t3];\n            };\n          });\n          var Hse = ye((Qnr, Gse) => {\n            "use strict";\n            var Mlt = _3(), Elt = z6(), klt = NS().getGraphDiv, Clt = zS(), bB = Gse.exports = {};\n            bB.wrapped = function(e3, t3, r4) {\n              e3 = klt(e3), e3._fullLayout && Elt.clear(e3._fullLayout._uid + Clt.HOVERID), bB.raw(e3, t3, r4);\n            };\n            bB.raw = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = t3._hoverdata;\n              r4 || (r4 = {}), !(r4.target && !t3._dragged && Mlt.triggerHandler(t3, "plotly_beforehover", r4) === false) && (n4._hoverlayer.selectAll("g").remove(), n4._hoverlayer.selectAll("line").remove(), n4._hoverlayer.selectAll("circle").remove(), t3._hoverdata = void 0, r4.target && i3 && t3.emit("plotly_unhover", { event: r4, points: i3 }));\n            };\n          });\n          var yv = ye((ear, Zse) => {\n            "use strict";\n            var Llt = zse(), wB = nq(), Plt = RL(), Ilt = Dr().removeElement, Rlt = hd(), Pb = Zse.exports = {};\n            Pb.align = Bse();\n            Pb.getCursor = Vse();\n            var Wse = Hse();\n            Pb.unhover = Wse.wrapped;\n            Pb.unhoverRaw = Wse.raw;\n            Pb.init = function(t3) {\n              var r4 = t3.gd, n4 = 1, i3 = r4._context.doubleClickDelay, a4 = t3.element, o4, s3, l3, u4, c5, f4, h3, d3;\n              r4._mouseDownTime || (r4._mouseDownTime = 0), a4.style.pointerEvents = "all", a4.onmousedown = b, Plt ? (a4._ontouchstart && a4.removeEventListener("touchstart", a4._ontouchstart), a4._ontouchstart = b, a4.addEventListener("touchstart", b, { passive: false })) : a4.ontouchstart = b;\n              function v3(E3, S2, L3) {\n                return Math.abs(E3) < L3 && (E3 = 0), Math.abs(S2) < L3 && (S2 = 0), [E3, S2];\n              }\n              var _2 = t3.clampFn || v3;\n              function b(E3) {\n                r4._dragged = false, r4._dragging = true;\n                var S2 = jse(E3);\n                o4 = S2[0], s3 = S2[1], h3 = E3.target, f4 = E3, d3 = E3.buttons === 2 || E3.ctrlKey, typeof E3.clientX == "undefined" && typeof E3.clientY == "undefined" && (E3.clientX = o4, E3.clientY = s3), l3 = (/* @__PURE__ */ new Date()).getTime(), l3 - r4._mouseDownTime < i3 ? n4 += 1 : (n4 = 1, r4._mouseDownTime = l3), t3.prepFn && t3.prepFn(E3, o4, s3), wB && !d3 ? (c5 = Xse(), c5.style.cursor = window.getComputedStyle(a4).cursor) : wB || (c5 = document, u4 = window.getComputedStyle(document.documentElement).cursor, document.documentElement.style.cursor = window.getComputedStyle(a4).cursor), document.addEventListener("mouseup", k4), document.addEventListener("touchend", k4), t3.dragmode !== false && (E3.preventDefault(), document.addEventListener("mousemove", p3), document.addEventListener("touchmove", p3, { passive: false }));\n              }\n              function p3(E3) {\n                E3.preventDefault();\n                var S2 = jse(E3), L3 = t3.minDrag || Rlt.MINDRAG, x2 = _2(S2[0] - o4, S2[1] - s3, L3), C3 = x2[0], M4 = x2[1];\n                (C3 || M4) && (r4._dragged = true, Pb.unhover(r4, E3)), r4._dragged && t3.moveFn && !d3 && (r4._dragdata = { element: a4, dx: C3, dy: M4 }, t3.moveFn(C3, M4));\n              }\n              function k4(E3) {\n                if (delete r4._dragdata, t3.dragmode !== false && (E3.preventDefault(), document.removeEventListener("mousemove", p3), document.removeEventListener("touchmove", p3)), document.removeEventListener("mouseup", k4), document.removeEventListener("touchend", k4), wB ? Ilt(c5) : u4 && (c5.documentElement.style.cursor = u4, u4 = null), !r4._dragging) {\n                  r4._dragged = false;\n                  return;\n                }\n                if (r4._dragging = false, (/* @__PURE__ */ new Date()).getTime() - r4._mouseDownTime > i3 && (n4 = Math.max(n4 - 1, 1)), r4._dragged) t3.doneFn && t3.doneFn();\n                else {\n                  var S2;\n                  f4.target === h3 ? S2 = f4 : (S2 = { target: h3, srcElement: h3, toElement: h3 }, Object.keys(f4).concat(Object.keys(f4.__proto__)).forEach((L3) => {\n                    var x2 = f4[L3];\n                    !S2[L3] && typeof x2 != "function" && (S2[L3] = x2);\n                  })), t3.clickFn && t3.clickFn(n4, S2), d3 || h3.dispatchEvent(new MouseEvent("click", E3));\n                }\n                r4._dragging = false, r4._dragged = false;\n              }\n            };\n            function Xse() {\n              var e3 = document.createElement("div");\n              e3.className = "dragcover";\n              var t3 = e3.style;\n              return t3.position = "fixed", t3.left = 0, t3.right = 0, t3.top = 0, t3.bottom = 0, t3.zIndex = 999999999, t3.background = "none", document.body.appendChild(e3), e3;\n            }\n            Pb.coverSlip = Xse;\n            function jse(e3) {\n              return Llt(e3.changedTouches ? e3.changedTouches[0] : e3, document.body);\n            }\n          });\n          var Sg = ye((tar, Yse) => {\n            "use strict";\n            Yse.exports = function(t3, r4) {\n              (t3.attr("class") || "").split(" ").forEach(function(n4) {\n                n4.indexOf("cursor-") === 0 && t3.classed(n4, false);\n              }), r4 && t3.classed("cursor-" + r4, true);\n            };\n          });\n          var $se = ye((rar, Jse) => {\n            "use strict";\n            var TB = Sg(), fM = "data-savedcursor", Kse = "!!";\n            Jse.exports = function(t3, r4) {\n              var n4 = t3.attr(fM);\n              if (r4) {\n                if (!n4) {\n                  for (var i3 = (t3.attr("class") || "").split(" "), a4 = 0; a4 < i3.length; a4++) {\n                    var o4 = i3[a4];\n                    o4.indexOf("cursor-") === 0 && t3.attr(fM, o4.slice(7)).classed(o4, false);\n                  }\n                  t3.attr(fM) || t3.attr(fM, Kse);\n                }\n                TB(t3, r4);\n              } else n4 && (t3.attr(fM, null), n4 === Kse ? TB(t3) : TB(t3, n4));\n            };\n          });\n          var SB = ye((iar, Qse) => {\n            "use strict";\n            var AB = ec(), Dlt = Lh();\n            Qse.exports = { _isSubplotObj: true, visible: { valType: "boolean", dflt: true, editType: "legend" }, bgcolor: { valType: "color", editType: "legend" }, bordercolor: { valType: "color", dflt: Dlt.defaultLine, editType: "legend" }, maxheight: { valType: "number", min: 0, editType: "legend" }, borderwidth: { valType: "number", min: 0, dflt: 0, editType: "legend" }, font: AB({ editType: "legend" }), grouptitlefont: AB({ editType: "legend" }), orientation: { valType: "enumerated", values: ["v", "h"], dflt: "v", editType: "legend" }, traceorder: { valType: "flaglist", flags: ["reversed", "grouped"], extras: ["normal"], editType: "legend" }, tracegroupgap: { valType: "number", min: 0, dflt: 10, editType: "legend" }, entrywidth: { valType: "number", min: 0, editType: "legend" }, entrywidthmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "pixels", editType: "legend" }, indentation: { valType: "number", min: -15, dflt: 0, editType: "legend" }, itemsizing: { valType: "enumerated", values: ["trace", "constant"], dflt: "trace", editType: "legend" }, itemwidth: { valType: "number", min: 30, dflt: 30, editType: "legend" }, itemclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], dflt: "toggle", editType: "legend" }, itemdoubleclick: { valType: "enumerated", values: ["toggle", "toggleothers", false], dflt: "toggleothers", editType: "legend" }, groupclick: { valType: "enumerated", values: ["toggleitem", "togglegroup"], dflt: "togglegroup", editType: "legend" }, x: { valType: "number", editType: "legend" }, xref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left", editType: "legend" }, y: { valType: "number", editType: "legend" }, yref: { valType: "enumerated", dflt: "paper", values: ["container", "paper"], editType: "layoutstyle" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], editType: "legend" }, uirevision: { valType: "any", editType: "none" }, valign: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "middle", editType: "legend" }, title: { text: { valType: "string", dflt: "", editType: "legend" }, font: AB({ editType: "legend" }), side: { valType: "enumerated", values: ["top", "left", "top left", "top center", "top right"], editType: "legend" }, editType: "legend" }, editType: "legend" };\n          });\n          var FL = ye((DL) => {\n            "use strict";\n            DL.isGrouped = function(t3) {\n              return (t3.traceorder || "").indexOf("grouped") !== -1;\n            };\n            DL.isVertical = function(t3) {\n              return t3.orientation !== "h";\n            };\n            DL.isReversed = function(t3) {\n              return (t3.traceorder || "").indexOf("reversed") !== -1;\n            };\n          });\n          var EB = ye((aar, ele) => {\n            "use strict";\n            var zL = qa(), Yp = Dr(), Flt = vl(), zlt = Gl(), Olt = SB(), qlt = c3(), MB = FL();\n            function Blt(e3, t3, r4, n4) {\n              var i3 = t3[e3] || {}, a4 = Flt.newContainer(r4, e3);\n              function o4(N2, H) {\n                return Yp.coerce(i3, a4, Olt, N2, H);\n              }\n              var s3 = Yp.coerceFont(o4, "font", r4.font);\n              o4("bgcolor", r4.paper_bgcolor), o4("bordercolor");\n              var l3 = o4("visible");\n              if (!l3) return;\n              var u4, c5 = function(N2, H) {\n                var te = u4._input, oe = u4;\n                return Yp.coerce(te, oe, zlt, N2, H);\n              }, f4 = r4.font || {}, h3 = Yp.coerceFont(o4, "grouptitlefont", f4, { overrideDflt: { size: Math.round(f4.size * 1.1) } }), d3 = 0, v3 = false, _2 = "normal", b = (r4.shapes || []).filter(function(N2) {\n                return N2.showlegend;\n              });\n              function p3(N2) {\n                return zL.traceIs(N2, "pie-like") && N2._length != null && (Array.isArray(N2.legend) || Array.isArray(N2.showlegend));\n              }\n              n4.filter(p3).forEach(function(N2) {\n                N2.visible && d3++;\n                for (var H = 0; H < N2._length; H++) {\n                  var te = (Array.isArray(N2.legend) ? N2.legend[H] : N2.legend) || "legend";\n                  te === e3 && ((Array.isArray(N2.showlegend) ? N2.showlegend[H] : N2.showlegend) || N2._dfltShowLegend) && (v3 = true, d3++);\n                }\n                if (e3 === "legend" && N2._length > N2.legend.length) for (var oe = N2.legend.length; oe < N2._length; oe++) v3 = true, d3++;\n              });\n              for (var k4 = n4.concat(b).filter(function(N2) {\n                return !p3(u4) && e3 === (N2.legend || "legend");\n              }), E3 = 0; E3 < k4.length; E3++) if (u4 = k4[E3], !!u4.visible) {\n                var S2 = u4._isShape;\n                (u4.showlegend || u4._dfltShowLegend && !(u4._module && u4._module.attributes && u4._module.attributes.showlegend && u4._module.attributes.showlegend.dflt === false)) && (d3++, u4.showlegend && (v3 = true, (!S2 && zL.traceIs(u4, "pie-like") || u4._input.showlegend === true) && d3++), Yp.coerceFont(c5, "legendgrouptitle.font", h3)), (!S2 && zL.traceIs(u4, "bar") && r4.barmode === "stack" || ["tonextx", "tonexty"].indexOf(u4.fill) !== -1) && (_2 = MB.isGrouped({ traceorder: _2 }) ? "grouped+reversed" : "reversed"), u4.legendgroup !== void 0 && u4.legendgroup !== "" && (_2 = MB.isReversed({ traceorder: _2 }) ? "reversed+grouped" : "grouped");\n              }\n              var L3 = Yp.coerce(t3, r4, qlt, "showlegend", r4.showlegend || v3 && d3 > (e3 === "legend" ? 1 : 0));\n              if (L3 === false && (r4[e3] = void 0), !(L3 === false && !i3.uirevision) && (o4("uirevision", r4.uirevision), L3 !== false)) {\n                o4("borderwidth");\n                var x2 = o4("orientation"), C3 = o4("yref"), M4 = o4("xref"), g3 = x2 === "h", P3 = C3 === "paper", T3 = M4 === "paper", z3, O3, V2, G2 = "left";\n                g3 ? (z3 = 0, zL.getComponentMethod("rangeslider", "isVisible")(t3.xaxis) ? P3 ? (O3 = 1.1, V2 = "bottom") : (O3 = 1, V2 = "top") : P3 ? (O3 = -0.1, V2 = "top") : (O3 = 0, V2 = "bottom")) : (O3 = 1, V2 = "auto", T3 ? z3 = 1.02 : (z3 = 1, G2 = "right")), Yp.coerce(i3, a4, { x: { valType: "number", editType: "legend", min: T3 ? -2 : 0, max: T3 ? 3 : 1, dflt: z3 } }, "x"), Yp.coerce(i3, a4, { y: { valType: "number", editType: "legend", min: P3 ? -2 : 0, max: P3 ? 3 : 1, dflt: O3 } }, "y"), o4("traceorder", _2), MB.isGrouped(r4[e3]) && o4("tracegroupgap"), o4("entrywidth"), o4("entrywidthmode"), o4("indentation"), o4("itemsizing"), o4("itemwidth"), o4("itemclick"), o4("itemdoubleclick"), o4("groupclick"), o4("xanchor", G2), o4("yanchor", V2), o4("maxheight"), o4("valign"), Yp.noneOrAll(i3, a4, ["x", "y"]);\n                var Z = o4("title.text");\n                if (Z) {\n                  o4("title.side", g3 ? "left" : "top");\n                  var j3 = Yp.extendFlat({}, s3, { size: Yp.bigFont(s3.size) });\n                  Yp.coerceFont(o4, "title.font", j3);\n                }\n              }\n            }\n            ele.exports = function(t3, r4, n4) {\n              var i3, a4 = n4.slice(), o4 = r4.shapes;\n              if (o4) for (i3 = 0; i3 < o4.length; i3++) {\n                var s3 = o4[i3];\n                if (s3.showlegend) {\n                  var l3 = { _input: s3._input, visible: s3.visible, showlegend: s3.showlegend, legend: s3.legend };\n                  a4.push(l3);\n                }\n              }\n              var u4 = ["legend"];\n              for (i3 = 0; i3 < a4.length; i3++) Array.isArray(a4[i3].legend) ? u4 = u4.concat(a4[i3].legend) : Yp.pushUnique(u4, a4[i3].legend);\n              for (r4._legends = [], i3 = 0; i3 < u4.length; i3++) {\n                var c5 = u4[i3];\n                Blt(c5, t3, r4, a4), r4[c5] && (r4[c5]._id = c5), r4._legends.push(c5);\n              }\n            };\n          });\n          var rle = ye((oar, tle) => {\n            "use strict";\n            var q3 = qa(), CB = Dr(), Nlt = CB.pushUnique, kB = true;\n            tle.exports = function(t3, r4, n4) {\n              var i3 = r4._fullLayout;\n              if (r4._dragged || r4._editing) return;\n              var a4 = i3.legend.itemclick, o4 = i3.legend.itemdoubleclick, s3 = i3.legend.groupclick;\n              n4 === 1 && a4 === "toggle" && o4 === "toggleothers" && kB && r4.data && r4._context.showTips && CB.notifier(CB._(r4, "Double-click on legend to isolate one trace"), "long"), kB = false;\n              var l3;\n              if (n4 === 1 ? l3 = a4 : n4 === 2 && (l3 = o4), !l3) return;\n              var u4 = s3 === "togglegroup", c5 = i3.hiddenlabels ? i3.hiddenlabels.slice() : [], f4 = t3.data()[0][0];\n              if (f4.groupTitle && f4.noClick) return;\n              var h3 = r4._fullData, d3 = (i3.shapes || []).filter(function(Gt) {\n                return Gt.showlegend;\n              }), v3 = h3.concat(d3), _2 = f4.trace;\n              _2._isShape && (_2 = _2._fullInput);\n              var b = _2.legendgroup, p3, k4, E3, S2, L3, x2, C3 = {}, M4 = [], g3 = [], P3 = [];\n              function T3(Gt, Nt) {\n                var Jt = M4.indexOf(Gt), sr = C3.visible;\n                return sr || (sr = C3.visible = []), M4.indexOf(Gt) === -1 && (M4.push(Gt), Jt = M4.length - 1), sr[Jt] = Nt, Jt;\n              }\n              var z3 = (i3.shapes || []).map(function(Gt) {\n                return Gt._input;\n              }), O3 = false;\n              function V2(Gt, Nt) {\n                z3[Gt].visible = Nt, O3 = true;\n              }\n              function G2(Gt, Nt) {\n                if (!(f4.groupTitle && !u4)) {\n                  var Jt = Gt._fullInput || Gt, sr = Jt._isShape, wr = Jt.index;\n                  wr === void 0 && (wr = Jt._index);\n                  var cr = Jt.visible === false ? false : Nt;\n                  sr ? V2(wr, cr) : T3(wr, cr);\n                }\n              }\n              var Z = _2.legend, j3 = _2._fullInput, N2 = j3 && j3._isShape;\n              if (!N2 && q3.traceIs(_2, "pie-like")) {\n                var H = f4.label, te = c5.indexOf(H);\n                if (l3 === "toggle") te === -1 ? c5.push(H) : c5.splice(te, 1);\n                else if (l3 === "toggleothers") {\n                  var oe = te !== -1, _e = [];\n                  for (p3 = 0; p3 < r4.calcdata.length; p3++) {\n                    var Ee = r4.calcdata[p3];\n                    for (k4 = 0; k4 < Ee.length; k4++) {\n                      var Ce = Ee[k4], me = Ce.label;\n                      Z === Ee[0].trace.legend && H !== me && (c5.indexOf(me) === -1 && (oe = true), Nlt(c5, me), _e.push(me));\n                    }\n                  }\n                  if (!oe) for (var ie = 0; ie < _e.length; ie++) {\n                    var Se = c5.indexOf(_e[ie]);\n                    Se !== -1 && c5.splice(Se, 1);\n                  }\n                }\n                q3.call("_guiRelayout", r4, "hiddenlabels", c5);\n              } else {\n                var Le = b && b.length, Ae = [], Fe;\n                if (Le) for (p3 = 0; p3 < v3.length; p3++) Fe = v3[p3], Fe.visible && Fe.legendgroup === b && Ae.push(p3);\n                if (l3 === "toggle") {\n                  var Pe;\n                  switch (_2.visible) {\n                    case true:\n                      Pe = "legendonly";\n                      break;\n                    case false:\n                      Pe = false;\n                      break;\n                    case "legendonly":\n                      Pe = true;\n                      break;\n                  }\n                  if (Le) if (u4) for (p3 = 0; p3 < v3.length; p3++) {\n                    var ge = v3[p3];\n                    ge.visible !== false && ge.legendgroup === b && G2(ge, Pe);\n                  }\n                  else G2(_2, Pe);\n                  else G2(_2, Pe);\n                } else if (l3 === "toggleothers") {\n                  var Re, ce, Ze, ut, pt, Zt = true;\n                  for (p3 = 0; p3 < v3.length; p3++) if (pt = v3[p3], Re = pt === _2, Ze = pt.showlegend !== true, !(Re || Ze) && (ce = Le && pt.legendgroup === b, !ce && pt.legend === Z && pt.visible === true && !q3.traceIs(pt, "notLegendIsolatable"))) {\n                    Zt = false;\n                    break;\n                  }\n                  for (p3 = 0; p3 < v3.length; p3++) if (pt = v3[p3], !(pt.visible === false || pt.legend !== Z) && !q3.traceIs(pt, "notLegendIsolatable")) switch (_2.visible) {\n                    case "legendonly":\n                      G2(pt, true);\n                      break;\n                    case true:\n                      ut = Zt ? true : "legendonly", Re = pt === _2, Ze = pt.showlegend !== true && !pt.legendgroup, ce = Re || Le && pt.legendgroup === b, G2(pt, ce || Ze ? true : ut);\n                      break;\n                  }\n                }\n                for (p3 = 0; p3 < g3.length; p3++) if (E3 = g3[p3], !!E3) {\n                  var st = E3.constructUpdate(), lt = Object.keys(st);\n                  for (k4 = 0; k4 < lt.length; k4++) S2 = lt[k4], x2 = C3[S2] = C3[S2] || [], x2[P3[p3]] = st[S2];\n                }\n                for (L3 = Object.keys(C3), p3 = 0; p3 < L3.length; p3++) for (S2 = L3[p3], k4 = 0; k4 < M4.length; k4++) C3[S2].hasOwnProperty(k4) || (C3[S2][k4] = void 0);\n                O3 ? q3.call("_guiUpdate", r4, C3, { shapes: z3 }, M4) : q3.call("_guiRestyle", r4, C3, M4);\n              }\n            };\n          });\n          var LB = ye((sar, ile) => {\n            "use strict";\n            ile.exports = { scrollBarWidth: 6, scrollBarMinHeight: 20, scrollBarColor: "#808BA4", scrollBarMargin: 4, scrollBarEnterAttrs: { rx: 20, ry: 3, width: 0, height: 0 }, titlePad: 2, itemGap: 5 };\n          });\n          var ole = ye((lar, ale) => {\n            "use strict";\n            var nle = qa(), PB = FL();\n            ale.exports = function(t3, r4, n4) {\n              var i3 = r4._inHover, a4 = PB.isGrouped(r4), o4 = PB.isReversed(r4), s3 = {}, l3 = [], u4 = false, c5 = {}, f4 = 0, h3 = 0, d3, v3;\n              function _2(H, te, oe) {\n                if (r4.visible !== false && !(n4 && H !== r4._id)) if (te === "" || !PB.isGrouped(r4)) {\n                  var _e = "~~i" + f4;\n                  l3.push(_e), s3[_e] = [oe], f4++;\n                } else l3.indexOf(te) === -1 ? (l3.push(te), u4 = true, s3[te] = [oe]) : s3[te].push(oe);\n              }\n              for (d3 = 0; d3 < t3.length; d3++) {\n                var b = t3[d3], p3 = b[0], k4 = p3.trace, E3 = k4.legend, S2 = k4.legendgroup;\n                if (!(!i3 && (!k4.visible || !k4.showlegend))) if (nle.traceIs(k4, "pie-like")) {\n                  var L3 = Array.isArray(k4.legend), x2 = Array.isArray(k4.showlegend);\n                  for (c5[S2] || (c5[S2] = {}), v3 = 0; v3 < b.length; v3++) if (!(x2 && k4.showlegend[b[v3].i] === false)) {\n                    L3 && (E3 = k4.legend[b[v3].i] || "legend");\n                    var C3 = b[v3].label;\n                    c5[S2][C3] || (_2(E3, S2, { label: C3, color: b[v3].color, i: b[v3].i, trace: k4, pts: b[v3].pts }), c5[S2][C3] = true, h3 = Math.max(h3, (C3 || "").length));\n                  }\n                } else _2(E3, S2, p3), h3 = Math.max(h3, (k4.name || "").length);\n              }\n              if (!l3.length) return [];\n              var M4 = !u4 || !a4, g3 = [];\n              for (d3 = 0; d3 < l3.length; d3++) {\n                var P3 = s3[l3[d3]];\n                M4 ? g3.push(P3[0]) : g3.push(P3);\n              }\n              for (M4 && (g3 = [g3]), d3 = 0; d3 < g3.length; d3++) {\n                var T3 = 1 / 0;\n                for (v3 = 0; v3 < g3[d3].length; v3++) {\n                  var z3 = g3[d3][v3].trace.legendrank;\n                  T3 > z3 && (T3 = z3);\n                }\n                g3[d3][0]._groupMinRank = T3, g3[d3][0]._preGroupSort = d3;\n              }\n              var O3 = function(H, te) {\n                return H[0]._groupMinRank - te[0]._groupMinRank || H[0]._preGroupSort - te[0]._preGroupSort;\n              }, V2 = function(H, te) {\n                return H.trace.legendrank - te.trace.legendrank || H._preSort - te._preSort;\n              };\n              for (g3.forEach(function(H, te) {\n                H[0]._preGroupSort = te;\n              }), g3.sort(O3), d3 = 0; d3 < g3.length; d3++) {\n                g3[d3].forEach(function(H, te) {\n                  H._preSort = te;\n                }), g3[d3].sort(V2);\n                var G2 = g3[d3][0].trace, Z = null;\n                for (v3 = 0; v3 < g3[d3].length; v3++) {\n                  var j3 = g3[d3][v3].trace.legendgrouptitle;\n                  if (j3 && j3.text) {\n                    Z = j3, i3 && (j3.font = r4._groupTitleFont);\n                    break;\n                  }\n                }\n                if (o4 && g3[d3].reverse(), Z) {\n                  var N2 = false;\n                  for (v3 = 0; v3 < g3[d3].length; v3++) if (nle.traceIs(g3[d3][v3].trace, "pie-like")) {\n                    N2 = true;\n                    break;\n                  }\n                  g3[d3].unshift({ i: -1, groupTitle: Z, noClick: N2, trace: { showlegend: G2.showlegend, legendgroup: G2.legendgroup, visible: r4.groupclick === "toggleitem" ? true : G2.visible } });\n                }\n                for (v3 = 0; v3 < g3[d3].length; v3++) g3[d3][v3] = [g3[d3][v3]];\n              }\n              return r4._lgroupsLength = g3.length, r4._maxNameLength = h3, g3;\n            };\n          });\n          var l_ = ye((Ib) => {\n            "use strict";\n            var OL = Dr();\n            function sle(e3) {\n              return e3.indexOf("e") !== -1 ? e3.replace(/[.]?0+e/, "e") : e3.indexOf(".") !== -1 ? e3.replace(/[.]?0+$/, "") : e3;\n            }\n            Ib.formatPiePercent = function(t3, r4) {\n              var n4 = sle((t3 * 100).toPrecision(3));\n              return OL.numSeparate(n4, r4) + "%";\n            };\n            Ib.formatPieValue = function(t3, r4) {\n              var n4 = sle(t3.toPrecision(10));\n              return OL.numSeparate(n4, r4);\n            };\n            Ib.getFirstFilled = function(t3, r4) {\n              if (OL.isArrayOrTypedArray(t3)) for (var n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]];\n                if (i3 || i3 === 0 || i3 === "") return i3;\n              }\n            };\n            Ib.castOption = function(t3, r4) {\n              if (OL.isArrayOrTypedArray(t3)) return Ib.getFirstFilled(t3, r4);\n              if (t3) return t3;\n            };\n            Ib.getRotationAngle = function(e3) {\n              return (e3 === "auto" ? 0 : e3) * Math.PI / 180;\n            };\n          });\n          var ule = ye((car, lle) => {\n            "use strict";\n            var Ult = So(), Vlt = ka();\n            lle.exports = function(t3, r4, n4, i3) {\n              var a4 = n4.marker.pattern;\n              a4 && a4.shape ? Ult.pointStyle(t3, n4, i3, r4) : Vlt.fill(t3, r4.color);\n            };\n          });\n          var B3 = ye((far, hle) => {\n            "use strict";\n            var cle = ka(), fle = l_().castOption, Glt = ule();\n            hle.exports = function(t3, r4, n4, i3) {\n              var a4 = n4.marker.line, o4 = fle(a4.color, r4.pts) || cle.defaultLine, s3 = fle(a4.width, r4.pts) || 0;\n              t3.call(Glt, r4, n4, i3).style("stroke-width", s3).call(cle.stroke, o4);\n            };\n          });\n          var FB = ye((har, yle) => {\n            "use strict";\n            var qv = Oa(), IB = qa(), _v = Dr(), dle = _v.strTranslate, Kp = So(), w0 = ka(), RB = pv().extractOpts, qL = Ru(), Hlt = B3(), jlt = l_().castOption, Wlt = LB(), vle = 12, ple = 5, Rb = 2, Xlt = 10, N3 = 5;\n            yle.exports = function(t3, r4, n4) {\n              var i3 = r4._fullLayout;\n              n4 || (n4 = i3.legend);\n              var a4 = n4.itemsizing === "constant", o4 = n4.itemwidth, s3 = (o4 + Wlt.itemGap * 2) / 2, l3 = dle(s3, 0), u4 = function(C3, M4, g3, P3) {\n                var T3;\n                if (C3 + 1) T3 = C3;\n                else if (M4 && M4.width > 0) T3 = M4.width;\n                else return 0;\n                return a4 ? P3 : Math.min(T3, g3);\n              };\n              t3.each(function(C3) {\n                var M4 = qv.select(this), g3 = _v.ensureSingle(M4, "g", "layers");\n                g3.style("opacity", C3[0].trace.opacity);\n                var P3 = n4.indentation, T3 = n4.valign, z3 = C3[0].lineHeight, O3 = C3[0].height;\n                if (T3 === "middle" && P3 === 0 || !z3 || !O3) g3.attr("transform", null);\n                else {\n                  var V2 = { top: 1, bottom: -1 }[T3], G2 = V2 * (0.5 * (z3 - O3 + 3)) || 0, Z = n4.indentation;\n                  g3.attr("transform", dle(Z, G2));\n                }\n                var j3 = g3.selectAll("g.legendfill").data([C3]);\n                j3.enter().append("g").classed("legendfill", true);\n                var N2 = g3.selectAll("g.legendlines").data([C3]);\n                N2.enter().append("g").classed("legendlines", true);\n                var H = g3.selectAll("g.legendsymbols").data([C3]);\n                H.enter().append("g").classed("legendsymbols", true), H.selectAll("g.legendpoints").data([C3]).enter().append("g").classed("legendpoints", true);\n              }).each(x2).each(h3).each(v3).each(d3).each(b).each(S2).each(E3).each(c5).each(f4).each(p3).each(k4);\n              function c5(C3) {\n                var M4 = gle(C3), g3 = M4.showFill, P3 = M4.showLine, T3 = M4.showGradientLine, z3 = M4.showGradientFill, O3 = M4.anyFill, V2 = M4.anyLine, G2 = C3[0], Z = G2.trace, j3, N2, H = RB(Z), te = H.colorscale, oe = H.reversescale, _e = function(Ae) {\n                  if (Ae.size()) if (g3) Kp.fillGroupStyle(Ae, r4, true);\n                  else {\n                    var Fe = "legendfill-" + Z.uid;\n                    Kp.gradient(Ae, r4, Fe, DB(oe), te, "fill");\n                  }\n                }, Ee = function(Ae) {\n                  if (Ae.size()) {\n                    var Fe = "legendline-" + Z.uid;\n                    Kp.lineGroupStyle(Ae), Kp.gradient(Ae, r4, Fe, DB(oe), te, "stroke");\n                  }\n                }, Ce = qL.hasMarkers(Z) || !O3 ? "M5,0" : V2 ? "M5,-2" : "M5,-3", me = qv.select(this), ie = me.select(".legendfill").selectAll("path").data(g3 || z3 ? [C3] : []);\n                if (ie.enter().append("path").classed("js-fill", true), ie.exit().remove(), ie.attr("d", Ce + "h" + o4 + "v6h-" + o4 + "z").call(_e), P3 || T3) {\n                  var Se = u4(void 0, Z.line, Xlt, ple);\n                  N2 = _v.minExtend(Z, { line: { width: Se } }), j3 = [_v.minExtend(G2, { trace: N2 })];\n                }\n                var Le = me.select(".legendlines").selectAll("path").data(P3 || T3 ? [j3] : []);\n                Le.enter().append("path").classed("js-line", true), Le.exit().remove(), Le.attr("d", Ce + (T3 ? "l" + o4 + ",0.0001" : "h" + o4)).call(P3 ? Kp.lineGroupStyle : Ee);\n              }\n              function f4(C3) {\n                var M4 = gle(C3), g3 = M4.anyFill, P3 = M4.anyLine, T3 = M4.showLine, z3 = M4.showMarker, O3 = C3[0], V2 = O3.trace, G2 = !z3 && !P3 && !g3 && qL.hasText(V2), Z, j3;\n                function N2(ie, Se, Le, Ae) {\n                  var Fe = _v.nestedProperty(V2, ie).get(), Pe = _v.isArrayOrTypedArray(Fe) && Se ? Se(Fe) : Fe;\n                  if (a4 && Pe && Ae !== void 0 && (Pe = Ae), Le) {\n                    if (Pe < Le[0]) return Le[0];\n                    if (Pe > Le[1]) return Le[1];\n                  }\n                  return Pe;\n                }\n                function H(ie) {\n                  return O3._distinct && O3.index && ie[O3.index] ? ie[O3.index] : ie[0];\n                }\n                if (z3 || G2 || T3) {\n                  var te = {}, oe = {};\n                  if (z3) {\n                    te.mc = N2("marker.color", H), te.mx = N2("marker.symbol", H), te.mo = N2("marker.opacity", _v.mean, [0.2, 1]), te.mlc = N2("marker.line.color", H), te.mlw = N2("marker.line.width", _v.mean, [0, 5], Rb), oe.marker = { sizeref: 1, sizemin: 1, sizemode: "diameter" };\n                    var _e = N2("marker.size", _v.mean, [2, 16], vle);\n                    te.ms = _e, oe.marker.size = _e;\n                  }\n                  T3 && (oe.line = { width: N2("line.width", H, [0, 10], ple) }), G2 && (te.tx = "Aa", te.tp = N2("textposition", H), te.ts = 10, te.tc = N2("textfont.color", H), te.tf = N2("textfont.family", H), te.tw = N2("textfont.weight", H), te.ty = N2("textfont.style", H), te.tv = N2("textfont.variant", H), te.tC = N2("textfont.textcase", H), te.tE = N2("textfont.lineposition", H), te.tS = N2("textfont.shadow", H)), Z = [_v.minExtend(O3, te)], j3 = _v.minExtend(V2, oe), j3.selectedpoints = null, j3.texttemplate = null;\n                }\n                var Ee = qv.select(this).select("g.legendpoints"), Ce = Ee.selectAll("path.scatterpts").data(z3 ? Z : []);\n                Ce.enter().insert("path", ":first-child").classed("scatterpts", true).attr("transform", l3), Ce.exit().remove(), Ce.call(Kp.pointStyle, j3, r4), z3 && (Z[0].mrc = 3);\n                var me = Ee.selectAll("g.pointtext").data(G2 ? Z : []);\n                me.enter().append("g").classed("pointtext", true).append("text").attr("transform", l3), me.exit().remove(), me.selectAll("text").call(Kp.textPointStyle, j3, r4);\n              }\n              function h3(C3) {\n                var M4 = C3[0].trace, g3 = M4.type === "waterfall";\n                if (C3[0]._distinct && g3) {\n                  var P3 = C3[0].trace[C3[0].dir].marker;\n                  return C3[0].mc = P3.color, C3[0].mlw = P3.line.width, C3[0].mlc = P3.line.color, _2(C3, this, "waterfall");\n                }\n                var T3 = [];\n                M4.visible && g3 && (T3 = C3[0].hasTotals ? [["increasing", "M-6,-6V6H0Z"], ["totals", "M6,6H0L-6,-6H-0Z"], ["decreasing", "M6,6V-6H0Z"]] : [["increasing", "M-6,-6V6H6Z"], ["decreasing", "M6,6V-6H-6Z"]]);\n                var z3 = qv.select(this).select("g.legendpoints").selectAll("path.legendwaterfall").data(T3);\n                z3.enter().append("path").classed("legendwaterfall", true).attr("transform", l3).style("stroke-miterlimit", 1), z3.exit().remove(), z3.each(function(O3) {\n                  var V2 = qv.select(this), G2 = M4[O3[0]].marker, Z = u4(void 0, G2.line, N3, Rb);\n                  V2.attr("d", O3[1]).style("stroke-width", Z + "px").call(w0.fill, G2.color), Z && V2.call(w0.stroke, G2.line.color);\n                });\n              }\n              function d3(C3) {\n                _2(C3, this);\n              }\n              function v3(C3) {\n                _2(C3, this, "funnel");\n              }\n              function _2(C3, M4, g3) {\n                var P3 = C3[0].trace, T3 = P3.marker || {}, z3 = T3.line || {}, O3 = T3.cornerradius ? "M6,3a3,3,0,0,1-3,3H-3a3,3,0,0,1-3-3V-3a3,3,0,0,1,3-3H3a3,3,0,0,1,3,3Z" : "M6,6H-6V-6H6Z", V2 = g3 ? P3.visible && P3.type === g3 : IB.traceIs(P3, "bar"), G2 = qv.select(M4).select("g.legendpoints").selectAll("path.legend" + g3).data(V2 ? [C3] : []);\n                G2.enter().append("path").classed("legend" + g3, true).attr("d", O3).attr("transform", l3), G2.exit().remove(), G2.each(function(Z) {\n                  var j3 = qv.select(this), N2 = Z[0], H = u4(N2.mlw, T3.line, N3, Rb);\n                  j3.style("stroke-width", H + "px");\n                  var te = N2.mcc;\n                  if (!n4._inHover && "mc" in N2) {\n                    var oe = RB(T3), _e = oe.mid;\n                    _e === void 0 && (_e = (oe.max + oe.min) / 2), te = Kp.tryColorscale(T3, "")(_e);\n                  }\n                  var Ee = te || N2.mc || T3.color, Ce = T3.pattern, me = Kp.getPatternAttr, ie = Ce && (me(Ce.shape, 0, "") || me(Ce.path, 0, ""));\n                  if (ie) {\n                    var Se = me(Ce.bgcolor, 0, null), Le = me(Ce.fgcolor, 0, null), Ae = Ce.fgopacity, Fe = mle(Ce.size, 8, 10), Pe = mle(Ce.solidity, 0.5, 1), ge = "legend-" + P3.uid;\n                    j3.call(Kp.pattern, "legend", r4, ge, ie, Fe, Pe, te, Ce.fillmode, Se, Le, Ae);\n                  } else j3.call(w0.fill, Ee);\n                  H && w0.stroke(j3, N2.mlc || z3.color);\n                });\n              }\n              function b(C3) {\n                var M4 = C3[0].trace, g3 = qv.select(this).select("g.legendpoints").selectAll("path.legendbox").data(M4.visible && IB.traceIs(M4, "box-violin") ? [C3] : []);\n                g3.enter().append("path").classed("legendbox", true).attr("d", "M6,6H-6V-6H6Z").attr("transform", l3), g3.exit().remove(), g3.each(function() {\n                  var P3 = qv.select(this);\n                  if ((M4.boxpoints === "all" || M4.points === "all") && w0.opacity(M4.fillcolor) === 0 && w0.opacity((M4.line || {}).color) === 0) {\n                    var T3 = _v.minExtend(M4, { marker: { size: a4 ? vle : _v.constrain(M4.marker.size, 2, 16), sizeref: 1, sizemin: 1, sizemode: "diameter" } });\n                    g3.call(Kp.pointStyle, T3, r4);\n                  } else {\n                    var z3 = u4(void 0, M4.line, N3, Rb);\n                    P3.style("stroke-width", z3 + "px").call(w0.fill, M4.fillcolor), z3 && w0.stroke(P3, M4.line.color);\n                  }\n                });\n              }\n              function p3(C3) {\n                var M4 = C3[0].trace, g3 = qv.select(this).select("g.legendpoints").selectAll("path.legendcandle").data(M4.visible && M4.type === "candlestick" ? [C3, C3] : []);\n                g3.enter().append("path").classed("legendcandle", true).attr("d", function(P3, T3) {\n                  return T3 ? "M-15,0H-8M-8,6V-6H8Z" : "M15,0H8M8,-6V6H-8Z";\n                }).attr("transform", l3).style("stroke-miterlimit", 1), g3.exit().remove(), g3.each(function(P3, T3) {\n                  var z3 = qv.select(this), O3 = M4[T3 ? "increasing" : "decreasing"], V2 = u4(void 0, O3.line, N3, Rb);\n                  z3.style("stroke-width", V2 + "px").call(w0.fill, O3.fillcolor), V2 && w0.stroke(z3, O3.line.color);\n                });\n              }\n              function k4(C3) {\n                var M4 = C3[0].trace, g3 = qv.select(this).select("g.legendpoints").selectAll("path.legendohlc").data(M4.visible && M4.type === "ohlc" ? [C3, C3] : []);\n                g3.enter().append("path").classed("legendohlc", true).attr("d", function(P3, T3) {\n                  return T3 ? "M-15,0H0M-8,-6V0" : "M15,0H0M8,6V0";\n                }).attr("transform", l3).style("stroke-miterlimit", 1), g3.exit().remove(), g3.each(function(P3, T3) {\n                  var z3 = qv.select(this), O3 = M4[T3 ? "increasing" : "decreasing"], V2 = u4(void 0, O3.line, N3, Rb);\n                  z3.style("fill", "none").call(Kp.dashLine, O3.line.dash, V2), V2 && w0.stroke(z3, O3.line.color);\n                });\n              }\n              function E3(C3) {\n                L3(C3, this, "pie");\n              }\n              function S2(C3) {\n                L3(C3, this, "funnelarea");\n              }\n              function L3(C3, M4, g3) {\n                var P3 = C3[0], T3 = P3.trace, z3 = g3 ? T3.visible && T3.type === g3 : IB.traceIs(T3, g3), O3 = qv.select(M4).select("g.legendpoints").selectAll("path.legend" + g3).data(z3 ? [C3] : []);\n                if (O3.enter().append("path").classed("legend" + g3, true).attr("d", "M6,6H-6V-6H6Z").attr("transform", l3), O3.exit().remove(), O3.size()) {\n                  var V2 = T3.marker || {}, G2 = u4(jlt(V2.line.width, P3.pts), V2.line, N3, Rb), Z = "pieLike", j3 = _v.minExtend(T3, { marker: { line: { width: G2 } } }, Z), N2 = _v.minExtend(P3, { trace: j3 }, Z);\n                  Hlt(O3, N2, j3, r4);\n                }\n              }\n              function x2(C3) {\n                var M4 = C3[0].trace, g3, P3 = [];\n                if (M4.visible) switch (M4.type) {\n                  case "histogram2d":\n                  case "heatmap":\n                    P3 = [["M-15,-2V4H15V-2Z"]], g3 = true;\n                    break;\n                  case "choropleth":\n                  case "choroplethmapbox":\n                  case "choroplethmap":\n                    P3 = [["M-6,-6V6H6V-6Z"]], g3 = true;\n                    break;\n                  case "densitymapbox":\n                  case "densitymap":\n                    P3 = [["M-6,0 a6,6 0 1,0 12,0 a 6,6 0 1,0 -12,0"]], g3 = "radial";\n                    break;\n                  case "cone":\n                    P3 = [["M-6,2 A2,2 0 0,0 -6,6 V6L6,4Z"], ["M-6,-6 A2,2 0 0,0 -6,-2 L6,-4Z"], ["M-6,-2 A2,2 0 0,0 -6,2 L6,0Z"]], g3 = false;\n                    break;\n                  case "streamtube":\n                    P3 = [["M-6,2 A2,2 0 0,0 -6,6 H6 A2,2 0 0,1 6,2 Z"], ["M-6,-6 A2,2 0 0,0 -6,-2 H6 A2,2 0 0,1 6,-6 Z"], ["M-6,-2 A2,2 0 0,0 -6,2 H6 A2,2 0 0,1 6,-2 Z"]], g3 = false;\n                    break;\n                  case "surface":\n                    P3 = [["M-6,-6 A2,3 0 0,0 -6,0 H6 A2,3 0 0,1 6,-6 Z"], ["M-6,1 A2,3 0 0,1 -6,6 H6 A2,3 0 0,0 6,0 Z"]], g3 = true;\n                    break;\n                  case "mesh3d":\n                    P3 = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]], g3 = false;\n                    break;\n                  case "volume":\n                    P3 = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6H6L0,6Z"]], g3 = true;\n                    break;\n                  case "isosurface":\n                    P3 = [["M-6,6H0L-6,-6Z"], ["M6,6H0L6,-6Z"], ["M-6,-6 A12,24 0 0,0 6,-6 L0,6Z"]], g3 = false;\n                    break;\n                }\n                var T3 = qv.select(this).select("g.legendpoints").selectAll("path.legend3dandfriends").data(P3);\n                T3.enter().append("path").classed("legend3dandfriends", true).attr("transform", l3).style("stroke-miterlimit", 1), T3.exit().remove(), T3.each(function(z3, O3) {\n                  var V2 = qv.select(this), G2 = RB(M4), Z = G2.colorscale, j3 = G2.reversescale, N2 = function(_e) {\n                    if (_e.size()) {\n                      var Ee = "legendfill-" + M4.uid;\n                      Kp.gradient(_e, r4, Ee, DB(j3, g3 === "radial"), Z, "fill");\n                    }\n                  }, H;\n                  if (Z) {\n                    if (!g3) {\n                      var oe = Z.length;\n                      H = O3 === 0 ? Z[j3 ? oe - 1 : 0][1] : O3 === 1 ? Z[j3 ? 0 : oe - 1][1] : Z[Math.floor((oe - 1) / 2)][1];\n                    }\n                  } else {\n                    var te = M4.vertexcolor || M4.facecolor || M4.color;\n                    H = _v.isArrayOrTypedArray(te) ? te[O3] || te[0] : te;\n                  }\n                  V2.attr("d", z3[0]), H ? V2.call(w0.fill, H) : V2.call(N2);\n                });\n              }\n            };\n            function DB(e3, t3) {\n              var r4 = t3 ? "radial" : "horizontal";\n              return r4 + (e3 ? "" : "reversed");\n            }\n            function gle(e3) {\n              var t3 = e3[0].trace, r4 = t3.contours, n4 = qL.hasLines(t3), i3 = qL.hasMarkers(t3), a4 = t3.visible && t3.fill && t3.fill !== "none", o4 = false, s3 = false;\n              if (r4) {\n                var l3 = r4.coloring;\n                l3 === "lines" ? o4 = true : n4 = l3 === "none" || l3 === "heatmap" || r4.showlines, r4.type === "constraint" ? a4 = r4._operation !== "=" : (l3 === "fill" || l3 === "heatmap") && (s3 = true);\n              }\n              return { showMarker: i3, showLine: n4, showFill: a4, showGradientLine: o4, showGradientFill: s3, anyLine: n4 || o4, anyFill: a4 || s3 };\n            }\n            function mle(e3, t3, r4) {\n              return e3 && _v.isArrayOrTypedArray(e3) ? t3 : e3 > r4 ? r4 : e3;\n            }\n          });\n          var BB = ye((dar, kle) => {\n            "use strict";\n            var Mp = Oa(), Rh = Dr(), OB = Mc(), G3 = qa(), _le = _3(), zB = yv(), Dh = So(), NL = ka(), Db = ru(), xle = rle(), ed = LB(), qB = $h(), Mle = qB.LINE_SPACING, V3 = qB.FROM_TL, ble = qB.FROM_BR, wle = ole(), Zlt = FB(), Tle = FL(), U3 = 1, Ylt = /^legend[0-9]*$/;\n            kle.exports = function(t3, r4) {\n              if (r4) Ale(t3, r4);\n              else {\n                var n4 = t3._fullLayout, i3 = n4._legends, a4 = n4._infolayer.selectAll(\'[class^="legend"]\');\n                a4.each(function() {\n                  var u4 = Mp.select(this), c5 = u4.attr("class"), f4 = c5.split(" ")[0];\n                  f4.match(Ylt) && i3.indexOf(f4) === -1 && u4.remove();\n                });\n                for (var o4 = 0; o4 < i3.length; o4++) {\n                  var s3 = i3[o4], l3 = t3._fullLayout[s3];\n                  Ale(t3, l3);\n                }\n              }\n            };\n            function Klt(e3, t3, r4) {\n              if (!(t3.title.side !== "top center" && t3.title.side !== "top right")) {\n                var n4 = t3.title.font, i3 = n4.size * Mle, a4 = 0, o4 = e3.node(), s3 = Dh.bBox(o4).width;\n                t3.title.side === "top center" ? a4 = 0.5 * (t3._width - 2 * r4 - 2 * ed.titlePad - s3) : t3.title.side === "top right" && (a4 = t3._width - 2 * r4 - 2 * ed.titlePad - s3), Db.positionText(e3, r4 + ed.titlePad + a4, r4 + i3);\n              }\n            }\n            function Ale(e3, t3) {\n              var r4 = t3 || {}, n4 = e3._fullLayout, i3 = HL(r4), a4, o4, s3 = r4._inHover;\n              if (s3 ? (o4 = r4.layer, a4 = "hover") : (o4 = n4._infolayer, a4 = i3), !!o4) {\n                a4 += n4._uid, e3._legendMouseDownTime || (e3._legendMouseDownTime = 0);\n                var l3;\n                if (s3) {\n                  if (!r4.entries) return;\n                  l3 = wle(r4.entries, r4);\n                } else {\n                  for (var u4 = (e3.calcdata || []).slice(), c5 = n4.shapes, f4 = 0; f4 < c5.length; f4++) {\n                    var h3 = c5[f4];\n                    if (h3.showlegend) {\n                      var d3 = { _isShape: true, _fullInput: h3, index: h3._index, name: h3.name || h3.label.text || "shape " + h3._index, legend: h3.legend, legendgroup: h3.legendgroup, legendgrouptitle: h3.legendgrouptitle, legendrank: h3.legendrank, legendwidth: h3.legendwidth, showlegend: h3.showlegend, visible: h3.visible, opacity: h3.opacity, mode: h3.type === "line" ? "lines" : "markers", line: h3.line, marker: { line: h3.line, color: h3.fillcolor, size: 12, symbol: h3.type === "rect" ? "square" : h3.type === "circle" ? "circle" : "hexagon2" } };\n                      u4.push([{ trace: d3 }]);\n                    }\n                  }\n                  l3 = n4.showlegend && wle(u4, r4, n4._legends.length > 1);\n                }\n                var v3 = n4.hiddenlabels || [];\n                if (!s3 && (!n4.showlegend || !l3.length)) return o4.selectAll("." + i3).remove(), n4._topdefs.select("#" + a4).remove(), OB.autoMargin(e3, i3);\n                var _2 = Rh.ensureSingle(o4, "g", i3, function(M4) {\n                  s3 || M4.attr("pointer-events", "all");\n                }), b = Rh.ensureSingleById(n4._topdefs, "clipPath", a4, function(M4) {\n                  M4.append("rect");\n                }), p3 = Rh.ensureSingle(_2, "rect", "bg", function(M4) {\n                  M4.attr("shape-rendering", "crispEdges");\n                });\n                p3.call(NL.stroke, r4.bordercolor).call(NL.fill, r4.bgcolor).style("stroke-width", r4.borderwidth + "px");\n                var k4 = Rh.ensureSingle(_2, "g", "scrollbox"), E3 = r4.title;\n                r4._titleWidth = 0, r4._titleHeight = 0;\n                var S2;\n                E3.text ? (S2 = Rh.ensureSingle(k4, "text", i3 + "titletext"), S2.attr("text-anchor", "start").call(Dh.font, E3.font).text(E3.text), UL(S2, k4, e3, r4, U3)) : k4.selectAll("." + i3 + "titletext").remove();\n                var L3 = Rh.ensureSingle(_2, "rect", "scrollbar", function(M4) {\n                  M4.attr(ed.scrollBarEnterAttrs).call(NL.fill, ed.scrollBarColor);\n                }), x2 = k4.selectAll("g.groups").data(l3);\n                x2.enter().append("g").attr("class", "groups"), x2.exit().remove();\n                var C3 = x2.selectAll("g.traces").data(Rh.identity);\n                C3.enter().append("g").attr("class", "traces"), C3.exit().remove(), C3.style("opacity", function(M4) {\n                  var g3 = M4[0].trace;\n                  return G3.traceIs(g3, "pie-like") ? v3.indexOf(M4[0].label) !== -1 ? 0.5 : 1 : g3.visible === "legendonly" ? 0.5 : 1;\n                }).each(function() {\n                  Mp.select(this).call(Jlt, e3, r4);\n                }).call(Zlt, e3, r4).each(function() {\n                  s3 || Mp.select(this).call($lt, e3, i3);\n                }), Rh.syncOrAsync([OB.previousPromises, function() {\n                  return tut(e3, x2, C3, r4);\n                }, function() {\n                  var M4 = n4._size, g3 = r4.borderwidth, P3 = r4.xref === "paper", T3 = r4.yref === "paper";\n                  if (E3.text && Klt(S2, r4, g3), !s3) {\n                    var z3, O3;\n                    P3 ? z3 = M4.l + M4.w * r4.x - V3[VL(r4)] * r4._width : z3 = n4.width * r4.x - V3[VL(r4)] * r4._width, T3 ? O3 = M4.t + M4.h * (1 - r4.y) - V3[GL(r4)] * r4._effHeight : O3 = n4.height * (1 - r4.y) - V3[GL(r4)] * r4._effHeight;\n                    var V2 = rut(e3, i3, z3, O3);\n                    if (V2) return;\n                    if (n4.margin.autoexpand) {\n                      var G2 = z3, Z = O3;\n                      z3 = P3 ? Rh.constrain(z3, 0, n4.width - r4._width) : G2, O3 = T3 ? Rh.constrain(O3, 0, n4.height - r4._effHeight) : Z, z3 !== G2 && Rh.log("Constrain " + i3 + ".x to make legend fit inside graph"), O3 !== Z && Rh.log("Constrain " + i3 + ".y to make legend fit inside graph");\n                    }\n                    Dh.setTranslate(_2, z3, O3);\n                  }\n                  if (L3.on(".drag", null), _2.on("wheel", null), s3 || r4._height <= r4._maxHeight || e3._context.staticPlot) {\n                    var j3 = r4._effHeight;\n                    s3 && (j3 = r4._height), p3.attr({ width: r4._width - g3, height: j3 - g3, x: g3 / 2, y: g3 / 2 }), Dh.setTranslate(k4, 0, 0), b.select("rect").attr({ width: r4._width - 2 * g3, height: j3 - 2 * g3, x: g3, y: g3 }), Dh.setClipUrl(k4, a4, e3), Dh.setRect(L3, 0, 0, 0, 0), delete r4._scrollY;\n                  } else {\n                    var N2 = Math.max(ed.scrollBarMinHeight, r4._effHeight * r4._effHeight / r4._height), H = r4._effHeight - N2 - 2 * ed.scrollBarMargin, te = r4._height - r4._effHeight, oe = H / te, _e = Math.min(r4._scrollY || 0, te);\n                    p3.attr({ width: r4._width - 2 * g3 + ed.scrollBarWidth + ed.scrollBarMargin, height: r4._effHeight - g3, x: g3 / 2, y: g3 / 2 }), b.select("rect").attr({ width: r4._width - 2 * g3 + ed.scrollBarWidth + ed.scrollBarMargin, height: r4._effHeight - 2 * g3, x: g3, y: g3 + _e }), Dh.setClipUrl(k4, a4, e3), Fe(_e, N2, oe), _2.on("wheel", function() {\n                      _e = Rh.constrain(r4._scrollY + Mp.event.deltaY / te * H, 0, te), Fe(_e, N2, oe), _e !== 0 && _e !== te && Mp.event.preventDefault();\n                    });\n                    var Ee, Ce, me, ie = function(Ze, ut, pt) {\n                      var Zt = (pt - ut) / oe + Ze;\n                      return Rh.constrain(Zt, 0, te);\n                    }, Se = function(Ze, ut, pt) {\n                      var Zt = (ut - pt) / oe + Ze;\n                      return Rh.constrain(Zt, 0, te);\n                    }, Le = Mp.behavior.drag().on("dragstart", function() {\n                      var Ze = Mp.event.sourceEvent;\n                      Ze.type === "touchstart" ? Ee = Ze.changedTouches[0].clientY : Ee = Ze.clientY, me = _e;\n                    }).on("drag", function() {\n                      var Ze = Mp.event.sourceEvent;\n                      Ze.buttons === 2 || Ze.ctrlKey || (Ze.type === "touchmove" ? Ce = Ze.changedTouches[0].clientY : Ce = Ze.clientY, _e = ie(me, Ee, Ce), Fe(_e, N2, oe));\n                    });\n                    L3.call(Le);\n                    var Ae = Mp.behavior.drag().on("dragstart", function() {\n                      var Ze = Mp.event.sourceEvent;\n                      Ze.type === "touchstart" && (Ee = Ze.changedTouches[0].clientY, me = _e);\n                    }).on("drag", function() {\n                      var Ze = Mp.event.sourceEvent;\n                      Ze.type === "touchmove" && (Ce = Ze.changedTouches[0].clientY, _e = Se(me, Ee, Ce), Fe(_e, N2, oe));\n                    });\n                    k4.call(Ae);\n                  }\n                  function Fe(Ze, ut, pt) {\n                    r4._scrollY = e3._fullLayout[i3]._scrollY = Ze, Dh.setTranslate(k4, 0, -Ze), Dh.setRect(L3, r4._width, ed.scrollBarMargin + Ze * pt, ed.scrollBarWidth, ut), b.select("rect").attr("y", g3 + Ze);\n                  }\n                  if (e3._context.edits.legendPosition) {\n                    var Pe, ge, Re, ce;\n                    _2.classed("cursor-move", true), zB.init({ element: _2.node(), gd: e3, prepFn: function(Ze) {\n                      if (Ze.target !== L3.node()) {\n                        var ut = Dh.getTranslate(_2);\n                        Re = ut.x, ce = ut.y;\n                      }\n                    }, moveFn: function(Ze, ut) {\n                      if (Re !== void 0 && ce !== void 0) {\n                        var pt = Re + Ze, Zt = ce + ut;\n                        Dh.setTranslate(_2, pt, Zt), Pe = zB.align(pt, r4._width, M4.l, M4.l + M4.w, r4.xanchor), ge = zB.align(Zt + r4._height, -r4._height, M4.t + M4.h, M4.t, r4.yanchor);\n                      }\n                    }, doneFn: function() {\n                      if (Pe !== void 0 && ge !== void 0) {\n                        var Ze = {};\n                        Ze[i3 + ".x"] = Pe, Ze[i3 + ".y"] = ge, G3.call("_guiRelayout", e3, Ze);\n                      }\n                    }, clickFn: function(Ze, ut) {\n                      var pt = o4.selectAll("g.traces").filter(function() {\n                        var Zt = this.getBoundingClientRect();\n                        return ut.clientX >= Zt.left && ut.clientX <= Zt.right && ut.clientY >= Zt.top && ut.clientY <= Zt.bottom;\n                      });\n                      pt.size() > 0 && Ele(e3, _2, pt, Ze, ut);\n                    } });\n                  }\n                }], e3);\n              }\n            }\n            function BL(e3, t3, r4) {\n              var n4 = e3[0], i3 = n4.width, a4 = t3.entrywidthmode, o4 = n4.trace.legendwidth || t3.entrywidth;\n              return a4 === "fraction" ? t3._maxWidth * o4 : r4 + (o4 || i3);\n            }\n            function Ele(e3, t3, r4, n4, i3) {\n              var a4 = r4.data()[0][0].trace, o4 = { event: i3, node: r4.node(), curveNumber: a4.index, expandedIndex: a4.index, data: e3.data, layout: e3.layout, frames: e3._transitionData._frames, config: e3._context, fullData: e3._fullData, fullLayout: e3._fullLayout };\n              a4._group && (o4.group = a4._group), G3.traceIs(a4, "pie-like") && (o4.label = r4.datum()[0].label);\n              var s3 = _le.triggerHandler(e3, "plotly_legendclick", o4);\n              if (n4 === 1) {\n                if (s3 === false) return;\n                t3._clickTimeout = setTimeout(function() {\n                  e3._fullLayout && xle(r4, e3, n4);\n                }, e3._context.doubleClickDelay);\n              } else if (n4 === 2) {\n                t3._clickTimeout && clearTimeout(t3._clickTimeout), e3._legendMouseDownTime = 0;\n                var l3 = _le.triggerHandler(e3, "plotly_legenddoubleclick", o4);\n                l3 !== false && s3 !== false && xle(r4, e3, n4);\n              }\n            }\n            function Jlt(e3, t3, r4) {\n              var n4 = HL(r4), i3 = e3.data()[0][0], a4 = i3.trace, o4 = G3.traceIs(a4, "pie-like"), s3 = !r4._inHover && t3._context.edits.legendText && !o4, l3 = r4._maxNameLength, u4, c5;\n              i3.groupTitle ? (u4 = i3.groupTitle.text, c5 = i3.groupTitle.font) : (c5 = r4.font, r4.entries ? u4 = i3.text : (u4 = o4 ? i3.label : a4.name, a4._meta && (u4 = Rh.templateString(u4, a4._meta))));\n              var f4 = Rh.ensureSingle(e3, "text", n4 + "text");\n              f4.attr("text-anchor", "start").call(Dh.font, c5).text(s3 ? Sle(u4, l3) : u4);\n              var h3 = r4.indentation + r4.itemwidth + ed.itemGap * 2;\n              Db.positionText(f4, h3, 0), s3 ? f4.call(Db.makeEditable, { gd: t3, text: u4 }).call(UL, e3, t3, r4).on("edit", function(d3) {\n                this.text(Sle(d3, l3)).call(UL, e3, t3, r4);\n                var v3 = i3.trace._fullInput || {}, _2 = {};\n                return _2.name = d3, v3._isShape ? G3.call("_guiRelayout", t3, "shapes[" + a4.index + "].name", _2.name) : G3.call("_guiRestyle", t3, _2, a4.index);\n              }) : UL(f4, e3, t3, r4);\n            }\n            function Sle(e3, t3) {\n              var r4 = Math.max(4, t3);\n              if (e3 && e3.trim().length >= r4 / 2) return e3;\n              e3 = e3 || "";\n              for (var n4 = r4 - e3.length; n4 > 0; n4--) e3 += " ";\n              return e3;\n            }\n            function $lt(e3, t3, r4) {\n              var n4 = t3._context.doubleClickDelay, i3, a4 = 1, o4 = Rh.ensureSingle(e3, "rect", r4 + "toggle", function(s3) {\n                t3._context.staticPlot || s3.style("cursor", "pointer").attr("pointer-events", "all"), s3.call(NL.fill, "rgba(0,0,0,0)");\n              });\n              t3._context.staticPlot || (o4.on("mousedown", function() {\n                i3 = (/* @__PURE__ */ new Date()).getTime(), i3 - t3._legendMouseDownTime < n4 ? a4 += 1 : (a4 = 1, t3._legendMouseDownTime = i3);\n              }), o4.on("mouseup", function() {\n                if (!(t3._dragged || t3._editing)) {\n                  var s3 = t3._fullLayout[r4];\n                  (/* @__PURE__ */ new Date()).getTime() - t3._legendMouseDownTime > n4 && (a4 = Math.max(a4 - 1, 1)), Ele(t3, s3, e3, a4, Mp.event);\n                }\n              }));\n            }\n            function UL(e3, t3, r4, n4, i3) {\n              n4._inHover && e3.attr("data-notex", true), Db.convertToTspans(e3, r4, function() {\n                Qlt(t3, r4, n4, i3);\n              });\n            }\n            function Qlt(e3, t3, r4, n4) {\n              var i3 = e3.data()[0][0], a4 = i3 && i3.trace.showlegend;\n              if (Array.isArray(a4) && (a4 = a4[i3.i] !== false), !r4._inHover && i3 && !a4) {\n                e3.remove();\n                return;\n              }\n              var o4 = e3.select("g[class*=math-group]"), s3 = o4.node(), l3 = HL(r4);\n              r4 || (r4 = t3._fullLayout[l3]);\n              var u4 = r4.borderwidth, c5;\n              n4 === U3 ? c5 = r4.title.font : i3.groupTitle ? c5 = i3.groupTitle.font : c5 = r4.font;\n              var f4 = c5.size * Mle, h3, d3;\n              if (s3) {\n                var v3 = Dh.bBox(s3);\n                h3 = v3.height, d3 = v3.width, n4 === U3 ? Dh.setTranslate(o4, u4, u4 + h3 * 0.75) : Dh.setTranslate(o4, 0, h3 * 0.25);\n              } else {\n                var _2 = "." + l3 + (n4 === U3 ? "title" : "") + "text", b = e3.select(_2), p3 = Db.lineCount(b), k4 = b.node();\n                if (h3 = f4 * p3, d3 = k4 ? Dh.bBox(k4).width : 0, n4 === U3) r4.title.side === "left" && (d3 += ed.itemGap * 2), Db.positionText(b, u4 + ed.titlePad, u4 + f4);\n                else {\n                  var E3 = ed.itemGap * 2 + r4.indentation + r4.itemwidth;\n                  i3.groupTitle && (E3 = ed.itemGap, d3 -= r4.indentation + r4.itemwidth), Db.positionText(b, E3, -f4 * ((p3 - 1) / 2 - 0.3));\n                }\n              }\n              n4 === U3 ? (r4._titleWidth = d3, r4._titleHeight = h3) : (i3.lineHeight = f4, i3.height = Math.max(h3, 16) + 3, i3.width = d3);\n            }\n            function eut(e3) {\n              var t3 = 0, r4 = 0, n4 = e3.title.side;\n              return n4 && (n4.indexOf("left") !== -1 && (t3 = e3._titleWidth), n4.indexOf("top") !== -1 && (r4 = e3._titleHeight)), [t3, r4];\n            }\n            function tut(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = HL(n4);\n              n4 || (n4 = i3[a4]);\n              var o4 = i3._size, s3 = Tle.isVertical(n4), l3 = Tle.isGrouped(n4), u4 = n4.entrywidthmode === "fraction", c5 = n4.borderwidth, f4 = 2 * c5, h3 = ed.itemGap, d3 = n4.indentation + n4.itemwidth + h3 * 2, v3 = 2 * (c5 + h3), _2 = GL(n4), b = n4.y < 0 || n4.y === 0 && _2 === "top", p3 = n4.y > 1 || n4.y === 1 && _2 === "bottom", k4 = n4.tracegroupgap, E3 = {};\n              let { orientation: S2, yref: L3 } = n4, { maxheight: x2 } = n4, C3 = b || p3 || S2 !== "v" || L3 !== "paper";\n              x2 || (x2 = C3 ? 0.5 : 1);\n              let M4 = C3 ? i3.height : o4.h;\n              n4._maxHeight = Math.max(x2 > 1 ? x2 : x2 * M4, 30);\n              var g3 = 0;\n              n4._width = 0, n4._height = 0;\n              var P3 = eut(n4);\n              if (s3) r4.each(function(Fe) {\n                var Pe = Fe[0].height;\n                Dh.setTranslate(this, c5 + P3[0], c5 + P3[1] + n4._height + Pe / 2 + h3), n4._height += Pe, n4._width = Math.max(n4._width, Fe[0].width);\n              }), g3 = d3 + n4._width, n4._width += h3 + d3 + f4, n4._height += v3, l3 && (t3.each(function(Fe, Pe) {\n                Dh.setTranslate(this, 0, Pe * n4.tracegroupgap);\n              }), n4._height += (n4._lgroupsLength - 1) * n4.tracegroupgap);\n              else {\n                var T3 = VL(n4), z3 = n4.x < 0 || n4.x === 0 && T3 === "right", O3 = n4.x > 1 || n4.x === 1 && T3 === "left", V2 = p3 || b, G2 = i3.width / 2;\n                n4._maxWidth = Math.max(z3 ? V2 && T3 === "left" ? o4.l + o4.w : G2 : O3 ? V2 && T3 === "right" ? o4.r + o4.w : G2 : o4.w, 2 * d3);\n                var Z = 0, j3 = 0;\n                r4.each(function(Fe) {\n                  var Pe = BL(Fe, n4, d3);\n                  Z = Math.max(Z, Pe), j3 += Pe;\n                }), g3 = null;\n                var N2 = 0;\n                if (l3) {\n                  var H = 0, te = 0, oe = 0;\n                  t3.each(function() {\n                    var Fe = 0, Pe = 0;\n                    Mp.select(this).selectAll("g.traces").each(function(Re) {\n                      var ce = BL(Re, n4, d3), Ze = Re[0].height;\n                      Dh.setTranslate(this, P3[0], P3[1] + c5 + h3 + Ze / 2 + Pe), Pe += Ze, Fe = Math.max(Fe, ce), E3[Re[0].trace.legendgroup] = Fe;\n                    });\n                    var ge = Fe + h3;\n                    te > 0 && ge + c5 + te > n4._maxWidth ? (N2 = Math.max(N2, te), te = 0, oe += H + k4, H = Pe) : H = Math.max(H, Pe), Dh.setTranslate(this, te, oe), te += ge;\n                  }), n4._width = Math.max(N2, te) + c5, n4._height = oe + H + v3;\n                } else {\n                  var _e = r4.size(), Ee = j3 + f4 + (_e - 1) * h3 < n4._maxWidth, Ce = 0, me = 0, ie = 0, Se = 0;\n                  r4.each(function(Fe) {\n                    var Pe = Fe[0].height, ge = BL(Fe, n4, d3, l3), Re = Ee ? ge : Z;\n                    u4 || (Re += h3), Re + c5 + me - h3 >= n4._maxWidth && (N2 = Math.max(N2, Se), me = 0, ie += Ce, n4._height += Ce, Ce = 0), Dh.setTranslate(this, P3[0] + c5 + me, P3[1] + c5 + ie + Pe / 2 + h3), Se = me + ge + h3, me += Re, Ce = Math.max(Ce, Pe);\n                  }), Ee ? (n4._width = me + f4, n4._height = Ce + v3) : (n4._width = Math.max(N2, Se) + f4, n4._height += Ce + v3);\n                }\n              }\n              n4._width = Math.ceil(Math.max(n4._width + P3[0], n4._titleWidth + 2 * (c5 + ed.titlePad))), n4._height = Math.ceil(Math.max(n4._height + P3[1], n4._titleHeight + 2 * (c5 + ed.itemGap))), n4._effHeight = Math.min(n4._height, n4._maxHeight);\n              var Le = e3._context.edits, Ae = Le.legendText || Le.legendPosition;\n              r4.each(function(Fe) {\n                var Pe = Mp.select(this).select("." + a4 + "toggle"), ge = Fe[0].height, Re = Fe[0].trace.legendgroup, ce = BL(Fe, n4, d3);\n                l3 && Re !== "" && (ce = E3[Re]);\n                var Ze = Ae ? d3 : g3 || ce;\n                !s3 && !u4 && (Ze += h3 / 2), Dh.setRect(Pe, 0, -ge / 2, Ze, ge);\n              });\n            }\n            function rut(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = i3[t3], o4 = VL(a4), s3 = GL(a4), l3 = a4.xref === "paper", u4 = a4.yref === "paper";\n              e3._fullLayout._reservedMargin[t3] = {};\n              var c5 = a4.y < 0.5 ? "b" : "t", f4 = a4.x < 0.5 ? "l" : "r", h3 = { r: i3.width - r4, l: r4 + a4._width, b: i3.height - n4, t: n4 + a4._effHeight };\n              if (l3 && u4) return OB.autoMargin(e3, t3, { x: a4.x, y: a4.y, l: a4._width * V3[o4], r: a4._width * ble[o4], b: a4._effHeight * ble[s3], t: a4._effHeight * V3[s3] });\n              l3 ? e3._fullLayout._reservedMargin[t3][c5] = h3[c5] : u4 || a4.orientation === "v" ? e3._fullLayout._reservedMargin[t3][f4] = h3[f4] : e3._fullLayout._reservedMargin[t3][c5] = h3[c5];\n            }\n            function VL(e3) {\n              return Rh.isRightAnchor(e3) ? "right" : Rh.isCenterAnchor(e3) ? "center" : "left";\n            }\n            function GL(e3) {\n              return Rh.isBottomAnchor(e3) ? "bottom" : Rh.isMiddleAnchor(e3) ? "middle" : "top";\n            }\n            function HL(e3) {\n              return e3._id || "legend";\n            }\n          });\n          var GB = ye((VB) => {\n            "use strict";\n            var Fb = Oa(), My = Eo(), Cle = cd(), zf = Dr(), iut = zf.pushUnique, NB = zf.strTranslate, nut = zf.strRotate, aut = _3(), T0 = ru(), out = $se(), bm = So(), vd = ka(), jL = yv(), wm = ho(), sut = hd().zindexSeparator, j3 = qa(), Mg = ip(), zb = zS(), lut = EB(), uut = BB(), Ole = zb.YANGLE, UB = Math.PI * Ole / 180, cut = 1 / Math.sin(UB), fut = Math.cos(UB), hut = Math.sin(UB), Qc = zb.HOVERARROWSIZE, sl = zb.HOVERTEXTPAD, Lle = { box: true, ohlc: true, violin: true, candlestick: true }, dut = { scatter: true, scattergl: true, splom: true };\n            function Ple(e3, t3) {\n              return e3.distance - t3.distance;\n            }\n            VB.hover = function(t3, r4, n4, i3) {\n              t3 = zf.getGraphDiv(t3);\n              var a4 = r4.target;\n              zf.throttle(t3._fullLayout._uid + zb.HOVERID, zb.HOVERMINTIME, function() {\n                vut(t3, r4, n4, i3, a4);\n              });\n            };\n            VB.loneHover = function(t3, r4) {\n              var n4 = true;\n              Array.isArray(t3) || (n4 = false, t3 = [t3]);\n              var i3 = r4.gd, a4 = Vle(i3), o4 = Gle(i3), s3 = t3.map(function(b) {\n                var p3 = b._x0 || b.x0 || b.x || 0, k4 = b._x1 || b.x1 || b.x || 0, E3 = b._y0 || b.y0 || b.y || 0, S2 = b._y1 || b.y1 || b.y || 0, L3 = b.eventData;\n                if (L3) {\n                  var x2 = Math.min(p3, k4), C3 = Math.max(p3, k4), M4 = Math.min(E3, S2), g3 = Math.max(E3, S2), P3 = b.trace;\n                  if (j3.traceIs(P3, "gl3d")) {\n                    var T3 = i3._fullLayout[P3.scene]._scene.container, z3 = T3.offsetLeft, O3 = T3.offsetTop;\n                    x2 += z3, C3 += z3, M4 += O3, g3 += O3;\n                  }\n                  L3.bbox = { x0: x2 + o4, x1: C3 + o4, y0: M4 + a4, y1: g3 + a4 }, r4.inOut_bbox && r4.inOut_bbox.push(L3.bbox);\n                } else L3 = false;\n                return { color: b.color || vd.defaultLine, x0: b.x0 || b.x || 0, x1: b.x1 || b.x || 0, y0: b.y0 || b.y || 0, y1: b.y1 || b.y || 0, xLabel: b.xLabel, yLabel: b.yLabel, zLabel: b.zLabel, text: b.text, name: b.name, idealAlign: b.idealAlign, borderColor: b.borderColor, fontFamily: b.fontFamily, fontSize: b.fontSize, fontColor: b.fontColor, fontWeight: b.fontWeight, fontStyle: b.fontStyle, fontVariant: b.fontVariant, nameLength: b.nameLength, textAlign: b.textAlign, trace: b.trace || { index: 0, hoverinfo: "" }, xa: { _offset: 0 }, ya: { _offset: 0 }, index: 0, hovertemplate: b.hovertemplate || false, hovertemplateLabels: b.hovertemplateLabels || false, eventData: L3 };\n              }), l3 = false, u4 = Ble(s3, { gd: i3, hovermode: "closest", rotateLabels: l3, bgColor: r4.bgColor || vd.background, container: Fb.select(r4.container), outerContainer: r4.outerContainer || r4.container }), c5 = u4.hoverLabels, f4 = 5, h3 = 0, d3 = 0;\n              c5.sort(function(b, p3) {\n                return b.y0 - p3.y0;\n              }).each(function(b, p3) {\n                var k4 = b.y0 - b.by / 2;\n                k4 - f4 < h3 ? b.offset = h3 - k4 + f4 : b.offset = 0, h3 = k4 + b.by + b.offset, p3 === r4.anchorIndex && (d3 = b.offset);\n              }).each(function(b) {\n                b.offset -= d3;\n              });\n              var v3 = i3._fullLayout._invScaleX, _2 = i3._fullLayout._invScaleY;\n              return Ule(c5, l3, v3, _2), n4 ? c5 : c5.node();\n            };\n            function vut(e3, t3, r4, n4, i3) {\n              r4 || (r4 = "xy"), typeof r4 == "string" && (r4 = r4.split(sut)[0]);\n              var a4 = Array.isArray(r4) ? r4 : [r4], o4, s3 = e3._fullLayout, l3 = s3.hoversubplots, u4 = s3._plots || [], c5 = u4[r4], f4 = s3._has("cartesian"), h3 = t3.hovermode || s3.hovermode, d3 = (h3 || "").charAt(0) === "x", v3 = (h3 || "").charAt(0) === "y", _2, b;\n              if (f4 && (d3 || v3) && l3 === "axis") {\n                for (var p3 = a4.length, k4 = 0; k4 < p3; k4++) if (o4 = a4[k4], u4[o4]) {\n                  _2 = wm.getFromId(e3, o4, "x"), b = wm.getFromId(e3, o4, "y");\n                  var E3 = (d3 ? _2 : b)._subplotsWith;\n                  if (E3 && E3.length) for (var S2 = 0; S2 < E3.length; S2++) iut(a4, E3[S2]);\n                }\n              }\n              if (c5 && l3 !== "single") {\n                var L3 = c5.overlays.map(function(wi) {\n                  return wi.id;\n                });\n                a4 = a4.concat(L3);\n              }\n              for (var x2 = a4.length, C3 = new Array(x2), M4 = new Array(x2), g3 = false, P3 = 0; P3 < x2; P3++) if (o4 = a4[P3], u4[o4]) g3 = true, C3[P3] = u4[o4].xaxis, M4[P3] = u4[o4].yaxis;\n              else if (s3[o4] && s3[o4]._subplot) {\n                var T3 = s3[o4]._subplot;\n                C3[P3] = T3.xaxis, M4[P3] = T3.yaxis;\n              } else {\n                zf.warn("Unrecognized subplot: " + o4);\n                return;\n              }\n              if (h3 && !g3 && (h3 = "closest"), ["x", "y", "closest", "x unified", "y unified"].indexOf(h3) === -1 || !e3.calcdata || e3.querySelector(".zoombox") || e3._dragging) return jL.unhoverRaw(e3, t3);\n              var z3 = s3.hoverdistance;\n              z3 === -1 && (z3 = 1 / 0);\n              var O3 = s3.spikedistance;\n              O3 === -1 && (O3 = 1 / 0);\n              var V2 = [], G2 = [], Z, j4, N2, H, te, oe, _e, Ee, Ce, me, ie, Se, Le, Ae = { hLinePoint: null, vLinePoint: null }, Fe = false;\n              if (Array.isArray(t3)) for (h3 = "array", N2 = 0; N2 < t3.length; N2++) te = e3.calcdata[t3[N2].curveNumber || 0], te && (oe = te[0].trace, te[0].trace.hoverinfo !== "skip" && (G2.push(te), oe.orientation === "h" && (Fe = true)));\n              else {\n                var Pe = e3.calcdata.slice();\n                for (Pe.sort(function(wi, On) {\n                  var qn = wi[0].trace.zorder || 0, Fn = On[0].trace.zorder || 0;\n                  return qn - Fn;\n                }), H = 0; H < Pe.length; H++) te = Pe[H], oe = te[0].trace, oe.hoverinfo !== "skip" && Mg.isTraceInSubplots(oe, a4) && (G2.push(te), oe.orientation === "h" && (Fe = true));\n                var ge = !i3, Re, ce;\n                if (ge) "xpx" in t3 ? Re = t3.xpx : Re = C3[0]._length / 2, "ypx" in t3 ? ce = t3.ypx : ce = M4[0]._length / 2;\n                else {\n                  if (aut.triggerHandler(e3, "plotly_beforehover", t3) === false) return;\n                  var Ze = i3.getBoundingClientRect();\n                  Re = t3.clientX - Ze.left, ce = t3.clientY - Ze.top, s3._calcInverseTransform(e3);\n                  var ut = zf.apply3DTransform(s3._invTransform)(Re, ce);\n                  if (Re = ut[0], ce = ut[1], Re < 0 || Re > C3[0]._length || ce < 0 || ce > M4[0]._length) return jL.unhoverRaw(e3, t3);\n                }\n                if (t3.pointerX = Re + C3[0]._offset, t3.pointerY = ce + M4[0]._offset, "xval" in t3 ? Z = Mg.flat(a4, t3.xval) : Z = Mg.p2c(C3, Re), "yval" in t3 ? j4 = Mg.flat(a4, t3.yval) : j4 = Mg.p2c(M4, ce), !My(Z[0]) || !My(j4[0])) return zf.warn("Fx.hover failed", t3, e3), jL.unhoverRaw(e3, t3);\n              }\n              var pt = 1 / 0;\n              function Zt(wi, On) {\n                for (H = 0; H < G2.length; H++) if (te = G2[H], !(!te || !te[0] || !te[0].trace) && (oe = te[0].trace, !(oe.visible !== true || oe._length === 0) && ["carpet", "contourcarpet"].indexOf(oe._module.name) === -1)) {\n                  if (Ce = h3, Mg.isUnifiedHover(Ce) && (Ce = Ce.charAt(0)), oe.type === "splom" ? (Ee = 0, _e = a4[Ee]) : (_e = Mg.getSubplot(oe), Ee = a4.indexOf(_e)), Se = { cd: te, trace: oe, xa: C3[Ee], ya: M4[Ee], maxHoverDistance: z3, maxSpikeDistance: O3, index: false, distance: Math.min(pt, z3), spikeDistance: 1 / 0, xSpike: void 0, ySpike: void 0, color: vd.defaultLine, name: oe.name, x0: void 0, x1: void 0, y0: void 0, y1: void 0, xLabelVal: void 0, yLabelVal: void 0, zLabelVal: void 0, text: void 0 }, s3[_e] && (Se.subplot = s3[_e]._subplot), s3._splomScenes && s3._splomScenes[oe.uid] && (Se.scene = s3._splomScenes[oe.uid]), Ce === "array") {\n                    var qn = t3[H];\n                    "pointNumber" in qn ? (Se.index = qn.pointNumber, Ce = "closest") : (Ce = "", "xval" in qn && (me = qn.xval, Ce = "x"), "yval" in qn && (ie = qn.yval, Ce = Ce ? "closest" : "y"));\n                  } else wi !== void 0 && On !== void 0 ? (me = wi, ie = On) : (me = Z[Ee], ie = j4[Ee]);\n                  if (Le = V2.length, z3 !== 0) if (oe._module && oe._module.hoverPoints) {\n                    var Fn = oe._module.hoverPoints(Se, me, ie, Ce, { finiteRange: true, hoverLayer: s3._hoverlayer, hoversubplots: l3, gd: e3 });\n                    if (Fn) for (var ra, la = 0; la < Fn.length; la++) ra = Fn[la], My(ra.x0) && My(ra.y0) && V2.push(yut(ra, h3));\n                  } else zf.log("Unrecognized trace type in hover:", oe);\n                  if (h3 === "closest" && V2.length > Le && (V2.splice(0, Le), pt = V2[0].distance), f4 && O3 !== 0 && V2.length === 0) {\n                    Se.distance = O3, Se.index = false;\n                    var Ut = oe._module.hoverPoints(Se, me, ie, "closest", { hoverLayer: s3._hoverlayer });\n                    if (Ut && (Ut = Ut.filter(function(ri) {\n                      return ri.spikeDistance <= O3;\n                    })), Ut && Ut.length) {\n                      var wt, rr = Ut.filter(function(ri) {\n                        return ri.xa.showspikes && ri.xa.spikesnap !== "hovered data";\n                      });\n                      if (rr.length) {\n                        var nr = rr[0];\n                        My(nr.x0) && My(nr.y0) && (wt = lt(nr), (!Ae.vLinePoint || Ae.vLinePoint.spikeDistance > wt.spikeDistance) && (Ae.vLinePoint = wt));\n                      }\n                      var Er = Ut.filter(function(ri) {\n                        return ri.ya.showspikes && ri.ya.spikesnap !== "hovered data";\n                      });\n                      if (Er.length) {\n                        var Xr = Er[0];\n                        My(Xr.x0) && My(Xr.y0) && (wt = lt(Xr), (!Ae.hLinePoint || Ae.hLinePoint.spikeDistance > wt.spikeDistance) && (Ae.hLinePoint = wt));\n                      }\n                    }\n                  }\n                }\n              }\n              Zt();\n              function st(wi, On, qn) {\n                for (var Fn = null, ra = 1 / 0, la, Ut = 0; Ut < wi.length; Ut++) _2 && _2._id !== wi[Ut].xa._id || b && b._id !== wi[Ut].ya._id || (la = wi[Ut].spikeDistance, qn && Ut === 0 && (la = -1 / 0), la <= ra && la <= On && (Fn = wi[Ut], ra = la));\n                return Fn;\n              }\n              function lt(wi) {\n                return wi ? { xa: wi.xa, ya: wi.ya, x: wi.xSpike !== void 0 ? wi.xSpike : (wi.x0 + wi.x1) / 2, y: wi.ySpike !== void 0 ? wi.ySpike : (wi.y0 + wi.y1) / 2, distance: wi.distance, spikeDistance: wi.spikeDistance, curveNumber: wi.trace.index, color: wi.color, pointNumber: wi.index } : null;\n              }\n              var Gt = { fullLayout: s3, container: s3._hoverlayer, event: t3 }, Nt = e3._spikepoints, Jt = { vLinePoint: Ae.vLinePoint, hLinePoint: Ae.hLinePoint };\n              e3._spikepoints = Jt;\n              var sr = function() {\n                var wi = V2.filter(function(qn) {\n                  return _2 && _2._id === qn.xa._id && b && b._id === qn.ya._id;\n                }), On = V2.filter(function(qn) {\n                  return !(_2 && _2._id === qn.xa._id && b && b._id === qn.ya._id);\n                });\n                wi.sort(Ple), On.sort(Ple), V2 = wi.concat(On), V2 = xut(V2, h3);\n              };\n              sr();\n              var wr = h3.charAt(0), cr = (wr === "x" || wr === "y") && V2[0] && dut[V2[0].trace.type];\n              if (f4 && O3 !== 0 && V2.length !== 0) {\n                var $e = V2.filter(function(wi) {\n                  return wi.ya.showspikes;\n                }), St = st($e, O3, cr);\n                Ae.hLinePoint = lt(St);\n                var Qt = V2.filter(function(wi) {\n                  return wi.xa.showspikes;\n                }), Vt = st(Qt, O3, cr);\n                Ae.vLinePoint = lt(Vt);\n              }\n              if (V2.length === 0) {\n                var _t = jL.unhoverRaw(e3, t3);\n                return f4 && (Ae.hLinePoint !== null || Ae.vLinePoint !== null) && Dle(Nt) && Rle(e3, Ae, Gt), _t;\n              }\n              if (f4 && Dle(Nt) && Rle(e3, Ae, Gt), Mg.isXYhover(Ce) && V2[0].length !== 0 && V2[0].trace.type !== "splom") {\n                var It = V2[0];\n                Lle[It.trace.type] ? V2 = V2.filter((wi) => wi.trace.index === It.trace.index) : V2 = [It];\n                var mt = V2.length, er = zle("x", It, s3), lr = zle("y", It, s3);\n                Zt(er, lr);\n                var Tr = [], Lr = {}, ti = 0, Br = function(wi) {\n                  var On = Lle[wi.trace.type] ? qle(wi) : wi.trace.index;\n                  if (!Lr[On]) ti++, Lr[On] = ti, Tr.push(wi);\n                  else {\n                    var qn = Lr[On] - 1, Fn = Tr[qn];\n                    qn > 0 && Math.abs(wi.distance) < Math.abs(Fn.distance) && (Tr[qn] = wi);\n                  }\n                }, Vr;\n                for (Vr = 0; Vr < mt; Vr++) Br(V2[Vr]);\n                for (Vr = V2.length - 1; Vr > mt - 1; Vr--) Br(V2[Vr]);\n                V2 = Tr, sr();\n              }\n              var dt = e3._hoverdata, Ge = [], Je = Vle(e3), je = Gle(e3);\n              for (let wi of V2) {\n                var tt = Mg.makeEventData(wi, wi.trace, wi.cd);\n                if (wi.hovertemplate !== false) {\n                  var xt = false;\n                  wi.cd[wi.index] && wi.cd[wi.index].ht && (xt = wi.cd[wi.index].ht), wi.hovertemplate = xt || wi.trace.hovertemplate || false;\n                }\n                if (wi.xa && wi.ya) {\n                  var Ie = wi.x0 + wi.xa._offset, xe = wi.x1 + wi.xa._offset, ke = wi.y0 + wi.ya._offset, vt = wi.y1 + wi.ya._offset, ir = Math.min(Ie, xe), ar = Math.max(Ie, xe), vr = Math.min(ke, vt), ii = Math.max(ke, vt);\n                  tt.bbox = { x0: ir + je, x1: ar + je, y0: vr + Je, y1: ii + Je };\n                }\n                wi.eventData = [tt], Ge.push(tt);\n              }\n              e3._hoverdata = Ge;\n              var pi = h3 === "y" && (G2.length > 1 || V2.length > 1) || h3 === "closest" && Fe && V2.length > 1, $r = vd.combine(s3.plot_bgcolor || vd.background, s3.paper_bgcolor), di = Ble(V2, { gd: e3, hovermode: h3, rotateLabels: pi, bgColor: $r, container: s3._hoverlayer, outerContainer: s3._paper.node(), commonLabelOpts: s3.hoverlabel, hoverdistance: s3.hoverdistance }), ji = di.hoverLabels;\n              if (Mg.isUnifiedHover(h3) || (gut(ji, pi, s3, di.commonLabelBoundingBox), Ule(ji, pi, s3._invScaleX, s3._invScaleY)), i3 && i3.tagName) {\n                var In = j3.getComponentMethod("annotations", "hasClickToShow")(e3, Ge);\n                out(Fb.select(i3), In ? "pointer" : "");\n              }\n              !i3 || n4 || !_ut(e3, t3, dt) || (dt && e3.emit("plotly_unhover", { event: t3, points: dt }), e3.emit("plotly_hover", { event: t3, points: e3._hoverdata, xaxes: C3, yaxes: M4, xvals: Z, yvals: j4 }));\n            }\n            function qle(e3) {\n              return [e3.trace.index, e3.index, e3.x0, e3.y0, e3.name, e3.attr, e3.xa ? e3.xa._id : "", e3.ya ? e3.ya._id : ""].join(",");\n            }\n            var put = /<extra>([\\s\\S]*)<\\/extra>/;\n            function Ble(e3, t3) {\n              var r4 = t3.gd, n4 = r4._fullLayout, i3 = t3.hovermode, a4 = t3.rotateLabels, o4 = t3.bgColor, s3 = t3.container, l3 = t3.outerContainer, u4 = t3.commonLabelOpts || {};\n              if (e3.length === 0) return [[]];\n              var c5 = t3.fontFamily || zb.HOVERFONT, f4 = t3.fontSize || zb.HOVERFONTSIZE, h3 = t3.fontWeight || n4.font.weight, d3 = t3.fontStyle || n4.font.style, v3 = t3.fontVariant || n4.font.variant, _2 = t3.fontTextcase || n4.font.textcase, b = t3.fontLineposition || n4.font.lineposition, p3 = t3.fontShadow || n4.font.shadow, k4 = e3[0], E3 = k4.xa, S2 = k4.ya, L3 = i3.charAt(0), x2 = L3 + "Label", C3 = k4[x2];\n              if (C3 === void 0 && E3.type === "multicategory") for (var M4 = 0; M4 < e3.length && (C3 = e3[M4][x2], C3 === void 0); M4++) ;\n              var g3 = H3(r4, l3), P3 = g3.top, T3 = g3.width, z3 = g3.height, O3 = C3 !== void 0 && k4.distance <= t3.hoverdistance && (i3 === "x" || i3 === "y");\n              if (O3) {\n                var V2 = true, G2, Z;\n                for (G2 = 0; G2 < e3.length; G2++) if (V2 && e3[G2].zLabel === void 0 && (V2 = false), Z = e3[G2].hoverinfo || e3[G2].trace.hoverinfo, Z) {\n                  var j4 = Array.isArray(Z) ? Z : Z.split("+");\n                  if (j4.indexOf("all") === -1 && j4.indexOf(i3) === -1) {\n                    O3 = false;\n                    break;\n                  }\n                }\n                V2 && (O3 = false);\n              }\n              var N2 = s3.selectAll("g.axistext").data(O3 ? [0] : []);\n              N2.enter().append("g").classed("axistext", true), N2.exit().remove();\n              var H = { minX: 0, maxX: 0, minY: 0, maxY: 0 };\n              if (N2.each(function() {\n                var _t = Fb.select(this), It = zf.ensureSingle(_t, "path", "", function(ii) {\n                  ii.style({ "stroke-width": "1px" });\n                }), mt = zf.ensureSingle(_t, "text", "", function(ii) {\n                  ii.attr("data-notex", 1);\n                }), er = u4.bgcolor || vd.defaultLine, lr = u4.bordercolor || vd.contrast(er), Tr = vd.contrast(er), Lr = u4.font, ti = { weight: Lr.weight || h3, style: Lr.style || d3, variant: Lr.variant || v3, textcase: Lr.textcase || _2, lineposition: Lr.lineposition || b, shadow: Lr.shadow || p3, family: Lr.family || c5, size: Lr.size || f4, color: Lr.color || Tr };\n                It.style({ fill: er, stroke: lr }), mt.text(C3).call(bm.font, ti).call(T0.positionText, 0, 0).call(T0.convertToTspans, r4), _t.attr("transform", "");\n                var Br = H3(r4, mt.node()), Vr, dt;\n                if (i3 === "x") {\n                  var Ge = E3.side === "top" ? "-" : "";\n                  mt.attr("text-anchor", "middle").call(T0.positionText, 0, E3.side === "top" ? P3 - Br.bottom - Qc - sl : P3 - Br.top + Qc + sl), Vr = E3._offset + (k4.x0 + k4.x1) / 2, dt = S2._offset + (E3.side === "top" ? 0 : S2._length);\n                  var Je = Br.width / 2 + sl, je = Vr;\n                  Vr < Je ? je = Je : Vr > n4.width - Je && (je = n4.width - Je), It.attr("d", "M" + (Vr - je) + ",0L" + (Vr - je + Qc) + "," + Ge + Qc + "H" + Je + "v" + Ge + (sl * 2 + Br.height) + "H" + -Je + "V" + Ge + Qc + "H" + (Vr - je - Qc) + "Z"), Vr = je, H.minX = Vr - Je, H.maxX = Vr + Je, E3.side === "top" ? (H.minY = dt - (sl * 2 + Br.height), H.maxY = dt - sl) : (H.minY = dt + sl, H.maxY = dt + (sl * 2 + Br.height));\n                } else {\n                  var tt, xt, Ie;\n                  S2.side === "right" ? (tt = "start", xt = 1, Ie = "", Vr = E3._offset + E3._length) : (tt = "end", xt = -1, Ie = "-", Vr = E3._offset), dt = S2._offset + (k4.y0 + k4.y1) / 2, mt.attr("text-anchor", tt), It.attr("d", "M0,0L" + Ie + Qc + "," + Qc + "V" + (sl + Br.height / 2) + "h" + Ie + (sl * 2 + Br.width) + "V-" + (sl + Br.height / 2) + "H" + Ie + Qc + "V-" + Qc + "Z"), H.minY = dt - (sl + Br.height / 2), H.maxY = dt + (sl + Br.height / 2), S2.side === "right" ? (H.minX = Vr + Qc, H.maxX = Vr + Qc + (sl * 2 + Br.width)) : (H.minX = Vr - Qc - (sl * 2 + Br.width), H.maxX = Vr - Qc);\n                  var xe = Br.height / 2, ke = P3 - Br.top - xe, vt = "clip" + n4._uid + "commonlabel" + S2._id, ir;\n                  if (Vr < Br.width + 2 * sl + Qc) {\n                    ir = "M-" + (Qc + sl) + "-" + xe + "h-" + (Br.width - sl) + "V" + xe + "h" + (Br.width - sl) + "Z";\n                    var ar = Br.width - Vr + sl;\n                    T0.positionText(mt, ar, ke), tt === "end" && mt.selectAll("tspan").each(function() {\n                      var ii = Fb.select(this), pi = bm.tester.append("text").text(ii.text()).call(bm.font, ti), $r = H3(r4, pi.node());\n                      Math.round($r.width) < Math.round(Br.width) && ii.attr("x", ar - $r.width), pi.remove();\n                    });\n                  } else T0.positionText(mt, xt * (sl + Qc), ke), ir = null;\n                  var vr = n4._topclips.selectAll("#" + vt).data(ir ? [0] : []);\n                  vr.enter().append("clipPath").attr("id", vt).append("path"), vr.exit().remove(), vr.select("path").attr("d", ir), bm.setClipUrl(mt, ir ? vt : null, r4);\n                }\n                _t.attr("transform", NB(Vr, dt));\n              }), Mg.isUnifiedHover(i3)) {\n                s3.selectAll("g.hovertext").remove();\n                let _t = e3.filter((It) => It.hoverinfo !== "none");\n                if (_t.length === 0) return [];\n                var te = n4.hoverlabel, oe = te.font, _e = _t[0], Ee = ((i3 === "x unified" ? _e.xa : _e.ya).unifiedhovertitle || {}).text, Ce = Ee ? zf.hovertemplateString({ data: i3 === "x unified" ? [{ xa: _e.xa, x: _e.xVal }] : [{ ya: _e.ya, y: _e.yVal }], fallback: _e.trace.hovertemplatefallback, locale: n4._d3locale, template: Ee }) : C3, me = { showlegend: true, legend: { title: { text: Ce, font: oe }, font: oe, bgcolor: te.bgcolor, bordercolor: te.bordercolor, borderwidth: 1, tracegroupgap: 7, traceorder: n4.legend ? n4.legend.traceorder : void 0, orientation: "v" } }, ie = { font: oe };\n                lut(me, ie, r4._fullData);\n                var Se = ie.legend;\n                Se.entries = [];\n                for (var Le = 0; Le < _t.length; Le++) {\n                  var Ae = _t[Le];\n                  if (Ae.hoverinfo !== "none") {\n                    var Fe = Ile(Ae, true, i3, n4, C3), Pe = Fe[0], ge = Fe[1];\n                    Ae.name = ge, ge !== "" ? Ae.text = ge + " : " + Pe : Ae.text = Pe;\n                    var Re = Ae.cd[Ae.index];\n                    Re && (Re.mc && (Ae.mc = Re.mc), Re.mcc && (Ae.mc = Re.mcc), Re.mlc && (Ae.mlc = Re.mlc), Re.mlcc && (Ae.mlc = Re.mlcc), Re.mlw && (Ae.mlw = Re.mlw), Re.mrc && (Ae.mrc = Re.mrc), Re.dir && (Ae.dir = Re.dir)), Ae._distinct = true, Se.entries.push([Ae]);\n                  }\n                }\n                Se.entries.sort(function(It, mt) {\n                  return It[0].trace.index - mt[0].trace.index;\n                }), Se.layer = s3, Se._inHover = true, Se._groupTitleFont = te.grouptitlefont, uut(r4, Se);\n                var ce = s3.select("g.legend"), Ze = H3(r4, ce.node()), ut = Ze.width + 2 * sl, pt = Ze.height + 2 * sl, Zt = _t[0], st = (Zt.x0 + Zt.x1) / 2, lt = (Zt.y0 + Zt.y1) / 2, Gt = !(j3.traceIs(Zt.trace, "bar-like") || j3.traceIs(Zt.trace, "box-violin")), Nt, Jt;\n                L3 === "y" ? Gt ? (Jt = lt - sl, Nt = lt + sl) : (Jt = Math.min.apply(null, _t.map(function(It) {\n                  return Math.min(It.y0, It.y1);\n                })), Nt = Math.max.apply(null, _t.map(function(It) {\n                  return Math.max(It.y0, It.y1);\n                }))) : Jt = Nt = zf.mean(_t.map(function(It) {\n                  return (It.y0 + It.y1) / 2;\n                })) - pt / 2;\n                var sr, wr;\n                L3 === "x" ? Gt ? (sr = st + sl, wr = st - sl) : (sr = Math.max.apply(null, _t.map(function(It) {\n                  return Math.max(It.x0, It.x1);\n                })), wr = Math.min.apply(null, _t.map(function(It) {\n                  return Math.min(It.x0, It.x1);\n                }))) : sr = wr = zf.mean(_t.map(function(It) {\n                  return (It.x0 + It.x1) / 2;\n                })) - ut / 2;\n                var cr = E3._offset, $e = S2._offset;\n                Nt += $e, sr += cr, wr += cr - ut, Jt += $e - pt;\n                var St, Qt;\n                return sr + ut < T3 && sr >= 0 ? St = sr : wr + ut < T3 && wr >= 0 ? St = wr : cr + ut < T3 ? St = cr : sr - st < st - wr + ut ? St = T3 - ut : St = 0, St += sl, Nt + pt < z3 && Nt >= 0 ? Qt = Nt : Jt + pt < z3 && Jt >= 0 ? Qt = Jt : $e + pt < z3 ? Qt = $e : Nt - lt < lt - Jt + pt ? Qt = z3 - pt : Qt = 0, Qt += sl, ce.attr("transform", NB(St - 1, Qt - 1)), ce;\n              }\n              var Vt = s3.selectAll("g.hovertext").data(e3, function(_t) {\n                return qle(_t);\n              });\n              return Vt.enter().append("g").classed("hovertext", true).each(function() {\n                var _t = Fb.select(this);\n                _t.append("rect").call(vd.fill, vd.addOpacity(o4, 0.8)), _t.append("text").classed("name", true), _t.append("path").style("stroke-width", "1px"), _t.append("text").classed("nums", true).call(bm.font, { weight: h3, style: d3, variant: v3, textcase: _2, lineposition: b, shadow: p3, family: c5, size: f4 });\n              }), Vt.exit().remove(), Vt.each(function(_t) {\n                var It = Fb.select(this).attr("transform", ""), mt = _t.color;\n                Array.isArray(mt) && (mt = mt[_t.eventData[0].pointNumber]);\n                var er = _t.bgcolor || mt, lr = vd.combine(vd.opacity(er) ? er : vd.defaultLine, o4), Tr = vd.combine(vd.opacity(mt) ? mt : vd.defaultLine, o4), Lr = _t.borderColor || vd.contrast(lr), ti = Ile(_t, O3, i3, n4, C3, It), Br = ti[0], Vr = ti[1], dt = It.select("text.nums").call(bm.font, { family: _t.fontFamily || c5, size: _t.fontSize || f4, color: _t.fontColor || Lr, weight: _t.fontWeight || h3, style: _t.fontStyle || d3, variant: _t.fontVariant || v3, textcase: _t.fontTextcase || _2, lineposition: _t.fontLineposition || b, shadow: _t.fontShadow || p3 }).text(Br).attr("data-notex", 1).call(T0.positionText, 0, 0).call(T0.convertToTspans, r4), Ge = It.select("text.name"), Je = 0, je = 0;\n                if (Vr && Vr !== Br) {\n                  Ge.call(bm.font, { family: _t.fontFamily || c5, size: _t.fontSize || f4, color: Tr, weight: _t.fontWeight || h3, style: _t.fontStyle || d3, variant: _t.fontVariant || v3, textcase: _t.fontTextcase || _2, lineposition: _t.fontLineposition || b, shadow: _t.fontShadow || p3 }).text(Vr).attr("data-notex", 1).call(T0.positionText, 0, 0).call(T0.convertToTspans, r4);\n                  var tt = H3(r4, Ge.node());\n                  Je = tt.width + 2 * sl, je = tt.height + 2 * sl;\n                } else Ge.remove(), It.select("rect").remove();\n                It.select("path").style({ fill: lr, stroke: Lr });\n                var xt = _t.xa._offset + (_t.x0 + _t.x1) / 2, Ie = _t.ya._offset + (_t.y0 + _t.y1) / 2, xe = Math.abs(_t.x1 - _t.x0), ke = Math.abs(_t.y1 - _t.y0), vt = H3(r4, dt.node()), ir = vt.width / n4._invScaleX, ar = vt.height / n4._invScaleY;\n                _t.ty0 = (P3 - vt.top) / n4._invScaleY, _t.bx = ir + 2 * sl, _t.by = Math.max(ar + 2 * sl, je), _t.anchor = "start", _t.txwidth = ir, _t.tx2width = Je, _t.offset = 0;\n                var vr = (ir + Qc + sl + Je) * n4._invScaleX, ii, pi;\n                if (a4) _t.pos = xt, ii = Ie + ke / 2 + vr <= z3, pi = Ie - ke / 2 - vr >= 0, (_t.idealAlign === "top" || !ii) && pi ? (Ie -= ke / 2, _t.anchor = "end") : ii ? (Ie += ke / 2, _t.anchor = "start") : _t.anchor = "middle", _t.crossPos = Ie;\n                else {\n                  if (_t.pos = Ie, ii = xt + xe / 2 + vr <= T3, pi = xt - xe / 2 - vr >= 0, (_t.idealAlign === "left" || !ii) && pi) xt -= xe / 2, _t.anchor = "end";\n                  else if (ii) xt += xe / 2, _t.anchor = "start";\n                  else {\n                    _t.anchor = "middle";\n                    var $r = vr / 2, di = xt + $r - T3, ji = xt - $r;\n                    di > 0 && (xt -= di), ji < 0 && (xt += -ji);\n                  }\n                  _t.crossPos = xt;\n                }\n                dt.attr("text-anchor", _t.anchor), Je && Ge.attr("text-anchor", _t.anchor), It.attr("transform", NB(xt, Ie) + (a4 ? nut(Ole) : ""));\n              }), { hoverLabels: Vt, commonLabelBoundingBox: H };\n            }\n            function Ile(e3, t3, r4, n4, i3, a4) {\n              var f4, h3;\n              var o4 = "", s3 = "";\n              e3.nameOverride !== void 0 && (e3.name = e3.nameOverride), e3.name && (e3.trace._meta && (e3.name = zf.templateString(e3.name, e3.trace._meta)), o4 = Fle(e3.name, e3.nameLength));\n              var l3 = r4.charAt(0), u4 = l3 === "x" ? "y" : "x";\n              e3.zLabel !== void 0 ? (e3.xLabel !== void 0 && (s3 += "x: " + e3.xLabel + "<br>"), e3.yLabel !== void 0 && (s3 += "y: " + e3.yLabel + "<br>"), e3.trace.type !== "choropleth" && e3.trace.type !== "choroplethmapbox" && e3.trace.type !== "choroplethmap" && (s3 += (s3 ? "z: " : "") + e3.zLabel)) : t3 && e3[l3 + "Label"] === i3 ? s3 = e3[u4 + "Label"] || "" : e3.xLabel === void 0 ? e3.yLabel !== void 0 && e3.trace.type !== "scattercarpet" && (s3 = e3.yLabel) : e3.yLabel === void 0 ? s3 = e3.xLabel : s3 = "(" + e3.xLabel + ", " + e3.yLabel + ")", (e3.text || e3.text === 0) && !Array.isArray(e3.text) && (s3 += (s3 ? "<br>" : "") + e3.text), e3.extraText !== void 0 && (s3 += (s3 ? "<br>" : "") + e3.extraText), a4 && s3 === "" && !e3.hovertemplate && (o4 === "" && a4.remove(), s3 = o4), (h3 = (f4 = e3.trace) == null ? void 0 : f4.hoverlabel) != null && h3.split && (e3.hovertemplate = "");\n              let { hovertemplate: c5 = false } = e3;\n              if (c5) {\n                let d3 = e3.hovertemplateLabels || e3;\n                e3[l3 + "Label"] !== i3 && (d3[l3 + "other"] = d3[l3 + "Val"], d3[l3 + "otherLabel"] = d3[l3 + "Label"]), s3 = zf.hovertemplateString({ data: [e3.eventData[0] || {}, e3.trace._meta], fallback: e3.trace.hovertemplatefallback, labels: d3, locale: n4._d3locale, template: c5 }), s3 = s3.replace(put, (v3, _2) => (o4 = Fle(_2, e3.nameLength), ""));\n              }\n              return [s3, o4];\n            }\n            function gut(e3, t3, r4, n4) {\n              var i3 = t3 ? "xa" : "ya", a4 = t3 ? "ya" : "xa", o4 = 0, s3 = 1, l3 = e3.size(), u4 = new Array(l3), c5 = 0, f4 = n4.minX, h3 = n4.maxX, d3 = n4.minY, v3 = n4.maxY, _2 = function(Z) {\n                return Z * r4._invScaleX;\n              }, b = function(Z) {\n                return Z * r4._invScaleY;\n              };\n              e3.each(function(Z) {\n                var j4 = Z[i3], N2 = Z[a4], H = j4._id.charAt(0) === "x", te = j4.range;\n                c5 === 0 && te && te[0] > te[1] !== H && (s3 = -1);\n                var oe = 0, _e = H ? r4.width : r4.height;\n                if (r4.hovermode === "x" || r4.hovermode === "y") {\n                  var Ee = Nle(Z, t3), Ce = Z.anchor, me = Ce === "end" ? -1 : 1, ie, Se;\n                  if (Ce === "middle") ie = Z.crossPos + (H ? b(Ee.y - Z.by / 2) : _2(Z.bx / 2 + Z.tx2width / 2)), Se = ie + (H ? b(Z.by) : _2(Z.bx));\n                  else if (H) ie = Z.crossPos + b(Qc + Ee.y) - b(Z.by / 2 - Qc), Se = ie + b(Z.by);\n                  else {\n                    var Le = _2(me * Qc + Ee.x), Ae = Le + _2(me * Z.bx);\n                    ie = Z.crossPos + Math.min(Le, Ae), Se = Z.crossPos + Math.max(Le, Ae);\n                  }\n                  H ? d3 !== void 0 && v3 !== void 0 && Math.min(Se, v3) - Math.max(ie, d3) > 1 && (N2.side === "left" ? (oe = N2._mainLinePosition, _e = r4.width) : _e = N2._mainLinePosition) : f4 !== void 0 && h3 !== void 0 && Math.min(Se, h3) - Math.max(ie, f4) > 1 && (N2.side === "top" ? (oe = N2._mainLinePosition, _e = r4.height) : _e = N2._mainLinePosition);\n                }\n                u4[c5++] = [{ datum: Z, traceIndex: Z.trace.index, dp: 0, pos: Z.pos, posref: Z.posref, size: Z.by * (H ? cut : 1) / 2, pmin: oe, pmax: _e }];\n              }), u4.sort(function(Z, j4) {\n                return Z[0].posref - j4[0].posref || s3 * (j4[0].traceIndex - Z[0].traceIndex);\n              });\n              var p3, k4, E3, S2, L3, x2, C3;\n              function M4(Z) {\n                var j4 = Z[0], N2 = Z[Z.length - 1];\n                if (k4 = j4.pmin - j4.pos - j4.dp + j4.size, E3 = N2.pos + N2.dp + N2.size - j4.pmax, k4 > 0.01) {\n                  for (L3 = Z.length - 1; L3 >= 0; L3--) Z[L3].dp += k4;\n                  p3 = false;\n                }\n                if (!(E3 < 0.01)) {\n                  if (k4 < -0.01) {\n                    for (L3 = Z.length - 1; L3 >= 0; L3--) Z[L3].dp -= E3;\n                    p3 = false;\n                  }\n                  if (p3) {\n                    var H = 0;\n                    for (S2 = 0; S2 < Z.length; S2++) x2 = Z[S2], x2.pos + x2.dp + x2.size > j4.pmax && H++;\n                    for (S2 = Z.length - 1; S2 >= 0 && !(H <= 0); S2--) x2 = Z[S2], x2.pos > j4.pmax - 1 && (x2.del = true, H--);\n                    for (S2 = 0; S2 < Z.length && !(H <= 0); S2++) if (x2 = Z[S2], x2.pos < j4.pmin + 1) for (x2.del = true, H--, E3 = x2.size * 2, L3 = Z.length - 1; L3 >= 0; L3--) Z[L3].dp -= E3;\n                    for (S2 = Z.length - 1; S2 >= 0 && !(H <= 0); S2--) x2 = Z[S2], x2.pos + x2.dp + x2.size > j4.pmax && (x2.del = true, H--);\n                  }\n                }\n              }\n              for (; !p3 && o4 <= l3; ) {\n                for (o4++, p3 = true, S2 = 0; S2 < u4.length - 1; ) {\n                  var g3 = u4[S2], P3 = u4[S2 + 1], T3 = g3[g3.length - 1], z3 = P3[0];\n                  if (k4 = T3.pos + T3.dp + T3.size - z3.pos - z3.dp + z3.size, k4 > 0.01) {\n                    for (L3 = P3.length - 1; L3 >= 0; L3--) P3[L3].dp += k4;\n                    for (g3.push.apply(g3, P3), u4.splice(S2 + 1, 1), C3 = 0, L3 = g3.length - 1; L3 >= 0; L3--) C3 += g3[L3].dp;\n                    for (E3 = C3 / g3.length, L3 = g3.length - 1; L3 >= 0; L3--) g3[L3].dp -= E3;\n                    p3 = false;\n                  } else S2++;\n                }\n                u4.forEach(M4);\n              }\n              for (S2 = u4.length - 1; S2 >= 0; S2--) {\n                var O3 = u4[S2];\n                for (L3 = O3.length - 1; L3 >= 0; L3--) {\n                  var V2 = O3[L3], G2 = V2.datum;\n                  G2.offset = V2.dp, G2.del = V2.del;\n                }\n              }\n            }\n            function Nle(e3, t3) {\n              var r4 = 0, n4 = e3.offset;\n              return t3 && (n4 *= -hut, r4 = e3.offset * fut), { x: r4, y: n4 };\n            }\n            function mut(e3) {\n              var t3 = { start: 1, end: -1, middle: 0 }[e3.anchor], r4 = t3 * (Qc + sl), n4 = r4 + t3 * (e3.txwidth + sl), i3 = e3.anchor === "middle";\n              return i3 && (r4 -= e3.tx2width / 2, n4 += e3.txwidth / 2 + sl), { alignShift: t3, textShiftX: r4, text2ShiftX: n4 };\n            }\n            function Ule(e3, t3, r4, n4) {\n              var i3 = function(o4) {\n                return o4 * r4;\n              }, a4 = function(o4) {\n                return o4 * n4;\n              };\n              e3.each(function(o4) {\n                var s3 = Fb.select(this);\n                if (o4.del) return s3.remove();\n                var l3 = s3.select("text.nums"), u4 = o4.anchor, c5 = u4 === "end" ? -1 : 1, f4 = mut(o4), h3 = Nle(o4, t3), d3 = h3.x, v3 = h3.y, _2 = u4 === "middle", b = "hoverlabel" in o4.trace ? o4.trace.hoverlabel.showarrow : true, p3;\n                _2 ? p3 = "M-" + i3(o4.bx / 2 + o4.tx2width / 2) + "," + a4(v3 - o4.by / 2) + "h" + i3(o4.bx) + "v" + a4(o4.by) + "h-" + i3(o4.bx) + "Z" : b ? p3 = "M0,0L" + i3(c5 * Qc + d3) + "," + a4(Qc + v3) + "v" + a4(o4.by / 2 - Qc) + "h" + i3(c5 * o4.bx) + "v-" + a4(o4.by) + "H" + i3(c5 * Qc + d3) + "V" + a4(v3 - Qc) + "Z" : p3 = "M" + i3(c5 * Qc + d3) + "," + a4(v3 - o4.by / 2) + "h" + i3(c5 * o4.bx) + "v" + a4(o4.by) + "h" + i3(-c5 * o4.bx) + "Z", s3.select("path").attr("d", p3);\n                var k4 = d3 + f4.textShiftX, E3 = v3 + o4.ty0 - o4.by / 2 + sl, S2 = o4.textAlign || "auto";\n                S2 !== "auto" && (S2 === "left" && u4 !== "start" ? (l3.attr("text-anchor", "start"), k4 = _2 ? -o4.bx / 2 - o4.tx2width / 2 + sl : -o4.bx - sl) : S2 === "right" && u4 !== "end" && (l3.attr("text-anchor", "end"), k4 = _2 ? o4.bx / 2 - o4.tx2width / 2 - sl : o4.bx + sl)), l3.call(T0.positionText, i3(k4), a4(E3)), o4.tx2width && (s3.select("text.name").call(T0.positionText, i3(f4.text2ShiftX + f4.alignShift * sl + d3), a4(v3 + o4.ty0 - o4.by / 2 + sl)), s3.select("rect").call(bm.setRect, i3(f4.text2ShiftX + (f4.alignShift - 1) * o4.tx2width / 2 + d3), a4(v3 - o4.by / 2 - 1), i3(o4.tx2width), a4(o4.by + 2)));\n              });\n            }\n            function yut(e3, t3) {\n              var r4 = e3.index, n4 = e3.trace || {}, i3 = e3.cd[0], a4 = e3.cd[r4] || {};\n              function o4(h3) {\n                return h3 || My(h3) && h3 === 0;\n              }\n              var s3 = Array.isArray(r4) ? function(h3, d3) {\n                var v3 = zf.castOption(i3, r4, h3);\n                return o4(v3) ? v3 : zf.extractOption({}, n4, "", d3);\n              } : function(h3, d3) {\n                return zf.extractOption(a4, n4, h3, d3);\n              };\n              function l3(h3, d3, v3) {\n                var _2 = s3(d3, v3);\n                o4(_2) && (e3[h3] = _2);\n              }\n              if (l3("hoverinfo", "hi", "hoverinfo"), l3("bgcolor", "hbg", "hoverlabel.bgcolor"), l3("borderColor", "hbc", "hoverlabel.bordercolor"), l3("fontFamily", "htf", "hoverlabel.font.family"), l3("fontSize", "hts", "hoverlabel.font.size"), l3("fontColor", "htc", "hoverlabel.font.color"), l3("fontWeight", "htw", "hoverlabel.font.weight"), l3("fontStyle", "hty", "hoverlabel.font.style"), l3("fontVariant", "htv", "hoverlabel.font.variant"), l3("nameLength", "hnl", "hoverlabel.namelength"), l3("textAlign", "hta", "hoverlabel.align"), e3.posref = t3 === "y" || t3 === "closest" && n4.orientation === "h" ? e3.xa._offset + (e3.x0 + e3.x1) / 2 : e3.ya._offset + (e3.y0 + e3.y1) / 2, e3.x0 = zf.constrain(e3.x0, 0, e3.xa._length), e3.x1 = zf.constrain(e3.x1, 0, e3.xa._length), e3.y0 = zf.constrain(e3.y0, 0, e3.ya._length), e3.y1 = zf.constrain(e3.y1, 0, e3.ya._length), e3.xLabelVal !== void 0 && (e3.xLabel = "xLabel" in e3 ? e3.xLabel : wm.hoverLabelText(e3.xa, e3.xLabelVal, n4.xhoverformat), e3.xVal = e3.xa.c2d(e3.xLabelVal)), e3.yLabelVal !== void 0 && (e3.yLabel = "yLabel" in e3 ? e3.yLabel : wm.hoverLabelText(e3.ya, e3.yLabelVal, n4.yhoverformat), e3.yVal = e3.ya.c2d(e3.yLabelVal)), e3.zLabelVal !== void 0 && e3.zLabel === void 0 && (e3.zLabel = String(e3.zLabelVal)), !isNaN(e3.xerr) && !(e3.xa.type === "log" && e3.xerr <= 0)) {\n                var u4 = wm.tickText(e3.xa, e3.xa.c2l(e3.xerr), "hover").text;\n                e3.xerrneg !== void 0 ? e3.xLabel += " +" + u4 + " / -" + wm.tickText(e3.xa, e3.xa.c2l(e3.xerrneg), "hover").text : e3.xLabel += " \\xB1 " + u4, t3 === "x" && (e3.distance += 1);\n              }\n              if (!isNaN(e3.yerr) && !(e3.ya.type === "log" && e3.yerr <= 0)) {\n                var c5 = wm.tickText(e3.ya, e3.ya.c2l(e3.yerr), "hover").text;\n                e3.yerrneg !== void 0 ? e3.yLabel += " +" + c5 + " / -" + wm.tickText(e3.ya, e3.ya.c2l(e3.yerrneg), "hover").text : e3.yLabel += " \\xB1 " + c5, t3 === "y" && (e3.distance += 1);\n              }\n              var f4 = e3.hoverinfo || e3.trace.hoverinfo;\n              return f4 && f4 !== "all" && (f4 = Array.isArray(f4) ? f4 : f4.split("+"), f4.indexOf("x") === -1 && (e3.xLabel = void 0), f4.indexOf("y") === -1 && (e3.yLabel = void 0), f4.indexOf("z") === -1 && (e3.zLabel = void 0), f4.indexOf("text") === -1 && (e3.text = void 0), f4.indexOf("name") === -1 && (e3.name = void 0)), e3;\n            }\n            function Rle(e3, t3, r4) {\n              var n4 = r4.container, i3 = r4.fullLayout, a4 = i3._size, o4 = r4.event, s3 = !!t3.hLinePoint, l3 = !!t3.vLinePoint, u4, c5;\n              if (n4.selectAll(".spikeline").remove(), !!(l3 || s3)) {\n                var f4 = vd.combine(i3.plot_bgcolor, i3.paper_bgcolor);\n                if (s3) {\n                  var h3 = t3.hLinePoint, d3, v3;\n                  u4 = h3 && h3.xa, c5 = h3 && h3.ya;\n                  var _2 = c5.spikesnap;\n                  _2 === "cursor" ? (d3 = o4.pointerX, v3 = o4.pointerY) : (d3 = u4._offset + h3.x, v3 = c5._offset + h3.y);\n                  var b = Cle.readability(h3.color, f4) < 1.5 ? vd.contrast(f4) : h3.color, p3 = c5.spikemode, k4 = c5.spikethickness, E3 = c5.spikecolor || b, S2 = wm.getPxPosition(e3, c5), L3, x2;\n                  if (p3.indexOf("toaxis") !== -1 || p3.indexOf("across") !== -1) {\n                    if (p3.indexOf("toaxis") !== -1 && (L3 = S2, x2 = d3), p3.indexOf("across") !== -1) {\n                      var C3 = c5._counterDomainMin, M4 = c5._counterDomainMax;\n                      c5.anchor === "free" && (C3 = Math.min(C3, c5.position), M4 = Math.max(M4, c5.position)), L3 = a4.l + C3 * a4.w, x2 = a4.l + M4 * a4.w;\n                    }\n                    n4.insert("line", ":first-child").attr({ x1: L3, x2, y1: v3, y2: v3, "stroke-width": k4, stroke: E3, "stroke-dasharray": bm.dashStyle(c5.spikedash, k4) }).classed("spikeline", true).classed("crisp", true), n4.insert("line", ":first-child").attr({ x1: L3, x2, y1: v3, y2: v3, "stroke-width": k4 + 2, stroke: f4 }).classed("spikeline", true).classed("crisp", true);\n                  }\n                  p3.indexOf("marker") !== -1 && n4.insert("circle", ":first-child").attr({ cx: S2 + (c5.side !== "right" ? k4 : -k4), cy: v3, r: k4, fill: E3 }).classed("spikeline", true);\n                }\n                if (l3) {\n                  var g3 = t3.vLinePoint, P3, T3;\n                  u4 = g3 && g3.xa, c5 = g3 && g3.ya;\n                  var z3 = u4.spikesnap;\n                  z3 === "cursor" ? (P3 = o4.pointerX, T3 = o4.pointerY) : (P3 = u4._offset + g3.x, T3 = c5._offset + g3.y);\n                  var O3 = Cle.readability(g3.color, f4) < 1.5 ? vd.contrast(f4) : g3.color, V2 = u4.spikemode, G2 = u4.spikethickness, Z = u4.spikecolor || O3, j4 = wm.getPxPosition(e3, u4), N2, H;\n                  if (V2.indexOf("toaxis") !== -1 || V2.indexOf("across") !== -1) {\n                    if (V2.indexOf("toaxis") !== -1 && (N2 = j4, H = T3), V2.indexOf("across") !== -1) {\n                      var te = u4._counterDomainMin, oe = u4._counterDomainMax;\n                      u4.anchor === "free" && (te = Math.min(te, u4.position), oe = Math.max(oe, u4.position)), N2 = a4.t + (1 - oe) * a4.h, H = a4.t + (1 - te) * a4.h;\n                    }\n                    n4.insert("line", ":first-child").attr({ x1: P3, x2: P3, y1: N2, y2: H, "stroke-width": G2, stroke: Z, "stroke-dasharray": bm.dashStyle(u4.spikedash, G2) }).classed("spikeline", true).classed("crisp", true), n4.insert("line", ":first-child").attr({ x1: P3, x2: P3, y1: N2, y2: H, "stroke-width": G2 + 2, stroke: f4 }).classed("spikeline", true).classed("crisp", true);\n                  }\n                  V2.indexOf("marker") !== -1 && n4.insert("circle", ":first-child").attr({ cx: P3, cy: j4 - (u4.side !== "top" ? G2 : -G2), r: G2, fill: Z }).classed("spikeline", true);\n                }\n              }\n            }\n            function _ut(e3, t3, r4) {\n              if (!r4 || r4.length !== e3._hoverdata.length) return true;\n              for (var n4 = r4.length - 1; n4 >= 0; n4--) {\n                var i3 = r4[n4], a4 = e3._hoverdata[n4];\n                if (i3.curveNumber !== a4.curveNumber || String(i3.pointNumber) !== String(a4.pointNumber) || String(i3.pointNumbers) !== String(a4.pointNumbers) || i3.binNumber !== a4.binNumber) return true;\n              }\n              return false;\n            }\n            function Dle(e3, t3) {\n              return !t3 || t3.vLinePoint !== e3._spikepoints.vLinePoint || t3.hLinePoint !== e3._spikepoints.hLinePoint;\n            }\n            function Fle(e3, t3) {\n              return T0.plainText(e3 || "", { len: t3, allowedTags: ["br", "sub", "sup", "b", "i", "em", "s", "u"] });\n            }\n            function xut(e3, t3) {\n              for (var r4 = t3.charAt(0), n4 = [], i3 = [], a4 = [], o4 = 0; o4 < e3.length; o4++) {\n                var s3 = e3[o4];\n                j3.traceIs(s3.trace, "bar-like") || j3.traceIs(s3.trace, "box-violin") ? a4.push(s3) : s3.trace[r4 + "period"] ? i3.push(s3) : n4.push(s3);\n              }\n              return n4.concat(i3).concat(a4);\n            }\n            function zle(e3, t3, r4) {\n              var n4 = t3[e3 + "a"], i3 = t3[e3 + "Val"], a4 = t3.cd[0];\n              if (n4.type === "category" || n4.type === "multicategory") i3 = n4._categoriesMap[i3];\n              else if (n4.type === "date") {\n                var o4 = t3.trace[e3 + "periodalignment"];\n                if (o4) {\n                  var s3 = t3.cd[t3.index], l3 = s3[e3 + "Start"];\n                  l3 === void 0 && (l3 = s3[e3]);\n                  var u4 = s3[e3 + "End"];\n                  u4 === void 0 && (u4 = s3[e3]);\n                  var c5 = u4 - l3;\n                  o4 === "end" ? i3 += c5 : o4 === "middle" && (i3 += c5 / 2);\n                }\n                i3 = n4.d2c(i3);\n              }\n              return a4 && a4.t && a4.t.posLetter === n4._id && (r4.boxmode === "group" || r4.violinmode === "group") && (i3 += a4.t.dPos), i3;\n            }\n            var Vle = (e3) => e3.offsetTop + e3.clientTop, Gle = (e3) => e3.offsetLeft + e3.clientLeft;\n            function H3(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3.getBoundingClientRect(), i3 = n4.left, a4 = n4.top, o4 = i3 + n4.width, s3 = a4 + n4.height, l3 = zf.apply3DTransform(r4._invTransform)(i3, a4), u4 = zf.apply3DTransform(r4._invTransform)(o4, s3), c5 = l3[0], f4 = l3[1], h3 = u4[0], d3 = u4[1];\n              return { x: c5, y: f4, width: h3 - c5, height: d3 - f4, top: Math.min(f4, d3), left: Math.min(c5, h3), right: Math.max(c5, h3), bottom: Math.max(f4, d3) };\n            }\n          });\n          var hM = ye((gar, Hle) => {\n            "use strict";\n            var but = Dr(), wut = ka(), Tut = ip().isUnifiedHover;\n            Hle.exports = function(t3, r4, n4, i3) {\n              i3 = i3 || {};\n              var a4 = r4.legend;\n              function o4(s3) {\n                i3.font[s3] || (i3.font[s3] = a4 ? r4.legend.font[s3] : r4.font[s3]);\n              }\n              r4 && Tut(r4.hovermode) && (i3.font || (i3.font = {}), o4("size"), o4("family"), o4("color"), o4("weight"), o4("style"), o4("variant"), a4 ? (i3.bgcolor || (i3.bgcolor = wut.combine(r4.legend.bgcolor, r4.paper_bgcolor)), i3.bordercolor || (i3.bordercolor = r4.legend.bordercolor)) : i3.bgcolor || (i3.bgcolor = r4.paper_bgcolor)), n4("hoverlabel.bgcolor", i3.bgcolor), n4("hoverlabel.bordercolor", i3.bordercolor), n4("hoverlabel.namelength", i3.namelength), n4("hoverlabel.showarrow", i3.showarrow), but.coerceFont(n4, "hoverlabel.font", i3.font), n4("hoverlabel.align", i3.align);\n            };\n          });\n          var Wle = ye((mar, jle) => {\n            "use strict";\n            var Aut = Dr(), Sut = hM(), Mut = B1();\n            jle.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return Aut.coerce(t3, r4, Mut, i3, a4);\n              }\n              Sut(t3, r4, n4);\n            };\n          });\n          var Yle = ye((yar, Zle) => {\n            "use strict";\n            var Xle = Dr(), Eut = a3(), kut = hM();\n            Zle.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return Xle.coerce(t3, r4, Eut, s3, l3);\n              }\n              var o4 = Xle.extendFlat({}, i3.hoverlabel);\n              r4.hovertemplate && (o4.namelength = -1), kut(t3, r4, a4, o4);\n            };\n          });\n          var HB = ye((_ar, Kle) => {\n            "use strict";\n            var Cut = Dr(), Lut = B1();\n            Kle.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return r4[i3] !== void 0 ? r4[i3] : Cut.coerce(t3, r4, Lut, i3, a4);\n              }\n              return n4("clickmode"), n4("hoversubplots"), n4("hovermode");\n            };\n          });\n          var Qle = ye((xar, $le) => {\n            "use strict";\n            var Jle = Dr(), Put = B1(), Iut = HB(), Rut = hM();\n            $le.exports = function(t3, r4) {\n              function n4(c5, f4) {\n                return Jle.coerce(t3, r4, Put, c5, f4);\n              }\n              var i3 = Iut(t3, r4);\n              i3 && (n4("hoverdistance"), n4("spikedistance"));\n              var a4 = n4("dragmode");\n              a4 === "select" && n4("selectdirection");\n              var o4 = r4._has("mapbox"), s3 = r4._has("map"), l3 = r4._has("geo"), u4 = r4._basePlotModules.length;\n              r4.dragmode === "zoom" && ((o4 || s3 || l3) && u4 === 1 || (o4 || s3) && l3 && u4 === 2) && (r4.dragmode = "pan"), Rut(t3, r4, n4), Jle.coerceFont(n4, "hoverlabel.grouptitlefont", r4.hoverlabel.font);\n            };\n          });\n          var rue = ye((bar, tue) => {\n            "use strict";\n            var jB = Dr(), eue = qa();\n            tue.exports = function(t3) {\n              var r4 = t3.calcdata, n4 = t3._fullLayout;\n              function i3(u4) {\n                return function(c5) {\n                  return jB.coerceHoverinfo({ hoverinfo: c5 }, { _module: u4._module }, n4);\n                };\n              }\n              for (var a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4], s3 = o4[0].trace;\n                if (!eue.traceIs(s3, "pie-like")) {\n                  var l3 = eue.traceIs(s3, "2dMap") ? Dut : jB.fillArray;\n                  l3(s3.hoverinfo, o4, "hi", i3(s3)), s3.hovertemplate && l3(s3.hovertemplate, o4, "ht"), s3.hoverlabel && (l3(s3.hoverlabel.bgcolor, o4, "hbg"), l3(s3.hoverlabel.bordercolor, o4, "hbc"), l3(s3.hoverlabel.font.size, o4, "hts"), l3(s3.hoverlabel.font.color, o4, "htc"), l3(s3.hoverlabel.font.family, o4, "htf"), l3(s3.hoverlabel.font.weight, o4, "htw"), l3(s3.hoverlabel.font.style, o4, "hty"), l3(s3.hoverlabel.font.variant, o4, "htv"), l3(s3.hoverlabel.namelength, o4, "hnl"), l3(s3.hoverlabel.align, o4, "hta"), l3(s3.hoverlabel.showarrow, o4, "htsa"));\n                }\n              }\n            };\n            function Dut(e3, t3, r4, n4) {\n              n4 = n4 || jB.identity, Array.isArray(e3) && (t3[0][r4] = n4(e3));\n            }\n          });\n          var nue = ye((war, iue) => {\n            "use strict";\n            var Fut = qa(), zut = GB().hover;\n            iue.exports = function(t3, r4, n4) {\n              var i3 = Fut.getComponentMethod("annotations", "onClick")(t3, t3._hoverdata);\n              n4 !== void 0 && zut(t3, r4, n4, true);\n              function a4() {\n                t3.emit("plotly_click", { points: t3._hoverdata, event: r4 });\n              }\n              t3._hoverdata && r4 && r4.target && (i3 && i3.then ? i3.then(a4) : a4(), r4.stopImmediatePropagation && r4.stopImmediatePropagation());\n            };\n          });\n          var vf = ye((Tar, sue) => {\n            "use strict";\n            var Out = Oa(), WL = Dr(), qut = yv(), dM = ip(), aue = B1(), oue = GB();\n            sue.exports = { moduleType: "component", name: "fx", constants: zS(), schema: { layout: aue }, attributes: a3(), layoutAttributes: aue, supplyLayoutGlobalDefaults: Wle(), supplyDefaults: Yle(), supplyLayoutDefaults: Qle(), calc: rue(), getDistanceFunction: dM.getDistanceFunction, getClosest: dM.getClosest, inbox: dM.inbox, quadrature: dM.quadrature, appendArrayPointValue: dM.appendArrayPointValue, castHoverOption: Nut, castHoverinfo: Uut, hover: oue.hover, unhover: qut.unhover, loneHover: oue.loneHover, loneUnhover: But, click: nue() };\n            function But(e3) {\n              var t3 = WL.isD3Selection(e3) ? e3 : Out.select(e3);\n              t3.selectAll("g.hovertext").remove(), t3.selectAll(".spikeline").remove();\n            }\n            function Nut(e3, t3, r4) {\n              return WL.castOption(e3, t3, "hoverlabel." + r4);\n            }\n            function Uut(e3, t3, r4) {\n              function n4(i3) {\n                return WL.coerceHoverinfo({ hoverinfo: i3 }, { _module: e3._module }, t3);\n              }\n              return WL.castOption(e3, r4, "hoverinfo", n4);\n            }\n          });\n          var Eg = ye((Ey) => {\n            "use strict";\n            Ey.selectMode = function(e3) {\n              return e3 === "lasso" || e3 === "select";\n            };\n            Ey.drawMode = function(e3) {\n              return e3 === "drawclosedpath" || e3 === "drawopenpath" || e3 === "drawline" || e3 === "drawrect" || e3 === "drawcircle";\n            };\n            Ey.openMode = function(e3) {\n              return e3 === "drawline" || e3 === "drawopenpath";\n            };\n            Ey.rectMode = function(e3) {\n              return e3 === "select" || e3 === "drawline" || e3 === "drawrect" || e3 === "drawcircle";\n            };\n            Ey.freeMode = function(e3) {\n              return e3 === "lasso" || e3 === "drawclosedpath" || e3 === "drawopenpath";\n            };\n            Ey.selectingOrDrawing = function(e3) {\n              return Ey.freeMode(e3) || Ey.rectMode(e3);\n            };\n          });\n          var vM = ye((Sar, lue) => {\n            "use strict";\n            lue.exports = function(t3) {\n              var r4 = t3._fullLayout;\n              r4._glcanvas && r4._glcanvas.size() && r4._glcanvas.each(function(n4) {\n                n4.regl && n4.regl.clear({ color: true, depth: true });\n              });\n            };\n          });\n          var XL = ye((Mar, uue) => {\n            "use strict";\n            uue.exports = { undo: { width: 857.1, height: 1e3, path: "m857 350q0-87-34-166t-91-137-137-92-166-34q-96 0-183 41t-147 114q-4 6-4 13t5 11l76 77q6 5 14 5 9-1 13-7 41-53 100-82t126-29q58 0 110 23t92 61 61 91 22 111-22 111-61 91-92 61-110 23q-55 0-105-20t-90-57l77-77q17-16 8-38-10-23-33-23h-250q-15 0-25 11t-11 25v250q0 24 22 33 22 10 39-8l72-72q60 57 137 88t159 31q87 0 166-34t137-92 91-137 34-166z", transform: "matrix(1 0 0 -1 0 850)" }, home: { width: 928.6, height: 1e3, path: "m786 296v-267q0-15-11-26t-25-10h-214v214h-143v-214h-214q-15 0-25 10t-11 26v267q0 1 0 2t0 2l321 264 321-264q1-1 1-4z m124 39l-34-41q-5-5-12-6h-2q-7 0-12 3l-386 322-386-322q-7-4-13-4-7 2-12 7l-35 41q-4 5-3 13t6 12l401 334q18 15 42 15t43-15l136-114v109q0 8 5 13t13 5h107q8 0 13-5t5-13v-227l122-102q5-5 6-12t-4-13z", transform: "matrix(1 0 0 -1 0 850)" }, "camera-retro": { width: 1e3, height: 1e3, path: "m518 386q0 8-5 13t-13 5q-37 0-63-27t-26-63q0-8 5-13t13-5 12 5 5 13q0 23 16 38t38 16q8 0 13 5t5 13z m125-73q0-59-42-101t-101-42-101 42-42 101 42 101 101 42 101-42 42-101z m-572-320h858v71h-858v-71z m643 320q0 89-62 152t-152 62-151-62-63-152 63-151 151-63 152 63 62 151z m-571 358h214v72h-214v-72z m-72-107h858v143h-462l-36-71h-360v-72z m929 143v-714q0-30-21-51t-50-21h-858q-29 0-50 21t-21 51v714q0 30 21 51t50 21h858q29 0 50-21t21-51z", transform: "matrix(1 0 0 -1 0 850)" }, zoombox: { width: 1e3, height: 1e3, path: "m1000-25l-250 251c40 63 63 138 63 218 0 224-182 406-407 406-224 0-406-182-406-406s183-406 407-406c80 0 155 22 218 62l250-250 125 125z m-812 250l0 438 437 0 0-438-437 0z m62 375l313 0 0-312-313 0 0 312z", transform: "matrix(1 0 0 -1 0 850)" }, pan: { width: 1e3, height: 1e3, path: "m1000 350l-187 188 0-125-250 0 0 250 125 0-188 187-187-187 125 0 0-250-250 0 0 125-188-188 186-187 0 125 252 0 0-250-125 0 187-188 188 188-125 0 0 250 250 0 0-126 187 188z", transform: "matrix(1 0 0 -1 0 850)" }, zoom_plus: { width: 875, height: 1e3, path: "m1 787l0-875 875 0 0 875-875 0z m687-500l-187 0 0-187-125 0 0 187-188 0 0 125 188 0 0 187 125 0 0-187 187 0 0-125z", transform: "matrix(1 0 0 -1 0 850)" }, zoom_minus: { width: 875, height: 1e3, path: "m0 788l0-876 875 0 0 876-875 0z m688-500l-500 0 0 125 500 0 0-125z", transform: "matrix(1 0 0 -1 0 850)" }, autoscale: { width: 1e3, height: 1e3, path: "m250 850l-187 0-63 0 0-62 0-188 63 0 0 188 187 0 0 62z m688 0l-188 0 0-62 188 0 0-188 62 0 0 188 0 62-62 0z m-875-938l0 188-63 0 0-188 0-62 63 0 187 0 0 62-187 0z m875 188l0-188-188 0 0-62 188 0 62 0 0 62 0 188-62 0z m-125 188l-1 0-93-94-156 156 156 156 92-93 2 0 0 250-250 0 0-2 93-92-156-156-156 156 94 92 0 2-250 0 0-250 0 0 93 93 157-156-157-156-93 94 0 0 0-250 250 0 0 0-94 93 156 157 156-157-93-93 0 0 250 0 0 250z", transform: "matrix(1 0 0 -1 0 850)" }, tooltip_basic: { width: 1500, height: 1e3, path: "m375 725l0 0-375-375 375-374 0-1 1125 0 0 750-1125 0z", transform: "matrix(1 0 0 -1 0 850)" }, tooltip_compare: { width: 1125, height: 1e3, path: "m187 786l0 2-187-188 188-187 0 0 937 0 0 373-938 0z m0-499l0 1-187-188 188-188 0 0 937 0 0 376-938-1z", transform: "matrix(1 0 0 -1 0 850)" }, plotlylogo: { width: 1542, height: 1e3, path: "m0-10h182v-140h-182v140z m228 146h183v-286h-183v286z m225 714h182v-1000h-182v1000z m225-285h182v-715h-182v715z m225 142h183v-857h-183v857z m231-428h182v-429h-182v429z m225-291h183v-138h-183v138z", transform: "matrix(1 0 0 -1 0 850)" }, "z-axis": { width: 1e3, height: 1e3, path: "m833 5l-17 108v41l-130-65 130-66c0 0 0 38 0 39 0-1 36-14 39-25 4-15-6-22-16-30-15-12-39-16-56-20-90-22-187-23-279-23-261 0-341 34-353 59 3 60 228 110 228 110-140-8-351-35-351-116 0-120 293-142 474-142 155 0 477 22 477 142 0 50-74 79-163 96z m-374 94c-58-5-99-21-99-40 0-24 65-43 144-43 79 0 143 19 143 43 0 19-42 34-98 40v216h87l-132 135-133-135h88v-216z m167 515h-136v1c16 16 31 34 46 52l84 109v54h-230v-71h124v-1c-16-17-28-32-44-51l-89-114v-51h245v72z", transform: "matrix(1 0 0 -1 0 850)" }, "3d_rotate": { width: 1e3, height: 1e3, path: "m922 660c-5 4-9 7-14 11-359 263-580-31-580-31l-102 28 58-400c0 1 1 1 2 2 118 108 351 249 351 249s-62 27-100 42c88 83 222 183 347 122 16-8 30-17 44-27-2 1-4 2-6 4z m36-329c0 0 64 229-88 296-62 27-124 14-175-11 157-78 225-208 249-266 8-19 11-31 11-31 2 5 6 15 11 32-5-13-8-20-8-20z m-775-239c70-31 117-50 198-32-121 80-199 346-199 346l-96-15-58-12c0 0 55-226 155-287z m603 133l-317-139c0 0 4-4 19-14 7-5 24-15 24-15s-177-147-389 4c235-287 536-112 536-112l31-22 100 299-4-1z m-298-153c6-4 14-9 24-15 0 0-17 10-24 15z", transform: "matrix(1 0 0 -1 0 850)" }, camera: { width: 1e3, height: 1e3, path: "m500 450c-83 0-150-67-150-150 0-83 67-150 150-150 83 0 150 67 150 150 0 83-67 150-150 150z m400 150h-120c-16 0-34 13-39 29l-31 93c-6 15-23 28-40 28h-340c-16 0-34-13-39-28l-31-94c-6-15-23-28-40-28h-120c-55 0-100-45-100-100v-450c0-55 45-100 100-100h800c55 0 100 45 100 100v450c0 55-45 100-100 100z m-400-550c-138 0-250 112-250 250 0 138 112 250 250 250 138 0 250-112 250-250 0-138-112-250-250-250z m365 380c-19 0-35 16-35 35 0 19 16 35 35 35 19 0 35-16 35-35 0-19-16-35-35-35z", transform: "matrix(1 0 0 -1 0 850)" }, movie: { width: 1e3, height: 1e3, path: "m938 413l-188-125c0 37-17 71-44 94 64 38 107 107 107 187 0 121-98 219-219 219-121 0-219-98-219-219 0-61 25-117 66-156h-115c30 33 49 76 49 125 0 103-84 187-187 187s-188-84-188-187c0-57 26-107 65-141-38-22-65-62-65-109v-250c0-70 56-126 125-126h500c69 0 125 56 125 126l188-126c34 0 62 28 62 63v375c0 35-28 63-62 63z m-750 0c-69 0-125 56-125 125s56 125 125 125 125-56 125-125-56-125-125-125z m406-1c-87 0-157 70-157 157 0 86 70 156 157 156s156-70 156-156-70-157-156-157z", transform: "matrix(1 0 0 -1 0 850)" }, question: { width: 857.1, height: 1e3, path: "m500 82v107q0 8-5 13t-13 5h-107q-8 0-13-5t-5-13v-107q0-8 5-13t13-5h107q8 0 13 5t5 13z m143 375q0 49-31 91t-77 65-95 23q-136 0-207-119-9-14 4-24l74-55q4-4 10-4 9 0 14 7 30 38 48 51 19 14 48 14 27 0 48-15t21-33q0-21-11-34t-38-25q-35-16-65-48t-29-70v-20q0-8 5-13t13-5h107q8 0 13 5t5 13q0 10 12 27t30 28q18 10 28 16t25 19 25 27 16 34 7 45z m214-107q0-117-57-215t-156-156-215-58-216 58-155 156-58 215 58 215 155 156 216 58 215-58 156-156 57-215z", transform: "matrix(1 0 0 -1 0 850)" }, disk: { width: 857.1, height: 1e3, path: "m214-7h429v214h-429v-214z m500 0h72v500q0 8-6 21t-11 20l-157 156q-5 6-19 12t-22 5v-232q0-22-15-38t-38-16h-322q-22 0-37 16t-16 38v232h-72v-714h72v232q0 22 16 38t37 16h465q22 0 38-16t15-38v-232z m-214 518v178q0 8-5 13t-13 5h-107q-7 0-13-5t-5-13v-178q0-8 5-13t13-5h107q7 0 13 5t5 13z m357-18v-518q0-22-15-38t-38-16h-750q-23 0-38 16t-16 38v750q0 22 16 38t38 16h517q23 0 50-12t42-26l156-157q16-15 27-42t11-49z", transform: "matrix(1 0 0 -1 0 850)" }, drawopenpath: { width: 70, height: 70, path: "M33.21,85.65a7.31,7.31,0,0,1-2.59-.48c-8.16-3.11-9.27-19.8-9.88-41.3-.1-3.58-.19-6.68-.35-9-.15-2.1-.67-3.48-1.43-3.79-2.13-.88-7.91,2.32-12,5.86L3,32.38c1.87-1.64,11.55-9.66,18.27-6.9,2.13.87,4.75,3.14,5.17,9,.17,2.43.26,5.59.36,9.25a224.17,224.17,0,0,0,1.5,23.4c1.54,10.76,4,12.22,4.48,12.4.84.32,2.79-.46,5.76-3.59L43,80.07C41.53,81.57,37.68,85.64,33.21,85.65ZM74.81,69a11.34,11.34,0,0,0,6.09-6.72L87.26,44.5,74.72,32,56.9,38.35c-2.37.86-5.57,3.42-6.61,6L38.65,72.14l8.42,8.43ZM55,46.27a7.91,7.91,0,0,1,3.64-3.17l14.8-5.3,8,8L76.11,60.6l-.06.19a6.37,6.37,0,0,1-3,3.43L48.25,74.59,44.62,71Zm16.57,7.82A6.9,6.9,0,1,0,64.64,61,6.91,6.91,0,0,0,71.54,54.09Zm-4.05,0a2.85,2.85,0,1,1-2.85-2.85A2.86,2.86,0,0,1,67.49,54.09Zm-4.13,5.22L60.5,56.45,44.26,72.7l2.86,2.86ZM97.83,35.67,84.14,22l-8.57,8.57L89.26,44.24Zm-13.69-8,8,8-2.85,2.85-8-8Z", transform: "matrix(1 0 0 1 -15 -15)" }, drawclosedpath: { width: 90, height: 90, path: "M88.41,21.12a26.56,26.56,0,0,0-36.18,0l-2.07,2-2.07-2a26.57,26.57,0,0,0-36.18,0,23.74,23.74,0,0,0,0,34.8L48,90.12a3.22,3.22,0,0,0,4.42,0l36-34.21a23.73,23.73,0,0,0,0-34.79ZM84,51.24,50.16,83.35,16.35,51.25a17.28,17.28,0,0,1,0-25.47,20,20,0,0,1,27.3,0l4.29,4.07a3.23,3.23,0,0,0,4.44,0l4.29-4.07a20,20,0,0,1,27.3,0,17.27,17.27,0,0,1,0,25.46ZM66.76,47.68h-33v6.91h33ZM53.35,35H46.44V68h6.91Z", transform: "matrix(1 0 0 1 -5 -5)" }, lasso: { width: 1031, height: 1e3, path: "m1018 538c-36 207-290 336-568 286-277-48-473-256-436-463 10-57 36-108 76-151-13-66 11-137 68-183 34-28 75-41 114-42l-55-70 0 0c-2-1-3-2-4-3-10-14-8-34 5-45 14-11 34-8 45 4 1 1 2 3 2 5l0 0 113 140c16 11 31 24 45 40 4 3 6 7 8 11 48-3 100 0 151 9 278 48 473 255 436 462z m-624-379c-80 14-149 48-197 96 42 42 109 47 156 9 33-26 47-66 41-105z m-187-74c-19 16-33 37-39 60 50-32 109-55 174-68-42-25-95-24-135 8z m360 75c-34-7-69-9-102-8 8 62-16 128-68 170-73 59-175 54-244-5-9 20-16 40-20 61-28 159 121 317 333 354s407-60 434-217c28-159-121-318-333-355z", transform: "matrix(1 0 0 -1 0 850)" }, selectbox: { width: 1e3, height: 1e3, path: "m0 850l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-285l0-143 143 0 0 143-143 0z m857 0l0-143 143 0 0 143-143 0z m-857-286l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z m285 0l0-143 143 0 0 143-143 0z m286 0l0-143 143 0 0 143-143 0z", transform: "matrix(1 0 0 -1 0 850)" }, drawline: { width: 70, height: 70, path: "M60.64,62.3a11.29,11.29,0,0,0,6.09-6.72l6.35-17.72L60.54,25.31l-17.82,6.4c-2.36.86-5.57,3.41-6.6,6L24.48,65.5l8.42,8.42ZM40.79,39.63a7.89,7.89,0,0,1,3.65-3.17l14.79-5.31,8,8L61.94,54l-.06.19a6.44,6.44,0,0,1-3,3.43L34.07,68l-3.62-3.63Zm16.57,7.81a6.9,6.9,0,1,0-6.89,6.9A6.9,6.9,0,0,0,57.36,47.44Zm-4,0a2.86,2.86,0,1,1-2.85-2.85A2.86,2.86,0,0,1,53.32,47.44Zm-4.13,5.22L46.33,49.8,30.08,66.05l2.86,2.86ZM83.65,29,70,15.34,61.4,23.9,75.09,37.59ZM70,21.06l8,8-2.84,2.85-8-8ZM87,80.49H10.67V87H87Z", transform: "matrix(1 0 0 1 -15 -15)" }, drawrect: { width: 80, height: 80, path: "M78,22V79H21V22H78m9-9H12V88H87V13ZM68,46.22H31V54H68ZM53,32H45.22V69H53Z", transform: "matrix(1 0 0 1 -10 -10)" }, drawcircle: { width: 80, height: 80, path: "M50,84.72C26.84,84.72,8,69.28,8,50.3S26.84,15.87,50,15.87,92,31.31,92,50.3,73.16,84.72,50,84.72Zm0-60.59c-18.6,0-33.74,11.74-33.74,26.17S31.4,76.46,50,76.46,83.74,64.72,83.74,50.3,68.6,24.13,50,24.13Zm17.15,22h-34v7.11h34Zm-13.8-13H46.24v34h7.11Z", transform: "matrix(1 0 0 1 -10 -10)" }, eraseshape: { width: 80, height: 80, path: "M82.77,78H31.85L6,49.57,31.85,21.14H82.77a8.72,8.72,0,0,1,8.65,8.77V69.24A8.72,8.72,0,0,1,82.77,78ZM35.46,69.84H82.77a.57.57,0,0,0,.49-.6V29.91a.57.57,0,0,0-.49-.61H35.46L17,49.57Zm32.68-34.7-24,24,5,5,24-24Zm-19,.53-5,5,24,24,5-5Z", transform: "matrix(1 0 0 1 -10 -10)" }, spikeline: { width: 1e3, height: 1e3, path: "M512 409c0-57-46-104-103-104-57 0-104 47-104 104 0 57 47 103 104 103 57 0 103-46 103-103z m-327-39l92 0 0 92-92 0z m-185 0l92 0 0 92-92 0z m370-186l92 0 0 93-92 0z m0-184l92 0 0 92-92 0z", transform: "matrix(1.5 0 0 -1.5 0 850)" }, pencil: { width: 1792, height: 1792, path: "M491 1536l91-91-235-235-91 91v107h128v128h107zm523-928q0-22-22-22-10 0-17 7l-542 542q-7 7-7 17 0 22 22 22 10 0 17-7l542-542q7-7 7-17zm-54-192l416 416-832 832h-416v-416zm683 96q0 53-37 90l-166 166-416-416 166-165q36-38 90-38 53 0 91 38l235 234q37 39 37 91z", transform: "matrix(1 0 0 1 0 1)" }, newplotlylogo: { name: "newplotlylogo", svg: ["<svg xmlns=\'http://www.w3.org/2000/svg\' viewBox=\'0 0 132 132\'>", " <title>plotly-logomark</title>", " <g id=\'symbol\'>", "  <rect fill=\'#000\' x=\'0\' y=\'0\' width=\'132\' height=\'132\' rx=\'18\' ry=\'18\'/>", "  <circle fill=\'#9EF\' cx=\'102\' cy=\'30\' r=\'6\'/>", "  <circle fill=\'#BAC\' cx=\'78\' cy=\'30\' r=\'6\'/>", "  <circle fill=\'#BAC\' cx=\'78\' cy=\'54\' r=\'6\'/>", "  <circle fill=\'#D69\' cx=\'54\' cy=\'30\' r=\'6\'/>", "  <circle fill=\'#F26\' cx=\'30\' cy=\'30\' r=\'6\'/>", "  <circle fill=\'#F26\' cx=\'30\' cy=\'54\' r=\'6\'/>", "  <path fill=\'#FFF\' d=\'M30,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,30,72Z\'/>", "  <path fill=\'#FFF\' d=\'M78,72a6,6,0,0,0-6,6v24a6,6,0,0,0,12,0V78A6,6,0,0,0,78,72Z\'/>", "  <path fill=\'#FFF\' d=\'M54,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,54,48Z\'/>", "  <path fill=\'#FFF\' d=\'M102,48a6,6,0,0,0-6,6v48a6,6,0,0,0,12,0V54A6,6,0,0,0,102,48Z\'/>", " </g>", "</svg>"].join("") } };\n          });\n          var YL = ye((Ear, cue) => {\n            "use strict";\n            var ZL = 32;\n            cue.exports = { CIRCLE_SIDES: ZL, i000: 0, i090: ZL / 4, i180: ZL / 2, i270: ZL / 4 * 3, cos45: Math.cos(Math.PI / 4), sin45: Math.sin(Math.PI / 4), SQRT2: Math.sqrt(2) };\n          });\n          var KL = ye((kar, hue) => {\n            "use strict";\n            var Vut = Dr().strTranslate;\n            function fue(e3, t3) {\n              switch (e3.type) {\n                case "log":\n                  return e3.p2d(t3);\n                case "date":\n                  return e3.p2r(t3, 0, e3.calendar);\n                default:\n                  return e3.p2r(t3);\n              }\n            }\n            function Gut(e3, t3) {\n              switch (e3.type) {\n                case "log":\n                  return e3.d2p(t3);\n                case "date":\n                  return e3.r2p(t3, 0, e3.calendar);\n                default:\n                  return e3.r2p(t3);\n              }\n            }\n            function Hut(e3) {\n              var t3 = e3._id.charAt(0) === "y" ? 1 : 0;\n              return function(r4) {\n                return fue(e3, r4[t3]);\n              };\n            }\n            function jut(e3) {\n              return Vut(e3.xaxis._offset, e3.yaxis._offset);\n            }\n            hue.exports = { p2r: fue, r2p: Gut, axValue: Hut, getTransform: jut };\n          });\n          var u_ = ye((ky) => {\n            "use strict";\n            var Wut = eM(), pue = YL(), W3 = pue.CIRCLE_SIDES, WB = pue.SQRT2, gue = KL(), due = gue.p2r, vue = gue.r2p, Xut = [0, 3, 4, 5, 6, 1, 2], Zut = [0, 3, 4, 1, 2];\n            ky.writePaths = function(e3) {\n              var t3 = e3.length;\n              if (!t3) return "M0,0Z";\n              for (var r4 = "", n4 = 0; n4 < t3; n4++) for (var i3 = e3[n4].length, a4 = 0; a4 < i3; a4++) {\n                var o4 = e3[n4][a4][0];\n                if (o4 === "Z") r4 += "Z";\n                else for (var s3 = e3[n4][a4].length, l3 = 0; l3 < s3; l3++) {\n                  var u4 = l3;\n                  o4 === "Q" || o4 === "S" ? u4 = Zut[l3] : o4 === "C" && (u4 = Xut[l3]), r4 += e3[n4][a4][u4], l3 > 0 && l3 < s3 - 1 && (r4 += ",");\n                }\n              }\n              return r4;\n            };\n            ky.readPaths = function(e3, t3, r4, n4) {\n              var i3 = Wut(e3), a4 = [], o4 = -1, s3 = function() {\n                o4++, a4[o4] = [];\n              }, l3, u4 = 0, c5 = 0, f4, h3, d3 = function() {\n                f4 = u4, h3 = c5;\n              };\n              d3();\n              for (var v3 = 0; v3 < i3.length; v3++) {\n                var _2 = [], b, p3, k4, E3, S2 = i3[v3][0], L3 = S2;\n                switch (S2) {\n                  case "M":\n                    s3(), u4 = +i3[v3][1], c5 = +i3[v3][2], _2.push([L3, u4, c5]), d3();\n                    break;\n                  case "Q":\n                  case "S":\n                    b = +i3[v3][1], k4 = +i3[v3][2], u4 = +i3[v3][3], c5 = +i3[v3][4], _2.push([L3, u4, c5, b, k4]);\n                    break;\n                  case "C":\n                    b = +i3[v3][1], k4 = +i3[v3][2], p3 = +i3[v3][3], E3 = +i3[v3][4], u4 = +i3[v3][5], c5 = +i3[v3][6], _2.push([L3, u4, c5, b, k4, p3, E3]);\n                    break;\n                  case "T":\n                  case "L":\n                    u4 = +i3[v3][1], c5 = +i3[v3][2], _2.push([L3, u4, c5]);\n                    break;\n                  case "H":\n                    L3 = "L", u4 = +i3[v3][1], _2.push([L3, u4, c5]);\n                    break;\n                  case "V":\n                    L3 = "L", c5 = +i3[v3][1], _2.push([L3, u4, c5]);\n                    break;\n                  case "A":\n                    L3 = "L";\n                    var x2 = +i3[v3][1], C3 = +i3[v3][2];\n                    +i3[v3][4] || (x2 = -x2, C3 = -C3);\n                    var M4 = u4 - x2, g3 = c5;\n                    for (l3 = 1; l3 <= W3 / 2; l3++) {\n                      var P3 = 2 * Math.PI * l3 / W3;\n                      _2.push([L3, M4 + x2 * Math.cos(P3), g3 + C3 * Math.sin(P3)]);\n                    }\n                    break;\n                  case "Z":\n                    (u4 !== f4 || c5 !== h3) && (u4 = f4, c5 = h3, _2.push([L3, u4, c5]));\n                    break;\n                }\n                for (var T3 = (r4 || {}).domain, z3 = t3._fullLayout._size, O3 = r4 && r4.xsizemode === "pixel", V2 = r4 && r4.ysizemode === "pixel", G2 = n4 === false, Z = 0; Z < _2.length; Z++) {\n                  for (l3 = 0; l3 + 2 < 7; l3 += 2) {\n                    var j3 = _2[Z][l3 + 1], N2 = _2[Z][l3 + 2];\n                    j3 === void 0 || N2 === void 0 || (u4 = j3, c5 = N2, r4 && (r4.xaxis && r4.xaxis.p2r ? (G2 && (j3 -= r4.xaxis._offset), O3 ? j3 = vue(r4.xaxis, r4.xanchor) + j3 : j3 = due(r4.xaxis, j3)) : (G2 && (j3 -= z3.l), T3 ? j3 = T3.x[0] + j3 / z3.w : j3 = j3 / z3.w), r4.yaxis && r4.yaxis.p2r ? (G2 && (N2 -= r4.yaxis._offset), V2 ? N2 = vue(r4.yaxis, r4.yanchor) - N2 : N2 = due(r4.yaxis, N2)) : (G2 && (N2 -= z3.t), T3 ? N2 = T3.y[1] - N2 / z3.h : N2 = 1 - N2 / z3.h)), _2[Z][l3 + 1] = j3, _2[Z][l3 + 2] = N2);\n                  }\n                  a4[o4].push(_2[Z].slice());\n                }\n              }\n              return a4;\n            };\n            function pM(e3, t3) {\n              return Math.abs(e3 - t3) <= 1e-6;\n            }\n            function JL(e3, t3) {\n              var r4 = t3[1] - e3[1], n4 = t3[2] - e3[2];\n              return Math.sqrt(r4 * r4 + n4 * n4);\n            }\n            ky.pointsOnRectangle = function(e3) {\n              var t3 = e3.length;\n              if (t3 !== 5) return false;\n              for (var r4 = 1; r4 < 3; r4++) {\n                var n4 = e3[0][r4] - e3[1][r4], i3 = e3[3][r4] - e3[2][r4];\n                if (!pM(n4, i3)) return false;\n                var a4 = e3[0][r4] - e3[3][r4], o4 = e3[1][r4] - e3[2][r4];\n                if (!pM(a4, o4)) return false;\n              }\n              return !pM(e3[0][1], e3[1][1]) && !pM(e3[0][1], e3[3][1]) ? false : !!(JL(e3[0], e3[1]) * JL(e3[0], e3[3]));\n            };\n            ky.pointsOnEllipse = function(e3) {\n              var t3 = e3.length;\n              if (t3 !== W3 + 1) return false;\n              t3 = W3;\n              for (var r4 = 0; r4 < t3; r4++) {\n                var n4 = (t3 * 2 - r4) % t3, i3 = (t3 / 2 + n4) % t3, a4 = (t3 / 2 + r4) % t3;\n                if (!pM(JL(e3[r4], e3[a4]), JL(e3[n4], e3[i3]))) return false;\n              }\n              return true;\n            };\n            ky.handleEllipse = function(e3, t3, r4) {\n              if (!e3) return [t3, r4];\n              var n4 = ky.ellipseOver({ x0: t3[0], y0: t3[1], x1: r4[0], y1: r4[1] }), i3 = (n4.x1 + n4.x0) / 2, a4 = (n4.y1 + n4.y0) / 2, o4 = (n4.x1 - n4.x0) / 2, s3 = (n4.y1 - n4.y0) / 2;\n              o4 || (o4 = s3 = s3 / WB), s3 || (s3 = o4 = o4 / WB);\n              for (var l3 = [], u4 = 0; u4 < W3; u4++) {\n                var c5 = u4 * 2 * Math.PI / W3;\n                l3.push([i3 + o4 * Math.cos(c5), a4 + s3 * Math.sin(c5)]);\n              }\n              return l3;\n            };\n            ky.ellipseOver = function(e3) {\n              var t3 = e3.x0, r4 = e3.y0, n4 = e3.x1, i3 = e3.y1, a4 = n4 - t3, o4 = i3 - r4;\n              t3 -= a4, r4 -= o4;\n              var s3 = (t3 + n4) / 2, l3 = (r4 + i3) / 2, u4 = WB;\n              return a4 *= u4, o4 *= u4, { x0: s3 - a4, y0: l3 - o4, x1: s3 + a4, y1: l3 + o4 };\n            };\n            ky.fixDatesForPaths = function(e3, t3, r4) {\n              var n4 = t3.type === "date", i3 = r4.type === "date";\n              if (!n4 && !i3) return e3;\n              for (var a4 = 0; a4 < e3.length; a4++) for (var o4 = 0; o4 < e3[a4].length; o4++) for (var s3 = 0; s3 + 2 < e3[a4][o4].length; s3 += 2) n4 && (e3[a4][o4][s3 + 1] = e3[a4][o4][s3 + 1].replace(" ", "_")), i3 && (e3[a4][o4][s3 + 2] = e3[a4][o4][s3 + 2].replace(" ", "_"));\n              return e3;\n            };\n          });\n          var eP = ye((Lar, Sue) => {\n            "use strict";\n            var mue = hf(), wue = Eg(), Yut = wue.drawMode, Kut = wue.openMode, X3 = YL(), yue = X3.i000, _ue = X3.i090, xue = X3.i180, bue = X3.i270, Jut = X3.cos45, $ut = X3.sin45, Tue = KL(), $L = Tue.p2r, c_ = Tue.r2p, Qut = Q1(), ect = Qut.clearOutline, QL = u_(), tct = QL.readPaths, rct = QL.writePaths, ict = QL.ellipseOver, nct = QL.fixDatesForPaths;\n            function act(e3, t3) {\n              if (e3.length) {\n                var r4 = e3[0][0];\n                if (r4) {\n                  var n4 = t3.gd, i3 = t3.isActiveShape, a4 = t3.dragmode, o4 = (n4.layout || {}).shapes || [];\n                  if (!Yut(a4) && i3 !== void 0) {\n                    var s3 = n4._fullLayout._activeShapeIndex;\n                    if (s3 < o4.length) switch (n4._fullLayout.shapes[s3].type) {\n                      case "rect":\n                        a4 = "drawrect";\n                        break;\n                      case "circle":\n                        a4 = "drawcircle";\n                        break;\n                      case "line":\n                        a4 = "drawline";\n                        break;\n                      case "path":\n                        var l3 = o4[s3].path || "";\n                        l3[l3.length - 1] === "Z" ? a4 = "drawclosedpath" : a4 = "drawopenpath";\n                        break;\n                    }\n                  }\n                  var u4 = Aue(e3, t3, a4);\n                  ect(n4);\n                  for (var c5 = t3.editHelpers, f4 = (c5 || {}).modifyItem, h3 = [], d3 = 0; d3 < o4.length; d3++) {\n                    var v3 = n4._fullLayout.shapes[d3];\n                    if (h3[d3] = v3._input, i3 !== void 0 && d3 === n4._fullLayout._activeShapeIndex) {\n                      var _2 = u4;\n                      switch (v3.type) {\n                        case "line":\n                        case "rect":\n                        case "circle":\n                          var b = mue.getFromId(n4, v3.xref);\n                          v3.xref.charAt(0) === "x" && b.type.includes("category") ? (f4("x0", _2.x0 - (v3.x0shift || 0)), f4("x1", _2.x1 - (v3.x1shift || 0))) : (f4("x0", _2.x0), f4("x1", _2.x1));\n                          var p3 = mue.getFromId(n4, v3.yref);\n                          v3.yref.charAt(0) === "y" && p3.type.includes("category") ? (f4("y0", _2.y0 - (v3.y0shift || 0)), f4("y1", _2.y1 - (v3.y1shift || 0))) : (f4("y0", _2.y0), f4("y1", _2.y1));\n                          break;\n                        case "path":\n                          f4("path", _2.path);\n                          break;\n                      }\n                    }\n                  }\n                  return i3 === void 0 ? (h3.push(u4), h3) : c5 ? c5.getUpdateObj() : {};\n                }\n              }\n            }\n            function Aue(e3, t3, r4) {\n              var n4 = e3[0][0], i3 = t3.gd, a4 = n4.getAttribute("d"), o4 = i3._fullLayout.newshape, s3 = t3.plotinfo, l3 = t3.isActiveShape, u4 = s3.xaxis, c5 = s3.yaxis, f4 = !!s3.domain || !s3.xaxis, h3 = !!s3.domain || !s3.yaxis, d3 = Kut(r4), v3 = tct(a4, i3, s3, l3), _2 = { editable: true, visible: o4.visible, name: o4.name, showlegend: o4.showlegend, legend: o4.legend, legendwidth: o4.legendwidth, legendgroup: o4.legendgroup, legendgrouptitle: { text: o4.legendgrouptitle.text, font: o4.legendgrouptitle.font }, legendrank: o4.legendrank, label: o4.label, xref: f4 ? "paper" : u4._id, yref: h3 ? "paper" : c5._id, layer: o4.layer, opacity: o4.opacity, line: { color: o4.line.color, width: o4.line.width, dash: o4.line.dash } };\n              d3 || (_2.fillcolor = o4.fillcolor, _2.fillrule = o4.fillrule);\n              var b;\n              if (v3.length === 1 && (b = v3[0]), b && b.length === 5 && r4 === "drawrect") _2.type = "rect", _2.x0 = b[0][1], _2.y0 = b[0][2], _2.x1 = b[2][1], _2.y1 = b[2][2];\n              else if (b && r4 === "drawline") _2.type = "line", _2.x0 = b[0][1], _2.y0 = b[0][2], _2.x1 = b[1][1], _2.y1 = b[1][2];\n              else if (b && r4 === "drawcircle") {\n                _2.type = "circle";\n                var p3 = b[yue][1], k4 = b[_ue][1], E3 = b[xue][1], S2 = b[bue][1], L3 = b[yue][2], x2 = b[_ue][2], C3 = b[xue][2], M4 = b[bue][2], g3 = s3.xaxis && (s3.xaxis.type === "date" || s3.xaxis.type === "log"), P3 = s3.yaxis && (s3.yaxis.type === "date" || s3.yaxis.type === "log");\n                g3 && (p3 = c_(s3.xaxis, p3), k4 = c_(s3.xaxis, k4), E3 = c_(s3.xaxis, E3), S2 = c_(s3.xaxis, S2)), P3 && (L3 = c_(s3.yaxis, L3), x2 = c_(s3.yaxis, x2), C3 = c_(s3.yaxis, C3), M4 = c_(s3.yaxis, M4));\n                var T3 = (k4 + S2) / 2, z3 = (L3 + C3) / 2, O3 = (S2 - k4 + E3 - p3) / 2, V2 = (M4 - x2 + C3 - L3) / 2, G2 = ict({ x0: T3, y0: z3, x1: T3 + O3 * Jut, y1: z3 + V2 * $ut });\n                g3 && (G2.x0 = $L(s3.xaxis, G2.x0), G2.x1 = $L(s3.xaxis, G2.x1)), P3 && (G2.y0 = $L(s3.yaxis, G2.y0), G2.y1 = $L(s3.yaxis, G2.y1)), _2.x0 = G2.x0, _2.y0 = G2.y0, _2.x1 = G2.x1, _2.y1 = G2.y1;\n              } else _2.type = "path", u4 && c5 && nct(v3, u4, c5), _2.path = rct(v3), b = null;\n              return _2;\n            }\n            Sue.exports = { newShapes: act, createShapeObj: Aue };\n          });\n          var ZB = ye((Par, Mue) => {\n            "use strict";\n            var oct = Eg(), sct = oct.selectMode, lct = Q1(), uct = lct.clearOutline, XB = u_(), cct = XB.readPaths, fct = XB.writePaths, hct = XB.fixDatesForPaths;\n            Mue.exports = function(t3, r4) {\n              if (t3.length) {\n                var n4 = t3[0][0];\n                if (n4) {\n                  var i3 = n4.getAttribute("d"), a4 = r4.gd, o4 = a4._fullLayout.newselection, s3 = r4.plotinfo, l3 = s3.xaxis, u4 = s3.yaxis, c5 = r4.isActiveSelection, f4 = r4.dragmode, h3 = (a4.layout || {}).selections || [];\n                  if (!sct(f4) && c5 !== void 0) {\n                    var d3 = a4._fullLayout._activeSelectionIndex;\n                    if (d3 < h3.length) switch (a4._fullLayout.selections[d3].type) {\n                      case "rect":\n                        f4 = "select";\n                        break;\n                      case "path":\n                        f4 = "lasso";\n                        break;\n                    }\n                  }\n                  var v3 = cct(i3, a4, s3, c5), _2 = { xref: l3._id, yref: u4._id, opacity: o4.opacity, line: { color: o4.line.color, width: o4.line.width, dash: o4.line.dash } }, b;\n                  v3.length === 1 && (b = v3[0]), b && b.length === 5 && f4 === "select" ? (_2.type = "rect", _2.x0 = b[0][1], _2.y0 = b[0][2], _2.x1 = b[2][1], _2.y1 = b[2][2]) : (_2.type = "path", l3 && u4 && hct(v3, l3, u4), _2.path = fct(v3), b = null), uct(a4);\n                  for (var p3 = r4.editHelpers, k4 = (p3 || {}).modifyItem, E3 = [], S2 = 0; S2 < h3.length; S2++) {\n                    var L3 = a4._fullLayout.selections[S2];\n                    if (!L3) {\n                      E3[S2] = L3;\n                      continue;\n                    }\n                    if (E3[S2] = L3._input, c5 !== void 0 && S2 === a4._fullLayout._activeSelectionIndex) {\n                      var x2 = _2;\n                      switch (L3.type) {\n                        case "rect":\n                          k4("x0", x2.x0), k4("x1", x2.x1), k4("y0", x2.y0), k4("y1", x2.y1);\n                          break;\n                        case "path":\n                          k4("path", x2.path);\n                          break;\n                      }\n                    }\n                  }\n                  return c5 === void 0 ? (E3.push(_2), E3) : p3 ? p3.getUpdateObj() : {};\n                }\n              }\n            };\n          });\n          var gM = ye((Iar, Eue) => {\n            "use strict";\n            Eue.exports = { segmentRE: /[MLHVQCTSZ][^MLHVQCTSZ]*/g, paramRE: /[^\\s,]+/g, paramIsX: { M: { 0: true, drawn: 0 }, L: { 0: true, drawn: 0 }, H: { 0: true, drawn: 0 }, V: {}, Q: { 0: true, 2: true, drawn: 2 }, C: { 0: true, 2: true, 4: true, drawn: 4 }, T: { 0: true, drawn: 0 }, S: { 0: true, 2: true, drawn: 2 }, Z: {} }, paramIsY: { M: { 1: true, drawn: 1 }, L: { 1: true, drawn: 1 }, H: {}, V: { 0: true, drawn: 0 }, Q: { 1: true, 3: true, drawn: 3 }, C: { 1: true, 3: true, 5: true, drawn: 5 }, T: { 1: true, drawn: 1 }, S: { 1: true, 3: true, drawn: 5 }, Z: {} }, numParams: { M: 2, L: 2, H: 1, V: 1, Q: 4, C: 6, T: 2, S: 4, Z: 0 } };\n          });\n          var f_ = ye((Dd) => {\n            "use strict";\n            var Ob = gM(), kue = Dr(), tP = ho();\n            Dd.rangeToShapePosition = function(e3) {\n              return e3.type === "log" ? e3.r2d : function(t3) {\n                return t3;\n              };\n            };\n            Dd.shapePositionToRange = function(e3) {\n              return e3.type === "log" ? e3.d2r : function(t3) {\n                return t3;\n              };\n            };\n            Dd.decodeDate = function(e3) {\n              return function(t3) {\n                return t3.replace && (t3 = t3.replace("_", " ")), e3(t3);\n              };\n            };\n            Dd.encodeDate = function(e3) {\n              return function(t3) {\n                return e3(t3).replace(" ", "_");\n              };\n            };\n            Dd.extractPathCoords = function(e3, t3, r4) {\n              var n4 = [], i3 = e3.match(Ob.segmentRE);\n              return i3.forEach(function(a4) {\n                var o4 = t3[a4.charAt(0)].drawn;\n                if (o4 !== void 0) {\n                  var s3 = a4.slice(1).match(Ob.paramRE);\n                  if (!(!s3 || s3.length < o4)) {\n                    var l3 = s3[o4], u4 = r4 ? l3 : kue.cleanNumber(l3);\n                    n4.push(u4);\n                  }\n                }\n              }), n4;\n            };\n            Dd.getDataToPixel = function(e3, t3, r4, n4, i3) {\n              var a4 = e3._fullLayout._size, o4;\n              if (t3) if (i3 === "domain") o4 = function(l3) {\n                return t3._length * (n4 ? 1 - l3 : l3) + t3._offset;\n              };\n              else {\n                var s3 = Dd.shapePositionToRange(t3);\n                o4 = function(l3) {\n                  var u4 = mM(t3, r4);\n                  return t3._offset + t3.r2p(s3(l3, true)) + u4;\n                }, t3.type === "date" && (o4 = Dd.decodeDate(o4));\n              }\n              else n4 ? o4 = function(l3) {\n                return a4.t + a4.h * (1 - l3);\n              } : o4 = function(l3) {\n                return a4.l + a4.w * l3;\n              };\n              return o4;\n            };\n            Dd.getPixelToData = function(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout._size, a4;\n              if (t3) if (n4 === "domain") a4 = function(s3) {\n                var l3 = (s3 - t3._offset) / t3._length;\n                return r4 ? 1 - l3 : l3;\n              };\n              else {\n                var o4 = Dd.rangeToShapePosition(t3);\n                a4 = function(s3) {\n                  return o4(t3.p2r(s3 - t3._offset));\n                };\n              }\n              else r4 ? a4 = function(s3) {\n                return 1 - (s3 - i3.t) / i3.h;\n              } : a4 = function(s3) {\n                return (s3 - i3.l) / i3.w;\n              };\n              return a4;\n            };\n            Dd.roundPositionForSharpStrokeRendering = function(e3, t3) {\n              var r4 = Math.round(t3 % 2) === 1, n4 = Math.round(e3);\n              return r4 ? n4 + 0.5 : n4;\n            };\n            Dd.makeShapesOptionsAndPlotinfo = function(e3, t3) {\n              var r4 = e3._fullLayout.shapes[t3] || {}, n4 = e3._fullLayout._plots[r4.xref + r4.yref], i3 = !!n4;\n              return i3 ? n4._hadPlotinfo = true : (n4 = {}, r4.xref && r4.xref !== "paper" && (n4.xaxis = e3._fullLayout[r4.xref + "axis"]), r4.yref && r4.yref !== "paper" && (n4.yaxis = e3._fullLayout[r4.yref + "axis"])), n4.xsizemode = r4.xsizemode, n4.ysizemode = r4.ysizemode, n4.xanchor = r4.xanchor, n4.yanchor = r4.yanchor, { options: r4, plotinfo: n4 };\n            };\n            Dd.makeSelectionsOptionsAndPlotinfo = function(e3, t3) {\n              var r4 = e3._fullLayout.selections[t3] || {}, n4 = e3._fullLayout._plots[r4.xref + r4.yref], i3 = !!n4;\n              return i3 ? n4._hadPlotinfo = true : (n4 = {}, r4.xref && (n4.xaxis = e3._fullLayout[r4.xref + "axis"]), r4.yref && (n4.yaxis = e3._fullLayout[r4.yref + "axis"])), { options: r4, plotinfo: n4 };\n            };\n            Dd.getPathString = function(e3, t3) {\n              var r4 = t3.type, n4 = tP.getRefType(t3.xref), i3 = tP.getRefType(t3.yref), a4 = tP.getFromId(e3, t3.xref), o4 = tP.getFromId(e3, t3.yref), s3 = e3._fullLayout._size, l3, u4, c5, f4, h3 = mM(a4, t3.x0shift), d3 = mM(a4, t3.x1shift), v3 = mM(o4, t3.y0shift), _2 = mM(o4, t3.y1shift), b, p3, k4, E3;\n              if (a4 ? n4 === "domain" ? u4 = function(O3) {\n                return a4._offset + a4._length * O3;\n              } : (l3 = Dd.shapePositionToRange(a4), u4 = function(O3) {\n                return a4._offset + a4.r2p(l3(O3, true));\n              }) : u4 = function(O3) {\n                return s3.l + s3.w * O3;\n              }, o4 ? i3 === "domain" ? f4 = function(O3) {\n                return o4._offset + o4._length * (1 - O3);\n              } : (c5 = Dd.shapePositionToRange(o4), f4 = function(O3) {\n                return o4._offset + o4.r2p(c5(O3, true));\n              }) : f4 = function(O3) {\n                return s3.t + s3.h * (1 - O3);\n              }, r4 === "path") return a4 && a4.type === "date" && (u4 = Dd.decodeDate(u4)), o4 && o4.type === "date" && (f4 = Dd.decodeDate(f4)), dct(t3, u4, f4);\n              if (t3.xsizemode === "pixel") {\n                var S2 = u4(t3.xanchor);\n                b = S2 + t3.x0 + h3, p3 = S2 + t3.x1 + d3;\n              } else b = u4(t3.x0) + h3, p3 = u4(t3.x1) + d3;\n              if (t3.ysizemode === "pixel") {\n                var L3 = f4(t3.yanchor);\n                k4 = L3 - t3.y0 + v3, E3 = L3 - t3.y1 + _2;\n              } else k4 = f4(t3.y0) + v3, E3 = f4(t3.y1) + _2;\n              if (r4 === "line") return "M" + b + "," + k4 + "L" + p3 + "," + E3;\n              if (r4 === "rect") return "M" + b + "," + k4 + "H" + p3 + "V" + E3 + "H" + b + "Z";\n              var x2 = (b + p3) / 2, C3 = (k4 + E3) / 2, M4 = Math.abs(x2 - b), g3 = Math.abs(C3 - k4), P3 = "A" + M4 + "," + g3, T3 = x2 + M4 + "," + C3, z3 = x2 + "," + (C3 - g3);\n              return "M" + T3 + P3 + " 0 1,1 " + z3 + P3 + " 0 0,1 " + T3 + "Z";\n            };\n            function dct(e3, t3, r4) {\n              var n4 = e3.path, i3 = e3.xsizemode, a4 = e3.ysizemode, o4 = e3.xanchor, s3 = e3.yanchor;\n              return n4.replace(Ob.segmentRE, function(l3) {\n                var u4 = 0, c5 = l3.charAt(0), f4 = Ob.paramIsX[c5], h3 = Ob.paramIsY[c5], d3 = Ob.numParams[c5], v3 = l3.slice(1).replace(Ob.paramRE, function(_2) {\n                  return f4[u4] ? i3 === "pixel" ? _2 = t3(o4) + Number(_2) : _2 = t3(_2) : h3[u4] && (a4 === "pixel" ? _2 = r4(s3) - Number(_2) : _2 = r4(_2)), u4++, u4 > d3 && (_2 = "X"), _2;\n                });\n                return u4 > d3 && (v3 = v3.replace(/[\\s,]*X.*/, ""), kue.log("Ignoring extra params in segment " + l3)), c5 + v3;\n              });\n            }\n            function mM(e3, t3) {\n              t3 = t3 || 0;\n              var r4 = 0;\n              return t3 && e3 && (e3.type === "category" || e3.type === "multicategory") && (r4 = (e3.r2p(1) - e3.r2p(0)) * t3), r4;\n            }\n          });\n          var KB = ye((Dar, Iue) => {\n            "use strict";\n            var vct = Dr(), Z3 = ho(), Cue = ru(), Lue = So(), pct = u_().readPaths, YB = f_(), gct = YB.getPathString, Pue = M6(), mct = $h().FROM_TL;\n            Iue.exports = function(t3, r4, n4, i3) {\n              if (i3.selectAll(".shape-label").remove(), !!(n4.label.text || n4.label.texttemplate)) {\n                var a4;\n                if (n4.label.texttemplate) {\n                  var o4 = {};\n                  if (n4.type !== "path") {\n                    var s3 = Z3.getFromId(t3, n4.xref), l3 = Z3.getFromId(t3, n4.yref);\n                    for (var u4 in Pue) {\n                      var c5 = Pue[u4](n4, s3, l3);\n                      c5 !== void 0 && (o4[u4] = c5);\n                    }\n                  }\n                  a4 = vct.texttemplateStringForShapes({ data: [o4], fallback: n4.label.texttemplatefallback, locale: t3._fullLayout._d3locale, template: n4.label.texttemplate });\n                } else a4 = n4.label.text;\n                var f4 = { "data-index": r4 }, h3 = n4.label.font, d3 = { "data-notex": 1 }, v3 = i3.append("g").attr(f4).classed("shape-label", true), _2 = v3.append("text").attr(d3).classed("shape-label-text", true).text(a4), b, p3, k4, E3;\n                if (n4.path) {\n                  var S2 = gct(t3, n4), L3 = pct(S2, t3);\n                  b = 1 / 0, k4 = 1 / 0, p3 = -1 / 0, E3 = -1 / 0;\n                  for (var x2 = 0; x2 < L3.length; x2++) for (var C3 = 0; C3 < L3[x2].length; C3++) for (var M4 = L3[x2][C3], g3 = 1; g3 < M4.length; g3 += 2) {\n                    var P3 = M4[g3], T3 = M4[g3 + 1];\n                    b = Math.min(b, P3), p3 = Math.max(p3, P3), k4 = Math.min(k4, T3), E3 = Math.max(E3, T3);\n                  }\n                } else {\n                  var z3 = Z3.getFromId(t3, n4.xref), O3 = n4.x0shift, V2 = n4.x1shift, G2 = Z3.getRefType(n4.xref), Z = Z3.getFromId(t3, n4.yref), j3 = n4.y0shift, N2 = n4.y1shift, H = Z3.getRefType(n4.yref), te = function(Le, Ae) {\n                    var Fe = YB.getDataToPixel(t3, z3, Ae, false, G2);\n                    return Fe(Le);\n                  }, oe = function(Le, Ae) {\n                    var Fe = YB.getDataToPixel(t3, Z, Ae, true, H);\n                    return Fe(Le);\n                  };\n                  b = te(n4.x0, O3), p3 = te(n4.x1, V2), k4 = oe(n4.y0, j3), E3 = oe(n4.y1, N2);\n                }\n                var _e = n4.label.textangle;\n                _e === "auto" && (n4.type === "line" ? _e = yct(b, k4, p3, E3) : _e = 0), _2.call(function(Le) {\n                  return Le.call(Lue.font, h3).attr({}), Cue.convertToTspans(Le, t3), Le;\n                });\n                var Ee = Lue.bBox(_2.node()), Ce = _ct(b, k4, p3, E3, n4, _e, Ee), me = Ce.textx, ie = Ce.texty, Se = Ce.xanchor;\n                _2.attr({ "text-anchor": { left: "start", center: "middle", right: "end" }[Se], y: ie, x: me, transform: "rotate(" + _e + "," + me + "," + ie + ")" }).call(Cue.positionText, me, ie);\n              }\n            };\n            function yct(e3, t3, r4, n4) {\n              var i3, a4;\n              return a4 = Math.abs(r4 - e3), r4 >= e3 ? i3 = t3 - n4 : i3 = n4 - t3, -180 / Math.PI * Math.atan2(i3, a4);\n            }\n            function _ct(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = i3.label.textposition, l3 = i3.label.textangle, u4 = i3.label.padding, c5 = i3.type, f4 = Math.PI / 180 * a4, h3 = Math.sin(f4), d3 = Math.cos(f4), v3 = i3.label.xanchor, _2 = i3.label.yanchor, b, p3, k4, E3;\n              if (c5 === "line") {\n                s3 === "start" ? (b = e3, p3 = t3) : s3 === "end" ? (b = r4, p3 = n4) : (b = (e3 + r4) / 2, p3 = (t3 + n4) / 2), v3 === "auto" && (s3 === "start" ? l3 === "auto" ? r4 > e3 ? v3 = "left" : r4 < e3 ? v3 = "right" : v3 = "center" : r4 > e3 ? v3 = "right" : r4 < e3 ? v3 = "left" : v3 = "center" : s3 === "end" ? l3 === "auto" ? r4 > e3 ? v3 = "right" : r4 < e3 ? v3 = "left" : v3 = "center" : r4 > e3 ? v3 = "left" : r4 < e3 ? v3 = "right" : v3 = "center" : v3 = "center");\n                var S2 = { left: 1, center: 0, right: -1 }, L3 = { bottom: -1, middle: 0, top: 1 };\n                if (l3 === "auto") {\n                  var x2 = L3[_2];\n                  k4 = -u4 * h3 * x2, E3 = u4 * d3 * x2;\n                } else {\n                  var C3 = S2[v3], M4 = L3[_2];\n                  k4 = u4 * C3, E3 = u4 * M4;\n                }\n                b = b + k4, p3 = p3 + E3;\n              } else k4 = u4 + 3, s3.indexOf("right") !== -1 ? (b = Math.max(e3, r4) - k4, v3 === "auto" && (v3 = "right")) : s3.indexOf("left") !== -1 ? (b = Math.min(e3, r4) + k4, v3 === "auto" && (v3 = "left")) : (b = (e3 + r4) / 2, v3 === "auto" && (v3 = "center")), s3.indexOf("top") !== -1 ? p3 = Math.min(t3, n4) : s3.indexOf("bottom") !== -1 ? p3 = Math.max(t3, n4) : p3 = (t3 + n4) / 2, E3 = u4, _2 === "bottom" ? p3 = p3 - E3 : _2 === "top" && (p3 = p3 + E3);\n              var g3 = mct[_2], P3 = i3.label.font.size, T3 = o4.height, z3 = (T3 * g3 - P3) * h3, O3 = -(T3 * g3 - P3) * d3;\n              return { textx: b + z3, texty: p3 + O3, xanchor: v3 };\n            }\n          });\n          var nP = ye((Far, Nue) => {\n            "use strict";\n            var xct = Dr(), bct = xct.strTranslate, Rue = yv(), zue = Eg(), wct = zue.drawMode, Oue = zue.selectMode, que = qa(), Due = ka(), iP = YL(), Tct = iP.i000, Act = iP.i090, Sct = iP.i180, Mct = iP.i270, Ect = Q1(), Bue = Ect.clearOutlineControllers, $B = u_(), rP = $B.pointsOnRectangle, JB = $B.pointsOnEllipse, kct = $B.writePaths, Cct = eP().newShapes, Lct = eP().createShapeObj, Pct = ZB(), Ict = KB();\n            Nue.exports = function e3(t3, r4, n4, i3) {\n              i3 || (i3 = 0);\n              var a4 = n4.gd;\n              function o4() {\n                e3(t3, r4, n4, i3++), (JB(t3[0]) || n4.hasText) && s3({ redrawing: true });\n              }\n              function s3(j3) {\n                var N2 = {};\n                n4.isActiveShape !== void 0 && (n4.isActiveShape = false, N2 = Cct(r4, n4)), n4.isActiveSelection !== void 0 && (n4.isActiveSelection = false, N2 = Pct(r4, n4), a4._fullLayout._reselect = true), Object.keys(N2).length && que.call((j3 || {}).redrawing ? "relayout" : "_guiRelayout", a4, N2);\n              }\n              var l3 = a4._fullLayout, u4 = l3._zoomlayer, c5 = n4.dragmode, f4 = wct(c5), h3 = Oue(c5);\n              (f4 || h3) && (a4._fullLayout._outlining = true), Bue(a4), r4.attr("d", kct(t3));\n              var d3, v3, _2, b, p3;\n              if (!i3 && (n4.isActiveShape || n4.isActiveSelection)) {\n                p3 = Rct([], t3);\n                var k4 = u4.append("g").attr("class", "outline-controllers");\n                P3(k4), Z();\n              }\n              if (f4 && n4.hasText) {\n                var E3 = u4.select(".label-temp"), S2 = Lct(r4, n4, n4.dragmode);\n                Ict(a4, "label-temp", S2, E3);\n              }\n              function L3(j3) {\n                _2 = +j3.srcElement.getAttribute("data-i"), b = +j3.srcElement.getAttribute("data-j"), d3[_2][b].moveFn = x2;\n              }\n              function x2(j3, N2) {\n                if (t3.length) {\n                  var H = p3[_2][b][1], te = p3[_2][b][2], oe = t3[_2], _e = oe.length;\n                  if (rP(oe)) {\n                    var Ee = j3, Ce = N2;\n                    if (n4.isActiveSelection) {\n                      var me = Fue(oe, b);\n                      me[1] === oe[b][1] ? Ce = 0 : Ee = 0;\n                    }\n                    for (var ie = 0; ie < _e; ie++) if (ie !== b) {\n                      var Se = oe[ie];\n                      Se[1] === oe[b][1] && (Se[1] = H + Ee), Se[2] === oe[b][2] && (Se[2] = te + Ce);\n                    }\n                    if (oe[b][1] = H + Ee, oe[b][2] = te + Ce, !rP(oe)) for (var Le = 0; Le < _e; Le++) for (var Ae = 0; Ae < oe[Le].length; Ae++) oe[Le][Ae] = p3[_2][Le][Ae];\n                  } else oe[b][1] = H + j3, oe[b][2] = te + N2;\n                  o4();\n                }\n              }\n              function C3() {\n                s3();\n              }\n              function M4() {\n                if (t3.length && t3[_2] && t3[_2].length) {\n                  for (var j3 = [], N2 = 0; N2 < t3[_2].length; N2++) N2 !== b && j3.push(t3[_2][N2]);\n                  j3.length > 1 && !(j3.length === 2 && j3[1][0] === "Z") && (b === 0 && (j3[0][0] = "M"), t3[_2] = j3, o4(), s3());\n                }\n              }\n              function g3(j3, N2) {\n                if (j3 === 2) {\n                  _2 = +N2.srcElement.getAttribute("data-i"), b = +N2.srcElement.getAttribute("data-j");\n                  var H = t3[_2];\n                  !rP(H) && !JB(H) && M4();\n                }\n              }\n              function P3(j3) {\n                d3 = [];\n                for (var N2 = 0; N2 < t3.length; N2++) {\n                  var H = t3[N2], te = rP(H), oe = !te && JB(H);\n                  d3[N2] = [];\n                  for (var _e = H.length, Ee = 0; Ee < _e; Ee++) if (H[Ee][0] !== "Z" && !(oe && Ee !== Tct && Ee !== Act && Ee !== Sct && Ee !== Mct)) {\n                    var Ce = te && n4.isActiveSelection, me;\n                    Ce && (me = Fue(H, Ee));\n                    var ie = H[Ee][1], Se = H[Ee][2], Le = j3.append(Ce ? "rect" : "circle").attr("data-i", N2).attr("data-j", Ee).style({ fill: Due.background, stroke: Due.defaultLine, "stroke-width": 1, "shape-rendering": "crispEdges" });\n                    if (Ce) {\n                      var Ae = me[1] - ie, Fe = me[2] - Se, Pe = Fe ? 5 : Math.max(Math.min(25, Math.abs(Ae) - 5), 5), ge = Ae ? 5 : Math.max(Math.min(25, Math.abs(Fe) - 5), 5);\n                      Le.classed(Fe ? "cursor-ew-resize" : "cursor-ns-resize", true).attr("width", Pe).attr("height", ge).attr("x", ie - Pe / 2).attr("y", Se - ge / 2).attr("transform", bct(Ae / 2, Fe / 2));\n                    } else Le.classed("cursor-grab", true).attr("r", 5).attr("cx", ie).attr("cy", Se);\n                    d3[N2][Ee] = { element: Le.node(), gd: a4, prepFn: L3, doneFn: C3, clickFn: g3 }, Rue.init(d3[N2][Ee]);\n                  }\n                }\n              }\n              function T3(j3, N2) {\n                if (t3.length) for (var H = 0; H < t3.length; H++) for (var te = 0; te < t3[H].length; te++) for (var oe = 0; oe + 2 < t3[H][te].length; oe += 2) t3[H][te][oe + 1] = p3[H][te][oe + 1] + j3, t3[H][te][oe + 2] = p3[H][te][oe + 2] + N2;\n              }\n              function z3(j3, N2) {\n                T3(j3, N2), o4();\n              }\n              function O3(j3) {\n                _2 = +j3.srcElement.getAttribute("data-i"), _2 || (_2 = 0), v3[_2].moveFn = z3;\n              }\n              function V2() {\n                s3();\n              }\n              function G2(j3) {\n                j3 === 2 && Dct(a4);\n              }\n              function Z() {\n                if (v3 = [], !!t3.length) {\n                  var j3 = 0;\n                  v3[j3] = { element: r4[0][0], gd: a4, prepFn: O3, doneFn: V2, clickFn: G2 }, Rue.init(v3[j3]);\n                }\n              }\n            };\n            function Rct(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                e3[r4] = [];\n                for (var i3 = 0; i3 < n4.length; i3++) {\n                  e3[r4][i3] = [];\n                  for (var a4 = 0; a4 < n4[i3].length; a4++) e3[r4][i3][a4] = n4[i3][a4];\n                }\n              }\n              return e3;\n            }\n            function Fue(e3, t3) {\n              var r4 = e3[t3][1], n4 = e3[t3][2], i3 = e3.length, a4, o4, s3;\n              return a4 = (t3 + 1) % i3, o4 = e3[a4][1], s3 = e3[a4][2], o4 === r4 && s3 === n4 && (a4 = (t3 + 2) % i3, o4 = e3[a4][1], s3 = e3[a4][2]), [a4, o4, s3];\n            }\n            function Dct(e3) {\n              if (Oue(e3._fullLayout.dragmode)) {\n                Bue(e3);\n                var t3 = e3._fullLayout._activeSelectionIndex, r4 = (e3.layout || {}).selections || [];\n                if (t3 < r4.length) {\n                  for (var n4 = [], i3 = 0; i3 < r4.length; i3++) i3 !== t3 && n4.push(r4[i3]);\n                  delete e3._fullLayout._activeSelectionIndex;\n                  var a4 = e3._fullLayout.selections[t3];\n                  e3._fullLayout._deselect = { xref: a4.xref, yref: a4.yref }, que.call("_guiRelayout", e3, { selections: n4 });\n                }\n              }\n            }\n          });\n          var lP = ye((zar, Kue) => {\n            "use strict";\n            var Fct = Oa(), Wue = qa(), Uue = Dr(), Y3 = ho(), zct = u_().readPaths, Oct = nP(), oP = KB(), Xue = Q1().clearOutlineControllers, QB = ka(), tN = So(), qct = vl().arrayEditor, Vue = yv(), Gue = Sg(), qb = gM(), Ep = f_(), eN = Ep.getPathString;\n            Kue.exports = { draw: rN, drawOne: Zue, eraseActiveShape: Uct, drawLabel: oP };\n            function rN(e3) {\n              var t3 = e3._fullLayout;\n              t3._shapeUpperLayer.selectAll("path").remove(), t3._shapeLowerLayer.selectAll("path").remove(), t3._shapeUpperLayer.selectAll("text").remove(), t3._shapeLowerLayer.selectAll("text").remove();\n              for (var r4 in t3._plots) {\n                var n4 = t3._plots[r4].shapelayer;\n                n4 && (n4.selectAll("path").remove(), n4.selectAll("text").remove());\n              }\n              for (var i3 = 0; i3 < t3.shapes.length; i3++) t3.shapes[i3].visible === true && Zue(e3, i3);\n            }\n            function aP(e3) {\n              return !!e3._fullLayout._outlining;\n            }\n            function sP(e3) {\n              return !e3._context.edits.shapePosition;\n            }\n            function Zue(e3, t3) {\n              e3._fullLayout._paperdiv.selectAll(\'.shapelayer [data-index="\' + t3 + \'"]\').remove();\n              var r4 = Ep.makeShapesOptionsAndPlotinfo(e3, t3), n4 = r4.options, i3 = r4.plotinfo;\n              if (!n4._input || n4.visible !== true) return;\n              if (n4.layer === "above") o4(e3._fullLayout._shapeUpperLayer);\n              else if (n4.xref === "paper" || n4.yref === "paper") o4(e3._fullLayout._shapeLowerLayer);\n              else if (n4.layer === "between") o4(i3.shapelayerBetween);\n              else if (i3._hadPlotinfo) {\n                var a4 = i3.mainplotinfo || i3;\n                o4(a4.shapelayer);\n              } else o4(e3._fullLayout._shapeLowerLayer);\n              function o4(s3) {\n                var l3 = eN(e3, n4), u4 = { "data-index": t3, "fill-rule": n4.fillrule, d: l3 }, c5 = n4.opacity, f4 = n4.fillcolor, h3 = n4.line.width ? n4.line.color : "rgba(0,0,0,0)", d3 = n4.line.width, v3 = n4.line.dash;\n                !d3 && n4.editable === true && (d3 = 5, v3 = "solid");\n                var _2 = l3[l3.length - 1] !== "Z", b = sP(e3) && n4.editable && e3._fullLayout._activeShapeIndex === t3;\n                b && (f4 = _2 ? "rgba(0,0,0,0)" : e3._fullLayout.activeshape.fillcolor, c5 = e3._fullLayout.activeshape.opacity);\n                var p3 = s3.append("g").classed("shape-group", true).attr({ "data-index": t3 }), k4 = p3.append("path").attr(u4).style("opacity", c5).call(QB.stroke, h3).call(QB.fill, f4).call(tN.dashLine, v3, d3);\n                Yue(p3, e3, n4), oP(e3, t3, n4, p3);\n                var E3;\n                if ((b || e3._context.edits.shapePosition) && (E3 = qct(e3.layout, "shapes", n4)), b) {\n                  k4.style({ cursor: "move" });\n                  var S2 = { element: k4.node(), plotinfo: i3, gd: e3, editHelpers: E3, hasText: n4.label.text || n4.label.texttemplate, isActiveShape: true }, L3 = zct(l3, e3);\n                  Oct(L3, k4, S2);\n                } else e3._context.edits.shapePosition ? Bct(e3, k4, n4, t3, s3, E3) : n4.editable === true && k4.style("pointer-events", _2 || QB.opacity(f4) * c5 <= 0.5 ? "stroke" : "all");\n                k4.node().addEventListener("click", function() {\n                  return Nct(e3, k4);\n                });\n              }\n            }\n            function Yue(e3, t3, r4) {\n              var n4 = (r4.xref + r4.yref).replace(/paper/g, "").replace(/[xyz][0-9]* *domain/g, "");\n              tN.setClipUrl(e3, n4 ? "clip" + t3._fullLayout._uid + n4 : null, t3);\n            }\n            function Bct(e3, t3, r4, n4, i3, a4) {\n              var o4 = 10, s3 = 10, l3 = r4.xsizemode === "pixel", u4 = r4.ysizemode === "pixel", c5 = r4.type === "line", f4 = r4.type === "path", h3 = a4.modifyItem, d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4, g3, P3, T3, z3 = Fct.select(t3.node().parentNode), O3 = Y3.getFromId(e3, r4.xref), V2 = Y3.getRefType(r4.xref), G2 = Y3.getFromId(e3, r4.yref), Z = Y3.getRefType(r4.yref), j3 = r4.x0shift, N2 = r4.x1shift, H = r4.y0shift, te = r4.y1shift, oe = function(st, lt) {\n                var Gt = Ep.getDataToPixel(e3, O3, lt, false, V2);\n                return Gt(st);\n              }, _e = function(st, lt) {\n                var Gt = Ep.getDataToPixel(e3, G2, lt, true, Z);\n                return Gt(st);\n              }, Ee = Ep.getPixelToData(e3, O3, false, V2), Ce = Ep.getPixelToData(e3, G2, true, Z), me = Le(), ie = { element: me.node(), gd: e3, prepFn: Pe, doneFn: ge, clickFn: Re }, Se;\n              Vue.init(ie), me.node().onmousemove = Fe;\n              function Le() {\n                return c5 ? Ae() : t3;\n              }\n              function Ae() {\n                var st = 10, lt = Math.max(r4.line.width, st), Gt = i3.append("g").attr("data-index", n4).attr("drag-helper", true);\n                Gt.append("path").attr("d", t3.attr("d")).style({ cursor: "move", "stroke-width": lt, "stroke-opacity": "0" });\n                var Nt = { "fill-opacity": "0" }, Jt = Math.max(lt / 2, st);\n                return Gt.append("circle").attr({ "data-line-point": "start-point", cx: l3 ? oe(r4.xanchor) + r4.x0 : oe(r4.x0, j3), cy: u4 ? _e(r4.yanchor) - r4.y0 : _e(r4.y0, H), r: Jt }).style(Nt).classed("cursor-grab", true), Gt.append("circle").attr({ "data-line-point": "end-point", cx: l3 ? oe(r4.xanchor) + r4.x1 : oe(r4.x1, N2), cy: u4 ? _e(r4.yanchor) - r4.y1 : _e(r4.y1, te), r: Jt }).style(Nt).classed("cursor-grab", true), Gt;\n              }\n              function Fe(st) {\n                if (aP(e3)) {\n                  Se = null;\n                  return;\n                }\n                if (c5) st.target.tagName === "path" ? Se = "move" : Se = st.target.attributes["data-line-point"].value === "start-point" ? "resize-over-start-point" : "resize-over-end-point";\n                else {\n                  var lt = ie.element.getBoundingClientRect(), Gt = lt.right - lt.left, Nt = lt.bottom - lt.top, Jt = st.clientX - lt.left, sr = st.clientY - lt.top, wr = !f4 && Gt > o4 && Nt > s3 && !st.shiftKey ? Vue.getCursor(Jt / Gt, 1 - sr / Nt) : "move";\n                  Gue(t3, wr), Se = wr.split("-")[0];\n                }\n              }\n              function Pe(st) {\n                aP(e3) || (l3 && (p3 = oe(r4.xanchor)), u4 && (k4 = _e(r4.yanchor)), r4.type === "path" ? T3 = r4.path : (d3 = l3 ? r4.x0 : oe(r4.x0), v3 = u4 ? r4.y0 : _e(r4.y0), _2 = l3 ? r4.x1 : oe(r4.x1), b = u4 ? r4.y1 : _e(r4.y1)), d3 < _2 ? (L3 = d3, g3 = "x0", x2 = _2, P3 = "x1") : (L3 = _2, g3 = "x1", x2 = d3, P3 = "x0"), !u4 && v3 < b || u4 && v3 > b ? (E3 = v3, C3 = "y0", S2 = b, M4 = "y1") : (E3 = b, C3 = "y1", S2 = v3, M4 = "y0"), Fe(st), ut(i3, r4), Zt(t3, r4, e3), ie.moveFn = Se === "move" ? ce : Ze, ie.altKey = st.altKey);\n              }\n              function ge() {\n                aP(e3) || (Gue(t3), pt(i3), Yue(t3, e3, r4), Wue.call("_guiRelayout", e3, a4.getUpdateObj()));\n              }\n              function Re() {\n                aP(e3) || pt(i3);\n              }\n              function ce(st, lt) {\n                if (r4.type === "path") {\n                  var Gt = function(sr) {\n                    return sr;\n                  }, Nt = Gt, Jt = Gt;\n                  l3 ? h3("xanchor", r4.xanchor = Ee(p3 + st)) : (Nt = function(wr) {\n                    return Ee(oe(wr) + st);\n                  }, O3 && O3.type === "date" && (Nt = Ep.encodeDate(Nt))), u4 ? h3("yanchor", r4.yanchor = Ce(k4 + lt)) : (Jt = function(wr) {\n                    return Ce(_e(wr) + lt);\n                  }, G2 && G2.type === "date" && (Jt = Ep.encodeDate(Jt))), h3("path", r4.path = Hue(T3, Nt, Jt));\n                } else l3 ? h3("xanchor", r4.xanchor = Ee(p3 + st)) : (h3("x0", r4.x0 = Ee(d3 + st)), h3("x1", r4.x1 = Ee(_2 + st))), u4 ? h3("yanchor", r4.yanchor = Ce(k4 + lt)) : (h3("y0", r4.y0 = Ce(v3 + lt)), h3("y1", r4.y1 = Ce(b + lt)));\n                t3.attr("d", eN(e3, r4)), ut(i3, r4), oP(e3, n4, r4, z3);\n              }\n              function Ze(st, lt) {\n                if (f4) {\n                  var Gt = function(Lr) {\n                    return Lr;\n                  }, Nt = Gt, Jt = Gt;\n                  l3 ? h3("xanchor", r4.xanchor = Ee(p3 + st)) : (Nt = function(ti) {\n                    return Ee(oe(ti) + st);\n                  }, O3 && O3.type === "date" && (Nt = Ep.encodeDate(Nt))), u4 ? h3("yanchor", r4.yanchor = Ce(k4 + lt)) : (Jt = function(ti) {\n                    return Ce(_e(ti) + lt);\n                  }, G2 && G2.type === "date" && (Jt = Ep.encodeDate(Jt))), h3("path", r4.path = Hue(T3, Nt, Jt));\n                } else if (c5) {\n                  if (Se === "resize-over-start-point") {\n                    var sr = d3 + st, wr = u4 ? v3 - lt : v3 + lt;\n                    h3("x0", r4.x0 = l3 ? sr : Ee(sr)), h3("y0", r4.y0 = u4 ? wr : Ce(wr));\n                  } else if (Se === "resize-over-end-point") {\n                    var cr = _2 + st, $e = u4 ? b - lt : b + lt;\n                    h3("x1", r4.x1 = l3 ? cr : Ee(cr)), h3("y1", r4.y1 = u4 ? $e : Ce($e));\n                  }\n                } else {\n                  var St = function(Lr) {\n                    return Se.indexOf(Lr) !== -1;\n                  }, Qt = St("n"), Vt = St("s"), _t = St("w"), It = St("e"), mt = Qt ? E3 + lt : E3, er = Vt ? S2 + lt : S2, lr = _t ? L3 + st : L3, Tr = It ? x2 + st : x2;\n                  u4 && (Qt && (mt = E3 - lt), Vt && (er = S2 - lt)), (!u4 && er - mt > s3 || u4 && mt - er > s3) && (h3(C3, r4[C3] = u4 ? mt : Ce(mt)), h3(M4, r4[M4] = u4 ? er : Ce(er))), Tr - lr > o4 && (h3(g3, r4[g3] = l3 ? lr : Ee(lr)), h3(P3, r4[P3] = l3 ? Tr : Ee(Tr)));\n                }\n                t3.attr("d", eN(e3, r4)), ut(i3, r4), oP(e3, n4, r4, z3);\n              }\n              function ut(st, lt) {\n                (l3 || u4) && Gt();\n                function Gt() {\n                  var Nt = lt.type !== "path", Jt = st.selectAll(".visual-cue").data([0]), sr = 1;\n                  Jt.enter().append("path").attr({ fill: "#fff", "fill-rule": "evenodd", stroke: "#000", "stroke-width": sr }).classed("visual-cue", true);\n                  var wr = oe(l3 ? lt.xanchor : Uue.midRange(Nt ? [lt.x0, lt.x1] : Ep.extractPathCoords(lt.path, qb.paramIsX))), cr = _e(u4 ? lt.yanchor : Uue.midRange(Nt ? [lt.y0, lt.y1] : Ep.extractPathCoords(lt.path, qb.paramIsY)));\n                  if (wr = Ep.roundPositionForSharpStrokeRendering(wr, sr), cr = Ep.roundPositionForSharpStrokeRendering(cr, sr), l3 && u4) {\n                    var $e = "M" + (wr - 1 - sr) + "," + (cr - 1 - sr) + "h-8v2h8 v8h2v-8 h8v-2h-8 v-8h-2 Z";\n                    Jt.attr("d", $e);\n                  } else if (l3) {\n                    var St = "M" + (wr - 1 - sr) + "," + (cr - 9 - sr) + "v18 h2 v-18 Z";\n                    Jt.attr("d", St);\n                  } else {\n                    var Qt = "M" + (wr - 9 - sr) + "," + (cr - 1 - sr) + "h18 v2 h-18 Z";\n                    Jt.attr("d", Qt);\n                  }\n                }\n              }\n              function pt(st) {\n                st.selectAll(".visual-cue").remove();\n              }\n              function Zt(st, lt, Gt) {\n                var Nt = lt.xref, Jt = lt.yref, sr = Y3.getFromId(Gt, Nt), wr = Y3.getFromId(Gt, Jt), cr = "";\n                Nt !== "paper" && !sr.autorange && (cr += Nt), Jt !== "paper" && !wr.autorange && (cr += Jt), tN.setClipUrl(st, cr ? "clip" + Gt._fullLayout._uid + cr : null, Gt);\n              }\n            }\n            function Hue(e3, t3, r4) {\n              return e3.replace(qb.segmentRE, function(n4) {\n                var i3 = 0, a4 = n4.charAt(0), o4 = qb.paramIsX[a4], s3 = qb.paramIsY[a4], l3 = qb.numParams[a4], u4 = n4.slice(1).replace(qb.paramRE, function(c5) {\n                  return i3 >= l3 || (o4[i3] ? c5 = t3(c5) : s3[i3] && (c5 = r4(c5)), i3++), c5;\n                });\n                return a4 + u4;\n              });\n            }\n            function Nct(e3, t3) {\n              if (sP(e3)) {\n                var r4 = t3.node(), n4 = +r4.getAttribute("data-index");\n                if (n4 >= 0) {\n                  if (n4 === e3._fullLayout._activeShapeIndex) {\n                    jue(e3);\n                    return;\n                  }\n                  e3._fullLayout._activeShapeIndex = n4, e3._fullLayout._deactivateShape = jue, rN(e3);\n                }\n              }\n            }\n            function jue(e3) {\n              if (sP(e3)) {\n                var t3 = e3._fullLayout._activeShapeIndex;\n                t3 >= 0 && (Xue(e3), delete e3._fullLayout._activeShapeIndex, rN(e3));\n              }\n            }\n            function Uct(e3) {\n              if (sP(e3)) {\n                Xue(e3);\n                var t3 = e3._fullLayout._activeShapeIndex, r4 = (e3.layout || {}).shapes || [];\n                if (t3 < r4.length) {\n                  for (var n4 = [], i3 = 0; i3 < r4.length; i3++) i3 !== t3 && n4.push(r4[i3]);\n                  return delete e3._fullLayout._activeShapeIndex, Wue.call("_guiRelayout", e3, { shapes: n4 });\n                }\n              }\n            }\n          });\n          var aN = ye((Oar, ace) => {\n            "use strict";\n            var A0 = qa(), Jue = Mc(), $ue = hf(), Pl = XL(), Vct = lP().eraseActiveShape, uP = Dr(), tl = uP._, Il = ace.exports = {};\n            Il.toImage = { name: "toImage", title: function(e3) {\n              var t3 = e3._context.toImageButtonOptions || {}, r4 = t3.format || "png";\n              return r4 === "png" ? tl(e3, "Download plot as a PNG") : tl(e3, "Download plot");\n            }, icon: Pl.camera, click: function(e3) {\n              var t3 = e3._context.toImageButtonOptions, r4 = { format: t3.format || "png" };\n              uP.notifier(tl(e3, "Taking snapshot - this may take a few seconds"), "long"), ["filename", "width", "height", "scale"].forEach(function(n4) {\n                n4 in t3 && (r4[n4] = t3[n4]);\n              }), A0.call("downloadImage", e3, r4).then(function(n4) {\n                uP.notifier(tl(e3, "Snapshot succeeded") + " - " + n4, "long");\n              }).catch(function() {\n                uP.notifier(tl(e3, "Sorry, there was a problem downloading your snapshot!"), "long");\n              });\n            } };\n            Il.sendDataToCloud = { name: "sendDataToCloud", title: function(e3) {\n              return tl(e3, "Edit in Chart Studio");\n            }, icon: Pl.disk, click: function(e3) {\n              Jue.sendDataToCloud(e3);\n            } };\n            Il.editInChartStudio = { name: "editInChartStudio", title: function(e3) {\n              return tl(e3, "Edit in Chart Studio");\n            }, icon: Pl.pencil, click: function(e3) {\n              Jue.sendDataToCloud(e3);\n            } };\n            Il.zoom2d = { name: "zoom2d", _cat: "zoom", title: function(e3) {\n              return tl(e3, "Zoom");\n            }, attr: "dragmode", val: "zoom", icon: Pl.zoombox, click: Bv };\n            Il.pan2d = { name: "pan2d", _cat: "pan", title: function(e3) {\n              return tl(e3, "Pan");\n            }, attr: "dragmode", val: "pan", icon: Pl.pan, click: Bv };\n            Il.select2d = { name: "select2d", _cat: "select", title: function(e3) {\n              return tl(e3, "Box Select");\n            }, attr: "dragmode", val: "select", icon: Pl.selectbox, click: Bv };\n            Il.lasso2d = { name: "lasso2d", _cat: "lasso", title: function(e3) {\n              return tl(e3, "Lasso Select");\n            }, attr: "dragmode", val: "lasso", icon: Pl.lasso, click: Bv };\n            Il.drawclosedpath = { name: "drawclosedpath", title: function(e3) {\n              return tl(e3, "Draw closed freeform");\n            }, attr: "dragmode", val: "drawclosedpath", icon: Pl.drawclosedpath, click: Bv };\n            Il.drawopenpath = { name: "drawopenpath", title: function(e3) {\n              return tl(e3, "Draw open freeform");\n            }, attr: "dragmode", val: "drawopenpath", icon: Pl.drawopenpath, click: Bv };\n            Il.drawline = { name: "drawline", title: function(e3) {\n              return tl(e3, "Draw line");\n            }, attr: "dragmode", val: "drawline", icon: Pl.drawline, click: Bv };\n            Il.drawrect = { name: "drawrect", title: function(e3) {\n              return tl(e3, "Draw rectangle");\n            }, attr: "dragmode", val: "drawrect", icon: Pl.drawrect, click: Bv };\n            Il.drawcircle = { name: "drawcircle", title: function(e3) {\n              return tl(e3, "Draw circle");\n            }, attr: "dragmode", val: "drawcircle", icon: Pl.drawcircle, click: Bv };\n            Il.eraseshape = { name: "eraseshape", title: function(e3) {\n              return tl(e3, "Erase active shape");\n            }, icon: Pl.eraseshape, click: Vct };\n            Il.zoomIn2d = { name: "zoomIn2d", _cat: "zoomin", title: function(e3) {\n              return tl(e3, "Zoom in");\n            }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: Bv };\n            Il.zoomOut2d = { name: "zoomOut2d", _cat: "zoomout", title: function(e3) {\n              return tl(e3, "Zoom out");\n            }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: Bv };\n            Il.autoScale2d = { name: "autoScale2d", _cat: "autoscale", title: function(e3) {\n              return tl(e3, "Autoscale");\n            }, attr: "zoom", val: "auto", icon: Pl.autoscale, click: Bv };\n            Il.resetScale2d = { name: "resetScale2d", _cat: "resetscale", title: function(e3) {\n              return tl(e3, "Reset axes");\n            }, attr: "zoom", val: "reset", icon: Pl.home, click: Bv };\n            Il.hoverClosestCartesian = { name: "hoverClosestCartesian", _cat: "hoverclosest", title: function(e3) {\n              return tl(e3, "Show closest data on hover");\n            }, attr: "hovermode", val: "closest", icon: Pl.tooltip_basic, gravity: "ne", click: Bv };\n            Il.hoverCompareCartesian = { name: "hoverCompareCartesian", _cat: "hoverCompare", title: function(e3) {\n              return tl(e3, "Compare data on hover");\n            }, attr: "hovermode", val: function(e3) {\n              return e3._fullLayout._isHoriz ? "y" : "x";\n            }, icon: Pl.tooltip_compare, gravity: "ne", click: Bv };\n            function Bv(e3, t3) {\n              var r4 = t3.currentTarget, n4 = r4.getAttribute("data-attr"), i3 = r4.getAttribute("data-val") || true, a4 = e3._fullLayout, o4 = {}, s3 = $ue.list(e3, null, true), l3 = a4._cartesianSpikesEnabled, u4, c5;\n              if (n4 === "zoom") {\n                var f4 = i3 === "in" ? 0.5 : 2, h3 = (1 + f4) / 2, d3 = (1 - f4) / 2, v3, _2;\n                for (c5 = 0; c5 < s3.length; c5++) if (u4 = s3[c5], _2 = u4.modebardisable === "none" || u4.modebardisable.indexOf(i3 === "auto" || i3 === "reset" ? "autoscale" : "zoominout") === -1, _2 && !u4.fixedrange) if (v3 = u4._name, i3 === "auto") o4[v3 + ".autorange"] = true;\n                else if (i3 === "reset") u4._rangeInitial0 === void 0 && u4._rangeInitial1 === void 0 ? o4[v3 + ".autorange"] = true : u4._rangeInitial0 === void 0 ? (o4[v3 + ".autorange"] = u4._autorangeInitial, o4[v3 + ".range"] = [null, u4._rangeInitial1]) : u4._rangeInitial1 === void 0 ? (o4[v3 + ".range"] = [u4._rangeInitial0, null], o4[v3 + ".autorange"] = u4._autorangeInitial) : o4[v3 + ".range"] = [u4._rangeInitial0, u4._rangeInitial1], u4._showSpikeInitial !== void 0 && (o4[v3 + ".showspikes"] = u4._showSpikeInitial, l3 === "on" && !u4._showSpikeInitial && (l3 = "off"));\n                else {\n                  var b = [u4.r2l(u4.range[0]), u4.r2l(u4.range[1])], p3 = [h3 * b[0] + d3 * b[1], h3 * b[1] + d3 * b[0]];\n                  o4[v3 + ".range[0]"] = u4.l2r(p3[0]), o4[v3 + ".range[1]"] = u4.l2r(p3[1]);\n                }\n              } else n4 === "hovermode" && (i3 === "x" || i3 === "y") && (i3 = a4._isHoriz ? "y" : "x", r4.setAttribute("data-val", i3)), o4[n4] = i3;\n              a4._cartesianSpikesEnabled = l3, A0.call("_guiRelayout", e3, o4);\n            }\n            Il.zoom3d = { name: "zoom3d", _cat: "zoom", title: function(e3) {\n              return tl(e3, "Zoom");\n            }, attr: "scene.dragmode", val: "zoom", icon: Pl.zoombox, click: cP };\n            Il.pan3d = { name: "pan3d", _cat: "pan", title: function(e3) {\n              return tl(e3, "Pan");\n            }, attr: "scene.dragmode", val: "pan", icon: Pl.pan, click: cP };\n            Il.orbitRotation = { name: "orbitRotation", title: function(e3) {\n              return tl(e3, "Orbital rotation");\n            }, attr: "scene.dragmode", val: "orbit", icon: Pl["3d_rotate"], click: cP };\n            Il.tableRotation = { name: "tableRotation", title: function(e3) {\n              return tl(e3, "Turntable rotation");\n            }, attr: "scene.dragmode", val: "turntable", icon: Pl["z-axis"], click: cP };\n            function cP(e3, t3) {\n              for (var r4 = t3.currentTarget, n4 = r4.getAttribute("data-attr"), i3 = r4.getAttribute("data-val") || true, a4 = e3._fullLayout._subplots.gl3d || [], o4 = {}, s3 = n4.split("."), l3 = 0; l3 < a4.length; l3++) o4[a4[l3] + "." + s3[1]] = i3;\n              var u4 = i3 === "pan" ? i3 : "zoom";\n              o4.dragmode = u4, A0.call("_guiRelayout", e3, o4);\n            }\n            Il.resetCameraDefault3d = { name: "resetCameraDefault3d", _cat: "resetCameraDefault", title: function(e3) {\n              return tl(e3, "Reset camera to default");\n            }, attr: "resetDefault", icon: Pl.home, click: iN };\n            Il.resetCameraLastSave3d = { name: "resetCameraLastSave3d", _cat: "resetCameraLastSave", title: function(e3) {\n              return tl(e3, "Reset camera to last save");\n            }, attr: "resetLastSave", icon: Pl.movie, click: iN };\n            function iN(e3, t3) {\n              for (var r4 = t3.currentTarget, n4 = r4.getAttribute("data-attr"), i3 = n4 === "resetLastSave", a4 = n4 === "resetDefault", o4 = e3._fullLayout, s3 = o4._subplots.gl3d || [], l3 = {}, u4 = 0; u4 < s3.length; u4++) {\n                var c5 = s3[u4], f4 = c5 + ".camera", h3 = c5 + ".aspectratio", d3 = c5 + ".aspectmode", v3 = o4[c5]._scene, _2;\n                i3 ? (l3[f4 + ".up"] = v3.viewInitial.up, l3[f4 + ".eye"] = v3.viewInitial.eye, l3[f4 + ".center"] = v3.viewInitial.center, _2 = true) : a4 && (l3[f4 + ".up"] = null, l3[f4 + ".eye"] = null, l3[f4 + ".center"] = null, _2 = true), _2 && (l3[h3 + ".x"] = v3.viewInitial.aspectratio.x, l3[h3 + ".y"] = v3.viewInitial.aspectratio.y, l3[h3 + ".z"] = v3.viewInitial.aspectratio.z, l3[d3] = v3.viewInitial.aspectmode);\n              }\n              A0.call("_guiRelayout", e3, l3);\n            }\n            Il.hoverClosest3d = { name: "hoverClosest3d", _cat: "hoverclosest", title: function(e3) {\n              return tl(e3, "Toggle show closest data on hover");\n            }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: Gct };\n            function Que(e3, t3) {\n              var r4 = t3.currentTarget, n4 = r4._previousVal, i3 = e3._fullLayout, a4 = i3._subplots.gl3d || [], o4 = ["xaxis", "yaxis", "zaxis"], s3 = {}, l3 = {};\n              if (n4) l3 = n4, r4._previousVal = null;\n              else {\n                for (var u4 = 0; u4 < a4.length; u4++) {\n                  var c5 = a4[u4], f4 = i3[c5], h3 = c5 + ".hovermode";\n                  s3[h3] = f4.hovermode, l3[h3] = false;\n                  for (var d3 = 0; d3 < 3; d3++) {\n                    var v3 = o4[d3], _2 = c5 + "." + v3 + ".showspikes";\n                    l3[_2] = false, s3[_2] = f4[v3].showspikes;\n                  }\n                }\n                r4._previousVal = s3;\n              }\n              return l3;\n            }\n            function Gct(e3, t3) {\n              var r4 = Que(e3, t3);\n              A0.call("_guiRelayout", e3, r4);\n            }\n            Il.zoomInGeo = { name: "zoomInGeo", _cat: "zoomin", title: function(e3) {\n              return tl(e3, "Zoom in");\n            }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: nN };\n            Il.zoomOutGeo = { name: "zoomOutGeo", _cat: "zoomout", title: function(e3) {\n              return tl(e3, "Zoom out");\n            }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: nN };\n            Il.resetGeo = { name: "resetGeo", _cat: "reset", title: function(e3) {\n              return tl(e3, "Reset");\n            }, attr: "reset", val: null, icon: Pl.autoscale, click: nN };\n            Il.hoverClosestGeo = { name: "hoverClosestGeo", _cat: "hoverclosest", title: function(e3) {\n              return tl(e3, "Toggle show closest data on hover");\n            }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: tce };\n            function nN(e3, t3) {\n              for (var r4 = t3.currentTarget, n4 = r4.getAttribute("data-attr"), i3 = r4.getAttribute("data-val") || true, a4 = e3._fullLayout, o4 = a4._subplots.geo || [], s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3], u4 = a4[l3];\n                if (n4 === "zoom") {\n                  var c5 = u4.projection.scale, f4 = i3 === "in" ? 2 * c5 : 0.5 * c5;\n                  A0.call("_guiRelayout", e3, l3 + ".projection.scale", f4);\n                }\n              }\n              n4 === "reset" && K3(e3, "geo");\n            }\n            Il.hoverClosestPie = { name: "hoverClosestPie", _cat: "hoverclosest", title: function(e3) {\n              return tl(e3, "Toggle show closest data on hover");\n            }, attr: "hovermode", val: "closest", icon: Pl.tooltip_basic, gravity: "ne", click: tce };\n            function ece(e3) {\n              var t3 = e3._fullLayout;\n              return t3.hovermode ? false : t3._has("cartesian") ? t3._isHoriz ? "y" : "x" : "closest";\n            }\n            function tce(e3) {\n              var t3 = ece(e3);\n              A0.call("_guiRelayout", e3, "hovermode", t3);\n            }\n            Il.resetViewSankey = { name: "resetSankeyGroup", title: function(e3) {\n              return tl(e3, "Reset view");\n            }, icon: Pl.home, click: function(e3) {\n              for (var t3 = { "node.groups": [], "node.x": [], "node.y": [] }, r4 = 0; r4 < e3._fullData.length; r4++) {\n                var n4 = e3._fullData[r4]._viewInitial;\n                t3["node.groups"].push(n4.node.groups.slice()), t3["node.x"].push(n4.node.x.slice()), t3["node.y"].push(n4.node.y.slice());\n              }\n              A0.call("restyle", e3, t3);\n            } };\n            Il.toggleHover = { name: "toggleHover", title: function(e3) {\n              return tl(e3, "Toggle show closest data on hover");\n            }, attr: "hovermode", val: null, toggle: true, icon: Pl.tooltip_basic, gravity: "ne", click: function(e3, t3) {\n              var r4 = Que(e3, t3);\n              r4.hovermode = ece(e3), A0.call("_guiRelayout", e3, r4);\n            } };\n            Il.resetViews = { name: "resetViews", title: function(e3) {\n              return tl(e3, "Reset views");\n            }, icon: Pl.home, click: function(e3, t3) {\n              var r4 = t3.currentTarget;\n              r4.setAttribute("data-attr", "zoom"), r4.setAttribute("data-val", "reset"), Bv(e3, t3), r4.setAttribute("data-attr", "resetLastSave"), iN(e3, t3), K3(e3, "geo"), K3(e3, "mapbox"), K3(e3, "map");\n            } };\n            Il.toggleSpikelines = { name: "toggleSpikelines", title: function(e3) {\n              return tl(e3, "Toggle Spike Lines");\n            }, icon: Pl.spikeline, attr: "_cartesianSpikesEnabled", val: "on", click: function(e3) {\n              var t3 = e3._fullLayout, r4 = t3._cartesianSpikesEnabled;\n              t3._cartesianSpikesEnabled = r4 === "on" ? "off" : "on", A0.call("_guiRelayout", e3, Hct(e3));\n            } };\n            function Hct(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._cartesianSpikesEnabled === "on", n4 = $ue.list(e3, null, true), i3 = {}, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4];\n                i3[o4._name + ".showspikes"] = r4 ? true : o4._showSpikeInitial;\n              }\n              return i3;\n            }\n            Il.resetViewMapbox = { name: "resetViewMapbox", _cat: "resetView", title: function(e3) {\n              return tl(e3, "Reset view");\n            }, attr: "reset", icon: Pl.home, click: function(e3) {\n              K3(e3, "mapbox");\n            } };\n            Il.resetViewMap = { name: "resetViewMap", _cat: "resetView", title: function(e3) {\n              return tl(e3, "Reset view");\n            }, attr: "reset", icon: Pl.home, click: function(e3) {\n              K3(e3, "map");\n            } };\n            Il.zoomInMapbox = { name: "zoomInMapbox", _cat: "zoomin", title: function(e3) {\n              return tl(e3, "Zoom in");\n            }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: rce };\n            Il.zoomInMap = { name: "zoomInMap", _cat: "zoomin", title: function(e3) {\n              return tl(e3, "Zoom in");\n            }, attr: "zoom", val: "in", icon: Pl.zoom_plus, click: ice };\n            Il.zoomOutMapbox = { name: "zoomOutMapbox", _cat: "zoomout", title: function(e3) {\n              return tl(e3, "Zoom out");\n            }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: rce };\n            Il.zoomOutMap = { name: "zoomOutMap", _cat: "zoomout", title: function(e3) {\n              return tl(e3, "Zoom out");\n            }, attr: "zoom", val: "out", icon: Pl.zoom_minus, click: ice };\n            function rce(e3, t3) {\n              nce(e3, t3, "mapbox");\n            }\n            function ice(e3, t3) {\n              nce(e3, t3, "map");\n            }\n            function nce(e3, t3, r4) {\n              for (var n4 = t3.currentTarget, i3 = n4.getAttribute("data-val"), a4 = e3._fullLayout, o4 = a4._subplots[r4] || [], s3 = 1.05, l3 = {}, u4 = 0; u4 < o4.length; u4++) {\n                var c5 = o4[u4], f4 = a4[c5].zoom, h3 = i3 === "in" ? s3 * f4 : f4 / s3;\n                l3[c5 + ".zoom"] = h3;\n              }\n              A0.call("_guiRelayout", e3, l3);\n            }\n            function K3(e3, t3) {\n              for (var r4 = e3._fullLayout, n4 = r4._subplots[t3] || [], i3 = {}, a4 = 0; a4 < n4.length; a4++) for (var o4 = n4[a4], s3 = r4[o4]._subplot, l3 = s3.viewInitial, u4 = Object.keys(l3), c5 = 0; c5 < u4.length; c5++) {\n                var f4 = u4[c5];\n                i3[o4 + "." + f4] = l3[f4];\n              }\n              A0.call("_guiRelayout", e3, i3);\n            }\n          });\n          var oN = ye((qar, uce) => {\n            "use strict";\n            var oce = aN(), jct = Object.keys(oce), sce = ["drawline", "drawopenpath", "drawclosedpath", "drawcircle", "drawrect", "eraseshape"], lce = ["v1hovermode", "hoverclosest", "hovercompare", "togglehover", "togglespikelines"].concat(sce), J3 = [], Wct = function(e3) {\n              if (lce.indexOf(e3._cat || e3.name) === -1) {\n                var t3 = e3.name, r4 = (e3._cat || e3.name).toLowerCase();\n                J3.indexOf(t3) === -1 && J3.push(t3), J3.indexOf(r4) === -1 && J3.push(r4);\n              }\n            };\n            jct.forEach(function(e3) {\n              Wct(oce[e3]);\n            });\n            J3.sort();\n            uce.exports = { DRAW_MODES: sce, backButtons: lce, foreButtons: J3 };\n          });\n          var sN = ye((Nar, cce) => {\n            "use strict";\n            var Bar = oN();\n            cce.exports = { editType: "modebar", orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h", editType: "modebar" }, bgcolor: { valType: "color", editType: "modebar" }, color: { valType: "color", editType: "modebar" }, activecolor: { valType: "color", editType: "modebar" }, uirevision: { valType: "any", editType: "none" }, add: { valType: "string", arrayOk: true, dflt: "", editType: "modebar" }, remove: { valType: "string", arrayOk: true, dflt: "", editType: "modebar" } };\n          });\n          var hce = ye((Uar, fce) => {\n            "use strict";\n            var Xct = Dr(), yM = ka(), Zct = vl(), Yct = sN();\n            fce.exports = function(t3, r4) {\n              var n4 = t3.modebar || {}, i3 = Zct.newContainer(r4, "modebar");\n              function a4(s3, l3) {\n                return Xct.coerce(n4, i3, Yct, s3, l3);\n              }\n              a4("orientation"), a4("bgcolor", yM.addOpacity(r4.paper_bgcolor, 0.5));\n              var o4 = yM.contrast(yM.rgb(r4.modebar.bgcolor));\n              a4("color", yM.addOpacity(o4, 0.3)), a4("activecolor", yM.addOpacity(o4, 0.7)), a4("uirevision", r4.uirevision), a4("add"), a4("remove");\n            };\n          });\n          var gce = ye((Var, pce) => {\n            "use strict";\n            var lN = Oa(), Kct = Eo(), fP = Dr(), dce = XL(), Jct = l6().version, $ct = new DOMParser();\n            function vce(e3) {\n              this.container = e3.container, this.element = document.createElement("div"), this.update(e3.graphInfo, e3.buttons), this.container.appendChild(this.element);\n            }\n            var Tm = vce.prototype;\n            Tm.update = function(e3, t3) {\n              this.graphInfo = e3;\n              var r4 = this.graphInfo._context, n4 = this.graphInfo._fullLayout, i3 = "modebar-" + n4._uid;\n              this.element.setAttribute("id", i3), this.element.setAttribute("role", "toolbar"), this._uid = i3, this.element.className = "modebar modebar--custom", r4.displayModeBar === "hover" && (this.element.className += " modebar--hover ease-bg"), n4.modebar.orientation === "v" && (this.element.className += " vertical", t3 = t3.reverse());\n              var a4 = n4.modebar, o4 = "#" + i3 + " .modebar-group";\n              document.querySelectorAll(o4).forEach(function(f4) {\n                f4.style.backgroundColor = a4.bgcolor;\n              });\n              var s3 = !this.hasButtons(t3), l3 = this.hasLogo !== r4.displaylogo, u4 = this.locale !== r4.locale;\n              if (this.locale = r4.locale, (s3 || l3 || u4) && (this.removeAllButtons(), this.updateButtons(t3), r4.watermark || r4.displaylogo)) {\n                var c5 = this.getLogo();\n                r4.watermark && (c5.className = c5.className + " watermark"), n4.modebar.orientation === "v" ? this.element.insertBefore(c5, this.element.childNodes[0]) : this.element.appendChild(c5), this.hasLogo = true;\n              }\n              this.updateActiveButton(), fP.setStyleOnHover("#" + i3 + " .modebar-btn", ".active", ".icon path", "fill: " + a4.activecolor, "fill: " + a4.color, this.element);\n            };\n            Tm.updateButtons = function(e3) {\n              var t3 = this;\n              this.buttons = e3, this.buttonElements = [], this.buttonsNames = [], this.buttons.forEach(function(r4) {\n                var n4 = t3.createGroup();\n                r4.forEach(function(i3) {\n                  var a4 = i3.name;\n                  if (!a4) throw new Error("must provide button \'name\' in button config");\n                  if (t3.buttonsNames.indexOf(a4) !== -1) throw new Error("button name \'" + a4 + "\' is taken");\n                  t3.buttonsNames.push(a4);\n                  var o4 = t3.createButton(i3);\n                  t3.buttonElements.push(o4), n4.appendChild(o4);\n                }), t3.element.appendChild(n4);\n              });\n            };\n            Tm.createGroup = function() {\n              var e3 = document.createElement("div");\n              e3.className = "modebar-group";\n              var t3 = this.graphInfo._fullLayout.modebar;\n              return e3.style.backgroundColor = t3.bgcolor, e3;\n            };\n            Tm.createButton = function(e3) {\n              var t3 = this, r4 = document.createElement("button");\n              r4.setAttribute("type", "button"), r4.setAttribute("rel", "tooltip"), r4.className = "modebar-btn";\n              var n4 = e3.title;\n              n4 === void 0 ? n4 = e3.name : typeof n4 == "function" && (n4 = n4(this.graphInfo)), (n4 || n4 === 0) && (r4.setAttribute("data-title", n4), r4.setAttribute("aria-label", n4)), e3.attr !== void 0 && r4.setAttribute("data-attr", e3.attr);\n              var i3 = e3.val;\n              i3 !== void 0 && (typeof i3 == "function" && (i3 = i3(this.graphInfo)), r4.setAttribute("data-val", i3));\n              var a4 = e3.click;\n              if (typeof a4 != "function") throw new Error("must provide button \'click\' function in button config");\n              r4.addEventListener("click", function(s3) {\n                e3.click(t3.graphInfo, s3), t3.updateActiveButton(s3.currentTarget);\n              }), r4.setAttribute("data-toggle", e3.toggle || false), e3.toggle && lN.select(r4).classed("active", true);\n              var o4 = e3.icon;\n              return typeof o4 == "function" ? r4.appendChild(o4()) : r4.appendChild(this.createIcon(o4 || dce.question)), r4.setAttribute("data-gravity", e3.gravity || "n"), r4;\n            };\n            Tm.createIcon = function(e3) {\n              var t3 = Kct(e3.height) ? Number(e3.height) : e3.ascent - e3.descent, r4 = "http://www.w3.org/2000/svg", n4;\n              if (e3.path) {\n                n4 = document.createElementNS(r4, "svg"), n4.setAttribute("viewBox", [0, 0, e3.width, t3].join(" ")), n4.setAttribute("class", "icon");\n                var i3 = document.createElementNS(r4, "path");\n                i3.setAttribute("d", e3.path), e3.transform ? i3.setAttribute("transform", e3.transform) : e3.ascent !== void 0 && i3.setAttribute("transform", "matrix(1 0 0 -1 0 " + e3.ascent + ")"), n4.appendChild(i3);\n              }\n              if (e3.svg) {\n                var a4 = $ct.parseFromString(e3.svg, "application/xml");\n                n4 = a4.childNodes[0];\n              }\n              return n4.setAttribute("height", "1em"), n4.setAttribute("width", "1em"), n4;\n            };\n            Tm.updateActiveButton = function(e3) {\n              var t3 = this.graphInfo._fullLayout, r4 = e3 !== void 0 ? e3.getAttribute("data-attr") : null;\n              this.buttonElements.forEach(function(n4) {\n                var i3 = n4.getAttribute("data-val") || true, a4 = n4.getAttribute("data-attr"), o4 = n4.getAttribute("data-toggle") === "true", s3 = lN.select(n4), l3 = function(f4, h3) {\n                  var d3 = t3.modebar, v3 = f4.querySelector(".icon path");\n                  v3 && (h3 || f4.matches(":hover") ? v3.style.fill = d3.activecolor : v3.style.fill = d3.color);\n                };\n                if (o4) {\n                  if (a4 === r4) {\n                    var u4 = !s3.classed("active");\n                    s3.classed("active", u4), l3(n4, u4);\n                  }\n                } else {\n                  var c5 = a4 === null ? a4 : fP.nestedProperty(t3, a4).get();\n                  s3.classed("active", c5 === i3), l3(n4, c5 === i3);\n                }\n              });\n            };\n            Tm.hasButtons = function(e3) {\n              var t3 = this.buttons;\n              if (!t3 || e3.length !== t3.length) return false;\n              for (var r4 = 0; r4 < e3.length; ++r4) {\n                if (e3[r4].length !== t3[r4].length) return false;\n                for (var n4 = 0; n4 < e3[r4].length; n4++) if (e3[r4][n4].name !== t3[r4][n4].name) return false;\n              }\n              return true;\n            };\n            function Qct(e3) {\n              return e3 + " (v" + Jct + ")";\n            }\n            Tm.getLogo = function() {\n              var e3 = this.createGroup(), t3 = document.createElement("a");\n              return t3.href = "https://plotly.com/", t3.target = "_blank", t3.setAttribute("data-title", Qct(fP._(this.graphInfo, "Produced with Plotly.js"))), t3.className = "modebar-btn plotlyjsicon modebar-btn--logo", t3.appendChild(this.createIcon(dce.newplotlylogo)), e3.appendChild(t3), e3;\n            };\n            Tm.removeAllButtons = function() {\n              for (; this.element.firstChild; ) this.element.removeChild(this.element.firstChild);\n              this.hasLogo = false;\n            };\n            Tm.destroy = function() {\n              fP.removeElement(this.container.querySelector(".modebar"));\n            };\n            function eft(e3, t3) {\n              var r4 = e3._fullLayout, n4 = new vce({ graphInfo: e3, container: r4._modebardiv.node(), buttons: t3 });\n              return r4._privateplot && lN.select(n4.element).append("span").classed("badge-private float--left", true).text("PRIVATE"), n4;\n            }\n            pce.exports = eft;\n          });\n          var _ce = ye((Gar, yce) => {\n            "use strict";\n            var tft = hf(), mce = Ru(), uN = qa(), rft = ip().isUnifiedHover, ift = gce(), hP = aN(), nft = oN().DRAW_MODES, aft = Dr().extendDeep;\n            yce.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = t3._context, i3 = r4._modeBar;\n              if (!n4.displayModeBar && !n4.watermark) {\n                i3 && (i3.destroy(), delete r4._modeBar);\n                return;\n              }\n              if (!Array.isArray(n4.modeBarButtonsToRemove)) throw new Error(["*modeBarButtonsToRemove* configuration options", "must be an array."].join(" "));\n              if (!Array.isArray(n4.modeBarButtonsToAdd)) throw new Error(["*modeBarButtonsToAdd* configuration options", "must be an array."].join(" "));\n              var a4 = n4.modeBarButtons, o4;\n              Array.isArray(a4) && a4.length ? o4 = fft(a4) : !n4.displayModeBar && n4.watermark ? o4 = [] : o4 = oft(t3), i3 ? i3.update(t3, o4) : r4._modeBar = ift(t3, o4);\n            };\n            function oft(e3) {\n              var t3 = e3._fullLayout, r4 = e3._fullData, n4 = e3._context;\n              function i3(N2, H) {\n                if (typeof H == "string") {\n                  if (H.toLowerCase() === N2.toLowerCase()) return true;\n                } else {\n                  var te = H.name, oe = H._cat || H.name;\n                  if (te === N2 || oe === N2.toLowerCase()) return true;\n                }\n                return false;\n              }\n              var a4 = t3.modebar.add;\n              typeof a4 == "string" && (a4 = [a4]);\n              var o4 = t3.modebar.remove;\n              typeof o4 == "string" && (o4 = [o4]);\n              var s3 = n4.modeBarButtonsToAdd.concat(a4.filter(function(N2) {\n                for (var H = 0; H < n4.modeBarButtonsToRemove.length; H++) if (i3(N2, n4.modeBarButtonsToRemove[H])) return false;\n                return true;\n              })), l3 = n4.modeBarButtonsToRemove.concat(o4.filter(function(N2) {\n                for (var H = 0; H < n4.modeBarButtonsToAdd.length; H++) if (i3(N2, n4.modeBarButtonsToAdd[H])) return false;\n                return true;\n              })), u4 = t3._has("cartesian"), c5 = t3._has("gl3d"), f4 = t3._has("geo"), h3 = t3._has("pie"), d3 = t3._has("funnelarea"), v3 = t3._has("ternary"), _2 = t3._has("mapbox"), b = t3._has("map"), p3 = t3._has("polar"), k4 = t3._has("smith"), E3 = t3._has("sankey"), S2 = sft(t3), L3 = rft(t3.hovermode), x2 = [];\n              function C3(N2) {\n                if (N2.length) {\n                  for (var H = [], te = 0; te < N2.length; te++) {\n                    for (var oe = N2[te], _e = hP[oe], Ee = _e.name.toLowerCase(), Ce = (_e._cat || _e.name).toLowerCase(), me = false, ie = 0; ie < l3.length; ie++) {\n                      var Se = l3[ie].toLowerCase();\n                      if (Se === Ee || Se === Ce) {\n                        me = true;\n                        break;\n                      }\n                    }\n                    me || H.push(hP[oe]);\n                  }\n                  x2.push(H);\n                }\n              }\n              var M4 = ["toImage"];\n              n4.showEditInChartStudio ? M4.push("editInChartStudio") : n4.showSendToCloud && M4.push("sendDataToCloud"), C3(M4);\n              var g3 = [], P3 = [], T3 = [], z3 = [];\n              (u4 || h3 || d3 || v3) + f4 + c5 + _2 + b + p3 + k4 > 1 ? (P3 = ["toggleHover"], T3 = ["resetViews"]) : f4 ? (g3 = ["zoomInGeo", "zoomOutGeo"], P3 = ["hoverClosestGeo"], T3 = ["resetGeo"]) : c5 ? (P3 = ["hoverClosest3d"], T3 = ["resetCameraDefault3d", "resetCameraLastSave3d"]) : _2 ? (g3 = ["zoomInMapbox", "zoomOutMapbox"], P3 = ["toggleHover"], T3 = ["resetViewMapbox"]) : b ? (g3 = ["zoomInMap", "zoomOutMap"], P3 = ["toggleHover"], T3 = ["resetViewMap"]) : h3 ? P3 = ["hoverClosestPie"] : E3 ? (P3 = ["hoverClosestCartesian", "hoverCompareCartesian"], T3 = ["resetViewSankey"]) : P3 = ["toggleHover"], u4 && P3.push("toggleSpikelines", "hoverClosestCartesian", "hoverCompareCartesian"), (uft(r4) || L3) && (P3 = []), u4 && !S2 && (g3 = ["zoomIn2d", "zoomOut2d", "autoScale2d"], T3[0] !== "resetViews" && (T3 = ["resetScale2d"])), c5 ? z3 = ["zoom3d", "pan3d", "orbitRotation", "tableRotation"] : u4 && !S2 || v3 ? z3 = ["zoom2d", "pan2d"] : _2 || b || f4 ? z3 = ["pan2d"] : p3 && (z3 = ["zoom2d"]), lft(r4) && z3.push("select2d", "lasso2d");\n              var O3 = [], V2 = function(N2) {\n                O3.indexOf(N2) === -1 && P3.indexOf(N2) !== -1 && O3.push(N2);\n              };\n              if (Array.isArray(s3)) {\n                for (var G2 = [], Z = 0; Z < s3.length; Z++) {\n                  var j3 = s3[Z];\n                  typeof j3 == "string" ? (j3 = j3.toLowerCase(), nft.indexOf(j3) !== -1 ? (t3._has("mapbox") || t3._has("map") || t3._has("cartesian")) && z3.push(j3) : j3 === "togglespikelines" ? V2("toggleSpikelines") : j3 === "togglehover" ? V2("toggleHover") : j3 === "hovercompare" ? V2("hoverCompareCartesian") : j3 === "hoverclosest" ? (V2("hoverClosestCartesian"), V2("hoverClosestGeo"), V2("hoverClosest3d"), V2("hoverClosestPie")) : j3 === "v1hovermode" && (V2("hoverClosestCartesian"), V2("hoverCompareCartesian"), V2("hoverClosestGeo"), V2("hoverClosest3d"), V2("hoverClosestPie"))) : G2.push(j3);\n                }\n                s3 = G2;\n              }\n              return C3(z3), C3(g3.concat(T3)), C3(O3), cft(x2, s3);\n            }\n            function sft(e3) {\n              for (var t3 = tft.list({ _fullLayout: e3 }, null, true), r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4].modebardisable;\n                if (!t3[r4].fixedrange && n4 !== "autoscale+zoominout" && n4 !== "zoominout+autoscale") return false;\n              }\n              return true;\n            }\n            function lft(e3) {\n              for (var t3 = false, r4 = 0; r4 < e3.length && !t3; r4++) {\n                var n4 = e3[r4];\n                !n4._module || !n4._module.selectPoints || (uN.traceIs(n4, "scatter-like") ? (mce.hasMarkers(n4) || mce.hasText(n4)) && (t3 = true) : uN.traceIs(n4, "box-violin") ? (n4.boxpoints === "all" || n4.points === "all") && (t3 = true) : t3 = true);\n              }\n              return t3;\n            }\n            function uft(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) if (!uN.traceIs(e3[t3], "noHover")) return false;\n              return true;\n            }\n            function cft(e3, t3) {\n              if (t3.length) if (Array.isArray(t3[0])) for (var r4 = 0; r4 < t3.length; r4++) e3.push(t3[r4]);\n              else e3.push(t3);\n              return e3;\n            }\n            function fft(e3) {\n              for (var t3 = aft([], e3), r4 = 0; r4 < t3.length; r4++) for (var n4 = t3[r4], i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                if (typeof a4 == "string") if (hP[a4] !== void 0) t3[r4][i3] = hP[a4];\n                else throw new Error(["*modeBarButtons* configuration options", "invalid button name"].join(" "));\n              }\n              return t3;\n            }\n          });\n          var cN = ye((Har, xce) => {\n            "use strict";\n            xce.exports = { moduleType: "component", name: "modebar", layoutAttributes: sN(), supplyLayoutDefaults: hce(), manage: _ce() };\n          });\n          var fN = ye((jar, bce) => {\n            "use strict";\n            var hft = $h().FROM_BL;\n            bce.exports = function(t3, r4, n4) {\n              n4 === void 0 && (n4 = hft[t3.constraintoward || "center"]);\n              var i3 = [t3.r2l(t3.range[0]), t3.r2l(t3.range[1])], a4 = i3[0] + (i3[1] - i3[0]) * n4;\n              t3.range = t3._input.range = [t3.l2r(a4 + (i3[0] - a4) * r4), t3.l2r(a4 + (i3[1] - a4) * r4)], t3.setScale();\n            };\n          });\n          var Nb = ye((_M) => {\n            "use strict";\n            var Bb = Dr(), hN = Ag(), kg = hf().id2name, dft = Rd(), wce = fN(), vft = ym(), pft = fs().ALMOST_EQUAL, gft = $h().FROM_BL;\n            _M.handleDefaults = function(e3, t3, r4) {\n              var n4 = r4.axIds, i3 = r4.axHasImage, a4 = t3._axisConstraintGroups = [], o4 = t3._axisMatchGroups = [], s3, l3, u4, c5, f4, h3, d3, v3;\n              for (s3 = 0; s3 < n4.length; s3++) c5 = kg(n4[s3]), f4 = e3[c5], h3 = t3[c5], mft(f4, h3, { axIds: n4, layoutOut: t3, hasImage: i3[c5] });\n              function _2(M4, g3) {\n                for (s3 = 0; s3 < M4.length; s3++) {\n                  l3 = M4[s3];\n                  for (u4 in l3) t3[kg(u4)][g3] = l3;\n                }\n              }\n              for (_2(o4, "_matchGroup"), s3 = 0; s3 < a4.length; s3++) {\n                l3 = a4[s3];\n                for (u4 in l3) if (h3 = t3[kg(u4)], h3.fixedrange) {\n                  for (var b in l3) {\n                    var p3 = kg(b);\n                    (e3[p3] || {}).fixedrange === false && Bb.warn("fixedrange was specified as false for axis " + p3 + " but was overridden because another axis in its constraint group has fixedrange true"), t3[p3].fixedrange = true;\n                  }\n                  break;\n                }\n              }\n              for (s3 = 0; s3 < a4.length; ) {\n                l3 = a4[s3];\n                for (u4 in l3) {\n                  h3 = t3[kg(u4)], h3._matchGroup && Object.keys(h3._matchGroup).length === Object.keys(l3).length && (a4.splice(s3, 1), s3--);\n                  break;\n                }\n                s3++;\n              }\n              _2(a4, "_constraintGroup");\n              var k4 = ["constrain", "range", "autorange", "rangemode", "rangebreaks", "categoryorder", "categoryarray"], E3 = false, S2 = false;\n              function L3() {\n                v3 = h3[d3], d3 === "rangebreaks" && (S2 = h3._hasDayOfWeekBreaks);\n              }\n              for (s3 = 0; s3 < o4.length; s3++) {\n                l3 = o4[s3];\n                for (var x2 = 0; x2 < k4.length; x2++) {\n                  d3 = k4[x2], v3 = null;\n                  var C3;\n                  for (u4 in l3) if (c5 = kg(u4), f4 = e3[c5], h3 = t3[c5], d3 in h3) {\n                    if (!h3.matches && (C3 = h3, d3 in f4)) {\n                      L3();\n                      break;\n                    }\n                    v3 === null && d3 in f4 && L3();\n                  }\n                  if (d3 === "range" && v3 && f4.range && f4.range.length === 2 && f4.range[0] !== null && f4.range[1] !== null && (E3 = true), d3 === "autorange" && v3 === null && E3 && (v3 = false), v3 === null && d3 in C3 && (v3 = C3[d3]), v3 !== null) for (u4 in l3) h3 = t3[kg(u4)], h3[d3] = d3 === "range" ? v3.slice() : v3, d3 === "rangebreaks" && (h3._hasDayOfWeekBreaks = S2, vft(h3, t3));\n                }\n              }\n            };\n            function mft(e3, t3, r4) {\n              var n4 = r4.axIds, i3 = r4.layoutOut, a4 = r4.hasImage, o4 = i3._axisConstraintGroups, s3 = i3._axisMatchGroups, l3 = t3._id, u4 = l3.charAt(0), c5 = ((i3._splomAxes || {})[u4] || {})[l3] || {}, f4 = t3._id, h3 = f4.charAt(0) === "x";\n              t3._matchGroup = null, t3._constraintGroup = null;\n              function d3(z3, O3) {\n                return Bb.coerce(e3, t3, dft, z3, O3);\n              }\n              d3("constrain", a4 ? "domain" : "range"), Bb.coerce(e3, t3, { constraintoward: { valType: "enumerated", values: h3 ? ["left", "center", "right"] : ["bottom", "middle", "top"], dflt: h3 ? "center" : "middle" } }, "constraintoward");\n              var v3 = t3.type, _2, b, p3 = [];\n              for (_2 = 0; _2 < n4.length; _2++) if (b = n4[_2], b !== f4) {\n                var k4 = i3[kg(b)];\n                k4.type === v3 && p3.push(b);\n              }\n              var E3 = Sce(o4, f4);\n              if (E3) {\n                var S2 = [];\n                for (_2 = 0; _2 < p3.length; _2++) b = p3[_2], E3[b] || S2.push(b);\n                p3 = S2;\n              }\n              var L3 = p3.length, x2, C3;\n              L3 && (e3.matches || c5.matches) && (x2 = Bb.coerce(e3, t3, { matches: { valType: "enumerated", values: p3, dflt: p3.indexOf(c5.matches) !== -1 ? c5.matches : void 0 } }, "matches"));\n              var M4 = a4 && !h3 ? t3.anchor : void 0;\n              if (L3 && !x2 && (e3.scaleanchor || M4) && (C3 = Bb.coerce(e3, t3, { scaleanchor: { valType: "enumerated", values: p3.concat([false]) } }, "scaleanchor", M4)), x2) {\n                t3._matchGroup = dN(s3, f4, x2, 1);\n                var g3 = i3[kg(x2)], P3 = Tce(i3, t3) / Tce(i3, g3);\n                h3 !== (x2.charAt(0) === "x") && (P3 = (h3 ? "x" : "y") + P3), dN(o4, f4, x2, P3);\n              } else e3.matches && n4.indexOf(e3.matches) !== -1 && Bb.warn("ignored " + t3._name + \'.matches: "\' + e3.matches + \'" to avoid an infinite loop\');\n              if (C3) {\n                var T3 = d3("scaleratio");\n                T3 || (T3 = t3.scaleratio = 1), dN(o4, f4, C3, T3);\n              } else e3.scaleanchor && n4.indexOf(e3.scaleanchor) !== -1 && Bb.warn("ignored " + t3._name + \'.scaleanchor: "\' + e3.scaleanchor + \'" to avoid either an infinite loop and possibly inconsistent scaleratios, or because this axis declares a *matches* constraint.\');\n            }\n            function Tce(e3, t3) {\n              var r4 = t3.domain;\n              return r4 || (r4 = e3[kg(t3.overlaying)].domain), r4[1] - r4[0];\n            }\n            function Sce(e3, t3) {\n              for (var r4 = 0; r4 < e3.length; r4++) if (e3[r4][t3]) return e3[r4];\n              return null;\n            }\n            function dN(e3, t3, r4, n4) {\n              var i3, a4, o4, s3, l3, u4 = Sce(e3, t3);\n              u4 === null ? (u4 = {}, u4[t3] = 1, l3 = e3.length, e3.push(u4)) : l3 = e3.indexOf(u4);\n              var c5 = Object.keys(u4);\n              for (i3 = 0; i3 < e3.length; i3++) if (o4 = e3[i3], i3 !== l3 && o4[r4]) {\n                var f4 = o4[r4];\n                for (a4 = 0; a4 < c5.length; a4++) s3 = c5[a4], o4[s3] = vN(f4, vN(n4, u4[s3]));\n                e3.splice(l3, 1);\n                return;\n              }\n              if (n4 !== 1) for (a4 = 0; a4 < c5.length; a4++) {\n                var h3 = c5[a4];\n                u4[h3] = vN(n4, u4[h3]);\n              }\n              u4[r4] = 1;\n            }\n            function vN(e3, t3) {\n              var r4 = "", n4 = "", i3, a4;\n              typeof e3 == "string" && (r4 = e3.match(/^[xy]*/)[0], i3 = r4.length, e3 = +e3.slice(i3)), typeof t3 == "string" && (n4 = t3.match(/^[xy]*/)[0], a4 = n4.length, t3 = +t3.slice(a4));\n              var o4 = e3 * t3;\n              return !i3 && !a4 ? o4 : !i3 || !a4 || r4.charAt(0) === n4.charAt(0) ? r4 + n4 + e3 * t3 : i3 === a4 ? o4 : (i3 > a4 ? r4.slice(a4) : n4.slice(i3)) + o4;\n            }\n            function yft(e3, t3) {\n              for (var r4 = t3._size, n4 = r4.h / r4.w, i3 = {}, a4 = Object.keys(e3), o4 = 0; o4 < a4.length; o4++) {\n                var s3 = a4[o4], l3 = e3[s3];\n                if (typeof l3 == "string") {\n                  var u4 = l3.match(/^[xy]*/)[0], c5 = u4.length;\n                  l3 = +l3.slice(c5);\n                  for (var f4 = u4.charAt(0) === "y" ? n4 : 1 / n4, h3 = 0; h3 < c5; h3++) l3 *= f4;\n                }\n                i3[s3] = l3;\n              }\n              return i3;\n            }\n            _M.enforce = function(t3) {\n              var r4 = t3._fullLayout, n4 = r4._axisConstraintGroups || [], i3, a4, o4, s3, l3, u4, c5, f4;\n              for (i3 = 0; i3 < n4.length; i3++) {\n                o4 = yft(n4[i3], r4);\n                var h3 = Object.keys(o4), d3 = 1 / 0, v3 = 0, _2 = 1 / 0, b = {}, p3 = {}, k4 = false;\n                for (a4 = 0; a4 < h3.length; a4++) s3 = h3[a4], p3[s3] = l3 = r4[kg(s3)], l3._inputDomain ? l3.domain = l3._inputDomain.slice() : l3._inputDomain = l3.domain.slice(), l3._inputRange || (l3._inputRange = l3.range.slice()), l3.setScale(), b[s3] = u4 = Math.abs(l3._m) / o4[s3], d3 = Math.min(d3, u4), (l3.constrain === "domain" || !l3._constraintShrinkable) && (_2 = Math.min(_2, u4)), delete l3._constraintShrinkable, v3 = Math.max(v3, u4), l3.constrain === "domain" && (k4 = true);\n                if (!(d3 > pft * v3 && !k4)) {\n                  for (a4 = 0; a4 < h3.length; a4++) if (s3 = h3[a4], u4 = b[s3], l3 = p3[s3], c5 = l3.constrain, u4 !== _2 || c5 === "domain") if (f4 = u4 / _2, c5 === "range") wce(l3, f4);\n                  else {\n                    var E3 = l3._inputDomain, S2 = (l3.domain[1] - l3.domain[0]) / (E3[1] - E3[0]), L3 = (l3.r2l(l3.range[1]) - l3.r2l(l3.range[0])) / (l3.r2l(l3._inputRange[1]) - l3.r2l(l3._inputRange[0]));\n                    if (f4 /= S2, f4 * L3 < 1) {\n                      l3.domain = l3._input.domain = E3.slice(), wce(l3, f4);\n                      continue;\n                    }\n                    if (L3 < 1 && (l3.range = l3._input.range = l3._inputRange.slice(), f4 *= L3), l3.autorange) {\n                      var x2 = l3.r2l(l3.range[0]), C3 = l3.r2l(l3.range[1]), M4 = (x2 + C3) / 2, g3 = M4, P3 = M4, T3 = Math.abs(C3 - M4), z3 = M4 - T3 * f4 * 1.0001, O3 = M4 + T3 * f4 * 1.0001, V2 = hN.makePadFn(r4, l3, 0), G2 = hN.makePadFn(r4, l3, 1);\n                      Ace(l3, f4);\n                      var Z = Math.abs(l3._m), j3 = hN.concatExtremes(t3, l3), N2 = j3.min, H = j3.max, te, oe;\n                      for (oe = 0; oe < N2.length; oe++) te = N2[oe].val - V2(N2[oe]) / Z, te > z3 && te < g3 && (g3 = te);\n                      for (oe = 0; oe < H.length; oe++) te = H[oe].val + G2(H[oe]) / Z, te < O3 && te > P3 && (P3 = te);\n                      var _e = (P3 - g3) / (2 * T3);\n                      f4 /= _e, g3 = l3.l2r(g3), P3 = l3.l2r(P3), l3.range = l3._input.range = x2 < C3 ? [g3, P3] : [P3, g3];\n                    }\n                    Ace(l3, f4);\n                  }\n                }\n              }\n            };\n            _M.getAxisGroup = function(t3, r4) {\n              for (var n4 = t3._axisMatchGroups, i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                if (a4[r4]) return "g" + i3;\n              }\n              return r4;\n            };\n            _M.clean = function(t3, r4) {\n              if (r4._inputDomain) {\n                for (var n4 = false, i3 = r4._id, a4 = t3._fullLayout._axisConstraintGroups, o4 = 0; o4 < a4.length; o4++) if (a4[o4][i3]) {\n                  n4 = true;\n                  break;\n                }\n                (!n4 || r4.constrain !== "domain") && (r4._input.domain = r4.domain = r4._inputDomain, delete r4._inputDomain);\n              }\n            };\n            function Ace(e3, t3) {\n              var r4 = e3._inputDomain, n4 = gft[e3.constraintoward], i3 = r4[0] + (r4[1] - r4[0]) * n4;\n              e3.domain = e3._input.domain = [i3 + (r4[0] - i3) / t3, i3 + (r4[1] - i3) / t3], e3.setScale();\n            }\n          });\n          var wM = ye((pd) => {\n            "use strict";\n            var vP = Oa(), Nv = qa(), Jp = Mc(), S0 = Dr(), pN = ru(), gN = vM(), xM = ka(), $3 = So(), Mce = Eb(), Pce = cN(), bM = ho(), Cy = $h(), Ice = Nb(), _ft = Ice.enforce, xft = Ice.clean, Ece = Ag().doAutoRange, Rce = "start", bft = "middle", Dce = "end", wft = hd().zindexSeparator;\n            pd.layoutStyles = function(e3) {\n              return S0.syncOrAsync([Jp.doAutoMargin, Aft], e3);\n            };\n            function Tft(e3, t3, r4) {\n              for (var n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4][0], a4 = r4[n4][1];\n                if (!(i3[0] >= e3[1] || i3[1] <= e3[0]) && a4[0] < t3[1] && a4[1] > t3[0]) return true;\n              }\n              return false;\n            }\n            function Aft(e3) {\n              var t3 = e3._fullLayout, r4 = t3._size, n4 = r4.p, i3 = bM.list(e3, "", true), a4, o4, s3, l3, u4, c5;\n              if (t3._paperdiv.style({ width: e3._context.responsive && t3.autosize && !e3._context._hasZeroWidth && !e3.layout.width ? "100%" : t3.width + "px", height: e3._context.responsive && t3.autosize && !e3._context._hasZeroHeight && !e3.layout.height ? "100%" : t3.height + "px" }).selectAll(".main-svg").call($3.setSize, t3.width, t3.height), e3._context.setBackground(e3, t3.paper_bgcolor), pd.drawMainTitle(e3), Pce.manage(e3), !t3._has("cartesian")) return Jp.previousPromises(e3);\n              function f4(Pe, ge, Re) {\n                var ce = Pe._lw / 2;\n                if (Pe._id.charAt(0) === "x") {\n                  if (ge) {\n                    if (Re === "top") return ge._offset - n4 - ce;\n                  } else return r4.t + r4.h * (1 - (Pe.position || 0)) + ce % 1;\n                  return ge._offset + ge._length + n4 + ce;\n                }\n                if (ge) {\n                  if (Re === "right") return ge._offset + ge._length + n4 + ce;\n                } else return r4.l + r4.w * (Pe.position || 0) + ce % 1;\n                return ge._offset - n4 - ce;\n              }\n              for (a4 = 0; a4 < i3.length; a4++) {\n                l3 = i3[a4];\n                var h3 = l3._anchorAxis;\n                l3._linepositions = {}, l3._lw = $3.crispRound(e3, l3.linewidth, 1), l3._mainLinePosition = f4(l3, h3, l3.side), l3._mainMirrorPosition = l3.mirror && h3 ? f4(l3, h3, Cy.OPPOSITE_SIDE[l3.side]) : null;\n              }\n              var d3 = [], v3 = [], _2 = [], b = xM.opacity(t3.paper_bgcolor) === 1 && xM.opacity(t3.plot_bgcolor) === 1 && t3.paper_bgcolor === t3.plot_bgcolor;\n              for (o4 in t3._plots) if (s3 = t3._plots[o4], s3.mainplot) s3.bg && s3.bg.remove(), s3.bg = void 0;\n              else {\n                var p3 = s3.xaxis.domain, k4 = s3.yaxis.domain, E3 = s3.plotgroup;\n                if (Tft(p3, k4, _2) && o4.indexOf(wft) === -1) {\n                  var S2 = E3.node(), L3 = s3.bg = S0.ensureSingle(E3, "rect", "bg");\n                  S2.insertBefore(L3.node(), S2.childNodes[0]), v3.push(o4);\n                } else E3.select("rect.bg").remove(), _2.push([p3, k4]), b || (d3.push(o4), v3.push(o4));\n              }\n              var x2 = t3._bgLayer.selectAll(".bg").data(d3);\n              for (x2.enter().append("rect").classed("bg", true), x2.exit().remove(), x2.each(function(Pe) {\n                t3._plots[Pe].bg = vP.select(this);\n              }), a4 = 0; a4 < v3.length; a4++) s3 = t3._plots[v3[a4]], u4 = s3.xaxis, c5 = s3.yaxis, s3.bg && u4._offset !== void 0 && c5._offset !== void 0 && s3.bg.call($3.setRect, u4._offset - n4, c5._offset - n4, u4._length + 2 * n4, c5._length + 2 * n4).call(xM.fill, t3.plot_bgcolor).style("stroke-width", 0);\n              if (!t3._hasOnlyLargeSploms) for (o4 in t3._plots) {\n                s3 = t3._plots[o4], u4 = s3.xaxis, c5 = s3.yaxis;\n                var C3 = s3.clipId = "clip" + t3._uid + o4 + "plot", M4 = S0.ensureSingleById(t3._clips, "clipPath", C3, function(Pe) {\n                  Pe.classed("plotclip", true).append("rect");\n                });\n                s3.clipRect = M4.select("rect").attr({ width: u4._length, height: c5._length }), $3.setTranslate(s3.plot, u4._offset, c5._offset);\n                var g3, P3;\n                s3._hasClipOnAxisFalse ? (g3 = null, P3 = C3) : (g3 = C3, P3 = null), $3.setClipUrl(s3.plot, g3, e3), s3.layerClipId = P3;\n              }\n              var T3, z3, O3, V2, G2, Z, j3, N2, H, te, oe, _e, Ee;\n              function Ce(Pe) {\n                return "M" + T3 + "," + Pe + "H" + z3;\n              }\n              function me(Pe) {\n                return "M" + u4._offset + "," + Pe + "h" + u4._length;\n              }\n              function ie(Pe) {\n                return "M" + Pe + "," + N2 + "V" + j3;\n              }\n              function Se(Pe) {\n                return c5._shift !== void 0 && (Pe += c5._shift), "M" + Pe + "," + c5._offset + "v" + c5._length;\n              }\n              function Le(Pe, ge, Re) {\n                if (!Pe.showline || o4 !== Pe._mainSubplot) return "";\n                if (!Pe._anchorAxis) return Re(Pe._mainLinePosition);\n                var ce = ge(Pe._mainLinePosition);\n                return Pe.mirror && (ce += ge(Pe._mainMirrorPosition)), ce;\n              }\n              for (o4 in t3._plots) {\n                s3 = t3._plots[o4], u4 = s3.xaxis, c5 = s3.yaxis;\n                var Ae = "M0,0";\n                kce(u4, o4) && (G2 = dP(u4, "left", c5, i3), T3 = u4._offset - (G2 ? n4 + G2 : 0), Z = dP(u4, "right", c5, i3), z3 = u4._offset + u4._length + (Z ? n4 + Z : 0), O3 = f4(u4, c5, "bottom"), V2 = f4(u4, c5, "top"), Ee = !u4._anchorAxis || o4 !== u4._mainSubplot, Ee && (u4.mirror === "allticks" || u4.mirror === "all") && (u4._linepositions[o4] = [O3, V2]), Ae = Le(u4, Ce, me), Ee && u4.showline && (u4.mirror === "all" || u4.mirror === "allticks") && (Ae += Ce(O3) + Ce(V2)), s3.xlines.style("stroke-width", u4._lw + "px").call(xM.stroke, u4.showline ? u4.linecolor : "rgba(0,0,0,0)")), s3.xlines.attr("d", Ae);\n                var Fe = "M0,0";\n                kce(c5, o4) && (oe = dP(c5, "bottom", u4, i3), j3 = c5._offset + c5._length + (oe ? n4 : 0), _e = dP(c5, "top", u4, i3), N2 = c5._offset - (_e ? n4 : 0), H = f4(c5, u4, "left"), te = f4(c5, u4, "right"), Ee = !c5._anchorAxis || o4 !== c5._mainSubplot, Ee && (c5.mirror === "allticks" || c5.mirror === "all") && (c5._linepositions[o4] = [H, te]), Fe = Le(c5, ie, Se), Ee && c5.showline && (c5.mirror === "all" || c5.mirror === "allticks") && (Fe += ie(H) + ie(te)), s3.ylines.style("stroke-width", c5._lw + "px").call(xM.stroke, c5.showline ? c5.linecolor : "rgba(0,0,0,0)")), s3.ylines.attr("d", Fe);\n              }\n              return bM.makeClipPaths(e3), Jp.previousPromises(e3);\n            }\n            function kce(e3, t3) {\n              return (e3.ticks || e3.showline) && (t3 === e3._mainSubplot || e3.mirror === "all" || e3.mirror === "allticks");\n            }\n            function Cce(e3, t3, r4) {\n              if (!r4.showline || !r4._lw) return false;\n              if (r4.mirror === "all" || r4.mirror === "allticks") return true;\n              var n4 = r4._anchorAxis;\n              if (!n4) return false;\n              var i3 = Cy.FROM_BL[t3];\n              return r4.side === t3 ? n4.domain[i3] === e3.domain[i3] : r4.mirror && n4.domain[1 - i3] === e3.domain[1 - i3];\n            }\n            function dP(e3, t3, r4, n4) {\n              if (Cce(e3, t3, r4)) return r4._lw;\n              for (var i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                if (a4._mainAxis === r4._mainAxis && Cce(e3, t3, a4)) return a4._lw;\n              }\n              return 0;\n            }\n            pd.drawMainTitle = function(e3) {\n              var t3 = e3._fullLayout.title, r4 = e3._fullLayout, n4 = Pft(r4), i3 = Ift(r4), a4 = Lft(r4, i3), o4 = Cft(r4, n4);\n              if (Mce.draw(e3, "gtitle", { propContainer: r4, propName: "title.text", subtitlePropName: "title.subtitle.text", placeholder: r4._dfltTitle.plot, subtitlePlaceholder: r4._dfltTitle.subtitle, attributes: { x: o4, y: a4, "text-anchor": n4, dy: i3 } }), t3.text && t3.automargin) {\n                var s3 = vP.select(e3).selectAll(".gtitle"), l3 = $3.bBox(vP.select(e3).selectAll(".g-gtitle").node()).height, u4 = Eft(e3, t3, l3);\n                if (u4 > 0) {\n                  kft(e3, a4, u4, l3), s3.attr({ x: o4, y: a4, "text-anchor": n4, dy: Lce(t3.yanchor) }).call(pN.positionText, o4, a4);\n                  var c5 = (t3.text.match(pN.BR_TAG_ALL) || []).length;\n                  if (c5) {\n                    var f4 = Cy.LINE_SPACING * c5 + Cy.MID_SHIFT;\n                    t3.y === 0 && (f4 = -f4), s3.selectAll(".line").each(function() {\n                      var b = +this.getAttribute("dy").slice(0, -2) - f4 + "em";\n                      this.setAttribute("dy", b);\n                    });\n                  }\n                  var h3 = vP.select(e3).selectAll(".gtitle-subtitle");\n                  if (h3.node()) {\n                    var d3 = s3.node().getBBox(), v3 = d3.y + d3.height, _2 = v3 + Mce.SUBTITLE_PADDING_EM * t3.subtitle.font.size;\n                    h3.attr({ x: o4, y: _2, "text-anchor": n4, dy: Lce(t3.yanchor) }).call(pN.positionText, o4, _2);\n                  }\n                }\n              }\n            };\n            function Sft(e3, t3, r4, n4, i3) {\n              var a4 = t3.yref === "paper" ? e3._fullLayout._size.h : e3._fullLayout.height, o4 = S0.isTopAnchor(t3) ? n4 : n4 - i3, s3 = r4 === "b" ? a4 - o4 : o4;\n              return S0.isTopAnchor(t3) && r4 === "t" || S0.isBottomAnchor(t3) && r4 === "b" ? false : s3 < i3;\n            }\n            function Mft(e3, t3, r4, n4, i3) {\n              var a4 = 0;\n              return r4 === "middle" && (a4 += i3 / 2), e3 === "t" ? (r4 === "top" && (a4 += i3), a4 += n4 - t3 * n4) : (r4 === "bottom" && (a4 += i3), a4 += t3 * n4), a4;\n            }\n            function Eft(e3, t3, r4) {\n              var n4 = t3.y, i3 = t3.yanchor, a4 = n4 > 0.5 ? "t" : "b", o4 = e3._fullLayout.margin[a4], s3 = 0;\n              return t3.yref === "paper" ? s3 = r4 + t3.pad.t + t3.pad.b : t3.yref === "container" && (s3 = Mft(a4, n4, i3, e3._fullLayout.height, r4) + t3.pad.t + t3.pad.b), s3 > o4 ? s3 : 0;\n            }\n            function kft(e3, t3, r4, n4) {\n              var i3 = "title.automargin", a4 = e3._fullLayout.title, o4 = a4.y > 0.5 ? "t" : "b", s3 = { x: a4.x, y: a4.y, t: 0, b: 0 }, l3 = {};\n              a4.yref === "paper" && Sft(e3, a4, o4, t3, n4) ? s3[o4] = r4 : a4.yref === "container" && (l3[o4] = r4, e3._fullLayout._reservedMargin[i3] = l3), Jp.allowAutoMargin(e3, i3), Jp.autoMargin(e3, i3, s3);\n            }\n            function Cft(e3, t3) {\n              var r4 = e3.title, n4 = e3._size, i3 = 0;\n              switch (t3 === Rce ? i3 = r4.pad.l : t3 === Dce && (i3 = -r4.pad.r), r4.xref) {\n                case "paper":\n                  return n4.l + n4.w * r4.x + i3;\n                case "container":\n                default:\n                  return e3.width * r4.x + i3;\n              }\n            }\n            function Lft(e3, t3) {\n              var r4 = e3.title, n4 = e3._size, i3 = 0;\n              if (t3 === "0em" || !t3 ? i3 = -r4.pad.b : t3 === Cy.CAP_SHIFT + "em" && (i3 = r4.pad.t), r4.y === "auto") return n4.t / 2;\n              switch (r4.yref) {\n                case "paper":\n                  return n4.t + n4.h - n4.h * r4.y + i3;\n                case "container":\n                default:\n                  return e3.height - e3.height * r4.y + i3;\n              }\n            }\n            function Lce(e3) {\n              return e3 === "top" ? Cy.CAP_SHIFT + 0.3 + "em" : e3 === "bottom" ? "-0.3em" : Cy.MID_SHIFT + "em";\n            }\n            function Pft(e3) {\n              var t3 = e3.title, r4 = bft;\n              return S0.isRightAnchor(t3) ? r4 = Dce : S0.isLeftAnchor(t3) && (r4 = Rce), r4;\n            }\n            function Ift(e3) {\n              var t3 = e3.title, r4 = "0em";\n              return S0.isTopAnchor(t3) ? r4 = Cy.CAP_SHIFT + "em" : S0.isMiddleAnchor(t3) && (r4 = Cy.MID_SHIFT + "em"), r4;\n            }\n            pd.doTraceStyle = function(e3) {\n              var t3 = e3.calcdata, r4 = [], n4;\n              for (n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4], a4 = i3[0] || {}, o4 = a4.trace || {}, s3 = o4._module || {}, l3 = s3.arraysToCalcdata;\n                l3 && l3(i3, o4);\n                var u4 = s3.editStyle;\n                u4 && r4.push({ fn: u4, cd0: a4 });\n              }\n              if (r4.length) {\n                for (n4 = 0; n4 < r4.length; n4++) {\n                  var c5 = r4[n4];\n                  c5.fn(e3, c5.cd0);\n                }\n                gN(e3), pd.redrawReglTraces(e3);\n              }\n              return Jp.style(e3), Nv.getComponentMethod("legend", "draw")(e3), Jp.previousPromises(e3);\n            };\n            pd.doColorBars = function(e3) {\n              return Nv.getComponentMethod("colorbar", "draw")(e3), Jp.previousPromises(e3);\n            };\n            pd.layoutReplot = function(e3) {\n              var t3 = e3.layout;\n              return e3.layout = void 0, Nv.call("_doPlot", e3, "", t3);\n            };\n            pd.doLegend = function(e3) {\n              return Nv.getComponentMethod("legend", "draw")(e3), Jp.previousPromises(e3);\n            };\n            pd.doTicksRelayout = function(e3) {\n              return bM.draw(e3, "redraw"), e3._fullLayout._hasOnlyLargeSploms && (Nv.subplotsRegistry.splom.updateGrid(e3), gN(e3), pd.redrawReglTraces(e3)), pd.drawMainTitle(e3), Jp.previousPromises(e3);\n            };\n            pd.doModeBar = function(e3) {\n              var t3 = e3._fullLayout;\n              Pce.manage(e3);\n              for (var r4 = 0; r4 < t3._basePlotModules.length; r4++) {\n                var n4 = t3._basePlotModules[r4].updateFx;\n                n4 && n4(e3);\n              }\n              return Jp.previousPromises(e3);\n            };\n            pd.doCamera = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots.gl3d, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]], a4 = i3._scene;\n                a4.setViewport(i3);\n              }\n            };\n            pd.drawData = function(e3) {\n              var t3 = e3._fullLayout;\n              gN(e3);\n              for (var r4 = t3._basePlotModules, n4 = 0; n4 < r4.length; n4++) r4[n4].plot(e3);\n              return pd.redrawReglTraces(e3), Jp.style(e3), Nv.getComponentMethod("selections", "draw")(e3), Nv.getComponentMethod("shapes", "draw")(e3), Nv.getComponentMethod("annotations", "draw")(e3), Nv.getComponentMethod("images", "draw")(e3), t3._replotting = false, Jp.previousPromises(e3);\n            };\n            pd.redrawReglTraces = function(e3) {\n              var t3 = e3._fullLayout;\n              if (t3._has("regl")) {\n                var r4 = e3._fullData, n4 = [], i3 = [], a4, o4;\n                for (t3._hasOnlyLargeSploms && t3._splomGrid.draw(), a4 = 0; a4 < r4.length; a4++) {\n                  var s3 = r4[a4];\n                  s3.visible === true && s3._length !== 0 && (s3.type === "splom" ? t3._splomScenes[s3.uid].draw() : s3.type === "scattergl" ? S0.pushUnique(n4, s3.xaxis + s3.yaxis) : s3.type === "scatterpolargl" && S0.pushUnique(i3, s3.subplot));\n                }\n                for (a4 = 0; a4 < n4.length; a4++) o4 = t3._plots[n4[a4]], o4._scene && o4._scene.draw();\n                for (a4 = 0; a4 < i3.length; a4++) o4 = t3[i3[a4]]._subplot, o4._scene && o4._scene.draw();\n              }\n            };\n            pd.doAutoRangeAndConstraints = function(e3) {\n              for (var t3 = bM.list(e3, "", true), r4, n4 = {}, i3 = 0; i3 < t3.length; i3++) if (r4 = t3[i3], !n4[r4._id]) {\n                n4[r4._id] = 1, xft(e3, r4), Ece(e3, r4);\n                var a4 = r4._matchGroup;\n                if (a4) for (var o4 in a4) {\n                  var s3 = bM.getFromId(e3, o4);\n                  Ece(e3, s3, r4.range), n4[o4] = 1;\n                }\n              }\n              _ft(e3);\n            };\n            pd.finalDraw = function(e3) {\n              Nv.getComponentMethod("rangeslider", "draw")(e3), Nv.getComponentMethod("rangeselector", "draw")(e3);\n            };\n            pd.drawMarginPushers = function(e3) {\n              Nv.getComponentMethod("legend", "draw")(e3), Nv.getComponentMethod("rangeselector", "draw")(e3), Nv.getComponentMethod("sliders", "draw")(e3), Nv.getComponentMethod("updatemenus", "draw")(e3), Nv.getComponentMethod("colorbar", "draw")(e3);\n            };\n          });\n          var _N = ye((Zar, Bce) => {\n            "use strict";\n            var Rft = u_().readPaths, Dft = nP(), Fce = Q1().clearOutlineControllers, mN = ka(), zce = So(), Fft = vl().arrayEditor, Oce = f_(), zft = Oce.getPathString;\n            Bce.exports = { draw: pP, drawOne: qce, activateLastSelection: Bft };\n            function pP(e3) {\n              var t3 = e3._fullLayout;\n              Fce(e3), t3._selectionLayer.selectAll("path").remove();\n              for (var r4 in t3._plots) {\n                var n4 = t3._plots[r4].selectionLayer;\n                n4 && n4.selectAll("path").remove();\n              }\n              for (var i3 = 0; i3 < t3.selections.length; i3++) qce(e3, i3);\n            }\n            function gP(e3) {\n              return e3._context.editSelection;\n            }\n            function qce(e3, t3) {\n              e3._fullLayout._paperdiv.selectAll(\'.selectionlayer [data-index="\' + t3 + \'"]\').remove();\n              var r4 = Oce.makeSelectionsOptionsAndPlotinfo(e3, t3), n4 = r4.options, i3 = r4.plotinfo;\n              if (!n4._input) return;\n              a4(e3._fullLayout._selectionLayer);\n              function a4(o4) {\n                var s3 = zft(e3, n4), l3 = { "data-index": t3, "fill-rule": "evenodd", d: s3 }, u4 = n4.opacity, c5 = "rgba(0,0,0,0)", f4 = n4.line.color || mN.contrast(e3._fullLayout.plot_bgcolor), h3 = n4.line.width, d3 = n4.line.dash;\n                h3 || (h3 = 5, d3 = "solid");\n                var v3 = gP(e3) && e3._fullLayout._activeSelectionIndex === t3;\n                v3 && (c5 = e3._fullLayout.activeselection.fillcolor, u4 = e3._fullLayout.activeselection.opacity);\n                for (var _2 = [], b = 1; b >= 0; b--) {\n                  var p3 = o4.append("path").attr(l3).style("opacity", b ? 0.1 : u4).call(mN.stroke, f4).call(mN.fill, c5).call(zce.dashLine, b ? "solid" : d3, b ? 4 + h3 : h3);\n                  if (Oft(p3, e3, n4), v3) {\n                    var k4 = Fft(e3.layout, "selections", n4);\n                    p3.style({ cursor: "move" });\n                    var E3 = { element: p3.node(), plotinfo: i3, gd: e3, editHelpers: k4, isActiveSelection: true }, S2 = Rft(s3, e3);\n                    Dft(S2, p3, E3);\n                  } else p3.style("pointer-events", b ? "all" : "none");\n                  _2[b] = p3;\n                }\n                var L3 = _2[0], x2 = _2[1];\n                x2.node().addEventListener("click", function() {\n                  return qft(e3, L3);\n                });\n              }\n            }\n            function Oft(e3, t3, r4) {\n              var n4 = r4.xref + r4.yref;\n              zce.setClipUrl(e3, "clip" + t3._fullLayout._uid + n4, t3);\n            }\n            function qft(e3, t3) {\n              if (gP(e3)) {\n                var r4 = t3.node(), n4 = +r4.getAttribute("data-index");\n                if (n4 >= 0) {\n                  if (n4 === e3._fullLayout._activeSelectionIndex) {\n                    yN(e3);\n                    return;\n                  }\n                  e3._fullLayout._activeSelectionIndex = n4, e3._fullLayout._deactivateSelection = yN, pP(e3);\n                }\n              }\n            }\n            function Bft(e3) {\n              if (gP(e3)) {\n                var t3 = e3._fullLayout.selections.length - 1;\n                e3._fullLayout._activeSelectionIndex = t3, e3._fullLayout._deactivateSelection = yN, pP(e3);\n              }\n            }\n            function yN(e3) {\n              if (gP(e3)) {\n                var t3 = e3._fullLayout._activeSelectionIndex;\n                t3 >= 0 && (Fce(e3), delete e3._fullLayout._activeSelectionIndex, pP(e3));\n              }\n            }\n          });\n          var Uce = ye((Yar, Nce) => {\n            function Nft() {\n              var e3, t3 = 0, r4 = false;\n              function n4(i3, a4) {\n                return e3.list.push({ type: i3, data: a4 ? JSON.parse(JSON.stringify(a4)) : void 0 }), e3;\n              }\n              return e3 = { list: [], segmentId: function() {\n                return t3++;\n              }, checkIntersection: function(i3, a4) {\n                return n4("check", { seg1: i3, seg2: a4 });\n              }, segmentChop: function(i3, a4) {\n                return n4("div_seg", { seg: i3, pt: a4 }), n4("chop", { seg: i3, pt: a4 });\n              }, statusRemove: function(i3) {\n                return n4("pop_seg", { seg: i3 });\n              }, segmentUpdate: function(i3) {\n                return n4("seg_update", { seg: i3 });\n              }, segmentNew: function(i3, a4) {\n                return n4("new_seg", { seg: i3, primary: a4 });\n              }, segmentRemove: function(i3) {\n                return n4("rem_seg", { seg: i3 });\n              }, tempStatus: function(i3, a4, o4) {\n                return n4("temp_status", { seg: i3, above: a4, below: o4 });\n              }, rewind: function(i3) {\n                return n4("rewind", { seg: i3 });\n              }, status: function(i3, a4, o4) {\n                return n4("status", { seg: i3, above: a4, below: o4 });\n              }, vert: function(i3) {\n                return i3 === r4 ? e3 : (r4 = i3, n4("vert", { x: i3 }));\n              }, log: function(i3) {\n                return typeof i3 != "string" && (i3 = JSON.stringify(i3, false, "  ")), n4("log", { txt: i3 });\n              }, reset: function() {\n                return n4("reset");\n              }, selected: function(i3) {\n                return n4("selected", { segs: i3 });\n              }, chainStart: function(i3) {\n                return n4("chain_start", { seg: i3 });\n              }, chainRemoveHead: function(i3, a4) {\n                return n4("chain_rem_head", { index: i3, pt: a4 });\n              }, chainRemoveTail: function(i3, a4) {\n                return n4("chain_rem_tail", { index: i3, pt: a4 });\n              }, chainNew: function(i3, a4) {\n                return n4("chain_new", { pt1: i3, pt2: a4 });\n              }, chainMatch: function(i3) {\n                return n4("chain_match", { index: i3 });\n              }, chainClose: function(i3) {\n                return n4("chain_close", { index: i3 });\n              }, chainAddHead: function(i3, a4) {\n                return n4("chain_add_head", { index: i3, pt: a4 });\n              }, chainAddTail: function(i3, a4) {\n                return n4("chain_add_tail", { index: i3, pt: a4 });\n              }, chainConnect: function(i3, a4) {\n                return n4("chain_con", { index1: i3, index2: a4 });\n              }, chainReverse: function(i3) {\n                return n4("chain_rev", { index: i3 });\n              }, chainJoin: function(i3, a4) {\n                return n4("chain_join", { index1: i3, index2: a4 });\n              }, done: function() {\n                return n4("done");\n              } }, e3;\n            }\n            Nce.exports = Nft;\n          });\n          var Gce = ye((Kar, Vce) => {\n            function Uft(e3) {\n              typeof e3 != "number" && (e3 = 1e-10);\n              var t3 = { epsilon: function(r4) {\n                return typeof r4 == "number" && (e3 = r4), e3;\n              }, pointAboveOrOnLine: function(r4, n4, i3) {\n                var a4 = n4[0], o4 = n4[1], s3 = i3[0], l3 = i3[1], u4 = r4[0], c5 = r4[1];\n                return (s3 - a4) * (c5 - o4) - (l3 - o4) * (u4 - a4) >= -e3;\n              }, pointBetween: function(r4, n4, i3) {\n                var a4 = r4[1] - n4[1], o4 = i3[0] - n4[0], s3 = r4[0] - n4[0], l3 = i3[1] - n4[1], u4 = s3 * o4 + a4 * l3;\n                if (u4 < e3) return false;\n                var c5 = o4 * o4 + l3 * l3;\n                return !(u4 - c5 > -e3);\n              }, pointsSameX: function(r4, n4) {\n                return Math.abs(r4[0] - n4[0]) < e3;\n              }, pointsSameY: function(r4, n4) {\n                return Math.abs(r4[1] - n4[1]) < e3;\n              }, pointsSame: function(r4, n4) {\n                return t3.pointsSameX(r4, n4) && t3.pointsSameY(r4, n4);\n              }, pointsCompare: function(r4, n4) {\n                return t3.pointsSameX(r4, n4) ? t3.pointsSameY(r4, n4) ? 0 : r4[1] < n4[1] ? -1 : 1 : r4[0] < n4[0] ? -1 : 1;\n              }, pointsCollinear: function(r4, n4, i3) {\n                var a4 = r4[0] - n4[0], o4 = r4[1] - n4[1], s3 = n4[0] - i3[0], l3 = n4[1] - i3[1];\n                return Math.abs(a4 * l3 - s3 * o4) < e3;\n              }, linesIntersect: function(r4, n4, i3, a4) {\n                var o4 = n4[0] - r4[0], s3 = n4[1] - r4[1], l3 = a4[0] - i3[0], u4 = a4[1] - i3[1], c5 = o4 * u4 - s3 * l3;\n                if (Math.abs(c5) < e3) return false;\n                var f4 = r4[0] - i3[0], h3 = r4[1] - i3[1], d3 = (l3 * h3 - u4 * f4) / c5, v3 = (o4 * h3 - s3 * f4) / c5, _2 = { alongA: 0, alongB: 0, pt: [r4[0] + d3 * o4, r4[1] + d3 * s3] };\n                return d3 <= -e3 ? _2.alongA = -2 : d3 < e3 ? _2.alongA = -1 : d3 - 1 <= -e3 ? _2.alongA = 0 : d3 - 1 < e3 ? _2.alongA = 1 : _2.alongA = 2, v3 <= -e3 ? _2.alongB = -2 : v3 < e3 ? _2.alongB = -1 : v3 - 1 <= -e3 ? _2.alongB = 0 : v3 - 1 < e3 ? _2.alongB = 1 : _2.alongB = 2, _2;\n              }, pointInsideRegion: function(r4, n4) {\n                for (var i3 = r4[0], a4 = r4[1], o4 = n4[n4.length - 1][0], s3 = n4[n4.length - 1][1], l3 = false, u4 = 0; u4 < n4.length; u4++) {\n                  var c5 = n4[u4][0], f4 = n4[u4][1];\n                  f4 - a4 > e3 != s3 - a4 > e3 && (o4 - c5) * (a4 - f4) / (s3 - f4) + c5 - i3 > e3 && (l3 = !l3), o4 = c5, s3 = f4;\n                }\n                return l3;\n              } };\n              return t3;\n            }\n            Vce.exports = Uft;\n          });\n          var jce = ye((Jar, Hce) => {\n            var Vft = { create: function() {\n              var e3 = { root: { root: true, next: null }, exists: function(t3) {\n                return !(t3 === null || t3 === e3.root);\n              }, isEmpty: function() {\n                return e3.root.next === null;\n              }, getHead: function() {\n                return e3.root.next;\n              }, insertBefore: function(t3, r4) {\n                for (var n4 = e3.root, i3 = e3.root.next; i3 !== null; ) {\n                  if (r4(i3)) {\n                    t3.prev = i3.prev, t3.next = i3, i3.prev.next = t3, i3.prev = t3;\n                    return;\n                  }\n                  n4 = i3, i3 = i3.next;\n                }\n                n4.next = t3, t3.prev = n4, t3.next = null;\n              }, findTransition: function(t3) {\n                for (var r4 = e3.root, n4 = e3.root.next; n4 !== null && !t3(n4); ) r4 = n4, n4 = n4.next;\n                return { before: r4 === e3.root ? null : r4, after: n4, insert: function(i3) {\n                  return i3.prev = r4, i3.next = n4, r4.next = i3, n4 !== null && (n4.prev = i3), i3;\n                } };\n              } };\n              return e3;\n            }, node: function(e3) {\n              return e3.prev = null, e3.next = null, e3.remove = function() {\n                e3.prev.next = e3.next, e3.next && (e3.next.prev = e3.prev), e3.prev = null, e3.next = null;\n              }, e3;\n            } };\n            Hce.exports = Vft;\n          });\n          var Xce = ye(($ar, Wce) => {\n            var TM = jce();\n            function Gft(e3, t3, r4) {\n              function n4(v3, _2) {\n                return { id: r4 ? r4.segmentId() : -1, start: v3, end: _2, myFill: { above: null, below: null }, otherFill: null };\n              }\n              function i3(v3, _2, b) {\n                return { id: r4 ? r4.segmentId() : -1, start: v3, end: _2, myFill: { above: b.myFill.above, below: b.myFill.below }, otherFill: null };\n              }\n              var a4 = TM.create();\n              function o4(v3, _2, b, p3, k4, E3) {\n                var S2 = t3.pointsCompare(_2, k4);\n                return S2 !== 0 ? S2 : t3.pointsSame(b, E3) ? 0 : v3 !== p3 ? v3 ? 1 : -1 : t3.pointAboveOrOnLine(b, p3 ? k4 : E3, p3 ? E3 : k4) ? 1 : -1;\n              }\n              function s3(v3, _2) {\n                a4.insertBefore(v3, function(b) {\n                  var p3 = o4(v3.isStart, v3.pt, _2, b.isStart, b.pt, b.other.pt);\n                  return p3 < 0;\n                });\n              }\n              function l3(v3, _2) {\n                var b = TM.node({ isStart: true, pt: v3.start, seg: v3, primary: _2, other: null, status: null });\n                return s3(b, v3.end), b;\n              }\n              function u4(v3, _2, b) {\n                var p3 = TM.node({ isStart: false, pt: _2.end, seg: _2, primary: b, other: v3, status: null });\n                v3.other = p3, s3(p3, v3.pt);\n              }\n              function c5(v3, _2) {\n                var b = l3(v3, _2);\n                return u4(b, v3, _2), b;\n              }\n              function f4(v3, _2) {\n                r4 && r4.segmentChop(v3.seg, _2), v3.other.remove(), v3.seg.end = _2, v3.other.pt = _2, s3(v3.other, v3.pt);\n              }\n              function h3(v3, _2) {\n                var b = i3(_2, v3.seg.end, v3.seg);\n                return f4(v3, _2), c5(b, v3.primary);\n              }\n              function d3(v3, _2) {\n                var b = TM.create();\n                function p3(G2, Z) {\n                  var j3 = G2.seg.start, N2 = G2.seg.end, H = Z.seg.start, te = Z.seg.end;\n                  return t3.pointsCollinear(j3, H, te) ? t3.pointsCollinear(N2, H, te) || t3.pointAboveOrOnLine(N2, H, te) ? 1 : -1 : t3.pointAboveOrOnLine(j3, H, te) ? 1 : -1;\n                }\n                function k4(G2) {\n                  return b.findTransition(function(Z) {\n                    var j3 = p3(G2, Z.ev);\n                    return j3 > 0;\n                  });\n                }\n                function E3(G2, Z) {\n                  var j3 = G2.seg, N2 = Z.seg, H = j3.start, te = j3.end, oe = N2.start, _e = N2.end;\n                  r4 && r4.checkIntersection(j3, N2);\n                  var Ee = t3.linesIntersect(H, te, oe, _e);\n                  if (Ee === false) {\n                    if (!t3.pointsCollinear(H, te, oe) || t3.pointsSame(H, _e) || t3.pointsSame(te, oe)) return false;\n                    var Ce = t3.pointsSame(H, oe), me = t3.pointsSame(te, _e);\n                    if (Ce && me) return Z;\n                    var ie = !Ce && t3.pointBetween(H, oe, _e), Se = !me && t3.pointBetween(te, oe, _e);\n                    if (Ce) return Se ? h3(Z, te) : h3(G2, _e), Z;\n                    ie && (me || (Se ? h3(Z, te) : h3(G2, _e)), h3(Z, H));\n                  } else Ee.alongA === 0 && (Ee.alongB === -1 ? h3(G2, oe) : Ee.alongB === 0 ? h3(G2, Ee.pt) : Ee.alongB === 1 && h3(G2, _e)), Ee.alongB === 0 && (Ee.alongA === -1 ? h3(Z, H) : Ee.alongA === 0 ? h3(Z, Ee.pt) : Ee.alongA === 1 && h3(Z, te));\n                  return false;\n                }\n                for (var S2 = []; !a4.isEmpty(); ) {\n                  var L3 = a4.getHead();\n                  if (r4 && r4.vert(L3.pt[0]), L3.isStart) {\n                    let G2 = function() {\n                      if (C3) {\n                        var Z = E3(L3, C3);\n                        if (Z) return Z;\n                      }\n                      return M4 ? E3(L3, M4) : false;\n                    };\n                    var V2 = G2;\n                    r4 && r4.segmentNew(L3.seg, L3.primary);\n                    var x2 = k4(L3), C3 = x2.before ? x2.before.ev : null, M4 = x2.after ? x2.after.ev : null;\n                    r4 && r4.tempStatus(L3.seg, C3 ? C3.seg : false, M4 ? M4.seg : false);\n                    var g3 = G2();\n                    if (g3) {\n                      if (e3) {\n                        var P3;\n                        L3.seg.myFill.below === null ? P3 = true : P3 = L3.seg.myFill.above !== L3.seg.myFill.below, P3 && (g3.seg.myFill.above = !g3.seg.myFill.above);\n                      } else g3.seg.otherFill = L3.seg.myFill;\n                      r4 && r4.segmentUpdate(g3.seg), L3.other.remove(), L3.remove();\n                    }\n                    if (a4.getHead() !== L3) {\n                      r4 && r4.rewind(L3.seg);\n                      continue;\n                    }\n                    if (e3) {\n                      var P3;\n                      L3.seg.myFill.below === null ? P3 = true : P3 = L3.seg.myFill.above !== L3.seg.myFill.below, M4 ? L3.seg.myFill.below = M4.seg.myFill.above : L3.seg.myFill.below = v3, P3 ? L3.seg.myFill.above = !L3.seg.myFill.below : L3.seg.myFill.above = L3.seg.myFill.below;\n                    } else if (L3.seg.otherFill === null) {\n                      var T3;\n                      M4 ? L3.primary === M4.primary ? T3 = M4.seg.otherFill.above : T3 = M4.seg.myFill.above : T3 = L3.primary ? _2 : v3, L3.seg.otherFill = { above: T3, below: T3 };\n                    }\n                    r4 && r4.status(L3.seg, C3 ? C3.seg : false, M4 ? M4.seg : false), L3.other.status = x2.insert(TM.node({ ev: L3 }));\n                  } else {\n                    var z3 = L3.status;\n                    if (z3 === null) throw new Error("PolyBool: Zero-length segment detected; your epsilon is probably too small or too large");\n                    if (b.exists(z3.prev) && b.exists(z3.next) && E3(z3.prev.ev, z3.next.ev), r4 && r4.statusRemove(z3.ev.seg), z3.remove(), !L3.primary) {\n                      var O3 = L3.seg.myFill;\n                      L3.seg.myFill = L3.seg.otherFill, L3.seg.otherFill = O3;\n                    }\n                    S2.push(L3.seg);\n                  }\n                  a4.getHead().remove();\n                }\n                return r4 && r4.done(), S2;\n              }\n              return e3 ? { addRegion: function(v3) {\n                for (var _2, b = v3[v3.length - 1], p3 = 0; p3 < v3.length; p3++) {\n                  _2 = b, b = v3[p3];\n                  var k4 = t3.pointsCompare(_2, b);\n                  k4 !== 0 && c5(n4(k4 < 0 ? _2 : b, k4 < 0 ? b : _2), true);\n                }\n              }, calculate: function(v3) {\n                return d3(v3, false);\n              } } : { calculate: function(v3, _2, b, p3) {\n                return v3.forEach(function(k4) {\n                  c5(i3(k4.start, k4.end, k4), true);\n                }), b.forEach(function(k4) {\n                  c5(i3(k4.start, k4.end, k4), false);\n                }), d3(_2, p3);\n              } };\n            }\n            Wce.exports = Gft;\n          });\n          var Yce = ye((Qar, Zce) => {\n            function Hft(e3, t3, r4) {\n              var n4 = [], i3 = [];\n              return e3.forEach(function(a4) {\n                var o4 = a4.start, s3 = a4.end;\n                if (t3.pointsSame(o4, s3)) {\n                  console.warn("PolyBool: Warning: Zero-length segment detected; your epsilon is probably too small or too large");\n                  return;\n                }\n                r4 && r4.chainStart(a4);\n                var l3 = { index: 0, matches_head: false, matches_pt1: false }, u4 = { index: 0, matches_head: false, matches_pt1: false }, c5 = l3;\n                function f4(V2, G2, Z) {\n                  return c5.index = V2, c5.matches_head = G2, c5.matches_pt1 = Z, c5 === l3 ? (c5 = u4, false) : (c5 = null, true);\n                }\n                for (var h3 = 0; h3 < n4.length; h3++) {\n                  var d3 = n4[h3], v3 = d3[0], _2 = d3[1], b = d3[d3.length - 1], p3 = d3[d3.length - 2];\n                  if (t3.pointsSame(v3, o4)) {\n                    if (f4(h3, true, true)) break;\n                  } else if (t3.pointsSame(v3, s3)) {\n                    if (f4(h3, true, false)) break;\n                  } else if (t3.pointsSame(b, o4)) {\n                    if (f4(h3, false, true)) break;\n                  } else if (t3.pointsSame(b, s3) && f4(h3, false, false)) break;\n                }\n                if (c5 === l3) {\n                  n4.push([o4, s3]), r4 && r4.chainNew(o4, s3);\n                  return;\n                }\n                if (c5 === u4) {\n                  r4 && r4.chainMatch(l3.index);\n                  var k4 = l3.index, E3 = l3.matches_pt1 ? s3 : o4, S2 = l3.matches_head, d3 = n4[k4], L3 = S2 ? d3[0] : d3[d3.length - 1], x2 = S2 ? d3[1] : d3[d3.length - 2], C3 = S2 ? d3[d3.length - 1] : d3[0], M4 = S2 ? d3[d3.length - 2] : d3[1];\n                  if (t3.pointsCollinear(x2, L3, E3) && (S2 ? (r4 && r4.chainRemoveHead(l3.index, E3), d3.shift()) : (r4 && r4.chainRemoveTail(l3.index, E3), d3.pop()), L3 = x2), t3.pointsSame(C3, E3)) {\n                    n4.splice(k4, 1), t3.pointsCollinear(M4, C3, L3) && (S2 ? (r4 && r4.chainRemoveTail(l3.index, L3), d3.pop()) : (r4 && r4.chainRemoveHead(l3.index, L3), d3.shift())), r4 && r4.chainClose(l3.index), i3.push(d3);\n                    return;\n                  }\n                  S2 ? (r4 && r4.chainAddHead(l3.index, E3), d3.unshift(E3)) : (r4 && r4.chainAddTail(l3.index, E3), d3.push(E3));\n                  return;\n                }\n                function g3(V2) {\n                  r4 && r4.chainReverse(V2), n4[V2].reverse();\n                }\n                function P3(V2, G2) {\n                  var Z = n4[V2], j3 = n4[G2], N2 = Z[Z.length - 1], H = Z[Z.length - 2], te = j3[0], oe = j3[1];\n                  t3.pointsCollinear(H, N2, te) && (r4 && r4.chainRemoveTail(V2, N2), Z.pop(), N2 = H), t3.pointsCollinear(N2, te, oe) && (r4 && r4.chainRemoveHead(G2, te), j3.shift()), r4 && r4.chainJoin(V2, G2), n4[V2] = Z.concat(j3), n4.splice(G2, 1);\n                }\n                var T3 = l3.index, z3 = u4.index;\n                r4 && r4.chainConnect(T3, z3);\n                var O3 = n4[T3].length < n4[z3].length;\n                l3.matches_head ? u4.matches_head ? O3 ? (g3(T3), P3(T3, z3)) : (g3(z3), P3(z3, T3)) : P3(z3, T3) : u4.matches_head ? P3(T3, z3) : O3 ? (g3(T3), P3(z3, T3)) : (g3(z3), P3(T3, z3));\n              }), i3;\n            }\n            Zce.exports = Hft;\n          });\n          var Jce = ye((eor, Kce) => {\n            function AM(e3, t3, r4) {\n              var n4 = [];\n              return e3.forEach(function(i3) {\n                var a4 = (i3.myFill.above ? 8 : 0) + (i3.myFill.below ? 4 : 0) + (i3.otherFill && i3.otherFill.above ? 2 : 0) + (i3.otherFill && i3.otherFill.below ? 1 : 0);\n                t3[a4] !== 0 && n4.push({ id: r4 ? r4.segmentId() : -1, start: i3.start, end: i3.end, myFill: { above: t3[a4] === 1, below: t3[a4] === 2 }, otherFill: null });\n              }), r4 && r4.selected(n4), n4;\n            }\n            var jft = { union: function(e3, t3) {\n              return AM(e3, [0, 2, 1, 0, 2, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0], t3);\n            }, intersect: function(e3, t3) {\n              return AM(e3, [0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 1, 1, 0, 2, 1, 0], t3);\n            }, difference: function(e3, t3) {\n              return AM(e3, [0, 0, 0, 0, 2, 0, 2, 0, 1, 1, 0, 0, 0, 1, 2, 0], t3);\n            }, differenceRev: function(e3, t3) {\n              return AM(e3, [0, 2, 1, 0, 0, 0, 1, 1, 0, 2, 0, 2, 0, 0, 0, 0], t3);\n            }, xor: function(e3, t3) {\n              return AM(e3, [0, 2, 1, 0, 2, 0, 0, 1, 1, 0, 0, 2, 0, 1, 2, 0], t3);\n            } };\n            Kce.exports = jft;\n          });\n          var Qce = ye((tor, $ce) => {\n            var Wft = { toPolygon: function(e3, t3) {\n              function r4(a4) {\n                if (a4.length <= 0) return e3.segments({ inverted: false, regions: [] });\n                function o4(u4) {\n                  var c5 = u4.slice(0, u4.length - 1);\n                  return e3.segments({ inverted: false, regions: [c5] });\n                }\n                for (var s3 = o4(a4[0]), l3 = 1; l3 < a4.length; l3++) s3 = e3.selectDifference(e3.combine(s3, o4(a4[l3])));\n                return s3;\n              }\n              if (t3.type === "Polygon") return e3.polygon(r4(t3.coordinates));\n              if (t3.type === "MultiPolygon") {\n                for (var n4 = e3.segments({ inverted: false, regions: [] }), i3 = 0; i3 < t3.coordinates.length; i3++) n4 = e3.selectUnion(e3.combine(n4, r4(t3.coordinates[i3])));\n                return e3.polygon(n4);\n              }\n              throw new Error("PolyBool: Cannot convert GeoJSON object to PolyBool polygon");\n            }, fromPolygon: function(e3, t3, r4) {\n              r4 = e3.polygon(e3.segments(r4));\n              function n4(d3, v3) {\n                return t3.pointInsideRegion([(d3[0][0] + d3[1][0]) * 0.5, (d3[0][1] + d3[1][1]) * 0.5], v3);\n              }\n              function i3(d3) {\n                return { region: d3, children: [] };\n              }\n              var a4 = i3(null);\n              function o4(d3, v3) {\n                for (var _2 = 0; _2 < d3.children.length; _2++) {\n                  var b = d3.children[_2];\n                  if (n4(v3, b.region)) {\n                    o4(b, v3);\n                    return;\n                  }\n                }\n                for (var p3 = i3(v3), _2 = 0; _2 < d3.children.length; _2++) {\n                  var b = d3.children[_2];\n                  n4(b.region, v3) && (p3.children.push(b), d3.children.splice(_2, 1), _2--);\n                }\n                d3.children.push(p3);\n              }\n              for (var s3 = 0; s3 < r4.regions.length; s3++) {\n                var l3 = r4.regions[s3];\n                l3.length < 3 || o4(a4, l3);\n              }\n              function u4(d3, v3) {\n                for (var _2 = 0, b = d3[d3.length - 1][0], p3 = d3[d3.length - 1][1], k4 = [], E3 = 0; E3 < d3.length; E3++) {\n                  var S2 = d3[E3][0], L3 = d3[E3][1];\n                  k4.push([S2, L3]), _2 += L3 * b - S2 * p3, b = S2, p3 = L3;\n                }\n                var x2 = _2 < 0;\n                return x2 !== v3 && k4.reverse(), k4.push([k4[0][0], k4[0][1]]), k4;\n              }\n              var c5 = [];\n              function f4(d3) {\n                var v3 = [u4(d3.region, false)];\n                c5.push(v3);\n                for (var _2 = 0; _2 < d3.children.length; _2++) v3.push(h3(d3.children[_2]));\n              }\n              function h3(d3) {\n                for (var v3 = 0; v3 < d3.children.length; v3++) f4(d3.children[v3]);\n                return u4(d3.region, true);\n              }\n              for (var s3 = 0; s3 < a4.children.length; s3++) f4(a4.children[s3]);\n              return c5.length <= 0 ? { type: "Polygon", coordinates: [] } : c5.length == 1 ? { type: "Polygon", coordinates: c5[0] } : { type: "MultiPolygon", coordinates: c5 };\n            } };\n            $ce.exports = Wft;\n          });\n          var ife = ye((ror, rfe) => {\n            var Xft = Uce(), Zft = Gce(), efe = Xce(), Yft = Yce(), SM = Jce(), tfe = Qce(), M0 = false, MM = Zft(), kp;\n            kp = { buildLog: function(e3) {\n              return e3 === true ? M0 = Xft() : e3 === false && (M0 = false), M0 === false ? false : M0.list;\n            }, epsilon: function(e3) {\n              return MM.epsilon(e3);\n            }, segments: function(e3) {\n              var t3 = efe(true, MM, M0);\n              return e3.regions.forEach(t3.addRegion), { segments: t3.calculate(e3.inverted), inverted: e3.inverted };\n            }, combine: function(e3, t3) {\n              var r4 = efe(false, MM, M0);\n              return { combined: r4.calculate(e3.segments, e3.inverted, t3.segments, t3.inverted), inverted1: e3.inverted, inverted2: t3.inverted };\n            }, selectUnion: function(e3) {\n              return { segments: SM.union(e3.combined, M0), inverted: e3.inverted1 || e3.inverted2 };\n            }, selectIntersect: function(e3) {\n              return { segments: SM.intersect(e3.combined, M0), inverted: e3.inverted1 && e3.inverted2 };\n            }, selectDifference: function(e3) {\n              return { segments: SM.difference(e3.combined, M0), inverted: e3.inverted1 && !e3.inverted2 };\n            }, selectDifferenceRev: function(e3) {\n              return { segments: SM.differenceRev(e3.combined, M0), inverted: !e3.inverted1 && e3.inverted2 };\n            }, selectXor: function(e3) {\n              return { segments: SM.xor(e3.combined, M0), inverted: e3.inverted1 !== e3.inverted2 };\n            }, polygon: function(e3) {\n              return { regions: Yft(e3.segments, MM, M0), inverted: e3.inverted };\n            }, polygonFromGeoJSON: function(e3) {\n              return tfe.toPolygon(kp, e3);\n            }, polygonToGeoJSON: function(e3) {\n              return tfe.fromPolygon(kp, MM, e3);\n            }, union: function(e3, t3) {\n              return EM(e3, t3, kp.selectUnion);\n            }, intersect: function(e3, t3) {\n              return EM(e3, t3, kp.selectIntersect);\n            }, difference: function(e3, t3) {\n              return EM(e3, t3, kp.selectDifference);\n            }, differenceRev: function(e3, t3) {\n              return EM(e3, t3, kp.selectDifferenceRev);\n            }, xor: function(e3, t3) {\n              return EM(e3, t3, kp.selectXor);\n            } };\n            function EM(e3, t3, r4) {\n              var n4 = kp.segments(e3), i3 = kp.segments(t3), a4 = kp.combine(n4, i3), o4 = r4(a4);\n              return kp.polygon(o4);\n            }\n            typeof window == "object" && (window.PolyBool = kp);\n            rfe.exports = kp;\n          });\n          var afe = ye((ior, nfe) => {\n            nfe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3[0], o4 = t3[1], s3 = false;\n              n4 === void 0 && (n4 = 0), i3 === void 0 && (i3 = r4.length);\n              for (var l3 = i3 - n4, u4 = 0, c5 = l3 - 1; u4 < l3; c5 = u4++) {\n                var f4 = r4[u4 + n4][0], h3 = r4[u4 + n4][1], d3 = r4[c5 + n4][0], v3 = r4[c5 + n4][1], _2 = h3 > o4 != v3 > o4 && a4 < (d3 - f4) * (o4 - h3) / (v3 - h3) + f4;\n                _2 && (s3 = !s3);\n              }\n              return s3;\n            };\n          });\n          var kM = ye((nor, ofe) => {\n            "use strict";\n            var xN = T6().dot, mP = fs().BADNUM, yP = ofe.exports = {};\n            yP.tester = function(t3) {\n              var r4 = t3.slice(), n4 = r4[0][0], i3 = n4, a4 = r4[0][1], o4 = a4, s3;\n              for ((r4[r4.length - 1][0] !== r4[0][0] || r4[r4.length - 1][1] !== r4[0][1]) && r4.push(r4[0]), s3 = 1; s3 < r4.length; s3++) n4 = Math.min(n4, r4[s3][0]), i3 = Math.max(i3, r4[s3][0]), a4 = Math.min(a4, r4[s3][1]), o4 = Math.max(o4, r4[s3][1]);\n              var l3 = false, u4;\n              r4.length === 5 && (r4[0][0] === r4[1][0] ? r4[2][0] === r4[3][0] && r4[0][1] === r4[3][1] && r4[1][1] === r4[2][1] && (l3 = true, u4 = function(v3) {\n                return v3[0] === r4[0][0];\n              }) : r4[0][1] === r4[1][1] && r4[2][1] === r4[3][1] && r4[0][0] === r4[3][0] && r4[1][0] === r4[2][0] && (l3 = true, u4 = function(v3) {\n                return v3[1] === r4[0][1];\n              }));\n              function c5(v3, _2) {\n                var b = v3[0], p3 = v3[1];\n                return !(b === mP || b < n4 || b > i3 || p3 === mP || p3 < a4 || p3 > o4 || _2 && u4(v3));\n              }\n              function f4(v3, _2) {\n                var b = v3[0], p3 = v3[1];\n                if (b === mP || b < n4 || b > i3 || p3 === mP || p3 < a4 || p3 > o4) return false;\n                var k4 = r4.length, E3 = r4[0][0], S2 = r4[0][1], L3 = 0, x2, C3, M4, g3, P3;\n                for (x2 = 1; x2 < k4; x2++) if (C3 = E3, M4 = S2, E3 = r4[x2][0], S2 = r4[x2][1], g3 = Math.min(C3, E3), !(b < g3 || b > Math.max(C3, E3) || p3 > Math.max(M4, S2))) if (p3 < Math.min(M4, S2)) b !== g3 && L3++;\n                else {\n                  if (E3 === C3 ? P3 = p3 : P3 = M4 + (b - C3) * (S2 - M4) / (E3 - C3), p3 === P3) return !(x2 === 1 && _2);\n                  p3 <= P3 && b !== g3 && L3++;\n                }\n                return L3 % 2 === 1;\n              }\n              var h3 = true, d3 = r4[0];\n              for (s3 = 1; s3 < r4.length; s3++) if (d3[0] !== r4[s3][0] || d3[1] !== r4[s3][1]) {\n                h3 = false;\n                break;\n              }\n              return { xmin: n4, xmax: i3, ymin: a4, ymax: o4, pts: r4, contains: l3 ? c5 : f4, isRect: l3, degenerate: h3 };\n            };\n            yP.isSegmentBent = function(t3, r4, n4, i3) {\n              var a4 = t3[r4], o4 = [t3[n4][0] - a4[0], t3[n4][1] - a4[1]], s3 = xN(o4, o4), l3 = Math.sqrt(s3), u4 = [-o4[1] / l3, o4[0] / l3], c5, f4, h3;\n              for (c5 = r4 + 1; c5 < n4; c5++) if (f4 = [t3[c5][0] - a4[0], t3[c5][1] - a4[1]], h3 = xN(f4, o4), h3 < 0 || h3 > s3 || Math.abs(xN(f4, u4)) > i3) return true;\n              return false;\n            };\n            yP.filter = function(t3, r4) {\n              var n4 = [t3[0]], i3 = 0, a4 = 0;\n              function o4(l3) {\n                t3.push(l3);\n                var u4 = n4.length, c5 = i3;\n                n4.splice(a4 + 1);\n                for (var f4 = c5 + 1; f4 < t3.length; f4++) (f4 === t3.length - 1 || yP.isSegmentBent(t3, c5, f4 + 1, r4)) && (n4.push(t3[f4]), n4.length < u4 - 2 && (i3 = f4, a4 = n4.length - 1), c5 = f4);\n              }\n              if (t3.length > 1) {\n                var s3 = t3.pop();\n                o4(s3);\n              }\n              return { addPt: o4, raw: t3, filtered: n4 };\n            };\n          });\n          var lfe = ye((aor, sfe) => {\n            "use strict";\n            sfe.exports = { BENDPX: 1.5, MINSELECT: 12, SELECTDELAY: 100, SELECTID: "-select" };\n          });\n          var Lfe = ye((oor, Cfe) => {\n            "use strict";\n            var ufe = ife(), Kft = afe(), PM = qa(), Jft = So().dashStyle, CM = ka(), $ft = vf(), Qft = ip().makeEventData, zM = Eg(), eht = zM.freeMode, tht = zM.rectMode, IM = zM.drawMode, AN = zM.openMode, SN = zM.selectMode, cfe = f_(), ffe = gM(), gfe = nP(), mfe = Q1().clearOutline, yfe = u_(), bN = yfe.handleEllipse, rht = yfe.readPaths, iht = eP().newShapes, nht = ZB(), aht = _N().activateLastSelection, xP = Dr(), oht = xP.sorterAsc, _fe = kM(), LM = z6(), E0 = hf().getFromId, sht = vM(), lht = wM().redrawReglTraces, bP = lfe(), Am = bP.MINSELECT, uht = _fe.filter, MN = _fe.tester, EN = KL(), hfe = EN.p2r, cht = EN.axValue, fht = EN.getTransform;\n            function kN(e3) {\n              return e3.subplot !== void 0;\n            }\n            function hht(e3, t3, r4, n4, i3) {\n              var a4 = !kN(n4), o4 = eht(i3), s3 = tht(i3), l3 = AN(i3), u4 = IM(i3), c5 = SN(i3), f4 = i3 === "drawline", h3 = i3 === "drawcircle", d3 = f4 || h3, v3 = n4.gd, _2 = v3._fullLayout, b = c5 && _2.newselection.mode === "immediate" && a4, p3 = _2._zoomlayer, k4 = n4.element.getBoundingClientRect(), E3 = n4.plotinfo, S2 = fht(E3), L3 = t3 - k4.left, x2 = r4 - k4.top;\n              _2._calcInverseTransform(v3);\n              var C3 = xP.apply3DTransform(_2._invTransform)(L3, x2);\n              L3 = C3[0], x2 = C3[1];\n              var M4 = _2._invScaleX, g3 = _2._invScaleY, P3 = L3, T3 = x2, z3 = "M" + L3 + "," + x2, O3 = n4.xaxes[0], V2 = n4.yaxes[0], G2 = O3._length, Z = V2._length, j3 = e3.altKey && !(IM(i3) && l3), N2, H, te, oe, _e, Ee, Ce;\n              bfe(e3, v3, n4), o4 && (N2 = uht([[L3, x2]], bP.BENDPX));\n              var me = p3.selectAll("path.select-outline-" + E3.id).data([1]), ie = u4 ? _2.newshape : _2.newselection;\n              u4 && (n4.hasText = ie.label.text || ie.label.texttemplate);\n              var Se = u4 && !l3 ? ie.fillcolor : "rgba(0,0,0,0)", Le = ie.line.color || (a4 ? CM.contrast(v3._fullLayout.plot_bgcolor) : "#7f7f7f");\n              me.enter().append("path").attr("class", "select-outline select-outline-" + E3.id).style({ opacity: u4 ? ie.opacity / 2 : 1, "stroke-dasharray": Jft(ie.line.dash, ie.line.width), "stroke-width": ie.line.width + "px", "shape-rendering": "crispEdges" }).call(CM.stroke, Le).call(CM.fill, Se).attr("fill-rule", "evenodd").classed("cursor-move", !!u4).attr("transform", S2).attr("d", z3 + "Z");\n              var Ae = p3.append("path").attr("class", "zoombox-corners").style({ fill: CM.background, stroke: CM.defaultLine, "stroke-width": 1 }).attr("transform", S2).attr("d", "M0,0Z");\n              if (u4 && n4.hasText) {\n                var Fe = p3.select(".label-temp");\n                Fe.empty() && (Fe = p3.append("g").classed("label-temp", true).classed("select-outline", true).style({ opacity: 0.8 }));\n              }\n              var Pe = _2._uid + bP.SELECTID, ge = [], Re = wP(v3, n4.xaxes, n4.yaxes, n4.subplot);\n              b && !e3.shiftKey && (n4._clearSubplotSelections = function() {\n                if (a4) {\n                  var Ze = O3._id, ut = V2._id;\n                  Mfe(v3, Ze, ut, Re);\n                  for (var pt = (v3.layout || {}).selections || [], Zt = [], st = false, lt = 0; lt < pt.length; lt++) {\n                    var Gt = _2.selections[lt];\n                    !Gt || Gt.xref !== Ze || Gt.yref !== ut ? Zt.push(pt[lt]) : st = true;\n                  }\n                  st && (v3._fullLayout._noEmitSelectedAtStart = true, PM.call("_guiRelayout", v3, { selections: Zt }));\n                }\n              });\n              var ce = Mht(n4);\n              n4.moveFn = function(Ze, ut) {\n                n4._clearSubplotSelections && (n4._clearSubplotSelections(), n4._clearSubplotSelections = void 0), P3 = Math.max(0, Math.min(G2, M4 * Ze + L3)), T3 = Math.max(0, Math.min(Z, g3 * ut + x2));\n                var pt = Math.abs(P3 - L3), Zt = Math.abs(T3 - x2);\n                if (s3) {\n                  var st, lt, Gt;\n                  if (c5) {\n                    var Nt = _2.selectdirection;\n                    switch (Nt === "any" ? Zt < Math.min(pt * 0.6, Am) ? st = "h" : pt < Math.min(Zt * 0.6, Am) ? st = "v" : st = "d" : st = Nt, st) {\n                      case "h":\n                        lt = h3 ? Z / 2 : 0, Gt = Z;\n                        break;\n                      case "v":\n                        lt = h3 ? G2 / 2 : 0, Gt = G2;\n                        break;\n                    }\n                  }\n                  if (u4) switch (_2.newshape.drawdirection) {\n                    case "vertical":\n                      st = "h", lt = h3 ? Z / 2 : 0, Gt = Z;\n                      break;\n                    case "horizontal":\n                      st = "v", lt = h3 ? G2 / 2 : 0, Gt = G2;\n                      break;\n                    case "ortho":\n                      pt < Zt ? (st = "h", lt = x2, Gt = T3) : (st = "v", lt = L3, Gt = P3);\n                      break;\n                    default:\n                      st = "d";\n                  }\n                  st === "h" ? (oe = d3 ? bN(h3, [P3, lt], [P3, Gt]) : [[L3, lt], [L3, Gt], [P3, Gt], [P3, lt]], oe.xmin = d3 ? P3 : Math.min(L3, P3), oe.xmax = d3 ? P3 : Math.max(L3, P3), oe.ymin = Math.min(lt, Gt), oe.ymax = Math.max(lt, Gt), Ae.attr("d", "M" + oe.xmin + "," + (x2 - Am) + "h-4v" + 2 * Am + "h4ZM" + (oe.xmax - 1) + "," + (x2 - Am) + "h4v" + 2 * Am + "h-4Z")) : st === "v" ? (oe = d3 ? bN(h3, [lt, T3], [Gt, T3]) : [[lt, x2], [lt, T3], [Gt, T3], [Gt, x2]], oe.xmin = Math.min(lt, Gt), oe.xmax = Math.max(lt, Gt), oe.ymin = d3 ? T3 : Math.min(x2, T3), oe.ymax = d3 ? T3 : Math.max(x2, T3), Ae.attr("d", "M" + (L3 - Am) + "," + oe.ymin + "v-4h" + 2 * Am + "v4ZM" + (L3 - Am) + "," + (oe.ymax - 1) + "v4h" + 2 * Am + "v-4Z")) : st === "d" && (oe = d3 ? bN(h3, [L3, x2], [P3, T3]) : [[L3, x2], [L3, T3], [P3, T3], [P3, x2]], oe.xmin = Math.min(L3, P3), oe.xmax = Math.max(L3, P3), oe.ymin = Math.min(x2, T3), oe.ymax = Math.max(x2, T3), Ae.attr("d", "M0,0Z"));\n                } else o4 && (N2.addPt([P3, T3]), oe = N2.filtered);\n                if (n4.selectionDefs && n4.selectionDefs.length ? (te = wfe(n4.mergedPolygons, oe, j3), oe.subtract = j3, H = CN(n4.selectionDefs.concat([oe]))) : (te = [oe], H = MN(oe)), gfe(Afe(te, l3), me, n4), c5) {\n                  var Jt = TN(v3, false), sr = Jt.eventData ? Jt.eventData.points.slice() : [];\n                  Jt = TN(v3, false, H, Re, n4), H = Jt.selectionTesters, Ce = Jt.eventData;\n                  var wr;\n                  N2 ? wr = N2.filtered : wr = Efe(te), LM.throttle(Pe, bP.SELECTDELAY, function() {\n                    ge = Sfe(H, Re);\n                    for (var cr = ge.slice(), $e = 0; $e < sr.length; $e++) {\n                      for (var St = sr[$e], Qt = false, Vt = 0; Vt < cr.length; Vt++) if (cr[Vt].curveNumber === St.curveNumber && cr[Vt].pointNumber === St.pointNumber) {\n                        Qt = true;\n                        break;\n                      }\n                      Qt || cr.push(St);\n                    }\n                    cr.length && (Ce || (Ce = {}), Ce.points = cr), ce(Ce, wr), Eht(v3, Ce);\n                  });\n                }\n              }, n4.clickFn = function(Ze, ut) {\n                if (Ae.remove(), v3._fullLayout._activeShapeIndex >= 0) {\n                  v3._fullLayout._deactivateShape(v3);\n                  return;\n                }\n                if (!u4) {\n                  var pt = _2.clickmode;\n                  LM.done(Pe).then(function() {\n                    if (LM.clear(Pe), Ze === 2) {\n                      for (me.remove(), _e = 0; _e < Re.length; _e++) Ee = Re[_e], Ee._module.selectPoints(Ee, false);\n                      if (DM(v3, Re), RM(n4), PN(v3), Re.length) {\n                        var Zt = Re[0].xaxis, st = Re[0].yaxis;\n                        if (Zt && st) {\n                          for (var lt = [], Gt = v3._fullLayout.selections, Nt = 0; Nt < Gt.length; Nt++) {\n                            var Jt = Gt[Nt];\n                            Jt && (Jt.xref !== Zt._id || Jt.yref !== st._id) && lt.push(Jt);\n                          }\n                          lt.length < Gt.length && (v3._fullLayout._noEmitSelectedAtStart = true, PM.call("_guiRelayout", v3, { selections: lt }));\n                        }\n                      }\n                    } else pt.indexOf("select") > -1 && xfe(ut, v3, n4.xaxes, n4.yaxes, n4.subplot, n4, me), pt === "event" && FM(v3, void 0);\n                    $ft.click(v3, ut, E3.id);\n                  }).catch(xP.error);\n                }\n              }, n4.doneFn = function() {\n                Ae.remove(), LM.done(Pe).then(function() {\n                  LM.clear(Pe), !b && oe && n4.selectionDefs && (oe.subtract = j3, n4.selectionDefs.push(oe), n4.mergedPolygons.length = 0, [].push.apply(n4.mergedPolygons, te)), (b || u4) && RM(n4, b), n4.doneFnCompleted && n4.doneFnCompleted(ge), c5 && FM(v3, Ce);\n                }).catch(xP.error);\n              };\n            }\n            function xfe(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = t3._hoverdata, l3 = t3._fullLayout, u4 = l3.clickmode, c5 = u4.indexOf("event") > -1, f4 = [], h3, d3, v3, _2, b, p3, k4, E3, S2, L3;\n              if (mht(s3)) {\n                bfe(e3, t3, a4), h3 = wP(t3, r4, n4, i3);\n                var x2 = yht(s3, h3), C3 = x2.pointNumbers.length > 0;\n                if (C3 ? _ht(h3, x2) : xht(h3) && (k4 = vfe(x2))) {\n                  for (o4 && o4.remove(), L3 = 0; L3 < h3.length; L3++) d3 = h3[L3], d3._module.selectPoints(d3, false);\n                  DM(t3, h3), RM(a4), c5 && PN(t3);\n                } else {\n                  E3 = e3.shiftKey && (k4 !== void 0 ? k4 : vfe(x2)), v3 = dht(x2.pointNumber, x2.searchInfo, E3);\n                  var M4 = a4.selectionDefs.concat([v3]);\n                  for (_2 = CN(M4, _2), L3 = 0; L3 < h3.length; L3++) if (b = h3[L3]._module.selectPoints(h3[L3], _2), p3 = Tfe(b, h3[L3]), f4.length) for (var g3 = 0; g3 < p3.length; g3++) f4.push(p3[g3]);\n                  else f4 = p3;\n                  if (S2 = { points: f4 }, DM(t3, h3, S2), v3 && a4 && a4.selectionDefs.push(v3), o4) {\n                    var P3 = a4.mergedPolygons, T3 = AN(a4.dragmode);\n                    gfe(Afe(P3, T3), o4, a4);\n                  }\n                  c5 && FM(t3, S2);\n                }\n              }\n            }\n            function dht(e3, t3, r4) {\n              return { pointNumber: e3, searchInfo: t3, subtract: !!r4 };\n            }\n            function wN(e3) {\n              return "pointNumber" in e3 && "searchInfo" in e3;\n            }\n            function vht(e3) {\n              return { xmin: 0, xmax: 0, ymin: 0, ymax: 0, pts: [], contains: function(t3, r4, n4, i3) {\n                var a4 = e3.searchInfo.cd[0].trace.index, o4 = i3.cd[0].trace.index;\n                return o4 === a4 && n4 === e3.pointNumber;\n              }, isRect: false, degenerate: false, subtract: !!e3.subtract };\n            }\n            function CN(e3) {\n              if (!e3.length) return;\n              for (var t3 = [], r4 = wN(e3[0]) ? 0 : e3[0][0][0], n4 = r4, i3 = wN(e3[0]) ? 0 : e3[0][0][1], a4 = i3, o4 = 0; o4 < e3.length; o4++) if (wN(e3[o4])) t3.push(vht(e3[o4]));\n              else {\n                var s3 = MN(e3[o4]);\n                s3.subtract = !!e3[o4].subtract, t3.push(s3), r4 = Math.min(r4, s3.xmin), n4 = Math.max(n4, s3.xmax), i3 = Math.min(i3, s3.ymin), a4 = Math.max(a4, s3.ymax);\n              }\n              function l3(u4, c5, f4, h3) {\n                for (var d3 = false, v3 = 0; v3 < t3.length; v3++) t3[v3].contains(u4, c5, f4, h3) && (d3 = !t3[v3].subtract);\n                return d3;\n              }\n              return { xmin: r4, xmax: n4, ymin: i3, ymax: a4, pts: [], contains: l3, isRect: false, degenerate: false };\n            }\n            function bfe(e3, t3, r4) {\n              var n4 = t3._fullLayout, i3 = r4.plotinfo, a4 = r4.dragmode, o4 = n4._lastSelectedSubplot && n4._lastSelectedSubplot === i3.id, s3 = (e3.shiftKey || e3.altKey) && !(IM(a4) && AN(a4));\n              o4 && s3 && i3.selection && i3.selection.selectionDefs && !r4.selectionDefs ? (r4.selectionDefs = i3.selection.selectionDefs, r4.mergedPolygons = i3.selection.mergedPolygons) : (!s3 || !i3.selection) && RM(r4), o4 || (mfe(t3), n4._lastSelectedSubplot = i3.id);\n            }\n            function pht(e3) {\n              return e3._fullLayout._activeShapeIndex >= 0;\n            }\n            function ght(e3) {\n              return e3._fullLayout._activeSelectionIndex >= 0;\n            }\n            function RM(e3, t3) {\n              var r4 = e3.dragmode, n4 = e3.plotinfo, i3 = e3.gd;\n              pht(i3) && i3._fullLayout._deactivateShape(i3), ght(i3) && i3._fullLayout._deactivateSelection(i3);\n              var a4 = i3._fullLayout, o4 = a4._zoomlayer, s3 = IM(r4), l3 = SN(r4);\n              if (s3 || l3) {\n                var u4 = o4.selectAll(".select-outline-" + n4.id);\n                if (u4 && i3._fullLayout._outlining) {\n                  var c5;\n                  s3 && (c5 = iht(u4, e3)), c5 && PM.call("_guiRelayout", i3, { shapes: c5 });\n                  var f4;\n                  l3 && !kN(e3) && (f4 = nht(u4, e3)), f4 && (i3._fullLayout._noEmitSelectedAtStart = true, PM.call("_guiRelayout", i3, { selections: f4 }).then(function() {\n                    t3 && aht(i3);\n                  })), i3._fullLayout._outlining = false;\n                }\n              }\n              n4.selection = {}, n4.selection.selectionDefs = e3.selectionDefs = [], n4.selection.mergedPolygons = e3.mergedPolygons = [];\n            }\n            function dfe(e3) {\n              return e3._id;\n            }\n            function wP(e3, t3, r4, n4) {\n              if (!e3.calcdata) return [];\n              var i3 = [], a4 = t3.map(dfe), o4 = r4.map(dfe), s3, l3, u4;\n              for (u4 = 0; u4 < e3.calcdata.length; u4++) if (s3 = e3.calcdata[u4], l3 = s3[0].trace, !(l3.visible !== true || !l3._module || !l3._module.selectPoints)) if (kN({ subplot: n4 }) && (l3.subplot === n4 || l3.geo === n4)) i3.push(_P(l3._module, s3, t3[0], r4[0]));\n              else if (l3.type === "splom") {\n                if (l3._xaxes[a4[0]] && l3._yaxes[o4[0]]) {\n                  var c5 = _P(l3._module, s3, t3[0], r4[0]);\n                  c5.scene = e3._fullLayout._splomScenes[l3.uid], i3.push(c5);\n                }\n              } else if (l3.type === "sankey") {\n                var f4 = _P(l3._module, s3, t3[0], r4[0]);\n                i3.push(f4);\n              } else {\n                if (a4.indexOf(l3.xaxis) === -1 && (!l3._xA || !l3._xA.overlaying) || o4.indexOf(l3.yaxis) === -1 && (!l3._yA || !l3._yA.overlaying)) continue;\n                i3.push(_P(l3._module, s3, E0(e3, l3.xaxis), E0(e3, l3.yaxis)));\n              }\n              return i3;\n            }\n            function _P(e3, t3, r4, n4) {\n              return { _module: e3, cd: t3, xaxis: r4, yaxis: n4 };\n            }\n            function mht(e3) {\n              return e3 && Array.isArray(e3) && e3[0].hoverOnBox !== true;\n            }\n            function yht(e3, t3) {\n              var r4 = e3[0], n4 = -1, i3 = [], a4, o4;\n              for (o4 = 0; o4 < t3.length; o4++) if (a4 = t3[o4], r4.fullData.index === a4.cd[0].trace.index) {\n                if (r4.hoverOnBox === true) break;\n                r4.pointNumber !== void 0 ? n4 = r4.pointNumber : r4.binNumber !== void 0 && (n4 = r4.binNumber, i3 = r4.pointNumbers);\n                break;\n              }\n              return { pointNumber: n4, pointNumbers: i3, searchInfo: a4 };\n            }\n            function vfe(e3) {\n              var t3 = e3.searchInfo.cd[0].trace, r4 = e3.pointNumber, n4 = e3.pointNumbers, i3 = n4.length > 0, a4 = i3 ? n4[0] : r4;\n              return t3.selectedpoints ? t3.selectedpoints.indexOf(a4) > -1 : false;\n            }\n            function _ht(e3, t3) {\n              var r4 = [], n4, i3, a4, o4;\n              for (o4 = 0; o4 < e3.length; o4++) n4 = e3[o4], n4.cd[0].trace.selectedpoints && n4.cd[0].trace.selectedpoints.length > 0 && r4.push(n4);\n              if (r4.length === 1 && (a4 = r4[0] === t3.searchInfo, a4 && (i3 = t3.searchInfo.cd[0].trace, i3.selectedpoints.length === t3.pointNumbers.length))) {\n                for (o4 = 0; o4 < t3.pointNumbers.length; o4++) if (i3.selectedpoints.indexOf(t3.pointNumbers[o4]) < 0) return false;\n                return true;\n              }\n              return false;\n            }\n            function xht(e3) {\n              var t3 = 0, r4, n4, i3;\n              for (i3 = 0; i3 < e3.length; i3++) if (r4 = e3[i3], n4 = r4.cd[0].trace, n4.selectedpoints && (n4.selectedpoints.length > 1 || (t3 += n4.selectedpoints.length, t3 > 1))) return false;\n              return t3 === 1;\n            }\n            function DM(e3, t3, r4) {\n              var n4;\n              for (n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4].cd[0].trace._fullInput, a4 = e3._fullLayout._tracePreGUI[i3.uid] || {};\n                a4.selectedpoints === void 0 && (a4.selectedpoints = i3._input.selectedpoints || null);\n              }\n              var o4;\n              if (r4) {\n                var s3 = r4.points || [];\n                for (n4 = 0; n4 < t3.length; n4++) o4 = t3[n4].cd[0].trace, o4._input.selectedpoints = o4._fullInput.selectedpoints = [], o4._fullInput !== o4 && (o4.selectedpoints = []);\n                for (var l3 = 0; l3 < s3.length; l3++) {\n                  var u4 = s3[l3], c5 = u4.data, f4 = u4.fullData, h3 = u4.pointIndex, d3 = u4.pointIndices;\n                  d3 ? ([].push.apply(c5.selectedpoints, d3), o4._fullInput !== o4 && [].push.apply(f4.selectedpoints, d3)) : (c5.selectedpoints.push(h3), o4._fullInput !== o4 && f4.selectedpoints.push(h3));\n                }\n              } else for (n4 = 0; n4 < t3.length; n4++) o4 = t3[n4].cd[0].trace, delete o4.selectedpoints, delete o4._input.selectedpoints, o4._fullInput !== o4 && delete o4._fullInput.selectedpoints;\n              bht(e3, t3);\n            }\n            function bht(e3, t3) {\n              for (var r4 = false, n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4], a4 = i3.cd;\n                PM.traceIs(a4[0].trace, "regl") && (r4 = true);\n                var o4 = i3._module, s3 = o4.styleOnSelect || o4.style;\n                s3 && (s3(e3, a4, a4[0].node3), a4[0].nodeRangePlot3 && s3(e3, a4, a4[0].nodeRangePlot3));\n              }\n              r4 && (sht(e3), lht(e3));\n            }\n            function wfe(e3, t3, r4) {\n              for (var n4 = r4 ? ufe.difference : ufe.union, i3 = n4({ regions: e3 }, { regions: [t3] }), a4 = i3.regions.reverse(), o4 = 0; o4 < a4.length; o4++) {\n                var s3 = a4[o4];\n                s3.subtract = LN(s3, a4.slice(0, o4));\n              }\n              return a4;\n            }\n            function Tfe(e3, t3) {\n              if (Array.isArray(e3)) for (var r4 = t3.cd, n4 = t3.cd[0].trace, i3 = 0; i3 < e3.length; i3++) e3[i3] = Qft(e3[i3], n4, r4);\n              return e3;\n            }\n            function Afe(e3, t3) {\n              for (var r4 = [], n4 = 0; n4 < e3.length; n4++) {\n                r4[n4] = [];\n                for (var i3 = 0; i3 < e3[n4].length; i3++) {\n                  r4[n4][i3] = [], r4[n4][i3][0] = i3 ? "L" : "M";\n                  for (var a4 = 0; a4 < e3[n4][i3].length; a4++) r4[n4][i3].push(e3[n4][i3][a4]);\n                }\n                t3 || r4[n4].push(["Z", r4[n4][0][1], r4[n4][0][2]]);\n              }\n              return r4;\n            }\n            function Sfe(e3, t3) {\n              for (var r4 = [], n4, i3 = [], a4, o4 = 0; o4 < t3.length; o4++) {\n                var s3 = t3[o4];\n                a4 = s3._module.selectPoints(s3, e3), i3.push(a4), n4 = Tfe(a4, s3), r4 = r4.concat(n4);\n              }\n              return r4;\n            }\n            function TN(e3, t3, r4, n4, i3) {\n              var a4 = !!n4, o4, s3, l3;\n              i3 && (o4 = i3.plotinfo, s3 = i3.xaxes[0]._id, l3 = i3.yaxes[0]._id);\n              var u4 = [], c5 = [], f4 = pfe(e3), h3 = e3._fullLayout;\n              if (o4) {\n                var d3 = h3._zoomlayer, v3 = h3.dragmode, _2 = IM(v3), b = SN(v3);\n                if (_2 || b) {\n                  var p3 = E0(e3, s3, "x"), k4 = E0(e3, l3, "y");\n                  if (p3 && k4) {\n                    var E3 = d3.selectAll(".select-outline-" + o4.id);\n                    if (E3 && e3._fullLayout._outlining && E3.length) {\n                      for (var S2 = E3[0][0], L3 = S2.getAttribute("d"), x2 = rht(L3, e3, o4), C3 = [], M4 = 0; M4 < x2.length; M4++) {\n                        for (var g3 = x2[M4], P3 = [], T3 = 0; T3 < g3.length; T3++) P3.push([h_(p3, g3[T3][1]), h_(k4, g3[T3][2])]);\n                        P3.xref = s3, P3.yref = l3, P3.subtract = LN(P3, C3), C3.push(P3);\n                      }\n                      f4 = f4.concat(C3);\n                    }\n                  }\n                }\n              }\n              var z3 = s3 && l3 ? [s3 + l3] : h3._subplots.cartesian;\n              wht(e3);\n              for (var O3 = {}, V2 = 0; V2 < z3.length; V2++) {\n                var G2 = z3[V2], Z = G2.indexOf("y"), j3 = G2.slice(0, Z), N2 = G2.slice(Z), H = s3 && l3 ? r4 : void 0;\n                if (H = Aht(f4, j3, N2, H), H) {\n                  var te = n4;\n                  if (!a4) {\n                    var oe = E0(e3, j3, "x"), _e = E0(e3, N2, "y");\n                    te = wP(e3, [oe], [_e], G2);\n                    for (var Ee = 0; Ee < te.length; Ee++) {\n                      var Ce = te[Ee], me = Ce.cd[0], ie = me.trace;\n                      if (Ce._module.name === "scattergl" && !me.t.xpx) {\n                        var Se = ie.x, Le = ie.y, Ae = ie._length;\n                        me.t.xpx = [], me.t.ypx = [];\n                        for (var Fe = 0; Fe < Ae; Fe++) me.t.xpx[Fe] = oe.c2p(Se[Fe]), me.t.ypx[Fe] = _e.c2p(Le[Fe]);\n                      }\n                      Ce._module.name === "splom" && (O3[ie.uid] || (O3[ie.uid] = true));\n                    }\n                  }\n                  var Pe = Sfe(H, te);\n                  u4 = u4.concat(Pe), c5 = c5.concat(te);\n                }\n              }\n              var ge = { points: u4 };\n              DM(e3, c5, ge);\n              var Re = h3.clickmode, ce = Re.indexOf("event") > -1 && t3;\n              if (!o4 && t3) {\n                var Ze = pfe(e3, true);\n                if (Ze.length) {\n                  var ut = Ze[0].xref, pt = Ze[0].yref;\n                  if (ut && pt) {\n                    var Zt = Efe(Ze), st = kfe([E0(e3, ut, "x"), E0(e3, pt, "y")]);\n                    st(ge, Zt);\n                  }\n                }\n                e3._fullLayout._noEmitSelectedAtStart ? e3._fullLayout._noEmitSelectedAtStart = false : ce && FM(e3, ge), h3._reselect = false;\n              }\n              if (!o4 && h3._deselect) {\n                var lt = h3._deselect;\n                s3 = lt.xref, l3 = lt.yref, Tht(s3, l3, c5) || Mfe(e3, s3, l3, n4), ce && (ge.points.length ? FM(e3, ge) : PN(e3)), h3._deselect = false;\n              }\n              return { eventData: ge, selectionTesters: r4 };\n            }\n            function wht(e3) {\n              var t3 = e3.calcdata;\n              if (t3) for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4][0], i3 = n4.trace, a4 = e3._fullLayout._splomScenes;\n                if (a4) {\n                  var o4 = a4[i3.uid];\n                  o4 && (o4.selectBatch = []);\n                }\n              }\n            }\n            function Tht(e3, t3, r4) {\n              for (var n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4];\n                if (i3.xaxis && i3.xaxis._id === e3 && i3.yaxis && i3.yaxis._id === t3) return true;\n              }\n              return false;\n            }\n            function Mfe(e3, t3, r4, n4) {\n              n4 = wP(e3, [E0(e3, t3, "x")], [E0(e3, r4, "y")], t3 + r4);\n              for (var i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                a4._module.selectPoints(a4, false);\n              }\n              DM(e3, n4);\n            }\n            function Aht(e3, t3, r4, n4) {\n              for (var i3, a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4];\n                if (!(t3 !== o4.xref || r4 !== o4.yref)) if (i3) {\n                  var s3 = !!o4.subtract;\n                  i3 = wfe(i3, o4, s3), n4 = CN(i3);\n                } else i3 = [o4], n4 = MN(o4);\n              }\n              return n4;\n            }\n            function pfe(e3, t3) {\n              for (var r4 = [], n4 = e3._fullLayout, i3 = n4.selections, a4 = i3.length, o4 = 0; o4 < a4; o4++) if (!(t3 && o4 !== n4._activeSelectionIndex)) {\n                var s3 = i3[o4];\n                if (s3) {\n                  var l3 = s3.xref, u4 = s3.yref, c5 = E0(e3, l3, "x"), f4 = E0(e3, u4, "y"), h3, d3, v3, _2, b;\n                  if (s3.type === "rect") {\n                    b = [];\n                    var p3 = h_(c5, s3.x0), k4 = h_(c5, s3.x1), E3 = h_(f4, s3.y0), S2 = h_(f4, s3.y1);\n                    b = [[p3, E3], [p3, S2], [k4, S2], [k4, E3]], h3 = Math.min(p3, k4), d3 = Math.max(p3, k4), v3 = Math.min(E3, S2), _2 = Math.max(E3, S2), b.xmin = h3, b.xmax = d3, b.ymin = v3, b.ymax = _2, b.xref = l3, b.yref = u4, b.subtract = false, b.isRect = true, r4.push(b);\n                  } else if (s3.type === "path") for (var L3 = s3.path.split("Z"), x2 = [], C3 = 0; C3 < L3.length; C3++) {\n                    var M4 = L3[C3];\n                    if (M4) {\n                      M4 += "Z";\n                      var g3 = cfe.extractPathCoords(M4, ffe.paramIsX, "raw"), P3 = cfe.extractPathCoords(M4, ffe.paramIsY, "raw");\n                      h3 = 1 / 0, d3 = -1 / 0, v3 = 1 / 0, _2 = -1 / 0, b = [];\n                      for (var T3 = 0; T3 < g3.length; T3++) {\n                        var z3 = h_(c5, g3[T3]), O3 = h_(f4, P3[T3]);\n                        b.push([z3, O3]), h3 = Math.min(z3, h3), d3 = Math.max(z3, d3), v3 = Math.min(O3, v3), _2 = Math.max(O3, _2);\n                      }\n                      b.xmin = h3, b.xmax = d3, b.ymin = v3, b.ymax = _2, b.xref = l3, b.yref = u4, b.subtract = LN(b, x2), x2.push(b), r4.push(b);\n                    }\n                  }\n                }\n              }\n              return r4;\n            }\n            function LN(e3, t3) {\n              for (var r4 = false, n4 = 0; n4 < t3.length; n4++) for (var i3 = t3[n4], a4 = 0; a4 < e3.length; a4++) if (Kft(e3[a4], i3)) {\n                r4 = !r4;\n                break;\n              }\n              return r4;\n            }\n            function h_(e3, t3) {\n              return e3.type === "date" && (t3 = t3.replace("_", " ")), e3.type === "log" ? e3.c2p(t3) : e3.r2p(t3, null, e3.calendar);\n            }\n            function Efe(e3) {\n              for (var t3 = e3.length, r4 = [], n4 = 0; n4 < t3; n4++) {\n                var i3 = e3[n4];\n                r4 = r4.concat(i3), r4 = r4.concat([i3[0]]);\n              }\n              return Sht(r4);\n            }\n            function Sht(e3) {\n              return e3.isRect = e3.length === 5 && e3[0][0] === e3[4][0] && e3[0][1] === e3[4][1] && e3[0][0] === e3[1][0] && e3[2][0] === e3[3][0] && e3[0][1] === e3[3][1] && e3[1][1] === e3[2][1] || e3[0][1] === e3[1][1] && e3[2][1] === e3[3][1] && e3[0][0] === e3[3][0] && e3[1][0] === e3[2][0], e3.isRect && (e3.xmin = Math.min(e3[0][0], e3[2][0]), e3.xmax = Math.max(e3[0][0], e3[2][0]), e3.ymin = Math.min(e3[0][1], e3[2][1]), e3.ymax = Math.max(e3[0][1], e3[2][1])), e3;\n            }\n            function kfe(e3) {\n              return function(t3, r4) {\n                for (var n4, i3, a4 = 0; a4 < e3.length; a4++) {\n                  var o4 = e3[a4], s3 = o4._id, l3 = s3.charAt(0);\n                  if (r4.isRect) {\n                    n4 || (n4 = {});\n                    var u4 = r4[l3 + "min"], c5 = r4[l3 + "max"];\n                    u4 !== void 0 && c5 !== void 0 && (n4[s3] = [hfe(o4, u4), hfe(o4, c5)].sort(oht));\n                  } else i3 || (i3 = {}), i3[s3] = r4.map(cht(o4));\n                }\n                n4 && (t3.range = n4), i3 && (t3.lassoPoints = i3);\n              };\n            }\n            function Mht(e3) {\n              var t3 = e3.plotinfo;\n              return t3.fillRangeItems || kfe(e3.xaxes.concat(e3.yaxes));\n            }\n            function Eht(e3, t3) {\n              e3.emit("plotly_selecting", t3);\n            }\n            function FM(e3, t3) {\n              t3 && (t3.selections = (e3.layout || {}).selections || []), e3.emit("plotly_selected", t3);\n            }\n            function PN(e3) {\n              e3.emit("plotly_deselect", null);\n            }\n            Cfe.exports = { reselect: TN, prepSelect: hht, clearOutline: mfe, clearSelectionsCache: RM, selectOnClick: xfe };\n          });\n          var IN = ye((sor, Pfe) => {\n            "use strict";\n            Pfe.exports = [{ path: "", backoff: 0 }, { path: "M-2.4,-3V3L0.6,0Z", backoff: 0.6 }, { path: "M-3.7,-2.5V2.5L1.3,0Z", backoff: 1.3 }, { path: "M-4.45,-3L-1.65,-0.2V0.2L-4.45,3L1.55,0Z", backoff: 1.55 }, { path: "M-2.2,-2.2L-0.2,-0.2V0.2L-2.2,2.2L-1.4,3L1.6,0L-1.4,-3Z", backoff: 1.6 }, { path: "M-4.4,-2.1L-0.6,-0.2V0.2L-4.4,2.1L-4,3L2,0L-4,-3Z", backoff: 2 }, { path: "M2,0A2,2 0 1,1 0,-2A2,2 0 0,1 2,0Z", backoff: 0, noRotate: true }, { path: "M2,2V-2H-2V2Z", backoff: 0, noRotate: true }];\n          });\n          var OM = ye((lor, Ife) => {\n            "use strict";\n            Ife.exports = { axisRefDescription: function(e3, t3, r4) {\n              return ["If set to a", e3, "axis id (e.g. *" + e3 + "* or", "*" + e3 + "2*), the `" + e3 + "` position refers to a", e3, "coordinate. If set to *paper*, the `" + e3 + "`", "position refers to the distance from the", t3, "of the plotting", "area in normalized coordinates where *0* (*1*) corresponds to the", t3, "(" + r4 + "). If set to a", e3, "axis ID followed by", "*domain* (separated by a space), the position behaves like for", "*paper*, but refers to the distance in fractions of the domain", "length from the", t3, "of the domain of that axis: e.g.,", "*" + e3 + "2 domain* refers to the domain of the second", e3, " axis and a", e3, "position of 0.5 refers to the", "point between the", t3, "and the", r4, "of the domain of the", "second", e3, "axis."].join(" ");\n            } };\n          });\n          var Ub = ye((cor, Ffe) => {\n            "use strict";\n            var Rfe = IN(), Dfe = ec(), TP = hd(), kht = vl().templatedArray, uor = OM();\n            Ffe.exports = kht("annotation", { visible: { valType: "boolean", dflt: true, editType: "calc+arraydraw" }, text: { valType: "string", editType: "calc+arraydraw" }, textangle: { valType: "angle", dflt: 0, editType: "calc+arraydraw" }, font: Dfe({ editType: "calc+arraydraw", colorEditType: "arraydraw" }), width: { valType: "number", min: 1, dflt: null, editType: "calc+arraydraw" }, height: { valType: "number", min: 1, dflt: null, editType: "calc+arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, align: { valType: "enumerated", values: ["left", "center", "right"], dflt: "center", editType: "arraydraw" }, valign: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "middle", editType: "arraydraw" }, bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, bordercolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, borderpad: { valType: "number", min: 0, dflt: 1, editType: "calc+arraydraw" }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "calc+arraydraw" }, showarrow: { valType: "boolean", dflt: true, editType: "calc+arraydraw" }, arrowcolor: { valType: "color", editType: "arraydraw" }, arrowhead: { valType: "integer", min: 0, max: Rfe.length, dflt: 1, editType: "arraydraw" }, startarrowhead: { valType: "integer", min: 0, max: Rfe.length, dflt: 1, editType: "arraydraw" }, arrowside: { valType: "flaglist", flags: ["end", "start"], extras: ["none"], dflt: "end", editType: "arraydraw" }, arrowsize: { valType: "number", min: 0.3, dflt: 1, editType: "calc+arraydraw" }, startarrowsize: { valType: "number", min: 0.3, dflt: 1, editType: "calc+arraydraw" }, arrowwidth: { valType: "number", min: 0.1, editType: "calc+arraydraw" }, standoff: { valType: "number", min: 0, dflt: 0, editType: "calc+arraydraw" }, startstandoff: { valType: "number", min: 0, dflt: 0, editType: "calc+arraydraw" }, ax: { valType: "any", editType: "calc+arraydraw" }, ay: { valType: "any", editType: "calc+arraydraw" }, axref: { valType: "enumerated", dflt: "pixel", values: ["pixel", TP.idRegex.x.toString()], editType: "calc" }, ayref: { valType: "enumerated", dflt: "pixel", values: ["pixel", TP.idRegex.y.toString()], editType: "calc" }, xref: { valType: "enumerated", values: ["paper", TP.idRegex.x.toString()], editType: "calc" }, x: { valType: "any", editType: "calc+arraydraw" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto", editType: "calc+arraydraw" }, xshift: { valType: "number", dflt: 0, editType: "calc+arraydraw" }, yref: { valType: "enumerated", values: ["paper", TP.idRegex.y.toString()], editType: "calc" }, y: { valType: "any", editType: "calc+arraydraw" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "auto", editType: "calc+arraydraw" }, yshift: { valType: "number", dflt: 0, editType: "calc+arraydraw" }, clicktoshow: { valType: "enumerated", values: [false, "onoff", "onout"], dflt: false, editType: "arraydraw" }, xclick: { valType: "any", editType: "arraydraw" }, yclick: { valType: "any", editType: "arraydraw" }, hovertext: { valType: "string", editType: "arraydraw" }, hoverlabel: { bgcolor: { valType: "color", editType: "arraydraw" }, bordercolor: { valType: "color", editType: "arraydraw" }, font: Dfe({ editType: "arraydraw" }), editType: "arraydraw" }, captureevents: { valType: "boolean", editType: "arraydraw" }, editType: "calc" });\n          });\n          var Sm = ye((hor, zfe) => {\n            "use strict";\n            zfe.exports = { PTS_LINESONLY: 20, minTolerance: 0.2, toleranceGrowth: 10, maxScreensAway: 20, eventDataKeys: [] };\n          });\n          var Cg = ye((dor, Ofe) => {\n            "use strict";\n            Ofe.exports = function(t3) {\n              return { valType: "color", editType: "style", anim: true };\n            };\n          });\n          var pf = ye((vor, Hfe) => {\n            "use strict";\n            var qfe = df().axisHoverFormat, { hovertemplateAttrs: Cht, texttemplateAttrs: Lht, templatefallbackAttrs: Bfe } = Ll(), Nfe = Tu(), Pht = ec(), Iht = Pd().dash, Rht = Pd().pattern, Dht = So(), Fht = Sm(), AP = Ao().extendFlat, zht = Cg();\n            function Ufe(e3) {\n              return { valType: "any", dflt: 0, editType: "calc" };\n            }\n            function Vfe(e3) {\n              return { valType: "any", editType: "calc" };\n            }\n            function Gfe(e3) {\n              return { valType: "enumerated", values: ["start", "middle", "end"], dflt: "middle", editType: "calc" };\n            }\n            Hfe.exports = { x: { valType: "data_array", editType: "calc+clearAxisTypes", anim: true }, x0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes", anim: true }, dx: { valType: "number", dflt: 1, editType: "calc", anim: true }, y: { valType: "data_array", editType: "calc+clearAxisTypes", anim: true }, y0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes", anim: true }, dy: { valType: "number", dflt: 1, editType: "calc", anim: true }, xperiod: Ufe("x"), yperiod: Ufe("y"), xperiod0: Vfe("x0"), yperiod0: Vfe("y0"), xperiodalignment: Gfe("x"), yperiodalignment: Gfe("y"), xhoverformat: qfe("x"), yhoverformat: qfe("y"), offsetgroup: { valType: "string", dflt: "", editType: "calc" }, alignmentgroup: { valType: "string", dflt: "", editType: "calc" }, stackgroup: { valType: "string", dflt: "", editType: "calc" }, orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc" }, groupnorm: { valType: "enumerated", values: ["", "fraction", "percent"], dflt: "", editType: "calc" }, stackgaps: { valType: "enumerated", values: ["infer zero", "interpolate"], dflt: "infer zero", editType: "calc" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, texttemplate: Lht(), texttemplatefallback: Bfe({ editType: "calc" }), hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "style" }, mode: { valType: "flaglist", flags: ["lines", "markers", "text"], extras: ["none"], editType: "calc" }, hoveron: { valType: "flaglist", flags: ["points", "fills"], editType: "style" }, hovertemplate: Cht({}, { keys: Fht.eventDataKeys }), hovertemplatefallback: Bfe(), line: { color: { valType: "color", editType: "style", anim: true }, width: { valType: "number", min: 0, dflt: 2, editType: "style", anim: true }, shape: { valType: "enumerated", values: ["linear", "spline", "hv", "vh", "hvh", "vhv"], dflt: "linear", editType: "plot" }, smoothing: { valType: "number", min: 0, max: 1.3, dflt: 1, editType: "plot" }, dash: AP({}, Iht, { editType: "style" }), backoff: { valType: "number", min: 0, dflt: "auto", arrayOk: true, editType: "plot" }, simplify: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, connectgaps: { valType: "boolean", dflt: false, editType: "calc" }, cliponaxis: { valType: "boolean", dflt: true, editType: "plot" }, fill: { valType: "enumerated", values: ["none", "tozeroy", "tozerox", "tonexty", "tonextx", "toself", "tonext"], editType: "calc" }, fillcolor: zht(true), fillgradient: AP({ type: { valType: "enumerated", values: ["radial", "horizontal", "vertical", "none"], dflt: "none", editType: "calc" }, start: { valType: "number", editType: "calc" }, stop: { valType: "number", editType: "calc" }, colorscale: { valType: "colorscale", editType: "style" }, editType: "calc" }), fillpattern: Rht, marker: AP({ symbol: { valType: "enumerated", values: Dht.symbolList, dflt: "circle", arrayOk: true, editType: "style" }, opacity: { valType: "number", min: 0, max: 1, arrayOk: true, editType: "style", anim: true }, angle: { valType: "angle", dflt: 0, arrayOk: true, editType: "plot", anim: false }, angleref: { valType: "enumerated", values: ["previous", "up"], dflt: "up", editType: "plot", anim: false }, standoff: { valType: "number", min: 0, dflt: 0, arrayOk: true, editType: "plot", anim: true }, size: { valType: "number", min: 0, dflt: 6, arrayOk: true, editType: "calc", anim: true }, maxdisplayed: { valType: "number", min: 0, dflt: 0, editType: "plot" }, sizeref: { valType: "number", dflt: 1, editType: "calc" }, sizemin: { valType: "number", min: 0, dflt: 0, editType: "calc" }, sizemode: { valType: "enumerated", values: ["diameter", "area"], dflt: "diameter", editType: "calc" }, line: AP({ width: { valType: "number", min: 0, arrayOk: true, editType: "style", anim: true }, editType: "calc" }, Nfe("marker.line", { anim: true })), gradient: { type: { valType: "enumerated", values: ["radial", "horizontal", "vertical", "none"], arrayOk: true, dflt: "none", editType: "calc" }, color: { valType: "color", arrayOk: true, editType: "calc" }, editType: "calc" }, editType: "calc" }, Nfe("marker", { anim: true })), selected: { marker: { opacity: { valType: "number", min: 0, max: 1, editType: "style" }, color: { valType: "color", editType: "style" }, size: { valType: "number", min: 0, editType: "style" }, editType: "style" }, textfont: { color: { valType: "color", editType: "style" }, editType: "style" }, editType: "style" }, unselected: { marker: { opacity: { valType: "number", min: 0, max: 1, editType: "style" }, color: { valType: "color", editType: "style" }, size: { valType: "number", min: 0, editType: "style" }, editType: "style" }, textfont: { color: { valType: "color", editType: "style" }, editType: "style" }, editType: "style" }, textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right"], dflt: "middle center", arrayOk: true, editType: "calc" }, textfont: Pht({ editType: "calc", colorEditType: "style", arrayOk: true }), zorder: { valType: "integer", dflt: 0, editType: "plot" } };\n          });\n          var RN = ye((gor, Xfe) => {\n            "use strict";\n            var jfe = Ub(), Wfe = pf().line, Oht = Pd().dash, SP = Ao().extendFlat, qht = mc().overrideAll, Bht = vl().templatedArray, por = OM();\n            Xfe.exports = qht(Bht("selection", { type: { valType: "enumerated", values: ["rect", "path"] }, xref: SP({}, jfe.xref, {}), yref: SP({}, jfe.yref, {}), x0: { valType: "any" }, x1: { valType: "any" }, y0: { valType: "any" }, y1: { valType: "any" }, path: { valType: "string", editType: "arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 0.7, editType: "arraydraw" }, line: { color: Wfe.color, width: SP({}, Wfe.width, { min: 1, dflt: 1 }), dash: SP({}, Oht, { dflt: "dot" }) } }), "arraydraw", "from-root");\n          });\n          var Jfe = ye((mor, Kfe) => {\n            "use strict";\n            var Zfe = Dr(), MP = ho(), Nht = Yd(), Uht = RN(), Yfe = f_();\n            Kfe.exports = function(t3, r4) {\n              Nht(t3, r4, { name: "selections", handleItemDefaults: Vht });\n              for (var n4 = r4.selections, i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                a4 && a4.path === void 0 && (a4.x0 === void 0 || a4.x1 === void 0 || a4.y0 === void 0 || a4.y1 === void 0) && (r4.selections[i3] = null);\n              }\n            };\n            function Vht(e3, t3, r4) {\n              function n4(x2, C3) {\n                return Zfe.coerce(e3, t3, Uht, x2, C3);\n              }\n              var i3 = n4("path"), a4 = i3 ? "path" : "rect", o4 = n4("type", a4), s3 = o4 !== "path";\n              s3 && delete t3.path, n4("opacity"), n4("line.color"), n4("line.width"), n4("line.dash");\n              for (var l3 = ["x", "y"], u4 = 0; u4 < 2; u4++) {\n                var c5 = l3[u4], f4 = { _fullLayout: r4 }, h3, d3, v3, _2 = MP.coerceRef(e3, t3, f4, c5);\n                if (h3 = MP.getFromId(f4, _2), h3._selectionIndices.push(t3._index), v3 = Yfe.rangeToShapePosition(h3), d3 = Yfe.shapePositionToRange(h3), s3) {\n                  var b = c5 + "0", p3 = c5 + "1", k4 = e3[b], E3 = e3[p3];\n                  e3[b] = d3(e3[b], true), e3[p3] = d3(e3[p3], true), MP.coercePosition(t3, f4, n4, _2, b), MP.coercePosition(t3, f4, n4, _2, p3);\n                  var S2 = t3[b], L3 = t3[p3];\n                  S2 !== void 0 && L3 !== void 0 && (t3[b] = v3(S2), t3[p3] = v3(L3), e3[b] = k4, e3[p3] = E3);\n                }\n              }\n              s3 && Zfe.noneOrAll(e3, t3, ["x0", "x1", "y0", "y1"]);\n            }\n          });\n          var Qfe = ye((yor, $fe) => {\n            "use strict";\n            $fe.exports = function(t3, r4, n4) {\n              n4("newselection.mode");\n              var i3 = n4("newselection.line.width");\n              i3 && (n4("newselection.line.color"), n4("newselection.line.dash")), n4("activeselection.fillcolor"), n4("activeselection.opacity");\n            };\n          });\n          var qM = ye((_or, rhe) => {\n            "use strict";\n            var Ght = qa(), ehe = Dr(), the = hf();\n            rhe.exports = function(t3) {\n              return function(n4, i3) {\n                var a4 = n4[t3];\n                if (Array.isArray(a4)) for (var o4 = Ght.subplotsRegistry.cartesian, s3 = o4.idRegex, l3 = i3._subplots, u4 = l3.xaxis, c5 = l3.yaxis, f4 = l3.cartesian, h3 = i3._has("cartesian"), d3 = 0; d3 < a4.length; d3++) {\n                  var v3 = a4[d3];\n                  if (ehe.isPlainObject(v3)) {\n                    var _2 = the.cleanId(v3.xref, "x", false), b = the.cleanId(v3.yref, "y", false), p3 = s3.x.test(_2), k4 = s3.y.test(b);\n                    if (p3 || k4) {\n                      h3 || ehe.pushUnique(i3._basePlotModules, o4);\n                      var E3 = false;\n                      p3 && u4.indexOf(_2) === -1 && (u4.push(_2), E3 = true), k4 && c5.indexOf(b) === -1 && (c5.push(b), E3 = true), E3 && p3 && k4 && f4.push(_2 + b);\n                    }\n                  }\n                }\n              };\n            };\n          });\n          var Of = ye((xor, nhe) => {\n            "use strict";\n            var ihe = _N(), BM = Lfe();\n            nhe.exports = { moduleType: "component", name: "selections", layoutAttributes: RN(), supplyLayoutDefaults: Jfe(), supplyDrawNewSelectionDefaults: Qfe(), includeBasePlot: qM()("selections"), draw: ihe.draw, drawOne: ihe.drawOne, reselect: BM.reselect, prepSelect: BM.prepSelect, clearOutline: BM.clearOutline, clearSelectionsCache: BM.clearSelectionsCache, selectOnClick: BM.selectOnClick };\n          });\n          var NN = ye((bor, Ahe) => {\n            "use strict";\n            var qN = Oa(), k0 = Dr(), ahe = k0.numberFormat, Hht = cd(), jht = RL(), EP = qa(), vhe = k0.strTranslate, Wht = ru(), ohe = ka(), d_ = So(), Xht = vf(), she = ho(), Zht = Sg(), Yht = yv(), phe = Eg(), kP = phe.selectingOrDrawing, Kht = phe.freeMode, Jht = $h().FROM_TL, $ht = vM(), Qht = wM().redrawReglTraces, edt = Mc(), FN = hf().getFromId, tdt = Of().prepSelect, rdt = Of().clearOutline, idt = Of().selectOnClick, DN = fN(), BN = hd(), lhe = BN.MINDRAG, np = BN.MINZOOM, uhe = true;\n            function ndt(e3, t3, r4, n4, i3, a4, o4, s3) {\n              var l3 = e3._fullLayout._zoomlayer, u4 = o4 + s3 === "nsew", c5 = (o4 + s3).length === 1, f4, h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2, Z, j3;\n              r4 += t3.yaxis._shift;\n              function N2() {\n                if (f4 = t3.xaxis, h3 = t3.yaxis, E3 = f4._length, S2 = h3._length, p3 = f4._offset, k4 = h3._offset, d3 = {}, d3[f4._id] = f4, v3 = {}, v3[h3._id] = h3, o4 && s3) for (var It = t3.overlays, mt = 0; mt < It.length; mt++) {\n                  var er = It[mt].xaxis;\n                  d3[er._id] = er;\n                  var lr = It[mt].yaxis;\n                  v3[lr._id] = lr;\n                }\n                _2 = dhe(d3), b = dhe(v3), C3 = che(_2, s3), M4 = che(b, o4), g3 = !M4 && !C3, x2 = hhe(e3, e3._fullLayout._axisMatchGroups, d3, v3), L3 = hhe(e3, e3._fullLayout._axisConstraintGroups, d3, v3, x2);\n                var Tr = L3.isSubplotConstrained || x2.isSubplotConstrained;\n                P3 = s3 || Tr, T3 = o4 || Tr;\n                var Lr = e3._fullLayout;\n                z3 = Lr._has("scattergl"), O3 = Lr._has("splom"), V2 = Lr._has("svg");\n              }\n              N2();\n              var H = sdt(M4 + C3, e3._fullLayout.dragmode, u4), te = mhe(t3, o4 + s3 + "drag", H, r4, n4, i3, a4);\n              if (g3 && !u4) return te.onmousedown = null, te.style.pointerEvents = "none", te;\n              var oe = { element: te, gd: e3, plotinfo: t3 };\n              oe.prepFn = function(It, mt, er) {\n                var lr = oe.dragmode, Tr = e3._fullLayout.dragmode;\n                Tr !== lr && (oe.dragmode = Tr), N2(), Z = e3._fullLayout._invScaleX, j3 = e3._fullLayout._invScaleY, g3 || (u4 ? It.shiftKey ? Tr === "pan" ? Tr = "zoom" : kP(Tr) || (Tr = "pan") : It.ctrlKey && (Tr = "pan") : Tr = "pan"), Kht(Tr) ? oe.minDrag = 1 : oe.minDrag = void 0, kP(Tr) ? (oe.xaxes = _2, oe.yaxes = b, tdt(It, mt, er, oe, Tr)) : (oe.clickFn = Ee, kP(lr) && _e(), g3 || (Tr === "zoom" ? (oe.moveFn = Ze, oe.doneFn = pt, oe.minDrag = 1, ce(It, mt, er)) : Tr === "pan" && (oe.moveFn = Jt, oe.doneFn = $e))), e3._fullLayout._redrag = function() {\n                  var Lr = e3._dragdata;\n                  if (Lr && Lr.element === te) {\n                    var ti = e3._fullLayout.dragmode;\n                    kP(ti) || (N2(), St([0, 0, E3, S2]), oe.moveFn(Lr.dx, Lr.dy));\n                  }\n                };\n              };\n              function _e() {\n                oe.plotinfo.selection = false, rdt(e3);\n              }\n              function Ee(It, mt) {\n                var er = oe.gd;\n                if (er._fullLayout._activeShapeIndex >= 0) {\n                  er._fullLayout._deactivateShape(er);\n                  return;\n                }\n                var lr = er._fullLayout.clickmode;\n                if (ON(er), It === 2 && !c5 && cr(), u4) lr.indexOf("select") > -1 && idt(mt, er, _2, b, t3.id, oe), lr.indexOf("event") > -1 && Xht.click(er, mt, t3.id);\n                else if (It === 1 && c5) {\n                  var Tr = o4 ? h3 : f4, Lr = o4 === "s" || s3 === "w" ? 0 : 1, ti = Tr._name + ".range[" + Lr + "]", Br = adt(Tr, Lr), Vr = "left", dt = "middle";\n                  if (Tr.fixedrange) return;\n                  o4 ? (dt = o4 === "n" ? "top" : "bottom", Tr.side === "right" && (Vr = "right")) : s3 === "e" && (Vr = "right"), er._context.showAxisRangeEntryBoxes && qN.select(te).call(Wht.makeEditable, { gd: er, immediate: true, background: er._fullLayout.paper_bgcolor, text: String(Br), fill: Tr.tickfont ? Tr.tickfont.color : "#444", horizontalAlign: Vr, verticalAlign: dt }).on("edit", function(Ge) {\n                    var Je = Tr.d2r(Ge);\n                    Je !== void 0 && EP.call("_guiRelayout", er, ti, Je);\n                  });\n                }\n              }\n              Yht.init(oe);\n              var Ce, me, ie, Se, Le, Ae, Fe, Pe, ge, Re;\n              function ce(It, mt, er) {\n                var lr = te.getBoundingClientRect();\n                Ce = mt - lr.left, me = er - lr.top, e3._fullLayout._calcInverseTransform(e3);\n                var Tr = k0.apply3DTransform(e3._fullLayout._invTransform)(Ce, me);\n                Ce = Tr[0], me = Tr[1], ie = { l: Ce, r: Ce, w: 0, t: me, b: me, h: 0 }, Se = e3._hmpixcount ? e3._hmlumcount / e3._hmpixcount : Hht(e3._fullLayout.plot_bgcolor).getLuminance(), Le = "M0,0H" + E3 + "V" + S2 + "H0V0", Ae = false, Fe = "xy", Re = false, Pe = yhe(l3, Se, p3, k4, Le), ge = _he(l3, p3, k4);\n              }\n              function Ze(It, mt) {\n                if (e3._transitioningWithDuration) return false;\n                var er = Math.max(0, Math.min(E3, Z * It + Ce)), lr = Math.max(0, Math.min(S2, j3 * mt + me)), Tr = Math.abs(er - Ce), Lr = Math.abs(lr - me);\n                ie.l = Math.min(Ce, er), ie.r = Math.max(Ce, er), ie.t = Math.min(me, lr), ie.b = Math.max(me, lr);\n                function ti() {\n                  Fe = "", ie.r = ie.l, ie.t = ie.b, ge.attr("d", "M0,0Z");\n                }\n                if (L3.isSubplotConstrained) Tr > np || Lr > np ? (Fe = "xy", Tr / E3 > Lr / S2 ? (Lr = Tr * S2 / E3, me > lr ? ie.t = me - Lr : ie.b = me + Lr) : (Tr = Lr * E3 / S2, Ce > er ? ie.l = Ce - Tr : ie.r = Ce + Tr), ge.attr("d", CP(ie))) : ti();\n                else if (x2.isSubplotConstrained) if (Tr > np || Lr > np) {\n                  Fe = "xy";\n                  var Br = Math.min(ie.l / E3, (S2 - ie.b) / S2), Vr = Math.max(ie.r / E3, (S2 - ie.t) / S2);\n                  ie.l = Br * E3, ie.r = Vr * E3, ie.b = (1 - Br) * S2, ie.t = (1 - Vr) * S2, ge.attr("d", CP(ie));\n                } else ti();\n                else !M4 || Lr < Math.min(Math.max(Tr * 0.6, lhe), np) ? Tr < lhe || !C3 ? ti() : (ie.t = 0, ie.b = S2, Fe = "x", ge.attr("d", ldt(ie, me))) : !C3 || Tr < Math.min(Lr * 0.6, np) ? (ie.l = 0, ie.r = E3, Fe = "y", ge.attr("d", udt(ie, Ce))) : (Fe = "xy", ge.attr("d", CP(ie)));\n                ie.w = ie.r - ie.l, ie.h = ie.b - ie.t, Fe && (Re = true), e3._dragged = Re, xhe(Pe, ge, ie, Le, Ae, Se), ut(), e3.emit("plotly_relayouting", G2), Ae = true;\n              }\n              function ut() {\n                G2 = {}, (Fe === "xy" || Fe === "x") && (zN(_2, ie.l / E3, ie.r / E3, G2, L3.xaxes), sr("x", G2)), (Fe === "xy" || Fe === "y") && (zN(b, (S2 - ie.b) / S2, (S2 - ie.t) / S2, G2, L3.yaxes), sr("y", G2));\n              }\n              function pt() {\n                ut(), ON(e3), $e(), whe(e3);\n              }\n              var Zt = [0, 0, E3, S2], st = null, lt = BN.REDRAWDELAY, Gt = t3.mainplot ? e3._fullLayout._plots[t3.mainplot] : t3;\n              function Nt(It) {\n                if (!e3._context._scrollZoom.cartesian && !e3._fullLayout._enablescrollzoom) return;\n                if (_e(), e3._transitioningWithDuration) {\n                  It.preventDefault(), It.stopPropagation();\n                  return;\n                }\n                N2(), clearTimeout(st);\n                var mt = -It.deltaY;\n                if (isFinite(mt) || (mt = It.wheelDelta / 10), !isFinite(mt)) {\n                  k0.log("Did not find wheel motion attributes: ", It);\n                  return;\n                }\n                var er = Math.exp(-Math.min(Math.max(mt, -20), 20) / 200), lr = Gt.draglayer.select(".nsewdrag").node().getBoundingClientRect(), Tr = (It.clientX - lr.left) / lr.width, Lr = (lr.bottom - It.clientY) / lr.height, ti;\n                function Br(Vr, dt, Ge) {\n                  if (Vr.fixedrange) return;\n                  var Je = k0.simpleMap(Vr.range, Vr.r2l), je = Je[0] + (Je[1] - Je[0]) * dt;\n                  function tt(xt) {\n                    return Vr.l2r(je + (xt - je) * Ge);\n                  }\n                  Vr.range = Je.map(tt);\n                }\n                if (P3) {\n                  for (s3 || (Tr = 0.5), ti = 0; ti < _2.length; ti++) Br(_2[ti], Tr, er);\n                  sr("x"), Zt[2] *= er, Zt[0] += Zt[2] * Tr * (1 / er - 1);\n                }\n                if (T3) {\n                  for (o4 || (Lr = 0.5), ti = 0; ti < b.length; ti++) Br(b[ti], Lr, er);\n                  sr("y"), Zt[3] *= er, Zt[1] += Zt[3] * (1 - Lr) * (1 / er - 1);\n                }\n                St(Zt), wr(), e3.emit("plotly_relayouting", G2), st = setTimeout(function() {\n                  e3._fullLayout && (Zt = [0, 0, E3, S2], $e());\n                }, lt), It.preventDefault();\n              }\n              o4.length * s3.length !== 1 && The(te, Nt);\n              function Jt(It, mt) {\n                if (It = It * Z, mt = mt * j3, e3._transitioningWithDuration) return;\n                if (e3._fullLayout._replotting = true, C3 === "ew" || M4 === "ns") {\n                  var er = C3 ? -It : 0, lr = M4 ? -mt : 0;\n                  if (x2.isSubplotConstrained) {\n                    if (C3 && M4) {\n                      var Tr = (It / E3 - mt / S2) / 2;\n                      It = Tr * E3, mt = -Tr * S2, er = -It, lr = -mt;\n                    }\n                    M4 ? er = -lr * E3 / S2 : lr = -er * S2 / E3;\n                  }\n                  C3 && (fhe(_2, It), sr("x")), M4 && (fhe(b, mt), sr("y")), St([er, lr, E3, S2]), wr(), e3.emit("plotly_relayouting", G2);\n                  return;\n                }\n                function Lr(tt, xt, Ie) {\n                  for (var xe = 1 - xt, ke, vt, ir = 0; ir < tt.length; ir++) {\n                    var ar = tt[ir];\n                    if (!ar.fixedrange) {\n                      ke = ar, vt = ar._rl[xe] + (ar._rl[xt] - ar._rl[xe]) / odt(Ie / ar._length);\n                      var vr = ar.l2r(vt);\n                      vr !== false && vr !== void 0 && (ar.range[xt] = vr);\n                    }\n                  }\n                  return ke._length * (ke._rl[xt] - vt) / (ke._rl[xt] - ke._rl[xe]);\n                }\n                var ti = C3 === "w" == (M4 === "n") ? 1 : -1;\n                if (C3 && M4 && (L3.isSubplotConstrained || x2.isSubplotConstrained)) {\n                  var Br = (It / E3 + ti * mt / S2) / 2;\n                  It = Br * E3, mt = ti * Br * S2;\n                }\n                var Vr, dt;\n                if (C3 === "w" ? It = Lr(_2, 0, It) : C3 === "e" ? It = Lr(_2, 1, -It) : C3 || (It = 0), M4 === "n" ? mt = Lr(b, 1, mt) : M4 === "s" ? mt = Lr(b, 0, -mt) : M4 || (mt = 0), Vr = C3 === "w" ? It : 0, dt = M4 === "n" ? mt : 0, L3.isSubplotConstrained && !x2.isSubplotConstrained || x2.isSubplotConstrained && C3 && M4 && ti > 0) {\n                  var Ge;\n                  if (x2.isSubplotConstrained || !C3 && M4.length === 1) {\n                    for (Ge = 0; Ge < _2.length; Ge++) _2[Ge].range = _2[Ge]._r.slice(), DN(_2[Ge], 1 - mt / S2);\n                    It = mt * E3 / S2, Vr = It / 2;\n                  }\n                  if (x2.isSubplotConstrained || !M4 && C3.length === 1) {\n                    for (Ge = 0; Ge < b.length; Ge++) b[Ge].range = b[Ge]._r.slice(), DN(b[Ge], 1 - It / E3);\n                    mt = It * S2 / E3, dt = mt / 2;\n                  }\n                }\n                (!x2.isSubplotConstrained || !M4) && sr("x"), (!x2.isSubplotConstrained || !C3) && sr("y");\n                var Je = E3 - It, je = S2 - mt;\n                x2.isSubplotConstrained && !(C3 && M4) && (C3 ? (dt = Vr ? 0 : It * S2 / E3, je = Je * S2 / E3) : (Vr = dt ? 0 : mt * E3 / S2, Je = je * E3 / S2)), St([Vr, dt, Je, je]), wr(), e3.emit("plotly_relayouting", G2);\n              }\n              function sr(It, mt) {\n                for (var er = x2.isSubplotConstrained ? { x: b, y: _2 }[It] : x2[It + "axes"], lr = x2.isSubplotConstrained ? { x: _2, y: b }[It] : [], Tr = 0; Tr < er.length; Tr++) {\n                  var Lr = er[Tr], ti = Lr._id, Br = x2.xLinks[ti] || x2.yLinks[ti], Vr = lr[0] || d3[Br] || v3[Br];\n                  Vr && (mt ? (mt[Lr._name + ".range[0]"] = mt[Vr._name + ".range[0]"], mt[Lr._name + ".range[1]"] = mt[Vr._name + ".range[1]"]) : Lr.range = Vr.range.slice());\n                }\n              }\n              function wr() {\n                var It = [], mt;\n                function er(ti) {\n                  for (mt = 0; mt < ti.length; mt++) ti[mt].fixedrange || It.push(ti[mt]._id);\n                }\n                function lr(ti, Br) {\n                  for (mt = 0; mt < ti.length; mt++) {\n                    var Vr = ti[mt], dt = Vr[Br];\n                    !Vr.fixedrange && dt.tickmode === "sync" && It.push(dt._id);\n                  }\n                }\n                for (P3 && (er(_2), er(L3.xaxes), er(x2.xaxes), lr(t3.overlays, "xaxis")), T3 && (er(b), er(L3.yaxes), er(x2.yaxes), lr(t3.overlays, "yaxis")), G2 = {}, mt = 0; mt < It.length; mt++) {\n                  var Tr = It[mt], Lr = FN(e3, Tr);\n                  she.drawOne(e3, Lr, { skipTitle: true }), G2[Lr._name + ".range[0]"] = Lr.range[0], G2[Lr._name + ".range[1]"] = Lr.range[1];\n                }\n                she.redrawComponents(e3, It);\n              }\n              function cr() {\n                if (!e3._transitioningWithDuration) {\n                  var It = e3._context.doubleClick, mt = [];\n                  C3 && (mt = mt.concat(_2)), M4 && (mt = mt.concat(b)), x2.xaxes && (mt = mt.concat(x2.xaxes)), x2.yaxes && (mt = mt.concat(x2.yaxes));\n                  var er = {}, lr, Tr;\n                  if (It === "reset+autosize") for (It = "autosize", Tr = 0; Tr < mt.length; Tr++) {\n                    lr = mt[Tr];\n                    var Lr = lr._rangeInitial0, ti = lr._rangeInitial1, Br = Lr !== void 0 || ti !== void 0;\n                    if (Br && (Lr !== void 0 && Lr !== lr.range[0] || ti !== void 0 && ti !== lr.range[1]) || !Br && lr.autorange !== true) {\n                      It = "reset";\n                      break;\n                    }\n                  }\n                  if (It === "autosize") for (Tr = 0; Tr < mt.length; Tr++) lr = mt[Tr], lr.fixedrange || (er[lr._name + ".autorange"] = true);\n                  else if (It === "reset") {\n                    for ((C3 || L3.isSubplotConstrained) && (mt = mt.concat(L3.xaxes)), M4 && !L3.isSubplotConstrained && (mt = mt.concat(L3.yaxes)), L3.isSubplotConstrained && (C3 ? M4 || (mt = mt.concat(b)) : mt = mt.concat(_2)), Tr = 0; Tr < mt.length; Tr++) if (lr = mt[Tr], !lr.fixedrange) {\n                      var Vr = lr._name, dt = lr._autorangeInitial;\n                      lr._rangeInitial0 === void 0 && lr._rangeInitial1 === void 0 ? er[Vr + ".autorange"] = true : lr._rangeInitial0 === void 0 ? (er[Vr + ".autorange"] = dt, er[Vr + ".range"] = [null, lr._rangeInitial1]) : lr._rangeInitial1 === void 0 ? (er[Vr + ".range"] = [lr._rangeInitial0, null], er[Vr + ".autorange"] = dt) : er[Vr + ".range"] = [lr._rangeInitial0, lr._rangeInitial1];\n                    }\n                  }\n                  e3.emit("plotly_doubleclick", null), EP.call("_guiRelayout", e3, er);\n                }\n              }\n              function $e() {\n                St([0, 0, E3, S2]), k0.syncOrAsync([edt.previousPromises, function() {\n                  e3._fullLayout._replotting = false, EP.call("_guiRelayout", e3, G2);\n                }], e3);\n              }\n              function St(It) {\n                var mt = e3._fullLayout, er = mt._plots, lr = mt._subplots.cartesian, Tr, Lr, ti, Br;\n                if (O3 && EP.subplotsRegistry.splom.drag(e3), z3) {\n                  for (Tr = 0; Tr < lr.length; Tr++) if (Lr = er[lr[Tr]], ti = Lr.xaxis, Br = Lr.yaxis, Lr._scene) {\n                    ti.limitRange && ti.limitRange(), Br.limitRange && Br.limitRange();\n                    var Vr = k0.simpleMap(ti.range, ti.r2l), dt = k0.simpleMap(Br.range, Br.r2l);\n                    Lr._scene.update({ range: [Vr[0], dt[0], Vr[1], dt[1]] });\n                  }\n                }\n                if ((O3 || z3) && ($ht(e3), Qht(e3)), V2) {\n                  var Ge = It[2] / f4._length, Je = It[3] / h3._length;\n                  for (Tr = 0; Tr < lr.length; Tr++) {\n                    Lr = er[lr[Tr]], ti = Lr.xaxis, Br = Lr.yaxis;\n                    var je = (P3 || x2.isSubplotConstrained) && !ti.fixedrange && d3[ti._id], tt = (T3 || x2.isSubplotConstrained) && !Br.fixedrange && v3[Br._id], xt, Ie, xe, ke;\n                    if (je ? (xt = Ge, xe = s3 || x2.isSubplotConstrained ? It[0] : _t(ti, xt)) : x2.xaHash[ti._id] ? (xt = Ge, xe = It[0] * ti._length / f4._length) : x2.yaHash[ti._id] ? (xt = Je, xe = M4 === "ns" ? -It[1] * ti._length / h3._length : _t(ti, xt, { n: "top", s: "bottom" }[M4])) : (xt = Qt(ti, Ge, Je), xe = Vt(ti, xt)), xt > 1 && (ti.maxallowed !== void 0 && P3 === (ti.range[0] < ti.range[1] ? "e" : "w") || ti.minallowed !== void 0 && P3 === (ti.range[0] < ti.range[1] ? "w" : "e")) && (xt = 1, xe = 0), tt ? (Ie = Je, ke = o4 || x2.isSubplotConstrained ? It[1] : _t(Br, Ie)) : x2.yaHash[Br._id] ? (Ie = Je, ke = It[1] * Br._length / h3._length) : x2.xaHash[Br._id] ? (Ie = Ge, ke = C3 === "ew" ? -It[0] * Br._length / f4._length : _t(Br, Ie, { e: "right", w: "left" }[C3])) : (Ie = Qt(Br, Ge, Je), ke = Vt(Br, Ie)), Ie > 1 && (Br.maxallowed !== void 0 && T3 === (Br.range[0] < Br.range[1] ? "n" : "s") || Br.minallowed !== void 0 && T3 === (Br.range[0] < Br.range[1] ? "s" : "n")) && (Ie = 1, ke = 0), !(!xt && !Ie)) {\n                      xt || (xt = 1), Ie || (Ie = 1);\n                      var vt = ti._offset - xe / xt, ir = Br._offset - ke / Ie;\n                      Lr.clipRect.call(d_.setTranslate, xe, ke).call(d_.setScale, xt, Ie), Lr.plot.call(d_.setTranslate, vt, ir).call(d_.setScale, 1 / xt, 1 / Ie), (xt !== Lr.xScaleFactor || Ie !== Lr.yScaleFactor) && (d_.setPointGroupScale(Lr.zoomScalePts, xt, Ie), d_.setTextPointsScale(Lr.zoomScaleTxt, xt, Ie)), d_.hideOutsideRangePoints(Lr.clipOnAxisFalseTraces, Lr), Lr.xScaleFactor = xt, Lr.yScaleFactor = Ie;\n                    }\n                  }\n                }\n              }\n              function Qt(It, mt, er) {\n                return It.fixedrange ? 0 : P3 && L3.xaHash[It._id] ? mt : T3 && (L3.isSubplotConstrained ? L3.xaHash : L3.yaHash)[It._id] ? er : 0;\n              }\n              function Vt(It, mt) {\n                return mt ? (It.range = It._r.slice(), DN(It, mt), _t(It, mt)) : 0;\n              }\n              function _t(It, mt, er) {\n                return It._length * (1 - mt) * Jht[er || It.constraintoward || "middle"];\n              }\n              return te;\n            }\n            function ghe(e3, t3, r4, n4) {\n              var i3 = k0.ensureSingle(e3.draglayer, t3, r4, function(a4) {\n                a4.classed("drag", true).style({ fill: "transparent", "stroke-width": 0 }).attr("data-subplot", e3.id);\n              });\n              return i3.call(Zht, n4), i3.node();\n            }\n            function mhe(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = ghe(e3, "rect", t3, r4);\n              return qN.select(s3).call(d_.setRect, n4, i3, a4, o4), s3;\n            }\n            function che(e3, t3) {\n              for (var r4 = 0; r4 < e3.length; r4++) if (!e3[r4].fixedrange) return t3;\n              return "";\n            }\n            function adt(e3, t3) {\n              var r4 = e3.range[t3], n4 = Math.abs(r4 - e3.range[1 - t3]), i3;\n              return e3.type === "date" ? r4 : e3.type === "log" ? (i3 = Math.ceil(Math.max(0, -Math.log(n4) / Math.LN10)) + 3, ahe("." + i3 + "g")(Math.pow(10, r4))) : (i3 = Math.floor(Math.log(Math.abs(r4)) / Math.LN10) - Math.floor(Math.log(n4) / Math.LN10) + 4, ahe("." + String(i3) + "g")(r4));\n            }\n            function zN(e3, t3, r4, n4, i3) {\n              for (var a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4];\n                if (!o4.fixedrange) if (o4.rangebreaks) {\n                  var s3 = o4._id.charAt(0) === "y", l3 = s3 ? 1 - t3 : t3, u4 = s3 ? 1 - r4 : r4;\n                  n4[o4._name + ".range[0]"] = o4.l2r(o4.p2l(l3 * o4._length)), n4[o4._name + ".range[1]"] = o4.l2r(o4.p2l(u4 * o4._length));\n                } else {\n                  var c5 = o4._rl[0], f4 = o4._rl[1] - c5;\n                  n4[o4._name + ".range[0]"] = o4.l2r(c5 + f4 * t3), n4[o4._name + ".range[1]"] = o4.l2r(c5 + f4 * r4);\n                }\n              }\n              if (i3 && i3.length) {\n                var h3 = (t3 + (1 - r4)) / 2;\n                zN(i3, h3, 1 - h3, n4, []);\n              }\n            }\n            function fhe(e3, t3) {\n              for (var r4 = 0; r4 < e3.length; r4++) {\n                var n4 = e3[r4];\n                if (!n4.fixedrange) {\n                  if (n4.rangebreaks) {\n                    var i3 = 0, a4 = n4._length, o4 = n4.p2l(i3 + t3) - n4.p2l(i3), s3 = n4.p2l(a4 + t3) - n4.p2l(a4), l3 = (o4 + s3) / 2;\n                    n4.range = [n4.l2r(n4._rl[0] - l3), n4.l2r(n4._rl[1] - l3)];\n                  } else n4.range = [n4.l2r(n4._rl[0] - t3 / n4._m), n4.l2r(n4._rl[1] - t3 / n4._m)];\n                  n4.limitRange && n4.limitRange();\n                }\n              }\n            }\n            function odt(e3) {\n              return 1 - (e3 >= 0 ? Math.min(e3, 0.9) : 1 / (1 / Math.max(e3, -0.3) + 3.222));\n            }\n            function sdt(e3, t3, r4) {\n              return e3 ? e3 === "nsew" ? r4 ? "" : t3 === "pan" ? "move" : "crosshair" : e3.toLowerCase() + "-resize" : "pointer";\n            }\n            function yhe(e3, t3, r4, n4, i3) {\n              return e3.append("path").attr("class", "zoombox").style({ fill: t3 > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)", "stroke-width": 0 }).attr("transform", vhe(r4, n4)).attr("d", i3 + "Z");\n            }\n            function _he(e3, t3, r4) {\n              return e3.append("path").attr("class", "zoombox-corners").style({ fill: ohe.background, stroke: ohe.defaultLine, "stroke-width": 1, opacity: 0 }).attr("transform", vhe(t3, r4)).attr("d", "M0,0Z");\n            }\n            function xhe(e3, t3, r4, n4, i3, a4) {\n              e3.attr("d", n4 + "M" + r4.l + "," + r4.t + "v" + r4.h + "h" + r4.w + "v-" + r4.h + "h-" + r4.w + "Z"), bhe(e3, t3, i3, a4);\n            }\n            function bhe(e3, t3, r4, n4) {\n              r4 || (e3.transition().style("fill", n4 > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200), t3.transition().style("opacity", 1).duration(200));\n            }\n            function ON(e3) {\n              qN.select(e3).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();\n            }\n            function whe(e3) {\n              uhe && e3.data && e3._context.showTips && (k0.notifier(k0._(e3, "Double-click to zoom back out"), "long"), uhe = false);\n            }\n            function ldt(e3, t3) {\n              return "M" + (e3.l - 0.5) + "," + (t3 - np - 0.5) + "h-3v" + (2 * np + 1) + "h3ZM" + (e3.r + 0.5) + "," + (t3 - np - 0.5) + "h3v" + (2 * np + 1) + "h-3Z";\n            }\n            function udt(e3, t3) {\n              return "M" + (t3 - np - 0.5) + "," + (e3.t - 0.5) + "v-3h" + (2 * np + 1) + "v3ZM" + (t3 - np - 0.5) + "," + (e3.b + 0.5) + "v3h" + (2 * np + 1) + "v-3Z";\n            }\n            function CP(e3) {\n              var t3 = Math.floor(Math.min(e3.b - e3.t, e3.r - e3.l, np) / 2);\n              return "M" + (e3.l - 3.5) + "," + (e3.t - 0.5 + t3) + "h3v" + -t3 + "h" + t3 + "v-3h-" + (t3 + 3) + "ZM" + (e3.r + 3.5) + "," + (e3.t - 0.5 + t3) + "h-3v" + -t3 + "h" + -t3 + "v-3h" + (t3 + 3) + "ZM" + (e3.r + 3.5) + "," + (e3.b + 0.5 - t3) + "h-3v" + t3 + "h" + -t3 + "v3h" + (t3 + 3) + "ZM" + (e3.l - 3.5) + "," + (e3.b + 0.5 - t3) + "h3v" + t3 + "h" + t3 + "v3h-" + (t3 + 3) + "Z";\n            }\n            function hhe(e3, t3, r4, n4, i3) {\n              for (var a4 = false, o4 = {}, s3 = {}, l3, u4, c5, f4, h3 = (i3 || {}).xaHash, d3 = (i3 || {}).yaHash, v3 = 0; v3 < t3.length; v3++) {\n                var _2 = t3[v3];\n                for (l3 in r4) if (_2[l3]) {\n                  for (c5 in _2) !(i3 && (h3[c5] || d3[c5])) && !(c5.charAt(0) === "x" ? r4 : n4)[c5] && (o4[c5] = l3);\n                  for (u4 in n4) !(i3 && (h3[u4] || d3[u4])) && _2[u4] && (a4 = true);\n                }\n                for (u4 in n4) if (_2[u4]) for (f4 in _2) !(i3 && (h3[f4] || d3[f4])) && !(f4.charAt(0) === "x" ? r4 : n4)[f4] && (s3[f4] = u4);\n              }\n              a4 && (k0.extendFlat(o4, s3), s3 = {});\n              var b = {}, p3 = [];\n              for (c5 in o4) {\n                var k4 = FN(e3, c5);\n                p3.push(k4), b[k4._id] = k4;\n              }\n              var E3 = {}, S2 = [];\n              for (f4 in s3) {\n                var L3 = FN(e3, f4);\n                S2.push(L3), E3[L3._id] = L3;\n              }\n              return { xaHash: b, yaHash: E3, xaxes: p3, yaxes: S2, xLinks: o4, yLinks: s3, isSubplotConstrained: a4 };\n            }\n            function The(e3, t3) {\n              if (!jht) e3.onwheel !== void 0 ? e3.onwheel = t3 : e3.onmousewheel !== void 0 ? e3.onmousewheel = t3 : e3.isAddedWheelEvent || (e3.isAddedWheelEvent = true, e3.addEventListener("wheel", t3, { passive: false }));\n              else {\n                var r4 = e3.onwheel !== void 0 ? "wheel" : "mousewheel";\n                e3._onwheel && e3.removeEventListener(r4, e3._onwheel), e3._onwheel = t3, e3.addEventListener(r4, t3, { passive: false });\n              }\n            }\n            function dhe(e3) {\n              var t3 = [];\n              for (var r4 in e3) t3.push(e3[r4]);\n              return t3;\n            }\n            Ahe.exports = { makeDragBox: ndt, makeDragger: ghe, makeRectDragger: mhe, makeZoombox: yhe, makeCorners: _he, updateZoombox: xhe, xyCorners: CP, transitionZoombox: bhe, removeZoombox: ON, showDoubleClickNotifier: whe, attachWheelEventHandler: The };\n          });\n          var UN = ye((PP) => {\n            "use strict";\n            var cdt = Oa(), LP = vf(), fdt = yv(), hdt = Sg(), Lg = NN().makeDragBox, gd = hd().DRAGGERSIZE;\n            PP.initInteractions = function(t3) {\n              var r4 = t3._fullLayout;\n              if (t3._context.staticPlot) {\n                cdt.select(t3).selectAll(".drag").remove();\n                return;\n              }\n              if (!(!r4._has("cartesian") && !r4._has("splom"))) {\n                var n4 = Object.keys(r4._plots || {}).sort(function(a4, o4) {\n                  if ((r4._plots[a4].mainplot && true) === (r4._plots[o4].mainplot && true)) {\n                    var s3 = a4.split("y"), l3 = o4.split("y");\n                    return s3[0] === l3[0] ? Number(s3[1] || 1) - Number(l3[1] || 1) : Number(s3[0] || 1) - Number(l3[0] || 1);\n                  }\n                  return r4._plots[a4].mainplot ? 1 : -1;\n                });\n                n4.forEach(function(a4) {\n                  var o4 = r4._plots[a4], s3 = o4.xaxis, l3 = o4.yaxis;\n                  if (!o4.mainplot) {\n                    var u4 = Lg(t3, o4, s3._offset, l3._offset, s3._length, l3._length, "ns", "ew");\n                    u4.onmousemove = function(h3) {\n                      t3._fullLayout._rehover = function() {\n                        t3._fullLayout._hoversubplot === a4 && t3._fullLayout._plots[a4] && LP.hover(t3, h3, a4);\n                      }, LP.hover(t3, h3, a4), t3._fullLayout._lasthover = u4, t3._fullLayout._hoversubplot = a4;\n                    }, u4.onmouseout = function(h3) {\n                      t3._dragging || (t3._fullLayout._hoversubplot = null, fdt.unhover(t3, h3));\n                    }, t3._context.showAxisDragHandles && (Lg(t3, o4, s3._offset - gd, l3._offset - gd, gd, gd, "n", "w"), Lg(t3, o4, s3._offset + s3._length, l3._offset - gd, gd, gd, "n", "e"), Lg(t3, o4, s3._offset - gd, l3._offset + l3._length, gd, gd, "s", "w"), Lg(t3, o4, s3._offset + s3._length, l3._offset + l3._length, gd, gd, "s", "e"));\n                  }\n                  if (t3._context.showAxisDragHandles) {\n                    if (a4 === s3._mainSubplot) {\n                      var c5 = s3._mainLinePosition;\n                      s3.side === "top" && (c5 -= gd), Lg(t3, o4, s3._offset + s3._length * 0.1, c5, s3._length * 0.8, gd, "", "ew"), Lg(t3, o4, s3._offset, c5, s3._length * 0.1, gd, "", "w"), Lg(t3, o4, s3._offset + s3._length * 0.9, c5, s3._length * 0.1, gd, "", "e");\n                    }\n                    if (a4 === l3._mainSubplot) {\n                      var f4 = l3._mainLinePosition;\n                      l3.side !== "right" && (f4 -= gd), Lg(t3, o4, f4, l3._offset + l3._length * 0.1, gd, l3._length * 0.8, "ns", ""), Lg(t3, o4, f4, l3._offset + l3._length * 0.9, gd, l3._length * 0.1, "s", ""), Lg(t3, o4, f4, l3._offset, gd, l3._length * 0.1, "n", "");\n                    }\n                  }\n                });\n                var i3 = r4._hoverlayer.node();\n                i3.onmousemove = function(a4) {\n                  a4.target = t3._fullLayout._lasthover, LP.hover(t3, a4, r4._hoversubplot);\n                }, i3.onclick = function(a4) {\n                  a4.target = t3._fullLayout._lasthover, LP.click(t3, a4);\n                }, i3.onmousedown = function(a4) {\n                  t3._fullLayout._lasthover.onmousedown(a4);\n                }, PP.updateFx(t3);\n              }\n            };\n            PP.updateFx = function(e3) {\n              var t3 = e3._fullLayout, r4 = t3.dragmode === "pan" ? "move" : "crosshair";\n              hdt(t3._draggers, r4);\n            };\n          });\n          var Ehe = ye((Tor, Mhe) => {\n            "use strict";\n            var She = qa();\n            Mhe.exports = function(t3) {\n              for (var r4 = She.layoutArrayContainers, n4 = She.layoutArrayRegexes, i3 = t3.split("[")[0], a4, o4, s3 = 0; s3 < n4.length; s3++) if (o4 = t3.match(n4[s3]), o4 && o4.index === 0) {\n                a4 = o4[0];\n                break;\n              }\n              if (a4 || (a4 = r4[r4.indexOf(i3)]), !a4) return false;\n              var l3 = t3.slice(a4.length);\n              return l3 ? (o4 = l3.match(/^\\[(0|[1-9][0-9]*)\\](\\.(.+))?$/), o4 ? { array: a4, index: Number(o4[1]), property: o4[3] || "" } : false) : { array: a4, index: "", property: "" };\n            };\n          });\n          var Che = ye((UM) => {\n            "use strict";\n            var ddt = my(), VN = w6(), NM = G1(), vdt = R6().sorterAsc, GN = qa();\n            UM.containerArrayMatch = Ehe();\n            var pdt = UM.isAddVal = function(t3) {\n              return t3 === "add" || ddt(t3);\n            }, khe = UM.isRemoveVal = function(t3) {\n              return t3 === null || t3 === "remove";\n            };\n            UM.applyContainerArrayChanges = function(t3, r4, n4, i3, a4) {\n              var o4 = r4.astr, s3 = GN.getComponentMethod(o4, "supplyLayoutDefaults"), l3 = GN.getComponentMethod(o4, "draw"), u4 = GN.getComponentMethod(o4, "drawOne"), c5 = i3.replot || i3.recalc || s3 === VN || l3 === VN, f4 = t3.layout, h3 = t3._fullLayout;\n              if (n4[""]) {\n                Object.keys(n4).length > 1 && NM.warn("Full array edits are incompatible with other edits", o4);\n                var d3 = n4[""][""];\n                if (khe(d3)) r4.set(null);\n                else if (Array.isArray(d3)) r4.set(d3);\n                else return NM.warn("Unrecognized full array edit value", o4, d3), true;\n                return c5 ? false : (s3(f4, h3), l3(t3), true);\n              }\n              var v3 = Object.keys(n4).map(Number).sort(vdt), _2 = r4.get(), b = _2 || [], p3 = a4(h3, o4).get(), k4 = [], E3 = -1, S2 = b.length, L3, x2, C3, M4, g3, P3, T3, z3;\n              for (L3 = 0; L3 < v3.length; L3++) {\n                if (C3 = v3[L3], M4 = n4[C3], g3 = Object.keys(M4), P3 = M4[""], T3 = pdt(P3), C3 < 0 || C3 > b.length - (T3 ? 0 : 1)) {\n                  NM.warn("index out of range", o4, C3);\n                  continue;\n                }\n                if (P3 !== void 0) g3.length > 1 && NM.warn("Insertion & removal are incompatible with edits to the same index.", o4, C3), khe(P3) ? k4.push(C3) : T3 ? (P3 === "add" && (P3 = {}), b.splice(C3, 0, P3), p3 && p3.splice(C3, 0, {})) : NM.warn("Unrecognized full object edit value", o4, C3, P3), E3 === -1 && (E3 = C3);\n                else for (x2 = 0; x2 < g3.length; x2++) z3 = o4 + "[" + C3 + "].", a4(b[C3], g3[x2], z3).set(M4[g3[x2]]);\n              }\n              for (L3 = k4.length - 1; L3 >= 0; L3--) b.splice(k4[L3], 1), p3 && p3.splice(k4[L3], 1);\n              if (b.length ? _2 || r4.set(b) : r4.set(null), c5) return false;\n              if (s3(f4, h3), u4 !== VN) {\n                var O3;\n                if (E3 === -1) O3 = v3;\n                else {\n                  for (S2 = Math.max(b.length, S2), O3 = [], L3 = 0; L3 < v3.length && (C3 = v3[L3], !(C3 >= E3)); L3++) O3.push(C3);\n                  for (L3 = E3; L3 < S2; L3++) O3.push(L3);\n                }\n                for (L3 = 0; L3 < O3.length; L3++) u4(t3, O3[L3]);\n              } else l3(t3);\n              return true;\n            };\n          });\n          var Ohe = ye((C0) => {\n            "use strict";\n            var Rhe = Eo(), Dhe = qa(), Uv = Dr(), VM = Mc(), Fhe = hf(), zhe = ka(), GM = Fhe.cleanId, gdt = Fhe.getFromTrace, HN = Dhe.traceIs, mdt = ["x", "y", "z"];\n            C0.clearPromiseQueue = function(e3) {\n              Array.isArray(e3._promises) && e3._promises.length > 0 && Uv.log("Clearing previous rejected promises from queue."), e3._promises = [];\n            };\n            C0.cleanLayout = function(e3) {\n              var t3, r4;\n              e3 || (e3 = {}), e3.xaxis1 && (e3.xaxis || (e3.xaxis = e3.xaxis1), delete e3.xaxis1), e3.yaxis1 && (e3.yaxis || (e3.yaxis = e3.yaxis1), delete e3.yaxis1), e3.scene1 && (e3.scene || (e3.scene = e3.scene1), delete e3.scene1);\n              var n4 = (VM.subplotsRegistry.cartesian || {}).attrRegex, i3 = (VM.subplotsRegistry.polar || {}).attrRegex, a4 = (VM.subplotsRegistry.ternary || {}).attrRegex, o4 = (VM.subplotsRegistry.gl3d || {}).attrRegex, s3 = Object.keys(e3);\n              for (t3 = 0; t3 < s3.length; t3++) {\n                var l3 = s3[t3];\n                if (n4 && n4.test(l3)) {\n                  var u4 = e3[l3];\n                  u4.anchor && u4.anchor !== "free" && (u4.anchor = GM(u4.anchor)), u4.overlaying && (u4.overlaying = GM(u4.overlaying)), u4.type || (u4.isdate ? u4.type = "date" : u4.islog ? u4.type = "log" : u4.isdate === false && u4.islog === false && (u4.type = "linear")), (u4.autorange === "withzero" || u4.autorange === "tozero") && (u4.autorange = true, u4.rangemode = "tozero"), u4.insiderange && delete u4.range, delete u4.islog, delete u4.isdate, delete u4.categories, IP(u4, "domain") && delete u4.domain;\n                }\n              }\n              var c5 = Array.isArray(e3.annotations) ? e3.annotations.length : 0;\n              for (t3 = 0; t3 < c5; t3++) {\n                var f4 = e3.annotations[t3];\n                Uv.isPlainObject(f4) && (Q3(f4, "xref"), Q3(f4, "yref"));\n              }\n              var h3 = Array.isArray(e3.shapes) ? e3.shapes.length : 0;\n              for (t3 = 0; t3 < h3; t3++) {\n                var d3 = e3.shapes[t3];\n                Uv.isPlainObject(d3) && (Q3(d3, "xref"), Q3(d3, "yref"));\n              }\n              var v3 = Array.isArray(e3.images) ? e3.images.length : 0;\n              for (t3 = 0; t3 < v3; t3++) {\n                var _2 = e3.images[t3];\n                Uv.isPlainObject(_2) && (Q3(_2, "xref"), Q3(_2, "yref"));\n              }\n              var b = e3.legend;\n              return b && (b.x > 3 ? (b.x = 1.02, b.xanchor = "left") : b.x < -2 && (b.x = -0.02, b.xanchor = "right"), b.y > 3 ? (b.y = 1.02, b.yanchor = "bottom") : b.y < -2 && (b.y = -0.02, b.yanchor = "top")), e3.dragmode === "rotate" && (e3.dragmode = "orbit"), zhe.clean(e3), e3.template && e3.template.layout && C0.cleanLayout(e3.template.layout), e3;\n            };\n            function Q3(e3, t3) {\n              var r4 = e3[t3], n4 = t3.charAt(0);\n              r4 && r4 !== "paper" && (e3[t3] = GM(r4, n4, true));\n            }\n            C0.cleanData = function(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) {\n                var r4 = e3[t3], n4;\n                if (r4.type === "histogramy" && "xbins" in r4 && !("ybins" in r4) && (r4.ybins = r4.xbins, delete r4.xbins), r4.type === "histogramy" && C0.swapXYData(r4), (r4.type === "histogramx" || r4.type === "histogramy") && (r4.type = "histogram"), "scl" in r4 && !("colorscale" in r4) && (r4.colorscale = r4.scl, delete r4.scl), "reversescl" in r4 && !("reversescale" in r4) && (r4.reversescale = r4.reversescl, delete r4.reversescl), r4.xaxis && (r4.xaxis = GM(r4.xaxis, "x")), r4.yaxis && (r4.yaxis = GM(r4.yaxis, "y")), HN(r4, "gl3d") && r4.scene && (r4.scene = VM.subplotsRegistry.gl3d.cleanId(r4.scene)), !HN(r4, "pie-like") && !HN(r4, "bar-like")) if (Array.isArray(r4.textposition)) for (n4 = 0; n4 < r4.textposition.length; n4++) r4.textposition[n4] = Phe(r4.textposition[n4]);\n                else r4.textposition && (r4.textposition = Phe(r4.textposition));\n                var i3 = Dhe.getModule(r4);\n                if (i3 && i3.colorbar) {\n                  var a4 = i3.colorbar.container, o4 = a4 ? r4[a4] : r4;\n                  o4 && o4.colorscale && (o4.colorscale === "YIGnBu" && (o4.colorscale = "YlGnBu"), o4.colorscale === "YIOrRd" && (o4.colorscale = "YlOrRd"));\n                }\n                if (r4.type === "surface" && Uv.isPlainObject(r4.contours)) {\n                  var s3 = ["x", "y", "z"];\n                  for (n4 = 0; n4 < s3.length; n4++) {\n                    var l3 = r4.contours[s3[n4]];\n                    Uv.isPlainObject(l3) && (l3.highlightColor && (l3.highlightcolor = l3.highlightColor, delete l3.highlightColor), l3.highlightWidth && (l3.highlightwidth = l3.highlightWidth, delete l3.highlightWidth));\n                  }\n                }\n                if (r4.type === "candlestick" || r4.type === "ohlc") {\n                  var u4 = (r4.increasing || {}).showlegend !== false, c5 = (r4.decreasing || {}).showlegend !== false, f4 = Lhe(r4.increasing), h3 = Lhe(r4.decreasing);\n                  if (f4 !== false && h3 !== false) {\n                    var d3 = ydt(f4, h3, u4, c5);\n                    d3 && (r4.name = d3);\n                  } else (f4 || h3) && !r4.name && (r4.name = f4 || h3);\n                }\n                IP(r4, "line") && delete r4.line, "marker" in r4 && (IP(r4.marker, "line") && delete r4.marker.line, IP(r4, "marker") && delete r4.marker), zhe.clean(r4), r4.autobinx && (delete r4.autobinx, delete r4.xbins), r4.autobiny && (delete r4.autobiny, delete r4.ybins);\n              }\n            };\n            function Lhe(e3) {\n              if (!Uv.isPlainObject(e3)) return false;\n              var t3 = e3.name;\n              return delete e3.name, delete e3.showlegend, (typeof t3 == "string" || typeof t3 == "number") && String(t3);\n            }\n            function ydt(e3, t3, r4, n4) {\n              if (r4 && !n4) return e3;\n              if (n4 && !r4 || !e3.trim()) return t3;\n              if (!t3.trim()) return e3;\n              var i3 = Math.min(e3.length, t3.length), a4;\n              for (a4 = 0; a4 < i3 && e3.charAt(a4) === t3.charAt(a4); a4++) ;\n              var o4 = e3.slice(0, a4);\n              return o4.trim();\n            }\n            function Phe(e3) {\n              var t3 = "middle", r4 = "center";\n              return typeof e3 == "string" && (e3.indexOf("top") !== -1 ? t3 = "top" : e3.indexOf("bottom") !== -1 && (t3 = "bottom"), e3.indexOf("left") !== -1 ? r4 = "left" : e3.indexOf("right") !== -1 && (r4 = "right")), t3 + " " + r4;\n            }\n            function IP(e3, t3) {\n              return t3 in e3 && typeof e3[t3] == "object" && Object.keys(e3[t3]).length === 0;\n            }\n            C0.swapXYData = function(e3) {\n              var t3;\n              if (Uv.swapAttrs(e3, ["?", "?0", "d?", "?bins", "nbins?", "autobin?", "?src", "error_?"]), Array.isArray(e3.z) && Array.isArray(e3.z[0]) && (e3.transpose ? delete e3.transpose : e3.transpose = true), e3.error_x && e3.error_y) {\n                var r4 = e3.error_y, n4 = "copy_ystyle" in r4 ? r4.copy_ystyle : !(r4.color || r4.thickness || r4.width);\n                Uv.swapAttrs(e3, ["error_?.copy_ystyle"]), n4 && Uv.swapAttrs(e3, ["error_?.color", "error_?.thickness", "error_?.width"]);\n              }\n              if (typeof e3.hoverinfo == "string") {\n                var i3 = e3.hoverinfo.split("+");\n                for (t3 = 0; t3 < i3.length; t3++) i3[t3] === "x" ? i3[t3] = "y" : i3[t3] === "y" && (i3[t3] = "x");\n                e3.hoverinfo = i3.join("+");\n              }\n            };\n            C0.coerceTraceIndices = function(e3, t3) {\n              if (Rhe(t3)) return [t3];\n              if (!Array.isArray(t3) || !t3.length) return e3.data.map(function(i3, a4) {\n                return a4;\n              });\n              if (Array.isArray(t3)) {\n                for (var r4 = [], n4 = 0; n4 < t3.length; n4++) Uv.isIndex(t3[n4], e3.data.length) ? r4.push(t3[n4]) : Uv.warn("trace index (", t3[n4], ") is not a number or is out of bounds");\n                return r4;\n              }\n              return t3;\n            };\n            C0.manageArrayContainers = function(e3, t3, r4) {\n              var n4 = e3.obj, i3 = e3.parts, a4 = i3.length, o4 = i3[a4 - 1], s3 = Rhe(o4);\n              if (s3 && t3 === null) {\n                var l3 = i3.slice(0, a4 - 1).join("."), u4 = Uv.nestedProperty(n4, l3).get();\n                u4.splice(o4, 1);\n              } else s3 && e3.get() === void 0 && e3.get() === void 0 && (r4[e3.astr] = null), e3.set(t3);\n            };\n            var _dt = /(\\.[^\\[\\]\\.]+|\\[[^\\[\\]\\.]+\\])$/;\n            function Ihe(e3) {\n              var t3 = e3.search(_dt);\n              if (t3 > 0) return e3.slice(0, t3);\n            }\n            C0.hasParent = function(e3, t3) {\n              for (var r4 = Ihe(t3); r4; ) {\n                if (r4 in e3) return true;\n                r4 = Ihe(r4);\n              }\n              return false;\n            };\n            C0.clearAxisTypes = function(e3, t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4++) for (var i3 = e3._fullData[n4], a4 = 0; a4 < 3; a4++) {\n                var o4 = gdt(e3, i3, mdt[a4]);\n                if (o4 && o4.type !== "log") {\n                  var s3 = o4._name, l3 = o4._id.slice(1);\n                  if (l3.slice(0, 5) === "scene") {\n                    if (r4[l3] !== void 0) continue;\n                    s3 = l3 + "." + s3;\n                  }\n                  var u4 = s3 + ".type";\n                  r4[s3] === void 0 && r4[u4] === void 0 && Uv.nestedProperty(e3.layout, u4).set(null);\n                }\n              }\n            };\n            var jN = (e3, t3) => {\n              let r4 = (...n4) => n4.every((i3) => Uv.isPlainObject(i3)) || n4.every((i3) => Array.isArray(i3));\n              if ([e3, t3].every((n4) => Array.isArray(n4))) {\n                if (e3.length !== t3.length) return false;\n                for (let n4 = 0; n4 < e3.length; n4++) {\n                  let i3 = e3[n4], a4 = t3[n4];\n                  if (i3 !== a4 && !(r4(i3, a4) ? jN(i3, a4) : false)) return false;\n                }\n                return true;\n              } else if ([e3, t3].every((n4) => Uv.isPlainObject(n4))) {\n                if (Object.keys(e3).length !== Object.keys(t3).length) return false;\n                for (let n4 in e3) {\n                  if (n4.startsWith("_")) continue;\n                  let i3 = e3[n4], a4 = t3[n4];\n                  if (i3 !== a4 && !(r4(i3, a4) ? jN(i3, a4) : false)) return false;\n                }\n                return true;\n              }\n              return false;\n            };\n            C0.collectionsAreEqual = jN;\n          });\n          var HP = ye((_l) => {\n            "use strict";\n            var FP = Oa(), xdt = Eo(), bdt = nq(), Sa = Dr(), Ec = Sa.nestedProperty, ZN = _3(), ap = yne(), L0 = qa(), VP = w3(), Qo = Mc(), Vv = ho(), wdt = xB(), Tdt = Rd(), WN = So(), Adt = ka(), Sdt = UN().initInteractions, Mdt = Wp(), Edt = Of().clearOutline, Vhe = cb().dfltConfig, RP = Che(), vh = Ohe(), Au = wM(), v_ = mc(), kdt = hd().AX_NAME_PATTERN, XN = 0, qhe = 5;\n            function Cdt(e3, t3, r4, n4) {\n              var i3;\n              if (e3 = Sa.getGraphDiv(e3), ZN.init(e3), Sa.isPlainObject(t3)) {\n                var a4 = t3;\n                t3 = a4.data, r4 = a4.layout, n4 = a4.config, i3 = a4.frames;\n              }\n              var o4 = ZN.triggerHandler(e3, "plotly_beforeplot", [t3, r4, n4]);\n              if (o4 === false) return Promise.reject();\n              !t3 && !r4 && !Sa.isPlotDiv(e3) && Sa.warn("Calling _doPlot as if redrawing but this container doesn\'t yet have a plot.", e3);\n              function s3() {\n                if (i3) return _l.addFrames(e3, i3);\n              }\n              Hhe(e3, n4), r4 || (r4 = {}), FP.select(e3).classed("js-plotly-plot", true), WN.makeTester(), Array.isArray(e3._promises) || (e3._promises = []);\n              var l3 = (e3.data || []).length === 0 && Array.isArray(t3);\n              Array.isArray(t3) && (vh.cleanData(t3), l3 ? e3.data = t3 : e3.data.push.apply(e3.data, t3), e3.empty = false), (!e3.layout || l3) && (e3.layout = vh.cleanLayout(r4)), Qo.supplyDefaults(e3);\n              var u4 = e3._fullLayout, c5 = u4._has("cartesian");\n              u4._replotting = true, (l3 || u4._shouldCreateBgLayer) && ($dt(e3), u4._shouldCreateBgLayer && delete u4._shouldCreateBgLayer), WN.initGradients(e3), WN.initPatterns(e3), l3 && Vv.saveShowSpikeInitial(e3);\n              var f4 = !e3.calcdata || e3.calcdata.length !== (e3._fullData || []).length;\n              f4 && Qo.doCalcdata(e3);\n              for (var h3 = 0; h3 < e3.calcdata.length; h3++) e3.calcdata[h3][0].trace = e3._fullData[h3];\n              e3._context.responsive ? e3._responsiveChartHandler || (e3._responsiveChartHandler = function() {\n                Sa.isHidden(e3) || Qo.resize(e3);\n              }, window.addEventListener("resize", e3._responsiveChartHandler)) : Sa.clearResponsive(e3);\n              var d3 = Sa.extendFlat({}, u4._size), v3 = 0;\n              function _2() {\n                for (var C3 = u4._basePlotModules, M4 = 0; M4 < C3.length; M4++) C3[M4].drawFramework && C3[M4].drawFramework(e3);\n                !u4._glcanvas && u4._has("gl") && (u4._glcanvas = u4._glcontainer.selectAll(".gl-canvas").data([{ key: "contextLayer", context: true, pick: false }, { key: "focusLayer", context: false, pick: false }, { key: "pickLayer", context: false, pick: true }], function(z3) {\n                  return z3.key;\n                }), u4._glcanvas.enter().append("canvas").attr("class", function(z3) {\n                  return "gl-canvas gl-canvas-" + z3.key.replace("Layer", "");\n                }).style({ position: "absolute", top: 0, left: 0, overflow: "visible", "pointer-events": "none" }));\n                var g3 = e3._context.plotGlPixelRatio;\n                if (u4._glcanvas) {\n                  u4._glcanvas.attr("width", u4.width * g3).attr("height", u4.height * g3).style("width", u4.width + "px").style("height", u4.height + "px");\n                  var P3 = u4._glcanvas.data()[0].regl;\n                  if (P3 && (Math.floor(u4.width * g3) !== P3._gl.drawingBufferWidth || Math.floor(u4.height * g3) !== P3._gl.drawingBufferHeight)) {\n                    var T3 = "WebGL context buffer and canvas dimensions do not match due to browser/WebGL bug.";\n                    if (v3) Sa.error(T3);\n                    else return Sa.log(T3 + " Clearing graph and plotting again."), Qo.cleanPlot([], {}, e3._fullData, u4), Qo.supplyDefaults(e3), u4 = e3._fullLayout, Qo.doCalcdata(e3), v3++, _2();\n                  }\n                }\n                return u4.modebar.orientation === "h" ? u4._modebardiv.style("height", null).style("width", "100%") : u4._modebardiv.style("width", null).style("height", u4.height + "px"), Qo.previousPromises(e3);\n              }\n              function b() {\n                if (Qo.clearAutoMarginIds(e3), Au.drawMarginPushers(e3), Vv.allowAutoMargin(e3), e3._fullLayout.title.text && e3._fullLayout.title.automargin && Qo.allowAutoMargin(e3, "title.automargin"), u4._has("pie")) for (var C3 = e3._fullData, M4 = 0; M4 < C3.length; M4++) {\n                  var g3 = C3[M4];\n                  g3.type === "pie" && g3.automargin && Qo.allowAutoMargin(e3, "pie." + g3.uid + ".automargin");\n                }\n                return Qo.doAutoMargin(e3), Qo.previousPromises(e3);\n              }\n              function p3() {\n                if (Qo.didMarginChange(d3, u4._size)) return Sa.syncOrAsync([b, Au.layoutStyles], e3);\n              }\n              function k4() {\n                if (!f4) {\n                  E3();\n                  return;\n                }\n                return Sa.syncOrAsync([L0.getComponentMethod("shapes", "calcAutorange"), L0.getComponentMethod("annotations", "calcAutorange"), E3], e3);\n              }\n              function E3() {\n                e3._transitioning || (Au.doAutoRangeAndConstraints(e3), l3 && Vv.saveRangeInitial(e3), L0.getComponentMethod("rangeslider", "calcAutorange")(e3));\n              }\n              function S2() {\n                return Vv.draw(e3, l3 ? "" : "redraw");\n              }\n              var L3 = [Qo.previousPromises, s3, _2, b, p3];\n              c5 && L3.push(k4), L3.push(Au.layoutStyles), c5 && L3.push(S2, function(M4) {\n                var g3 = M4._fullLayout._insideTickLabelsUpdaterange;\n                if (g3) return M4._fullLayout._insideTickLabelsUpdaterange = void 0, HM(M4, g3).then(function() {\n                  Vv.saveRangeInitial(M4, true);\n                });\n              }), L3.push(Au.drawData, Au.finalDraw, Sdt, Qo.addLinks, Qo.rehover, Qo.redrag, Qo.reselect, Qo.doAutoMargin, Qo.previousPromises);\n              var x2 = Sa.syncOrAsync(L3, e3);\n              return (!x2 || !x2.then) && (x2 = Promise.resolve()), x2.then(function() {\n                return jM(e3), e3;\n              });\n            }\n            function jM(e3) {\n              var t3 = e3._fullLayout;\n              t3._redrawFromAutoMarginCount ? t3._redrawFromAutoMarginCount-- : e3.emit("plotly_afterplot");\n            }\n            function Ldt(e3) {\n              return Sa.extendFlat(Vhe, e3);\n            }\n            function Ghe(e3, t3) {\n              try {\n                e3._fullLayout._paper.style("background", t3);\n              } catch (r4) {\n                Sa.error(r4);\n              }\n            }\n            function Pdt(e3, t3) {\n              var r4 = Adt.combine(t3, "white");\n              Ghe(e3, r4);\n            }\n            function Hhe(e3, t3) {\n              if (!e3._context) {\n                e3._context = Sa.extendDeep({}, Vhe);\n                var r4 = FP.select("base");\n                e3._context._baseUrl = r4.size() && r4.attr("href") ? window.location.href.split("#")[0] : "";\n              }\n              var n4 = e3._context, i3, a4, o4;\n              if (t3) {\n                for (a4 = Object.keys(t3), i3 = 0; i3 < a4.length; i3++) o4 = a4[i3], !(o4 === "editable" || o4 === "edits") && o4 in n4 && (o4 === "setBackground" && t3[o4] === "opaque" ? n4[o4] = Pdt : n4[o4] = t3[o4]);\n                var s3 = t3.editable;\n                if (s3 !== void 0) for (n4.editable = s3, a4 = Object.keys(n4.edits), i3 = 0; i3 < a4.length; i3++) n4.edits[a4[i3]] = s3;\n                if (t3.edits) for (a4 = Object.keys(t3.edits), i3 = 0; i3 < a4.length; i3++) o4 = a4[i3], o4 in n4.edits && (n4.edits[o4] = t3.edits[o4]);\n                n4._exportedPlot = t3._exportedPlot;\n              }\n              n4.staticPlot && (n4.editable = false, n4.edits = {}, n4.autosizable = false, n4.scrollZoom = false, n4.doubleClick = false, n4.showTips = false, n4.showLink = false, n4.displayModeBar = false), n4.displayModeBar === "hover" && !bdt && (n4.displayModeBar = true), (n4.setBackground === "transparent" || typeof n4.setBackground != "function") && (n4.setBackground = Ghe), n4._hasZeroHeight = n4._hasZeroHeight || e3.clientHeight === 0, n4._hasZeroWidth = n4._hasZeroWidth || e3.clientWidth === 0;\n              var l3 = n4.scrollZoom, u4 = n4._scrollZoom = {};\n              if (l3 === true) u4.cartesian = 1, u4.gl3d = 1, u4.geo = 1, u4.mapbox = 1, u4.map = 1;\n              else if (typeof l3 == "string") {\n                var c5 = l3.split("+");\n                for (i3 = 0; i3 < c5.length; i3++) u4[c5[i3]] = 1;\n              } else l3 !== false && (u4.gl3d = 1, u4.geo = 1, u4.mapbox = 1, u4.map = 1);\n            }\n            function Idt(e3) {\n              if (e3 = Sa.getGraphDiv(e3), !Sa.isPlotDiv(e3)) throw new Error("This element is not a Plotly plot: " + e3);\n              return vh.cleanData(e3.data), vh.cleanLayout(e3.layout), e3.calcdata = void 0, _l._doPlot(e3).then(function() {\n                return e3.emit("plotly_redraw"), e3;\n              });\n            }\n            function Rdt(e3, t3, r4, n4) {\n              return e3 = Sa.getGraphDiv(e3), Qo.cleanPlot([], {}, e3._fullData || [], e3._fullLayout || {}), Qo.purge(e3), _l._doPlot(e3, t3, r4, n4);\n            }\n            function zP(e3, t3) {\n              var r4 = t3 + 1, n4 = [], i3, a4;\n              for (i3 = 0; i3 < e3.length; i3++) a4 = e3[i3], a4 < 0 ? n4.push(r4 + a4) : n4.push(a4);\n              return n4;\n            }\n            function OP(e3, t3, r4) {\n              var n4, i3;\n              for (n4 = 0; n4 < t3.length; n4++) {\n                if (i3 = t3[n4], i3 !== parseInt(i3, 10)) throw new Error("all values in " + r4 + " must be integers");\n                if (i3 >= e3.data.length || i3 < -e3.data.length) throw new Error(r4 + " must be valid indices for gd.data.");\n                if (t3.indexOf(i3, n4 + 1) > -1 || i3 >= 0 && t3.indexOf(-e3.data.length + i3) > -1 || i3 < 0 && t3.indexOf(e3.data.length + i3) > -1) throw new Error("each index in " + r4 + " must be unique.");\n              }\n            }\n            function jhe(e3, t3, r4) {\n              if (!Array.isArray(e3.data)) throw new Error("gd.data must be an array.");\n              if (typeof t3 == "undefined") throw new Error("currentIndices is a required argument.");\n              if (Array.isArray(t3) || (t3 = [t3]), OP(e3, t3, "currentIndices"), typeof r4 != "undefined" && !Array.isArray(r4) && (r4 = [r4]), typeof r4 != "undefined" && OP(e3, r4, "newIndices"), typeof r4 != "undefined" && t3.length !== r4.length) throw new Error("current and new indices must be of equal length.");\n            }\n            function Ddt(e3, t3, r4) {\n              var n4, i3;\n              if (!Array.isArray(e3.data)) throw new Error("gd.data must be an array.");\n              if (typeof t3 == "undefined") throw new Error("traces must be defined.");\n              for (Array.isArray(t3) || (t3 = [t3]), n4 = 0; n4 < t3.length; n4++) if (i3 = t3[n4], typeof i3 != "object" || Array.isArray(i3) || i3 === null) throw new Error("all values in traces array must be non-array objects");\n              if (typeof r4 != "undefined" && !Array.isArray(r4) && (r4 = [r4]), typeof r4 != "undefined" && r4.length !== t3.length) throw new Error("if indices is specified, traces.length must equal indices.length");\n            }\n            function Fdt(e3, t3, r4, n4) {\n              var i3 = Sa.isPlainObject(n4);\n              if (!Array.isArray(e3.data)) throw new Error("gd.data must be an array");\n              if (!Sa.isPlainObject(t3)) throw new Error("update must be a key:value object");\n              if (typeof r4 == "undefined") throw new Error("indices must be an integer or array of integers");\n              OP(e3, r4, "indices");\n              for (var a4 in t3) {\n                if (!Array.isArray(t3[a4]) || t3[a4].length !== r4.length) throw new Error("attribute " + a4 + " must be an array of length equal to indices array length");\n                if (i3 && (!(a4 in n4) || !Array.isArray(n4[a4]) || n4[a4].length !== t3[a4].length)) throw new Error("when maxPoints is set as a key:value object it must contain a 1:1 correspondence with the keys and number of traces in the update object");\n              }\n            }\n            function zdt(e3, t3, r4, n4) {\n              var i3 = Sa.isPlainObject(n4), a4 = [], o4, s3, l3, u4, c5;\n              Array.isArray(r4) || (r4 = [r4]), r4 = zP(r4, e3.data.length - 1);\n              for (var f4 in t3) for (var h3 = 0; h3 < r4.length; h3++) {\n                if (o4 = e3.data[r4[h3]], l3 = Ec(o4, f4), s3 = l3.get(), u4 = t3[f4][h3], !Sa.isArrayOrTypedArray(u4)) throw new Error("attribute: " + f4 + " index: " + h3 + " must be an array");\n                if (!Sa.isArrayOrTypedArray(s3)) throw new Error("cannot extend missing or non-array attribute: " + f4);\n                if (s3.constructor !== u4.constructor) throw new Error("cannot extend array with an array of a different type: " + f4);\n                c5 = i3 ? n4[f4][h3] : n4, xdt(c5) || (c5 = -1), a4.push({ prop: l3, target: s3, insert: u4, maxp: Math.floor(c5) });\n              }\n              return a4;\n            }\n            function Whe(e3, t3, r4, n4, i3) {\n              Fdt(e3, t3, r4, n4);\n              for (var a4 = zdt(e3, t3, r4, n4), o4 = {}, s3 = {}, l3 = 0; l3 < a4.length; l3++) {\n                var u4 = a4[l3].prop, c5 = a4[l3].maxp, f4 = i3(a4[l3].target, a4[l3].insert, c5);\n                u4.set(f4[0]), Array.isArray(o4[u4.astr]) || (o4[u4.astr] = []), o4[u4.astr].push(f4[1]), Array.isArray(s3[u4.astr]) || (s3[u4.astr] = []), s3[u4.astr].push(a4[l3].target.length);\n              }\n              return { update: o4, maxPoints: s3 };\n            }\n            function Xhe(e3, t3) {\n              var r4 = new e3.constructor(e3.length + t3.length);\n              return r4.set(e3), r4.set(t3, e3.length), r4;\n            }\n            function Zhe(e3, t3, r4, n4) {\n              e3 = Sa.getGraphDiv(e3);\n              function i3(l3, u4, c5) {\n                var f4, h3;\n                if (Sa.isTypedArray(l3)) if (c5 < 0) {\n                  var d3 = new l3.constructor(0), v3 = Xhe(l3, u4);\n                  c5 < 0 ? (f4 = v3, h3 = d3) : (f4 = d3, h3 = v3);\n                } else if (f4 = new l3.constructor(c5), h3 = new l3.constructor(l3.length + u4.length - c5), c5 === u4.length) f4.set(u4), h3.set(l3);\n                else if (c5 < u4.length) {\n                  var _2 = u4.length - c5;\n                  f4.set(u4.subarray(_2)), h3.set(l3), h3.set(u4.subarray(0, _2), l3.length);\n                } else {\n                  var b = c5 - u4.length, p3 = l3.length - b;\n                  f4.set(l3.subarray(p3)), f4.set(u4, b), h3.set(l3.subarray(0, p3));\n                }\n                else f4 = l3.concat(u4), h3 = c5 >= 0 && c5 < f4.length ? f4.splice(0, f4.length - c5) : [];\n                return [f4, h3];\n              }\n              var a4 = Whe(e3, t3, r4, n4, i3), o4 = _l.redraw(e3), s3 = [e3, a4.update, r4, a4.maxPoints];\n              return ap.add(e3, _l.prependTraces, s3, Zhe, arguments), o4;\n            }\n            function Yhe(e3, t3, r4, n4) {\n              e3 = Sa.getGraphDiv(e3);\n              function i3(l3, u4, c5) {\n                var f4, h3;\n                if (Sa.isTypedArray(l3)) if (c5 <= 0) {\n                  var d3 = new l3.constructor(0), v3 = Xhe(u4, l3);\n                  c5 < 0 ? (f4 = v3, h3 = d3) : (f4 = d3, h3 = v3);\n                } else if (f4 = new l3.constructor(c5), h3 = new l3.constructor(l3.length + u4.length - c5), c5 === u4.length) f4.set(u4), h3.set(l3);\n                else if (c5 < u4.length) {\n                  var _2 = u4.length - c5;\n                  f4.set(u4.subarray(0, _2)), h3.set(u4.subarray(_2)), h3.set(l3, _2);\n                } else {\n                  var b = c5 - u4.length;\n                  f4.set(u4), f4.set(l3.subarray(0, b), u4.length), h3.set(l3.subarray(b));\n                }\n                else f4 = u4.concat(l3), h3 = c5 >= 0 && c5 < f4.length ? f4.splice(c5, f4.length) : [];\n                return [f4, h3];\n              }\n              var a4 = Whe(e3, t3, r4, n4, i3), o4 = _l.redraw(e3), s3 = [e3, a4.update, r4, a4.maxPoints];\n              return ap.add(e3, _l.extendTraces, s3, Yhe, arguments), o4;\n            }\n            function Khe(e3, t3, r4) {\n              e3 = Sa.getGraphDiv(e3);\n              var n4 = [], i3 = _l.deleteTraces, a4 = Khe, o4 = [e3, n4], s3 = [e3, t3], l3, u4;\n              for (Ddt(e3, t3, r4), Array.isArray(t3) || (t3 = [t3]), t3 = t3.map(function(c5) {\n                return Sa.extendFlat({}, c5);\n              }), vh.cleanData(t3), l3 = 0; l3 < t3.length; l3++) e3.data.push(t3[l3]);\n              for (l3 = 0; l3 < t3.length; l3++) n4.push(-t3.length + l3);\n              if (typeof r4 == "undefined") return u4 = _l.redraw(e3), ap.add(e3, i3, o4, a4, s3), u4;\n              Array.isArray(r4) || (r4 = [r4]);\n              try {\n                jhe(e3, n4, r4);\n              } catch (c5) {\n                throw e3.data.splice(e3.data.length - t3.length, t3.length), c5;\n              }\n              return ap.startSequence(e3), ap.add(e3, i3, o4, a4, s3), u4 = _l.moveTraces(e3, n4, r4), ap.stopSequence(e3), u4;\n            }\n            function Jhe(e3, t3) {\n              e3 = Sa.getGraphDiv(e3);\n              var r4 = [], n4 = _l.addTraces, i3 = Jhe, a4 = [e3, r4, t3], o4 = [e3, t3], s3, l3;\n              if (typeof t3 == "undefined") throw new Error("indices must be an integer or array of integers.");\n              for (Array.isArray(t3) || (t3 = [t3]), OP(e3, t3, "indices"), t3 = zP(t3, e3.data.length - 1), t3.sort(Sa.sorterDes), s3 = 0; s3 < t3.length; s3 += 1) l3 = e3.data.splice(t3[s3], 1)[0], r4.push(l3);\n              var u4 = _l.redraw(e3);\n              return ap.add(e3, n4, a4, i3, o4), u4;\n            }\n            function YN(e3, t3, r4) {\n              e3 = Sa.getGraphDiv(e3);\n              var n4 = [], i3 = [], a4 = YN, o4 = YN, s3 = [e3, r4, t3], l3 = [e3, t3, r4], u4;\n              if (jhe(e3, t3, r4), t3 = Array.isArray(t3) ? t3 : [t3], typeof r4 == "undefined") for (r4 = [], u4 = 0; u4 < t3.length; u4++) r4.push(-t3.length + u4);\n              for (r4 = Array.isArray(r4) ? r4 : [r4], t3 = zP(t3, e3.data.length - 1), r4 = zP(r4, e3.data.length - 1), u4 = 0; u4 < e3.data.length; u4++) t3.indexOf(u4) === -1 && n4.push(e3.data[u4]);\n              for (u4 = 0; u4 < t3.length; u4++) i3.push({ newIndex: r4[u4], trace: e3.data[t3[u4]] });\n              for (i3.sort(function(f4, h3) {\n                return f4.newIndex - h3.newIndex;\n              }), u4 = 0; u4 < i3.length; u4 += 1) n4.splice(i3[u4].newIndex, 0, i3[u4].trace);\n              e3.data = n4;\n              var c5 = _l.redraw(e3);\n              return ap.add(e3, a4, s3, o4, l3), c5;\n            }\n            function qP(e3, t3, r4, n4) {\n              e3 = Sa.getGraphDiv(e3), vh.clearPromiseQueue(e3);\n              var i3 = {};\n              if (typeof t3 == "string") i3[t3] = r4;\n              else if (Sa.isPlainObject(t3)) i3 = Sa.extendFlat({}, t3), n4 === void 0 && (n4 = r4);\n              else return Sa.warn("Restyle fail.", t3, r4, n4), Promise.reject();\n              Object.keys(i3).length && (e3.changed = true);\n              var a4 = vh.coerceTraceIndices(e3, n4), o4 = $he(e3, i3, a4), s3 = o4.flags;\n              s3.calc && (e3.calcdata = void 0), s3.clearAxisTypes && vh.clearAxisTypes(e3, a4, {});\n              var l3 = [];\n              s3.fullReplot ? l3.push(_l._doPlot) : (l3.push(Qo.previousPromises), Qo.supplyDefaults(e3), s3.markerSize && (Qo.doCalcdata(e3), GP(l3)), s3.style && l3.push(Au.doTraceStyle), s3.colorbars && l3.push(Au.doColorBars), l3.push(jM)), l3.push(Qo.rehover, Qo.redrag, Qo.reselect), ap.add(e3, qP, [e3, o4.undoit, o4.traces], qP, [e3, o4.redoit, o4.traces]);\n              var u4 = Sa.syncOrAsync(l3, e3);\n              return (!u4 || !u4.then) && (u4 = Promise.resolve()), u4.then(function() {\n                return e3.emit("plotly_restyle", o4.eventData), e3;\n              });\n            }\n            function Ly(e3) {\n              return e3 === void 0 ? null : e3;\n            }\n            function DP(e3, t3) {\n              return t3 ? function(r4, n4, i3) {\n                var a4 = Ec(r4, n4), o4 = a4.set;\n                return a4.set = function(s3) {\n                  var l3 = (i3 || "") + n4;\n                  BP(l3, a4.get(), s3, e3), o4(s3);\n                }, a4;\n              } : Ec;\n            }\n            function BP(e3, t3, r4, n4) {\n              if (Array.isArray(t3) || Array.isArray(r4)) for (var i3 = Array.isArray(t3) ? t3 : [], a4 = Array.isArray(r4) ? r4 : [], o4 = Math.max(i3.length, a4.length), s3 = 0; s3 < o4; s3++) BP(e3 + "[" + s3 + "]", i3[s3], a4[s3], n4);\n              else if (Sa.isPlainObject(t3) || Sa.isPlainObject(r4)) {\n                var l3 = Sa.isPlainObject(t3) ? t3 : {}, u4 = Sa.isPlainObject(r4) ? r4 : {}, c5 = Sa.extendFlat({}, l3, u4);\n                for (var f4 in c5) BP(e3 + "." + f4, l3[f4], u4[f4], n4);\n              } else n4[e3] === void 0 && (n4[e3] = Ly(t3));\n            }\n            function Odt(e3, t3, r4) {\n              for (var n4 in r4) {\n                var i3 = Ec(e3, n4);\n                BP(n4, i3.get(), r4[n4], t3);\n              }\n            }\n            function $he(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = e3._fullData, a4 = e3.data, o4 = n4._guiEditing, s3 = DP(n4._preGUI, o4), l3 = Sa.extendDeepAll({}, t3), u4, c5 = v_.traceFlags(), f4 = {}, h3 = {}, d3;\n              function v3() {\n                return r4.map(function() {\n                });\n              }\n              function _2(ge) {\n                var Re = Vv.id2name(ge);\n                d3.indexOf(Re) === -1 && d3.push(Re);\n              }\n              function b(ge) {\n                return "LAYOUT" + ge + ".autorange";\n              }\n              function p3(ge) {\n                return "LAYOUT" + ge + ".range";\n              }\n              function k4(ge) {\n                for (var Re = ge; Re < i3.length; Re++) if (i3[Re]._input === a4[ge]) return i3[Re];\n              }\n              function E3(ge, Re, ce) {\n                if (Array.isArray(ge)) {\n                  ge.forEach(function(Zt) {\n                    E3(Zt, Re, ce);\n                  });\n                  return;\n                }\n                if (!(ge in t3 || vh.hasParent(t3, ge))) {\n                  var Ze;\n                  if (ge.slice(0, 6) === "LAYOUT") Ze = s3(e3.layout, ge.replace("LAYOUT", ""));\n                  else {\n                    var ut = r4[ce], pt = n4._tracePreGUI[k4(ut)._fullInput.uid];\n                    Ze = DP(pt, o4)(a4[ut], ge);\n                  }\n                  ge in h3 || (h3[ge] = v3()), h3[ge][ce] === void 0 && (h3[ge][ce] = Ly(Ze.get())), Re !== void 0 && Ze.set(Re);\n                }\n              }\n              function S2(ge) {\n                return function(Re) {\n                  return i3[Re][ge];\n                };\n              }\n              function L3(ge) {\n                return function(Re, ce) {\n                  return Re === false ? i3[r4[ce]][ge] : null;\n                };\n              }\n              for (var x2 in t3) {\n                if (vh.hasParent(t3, x2)) throw new Error("cannot set " + x2 + " and a parent attribute simultaneously");\n                var C3 = t3[x2], M4, g3, P3, T3, z3, O3;\n                if ((x2 === "autobinx" || x2 === "autobiny") && (x2 = x2.charAt(x2.length - 1) + "bins", Array.isArray(C3) ? C3 = C3.map(L3(x2)) : C3 === false ? C3 = r4.map(S2(x2)) : C3 = null), f4[x2] = C3, x2.slice(0, 6) === "LAYOUT") {\n                  P3 = s3(e3.layout, x2.replace("LAYOUT", "")), h3[x2] = [Ly(P3.get())], P3.set(Array.isArray(C3) ? C3[0] : C3), c5.calc = true;\n                  continue;\n                }\n                for (h3[x2] = v3(), u4 = 0; u4 < r4.length; u4++) {\n                  M4 = a4[r4[u4]], g3 = k4(r4[u4]);\n                  var V2 = n4._tracePreGUI[g3._fullInput.uid];\n                  if (P3 = DP(V2, o4)(M4, x2), T3 = P3.get(), z3 = Array.isArray(C3) ? C3[u4 % C3.length] : C3, z3 !== void 0) {\n                    var G2 = P3.parts[P3.parts.length - 1], Z = x2.slice(0, x2.length - G2.length - 1), j3 = Z ? Z + "." : "", N2 = Z ? Ec(g3, Z).get() : g3;\n                    if (O3 = VP.getTraceValObject(g3, P3.parts), O3 && O3.impliedEdits && z3 !== null) for (var H in O3.impliedEdits) E3(Sa.relativeAttr(x2, H), O3.impliedEdits[H], u4);\n                    else if ((G2 === "thicknessmode" || G2 === "lenmode") && T3 !== z3 && (z3 === "fraction" || z3 === "pixels") && N2) {\n                      var te = n4._size, oe = N2.orient, _e = oe === "top" || oe === "bottom";\n                      if (G2 === "thicknessmode") {\n                        var Ee = _e ? te.h : te.w;\n                        E3(j3 + "thickness", N2.thickness * (z3 === "fraction" ? 1 / Ee : Ee), u4);\n                      } else {\n                        var Ce = _e ? te.w : te.h;\n                        E3(j3 + "len", N2.len * (z3 === "fraction" ? 1 / Ce : Ce), u4);\n                      }\n                    } else if (x2 === "type" && (z3 === "pie" != (T3 === "pie") || z3 === "funnelarea" != (T3 === "funnelarea"))) {\n                      var me = "x", ie = "y";\n                      (z3 === "bar" || T3 === "bar") && M4.orientation === "h" && (me = "y", ie = "x"), Sa.swapAttrs(M4, ["?", "?src"], "labels", me), Sa.swapAttrs(M4, ["d?", "?0"], "label", me), Sa.swapAttrs(M4, ["?", "?src"], "values", ie), T3 === "pie" || T3 === "funnelarea" ? (Ec(M4, "marker.color").set(Ec(M4, "marker.colors").get()), n4._pielayer.selectAll("g.trace").remove()) : L0.traceIs(M4, "cartesian") && Ec(M4, "marker.colors").set(Ec(M4, "marker.color").get());\n                    }\n                    h3[x2][u4] = Ly(T3);\n                    var Se = ["swapxy", "swapxyaxes", "orientation", "orientationaxes"];\n                    if (Se.indexOf(x2) !== -1) {\n                      if (x2 === "orientation") {\n                        P3.set(z3);\n                        var Le = M4.x && !M4.y ? "h" : "v";\n                        if ((P3.get() || Le) === g3.orientation) continue;\n                      } else x2 === "orientationaxes" && (M4.orientation = { v: "h", h: "v" }[g3.orientation]);\n                      vh.swapXYData(M4), c5.calc = c5.clearAxisTypes = true;\n                    } else Qo.dataArrayContainers.indexOf(P3.parts[0]) !== -1 ? (vh.manageArrayContainers(P3, z3, h3), c5.calc = true) : (O3 ? O3.arrayOk && !L0.traceIs(g3, "regl") && (Sa.isArrayOrTypedArray(z3) || Sa.isArrayOrTypedArray(T3)) ? c5.calc = true : v_.update(c5, O3) : c5.calc = true, P3.set(z3));\n                  }\n                }\n                if (["swapxyaxes", "orientationaxes"].indexOf(x2) !== -1 && Vv.swap(e3, r4), x2 === "orientationaxes") {\n                  var Ae = Ec(e3.layout, "hovermode"), Fe = Ae.get();\n                  Fe === "x" ? Ae.set("y") : Fe === "y" ? Ae.set("x") : Fe === "x unified" ? Ae.set("y unified") : Fe === "y unified" && Ae.set("x unified");\n                }\n                if (["orientation", "type"].indexOf(x2) !== -1) {\n                  for (d3 = [], u4 = 0; u4 < r4.length; u4++) {\n                    var Pe = a4[r4[u4]];\n                    L0.traceIs(Pe, "cartesian") && (_2(Pe.xaxis || "x"), _2(Pe.yaxis || "y"));\n                  }\n                  E3(d3.map(b), true, 0), E3(d3.map(p3), [0, 1], 0);\n                }\n              }\n              return (c5.calc || c5.plot) && (c5.fullReplot = true), { flags: c5, undoit: h3, redoit: f4, traces: r4, eventData: Sa.extendDeepNoArrays([], [l3, r4]) };\n            }\n            function HM(e3, t3, r4) {\n              e3 = Sa.getGraphDiv(e3), vh.clearPromiseQueue(e3);\n              var n4 = {};\n              if (typeof t3 == "string") n4[t3] = r4;\n              else if (Sa.isPlainObject(t3)) n4 = Sa.extendFlat({}, t3);\n              else return Sa.warn("Relayout fail.", t3, r4), Promise.reject();\n              Object.keys(n4).length && (e3.changed = true);\n              var i3 = rde(e3, n4), a4 = i3.flags;\n              a4.calc && (e3.calcdata = void 0);\n              var o4 = [Qo.previousPromises];\n              a4.layoutReplot ? o4.push(Au.layoutReplot) : Object.keys(n4).length && (Qhe(e3, a4, i3) || Qo.supplyDefaults(e3), a4.legend && o4.push(Au.doLegend), a4.layoutstyle && o4.push(Au.layoutStyles), a4.axrange && GP(o4, i3.rangesAltered), a4.ticks && o4.push(Au.doTicksRelayout), a4.modebar && o4.push(Au.doModeBar), a4.camera && o4.push(Au.doCamera), a4.colorbars && o4.push(Au.doColorBars), o4.push(jM)), o4.push(Qo.rehover, Qo.redrag, Qo.reselect), ap.add(e3, HM, [e3, i3.undoit], HM, [e3, i3.redoit]);\n              var s3 = Sa.syncOrAsync(o4, e3);\n              return (!s3 || !s3.then) && (s3 = Promise.resolve(e3)), s3.then(function() {\n                return e3.emit("plotly_relayout", i3.eventData), e3;\n              });\n            }\n            function Qhe(e3, t3, r4) {\n              var n4 = e3._fullLayout;\n              if (!t3.axrange) return false;\n              for (var i3 in t3) if (i3 !== "axrange" && t3[i3]) return false;\n              var a4, o4, s3 = function(d3, v3) {\n                return Sa.coerce(a4, o4, Tdt, d3, v3);\n              }, l3 = {};\n              for (var u4 in r4.rangesAltered) {\n                var c5 = Vv.id2name(u4);\n                if (a4 = e3.layout[c5], o4 = n4[c5], wdt(a4, o4, s3, l3), o4._matchGroup) {\n                  for (var f4 in o4._matchGroup) if (f4 !== u4) {\n                    var h3 = n4[Vv.id2name(f4)];\n                    h3.autorange = o4.autorange, h3.range = o4.range.slice(), h3._input.range = o4.range.slice();\n                  }\n                }\n              }\n              return true;\n            }\n            function GP(e3, t3) {\n              var r4 = t3 ? function(n4) {\n                var i3 = [], a4 = true;\n                for (var o4 in t3) {\n                  var s3 = Vv.getFromId(n4, o4);\n                  if (i3.push(o4), (s3.ticklabelposition || "").indexOf("inside") !== -1 && s3._anchorAxis && i3.push(s3._anchorAxis._id), s3._matchGroup) for (var l3 in s3._matchGroup) t3[l3] || i3.push(l3);\n                }\n                return Vv.draw(n4, i3, { skipTitle: a4 });\n              } : function(n4) {\n                return Vv.draw(n4, "redraw");\n              };\n              e3.push(Edt, Au.doAutoRangeAndConstraints, r4, Au.drawData, Au.finalDraw);\n            }\n            var ede = /^[xyz]axis[0-9]*\\.range(\\[[0|1]\\])?$/, tde = /^[xyz]axis[0-9]*\\.autorange$/, qdt = /^[xyz]axis[0-9]*\\.domain(\\[[0|1]\\])?$/;\n            function rde(e3, t3) {\n              var r4 = e3.layout, n4 = e3._fullLayout, i3 = n4._guiEditing, a4 = DP(n4._preGUI, i3), o4 = Object.keys(t3), s3 = Vv.list(e3), l3 = Sa.extendDeepAll({}, t3), u4 = {}, c5, f4, h3;\n              for (o4 = Object.keys(t3), f4 = 0; f4 < o4.length; f4++) if (o4[f4].indexOf("allaxes") === 0) {\n                for (h3 = 0; h3 < s3.length; h3++) {\n                  var d3 = s3[h3]._id.slice(1), v3 = d3.indexOf("scene") !== -1 ? d3 + "." : "", _2 = o4[f4].replace("allaxes", v3 + s3[h3]._name);\n                  t3[_2] || (t3[_2] = t3[o4[f4]]);\n                }\n                delete t3[o4[f4]];\n              }\n              var b = v_.layoutFlags(), p3 = {}, k4 = {};\n              function E3(pt, Zt) {\n                if (Array.isArray(pt)) {\n                  pt.forEach(function(lt) {\n                    E3(lt, Zt);\n                  });\n                  return;\n                }\n                if (!(pt in t3 || vh.hasParent(t3, pt))) {\n                  var st = a4(r4, pt);\n                  pt in k4 || (k4[pt] = Ly(st.get())), Zt !== void 0 && st.set(Zt);\n                }\n              }\n              var S2 = {}, L3;\n              function x2(pt) {\n                var Zt = Vv.name2id(pt.split(".")[0]);\n                return S2[Zt] = 1, Zt;\n              }\n              for (var C3 in t3) {\n                if (vh.hasParent(t3, C3)) throw new Error("cannot set " + C3 + " and a parent attribute simultaneously");\n                for (var M4 = a4(r4, C3), g3 = t3[C3], P3 = M4.parts.length, T3 = P3 - 1; T3 > 0 && typeof M4.parts[T3] != "string"; ) T3--;\n                var z3 = M4.parts[T3], O3 = M4.parts[T3 - 1] + "." + z3, V2 = M4.parts.slice(0, T3).join("."), G2 = Ec(e3.layout, V2).get(), Z = Ec(n4, V2).get(), j3 = M4.get();\n                if (g3 !== void 0) {\n                  p3[C3] = g3, k4[C3] = z3 === "reverse" ? g3 : Ly(j3);\n                  var N2 = VP.getLayoutValObject(n4, M4.parts);\n                  if (N2 && N2.impliedEdits && g3 !== null) for (var H in N2.impliedEdits) E3(Sa.relativeAttr(C3, H), N2.impliedEdits[H]);\n                  if (["width", "height"].indexOf(C3) !== -1) if (g3) {\n                    E3("autosize", null);\n                    var te = C3 === "height" ? "width" : "height";\n                    E3(te, n4[te]);\n                  } else n4[C3] = e3._initialAutoSize[C3];\n                  else if (C3 === "autosize") E3("width", g3 ? null : n4.width), E3("height", g3 ? null : n4.height);\n                  else if (O3.match(ede)) x2(O3), Ec(n4, V2 + "._inputRange").set(null);\n                  else if (O3.match(tde)) {\n                    x2(O3), Ec(n4, V2 + "._inputRange").set(null);\n                    var oe = Ec(n4, V2).get();\n                    oe._inputDomain && (oe._input.domain = oe._inputDomain.slice());\n                  } else O3.match(qdt) && Ec(n4, V2 + "._inputDomain").set(null);\n                  if (z3 === "type") {\n                    L3 = G2;\n                    var _e = Z.type === "linear" && g3 === "log", Ee = Z.type === "log" && g3 === "linear";\n                    if (_e || Ee) {\n                      if (!L3 || !L3.range) E3(V2 + ".autorange", true);\n                      else if (Z.autorange) _e && (L3.range = L3.range[1] > L3.range[0] ? [1, 2] : [2, 1]);\n                      else {\n                        var Ce = L3.range[0], me = L3.range[1];\n                        _e ? (Ce <= 0 && me <= 0 && E3(V2 + ".autorange", true), Ce <= 0 ? Ce = me / 1e6 : me <= 0 && (me = Ce / 1e6), E3(V2 + ".range[0]", Math.log(Ce) / Math.LN10), E3(V2 + ".range[1]", Math.log(me) / Math.LN10)) : (E3(V2 + ".range[0]", Math.pow(10, Ce)), E3(V2 + ".range[1]", Math.pow(10, me)));\n                      }\n                      Array.isArray(n4._subplots.polar) && n4._subplots.polar.length && n4[M4.parts[0]] && M4.parts[1] === "radialaxis" && delete n4[M4.parts[0]]._subplot.viewInitial["radialaxis.range"], L0.getComponentMethod("annotations", "convertCoords")(e3, Z, g3, E3), L0.getComponentMethod("images", "convertCoords")(e3, Z, g3, E3);\n                    } else E3(V2 + ".autorange", true), E3(V2 + ".range", null);\n                    Ec(n4, V2 + "._inputRange").set(null);\n                  } else if (z3.match(kdt)) {\n                    var ie = Ec(n4, C3).get(), Se = (g3 || {}).type;\n                    (!Se || Se === "-") && (Se = "linear"), L0.getComponentMethod("annotations", "convertCoords")(e3, ie, Se, E3), L0.getComponentMethod("images", "convertCoords")(e3, ie, Se, E3);\n                  }\n                  var Le = RP.containerArrayMatch(C3);\n                  if (Le) {\n                    c5 = Le.array, f4 = Le.index;\n                    var Ae = Le.property, Fe = N2 || { editType: "calc" };\n                    f4 !== "" && Ae === "" && (RP.isAddVal(g3) ? k4[C3] = null : RP.isRemoveVal(g3) ? k4[C3] = (Ec(r4, c5).get() || [])[f4] : Sa.warn("unrecognized full object value", t3)), v_.update(b, Fe), u4[c5] || (u4[c5] = {});\n                    var Pe = u4[c5][f4];\n                    Pe || (Pe = u4[c5][f4] = {}), Pe[Ae] = g3, delete t3[C3];\n                  } else z3 === "reverse" ? (G2.range ? G2.range.reverse() : (E3(V2 + ".autorange", true), G2.range = [1, 0]), Z.autorange ? b.calc = true : b.plot = true) : (C3 === "dragmode" && (g3 === false && j3 !== false || g3 !== false && j3 === false) || n4._has("scatter-like") && n4._has("regl") && C3 === "dragmode" && (g3 === "lasso" || g3 === "select") && !(j3 === "lasso" || j3 === "select") ? b.plot = true : N2 ? v_.update(b, N2) : b.calc = true, M4.set(g3));\n                }\n              }\n              for (c5 in u4) {\n                var ge = RP.applyContainerArrayChanges(e3, a4(r4, c5), u4[c5], b, a4);\n                ge || (b.plot = true);\n              }\n              for (var Re in S2) {\n                L3 = Vv.getFromId(e3, Re);\n                var ce = L3 && L3._constraintGroup;\n                if (ce) {\n                  b.calc = true;\n                  for (var Ze in ce) S2[Ze] || (Vv.getFromId(e3, Ze)._constraintShrinkable = true);\n                }\n              }\n              (ide(e3) || t3.height || t3.width) && (b.plot = true);\n              var ut = n4.shapes;\n              for (f4 = 0; f4 < ut.length; f4++) if (ut[f4].showlegend) {\n                b.calc = true;\n                break;\n              }\n              return (b.plot || b.calc) && (b.layoutReplot = true), { flags: b, rangesAltered: S2, undoit: k4, redoit: p3, eventData: l3 };\n            }\n            function ide(e3) {\n              var t3 = e3._fullLayout, r4 = t3.width, n4 = t3.height;\n              return e3.layout.autosize && Qo.plotAutoSize(e3, e3.layout, t3), t3.width !== r4 || t3.height !== n4;\n            }\n            function NP(e3, t3, r4, n4) {\n              e3 = Sa.getGraphDiv(e3), vh.clearPromiseQueue(e3), Sa.isPlainObject(t3) || (t3 = {}), Sa.isPlainObject(r4) || (r4 = {}), Object.keys(t3).length && (e3.changed = true), Object.keys(r4).length && (e3.changed = true);\n              var i3 = vh.coerceTraceIndices(e3, n4), a4 = $he(e3, Sa.extendFlat({}, t3), i3), o4 = a4.flags, s3 = rde(e3, Sa.extendFlat({}, r4)), l3 = s3.flags;\n              (o4.calc || l3.calc) && (e3.calcdata = void 0), o4.clearAxisTypes && vh.clearAxisTypes(e3, i3, r4);\n              var u4 = [];\n              l3.layoutReplot ? u4.push(Au.layoutReplot) : o4.fullReplot ? u4.push(_l._doPlot) : (u4.push(Qo.previousPromises), Qhe(e3, l3, s3) || Qo.supplyDefaults(e3), o4.style && u4.push(Au.doTraceStyle), (o4.colorbars || l3.colorbars) && u4.push(Au.doColorBars), l3.legend && u4.push(Au.doLegend), l3.layoutstyle && u4.push(Au.layoutStyles), l3.axrange && GP(u4, s3.rangesAltered), l3.ticks && u4.push(Au.doTicksRelayout), l3.modebar && u4.push(Au.doModeBar), l3.camera && u4.push(Au.doCamera), u4.push(jM)), u4.push(Qo.rehover, Qo.redrag, Qo.reselect), ap.add(e3, NP, [e3, a4.undoit, s3.undoit, a4.traces], NP, [e3, a4.redoit, s3.redoit, a4.traces]);\n              var c5 = Sa.syncOrAsync(u4, e3);\n              return (!c5 || !c5.then) && (c5 = Promise.resolve(e3)), c5.then(function() {\n                return e3.emit("plotly_update", { data: a4.eventData, layout: s3.eventData }), e3;\n              });\n            }\n            function KN(e3) {\n              return function(r4) {\n                r4._fullLayout._guiEditing = true;\n                var n4 = e3.apply(null, arguments);\n                return r4._fullLayout._guiEditing = false, n4;\n              };\n            }\n            var Bdt = [{ pattern: /^hiddenlabels/, attr: "legend.uirevision" }, { pattern: /^((x|y)axis\\d*)\\.((auto)?range|title\\.text)/ }, { pattern: /axis\\d*\\.showspikes$/, attr: "modebar.uirevision" }, { pattern: /(hover|drag)mode$/, attr: "modebar.uirevision" }, { pattern: /^(scene\\d*)\\.camera/ }, { pattern: /^(geo\\d*)\\.(projection|center|fitbounds)/ }, { pattern: /^(ternary\\d*\\.[abc]axis)\\.(min|title\\.text)$/ }, { pattern: /^(polar\\d*\\.radialaxis)\\.((auto)?range|angle|title\\.text)/ }, { pattern: /^(polar\\d*\\.angularaxis)\\.rotation/ }, { pattern: /^(mapbox\\d*)\\.(center|zoom|bearing|pitch)/ }, { pattern: /^(map\\d*)\\.(center|zoom|bearing|pitch)/ }, { pattern: /^legend\\.(x|y)$/, attr: "editrevision" }, { pattern: /^(shapes|annotations)/, attr: "editrevision" }, { pattern: /^title\\.text$/, attr: "editrevision" }], Ndt = [{ pattern: /^selectedpoints$/, attr: "selectionrevision" }, { pattern: /(^|value\\.)visible$/, attr: "legend.uirevision" }, { pattern: /^dimensions\\[\\d+\\]\\.constraintrange/ }, { pattern: /^node\\.(x|y|groups)/ }, { pattern: /^level$/ }, { pattern: /(^|value\\.)name$/ }, { pattern: /colorbar\\.title\\.text$/ }, { pattern: /colorbar\\.(x|y)$/, attr: "editrevision" }];\n            function Bhe(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4], i3 = e3.match(n4.pattern);\n                if (i3) {\n                  var a4 = i3[1] || "";\n                  return { head: a4, tail: e3.slice(a4.length + 1), attr: n4.attr };\n                }\n              }\n            }\n            function Nhe(e3, t3) {\n              var r4 = Ec(t3, e3).get();\n              if (r4 !== void 0) return r4;\n              var n4 = e3.split(".");\n              for (n4.pop(); n4.length > 1; ) if (n4.pop(), r4 = Ec(t3, n4.join(".") + ".uirevision").get(), r4 !== void 0) return r4;\n              return t3.uirevision;\n            }\n            function Udt(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) if (t3[r4]._fullInput.uid === e3) return r4;\n              return -1;\n            }\n            function Vdt(e3, t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4++) if (t3[n4].uid === e3) return n4;\n              return !t3[r4] || t3[r4].uid ? -1 : r4;\n            }\n            function Uhe(e3, t3) {\n              var r4 = Sa.isPlainObject(e3), n4 = Array.isArray(e3);\n              return r4 || n4 ? (r4 && Sa.isPlainObject(t3) || n4 && Array.isArray(t3)) && JSON.stringify(e3) === JSON.stringify(t3) : e3 === t3;\n            }\n            function Gdt(e3, t3, r4, n4) {\n              var i3 = n4._preGUI, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3, _2 = [], b = {}, p3 = {};\n              for (a4 in i3) {\n                if (u4 = Bhe(a4, Bdt), u4) {\n                  if (d3 = u4.head, v3 = u4.tail, o4 = u4.attr || d3 + ".uirevision", s3 = Ec(n4, o4).get(), l3 = s3 && Nhe(o4, t3), l3 && l3 === s3) {\n                    if (c5 = i3[a4], c5 === null && (c5 = void 0), f4 = Ec(t3, a4), h3 = f4.get(), Uhe(h3, c5)) {\n                      h3 === void 0 && v3 === "autorange" && _2.push(d3), f4.set(Ly(Ec(n4, a4).get()));\n                      continue;\n                    } else if (v3 === "autorange" || v3.slice(0, 6) === "range[") {\n                      var k4 = i3[d3 + ".range[0]"], E3 = i3[d3 + ".range[1]"], S2 = i3[d3 + ".autorange"];\n                      if (S2 || S2 === null && k4 === null && E3 === null) {\n                        if (!(d3 in b)) {\n                          var L3 = Ec(t3, d3).get();\n                          b[d3] = L3 && (L3.autorange || L3.autorange !== false && (!L3.range || L3.range.length !== 2));\n                        }\n                        if (b[d3]) {\n                          f4.set(Ly(Ec(n4, a4).get()));\n                          continue;\n                        }\n                      }\n                    }\n                  }\n                } else Sa.warn("unrecognized GUI edit: " + a4);\n                delete i3[a4], u4 && u4.tail.slice(0, 6) === "range[" && (p3[u4.head] = 1);\n              }\n              for (var x2 = 0; x2 < _2.length; x2++) {\n                var C3 = _2[x2];\n                if (p3[C3]) {\n                  var M4 = Ec(t3, C3).get();\n                  M4 && delete M4.autorange;\n                }\n              }\n              var g3 = n4._tracePreGUI;\n              for (var P3 in g3) {\n                var T3 = g3[P3], z3 = null, O3;\n                for (a4 in T3) {\n                  if (!z3) {\n                    var V2 = Udt(P3, r4);\n                    if (V2 < 0) {\n                      delete g3[P3];\n                      break;\n                    }\n                    var G2 = r4[V2];\n                    O3 = G2._fullInput;\n                    var Z = Vdt(P3, e3, O3.index);\n                    if (Z < 0) {\n                      delete g3[P3];\n                      break;\n                    }\n                    z3 = e3[Z];\n                  }\n                  if (u4 = Bhe(a4, Ndt), u4) {\n                    if (u4.attr ? (s3 = Ec(n4, u4.attr).get(), l3 = s3 && Nhe(u4.attr, t3)) : (s3 = O3.uirevision, l3 = z3.uirevision, l3 === void 0 && (l3 = t3.uirevision)), l3 && l3 === s3 && (c5 = T3[a4], c5 === null && (c5 = void 0), f4 = Ec(z3, a4), h3 = f4.get(), Uhe(h3, c5))) {\n                      f4.set(Ly(Ec(O3, a4).get()));\n                      continue;\n                    }\n                  } else Sa.warn("unrecognized GUI edit: " + a4 + " in trace uid " + P3);\n                  delete T3[a4];\n                }\n              }\n            }\n            function Hdt(e3, t3, r4, n4) {\n              var i3, a4;\n              function o4() {\n                return _l.addFrames(e3, i3);\n              }\n              e3 = Sa.getGraphDiv(e3), vh.clearPromiseQueue(e3);\n              var s3 = e3._fullData, l3 = e3._fullLayout;\n              if (!Sa.isPlotDiv(e3) || !s3 || !l3) a4 = _l.newPlot(e3, t3, r4, n4);\n              else {\n                if (Sa.isPlainObject(t3)) {\n                  var u4 = t3;\n                  t3 = u4.data, r4 = u4.layout, n4 = u4.config, i3 = u4.frames;\n                }\n                var c5 = false;\n                if (n4) {\n                  let O3 = Sa.extendDeepAll({}, e3._context);\n                  e3._context = void 0, Hhe(e3, n4), c5 = !vh.collectionsAreEqual(O3, e3._context);\n                }\n                if (c5) {\n                  let O3 = e3._ev.eventNames().map((V2) => [V2, e3._ev.listeners(V2)]);\n                  a4 = _l.newPlot(e3, t3, r4, n4).then(() => {\n                    for (let [V2, G2] of O3) G2.forEach((Z) => e3.on(V2, Z));\n                    return _l.react(e3, t3, r4, n4);\n                  });\n                } else {\n                  e3.data = t3 || [], vh.cleanData(e3.data), e3.layout = r4 || {}, vh.cleanLayout(e3.layout), Gdt(e3.data, e3.layout, s3, l3), Qo.supplyDefaults(e3, { skipUpdateCalc: true });\n                  var f4 = e3._fullData, h3 = e3._fullLayout, d3 = h3.datarevision === void 0, v3 = h3.transition, _2 = Wdt(e3, l3, h3, d3, v3), b = _2.newDataRevision, p3 = jdt(e3, s3, f4, d3, v3, b);\n                  if (ide(e3) && (_2.layoutReplot = true), p3.calc || _2.calc) {\n                    e3.calcdata = void 0;\n                    for (var k4 = Object.getOwnPropertyNames(h3), E3 = 0; E3 < k4.length; E3++) {\n                      var S2 = k4[E3], L3 = S2.substring(0, 5);\n                      if (L3 === "xaxis" || L3 === "yaxis") {\n                        var x2 = h3[S2]._emptyCategories;\n                        x2 && x2();\n                      }\n                    }\n                  } else Qo.supplyDefaultsUpdateCalc(e3.calcdata, f4);\n                  var C3 = [];\n                  if (i3 && (e3._transitionData = {}, Qo.createTransitionData(e3), C3.push(o4)), h3.transition && (p3.anim || _2.anim)) _2.ticks && C3.push(Au.doTicksRelayout), Qo.doCalcdata(e3), Au.doAutoRangeAndConstraints(e3), C3.push(function() {\n                    return Qo.transitionFromReact(e3, p3, _2, l3);\n                  });\n                  else if (p3.fullReplot || _2.layoutReplot) e3._fullLayout._skipDefaults = true, C3.push(_l._doPlot);\n                  else {\n                    for (var M4 in _2.arrays) {\n                      var g3 = _2.arrays[M4];\n                      if (g3.length) {\n                        var P3 = L0.getComponentMethod(M4, "drawOne");\n                        if (P3 !== Sa.noop) for (var T3 = 0; T3 < g3.length; T3++) P3(e3, g3[T3]);\n                        else {\n                          var z3 = L0.getComponentMethod(M4, "draw");\n                          if (z3 === Sa.noop) throw new Error("cannot draw components: " + M4);\n                          z3(e3);\n                        }\n                      }\n                    }\n                    C3.push(Qo.previousPromises), p3.style && C3.push(Au.doTraceStyle), (p3.colorbars || _2.colorbars) && C3.push(Au.doColorBars), _2.legend && C3.push(Au.doLegend), _2.layoutstyle && C3.push(Au.layoutStyles), _2.axrange && GP(C3), _2.ticks && C3.push(Au.doTicksRelayout), _2.modebar && C3.push(Au.doModeBar), _2.camera && C3.push(Au.doCamera), C3.push(jM);\n                  }\n                  C3.push(Qo.rehover, Qo.redrag, Qo.reselect), a4 = Sa.syncOrAsync(C3, e3), (!a4 || !a4.then) && (a4 = Promise.resolve(e3));\n                }\n              }\n              return a4.then(() => (c5 || e3.emit("plotly_react", { config: n4, data: t3, layout: r4 }), e3));\n            }\n            function jdt(e3, t3, r4, n4, i3, a4) {\n              var o4 = t3.length === r4.length;\n              if (!i3 && !o4) return { fullReplot: true, calc: true };\n              var s3 = v_.traceFlags();\n              s3.arrays = {}, s3.nChanges = 0, s3.nChangesAnim = 0;\n              var l3, u4;\n              function c5(d3) {\n                var v3 = VP.getTraceValObject(u4, d3);\n                return !u4._module.animatable && v3.anim && (v3.anim = false), v3;\n              }\n              var f4 = { getValObject: c5, flags: s3, immutable: n4, transition: i3, newDataRevision: a4, gd: e3 }, h3 = {};\n              for (l3 = 0; l3 < t3.length; l3++) if (r4[l3]) {\n                if (u4 = r4[l3]._fullInput, h3[u4.uid]) continue;\n                h3[u4.uid] = 1, UP(t3[l3]._fullInput, u4, [], f4);\n              }\n              return (s3.calc || s3.plot) && (s3.fullReplot = true), i3 && s3.nChanges && s3.nChangesAnim && (s3.anim = s3.nChanges === s3.nChangesAnim && o4 ? "all" : "some"), s3;\n            }\n            function Wdt(e3, t3, r4, n4, i3) {\n              var a4 = v_.layoutFlags();\n              a4.arrays = {}, a4.rangesAltered = {}, a4.nChanges = 0, a4.nChangesAnim = 0;\n              function o4(h3) {\n                return VP.getLayoutValObject(r4, h3);\n              }\n              for (var s3 in r4) if (!(!s3.startsWith("xaxis") && !s3.startsWith("yaxis")) && t3[s3]) {\n                var l3 = r4[s3].domain, u4 = t3[s3].domain, c5 = t3[s3]._inputDomain;\n                t3[s3]._inputDomain && (l3[0] === c5[0] && l3[1] === c5[1] ? r4[s3].domain = t3[s3].domain : (l3[0] !== u4[0] || l3[1] !== u4[1]) && (r4[s3]._inputDomain = null));\n              }\n              var f4 = { getValObject: o4, flags: a4, immutable: n4, transition: i3, gd: e3 };\n              return UP(t3, r4, [], f4), (a4.plot || a4.calc) && (a4.layoutReplot = true), i3 && a4.nChanges && a4.nChangesAnim && (a4.anim = a4.nChanges === a4.nChangesAnim ? "all" : "some"), a4;\n            }\n            function UP(e3, t3, r4, n4) {\n              var i3, a4, o4, s3 = n4.getValObject, l3 = n4.flags, u4 = n4.immutable, c5 = n4.inArray, f4 = n4.arrayIndex;\n              function h3() {\n                var V2 = i3.editType;\n                if (c5 && V2.indexOf("arraydraw") !== -1) {\n                  Sa.pushUnique(l3.arrays[c5], f4);\n                  return;\n                }\n                v_.update(l3, i3), V2 !== "none" && l3.nChanges++, n4.transition && i3.anim && l3.nChangesAnim++, (ede.test(o4) || tde.test(o4)) && (l3.rangesAltered[r4[0]] = 1), a4 === "datarevision" && (l3.newDataRevision = 1);\n              }\n              function d3(V2) {\n                return V2.valType === "data_array" || V2.arrayOk;\n              }\n              for (a4 in e3) {\n                if (l3.calc && !n4.transition) return;\n                var v3 = e3[a4], _2 = t3[a4], b = r4.concat(a4);\n                if (o4 = b.join("."), !(a4.charAt(0) === "_" || typeof v3 == "function" || v3 === _2)) {\n                  if ((a4 === "tick0" || a4 === "dtick") && r4[0] !== "geo") {\n                    var p3 = t3.tickmode;\n                    if (p3 === "auto" || p3 === "array" || !p3) continue;\n                  }\n                  if (!(a4 === "range" && t3.autorange) && !((a4 === "zmin" || a4 === "zmax") && t3.type === "contourcarpet") && (i3 = s3(b), !!i3 && !(i3._compareAsJSON && JSON.stringify(v3) === JSON.stringify(_2)))) {\n                    var k4 = i3.valType, E3, S2 = d3(i3), L3 = Array.isArray(v3), x2 = Array.isArray(_2);\n                    if (L3 && x2) {\n                      var C3 = "_input_" + a4, M4 = e3[C3], g3 = t3[C3];\n                      if (Array.isArray(M4) && M4 === g3) continue;\n                    }\n                    if (_2 === void 0) S2 && L3 ? l3.calc = true : h3();\n                    else if (i3._isLinkedToArray) {\n                      var P3 = [], T3 = false;\n                      c5 || (l3.arrays[a4] = P3);\n                      var z3 = Math.min(v3.length, _2.length), O3 = Math.max(v3.length, _2.length);\n                      if (z3 !== O3) if (i3.editType === "arraydraw") T3 = true;\n                      else {\n                        h3();\n                        continue;\n                      }\n                      for (E3 = 0; E3 < z3; E3++) UP(v3[E3], _2[E3], b.concat(E3), Sa.extendFlat({ inArray: a4, arrayIndex: E3 }, n4));\n                      if (T3) for (E3 = z3; E3 < O3; E3++) P3.push(E3);\n                    } else !k4 && Sa.isPlainObject(v3) ? UP(v3, _2, b, n4) : S2 ? L3 && x2 ? (u4 && (l3.calc = true), (u4 || n4.newDataRevision) && h3()) : L3 !== x2 ? l3.calc = true : h3() : L3 && x2 ? (v3.length !== _2.length || String(v3) !== String(_2)) && h3() : h3();\n                  }\n                }\n              }\n              for (a4 in t3) if (!(a4 in e3 || a4.charAt(0) === "_" || typeof t3[a4] == "function")) if (i3 = s3(r4.concat(a4)), d3(i3) && Array.isArray(t3[a4])) {\n                l3.calc = true;\n                return;\n              } else h3();\n            }\n            function Xdt(e3, t3, r4) {\n              if (e3 = Sa.getGraphDiv(e3), !Sa.isPlotDiv(e3)) throw new Error("This element is not a Plotly plot: " + e3 + ". It\'s likely that you\'ve failed to create a plot before animating it. For more details, see https://plotly.com/javascript/animations/");\n              var n4 = e3._transitionData;\n              n4._frameQueue || (n4._frameQueue = []), r4 = Qo.supplyAnimationDefaults(r4);\n              var i3 = r4.transition, a4 = r4.frame;\n              n4._frameWaitingCnt === void 0 && (n4._frameWaitingCnt = 0);\n              function o4(u4) {\n                return Array.isArray(i3) ? u4 >= i3.length ? i3[0] : i3[u4] : i3;\n              }\n              function s3(u4) {\n                return Array.isArray(a4) ? u4 >= a4.length ? a4[0] : a4[u4] : a4;\n              }\n              function l3(u4, c5) {\n                var f4 = 0;\n                return function() {\n                  if (u4 && ++f4 === c5) return u4();\n                };\n              }\n              return new Promise(function(u4, c5) {\n                function f4() {\n                  if (n4._frameQueue.length !== 0) {\n                    for (; n4._frameQueue.length; ) {\n                      var z3 = n4._frameQueue.pop();\n                      z3.onInterrupt && z3.onInterrupt();\n                    }\n                    e3.emit("plotly_animationinterrupted", []);\n                  }\n                }\n                function h3(z3) {\n                  if (z3.length !== 0) {\n                    for (var O3 = 0; O3 < z3.length; O3++) {\n                      var V2;\n                      z3[O3].type === "byname" ? V2 = Qo.computeFrame(e3, z3[O3].name) : V2 = z3[O3].data;\n                      var G2 = s3(O3), Z = o4(O3);\n                      Z.duration = Math.min(Z.duration, G2.duration);\n                      var j3 = { frame: V2, name: z3[O3].name, frameOpts: G2, transitionOpts: Z };\n                      O3 === z3.length - 1 && (j3.onComplete = l3(u4, 2), j3.onInterrupt = c5), n4._frameQueue.push(j3);\n                    }\n                    r4.mode === "immediate" && (n4._lastFrameAt = -1 / 0), n4._animationRaf || _2();\n                  }\n                }\n                function d3() {\n                  e3.emit("plotly_animated"), window.cancelAnimationFrame(n4._animationRaf), n4._animationRaf = null;\n                }\n                function v3() {\n                  n4._currentFrame && n4._currentFrame.onComplete && n4._currentFrame.onComplete();\n                  var z3 = n4._currentFrame = n4._frameQueue.shift();\n                  if (z3) {\n                    var O3 = z3.name ? z3.name.toString() : null;\n                    e3._fullLayout._currentFrame = O3, n4._lastFrameAt = Date.now(), n4._timeToNext = z3.frameOpts.duration, Qo.transition(e3, z3.frame.data, z3.frame.layout, vh.coerceTraceIndices(e3, z3.frame.traces), z3.frameOpts, z3.transitionOpts).then(function() {\n                      z3.onComplete && z3.onComplete();\n                    }), e3.emit("plotly_animatingframe", { name: O3, frame: z3.frame, animation: { frame: z3.frameOpts, transition: z3.transitionOpts } });\n                  } else d3();\n                }\n                function _2() {\n                  e3.emit("plotly_animating"), n4._lastFrameAt = -1 / 0, n4._timeToNext = 0, n4._runningTransitions = 0, n4._currentFrame = null;\n                  var z3 = function() {\n                    n4._animationRaf = window.requestAnimationFrame(z3), Date.now() - n4._lastFrameAt > n4._timeToNext && v3();\n                  };\n                  z3();\n                }\n                var b = 0;\n                function p3(z3) {\n                  return Array.isArray(i3) ? b >= i3.length ? z3.transitionOpts = i3[b] : z3.transitionOpts = i3[0] : z3.transitionOpts = i3, b++, z3;\n                }\n                var k4, E3, S2 = [], L3 = t3 == null, x2 = Array.isArray(t3), C3 = !L3 && !x2 && Sa.isPlainObject(t3);\n                if (C3) S2.push({ type: "object", data: p3(Sa.extendFlat({}, t3)) });\n                else if (L3 || ["string", "number"].indexOf(typeof t3) !== -1) for (k4 = 0; k4 < n4._frames.length; k4++) E3 = n4._frames[k4], E3 && (L3 || String(E3.group) === String(t3)) && S2.push({ type: "byname", name: String(E3.name), data: p3({ name: E3.name }) });\n                else if (x2) for (k4 = 0; k4 < t3.length; k4++) {\n                  var M4 = t3[k4];\n                  ["number", "string"].indexOf(typeof M4) !== -1 ? (M4 = String(M4), S2.push({ type: "byname", name: M4, data: p3({ name: M4 }) })) : Sa.isPlainObject(M4) && S2.push({ type: "object", data: p3(Sa.extendFlat({}, M4)) });\n                }\n                for (k4 = 0; k4 < S2.length; k4++) if (E3 = S2[k4], E3.type === "byname" && !n4._frameHash[E3.data.name]) {\n                  Sa.warn(\'animate failure: frame not found: "\' + E3.data.name + \'"\'), c5();\n                  return;\n                }\n                ["next", "immediate"].indexOf(r4.mode) !== -1 && f4(), r4.direction === "reverse" && S2.reverse();\n                var g3 = e3._fullLayout._currentFrame;\n                if (g3 && r4.fromcurrent) {\n                  var P3 = -1;\n                  for (k4 = 0; k4 < S2.length; k4++) if (E3 = S2[k4], E3.type === "byname" && E3.name === g3) {\n                    P3 = k4;\n                    break;\n                  }\n                  if (P3 > 0 && P3 < S2.length - 1) {\n                    var T3 = [];\n                    for (k4 = 0; k4 < S2.length; k4++) E3 = S2[k4], (S2[k4].type !== "byname" || k4 > P3) && T3.push(E3);\n                    S2 = T3;\n                  }\n                }\n                S2.length > 0 ? h3(S2) : (e3.emit("plotly_animated"), u4());\n              });\n            }\n            function Zdt(e3, t3, r4) {\n              if (e3 = Sa.getGraphDiv(e3), t3 == null) return Promise.resolve();\n              if (!Sa.isPlotDiv(e3)) throw new Error("This element is not a Plotly plot: " + e3 + ". It\'s likely that you\'ve failed to create a plot before adding frames. For more details, see https://plotly.com/javascript/animations/");\n              var n4, i3, a4, o4, s3 = e3._transitionData._frames, l3 = e3._transitionData._frameHash;\n              if (!Array.isArray(t3)) throw new Error("addFrames failure: frameList must be an Array of frame definitions" + t3);\n              var u4 = s3.length + t3.length * 2, c5 = [], f4 = {};\n              for (n4 = t3.length - 1; n4 >= 0; n4--) if (Sa.isPlainObject(t3[n4])) {\n                var h3 = t3[n4].name, d3 = (l3[h3] || f4[h3] || {}).name, v3 = t3[n4].name, _2 = l3[d3] || f4[d3];\n                d3 && v3 && typeof v3 == "number" && _2 && XN < qhe && (XN++, Sa.warn(\'addFrames: overwriting frame "\' + (l3[d3] || f4[d3]).name + \'" with a frame whose name of type "number" also equates to "\' + d3 + \'". This is valid but may potentially lead to unexpected behavior since all plotly.js frame names are stored internally as strings.\'), XN === qhe && Sa.warn("addFrames: This API call has yielded too many of these warnings. For the rest of this call, further warnings about numeric frame names will be suppressed.")), f4[h3] = { name: h3 }, c5.push({ frame: Qo.supplyFrameDefaults(t3[n4]), index: r4 && r4[n4] !== void 0 && r4[n4] !== null ? r4[n4] : u4 + n4 });\n              }\n              c5.sort(function(C3, M4) {\n                return C3.index > M4.index ? -1 : C3.index < M4.index ? 1 : 0;\n              });\n              var b = [], p3 = [], k4 = s3.length;\n              for (n4 = c5.length - 1; n4 >= 0; n4--) {\n                if (i3 = c5[n4].frame, typeof i3.name == "number" && Sa.warn("Warning: addFrames accepts frames with numeric names, but the numbers areimplicitly cast to strings"), !i3.name) for (; l3[i3.name = "frame " + e3._transitionData._counter++]; ) ;\n                if (l3[i3.name]) {\n                  for (a4 = 0; a4 < s3.length && (s3[a4] || {}).name !== i3.name; a4++) ;\n                  b.push({ type: "replace", index: a4, value: i3 }), p3.unshift({ type: "replace", index: a4, value: s3[a4] });\n                } else o4 = Math.max(0, Math.min(c5[n4].index, k4)), b.push({ type: "insert", index: o4, value: i3 }), p3.unshift({ type: "delete", index: o4 }), k4++;\n              }\n              var E3 = Qo.modifyFrames, S2 = Qo.modifyFrames, L3 = [e3, p3], x2 = [e3, b];\n              return ap && ap.add(e3, E3, L3, S2, x2), Qo.modifyFrames(e3, b);\n            }\n            function Ydt(e3, t3) {\n              if (e3 = Sa.getGraphDiv(e3), !Sa.isPlotDiv(e3)) throw new Error("This element is not a Plotly plot: " + e3);\n              var r4, n4, i3 = e3._transitionData._frames, a4 = [], o4 = [];\n              if (!t3) for (t3 = [], r4 = 0; r4 < i3.length; r4++) t3.push(r4);\n              for (t3 = t3.slice(), t3.sort(), r4 = t3.length - 1; r4 >= 0; r4--) n4 = t3[r4], a4.push({ type: "delete", index: n4 }), o4.unshift({ type: "insert", index: n4, value: i3[n4] });\n              var s3 = Qo.modifyFrames, l3 = Qo.modifyFrames, u4 = [e3, o4], c5 = [e3, a4];\n              return ap && ap.add(e3, s3, u4, l3, c5), Qo.modifyFrames(e3, a4);\n            }\n            function Kdt(e3) {\n              e3 = Sa.getGraphDiv(e3);\n              var t3 = e3._fullLayout || {}, r4 = e3._fullData || [];\n              return Qo.cleanPlot([], {}, r4, t3), Qo.purge(e3), ZN.purge(e3), t3._container && t3._container.remove(), delete e3._context, e3;\n            }\n            function Jdt(e3) {\n              var t3 = e3._fullLayout, r4 = e3.getBoundingClientRect();\n              if (!Sa.equalDomRects(r4, t3._lastBBox)) {\n                var n4 = t3._invTransform = Sa.inverseTransformMatrix(Sa.getFullTransformMatrix(e3));\n                t3._invScaleX = Math.sqrt(n4[0][0] * n4[0][0] + n4[0][1] * n4[0][1] + n4[0][2] * n4[0][2]), t3._invScaleY = Math.sqrt(n4[1][0] * n4[1][0] + n4[1][1] * n4[1][1] + n4[1][2] * n4[1][2]), t3._lastBBox = r4;\n              }\n            }\n            function $dt(e3) {\n              var t3 = FP.select(e3), r4 = e3._fullLayout;\n              if (r4._calcInverseTransform = Jdt, r4._calcInverseTransform(e3), r4._container = t3.selectAll(".plot-container").data([0]), r4._container.enter().insert("div", ":first-child").classed("plot-container", true).classed("plotly", true).style({ width: "100%", height: "100%" }), r4._paperdiv = r4._container.selectAll(".svg-container").data([0]), r4._paperdiv.enter().append("div").classed("user-select-none", true).classed("svg-container", true).style("position", "relative"), r4._glcontainer = r4._paperdiv.selectAll(".gl-container").data([{}]), r4._glcontainer.enter().append("div").classed("gl-container", true), r4._paperdiv.selectAll(".main-svg").remove(), r4._paperdiv.select(".modebar-container").remove(), r4._paper = r4._paperdiv.insert("svg", ":first-child").classed("main-svg", true), r4._toppaper = r4._paperdiv.append("svg").classed("main-svg", true), r4._modebardiv = r4._paperdiv.append("div"), delete r4._modeBar, r4._hoverpaper = r4._paperdiv.append("svg").classed("main-svg", true), !r4._uid) {\n                var n4 = {};\n                FP.selectAll("defs").each(function() {\n                  this.id && (n4[this.id.split("-")[1]] = 1);\n                }), r4._uid = Sa.randstr(n4);\n              }\n              r4._paperdiv.selectAll(".main-svg").attr(Mdt.svgAttrs), r4._defs = r4._paper.append("defs").attr("id", "defs-" + r4._uid), r4._clips = r4._defs.append("g").classed("clips", true), r4._topdefs = r4._toppaper.append("defs").attr("id", "topdefs-" + r4._uid), r4._topclips = r4._topdefs.append("g").classed("clips", true), r4._bgLayer = r4._paper.append("g").classed("bglayer", true), r4._draggers = r4._paper.append("g").classed("draglayer", true);\n              var i3 = r4._paper.append("g").classed("layer-below", true);\n              r4._imageLowerLayer = i3.append("g").classed("imagelayer", true), r4._shapeLowerLayer = i3.append("g").classed("shapelayer", true), r4._cartesianlayer = r4._paper.append("g").classed("cartesianlayer", true), r4._polarlayer = r4._paper.append("g").classed("polarlayer", true), r4._smithlayer = r4._paper.append("g").classed("smithlayer", true), r4._ternarylayer = r4._paper.append("g").classed("ternarylayer", true), r4._geolayer = r4._paper.append("g").classed("geolayer", true), r4._funnelarealayer = r4._paper.append("g").classed("funnelarealayer", true), r4._pielayer = r4._paper.append("g").classed("pielayer", true), r4._iciclelayer = r4._paper.append("g").classed("iciclelayer", true), r4._treemaplayer = r4._paper.append("g").classed("treemaplayer", true), r4._sunburstlayer = r4._paper.append("g").classed("sunburstlayer", true), r4._indicatorlayer = r4._toppaper.append("g").classed("indicatorlayer", true), r4._glimages = r4._paper.append("g").classed("glimages", true);\n              var a4 = r4._toppaper.append("g").classed("layer-above", true);\n              r4._imageUpperLayer = a4.append("g").classed("imagelayer", true), r4._shapeUpperLayer = a4.append("g").classed("shapelayer", true), r4._selectionLayer = r4._toppaper.append("g").classed("selectionlayer", true), r4._infolayer = r4._toppaper.append("g").classed("infolayer", true), r4._menulayer = r4._toppaper.append("g").classed("menulayer", true), r4._zoomlayer = r4._toppaper.append("g").classed("zoomlayer", true), r4._hoverlayer = r4._hoverpaper.append("g").classed("hoverlayer", true), r4._modebardiv.classed("modebar-container", true).style("position", "absolute").style("top", "0px").style("right", "0px"), e3.emit("plotly_framework");\n            }\n            _l.animate = Xdt;\n            _l.addFrames = Zdt;\n            _l.deleteFrames = Ydt;\n            _l.addTraces = Khe;\n            _l.deleteTraces = Jhe;\n            _l.extendTraces = Zhe;\n            _l.moveTraces = YN;\n            _l.prependTraces = Yhe;\n            _l.newPlot = Rdt;\n            _l._doPlot = Cdt;\n            _l.purge = Kdt;\n            _l.react = Hdt;\n            _l.redraw = Idt;\n            _l.relayout = HM;\n            _l.restyle = qP;\n            _l.setPlotConfig = Ldt;\n            _l.update = NP;\n            _l._guiRelayout = KN(HM);\n            _l._guiRestyle = KN(qP);\n            _l._guiUpdate = KN(NP);\n            _l._storeDirectGUIEdit = Odt;\n          });\n          var Py = ye((Mm) => {\n            "use strict";\n            var Qdt = qa();\n            Mm.getDelay = function(e3) {\n              return e3._has && (e3._has("gl3d") || e3._has("mapbox") || e3._has("map")) ? 500 : 0;\n            };\n            Mm.getRedrawFunc = function(e3) {\n              return function() {\n                Qdt.getComponentMethod("colorbar", "draw")(e3);\n              };\n            };\n            Mm.encodeSVG = function(e3) {\n              return "data:image/svg+xml," + encodeURIComponent(e3);\n            };\n            Mm.encodeJSON = function(e3) {\n              return "data:application/json," + encodeURIComponent(e3);\n            };\n            var nde = window.URL || window.webkitURL;\n            Mm.createObjectURL = function(e3) {\n              return nde.createObjectURL(e3);\n            };\n            Mm.revokeObjectURL = function(e3) {\n              return nde.revokeObjectURL(e3);\n            };\n            Mm.createBlob = function(e3, t3) {\n              if (t3 === "svg") return new window.Blob([e3], { type: "image/svg+xml;charset=utf-8" });\n              if (t3 === "full-json") return new window.Blob([e3], { type: "application/json;charset=utf-8" });\n              var r4 = evt(window.atob(e3));\n              return new window.Blob([r4], { type: "image/" + t3 });\n            };\n            Mm.octetStream = function(e3) {\n              document.location.href = "data:application/octet-stream" + e3;\n            };\n            function evt(e3) {\n              for (var t3 = e3.length, r4 = new ArrayBuffer(t3), n4 = new Uint8Array(r4), i3 = 0; i3 < t3; i3++) n4[i3] = e3.charCodeAt(i3);\n              return r4;\n            }\n            Mm.IMAGE_URL_PREFIX = /^data:image\\/\\w+;base64,/;\n          });\n          var jP = ye((Lor, ade) => {\n            "use strict";\n            var $N = Oa(), kor = Dr(), tvt = So(), rvt = ka(), Cor = Wp(), JN = /"/g, WM = "TOBESTRIPPED", ivt = new RegExp(\'("\' + WM + ")|(" + WM + \'")\', "g");\n            function nvt(e3) {\n              var t3 = $N.select("body").append("div").style({ display: "none" }).html(""), r4 = e3.replace(/(&[^;]*;)/gi, function(n4) {\n                return n4 === "&lt;" ? "&#60;" : n4 === "&rt;" ? "&#62;" : n4.indexOf("<") !== -1 || n4.indexOf(">") !== -1 ? "" : t3.html(n4).text();\n              });\n              return t3.remove(), r4;\n            }\n            function avt(e3) {\n              return e3.replace(/&(?!\\w+;|\\#[0-9]+;| \\#x[0-9A-F]+;)/g, "&amp;");\n            }\n            ade.exports = function(t3, r4, n4) {\n              var i3 = t3._fullLayout, a4 = i3._paper, o4 = i3._toppaper, s3 = i3.width, l3 = i3.height, u4;\n              a4.insert("rect", ":first-child").call(tvt.setRect, 0, 0, s3, l3).call(rvt.fill, i3.paper_bgcolor);\n              var c5 = i3._basePlotModules || [];\n              for (u4 = 0; u4 < c5.length; u4++) {\n                var f4 = c5[u4];\n                f4.toSVG && f4.toSVG(t3);\n              }\n              if (o4) {\n                var h3 = o4.node().childNodes, d3 = Array.prototype.slice.call(h3);\n                for (u4 = 0; u4 < d3.length; u4++) {\n                  var v3 = d3[u4];\n                  v3.childNodes.length && a4.node().appendChild(v3);\n                }\n              }\n              i3._draggers && i3._draggers.remove(), a4.node().style.background = "", a4.selectAll("text").attr({ "data-unformatted": null, "data-math": null }).each(function() {\n                var b = $N.select(this);\n                if (this.style.visibility === "hidden" || this.style.display === "none") {\n                  b.remove();\n                  return;\n                } else b.style({ visibility: null, display: null });\n                var p3 = this.style.fontFamily;\n                p3 && p3.indexOf(\'"\') !== -1 && b.style("font-family", p3.replace(JN, WM));\n                var k4 = this.style.fontWeight;\n                k4 && (k4 === "normal" || k4 === "400") && b.style("font-weight", void 0);\n                var E3 = this.style.fontStyle;\n                E3 && E3 === "normal" && b.style("font-style", void 0);\n                var S2 = this.style.fontVariant;\n                S2 && S2 === "normal" && b.style("font-variant", void 0);\n              }), a4.selectAll(".gradient_filled,.pattern_filled").each(function() {\n                var b = $N.select(this), p3 = this.style.fill;\n                p3 && p3.indexOf("url(") !== -1 && b.style("fill", p3.replace(JN, WM));\n                var k4 = this.style.stroke;\n                k4 && k4.indexOf("url(") !== -1 && b.style("stroke", k4.replace(JN, WM));\n              }), (r4 === "pdf" || r4 === "eps") && a4.selectAll("#MathJax_SVG_glyphs path").attr("stroke-width", 0), r4 === "svg" && n4 && (a4.attr("width", n4 * s3), a4.attr("height", n4 * l3), a4.attr("viewBox", "0 0 " + s3 + " " + l3));\n              var _2 = new window.XMLSerializer().serializeToString(a4.node());\n              return _2 = nvt(_2), _2 = avt(_2), _2 = _2.replace(ivt, "\'"), _2;\n            };\n          });\n          var WP = ye((Por, ode) => {\n            "use strict";\n            var ovt = Dr(), svt = pb().EventEmitter, XM = Py();\n            function lvt(e3) {\n              var t3 = e3.emitter || new svt(), r4 = new Promise(function(n4, i3) {\n                var a4 = window.Image, o4 = e3.svg, s3 = e3.format || "png", l3 = e3.canvas, u4 = e3.scale || 1, c5 = e3.width || 300, f4 = e3.height || 150, h3 = u4 * c5, d3 = u4 * f4, v3 = l3.getContext("2d", { willReadFrequently: true }), _2 = new a4(), b, p3;\n                s3 === "svg" || ovt.isSafari() ? p3 = XM.encodeSVG(o4) : (b = XM.createBlob(o4, "svg"), p3 = XM.createObjectURL(b)), l3.width = h3, l3.height = d3, _2.onload = function() {\n                  var k4;\n                  switch (b = null, XM.revokeObjectURL(p3), s3 !== "svg" && v3.drawImage(_2, 0, 0, h3, d3), s3) {\n                    case "jpeg":\n                      k4 = l3.toDataURL("image/jpeg");\n                      break;\n                    case "png":\n                      k4 = l3.toDataURL("image/png");\n                      break;\n                    case "webp":\n                      k4 = l3.toDataURL("image/webp");\n                      break;\n                    case "svg":\n                      k4 = p3;\n                      break;\n                    default:\n                      var E3 = "Image format is not jpeg, png, svg or webp.";\n                      if (i3(new Error(E3)), !e3.promise) return t3.emit("error", E3);\n                  }\n                  n4(k4), e3.promise || t3.emit("success", k4);\n                }, _2.onerror = function(k4) {\n                  if (b = null, XM.revokeObjectURL(p3), i3(k4), !e3.promise) return t3.emit("error", k4);\n                }, _2.src = p3;\n              });\n              return e3.promise ? r4 : t3;\n            }\n            ode.exports = lvt;\n          });\n          var eU = ye((Ior, ude) => {\n            "use strict";\n            var sde = Eo(), lde = HP(), uvt = Mc(), Em = Dr(), ZM = Py(), cvt = jP(), fvt = WP(), hvt = l6().version, QN = { format: { valType: "enumerated", values: ["png", "jpeg", "webp", "svg", "full-json"], dflt: "png" }, width: { valType: "number", min: 1 }, height: { valType: "number", min: 1 }, scale: { valType: "number", min: 0, dflt: 1 }, setBackground: { valType: "any", dflt: false }, imageDataOnly: { valType: "boolean", dflt: false } };\n            function dvt(e3, t3) {\n              t3 = t3 || {};\n              var r4, n4, i3, a4;\n              Em.isPlainObject(e3) ? (r4 = e3.data || [], n4 = e3.layout || {}, i3 = e3.config || {}, a4 = {}) : (e3 = Em.getGraphDiv(e3), r4 = Em.extendDeep([], e3.data), n4 = Em.extendDeep({}, e3.layout), i3 = e3._context, a4 = e3._fullLayout || {});\n              function o4(x2) {\n                return !(x2 in t3) || Em.validate(t3[x2], QN[x2]);\n              }\n              if (!o4("width") && t3.width !== null || !o4("height") && t3.height !== null) throw new Error("Height and width should be pixel values.");\n              if (!o4("format")) throw new Error("Export format is not " + Em.join2(QN.format.values, ", ", " or ") + ".");\n              var s3 = {};\n              function l3(x2, C3) {\n                return Em.coerce(t3, s3, QN, x2, C3);\n              }\n              var u4 = l3("format"), c5 = l3("width"), f4 = l3("height"), h3 = l3("scale"), d3 = l3("setBackground"), v3 = l3("imageDataOnly"), _2 = document.createElement("div");\n              _2.style.position = "absolute", _2.style.left = "-5000px", document.body.appendChild(_2);\n              var b = Em.extendFlat({}, n4);\n              c5 ? b.width = c5 : t3.width === null && sde(a4.width) && (b.width = a4.width), f4 ? b.height = f4 : t3.height === null && sde(a4.height) && (b.height = a4.height);\n              var p3 = Em.extendFlat({}, i3, { _exportedPlot: true, staticPlot: true, setBackground: d3 }), k4 = ZM.getRedrawFunc(_2);\n              function E3() {\n                return new Promise(function(x2) {\n                  setTimeout(x2, ZM.getDelay(_2._fullLayout));\n                });\n              }\n              function S2() {\n                return new Promise(function(x2, C3) {\n                  var M4 = cvt(_2, u4, h3), g3 = _2._fullLayout.width, P3 = _2._fullLayout.height;\n                  function T3() {\n                    lde.purge(_2), document.body.removeChild(_2);\n                  }\n                  if (u4 === "full-json") {\n                    var z3 = uvt.graphJson(_2, false, "keepdata", "object", true, true);\n                    return z3.version = hvt, z3 = JSON.stringify(z3), T3(), x2(v3 ? z3 : ZM.encodeJSON(z3));\n                  }\n                  if (T3(), u4 === "svg") return x2(v3 ? M4 : ZM.encodeSVG(M4));\n                  var O3 = document.createElement("canvas");\n                  O3.id = Em.randstr(), fvt({ format: u4, width: g3, height: P3, scale: h3, canvas: O3, svg: M4, promise: true }).then(x2).catch(C3);\n                });\n              }\n              function L3(x2) {\n                return v3 ? x2.replace(ZM.IMAGE_URL_PREFIX, "") : x2;\n              }\n              return new Promise(function(x2, C3) {\n                lde.newPlot(_2, r4, b, p3).then(k4).then(E3).then(S2).then(function(M4) {\n                  x2(L3(M4));\n                }).catch(function(M4) {\n                  C3(M4);\n                });\n              });\n            }\n            ude.exports = dvt;\n          });\n          var hde = ye((Ror, fde) => {\n            "use strict";\n            var P0 = Dr(), vvt = Mc(), pvt = w3(), gvt = cb().dfltConfig, Pg = P0.isPlainObject, Gb = Array.isArray, tU = P0.isArrayOrTypedArray;\n            fde.exports = function(t3, r4) {\n              t3 === void 0 && (t3 = []), r4 === void 0 && (r4 = {});\n              var n4 = pvt.get(), i3 = [], a4 = { _context: P0.extendFlat({}, gvt) }, o4, s3;\n              Gb(t3) ? (a4.data = P0.extendDeep([], t3), o4 = t3) : (a4.data = [], o4 = [], i3.push(md("array", "data"))), Pg(r4) ? (a4.layout = P0.extendDeep({}, r4), s3 = r4) : (a4.layout = {}, s3 = {}, arguments.length > 1 && i3.push(md("object", "layout"))), vvt.supplyDefaults(a4);\n              for (var l3 = a4._fullData, u4 = o4.length, c5 = 0; c5 < u4; c5++) {\n                var f4 = o4[c5], h3 = ["data", c5];\n                if (!Pg(f4)) {\n                  i3.push(md("object", h3));\n                  continue;\n                }\n                var d3 = l3[c5], v3 = d3.type, _2 = n4.traces[v3].attributes;\n                _2.type = { valType: "enumerated", values: [v3] }, d3.visible === false && f4.visible !== false && i3.push(md("invisible", h3)), XP(f4, d3, _2, i3, h3);\n              }\n              var b = a4._fullLayout, p3 = mvt(n4, l3);\n              return XP(s3, b, p3, i3, "layout"), i3.length === 0 ? void 0 : i3;\n            };\n            function XP(e3, t3, r4, n4, i3, a4) {\n              a4 = a4 || [];\n              for (var o4 = Object.keys(e3), s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3], u4 = a4.slice();\n                u4.push(l3);\n                var c5 = e3[l3], f4 = t3[l3], h3 = xvt(r4, l3), d3 = (h3 || {}).valType, v3 = d3 === "info_array", _2 = d3 === "colorscale", b = (h3 || {}).items;\n                if (!_vt(r4, l3)) n4.push(md("schema", i3, u4));\n                else if (Pg(c5) && Pg(f4) && d3 !== "any") XP(c5, f4, h3, n4, i3, u4);\n                else if (v3 && Gb(c5)) {\n                  c5.length > f4.length && n4.push(md("unused", i3, u4.concat(f4.length)));\n                  var p3 = f4.length, k4 = Array.isArray(b);\n                  k4 && (p3 = Math.min(p3, b.length));\n                  var E3, S2, L3, x2, C3;\n                  if (h3.dimensions === 2) for (S2 = 0; S2 < p3; S2++) if (Gb(c5[S2])) {\n                    c5[S2].length > f4[S2].length && n4.push(md("unused", i3, u4.concat(S2, f4[S2].length)));\n                    var M4 = f4[S2].length;\n                    for (E3 = 0; E3 < (k4 ? Math.min(M4, b[S2].length) : M4); E3++) L3 = k4 ? b[S2][E3] : b, x2 = c5[S2][E3], C3 = f4[S2][E3], P0.validate(x2, L3) ? C3 !== x2 && C3 !== +x2 && n4.push(md("dynamic", i3, u4.concat(S2, E3), x2, C3)) : n4.push(md("value", i3, u4.concat(S2, E3), x2));\n                  } else n4.push(md("array", i3, u4.concat(S2), c5[S2]));\n                  else for (S2 = 0; S2 < p3; S2++) L3 = k4 ? b[S2] : b, x2 = c5[S2], C3 = f4[S2], P0.validate(x2, L3) ? C3 !== x2 && C3 !== +x2 && n4.push(md("dynamic", i3, u4.concat(S2), x2, C3)) : n4.push(md("value", i3, u4.concat(S2), x2));\n                } else if (h3.items && !v3 && Gb(c5)) {\n                  var g3 = b[Object.keys(b)[0]], P3 = [], T3, z3;\n                  for (T3 = 0; T3 < f4.length; T3++) {\n                    var O3 = f4[T3]._index || T3;\n                    if (z3 = u4.slice(), z3.push(O3), Pg(c5[O3]) && Pg(f4[T3])) {\n                      P3.push(O3);\n                      var V2 = c5[O3], G2 = f4[T3];\n                      Pg(V2) && V2.visible !== false && G2.visible === false ? n4.push(md("invisible", i3, z3)) : XP(V2, G2, g3, n4, i3, z3);\n                    }\n                  }\n                  for (T3 = 0; T3 < c5.length; T3++) z3 = u4.slice(), z3.push(T3), Pg(c5[T3]) ? P3.indexOf(T3) === -1 && n4.push(md("unused", i3, z3)) : n4.push(md("object", i3, z3, c5[T3]));\n                } else !Pg(c5) && Pg(f4) ? n4.push(md("object", i3, u4, c5)) : !tU(c5) && tU(f4) && !v3 && !_2 ? n4.push(md("array", i3, u4, c5)) : l3 in t3 ? P0.validate(c5, h3) ? h3.valType === "enumerated" && (h3.coerceNumber && c5 !== +f4 || !tU(c5) && c5 !== f4 || String(c5) !== String(f4)) && n4.push(md("dynamic", i3, u4, c5, f4)) : n4.push(md("value", i3, u4, c5)) : n4.push(md("unused", i3, u4, c5));\n              }\n              return n4;\n            }\n            function mvt(e3, t3) {\n              for (var r4 = e3.layout.layoutAttributes, n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4], a4 = e3.traces[i3.type], o4 = a4.layoutAttributes;\n                o4 && (i3.subplot ? P0.extendFlat(r4[a4.attributes.subplot.dflt], o4) : P0.extendFlat(r4, o4));\n              }\n              return r4;\n            }\n            var yvt = { object: function(e3, t3) {\n              var r4;\n              return e3 === "layout" && t3 === "" ? r4 = "The layout argument" : e3[0] === "data" && t3 === "" ? r4 = "Trace " + e3[1] + " in the data argument" : r4 = Vb(e3) + "key " + t3, r4 + " must be linked to an object container";\n            }, array: function(e3, t3) {\n              var r4;\n              return e3 === "data" ? r4 = "The data argument" : r4 = Vb(e3) + "key " + t3, r4 + " must be linked to an array container";\n            }, schema: function(e3, t3) {\n              return Vb(e3) + "key " + t3 + " is not part of the schema";\n            }, unused: function(e3, t3, r4) {\n              var n4 = Pg(r4) ? "container" : "key";\n              return Vb(e3) + n4 + " " + t3 + " did not get coerced";\n            }, dynamic: function(e3, t3, r4, n4) {\n              return [Vb(e3) + "key", t3, "(set to \'" + r4 + "\')", "got reset to", "\'" + n4 + "\'", "during defaults."].join(" ");\n            }, invisible: function(e3, t3) {\n              return (t3 ? Vb(e3) + "item " + t3 : "Trace " + e3[1]) + " got defaulted to be not visible";\n            }, value: function(e3, t3, r4) {\n              return [Vb(e3) + "key " + t3, "is set to an invalid value (" + r4 + ")"].join(" ");\n            } };\n            function Vb(e3) {\n              return Gb(e3) ? "In data trace " + e3[1] + ", " : "In " + e3 + ", ";\n            }\n            function md(e3, t3, r4, n4, i3) {\n              r4 = r4 || "";\n              var a4, o4;\n              Gb(t3) ? (a4 = t3[0], o4 = t3[1]) : (a4 = t3, o4 = null);\n              var s3 = wvt(r4), l3 = yvt[e3](t3, s3, n4, i3);\n              return P0.log(l3), { code: e3, container: a4, trace: o4, path: r4, astr: s3, msg: l3 };\n            }\n            function _vt(e3, t3) {\n              var r4 = cde(t3), n4 = r4.keyMinusId, i3 = r4.id;\n              return n4 in e3 && e3[n4]._isSubplotObj && i3 ? true : t3 in e3;\n            }\n            function xvt(e3, t3) {\n              if (t3 in e3) return e3[t3];\n              var r4 = cde(t3);\n              return e3[r4.keyMinusId];\n            }\n            var bvt = P0.counterRegex("([a-z]+)");\n            function cde(e3) {\n              var t3 = e3.match(bvt);\n              return { keyMinusId: t3 && t3[1], id: t3 && t3[2] };\n            }\n            function wvt(e3) {\n              if (!Gb(e3)) return String(e3);\n              for (var t3 = "", r4 = 0; r4 < e3.length; r4++) {\n                var n4 = e3[r4];\n                typeof n4 == "number" ? t3 = t3.slice(0, -1) + "[" + n4 + "]" : t3 += n4, r4 < e3.length - 1 && (t3 += ".");\n              }\n              return t3;\n            }\n          });\n          var vde = ye((Dor, dde) => {\n            "use strict";\n            var Tvt = Dr(), ZP = Py();\n            function Avt(e3, t3, r4) {\n              var n4 = document.createElement("a"), i3 = "download" in n4, a4 = new Promise(function(o4, s3) {\n                var l3, u4;\n                if (i3) return l3 = ZP.createBlob(e3, r4), u4 = ZP.createObjectURL(l3), n4.href = u4, n4.download = t3, document.body.appendChild(n4), n4.click(), document.body.removeChild(n4), ZP.revokeObjectURL(u4), l3 = null, o4(t3);\n                if (Tvt.isSafari()) {\n                  var c5 = r4 === "svg" ? "," : ";base64,";\n                  return ZP.octetStream(c5 + encodeURIComponent(e3)), o4(t3);\n                }\n                s3(new Error("download error"));\n              });\n              return a4;\n            }\n            dde.exports = Avt;\n          });\n          var rU = ye((zor, gde) => {\n            "use strict";\n            var pde = Dr(), Svt = eU(), Mvt = vde(), For = Py();\n            function Evt(e3, t3) {\n              var r4;\n              return pde.isPlainObject(e3) || (r4 = pde.getGraphDiv(e3)), t3 = t3 || {}, t3.format = t3.format || "png", t3.width = t3.width || null, t3.height = t3.height || null, t3.imageDataOnly = true, new Promise(function(n4, i3) {\n                r4 && r4._snapshotInProgress && i3(new Error("Snapshotting already in progress.")), r4 && (r4._snapshotInProgress = true);\n                var a4 = Svt(e3, t3), o4 = t3.filename || e3.fn || "newplot";\n                o4 += "." + t3.format.replace("-", "."), a4.then(function(s3) {\n                  return r4 && (r4._snapshotInProgress = false), Mvt(s3, o4, t3.format);\n                }).then(function(s3) {\n                  n4(s3);\n                }).catch(function(s3) {\n                  r4 && (r4._snapshotInProgress = false), i3(s3);\n                });\n              });\n            }\n            gde.exports = Evt;\n          });\n          var bde = ye((iU) => {\n            "use strict";\n            var Cp = Dr(), Lp = Cp.isPlainObject, mde = w3(), yde = Mc(), kvt = Gl(), _de = vl(), xde = cb().dfltConfig;\n            iU.makeTemplate = function(e3) {\n              e3 = Cp.isPlainObject(e3) ? e3 : Cp.getGraphDiv(e3), e3 = Cp.extendDeep({ _context: xde }, { data: e3.data, layout: e3.layout }), yde.supplyDefaults(e3);\n              var t3 = e3.data || [], r4 = e3.layout || {};\n              r4._basePlotModules = e3._fullLayout._basePlotModules, r4._modules = e3._fullLayout._modules;\n              var n4 = { data: {}, layout: {} };\n              t3.forEach(function(d3) {\n                var v3 = {};\n                YM(d3, v3, Lvt.bind(null, d3));\n                var _2 = Cp.coerce(d3, {}, kvt, "type"), b = n4.data[_2];\n                b || (b = n4.data[_2] = []), b.push(v3);\n              }), YM(r4, n4.layout, Cvt.bind(null, r4)), delete n4.layout.template;\n              var i3 = r4.template;\n              if (Lp(i3)) {\n                var a4 = i3.layout, o4, s3, l3, u4, c5, f4;\n                Lp(a4) && YP(a4, n4.layout);\n                var h3 = i3.data;\n                if (Lp(h3)) {\n                  for (s3 in n4.data) if (l3 = h3[s3], Array.isArray(l3)) {\n                    for (c5 = n4.data[s3], f4 = c5.length, u4 = l3.length, o4 = 0; o4 < f4; o4++) YP(l3[o4 % u4], c5[o4]);\n                    for (o4 = f4; o4 < u4; o4++) c5.push(Cp.extendDeep({}, l3[o4]));\n                  }\n                  for (s3 in h3) s3 in n4.data || (n4.data[s3] = Cp.extendDeep([], h3[s3]));\n                }\n              }\n              return n4;\n            };\n            function YP(e3, t3) {\n              e3 = Cp.extendDeep({}, e3);\n              var r4 = Object.keys(e3).sort(), n4, i3;\n              function a4(c5, f4, h3) {\n                if (Lp(f4) && Lp(c5)) YP(c5, f4);\n                else if (Array.isArray(f4) && Array.isArray(c5)) {\n                  var d3 = _de.arrayTemplater({ _template: e3 }, h3);\n                  for (i3 = 0; i3 < f4.length; i3++) {\n                    var v3 = f4[i3], _2 = d3.newItem(v3)._template;\n                    _2 && YP(_2, v3);\n                  }\n                  var b = d3.defaultItems();\n                  for (i3 = 0; i3 < b.length; i3++) f4.push(b[i3]._template);\n                  for (i3 = 0; i3 < f4.length; i3++) delete f4[i3].templateitemname;\n                }\n              }\n              for (n4 = 0; n4 < r4.length; n4++) {\n                var o4 = r4[n4], s3 = e3[o4];\n                if (o4 in t3 ? a4(s3, t3[o4], o4) : t3[o4] = s3, KP(o4) === o4) for (var l3 in t3) {\n                  var u4 = KP(l3);\n                  l3 !== u4 && u4 === o4 && !(l3 in e3) && a4(s3, t3[l3], o4);\n                }\n              }\n            }\n            function KP(e3) {\n              return e3.replace(/[0-9]+$/, "");\n            }\n            function YM(e3, t3, r4, n4, i3) {\n              var a4 = i3 && r4(i3);\n              for (var o4 in e3) {\n                var s3 = e3[o4], l3 = I0(e3, o4, n4), u4 = I0(e3, o4, i3), c5 = r4(u4);\n                if (!c5) {\n                  var f4 = KP(o4);\n                  f4 !== o4 && (u4 = I0(e3, f4, i3), c5 = r4(u4));\n                }\n                if (!(a4 && a4 === c5) && !(!c5 || c5._noTemplating || c5.valType === "data_array" || c5.arrayOk && Array.isArray(s3))) if (!c5.valType && Lp(s3)) YM(s3, t3, r4, l3, u4);\n                else if (c5._isLinkedToArray && Array.isArray(s3)) for (var h3 = false, d3 = 0, v3 = {}, _2 = 0; _2 < s3.length; _2++) {\n                  var b = s3[_2];\n                  if (Lp(b)) {\n                    var p3 = b.name;\n                    if (p3) v3[p3] || (YM(b, t3, r4, I0(s3, d3, l3), I0(s3, d3, u4)), d3++, v3[p3] = 1);\n                    else if (!h3) {\n                      var k4 = _de.arrayDefaultKey(o4), E3 = I0(e3, k4, n4), S2 = I0(s3, d3, l3);\n                      YM(b, t3, r4, S2, I0(s3, d3, u4));\n                      var L3 = Cp.nestedProperty(t3, S2), x2 = Cp.nestedProperty(t3, E3);\n                      x2.set(L3.get()), L3.set(null), h3 = true;\n                    }\n                  }\n                }\n                else {\n                  var C3 = Cp.nestedProperty(t3, l3);\n                  C3.set(s3);\n                }\n              }\n            }\n            function Cvt(e3, t3) {\n              return mde.getLayoutValObject(e3, Cp.nestedProperty({}, t3).parts);\n            }\n            function Lvt(e3, t3) {\n              return mde.getTraceValObject(e3, Cp.nestedProperty({}, t3).parts);\n            }\n            function I0(e3, t3, r4) {\n              var n4;\n              return r4 ? Array.isArray(e3) ? n4 = r4 + "[" + t3 + "]" : n4 = r4 + "." + t3 : n4 = t3, n4;\n            }\n            iU.validateTemplate = function(e3, t3) {\n              var r4 = Cp.extendDeep({}, { _context: xde, data: e3.data, layout: e3.layout }), n4 = r4.layout || {};\n              Lp(t3) || (t3 = n4.template || {});\n              var i3 = t3.layout, a4 = t3.data, o4 = [];\n              r4.layout = n4, r4.layout.template = t3, yde.supplyDefaults(r4);\n              var s3 = r4._fullLayout, l3 = r4._fullData, u4 = {};\n              function c5(E3, S2) {\n                for (var L3 in E3) if (L3.charAt(0) !== "_" && Lp(E3[L3])) {\n                  var x2 = KP(L3), C3 = [], M4;\n                  for (M4 = 0; M4 < S2.length; M4++) C3.push(I0(E3, L3, S2[M4])), x2 !== L3 && C3.push(I0(E3, x2, S2[M4]));\n                  for (M4 = 0; M4 < C3.length; M4++) u4[C3[M4]] = 1;\n                  c5(E3[L3], C3);\n                }\n              }\n              function f4(E3, S2) {\n                for (var L3 in E3) if (L3.indexOf("defaults") === -1 && Lp(E3[L3])) {\n                  var x2 = I0(E3, L3, S2);\n                  u4[x2] ? f4(E3[L3], x2) : o4.push({ code: "unused", path: x2 });\n                }\n              }\n              if (Lp(i3) ? (c5(s3, ["layout"]), f4(i3, "layout")) : o4.push({ code: "layout" }), !Lp(a4)) o4.push({ code: "data" });\n              else {\n                for (var h3 = {}, d3, v3 = 0; v3 < l3.length; v3++) {\n                  var _2 = l3[v3];\n                  d3 = _2.type, h3[d3] = (h3[d3] || 0) + 1, _2._fullInput._template || o4.push({ code: "missing", index: _2.index, traceType: d3 });\n                }\n                for (d3 in a4) {\n                  var b = a4[d3].length, p3 = h3[d3] || 0;\n                  b > p3 ? o4.push({ code: "unused", traceType: d3, templateCount: b, dataCount: p3 }) : p3 > b && o4.push({ code: "reused", traceType: d3, templateCount: b, dataCount: p3 });\n                }\n              }\n              function k4(E3, S2) {\n                for (var L3 in E3) if (L3.charAt(0) !== "_") {\n                  var x2 = E3[L3], C3 = I0(E3, L3, S2);\n                  Lp(x2) ? (Array.isArray(E3) && x2._template === false && x2.templateitemname && o4.push({ code: "missing", path: C3, templateitemname: x2.templateitemname }), k4(x2, C3)) : Array.isArray(x2) && Pvt(x2) && k4(x2, C3);\n                }\n              }\n              if (k4({ data: l3, layout: s3 }, ""), o4.length) return o4.map(Ivt);\n            };\n            function Pvt(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) if (Lp(e3[t3])) return true;\n            }\n            function Ivt(e3) {\n              var t3;\n              switch (e3.code) {\n                case "data":\n                  t3 = "The template has no key data.";\n                  break;\n                case "layout":\n                  t3 = "The template has no key layout.";\n                  break;\n                case "missing":\n                  e3.path ? t3 = "There are no templates for item " + e3.path + " with name " + e3.templateitemname : t3 = "There are no templates for trace " + e3.index + ", of type " + e3.traceType + ".";\n                  break;\n                case "unused":\n                  e3.path ? t3 = "The template item at " + e3.path + " was not used in constructing the plot." : e3.dataCount ? t3 = "Some of the templates of type " + e3.traceType + " were not used. The template has " + e3.templateCount + " traces, the data only has " + e3.dataCount + " of this type." : t3 = "The template has " + e3.templateCount + " traces of type " + e3.traceType + " but there are none in the data.";\n                  break;\n                case "reused":\n                  t3 = "Some of the templates of type " + e3.traceType + " were used more than once. The template has " + e3.templateCount + " traces, the data has " + e3.dataCount + " of this type.";\n                  break;\n              }\n              return e3.msg = t3, e3;\n            }\n          });\n          var Tde = ye((ef) => {\n            "use strict";\n            var td = HP();\n            ef._doPlot = td._doPlot;\n            ef.newPlot = td.newPlot;\n            ef.restyle = td.restyle;\n            ef.relayout = td.relayout;\n            ef.redraw = td.redraw;\n            ef.update = td.update;\n            ef._guiRestyle = td._guiRestyle;\n            ef._guiRelayout = td._guiRelayout;\n            ef._guiUpdate = td._guiUpdate;\n            ef._storeDirectGUIEdit = td._storeDirectGUIEdit;\n            ef.react = td.react;\n            ef.extendTraces = td.extendTraces;\n            ef.prependTraces = td.prependTraces;\n            ef.addTraces = td.addTraces;\n            ef.deleteTraces = td.deleteTraces;\n            ef.moveTraces = td.moveTraces;\n            ef.purge = td.purge;\n            ef.addFrames = td.addFrames;\n            ef.deleteFrames = td.deleteFrames;\n            ef.animate = td.animate;\n            ef.setPlotConfig = td.setPlotConfig;\n            var Rvt = NS().getGraphDiv, Dvt = lP().eraseActiveShape;\n            ef.deleteActiveShape = function(e3) {\n              return Dvt(Rvt(e3));\n            };\n            ef.toImage = eU();\n            ef.validate = hde();\n            ef.downloadImage = rU();\n            var wde = bde();\n            ef.makeTemplate = wde.makeTemplate;\n            ef.validateTemplate = wde.validateTemplate;\n          });\n          var eT = ye((Bor, Ade) => {\n            "use strict";\n            var nU = Dr(), Fvt = qa();\n            Ade.exports = function(t3, r4, n4, i3) {\n              var a4 = i3("x"), o4 = i3("y"), s3, l3 = Fvt.getComponentMethod("calendars", "handleTraceDefaults");\n              if (l3(t3, r4, ["x", "y"], n4), a4) {\n                var u4 = nU.minRowLength(a4);\n                o4 ? s3 = Math.min(u4, nU.minRowLength(o4)) : (s3 = u4, i3("y0"), i3("dy"));\n              } else {\n                if (!o4) return 0;\n                s3 = nU.minRowLength(o4), i3("x0"), i3("dx");\n              }\n              return r4._length = s3, s3;\n            };\n          });\n          var Ig = ye((Nor, Ede) => {\n            "use strict";\n            var Sde = Dr().dateTick0, zvt = fs(), Ovt = zvt.ONEWEEK;\n            function Mde(e3, t3) {\n              return e3 % Ovt === 0 ? Sde(t3, 1) : Sde(t3, 0);\n            }\n            Ede.exports = function(t3, r4, n4, i3, a4) {\n              if (a4 || (a4 = { x: true, y: true }), a4.x) {\n                var o4 = i3("xperiod");\n                o4 && (i3("xperiod0", Mde(o4, r4.xcalendar)), i3("xperiodalignment"));\n              }\n              if (a4.y) {\n                var s3 = i3("yperiod");\n                s3 && (i3("yperiod0", Mde(s3, r4.ycalendar)), i3("yperiodalignment"));\n              }\n            };\n          });\n          var Lde = ye((Uor, Cde) => {\n            "use strict";\n            var kde = ["orientation", "groupnorm", "stackgaps"];\n            Cde.exports = function(t3, r4, n4, i3) {\n              var a4 = n4._scatterStackOpts, o4 = i3("stackgroup");\n              if (o4) {\n                var s3 = r4.xaxis + r4.yaxis, l3 = a4[s3];\n                l3 || (l3 = a4[s3] = {});\n                var u4 = l3[o4], c5 = false;\n                u4 ? u4.traces.push(r4) : (u4 = l3[o4] = { traceIndices: [], traces: [r4] }, c5 = true);\n                for (var f4 = { orientation: r4.x && !r4.y ? "h" : "v" }, h3 = 0; h3 < kde.length; h3++) {\n                  var d3 = kde[h3], v3 = d3 + "Found";\n                  if (!u4[v3]) {\n                    var _2 = t3[d3] !== void 0, b = d3 === "orientation";\n                    if ((_2 || c5) && (u4[d3] = i3(d3, f4[d3]), b && (u4.fillDflt = u4[d3] === "h" ? "tonextx" : "tonexty"), _2 && (u4[v3] = true, !c5 && (delete u4.traces[0][d3], b)))) for (var p3 = 0; p3 < u4.traces.length - 1; p3++) {\n                      var k4 = u4.traces[p3];\n                      k4._input.fill !== k4.fill && (k4.fill = u4.fillDflt);\n                    }\n                  }\n                }\n                return u4;\n              }\n            };\n          });\n          var $p = ye((Vor, Dde) => {\n            "use strict";\n            var Pde = ka(), Ide = pv().hasColorscale, Rde = Qh(), qvt = Ru();\n            Dde.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = qvt.isBubble(t3), l3 = (t3.line || {}).color, u4;\n              if (o4 = o4 || {}, l3 && (n4 = l3), a4("marker.symbol"), a4("marker.opacity", s3 ? 0.7 : 1), a4("marker.size"), o4.noAngle || (a4("marker.angle"), o4.noAngleRef || a4("marker.angleref"), o4.noStandOff || a4("marker.standoff")), a4("marker.color", n4), Ide(t3, "marker") && Rde(t3, r4, i3, a4, { prefix: "marker.", cLetter: "c" }), o4.noSelect || (a4("selected.marker.color"), a4("unselected.marker.color"), a4("selected.marker.size"), a4("unselected.marker.size")), o4.noLine || (l3 && !Array.isArray(l3) && r4.marker.color !== l3 ? u4 = l3 : s3 ? u4 = Pde.background : u4 = Pde.defaultLine, a4("marker.line.color", u4), Ide(t3, "marker.line") && Rde(t3, r4, i3, a4, { prefix: "marker.line.", cLetter: "c" }), a4("marker.line.width", s3 ? 1 : 0)), s3 && (a4("marker.sizeref"), a4("marker.sizemin"), a4("marker.sizemode")), o4.gradient) {\n                var c5 = a4("marker.gradient.type");\n                c5 !== "none" && a4("marker.gradient.color");\n              }\n            };\n          });\n          var R0 = ye((Gor, Fde) => {\n            "use strict";\n            var Bvt = Dr().isArrayOrTypedArray, Nvt = pv().hasColorscale, Uvt = Qh();\n            Fde.exports = function(t3, r4, n4, i3, a4, o4) {\n              o4 || (o4 = {});\n              var s3 = (t3.marker || {}).color;\n              if (s3 && s3._inputArray && (s3 = s3._inputArray), a4("line.color", n4), Nvt(t3, "line")) Uvt(t3, r4, i3, a4, { prefix: "line.", cLetter: "c" });\n              else {\n                var l3 = (Bvt(s3) ? false : s3) || n4;\n                a4("line.color", l3);\n              }\n              a4("line.width"), o4.noDash || a4("line.dash"), o4.backoff && a4("line.backoff");\n            };\n          });\n          var tT = ye((Hor, zde) => {\n            "use strict";\n            zde.exports = function(t3, r4, n4) {\n              var i3 = n4("line.shape");\n              i3 === "spline" && n4("line.smoothing");\n            };\n          });\n          var D0 = ye((jor, Ode) => {\n            "use strict";\n            var Vvt = Dr();\n            Ode.exports = function(e3, t3, r4, n4, i3) {\n              i3 = i3 || {}, n4("textposition"), Vvt.coerceFont(n4, "textfont", i3.font || r4.font, i3), i3.noSelect || (n4("selected.textfont.color"), n4("unselected.textfont.color"));\n            };\n          });\n          var Rg = ye((Wor, Bde) => {\n            "use strict";\n            var JP = ka(), qde = Dr().isArrayOrTypedArray;\n            function Gvt(e3) {\n              for (var t3 = JP.interpolate(e3[0][1], e3[1][1], 0.5), r4 = 2; r4 < e3.length; r4++) {\n                var n4 = JP.interpolate(e3[r4 - 1][1], e3[r4][1], 0.5);\n                t3 = JP.interpolate(t3, n4, e3[r4 - 1][0] / e3[r4][0]);\n              }\n              return t3;\n            }\n            Bde.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = false;\n              if (r4.marker) {\n                var s3 = r4.marker.color, l3 = (r4.marker.line || {}).color;\n                s3 && !qde(s3) ? o4 = s3 : l3 && !qde(l3) && (o4 = l3);\n              }\n              var u4;\n              if (a4.moduleHasFillgradient) {\n                var c5 = i3("fillgradient.type");\n                if (c5 !== "none") {\n                  i3("fillgradient.start"), i3("fillgradient.stop");\n                  var f4 = i3("fillgradient.colorscale");\n                  f4 && (u4 = Gvt(f4));\n                }\n              }\n              i3("fillcolor", JP.addOpacity((r4.line || {}).color || o4 || u4 || n4, 0.5));\n            };\n          });\n          var Gde = ye((Xor, Vde) => {\n            "use strict";\n            var Nde = Dr(), Hvt = qa(), jvt = pf(), Wvt = Sm(), rT = Ru(), Xvt = eT(), Zvt = Ig(), Yvt = Lde(), Kvt = $p(), Jvt = R0(), Ude = tT(), $vt = D0(), Qvt = Rg(), ept = Dr().coercePattern;\n            Vde.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return Nde.coerce(t3, r4, jvt, d3, v3);\n              }\n              var o4 = Xvt(t3, r4, i3, a4);\n              if (o4 || (r4.visible = false), !!r4.visible) {\n                Zvt(t3, r4, i3, a4), a4("xhoverformat"), a4("yhoverformat"), a4("zorder");\n                var s3 = Yvt(t3, r4, i3, a4);\n                i3.scattermode === "group" && r4.orientation === void 0 && a4("orientation", "v");\n                var l3 = !s3 && o4 < Wvt.PTS_LINESONLY ? "lines+markers" : "lines";\n                a4("text"), a4("hovertext"), a4("mode", l3), rT.hasMarkers(r4) && Kvt(t3, r4, n4, i3, a4, { gradient: true }), rT.hasLines(r4) && (Jvt(t3, r4, n4, i3, a4, { backoff: true }), Ude(t3, r4, a4), a4("connectgaps"), a4("line.simplify")), rT.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), $vt(t3, r4, i3, a4));\n                var u4 = [];\n                (rT.hasMarkers(r4) || rT.hasText(r4)) && (a4("cliponaxis"), a4("marker.maxdisplayed"), u4.push("points")), a4("fill", s3 ? s3.fillDflt : "none"), r4.fill !== "none" && (Qvt(t3, r4, n4, a4, { moduleHasFillgradient: true }), rT.hasLines(r4) || Ude(t3, r4, a4), ept(a4, "fillpattern", r4.fillcolor, false));\n                var c5 = (r4.line || {}).color, f4 = (r4.marker || {}).color;\n                (r4.fill === "tonext" || r4.fill === "toself") && u4.push("fills"), a4("hoveron", u4.join("+") || "points"), r4.hoveron !== "fills" && (a4("hovertemplate"), a4("hovertemplatefallback"));\n                var h3 = Hvt.getComponentMethod("errorbars", "supplyDefaults");\n                h3(t3, r4, c5 || f4 || n4, { axis: "y" }), h3(t3, r4, c5 || f4 || n4, { axis: "x", inherit: "y" }), Nde.coerceSelectionMarkerOpacity(r4, a4);\n              }\n            };\n          });\n          var Hb = ye((Zor, Hde) => {\n            "use strict";\n            var tpt = Nb().getAxisGroup;\n            Hde.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = r4.orientation, s3 = r4[{ v: "x", h: "y" }[o4] + "axis"], l3 = tpt(n4, s3) + o4, u4 = n4._alignmentOpts || {}, c5 = i3("alignmentgroup"), f4 = u4[l3];\n              f4 || (f4 = u4[l3] = {});\n              var h3 = f4[c5];\n              h3 ? h3.traces.push(r4) : h3 = f4[c5] = { traces: [r4], alignmentIndex: Object.keys(f4).length, offsetGroups: {} };\n              var d3 = i3("offsetgroup") || "", v3 = h3.offsetGroups, _2 = v3[d3];\n              r4._offsetIndex = 0, (a4 !== "group" || d3) && (_2 || (_2 = v3[d3] = { offsetIndex: Object.keys(v3).length }), r4._offsetIndex = _2.offsetIndex);\n            };\n          });\n          var aU = ye((Yor, jde) => {\n            "use strict";\n            var rpt = Dr(), ipt = Hb(), npt = pf();\n            jde.exports = function(t3, r4) {\n              var n4, i3, a4, o4 = r4.scattermode;\n              function s3(h3) {\n                return rpt.coerce(i3._input, i3, npt, h3);\n              }\n              if (r4.scattermode === "group") for (a4 = 0; a4 < t3.length; a4++) i3 = t3[a4], i3.type === "scatter" && (n4 = i3._input, ipt(n4, i3, r4, s3, o4));\n              for (a4 = 0; a4 < t3.length; a4++) {\n                var l3 = t3[a4];\n                if (l3.type === "scatter") {\n                  var u4 = l3.fill;\n                  if (!(u4 === "none" || u4 === "toself") && (l3.opacity = void 0, u4 === "tonexty" || u4 === "tonextx")) for (var c5 = a4 - 1; c5 >= 0; c5--) {\n                    var f4 = t3[c5];\n                    if (f4.type === "scatter" && f4.xaxis === l3.xaxis && f4.yaxis === l3.yaxis) {\n                      f4.opacity = void 0;\n                      break;\n                    }\n                  }\n                }\n              }\n            };\n          });\n          var Xde = ye((Kor, Wde) => {\n            "use strict";\n            var apt = Dr(), opt = X6();\n            Wde.exports = function(e3, t3) {\n              function r4(i3, a4) {\n                return apt.coerce(e3, t3, opt, i3, a4);\n              }\n              var n4 = t3.barmode === "group";\n              t3.scattermode === "group" && r4("scattergap", n4 ? t3.bargap : 0.2);\n            };\n          });\n          var Dg = ye((Jor, Yde) => {\n            "use strict";\n            var spt = Eo(), Zde = Dr(), lpt = Zde.dateTime2ms, $P = Zde.incrementMonth, upt = fs(), cpt = upt.ONEAVGMONTH;\n            Yde.exports = function(t3, r4, n4, i3) {\n              if (r4.type !== "date") return { vals: i3 };\n              var a4 = t3[n4 + "periodalignment"];\n              if (!a4) return { vals: i3 };\n              var o4 = t3[n4 + "period"], s3;\n              if (spt(o4)) {\n                if (o4 = +o4, o4 <= 0) return { vals: i3 };\n              } else if (typeof o4 == "string" && o4.charAt(0) === "M") {\n                var l3 = +o4.substring(1);\n                if (l3 > 0 && Math.round(l3) === l3) s3 = l3;\n                else return { vals: i3 };\n              }\n              for (var u4 = r4.calendar, c5 = a4 === "start", f4 = a4 === "end", h3 = t3[n4 + "period0"], d3 = lpt(h3, u4) || 0, v3 = [], _2 = [], b = [], p3 = i3.length, k4 = 0; k4 < p3; k4++) {\n                var E3 = i3[k4], S2, L3, x2;\n                if (s3) {\n                  for (S2 = Math.round((E3 - d3) / (s3 * cpt)), x2 = $P(d3, s3 * S2, u4); x2 > E3; ) x2 = $P(x2, -s3, u4);\n                  for (; x2 <= E3; ) x2 = $P(x2, s3, u4);\n                  L3 = $P(x2, -s3, u4);\n                } else {\n                  for (S2 = Math.round((E3 - d3) / o4), x2 = d3 + S2 * o4; x2 > E3; ) x2 -= o4;\n                  for (; x2 <= E3; ) x2 += o4;\n                  L3 = x2 - o4;\n                }\n                v3[k4] = c5 ? L3 : f4 ? x2 : (L3 + x2) / 2, _2[k4] = L3, b[k4] = x2;\n              }\n              return { vals: v3, starts: _2, ends: b };\n            };\n          });\n          var F0 = ye(($or, Jde) => {\n            "use strict";\n            var oU = pv().hasColorscale, sU = gv(), Kde = Ru();\n            Jde.exports = function(t3, r4) {\n              Kde.hasLines(r4) && oU(r4, "line") && sU(t3, r4, { vals: r4.line.color, containerStr: "line", cLetter: "c" }), Kde.hasMarkers(r4) && (oU(r4, "marker") && sU(t3, r4, { vals: r4.marker.color, containerStr: "marker", cLetter: "c" }), oU(r4, "marker.line") && sU(t3, r4, { vals: r4.marker.line.color, containerStr: "marker.line", cLetter: "c" }));\n            };\n          });\n          var km = ye((Qor, $de) => {\n            "use strict";\n            var Yf = Dr();\n            $de.exports = function(t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4++) t3[n4].i = n4;\n              Yf.mergeArray(r4.text, t3, "tx"), Yf.mergeArray(r4.texttemplate, t3, "txt"), Yf.mergeArray(r4.hovertext, t3, "htx"), Yf.mergeArray(r4.customdata, t3, "data"), Yf.mergeArray(r4.textposition, t3, "tp"), r4.textfont && (Yf.mergeArrayCastPositive(r4.textfont.size, t3, "ts"), Yf.mergeArray(r4.textfont.color, t3, "tc"), Yf.mergeArray(r4.textfont.family, t3, "tf"), Yf.mergeArray(r4.textfont.weight, t3, "tw"), Yf.mergeArray(r4.textfont.style, t3, "ty"), Yf.mergeArray(r4.textfont.variant, t3, "tv"), Yf.mergeArray(r4.textfont.textcase, t3, "tC"), Yf.mergeArray(r4.textfont.lineposition, t3, "tE"), Yf.mergeArray(r4.textfont.shadow, t3, "tS"));\n              var i3 = r4.marker;\n              if (i3) {\n                Yf.mergeArrayCastPositive(i3.size, t3, "ms"), Yf.mergeArrayCastPositive(i3.opacity, t3, "mo"), Yf.mergeArray(i3.symbol, t3, "mx"), Yf.mergeArray(i3.angle, t3, "ma"), Yf.mergeArray(i3.standoff, t3, "mf"), Yf.mergeArray(i3.color, t3, "mc");\n                var a4 = i3.line;\n                i3.line && (Yf.mergeArray(a4.color, t3, "mlc"), Yf.mergeArrayCastPositive(a4.width, t3, "mlw"));\n                var o4 = i3.gradient;\n                o4 && o4.type !== "none" && (Yf.mergeArray(o4.type, t3, "mgt"), Yf.mergeArray(o4.color, t3, "mgc"));\n              }\n            };\n          });\n          var z0 = ye((esr, eve) => {\n            "use strict";\n            var Qde = Dr();\n            eve.exports = function(t3, r4) {\n              Qde.isArrayOrTypedArray(r4.selectedpoints) && Qde.tagSelected(t3, r4);\n            };\n          });\n          var O0 = ye((tsr, sve) => {\n            "use strict";\n            var tve = Eo(), uU = Dr(), KM = ho(), rve = Dg(), lU = fs().BADNUM, cU = Ru(), fpt = F0(), hpt = km(), dpt = z0();\n            function vpt(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3._xA = KM.getFromId(e3, t3.xaxis || "x", "x"), i3 = t3._yA = KM.getFromId(e3, t3.yaxis || "y", "y"), a4 = n4.makeCalcdata(t3, "x"), o4 = i3.makeCalcdata(t3, "y"), s3 = rve(t3, n4, "x", a4), l3 = rve(t3, i3, "y", o4), u4 = s3.vals, c5 = l3.vals, f4 = t3._length, h3 = new Array(f4), d3 = t3.ids, v3 = fU(t3, r4, n4, i3), _2 = false, b, p3, k4, E3, S2, L3;\n              ave(r4, t3);\n              var x2 = "x", C3 = "y", M4;\n              if (v3) uU.pushUnique(v3.traceIndices, t3.index), b = v3.orientation === "v", b ? (C3 = "s", M4 = "x") : (x2 = "s", M4 = "y"), S2 = v3.stackgaps === "interpolate";\n              else {\n                var g3 = nve(t3, f4);\n                ive(e3, t3, n4, i3, u4, c5, g3);\n              }\n              var P3 = !!t3.xperiodalignment, T3 = !!t3.yperiodalignment;\n              for (p3 = 0; p3 < f4; p3++) {\n                var z3 = h3[p3] = {}, O3 = tve(u4[p3]), V2 = tve(c5[p3]);\n                O3 && V2 ? (z3[x2] = u4[p3], z3[C3] = c5[p3], P3 && (z3.orig_x = a4[p3], z3.xEnd = s3.ends[p3], z3.xStart = s3.starts[p3]), T3 && (z3.orig_y = o4[p3], z3.yEnd = l3.ends[p3], z3.yStart = l3.starts[p3])) : v3 && (b ? O3 : V2) ? (z3[M4] = b ? u4[p3] : c5[p3], z3.gap = true, S2 ? (z3.s = lU, _2 = true) : z3.s = 0) : z3[x2] = z3[C3] = lU, d3 && (z3.id = String(d3[p3]));\n              }\n              if (hpt(h3, t3), fpt(e3, t3), dpt(h3, t3), v3) {\n                for (p3 = 0; p3 < h3.length; ) h3[p3][M4] === lU ? h3.splice(p3, 1) : p3++;\n                if (uU.sort(h3, function(N2, H) {\n                  return N2[M4] - H[M4] || N2.i - H.i;\n                }), _2) {\n                  for (p3 = 0; p3 < h3.length - 1 && h3[p3].gap; ) p3++;\n                  for (L3 = h3[p3].s, L3 || (L3 = h3[p3].s = 0), k4 = 0; k4 < p3; k4++) h3[k4].s = L3;\n                  for (E3 = h3.length - 1; E3 > p3 && h3[E3].gap; ) E3--;\n                  for (L3 = h3[E3].s, k4 = h3.length - 1; k4 > E3; k4--) h3[k4].s = L3;\n                  for (; p3 < E3; ) if (p3++, h3[p3].gap) {\n                    for (k4 = p3 + 1; h3[k4].gap; ) k4++;\n                    for (var G2 = h3[p3 - 1][M4], Z = h3[p3 - 1].s, j3 = (h3[k4].s - Z) / (h3[k4][M4] - G2); p3 < k4; ) h3[p3].s = Z + (h3[p3][M4] - G2) * j3, p3++;\n                  }\n                }\n              }\n              return h3;\n            }\n            function ive(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = t3._length, l3 = e3._fullLayout, u4 = r4._id, c5 = n4._id, f4 = l3._firstScatter[ove(t3)] === t3.uid, h3 = (fU(t3, l3, r4, n4) || {}).orientation, d3 = t3.fill;\n              r4._minDtick = 0, n4._minDtick = 0;\n              var v3 = { padded: true }, _2 = { padded: true };\n              o4 && (v3.ppad = _2.ppad = o4);\n              var b = s3 < 2 || i3[0] !== i3[s3 - 1] || a4[0] !== a4[s3 - 1];\n              b && (d3 === "tozerox" || d3 === "tonextx" && (f4 || h3 === "h")) ? v3.tozero = true : !(t3.error_y || {}).visible && (d3 === "tonexty" || d3 === "tozeroy" || !cU.hasMarkers(t3) && !cU.hasText(t3)) && (v3.padded = false, v3.ppad = 0), b && (d3 === "tozeroy" || d3 === "tonexty" && (f4 || h3 === "v")) ? _2.tozero = true : (d3 === "tonextx" || d3 === "tozerox") && (_2.padded = false), u4 && (t3._extremes[u4] = KM.findExtremes(r4, i3, v3)), c5 && (t3._extremes[c5] = KM.findExtremes(n4, a4, _2));\n            }\n            function nve(e3, t3) {\n              if (cU.hasMarkers(e3)) {\n                var r4 = e3.marker, n4 = 1.6 * (e3.marker.sizeref || 1), i3;\n                if (e3.marker.sizemode === "area" ? i3 = function(u4) {\n                  return Math.max(Math.sqrt((u4 || 0) / n4), 3);\n                } : i3 = function(u4) {\n                  return Math.max((u4 || 0) / n4, 3);\n                }, uU.isArrayOrTypedArray(r4.size)) {\n                  var a4 = { type: "linear" };\n                  KM.setConvert(a4);\n                  for (var o4 = a4.makeCalcdata(e3.marker, "size"), s3 = new Array(t3), l3 = 0; l3 < t3; l3++) s3[l3] = i3(o4[l3]);\n                  return s3;\n                } else return i3(r4.size);\n              }\n            }\n            function ave(e3, t3) {\n              var r4 = ove(t3), n4 = e3._firstScatter;\n              n4[r4] || (n4[r4] = t3.uid);\n            }\n            function ove(e3) {\n              var t3 = e3.stackgroup;\n              return e3.xaxis + e3.yaxis + e3.type + (t3 ? "-" + t3 : "");\n            }\n            function fU(e3, t3, r4, n4) {\n              var i3 = e3.stackgroup;\n              if (i3) {\n                var a4 = t3._scatterStackOpts[r4._id + n4._id][i3], o4 = a4.orientation === "v" ? n4 : r4;\n                if (o4.type === "linear" || o4.type === "log") return a4;\n              }\n            }\n            sve.exports = { calc: vpt, calcMarkerSize: nve, calcAxisExpansion: ive, setFirstScatter: ave, getStackOpts: fU };\n          });\n          var uve = ye((rsr, lve) => {\n            "use strict";\n            lve.exports = QP;\n            var ppt = Dr().distinctVals;\n            function QP(e3, t3) {\n              this.traces = e3, this.sepNegVal = t3.sepNegVal, this.overlapNoMerge = t3.overlapNoMerge;\n              for (var r4 = 1 / 0, n4 = t3.posAxis._id.charAt(0), i3 = [], a4 = 0; a4 < e3.length; a4++) {\n                for (var o4 = e3[a4], s3 = 0; s3 < o4.length; s3++) {\n                  var l3 = o4[s3], u4 = l3.p;\n                  u4 === void 0 && (u4 = l3[n4]), u4 !== void 0 && i3.push(u4);\n                }\n                o4[0] && o4[0].width1 && (r4 = Math.min(o4[0].width1, r4));\n              }\n              this.positions = i3;\n              var c5 = ppt(i3);\n              this.distinctPositions = c5.vals, c5.vals.length === 1 && r4 !== 1 / 0 ? this.minDiff = r4 : this.minDiff = Math.min(c5.minDiff, r4);\n              var f4 = (t3.posAxis || {}).type;\n              (f4 === "category" || f4 === "multicategory") && (this.minDiff = 1), this.binWidth = this.minDiff, this.bins = {};\n            }\n            QP.prototype.put = function(t3, r4, n4) {\n              var i3 = this.getLabel(t3, r4, n4), a4 = this.bins[i3] || 0;\n              return this.bins[i3] = a4 + n4, a4;\n            };\n            QP.prototype.get = function(t3, r4, n4) {\n              var i3 = this.getLabel(t3, r4, n4);\n              return this.bins[i3] || 0;\n            };\n            QP.prototype.getLabel = function(t3, r4, n4) {\n              var i3 = n4 < 0 && this.sepNegVal ? "v" : "^", a4 = this.overlapNoMerge ? t3 : Math.round(t3 / this.binWidth);\n              return i3 + a4 + "g" + r4;\n            };\n          });\n          var jb = ye((isr, dve) => {\n            "use strict";\n            var q0 = Eo(), p_ = Dr().isArrayOrTypedArray, iT = fs().BADNUM, gpt = qa(), JM = ho(), mpt = Nb().getAxisGroup, eI = uve();\n            function ypt(e3, t3) {\n              for (var r4 = t3.xaxis, n4 = t3.yaxis, i3 = e3._fullLayout, a4 = e3._fullData, o4 = e3.calcdata, s3 = [], l3 = [], u4 = 0; u4 < a4.length; u4++) {\n                var c5 = a4[u4];\n                if (c5.visible === true && gpt.traceIs(c5, "bar") && c5.xaxis === r4._id && c5.yaxis === n4._id && (c5.orientation === "h" ? s3.push(o4[u4]) : l3.push(o4[u4]), c5._computePh)) for (var f4 = e3.calcdata[u4], h3 = 0; h3 < f4.length; h3++) typeof f4[h3].ph0 == "function" && (f4[h3].ph0 = f4[h3].ph0()), typeof f4[h3].ph1 == "function" && (f4[h3].ph1 = f4[h3].ph1());\n              }\n              var d3 = { xCat: r4.type === "category" || r4.type === "multicategory", yCat: n4.type === "category" || n4.type === "multicategory", mode: i3.barmode, norm: i3.barnorm, gap: i3.bargap, groupgap: i3.bargroupgap };\n              dU(e3, r4, n4, l3, d3), dU(e3, n4, r4, s3, d3);\n            }\n            function dU(e3, t3, r4, n4, i3) {\n              if (n4.length) {\n                var a4, o4, s3, l3, u4;\n                switch (bpt(r4, n4), i3.mode) {\n                  case "overlay":\n                    hU(e3, t3, r4, n4, i3);\n                    break;\n                  case "group":\n                    for (a4 = [], o4 = [], s3 = 0; s3 < n4.length; s3++) l3 = n4[s3], u4 = l3[0].trace, u4.offset === void 0 ? o4.push(l3) : a4.push(l3);\n                    o4.length && wpt(e3, t3, r4, o4, i3), a4.length && hU(e3, t3, r4, a4, i3);\n                    break;\n                  case "stack":\n                  case "relative":\n                    for (a4 = [], o4 = [], s3 = 0; s3 < n4.length; s3++) l3 = n4[s3], u4 = l3[0].trace, u4.base === void 0 ? o4.push(l3) : a4.push(l3);\n                    xpt(o4), o4.length && Tpt(e3, t3, r4, o4, i3), a4.length && hU(e3, t3, r4, a4, i3);\n                    break;\n                }\n                _pt(n4), Cpt(n4, t3);\n              }\n            }\n            function _pt(e3) {\n              var t3, r4, n4, i3, a4, o4, s3;\n              for (t3 = 0; t3 < e3.length; t3++) r4 = e3[t3], n4 = r4[0].trace, i3 = r4[0].t, i3.cornerradiusvalue === void 0 && (a4 = n4.marker ? n4.marker.cornerradius : void 0, a4 !== void 0 && (o4 = q0(a4) ? +a4 : +a4.slice(0, -1), s3 = q0(a4) ? "px" : "%", i3.cornerradiusvalue = o4, i3.cornerradiusform = s3));\n            }\n            function xpt(e3) {\n              if (!(e3.length < 2)) {\n                var t3, r4, n4, i3, a4, o4, s3;\n                for (t3 = 0; t3 < e3.length && (r4 = e3[t3], n4 = r4[0].trace, a4 = n4.marker ? n4.marker.cornerradius : void 0, a4 === void 0); t3++) ;\n                if (a4 !== void 0) for (o4 = q0(a4) ? +a4 : +a4.slice(0, -1), s3 = q0(a4) ? "px" : "%", t3 = 0; t3 < e3.length; t3++) r4 = e3[t3], i3 = r4[0].t, i3.cornerradiusvalue = o4, i3.cornerradiusform = s3;\n              }\n            }\n            function bpt(e3, t3) {\n              var r4, n4;\n              for (r4 = 0; r4 < t3.length; r4++) {\n                var i3 = t3[r4], a4 = i3[0].trace, o4 = a4.type === "funnel" ? a4._base : a4.base, s3, l3 = a4.orientation === "h" ? a4.xcalendar : a4.ycalendar, u4 = e3.type === "category" || e3.type === "multicategory" ? function() {\n                  return null;\n                } : e3.d2c;\n                if (p_(o4)) {\n                  for (n4 = 0; n4 < Math.min(o4.length, i3.length); n4++) s3 = u4(o4[n4], 0, l3), q0(s3) ? (i3[n4].b = +s3, i3[n4].hasB = 1) : i3[n4].b = 0;\n                  for (; n4 < i3.length; n4++) i3[n4].b = 0;\n                } else {\n                  s3 = u4(o4, 0, l3);\n                  var c5 = q0(s3);\n                  for (s3 = c5 ? s3 : 0, n4 = 0; n4 < i3.length; n4++) i3[n4].b = s3, c5 && (i3[n4].hasB = 1);\n                }\n              }\n            }\n            function hU(e3, t3, r4, n4, i3) {\n              for (var a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = new eI([o4], { posAxis: t3, sepNegVal: false, overlapNoMerge: !i3.norm });\n                vU(e3, t3, s3, i3), i3.norm ? (hve(s3), pU(r4, s3, i3)) : fve(r4, s3);\n              }\n            }\n            function wpt(e3, t3, r4, n4, i3) {\n              var a4 = new eI(n4, { posAxis: t3, sepNegVal: false, overlapNoMerge: !i3.norm });\n              vU(e3, t3, a4, i3), Ept(a4, t3), i3.norm ? (hve(a4), pU(r4, a4, i3)) : fve(r4, a4);\n            }\n            function Tpt(e3, t3, r4, n4, i3) {\n              var a4 = new eI(n4, { posAxis: t3, sepNegVal: i3.mode === "relative", overlapNoMerge: !(i3.norm || i3.mode === "stack" || i3.mode === "relative") });\n              vU(e3, t3, a4, i3), Mpt(r4, a4, i3);\n              for (var o4 = 0; o4 < n4.length; o4++) for (var s3 = n4[o4], l3 = s3[0].t.offsetindex, u4 = 0; u4 < s3.length; u4++) {\n                var c5 = s3[u4];\n                if (c5.s !== iT) {\n                  var f4 = c5.b + c5.s === a4.get(c5.p, l3, c5.s);\n                  f4 && (c5._outmost = true);\n                }\n              }\n              i3.norm && pU(r4, a4, i3);\n            }\n            function vU(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = r4.positions, o4 = r4.distinctPositions, s3 = r4.minDiff, l3 = r4.traces, u4 = l3.length, c5 = a4.length !== o4.length, f4 = s3 * (1 - n4.gap), h3, d3, v3, _2;\n              if (t3._id === "angularaxis") h3 = f4, d3 = h3 * (1 - (n4.groupgap || 0)), v3 = -d3 / 2;\n              else {\n                var b = mpt(i3, t3._id) + l3[0][0].trace.orientation;\n                _2 = i3._alignmentOpts[b] || {};\n              }\n              for (var p3 = 0; p3 < u4; p3++) {\n                var k4 = l3[p3], E3 = k4[0].trace;\n                if (t3._id !== "angularaxis") {\n                  var S2 = _2[E3.alignmentgroup] || {}, L3 = Object.keys(S2.offsetGroups || {}).length;\n                  L3 ? h3 = f4 / L3 : h3 = c5 ? f4 / u4 : f4, d3 = h3 * (1 - (n4.groupgap || 0)), L3 ? v3 = ((2 * E3._offsetIndex + 1 - L3) * h3 - d3) / 2 : v3 = c5 ? ((2 * p3 + 1 - u4) * h3 - d3) / 2 : -d3 / 2;\n                }\n                var x2 = k4[0].t;\n                x2.barwidth = d3, x2.offsetindex = E3._offsetIndex || 0, x2.poffset = v3, x2.bargroupwidth = f4, x2.bardelta = s3;\n              }\n              r4.binWidth = l3[0][0].t.barwidth / 100, Apt(r4), Spt(t3, r4), t3._id === "angularaxis" ? cve(t3, r4) : cve(t3, r4, c5);\n            }\n            function Apt(e3) {\n              var t3 = e3.traces, r4, n4;\n              for (r4 = 0; r4 < t3.length; r4++) {\n                var i3 = t3[r4], a4 = i3[0], o4 = a4.trace, s3 = a4.t, l3 = o4._offset || o4.offset, u4 = s3.poffset, c5;\n                if (p_(l3)) {\n                  for (c5 = Array.prototype.slice.call(l3, 0, i3.length), n4 = 0; n4 < c5.length; n4++) q0(c5[n4]) || (c5[n4] = u4);\n                  for (n4 = c5.length; n4 < i3.length; n4++) c5.push(u4);\n                  s3.poffset = c5;\n                } else l3 !== void 0 && (s3.poffset = l3);\n                var f4 = o4._width || o4.width, h3 = s3.barwidth;\n                if (p_(f4)) {\n                  var d3 = Array.prototype.slice.call(f4, 0, i3.length);\n                  for (n4 = 0; n4 < d3.length; n4++) q0(d3[n4]) || (d3[n4] = h3);\n                  for (n4 = d3.length; n4 < i3.length; n4++) d3.push(h3);\n                  if (s3.barwidth = d3, l3 === void 0) {\n                    for (c5 = [], n4 = 0; n4 < i3.length; n4++) c5.push(u4 + (h3 - d3[n4]) / 2);\n                    s3.poffset = c5;\n                  }\n                } else f4 !== void 0 && (s3.barwidth = f4, l3 === void 0 && (s3.poffset = u4 + (h3 - f4) / 2));\n              }\n            }\n            function Spt(e3, t3) {\n              for (var r4 = t3.traces, n4 = nT(e3), i3 = 0; i3 < r4.length; i3++) for (var a4 = r4[i3], o4 = a4[0].t, s3 = o4.poffset, l3 = p_(s3), u4 = o4.barwidth, c5 = p_(u4), f4 = 0; f4 < a4.length; f4++) {\n                var h3 = a4[f4], d3 = h3.w = c5 ? u4[f4] : u4;\n                h3.p === void 0 && (h3.p = h3[n4], h3["orig_" + n4] = h3[n4]);\n                var v3 = (l3 ? s3[f4] : s3) + d3 / 2;\n                h3[n4] = h3.p + v3;\n              }\n            }\n            function cve(e3, t3, r4) {\n              var n4 = t3.traces, i3 = t3.minDiff, a4 = i3 / 2;\n              JM.minDtick(e3, t3.minDiff, t3.distinctPositions[0], r4);\n              for (var o4 = 0; o4 < n4.length; o4++) {\n                var s3 = n4[o4], l3 = s3[0], u4 = l3.trace, c5 = [], f4, h3, d3, v3;\n                for (v3 = 0; v3 < s3.length; v3++) f4 = s3[v3], h3 = f4.p - a4, d3 = f4.p + a4, c5.push(h3, d3);\n                if (u4.width || u4.offset) {\n                  var _2 = l3.t, b = _2.poffset, p3 = _2.barwidth, k4 = p_(b), E3 = p_(p3);\n                  for (v3 = 0; v3 < s3.length; v3++) {\n                    f4 = s3[v3];\n                    var S2 = k4 ? b[v3] : b, L3 = E3 ? p3[v3] : p3;\n                    h3 = f4.p + S2, d3 = h3 + L3, c5.push(h3, d3);\n                  }\n                }\n                u4._extremes[e3._id] = JM.findExtremes(e3, c5, { padded: false });\n              }\n            }\n            function fve(e3, t3) {\n              for (var r4 = t3.traces, n4 = nT(e3), i3 = 0; i3 < r4.length; i3++) {\n                for (var a4 = r4[i3], o4 = a4[0].trace, s3 = o4.type === "scatter", l3 = o4.orientation === "v", u4 = [], c5 = false, f4 = 0; f4 < a4.length; f4++) {\n                  var h3 = a4[f4], d3 = s3 ? 0 : h3.b, v3 = s3 ? l3 ? h3.y : h3.x : d3 + h3.s;\n                  h3[n4] = v3, u4.push(v3), h3.hasB && u4.push(d3), (!h3.hasB || !h3.b) && (c5 = true);\n                }\n                o4._extremes[e3._id] = JM.findExtremes(e3, u4, { tozero: c5, padded: true });\n              }\n            }\n            function Mpt(e3, t3, r4) {\n              var n4 = nT(e3), i3 = t3.traces, a4, o4, s3, l3, u4, c5, f4;\n              for (l3 = 0; l3 < i3.length; l3++) if (a4 = i3[l3], o4 = a4[0].trace, o4.type === "funnel") for (f4 = a4[0].t.offsetindex, u4 = 0; u4 < a4.length; u4++) c5 = a4[u4], c5.s !== iT && t3.put(c5.p, f4, -0.5 * c5.s);\n              for (l3 = 0; l3 < i3.length; l3++) {\n                a4 = i3[l3], o4 = a4[0].trace, s3 = o4.type === "funnel", f4 = o4.type === "barpolar" ? 0 : a4[0].t.offsetindex;\n                var h3 = [];\n                for (u4 = 0; u4 < a4.length; u4++) if (c5 = a4[u4], c5.s !== iT) {\n                  var d3;\n                  s3 ? d3 = c5.s : d3 = c5.s + c5.b;\n                  var v3 = t3.put(c5.p, f4, d3), _2 = v3 + d3;\n                  c5.b = v3, c5[n4] = _2, r4.norm || (h3.push(_2), c5.hasB && h3.push(v3));\n                }\n                r4.norm || (o4._extremes[e3._id] = JM.findExtremes(e3, h3, { tozero: true, padded: true }));\n              }\n            }\n            function hve(e3) {\n              for (var t3 = e3.traces, r4 = 0; r4 < t3.length; r4++) for (var n4 = t3[r4], i3 = n4[0].t.offsetindex, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4];\n                o4.s !== iT && e3.put(o4.p, i3, o4.b + o4.s);\n              }\n            }\n            function Ept(e3, t3) {\n              for (var r4 = e3.traces, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3[0].trace, o4 = i3[0].t.offsetindex;\n                if (a4.base === void 0) for (var s3 = new eI([i3], { posAxis: t3, sepNegVal: true, overlapNoMerge: true }), l3 = 0; l3 < i3.length; l3++) {\n                  var u4 = i3[l3];\n                  if (u4.p !== iT) {\n                    var c5 = s3.put(u4.p, o4, u4.b + u4.s);\n                    c5 && (u4.b = c5);\n                  }\n                }\n              }\n            }\n            function pU(e3, t3, r4) {\n              var n4 = t3.traces, i3 = nT(e3), a4 = r4.norm === "fraction" ? 1 : 100, o4 = a4 / 1e9, s3 = e3.l2c(e3.c2l(0)), l3 = r4.mode === "stack" ? a4 : s3;\n              function u4(x2) {\n                return q0(e3.c2l(x2)) && (x2 < s3 - o4 || x2 > l3 + o4 || !q0(s3));\n              }\n              for (var c5 = 0; c5 < n4.length; c5++) {\n                for (var f4 = n4[c5], h3 = f4[0].t.offsetindex, d3 = f4[0].trace, v3 = [], _2 = false, b = false, p3 = 0; p3 < f4.length; p3++) {\n                  var k4 = f4[p3];\n                  if (k4.s !== iT) {\n                    var E3 = Math.abs(a4 / t3.get(k4.p, h3, k4.s));\n                    k4.b *= E3, k4.s *= E3;\n                    var S2 = k4.b, L3 = S2 + k4.s;\n                    k4[i3] = L3, v3.push(L3), b = b || u4(L3), k4.hasB && (v3.push(S2), b = b || u4(S2)), (!k4.hasB || !k4.b) && (_2 = true);\n                  }\n                }\n                d3._extremes[e3._id] = JM.findExtremes(e3, v3, { tozero: _2, padded: b });\n              }\n            }\n            function kpt(e3, t3, r4, n4) {\n              for (var i3 = nT(n4), a4 = 0; a4 < e3.length; a4++) for (var o4 = e3[a4], s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3], u4 = l3[i3];\n                l3._sMin = t3[u4], l3._sMax = r4[u4];\n              }\n            }\n            function Cpt(e3, t3) {\n              var r4 = nT(t3), n4 = {}, i3, a4, o4, s3 = 1 / 0, l3 = -1 / 0;\n              for (i3 = 0; i3 < e3.length; i3++) for (o4 = e3[i3], a4 = 0; a4 < o4.length; a4++) {\n                var u4 = o4[a4].p;\n                q0(u4) && (s3 = Math.min(s3, u4), l3 = Math.max(l3, u4));\n              }\n              var c5 = 1e4 / (l3 - s3), f4 = n4.round = function(M4) {\n                return String(Math.round(c5 * (M4 - s3)));\n              }, h3 = {}, d3 = {}, v3 = e3.some(function(M4) {\n                var g3 = M4[0].trace;\n                return "marker" in g3 && g3.marker.cornerradius;\n              });\n              for (i3 = 0; i3 < e3.length; i3++) {\n                o4 = e3[i3], o4[0].t.extents = n4;\n                var _2 = o4[0].t.poffset, b = p_(_2);\n                for (a4 = 0; a4 < o4.length; a4++) {\n                  var p3 = o4[a4], k4 = p3[r4] - p3.w / 2;\n                  if (q0(k4)) {\n                    var E3 = p3[r4] + p3.w / 2, S2 = f4(p3.p);\n                    n4[S2] ? n4[S2] = [Math.min(k4, n4[S2][0]), Math.max(E3, n4[S2][1])] : n4[S2] = [k4, E3];\n                  }\n                  if (p3.p0 = p3.p + (b ? _2[a4] : _2), p3.p1 = p3.p0 + p3.w, p3.s0 = p3.b, p3.s1 = p3.s0 + p3.s, v3) {\n                    var L3 = Math.min(p3.s0, p3.s1) || 0, x2 = Math.max(p3.s0, p3.s1) || 0, C3 = p3[r4];\n                    h3[C3] = C3 in h3 ? Math.min(h3[C3], L3) : L3, d3[C3] = C3 in d3 ? Math.max(d3[C3], x2) : x2;\n                  }\n                }\n              }\n              v3 && kpt(e3, h3, d3, t3);\n            }\n            function nT(e3) {\n              return e3._id.charAt(0);\n            }\n            dve.exports = { crossTraceCalc: ypt, setGroupPositions: dU };\n          });\n          var mve = ye((nsr, gve) => {\n            "use strict";\n            var vve = O0(), pve = jb().setGroupPositions;\n            function Lpt(e3, t3) {\n              for (var r4 = t3.xaxis, n4 = t3.yaxis, i3 = e3._fullLayout, a4 = e3._fullData, o4 = e3.calcdata, s3 = [], l3 = [], u4 = 0; u4 < a4.length; u4++) {\n                var c5 = a4[u4];\n                c5.visible === true && c5.type === "scatter" && c5.xaxis === r4._id && c5.yaxis === n4._id && (c5.orientation === "h" ? s3.push(o4[u4]) : c5.orientation === "v" && l3.push(o4[u4]));\n              }\n              var f4 = { mode: i3.scattermode, gap: i3.scattergap };\n              pve(e3, r4, n4, l3, f4), pve(e3, n4, r4, s3, f4);\n            }\n            gve.exports = function(t3, r4) {\n              t3._fullLayout.scattermode === "group" && Lpt(t3, r4);\n              var n4 = r4.xaxis, i3 = r4.yaxis, a4 = n4._id + i3._id, o4 = t3._fullLayout._scatterStackOpts[a4];\n              if (o4) {\n                var s3 = t3.calcdata, l3, u4, c5, f4, h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2;\n                for (var C3 in o4) {\n                  p3 = o4[C3];\n                  var M4 = p3.traceIndices;\n                  if (M4.length) {\n                    for (k4 = p3.stackgaps === "interpolate", E3 = p3.groupnorm, p3.orientation === "v" ? (S2 = "x", L3 = "y") : (S2 = "y", L3 = "x"), x2 = new Array(M4.length), l3 = 0; l3 < x2.length; l3++) x2[l3] = false;\n                    d3 = s3[M4[0]];\n                    var g3 = new Array(d3.length);\n                    for (l3 = 0; l3 < d3.length; l3++) g3[l3] = d3[l3][S2];\n                    for (l3 = 1; l3 < M4.length; l3++) {\n                      for (h3 = s3[M4[l3]], u4 = c5 = 0; u4 < h3.length; u4++) {\n                        for (v3 = h3[u4][S2]; v3 > g3[c5] && c5 < g3.length; c5++) gU(h3, u4, g3[c5], l3, x2, k4, S2), u4++;\n                        if (v3 !== g3[c5]) {\n                          for (f4 = 0; f4 < l3; f4++) gU(s3[M4[f4]], c5, v3, f4, x2, k4, S2);\n                          g3.splice(c5, 0, v3);\n                        }\n                        c5++;\n                      }\n                      for (; c5 < g3.length; c5++) gU(h3, u4, g3[c5], l3, x2, k4, S2), u4++;\n                    }\n                    var P3 = g3.length;\n                    for (u4 = 0; u4 < d3.length; u4++) {\n                      for (_2 = d3[u4][L3] = d3[u4].s, l3 = 1; l3 < M4.length; l3++) h3 = s3[M4[l3]], h3[0].trace._rawLength = h3[0].trace._length, h3[0].trace._length = P3, _2 += h3[u4].s, h3[u4][L3] = _2;\n                      if (E3) for (b = (E3 === "fraction" ? _2 : _2 / 100) || 1, l3 = 0; l3 < M4.length; l3++) {\n                        var T3 = s3[M4[l3]][u4];\n                        T3[L3] /= b, T3.sNorm = T3.s / b;\n                      }\n                    }\n                    for (l3 = 0; l3 < M4.length; l3++) {\n                      h3 = s3[M4[l3]];\n                      var z3 = h3[0].trace, O3 = vve.calcMarkerSize(z3, z3._rawLength), V2 = Array.isArray(O3);\n                      if (O3 && x2[l3] || V2) {\n                        var G2 = O3;\n                        for (O3 = new Array(P3), u4 = 0; u4 < P3; u4++) O3[u4] = h3[u4].gap ? 0 : V2 ? G2[h3[u4].i] : G2;\n                      }\n                      var Z = new Array(P3), j3 = new Array(P3);\n                      for (u4 = 0; u4 < P3; u4++) Z[u4] = h3[u4].x, j3[u4] = h3[u4].y;\n                      vve.calcAxisExpansion(t3, z3, n4, i3, Z, j3, O3), h3[0].t.orientation = p3.orientation;\n                    }\n                  }\n                }\n              }\n            };\n            function gU(e3, t3, r4, n4, i3, a4, o4) {\n              i3[n4] = true;\n              var s3 = { i: null, gap: true, s: 0 };\n              if (s3[o4] = r4, e3.splice(t3, 0, s3), t3 && r4 === e3[t3 - 1][o4]) {\n                var l3 = e3[t3 - 1];\n                s3.s = l3.s, s3.i = l3.i, s3.gap = l3.gap;\n              } else a4 && (s3.s = Ppt(e3, t3, r4, o4));\n              t3 || (e3[0].t = e3[1].t, e3[0].trace = e3[1].trace, delete e3[1].t, delete e3[1].trace);\n            }\n            function Ppt(e3, t3, r4, n4) {\n              var i3 = e3[t3 - 1], a4 = e3[t3 + 1];\n              return a4 ? i3 ? i3.s + (a4.s - i3.s) * (r4 - i3[n4]) / (a4[n4] - i3[n4]) : a4.s : i3.s;\n            }\n          });\n          var yU = ye((asr, Tve) => {\n            "use strict";\n            var Ipt = So(), bve = fs(), $M = bve.BADNUM, wve = bve.LOG_CLIP, yve = wve + 0.5, _ve = wve - 0.5, tI = Dr(), Rpt = tI.segmentsIntersect, xve = tI.constrain, mU = Sm();\n            Tve.exports = function(t3, r4) {\n              var n4 = r4.trace || {}, i3 = r4.xaxis, a4 = r4.yaxis, o4 = i3.type === "log", s3 = a4.type === "log", l3 = i3._length, u4 = a4._length, c5 = r4.backoff, f4 = n4.marker, h3 = r4.connectGaps, d3 = r4.baseTolerance, v3 = r4.shape, _2 = v3 === "linear", b = n4.fill && n4.fill !== "none", p3 = [], k4 = mU.minTolerance, E3 = t3.length, S2 = new Array(E3), L3 = 0, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2, Z, j3, N2, H, te, oe;\n              function _e(dt) {\n                var Ge = t3[dt];\n                if (!Ge) return false;\n                var Je = r4.linearized ? i3.l2p(Ge.x) : i3.c2p(Ge.x), je = r4.linearized ? a4.l2p(Ge.y) : a4.c2p(Ge.y);\n                if (Je === $M) {\n                  if (o4 && (Je = i3.c2p(Ge.x, true)), Je === $M) return false;\n                  s3 && je === $M && (Je *= Math.abs(i3._m * u4 * (i3._m > 0 ? yve : _ve) / (a4._m * l3 * (a4._m > 0 ? yve : _ve)))), Je *= 1e3;\n                }\n                if (je === $M) {\n                  if (s3 && (je = a4.c2p(Ge.y, true)), je === $M) return false;\n                  je *= 1e3;\n                }\n                return [Je, je];\n              }\n              function Ee(dt, Ge, Je, je) {\n                var tt = Je - dt, xt = je - Ge, Ie = 0.5 - dt, xe = 0.5 - Ge, ke = tt * tt + xt * xt, vt = tt * Ie + xt * xe;\n                if (vt > 0 && vt < ke) {\n                  var ir = Ie * xt - xe * tt;\n                  if (ir * ir < ke) return true;\n                }\n              }\n              var Ce, me;\n              function ie(dt, Ge) {\n                var Je = dt[0] / l3, je = dt[1] / u4, tt = Math.max(0, -Je, Je - 1, -je, je - 1);\n                return tt && Ce !== void 0 && Ee(Je, je, Ce, me) && (tt = 0), tt && Ge && Ee(Je, je, Ge[0] / l3, Ge[1] / u4) && (tt = 0), (1 + mU.toleranceGrowth * tt) * d3;\n              }\n              function Se(dt, Ge) {\n                var Je = dt[0] - Ge[0], je = dt[1] - Ge[1];\n                return Math.sqrt(Je * Je + je * je);\n              }\n              var Le = mU.maxScreensAway, Ae = -l3 * Le, Fe = l3 * (1 + Le), Pe = -u4 * Le, ge = u4 * (1 + Le), Re = [[Ae, Pe, Fe, Pe], [Fe, Pe, Fe, ge], [Fe, ge, Ae, ge], [Ae, ge, Ae, Pe]], ce, Ze, ut, pt, Zt, st;\n              function lt(dt, Ge) {\n                for (var Je = [], je = 0, tt = 0; tt < 4; tt++) {\n                  var xt = Re[tt], Ie = Rpt(dt[0], dt[1], Ge[0], Ge[1], xt[0], xt[1], xt[2], xt[3]);\n                  Ie && (!je || Math.abs(Ie.x - Je[0][0]) > 1 || Math.abs(Ie.y - Je[0][1]) > 1) && (Ie = [Ie.x, Ie.y], je && Se(Ie, dt) < Se(Je[0], dt) ? Je.unshift(Ie) : Je.push(Ie), je++);\n                }\n                return Je;\n              }\n              function Gt(dt) {\n                if (dt[0] < Ae || dt[0] > Fe || dt[1] < Pe || dt[1] > ge) return [xve(dt[0], Ae, Fe), xve(dt[1], Pe, ge)];\n              }\n              function Nt(dt, Ge) {\n                if (dt[0] === Ge[0] && (dt[0] === Ae || dt[0] === Fe) || dt[1] === Ge[1] && (dt[1] === Pe || dt[1] === ge)) return true;\n              }\n              function Jt(dt, Ge) {\n                var Je = [], je = Gt(dt), tt = Gt(Ge);\n                return je && tt && Nt(je, tt) || (je && Je.push(je), tt && Je.push(tt)), Je;\n              }\n              function sr(dt, Ge, Je) {\n                return function(je, tt) {\n                  var xt = Gt(je), Ie = Gt(tt), xe = [];\n                  if (xt && Ie && Nt(xt, Ie)) return xe;\n                  xt && xe.push(xt), Ie && xe.push(Ie);\n                  var ke = 2 * tI.constrain((je[dt] + tt[dt]) / 2, Ge, Je) - ((xt || je)[dt] + (Ie || tt)[dt]);\n                  if (ke) {\n                    var vt;\n                    xt && Ie ? vt = ke > 0 == xt[dt] > Ie[dt] ? xt : Ie : vt = xt || Ie, vt[dt] += ke;\n                  }\n                  return xe;\n                };\n              }\n              var wr;\n              v3 === "linear" || v3 === "spline" ? wr = lt : v3 === "hv" || v3 === "vh" ? wr = Jt : v3 === "hvh" ? wr = sr(0, Ae, Fe) : v3 === "vhv" && (wr = sr(1, Pe, ge));\n              function cr(dt, Ge) {\n                var Je = Ge[0] - dt[0], je = (Ge[1] - dt[1]) / Je, tt = (dt[1] * Ge[0] - Ge[1] * dt[0]) / Je;\n                return tt > 0 ? [je > 0 ? Ae : Fe, ge] : [je > 0 ? Fe : Ae, Pe];\n              }\n              function $e(dt) {\n                var Ge = dt[0], Je = dt[1], je = Ge === S2[L3 - 1][0], tt = Je === S2[L3 - 1][1];\n                if (!(je && tt)) if (L3 > 1) {\n                  var xt = Ge === S2[L3 - 2][0], Ie = Je === S2[L3 - 2][1];\n                  je && (Ge === Ae || Ge === Fe) && xt ? Ie ? L3-- : S2[L3 - 1] = dt : tt && (Je === Pe || Je === ge) && Ie ? xt ? L3-- : S2[L3 - 1] = dt : S2[L3++] = dt;\n                } else S2[L3++] = dt;\n              }\n              function St(dt) {\n                S2[L3 - 1][0] !== dt[0] && S2[L3 - 1][1] !== dt[1] && $e([ut, pt]), $e(dt), Zt = null, ut = pt = 0;\n              }\n              var Qt = tI.isArrayOrTypedArray(f4);\n              function Vt(dt) {\n                if (dt && c5 && (dt.i = x2, dt.d = t3, dt.trace = n4, dt.marker = Qt ? f4[dt.i] : f4, dt.backoff = c5), Ce = dt[0] / l3, me = dt[1] / u4, ce = dt[0] < Ae ? Ae : dt[0] > Fe ? Fe : 0, Ze = dt[1] < Pe ? Pe : dt[1] > ge ? ge : 0, ce || Ze) {\n                  if (!L3) S2[L3++] = [ce || dt[0], Ze || dt[1]];\n                  else if (Zt) {\n                    var Ge = wr(Zt, dt);\n                    Ge.length > 1 && (St(Ge[0]), S2[L3++] = Ge[1]);\n                  } else st = wr(S2[L3 - 1], dt)[0], S2[L3++] = st;\n                  var Je = S2[L3 - 1];\n                  ce && Ze && (Je[0] !== ce || Je[1] !== Ze) ? (Zt && (ut !== ce && pt !== Ze ? $e(ut && pt ? cr(Zt, dt) : [ut || ce, pt || Ze]) : ut && pt && $e([ut, pt])), $e([ce, Ze])) : ut - ce && pt - Ze && $e([ce || ut, Ze || pt]), Zt = dt, ut = ce, pt = Ze;\n                } else Zt && St(wr(Zt, dt)[0]), S2[L3++] = dt;\n              }\n              for (x2 = 0; x2 < E3; x2++) if (C3 = _e(x2), !!C3) {\n                for (L3 = 0, Zt = null, Vt(C3), x2++; x2 < E3; x2++) {\n                  if (g3 = _e(x2), !g3) {\n                    if (h3) continue;\n                    break;\n                  }\n                  if (!_2 || !r4.simplify) {\n                    Vt(g3);\n                    continue;\n                  }\n                  var _t = _e(x2 + 1);\n                  if (G2 = Se(g3, C3), !(!(b && (L3 === 0 || L3 === E3 - 1)) && G2 < ie(g3, _t) * k4)) {\n                    for (O3 = [(g3[0] - C3[0]) / G2, (g3[1] - C3[1]) / G2], P3 = C3, Z = G2, j3 = H = te = 0, z3 = false, M4 = g3, x2++; x2 < t3.length; x2++) {\n                      if (T3 = _t, _t = _e(x2 + 1), !T3) {\n                        if (h3) continue;\n                        break;\n                      }\n                      if (V2 = [T3[0] - C3[0], T3[1] - C3[1]], oe = V2[0] * O3[1] - V2[1] * O3[0], H = Math.min(H, oe), te = Math.max(te, oe), te - H > ie(T3, _t)) break;\n                      M4 = T3, N2 = V2[0] * O3[0] + V2[1] * O3[1], N2 > Z ? (Z = N2, g3 = T3, z3 = false) : N2 < j3 && (j3 = N2, P3 = T3, z3 = true);\n                    }\n                    if (z3 ? (Vt(g3), M4 !== P3 && Vt(P3)) : (P3 !== C3 && Vt(P3), M4 !== g3 && Vt(g3)), Vt(M4), x2 >= t3.length || !T3) break;\n                    Vt(T3), C3 = T3;\n                  }\n                }\n                Zt && $e([ut || Zt[0], pt || Zt[1]]), p3.push(S2.slice(0, L3));\n              }\n              var It = v3.slice(v3.length - 1);\n              if (c5 && It !== "h" && It !== "v") {\n                for (var mt = false, er = -1, lr = [], Tr = 0; Tr < p3.length; Tr++) for (var Lr = 0; Lr < p3[Tr].length - 1; Lr++) {\n                  var ti = p3[Tr][Lr], Br = p3[Tr][Lr + 1], Vr = Ipt.applyBackoff(Br, ti);\n                  (Vr[0] !== Br[0] || Vr[1] !== Br[1]) && (mt = true), lr[er + 1] || (er++, lr[er] = [ti, [Vr[0], Vr[1]]]);\n                }\n                return mt ? lr : p3;\n              }\n              return p3;\n            };\n          });\n          var _U = ye((osr, Sve) => {\n            "use strict";\n            var Ave = { tonextx: 1, tonexty: 1, tonext: 1 };\n            Sve.exports = function(t3, r4, n4) {\n              var i3, a4, o4, s3, l3, u4 = {}, c5 = false, f4 = -1, h3 = 0, d3 = -1;\n              for (a4 = 0; a4 < n4.length; a4++) i3 = n4[a4][0].trace, o4 = i3.stackgroup || "", o4 ? o4 in u4 ? l3 = u4[o4] : (l3 = u4[o4] = h3, h3++) : i3.fill in Ave && d3 >= 0 ? l3 = d3 : (l3 = d3 = h3, h3++), l3 < f4 && (c5 = true), i3._groupIndex = f4 = l3;\n              var v3 = n4.slice();\n              c5 && v3.sort(function(b, p3) {\n                var k4 = b[0].trace, E3 = p3[0].trace;\n                return k4._groupIndex - E3._groupIndex || k4.index - E3.index;\n              });\n              var _2 = {};\n              for (a4 = 0; a4 < v3.length; a4++) i3 = v3[a4][0].trace, o4 = i3.stackgroup || "", i3.visible === true ? (i3._nexttrace = null, i3.fill in Ave && (s3 = _2[o4], i3._prevtrace = s3 || null, s3 && (s3._nexttrace = i3)), i3._ownfill = i3.fill && (i3.fill.slice(0, 6) === "tozero" || i3.fill === "toself" || i3.fill.slice(0, 2) === "to" && !i3._prevtrace), _2[o4] = i3) : i3._prevtrace = i3._nexttrace = i3._ownfill = null;\n              return v3;\n            };\n          });\n          var sT = ye((ssr, kve) => {\n            "use strict";\n            var Fg = Oa(), Dpt = qa(), QM = Dr(), aT = QM.ensureSingle, Eve = QM.identity, Kf = So(), oT = Ru(), Fpt = yU(), zpt = _U(), rI = kM().tester;\n            kve.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3, l3, u4 = !a4, c5 = !!a4 && a4.duration > 0, f4 = zpt(t3, r4, n4);\n              if (s3 = i3.selectAll("g.trace").data(f4, function(d3) {\n                return d3[0].trace.uid;\n              }), s3.enter().append("g").attr("class", function(d3) {\n                return "trace scatter trace" + d3[0].trace.uid;\n              }).style("stroke-miterlimit", 2), s3.order(), Opt(t3, s3, r4), c5) {\n                o4 && (l3 = o4());\n                var h3 = Fg.transition().duration(a4.duration).ease(a4.easing).each("end", function() {\n                  l3 && l3();\n                }).each("interrupt", function() {\n                  l3 && l3();\n                });\n                h3.each(function() {\n                  i3.selectAll("g.trace").each(function(d3, v3) {\n                    Mve(t3, v3, r4, d3, f4, this, a4);\n                  });\n                });\n              } else s3.each(function(d3, v3) {\n                Mve(t3, v3, r4, d3, f4, this, a4);\n              });\n              u4 && s3.exit().remove(), i3.selectAll("path:not([d])").remove();\n            };\n            function Opt(e3, t3, r4) {\n              t3.each(function(n4) {\n                var i3 = aT(Fg.select(this), "g", "fills");\n                Kf.setClipUrl(i3, r4.layerClipId, e3);\n                var a4 = n4[0].trace, o4 = [];\n                a4._ownfill && o4.push("_ownFill"), a4._nexttrace && o4.push("_nextFill");\n                var s3 = i3.selectAll("g").data(o4, Eve);\n                s3.enter().append("g"), s3.exit().each(function(l3) {\n                  a4[l3] = null;\n                }).remove(), s3.order().each(function(l3) {\n                  a4[l3] = aT(Fg.select(this), "path", "js-fill");\n                });\n              });\n            }\n            function Mve(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = e3._context.staticPlot, l3;\n              qpt(e3, t3, r4, n4, i3);\n              var u4 = !!o4 && o4.duration > 0;\n              function c5(sr) {\n                return u4 ? sr.transition() : sr;\n              }\n              var f4 = r4.xaxis, h3 = r4.yaxis, d3 = n4[0].trace, v3 = d3.line, _2 = Fg.select(a4), b = aT(_2, "g", "errorbars"), p3 = aT(_2, "g", "lines"), k4 = aT(_2, "g", "points"), E3 = aT(_2, "g", "text");\n              if (Dpt.getComponentMethod("errorbars", "plot")(e3, b, r4, o4), d3.visible !== true) return;\n              c5(_2).style("opacity", d3.opacity);\n              var S2, L3, x2 = d3.fill.charAt(d3.fill.length - 1);\n              x2 !== "x" && x2 !== "y" && (x2 = "");\n              var C3, M4;\n              x2 === "y" ? (C3 = 1, M4 = h3.c2p(0, true)) : x2 === "x" && (C3 = 0, M4 = f4.c2p(0, true)), n4[0][r4.isRangePlot ? "nodeRangePlot3" : "node3"] = _2;\n              var g3 = "", P3 = [], T3 = d3._prevtrace, z3 = null, O3 = null;\n              T3 && (g3 = T3._prevRevpath || "", L3 = T3._nextFill, P3 = T3._ownPolygons, z3 = T3._fillsegments, O3 = T3._fillElement);\n              var V2, G2, Z = "", j3 = "", N2, H, te, oe, _e, Ee, Ce = [];\n              d3._polygons = [];\n              var me = [], ie = [], Se = QM.noop;\n              if (S2 = d3._ownFill, oT.hasLines(d3) || d3.fill !== "none") {\n                L3 && L3.datum(n4), ["hv", "vh", "hvh", "vhv"].indexOf(v3.shape) !== -1 ? (N2 = Kf.steps(v3.shape), H = Kf.steps(v3.shape.split("").reverse().join(""))) : v3.shape === "spline" ? N2 = H = function(sr) {\n                  var wr = sr[sr.length - 1];\n                  return sr.length > 1 && sr[0][0] === wr[0] && sr[0][1] === wr[1] ? Kf.smoothclosed(sr.slice(1), v3.smoothing) : Kf.smoothopen(sr, v3.smoothing);\n                } : N2 = H = function(sr) {\n                  return "M" + sr.join("L");\n                }, te = function(sr) {\n                  return H(sr.reverse());\n                }, ie = Fpt(n4, { xaxis: f4, yaxis: h3, trace: d3, connectGaps: d3.connectgaps, baseTolerance: Math.max(v3.width || 1, 3) / 4, shape: v3.shape, backoff: v3.backoff, simplify: v3.simplify, fill: d3.fill }), me = new Array(ie.length);\n                var Le = 0;\n                for (l3 = 0; l3 < ie.length; l3++) {\n                  var Ae, Fe = ie[l3];\n                  !Ae || !x2 ? (Ae = Fe.slice(), me[Le] = Ae, Le++) : Ae.push.apply(Ae, Fe);\n                }\n                d3._fillElement = null, d3._fillExclusionElement = O3, d3._fillsegments = me.slice(0, Le), me = d3._fillsegments, ie.length && (oe = ie[0][0].slice(), _e = ie[ie.length - 1], Ee = _e[_e.length - 1].slice()), Se = function(sr) {\n                  return function(wr) {\n                    if (V2 = N2(wr), G2 = te(wr), Z ? x2 ? (Z += "L" + V2.slice(1), j3 = G2 + ("L" + j3.slice(1))) : (Z += "Z" + V2, j3 = G2 + "Z" + j3) : (Z = V2, j3 = G2), oT.hasLines(d3)) {\n                      var cr = Fg.select(this);\n                      if (cr.datum(n4), sr) c5(cr.style("opacity", 0).attr("d", V2).call(Kf.lineGroupStyle)).style("opacity", 1);\n                      else {\n                        var $e = c5(cr);\n                        $e.attr("d", V2), Kf.singleLineStyle(n4, $e);\n                      }\n                    }\n                  };\n                };\n              }\n              var Pe = p3.selectAll(".js-line").data(ie);\n              c5(Pe.exit()).style("opacity", 0).remove(), Pe.each(Se(false)), Pe.enter().append("path").classed("js-line", true).style("vector-effect", s3 ? "none" : "non-scaling-stroke").call(Kf.lineGroupStyle).each(Se(true)), Kf.setClipUrl(Pe, r4.layerClipId, e3);\n              function ge(sr) {\n                c5(sr).attr("d", "M0,0Z");\n              }\n              var Re = function() {\n                var sr = new Array(me.length);\n                for (l3 = 0; l3 < me.length; l3++) sr[l3] = rI(me[l3]);\n                return sr;\n              }, ce = function(sr) {\n                var wr, cr;\n                if (!sr || sr.length === 0) for (wr = new Array(me.length), cr = 0; cr < me.length; cr++) {\n                  var $e = me[cr][0].slice(), St = me[cr][me[cr].length - 1].slice();\n                  $e[C3] = St[C3] = M4;\n                  var Qt = [St, $e], Vt = Qt.concat(me[cr]);\n                  wr[cr] = rI(Vt);\n                }\n                else {\n                  for (wr = new Array(sr.length - 1 + me.length), cr = 0; cr < sr.length - 1; cr++) wr[cr] = rI(sr[cr]);\n                  var _t = sr[sr.length - 1].slice();\n                  for (_t.reverse(), cr = 0; cr < me.length; cr++) wr[sr.length - 1 + cr] = rI(me[cr].concat(_t));\n                }\n                return wr;\n              };\n              ie.length ? (S2 ? (S2.datum(n4), oe && Ee && (x2 ? (oe[C3] = Ee[C3] = M4, c5(S2).attr("d", "M" + Ee + "L" + oe + "L" + Z.slice(1)).call(Kf.singleFillStyle, e3), Ce = ce(null)) : (c5(S2).attr("d", Z + "Z").call(Kf.singleFillStyle, e3), Ce = Re())), d3._polygons = Ce, d3._fillElement = S2) : L3 && (d3.fill.slice(0, 6) === "tonext" && Z && g3 ? (d3.fill === "tonext" ? (c5(L3).attr("d", Z + "Z" + g3 + "Z").call(Kf.singleFillStyle, e3), Ce = Re(), d3._polygons = Ce.concat(P3)) : (c5(L3).attr("d", Z + "L" + g3.slice(1) + "Z").call(Kf.singleFillStyle, e3), Ce = ce(z3), d3._polygons = Ce), d3._fillElement = L3) : ge(L3)), d3._prevRevpath = j3) : (S2 ? ge(S2) : L3 && ge(L3), d3._prevRevpath = null), d3._ownPolygons = Ce;\n              function Ze(sr) {\n                return sr.filter(function(wr) {\n                  return !wr.gap && wr.vis;\n                });\n              }\n              function ut(sr) {\n                return sr.filter(function(wr) {\n                  return wr.vis;\n                });\n              }\n              function pt(sr) {\n                return sr.filter(function(wr) {\n                  return !wr.gap;\n                });\n              }\n              function Zt(sr) {\n                return sr.id;\n              }\n              function st(sr) {\n                if (sr.ids) return Zt;\n              }\n              function lt() {\n                return false;\n              }\n              function Gt(sr, wr, cr) {\n                var $e, St, Qt, Vt = cr[0].trace, _t = oT.hasMarkers(Vt), It = oT.hasText(Vt), mt = st(Vt), er = lt, lr = lt;\n                if (_t || It) {\n                  var Tr = Eve, Lr = Vt.stackgroup, ti = Lr && e3._fullLayout._scatterStackOpts[f4._id + h3._id][Lr].stackgaps === "infer zero";\n                  Vt.marker.maxdisplayed || Vt._needsCull ? Tr = ti ? ut : Ze : Lr && !ti && (Tr = pt), _t && (er = Tr), It && (lr = Tr);\n                }\n                St = sr.selectAll("path.point"), $e = St.data(er, mt);\n                var Br = $e.enter().append("path").classed("point", true);\n                u4 && Br.call(Kf.pointStyle, Vt, e3).call(Kf.translatePoints, f4, h3).style("opacity", 0).transition().style("opacity", 1), $e.order();\n                var Vr;\n                _t && (Vr = Kf.makePointStyleFns(Vt)), $e.each(function(dt) {\n                  var Ge = Fg.select(this), Je = c5(Ge);\n                  Qt = Kf.translatePoint(dt, Je, f4, h3), Qt ? (Kf.singlePointStyle(dt, Je, Vt, Vr, e3), r4.layerClipId && Kf.hideOutsideRangePoint(dt, Je, f4, h3, Vt.xcalendar, Vt.ycalendar), Vt.customdata && Ge.classed("plotly-customdata", dt.data !== null && dt.data !== void 0)) : Je.remove();\n                }), u4 ? $e.exit().transition().style("opacity", 0).remove() : $e.exit().remove(), St = wr.selectAll("g"), $e = St.data(lr, mt), $e.enter().append("g").classed("textpoint", true).append("text"), $e.order(), $e.each(function(dt) {\n                  var Ge = Fg.select(this), Je = c5(Ge.select("text"));\n                  Qt = Kf.translatePoint(dt, Je, f4, h3), Qt ? r4.layerClipId && Kf.hideOutsideRangePoint(dt, Ge, f4, h3, Vt.xcalendar, Vt.ycalendar) : Ge.remove();\n                }), $e.selectAll("text").call(Kf.textPointStyle, Vt, e3).each(function(dt) {\n                  var Ge = f4.c2p(dt.x), Je = h3.c2p(dt.y);\n                  Fg.select(this).selectAll("tspan.line").each(function() {\n                    c5(Fg.select(this)).attr({ x: Ge, y: Je });\n                  });\n                }), $e.exit().remove();\n              }\n              k4.datum(n4), E3.datum(n4), Gt(k4, E3, n4);\n              var Nt = d3.cliponaxis === false, Jt = Nt ? null : r4.layerClipId;\n              Kf.setClipUrl(k4, Jt, e3), Kf.setClipUrl(E3, Jt, e3);\n            }\n            function qpt(e3, t3, r4, n4, i3) {\n              var a4 = r4.xaxis, o4 = r4.yaxis, s3 = Fg.extent(QM.simpleMap(a4.range, a4.r2c)), l3 = Fg.extent(QM.simpleMap(o4.range, o4.r2c)), u4 = n4[0].trace;\n              if (oT.hasMarkers(u4)) {\n                var c5 = u4.marker.maxdisplayed;\n                if (c5 !== 0) {\n                  var f4 = n4.filter(function(_2) {\n                    return _2.x >= s3[0] && _2.x <= s3[1] && _2.y >= l3[0] && _2.y <= l3[1];\n                  }), h3 = Math.ceil(f4.length / c5), d3 = 0;\n                  i3.forEach(function(_2, b) {\n                    var p3 = _2[0].trace;\n                    oT.hasMarkers(p3) && p3.marker.maxdisplayed > 0 && b < t3 && d3++;\n                  });\n                  var v3 = Math.round(d3 * h3 / 3 + Math.floor(d3 / 3) * h3 / 7.1);\n                  n4.forEach(function(_2) {\n                    delete _2.vis;\n                  }), f4.forEach(function(_2, b) {\n                    Math.round((b + v3) % h3) === 0 && (_2.vis = true);\n                  });\n                }\n              }\n            }\n          });\n          var $d = ye((lsr, Cve) => {\n            "use strict";\n            Cve.exports = { container: "marker", min: "cmin", max: "cmax" };\n          });\n          var nI = ye((usr, Lve) => {\n            "use strict";\n            var iI = ho();\n            Lve.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = { _fullLayout: n4 }, o4 = iI.getFromTrace(a4, r4, "x"), s3 = iI.getFromTrace(a4, r4, "y"), l3 = t3.orig_x;\n              l3 === void 0 && (l3 = t3.x);\n              var u4 = t3.orig_y;\n              return u4 === void 0 && (u4 = t3.y), i3.xLabel = iI.tickText(o4, o4.c2l(l3), true).text, i3.yLabel = iI.tickText(s3, s3.c2l(u4), true).text, i3;\n            };\n          });\n          var op = ye((csr, Pve) => {\n            "use strict";\n            var xU = Oa(), lT = So(), Bpt = qa();\n            function Npt(e3) {\n              var t3 = xU.select(e3).selectAll("g.trace.scatter");\n              t3.style("opacity", function(r4) {\n                return r4[0].trace.opacity;\n              }), t3.selectAll("g.points").each(function(r4) {\n                var n4 = xU.select(this), i3 = r4.trace || r4[0].trace;\n                bU(n4, i3, e3);\n              }), t3.selectAll("g.text").each(function(r4) {\n                var n4 = xU.select(this), i3 = r4.trace || r4[0].trace;\n                wU(n4, i3, e3);\n              }), t3.selectAll("g.trace path.js-line").call(lT.lineGroupStyle), t3.selectAll("g.trace path.js-fill").call(lT.fillGroupStyle, e3, false), Bpt.getComponentMethod("errorbars", "style")(t3);\n            }\n            function bU(e3, t3, r4) {\n              lT.pointStyle(e3.selectAll("path.point"), t3, r4);\n            }\n            function wU(e3, t3, r4) {\n              lT.textPointStyle(e3.selectAll("text"), t3, r4);\n            }\n            function Upt(e3, t3, r4) {\n              var n4 = t3[0].trace;\n              n4.selectedpoints ? (lT.selectedPointStyle(r4.selectAll("path.point"), n4), lT.selectedTextStyle(r4.selectAll("text"), n4)) : (bU(r4, n4, e3), wU(r4, n4, e3));\n            }\n            Pve.exports = { style: Npt, stylePoints: bU, styleText: wU, styleOnSelect: Upt };\n          });\n          var cT = ye((fsr, Ive) => {\n            "use strict";\n            var uT = ka(), Vpt = Ru();\n            Ive.exports = function(t3, r4) {\n              var n4, i3;\n              if (t3.mode === "lines") return n4 = t3.line.color, n4 && uT.opacity(n4) ? n4 : t3.fillcolor;\n              if (t3.mode === "none") return t3.fill ? t3.fillcolor : "";\n              var a4 = r4.mcc || (t3.marker || {}).color, o4 = r4.mlcc || ((t3.marker || {}).line || {}).color;\n              return i3 = a4 && uT.opacity(a4) ? a4 : o4 && uT.opacity(o4) && (r4.mlw || ((t3.marker || {}).line || {}).width) ? o4 : "", i3 ? uT.opacity(i3) < 0.3 ? uT.addOpacity(i3, 0.3) : i3 : (n4 = (t3.line || {}).color, n4 && uT.opacity(n4) && Vpt.hasLines(t3) && t3.line.width ? n4 : t3.fillcolor);\n            };\n          });\n          var fT = ye((hsr, Dve) => {\n            "use strict";\n            var aI = Dr(), Rve = vf(), Gpt = qa(), Hpt = cT(), TU = ka(), jpt = aI.fillText;\n            Dve.exports = function(t3, r4, n4, i3) {\n              var a4 = t3.cd, o4 = a4[0].trace, s3 = t3.xa, l3 = t3.ya, u4 = s3.c2p(r4), c5 = l3.c2p(n4), f4 = [u4, c5], h3 = o4.hoveron || "", d3 = o4.mode.indexOf("markers") !== -1 ? 3 : 0.5, v3 = !!o4.xperiodalignment, _2 = !!o4.yperiodalignment;\n              if (h3.indexOf("points") !== -1) {\n                var b = function(j3) {\n                  if (v3) {\n                    var N2 = s3.c2p(j3.xStart), H = s3.c2p(j3.xEnd);\n                    return u4 >= Math.min(N2, H) && u4 <= Math.max(N2, H) ? 0 : 1 / 0;\n                  }\n                  var te = Math.max(3, j3.mrc || 0), oe = 1 - 1 / te, _e = Math.abs(s3.c2p(j3.x) - u4);\n                  return _e < te ? oe * _e / te : _e - te + oe;\n                }, p3 = function(j3) {\n                  if (_2) {\n                    var N2 = l3.c2p(j3.yStart), H = l3.c2p(j3.yEnd);\n                    return c5 >= Math.min(N2, H) && c5 <= Math.max(N2, H) ? 0 : 1 / 0;\n                  }\n                  var te = Math.max(3, j3.mrc || 0), oe = 1 - 1 / te, _e = Math.abs(l3.c2p(j3.y) - c5);\n                  return _e < te ? oe * _e / te : _e - te + oe;\n                }, k4 = function(j3) {\n                  var N2 = Math.max(d3, j3.mrc || 0), H = s3.c2p(j3.x) - u4, te = l3.c2p(j3.y) - c5;\n                  return Math.max(Math.sqrt(H * H + te * te) - N2, 1 - d3 / N2);\n                }, E3 = Rve.getDistanceFunction(i3, b, p3, k4);\n                if (Rve.getClosest(a4, E3, t3), t3.index !== false) {\n                  var S2 = a4[t3.index], L3 = s3.c2p(S2.x, true), x2 = l3.c2p(S2.y, true), C3 = S2.mrc || 1;\n                  t3.index = S2.i;\n                  var M4 = a4[0].t.orientation, g3 = M4 && (S2.sNorm || S2.s), P3 = M4 === "h" ? g3 : S2.orig_x !== void 0 ? S2.orig_x : S2.x, T3 = M4 === "v" ? g3 : S2.orig_y !== void 0 ? S2.orig_y : S2.y;\n                  return aI.extendFlat(t3, { color: Hpt(o4, S2), x0: L3 - C3, x1: L3 + C3, xLabelVal: P3, y0: x2 - C3, y1: x2 + C3, yLabelVal: T3, spikeDistance: k4(S2), hovertemplate: o4.hovertemplate }), jpt(S2, o4, t3), Gpt.getComponentMethod("errorbars", "hoverInfo")(S2, o4, t3), [t3];\n                }\n              }\n              function z3(j3) {\n                if (!j3) return false;\n                var N2 = j3.node();\n                try {\n                  var H = new DOMPoint(f4[0], f4[1]);\n                  return N2.isPointInFill(H);\n                } catch (oe) {\n                  var te = N2.ownerSVGElement.createSVGPoint();\n                  return te.x = f4[0], te.y = f4[1], N2.isPointInFill(te);\n                }\n              }\n              function O3(j3) {\n                var N2, H = [], te = 1 / 0, oe = -1 / 0, _e = 1 / 0, Ee = -1 / 0, Ce;\n                for (N2 = 0; N2 < j3.length; N2++) {\n                  var me = j3[N2];\n                  me.contains(f4) && (H.push(me), _e = Math.min(_e, me.ymin), Ee = Math.max(Ee, me.ymax));\n                }\n                if (H.length === 0) return null;\n                _e = Math.max(_e, 0), Ee = Math.min(Ee, l3._length), Ce = (_e + Ee) / 2;\n                var ie, Se, Le, Ae, Fe, Pe, ge;\n                for (N2 = 0; N2 < H.length; N2++) for (Se = H[N2].pts, ie = 1; ie < Se.length; ie++) Pe = Se[ie - 1][1], ge = Se[ie][1], Pe > Ce != ge >= Ce && (Ae = Se[ie - 1][0], Fe = Se[ie][0], ge - Pe && (Le = Ae + (Fe - Ae) * (Ce - Pe) / (ge - Pe), te = Math.min(te, Le), oe = Math.max(oe, Le)));\n                return te = Math.max(te, 0), oe = Math.min(oe, s3._length), { x0: te, x1: oe, y0: Ce, y1: Ce };\n              }\n              if (h3.indexOf("fills") !== -1 && o4._fillElement) {\n                var V2 = z3(o4._fillElement) && !z3(o4._fillExclusionElement);\n                if (V2) {\n                  var G2 = O3(o4._polygons);\n                  G2 === null && (G2 = { x0: f4[0], x1: f4[0], y0: f4[1], y1: f4[1] });\n                  var Z = TU.defaultLine;\n                  return TU.opacity(o4.fillcolor) ? Z = o4.fillcolor : TU.opacity((o4.line || {}).color) && (Z = o4.line.color), aI.extendFlat(t3, { distance: t3.maxHoverDistance, x0: G2.x0, x1: G2.x1, y0: G2.y0, y1: G2.y1, color: Z, hovertemplate: false }), delete t3.index, o4.text && !aI.isArrayOrTypedArray(o4.text) ? t3.text = String(o4.text) : t3.text = o4.name, [t3];\n                }\n              }\n            };\n          });\n          var hT = ye((dsr, zve) => {\n            "use strict";\n            var Fve = Ru();\n            zve.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3 = n4[0].trace, l3, u4, c5, f4, h3 = !Fve.hasMarkers(s3) && !Fve.hasText(s3);\n              if (h3) return [];\n              if (r4 === false) for (l3 = 0; l3 < n4.length; l3++) n4[l3].selected = 0;\n              else for (l3 = 0; l3 < n4.length; l3++) u4 = n4[l3], c5 = i3.c2p(u4.x), f4 = a4.c2p(u4.y), u4.i !== null && r4.contains([c5, f4], false, l3, t3) ? (o4.push({ pointNumber: u4.i, x: i3.c2d(u4.x), y: a4.c2d(u4.y) }), u4.selected = 1) : u4.selected = 0;\n              return o4;\n            };\n          });\n          var qve = ye((vsr, Ove) => {\n            "use strict";\n            Ove.exports = { xaxis: { valType: "subplotid", dflt: "x", editType: "calc+clearAxisTypes" }, yaxis: { valType: "subplotid", dflt: "y", editType: "calc+clearAxisTypes" } };\n          });\n          var SU = ye((psr, Uve) => {\n            "use strict";\n            var e4 = qa().traceIs, AU = R3();\n            Uve.exports = function(t3, r4, n4, i3) {\n              n4("autotypenumbers", i3.autotypenumbersDflt);\n              var a4 = n4("type", (i3.splomStash || {}).type);\n              a4 === "-" && (Wpt(r4, i3.data), r4.type === "-" ? r4.type = "linear" : t3.type = r4.type);\n            };\n            function Wpt(e3, t3) {\n              if (e3.type === "-") {\n                var r4 = e3._id, n4 = r4.charAt(0), i3;\n                r4.indexOf("scene") !== -1 && (r4 = n4);\n                var a4 = Xpt(t3, r4, n4);\n                if (a4) {\n                  if (a4.type === "histogram" && n4 === { v: "y", h: "x" }[a4.orientation || "v"]) {\n                    e3.type = "linear";\n                    return;\n                  }\n                  var o4 = n4 + "calendar", s3 = a4[o4], l3 = { noMultiCategory: !e4(a4, "cartesian") || e4(a4, "noMultiCategory") };\n                  if (a4.type === "box" && a4._hasPreCompStats && n4 === { h: "x", v: "y" }[a4.orientation || "v"] && (l3.noMultiCategory = true), l3.autotypenumbers = e3.autotypenumbers, Nve(a4, n4)) {\n                    var u4 = Bve(a4), c5 = [];\n                    for (i3 = 0; i3 < t3.length; i3++) {\n                      var f4 = t3[i3];\n                      !e4(f4, "box-violin") || (f4[n4 + "axis"] || n4) !== r4 || (f4[u4] !== void 0 ? c5.push(f4[u4][0]) : f4.name !== void 0 ? c5.push(f4.name) : c5.push("text"), f4[o4] !== s3 && (s3 = void 0));\n                    }\n                    e3.type = AU(c5, s3, l3);\n                  } else if (a4.type === "splom") {\n                    var h3 = a4.dimensions, d3 = h3[a4._axesDim[r4]];\n                    d3.visible && (e3.type = AU(d3.values, s3, l3));\n                  } else e3.type = AU(a4[n4] || [a4[n4 + "0"]], s3, l3);\n                }\n              }\n            }\n            function Xpt(e3, t3, r4) {\n              for (var n4 = 0; n4 < e3.length; n4++) {\n                var i3 = e3[n4];\n                if (i3.type === "splom" && i3._length > 0 && (i3["_" + r4 + "axes"] || {})[t3]) return i3;\n                if ((i3[r4 + "axis"] || r4) === t3) {\n                  if (Nve(i3, r4)) return i3;\n                  if ((i3[r4] || []).length || i3[r4 + "0"]) return i3;\n                }\n              }\n            }\n            function Bve(e3) {\n              return { v: "x", h: "y" }[e3.orientation || "v"];\n            }\n            function Nve(e3, t3) {\n              var r4 = Bve(e3), n4 = e4(e3, "box-violin"), i3 = e4(e3._fullInput || {}, "candlestick");\n              return n4 && !i3 && t3 === r4 && e3[r4] === void 0 && e3[r4 + "0"] === void 0;\n            }\n          });\n          var oI = ye((gsr, Vve) => {\n            "use strict";\n            var Zpt = vv().isTypedArraySpec;\n            function Ypt(e3, t3) {\n              var r4 = t3.dataAttr || e3._id.charAt(0), n4 = {}, i3, a4, o4;\n              if (t3.axData) i3 = t3.axData;\n              else for (i3 = [], a4 = 0; a4 < t3.data.length; a4++) {\n                var s3 = t3.data[a4];\n                s3[r4 + "axis"] === e3._id && i3.push(s3);\n              }\n              for (a4 = 0; a4 < i3.length; a4++) {\n                var l3 = i3[a4][r4];\n                for (o4 = 0; o4 < l3.length; o4++) {\n                  var u4 = l3[o4];\n                  u4 != null && (n4[u4] = 1);\n                }\n              }\n              return Object.keys(n4);\n            }\n            Vve.exports = function(t3, r4, n4, i3) {\n              if (r4.type === "category") {\n                var a4 = t3.categoryarray, o4 = Array.isArray(a4) && a4.length > 0 || Zpt(a4), s3;\n                o4 && (s3 = "array");\n                var l3 = n4("categoryorder", s3), u4;\n                l3 === "array" && (u4 = n4("categoryarray")), !o4 && l3 === "array" && (l3 = r4.categoryorder = "trace"), l3 === "trace" ? r4._initialCategories = [] : l3 === "array" ? r4._initialCategories = u4.slice() : (u4 = Ypt(r4, i3).sort(), l3 === "category ascending" ? r4._initialCategories = u4 : l3 === "category descending" && (r4._initialCategories = u4.reverse()));\n              }\n            };\n          });\n          var t4 = ye((msr, Hve) => {\n            "use strict";\n            var Gve = cd().mix, Kpt = Lh(), Jpt = Dr();\n            Hve.exports = function(t3, r4, n4, i3) {\n              i3 = i3 || {};\n              var a4 = i3.dfltColor;\n              function o4(M4, g3) {\n                return Jpt.coerce2(t3, r4, i3.attributes, M4, g3);\n              }\n              var s3 = o4("linecolor", a4), l3 = o4("linewidth"), u4 = n4("showline", i3.showLine || !!s3 || !!l3);\n              u4 || (delete r4.linecolor, delete r4.linewidth);\n              var c5 = Gve(a4, i3.bgColor, i3.blend || Kpt.lightFraction).toRgbString(), f4 = o4("gridcolor", c5), h3 = o4("gridwidth"), d3 = o4("griddash"), v3 = n4("showgrid", i3.showGrid || !!f4 || !!h3 || !!d3);\n              if (v3 || (delete r4.gridcolor, delete r4.gridwidth, delete r4.griddash), i3.hasMinor) {\n                var _2 = Gve(r4.gridcolor, i3.bgColor, 67).toRgbString(), b = o4("minor.gridcolor", _2), p3 = o4("minor.gridwidth", r4.gridwidth || 1), k4 = o4("minor.griddash", r4.griddash || "solid"), E3 = n4("minor.showgrid", !!b || !!p3 || !!k4);\n                E3 || (delete r4.minor.gridcolor, delete r4.minor.gridwidth, delete r4.minor.griddash);\n              }\n              if (!i3.noZeroLine) {\n                var S2 = o4("zerolinelayer"), L3 = o4("zerolinecolor", a4), x2 = o4("zerolinewidth"), C3 = n4("zeroline", i3.showGrid || !!L3 || !!x2);\n                C3 || (delete r4.zerolinelayer, delete r4.zerolinecolor, delete r4.zerolinewidth);\n              }\n            };\n          });\n          var i4 = ye((ysr, Kve) => {\n            "use strict";\n            var jve = Eo(), $pt = qa(), r4 = Dr(), Qpt = vl(), e0t = Yd(), MU = Rd(), Wve = bb(), Xve = M3(), t0t = e_(), r0t = t_(), i0t = oI(), n0t = t4(), a0t = xB(), Zve = ym(), sI = hd().WEEKDAY_PATTERN, o0t = hd().HOUR_PATTERN;\n            Kve.exports = function(t3, r5, n4, i3, a4) {\n              var o4 = i3.letter, s3 = i3.font || {}, l3 = i3.splomStash || {}, u4 = n4("visible", !i3.visibleDflt), c5 = r5._template || {}, f4 = r5.type || c5.type || "-", h3;\n              if (f4 === "date") {\n                var d3 = $pt.getComponentMethod("calendars", "handleDefaults");\n                d3(t3, r5, "calendar", i3.calendar), i3.noTicklabelmode || (h3 = n4("ticklabelmode"));\n              }\n              !i3.noTicklabelindex && (f4 === "date" || f4 === "linear") && n4("ticklabelindex");\n              var v3 = "";\n              (!i3.noTicklabelposition || f4 === "multicategory") && (v3 = r4.coerce(t3, r5, { ticklabelposition: { valType: "enumerated", dflt: "outside", values: h3 === "period" ? ["outside", "inside"] : o4 === "x" ? ["outside", "inside", "outside left", "inside left", "outside right", "inside right"] : ["outside", "inside", "outside top", "inside top", "outside bottom", "inside bottom"] } }, "ticklabelposition")), i3.noTicklabeloverflow || n4("ticklabeloverflow", v3.indexOf("inside") !== -1 ? "hide past domain" : f4 === "category" || f4 === "multicategory" ? "allow" : "hide past div"), Zve(r5, a4), a0t(t3, r5, n4, i3), i0t(t3, r5, n4, i3), i3.noHover || (f4 !== "category" && n4("hoverformat"), i3.noUnifiedhovertitle || n4("unifiedhovertitle.text"));\n              var _2 = n4("color"), b = _2 !== MU.color.dflt ? _2 : s3.color, p3 = l3.label || a4._dfltTitle[o4];\n              if (r0t(t3, r5, n4, f4, i3), !u4) return r5;\n              n4("title.text", p3), r4.coerceFont(n4, "title.font", s3, { overrideDflt: { size: r4.bigFont(s3.size), color: b } }), Wve(t3, r5, n4, f4);\n              var k4 = i3.hasMinor;\n              if (k4 && (Qpt.newContainer(r5, "minor"), Wve(t3, r5, n4, f4, { isMinor: true })), t0t(t3, r5, n4, f4, i3), Xve(t3, r5, n4, i3), k4) {\n                var E3 = i3.isMinor;\n                i3.isMinor = true, Xve(t3, r5, n4, i3), i3.isMinor = E3;\n              }\n              n0t(t3, r5, n4, { dfltColor: _2, bgColor: i3.bgColor, showGrid: i3.showGrid, hasMinor: k4, attributes: MU }), k4 && !r5.minor.ticks && !r5.minor.showgrid && delete r5.minor, (r5.showline || r5.ticks) && n4("mirror");\n              var S2 = f4 === "multicategory";\n              if (!i3.noTickson && (f4 === "category" || S2) && (r5.ticks || r5.showgrid) && (S2 ? (n4("tickson", "boundaries"), delete r5.ticklabelposition) : n4("tickson")), S2) {\n                var L3 = n4("showdividers");\n                L3 && (n4("dividercolor"), n4("dividerwidth"));\n              }\n              if (f4 === "date") if (e0t(t3, r5, { name: "rangebreaks", inclusionAttr: "enabled", handleItemDefaults: s0t }), !r5.rangebreaks.length) delete r5.rangebreaks;\n              else {\n                for (var x2 = 0; x2 < r5.rangebreaks.length; x2++) if (r5.rangebreaks[x2].pattern === sI) {\n                  r5._hasDayOfWeekBreaks = true;\n                  break;\n                }\n                if (Zve(r5, a4), a4._has("scattergl") || a4._has("splom")) for (var C3 = 0; C3 < i3.data.length; C3++) {\n                  var M4 = i3.data[C3];\n                  (M4.type === "scattergl" || M4.type === "splom") && (M4.visible = false, r4.warn(M4.type + " traces do not work on axes with rangebreaks. Setting trace " + M4.index + " to `visible: false`."));\n                }\n              }\n              return r5;\n            };\n            function s0t(e3, t3, r5) {\n              function n4(h3, d3) {\n                return r4.coerce(e3, t3, MU.rangebreaks, h3, d3);\n              }\n              var i3 = n4("enabled");\n              if (i3) {\n                var a4 = n4("bounds");\n                if (a4 && a4.length >= 2) {\n                  var o4 = "", s3, l3;\n                  if (a4.length === 2) {\n                    for (s3 = 0; s3 < 2; s3++) if (l3 = Yve(a4[s3]), l3) {\n                      o4 = sI;\n                      break;\n                    }\n                  }\n                  var u4 = n4("pattern", o4);\n                  if (u4 === sI) for (s3 = 0; s3 < 2; s3++) l3 = Yve(a4[s3]), l3 && (t3.bounds[s3] = a4[s3] = l3 - 1);\n                  if (u4) for (s3 = 0; s3 < 2; s3++) switch (l3 = a4[s3], u4) {\n                    case sI:\n                      if (!jve(l3)) {\n                        t3.enabled = false;\n                        return;\n                      }\n                      if (l3 = +l3, l3 !== Math.floor(l3) || l3 < 0 || l3 >= 7) {\n                        t3.enabled = false;\n                        return;\n                      }\n                      t3.bounds[s3] = a4[s3] = l3;\n                      break;\n                    case o0t:\n                      if (!jve(l3)) {\n                        t3.enabled = false;\n                        return;\n                      }\n                      if (l3 = +l3, l3 < 0 || l3 > 24) {\n                        t3.enabled = false;\n                        return;\n                      }\n                      t3.bounds[s3] = a4[s3] = l3;\n                      break;\n                  }\n                  if (r5.autorange === false) {\n                    var c5 = r5.range;\n                    if (c5[0] < c5[1]) {\n                      if (a4[0] < c5[0] && a4[1] > c5[1]) {\n                        t3.enabled = false;\n                        return;\n                      }\n                    } else if (a4[0] > c5[0] && a4[1] < c5[1]) {\n                      t3.enabled = false;\n                      return;\n                    }\n                  }\n                } else {\n                  var f4 = n4("values");\n                  if (f4 && f4.length) n4("dvalue");\n                  else {\n                    t3.enabled = false;\n                    return;\n                  }\n                }\n              }\n            }\n            var l0t = { sun: 1, mon: 2, tue: 3, wed: 4, thu: 5, fri: 6, sat: 7 };\n            function Yve(e3) {\n              if (typeof e3 == "string") return l0t[e3.slice(0, 3).toLowerCase()];\n            }\n          });\n          var uI = ye((_sr, Jve) => {\n            "use strict";\n            var u0t = Eo(), lI = Dr();\n            Jve.exports = function(t3, r4, n4, i3) {\n              var a4 = i3.counterAxes || [], o4 = i3.overlayableAxes || [], s3 = i3.letter, l3 = i3.grid, u4 = i3.overlayingDomain, c5, f4, h3, d3, v3, _2;\n              l3 && (f4 = l3._domains[s3][l3._axisMap[r4._id]], c5 = l3._anchors[r4._id], f4 && (h3 = l3[s3 + "side"].split(" ")[0], d3 = l3.domain[s3][h3 === "right" || h3 === "top" ? 1 : 0])), f4 = f4 || [0, 1], c5 = c5 || (u0t(t3.position) ? "free" : a4[0] || "free"), h3 = h3 || (s3 === "x" ? "bottom" : "left"), d3 = d3 || 0, v3 = 0, _2 = false;\n              var b = lI.coerce(t3, r4, { anchor: { valType: "enumerated", values: ["free"].concat(a4), dflt: c5 } }, "anchor"), p3 = lI.coerce(t3, r4, { side: { valType: "enumerated", values: s3 === "x" ? ["bottom", "top"] : ["left", "right"], dflt: h3 } }, "side");\n              if (b === "free") {\n                if (s3 === "y") {\n                  var k4 = n4("autoshift");\n                  k4 && (d3 = p3 === "left" ? u4[0] : u4[1], _2 = r4.automargin ? r4.automargin : true, v3 = p3 === "left" ? -3 : 3), n4("shift", v3);\n                }\n                n4("position", d3);\n              }\n              n4("automargin", _2);\n              var E3 = false;\n              if (o4.length && (E3 = lI.coerce(t3, r4, { overlaying: { valType: "enumerated", values: [false].concat(o4), dflt: false } }, "overlaying")), !E3) {\n                var S2 = n4("domain", f4);\n                S2[0] > S2[1] - 1 / 4096 && (r4.domain = f4), lI.noneOrAll(t3.domain, r4.domain, f4), r4.tickmode === "sync" && (r4.tickmode = "auto");\n              }\n              return n4("layer"), r4;\n            };\n          });\n          var ope = ye((xsr, ape) => {\n            "use strict";\n            var Wb = Dr(), $ve = ka(), c0t = ip().isUnifiedHover, f0t = HB(), Qve = vl(), h0t = c3(), epe = Rd(), d0t = SU(), tpe = i4(), v0t = Nb(), rpe = uI(), kU = hf(), Cm = kU.id2name, ipe = kU.name2id, p0t = hd().AX_ID_PATTERN, npe = qa(), cI = npe.traceIs, EU = npe.getComponentMethod;\n            function fI(e3, t3, r4) {\n              Array.isArray(e3[t3]) ? e3[t3].push(r4) : e3[t3] = [r4];\n            }\n            ape.exports = function(t3, r4, n4) {\n              var i3 = r4.autotypenumbers, a4 = {}, o4 = {}, s3 = {}, l3 = {}, u4 = {}, c5 = {}, f4 = {}, h3 = {}, d3 = {}, v3 = {}, _2, b;\n              for (_2 = 0; _2 < n4.length; _2++) {\n                var p3 = n4[_2];\n                if (cI(p3, "cartesian")) {\n                  var k4;\n                  if (p3.xaxis) k4 = Cm(p3.xaxis), fI(a4, k4, p3);\n                  else if (p3.xaxes) for (b = 0; b < p3.xaxes.length; b++) fI(a4, Cm(p3.xaxes[b]), p3);\n                  var E3;\n                  if (p3.yaxis) E3 = Cm(p3.yaxis), fI(a4, E3, p3);\n                  else if (p3.yaxes) for (b = 0; b < p3.yaxes.length; b++) fI(a4, Cm(p3.yaxes[b]), p3);\n                  if (p3.type === "funnel" ? p3.orientation === "h" ? (k4 && (o4[k4] = true), E3 && (f4[E3] = true)) : E3 && (s3[E3] = true) : p3.type === "image" ? (E3 && (h3[E3] = true), k4 && (h3[k4] = true)) : (E3 && (u4[E3] = true, c5[E3] = true), (!cI(p3, "carpet") || p3.type === "carpet" && !p3._cheater) && k4 && (l3[k4] = true)), p3.type === "carpet" && p3._cheater && k4 && (o4[k4] = true), cI(p3, "2dMap") && (d3[k4] = true, d3[E3] = true), cI(p3, "oriented")) {\n                    var S2 = p3.orientation === "h" ? E3 : k4;\n                    v3[S2] = true;\n                  }\n                }\n              }\n              var L3 = r4._subplots, x2 = L3.xaxis, C3 = L3.yaxis, M4 = Wb.simpleMap(x2, Cm), g3 = Wb.simpleMap(C3, Cm), P3 = M4.concat(g3), T3 = $ve.background;\n              x2.length && C3.length && (T3 = Wb.coerce(t3, r4, h0t, "plot_bgcolor"));\n              var z3 = $ve.combine(T3, r4.paper_bgcolor), O3, V2, G2, Z, j3;\n              function N2() {\n                var St = a4[O3] || [];\n                j3._traceIndices = St.map(function(Qt) {\n                  return Qt.index;\n                }), j3._annIndices = [], j3._shapeIndices = [], j3._selectionIndices = [], j3._imgIndices = [], j3._subplotsWith = [], j3._counterAxes = [], j3._name = j3._attr = O3, j3._id = V2;\n              }\n              function H(St, Qt) {\n                return Wb.coerce(Z, j3, epe, St, Qt);\n              }\n              function te(St, Qt) {\n                return Wb.coerce2(Z, j3, epe, St, Qt);\n              }\n              function oe(St) {\n                return St === "x" ? C3 : x2;\n              }\n              function _e(St, Qt) {\n                for (var Vt = St === "x" ? M4 : g3, _t = [], It = 0; It < Vt.length; It++) {\n                  var mt = Vt[It];\n                  mt !== Qt && !(t3[mt] || {}).overlaying && _t.push(ipe(mt));\n                }\n                return _t;\n              }\n              var Ee = { x: oe("x"), y: oe("y") }, Ce = Ee.x.concat(Ee.y), me = {}, ie = [];\n              function Se() {\n                var St = Z.matches;\n                p0t.test(St) && Ce.indexOf(St) === -1 && (me[St] = Z.type, ie = Object.keys(me));\n              }\n              var Le = f0t(t3, r4), Ae = c0t(Le);\n              for (_2 = 0; _2 < P3.length; _2++) {\n                O3 = P3[_2], V2 = ipe(O3), G2 = O3.charAt(0), Wb.isPlainObject(t3[O3]) || (t3[O3] = {}), Z = t3[O3], j3 = Qve.newContainer(r4, O3, G2 + "axis"), N2();\n                var Fe = G2 === "x" && !l3[O3] && o4[O3] || G2 === "y" && !u4[O3] && s3[O3], Pe = G2 === "y" && (!c5[O3] && f4[O3] || h3[O3]), ge = { hasMinor: true, letter: G2, font: r4.font, outerTicks: d3[O3], showGrid: !v3[O3], data: a4[O3] || [], bgColor: z3, calendar: r4.calendar, automargin: true, visibleDflt: Fe, reverseDflt: Pe, autotypenumbersDflt: i3, splomStash: ((r4._splomAxes || {})[G2] || {})[V2], noAutotickangles: G2 === "y" };\n                H("uirevision", r4.uirevision), d0t(Z, j3, H, ge), tpe(Z, j3, H, ge, r4);\n                var Re = Ae && G2 === Le.charAt(0), ce = te("spikecolor", Ae ? j3.color : void 0), Ze = te("spikethickness", Ae ? 1.5 : void 0), ut = te("spikedash", Ae ? "dot" : void 0), pt = te("spikemode", Ae ? "across" : void 0), Zt = te("spikesnap"), st = H("showspikes", !!Re || !!ce || !!Ze || !!ut || !!pt || !!Zt);\n                st || (delete j3.spikecolor, delete j3.spikethickness, delete j3.spikedash, delete j3.spikemode, delete j3.spikesnap);\n                var lt = Cm(Z.overlaying), Gt = [0, 1];\n                if (r4[lt] !== void 0) {\n                  var Nt = Cm(r4[lt].anchor);\n                  r4[Nt] !== void 0 && (Gt = r4[Nt].domain);\n                }\n                rpe(Z, j3, H, { letter: G2, counterAxes: Ee[G2], overlayableAxes: _e(G2, O3), grid: r4.grid, overlayingDomain: Gt }), H("title.standoff"), Se(), j3._input = Z;\n              }\n              for (_2 = 0; _2 < ie.length; ) {\n                V2 = ie[_2++], O3 = Cm(V2), G2 = O3.charAt(0), Wb.isPlainObject(t3[O3]) || (t3[O3] = {}), Z = t3[O3], j3 = Qve.newContainer(r4, O3, G2 + "axis"), N2();\n                var Jt = { letter: G2, font: r4.font, outerTicks: d3[O3], showGrid: !v3[O3], data: [], bgColor: z3, calendar: r4.calendar, automargin: true, visibleDflt: false, reverseDflt: false, autotypenumbersDflt: i3, splomStash: ((r4._splomAxes || {})[G2] || {})[V2] };\n                H("uirevision", r4.uirevision), j3.type = me[V2] || "linear", tpe(Z, j3, H, Jt, r4), rpe(Z, j3, H, { letter: G2, counterAxes: Ee[G2], overlayableAxes: _e(G2, O3), grid: r4.grid }), H("fixedrange"), H("modebardisable"), Se(), j3._input = Z;\n              }\n              var sr = EU("rangeslider", "handleDefaults"), wr = EU("rangeselector", "handleDefaults");\n              for (_2 = 0; _2 < M4.length; _2++) O3 = M4[_2], Z = t3[O3], j3 = r4[O3], sr(t3, r4, O3), j3.type === "date" && wr(Z, j3, r4, g3, j3.calendar), H("fixedrange"), H("modebardisable");\n              for (_2 = 0; _2 < g3.length; _2++) {\n                O3 = g3[_2], Z = t3[O3], j3 = r4[O3];\n                var cr = r4[Cm(j3.anchor)], $e = EU("rangeslider", "isVisible")(cr);\n                H("fixedrange", $e), H("modebardisable");\n              }\n              v0t.handleDefaults(t3, r4, { axIds: Ce.concat(ie).sort(kU.idSort), axHasImage: h3 });\n            };\n          });\n          var upe = ye((bsr, lpe) => {\n            "use strict";\n            var g0t = Oa(), spe = qa(), hI = Dr(), Qp = So(), dI = ho();\n            lpe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._fullLayout;\n              if (r4.length === 0) {\n                dI.redrawComponents(t3);\n                return;\n              }\n              function o4(b) {\n                var p3 = b.xaxis, k4 = b.yaxis;\n                a4._defs.select("#" + b.clipId + "> rect").call(Qp.setTranslate, 0, 0).call(Qp.setScale, 1, 1), b.plot.call(Qp.setTranslate, p3._offset, k4._offset).call(Qp.setScale, 1, 1);\n                var E3 = b.plot.selectAll(".scatterlayer .trace");\n                E3.selectAll(".point").call(Qp.setPointGroupScale, 1, 1), E3.selectAll(".textpoint").call(Qp.setTextPointsScale, 1, 1), E3.call(Qp.hideOutsideRangePoints, b);\n              }\n              function s3(b, p3) {\n                var k4 = b.plotinfo, E3 = k4.xaxis, S2 = k4.yaxis, L3 = E3._length, x2 = S2._length, C3 = !!b.xr1, M4 = !!b.yr1, g3 = [];\n                if (C3) {\n                  var P3 = hI.simpleMap(b.xr0, E3.r2l), T3 = hI.simpleMap(b.xr1, E3.r2l), z3 = P3[1] - P3[0], O3 = T3[1] - T3[0];\n                  g3[0] = (P3[0] * (1 - p3) + p3 * T3[0] - P3[0]) / (P3[1] - P3[0]) * L3, g3[2] = L3 * (1 - p3 + p3 * O3 / z3), E3.range[0] = E3.l2r(P3[0] * (1 - p3) + p3 * T3[0]), E3.range[1] = E3.l2r(P3[1] * (1 - p3) + p3 * T3[1]);\n                } else g3[0] = 0, g3[2] = L3;\n                if (M4) {\n                  var V2 = hI.simpleMap(b.yr0, S2.r2l), G2 = hI.simpleMap(b.yr1, S2.r2l), Z = V2[1] - V2[0], j3 = G2[1] - G2[0];\n                  g3[1] = (V2[1] * (1 - p3) + p3 * G2[1] - V2[1]) / (V2[0] - V2[1]) * x2, g3[3] = x2 * (1 - p3 + p3 * j3 / Z), S2.range[0] = E3.l2r(V2[0] * (1 - p3) + p3 * G2[0]), S2.range[1] = S2.l2r(V2[1] * (1 - p3) + p3 * G2[1]);\n                } else g3[1] = 0, g3[3] = x2;\n                dI.drawOne(t3, E3, { skipTitle: true }), dI.drawOne(t3, S2, { skipTitle: true }), dI.redrawComponents(t3, [E3._id, S2._id]);\n                var N2 = C3 ? L3 / g3[2] : 1, H = M4 ? x2 / g3[3] : 1, te = C3 ? g3[0] : 0, oe = M4 ? g3[1] : 0, _e = C3 ? g3[0] / g3[2] * L3 : 0, Ee = M4 ? g3[1] / g3[3] * x2 : 0, Ce = E3._offset - _e, me = S2._offset - Ee;\n                k4.clipRect.call(Qp.setTranslate, te, oe).call(Qp.setScale, 1 / N2, 1 / H), k4.plot.call(Qp.setTranslate, Ce, me).call(Qp.setScale, N2, H), Qp.setPointGroupScale(k4.zoomScalePts, 1 / N2, 1 / H), Qp.setTextPointsScale(k4.zoomScaleTxt, 1 / N2, 1 / H);\n              }\n              var l3;\n              i3 && (l3 = i3());\n              function u4() {\n                for (var b = {}, p3 = 0; p3 < r4.length; p3++) {\n                  var k4 = r4[p3], E3 = k4.plotinfo.xaxis, S2 = k4.plotinfo.yaxis;\n                  k4.xr1 && (b[E3._name + ".range"] = k4.xr1.slice()), k4.yr1 && (b[S2._name + ".range"] = k4.yr1.slice());\n                }\n                return l3 && l3(), spe.call("relayout", t3, b).then(function() {\n                  for (var L3 = 0; L3 < r4.length; L3++) o4(r4[L3].plotinfo);\n                });\n              }\n              function c5() {\n                for (var b = {}, p3 = 0; p3 < r4.length; p3++) {\n                  var k4 = r4[p3], E3 = k4.plotinfo.xaxis, S2 = k4.plotinfo.yaxis;\n                  k4.xr0 && (b[E3._name + ".range"] = k4.xr0.slice()), k4.yr0 && (b[S2._name + ".range"] = k4.yr0.slice());\n                }\n                return spe.call("relayout", t3, b).then(function() {\n                  for (var L3 = 0; L3 < r4.length; L3++) o4(r4[L3].plotinfo);\n                });\n              }\n              var f4, h3, d3, v3 = g0t.ease(n4.easing);\n              t3._transitionData._interruptCallbacks.push(function() {\n                return window.cancelAnimationFrame(d3), d3 = null, c5();\n              });\n              function _2() {\n                h3 = Date.now();\n                for (var b = Math.min(1, (h3 - f4) / n4.duration), p3 = v3(b), k4 = 0; k4 < r4.length; k4++) s3(r4[k4], p3);\n                h3 - f4 > n4.duration ? (u4(), d3 = window.cancelAnimationFrame(_2)) : d3 = window.requestAnimationFrame(_2);\n              }\n              return f4 = Date.now(), d3 = window.requestAnimationFrame(_2), Promise.resolve();\n            };\n          });\n          var ph = ye((xv) => {\n            "use strict";\n            var pI = Oa(), cpe = qa(), Xb = Dr(), m0t = Mc(), y0t = So(), fpe = Id().getModuleCalcData, g_ = hf(), zg = hd(), _0t = Wp(), iu = Xb.ensureSingle;\n            function vI(e3, t3, r4) {\n              return Xb.ensureSingle(e3, t3, r4, function(n4) {\n                n4.datum(r4);\n              });\n            }\n            var Zb = zg.zindexSeparator;\n            xv.name = "cartesian";\n            xv.attr = ["xaxis", "yaxis"];\n            xv.idRoot = ["x", "y"];\n            xv.idRegex = zg.idRegex;\n            xv.attrRegex = zg.attrRegex;\n            xv.attributes = qve();\n            xv.layoutAttributes = Rd();\n            xv.supplyLayoutDefaults = ope();\n            xv.transitionAxes = upe();\n            xv.finalizeSubplots = function(e3, t3) {\n              var r4 = t3._subplots, n4 = r4.xaxis, i3 = r4.yaxis, a4 = r4.cartesian, o4 = a4, s3 = {}, l3 = {}, u4, c5, f4;\n              for (u4 = 0; u4 < o4.length; u4++) {\n                var h3 = o4[u4].split("y");\n                s3[h3[0]] = 1, l3["y" + h3[1]] = 1;\n              }\n              for (u4 = 0; u4 < n4.length; u4++) c5 = n4[u4], s3[c5] || (f4 = (e3[g_.id2name(c5)] || {}).anchor, zg.idRegex.y.test(f4) || (f4 = "y"), a4.push(c5 + f4), o4.push(c5 + f4), l3[f4] || (l3[f4] = 1, Xb.pushUnique(i3, f4)));\n              for (u4 = 0; u4 < i3.length; u4++) f4 = i3[u4], l3[f4] || (c5 = (e3[g_.id2name(f4)] || {}).anchor, zg.idRegex.x.test(c5) || (c5 = "x"), a4.push(c5 + f4), o4.push(c5 + f4), s3[c5] || (s3[c5] = 1, Xb.pushUnique(n4, c5)));\n              if (!o4.length) {\n                c5 = "", f4 = "";\n                for (var d3 in e3) if (zg.attrRegex.test(d3)) {\n                  var v3 = d3.charAt(0);\n                  v3 === "x" ? (!c5 || +d3.slice(5) < +c5.slice(5)) && (c5 = d3) : (!f4 || +d3.slice(5) < +f4.slice(5)) && (f4 = d3);\n                }\n                c5 = c5 ? g_.name2id(c5) : "x", f4 = f4 ? g_.name2id(f4) : "y", n4.push(c5), i3.push(f4), a4.push(c5 + f4);\n              }\n            };\n            xv.plot = function(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = i3._subplots.cartesian, o4 = e3.calcdata, s3;\n              if (!Array.isArray(t3)) for (t3 = [], s3 = 0; s3 < o4.length; s3++) t3.push(s3);\n              for (var l3 = i3._zindices, u4 = 0; u4 < l3.length; u4++) {\n                var c5 = l3[u4];\n                for (s3 = 0; s3 < a4.length; s3++) {\n                  var f4 = a4[s3], h3 = i3._plots[f4];\n                  if (u4 > 0) {\n                    var d3 = h3.id;\n                    if (d3.indexOf(Zb) !== -1) continue;\n                    d3 += Zb + (u4 + 1), h3 = Xb.extendFlat({}, h3, { id: d3, plot: i3._cartesianlayer.selectAll(".subplot").select("." + d3) });\n                  }\n                  for (var v3 = [], _2, b = 0; b < o4.length; b++) {\n                    var p3 = o4[b], k4 = p3[0].trace;\n                    c5 === (k4.zorder || 0) && k4.xaxis + k4.yaxis === f4 && ((t3.indexOf(k4.index) !== -1 || k4.carpet) && (_2 && _2[0].trace.xaxis + _2[0].trace.yaxis === f4 && ["tonextx", "tonexty", "tonext"].indexOf(k4.fill) !== -1 && v3.indexOf(_2) === -1 && v3.push(_2), v3.push(p3)), _2 = p3);\n                  }\n                  hpe(e3, h3, v3, r4, n4);\n                }\n              }\n            };\n            function hpe(e3, t3, r4, n4, i3) {\n              for (var a4 = zg.traceLayerClasses, o4 = e3._fullLayout, s3 = o4._zindices, l3 = o4._modules, u4, c5, f4, h3 = [], d3 = [], v3 = 0; v3 < s3.length; v3++) for (var _2 = s3[v3], b = 0; b < l3.length; b++) {\n                u4 = l3[b];\n                var p3 = u4.name, k4 = cpe.modules[p3].categories;\n                if (k4.svg) {\n                  var E3 = u4.layerName || p3 + "layer", S2 = E3 + (v3 ? Number(v3) + 1 : ""), L3 = u4.plot;\n                  c5 = fpe(r4, L3, _2), f4 = c5[0], r4 = c5[1], f4.length && h3.push({ i: a4.indexOf(E3), zindex: v3, className: S2, plotMethod: L3, cdModule: f4 }), k4.zoomScale && d3.push("." + S2);\n                }\n              }\n              h3.sort(function(M4, g3) {\n                return (M4.zindex || 0) - (g3.zindex || 0) || M4.i - g3.i;\n              });\n              var x2 = t3.plot.selectAll("g.mlayer").data(h3, function(M4) {\n                return M4.className;\n              });\n              if (x2.enter().append("g").attr("class", function(M4) {\n                return M4.className;\n              }).classed("mlayer", true).classed("rangeplot", t3.isRangePlot), x2.exit().remove(), x2.order(), x2.each(function(M4) {\n                var g3 = pI.select(this), P3 = M4.className;\n                M4.plotMethod(e3, t3, M4.cdModule, g3, n4, i3), zg.clipOnAxisFalseQuery.indexOf("." + P3) === -1 && y0t.setClipUrl(g3, t3.layerClipId, e3);\n              }), o4._has("scattergl") && (u4 = cpe.getModule("scattergl"), f4 = fpe(r4, u4)[0], u4.plot(e3, t3, f4)), !e3._context.staticPlot && (t3._hasClipOnAxisFalse && (t3.clipOnAxisFalseTraces = t3.plot.selectAll(zg.clipOnAxisFalseQuery.join(",")).selectAll(".trace")), d3.length)) {\n                var C3 = t3.plot.selectAll(d3.join(",")).selectAll(".trace");\n                t3.zoomScalePts = C3.selectAll("path.point"), t3.zoomScaleTxt = C3.selectAll(".textpoint");\n              }\n            }\n            xv.clean = function(e3, t3, r4, n4) {\n              var i3 = n4._plots || {}, a4 = t3._plots || {}, o4 = n4._subplots || {}, s3, l3, u4;\n              if (n4._hasOnlyLargeSploms && !t3._hasOnlyLargeSploms) for (u4 in i3) s3 = i3[u4], s3.plotgroup && s3.plotgroup.remove();\n              var c5 = n4._has && n4._has("gl"), f4 = t3._has && t3._has("gl");\n              if (c5 && !f4) for (u4 in i3) s3 = i3[u4], s3._scene && s3._scene.destroy();\n              if (o4.xaxis && o4.yaxis) {\n                var h3 = g_.listIds({ _fullLayout: n4 });\n                for (l3 = 0; l3 < h3.length; l3++) {\n                  var d3 = h3[l3];\n                  t3[g_.id2name(d3)] || n4._infolayer.selectAll(".g-" + d3 + "title").remove();\n                }\n              }\n              var v3 = n4._has && n4._has("cartesian"), _2 = t3._has && t3._has("cartesian");\n              if (v3 && !_2) vpe(n4._cartesianlayer.selectAll(".subplot"), n4), n4._defs.selectAll(".axesclip").remove(), delete n4._axisConstraintGroups, delete n4._axisMatchGroups;\n              else if (o4.cartesian) for (l3 = 0; l3 < o4.cartesian.length; l3++) {\n                var b = o4.cartesian[l3];\n                if (b.indexOf(Zb) === -1 && !a4[b]) {\n                  var p3 = "." + b + ",." + b + "-x,." + b + "-y";\n                  n4._cartesianlayer.selectAll(p3).remove(), ppe(b, n4);\n                }\n              }\n            };\n            xv.drawFramework = function(e3) {\n              var t3 = e3._fullLayout, r4 = e3.calcdata, n4, i3 = {};\n              for (n4 = 0; n4 < r4.length; n4++) {\n                var a4 = r4[n4][0], o4 = a4.trace, s3 = o4.zorder || 0;\n                i3[s3] || (i3[s3] = []), i3[s3].push(a4);\n              }\n              var l3 = Object.keys(i3).map(Number).sort(Xb.sorterAsc);\n              l3.length || (l3 = [0]), t3._zindices = l3;\n              var u4 = x0t(e3), c5 = u4.length, f4 = [];\n              for (n4 = 0; n4 < c5; n4++) f4[n4] = u4[n4].slice();\n              for (var h3 = 1; h3 < l3.length; h3++) {\n                var d3 = [];\n                for (n4 = 0; n4 < c5; n4++) d3[n4] = u4[n4].slice(), d3[n4][0] += Zb + (h3 + 1);\n                f4 = f4.concat(d3);\n              }\n              var v3 = t3._cartesianlayer.selectAll(".subplot").data(f4, String);\n              v3.enter().append("g").attr("class", function(_2) {\n                return "subplot " + _2[0];\n              }), v3.order(), v3.exit().call(vpe, t3), v3.each(function(_2) {\n                var b = _2[0], p3 = b.indexOf(Zb), k4 = p3 !== -1, E3 = k4 ? b.slice(0, p3) : b, S2 = t3._plots[b];\n                S2 || (S2 = Xb.extendFlat({}, t3._plots[E3]), S2 && (S2.id = b, t3._plots[b] = S2, t3._subplots.cartesian.push(b))), S2 && (S2.plotgroup = pI.select(this), dpe(e3, S2), k4 || (S2.draglayer = iu(t3._draggers, "g", b)));\n              });\n            };\n            xv.rangePlot = function(e3, t3, r4) {\n              dpe(e3, t3), hpe(e3, t3, r4), m0t.style(e3);\n            };\n            function x0t(e3) {\n              var t3 = e3._fullLayout, r4 = t3._zindices.length, n4 = t3._subplots.cartesian, i3 = n4.length, a4, o4, s3, l3, u4, c5, f4 = [], h3 = [];\n              for (a4 = 0; a4 < i3; a4++) {\n                s3 = n4[a4], l3 = t3._plots[s3], u4 = l3.xaxis, c5 = l3.yaxis;\n                var d3 = u4._mainAxis, v3 = c5._mainAxis, _2 = d3._id + v3._id, b = t3._plots[_2];\n                l3.overlays = [], _2 !== s3 && b ? (l3.mainplot = _2, l3.mainplotinfo = b, h3.push(s3)) : (l3.mainplot = void 0, l3.mainplotinfo = void 0, f4.push(s3));\n              }\n              for (a4 = 0; a4 < h3.length; a4++) s3 = h3[a4], l3 = t3._plots[s3], l3.mainplotinfo.overlays.push(l3);\n              var p3 = f4.concat(h3), k4 = [];\n              for (a4 = 0; a4 < i3; a4++) {\n                s3 = p3[a4], l3 = t3._plots[s3], u4 = l3.xaxis, c5 = l3.yaxis;\n                for (var E3 = [], S2 = 1; S2 <= r4; S2++) {\n                  var L3 = "";\n                  for (S2 > 1 && (L3 += Zb + S2), E3.push(s3 + L3), o4 = 0; o4 < l3.overlays.length; o4++) E3.push(l3.overlays[o4].id + L3);\n                }\n                E3 = E3.concat([u4.layer, c5.layer, u4.overlaying || "", c5.overlaying || ""]), k4.push(E3);\n              }\n              return k4;\n            }\n            function dpe(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3.plotgroup, i3 = t3.id, a4 = i3.indexOf(Zb), o4 = a4 !== -1, s3 = zg.layerValue2layerClass[t3.xaxis.layer], l3 = zg.layerValue2layerClass[t3.yaxis.layer], u4 = r4._hasOnlyLargeSploms, c5 = r4._zindices.length > 1, f4 = t3.mainplotinfo;\n              if (!t3.mainplot || c5) if (u4) t3.xlines = iu(n4, "path", "xlines-above"), t3.ylines = iu(n4, "path", "ylines-above"), t3.xaxislayer = iu(n4, "g", "xaxislayer-above"), t3.yaxislayer = iu(n4, "g", "yaxislayer-above");\n              else {\n                if (!o4) {\n                  var h3 = iu(n4, "g", "layer-subplot");\n                  t3.shapelayer = iu(h3, "g", "shapelayer"), t3.imagelayer = iu(h3, "g", "imagelayer"), f4 && c5 ? (t3.minorGridlayer = f4.minorGridlayer, t3.gridlayer = f4.gridlayer, t3.zerolinelayer = f4.zerolinelayer) : (t3.minorGridlayer = iu(n4, "g", "minor-gridlayer"), t3.gridlayer = iu(n4, "g", "gridlayer"), t3.zerolinelayer = iu(n4, "g", "zerolinelayer"));\n                  var d3 = iu(n4, "g", "layer-between");\n                  t3.shapelayerBetween = iu(d3, "g", "shapelayer"), t3.imagelayerBetween = iu(d3, "g", "imagelayer"), iu(n4, "path", "xlines-below"), iu(n4, "path", "ylines-below"), t3.overlinesBelow = iu(n4, "g", "overlines-below"), iu(n4, "g", "xaxislayer-below"), iu(n4, "g", "yaxislayer-below"), t3.overaxesBelow = iu(n4, "g", "overaxes-below");\n                }\n                t3.overplot = iu(n4, "g", "overplot"), t3.plot = iu(t3.overplot, "g", i3), f4 && c5 ? t3.zerolinelayerAbove = f4.zerolinelayerAbove : t3.zerolinelayerAbove = iu(n4, "g", "zerolinelayer-above"), o4 || (t3.xlines = iu(n4, "path", "xlines-above"), t3.ylines = iu(n4, "path", "ylines-above"), t3.overlinesAbove = iu(n4, "g", "overlines-above"), iu(n4, "g", "xaxislayer-above"), iu(n4, "g", "yaxislayer-above"), t3.overaxesAbove = iu(n4, "g", "overaxes-above"), t3.xlines = n4.select(".xlines-" + s3), t3.ylines = n4.select(".ylines-" + l3), t3.xaxislayer = n4.select(".xaxislayer-" + s3), t3.yaxislayer = n4.select(".yaxislayer-" + l3));\n              }\n              else {\n                var v3 = f4.plotgroup, _2 = i3 + "-x", b = i3 + "-y";\n                t3.minorGridlayer = f4.minorGridlayer, t3.gridlayer = f4.gridlayer, t3.zerolinelayer = f4.zerolinelayer, t3.zerolinelayerAbove = f4.zerolinelayerAbove, iu(f4.overlinesBelow, "path", _2), iu(f4.overlinesBelow, "path", b), iu(f4.overaxesBelow, "g", _2), iu(f4.overaxesBelow, "g", b), t3.plot = iu(f4.overplot, "g", i3), iu(f4.overlinesAbove, "path", _2), iu(f4.overlinesAbove, "path", b), iu(f4.overaxesAbove, "g", _2), iu(f4.overaxesAbove, "g", b), t3.xlines = v3.select(".overlines-" + s3).select("." + _2), t3.ylines = v3.select(".overlines-" + l3).select("." + b), t3.xaxislayer = v3.select(".overaxes-" + s3).select("." + _2), t3.yaxislayer = v3.select(".overaxes-" + l3).select("." + b);\n              }\n              o4 || (u4 || (vI(t3.minorGridlayer, "g", t3.xaxis._id), vI(t3.minorGridlayer, "g", t3.yaxis._id), t3.minorGridlayer.selectAll("g").map(function(p3) {\n                return p3[0];\n              }).sort(g_.idSort), vI(t3.gridlayer, "g", t3.xaxis._id), vI(t3.gridlayer, "g", t3.yaxis._id), t3.gridlayer.selectAll("g").map(function(p3) {\n                return p3[0];\n              }).sort(g_.idSort)), t3.xlines.style("fill", "none").classed("crisp", true), t3.ylines.style("fill", "none").classed("crisp", true));\n            }\n            function vpe(e3, t3) {\n              if (e3) {\n                var r4 = {};\n                e3.each(function(l3) {\n                  var u4 = l3[0], c5 = pI.select(this);\n                  c5.remove(), ppe(u4, t3), r4[u4] = true;\n                });\n                for (var n4 in t3._plots) for (var i3 = t3._plots[n4], a4 = i3.overlays || [], o4 = 0; o4 < a4.length; o4++) {\n                  var s3 = a4[o4];\n                  r4[s3.id] && s3.plot.selectAll(".trace").remove();\n                }\n              }\n            }\n            function ppe(e3, t3) {\n              t3._draggers.selectAll("g." + e3).remove(), t3._defs.select("#clip" + t3._uid + e3 + "plot").remove();\n            }\n            xv.toSVG = function(e3) {\n              var t3 = e3._fullLayout._glimages, r4 = pI.select(e3).selectAll(".svg-container"), n4 = r4.filter(function(a4, o4) {\n                return o4 === r4.size() - 1;\n              }).selectAll(".gl-canvas-context, .gl-canvas-focus");\n              function i3() {\n                var a4 = this, o4 = a4.toDataURL("image/png"), s3 = t3.append("svg:image");\n                s3.attr({ xmlns: _0t.svg, "xlink:href": o4, preserveAspectRatio: "none", x: 0, y: 0, width: a4.style.width, height: a4.style.height });\n              }\n              n4.each(i3);\n            };\n            xv.updateFx = UN().updateFx;\n          });\n          var mpe = ye((Tsr, gpe) => {\n            "use strict";\n            var gI = Ru();\n            gpe.exports = { hasLines: gI.hasLines, hasMarkers: gI.hasMarkers, hasText: gI.hasText, isBubble: gI.isBubble, attributes: pf(), layoutAttributes: X6(), supplyDefaults: Gde(), crossTraceDefaults: aU(), supplyLayoutDefaults: Xde(), calc: O0().calc, crossTraceCalc: mve(), arraysToCalcdata: km(), plot: sT(), colorbar: $d(), formatLabels: nI(), style: op().style, styleOnSelect: op().styleOnSelect, hoverPoints: fT(), selectPoints: hT(), animatable: true, moduleType: "trace", name: "scatter", basePlotModule: ph(), categories: ["cartesian", "svg", "symbols", "errorBarsOK", "showLegend", "scatter-like", "zoomScale"], meta: {} };\n          });\n          var xpe = ye((Asr, _pe) => {\n            "use strict";\n            var b0t = Oa(), w0t = ka(), ype = IN(), CU = Dr(), T0t = CU.strScale, A0t = CU.strRotate, S0t = CU.strTranslate;\n            _pe.exports = function(t3, r4, n4) {\n              var i3 = t3.node(), a4 = ype[n4.arrowhead || 0], o4 = ype[n4.startarrowhead || 0], s3 = (n4.arrowwidth || 1) * (n4.arrowsize || 1), l3 = (n4.arrowwidth || 1) * (n4.startarrowsize || 1), u4 = r4.indexOf("start") >= 0, c5 = r4.indexOf("end") >= 0, f4 = a4.backoff * s3 + n4.standoff, h3 = o4.backoff * l3 + n4.startstandoff, d3, v3, _2, b;\n              if (i3.nodeName === "line") {\n                d3 = { x: +t3.attr("x1"), y: +t3.attr("y1") }, v3 = { x: +t3.attr("x2"), y: +t3.attr("y2") };\n                var p3 = d3.x - v3.x, k4 = d3.y - v3.y;\n                if (_2 = Math.atan2(k4, p3), b = _2 + Math.PI, f4 && h3 && f4 + h3 > Math.sqrt(p3 * p3 + k4 * k4)) {\n                  V2();\n                  return;\n                }\n                if (f4) {\n                  if (f4 * f4 > p3 * p3 + k4 * k4) {\n                    V2();\n                    return;\n                  }\n                  var E3 = f4 * Math.cos(_2), S2 = f4 * Math.sin(_2);\n                  v3.x += E3, v3.y += S2, t3.attr({ x2: v3.x, y2: v3.y });\n                }\n                if (h3) {\n                  if (h3 * h3 > p3 * p3 + k4 * k4) {\n                    V2();\n                    return;\n                  }\n                  var L3 = h3 * Math.cos(_2), x2 = h3 * Math.sin(_2);\n                  d3.x -= L3, d3.y -= x2, t3.attr({ x1: d3.x, y1: d3.y });\n                }\n              } else if (i3.nodeName === "path") {\n                var C3 = i3.getTotalLength(), M4 = "";\n                if (C3 < f4 + h3) {\n                  V2();\n                  return;\n                }\n                var g3 = i3.getPointAtLength(0), P3 = i3.getPointAtLength(0.1);\n                _2 = Math.atan2(g3.y - P3.y, g3.x - P3.x), d3 = i3.getPointAtLength(Math.min(h3, C3)), M4 = "0px," + h3 + "px,";\n                var T3 = i3.getPointAtLength(C3), z3 = i3.getPointAtLength(C3 - 0.1);\n                b = Math.atan2(T3.y - z3.y, T3.x - z3.x), v3 = i3.getPointAtLength(Math.max(0, C3 - f4));\n                var O3 = M4 ? h3 + f4 : f4;\n                M4 += C3 - O3 + "px," + C3 + "px", t3.style("stroke-dasharray", M4);\n              }\n              function V2() {\n                t3.style("stroke-dasharray", "0px,100px");\n              }\n              function G2(Z, j3, N2, H) {\n                Z.path && (Z.noRotate && (N2 = 0), b0t.select(i3.parentNode).append("path").attr({ class: t3.attr("class"), d: Z.path, transform: S0t(j3.x, j3.y) + A0t(N2 * 180 / Math.PI) + T0t(H) }).style({ fill: w0t.rgb(n4.arrowcolor), "stroke-width": 0 }));\n              }\n              u4 && G2(o4, d3, _2, l3), c5 && G2(a4, v3, b, s3);\n            };\n          });\n          var mI = ye((Ssr, Spe) => {\n            "use strict";\n            var bpe = Oa(), LU = qa(), M0t = Mc(), y_ = Dr(), PU = y_.strTranslate, a4 = ho(), Yb = ka(), Iy = So(), wpe = vf(), IU = ru(), RU = Sg(), n4 = yv(), E0t = vl().arrayEditor, k0t = xpe();\n            Spe.exports = { draw: C0t, drawOne: Tpe, drawRaw: Ape };\n            function C0t(e3) {\n              var t3 = e3._fullLayout;\n              t3._infolayer.selectAll(".annotation").remove();\n              for (var r4 = 0; r4 < t3.annotations.length; r4++) t3.annotations[r4].visible && Tpe(e3, r4);\n              return M0t.previousPromises(e3);\n            }\n            function Tpe(e3, t3) {\n              var r4 = e3._fullLayout, n5 = r4.annotations[t3] || {}, i3 = a4.getFromId(e3, n5.xref), a5 = a4.getFromId(e3, n5.yref);\n              i3 && i3.setScale(), a5 && a5.setScale(), Ape(e3, n5, t3, false, i3, a5);\n            }\n            function m_(e3, t3, r4, n5, i3) {\n              var a5 = i3[r4], o4 = i3[r4 + "ref"], s3 = r4.indexOf("y") !== -1, l3 = a4.getRefType(o4) === "domain", u4 = s3 ? n5.h : n5.w;\n              return e3 ? l3 ? a5 + (s3 ? -t3 : t3) / e3._length : e3.p2r(e3.r2p(a5) + t3) : a5 + (s3 ? -t3 : t3) / u4;\n            }\n            function Ape(e3, t3, r4, n5, i3, a5) {\n              var o4 = e3._fullLayout, s3 = e3._fullLayout._size, l3 = e3._context.edits, u4, c5;\n              n5 ? (u4 = "annotation-" + n5, c5 = n5 + ".annotations") : (u4 = "annotation", c5 = "annotations");\n              var f4 = E0t(e3.layout, c5, t3), h3 = f4.modifyBase, d3 = f4.modifyItem, v3 = f4.getUpdateObj;\n              o4._infolayer.selectAll("." + u4 + \'[data-index="\' + r4 + \'"]\').remove();\n              var _2 = "clip" + o4._uid + "_ann" + r4;\n              if (!t3._input || t3.visible === false) {\n                bpe.selectAll("#" + _2).remove();\n                return;\n              }\n              var b = { x: {}, y: {} }, p3 = +t3.textangle || 0, k4 = o4._infolayer.append("g").classed(u4, true).attr("data-index", String(r4)).style("opacity", t3.opacity), E3 = k4.append("g").classed("annotation-text-g", true), S2 = l3[t3.showarrow ? "annotationTail" : "annotationPosition"], L3 = t3.captureevents || l3.annotationText || S2;\n              function x2(H) {\n                var te = { index: r4, annotation: t3._input, fullAnnotation: t3, event: H };\n                return n5 && (te.subplotId = n5), te;\n              }\n              var C3 = E3.append("g").style("pointer-events", L3 ? "all" : null).call(RU, "pointer").on("click", function() {\n                e3._dragging = false, e3.emit("plotly_clickannotation", x2(bpe.event));\n              });\n              t3.hovertext && C3.on("mouseover", function() {\n                var H = t3.hoverlabel, te = H.font, oe = this.getBoundingClientRect(), _e = e3.getBoundingClientRect();\n                wpe.loneHover({ x0: oe.left - _e.left, x1: oe.right - _e.left, y: (oe.top + oe.bottom) / 2 - _e.top, text: t3.hovertext, color: H.bgcolor, borderColor: H.bordercolor, fontFamily: te.family, fontSize: te.size, fontColor: te.color, fontWeight: te.weight, fontStyle: te.style, fontVariant: te.variant, fontShadow: te.fontShadow, fontLineposition: te.fontLineposition, fontTextcase: te.fontTextcase }, { container: o4._hoverlayer.node(), outerContainer: o4._paper.node(), gd: e3 });\n              }).on("mouseout", function() {\n                wpe.loneUnhover(o4._hoverlayer.node());\n              });\n              var M4 = t3.borderwidth, g3 = t3.borderpad, P3 = M4 + g3, T3 = C3.append("rect").attr("class", "bg").style("stroke-width", M4 + "px").call(Yb.stroke, t3.bordercolor).call(Yb.fill, t3.bgcolor), z3 = t3.width || t3.height, O3 = o4._topclips.selectAll("#" + _2).data(z3 ? [0] : []);\n              O3.enter().append("clipPath").classed("annclip", true).attr("id", _2).append("rect"), O3.exit().remove();\n              var V2 = t3.font, G2 = o4._meta ? y_.templateString(t3.text, o4._meta) : t3.text, Z = C3.append("text").classed("annotation-text", true).text(G2);\n              function j3(H) {\n                return H.call(Iy.font, V2).attr({ "text-anchor": { left: "start", right: "end" }[t3.align] || "middle" }), IU.convertToTspans(H, e3, N2), H;\n              }\n              function N2() {\n                var H = Z.selectAll("a");\n                if (H.size() === 1 && H.text() === Z.text()) {\n                  var te = C3.insert("a", ":first-child").attr({ "xlink:xlink:href": H.attr("xlink:href"), "xlink:xlink:show": H.attr("xlink:show") }).style({ cursor: "pointer" });\n                  te.node().appendChild(T3.node());\n                }\n                var oe = C3.select(".annotation-text-math-group"), _e = !oe.empty(), Ee = Iy.bBox((_e ? oe : Z).node()), Ce = Ee.width, me = Ee.height, ie = t3.width || Ce, Se = t3.height || me, Le = Math.round(ie + 2 * P3), Ae = Math.round(Se + 2 * P3);\n                function Fe(je, tt) {\n                  return tt === "auto" && (je < 1 / 3 ? tt = "left" : je > 2 / 3 ? tt = "right" : tt = "center"), { center: 0, middle: 0, left: 0.5, bottom: -0.5, right: -0.5, top: 0.5 }[tt];\n                }\n                for (var Pe = false, ge = ["x", "y"], Re = 0; Re < ge.length; Re++) {\n                  var ce = ge[Re], Ze = t3[ce + "ref"] || ce, ut = t3["a" + ce + "ref"], pt = { x: i3, y: a5 }[ce], Zt = (p3 + (ce === "x" ? 0 : -90)) * Math.PI / 180, st = Le * Math.cos(Zt), lt = Ae * Math.sin(Zt), Gt = Math.abs(st) + Math.abs(lt), Nt = t3[ce + "anchor"], Jt = t3[ce + "shift"] * (ce === "x" ? 1 : -1), sr = b[ce], wr, cr, $e, St, Qt, Vt = a4.getRefType(Ze);\n                  if (pt && Vt !== "domain") {\n                    var _t = pt.r2fraction(t3[ce]);\n                    (_t < 0 || _t > 1) && (ut === Ze ? (_t = pt.r2fraction(t3["a" + ce]), (_t < 0 || _t > 1) && (Pe = true)) : Pe = true), wr = pt._offset + pt.r2p(t3[ce]), St = 0.5;\n                  } else {\n                    var It = Vt === "domain";\n                    ce === "x" ? ($e = t3[ce], wr = It ? pt._offset + pt._length * $e : wr = s3.l + s3.w * $e) : ($e = 1 - t3[ce], wr = It ? pt._offset + pt._length * $e : wr = s3.t + s3.h * $e), St = t3.showarrow ? 0.5 : $e;\n                  }\n                  if (t3.showarrow) {\n                    sr.head = wr;\n                    var mt = t3["a" + ce];\n                    if (Qt = st * Fe(0.5, t3.xanchor) - lt * Fe(0.5, t3.yanchor), ut === Ze) {\n                      var er = a4.getRefType(ut);\n                      er === "domain" ? (ce === "y" && (mt = 1 - mt), sr.tail = pt._offset + pt._length * mt) : er === "paper" ? ce === "y" ? (mt = 1 - mt, sr.tail = s3.t + s3.h * mt) : sr.tail = s3.l + s3.w * mt : sr.tail = pt._offset + pt.r2p(mt), cr = Qt;\n                    } else sr.tail = wr + mt, cr = Qt + mt;\n                    sr.text = sr.tail + Qt;\n                    var lr = o4[ce === "x" ? "width" : "height"];\n                    if (Ze === "paper" && (sr.head = y_.constrain(sr.head, 1, lr - 1)), ut === "pixel") {\n                      var Tr = -Math.max(sr.tail - 3, sr.text), Lr = Math.min(sr.tail + 3, sr.text) - lr;\n                      Tr > 0 ? (sr.tail += Tr, sr.text += Tr) : Lr > 0 && (sr.tail -= Lr, sr.text -= Lr);\n                    }\n                    sr.tail += Jt, sr.head += Jt;\n                  } else Qt = Gt * Fe(St, Nt), cr = Qt, sr.text = wr + Qt;\n                  sr.text += Jt, Qt += Jt, cr += Jt, t3["_" + ce + "padplus"] = Gt / 2 + cr, t3["_" + ce + "padminus"] = Gt / 2 - cr, t3["_" + ce + "size"] = Gt, t3["_" + ce + "shift"] = Qt;\n                }\n                if (Pe) {\n                  C3.remove();\n                  return;\n                }\n                var ti = 0, Br = 0;\n                if (t3.align !== "left" && (ti = (ie - Ce) * (t3.align === "center" ? 0.5 : 1)), t3.valign !== "top" && (Br = (Se - me) * (t3.valign === "middle" ? 0.5 : 1)), _e) oe.select("svg").attr({ x: P3 + ti - 1, y: P3 + Br }).call(Iy.setClipUrl, z3 ? _2 : null, e3);\n                else {\n                  var Vr = P3 + Br - Ee.top, dt = P3 + ti - Ee.left;\n                  Z.call(IU.positionText, dt, Vr).call(Iy.setClipUrl, z3 ? _2 : null, e3);\n                }\n                O3.select("rect").call(Iy.setRect, P3, P3, ie, Se), T3.call(Iy.setRect, M4 / 2, M4 / 2, Le - M4, Ae - M4), C3.call(Iy.setTranslate, Math.round(b.x.text - Le / 2), Math.round(b.y.text - Ae / 2)), E3.attr({ transform: "rotate(" + p3 + "," + b.x.text + "," + b.y.text + ")" });\n                var Ge = function(je, tt) {\n                  k4.selectAll(".annotation-arrow-g").remove();\n                  var xt = b.x.head, Ie = b.y.head, xe = b.x.tail + je, ke = b.y.tail + tt, vt = b.x.text + je, ir = b.y.text + tt, ar = y_.rotationXYMatrix(p3, vt, ir), vr = y_.apply2DTransform(ar), ii = y_.apply2DTransform2(ar), pi = +T3.attr("width"), $r = +T3.attr("height"), di = vt - 0.5 * pi, ji = di + pi, In = ir - 0.5 * $r, wi = In + $r, On = [[di, In, di, wi], [di, wi, ji, wi], [ji, wi, ji, In], [ji, In, di, In]].map(ii);\n                  if (!On.reduce(function(Qr, Oi) {\n                    return Qr ^ !!y_.segmentsIntersect(xt, Ie, xt + 1e6, Ie + 1e6, Oi[0], Oi[1], Oi[2], Oi[3]);\n                  }, false)) {\n                    On.forEach(function(Qr) {\n                      var Oi = y_.segmentsIntersect(xe, ke, xt, Ie, Qr[0], Qr[1], Qr[2], Qr[3]);\n                      Oi && (xe = Oi.x, ke = Oi.y);\n                    });\n                    var qn = t3.arrowwidth, Fn = t3.arrowcolor, ra = t3.arrowside, la = k4.append("g").style({ opacity: Yb.opacity(Fn) }).classed("annotation-arrow-g", true), Ut = la.append("path").attr("d", "M" + xe + "," + ke + "L" + xt + "," + Ie).style("stroke-width", qn + "px").call(Yb.stroke, Yb.rgb(Fn));\n                    if (k0t(Ut, ra, t3), l3.annotationPosition && Ut.node().parentNode && !n5) {\n                      var wt = xt, rr = Ie;\n                      if (t3.standoff) {\n                        var nr = Math.sqrt(Math.pow(xt - xe, 2) + Math.pow(Ie - ke, 2));\n                        wt += t3.standoff * (xe - xt) / nr, rr += t3.standoff * (ke - Ie) / nr;\n                      }\n                      var Er = la.append("path").classed("annotation-arrow", true).classed("anndrag", true).classed("cursor-move", true).attr({ d: "M3,3H-3V-3H3ZM0,0L" + (xe - wt) + "," + (ke - rr), transform: PU(wt, rr) }).style("stroke-width", qn + 6 + "px").call(Yb.stroke, "rgba(0,0,0,0)").call(Yb.fill, "rgba(0,0,0,0)"), Xr, ri;\n                      n4.init({ element: Er.node(), gd: e3, prepFn: function() {\n                        var Qr = Iy.getTranslate(C3);\n                        Xr = Qr.x, ri = Qr.y, i3 && i3.autorange && h3(i3._name + ".autorange", true), a5 && a5.autorange && h3(a5._name + ".autorange", true);\n                      }, moveFn: function(Qr, Oi) {\n                        var $i = vr(Xr, ri), tn = $i[0] + Qr, fn = $i[1] + Oi;\n                        C3.call(Iy.setTranslate, tn, fn), d3("x", m_(i3, Qr, "x", s3, t3)), d3("y", m_(a5, Oi, "y", s3, t3)), t3.axref === t3.xref && d3("ax", m_(i3, Qr, "ax", s3, t3)), t3.ayref === t3.yref && d3("ay", m_(a5, Oi, "ay", s3, t3)), la.attr("transform", PU(Qr, Oi)), E3.attr({ transform: "rotate(" + p3 + "," + tn + "," + fn + ")" });\n                      }, doneFn: function() {\n                        LU.call("_guiRelayout", e3, v3());\n                        var Qr = document.querySelector(".js-notes-box-panel");\n                        Qr && Qr.redraw(Qr.selectedObj);\n                      } });\n                    }\n                  }\n                };\n                if (t3.showarrow && Ge(0, 0), S2) {\n                  var Je;\n                  n4.init({ element: C3.node(), gd: e3, prepFn: function() {\n                    Je = E3.attr("transform");\n                  }, moveFn: function(je, tt) {\n                    var xt = "pointer";\n                    if (t3.showarrow) t3.axref === t3.xref ? d3("ax", m_(i3, je, "ax", s3, t3)) : d3("ax", t3.ax + je), t3.ayref === t3.yref ? d3("ay", m_(a5, tt, "ay", s3.w, t3)) : d3("ay", t3.ay + tt), Ge(je, tt);\n                    else {\n                      if (n5) return;\n                      var Ie, xe;\n                      if (i3) Ie = m_(i3, je, "x", s3, t3);\n                      else {\n                        var ke = t3._xsize / s3.w, vt = t3.x + (t3._xshift - t3.xshift) / s3.w - ke / 2;\n                        Ie = n4.align(vt + je / s3.w, ke, 0, 1, t3.xanchor);\n                      }\n                      if (a5) xe = m_(a5, tt, "y", s3, t3);\n                      else {\n                        var ir = t3._ysize / s3.h, ar = t3.y - (t3._yshift + t3.yshift) / s3.h - ir / 2;\n                        xe = n4.align(ar - tt / s3.h, ir, 0, 1, t3.yanchor);\n                      }\n                      d3("x", Ie), d3("y", xe), (!i3 || !a5) && (xt = n4.getCursor(i3 ? 0.5 : Ie, a5 ? 0.5 : xe, t3.xanchor, t3.yanchor));\n                    }\n                    E3.attr({ transform: PU(je, tt) + Je }), RU(C3, xt);\n                  }, clickFn: function(je, tt) {\n                    t3.captureevents && e3.emit("plotly_clickannotation", x2(tt));\n                  }, doneFn: function() {\n                    RU(C3), LU.call("_guiRelayout", e3, v3());\n                    var je = document.querySelector(".js-notes-box-panel");\n                    je && je.redraw(je.selectedObj);\n                  } });\n                }\n              }\n              l3.annotationText ? Z.call(IU.makeEditable, { delegate: C3, gd: e3 }).call(j3).on("edit", function(H) {\n                t3.text = H, this.call(j3), d3("text", H), i3 && i3.autorange && h3(i3._name + ".autorange", true), a5 && a5.autorange && h3(a5._name + ".autorange", true), LU.call("_guiRelayout", e3, v3());\n              }) : Z.call(j3);\n            }\n          });\n          var Ppe = ye((Msr, Lpe) => {\n            "use strict";\n            var Mpe = Dr(), L0t = qa(), Epe = vl().arrayEditor;\n            Lpe.exports = { hasClickToShow: P0t, onClick: I0t };\n            function P0t(e3, t3) {\n              var r4 = Cpe(e3, t3);\n              return r4.on.length > 0 || r4.explicitOff.length > 0;\n            }\n            function I0t(e3, t3) {\n              var r4 = Cpe(e3, t3), n4 = r4.on, i3 = r4.off.concat(r4.explicitOff), a4 = {}, o4 = e3._fullLayout.annotations, s3, l3;\n              if (n4.length || i3.length) {\n                for (s3 = 0; s3 < n4.length; s3++) l3 = Epe(e3.layout, "annotations", o4[n4[s3]]), l3.modifyItem("visible", true), Mpe.extendFlat(a4, l3.getUpdateObj());\n                for (s3 = 0; s3 < i3.length; s3++) l3 = Epe(e3.layout, "annotations", o4[i3[s3]]), l3.modifyItem("visible", false), Mpe.extendFlat(a4, l3.getUpdateObj());\n                return L0t.call("update", e3, {}, a4);\n              }\n            }\n            function Cpe(e3, t3) {\n              var r4 = e3._fullLayout.annotations, n4 = [], i3 = [], a4 = [], o4 = (t3 || []).length, s3, l3, u4, c5, f4, h3, d3, v3;\n              for (s3 = 0; s3 < r4.length; s3++) if (u4 = r4[s3], c5 = u4.clicktoshow, c5) {\n                for (l3 = 0; l3 < o4; l3++) if (f4 = t3[l3], h3 = f4.xaxis, d3 = f4.yaxis, h3._id === u4.xref && d3._id === u4.yref && h3.d2r(f4.x) === kpe(u4._xclick, h3) && d3.d2r(f4.y) === kpe(u4._yclick, d3)) {\n                  u4.visible ? c5 === "onout" ? v3 = i3 : v3 = a4 : v3 = n4, v3.push(s3);\n                  break;\n                }\n                l3 === o4 && u4.visible && c5 === "onout" && i3.push(s3);\n              }\n              return { on: n4, off: i3, explicitOff: a4 };\n            }\n            function kpe(e3, t3) {\n              return t3.type === "log" ? t3.l2r(e3) : t3.d2r(e3);\n            }\n          });\n          var FU = ye((Esr, Ipe) => {\n            "use strict";\n            var DU = Dr(), dT = ka();\n            Ipe.exports = function(t3, r4, n4, i3) {\n              i3("opacity");\n              var a4 = i3("bgcolor"), o4 = i3("bordercolor"), s3 = dT.opacity(o4);\n              i3("borderpad");\n              var l3 = i3("borderwidth"), u4 = i3("showarrow");\n              i3("text", u4 ? " " : n4._dfltTitle.annotation), i3("textangle"), DU.coerceFont(i3, "font", n4.font), i3("width"), i3("align");\n              var c5 = i3("height");\n              if (c5 && i3("valign"), u4) {\n                var f4 = i3("arrowside"), h3, d3;\n                f4.indexOf("end") !== -1 && (h3 = i3("arrowhead"), d3 = i3("arrowsize")), f4.indexOf("start") !== -1 && (i3("startarrowhead", h3), i3("startarrowsize", d3)), i3("arrowcolor", s3 ? r4.bordercolor : dT.defaultLine), i3("arrowwidth", (s3 && l3 || 1) * 2), i3("standoff"), i3("startstandoff");\n              }\n              var v3 = i3("hovertext"), _2 = n4.hoverlabel || {};\n              if (v3) {\n                var b = i3("hoverlabel.bgcolor", _2.bgcolor || (dT.opacity(a4) ? dT.rgb(a4) : dT.defaultLine)), p3 = i3("hoverlabel.bordercolor", _2.bordercolor || dT.contrast(b)), k4 = DU.extendFlat({}, _2.font);\n                k4.color || (k4.color = p3), DU.coerceFont(i3, "hoverlabel.font", k4);\n              }\n              i3("captureevents", !!v3);\n            };\n          });\n          var Dpe = ye((ksr, Rpe) => {\n            "use strict";\n            var zU = Dr(), Kb = ho(), R0t = Yd(), D0t = FU(), F0t = Ub();\n            Rpe.exports = function(t3, r4) {\n              R0t(t3, r4, { name: "annotations", handleItemDefaults: z0t });\n            };\n            function z0t(e3, t3, r4) {\n              function n4(E3, S2) {\n                return zU.coerce(e3, t3, F0t, E3, S2);\n              }\n              var i3 = n4("visible"), a4 = n4("clicktoshow");\n              if (i3 || a4) {\n                D0t(e3, t3, r4, n4);\n                for (var o4 = t3.showarrow, s3 = ["x", "y"], l3 = [-10, -30], u4 = { _fullLayout: r4 }, c5 = 0; c5 < 2; c5++) {\n                  var f4 = s3[c5], h3 = Kb.coerceRef(e3, t3, u4, f4, "", "paper");\n                  if (h3 !== "paper") {\n                    var d3 = Kb.getFromId(u4, h3);\n                    d3._annIndices.push(t3._index);\n                  }\n                  if (Kb.coercePosition(t3, u4, n4, h3, f4, 0.5), o4) {\n                    var v3 = "a" + f4, _2 = Kb.coerceRef(e3, t3, u4, v3, "pixel", ["pixel", "paper"]);\n                    _2 !== "pixel" && _2 !== h3 && (_2 = t3[v3] = "pixel");\n                    var b = _2 === "pixel" ? l3[c5] : 0.4;\n                    Kb.coercePosition(t3, u4, n4, _2, v3, b);\n                  }\n                  n4(f4 + "anchor"), n4(f4 + "shift");\n                }\n                if (zU.noneOrAll(e3, t3, ["x", "y"]), o4 && zU.noneOrAll(e3, t3, ["ax", "ay"]), a4) {\n                  var p3 = n4("xclick"), k4 = n4("yclick");\n                  t3._xclick = p3 === void 0 ? t3.x : Kb.cleanPosition(p3, u4, t3.xref), t3._yclick = k4 === void 0 ? t3.y : Kb.cleanPosition(k4, u4, t3.yref);\n                }\n              }\n            }\n          });\n          var Ope = ye((Csr, zpe) => {\n            "use strict";\n            var OU = Dr(), Jb = ho(), O0t = mI().draw;\n            zpe.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = OU.filterVisible(r4.annotations);\n              if (n4.length && t3._fullData.length) return OU.syncOrAsync([O0t, q0t], t3);\n            };\n            function q0t(e3) {\n              var t3 = e3._fullLayout;\n              OU.filterVisible(t3.annotations).forEach(function(r4) {\n                var n4 = Jb.getFromId(e3, r4.xref), i3 = Jb.getFromId(e3, r4.yref), a4 = Jb.getRefType(r4.xref), o4 = Jb.getRefType(r4.yref);\n                r4._extremes = {}, a4 === "range" && Fpe(r4, n4), o4 === "range" && Fpe(r4, i3);\n              });\n            }\n            function Fpe(e3, t3) {\n              var r4 = t3._id, n4 = r4.charAt(0), i3 = e3[n4], a4 = e3["a" + n4], o4 = e3[n4 + "ref"], s3 = e3["a" + n4 + "ref"], l3 = e3["_" + n4 + "padplus"], u4 = e3["_" + n4 + "padminus"], c5 = { x: 1, y: -1 }[n4] * e3[n4 + "shift"], f4 = 3 * e3.arrowsize * e3.arrowwidth || 0, h3 = f4 + c5, d3 = f4 - c5, v3 = 3 * e3.startarrowsize * e3.arrowwidth || 0, _2 = v3 + c5, b = v3 - c5, p3;\n              if (s3 === o4) {\n                var k4 = Jb.findExtremes(t3, [t3.r2c(i3)], { ppadplus: h3, ppadminus: d3 }), E3 = Jb.findExtremes(t3, [t3.r2c(a4)], { ppadplus: Math.max(l3, _2), ppadminus: Math.max(u4, b) });\n                p3 = { min: [k4.min[0], E3.min[0]], max: [k4.max[0], E3.max[0]] };\n              } else _2 = a4 ? _2 + a4 : _2, b = a4 ? b - a4 : b, p3 = Jb.findExtremes(t3, [t3.r2c(i3)], { ppadplus: Math.max(l3, h3, _2), ppadminus: Math.max(u4, d3, b) });\n              e3._extremes[r4] = p3;\n            }\n          });\n          var Bpe = ye((Lsr, qpe) => {\n            "use strict";\n            var B0t = Eo(), N0t = m6();\n            qpe.exports = function(t3, r4, n4, i3) {\n              r4 = r4 || {};\n              var a4 = n4 === "log" && r4.type === "linear", o4 = n4 === "linear" && r4.type === "log";\n              if (!(a4 || o4)) return;\n              var s3 = t3._fullLayout.annotations, l3 = r4._id.charAt(0), u4, c5;\n              function f4(d3) {\n                var v3 = u4[d3], _2 = null;\n                a4 ? _2 = N0t(v3, r4.range) : _2 = Math.pow(10, v3), B0t(_2) || (_2 = null), i3(c5 + d3, _2);\n              }\n              for (var h3 = 0; h3 < s3.length; h3++) u4 = s3[h3], c5 = "annotations[" + h3 + "].", u4[l3 + "ref"] === r4._id && f4(l3), u4["a" + l3 + "ref"] === r4._id && f4("a" + l3);\n            };\n          });\n          var Vpe = ye((Psr, Upe) => {\n            "use strict";\n            var qU = mI(), Npe = Ppe();\n            Upe.exports = { moduleType: "component", name: "annotations", layoutAttributes: Ub(), supplyLayoutDefaults: Dpe(), includeBasePlot: qM()("annotations"), calcAutorange: Ope(), draw: qU.draw, drawOne: qU.drawOne, drawRaw: qU.drawRaw, hasClickToShow: Npe.hasClickToShow, onClick: Npe.onClick, convertCoords: Bpe() };\n          });\n          var yI = ye((Isr, Gpe) => {\n            "use strict";\n            var kc = Ub(), U0t = mc().overrideAll, V0t = vl().templatedArray;\n            Gpe.exports = U0t(V0t("annotation", { visible: kc.visible, x: { valType: "any" }, y: { valType: "any" }, z: { valType: "any" }, ax: { valType: "number" }, ay: { valType: "number" }, xanchor: kc.xanchor, xshift: kc.xshift, yanchor: kc.yanchor, yshift: kc.yshift, text: kc.text, textangle: kc.textangle, font: kc.font, width: kc.width, height: kc.height, opacity: kc.opacity, align: kc.align, valign: kc.valign, bgcolor: kc.bgcolor, bordercolor: kc.bordercolor, borderpad: kc.borderpad, borderwidth: kc.borderwidth, showarrow: kc.showarrow, arrowcolor: kc.arrowcolor, arrowhead: kc.arrowhead, startarrowhead: kc.startarrowhead, arrowside: kc.arrowside, arrowsize: kc.arrowsize, startarrowsize: kc.startarrowsize, arrowwidth: kc.arrowwidth, standoff: kc.standoff, startstandoff: kc.startstandoff, hovertext: kc.hovertext, hoverlabel: kc.hoverlabel, captureevents: kc.captureevents }), "calc", "from-root");\n          });\n          var jpe = ye((Rsr, Hpe) => {\n            "use strict";\n            var BU = Dr(), G0t = ho(), H0t = Yd(), j0t = FU(), W0t = yI();\n            Hpe.exports = function(t3, r4, n4) {\n              H0t(t3, r4, { name: "annotations", handleItemDefaults: X0t, fullLayout: n4.fullLayout });\n            };\n            function X0t(e3, t3, r4, n4) {\n              function i3(s3, l3) {\n                return BU.coerce(e3, t3, W0t, s3, l3);\n              }\n              function a4(s3) {\n                var l3 = s3 + "axis", u4 = { _fullLayout: {} };\n                return u4._fullLayout[l3] = r4[l3], G0t.coercePosition(t3, u4, i3, s3, s3, 0.5);\n              }\n              var o4 = i3("visible");\n              o4 && (j0t(e3, t3, n4.fullLayout, i3), a4("x"), a4("y"), a4("z"), BU.noneOrAll(e3, t3, ["x", "y", "z"]), t3.xref = "x", t3.yref = "y", t3.zref = "z", i3("xanchor"), i3("yanchor"), i3("xshift"), i3("yshift"), t3.showarrow && (t3.axref = "pixel", t3.ayref = "pixel", i3("ax", -10), i3("ay", -30), BU.noneOrAll(e3, t3, ["ax", "ay"])));\n            }\n          });\n          var Ype = ye((Dsr, Zpe) => {\n            "use strict";\n            var Wpe = Dr(), Xpe = ho();\n            Zpe.exports = function(t3) {\n              for (var r4 = t3.fullSceneLayout, n4 = r4.annotations, i3 = 0; i3 < n4.length; i3++) Z0t(n4[i3], t3);\n              t3.fullLayout._infolayer.selectAll(".annotation-" + t3.id).remove();\n            };\n            function Z0t(e3, t3) {\n              var r4 = t3.fullSceneLayout, n4 = r4.domain, i3 = t3.fullLayout._size, a4 = { pdata: null, type: "linear", autorange: false, range: [-1 / 0, 1 / 0] };\n              e3._xa = {}, Wpe.extendFlat(e3._xa, a4), Xpe.setConvert(e3._xa), e3._xa._offset = i3.l + n4.x[0] * i3.w, e3._xa.l2p = function() {\n                return 0.5 * (1 + e3._pdata[0] / e3._pdata[3]) * i3.w * (n4.x[1] - n4.x[0]);\n              }, e3._ya = {}, Wpe.extendFlat(e3._ya, a4), Xpe.setConvert(e3._ya), e3._ya._offset = i3.t + (1 - n4.y[1]) * i3.h, e3._ya.l2p = function() {\n                return 0.5 * (1 - e3._pdata[1] / e3._pdata[3]) * i3.h * (n4.y[1] - n4.y[0]);\n              };\n            }\n          });\n          var UU = ye((Fsr, Kpe) => {\n            "use strict";\n            function NU(e3, t3) {\n              var r4 = [0, 0, 0, 0], n4, i3;\n              for (n4 = 0; n4 < 4; ++n4) for (i3 = 0; i3 < 4; ++i3) r4[i3] += e3[4 * n4 + i3] * t3[n4];\n              return r4;\n            }\n            function Y0t(e3, t3) {\n              var r4 = NU(e3.projection, NU(e3.view, NU(e3.model, [t3[0], t3[1], t3[2], 1])));\n              return r4;\n            }\n            Kpe.exports = Y0t;\n          });\n          var $pe = ye((zsr, Jpe) => {\n            "use strict";\n            var K0t = mI().drawRaw, J0t = UU(), $0t = ["x", "y", "z"];\n            Jpe.exports = function(t3) {\n              for (var r4 = t3.fullSceneLayout, n4 = t3.dataScale, i3 = r4.annotations, a4 = 0; a4 < i3.length; a4++) {\n                for (var o4 = i3[a4], s3 = false, l3 = 0; l3 < 3; l3++) {\n                  var u4 = $0t[l3], c5 = o4[u4], f4 = r4[u4 + "axis"], h3 = f4.r2fraction(c5);\n                  if (h3 < 0 || h3 > 1) {\n                    s3 = true;\n                    break;\n                  }\n                }\n                s3 ? t3.fullLayout._infolayer.select(".annotation-" + t3.id + \'[data-index="\' + a4 + \'"]\').remove() : (o4._pdata = J0t(t3.glplot.cameraParams, [r4.xaxis.r2l(o4.x) * n4[0], r4.yaxis.r2l(o4.y) * n4[1], r4.zaxis.r2l(o4.z) * n4[2]]), K0t(t3.graphDiv, o4, a4, t3.id, o4._xa, o4._ya));\n              }\n            };\n          });\n          var t0e = ye((Osr, e0e) => {\n            "use strict";\n            var Q0t = qa(), Qpe = Dr();\n            e0e.exports = { moduleType: "component", name: "annotations3d", schema: { subplots: { scene: { annotations: yI() } } }, layoutAttributes: yI(), handleDefaults: jpe(), includeBasePlot: egt, convert: Ype(), draw: $pe() };\n            function egt(e3, t3) {\n              var r4 = Q0t.subplotsRegistry.gl3d;\n              if (r4) for (var n4 = r4.attrRegex, i3 = Object.keys(e3), a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                n4.test(o4) && (e3[o4].annotations || []).length && (Qpe.pushUnique(t3._basePlotModules, r4), Qpe.pushUnique(t3._subplots.gl3d, o4));\n              }\n            }\n          });\n          var VU = ye((Bsr, a0e) => {\n            "use strict";\n            var r0e = Ub(), i0e = ec(), n0e = pf().line, tgt = Pd().dash, Og = Ao().extendFlat, rgt = vl().templatedArray, qsr = OM(), vT = Gl(), { shapeTexttemplateAttrs: igt, templatefallbackAttrs: ngt } = Ll(), agt = M6();\n            a0e.exports = rgt("shape", { visible: Og({}, vT.visible, { editType: "calc+arraydraw" }), showlegend: { valType: "boolean", dflt: false, editType: "calc+arraydraw" }, legend: Og({}, vT.legend, { editType: "calc+arraydraw" }), legendgroup: Og({}, vT.legendgroup, { editType: "calc+arraydraw" }), legendgrouptitle: { text: Og({}, vT.legendgrouptitle.text, { editType: "calc+arraydraw" }), font: i0e({ editType: "calc+arraydraw" }), editType: "calc+arraydraw" }, legendrank: Og({}, vT.legendrank, { editType: "calc+arraydraw" }), legendwidth: Og({}, vT.legendwidth, { editType: "calc+arraydraw" }), type: { valType: "enumerated", values: ["circle", "rect", "path", "line"], editType: "calc+arraydraw" }, layer: { valType: "enumerated", values: ["below", "above", "between"], dflt: "above", editType: "arraydraw" }, xref: Og({}, r0e.xref, {}), xsizemode: { valType: "enumerated", values: ["scaled", "pixel"], dflt: "scaled", editType: "calc+arraydraw" }, xanchor: { valType: "any", editType: "calc+arraydraw" }, x0: { valType: "any", editType: "calc+arraydraw" }, x1: { valType: "any", editType: "calc+arraydraw" }, x0shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, x1shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, yref: Og({}, r0e.yref, {}), ysizemode: { valType: "enumerated", values: ["scaled", "pixel"], dflt: "scaled", editType: "calc+arraydraw" }, yanchor: { valType: "any", editType: "calc+arraydraw" }, y0: { valType: "any", editType: "calc+arraydraw" }, y1: { valType: "any", editType: "calc+arraydraw" }, y0shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, y1shift: { valType: "number", dflt: 0, min: -1, max: 1, editType: "calc" }, path: { valType: "string", editType: "calc+arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, line: { color: Og({}, n0e.color, { editType: "arraydraw" }), width: Og({}, n0e.width, { editType: "calc+arraydraw" }), dash: Og({}, tgt, { editType: "arraydraw" }), editType: "calc+arraydraw" }, fillcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "arraydraw" }, fillrule: { valType: "enumerated", values: ["evenodd", "nonzero"], dflt: "evenodd", editType: "arraydraw" }, editable: { valType: "boolean", dflt: false, editType: "calc+arraydraw" }, label: { text: { valType: "string", dflt: "", editType: "arraydraw" }, texttemplate: igt({}, { keys: Object.keys(agt) }), texttemplatefallback: ngt({ editType: "arraydraw" }), font: i0e({ editType: "calc+arraydraw", colorEditType: "arraydraw" }), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right", "start", "middle", "end"], editType: "arraydraw" }, textangle: { valType: "angle", dflt: "auto", editType: "calc+arraydraw" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "auto", editType: "calc+arraydraw" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"], editType: "calc+arraydraw" }, padding: { valType: "number", dflt: 3, min: 0, editType: "arraydraw" }, editType: "arraydraw" }, editType: "arraydraw" });\n          });\n          var l0e = ye((Nsr, s0e) => {\n            "use strict";\n            var o4 = Dr(), pT = ho(), ogt = Yd(), sgt = VU(), o0e = f_();\n            s0e.exports = function(t3, r4) {\n              ogt(t3, r4, { name: "shapes", handleItemDefaults: ugt });\n            };\n            function lgt(e3, t3) {\n              return e3 ? "bottom" : t3.indexOf("top") !== -1 ? "top" : t3.indexOf("bottom") !== -1 ? "bottom" : "middle";\n            }\n            function ugt(e3, t3, r4) {\n              function n4(H, te) {\n                return o4.coerce(e3, t3, sgt, H, te);\n              }\n              t3._isShape = true;\n              var i3 = n4("visible");\n              if (i3) {\n                var a4 = n4("showlegend");\n                a4 && (n4("legend"), n4("legendwidth"), n4("legendgroup"), n4("legendgrouptitle.text"), o4.coerceFont(n4, "legendgrouptitle.font"), n4("legendrank"));\n                var o5 = n4("path"), s3 = o5 ? "path" : "rect", l3 = n4("type", s3), u4 = l3 !== "path";\n                u4 && delete t3.path, n4("editable"), n4("layer"), n4("opacity"), n4("fillcolor"), n4("fillrule");\n                var c5 = n4("line.width");\n                c5 && (n4("line.color"), n4("line.dash"));\n                for (var f4 = n4("xsizemode"), h3 = n4("ysizemode"), d3 = ["x", "y"], v3 = 0; v3 < 2; v3++) {\n                  var _2 = d3[v3], b = _2 + "anchor", p3 = _2 === "x" ? f4 : h3, k4 = { _fullLayout: r4 }, E3, S2, L3, x2 = pT.coerceRef(e3, t3, k4, _2, void 0, "paper"), C3 = pT.getRefType(x2);\n                  if (C3 === "range" ? (E3 = pT.getFromId(k4, x2), E3._shapeIndices.push(t3._index), L3 = o0e.rangeToShapePosition(E3), S2 = o0e.shapePositionToRange(E3), (E3.type === "category" || E3.type === "multicategory") && (n4(_2 + "0shift"), n4(_2 + "1shift"))) : S2 = L3 = o4.identity, u4) {\n                    var M4 = 0.25, g3 = 0.75, P3 = _2 + "0", T3 = _2 + "1", z3 = e3[P3], O3 = e3[T3];\n                    e3[P3] = S2(e3[P3], true), e3[T3] = S2(e3[T3], true), p3 === "pixel" ? (n4(P3, 0), n4(T3, 10)) : (pT.coercePosition(t3, k4, n4, x2, P3, M4), pT.coercePosition(t3, k4, n4, x2, T3, g3)), t3[P3] = L3(t3[P3]), t3[T3] = L3(t3[T3]), e3[P3] = z3, e3[T3] = O3;\n                  }\n                  if (p3 === "pixel") {\n                    var V2 = e3[b];\n                    e3[b] = S2(e3[b], true), pT.coercePosition(t3, k4, n4, x2, b, 0.25), t3[b] = L3(t3[b]), e3[b] = V2;\n                  }\n                }\n                u4 && o4.noneOrAll(e3, t3, ["x0", "x1", "y0", "y1"]);\n                var G2 = l3 === "line", Z, j3;\n                if (u4 && (Z = n4("label.texttemplate"), n4("label.texttemplatefallback")), Z || (j3 = n4("label.text")), j3 || Z) {\n                  n4("label.textangle");\n                  var N2 = n4("label.textposition", G2 ? "middle" : "middle center");\n                  n4("label.xanchor"), n4("label.yanchor", lgt(G2, N2)), n4("label.padding"), o4.coerceFont(n4, "label.font", r4.font);\n                }\n              }\n            }\n          });\n          var f0e = ye((Usr, c0e) => {\n            "use strict";\n            var cgt = ka(), u0e = Dr();\n            function fgt(e3, t3) {\n              return e3 ? "bottom" : t3.indexOf("top") !== -1 ? "top" : t3.indexOf("bottom") !== -1 ? "bottom" : "middle";\n            }\n            c0e.exports = function(t3, r4, n4) {\n              n4("newshape.visible"), n4("newshape.name"), n4("newshape.showlegend"), n4("newshape.legend"), n4("newshape.legendwidth"), n4("newshape.legendgroup"), n4("newshape.legendgrouptitle.text"), u0e.coerceFont(n4, "newshape.legendgrouptitle.font"), n4("newshape.legendrank"), n4("newshape.drawdirection"), n4("newshape.layer"), n4("newshape.fillcolor"), n4("newshape.fillrule"), n4("newshape.opacity");\n              var i3 = n4("newshape.line.width");\n              if (i3) {\n                var a4 = (t3 || {}).plot_bgcolor || "#FFF";\n                n4("newshape.line.color", cgt.contrast(a4)), n4("newshape.line.dash");\n              }\n              var o4 = t3.dragmode === "drawline", s3 = n4("newshape.label.text"), l3 = n4("newshape.label.texttemplate");\n              if (n4("newshape.label.texttemplatefallback"), s3 || l3) {\n                n4("newshape.label.textangle");\n                var u4 = n4("newshape.label.textposition", o4 ? "middle" : "middle center");\n                n4("newshape.label.xanchor"), n4("newshape.label.yanchor", fgt(o4, u4)), n4("newshape.label.padding"), u0e.coerceFont(n4, "newshape.label.font", r4.font);\n              }\n              n4("activeshape.fillcolor"), n4("activeshape.opacity");\n            };\n          });\n          var g0e = ye((Vsr, p0e) => {\n            "use strict";\n            var GU = Dr(), gT = ho(), mT = gM(), d0e = f_();\n            p0e.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = GU.filterVisible(r4.shapes);\n              if (!(!n4.length || !t3._fullData.length)) for (var i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3];\n                a4._extremes = {};\n                var o4, s3, l3 = gT.getRefType(a4.xref), u4 = gT.getRefType(a4.yref);\n                a4.xref !== "paper" && l3 !== "domain" && (o4 = gT.getFromId(t3, a4.xref), s3 = h0e(o4, a4, mT.paramIsX), s3 && (a4._extremes[o4._id] = gT.findExtremes(o4, s3, hgt(a4)))), a4.yref !== "paper" && u4 !== "domain" && (o4 = gT.getFromId(t3, a4.yref), s3 = h0e(o4, a4, mT.paramIsY), s3 && (a4._extremes[o4._id] = gT.findExtremes(o4, s3, dgt(a4))));\n              }\n            };\n            function hgt(e3) {\n              return v0e(e3.line.width, e3.xsizemode, e3.x0, e3.x1, e3.path, false);\n            }\n            function dgt(e3) {\n              return v0e(e3.line.width, e3.ysizemode, e3.y0, e3.y1, e3.path, true);\n            }\n            function v0e(e3, t3, r4, n4, i3, a4) {\n              var o4 = e3 / 2, s3 = a4;\n              if (t3 === "pixel") {\n                var l3 = i3 ? d0e.extractPathCoords(i3, a4 ? mT.paramIsY : mT.paramIsX) : [r4, n4], u4 = GU.aggNums(Math.max, null, l3), c5 = GU.aggNums(Math.min, null, l3), f4 = c5 < 0 ? Math.abs(c5) + o4 : o4, h3 = u4 > 0 ? u4 + o4 : o4;\n                return { ppad: o4, ppadplus: s3 ? f4 : h3, ppadminus: s3 ? h3 : f4 };\n              } else return { ppad: o4 };\n            }\n            function h0e(e3, t3, r4) {\n              var n4 = e3._id.charAt(0) === "x" ? "x" : "y", i3 = e3.type === "category" || e3.type === "multicategory", a4, o4, s3 = 0, l3 = 0, u4 = i3 ? e3.r2c : e3.d2c, c5 = t3[n4 + "sizemode"] === "scaled";\n              if (c5 ? (a4 = t3[n4 + "0"], o4 = t3[n4 + "1"], i3 && (s3 = t3[n4 + "0shift"], l3 = t3[n4 + "1shift"])) : (a4 = t3[n4 + "anchor"], o4 = t3[n4 + "anchor"]), a4 !== void 0) return [u4(a4) + s3, u4(o4) + l3];\n              if (t3.path) {\n                var f4 = 1 / 0, h3 = -1 / 0, d3 = t3.path.match(mT.segmentRE), v3, _2, b, p3, k4;\n                for (e3.type === "date" && (u4 = d0e.decodeDate(u4)), v3 = 0; v3 < d3.length; v3++) _2 = d3[v3], b = r4[_2.charAt(0)].drawn, b !== void 0 && (p3 = d3[v3].slice(1).match(mT.paramRE), !(!p3 || p3.length < b) && (k4 = u4(p3[b]), k4 < f4 && (f4 = k4), k4 > h3 && (h3 = k4)));\n                if (h3 >= f4) return [f4, h3];\n              }\n            }\n          });\n          var _0e = ye((Gsr, y0e) => {\n            "use strict";\n            var m0e = lP();\n            y0e.exports = { moduleType: "component", name: "shapes", layoutAttributes: VU(), supplyLayoutDefaults: l0e(), supplyDrawNewShapeDefaults: f0e(), includeBasePlot: qM()("shapes"), calcAutorange: g0e(), draw: m0e.draw, drawOne: m0e.drawOne };\n          });\n          var HU = ye((jsr, b0e) => {\n            "use strict";\n            var x0e = hd(), vgt = vl().templatedArray, Hsr = OM();\n            b0e.exports = vgt("image", { visible: { valType: "boolean", dflt: true, editType: "arraydraw" }, source: { valType: "string", editType: "arraydraw" }, layer: { valType: "enumerated", values: ["below", "above"], dflt: "above", editType: "arraydraw" }, sizex: { valType: "number", dflt: 0, editType: "arraydraw" }, sizey: { valType: "number", dflt: 0, editType: "arraydraw" }, sizing: { valType: "enumerated", values: ["fill", "contain", "stretch"], dflt: "contain", editType: "arraydraw" }, opacity: { valType: "number", min: 0, max: 1, dflt: 1, editType: "arraydraw" }, x: { valType: "any", dflt: 0, editType: "arraydraw" }, y: { valType: "any", dflt: 0, editType: "arraydraw" }, xanchor: { valType: "enumerated", values: ["left", "center", "right"], dflt: "left", editType: "arraydraw" }, yanchor: { valType: "enumerated", values: ["top", "middle", "bottom"], dflt: "top", editType: "arraydraw" }, xref: { valType: "enumerated", values: ["paper", x0e.idRegex.x.toString()], dflt: "paper", editType: "arraydraw" }, yref: { valType: "enumerated", values: ["paper", x0e.idRegex.y.toString()], dflt: "paper", editType: "arraydraw" }, editType: "arraydraw" });\n          });\n          var T0e = ye((Wsr, w0e) => {\n            "use strict";\n            var pgt = Dr(), jU = ho(), ggt = Yd(), mgt = HU(), ygt = "images";\n            w0e.exports = function(t3, r4) {\n              var n4 = { name: ygt, handleItemDefaults: _gt };\n              ggt(t3, r4, n4);\n            };\n            function _gt(e3, t3, r4) {\n              function n4(h3, d3) {\n                return pgt.coerce(e3, t3, mgt, h3, d3);\n              }\n              var i3 = n4("source"), a4 = n4("visible", !!i3);\n              if (!a4) return t3;\n              n4("layer"), n4("xanchor"), n4("yanchor"), n4("sizex"), n4("sizey"), n4("sizing"), n4("opacity");\n              for (var o4 = { _fullLayout: r4 }, s3 = ["x", "y"], l3 = 0; l3 < 2; l3++) {\n                var u4 = s3[l3], c5 = jU.coerceRef(e3, t3, o4, u4, "paper", void 0);\n                if (c5 !== "paper") {\n                  var f4 = jU.getFromId(o4, c5);\n                  f4._imgIndices.push(t3._index);\n                }\n                jU.coercePosition(t3, o4, n4, c5, u4, 0);\n              }\n              return t3;\n            }\n          });\n          var E0e = ye((Xsr, M0e) => {\n            "use strict";\n            var A0e = Oa(), xgt = So(), yT = ho(), S0e = hf(), bgt = Wp();\n            M0e.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = [], i3 = {}, a4 = [], o4, s3;\n              for (s3 = 0; s3 < r4.images.length; s3++) {\n                var l3 = r4.images[s3];\n                if (l3.visible) if (l3.layer === "below" && l3.xref !== "paper" && l3.yref !== "paper") {\n                  o4 = S0e.ref2id(l3.xref) + S0e.ref2id(l3.yref);\n                  var u4 = r4._plots[o4];\n                  if (!u4) {\n                    a4.push(l3);\n                    continue;\n                  }\n                  u4.mainplot && (o4 = u4.mainplot.id), i3[o4] || (i3[o4] = []), i3[o4].push(l3);\n                } else l3.layer === "above" ? n4.push(l3) : a4.push(l3);\n              }\n              var c5 = { x: { left: { sizing: "xMin", offset: 0 }, center: { sizing: "xMid", offset: -1 / 2 }, right: { sizing: "xMax", offset: -1 } }, y: { top: { sizing: "YMin", offset: 0 }, middle: { sizing: "YMid", offset: -1 / 2 }, bottom: { sizing: "YMax", offset: -1 } } };\n              function f4(S2) {\n                var L3 = A0e.select(this);\n                if (this._imgSrc !== S2.source) if (L3.attr("xmlns", bgt.svg), !t3._context.staticPlot || S2.source && S2.source.slice(0, 5) === "data:") L3.attr("xlink:href", S2.source), this._imgSrc = S2.source;\n                else {\n                  var x2 = new Promise(function(C3) {\n                    var M4 = new Image();\n                    this.img = M4, M4.setAttribute("crossOrigin", "anonymous"), M4.onerror = g3, M4.onload = function() {\n                      var P3 = document.createElement("canvas");\n                      P3.width = this.width, P3.height = this.height;\n                      var T3 = P3.getContext("2d", { willReadFrequently: true });\n                      T3.drawImage(this, 0, 0);\n                      var z3 = P3.toDataURL("image/png");\n                      L3.attr("xlink:href", z3), C3();\n                    }, L3.on("error", g3), M4.src = S2.source, this._imgSrc = S2.source;\n                    function g3() {\n                      L3.remove(), C3();\n                    }\n                  }.bind(this));\n                  t3._promises.push(x2);\n                }\n              }\n              function h3(S2) {\n                var L3 = A0e.select(this), x2 = yT.getFromId(t3, S2.xref), C3 = yT.getFromId(t3, S2.yref), M4 = yT.getRefType(S2.xref) === "domain", g3 = yT.getRefType(S2.yref) === "domain", P3 = r4._size, T3, z3;\n                x2 !== void 0 ? T3 = typeof S2.xref == "string" && M4 ? x2._length * S2.sizex : Math.abs(x2.l2p(S2.sizex) - x2.l2p(0)) : T3 = S2.sizex * P3.w, C3 !== void 0 ? z3 = typeof S2.yref == "string" && g3 ? C3._length * S2.sizey : Math.abs(C3.l2p(S2.sizey) - C3.l2p(0)) : z3 = S2.sizey * P3.h;\n                var O3 = T3 * c5.x[S2.xanchor].offset, V2 = z3 * c5.y[S2.yanchor].offset, G2 = c5.x[S2.xanchor].sizing + c5.y[S2.yanchor].sizing, Z, j3;\n                switch (x2 !== void 0 ? Z = typeof S2.xref == "string" && M4 ? x2._length * S2.x + x2._offset : x2.r2p(S2.x) + x2._offset : Z = S2.x * P3.w + P3.l, Z += O3, C3 !== void 0 ? j3 = typeof S2.yref == "string" && g3 ? C3._length * (1 - S2.y) + C3._offset : C3.r2p(S2.y) + C3._offset : j3 = P3.h - S2.y * P3.h + P3.t, j3 += V2, S2.sizing) {\n                  case "fill":\n                    G2 += " slice";\n                    break;\n                  case "stretch":\n                    G2 = "none";\n                    break;\n                }\n                L3.attr({ x: Z, y: j3, width: T3, height: z3, preserveAspectRatio: G2, opacity: S2.opacity });\n                var N2 = x2 && yT.getRefType(S2.xref) !== "domain" ? x2._id : "", H = C3 && yT.getRefType(S2.yref) !== "domain" ? C3._id : "", te = N2 + H;\n                xgt.setClipUrl(L3, te ? "clip" + r4._uid + te : null, t3);\n              }\n              function d3(S2) {\n                return [S2.xref, S2.x, S2.sizex, S2.yref, S2.y, S2.sizey].join("_");\n              }\n              function v3(S2, L3) {\n                return S2._index - L3._index;\n              }\n              var _2 = r4._imageLowerLayer.selectAll("image").data(a4, d3), b = r4._imageUpperLayer.selectAll("image").data(n4, d3);\n              _2.enter().append("image"), b.enter().append("image"), _2.exit().remove(), b.exit().remove(), _2.each(function(S2) {\n                f4.bind(this)(S2), h3.bind(this)(S2);\n              }), b.each(function(S2) {\n                f4.bind(this)(S2), h3.bind(this)(S2);\n              }), _2.sort(v3), b.sort(v3);\n              var p3 = Object.keys(r4._plots);\n              for (s3 = 0; s3 < p3.length; s3++) {\n                o4 = p3[s3];\n                var k4 = r4._plots[o4];\n                if (k4.imagelayer) {\n                  var E3 = k4.imagelayer.selectAll("image").data(i3[o4] || [], d3);\n                  E3.enter().append("image"), E3.exit().remove(), E3.each(function(S2) {\n                    f4.bind(this)(S2), h3.bind(this)(S2);\n                  }), E3.sort(v3);\n                }\n              }\n            };\n          });\n          var L0e = ye((Zsr, C0e) => {\n            "use strict";\n            var k0e = Eo(), wgt = m6();\n            C0e.exports = function(t3, r4, n4, i3) {\n              r4 = r4 || {};\n              var a4 = n4 === "log" && r4.type === "linear", o4 = n4 === "linear" && r4.type === "log";\n              if (a4 || o4) {\n                for (var s3 = t3._fullLayout.images, l3 = r4._id.charAt(0), u4, c5, f4 = 0; f4 < s3.length; f4++) if (u4 = s3[f4], c5 = "images[" + f4 + "].", u4[l3 + "ref"] === r4._id) {\n                  var h3 = u4[l3], d3 = u4["size" + l3], v3 = null, _2 = null;\n                  if (a4) {\n                    v3 = wgt(h3, r4.range);\n                    var b = d3 / Math.pow(10, v3) / 2;\n                    _2 = 2 * Math.log(b + Math.sqrt(1 + b * b)) / Math.LN10;\n                  } else v3 = Math.pow(10, h3), _2 = v3 * (Math.pow(10, d3 / 2) - Math.pow(10, -d3 / 2));\n                  k0e(v3) ? k0e(_2) || (_2 = null) : (v3 = null, _2 = null), i3(c5 + l3, v3), i3(c5 + "size" + l3, _2);\n                }\n              }\n            };\n          });\n          var I0e = ye((Ysr, P0e) => {\n            "use strict";\n            P0e.exports = { moduleType: "component", name: "images", layoutAttributes: HU(), supplyLayoutDefaults: T0e(), includeBasePlot: qM()("images"), draw: E0e(), convertCoords: L0e() };\n          });\n          var _I = ye((Ksr, R0e) => {\n            "use strict";\n            R0e.exports = { name: "updatemenus", containerClassName: "updatemenu-container", headerGroupClassName: "updatemenu-header-group", headerClassName: "updatemenu-header", headerArrowClassName: "updatemenu-header-arrow", dropdownButtonGroupClassName: "updatemenu-dropdown-button-group", dropdownButtonClassName: "updatemenu-dropdown-button", buttonClassName: "updatemenu-button", itemRectClassName: "updatemenu-item-rect", itemTextClassName: "updatemenu-item-text", menuIndexAttrName: "updatemenu-active-index", autoMarginIdRoot: "updatemenu-", blankHeaderOpts: { label: "  " }, minWidth: 30, minHeight: 30, textPadX: 24, arrowPadX: 16, rx: 2, ry: 2, textOffsetX: 12, textOffsetY: 3, arrowOffsetX: 4, gapButtonHeader: 5, gapButton: 2, activeColor: "#F4FAFF", hoverColor: "#F4FAFF", arrowSymbol: { left: "\\u25C4", right: "\\u25BA", up: "\\u25B2", down: "\\u25BC" } };\n          });\n          var WU = ye((Jsr, F0e) => {\n            "use strict";\n            var Tgt = ec(), Agt = Lh(), Sgt = Ao().extendFlat, Mgt = mc().overrideAll, Egt = E6(), D0e = vl().templatedArray, kgt = D0e("button", { visible: { valType: "boolean" }, method: { valType: "enumerated", values: ["restyle", "relayout", "animate", "update", "skip"], dflt: "restyle" }, args: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, args2: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, label: { valType: "string", dflt: "" }, execute: { valType: "boolean", dflt: true } });\n            F0e.exports = Mgt(D0e("updatemenu", { _arrayAttrRegexps: [/^updatemenus\\[(0|[1-9][0-9]+)\\]\\.buttons/], visible: { valType: "boolean" }, type: { valType: "enumerated", values: ["dropdown", "buttons"], dflt: "dropdown" }, direction: { valType: "enumerated", values: ["left", "right", "up", "down"], dflt: "down" }, active: { valType: "integer", min: -1, dflt: 0 }, showactive: { valType: "boolean", dflt: true }, buttons: kgt, x: { valType: "number", min: -2, max: 3, dflt: -0.05 }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "right" }, y: { valType: "number", min: -2, max: 3, dflt: 1 }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "top" }, pad: Sgt(Egt({ editType: "arraydraw" }), {}), font: Tgt({}), bgcolor: { valType: "color" }, bordercolor: { valType: "color", dflt: Agt.borderLine }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "arraydraw" } }), "arraydraw", "from-root");\n          });\n          var B0e = ye(($sr, q0e) => {\n            "use strict";\n            var xI = Dr(), z0e = Yd(), O0e = WU(), Cgt = _I(), Lgt = Cgt.name, Pgt = O0e.buttons;\n            q0e.exports = function(t3, r4) {\n              var n4 = { name: Lgt, handleItemDefaults: Igt };\n              z0e(t3, r4, n4);\n            };\n            function Igt(e3, t3, r4) {\n              function n4(o4, s3) {\n                return xI.coerce(e3, t3, O0e, o4, s3);\n              }\n              var i3 = z0e(e3, t3, { name: "buttons", handleItemDefaults: Rgt }), a4 = n4("visible", i3.length > 0);\n              a4 && (n4("active"), n4("direction"), n4("type"), n4("showactive"), n4("x"), n4("y"), xI.noneOrAll(e3, t3, ["x", "y"]), n4("xanchor"), n4("yanchor"), n4("pad.t"), n4("pad.r"), n4("pad.b"), n4("pad.l"), xI.coerceFont(n4, "font", r4.font), n4("bgcolor", r4.paper_bgcolor), n4("bordercolor"), n4("borderwidth"));\n            }\n            function Rgt(e3, t3) {\n              function r4(i3, a4) {\n                return xI.coerce(e3, t3, Pgt, i3, a4);\n              }\n              var n4 = r4("visible", e3.method === "skip" || Array.isArray(e3.args));\n              n4 && (r4("method"), r4("args"), r4("args2"), r4("label"), r4("execute"));\n            }\n          });\n          var V0e = ye((Qsr, U0e) => {\n            "use strict";\n            U0e.exports = Mf;\n            var qg = Oa(), N0e = ka(), _T = So(), bI = Dr();\n            function Mf(e3, t3, r4) {\n              this.gd = e3, this.container = t3, this.id = r4, this.position = null, this.translateX = null, this.translateY = null, this.hbar = null, this.vbar = null, this.bg = this.container.selectAll("rect.scrollbox-bg").data([0]), this.bg.exit().on(".drag", null).on("wheel", null).remove(), this.bg.enter().append("rect").classed("scrollbox-bg", true).style("pointer-events", "all").attr({ opacity: 0, x: 0, y: 0, width: 0, height: 0 });\n            }\n            Mf.barWidth = 2;\n            Mf.barLength = 20;\n            Mf.barRadius = 2;\n            Mf.barPad = 1;\n            Mf.barColor = "#808BA4";\n            Mf.prototype.enable = function(t3, r4, n4) {\n              var i3 = this.gd._fullLayout, a4 = i3.width, o4 = i3.height;\n              this.position = t3;\n              var s3 = this.position.l, l3 = this.position.w, u4 = this.position.t, c5 = this.position.h, f4 = this.position.direction, h3 = f4 === "down", d3 = f4 === "left", v3 = f4 === "right", _2 = f4 === "up", b = l3, p3 = c5, k4, E3, S2, L3;\n              !h3 && !d3 && !v3 && !_2 && (this.position.direction = "down", h3 = true);\n              var x2 = h3 || _2;\n              x2 ? (k4 = s3, E3 = k4 + b, h3 ? (S2 = u4, L3 = Math.min(S2 + p3, o4), p3 = L3 - S2) : (L3 = u4 + p3, S2 = Math.max(L3 - p3, 0), p3 = L3 - S2)) : (S2 = u4, L3 = S2 + p3, d3 ? (E3 = s3 + b, k4 = Math.max(E3 - b, 0), b = E3 - k4) : (k4 = s3, E3 = Math.min(k4 + b, a4), b = E3 - k4)), this._box = { l: k4, t: S2, w: b, h: p3 };\n              var C3 = l3 > b, M4 = Mf.barLength + 2 * Mf.barPad, g3 = Mf.barWidth + 2 * Mf.barPad, P3 = s3, T3 = u4 + c5;\n              T3 + g3 > o4 && (T3 = o4 - g3);\n              var z3 = this.container.selectAll("rect.scrollbar-horizontal").data(C3 ? [0] : []);\n              z3.exit().on(".drag", null).remove(), z3.enter().append("rect").classed("scrollbar-horizontal", true).call(N0e.fill, Mf.barColor), C3 ? (this.hbar = z3.attr({ rx: Mf.barRadius, ry: Mf.barRadius, x: P3, y: T3, width: M4, height: g3 }), this._hbarXMin = P3 + M4 / 2, this._hbarTranslateMax = b - M4) : (delete this.hbar, delete this._hbarXMin, delete this._hbarTranslateMax);\n              var O3 = c5 > p3, V2 = Mf.barWidth + 2 * Mf.barPad, G2 = Mf.barLength + 2 * Mf.barPad, Z = s3 + l3, j3 = u4;\n              Z + V2 > a4 && (Z = a4 - V2);\n              var N2 = this.container.selectAll("rect.scrollbar-vertical").data(O3 ? [0] : []);\n              N2.exit().on(".drag", null).remove(), N2.enter().append("rect").classed("scrollbar-vertical", true).call(N0e.fill, Mf.barColor), O3 ? (this.vbar = N2.attr({ rx: Mf.barRadius, ry: Mf.barRadius, x: Z, y: j3, width: V2, height: G2 }), this._vbarYMin = j3 + G2 / 2, this._vbarTranslateMax = p3 - G2) : (delete this.vbar, delete this._vbarYMin, delete this._vbarTranslateMax);\n              var H = this.id, te = k4 - 0.5, oe = O3 ? E3 + V2 + 0.5 : E3 + 0.5, _e = S2 - 0.5, Ee = C3 ? L3 + g3 + 0.5 : L3 + 0.5, Ce = i3._topdefs.selectAll("#" + H).data(C3 || O3 ? [0] : []);\n              if (Ce.exit().remove(), Ce.enter().append("clipPath").attr("id", H).append("rect"), C3 || O3 ? (this._clipRect = Ce.select("rect").attr({ x: Math.floor(te), y: Math.floor(_e), width: Math.ceil(oe) - Math.floor(te), height: Math.ceil(Ee) - Math.floor(_e) }), this.container.call(_T.setClipUrl, H, this.gd), this.bg.attr({ x: s3, y: u4, width: l3, height: c5 })) : (this.bg.attr({ width: 0, height: 0 }), this.container.on("wheel", null).on(".drag", null).call(_T.setClipUrl, null), delete this._clipRect), C3 || O3) {\n                var me = qg.behavior.drag().on("dragstart", function() {\n                  qg.event.sourceEvent.preventDefault();\n                }).on("drag", this._onBoxDrag.bind(this));\n                this.container.on("wheel", null).on("wheel", this._onBoxWheel.bind(this)).on(".drag", null).call(me);\n                var ie = qg.behavior.drag().on("dragstart", function() {\n                  qg.event.sourceEvent.preventDefault(), qg.event.sourceEvent.stopPropagation();\n                }).on("drag", this._onBarDrag.bind(this));\n                C3 && this.hbar.on(".drag", null).call(ie), O3 && this.vbar.on(".drag", null).call(ie);\n              }\n              this.setTranslate(r4, n4);\n            };\n            Mf.prototype.disable = function() {\n              (this.hbar || this.vbar) && (this.bg.attr({ width: 0, height: 0 }), this.container.on("wheel", null).on(".drag", null).call(_T.setClipUrl, null), delete this._clipRect), this.hbar && (this.hbar.on(".drag", null), this.hbar.remove(), delete this.hbar, delete this._hbarXMin, delete this._hbarTranslateMax), this.vbar && (this.vbar.on(".drag", null), this.vbar.remove(), delete this.vbar, delete this._vbarYMin, delete this._vbarTranslateMax);\n            };\n            Mf.prototype._onBoxDrag = function() {\n              var t3 = this.translateX, r4 = this.translateY;\n              this.hbar && (t3 -= qg.event.dx), this.vbar && (r4 -= qg.event.dy), this.setTranslate(t3, r4);\n            };\n            Mf.prototype._onBoxWheel = function() {\n              var t3 = this.translateX, r4 = this.translateY;\n              this.hbar && (t3 += qg.event.deltaY), this.vbar && (r4 += qg.event.deltaY), this.setTranslate(t3, r4);\n            };\n            Mf.prototype._onBarDrag = function() {\n              var t3 = this.translateX, r4 = this.translateY;\n              if (this.hbar) {\n                var n4 = t3 + this._hbarXMin, i3 = n4 + this._hbarTranslateMax, a4 = bI.constrain(qg.event.x, n4, i3), o4 = (a4 - n4) / (i3 - n4), s3 = this.position.w - this._box.w;\n                t3 = o4 * s3;\n              }\n              if (this.vbar) {\n                var l3 = r4 + this._vbarYMin, u4 = l3 + this._vbarTranslateMax, c5 = bI.constrain(qg.event.y, l3, u4), f4 = (c5 - l3) / (u4 - l3), h3 = this.position.h - this._box.h;\n                r4 = f4 * h3;\n              }\n              this.setTranslate(t3, r4);\n            };\n            Mf.prototype.setTranslate = function(t3, r4) {\n              var n4 = this.position.w - this._box.w, i3 = this.position.h - this._box.h;\n              if (t3 = bI.constrain(t3 || 0, 0, n4), r4 = bI.constrain(r4 || 0, 0, i3), this.translateX = t3, this.translateY = r4, this.container.call(_T.setTranslate, this._box.l - this.position.l - t3, this._box.t - this.position.t - r4), this._clipRect && this._clipRect.attr({ x: Math.floor(this.position.l + t3 - 0.5), y: Math.floor(this.position.t + r4 - 0.5) }), this.hbar) {\n                var a4 = t3 / n4;\n                this.hbar.call(_T.setTranslate, t3 + a4 * this._hbarTranslateMax, r4);\n              }\n              if (this.vbar) {\n                var o4 = r4 / i3;\n                this.vbar.call(_T.setTranslate, t3, r4 + o4 * this._vbarTranslateMax);\n              }\n            };\n          });\n          var $0e = ye((elr, J0e) => {\n            "use strict";\n            var xT = Oa(), s4 = Mc(), l4 = ka(), bT = So(), e0 = Dr(), wI = ru(), Dgt = vl().arrayEditor, H0e = $h().LINE_SPACING, es = _I(), Fgt = V0e();\n            J0e.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = e0.filterVisible(r4[es.name]);\n              function i3(h3) {\n                s4.autoMargin(t3, Y0e(h3));\n              }\n              var a4 = r4._menulayer.selectAll("g." + es.containerClassName).data(n4.length > 0 ? [0] : []);\n              if (a4.enter().append("g").classed(es.containerClassName, true).style("cursor", "pointer"), a4.exit().each(function() {\n                xT.select(this).selectAll("g." + es.headerGroupClassName).each(i3);\n              }).remove(), n4.length !== 0) {\n                var o4 = a4.selectAll("g." + es.headerGroupClassName).data(n4, zgt);\n                o4.enter().append("g").classed(es.headerGroupClassName, true);\n                for (var s3 = e0.ensureSingle(a4, "g", es.dropdownButtonGroupClassName, function(h3) {\n                  h3.style("pointer-events", "all");\n                }), l3 = 0; l3 < n4.length; l3++) {\n                  var u5 = n4[l3];\n                  Vgt(t3, u5);\n                }\n                var c5 = "updatemenus" + r4._uid, f4 = new Fgt(t3, s3, c5);\n                o4.enter().size() && (s3.node().parentNode.appendChild(s3.node()), s3.call(ZU)), o4.exit().each(function(h3) {\n                  s3.call(ZU), i3(h3);\n                }).remove(), o4.each(function(h3) {\n                  var d3 = xT.select(this), v3 = h3.type === "dropdown" ? s3 : null;\n                  s4.manageCommandObserver(t3, h3, h3.buttons, function(_2) {\n                    XU(t3, h3, h3.buttons[_2.index], d3, v3, f4, _2.index, true);\n                  }), h3.type === "dropdown" ? (W0e(t3, d3, s3, f4, h3), j0e(s3, h3) && u4(t3, d3, s3, f4, h3)) : u4(t3, d3, null, null, h3);\n                });\n              }\n            };\n            function zgt(e3) {\n              return e3._index;\n            }\n            function Ogt(e3) {\n              return +e3.attr(es.menuIndexAttrName) == -1;\n            }\n            function j0e(e3, t3) {\n              return +e3.attr(es.menuIndexAttrName) === t3._index;\n            }\n            function XU(e3, t3, r4, n4, i3, a4, o4, s3) {\n              t3.active = o4, Dgt(e3.layout, es.name, t3).applyUpdate("active", o4), t3.type === "buttons" ? u4(e3, n4, null, null, t3) : t3.type === "dropdown" && (i3.attr(es.menuIndexAttrName, "-1"), W0e(e3, n4, i3, a4, t3), s3 || u4(e3, n4, i3, a4, t3));\n            }\n            function W0e(e3, t3, r4, n4, i3) {\n              var a4 = e0.ensureSingle(t3, "g", es.headerClassName, function(h3) {\n                h3.style("pointer-events", "all");\n              }), o4 = i3._dims, s3 = i3.active, l3 = i3.buttons[s3] || es.blankHeaderOpts, u5 = { y: i3.pad.t, yPad: 0, x: i3.pad.l, xPad: 0, index: 0 }, c5 = { width: o4.headerWidth, height: o4.headerHeight };\n              a4.call(YU, i3, l3, e3).call(K0e, i3, u5, c5);\n              var f4 = e0.ensureSingle(t3, "text", es.headerArrowClassName, function(h3) {\n                h3.attr("text-anchor", "end").call(bT.font, i3.font).text(es.arrowSymbol[i3.direction]);\n              });\n              f4.attr({ x: o4.headerWidth - es.arrowOffsetX + i3.pad.l, y: o4.headerHeight / 2 + es.textOffsetY + i3.pad.t }), a4.on("click", function() {\n                r4.call(ZU, String(j0e(r4, i3) ? -1 : i3._index)), u4(e3, t3, r4, n4, i3);\n              }), a4.on("mouseover", function() {\n                a4.call(X0e);\n              }), a4.on("mouseout", function() {\n                a4.call(Z0e, i3);\n              }), bT.setTranslate(t3, o4.lx, o4.ly);\n            }\n            function u4(e3, t3, r4, n4, i3) {\n              r4 || (r4 = t3, r4.attr("pointer-events", "all"));\n              var a4 = !Ogt(r4) || i3.type === "buttons" ? i3.buttons : [], o4 = i3.type === "dropdown" ? es.dropdownButtonClassName : es.buttonClassName, s3 = r4.selectAll("g." + o4).data(e0.filterVisible(a4)), l3 = s3.enter().append("g").classed(o4, true), u5 = s3.exit();\n              i3.type === "dropdown" ? (l3.attr("opacity", "0").transition().attr("opacity", "1"), u5.transition().attr("opacity", "0").remove()) : u5.remove();\n              var c5 = 0, f4 = 0, h3 = i3._dims, d3 = ["up", "down"].indexOf(i3.direction) !== -1;\n              i3.type === "dropdown" && (d3 ? f4 = h3.headerHeight + es.gapButtonHeader : c5 = h3.headerWidth + es.gapButtonHeader), i3.type === "dropdown" && i3.direction === "up" && (f4 = -es.gapButtonHeader + es.gapButton - h3.openHeight), i3.type === "dropdown" && i3.direction === "left" && (c5 = -es.gapButtonHeader + es.gapButton - h3.openWidth);\n              var v3 = { x: h3.lx + c5 + i3.pad.l, y: h3.ly + f4 + i3.pad.t, yPad: es.gapButton, xPad: es.gapButton, index: 0 }, _2 = { l: v3.x + i3.borderwidth, t: v3.y + i3.borderwidth };\n              s3.each(function(b, p3) {\n                var k4 = xT.select(this);\n                k4.call(YU, i3, b, e3).call(K0e, i3, v3), k4.on("click", function() {\n                  xT.event.defaultPrevented || (b.execute && (b.args2 && i3.active === p3 ? (XU(e3, i3, b, t3, r4, n4, -1), s4.executeAPICommand(e3, b.method, b.args2)) : (XU(e3, i3, b, t3, r4, n4, p3), s4.executeAPICommand(e3, b.method, b.args))), e3.emit("plotly_buttonclicked", { menu: i3, button: b, active: i3.active }));\n                }), k4.on("mouseover", function() {\n                  k4.call(X0e);\n                }), k4.on("mouseout", function() {\n                  k4.call(Z0e, i3), s3.call(G0e, i3);\n                });\n              }), s3.call(G0e, i3), d3 ? (_2.w = Math.max(h3.openWidth, h3.headerWidth), _2.h = v3.y - _2.t) : (_2.w = v3.x - _2.l, _2.h = Math.max(h3.openHeight, h3.headerHeight)), _2.direction = i3.direction, n4 && (s3.size() ? qgt(e3, t3, r4, n4, i3, _2) : Bgt(n4));\n            }\n            function qgt(e3, t3, r4, n4, i3, a4) {\n              var o4 = i3.direction, s3 = o4 === "up" || o4 === "down", l3 = i3._dims, u5 = i3.active, c5, f4, h3;\n              if (s3) for (f4 = 0, h3 = 0; h3 < u5; h3++) f4 += l3.heights[h3] + es.gapButton;\n              else for (c5 = 0, h3 = 0; h3 < u5; h3++) c5 += l3.widths[h3] + es.gapButton;\n              n4.enable(a4, c5, f4), n4.hbar && n4.hbar.attr("opacity", "0").transition().attr("opacity", "1"), n4.vbar && n4.vbar.attr("opacity", "0").transition().attr("opacity", "1");\n            }\n            function Bgt(e3) {\n              var t3 = !!e3.hbar, r4 = !!e3.vbar;\n              t3 && e3.hbar.transition().attr("opacity", "0").each("end", function() {\n                t3 = false, r4 || e3.disable();\n              }), r4 && e3.vbar.transition().attr("opacity", "0").each("end", function() {\n                r4 = false, t3 || e3.disable();\n              });\n            }\n            function YU(e3, t3, r4, n4) {\n              e3.call(Ngt, t3).call(Ugt, t3, r4, n4);\n            }\n            function Ngt(e3, t3) {\n              var r4 = e0.ensureSingle(e3, "rect", es.itemRectClassName, function(n4) {\n                n4.attr({ rx: es.rx, ry: es.ry, "shape-rendering": "crispEdges" });\n              });\n              r4.call(l4.stroke, t3.bordercolor).call(l4.fill, t3.bgcolor).style("stroke-width", t3.borderwidth + "px");\n            }\n            function Ugt(e3, t3, r4, n4) {\n              var i3 = e0.ensureSingle(e3, "text", es.itemTextClassName, function(s3) {\n                s3.attr({ "text-anchor": "start", "data-notex": 1 });\n              }), a4 = r4.label, o4 = n4._fullLayout._meta;\n              o4 && (a4 = e0.templateString(a4, o4)), i3.call(bT.font, t3.font).text(a4).call(wI.convertToTspans, n4);\n            }\n            function G0e(e3, t3) {\n              var r4 = t3.active;\n              e3.each(function(n4, i3) {\n                var a4 = xT.select(this);\n                i3 === r4 && t3.showactive && a4.select("rect." + es.itemRectClassName).call(l4.fill, es.activeColor);\n              });\n            }\n            function X0e(e3) {\n              e3.select("rect." + es.itemRectClassName).call(l4.fill, es.hoverColor);\n            }\n            function Z0e(e3, t3) {\n              e3.select("rect." + es.itemRectClassName).call(l4.fill, t3.bgcolor);\n            }\n            function Vgt(e3, t3) {\n              var r4 = t3._dims = { width1: 0, height1: 0, heights: [], widths: [], totalWidth: 0, totalHeight: 0, openWidth: 0, openHeight: 0, lx: 0, ly: 0 }, n4 = bT.tester.selectAll("g." + es.dropdownButtonClassName).data(e0.filterVisible(t3.buttons));\n              n4.enter().append("g").classed(es.dropdownButtonClassName, true);\n              var i3 = ["up", "down"].indexOf(t3.direction) !== -1;\n              n4.each(function(c5, f4) {\n                var h3 = xT.select(this);\n                h3.call(YU, t3, c5, e3);\n                var d3 = h3.select("." + es.itemTextClassName), v3 = d3.node() && bT.bBox(d3.node()).width, _2 = Math.max(v3 + es.textPadX, es.minWidth), b = t3.font.size * H0e, p3 = wI.lineCount(d3), k4 = Math.max(b * p3, es.minHeight) + es.textOffsetY;\n                k4 = Math.ceil(k4), _2 = Math.ceil(_2), r4.widths[f4] = _2, r4.heights[f4] = k4, r4.height1 = Math.max(r4.height1, k4), r4.width1 = Math.max(r4.width1, _2), i3 ? (r4.totalWidth = Math.max(r4.totalWidth, _2), r4.openWidth = r4.totalWidth, r4.totalHeight += k4 + es.gapButton, r4.openHeight += k4 + es.gapButton) : (r4.totalWidth += _2 + es.gapButton, r4.openWidth += _2 + es.gapButton, r4.totalHeight = Math.max(r4.totalHeight, k4), r4.openHeight = r4.totalHeight);\n              }), i3 ? r4.totalHeight -= es.gapButton : r4.totalWidth -= es.gapButton, r4.headerWidth = r4.width1 + es.arrowPadX, r4.headerHeight = r4.height1, t3.type === "dropdown" && (i3 ? (r4.width1 += es.arrowPadX, r4.totalHeight = r4.height1) : r4.totalWidth = r4.width1, r4.totalWidth += es.arrowPadX), n4.remove();\n              var a4 = r4.totalWidth + t3.pad.l + t3.pad.r, o4 = r4.totalHeight + t3.pad.t + t3.pad.b, s3 = e3._fullLayout._size;\n              r4.lx = s3.l + s3.w * t3.x, r4.ly = s3.t + s3.h * (1 - t3.y);\n              var l3 = "left";\n              e0.isRightAnchor(t3) && (r4.lx -= a4, l3 = "right"), e0.isCenterAnchor(t3) && (r4.lx -= a4 / 2, l3 = "center");\n              var u5 = "top";\n              e0.isBottomAnchor(t3) && (r4.ly -= o4, u5 = "bottom"), e0.isMiddleAnchor(t3) && (r4.ly -= o4 / 2, u5 = "middle"), r4.totalWidth = Math.ceil(r4.totalWidth), r4.totalHeight = Math.ceil(r4.totalHeight), r4.lx = Math.round(r4.lx), r4.ly = Math.round(r4.ly), s4.autoMargin(e3, Y0e(t3), { x: t3.x, y: t3.y, l: a4 * ({ right: 1, center: 0.5 }[l3] || 0), r: a4 * ({ left: 1, center: 0.5 }[l3] || 0), b: o4 * ({ top: 1, middle: 0.5 }[u5] || 0), t: o4 * ({ bottom: 1, middle: 0.5 }[u5] || 0) });\n            }\n            function Y0e(e3) {\n              return es.autoMarginIdRoot + e3._index;\n            }\n            function K0e(e3, t3, r4, n4) {\n              n4 = n4 || {};\n              var i3 = e3.select("." + es.itemRectClassName), a4 = e3.select("." + es.itemTextClassName), o4 = t3.borderwidth, s3 = r4.index, l3 = t3._dims;\n              bT.setTranslate(e3, o4 + r4.x, o4 + r4.y);\n              var u5 = ["up", "down"].indexOf(t3.direction) !== -1, c5 = n4.height || (u5 ? l3.heights[s3] : l3.height1);\n              i3.attr({ x: 0, y: 0, width: n4.width || (u5 ? l3.width1 : l3.widths[s3]), height: c5 });\n              var f4 = t3.font.size * H0e, h3 = wI.lineCount(a4), d3 = (h3 - 1) * f4 / 2;\n              wI.positionText(a4, es.textOffsetX, c5 / 2 - d3 + es.textOffsetY), u5 ? r4.y += l3.heights[s3] + r4.yPad : r4.x += l3.widths[s3] + r4.xPad, r4.index++;\n            }\n            function ZU(e3, t3) {\n              e3.attr(es.menuIndexAttrName, t3 || "-1").selectAll("g." + es.dropdownButtonClassName).remove();\n            }\n          });\n          var ege = ye((tlr, Q0e) => {\n            "use strict";\n            var Ggt = _I();\n            Q0e.exports = { moduleType: "component", name: Ggt.name, layoutAttributes: WU(), supplyLayoutDefaults: B0e(), draw: $0e() };\n          });\n          var c4 = ye((rlr, tge) => {\n            "use strict";\n            tge.exports = { name: "sliders", containerClassName: "slider-container", groupClassName: "slider-group", inputAreaClass: "slider-input-area", railRectClass: "slider-rail-rect", railTouchRectClass: "slider-rail-touch-rect", gripRectClass: "slider-grip-rect", tickRectClass: "slider-tick-rect", inputProxyClass: "slider-input-proxy", labelsClass: "slider-labels", labelGroupClass: "slider-label-group", labelClass: "slider-label", currentValueClass: "slider-current-value", railHeight: 5, menuIndexAttrName: "slider-active-index", autoMarginIdRoot: "slider-", minWidth: 30, minHeight: 30, textPadX: 40, arrowOffsetX: 4, railRadius: 2, railWidth: 5, railBorder: 4, railBorderWidth: 1, railBorderColor: "#bec8d9", railBgColor: "#f8fafc", railInset: 8, stepInset: 10, gripRadius: 10, gripWidth: 20, gripHeight: 20, gripBorder: 20, gripBorderWidth: 1, gripBorderColor: "#bec8d9", gripBgColor: "#f6f8fa", gripBgActiveColor: "#dbdde0", labelPadding: 8, labelOffset: 0, tickWidth: 1, tickColor: "#333", tickOffset: 25, tickLength: 7, minorTickOffset: 25, minorTickColor: "#333", minorTickLength: 4, currentValuePadding: 8, currentValueInset: 0 };\n          });\n          var KU = ye((ilr, nge) => {\n            "use strict";\n            var rge = ec(), Hgt = E6(), jgt = Ao().extendDeepAll, Wgt = mc().overrideAll, Xgt = US(), ige = vl().templatedArray, $b = c4(), Zgt = ige("step", { visible: { valType: "boolean", dflt: true }, method: { valType: "enumerated", values: ["restyle", "relayout", "animate", "update", "skip"], dflt: "restyle" }, args: { valType: "info_array", freeLength: true, items: [{ valType: "any" }, { valType: "any" }, { valType: "any" }] }, label: { valType: "string" }, value: { valType: "string" }, execute: { valType: "boolean", dflt: true } });\n            nge.exports = Wgt(ige("slider", { visible: { valType: "boolean", dflt: true }, active: { valType: "number", min: 0, dflt: 0 }, steps: Zgt, lenmode: { valType: "enumerated", values: ["fraction", "pixels"], dflt: "fraction" }, len: { valType: "number", min: 0, dflt: 1 }, x: { valType: "number", min: -2, max: 3, dflt: 0 }, pad: jgt(Hgt({ editType: "arraydraw" }), {}, { t: { dflt: 20 } }), xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left" }, y: { valType: "number", min: -2, max: 3, dflt: 0 }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "top" }, transition: { duration: { valType: "number", min: 0, dflt: 150 }, easing: { valType: "enumerated", values: Xgt.transition.easing.values, dflt: "cubic-in-out" } }, currentvalue: { visible: { valType: "boolean", dflt: true }, xanchor: { valType: "enumerated", values: ["left", "center", "right"], dflt: "left" }, offset: { valType: "number", dflt: 10 }, prefix: { valType: "string" }, suffix: { valType: "string" }, font: rge({}) }, font: rge({}), activebgcolor: { valType: "color", dflt: $b.gripBgActiveColor }, bgcolor: { valType: "color", dflt: $b.railBgColor }, bordercolor: { valType: "color", dflt: $b.railBorderColor }, borderwidth: { valType: "number", min: 0, dflt: $b.railBorderWidth }, ticklen: { valType: "number", min: 0, dflt: $b.tickLength }, tickcolor: { valType: "color", dflt: $b.tickColor }, tickwidth: { valType: "number", min: 0, dflt: 1 }, minorticklen: { valType: "number", min: 0, dflt: $b.minorTickLength } }), "arraydraw", "from-root");\n          });\n          var lge = ye((nlr, sge) => {\n            "use strict";\n            var wT = Dr(), age = Yd(), oge = KU(), Ygt = c4(), Kgt = Ygt.name, Jgt = oge.steps;\n            sge.exports = function(t3, r4) {\n              age(t3, r4, { name: Kgt, handleItemDefaults: $gt });\n            };\n            function $gt(e3, t3, r4) {\n              function n4(f4, h3) {\n                return wT.coerce(e3, t3, oge, f4, h3);\n              }\n              for (var i3 = age(e3, t3, { name: "steps", handleItemDefaults: Qgt }), a4 = 0, o4 = 0; o4 < i3.length; o4++) i3[o4].visible && a4++;\n              var s3;\n              if (a4 < 2 ? s3 = t3.visible = false : s3 = n4("visible"), !!s3) {\n                t3._stepCount = a4;\n                var l3 = t3._visibleSteps = wT.filterVisible(i3), u4 = n4("active");\n                (i3[u4] || {}).visible || (t3.active = l3[0]._index), n4("x"), n4("y"), wT.noneOrAll(e3, t3, ["x", "y"]), n4("xanchor"), n4("yanchor"), n4("len"), n4("lenmode"), n4("pad.t"), n4("pad.r"), n4("pad.b"), n4("pad.l"), wT.coerceFont(n4, "font", r4.font);\n                var c5 = n4("currentvalue.visible");\n                c5 && (n4("currentvalue.xanchor"), n4("currentvalue.prefix"), n4("currentvalue.suffix"), n4("currentvalue.offset"), wT.coerceFont(n4, "currentvalue.font", t3.font)), n4("transition.duration"), n4("transition.easing"), n4("bgcolor"), n4("activebgcolor"), n4("bordercolor"), n4("borderwidth"), n4("ticklen"), n4("tickwidth"), n4("tickcolor"), n4("minorticklen");\n              }\n            }\n            function Qgt(e3, t3) {\n              function r4(a4, o4) {\n                return wT.coerce(e3, t3, Jgt, a4, o4);\n              }\n              var n4;\n              if (e3.method !== "skip" && !Array.isArray(e3.args) ? n4 = t3.visible = false : n4 = r4("visible"), n4) {\n                r4("method"), r4("args");\n                var i3 = r4("label", "step-" + t3._index);\n                r4("value", i3), r4("execute");\n              }\n            }\n          });\n          var yge = ye((alr, mge) => {\n            "use strict";\n            var Bg = Oa(), TI = Mc(), __ = ka(), Ng = So(), t0 = Dr(), emt = t0.strTranslate, f4 = ru(), tmt = vl().arrayEditor, Rs = c4(), QU = $h(), fge = QU.LINE_SPACING, JU = QU.FROM_TL, $U = QU.FROM_BR;\n            mge.exports = function(t3) {\n              var r4 = t3._context.staticPlot, n4 = t3._fullLayout, i3 = rmt(n4, t3), a4 = n4._infolayer.selectAll("g." + Rs.containerClassName).data(i3.length > 0 ? [0] : []);\n              a4.enter().append("g").classed(Rs.containerClassName, true).style("cursor", r4 ? null : "ew-resize");\n              function o4(c5) {\n                c5._commandObserver && (c5._commandObserver.remove(), delete c5._commandObserver), TI.autoMargin(t3, hge(c5));\n              }\n              if (a4.exit().each(function() {\n                Bg.select(this).selectAll("g." + Rs.groupClassName).each(o4);\n              }).remove(), i3.length !== 0) {\n                var s3 = a4.selectAll("g." + Rs.groupClassName).data(i3, imt);\n                s3.enter().append("g").classed(Rs.groupClassName, true), s3.exit().each(o4).remove();\n                for (var l3 = 0; l3 < i3.length; l3++) {\n                  var u4 = i3[l3];\n                  nmt(t3, u4);\n                }\n                s3.each(function(c5) {\n                  var f5 = Bg.select(this);\n                  umt(c5), TI.manageCommandObserver(t3, c5, c5._visibleSteps, function(h3) {\n                    var d3 = f5.data()[0];\n                    d3.active !== h3.index && (d3._dragging || vge(t3, f5, d3, h3.index, false, true));\n                  }), amt(t3, Bg.select(this), c5);\n                });\n              }\n            };\n            function hge(e3) {\n              return Rs.autoMarginIdRoot + e3._index;\n            }\n            function rmt(e3, t3) {\n              for (var r4 = e3[Rs.name], n4 = [], i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3];\n                a4.visible && (a4._gd = t3, n4.push(a4));\n              }\n              return n4;\n            }\n            function imt(e3) {\n              return e3._index;\n            }\n            function nmt(e3, t3) {\n              var r4 = Ng.tester.selectAll("g." + Rs.labelGroupClass).data(t3._visibleSteps);\n              r4.enter().append("g").classed(Rs.labelGroupClass, true);\n              var n4 = 0, i3 = 0;\n              r4.each(function(v3) {\n                var _2 = Bg.select(this), b = dge(_2, { step: v3 }, t3), p3 = b.node();\n                if (p3) {\n                  var k4 = Ng.bBox(p3);\n                  i3 = Math.max(i3, k4.height), n4 = Math.max(n4, k4.width);\n                }\n              }), r4.remove();\n              var a4 = t3._dims = {};\n              a4.inputAreaWidth = Math.max(Rs.railWidth, Rs.gripHeight);\n              var o4 = e3._fullLayout._size;\n              a4.lx = o4.l + o4.w * t3.x, a4.ly = o4.t + o4.h * (1 - t3.y), t3.lenmode === "fraction" ? a4.outerLength = Math.round(o4.w * t3.len) : a4.outerLength = t3.len, a4.inputAreaStart = 0, a4.inputAreaLength = Math.round(a4.outerLength - t3.pad.l - t3.pad.r);\n              var s3 = a4.inputAreaLength - 2 * Rs.stepInset, l3 = s3 / (t3._stepCount - 1), u4 = n4 + Rs.labelPadding;\n              if (a4.labelStride = Math.max(1, Math.ceil(u4 / l3)), a4.labelHeight = i3, a4.currentValueMaxWidth = 0, a4.currentValueHeight = 0, a4.currentValueTotalHeight = 0, a4.currentValueMaxLines = 1, t3.currentvalue.visible) {\n                var c5 = Ng.tester.append("g");\n                r4.each(function(v3) {\n                  var _2 = AI(c5, t3, v3.label), b = _2.node() && Ng.bBox(_2.node()) || { width: 0, height: 0 }, p3 = f4.lineCount(_2);\n                  a4.currentValueMaxWidth = Math.max(a4.currentValueMaxWidth, Math.ceil(b.width)), a4.currentValueHeight = Math.max(a4.currentValueHeight, Math.ceil(b.height)), a4.currentValueMaxLines = Math.max(a4.currentValueMaxLines, p3);\n                }), a4.currentValueTotalHeight = a4.currentValueHeight + t3.currentvalue.offset, c5.remove();\n              }\n              a4.height = a4.currentValueTotalHeight + Rs.tickOffset + t3.ticklen + Rs.labelOffset + a4.labelHeight + t3.pad.t + t3.pad.b;\n              var f5 = "left";\n              t0.isRightAnchor(t3) && (a4.lx -= a4.outerLength, f5 = "right"), t0.isCenterAnchor(t3) && (a4.lx -= a4.outerLength / 2, f5 = "center");\n              var h3 = "top";\n              t0.isBottomAnchor(t3) && (a4.ly -= a4.height, h3 = "bottom"), t0.isMiddleAnchor(t3) && (a4.ly -= a4.height / 2, h3 = "middle"), a4.outerLength = Math.ceil(a4.outerLength), a4.height = Math.ceil(a4.height), a4.lx = Math.round(a4.lx), a4.ly = Math.round(a4.ly);\n              var d3 = { y: t3.y, b: a4.height * $U[h3], t: a4.height * JU[h3] };\n              t3.lenmode === "fraction" ? (d3.l = 0, d3.xl = t3.x - t3.len * JU[f5], d3.r = 0, d3.xr = t3.x + t3.len * $U[f5]) : (d3.x = t3.x, d3.l = a4.outerLength * JU[f5], d3.r = a4.outerLength * $U[f5]), TI.autoMargin(e3, hge(t3), d3);\n            }\n            function amt(e3, t3, r4) {\n              (r4.steps[r4.active] || {}).visible || (r4.active = r4._visibleSteps[0]._index), t3.call(AI, r4).call(fmt, r4).call(smt, r4).call(lmt, r4).call(cmt, e3, r4).call(omt, e3, r4);\n              var n4 = r4._dims;\n              Ng.setTranslate(t3, n4.lx + r4.pad.l, n4.ly + r4.pad.t), t3.call(gge, r4, false), t3.call(AI, r4);\n            }\n            function AI(e3, t3, r4) {\n              if (t3.currentvalue.visible) {\n                var n4 = t3._dims, i3, a4;\n                switch (t3.currentvalue.xanchor) {\n                  case "right":\n                    i3 = n4.inputAreaLength - Rs.currentValueInset - n4.currentValueMaxWidth, a4 = "left";\n                    break;\n                  case "center":\n                    i3 = n4.inputAreaLength * 0.5, a4 = "middle";\n                    break;\n                  default:\n                    i3 = Rs.currentValueInset, a4 = "left";\n                }\n                var o4 = t0.ensureSingle(e3, "text", Rs.labelClass, function(h3) {\n                  h3.attr({ "text-anchor": a4, "data-notex": 1 });\n                }), s3 = t3.currentvalue.prefix ? t3.currentvalue.prefix : "";\n                if (typeof r4 == "string") s3 += r4;\n                else {\n                  var l3 = t3.steps[t3.active].label, u4 = t3._gd._fullLayout._meta;\n                  u4 && (l3 = t0.templateString(l3, u4)), s3 += l3;\n                }\n                t3.currentvalue.suffix && (s3 += t3.currentvalue.suffix), o4.call(Ng.font, t3.currentvalue.font).text(s3).call(f4.convertToTspans, t3._gd);\n                var c5 = f4.lineCount(o4), f5 = (n4.currentValueMaxLines + 1 - c5) * t3.currentvalue.font.size * fge;\n                return f4.positionText(o4, i3, f5), o4;\n              }\n            }\n            function omt(e3, t3, r4) {\n              var n4 = t0.ensureSingle(e3, "rect", Rs.gripRectClass, function(i3) {\n                i3.call(pge, t3, e3, r4).style("pointer-events", "all");\n              });\n              n4.attr({ width: Rs.gripWidth, height: Rs.gripHeight, rx: Rs.gripRadius, ry: Rs.gripRadius }).call(__.stroke, r4.bordercolor).call(__.fill, r4.bgcolor).style("stroke-width", r4.borderwidth + "px");\n            }\n            function dge(e3, t3, r4) {\n              var n4 = t0.ensureSingle(e3, "text", Rs.labelClass, function(o4) {\n                o4.attr({ "text-anchor": "middle", "data-notex": 1 });\n              }), i3 = t3.step.label, a4 = r4._gd._fullLayout._meta;\n              return a4 && (i3 = t0.templateString(i3, a4)), n4.call(Ng.font, r4.font).text(i3).call(f4.convertToTspans, r4._gd), n4;\n            }\n            function smt(e3, t3) {\n              var r4 = t0.ensureSingle(e3, "g", Rs.labelsClass), n4 = t3._dims, i3 = r4.selectAll("g." + Rs.labelGroupClass).data(n4.labelSteps);\n              i3.enter().append("g").classed(Rs.labelGroupClass, true), i3.exit().remove(), i3.each(function(a4) {\n                var o4 = Bg.select(this);\n                o4.call(dge, a4, t3), Ng.setTranslate(o4, eV(t3, a4.fraction), Rs.tickOffset + t3.ticklen + t3.font.size * fge + Rs.labelOffset + n4.currentValueTotalHeight);\n              });\n            }\n            function uge(e3, t3, r4, n4, i3) {\n              var a4 = Math.round(n4 * (r4._stepCount - 1)), o4 = r4._visibleSteps[a4]._index;\n              o4 !== r4.active && vge(e3, t3, r4, o4, true, i3);\n            }\n            function vge(e3, t3, r4, n4, i3, a4) {\n              var o4 = r4.active;\n              r4.active = n4, tmt(e3.layout, Rs.name, r4).applyUpdate("active", n4);\n              var s3 = r4.steps[r4.active];\n              t3.call(gge, r4, a4), t3.call(AI, r4), e3.emit("plotly_sliderchange", { slider: r4, step: r4.steps[r4.active], interaction: i3, previousActive: o4 }), s3 && s3.method && i3 && (t3._nextMethod ? (t3._nextMethod.step = s3, t3._nextMethod.doCallback = i3, t3._nextMethod.doTransition = a4) : (t3._nextMethod = { step: s3, doCallback: i3, doTransition: a4 }, t3._nextMethodRaf = window.requestAnimationFrame(function() {\n                var l3 = t3._nextMethod.step;\n                l3.method && (l3.execute && TI.executeAPICommand(e3, l3.method, l3.args), t3._nextMethod = null, t3._nextMethodRaf = null);\n              })));\n            }\n            function pge(e3, t3, r4) {\n              if (t3._context.staticPlot) return;\n              var n4 = r4.node(), i3 = Bg.select(t3);\n              function a4() {\n                return r4.data()[0];\n              }\n              function o4() {\n                var s3 = a4();\n                t3.emit("plotly_sliderstart", { slider: s3 });\n                var l3 = r4.select("." + Rs.gripRectClass);\n                Bg.event.stopPropagation(), Bg.event.preventDefault(), l3.call(__.fill, s3.activebgcolor);\n                var u4 = cge(s3, Bg.mouse(n4)[0]);\n                uge(t3, r4, s3, u4, true), s3._dragging = true;\n                function c5() {\n                  var h3 = a4(), d3 = cge(h3, Bg.mouse(n4)[0]);\n                  uge(t3, r4, h3, d3, false);\n                }\n                i3.on("mousemove", c5), i3.on("touchmove", c5);\n                function f5() {\n                  var h3 = a4();\n                  h3._dragging = false, l3.call(__.fill, h3.bgcolor), i3.on("mouseup", null), i3.on("mousemove", null), i3.on("touchend", null), i3.on("touchmove", null), t3.emit("plotly_sliderend", { slider: h3, step: h3.steps[h3.active] });\n                }\n                i3.on("mouseup", f5), i3.on("touchend", f5);\n              }\n              e3.on("mousedown", o4), e3.on("touchstart", o4);\n            }\n            function lmt(e3, t3) {\n              var r4 = e3.selectAll("rect." + Rs.tickRectClass).data(t3._visibleSteps), n4 = t3._dims;\n              r4.enter().append("rect").classed(Rs.tickRectClass, true), r4.exit().remove(), r4.attr({ width: t3.tickwidth + "px", "shape-rendering": "crispEdges" }), r4.each(function(i3, a4) {\n                var o4 = a4 % n4.labelStride === 0, s3 = Bg.select(this);\n                s3.attr({ height: o4 ? t3.ticklen : t3.minorticklen }).call(__.fill, t3.tickcolor), Ng.setTranslate(s3, eV(t3, a4 / (t3._stepCount - 1)) - 0.5 * t3.tickwidth, (o4 ? Rs.tickOffset : Rs.minorTickOffset) + n4.currentValueTotalHeight);\n              });\n            }\n            function umt(e3) {\n              var t3 = e3._dims;\n              t3.labelSteps = [];\n              for (var r4 = e3._stepCount, n4 = 0; n4 < r4; n4 += t3.labelStride) t3.labelSteps.push({ fraction: n4 / (r4 - 1), step: e3._visibleSteps[n4] });\n            }\n            function gge(e3, t3, r4) {\n              for (var n4 = e3.select("rect." + Rs.gripRectClass), i3 = 0, a4 = 0; a4 < t3._stepCount; a4++) if (t3._visibleSteps[a4]._index === t3.active) {\n                i3 = a4;\n                break;\n              }\n              var o4 = eV(t3, i3 / (t3._stepCount - 1));\n              if (!t3._invokingCommand) {\n                var s3 = n4;\n                r4 && t3.transition.duration > 0 && (s3 = s3.transition().duration(t3.transition.duration).ease(t3.transition.easing)), s3.attr("transform", emt(o4 - Rs.gripWidth * 0.5, t3._dims.currentValueTotalHeight));\n              }\n            }\n            function eV(e3, t3) {\n              var r4 = e3._dims;\n              return r4.inputAreaStart + Rs.stepInset + (r4.inputAreaLength - 2 * Rs.stepInset) * Math.min(1, Math.max(0, t3));\n            }\n            function cge(e3, t3) {\n              var r4 = e3._dims;\n              return Math.min(1, Math.max(0, (t3 - Rs.stepInset - r4.inputAreaStart) / (r4.inputAreaLength - 2 * Rs.stepInset - 2 * r4.inputAreaStart)));\n            }\n            function cmt(e3, t3, r4) {\n              var n4 = r4._dims, i3 = t0.ensureSingle(e3, "rect", Rs.railTouchRectClass, function(a4) {\n                a4.call(pge, t3, e3, r4).style("pointer-events", "all");\n              });\n              i3.attr({ width: n4.inputAreaLength, height: Math.max(n4.inputAreaWidth, Rs.tickOffset + r4.ticklen + n4.labelHeight) }).call(__.fill, r4.bgcolor).attr("opacity", 0), Ng.setTranslate(i3, 0, n4.currentValueTotalHeight);\n            }\n            function fmt(e3, t3) {\n              var r4 = t3._dims, n4 = r4.inputAreaLength - Rs.railInset * 2, i3 = t0.ensureSingle(e3, "rect", Rs.railRectClass);\n              i3.attr({ width: n4, height: Rs.railWidth, rx: Rs.railRadius, ry: Rs.railRadius, "shape-rendering": "crispEdges" }).call(__.stroke, t3.bordercolor).call(__.fill, t3.bgcolor).style("stroke-width", t3.borderwidth + "px"), Ng.setTranslate(i3, Rs.railInset, (r4.inputAreaWidth - Rs.railWidth) * 0.5 + r4.currentValueTotalHeight);\n            }\n          });\n          var xge = ye((olr, _ge) => {\n            "use strict";\n            var hmt = c4();\n            _ge.exports = { moduleType: "component", name: hmt.name, layoutAttributes: KU(), supplyLayoutDefaults: lge(), draw: yge() };\n          });\n          var SI = ye((slr, wge) => {\n            "use strict";\n            var bge = Lh();\n            wge.exports = { bgcolor: { valType: "color", dflt: bge.background, editType: "plot" }, bordercolor: { valType: "color", dflt: bge.defaultLine, editType: "plot" }, borderwidth: { valType: "integer", dflt: 0, min: 0, editType: "plot" }, autorange: { valType: "boolean", dflt: true, editType: "calc", impliedEdits: { "range[0]": void 0, "range[1]": void 0 } }, range: { valType: "info_array", items: [{ valType: "any", editType: "calc", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "calc", impliedEdits: { "^autorange": false } }], editType: "calc", impliedEdits: { autorange: false } }, thickness: { valType: "number", dflt: 0.15, min: 0, max: 1, editType: "plot" }, visible: { valType: "boolean", dflt: true, editType: "calc" }, editType: "calc" };\n          });\n          var tV = ye((llr, Tge) => {\n            "use strict";\n            Tge.exports = { _isSubplotObj: true, rangemode: { valType: "enumerated", values: ["auto", "fixed", "match"], dflt: "match", editType: "calc" }, range: { valType: "info_array", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, editType: "calc" };\n          });\n          var MI = ye((ulr, Age) => {\n            "use strict";\n            Age.exports = { name: "rangeslider", containerClassName: "rangeslider-container", bgClassName: "rangeslider-bg", rangePlotClassName: "rangeslider-rangeplot", maskMinClassName: "rangeslider-mask-min", maskMaxClassName: "rangeslider-mask-max", slideBoxClassName: "rangeslider-slidebox", grabberMinClassName: "rangeslider-grabber-min", grabAreaMinClassName: "rangeslider-grabarea-min", handleMinClassName: "rangeslider-handle-min", grabberMaxClassName: "rangeslider-grabber-max", grabAreaMaxClassName: "rangeslider-grabarea-max", handleMaxClassName: "rangeslider-handle-max", maskMinOppAxisClassName: "rangeslider-mask-min-opp-axis", maskMaxOppAxisClassName: "rangeslider-mask-max-opp-axis", maskColor: "rgba(0,0,0,0.4)", maskOppAxisColor: "rgba(0,0,0,0.2)", slideBoxFill: "transparent", slideBoxCursor: "ew-resize", grabAreaFill: "transparent", grabAreaCursor: "col-resize", grabAreaWidth: 10, handleWidth: 4, handleRadius: 1, handleStrokeWidth: 1, extraPad: 15 };\n          });\n          var Ege = ye((kI) => {\n            "use strict";\n            var dmt = hf(), vmt = ru(), Sge = MI(), pmt = $h().LINE_SPACING, EI = Sge.name;\n            function Mge(e3) {\n              var t3 = e3 && e3[EI];\n              return t3 && t3.visible;\n            }\n            kI.isVisible = Mge;\n            kI.makeData = function(e3) {\n              for (var t3 = dmt.list({ _fullLayout: e3 }, "x", true), r4 = e3.margin, n4 = [], i3 = 0; i3 < t3.length; i3++) {\n                var a4 = t3[i3];\n                if (Mge(a4)) {\n                  n4.push(a4);\n                  var o4 = a4[EI];\n                  o4._id = EI + a4._id, o4._height = (e3.height - r4.b - r4.t) * o4.thickness, o4._offsetShift = Math.floor(o4.borderwidth / 2);\n                }\n              }\n              e3._rangeSliderData = n4;\n            };\n            kI.autoMarginOpts = function(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3[EI], i3 = t3._id.charAt(0), a4 = 0, o4 = 0;\n              if (t3.side === "bottom" && (a4 = t3._depth, t3.title.text !== r4._dfltTitle[i3])) {\n                o4 = 1.5 * t3.title.font.size + 10 + n4._offsetShift;\n                var s3 = (t3.title.text.match(vmt.BR_TAG_ALL) || []).length;\n                o4 += s3 * t3.title.font.size * pmt;\n              }\n              return { x: 0, y: t3._counterDomainMin, l: 0, r: 0, t: 0, b: n4._height + a4 + Math.max(r4.margin.b, o4), pad: Sge.extraPad + n4._offsetShift * 2 };\n            };\n          });\n          var Pge = ye((flr, Lge) => {\n            "use strict";\n            var CI = Dr(), kge = vl(), Cge = hf(), gmt = SI(), mmt = tV();\n            Lge.exports = function(t3, r4, n4) {\n              var i3 = t3[n4], a4 = r4[n4];\n              if (!(i3.rangeslider || r4._requestRangeslider[a4._id])) return;\n              CI.isPlainObject(i3.rangeslider) || (i3.rangeslider = {});\n              var o4 = i3.rangeslider, s3 = kge.newContainer(a4, "rangeslider");\n              function l3(L3, x2) {\n                return CI.coerce(o4, s3, gmt, L3, x2);\n              }\n              var u4, c5;\n              function f4(L3, x2) {\n                return CI.coerce(u4, c5, mmt, L3, x2);\n              }\n              var h3 = l3("visible");\n              if (h3) {\n                l3("bgcolor", r4.plot_bgcolor), l3("bordercolor"), l3("borderwidth"), l3("thickness"), l3("autorange", !a4.isValidRange(o4.range)), l3("range");\n                var d3 = r4._subplots;\n                if (d3) for (var v3 = d3.cartesian.filter(function(L3) {\n                  return L3.slice(0, Math.max(0, L3.indexOf("y"))) === Cge.name2id(n4);\n                }).map(function(L3) {\n                  return L3.slice(L3.indexOf("y"), L3.length);\n                }), _2 = CI.simpleMap(v3, Cge.id2name), b = 0; b < _2.length; b++) {\n                  var p3 = _2[b];\n                  u4 = o4[p3] || {}, c5 = kge.newContainer(s3, p3, "yaxis");\n                  var k4 = r4[p3], E3;\n                  u4.range && k4.isValidRange(u4.range) && (E3 = "fixed");\n                  var S2 = f4("rangemode", E3);\n                  S2 !== "match" && f4("range", k4.range.slice());\n                }\n                s3._input = o4;\n              }\n            };\n          });\n          var Rge = ye((hlr, Ige) => {\n            "use strict";\n            var ymt = hf().list, _mt = Ag().getAutoRange, xmt = MI();\n            Ige.exports = function(t3) {\n              for (var r4 = ymt(t3, "x", true), n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3[xmt.name];\n                a4 && a4.visible && a4.autorange && (a4._input.autorange = true, a4._input.range = a4.range = _mt(t3, i3));\n              }\n            };\n          });\n          var Oge = ye((dlr, zge) => {\n            "use strict";\n            var LI = Oa(), bmt = qa(), wmt = Mc(), Jf = Dr(), PI = Jf.strTranslate, Fge = So(), x_ = ka(), Tmt = Eb(), Amt = ph(), rV = hf(), Smt = yv(), Mmt = Sg(), rl = MI();\n            zge.exports = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._rangeSliderData, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4][rl.name];\n                i3._clipId = i3._id + "-" + t3._uid;\n              }\n              function a4(s3) {\n                return s3._name;\n              }\n              var o4 = t3._infolayer.selectAll("g." + rl.containerClassName).data(r4, a4);\n              o4.exit().each(function(s3) {\n                var l3 = s3[rl.name];\n                t3._topdefs.select("#" + l3._clipId).remove();\n              }).remove(), r4.length !== 0 && (o4.enter().append("g").classed(rl.containerClassName, true).attr("pointer-events", "all"), o4.each(function(s3) {\n                var l3 = LI.select(this), u4 = s3[rl.name], c5 = t3[rV.id2name(s3.anchor)], f4 = u4[rV.id2name(s3.anchor)];\n                if (u4.range) {\n                  var h3 = Jf.simpleMap(u4.range, s3.r2l), d3 = Jf.simpleMap(s3.range, s3.r2l), v3;\n                  d3[0] < d3[1] ? v3 = [Math.min(h3[0], d3[0]), Math.max(h3[1], d3[1])] : v3 = [Math.max(h3[0], d3[0]), Math.min(h3[1], d3[1])], u4.range = u4._input.range = Jf.simpleMap(v3, s3.l2r);\n                }\n                s3.cleanRange("rangeslider.range");\n                var _2 = t3._size, b = s3.domain;\n                u4._width = _2.w * (b[1] - b[0]);\n                var p3 = Math.round(_2.l + _2.w * b[0]), k4 = Math.round(_2.t + _2.h * (1 - s3._counterDomainMin) + (s3.side === "bottom" ? s3._depth : 0) + u4._offsetShift + rl.extraPad);\n                l3.attr("transform", PI(p3, k4)), u4._rl = Jf.simpleMap(u4.range, s3.r2l);\n                var E3 = u4._rl[0], S2 = u4._rl[1], L3 = S2 - E3;\n                if (u4.p2d = function(G2) {\n                  return G2 / u4._width * L3 + E3;\n                }, u4.d2p = function(G2) {\n                  return (G2 - E3) / L3 * u4._width;\n                }, s3.rangebreaks) {\n                  var x2 = s3.locateBreaks(E3, S2);\n                  if (x2.length) {\n                    var C3, M4, g3 = 0;\n                    for (C3 = 0; C3 < x2.length; C3++) M4 = x2[C3], g3 += M4.max - M4.min;\n                    var P3 = u4._width / (S2 - E3 - g3), T3 = [-P3 * E3];\n                    for (C3 = 0; C3 < x2.length; C3++) M4 = x2[C3], T3.push(T3[T3.length - 1] - P3 * (M4.max - M4.min));\n                    for (u4.d2p = function(G2) {\n                      for (var Z = T3[0], j3 = 0; j3 < x2.length; j3++) {\n                        var N2 = x2[j3];\n                        if (G2 >= N2.max) Z = T3[j3 + 1];\n                        else if (G2 < N2.min) break;\n                      }\n                      return Z + P3 * G2;\n                    }, C3 = 0; C3 < x2.length; C3++) M4 = x2[C3], M4.pmin = u4.d2p(M4.min), M4.pmax = u4.d2p(M4.max);\n                    u4.p2d = function(G2) {\n                      for (var Z = T3[0], j3 = 0; j3 < x2.length; j3++) {\n                        var N2 = x2[j3];\n                        if (G2 >= N2.pmax) Z = T3[j3 + 1];\n                        else if (G2 < N2.pmin) break;\n                      }\n                      return (G2 - Z) / P3;\n                    };\n                  }\n                }\n                if (f4.rangemode !== "match") {\n                  var z3 = c5.r2l(f4.range[0]), O3 = c5.r2l(f4.range[1]), V2 = O3 - z3;\n                  u4.d2pOppAxis = function(G2) {\n                    return (G2 - z3) / V2 * u4._height;\n                  };\n                }\n                l3.call(Lmt, e3, s3, u4).call(Pmt, e3, s3, u4).call(Imt, e3, s3, u4).call(Dmt, e3, s3, u4, f4).call(Fmt, e3, s3, u4).call(zmt, e3, s3, u4), Emt(l3, e3, s3, u4), Cmt(l3, e3, s3, u4, c5, f4), s3.side === "bottom" && Tmt.draw(e3, s3._id + "title", { propContainer: s3, propName: s3._name + ".title.text", placeholder: t3._dfltTitle.x, attributes: { x: s3._offset + s3._length / 2, y: k4 + u4._height + u4._offsetShift + 10 + 1.5 * s3.title.font.size, "text-anchor": "middle" } });\n              }));\n            };\n            function Dge(e3) {\n              return typeof e3.clientX == "number" ? e3.clientX : e3.touches && e3.touches.length > 0 ? e3.touches[0].clientX : 0;\n            }\n            function Emt(e3, t3, r4, n4) {\n              if (t3._context.staticPlot) return;\n              var i3 = e3.select("rect." + rl.slideBoxClassName).node(), a4 = e3.select("rect." + rl.grabAreaMinClassName).node(), o4 = e3.select("rect." + rl.grabAreaMaxClassName).node();\n              function s3() {\n                var l3 = LI.event, u4 = l3.target, c5 = Dge(l3), f4 = c5 - e3.node().getBoundingClientRect().left, h3 = n4.d2p(r4._rl[0]), d3 = n4.d2p(r4._rl[1]), v3 = Smt.coverSlip();\n                this.addEventListener("touchmove", _2), this.addEventListener("touchend", b), v3.addEventListener("mousemove", _2), v3.addEventListener("mouseup", b);\n                function _2(p3) {\n                  var k4 = Dge(p3), E3 = +k4 - c5, S2, L3, x2;\n                  switch (u4) {\n                    case i3:\n                      if (x2 = "ew-resize", h3 + E3 > r4._length || d3 + E3 < 0) return;\n                      S2 = h3 + E3, L3 = d3 + E3;\n                      break;\n                    case a4:\n                      if (x2 = "col-resize", h3 + E3 > r4._length) return;\n                      S2 = h3 + E3, L3 = d3;\n                      break;\n                    case o4:\n                      if (x2 = "col-resize", d3 + E3 < 0) return;\n                      S2 = h3, L3 = d3 + E3;\n                      break;\n                    default:\n                      x2 = "ew-resize", S2 = f4, L3 = f4 + E3;\n                      break;\n                  }\n                  if (L3 < S2) {\n                    var C3 = L3;\n                    L3 = S2, S2 = C3;\n                  }\n                  n4._pixelMin = S2, n4._pixelMax = L3, Mmt(LI.select(v3), x2), kmt(e3, t3, r4, n4);\n                }\n                function b() {\n                  v3.removeEventListener("mousemove", _2), v3.removeEventListener("mouseup", b), this.removeEventListener("touchmove", _2), this.removeEventListener("touchend", b), Jf.removeElement(v3);\n                }\n              }\n              e3.on("mousedown", s3), e3.on("touchstart", s3);\n            }\n            function kmt(e3, t3, r4, n4) {\n              function i3(s3) {\n                return r4.l2r(Jf.constrain(s3, n4._rl[0], n4._rl[1]));\n              }\n              var a4 = i3(n4.p2d(n4._pixelMin)), o4 = i3(n4.p2d(n4._pixelMax));\n              window.requestAnimationFrame(function() {\n                bmt.call("_guiRelayout", t3, r4._name + ".range", [a4, o4]);\n              });\n            }\n            function Cmt(e3, t3, r4, n4, i3, a4) {\n              var o4 = rl.handleWidth / 2;\n              function s3(p3) {\n                return Jf.constrain(p3, 0, n4._width);\n              }\n              function l3(p3) {\n                return Jf.constrain(p3, 0, n4._height);\n              }\n              function u4(p3) {\n                return Jf.constrain(p3, -o4, n4._width + o4);\n              }\n              var c5 = s3(n4.d2p(r4._rl[0])), f4 = s3(n4.d2p(r4._rl[1]));\n              if (e3.select("rect." + rl.slideBoxClassName).attr("x", c5).attr("width", f4 - c5), e3.select("rect." + rl.maskMinClassName).attr("width", c5), e3.select("rect." + rl.maskMaxClassName).attr("x", f4).attr("width", n4._width - f4), a4.rangemode !== "match") {\n                var h3 = n4._height - l3(n4.d2pOppAxis(i3._rl[1])), d3 = n4._height - l3(n4.d2pOppAxis(i3._rl[0]));\n                e3.select("rect." + rl.maskMinOppAxisClassName).attr("x", c5).attr("height", h3).attr("width", f4 - c5), e3.select("rect." + rl.maskMaxOppAxisClassName).attr("x", c5).attr("y", d3).attr("height", n4._height - d3).attr("width", f4 - c5), e3.select("rect." + rl.slideBoxClassName).attr("y", h3).attr("height", d3 - h3);\n              }\n              var v3 = 0.5, _2 = Math.round(u4(c5 - o4)) - v3, b = Math.round(u4(f4 - o4)) + v3;\n              e3.select("g." + rl.grabberMinClassName).attr("transform", PI(_2, v3)), e3.select("g." + rl.grabberMaxClassName).attr("transform", PI(b, v3));\n            }\n            function Lmt(e3, t3, r4, n4) {\n              var i3 = Jf.ensureSingle(e3, "rect", rl.bgClassName, function(l3) {\n                l3.attr({ x: 0, y: 0, "shape-rendering": "crispEdges" });\n              }), a4 = n4.borderwidth % 2 === 0 ? n4.borderwidth : n4.borderwidth - 1, o4 = -n4._offsetShift, s3 = Fge.crispRound(t3, n4.borderwidth);\n              i3.attr({ width: n4._width + a4, height: n4._height + a4, transform: PI(o4, o4), "stroke-width": s3 }).call(x_.stroke, n4.bordercolor).call(x_.fill, n4.bgcolor);\n            }\n            function Pmt(e3, t3, r4, n4) {\n              var i3 = t3._fullLayout, a4 = Jf.ensureSingleById(i3._topdefs, "clipPath", n4._clipId, function(o4) {\n                o4.append("rect").attr({ x: 0, y: 0 });\n              });\n              a4.select("rect").attr({ width: n4._width, height: n4._height });\n            }\n            function Imt(e3, t3, r4, n4) {\n              var i3 = t3.calcdata, a4 = e3.selectAll("g." + rl.rangePlotClassName).data(r4._subplotsWith, Jf.identity);\n              a4.enter().append("g").attr("class", function(s3) {\n                return rl.rangePlotClassName + " " + s3;\n              }).call(Fge.setClipUrl, n4._clipId, t3), a4.order(), a4.exit().remove();\n              var o4;\n              a4.each(function(s3, l3) {\n                var u4 = LI.select(this), c5 = l3 === 0, f4 = rV.getFromId(t3, s3, "y"), h3 = f4._name, d3 = n4[h3], v3 = { data: [], layout: { xaxis: { type: r4.type, domain: [0, 1], range: n4.range.slice(), calendar: r4.calendar }, width: n4._width, height: n4._height, margin: { t: 0, b: 0, l: 0, r: 0 } }, _context: t3._context };\n                r4.rangebreaks && (v3.layout.xaxis.rangebreaks = r4.rangebreaks), v3.layout[h3] = { type: f4.type, domain: [0, 1], range: d3.rangemode !== "match" ? d3.range.slice() : f4.range.slice(), calendar: f4.calendar }, f4.rangebreaks && (v3.layout[h3].rangebreaks = f4.rangebreaks), wmt.supplyDefaults(v3);\n                var _2 = v3._fullLayout.xaxis, b = v3._fullLayout[h3];\n                _2.clearCalc(), _2.setScale(), b.clearCalc(), b.setScale();\n                var p3 = { id: s3, plotgroup: u4, xaxis: _2, yaxis: b, isRangePlot: true };\n                c5 ? o4 = p3 : (p3.mainplot = "xy", p3.mainplotinfo = o4), Amt.rangePlot(t3, p3, Rmt(i3, s3));\n              });\n            }\n            function Rmt(e3, t3) {\n              for (var r4 = [], n4 = 0; n4 < e3.length; n4++) {\n                var i3 = e3[n4], a4 = i3[0].trace;\n                a4.xaxis + a4.yaxis === t3 && r4.push(i3);\n              }\n              return r4;\n            }\n            function Dmt(e3, t3, r4, n4, i3) {\n              var a4 = Jf.ensureSingle(e3, "rect", rl.maskMinClassName, function(u4) {\n                u4.attr({ x: 0, y: 0, "shape-rendering": "crispEdges" });\n              });\n              a4.attr("height", n4._height).call(x_.fill, rl.maskColor);\n              var o4 = Jf.ensureSingle(e3, "rect", rl.maskMaxClassName, function(u4) {\n                u4.attr({ y: 0, "shape-rendering": "crispEdges" });\n              });\n              if (o4.attr("height", n4._height).call(x_.fill, rl.maskColor), i3.rangemode !== "match") {\n                var s3 = Jf.ensureSingle(e3, "rect", rl.maskMinOppAxisClassName, function(u4) {\n                  u4.attr({ y: 0, "shape-rendering": "crispEdges" });\n                });\n                s3.attr("width", n4._width).call(x_.fill, rl.maskOppAxisColor);\n                var l3 = Jf.ensureSingle(e3, "rect", rl.maskMaxOppAxisClassName, function(u4) {\n                  u4.attr({ y: 0, "shape-rendering": "crispEdges" });\n                });\n                l3.attr("width", n4._width).style("border-top", rl.maskOppBorder).call(x_.fill, rl.maskOppAxisColor);\n              }\n            }\n            function Fmt(e3, t3, r4, n4) {\n              if (!t3._context.staticPlot) {\n                var i3 = Jf.ensureSingle(e3, "rect", rl.slideBoxClassName, function(a4) {\n                  a4.attr({ y: 0, cursor: rl.slideBoxCursor, "shape-rendering": "crispEdges" });\n                });\n                i3.attr({ height: n4._height, fill: rl.slideBoxFill });\n              }\n            }\n            function zmt(e3, t3, r4, n4) {\n              var i3 = Jf.ensureSingle(e3, "g", rl.grabberMinClassName), a4 = Jf.ensureSingle(e3, "g", rl.grabberMaxClassName), o4 = { x: 0, width: rl.handleWidth, rx: rl.handleRadius, fill: x_.background, stroke: x_.defaultLine, "stroke-width": rl.handleStrokeWidth, "shape-rendering": "crispEdges" }, s3 = { y: Math.round(n4._height / 4), height: Math.round(n4._height / 2) }, l3 = Jf.ensureSingle(i3, "rect", rl.handleMinClassName, function(d3) {\n                d3.attr(o4);\n              });\n              l3.attr(s3);\n              var u4 = Jf.ensureSingle(a4, "rect", rl.handleMaxClassName, function(d3) {\n                d3.attr(o4);\n              });\n              u4.attr(s3);\n              var c5 = { width: rl.grabAreaWidth, x: 0, y: 0, fill: rl.grabAreaFill, cursor: t3._context.staticPlot ? void 0 : rl.grabAreaCursor }, f4 = Jf.ensureSingle(i3, "rect", rl.grabAreaMinClassName, function(d3) {\n                d3.attr(c5);\n              });\n              f4.attr("height", n4._height);\n              var h3 = Jf.ensureSingle(a4, "rect", rl.grabAreaMaxClassName, function(d3) {\n                d3.attr(c5);\n              });\n              h3.attr("height", n4._height);\n            }\n          });\n          var Bge = ye((vlr, qge) => {\n            "use strict";\n            var Omt = Dr(), qmt = SI(), Bmt = tV(), iV = Ege();\n            qge.exports = { moduleType: "component", name: "rangeslider", schema: { subplots: { xaxis: { rangeslider: Omt.extendFlat({}, qmt, { yaxis: Bmt }) } } }, layoutAttributes: SI(), handleDefaults: Pge(), calcAutorange: Rge(), draw: Oge(), isVisible: iV.isVisible, makeData: iV.makeData, autoMarginOpts: iV.autoMarginOpts };\n          });\n          var II = ye((plr, Uge) => {\n            "use strict";\n            var Nmt = ec(), Nge = Lh(), Umt = vl().templatedArray, Vmt = Umt("button", { visible: { valType: "boolean", dflt: true, editType: "plot" }, step: { valType: "enumerated", values: ["month", "year", "day", "hour", "minute", "second", "all"], dflt: "month", editType: "plot" }, stepmode: { valType: "enumerated", values: ["backward", "todate"], dflt: "backward", editType: "plot" }, count: { valType: "number", min: 0, dflt: 1, editType: "plot" }, label: { valType: "string", editType: "plot" }, editType: "plot" });\n            Uge.exports = { visible: { valType: "boolean", editType: "plot" }, buttons: Vmt, x: { valType: "number", min: -2, max: 3, editType: "plot" }, xanchor: { valType: "enumerated", values: ["auto", "left", "center", "right"], dflt: "left", editType: "plot" }, y: { valType: "number", min: -2, max: 3, editType: "plot" }, yanchor: { valType: "enumerated", values: ["auto", "top", "middle", "bottom"], dflt: "bottom", editType: "plot" }, font: Nmt({ editType: "plot" }), bgcolor: { valType: "color", dflt: Nge.lightLine, editType: "plot" }, activecolor: { valType: "color", editType: "plot" }, bordercolor: { valType: "color", dflt: Nge.defaultLine, editType: "plot" }, borderwidth: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "plot" };\n          });\n          var nV = ye((glr, Vge) => {\n            "use strict";\n            Vge.exports = { yPad: 0.02, minButtonWidth: 30, rx: 3, ry: 3, lightAmount: 25, darkAmount: 10 };\n          });\n          var jge = ye((mlr, Hge) => {\n            "use strict";\n            var RI = Dr(), Gmt = ka(), Hmt = vl(), jmt = Yd(), Gge = II(), aV = nV();\n            Hge.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = t3.rangeselector || {}, s3 = Hmt.newContainer(r4, "rangeselector");\n              function l3(d3, v3) {\n                return RI.coerce(o4, s3, Gge, d3, v3);\n              }\n              var u4 = jmt(o4, s3, { name: "buttons", handleItemDefaults: Wmt, calendar: a4 }), c5 = l3("visible", u4.length > 0);\n              if (c5) {\n                var f4 = Xmt(r4, n4, i3);\n                l3("x", f4[0]), l3("y", f4[1]), RI.noneOrAll(t3, r4, ["x", "y"]), l3("xanchor"), l3("yanchor"), RI.coerceFont(l3, "font", n4.font);\n                var h3 = l3("bgcolor");\n                l3("activecolor", Gmt.contrast(h3, aV.lightAmount, aV.darkAmount)), l3("bordercolor"), l3("borderwidth");\n              }\n            };\n            function Wmt(e3, t3, r4, n4) {\n              var i3 = n4.calendar;\n              function a4(l3, u4) {\n                return RI.coerce(e3, t3, Gge.buttons, l3, u4);\n              }\n              var o4 = a4("visible");\n              if (o4) {\n                var s3 = a4("step");\n                s3 !== "all" && (i3 && i3 !== "gregorian" && (s3 === "month" || s3 === "year") ? t3.stepmode = "backward" : a4("stepmode"), a4("count")), a4("label");\n              }\n            }\n            function Xmt(e3, t3, r4) {\n              for (var n4 = r4.filter(function(s3) {\n                return t3[s3].anchor === e3._id;\n              }), i3 = 0, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = t3[n4[a4]].domain;\n                o4 && (i3 = Math.max(o4[1], i3));\n              }\n              return [e3.domain[0], i3 + aV.yPad];\n            }\n          });\n          var Xge = ye((ylr, Wge) => {\n            "use strict";\n            var Zmt = bO(), Ymt = Dr().titleCase;\n            Wge.exports = function(t3, r4) {\n              var n4 = t3._name, i3 = {};\n              if (r4.step === "all") i3[n4 + ".autorange"] = true;\n              else {\n                var a4 = Kmt(t3, r4);\n                i3[n4 + ".range[0]"] = a4[0], i3[n4 + ".range[1]"] = a4[1];\n              }\n              return i3;\n            };\n            function Kmt(e3, t3) {\n              var r4 = e3.range, n4 = new Date(e3.r2l(r4[1])), i3 = t3.step, a4 = Zmt["utc" + Ymt(i3)], o4 = t3.count, s3;\n              switch (t3.stepmode) {\n                case "backward":\n                  s3 = e3.l2r(+a4.offset(n4, -o4));\n                  break;\n                case "todate":\n                  var l3 = a4.offset(n4, -o4);\n                  s3 = e3.l2r(+a4.ceil(l3));\n                  break;\n              }\n              var u4 = r4[1];\n              return [s3, u4];\n            }\n          });\n          var tme = ye((_lr, eme) => {\n            "use strict";\n            var FI = Oa(), Jmt = qa(), $mt = Mc(), Zge = ka(), Qge = So(), Ry = Dr(), Yge = Ry.strTranslate, DI = ru(), Qmt = hf(), lV = $h(), Kge = lV.LINE_SPACING, Jge = lV.FROM_TL, $ge = lV.FROM_BR, sV = nV(), eyt = Xge();\n            eme.exports = function(t3) {\n              var r4 = t3._fullLayout, n4 = r4._infolayer.selectAll(".rangeselector").data(tyt(t3), ryt);\n              n4.enter().append("g").classed("rangeselector", true), n4.exit().remove(), n4.style({ cursor: "pointer", "pointer-events": "all" }), n4.each(function(i3) {\n                var a4 = FI.select(this), o4 = i3, s3 = o4.rangeselector, l3 = a4.selectAll("g.button").data(Ry.filterVisible(s3.buttons));\n                l3.enter().append("g").classed("button", true), l3.exit().remove(), l3.each(function(u4) {\n                  var c5 = FI.select(this), f4 = eyt(o4, u4);\n                  u4._isActive = iyt(o4, u4, f4), c5.call(oV, s3, u4), c5.call(ayt, s3, u4, t3), c5.on("click", function() {\n                    t3._dragged || Jmt.call("_guiRelayout", t3, f4);\n                  }), c5.on("mouseover", function() {\n                    u4._isHovered = true, c5.call(oV, s3, u4);\n                  }), c5.on("mouseout", function() {\n                    u4._isHovered = false, c5.call(oV, s3, u4);\n                  });\n                }), syt(t3, l3, s3, o4._name, a4);\n              });\n            };\n            function tyt(e3) {\n              for (var t3 = Qmt.list(e3, "x", true), r4 = [], n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4];\n                i3.rangeselector && i3.rangeselector.visible && r4.push(i3);\n              }\n              return r4;\n            }\n            function ryt(e3) {\n              return e3._id;\n            }\n            function iyt(e3, t3, r4) {\n              if (t3.step === "all") return e3.autorange === true;\n              var n4 = Object.keys(r4);\n              return e3.range[0] === r4[n4[0]] && e3.range[1] === r4[n4[1]];\n            }\n            function oV(e3, t3, r4) {\n              var n4 = Ry.ensureSingle(e3, "rect", "selector-rect", function(i3) {\n                i3.attr("shape-rendering", "crispEdges");\n              });\n              n4.attr({ rx: sV.rx, ry: sV.ry }), n4.call(Zge.stroke, t3.bordercolor).call(Zge.fill, nyt(t3, r4)).style("stroke-width", t3.borderwidth + "px");\n            }\n            function nyt(e3, t3) {\n              return t3._isActive || t3._isHovered ? e3.activecolor : e3.bgcolor;\n            }\n            function ayt(e3, t3, r4, n4) {\n              function i3(o4) {\n                DI.convertToTspans(o4, n4);\n              }\n              var a4 = Ry.ensureSingle(e3, "text", "selector-text", function(o4) {\n                o4.attr("text-anchor", "middle");\n              });\n              a4.call(Qge.font, t3.font).text(oyt(r4, n4._fullLayout._meta)).call(i3);\n            }\n            function oyt(e3, t3) {\n              return e3.label ? t3 ? Ry.templateString(e3.label, t3) : e3.label : e3.step === "all" ? "all" : e3.count + e3.step.charAt(0);\n            }\n            function syt(e3, t3, r4, n4, i3) {\n              var a4 = 0, o4 = 0, s3 = r4.borderwidth;\n              t3.each(function() {\n                var d3 = FI.select(this), v3 = d3.select(".selector-text"), _2 = r4.font.size * Kge, b = Math.max(_2 * DI.lineCount(v3), 16) + 3;\n                o4 = Math.max(o4, b);\n              }), t3.each(function() {\n                var d3 = FI.select(this), v3 = d3.select(".selector-rect"), _2 = d3.select(".selector-text"), b = _2.node() && Qge.bBox(_2.node()).width, p3 = r4.font.size * Kge, k4 = DI.lineCount(_2), E3 = Math.max(b + 10, sV.minButtonWidth);\n                d3.attr("transform", Yge(s3 + a4, s3)), v3.attr({ x: 0, y: 0, width: E3, height: o4 }), DI.positionText(_2, E3 / 2, o4 / 2 - (k4 - 1) * p3 / 2 + 3), a4 += E3 + 5;\n              });\n              var l3 = e3._fullLayout._size, u4 = l3.l + l3.w * r4.x, c5 = l3.t + l3.h * (1 - r4.y), f4 = "left";\n              Ry.isRightAnchor(r4) && (u4 -= a4, f4 = "right"), Ry.isCenterAnchor(r4) && (u4 -= a4 / 2, f4 = "center");\n              var h3 = "top";\n              Ry.isBottomAnchor(r4) && (c5 -= o4, h3 = "bottom"), Ry.isMiddleAnchor(r4) && (c5 -= o4 / 2, h3 = "middle"), a4 = Math.ceil(a4), o4 = Math.ceil(o4), u4 = Math.round(u4), c5 = Math.round(c5), $mt.autoMargin(e3, n4 + "-range-selector", { x: r4.x, y: r4.y, l: a4 * Jge[f4], r: a4 * $ge[f4], b: o4 * $ge[h3], t: o4 * Jge[h3] }), i3.attr("transform", Yge(u4, c5));\n            }\n          });\n          var ime = ye((xlr, rme) => {\n            "use strict";\n            rme.exports = { moduleType: "component", name: "rangeselector", schema: { subplots: { xaxis: { rangeselector: II() } } }, layoutAttributes: II(), handleDefaults: jge(), draw: tme() };\n          });\n          var Cc = ye((uV) => {\n            "use strict";\n            var nme = Ao().extendFlat;\n            uV.attributes = function(e3, t3) {\n              e3 = e3 || {}, t3 = t3 || {};\n              var r4 = { valType: "info_array", editType: e3.editType, items: [{ valType: "number", min: 0, max: 1, editType: e3.editType }, { valType: "number", min: 0, max: 1, editType: e3.editType }], dflt: [0, 1] }, n4 = e3.name ? e3.name + " " : "", i3 = e3.trace ? "trace " : "subplot ", a4 = t3.description ? " " + t3.description : "", o4 = { x: nme({}, r4, {}), y: nme({}, r4, {}), editType: e3.editType };\n              return e3.noGridCell || (o4.row = { valType: "integer", min: 0, dflt: 0, editType: e3.editType }, o4.column = { valType: "integer", min: 0, dflt: 0, editType: e3.editType }), o4;\n            };\n            uV.defaults = function(e3, t3, r4, n4) {\n              var i3 = n4 && n4.x || [0, 1], a4 = n4 && n4.y || [0, 1], o4 = t3.grid;\n              if (o4) {\n                var s3 = r4("domain.column");\n                s3 !== void 0 && (s3 < o4.columns ? i3 = o4._domains.x[s3] : delete e3.domain.column);\n                var l3 = r4("domain.row");\n                l3 !== void 0 && (l3 < o4.rows ? a4 = o4._domains.y[l3] : delete e3.domain.row);\n              }\n              var u4 = r4("domain.x", i3), c5 = r4("domain.y", a4);\n              u4[0] < u4[1] || (e3.domain.x = i3.slice()), c5[0] < c5[1] || (e3.domain.y = a4.slice());\n            };\n          });\n          var fV = ye((wlr, lme) => {\n            "use strict";\n            var lyt = Dr(), uyt = o3().counter, cyt = Cc().attributes, ame = hd().idRegex, fyt = vl(), cV = { rows: { valType: "integer", min: 1, editType: "plot" }, roworder: { valType: "enumerated", values: ["top to bottom", "bottom to top"], dflt: "top to bottom", editType: "plot" }, columns: { valType: "integer", min: 1, editType: "plot" }, subplots: { valType: "info_array", freeLength: true, dimensions: 2, items: { valType: "enumerated", values: [uyt("xy").toString(), ""], editType: "plot" }, editType: "plot" }, xaxes: { valType: "info_array", freeLength: true, items: { valType: "enumerated", values: [ame.x.toString(), ""], editType: "plot" }, editType: "plot" }, yaxes: { valType: "info_array", freeLength: true, items: { valType: "enumerated", values: [ame.y.toString(), ""], editType: "plot" }, editType: "plot" }, pattern: { valType: "enumerated", values: ["independent", "coupled"], dflt: "coupled", editType: "plot" }, xgap: { valType: "number", min: 0, max: 1, editType: "plot" }, ygap: { valType: "number", min: 0, max: 1, editType: "plot" }, domain: cyt({ name: "grid", editType: "plot", noGridCell: true }, {}), xside: { valType: "enumerated", values: ["bottom", "bottom plot", "top plot", "top"], dflt: "bottom plot", editType: "plot" }, yside: { valType: "enumerated", values: ["left", "left plot", "right plot", "right"], dflt: "left plot", editType: "plot" }, editType: "plot" };\n            function zI(e3, t3, r4) {\n              var n4 = t3[r4 + "axes"], i3 = Object.keys((e3._splomAxes || {})[r4] || {});\n              if (Array.isArray(n4)) return n4;\n              if (i3.length) return i3;\n            }\n            function hyt(e3, t3) {\n              var r4 = e3.grid || {}, n4 = zI(t3, r4, "x"), i3 = zI(t3, r4, "y");\n              if (!e3.grid && !n4 && !i3) return;\n              var a4 = Array.isArray(r4.subplots) && Array.isArray(r4.subplots[0]), o4 = Array.isArray(n4), s3 = Array.isArray(i3), l3 = o4 && n4 !== r4.xaxes && s3 && i3 !== r4.yaxes, u4, c5;\n              a4 ? (u4 = r4.subplots.length, c5 = r4.subplots[0].length) : (s3 && (u4 = i3.length), o4 && (c5 = n4.length));\n              var f4 = fyt.newContainer(t3, "grid");\n              function h3(x2, C3) {\n                return lyt.coerce(r4, f4, cV, x2, C3);\n              }\n              var d3 = h3("rows", u4), v3 = h3("columns", c5);\n              if (!(d3 * v3 > 1)) {\n                delete t3.grid;\n                return;\n              }\n              if (!a4 && !o4 && !s3) {\n                var _2 = h3("pattern") === "independent";\n                _2 && (a4 = true);\n              }\n              f4._hasSubplotGrid = a4;\n              var b = h3("roworder"), p3 = b === "top to bottom", k4 = a4 ? 0.2 : 0.1, E3 = a4 ? 0.3 : 0.1, S2, L3;\n              l3 && t3._splomGridDflt && (S2 = t3._splomGridDflt.xside, L3 = t3._splomGridDflt.yside), f4._domains = { x: ome("x", h3, k4, S2, v3), y: ome("y", h3, E3, L3, d3, p3) };\n            }\n            function ome(e3, t3, r4, n4, i3, a4) {\n              var o4 = t3(e3 + "gap", r4), s3 = t3("domain." + e3);\n              t3(e3 + "side", n4);\n              for (var l3 = new Array(i3), u4 = s3[0], c5 = (s3[1] - u4) / (i3 - o4), f4 = c5 * (1 - o4), h3 = 0; h3 < i3; h3++) {\n                var d3 = u4 + c5 * h3;\n                l3[a4 ? i3 - 1 - h3 : h3] = [d3, d3 + f4];\n              }\n              return l3;\n            }\n            function dyt(e3, t3) {\n              var r4 = t3.grid;\n              if (!(!r4 || !r4._domains)) {\n                var n4 = e3.grid || {}, i3 = t3._subplots, a4 = r4._hasSubplotGrid, o4 = r4.rows, s3 = r4.columns, l3 = r4.pattern === "independent", u4, c5, f4, h3, d3, v3, _2, b = r4._axisMap = {};\n                if (a4) {\n                  var p3 = n4.subplots || [];\n                  v3 = r4.subplots = new Array(o4);\n                  var k4 = 1;\n                  for (u4 = 0; u4 < o4; u4++) {\n                    var E3 = v3[u4] = new Array(s3), S2 = p3[u4] || [];\n                    for (c5 = 0; c5 < s3; c5++) if (l3 ? (d3 = k4 === 1 ? "xy" : "x" + k4 + "y" + k4, k4++) : d3 = S2[c5], E3[c5] = "", i3.cartesian.indexOf(d3) !== -1) {\n                      if (_2 = d3.indexOf("y"), f4 = d3.slice(0, _2), h3 = d3.slice(_2), b[f4] !== void 0 && b[f4] !== c5 || b[h3] !== void 0 && b[h3] !== u4) continue;\n                      E3[c5] = d3, b[f4] = c5, b[h3] = u4;\n                    }\n                  }\n                } else {\n                  var L3 = zI(t3, n4, "x"), x2 = zI(t3, n4, "y");\n                  r4.xaxes = sme(L3, i3.xaxis, s3, b, "x"), r4.yaxes = sme(x2, i3.yaxis, o4, b, "y");\n                }\n                var C3 = r4._anchors = {}, M4 = r4.roworder === "top to bottom";\n                for (var g3 in b) {\n                  var P3 = g3.charAt(0), T3 = r4[P3 + "side"], z3, O3, V2;\n                  if (T3.length < 8) C3[g3] = "free";\n                  else if (P3 === "x") {\n                    if (T3.charAt(0) === "t" === M4 ? (z3 = 0, O3 = 1, V2 = o4) : (z3 = o4 - 1, O3 = -1, V2 = -1), a4) {\n                      var G2 = b[g3];\n                      for (u4 = z3; u4 !== V2; u4 += O3) if (d3 = v3[u4][G2], !!d3 && (_2 = d3.indexOf("y"), d3.slice(0, _2) === g3)) {\n                        C3[g3] = d3.slice(_2);\n                        break;\n                      }\n                    } else for (u4 = z3; u4 !== V2; u4 += O3) if (h3 = r4.yaxes[u4], i3.cartesian.indexOf(g3 + h3) !== -1) {\n                      C3[g3] = h3;\n                      break;\n                    }\n                  } else if (T3.charAt(0) === "l" ? (z3 = 0, O3 = 1, V2 = s3) : (z3 = s3 - 1, O3 = -1, V2 = -1), a4) {\n                    var Z = b[g3];\n                    for (u4 = z3; u4 !== V2; u4 += O3) if (d3 = v3[Z][u4], !!d3 && (_2 = d3.indexOf("y"), d3.slice(_2) === g3)) {\n                      C3[g3] = d3.slice(0, _2);\n                      break;\n                    }\n                  } else for (u4 = z3; u4 !== V2; u4 += O3) if (f4 = r4.xaxes[u4], i3.cartesian.indexOf(f4 + g3) !== -1) {\n                    C3[g3] = f4;\n                    break;\n                  }\n                }\n              }\n            }\n            function sme(e3, t3, r4, n4, i3) {\n              var a4 = new Array(r4), o4;\n              function s3(l3, u4) {\n                t3.indexOf(u4) !== -1 && n4[u4] === void 0 ? (a4[l3] = u4, n4[u4] = l3) : a4[l3] = "";\n              }\n              if (Array.isArray(e3)) for (o4 = 0; o4 < r4; o4++) s3(o4, e3[o4]);\n              else for (s3(0, i3), o4 = 1; o4 < r4; o4++) s3(o4, i3 + (o4 + 1));\n              return a4;\n            }\n            lme.exports = { moduleType: "component", name: "grid", schema: { layout: { grid: cV } }, layoutAttributes: cV, sizeDefaults: hyt, contentDefaults: dyt };\n          });\n          var hV = ye((Tlr, ume) => {\n            "use strict";\n            ume.exports = { visible: { valType: "boolean", editType: "calc" }, type: { valType: "enumerated", values: ["percent", "constant", "sqrt", "data"], editType: "calc" }, symmetric: { valType: "boolean", editType: "calc" }, array: { valType: "data_array", editType: "calc" }, arrayminus: { valType: "data_array", editType: "calc" }, value: { valType: "number", min: 0, dflt: 10, editType: "calc" }, valueminus: { valType: "number", min: 0, dflt: 10, editType: "calc" }, traceref: { valType: "integer", min: 0, dflt: 0, editType: "style" }, tracerefminus: { valType: "integer", min: 0, dflt: 0, editType: "style" }, copy_ystyle: { valType: "boolean", editType: "plot" }, copy_zstyle: { valType: "boolean", editType: "style" }, color: { valType: "color", editType: "style" }, thickness: { valType: "number", min: 0, dflt: 2, editType: "style" }, width: { valType: "number", min: 0, editType: "plot" }, editType: "calc" };\n          });\n          var hme = ye((Alr, fme) => {\n            "use strict";\n            var cme = Eo(), vyt = qa(), pyt = Dr(), gyt = vl(), myt = hV();\n            fme.exports = function(e3, t3, r4, n4) {\n              var i3 = "error_" + n4.axis, a4 = gyt.newContainer(t3, i3), o4 = e3[i3] || {};\n              function s3(v3, _2) {\n                return pyt.coerce(o4, a4, myt, v3, _2);\n              }\n              var l3 = o4.array !== void 0 || o4.value !== void 0 || o4.type === "sqrt", u4 = s3("visible", l3);\n              if (u4 !== false) {\n                var c5 = s3("type", "array" in o4 ? "data" : "percent"), f4 = true;\n                c5 !== "sqrt" && (f4 = s3("symmetric", !((c5 === "data" ? "arrayminus" : "valueminus") in o4))), c5 === "data" ? (s3("array"), s3("traceref"), f4 || (s3("arrayminus"), s3("tracerefminus"))) : (c5 === "percent" || c5 === "constant") && (s3("value"), f4 || s3("valueminus"));\n                var h3 = "copy_" + n4.inherit + "style";\n                if (n4.inherit) {\n                  var d3 = t3["error_" + n4.inherit];\n                  (d3 || {}).visible && s3(h3, !(o4.color || cme(o4.thickness) || cme(o4.width)));\n                }\n                (!n4.inherit || !a4[h3]) && (s3("color", r4), s3("thickness"), s3("width", vyt.traceIs(t3, "gl3d") ? 0 : 4));\n              }\n            };\n          });\n          var dV = ye((Slr, vme) => {\n            "use strict";\n            vme.exports = function(t3) {\n              var r4 = t3.type, n4 = t3.symmetric;\n              if (r4 === "data") {\n                var i3 = t3.array || [];\n                if (n4) return function(u4, c5) {\n                  var f4 = +i3[c5];\n                  return [f4, f4];\n                };\n                var a4 = t3.arrayminus || [];\n                return function(u4, c5) {\n                  var f4 = +i3[c5], h3 = +a4[c5];\n                  return !isNaN(f4) || !isNaN(h3) ? [h3 || 0, f4 || 0] : [NaN, NaN];\n                };\n              } else {\n                var o4 = dme(r4, t3.value), s3 = dme(r4, t3.valueminus);\n                return n4 || t3.valueminus === void 0 ? function(u4) {\n                  var c5 = o4(u4);\n                  return [c5, c5];\n                } : function(u4) {\n                  return [s3(u4), o4(u4)];\n                };\n              }\n            };\n            function dme(e3, t3) {\n              if (e3 === "percent") return function(r4) {\n                return Math.abs(r4 * t3 / 100);\n              };\n              if (e3 === "constant") return function() {\n                return Math.abs(t3);\n              };\n              if (e3 === "sqrt") return function(r4) {\n                return Math.sqrt(Math.abs(r4));\n              };\n            }\n          });\n          var mme = ye((Mlr, gme) => {\n            "use strict";\n            var vV = Eo(), yyt = qa(), pV = ho(), _yt = Dr(), xyt = dV();\n            gme.exports = function(t3) {\n              for (var r4 = t3.calcdata, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3[0].trace;\n                if (a4.visible === true && yyt.traceIs(a4, "errorBarsOK")) {\n                  var o4 = pV.getFromId(t3, a4.xaxis), s3 = pV.getFromId(t3, a4.yaxis);\n                  pme(i3, a4, o4, "x"), pme(i3, a4, s3, "y");\n                }\n              }\n            };\n            function pme(e3, t3, r4, n4) {\n              var i3 = t3["error_" + n4] || {}, a4 = i3.visible && ["linear", "log"].indexOf(r4.type) !== -1, o4 = [];\n              if (a4) {\n                for (var s3 = xyt(i3), l3 = 0; l3 < e3.length; l3++) {\n                  var u4 = e3[l3], c5 = u4.i;\n                  if (c5 === void 0) c5 = l3;\n                  else if (c5 === null) continue;\n                  var f4 = u4[n4];\n                  if (vV(r4.c2l(f4))) {\n                    var h3 = s3(f4, c5);\n                    if (vV(h3[0]) && vV(h3[1])) {\n                      var d3 = u4[n4 + "s"] = f4 - h3[0], v3 = u4[n4 + "h"] = f4 + h3[1];\n                      o4.push(d3, v3);\n                    }\n                  }\n                }\n                var _2 = r4._id, b = t3._extremes[_2], p3 = pV.findExtremes(r4, o4, _yt.extendFlat({ tozero: b.opts.tozero }, { padded: true }));\n                b.min = b.min.concat(p3.min), b.max = b.max.concat(p3.max);\n              }\n            }\n          });\n          var xme = ye((Elr, _me) => {\n            "use strict";\n            var yme = Oa(), b_ = Eo(), byt = So(), wyt = Ru();\n            _me.exports = function(t3, r4, n4, i3) {\n              var a4, o4 = n4.xaxis, s3 = n4.yaxis, l3 = i3 && i3.duration > 0, u4 = t3._context.staticPlot;\n              r4.each(function(c5) {\n                var f4 = c5[0].trace, h3 = f4.error_x || {}, d3 = f4.error_y || {}, v3;\n                f4.ids && (v3 = function(k4) {\n                  return k4.id;\n                });\n                var _2 = wyt.hasMarkers(f4) && f4.marker.maxdisplayed > 0;\n                !d3.visible && !h3.visible && (c5 = []);\n                var b = yme.select(this).selectAll("g.errorbar").data(c5, v3);\n                if (b.exit().remove(), !!c5.length) {\n                  h3.visible || b.selectAll("path.xerror").remove(), d3.visible || b.selectAll("path.yerror").remove(), b.style("opacity", 1);\n                  var p3 = b.enter().append("g").classed("errorbar", true);\n                  l3 && p3.style("opacity", 0).transition().duration(i3.duration).style("opacity", 1), byt.setClipUrl(b, n4.layerClipId, t3), b.each(function(k4) {\n                    var E3 = yme.select(this), S2 = Tyt(k4, o4, s3);\n                    if (!(_2 && !k4.vis)) {\n                      var L3, x2 = E3.select("path.yerror");\n                      if (d3.visible && b_(S2.x) && b_(S2.yh) && b_(S2.ys)) {\n                        var C3 = d3.width;\n                        L3 = "M" + (S2.x - C3) + "," + S2.yh + "h" + 2 * C3 + "m-" + C3 + ",0V" + S2.ys, S2.noYS || (L3 += "m-" + C3 + ",0h" + 2 * C3), a4 = !x2.size(), a4 ? x2 = E3.append("path").style("vector-effect", u4 ? "none" : "non-scaling-stroke").classed("yerror", true) : l3 && (x2 = x2.transition().duration(i3.duration).ease(i3.easing)), x2.attr("d", L3);\n                      } else x2.remove();\n                      var M4 = E3.select("path.xerror");\n                      if (h3.visible && b_(S2.y) && b_(S2.xh) && b_(S2.xs)) {\n                        var g3 = (h3.copy_ystyle ? d3 : h3).width;\n                        L3 = "M" + S2.xh + "," + (S2.y - g3) + "v" + 2 * g3 + "m0,-" + g3 + "H" + S2.xs, S2.noXS || (L3 += "m0,-" + g3 + "v" + 2 * g3), a4 = !M4.size(), a4 ? M4 = E3.append("path").style("vector-effect", u4 ? "none" : "non-scaling-stroke").classed("xerror", true) : l3 && (M4 = M4.transition().duration(i3.duration).ease(i3.easing)), M4.attr("d", L3);\n                      } else M4.remove();\n                    }\n                  });\n                }\n              });\n            };\n            function Tyt(e3, t3, r4) {\n              var n4 = { x: t3.c2p(e3.x), y: r4.c2p(e3.y) };\n              return e3.yh !== void 0 && (n4.yh = r4.c2p(e3.yh), n4.ys = r4.c2p(e3.ys), b_(n4.ys) || (n4.noYS = true, n4.ys = r4.c2p(e3.ys, true))), e3.xh !== void 0 && (n4.xh = t3.c2p(e3.xh), n4.xs = t3.c2p(e3.xs), b_(n4.xs) || (n4.noXS = true, n4.xs = t3.c2p(e3.xs, true))), n4;\n            }\n          });\n          var Tme = ye((klr, wme) => {\n            "use strict";\n            var Ayt = Oa(), bme = ka();\n            wme.exports = function(t3) {\n              t3.each(function(r4) {\n                var n4 = r4[0].trace, i3 = n4.error_y || {}, a4 = n4.error_x || {}, o4 = Ayt.select(this);\n                o4.selectAll("path.yerror").style("stroke-width", i3.thickness + "px").call(bme.stroke, i3.color), a4.copy_ystyle && (a4 = i3), o4.selectAll("path.xerror").style("stroke-width", a4.thickness + "px").call(bme.stroke, a4.color);\n              });\n            };\n          });\n          var Mme = ye((Clr, Sme) => {\n            "use strict";\n            var h4 = Dr(), Ame = mc().overrideAll, d4 = hV(), Qb = { error_x: h4.extendFlat({}, d4), error_y: h4.extendFlat({}, d4) };\n            delete Qb.error_x.copy_zstyle;\n            delete Qb.error_y.copy_zstyle;\n            delete Qb.error_y.copy_ystyle;\n            var v4 = { error_x: h4.extendFlat({}, d4), error_y: h4.extendFlat({}, d4), error_z: h4.extendFlat({}, d4) };\n            delete v4.error_x.copy_ystyle;\n            delete v4.error_y.copy_ystyle;\n            delete v4.error_z.copy_ystyle;\n            delete v4.error_z.copy_zstyle;\n            Sme.exports = { moduleType: "component", name: "errorbars", schema: { traces: { scatter: Qb, bar: Qb, histogram: Qb, scatter3d: Ame(v4, "calc", "nested"), scattergl: Ame(Qb, "calc", "nested") } }, supplyDefaults: hme(), calc: mme(), makeComputeError: dV(), plot: xme(), style: Tme(), hoverInfo: Syt };\n            function Syt(e3, t3, r4) {\n              (t3.error_y || {}).visible && (r4.yerr = e3.yh - e3.y, t3.error_y.symmetric || (r4.yerrneg = e3.y - e3.ys)), (t3.error_x || {}).visible && (r4.xerr = e3.xh - e3.x, t3.error_x.symmetric || (r4.xerrneg = e3.x - e3.xs));\n            }\n          });\n          var kme = ye((Llr, Eme) => {\n            "use strict";\n            Eme.exports = { cn: { colorbar: "colorbar", cbbg: "cbbg", cbfill: "cbfill", cbfills: "cbfills", cbline: "cbline", cblines: "cblines", cbaxis: "cbaxis", cbtitleunshift: "cbtitleunshift", cbtitle: "cbtitle", cboutline: "cboutline", crisp: "crisp", jsPlaceholder: "js-placeholder" } };\n          });\n          var Fme = ye((Plr, Dme) => {\n            "use strict";\n            var w_ = Oa(), gV = cd(), qI = Mc(), Cme = qa(), Dy = ho(), OI = yv(), B0 = Dr(), Vg = B0.strTranslate, Rme = Ao().extendFlat, mV = Sg(), Ug = So(), yV = ka(), Myt = Eb(), Eyt = ru(), kyt = pv().flipScale, Cyt = i4(), Lyt = uI(), Pyt = Rd(), _V = $h(), Lme = _V.LINE_SPACING, Pme = _V.FROM_TL, Ime = _V.FROM_BR, gf = kme().cn;\n            function Iyt(e3) {\n              var t3 = e3._fullLayout, r4 = t3._infolayer.selectAll("g." + gf.colorbar).data(Ryt(e3), function(n4) {\n                return n4._id;\n              });\n              r4.enter().append("g").attr("class", function(n4) {\n                return n4._id;\n              }).classed(gf.colorbar, true), r4.each(function(n4) {\n                var i3 = w_.select(this);\n                B0.ensureSingle(i3, "rect", gf.cbbg), B0.ensureSingle(i3, "g", gf.cbfills), B0.ensureSingle(i3, "g", gf.cblines), B0.ensureSingle(i3, "g", gf.cbaxis, function(o4) {\n                  o4.classed(gf.crisp, true);\n                }), B0.ensureSingle(i3, "g", gf.cbtitleunshift, function(o4) {\n                  o4.append("g").classed(gf.cbtitle, true);\n                }), B0.ensureSingle(i3, "rect", gf.cboutline);\n                var a4 = Dyt(i3, n4, e3);\n                a4 && a4.then && (e3._promises || []).push(a4), e3._context.edits.colorbarPosition && Fyt(i3, n4, e3);\n              }), r4.exit().each(function(n4) {\n                qI.autoMargin(e3, n4._id);\n              }).remove(), r4.order();\n            }\n            function Ryt(e3) {\n              var t3 = e3._fullLayout, r4 = e3.calcdata, n4 = [], i3, a4, o4, s3;\n              function l3(E3) {\n                return Rme(E3, { _fillcolor: null, _line: { color: null, width: null, dash: null }, _levels: { start: null, end: null, size: null }, _filllevels: null, _fillgradient: null, _zrange: null });\n              }\n              function u4() {\n                typeof s3.calc == "function" ? s3.calc(e3, o4, i3) : (i3._fillgradient = a4.reversescale ? kyt(a4.colorscale) : a4.colorscale, i3._zrange = [a4[s3.min], a4[s3.max]]);\n              }\n              for (var c5 = 0; c5 < r4.length; c5++) {\n                var f4 = r4[c5];\n                if (o4 = f4[0].trace, !!o4._module) {\n                  var h3 = o4._module.colorbar;\n                  if (o4.visible === true && h3) for (var d3 = Array.isArray(h3), v3 = d3 ? h3 : [h3], _2 = 0; _2 < v3.length; _2++) {\n                    s3 = v3[_2];\n                    var b = s3.container;\n                    a4 = b ? o4[b] : o4, a4 && a4.showscale && (i3 = l3(a4.colorbar), i3._id = "cb" + o4.uid + (d3 && b ? "-" + b : ""), i3._traceIndex = o4.index, i3._propPrefix = (b ? b + "." : "") + "colorbar.", i3._meta = o4._meta, u4(), n4.push(i3));\n                  }\n                }\n              }\n              for (var p3 in t3._colorAxes) if (a4 = t3[p3], a4.showscale) {\n                var k4 = t3._colorAxes[p3];\n                i3 = l3(a4.colorbar), i3._id = "cb" + p3, i3._propPrefix = p3 + ".colorbar.", i3._meta = t3._meta, s3 = { min: "cmin", max: "cmax" }, k4[0] !== "heatmap" && (o4 = k4[1], s3.calc = o4._module.colorbar.calc), u4(), n4.push(i3);\n              }\n              return n4;\n            }\n            function Dyt(e3, t3, r4) {\n              var n4 = t3.orientation === "v", i3 = t3.len, a4 = t3.lenmode, o4 = t3.thickness, s3 = t3.thicknessmode, l3 = t3.outlinewidth, u4 = t3.borderwidth, c5 = t3.bgcolor, f4 = t3.xanchor, h3 = t3.yanchor, d3 = t3.xpad, v3 = t3.ypad, _2 = t3.x, b = n4 ? t3.y : 1 - t3.y, p3 = t3.yref === "paper", k4 = t3.xref === "paper", E3 = r4._fullLayout, S2 = E3._size, L3 = t3._fillcolor, x2 = t3._line, C3 = t3.title, M4 = C3.side, g3 = t3._zrange || w_.extent((typeof L3 == "function" ? L3 : x2.color).domain()), P3 = typeof x2.color == "function" ? x2.color : function() {\n                return x2.color;\n              }, T3 = typeof L3 == "function" ? L3 : function() {\n                return L3;\n              }, z3 = t3._levels, O3 = zyt(r4, t3, g3), V2 = O3.fill, G2 = O3.line, Z = Math.round(o4 * (s3 === "fraction" ? n4 ? S2.w : S2.h : 1)), j3 = Z / (n4 ? S2.w : S2.h), N2 = Math.round(i3 * (a4 === "fraction" ? n4 ? S2.h : S2.w : 1)), H = N2 / (n4 ? S2.h : S2.w), te = k4 ? S2.w : r4._fullLayout.width, oe = p3 ? S2.h : r4._fullLayout.height, _e = Math.round(n4 ? _2 * te + d3 : b * oe + v3), Ee = { center: 0.5, right: 1 }[f4] || 0, Ce = { top: 1, middle: 0.5 }[h3] || 0, me = n4 ? _2 - Ee * j3 : b - Ce * j3, ie = n4 ? b - Ce * H : _2 - Ee * H, Se = Math.round(n4 ? oe * (1 - ie) : te * ie);\n              t3._lenFrac = H, t3._thickFrac = j3, t3._uFrac = me, t3._vFrac = ie;\n              var Le = t3._axis = Oyt(r4, t3, g3);\n              Le.position = j3 + (n4 ? _2 + d3 / S2.w : b + v3 / S2.h);\n              var Ae = ["top", "bottom"].indexOf(M4) !== -1;\n              if (n4 && Ae && (Le.title.side = M4, Le.titlex = _2 + d3 / S2.w, Le.titley = ie + (C3.side === "top" ? H - v3 / S2.h : v3 / S2.h)), !n4 && !Ae && (Le.title.side = M4, Le.titley = b + v3 / S2.h, Le.titlex = ie + d3 / S2.w), x2.color && t3.tickmode === "auto") {\n                Le.tickmode = "linear", Le.tick0 = z3.start;\n                var Fe = z3.size, Pe = B0.constrain(N2 / 50, 4, 15) + 1, ge = (g3[1] - g3[0]) / ((t3.nticks || Pe) * Fe);\n                if (ge > 1) {\n                  var Re = Math.pow(10, Math.floor(Math.log(ge) / Math.LN10));\n                  Fe *= Re * B0.roundUp(ge / Re, [2, 5, 10]), (Math.abs(z3.start) / z3.size + 1e-6) % 1 < 2e-6 && (Le.tick0 = 0);\n                }\n                Le.dtick = Fe;\n              }\n              Le.domain = n4 ? [ie + v3 / S2.h, ie + H - v3 / S2.h] : [ie + d3 / S2.w, ie + H - d3 / S2.w], Le.setScale(), e3.attr("transform", Vg(Math.round(S2.l), Math.round(S2.t)));\n              var ce = e3.select("." + gf.cbtitleunshift).attr("transform", Vg(-Math.round(S2.l), -Math.round(S2.t))), Ze = Le.ticklabelposition, ut = Le.title.font.size, pt = e3.select("." + gf.cbaxis), Zt, st = 0, lt = 0;\n              function Gt(cr, $e) {\n                var St = { propContainer: Le, propName: t3._propPrefix + "title.text", traceIndex: t3._traceIndex, _meta: t3._meta, placeholder: E3._dfltTitle.colorbar, containerGroup: e3.select("." + gf.cbtitle) }, Qt = cr.charAt(0) === "h" ? cr.slice(1) : "h" + cr;\n                e3.selectAll("." + Qt + ",." + Qt + "-math-group").remove(), Myt.draw(r4, cr, Rme(St, $e || {}));\n              }\n              function Nt() {\n                if (n4 && Ae || !n4 && !Ae) {\n                  var cr, $e;\n                  M4 === "top" && (cr = d3 + S2.l + te * _2, $e = v3 + S2.t + oe * (1 - ie - H) + 3 + ut * 0.75), M4 === "bottom" && (cr = d3 + S2.l + te * _2, $e = v3 + S2.t + oe * (1 - ie) - 3 - ut * 0.25), M4 === "right" && ($e = v3 + S2.t + oe * b + 3 + ut * 0.75, cr = d3 + S2.l + te * ie), Gt(Le._id + "title", { attributes: { x: cr, y: $e, "text-anchor": n4 ? "start" : "middle" } });\n                }\n              }\n              function Jt() {\n                if (n4 && !Ae || !n4 && Ae) {\n                  var cr = Le.position || 0, $e = Le._offset + Le._length / 2, St, Qt;\n                  if (M4 === "right") Qt = $e, St = S2.l + te * cr + 10 + ut * (Le.showticklabels ? 1 : 0.5);\n                  else if (St = $e, M4 === "bottom" && (Qt = S2.t + oe * cr + 10 + (Ze.indexOf("inside") === -1 ? Le.tickfont.size : 0) + (Le.ticks !== "inside" && t3.ticklen || 0)), M4 === "top") {\n                    var Vt = C3.text.split("<br>").length;\n                    Qt = S2.t + oe * cr + 10 - Z - Lme * ut * Vt;\n                  }\n                  Gt((n4 ? "h" : "v") + Le._id + "title", { avoid: { selection: w_.select(r4).selectAll("g." + Le._id + "tick"), side: M4, offsetTop: n4 ? 0 : S2.t, offsetLeft: n4 ? S2.l : 0, maxShift: n4 ? E3.width : E3.height }, attributes: { x: St, y: Qt, "text-anchor": "middle" }, transform: { rotate: n4 ? -90 : 0, offset: 0 } });\n                }\n              }\n              function sr() {\n                if (!n4 && !Ae || n4 && Ae) {\n                  var cr = e3.select("." + gf.cbtitle), $e = cr.select("text"), St = [-l3 / 2, l3 / 2], Qt = cr.select(".h" + Le._id + "title-math-group").node(), Vt = 15.6;\n                  $e.node() && (Vt = parseInt($e.node().style.fontSize, 10) * Lme);\n                  var _t;\n                  if (Qt ? (_t = Ug.bBox(Qt), lt = _t.width, st = _t.height, st > Vt && (St[1] -= (st - Vt) / 2)) : $e.node() && !$e.classed(gf.jsPlaceholder) && (_t = Ug.bBox($e.node()), lt = _t.width, st = _t.height), n4) {\n                    if (st) {\n                      if (st += 5, M4 === "top") Le.domain[1] -= st / S2.h, St[1] *= -1;\n                      else {\n                        Le.domain[0] += st / S2.h;\n                        var It = Eyt.lineCount($e);\n                        St[1] += (1 - It) * Vt;\n                      }\n                      cr.attr("transform", Vg(St[0], St[1])), Le.setScale();\n                    }\n                  } else lt && (M4 === "right" && (Le.domain[0] += (lt + ut / 2) / S2.w), cr.attr("transform", Vg(St[0], St[1])), Le.setScale());\n                }\n                e3.selectAll("." + gf.cbfills + ",." + gf.cblines).attr("transform", n4 ? Vg(0, Math.round(S2.h * (1 - Le.domain[1]))) : Vg(Math.round(S2.w * Le.domain[0]), 0)), pt.attr("transform", n4 ? Vg(0, Math.round(-S2.t)) : Vg(Math.round(-S2.l), 0));\n                var mt = e3.select("." + gf.cbfills).selectAll("rect." + gf.cbfill).attr("style", "").data(V2);\n                mt.enter().append("rect").classed(gf.cbfill, true).attr("style", ""), mt.exit().remove();\n                var er = g3.map(Le.c2p).map(Math.round).sort(function(Br, Vr) {\n                  return Br - Vr;\n                });\n                mt.each(function(Br, Vr) {\n                  var dt = [Vr === 0 ? g3[0] : (V2[Vr] + V2[Vr - 1]) / 2, Vr === V2.length - 1 ? g3[1] : (V2[Vr] + V2[Vr + 1]) / 2].map(Le.c2p).map(Math.round);\n                  n4 && (dt[1] = B0.constrain(dt[1] + (dt[1] > dt[0]) ? 1 : -1, er[0], er[1]));\n                  var Ge = w_.select(this).attr(n4 ? "x" : "y", _e).attr(n4 ? "y" : "x", w_.min(dt)).attr(n4 ? "width" : "height", Math.max(Z, 2)).attr(n4 ? "height" : "width", Math.max(w_.max(dt) - w_.min(dt), 2));\n                  if (t3._fillgradient) Ug.gradient(Ge, r4, t3._id, n4 ? "vertical" : "horizontalreversed", t3._fillgradient, "fill");\n                  else {\n                    var Je = T3(Br).replace("e-", "");\n                    Ge.attr("fill", gV(Je).toHexString());\n                  }\n                });\n                var lr = e3.select("." + gf.cblines).selectAll("path." + gf.cbline).data(x2.color && x2.width ? G2 : []);\n                lr.enter().append("path").classed(gf.cbline, true), lr.exit().remove(), lr.each(function(Br) {\n                  var Vr = _e, dt = Math.round(Le.c2p(Br)) + x2.width / 2 % 1;\n                  w_.select(this).attr("d", "M" + (n4 ? Vr + "," + dt : dt + "," + Vr) + (n4 ? "h" : "v") + Z).call(Ug.lineGroupStyle, x2.width, P3(Br), x2.dash);\n                }), pt.selectAll("g." + Le._id + "tick,path").remove();\n                var Tr = _e + Z + (l3 || 0) / 2 - (t3.ticks === "outside" ? 1 : 0), Lr = Dy.calcTicks(Le), ti = Dy.getTickSigns(Le)[2];\n                return Dy.drawTicks(r4, Le, { vals: Le.ticks === "inside" ? Dy.clipEnds(Le, Lr) : Lr, layer: pt, path: Dy.makeTickPath(Le, Tr, ti), transFn: Dy.makeTransTickFn(Le) }), Dy.drawLabels(r4, Le, { vals: Lr, layer: pt, transFn: Dy.makeTransTickLabelFn(Le), labelFns: Dy.makeLabelFns(Le, Tr) });\n              }\n              function wr() {\n                var cr, $e = Z + l3 / 2;\n                Ze.indexOf("inside") === -1 && (cr = Ug.bBox(pt.node()), $e += n4 ? cr.width : cr.height), Zt = ce.select("text");\n                var St = 0, Qt = n4 && M4 === "top", Vt = !n4 && M4 === "right", _t = 0;\n                if (Zt.node() && !Zt.classed(gf.jsPlaceholder)) {\n                  var It, mt = ce.select(".h" + Le._id + "title-math-group").node();\n                  mt && (n4 && Ae || !n4 && !Ae) ? (cr = Ug.bBox(mt), St = cr.width, It = cr.height) : (cr = Ug.bBox(ce.node()), St = cr.right - S2.l - (n4 ? _e : Se), It = cr.bottom - S2.t - (n4 ? Se : _e), !n4 && M4 === "top" && ($e += cr.height, _t = cr.height)), Vt && (Zt.attr("transform", Vg(St / 2 + ut / 2, 0)), St *= 2), $e = Math.max($e, n4 ? St : It);\n                }\n                var er = (n4 ? d3 : v3) * 2 + $e + u4 + l3 / 2, lr = 0;\n                !n4 && C3.text && h3 === "bottom" && b <= 0 && (lr = er / 2, er += lr, _t += lr), E3._hColorbarMoveTitle = lr, E3._hColorbarMoveCBTitle = _t;\n                var Tr = u4 + l3, Lr = (n4 ? _e : Se) - Tr / 2 - (n4 ? d3 : 0), ti = (n4 ? Se : _e) - (n4 ? N2 : v3 + _t - lr);\n                e3.select("." + gf.cbbg).attr("x", Lr).attr("y", ti).attr(n4 ? "width" : "height", Math.max(er - lr, 2)).attr(n4 ? "height" : "width", Math.max(N2 + Tr, 2)).call(yV.fill, c5).call(yV.stroke, t3.bordercolor).style("stroke-width", u4);\n                var Br = Vt ? Math.max(St - 10, 0) : 0;\n                e3.selectAll("." + gf.cboutline).attr("x", (n4 ? _e : Se + d3) + Br).attr("y", (n4 ? Se + v3 - N2 : _e) + (Qt ? st : 0)).attr(n4 ? "width" : "height", Math.max(Z, 2)).attr(n4 ? "height" : "width", Math.max(N2 - (n4 ? 2 * v3 + st : 2 * d3 + Br), 2)).call(yV.stroke, t3.outlinecolor).style({ fill: "none", "stroke-width": l3 });\n                var Vr = n4 ? Ee * er : 0, dt = n4 ? 0 : (1 - Ce) * er - _t;\n                if (Vr = k4 ? S2.l - Vr : -Vr, dt = p3 ? S2.t - dt : -dt, e3.attr("transform", Vg(Vr, dt)), !n4 && (u4 || gV(c5).getAlpha() && !gV.equals(E3.paper_bgcolor, c5))) {\n                  var Ge = pt.selectAll("text"), Je = Ge[0].length, je = e3.select("." + gf.cbbg).node(), tt = Ug.bBox(je), xt = Ug.getTranslate(e3), Ie = 2;\n                  Ge.each(function(di, ji) {\n                    var In = 0, wi = Je - 1;\n                    if (ji === In || ji === wi) {\n                      var On = Ug.bBox(this), qn = Ug.getTranslate(this), Fn;\n                      if (ji === wi) {\n                        var ra = On.right + qn.x, la = tt.right + xt.x + Se - u4 - Ie + _2;\n                        Fn = la - ra, Fn > 0 && (Fn = 0);\n                      } else if (ji === In) {\n                        var Ut = On.left + qn.x, wt = tt.left + xt.x + Se + u4 + Ie;\n                        Fn = wt - Ut, Fn < 0 && (Fn = 0);\n                      }\n                      Fn && (Je < 3 ? this.setAttribute("transform", "translate(" + Fn + ",0) " + this.getAttribute("transform")) : this.setAttribute("visibility", "hidden"));\n                    }\n                  });\n                }\n                var xe = {}, ke = Pme[f4], vt = Ime[f4], ir = Pme[h3], ar = Ime[h3], vr = er - Z;\n                n4 ? (a4 === "pixels" ? (xe.y = b, xe.t = N2 * ir, xe.b = N2 * ar) : (xe.t = xe.b = 0, xe.yt = b + i3 * ir, xe.yb = b - i3 * ar), s3 === "pixels" ? (xe.x = _2, xe.l = er * ke, xe.r = er * vt) : (xe.l = vr * ke, xe.r = vr * vt, xe.xl = _2 - o4 * ke, xe.xr = _2 + o4 * vt)) : (a4 === "pixels" ? (xe.x = _2, xe.l = N2 * ke, xe.r = N2 * vt) : (xe.l = xe.r = 0, xe.xl = _2 + i3 * ke, xe.xr = _2 - i3 * vt), s3 === "pixels" ? (xe.y = 1 - b, xe.t = er * ir, xe.b = er * ar) : (xe.t = vr * ir, xe.b = vr * ar, xe.yt = b - o4 * ir, xe.yb = b + o4 * ar));\n                var ii = t3.y < 0.5 ? "b" : "t", pi = t3.x < 0.5 ? "l" : "r";\n                r4._fullLayout._reservedMargin[t3._id] = {};\n                var $r = { r: E3.width - Lr - Vr, l: Lr + xe.r, b: E3.height - ti - dt, t: ti + xe.b };\n                k4 && p3 ? qI.autoMargin(r4, t3._id, xe) : k4 ? r4._fullLayout._reservedMargin[t3._id][ii] = $r[ii] : p3 || n4 ? r4._fullLayout._reservedMargin[t3._id][pi] = $r[pi] : r4._fullLayout._reservedMargin[t3._id][ii] = $r[ii];\n              }\n              return B0.syncOrAsync([qI.previousPromises, Nt, sr, Jt, qI.previousPromises, wr], r4);\n            }\n            function Fyt(e3, t3, r4) {\n              var n4 = t3.orientation === "v", i3 = r4._fullLayout, a4 = i3._size, o4, s3, l3;\n              OI.init({ element: e3.node(), gd: r4, prepFn: function() {\n                o4 = e3.attr("transform"), mV(e3);\n              }, moveFn: function(u4, c5) {\n                e3.attr("transform", o4 + Vg(u4, c5)), s3 = OI.align((n4 ? t3._uFrac : t3._vFrac) + u4 / a4.w, n4 ? t3._thickFrac : t3._lenFrac, 0, 1, t3.xanchor), l3 = OI.align((n4 ? t3._vFrac : 1 - t3._uFrac) - c5 / a4.h, n4 ? t3._lenFrac : t3._thickFrac, 0, 1, t3.yanchor);\n                var f4 = OI.getCursor(s3, l3, t3.xanchor, t3.yanchor);\n                mV(e3, f4);\n              }, doneFn: function() {\n                if (mV(e3), s3 !== void 0 && l3 !== void 0) {\n                  var u4 = {};\n                  u4[t3._propPrefix + "x"] = s3, u4[t3._propPrefix + "y"] = l3, t3._traceIndex !== void 0 ? Cme.call("_guiRestyle", r4, u4, t3._traceIndex) : Cme.call("_guiRelayout", r4, u4);\n                }\n              } });\n            }\n            function zyt(e3, t3, r4) {\n              var n4 = t3._levels, i3 = [], a4 = [], o4, s3, l3 = n4.end + n4.size / 100, u4 = n4.size, c5 = 1.001 * r4[0] - 1e-3 * r4[1], f4 = 1.001 * r4[1] - 1e-3 * r4[0];\n              for (s3 = 0; s3 < 1e5 && (o4 = n4.start + s3 * u4, !(u4 > 0 ? o4 >= l3 : o4 <= l3)); s3++) o4 > c5 && o4 < f4 && i3.push(o4);\n              if (t3._fillgradient) a4 = [0];\n              else if (typeof t3._fillcolor == "function") {\n                var h3 = t3._filllevels;\n                if (h3) for (l3 = h3.end + h3.size / 100, u4 = h3.size, s3 = 0; s3 < 1e5 && (o4 = h3.start + s3 * u4, !(u4 > 0 ? o4 >= l3 : o4 <= l3)); s3++) o4 > r4[0] && o4 < r4[1] && a4.push(o4);\n                else a4 = i3.map(function(d3) {\n                  return d3 - n4.size / 2;\n                }), a4.push(a4[a4.length - 1] + n4.size);\n              } else t3._fillcolor && typeof t3._fillcolor == "string" && (a4 = [0]);\n              return n4.size < 0 && (i3.reverse(), a4.reverse()), { line: i3, fill: a4 };\n            }\n            function Oyt(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = t3.orientation === "v", a4 = { type: "linear", range: r4, tickmode: t3.tickmode, nticks: t3.nticks, tick0: t3.tick0, dtick: t3.dtick, tickvals: t3.tickvals, ticktext: t3.ticktext, ticks: t3.ticks, ticklen: t3.ticklen, tickwidth: t3.tickwidth, tickcolor: t3.tickcolor, showticklabels: t3.showticklabels, labelalias: t3.labelalias, ticklabelposition: t3.ticklabelposition, ticklabeloverflow: t3.ticklabeloverflow, ticklabelstep: t3.ticklabelstep, tickfont: t3.tickfont, tickangle: t3.tickangle, tickformat: t3.tickformat, exponentformat: t3.exponentformat, minexponent: t3.minexponent, separatethousands: t3.separatethousands, showexponent: t3.showexponent, showtickprefix: t3.showtickprefix, tickprefix: t3.tickprefix, showticksuffix: t3.showticksuffix, ticksuffix: t3.ticksuffix, title: t3.title, showline: true, anchor: "free", side: i3 ? "right" : "bottom", position: 1 }, o4 = i3 ? "y" : "x", s3 = { type: "linear", _id: o4 + t3._id }, l3 = { letter: o4, font: n4.font, noAutotickangles: o4 === "y", noHover: true, noTickson: true, noTicklabelmode: true, noInsideRange: true, calendar: n4.calendar };\n              function u4(c5, f4) {\n                return B0.coerce(a4, s3, Pyt, c5, f4);\n              }\n              return Cyt(a4, s3, u4, l3, n4), Lyt(a4, s3, u4, l3), s3;\n            }\n            Dme.exports = { draw: Iyt };\n          });\n          var Ome = ye((Ilr, zme) => {\n            "use strict";\n            zme.exports = { moduleType: "component", name: "colorbar", attributes: tL(), supplyDefaults: Pq(), draw: Fme().draw, hasColorbar: Aq() };\n          });\n          var Bme = ye((Rlr, qme) => {\n            "use strict";\n            qme.exports = { moduleType: "component", name: "legend", layoutAttributes: SB(), supplyLayoutDefaults: EB(), draw: BB(), style: FB() };\n          });\n          var Ume = ye((Dlr, Nme) => {\n            "use strict";\n            Nme.exports = { moduleType: "locale", name: "en", dictionary: { "Click to enter Colorscale title": "Click to enter Colourscale title" }, format: { days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], periods: ["AM", "PM"], dateTime: "%a %b %e %X %Y", date: "%d/%m/%Y", time: "%H:%M:%S", decimal: ".", thousands: ",", grouping: [3], currency: ["$", ""], year: "%Y", month: "%b %Y", dayMonth: "%b %-d", dayMonthYear: "%b %-d, %Y" } };\n          });\n          var Gme = ye((Flr, Vme) => {\n            "use strict";\n            Vme.exports = { moduleType: "locale", name: "en-US", dictionary: { "Click to enter Colorscale title": "Click to enter Colorscale title" }, format: { date: "%m/%d/%Y" } };\n          });\n          var bV = ye((zlr, Xme) => {\n            "use strict";\n            var qyt = qa(), Wme = Dr(), xV = Wme.extendFlat, Hme = Wme.extendDeep;\n            function jme(e3) {\n              var t3;\n              switch (e3) {\n                case "themes__thumb":\n                  t3 = { autosize: true, width: 150, height: 150, title: { text: "" }, showlegend: false, margin: { l: 5, r: 5, t: 5, b: 5, pad: 0 }, annotations: [] };\n                  break;\n                case "thumbnail":\n                  t3 = { title: { text: "" }, hidesources: true, showlegend: false, borderwidth: 0, bordercolor: "", margin: { l: 1, r: 1, t: 1, b: 1, pad: 0 }, annotations: [] };\n                  break;\n                default:\n                  t3 = {};\n              }\n              return t3;\n            }\n            function Byt(e3) {\n              var t3 = ["xaxis", "yaxis", "zaxis"];\n              return t3.indexOf(e3.slice(0, 5)) > -1;\n            }\n            Xme.exports = function(t3, r4) {\n              var n4, i3 = t3.data, a4 = t3.layout, o4 = Hme([], i3), s3 = Hme({}, a4, jme(r4.tileClass)), l3 = t3._context || {};\n              if (r4.width && (s3.width = r4.width), r4.height && (s3.height = r4.height), r4.tileClass === "thumbnail" || r4.tileClass === "themes__thumb") {\n                s3.annotations = [];\n                var u4 = Object.keys(s3);\n                for (n4 = 0; n4 < u4.length; n4++) Byt(u4[n4]) && (s3[u4[n4]].title = { text: "" });\n                for (n4 = 0; n4 < o4.length; n4++) {\n                  var c5 = o4[n4];\n                  c5.showscale = false, c5.marker && (c5.marker.showscale = false), qyt.traceIs(c5, "pie-like") && (c5.textposition = "none");\n                }\n              }\n              if (Array.isArray(r4.annotations)) for (n4 = 0; n4 < r4.annotations.length; n4++) s3.annotations.push(r4.annotations[n4]);\n              var f4 = Object.keys(s3).filter(function(b) {\n                return b.match(/^scene\\d*$/);\n              });\n              if (f4.length) {\n                var h3 = {};\n                for (r4.tileClass === "thumbnail" && (h3 = { title: { text: "" }, showaxeslabels: false, showticklabels: false, linetickenable: false }), n4 = 0; n4 < f4.length; n4++) {\n                  var d3 = s3[f4[n4]];\n                  d3.xaxis || (d3.xaxis = {}), d3.yaxis || (d3.yaxis = {}), d3.zaxis || (d3.zaxis = {}), xV(d3.xaxis, h3), xV(d3.yaxis, h3), xV(d3.zaxis, h3), d3._scene = null;\n                }\n              }\n              var v3 = document.createElement("div");\n              r4.tileClass && (v3.className = r4.tileClass);\n              var _2 = { gd: v3, td: v3, layout: s3, data: o4, config: { staticPlot: r4.staticPlot === void 0 ? true : r4.staticPlot, plotGlPixelRatio: r4.plotGlPixelRatio === void 0 ? 2 : r4.plotGlPixelRatio, displaylogo: r4.displaylogo || false, showLink: r4.showLink || false, showTips: r4.showTips || false, mapboxAccessToken: l3.mapboxAccessToken } };\n              return r4.setBackground !== "transparent" && (_2.config.setBackground = r4.setBackground || "opaque"), _2.gd.defaultLayout = jme(r4.tileClass), _2;\n            };\n          });\n          var Kme = ye((Olr, Yme) => {\n            "use strict";\n            var Nyt = pb().EventEmitter, Uyt = qa(), Vyt = Dr(), Zme = Py(), Gyt = bV(), Hyt = jP(), jyt = WP();\n            function Wyt(e3, t3) {\n              var r4 = new Nyt(), n4 = Gyt(e3, { format: "png" }), i3 = n4.gd;\n              i3.style.position = "absolute", i3.style.left = "-5000px", document.body.appendChild(i3);\n              function a4() {\n                var s3 = Zme.getDelay(i3._fullLayout);\n                setTimeout(function() {\n                  var l3 = Hyt(i3), u4 = document.createElement("canvas");\n                  u4.id = Vyt.randstr(), r4 = jyt({ format: t3.format, width: i3._fullLayout.width, height: i3._fullLayout.height, canvas: u4, emitter: r4, svg: l3 }), r4.clean = function() {\n                    i3 && document.body.removeChild(i3);\n                  };\n                }, s3);\n              }\n              var o4 = Zme.getRedrawFunc(i3);\n              return Uyt.call("_doPlot", i3, n4.data, n4.layout, n4.config).then(o4).then(a4).catch(function(s3) {\n                r4.emit("error", s3);\n              }), r4;\n            }\n            Yme.exports = Wyt;\n          });\n          var Qme = ye((qlr, $me) => {\n            "use strict";\n            var Jme = Py(), Xyt = { getDelay: Jme.getDelay, getRedrawFunc: Jme.getRedrawFunc, clone: bV(), toSVG: jP(), svgToImg: WP(), toImage: Kme(), downloadImage: rU() };\n            $me.exports = Xyt;\n          });\n          var tye = ye((Fy) => {\n            "use strict";\n            Fy.version = l6().version;\n            vee();\n            rne();\n            var Zyt = qa(), p4 = Fy.register = Zyt.register, TV = Tde(), eye = Object.keys(TV);\n            for (BI = 0; BI < eye.length; BI++) TT = eye[BI], TT.charAt(0) !== "_" && (Fy[TT] = TV[TT]), p4({ moduleType: "apiMethod", name: TT, fn: TV[TT] });\n            var TT, BI;\n            p4(mpe());\n            p4([Vpe(), t0e(), Of(), _0e(), I0e(), ege(), xge(), Bge(), ime(), fV(), Mme(), tc(), Ome(), Bme(), vf(), cN()]);\n            p4([Ume(), Gme()]);\n            window.PlotlyLocales && Array.isArray(window.PlotlyLocales) && (p4(window.PlotlyLocales), delete window.PlotlyLocales);\n            Fy.Icons = XL();\n            var NI = vf(), wV = Mc();\n            Fy.Plots = { resize: wV.resize, graphJson: wV.graphJson, sendDataToCloud: wV.sendDataToCloud };\n            Fy.Fx = { hover: NI.hover, unhover: NI.unhover, loneHover: NI.loneHover, loneUnhover: NI.loneUnhover };\n            Fy.Snapshot = Qme();\n            Fy.PlotSchema = w3();\n          });\n          var iye = ye((Nlr, rye) => {\n            "use strict";\n            rye.exports = tye();\n          });\n          var e22 = ye((Ulr, nye) => {\n            "use strict";\n            nye.exports = { TEXTPAD: 3, eventDataKeys: ["value", "label"] };\n          });\n          var Lm = ye((Vlr, uye) => {\n            "use strict";\n            var qf = pf(), aye = df().axisHoverFormat, { hovertemplateAttrs: Yyt, texttemplateAttrs: Kyt, templatefallbackAttrs: oye } = Ll(), lye = Tu(), Jyt = ec(), sye = e22(), $yt = Pd().pattern, t22 = Ao().extendFlat, AV = Jyt({ editType: "calc", arrayOk: true, colorEditType: "style" }), Qyt = qf.marker, e1t = Qyt.line, t1t = t22({}, e1t.width, { dflt: 0 }), r1t = t22({ width: t1t, editType: "calc" }, lye("marker.line")), i1t = t22({ line: r1t, editType: "calc" }, lye("marker"), { opacity: { valType: "number", arrayOk: true, dflt: 1, min: 0, max: 1, editType: "style" }, pattern: $yt, cornerradius: { valType: "any", editType: "calc" } });\n            uye.exports = { x: qf.x, x0: qf.x0, dx: qf.dx, y: qf.y, y0: qf.y0, dy: qf.dy, xperiod: qf.xperiod, yperiod: qf.yperiod, xperiod0: qf.xperiod0, yperiod0: qf.yperiod0, xperiodalignment: qf.xperiodalignment, yperiodalignment: qf.yperiodalignment, xhoverformat: aye("x"), yhoverformat: aye("y"), text: qf.text, texttemplate: Kyt({ editType: "plot" }, { keys: sye.eventDataKeys }), texttemplatefallback: oye({ editType: "plot" }), hovertext: qf.hovertext, hovertemplate: Yyt({}, { keys: sye.eventDataKeys }), hovertemplatefallback: oye(), textposition: { valType: "enumerated", values: ["inside", "outside", "auto", "none"], dflt: "auto", arrayOk: true, editType: "calc" }, insidetextanchor: { valType: "enumerated", values: ["end", "middle", "start"], dflt: "end", editType: "plot" }, textangle: { valType: "angle", dflt: "auto", editType: "plot" }, textfont: t22({}, AV, {}), insidetextfont: t22({}, AV, {}), outsidetextfont: t22({}, AV, {}), constraintext: { valType: "enumerated", values: ["inside", "outside", "both", "none"], dflt: "both", editType: "calc" }, cliponaxis: t22({}, qf.cliponaxis, {}), orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc+clearAxisTypes" }, base: { valType: "any", dflt: null, arrayOk: true, editType: "calc" }, offset: { valType: "number", dflt: null, arrayOk: true, editType: "calc" }, width: { valType: "number", dflt: null, min: 0, arrayOk: true, editType: "calc" }, marker: i1t, offsetgroup: qf.offsetgroup, alignmentgroup: qf.alignmentgroup, selected: { marker: { opacity: qf.selected.marker.opacity, color: qf.selected.marker.color, editType: "style" }, textfont: qf.selected.textfont, editType: "style" }, unselected: { marker: { opacity: qf.unselected.marker.opacity, color: qf.unselected.marker.color, editType: "style" }, textfont: qf.unselected.textfont, editType: "style" }, zorder: qf.zorder };\n          });\n          var UI = ye((Glr, cye) => {\n            "use strict";\n            cye.exports = { barmode: { valType: "enumerated", values: ["stack", "group", "overlay", "relative"], dflt: "group", editType: "calc" }, barnorm: { valType: "enumerated", values: ["", "fraction", "percent"], dflt: "", editType: "calc" }, bargap: { valType: "number", min: 0, max: 1, editType: "calc" }, bargroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" }, barcornerradius: { valType: "any", editType: "calc" } };\n          });\n          var VI = ye((Hlr, dye) => {\n            "use strict";\n            var n1t = ka(), fye = pv().hasColorscale, hye = Qh(), a1t = Dr().coercePattern;\n            dye.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = n4("marker.color", i3), s3 = fye(t3, "marker");\n              s3 && hye(t3, r4, a4, n4, { prefix: "marker.", cLetter: "c" }), n4("marker.line.color", n1t.defaultLine), fye(t3, "marker.line") && hye(t3, r4, a4, n4, { prefix: "marker.line.", cLetter: "c" }), n4("marker.line.width"), n4("marker.opacity"), a1t(n4, "marker.pattern", o4, s3), n4("selected.marker.color"), n4("unselected.marker.color");\n            };\n          });\n          var r0 = ye((jlr, _ye) => {\n            "use strict";\n            var vye = Eo(), AT = Dr(), pye = ka(), o1t = qa(), s1t = eT(), l1t = Ig(), u1t = VI(), c1t = Hb(), gye = Lm(), GI = AT.coerceFont;\n            function f1t(e3, t3, r4, n4) {\n              function i3(u4, c5) {\n                return AT.coerce(e3, t3, gye, u4, c5);\n              }\n              var a4 = s1t(e3, t3, n4, i3);\n              if (!a4) {\n                t3.visible = false;\n                return;\n              }\n              l1t(e3, t3, n4, i3), i3("xhoverformat"), i3("yhoverformat"), i3("zorder"), i3("orientation", t3.x && !t3.y ? "h" : "v"), i3("base"), i3("offset"), i3("width"), i3("text"), i3("hovertext"), i3("hovertemplate"), i3("hovertemplatefallback");\n              var o4 = i3("textposition");\n              yye(e3, t3, n4, i3, o4, { moduleHasSelected: true, moduleHasUnselected: true, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), u1t(e3, t3, i3, r4, n4);\n              var s3 = (t3.marker.line || {}).color, l3 = o1t.getComponentMethod("errorbars", "supplyDefaults");\n              l3(e3, t3, s3 || pye.defaultLine, { axis: "y" }), l3(e3, t3, s3 || pye.defaultLine, { axis: "x", inherit: "y" }), AT.coerceSelectionMarkerOpacity(t3, i3);\n            }\n            function h1t(e3, t3) {\n              var r4, n4;\n              function i3(s3, l3) {\n                return AT.coerce(n4._input, n4, gye, s3, l3);\n              }\n              for (var a4 = 0; a4 < e3.length; a4++) if (n4 = e3[a4], n4.type === "bar") {\n                r4 = n4._input;\n                var o4 = i3("marker.cornerradius", t3.barcornerradius);\n                n4.marker && (n4.marker.cornerradius = mye(o4)), c1t(r4, n4, t3, i3, t3.barmode);\n              }\n            }\n            function mye(e3) {\n              if (vye(e3)) {\n                if (e3 = +e3, e3 >= 0) return e3;\n              } else if (typeof e3 == "string" && (e3 = e3.trim(), e3.slice(-1) === "%" && vye(e3.slice(0, -1)) && (e3 = +e3.slice(0, -1), e3 >= 0))) return e3 + "%";\n            }\n            function yye(e3, t3, r4, n4, i3, a4) {\n              a4 = a4 || {};\n              var o4 = a4.moduleHasSelected !== false, s3 = a4.moduleHasUnselected !== false, l3 = a4.moduleHasConstrain !== false, u4 = a4.moduleHasCliponaxis !== false, c5 = a4.moduleHasTextangle !== false, f4 = a4.moduleHasInsideanchor !== false, h3 = !!a4.hasPathbar, d3 = Array.isArray(i3) || i3 === "auto", v3 = d3 || i3 === "inside", _2 = d3 || i3 === "outside";\n              if (v3 || _2) {\n                var b = GI(n4, "textfont", r4.font), p3 = AT.extendFlat({}, b), k4 = e3.textfont && e3.textfont.color, E3 = !k4;\n                if (E3 && delete p3.color, GI(n4, "insidetextfont", p3), h3) {\n                  var S2 = AT.extendFlat({}, b);\n                  E3 && delete S2.color, GI(n4, "pathbar.textfont", S2);\n                }\n                _2 && GI(n4, "outsidetextfont", b), o4 && n4("selected.textfont.color"), s3 && n4("unselected.textfont.color"), l3 && n4("constraintext"), u4 && n4("cliponaxis"), c5 && n4("textangle"), n4("texttemplate"), n4("texttemplatefallback");\n              }\n              v3 && f4 && n4("insidetextanchor");\n            }\n            _ye.exports = { supplyDefaults: f1t, crossTraceDefaults: h1t, handleText: yye, validateCornerradius: mye };\n          });\n          var SV = ye((Wlr, xye) => {\n            "use strict";\n            var d1t = qa(), v1t = ho(), p1t = Dr(), g1t = UI(), m1t = r0().validateCornerradius;\n            xye.exports = function(e3, t3, r4) {\n              function n4(_2, b) {\n                return p1t.coerce(e3, t3, g1t, _2, b);\n              }\n              for (var i3 = false, a4 = false, o4 = false, s3 = {}, l3 = n4("barmode"), u4 = l3 === "group", c5 = 0; c5 < r4.length; c5++) {\n                var f4 = r4[c5];\n                if (d1t.traceIs(f4, "bar") && f4.visible) i3 = true;\n                else continue;\n                var h3 = f4.xaxis + f4.yaxis;\n                if (u4 ? (s3[h3] && (o4 = true), s3[h3] = true) : (h3 += f4._input.offsetgroup, s3.length > 0 && !s3[h3] && (o4 = true), s3[h3] = true), f4.visible && f4.type === "histogram") {\n                  var d3 = v1t.getFromId({ _fullLayout: t3 }, f4[f4.orientation === "v" ? "xaxis" : "yaxis"]);\n                  d3.type !== "category" && (a4 = true);\n                }\n              }\n              if (!i3) {\n                delete t3.barmode;\n                return;\n              }\n              l3 !== "overlay" && n4("barnorm"), n4("bargap", a4 && !o4 ? 0 : 0.2), n4("bargroupgap");\n              var v3 = n4("barcornerradius");\n              t3.barcornerradius = m1t(v3);\n            };\n          });\n          var g4 = ye((Xlr, bye) => {\n            "use strict";\n            var ST = Dr();\n            bye.exports = function(t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4++) t3[n4].i = n4;\n              ST.mergeArray(r4.text, t3, "tx"), ST.mergeArray(r4.hovertext, t3, "htx");\n              var i3 = r4.marker;\n              if (i3) {\n                ST.mergeArray(i3.opacity, t3, "mo", true), ST.mergeArray(i3.color, t3, "mc");\n                var a4 = i3.line;\n                a4 && (ST.mergeArray(a4.color, t3, "mlc"), ST.mergeArrayCastPositive(a4.width, t3, "mlw"));\n              }\n            };\n          });\n          var Eye = ye((Zlr, Mye) => {\n            "use strict";\n            var wye = ho(), Tye = Dg(), Aye = pv().hasColorscale, Sye = gv(), y1t = g4(), _1t = z0();\n            Mye.exports = function(t3, r4) {\n              var n4 = wye.getFromId(t3, r4.xaxis || "x"), i3 = wye.getFromId(t3, r4.yaxis || "y"), a4, o4, s3, l3, u4, c5, f4 = { msUTC: !!(r4.base || r4.base === 0) };\n              r4.orientation === "h" ? (a4 = n4.makeCalcdata(r4, "x", f4), s3 = i3.makeCalcdata(r4, "y"), l3 = Tye(r4, i3, "y", s3), u4 = !!r4.yperiodalignment, c5 = "y") : (a4 = i3.makeCalcdata(r4, "y", f4), s3 = n4.makeCalcdata(r4, "x"), l3 = Tye(r4, n4, "x", s3), u4 = !!r4.xperiodalignment, c5 = "x"), o4 = l3.vals;\n              for (var h3 = Math.min(o4.length, a4.length), d3 = new Array(h3), v3 = 0; v3 < h3; v3++) d3[v3] = { p: o4[v3], s: a4[v3] }, u4 && (d3[v3].orig_p = s3[v3], d3[v3][c5 + "End"] = l3.ends[v3], d3[v3][c5 + "Start"] = l3.starts[v3]), r4.ids && (d3[v3].id = String(r4.ids[v3]));\n              return Aye(r4, "marker") && Sye(t3, r4, { vals: r4.marker.color, containerStr: "marker", cLetter: "c" }), Aye(r4, "marker.line") && Sye(t3, r4, { vals: r4.marker.line.color, containerStr: "marker.line", cLetter: "c" }), y1t(d3, r4), _1t(d3, r4), d3;\n            };\n          });\n          var bv = ye((Ylr, Cye) => {\n            "use strict";\n            var x1t = Oa(), b1t = Dr();\n            function w1t(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = n4["_" + r4 + "Text_minsize"];\n              if (i3) {\n                var a4 = n4.uniformtext.mode === "hide", o4;\n                switch (r4) {\n                  case "funnelarea":\n                  case "pie":\n                  case "sunburst":\n                    o4 = "g.slice";\n                    break;\n                  case "treemap":\n                  case "icicle":\n                    o4 = "g.slice, g.pathbar";\n                    break;\n                  default:\n                    o4 = "g.points > g.point";\n                }\n                t3.selectAll(o4).each(function(s3) {\n                  var l3 = s3.transform;\n                  if (l3) {\n                    l3.scale = a4 && l3.hide ? 0 : i3 / l3.fontSize;\n                    var u4 = x1t.select(this).select("text");\n                    b1t.setTransormAndDisplay(u4, l3);\n                  }\n                });\n              }\n            }\n            function T1t(e3, t3, r4) {\n              if (r4.uniformtext.mode) {\n                var n4 = kye(e3), i3 = r4.uniformtext.minsize, a4 = t3.scale * t3.fontSize;\n                t3.hide = a4 < i3, r4[n4] = r4[n4] || 1 / 0, t3.hide || (r4[n4] = Math.min(r4[n4], Math.max(a4, i3)));\n              }\n            }\n            function A1t(e3, t3) {\n              var r4 = kye(e3);\n              t3[r4] = void 0;\n            }\n            function kye(e3) {\n              return "_" + e3 + "Text_minsize";\n            }\n            Cye.exports = { recordMinTextSize: T1t, clearMinTextSize: A1t, resizeText: w1t };\n          });\n          var HI = ye((r22) => {\n            "use strict";\n            var S1t = Eo(), M1t = cd(), Lye = Dr().isArrayOrTypedArray;\n            r22.coerceString = function(e3, t3, r4) {\n              if (typeof t3 == "string") {\n                if (t3 || !e3.noBlank) return t3;\n              } else if ((typeof t3 == "number" || t3 === true) && !e3.strict) return String(t3);\n              return r4 !== void 0 ? r4 : e3.dflt;\n            };\n            r22.coerceNumber = function(e3, t3, r4) {\n              if (S1t(t3)) {\n                t3 = +t3;\n                var n4 = e3.min, i3 = e3.max, a4 = n4 !== void 0 && t3 < n4 || i3 !== void 0 && t3 > i3;\n                if (!a4) return t3;\n              }\n              return r4 !== void 0 ? r4 : e3.dflt;\n            };\n            r22.coerceColor = function(e3, t3, r4) {\n              return M1t(t3).isValid() ? t3 : r4 !== void 0 ? r4 : e3.dflt;\n            };\n            r22.coerceEnumerated = function(e3, t3, r4) {\n              return e3.coerceNumber && (t3 = +t3), e3.values.indexOf(t3) !== -1 ? t3 : r4 !== void 0 ? r4 : e3.dflt;\n            };\n            r22.getValue = function(e3, t3) {\n              var r4;\n              return Lye(e3) ? t3 < e3.length && (r4 = e3[t3]) : r4 = e3, r4;\n            };\n            r22.getLineWidth = function(e3, t3) {\n              var r4 = 0 < t3.mlw ? t3.mlw : Lye(e3.marker.line.width) ? 0 : e3.marker.line.width;\n              return r4;\n            };\n          });\n          var N0 = ye((Jlr, Uye) => {\n            "use strict";\n            var m4 = Oa(), E1t = ka(), y4 = So(), Pye = Dr(), Iye = qa(), Rye = bv().resizeText, MV = Lm(), k1t = MV.textfont, C1t = MV.insidetextfont, L1t = MV.outsidetextfont, Qd = HI();\n            function P1t(e3) {\n              var t3 = m4.select(e3).selectAll(\'g[class^="barlayer"]\').selectAll("g.trace");\n              Rye(e3, t3, "bar");\n              var r4 = t3.size(), n4 = e3._fullLayout;\n              t3.style("opacity", function(i3) {\n                return i3[0].trace.opacity;\n              }).each(function(i3) {\n                (n4.barmode === "stack" && r4 > 1 || n4.bargap === 0 && n4.bargroupgap === 0 && !i3[0].trace.marker.line.width) && m4.select(this).attr("shape-rendering", "crispEdges");\n              }), t3.selectAll("g.points").each(function(i3) {\n                var a4 = m4.select(this), o4 = i3[0].trace;\n                Dye(a4, o4, e3);\n              }), Iye.getComponentMethod("errorbars", "style")(t3);\n            }\n            function Dye(e3, t3, r4) {\n              y4.pointStyle(e3.selectAll("path"), t3, r4), Fye(e3, t3, r4);\n            }\n            function Fye(e3, t3, r4) {\n              e3.selectAll("text").each(function(n4) {\n                var i3 = m4.select(this), a4 = Pye.ensureUniformFontSize(r4, zye(i3, n4, t3, r4));\n                y4.font(i3, a4);\n              });\n            }\n            function I1t(e3, t3, r4) {\n              var n4 = t3[0].trace;\n              n4.selectedpoints ? R1t(r4, n4, e3) : (Dye(r4, n4, e3), Iye.getComponentMethod("errorbars", "style")(r4));\n            }\n            function R1t(e3, t3, r4) {\n              y4.selectedPointStyle(e3.selectAll("path"), t3), D1t(e3.selectAll("text"), t3, r4);\n            }\n            function D1t(e3, t3, r4) {\n              e3.each(function(n4) {\n                var i3 = m4.select(this), a4;\n                if (n4.selected) {\n                  a4 = Pye.ensureUniformFontSize(r4, zye(i3, n4, t3, r4));\n                  var o4 = t3.selected.textfont && t3.selected.textfont.color;\n                  o4 && (a4.color = o4), y4.font(i3, a4);\n                } else y4.selectedTextStyle(i3, t3);\n              });\n            }\n            function zye(e3, t3, r4, n4) {\n              var i3 = n4._fullLayout.font, a4 = r4.textfont;\n              if (e3.classed("bartext-inside")) {\n                var o4 = Nye(t3, r4);\n                a4 = qye(r4, t3.i, i3, o4);\n              } else e3.classed("bartext-outside") && (a4 = Bye(r4, t3.i, i3));\n              return a4;\n            }\n            function Oye(e3, t3, r4) {\n              return EV(k1t, e3.textfont, t3, r4);\n            }\n            function qye(e3, t3, r4, n4) {\n              var i3 = Oye(e3, t3, r4), a4 = e3._input.textfont === void 0 || e3._input.textfont.color === void 0 || Array.isArray(e3.textfont.color) && e3.textfont.color[t3] === void 0;\n              return a4 && (i3 = { color: E1t.contrast(n4), family: i3.family, size: i3.size, weight: i3.weight, style: i3.style, variant: i3.variant, textcase: i3.textcase, lineposition: i3.lineposition, shadow: i3.shadow }), EV(C1t, e3.insidetextfont, t3, i3);\n            }\n            function Bye(e3, t3, r4) {\n              var n4 = Oye(e3, t3, r4);\n              return EV(L1t, e3.outsidetextfont, t3, n4);\n            }\n            function EV(e3, t3, r4, n4) {\n              t3 = t3 || {};\n              var i3 = Qd.getValue(t3.family, r4), a4 = Qd.getValue(t3.size, r4), o4 = Qd.getValue(t3.color, r4), s3 = Qd.getValue(t3.weight, r4), l3 = Qd.getValue(t3.style, r4), u4 = Qd.getValue(t3.variant, r4), c5 = Qd.getValue(t3.textcase, r4), f4 = Qd.getValue(t3.lineposition, r4), h3 = Qd.getValue(t3.shadow, r4);\n              return { family: Qd.coerceString(e3.family, i3, n4.family), size: Qd.coerceNumber(e3.size, a4, n4.size), color: Qd.coerceColor(e3.color, o4, n4.color), weight: Qd.coerceString(e3.weight, s3, n4.weight), style: Qd.coerceString(e3.style, l3, n4.style), variant: Qd.coerceString(e3.variant, u4, n4.variant), textcase: Qd.coerceString(e3.variant, c5, n4.textcase), lineposition: Qd.coerceString(e3.variant, f4, n4.lineposition), shadow: Qd.coerceString(e3.variant, h3, n4.shadow) };\n            }\n            function Nye(e3, t3) {\n              return t3.type === "waterfall" ? t3[e3.dir].marker.color : e3.mcc || e3.mc || t3.marker.color;\n            }\n            Uye.exports = { style: P1t, styleTextPoints: Fye, styleOnSelect: I1t, getInsideTextFont: qye, getOutsideTextFont: Bye, getBarColor: Nye, resizeText: Rye };\n          });\n          var n2 = ye(($lr, Yye) => {\n            "use strict";\n            var jI = Oa(), WI = Eo(), Fd = Dr(), F1t = ru(), z1t = ka(), T_ = So(), O1t = qa(), XI = ho().tickText, Vye = bv(), q1t = Vye.recordMinTextSize, B1t = Vye.clearMinTextSize, kV = N0(), MT = HI(), N1t = e22(), Gye = Lm(), U1t = Gye.text, V1t = Gye.textposition, G1t = ip().appendArrayPointValue, Gv = N1t.TEXTPAD;\n            function H1t(e3) {\n              return e3.id;\n            }\n            function j1t(e3) {\n              if (e3.ids) return H1t;\n            }\n            function CV(e3) {\n              return (e3 > 0) - (e3 < 0);\n            }\n            function Pm(e3, t3) {\n              return e3 < t3 ? 1 : -1;\n            }\n            function W1t(e3, t3, r4, n4) {\n              var i3 = [], a4 = [], o4 = n4 ? t3 : r4, s3 = n4 ? r4 : t3;\n              return i3[0] = o4.c2p(e3.s0, true), a4[0] = s3.c2p(e3.p0, true), i3[1] = o4.c2p(e3.s1, true), a4[1] = s3.c2p(e3.p1, true), n4 ? [i3, a4] : [a4, i3];\n            }\n            function Hye(e3, t3, r4, n4) {\n              if (!t3.uniformtext.mode && jye(r4)) {\n                var i3;\n                return n4 && (i3 = n4()), e3.transition().duration(r4.duration).ease(r4.easing).each("end", function() {\n                  i3 && i3();\n                }).each("interrupt", function() {\n                  i3 && i3();\n                });\n              } else return e3;\n            }\n            function jye(e3) {\n              return e3 && e3.duration > 0;\n            }\n            function X1t(e3, t3, r4, n4, i3, a4) {\n              var o4 = t3.xaxis, s3 = t3.yaxis, l3 = e3._fullLayout, u4 = e3._context.staticPlot;\n              i3 || (i3 = { mode: l3.barmode, norm: l3.barmode, gap: l3.bargap, groupgap: l3.bargroupgap }, B1t("bar", l3));\n              var c5 = Fd.makeTraceGroups(n4, r4, "trace bars").each(function(f4) {\n                var h3 = jI.select(this), d3 = f4[0].trace, v3 = f4[0].t, _2 = d3.type === "waterfall", b = d3.type === "funnel", p3 = d3.type === "histogram", k4 = d3.type === "bar", E3 = k4 || b, S2 = 0;\n                _2 && d3.connector.visible && d3.connector.mode === "between" && (S2 = d3.connector.line.width / 2);\n                var L3 = d3.orientation === "h", x2 = jye(i3), C3 = Fd.ensureSingle(h3, "g", "points"), M4 = j1t(d3), g3 = C3.selectAll("g.point").data(Fd.identity, M4);\n                g3.enter().append("g").classed("point", true), g3.exit().remove(), g3.each(function(T3, z3) {\n                  var O3 = jI.select(this), V2 = W1t(T3, o4, s3, L3), G2 = V2[0][0], Z = V2[0][1], j3 = V2[1][0], N2 = V2[1][1], H = (L3 ? Z - G2 : N2 - j3) === 0;\n                  H && E3 && MT.getLineWidth(d3, T3) && (H = false), H || (H = !WI(G2) || !WI(Z) || !WI(j3) || !WI(N2)), T3.isBlank = H, H && (L3 ? Z = G2 : N2 = j3), S2 && !H && (L3 ? (G2 -= Pm(G2, Z) * S2, Z += Pm(G2, Z) * S2) : (j3 -= Pm(j3, N2) * S2, N2 += Pm(j3, N2) * S2));\n                  var te, oe;\n                  if (d3.type === "waterfall") {\n                    if (!H) {\n                      var _e = d3[T3.dir].marker;\n                      te = _e.line.width, oe = _e.color;\n                    }\n                  } else te = MT.getLineWidth(d3, T3), oe = T3.mc || d3.marker.color;\n                  function Ee($e) {\n                    var St = jI.round(te / 2 % 1, 2);\n                    return i3.gap === 0 && i3.groupgap === 0 ? jI.round(Math.round($e) - St, 2) : $e;\n                  }\n                  function Ce($e, St, Qt) {\n                    return Qt && $e === St ? $e : Math.abs($e - St) >= 2 ? Ee($e) : $e > St ? Math.ceil($e) : Math.floor($e);\n                  }\n                  var me = z1t.opacity(oe), ie = me < 1 || te > 0.01 ? Ee : Ce;\n                  e3._context.staticPlot || (G2 = ie(G2, Z, L3), Z = ie(Z, G2, L3), j3 = ie(j3, N2, !L3), N2 = ie(N2, j3, !L3));\n                  var Se = L3 ? o4.c2p : s3.c2p, Le;\n                  T3.s0 > 0 ? Le = T3._sMax : T3.s0 < 0 ? Le = T3._sMin : Le = T3.s1 > 0 ? T3._sMax : T3._sMin;\n                  function Ae($e, St) {\n                    if (!$e) return 0;\n                    var Qt = Math.abs(L3 ? N2 - j3 : Z - G2), Vt = Math.abs(L3 ? Z - G2 : N2 - j3), _t = ie(Math.abs(Se(Le, true) - Se(0, true))), It = T3.hasB ? Math.min(Qt / 2, Vt / 2) : Math.min(Qt / 2, _t), mt;\n                    if (St === "%") {\n                      var er = Math.min(50, $e);\n                      mt = Qt * (er / 100);\n                    } else mt = $e;\n                    return ie(Math.max(Math.min(mt, It), 0));\n                  }\n                  var Fe = k4 || p3 ? Ae(v3.cornerradiusvalue, v3.cornerradiusform) : 0, Pe, ge, Re = "M" + G2 + "," + j3 + "V" + N2 + "H" + Z + "V" + j3 + "Z", ce = 0;\n                  if (Fe && T3.s) {\n                    var Ze = CV(T3.s0) === 0 || CV(T3.s) === CV(T3.s0) ? T3.s1 : T3.s0;\n                    if (ce = ie(T3.hasB ? 0 : Math.abs(Se(Le, true) - Se(Ze, true))), ce < Fe) {\n                      var ut = Pm(G2, Z), pt = Pm(j3, N2), Zt = ut === -pt ? 1 : 0;\n                      if (L3) if (T3.hasB) Pe = "M" + (G2 + Fe * ut) + "," + j3 + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + G2 + "," + (j3 + Fe * pt) + "V" + (N2 - Fe * pt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (G2 + Fe * ut) + "," + N2 + "H" + (Z - Fe * ut) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + Z + "," + (N2 - Fe * pt) + "V" + (j3 + Fe * pt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (Z - Fe * ut) + "," + j3 + "Z";\n                      else {\n                        ge = Math.abs(Z - G2) + ce;\n                        var st = ge < Fe ? Fe - Math.sqrt(ge * (2 * Fe - ge)) : 0, lt = ce > 0 ? Math.sqrt(ce * (2 * Fe - ce)) : 0, Gt = ut > 0 ? Math.max : Math.min;\n                        Pe = "M" + G2 + "," + j3 + "V" + (N2 - st * pt) + "H" + Gt(Z - (Fe - ce) * ut, G2) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + Z + "," + (N2 - Fe * pt - lt) + "V" + (j3 + Fe * pt + lt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + Gt(Z - (Fe - ce) * ut, G2) + "," + (j3 + st * pt) + "Z";\n                      }\n                      else if (T3.hasB) Pe = "M" + (G2 + Fe * ut) + "," + j3 + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + G2 + "," + (j3 + Fe * pt) + "V" + (N2 - Fe * pt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (G2 + Fe * ut) + "," + N2 + "H" + (Z - Fe * ut) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + Z + "," + (N2 - Fe * pt) + "V" + (j3 + Fe * pt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (Z - Fe * ut) + "," + j3 + "Z";\n                      else {\n                        ge = Math.abs(N2 - j3) + ce;\n                        var Nt = ge < Fe ? Fe - Math.sqrt(ge * (2 * Fe - ge)) : 0, Jt = ce > 0 ? Math.sqrt(ce * (2 * Fe - ce)) : 0, sr = pt > 0 ? Math.max : Math.min;\n                        Pe = "M" + (G2 + Nt * ut) + "," + j3 + "V" + sr(N2 - (Fe - ce) * pt, j3) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (G2 + Fe * ut - Jt) + "," + N2 + "H" + (Z - Fe * ut + Jt) + "A " + Fe + "," + Fe + " 0 0 " + Zt + " " + (Z - Nt * ut) + "," + sr(N2 - (Fe - ce) * pt, j3) + "V" + j3 + "Z";\n                      }\n                    } else Pe = Re;\n                  } else Pe = Re;\n                  var wr = Hye(Fd.ensureSingle(O3, "path"), l3, i3, a4);\n                  if (wr.style("vector-effect", u4 ? "none" : "non-scaling-stroke").attr("d", isNaN((Z - G2) * (N2 - j3)) || H && e3._context.staticPlot ? "M0,0Z" : Pe).call(T_.setClipUrl, t3.layerClipId, e3), !l3.uniformtext.mode && x2) {\n                    var cr = T_.makePointStyleFns(d3);\n                    T_.singlePointStyle(T3, wr, d3, cr, e3);\n                  }\n                  Z1t(e3, t3, O3, f4, z3, G2, Z, j3, N2, Fe, ce, i3, a4), t3.layerClipId && T_.hideOutsideRangePoint(T3, O3.select("text"), o4, s3, d3.xcalendar, d3.ycalendar);\n                });\n                var P3 = d3.cliponaxis === false;\n                T_.setClipUrl(h3, P3 ? null : t3.layerClipId, e3);\n              });\n              O1t.getComponentMethod("errorbars", "plot")(e3, c5, t3, i3);\n            }\n            function Z1t(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4, c5, f4, h3) {\n              var d3 = t3.xaxis, v3 = t3.yaxis, _2 = e3._fullLayout, b;\n              function p3(ge, Re, ce) {\n                var Ze = Fd.ensureSingle(ge, "text").text(Re).attr({ class: "bartext bartext-" + b, "text-anchor": "middle", "data-notex": 1 }).call(T_.font, ce).call(F1t.convertToTspans, e3);\n                return Ze;\n              }\n              var k4 = n4[0].trace, E3 = k4.orientation === "h", S2 = J1t(_2, n4, i3, d3, v3);\n              b = $1t(k4, i3);\n              var L3 = f4.mode === "stack" || f4.mode === "relative", x2 = n4[i3], C3 = !L3 || x2._outmost, M4 = x2.hasB, g3 = u4 && u4 - c5 > Gv;\n              if (!S2 || b === "none" || (x2.isBlank || a4 === o4 || s3 === l3) && (b === "auto" || b === "inside")) {\n                r4.select("text").remove();\n                return;\n              }\n              var P3 = _2.font, T3 = kV.getBarColor(n4[i3], k4), z3 = kV.getInsideTextFont(k4, i3, P3, T3), O3 = kV.getOutsideTextFont(k4, i3, P3), V2 = k4.insidetextanchor || "end", G2 = r4.datum();\n              E3 ? d3.type === "log" && G2.s0 <= 0 && (d3.range[0] < d3.range[1] ? a4 = 0 : a4 = d3._length) : v3.type === "log" && G2.s0 <= 0 && (v3.range[0] < v3.range[1] ? s3 = v3._length : s3 = 0);\n              var Z = Math.abs(o4 - a4), j3 = Math.abs(l3 - s3), N2 = Z - 2 * Gv, H = j3 - 2 * Gv, te, oe, _e, Ee, Ce;\n              if (b === "outside" && !C3 && !x2.hasB && (b = "inside"), b === "auto") if (C3) {\n                b = "inside", Ce = Fd.ensureUniformFontSize(e3, z3), te = p3(r4, S2, Ce), oe = T_.bBox(te.node()), _e = oe.width, Ee = oe.height;\n                var me = _e > 0 && Ee > 0, ie;\n                g3 ? M4 ? ie = i22(N2 - 2 * u4, H, _e, Ee, E3) || i22(N2, H - 2 * u4, _e, Ee, E3) : E3 ? ie = i22(N2 - (u4 - c5), H, _e, Ee, E3) || i22(N2, H - 2 * (u4 - c5), _e, Ee, E3) : ie = i22(N2, H - (u4 - c5), _e, Ee, E3) || i22(N2 - 2 * (u4 - c5), H, _e, Ee, E3) : ie = i22(N2, H, _e, Ee, E3), me && ie ? b = "inside" : (b = "outside", te.remove(), te = null);\n              } else b = "inside";\n              if (!te) {\n                Ce = Fd.ensureUniformFontSize(e3, b === "outside" ? O3 : z3), te = p3(r4, S2, Ce);\n                var Se = te.attr("transform");\n                if (te.attr("transform", ""), oe = T_.bBox(te.node()), _e = oe.width, Ee = oe.height, te.attr("transform", Se), _e <= 0 || Ee <= 0) {\n                  te.remove();\n                  return;\n                }\n              }\n              var Le = k4.textangle, Ae, Fe;\n              b === "outside" ? (Fe = k4.constraintext === "both" || k4.constraintext === "outside", Ae = K1t(a4, o4, s3, l3, oe, { isHorizontal: E3, constrained: Fe, angle: Le })) : (Fe = k4.constraintext === "both" || k4.constraintext === "inside", Ae = Zye(a4, o4, s3, l3, oe, { isHorizontal: E3, constrained: Fe, angle: Le, anchor: V2, hasB: M4, r: u4, overhead: c5 })), Ae.fontSize = Ce.size, q1t(k4.type === "histogram" ? "bar" : k4.type, Ae, _2), x2.transform = Ae;\n              var Pe = Hye(te, _2, f4, h3);\n              Fd.setTransormAndDisplay(Pe, Ae);\n            }\n            function i22(e3, t3, r4, n4, i3) {\n              if (e3 < 0 || t3 < 0) return false;\n              var a4 = r4 <= e3 && n4 <= t3, o4 = r4 <= t3 && n4 <= e3, s3 = i3 ? e3 >= r4 * (t3 / n4) : t3 >= n4 * (e3 / r4);\n              return a4 || o4 || s3;\n            }\n            function Wye(e3) {\n              return e3 === "auto" ? 0 : e3;\n            }\n            function Xye(e3, t3) {\n              var r4 = Math.PI / 180 * t3, n4 = Math.abs(Math.sin(r4)), i3 = Math.abs(Math.cos(r4));\n              return { x: e3.width * i3 + e3.height * n4, y: e3.width * n4 + e3.height * i3 };\n            }\n            function Zye(e3, t3, r4, n4, i3, a4) {\n              var o4 = !!a4.isHorizontal, s3 = !!a4.constrained, l3 = a4.angle || 0, u4 = a4.anchor, c5 = u4 === "end", f4 = u4 === "start", h3 = a4.leftToRight || 0, d3 = (h3 + 1) / 2, v3 = 1 - d3, _2 = a4.hasB, b = a4.r, p3 = a4.overhead, k4 = i3.width, E3 = i3.height, S2 = Math.abs(t3 - e3), L3 = Math.abs(n4 - r4), x2 = S2 > 2 * Gv && L3 > 2 * Gv ? Gv : 0;\n              S2 -= 2 * x2, L3 -= 2 * x2;\n              var C3 = Wye(l3);\n              l3 === "auto" && !(k4 <= S2 && E3 <= L3) && (k4 > S2 || E3 > L3) && (!(k4 > L3 || E3 > S2) || k4 < E3 != S2 < L3) && (C3 += 90);\n              var M4 = Xye(i3, C3), g3, P3;\n              if (b && b - p3 > Gv) {\n                var T3 = Y1t(e3, t3, r4, n4, M4, b, p3, o4, _2);\n                g3 = T3.scale, P3 = T3.pad;\n              } else g3 = 1, s3 && (g3 = Math.min(1, S2 / M4.x, L3 / M4.y)), P3 = 0;\n              var z3 = i3.left * v3 + i3.right * d3, O3 = (i3.top + i3.bottom) / 2, V2 = (e3 + Gv) * v3 + (t3 - Gv) * d3, G2 = (r4 + n4) / 2, Z = 0, j3 = 0;\n              if (f4 || c5) {\n                var N2 = (o4 ? M4.x : M4.y) / 2;\n                b && (c5 || _2) && (x2 += P3);\n                var H = o4 ? Pm(e3, t3) : Pm(r4, n4);\n                o4 ? f4 ? (V2 = e3 + H * x2, Z = -H * N2) : (V2 = t3 - H * x2, Z = H * N2) : f4 ? (G2 = r4 + H * x2, j3 = -H * N2) : (G2 = n4 - H * x2, j3 = H * N2);\n              }\n              return { textX: z3, textY: O3, targetX: V2, targetY: G2, anchorX: Z, anchorY: j3, scale: g3, rotate: C3 };\n            }\n            function Y1t(e3, t3, r4, n4, i3, a4, o4, s3, l3) {\n              var u4 = Math.max(0, Math.abs(t3 - e3) - 2 * Gv), c5 = Math.max(0, Math.abs(n4 - r4) - 2 * Gv), f4 = a4 - Gv, h3 = o4 ? f4 - Math.sqrt(f4 * f4 - (f4 - o4) * (f4 - o4)) : f4, d3 = l3 ? f4 * 2 : s3 ? f4 - o4 : 2 * h3, v3 = l3 ? f4 * 2 : s3 ? 2 * h3 : f4 - o4, _2, b, p3, k4, E3;\n              return i3.y / i3.x >= c5 / (u4 - d3) ? k4 = c5 / i3.y : i3.y / i3.x <= (c5 - v3) / u4 ? k4 = u4 / i3.x : !l3 && s3 ? (_2 = i3.x * i3.x + i3.y * i3.y / 4, b = -2 * i3.x * (u4 - f4) - i3.y * (c5 / 2 - f4), p3 = (u4 - f4) * (u4 - f4) + (c5 / 2 - f4) * (c5 / 2 - f4) - f4 * f4, k4 = (-b + Math.sqrt(b * b - 4 * _2 * p3)) / (2 * _2)) : l3 ? (_2 = (i3.x * i3.x + i3.y * i3.y) / 4, b = -i3.x * (u4 / 2 - f4) - i3.y * (c5 / 2 - f4), p3 = (u4 / 2 - f4) * (u4 / 2 - f4) + (c5 / 2 - f4) * (c5 / 2 - f4) - f4 * f4, k4 = (-b + Math.sqrt(b * b - 4 * _2 * p3)) / (2 * _2)) : (_2 = i3.x * i3.x / 4 + i3.y * i3.y, b = -i3.x * (u4 / 2 - f4) - 2 * i3.y * (c5 - f4), p3 = (u4 / 2 - f4) * (u4 / 2 - f4) + (c5 - f4) * (c5 - f4) - f4 * f4, k4 = (-b + Math.sqrt(b * b - 4 * _2 * p3)) / (2 * _2)), k4 = Math.min(1, k4), s3 ? E3 = Math.max(0, f4 - Math.sqrt(Math.max(0, f4 * f4 - (f4 - (c5 - i3.y * k4) / 2) * (f4 - (c5 - i3.y * k4) / 2))) - o4) : E3 = Math.max(0, f4 - Math.sqrt(Math.max(0, f4 * f4 - (f4 - (u4 - i3.x * k4) / 2) * (f4 - (u4 - i3.x * k4) / 2))) - o4), { scale: k4, pad: E3 };\n            }\n            function K1t(e3, t3, r4, n4, i3, a4) {\n              var o4 = !!a4.isHorizontal, s3 = !!a4.constrained, l3 = a4.angle || 0, u4 = i3.width, c5 = i3.height, f4 = Math.abs(t3 - e3), h3 = Math.abs(n4 - r4), d3;\n              o4 ? d3 = h3 > 2 * Gv ? Gv : 0 : d3 = f4 > 2 * Gv ? Gv : 0;\n              var v3 = 1;\n              s3 && (v3 = o4 ? Math.min(1, h3 / c5) : Math.min(1, f4 / u4));\n              var _2 = Wye(l3), b = Xye(i3, _2), p3 = (o4 ? b.x : b.y) / 2, k4 = (i3.left + i3.right) / 2, E3 = (i3.top + i3.bottom) / 2, S2 = (e3 + t3) / 2, L3 = (r4 + n4) / 2, x2 = 0, C3 = 0, M4 = o4 ? Pm(t3, e3) : Pm(r4, n4);\n              return o4 ? (S2 = t3 - M4 * d3, x2 = M4 * p3) : (L3 = n4 + M4 * d3, C3 = -M4 * p3), { textX: k4, textY: E3, targetX: S2, targetY: L3, anchorX: x2, anchorY: C3, scale: v3, rotate: _2 };\n            }\n            function J1t(e3, t3, r4, n4, i3) {\n              var a4 = t3[0].trace, o4 = a4.texttemplate, s3;\n              return o4 ? s3 = Q1t(e3, t3, r4, n4, i3) : a4.textinfo ? s3 = e_t(t3, r4, n4, i3) : s3 = MT.getValue(a4.text, r4), MT.coerceString(U1t, s3);\n            }\n            function $1t(e3, t3) {\n              var r4 = MT.getValue(e3.textposition, t3);\n              return MT.coerceEnumerated(V1t, r4);\n            }\n            function Q1t(e3, t3, r4, n4, i3) {\n              var a4 = t3[0].trace, o4 = Fd.castOption(a4, r4, "texttemplate");\n              if (!o4) return "";\n              var s3 = a4.type === "histogram", l3 = a4.type === "waterfall", u4 = a4.type === "funnel", c5 = a4.orientation === "h", f4, h3, d3, v3;\n              c5 ? (f4 = "y", h3 = i3, d3 = "x", v3 = n4) : (f4 = "x", h3 = n4, d3 = "y", v3 = i3);\n              function _2(x2) {\n                return XI(h3, h3.c2l(x2), true).text;\n              }\n              function b(x2) {\n                return XI(v3, v3.c2l(x2), true).text;\n              }\n              var p3 = t3[r4], k4 = {};\n              k4.label = p3.p, k4.labelLabel = k4[f4 + "Label"] = _2(p3.p);\n              var E3 = Fd.castOption(a4, p3.i, "text");\n              (E3 === 0 || E3) && (k4.text = E3), k4.value = p3.s, k4.valueLabel = k4[d3 + "Label"] = b(p3.s);\n              var S2 = {};\n              G1t(S2, a4, p3.i), (s3 || S2.x === void 0) && (S2.x = c5 ? k4.value : k4.label), (s3 || S2.y === void 0) && (S2.y = c5 ? k4.label : k4.value), (s3 || S2.xLabel === void 0) && (S2.xLabel = c5 ? k4.valueLabel : k4.labelLabel), (s3 || S2.yLabel === void 0) && (S2.yLabel = c5 ? k4.labelLabel : k4.valueLabel), l3 && (k4.delta = +p3.rawS || p3.s, k4.deltaLabel = b(k4.delta), k4.final = p3.v, k4.finalLabel = b(k4.final), k4.initial = k4.final - k4.delta, k4.initialLabel = b(k4.initial)), u4 && (k4.value = p3.s, k4.valueLabel = b(k4.value), k4.percentInitial = p3.begR, k4.percentInitialLabel = Fd.formatPercent(p3.begR), k4.percentPrevious = p3.difR, k4.percentPreviousLabel = Fd.formatPercent(p3.difR), k4.percentTotal = p3.sumR, k4.percenTotalLabel = Fd.formatPercent(p3.sumR));\n              var L3 = Fd.castOption(a4, p3.i, "customdata");\n              return L3 && (k4.customdata = L3), Fd.texttemplateString({ data: [S2, k4, a4._meta], fallback: a4.texttemplatefallback, labels: k4, locale: e3._d3locale, template: o4 });\n            }\n            function e_t(e3, t3, r4, n4) {\n              var i3 = e3[0].trace, a4 = i3.orientation === "h", o4 = i3.type === "waterfall", s3 = i3.type === "funnel";\n              function l3(L3) {\n                var x2 = a4 ? n4 : r4;\n                return XI(x2, L3, true).text;\n              }\n              function u4(L3) {\n                var x2 = a4 ? r4 : n4;\n                return XI(x2, +L3, true).text;\n              }\n              var c5 = i3.textinfo, f4 = e3[t3], h3 = c5.split("+"), d3 = [], v3, _2 = function(L3) {\n                return h3.indexOf(L3) !== -1;\n              };\n              if (_2("label") && d3.push(l3(e3[t3].p)), _2("text") && (v3 = Fd.castOption(i3, f4.i, "text"), (v3 === 0 || v3) && d3.push(v3)), o4) {\n                var b = +f4.rawS || f4.s, p3 = f4.v, k4 = p3 - b;\n                _2("initial") && d3.push(u4(k4)), _2("delta") && d3.push(u4(b)), _2("final") && d3.push(u4(p3));\n              }\n              if (s3) {\n                _2("value") && d3.push(u4(f4.s));\n                var E3 = 0;\n                _2("percent initial") && E3++, _2("percent previous") && E3++, _2("percent total") && E3++;\n                var S2 = E3 > 1;\n                _2("percent initial") && (v3 = Fd.formatPercent(f4.begR), S2 && (v3 += " of initial"), d3.push(v3)), _2("percent previous") && (v3 = Fd.formatPercent(f4.difR), S2 && (v3 += " of previous"), d3.push(v3)), _2("percent total") && (v3 = Fd.formatPercent(f4.sumR), S2 && (v3 += " of total"), d3.push(v3));\n              }\n              return d3.join("<br>");\n            }\n            Yye.exports = { plot: X1t, toMoveInsideBar: Zye };\n          });\n          var ET = ye((Qlr, Qye) => {\n            "use strict";\n            var _4 = vf(), t_t = qa(), Kye = ka(), r_t = Dr().fillText, i_t = HI().getLineWidth, LV = ho().hoverLabelText, n_t = fs().BADNUM;\n            function a_t(e3, t3, r4, n4, i3) {\n              var a4 = Jye(e3, t3, r4, n4, i3);\n              if (a4) {\n                var o4 = a4.cd, s3 = o4[0].trace, l3 = o4[a4.index];\n                return a4.color = $ye(s3, l3), t_t.getComponentMethod("errorbars", "hoverInfo")(l3, s3, a4), [a4];\n              }\n            }\n            function Jye(e3, t3, r4, n4, i3) {\n              var a4 = e3.cd, o4 = a4[0].trace, s3 = a4[0].t, l3 = n4 === "closest", u4 = o4.type === "waterfall", c5 = e3.maxHoverDistance, f4 = e3.maxSpikeDistance, h3, d3, v3, _2, b, p3, k4;\n              o4.orientation === "h" ? (h3 = r4, d3 = t3, v3 = "y", _2 = "x", b = G2, p3 = z3) : (h3 = t3, d3 = r4, v3 = "x", _2 = "y", p3 = G2, b = z3);\n              var E3 = o4[v3 + "period"], S2 = l3 || E3;\n              function L3(ie) {\n                return C3(ie, -1);\n              }\n              function x2(ie) {\n                return C3(ie, 1);\n              }\n              function C3(ie, Se) {\n                var Le = ie.w;\n                return ie[v3] + Se * Le / 2;\n              }\n              function M4(ie) {\n                return ie[v3 + "End"] - ie[v3 + "Start"];\n              }\n              var g3 = l3 ? L3 : E3 ? function(ie) {\n                return ie.p - M4(ie) / 2;\n              } : function(ie) {\n                return Math.min(L3(ie), ie.p - s3.bardelta / 2);\n              }, P3 = l3 ? x2 : E3 ? function(ie) {\n                return ie.p + M4(ie) / 2;\n              } : function(ie) {\n                return Math.max(x2(ie), ie.p + s3.bardelta / 2);\n              };\n              function T3(ie, Se, Le) {\n                return i3.finiteRange && (Le = 0), _4.inbox(ie - h3, Se - h3, Le + Math.min(1, Math.abs(Se - ie) / k4) - 1);\n              }\n              function z3(ie) {\n                return T3(g3(ie), P3(ie), c5);\n              }\n              function O3(ie) {\n                return T3(L3(ie), x2(ie), f4);\n              }\n              function V2(ie) {\n                var Se = ie[_2];\n                if (u4) {\n                  var Le = Math.abs(ie.rawS) || 0;\n                  d3 > 0 ? Se += Le : d3 < 0 && (Se -= Le);\n                }\n                return Se;\n              }\n              function G2(ie) {\n                var Se = d3, Le = ie.b, Ae = V2(ie);\n                return _4.inbox(Le - Se, Ae - Se, c5 + (Ae - Se) / (Ae - Le) - 1);\n              }\n              function Z(ie) {\n                var Se = d3, Le = ie.b, Ae = V2(ie);\n                return _4.inbox(Le - Se, Ae - Se, f4 + (Ae - Se) / (Ae - Le) - 1);\n              }\n              var j3 = e3[v3 + "a"], N2 = e3[_2 + "a"];\n              k4 = Math.abs(j3.r2c(j3.range[1]) - j3.r2c(j3.range[0]));\n              function H(ie) {\n                return (b(ie) + p3(ie)) / 2;\n              }\n              var te = _4.getDistanceFunction(n4, b, p3, H);\n              if (_4.getClosest(a4, te, e3), e3.index !== false && a4[e3.index].p !== n_t) {\n                S2 || (g3 = function(ie) {\n                  return Math.min(L3(ie), ie.p - s3.bargroupwidth / 2);\n                }, P3 = function(ie) {\n                  return Math.max(x2(ie), ie.p + s3.bargroupwidth / 2);\n                });\n                var oe = e3.index, _e = a4[oe], Ee = o4.base ? _e.b + _e.s : _e.s;\n                e3[_2 + "0"] = e3[_2 + "1"] = N2.c2p(_e[_2], true), e3[_2 + "LabelVal"] = Ee;\n                var Ce = s3.extents[s3.extents.round(_e.p)];\n                e3[v3 + "0"] = j3.c2p(l3 ? g3(_e) : Ce[0], true), e3[v3 + "1"] = j3.c2p(l3 ? P3(_e) : Ce[1], true);\n                var me = _e.orig_p !== void 0;\n                return e3[v3 + "LabelVal"] = me ? _e.orig_p : _e.p, e3.labelLabel = LV(j3, e3[v3 + "LabelVal"], o4[v3 + "hoverformat"]), e3.valueLabel = LV(N2, e3[_2 + "LabelVal"], o4[_2 + "hoverformat"]), e3.baseLabel = LV(N2, _e.b, o4[_2 + "hoverformat"]), e3.spikeDistance = (Z(_e) + O3(_e)) / 2, e3[v3 + "Spike"] = j3.c2p(_e.p, true), r_t(_e, o4, e3), e3.hovertemplate = o4.hovertemplate, e3;\n              }\n            }\n            function $ye(e3, t3) {\n              var r4 = t3.mcc || e3.marker.color, n4 = t3.mlcc || e3.marker.line.color, i3 = i_t(e3, t3);\n              if (Kye.opacity(r4)) return r4;\n              if (Kye.opacity(n4) && i3) return n4;\n            }\n            Qye.exports = { hoverPoints: a_t, hoverOnBars: Jye, getTraceColor: $ye };\n          });\n          var t1e = ye((eur, e1e) => {\n            "use strict";\n            e1e.exports = function(t3, r4, n4) {\n              return t3.x = "xVal" in r4 ? r4.xVal : r4.x, t3.y = "yVal" in r4 ? r4.yVal : r4.y, r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), n4.orientation === "h" ? (t3.label = t3.y, t3.value = t3.x) : (t3.label = t3.x, t3.value = t3.y), t3;\n            };\n          });\n          var kT = ye((tur, r1e) => {\n            "use strict";\n            r1e.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = n4[0].trace, s3 = o4.type === "funnel", l3 = o4.orientation === "h", u4 = [], c5;\n              if (r4 === false) for (c5 = 0; c5 < n4.length; c5++) n4[c5].selected = 0;\n              else for (c5 = 0; c5 < n4.length; c5++) {\n                var f4 = n4[c5], h3 = "ct" in f4 ? f4.ct : o_t(f4, i3, a4, l3, s3);\n                r4.contains(h3, false, c5, t3) ? (u4.push({ pointNumber: c5, x: i3.c2d(f4.x), y: a4.c2d(f4.y) }), f4.selected = 1) : f4.selected = 0;\n              }\n              return u4;\n            };\n            function o_t(e3, t3, r4, n4, i3) {\n              var a4 = t3.c2p(n4 ? e3.s0 : e3.p0, true), o4 = t3.c2p(n4 ? e3.s1 : e3.p1, true), s3 = r4.c2p(n4 ? e3.p0 : e3.s0, true), l3 = r4.c2p(n4 ? e3.p1 : e3.s1, true);\n              return i3 ? [(a4 + o4) / 2, (s3 + l3) / 2] : n4 ? [o4, (s3 + l3) / 2] : [(a4 + o4) / 2, l3];\n            }\n          });\n          var n1e = ye((rur, i1e) => {\n            "use strict";\n            i1e.exports = { attributes: Lm(), layoutAttributes: UI(), supplyDefaults: r0().supplyDefaults, crossTraceDefaults: r0().crossTraceDefaults, supplyLayoutDefaults: SV(), calc: Eye(), crossTraceCalc: jb().crossTraceCalc, colorbar: $d(), arraysToCalcdata: g4(), plot: n2().plot, style: N0().style, styleOnSelect: N0().styleOnSelect, hoverPoints: ET().hoverPoints, eventData: t1e(), selectPoints: kT(), moduleType: "trace", name: "bar", basePlotModule: ph(), categories: ["bar-like", "cartesian", "svg", "bar", "oriented", "errorBarsOK", "showLegend", "zoomScale"], animatable: true, meta: {} };\n          });\n          var o1e = ye((iur, a1e) => {\n            "use strict";\n            a1e.exports = n1e();\n          });\n          var x4 = ye((nur, c1e) => {\n            "use strict";\n            var s_t = Cg(), U0 = pf(), s1e = Lm(), l_t = Lh(), l1e = df().axisHoverFormat, { hovertemplateAttrs: u_t, templatefallbackAttrs: c_t } = Ll(), zy = Ao().extendFlat, CT = U0.marker, u1e = CT.line;\n            c1e.exports = { y: { valType: "data_array", editType: "calc+clearAxisTypes" }, x: { valType: "data_array", editType: "calc+clearAxisTypes" }, x0: { valType: "any", editType: "calc+clearAxisTypes" }, y0: { valType: "any", editType: "calc+clearAxisTypes" }, dx: { valType: "number", editType: "calc" }, dy: { valType: "number", editType: "calc" }, xperiod: U0.xperiod, yperiod: U0.yperiod, xperiod0: U0.xperiod0, yperiod0: U0.yperiod0, xperiodalignment: U0.xperiodalignment, yperiodalignment: U0.yperiodalignment, xhoverformat: l1e("x"), yhoverformat: l1e("y"), name: { valType: "string", editType: "calc+clearAxisTypes" }, q1: { valType: "data_array", editType: "calc+clearAxisTypes" }, median: { valType: "data_array", editType: "calc+clearAxisTypes" }, q3: { valType: "data_array", editType: "calc+clearAxisTypes" }, lowerfence: { valType: "data_array", editType: "calc" }, upperfence: { valType: "data_array", editType: "calc" }, notched: { valType: "boolean", editType: "calc" }, notchwidth: { valType: "number", min: 0, max: 0.5, dflt: 0.25, editType: "calc" }, notchspan: { valType: "data_array", editType: "calc" }, boxpoints: { valType: "enumerated", values: ["all", "outliers", "suspectedoutliers", false], editType: "calc" }, jitter: { valType: "number", min: 0, max: 1, editType: "calc" }, pointpos: { valType: "number", min: -2, max: 2, editType: "calc" }, sdmultiple: { valType: "number", min: 0, editType: "calc", dflt: 1 }, sizemode: { valType: "enumerated", values: ["quartiles", "sd"], editType: "calc", dflt: "quartiles" }, boxmean: { valType: "enumerated", values: [true, "sd", false], editType: "calc" }, mean: { valType: "data_array", editType: "calc" }, sd: { valType: "data_array", editType: "calc" }, orientation: { valType: "enumerated", values: ["v", "h"], editType: "calc+clearAxisTypes" }, quartilemethod: { valType: "enumerated", values: ["linear", "exclusive", "inclusive"], dflt: "linear", editType: "calc" }, width: { valType: "number", min: 0, dflt: 0, editType: "calc" }, marker: { outliercolor: { valType: "color", dflt: "rgba(0, 0, 0, 0)", editType: "style" }, symbol: zy({}, CT.symbol, { arrayOk: false, editType: "plot" }), opacity: zy({}, CT.opacity, { arrayOk: false, dflt: 1, editType: "style" }), angle: zy({}, CT.angle, { arrayOk: false, editType: "calc" }), size: zy({}, CT.size, { arrayOk: false, editType: "calc" }), color: zy({}, CT.color, { arrayOk: false, editType: "style" }), line: { color: zy({}, u1e.color, { arrayOk: false, dflt: l_t.defaultLine, editType: "style" }), width: zy({}, u1e.width, { arrayOk: false, dflt: 0, editType: "style" }), outliercolor: { valType: "color", editType: "style" }, outlierwidth: { valType: "number", min: 0, dflt: 1, editType: "style" }, editType: "style" }, editType: "plot" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, dflt: 2, editType: "style" }, editType: "plot" }, fillcolor: s_t(), whiskerwidth: { valType: "number", min: 0, max: 1, dflt: 0.5, editType: "calc" }, showwhiskers: { valType: "boolean", editType: "calc" }, offsetgroup: s1e.offsetgroup, alignmentgroup: s1e.alignmentgroup, selected: { marker: U0.selected.marker, editType: "style" }, unselected: { marker: U0.unselected.marker, editType: "style" }, text: zy({}, U0.text, {}), hovertext: zy({}, U0.hovertext, {}), hovertemplate: u_t({}), hovertemplatefallback: c_t(), hoveron: { valType: "flaglist", flags: ["boxes", "points"], dflt: "boxes+points", editType: "style" }, zorder: U0.zorder };\n          });\n          var b4 = ye((aur, f1e) => {\n            "use strict";\n            f1e.exports = { boxmode: { valType: "enumerated", values: ["group", "overlay"], dflt: "overlay", editType: "calc" }, boxgap: { valType: "number", min: 0, max: 1, dflt: 0.3, editType: "calc" }, boxgroupgap: { valType: "number", min: 0, max: 1, dflt: 0.3, editType: "calc" } };\n          });\n          var T4 = ye((our, p1e) => {\n            "use strict";\n            var V0 = Dr(), f_t = qa(), h_t = ka(), d_t = Ig(), v_t = Hb(), h1e = R3(), w4 = x4();\n            function p_t(e3, t3, r4, n4) {\n              function i3(v3, _2) {\n                return V0.coerce(e3, t3, w4, v3, _2);\n              }\n              if (d1e(e3, t3, i3, n4), t3.visible !== false) {\n                d_t(e3, t3, n4, i3), i3("xhoverformat"), i3("yhoverformat");\n                var a4 = t3._hasPreCompStats;\n                a4 && (i3("lowerfence"), i3("upperfence")), i3("line.color", (e3.marker || {}).color || r4), i3("line.width"), i3("fillcolor", h_t.addOpacity(t3.line.color, 0.5));\n                var o4 = false;\n                if (a4) {\n                  var s3 = i3("mean"), l3 = i3("sd");\n                  s3 && s3.length && (o4 = true, l3 && l3.length && (o4 = "sd"));\n                }\n                i3("whiskerwidth");\n                var u4 = i3("sizemode"), c5;\n                u4 === "quartiles" && (c5 = i3("boxmean", o4)), i3("showwhiskers", u4 === "quartiles"), (u4 === "sd" || c5 === "sd") && i3("sdmultiple"), i3("width"), i3("quartilemethod");\n                var f4 = false;\n                if (a4) {\n                  var h3 = i3("notchspan");\n                  h3 && h3.length && (f4 = true);\n                } else V0.validate(e3.notchwidth, w4.notchwidth) && (f4 = true);\n                var d3 = i3("notched", f4);\n                d3 && i3("notchwidth"), v1e(e3, t3, i3, { prefix: "box" }), i3("zorder");\n              }\n            }\n            function d1e(e3, t3, r4, n4) {\n              function i3(P3) {\n                var T3 = 0;\n                return P3 && P3.length && (T3 += 1, V0.isArrayOrTypedArray(P3[0]) && P3[0].length && (T3 += 1)), T3;\n              }\n              function a4(P3) {\n                return V0.validate(e3[P3], w4[P3]);\n              }\n              var o4 = r4("y"), s3 = r4("x"), l3;\n              if (t3.type === "box") {\n                var u4 = r4("q1"), c5 = r4("median"), f4 = r4("q3");\n                t3._hasPreCompStats = u4 && u4.length && c5 && c5.length && f4 && f4.length, l3 = Math.min(V0.minRowLength(u4), V0.minRowLength(c5), V0.minRowLength(f4));\n              }\n              var h3 = i3(o4), d3 = i3(s3), v3 = h3 && V0.minRowLength(o4), _2 = d3 && V0.minRowLength(s3), b = n4.calendar, p3 = { autotypenumbers: n4.autotypenumbers }, k4, E3;\n              if (t3._hasPreCompStats) switch (String(d3) + String(h3)) {\n                case "00":\n                  var S2 = a4("x0") || a4("dx"), L3 = a4("y0") || a4("dy");\n                  L3 && !S2 ? k4 = "h" : k4 = "v", E3 = l3;\n                  break;\n                case "10":\n                  k4 = "v", E3 = Math.min(l3, _2);\n                  break;\n                case "20":\n                  k4 = "h", E3 = Math.min(l3, s3.length);\n                  break;\n                case "01":\n                  k4 = "h", E3 = Math.min(l3, v3);\n                  break;\n                case "02":\n                  k4 = "v", E3 = Math.min(l3, o4.length);\n                  break;\n                case "12":\n                  k4 = "v", E3 = Math.min(l3, _2, o4.length);\n                  break;\n                case "21":\n                  k4 = "h", E3 = Math.min(l3, s3.length, v3);\n                  break;\n                case "11":\n                  E3 = 0;\n                  break;\n                case "22":\n                  var x2 = false, C3;\n                  for (C3 = 0; C3 < s3.length; C3++) if (h1e(s3[C3], b, p3) === "category") {\n                    x2 = true;\n                    break;\n                  }\n                  if (x2) k4 = "v", E3 = Math.min(l3, _2, o4.length);\n                  else {\n                    for (C3 = 0; C3 < o4.length; C3++) if (h1e(o4[C3], b, p3) === "category") {\n                      x2 = true;\n                      break;\n                    }\n                    x2 ? (k4 = "h", E3 = Math.min(l3, s3.length, v3)) : (k4 = "v", E3 = Math.min(l3, _2, o4.length));\n                  }\n                  break;\n              }\n              else h3 > 0 ? (k4 = "v", d3 > 0 ? E3 = Math.min(_2, v3) : E3 = Math.min(v3)) : d3 > 0 ? (k4 = "h", E3 = Math.min(_2)) : E3 = 0;\n              if (!E3) {\n                t3.visible = false;\n                return;\n              }\n              t3._length = E3;\n              var M4 = r4("orientation", k4);\n              t3._hasPreCompStats ? M4 === "v" && d3 === 0 ? (r4("x0", 0), r4("dx", 1)) : M4 === "h" && h3 === 0 && (r4("y0", 0), r4("dy", 1)) : M4 === "v" && d3 === 0 ? r4("x0") : M4 === "h" && h3 === 0 && r4("y0");\n              var g3 = f_t.getComponentMethod("calendars", "handleTraceDefaults");\n              g3(e3, t3, ["x", "y"], n4);\n            }\n            function v1e(e3, t3, r4, n4) {\n              var i3 = n4.prefix, a4 = V0.coerce2(e3, t3, w4, "marker.outliercolor"), o4 = r4("marker.line.outliercolor"), s3 = "outliers";\n              t3._hasPreCompStats ? s3 = "all" : (a4 || o4) && (s3 = "suspectedoutliers");\n              var l3 = r4(i3 + "points", s3);\n              l3 ? (r4("jitter", l3 === "all" ? 0.3 : 0), r4("pointpos", l3 === "all" ? -1.5 : 0), r4("marker.symbol"), r4("marker.opacity"), r4("marker.size"), r4("marker.angle"), r4("marker.color", t3.line.color), r4("marker.line.color"), r4("marker.line.width"), l3 === "suspectedoutliers" && (r4("marker.line.outliercolor", t3.marker.color), r4("marker.line.outlierwidth")), r4("selected.marker.color"), r4("unselected.marker.color"), r4("selected.marker.size"), r4("unselected.marker.size"), r4("text"), r4("hovertext")) : delete t3.marker;\n              var u4 = r4("hoveron");\n              (u4 === "all" || u4.indexOf("points") !== -1) && (r4("hovertemplate"), r4("hovertemplatefallback")), V0.coerceSelectionMarkerOpacity(t3, r4);\n            }\n            function g_t(e3, t3) {\n              var r4, n4;\n              function i3(l3) {\n                return V0.coerce(n4._input, n4, w4, l3);\n              }\n              for (var a4 = 0; a4 < e3.length; a4++) {\n                n4 = e3[a4];\n                var o4 = n4.type;\n                if (o4 === "box" || o4 === "violin") {\n                  r4 = n4._input;\n                  var s3 = t3[o4 + "mode"];\n                  s3 === "group" && v_t(r4, n4, t3, i3, s3);\n                }\n              }\n            }\n            p1e.exports = { supplyDefaults: p_t, crossTraceDefaults: g_t, handleSampleDefaults: d1e, handlePointsDefaults: v1e };\n          });\n          var ZI = ye((sur, m1e) => {\n            "use strict";\n            var m_t = qa(), y_t = Dr(), __t = b4();\n            function g1e(e3, t3, r4, n4, i3) {\n              for (var a4 = i3 + "Layout", o4 = false, s3 = 0; s3 < r4.length; s3++) {\n                var l3 = r4[s3];\n                if (m_t.traceIs(l3, a4)) {\n                  o4 = true;\n                  break;\n                }\n              }\n              o4 && (n4(i3 + "mode"), n4(i3 + "gap"), n4(i3 + "groupgap"));\n            }\n            function x_t(e3, t3, r4) {\n              function n4(i3, a4) {\n                return y_t.coerce(e3, t3, __t, i3, a4);\n              }\n              g1e(e3, t3, r4, n4, "box");\n            }\n            m1e.exports = { supplyLayoutDefaults: x_t, _supply: g1e };\n          });\n          var RV = ye((lur, M1e) => {\n            "use strict";\n            var IV = Eo(), YI = ho(), b_t = Dg(), gh = Dr(), i0 = fs().BADNUM, Oy = gh._;\n            M1e.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = YI.getFromId(t3, r4.xaxis || "x"), a4 = YI.getFromId(t3, r4.yaxis || "y"), o4 = [], s3 = r4.type === "violin" ? "_numViolins" : "_numBoxes", l3, u4, c5, f4, h3, d3, v3;\n              r4.orientation === "h" ? (c5 = i3, f4 = "x", h3 = a4, d3 = "y", v3 = !!r4.yperiodalignment) : (c5 = a4, f4 = "y", h3 = i3, d3 = "x", v3 = !!r4.xperiodalignment);\n              var _2 = w_t(r4, d3, h3, n4[s3]), b = _2[0], p3 = _2[1], k4 = gh.distinctVals(b, h3), E3 = k4.vals, S2 = k4.minDiff / 2, L3, x2, C3, M4, g3, P3, T3 = (r4.boxpoints || r4.points) === "all" ? gh.identity : function(Zt) {\n                return Zt.v < L3.lf || Zt.v > L3.uf;\n              };\n              if (r4._hasPreCompStats) {\n                var z3 = r4[f4], O3 = function(Zt) {\n                  return c5.d2c((r4[Zt] || [])[l3]);\n                }, V2 = 1 / 0, G2 = -1 / 0;\n                for (l3 = 0; l3 < r4._length; l3++) {\n                  var Z = b[l3];\n                  if (IV(Z)) {\n                    if (L3 = {}, L3.pos = L3[d3] = Z, v3 && p3 && (L3.orig_p = p3[l3]), L3.q1 = O3("q1"), L3.med = O3("median"), L3.q3 = O3("q3"), x2 = [], z3 && gh.isArrayOrTypedArray(z3[l3])) for (u4 = 0; u4 < z3[l3].length; u4++) P3 = c5.d2c(z3[l3][u4]), P3 !== i0 && (g3 = { v: P3, i: [l3, u4] }, y1e(g3, r4, [l3, u4]), x2.push(g3));\n                    if (L3.pts = x2.sort(_1e), C3 = L3[f4] = x2.map(x1e), M4 = C3.length, L3.med !== i0 && L3.q1 !== i0 && L3.q3 !== i0 && L3.med >= L3.q1 && L3.q3 >= L3.med) {\n                      var j3 = O3("lowerfence");\n                      L3.lf = j3 !== i0 && j3 <= L3.q1 ? j3 : b1e(L3, C3, M4);\n                      var N2 = O3("upperfence");\n                      L3.uf = N2 !== i0 && N2 >= L3.q3 ? N2 : w1e(L3, C3, M4);\n                      var H = O3("mean");\n                      L3.mean = H !== i0 ? H : M4 ? gh.mean(C3, M4) : (L3.q1 + L3.q3) / 2;\n                      var te = O3("sd");\n                      L3.sd = H !== i0 && te >= 0 ? te : M4 ? gh.stdev(C3, M4, L3.mean) : L3.q3 - L3.q1, L3.lo = T1e(L3), L3.uo = A1e(L3);\n                      var oe = O3("notchspan");\n                      oe = oe !== i0 && oe > 0 ? oe : S1e(L3, M4), L3.ln = L3.med - oe, L3.un = L3.med + oe;\n                      var _e = L3.lf, Ee = L3.uf;\n                      r4.boxpoints && C3.length && (_e = Math.min(_e, C3[0]), Ee = Math.max(Ee, C3[M4 - 1])), r4.notched && (_e = Math.min(_e, L3.ln), Ee = Math.max(Ee, L3.un)), L3.min = _e, L3.max = Ee;\n                    } else {\n                      gh.warn(["Invalid input - make sure that q1 <= median <= q3", "q1 = " + L3.q1, "median = " + L3.med, "q3 = " + L3.q3].join(`\n`));\n                      var Ce;\n                      L3.med !== i0 ? Ce = L3.med : L3.q1 !== i0 ? L3.q3 !== i0 ? Ce = (L3.q1 + L3.q3) / 2 : Ce = L3.q1 : L3.q3 !== i0 ? Ce = L3.q3 : Ce = 0, L3.med = Ce, L3.q1 = L3.q3 = Ce, L3.lf = L3.uf = Ce, L3.mean = L3.sd = Ce, L3.ln = L3.un = Ce, L3.min = L3.max = Ce;\n                    }\n                    V2 = Math.min(V2, L3.min), G2 = Math.max(G2, L3.max), L3.pts2 = x2.filter(T3), o4.push(L3);\n                  }\n                }\n                r4._extremes[c5._id] = YI.findExtremes(c5, [V2, G2], { padded: true });\n              } else {\n                var me = c5.makeCalcdata(r4, f4), ie = T_t(E3, S2), Se = E3.length, Le = A_t(Se);\n                for (l3 = 0; l3 < r4._length; l3++) if (P3 = me[l3], !!IV(P3)) {\n                  var Ae = gh.findBin(b[l3], ie);\n                  Ae >= 0 && Ae < Se && (g3 = { v: P3, i: l3 }, y1e(g3, r4, l3), Le[Ae].push(g3));\n                }\n                var Fe = 1 / 0, Pe = -1 / 0, ge = r4.quartilemethod, Re = ge === "exclusive", ce = ge === "inclusive";\n                for (l3 = 0; l3 < Se; l3++) if (Le[l3].length > 0) {\n                  if (L3 = {}, L3.pos = L3[d3] = E3[l3], x2 = L3.pts = Le[l3].sort(_1e), C3 = L3[f4] = x2.map(x1e), M4 = C3.length, L3.min = C3[0], L3.max = C3[M4 - 1], L3.mean = gh.mean(C3, M4), L3.sd = gh.stdev(C3, M4, L3.mean) * r4.sdmultiple, L3.med = gh.interp(C3, 0.5), M4 % 2 && (Re || ce)) {\n                    var Ze, ut;\n                    Re ? (Ze = C3.slice(0, M4 / 2), ut = C3.slice(M4 / 2 + 1)) : ce && (Ze = C3.slice(0, M4 / 2 + 1), ut = C3.slice(M4 / 2)), L3.q1 = gh.interp(Ze, 0.5), L3.q3 = gh.interp(ut, 0.5);\n                  } else L3.q1 = gh.interp(C3, 0.25), L3.q3 = gh.interp(C3, 0.75);\n                  L3.lf = b1e(L3, C3, M4), L3.uf = w1e(L3, C3, M4), L3.lo = T1e(L3), L3.uo = A1e(L3);\n                  var pt = S1e(L3, M4);\n                  L3.ln = L3.med - pt, L3.un = L3.med + pt, Fe = Math.min(Fe, L3.ln), Pe = Math.max(Pe, L3.un), L3.pts2 = x2.filter(T3), o4.push(L3);\n                }\n                r4.notched && gh.isTypedArray(me) && (me = Array.from(me)), r4._extremes[c5._id] = YI.findExtremes(c5, r4.notched ? me.concat([Fe, Pe]) : me, { padded: true });\n              }\n              return S_t(o4, r4), o4.length > 0 ? (o4[0].t = { num: n4[s3], dPos: S2, posLetter: d3, valLetter: f4, labels: { med: Oy(t3, "median:"), min: Oy(t3, "min:"), q1: Oy(t3, "q1:"), q3: Oy(t3, "q3:"), max: Oy(t3, "max:"), mean: r4.boxmean === "sd" || r4.sizemode === "sd" ? Oy(t3, "mean \\xB1 \\u03C3:").replace("\\u03C3", r4.sdmultiple === 1 ? "\\u03C3" : r4.sdmultiple + "\\u03C3") : Oy(t3, "mean:"), lf: Oy(t3, "lower fence:"), uf: Oy(t3, "upper fence:") } }, n4[s3]++, o4) : [{ t: { empty: true } }];\n            };\n            function w_t(e3, t3, r4, n4) {\n              var i3 = t3 in e3, a4 = t3 + "0" in e3, o4 = "d" + t3 in e3;\n              if (i3 || a4 && o4) {\n                var s3 = r4.makeCalcdata(e3, t3), l3 = b_t(e3, r4, t3, s3).vals;\n                return [l3, s3];\n              }\n              var u4;\n              a4 ? u4 = e3[t3 + "0"] : "name" in e3 && (r4.type === "category" || IV(e3.name) && ["linear", "log"].indexOf(r4.type) !== -1 || gh.isDateTime(e3.name) && r4.type === "date") ? u4 = e3.name : u4 = n4;\n              for (var c5 = r4.type === "multicategory" ? r4.r2c_just_indices(u4) : r4.d2c(u4, 0, e3[t3 + "calendar"]), f4 = e3._length, h3 = new Array(f4), d3 = 0; d3 < f4; d3++) h3[d3] = c5;\n              return [h3];\n            }\n            function T_t(e3, t3) {\n              for (var r4 = e3.length, n4 = new Array(r4 + 1), i3 = 0; i3 < r4; i3++) n4[i3] = e3[i3] - t3;\n              return n4[r4] = e3[r4 - 1] + t3, n4;\n            }\n            function A_t(e3) {\n              for (var t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = [];\n              return t3;\n            }\n            var PV = { text: "tx", hovertext: "htx" };\n            function y1e(e3, t3, r4) {\n              for (var n4 in PV) gh.isArrayOrTypedArray(t3[n4]) && (Array.isArray(r4) ? gh.isArrayOrTypedArray(t3[n4][r4[0]]) && (e3[PV[n4]] = t3[n4][r4[0]][r4[1]]) : e3[PV[n4]] = t3[n4][r4]);\n            }\n            function S_t(e3, t3) {\n              if (gh.isArrayOrTypedArray(t3.selectedpoints)) for (var r4 = 0; r4 < e3.length; r4++) {\n                for (var n4 = e3[r4].pts || [], i3 = {}, a4 = 0; a4 < n4.length; a4++) i3[n4[a4].i] = a4;\n                gh.tagSelected(n4, t3, i3);\n              }\n            }\n            function _1e(e3, t3) {\n              return e3.v - t3.v;\n            }\n            function x1e(e3) {\n              return e3.v;\n            }\n            function b1e(e3, t3, r4) {\n              return r4 === 0 ? e3.q1 : Math.min(e3.q1, t3[Math.min(gh.findBin(2.5 * e3.q1 - 1.5 * e3.q3, t3, true) + 1, r4 - 1)]);\n            }\n            function w1e(e3, t3, r4) {\n              return r4 === 0 ? e3.q3 : Math.max(e3.q3, t3[Math.max(gh.findBin(2.5 * e3.q3 - 1.5 * e3.q1, t3), 0)]);\n            }\n            function T1e(e3) {\n              return 4 * e3.q1 - 3 * e3.q3;\n            }\n            function A1e(e3) {\n              return 4 * e3.q3 - 3 * e3.q1;\n            }\n            function S1e(e3, t3) {\n              return t3 === 0 ? 0 : 1.57 * (e3.q3 - e3.q1) / Math.sqrt(t3);\n            }\n          });\n          var KI = ye((uur, L1e) => {\n            "use strict";\n            var E1e = ho(), M_t = Dr(), E_t = Nb().getAxisGroup, k1e = ["v", "h"];\n            function k_t(e3, t3) {\n              for (var r4 = e3.calcdata, n4 = t3.xaxis, i3 = t3.yaxis, a4 = 0; a4 < k1e.length; a4++) {\n                for (var o4 = k1e[a4], s3 = o4 === "h" ? i3 : n4, l3 = [], u4 = 0; u4 < r4.length; u4++) {\n                  var c5 = r4[u4], f4 = c5[0].t, h3 = c5[0].trace;\n                  h3.visible === true && (h3.type === "box" || h3.type === "candlestick") && !f4.empty && (h3.orientation || "v") === o4 && h3.xaxis === n4._id && h3.yaxis === i3._id && l3.push(u4);\n                }\n                C1e("box", e3, l3, s3);\n              }\n            }\n            function C1e(e3, t3, r4, n4) {\n              var i3 = t3.calcdata, a4 = t3._fullLayout, o4 = n4._id, s3 = o4.charAt(0), l3, u4, c5, f4 = [], h3 = 0;\n              for (l3 = 0; l3 < r4.length; l3++) for (c5 = i3[r4[l3]], u4 = 0; u4 < c5.length; u4++) f4.push(n4.c2l(c5[u4].pos, true)), h3 += (c5[u4].pts2 || []).length;\n              if (f4.length) {\n                var d3 = M_t.distinctVals(f4);\n                (n4.type === "category" || n4.type === "multicategory") && (d3.minDiff = 1);\n                var v3 = d3.minDiff / 2;\n                E1e.minDtick(n4, d3.minDiff, d3.vals[0], true);\n                var _2 = e3 === "violin" ? "_numViolins" : "_numBoxes", b = a4[_2], p3 = a4[e3 + "mode"] === "group" && b > 1, k4 = 1 - a4[e3 + "gap"], E3 = 1 - a4[e3 + "groupgap"];\n                for (l3 = 0; l3 < r4.length; l3++) {\n                  c5 = i3[r4[l3]];\n                  var S2 = c5[0].trace, L3 = c5[0].t, x2 = S2.width, C3 = S2.side, M4, g3, P3, T3;\n                  if (x2) M4 = g3 = T3 = x2 / 2, P3 = 0;\n                  else if (M4 = v3, p3) {\n                    var z3 = E_t(a4, n4._id) + S2.orientation, O3 = a4._alignmentOpts[z3] || {}, V2 = O3[S2.alignmentgroup] || {}, G2 = Object.keys(V2.offsetGroups || {}).length, Z = G2 || b, j3 = G2 ? S2._offsetIndex : L3.num;\n                    g3 = M4 * k4 * E3 / Z, P3 = 2 * M4 * (-0.5 + (j3 + 0.5) / Z) * k4, T3 = M4 * k4 / Z;\n                  } else g3 = M4 * k4 * E3, P3 = 0, T3 = M4;\n                  L3.dPos = M4, L3.bPos = P3, L3.bdPos = g3, L3.wHover = T3;\n                  var N2, H, te = P3 + g3, oe, _e, Ee, Ce, me, ie, Se = !!x2, Le = (S2.boxpoints || S2.points) && h3 > 0;\n                  if (C3 === "positive" ? (N2 = M4 * (x2 ? 1 : 0.5), oe = te, H = oe = P3) : C3 === "negative" ? (N2 = oe = P3, H = M4 * (x2 ? 1 : 0.5), _e = te) : (N2 = H = M4, oe = _e = te), Le) {\n                    var Ae = S2.pointpos, Fe = S2.jitter, Pe = S2.marker.size / 2, ge = 0;\n                    Ae + Fe >= 0 && (ge = te * (Ae + Fe), ge > N2 ? (Se = true, me = Pe, Ee = ge) : ge > oe && (me = Pe, Ee = N2)), ge <= N2 && (Ee = N2);\n                    var Re = 0;\n                    Ae - Fe <= 0 && (Re = -te * (Ae - Fe), Re > H ? (Se = true, ie = Pe, Ce = Re) : Re > _e && (ie = Pe, Ce = H)), Re <= H && (Ce = H);\n                  } else Ee = N2, Ce = H;\n                  var ce = new Array(c5.length);\n                  for (u4 = 0; u4 < c5.length; u4++) ce[u4] = c5[u4].pos;\n                  S2._extremes[o4] = E1e.findExtremes(n4, ce, { padded: Se, vpadminus: Ce, vpadplus: Ee, vpadLinearized: true, ppadminus: { x: ie, y: me }[s3], ppadplus: { x: me, y: ie }[s3] });\n                }\n              }\n            }\n            L1e.exports = { crossTraceCalc: k_t, setPositionOffset: C1e };\n          });\n          var JI = ye((cur, F1e) => {\n            "use strict";\n            var LT = Oa(), a22 = Dr(), C_t = So(), P1e = 5, L_t = 0.01;\n            function P_t(e3, t3, r4, n4) {\n              var i3 = e3._context.staticPlot, a4 = t3.xaxis, o4 = t3.yaxis;\n              a22.makeTraceGroups(n4, r4, "trace boxes").each(function(s3) {\n                var l3 = LT.select(this), u4 = s3[0], c5 = u4.t, f4 = u4.trace;\n                if (c5.wdPos = c5.bdPos * f4.whiskerwidth, f4.visible !== true || c5.empty) {\n                  l3.remove();\n                  return;\n                }\n                var h3, d3;\n                f4.orientation === "h" ? (h3 = o4, d3 = a4) : (h3 = a4, d3 = o4), I1e(l3, { pos: h3, val: d3 }, f4, c5, i3), R1e(l3, { x: a4, y: o4 }, f4, c5), D1e(l3, { pos: h3, val: d3 }, f4, c5);\n              });\n            }\n            function I1e(e3, t3, r4, n4, i3) {\n              var a4 = r4.orientation === "h", o4 = t3.val, s3 = t3.pos, l3 = !!s3.rangebreaks, u4 = n4.bPos, c5 = n4.wdPos || 0, f4 = n4.bPosPxOffset || 0, h3 = r4.whiskerwidth || 0, d3 = r4.showwhiskers !== false, v3 = r4.notched || false, _2 = v3 ? 1 - 2 * r4.notchwidth : 1, b, p3;\n              Array.isArray(n4.bdPos) ? (b = n4.bdPos[0], p3 = n4.bdPos[1]) : (b = n4.bdPos, p3 = n4.bdPos);\n              var k4 = e3.selectAll("path.box").data(r4.type !== "violin" || r4.box.visible ? a22.identity : []);\n              k4.enter().append("path").style("vector-effect", i3 ? "none" : "non-scaling-stroke").attr("class", "box"), k4.exit().remove(), k4.each(function(E3) {\n                if (E3.empty) return LT.select(this).attr("d", "M0,0Z");\n                var S2 = s3.c2l(E3.pos + u4, true), L3 = s3.l2p(S2 - b) + f4, x2 = s3.l2p(S2 + p3) + f4, C3 = l3 ? (L3 + x2) / 2 : s3.l2p(S2) + f4, M4 = r4.whiskerwidth, g3 = l3 ? L3 * M4 + (1 - M4) * C3 : s3.l2p(S2 - c5) + f4, P3 = l3 ? x2 * M4 + (1 - M4) * C3 : s3.l2p(S2 + c5) + f4, T3 = s3.l2p(S2 - b * _2) + f4, z3 = s3.l2p(S2 + p3 * _2) + f4, O3 = r4.sizemode === "sd", V2 = o4.c2p(O3 ? E3.mean - E3.sd : E3.q1, true), G2 = O3 ? o4.c2p(E3.mean + E3.sd, true) : o4.c2p(E3.q3, true), Z = a22.constrain(O3 ? o4.c2p(E3.mean, true) : o4.c2p(E3.med, true), Math.min(V2, G2) + 1, Math.max(V2, G2) - 1), j3 = E3.lf === void 0 || r4.boxpoints === false || O3, N2 = o4.c2p(j3 ? E3.min : E3.lf, true), H = o4.c2p(j3 ? E3.max : E3.uf, true), te = o4.c2p(E3.ln, true), oe = o4.c2p(E3.un, true);\n                a4 ? LT.select(this).attr("d", "M" + Z + "," + T3 + "V" + z3 + "M" + V2 + "," + L3 + "V" + x2 + (v3 ? "H" + te + "L" + Z + "," + z3 + "L" + oe + "," + x2 : "") + "H" + G2 + "V" + L3 + (v3 ? "H" + oe + "L" + Z + "," + T3 + "L" + te + "," + L3 : "") + "Z" + (d3 ? "M" + V2 + "," + C3 + "H" + N2 + "M" + G2 + "," + C3 + "H" + H + (h3 === 0 ? "" : "M" + N2 + "," + g3 + "V" + P3 + "M" + H + "," + g3 + "V" + P3) : "")) : LT.select(this).attr("d", "M" + T3 + "," + Z + "H" + z3 + "M" + L3 + "," + V2 + "H" + x2 + (v3 ? "V" + te + "L" + z3 + "," + Z + "L" + x2 + "," + oe : "") + "V" + G2 + "H" + L3 + (v3 ? "V" + oe + "L" + T3 + "," + Z + "L" + L3 + "," + te : "") + "Z" + (d3 ? "M" + C3 + "," + V2 + "V" + N2 + "M" + C3 + "," + G2 + "V" + H + (h3 === 0 ? "" : "M" + g3 + "," + N2 + "H" + P3 + "M" + g3 + "," + H + "H" + P3) : ""));\n              });\n            }\n            function R1e(e3, t3, r4, n4) {\n              var i3 = t3.x, a4 = t3.y, o4 = n4.bdPos, s3 = n4.bPos, l3 = r4.boxpoints || r4.points;\n              a22.seedPseudoRandom();\n              var u4 = function(h3) {\n                return h3.forEach(function(d3) {\n                  d3.t = n4, d3.trace = r4;\n                }), h3;\n              }, c5 = e3.selectAll("g.points").data(l3 ? u4 : []);\n              c5.enter().append("g").attr("class", "points"), c5.exit().remove();\n              var f4 = c5.selectAll("path").data(function(h3) {\n                var d3, v3 = h3.pts2, _2 = Math.max((h3.max - h3.min) / 10, h3.q3 - h3.q1), b = _2 * 1e-9, p3 = _2 * L_t, k4 = [], E3 = 0, S2;\n                if (r4.jitter) {\n                  if (_2 === 0) for (E3 = 1, k4 = new Array(v3.length), d3 = 0; d3 < v3.length; d3++) k4[d3] = 1;\n                  else for (d3 = 0; d3 < v3.length; d3++) {\n                    var L3 = Math.max(0, d3 - P1e), x2 = v3[L3].v, C3 = Math.min(v3.length - 1, d3 + P1e), M4 = v3[C3].v;\n                    l3 !== "all" && (v3[d3].v < h3.lf ? M4 = Math.min(M4, h3.lf) : x2 = Math.max(x2, h3.uf));\n                    var g3 = Math.sqrt(p3 * (C3 - L3) / (M4 - x2 + b)) || 0;\n                    g3 = a22.constrain(Math.abs(g3), 0, 1), k4.push(g3), E3 = Math.max(g3, E3);\n                  }\n                  S2 = r4.jitter * 2 / (E3 || 1);\n                }\n                for (d3 = 0; d3 < v3.length; d3++) {\n                  var P3 = v3[d3], T3 = P3.v, z3 = r4.jitter ? S2 * k4[d3] * (a22.pseudoRandom() - 0.5) : 0, O3 = h3.pos + s3 + o4 * (r4.pointpos + z3);\n                  r4.orientation === "h" ? (P3.y = O3, P3.x = T3) : (P3.x = O3, P3.y = T3), l3 === "suspectedoutliers" && T3 < h3.uo && T3 > h3.lo && (P3.so = true);\n                }\n                return v3;\n              });\n              f4.enter().append("path").classed("point", true), f4.exit().remove(), f4.call(C_t.translatePoints, i3, a4);\n            }\n            function D1e(e3, t3, r4, n4) {\n              var i3 = t3.val, a4 = t3.pos, o4 = !!a4.rangebreaks, s3 = n4.bPos, l3 = n4.bPosPxOffset || 0, u4 = r4.boxmean || (r4.meanline || {}).visible, c5, f4;\n              Array.isArray(n4.bdPos) ? (c5 = n4.bdPos[0], f4 = n4.bdPos[1]) : (c5 = n4.bdPos, f4 = n4.bdPos);\n              var h3 = e3.selectAll("path.mean").data(r4.type === "box" && r4.boxmean || r4.type === "violin" && r4.box.visible && r4.meanline.visible ? a22.identity : []);\n              h3.enter().append("path").attr("class", "mean").style({ fill: "none", "vector-effect": "non-scaling-stroke" }), h3.exit().remove(), h3.each(function(d3) {\n                var v3 = a4.c2l(d3.pos + s3, true), _2 = a4.l2p(v3 - c5) + l3, b = a4.l2p(v3 + f4) + l3, p3 = o4 ? (_2 + b) / 2 : a4.l2p(v3) + l3, k4 = i3.c2p(d3.mean, true), E3 = i3.c2p(d3.mean - d3.sd, true), S2 = i3.c2p(d3.mean + d3.sd, true);\n                r4.orientation === "h" ? LT.select(this).attr("d", "M" + k4 + "," + _2 + "V" + b + (u4 === "sd" ? "m0,0L" + E3 + "," + p3 + "L" + k4 + "," + _2 + "L" + S2 + "," + p3 + "Z" : "")) : LT.select(this).attr("d", "M" + _2 + "," + k4 + "H" + b + (u4 === "sd" ? "m0,0L" + p3 + "," + E3 + "L" + _2 + "," + k4 + "L" + p3 + "," + S2 + "Z" : ""));\n              });\n            }\n            F1e.exports = { plot: P_t, plotBoxAndWhiskers: I1e, plotPoints: R1e, plotBoxMean: D1e };\n          });\n          var $I = ye((fur, z1e) => {\n            "use strict";\n            var DV = Oa(), FV = ka(), zV = So();\n            function I_t(e3, t3, r4) {\n              var n4 = r4 || DV.select(e3).selectAll("g.trace.boxes");\n              n4.style("opacity", function(i3) {\n                return i3[0].trace.opacity;\n              }), n4.each(function(i3) {\n                var a4 = DV.select(this), o4 = i3[0].trace, s3 = o4.line.width;\n                function l3(f4, h3, d3, v3) {\n                  f4.style("stroke-width", h3 + "px").call(FV.stroke, d3).call(FV.fill, v3);\n                }\n                var u4 = a4.selectAll("path.box");\n                if (o4.type === "candlestick") u4.each(function(f4) {\n                  if (!f4.empty) {\n                    var h3 = DV.select(this), d3 = o4[f4.dir];\n                    l3(h3, d3.line.width, d3.line.color, d3.fillcolor), h3.style("opacity", o4.selectedpoints && !f4.selected ? 0.3 : 1);\n                  }\n                });\n                else {\n                  l3(u4, s3, o4.line.color, o4.fillcolor), a4.selectAll("path.mean").style({ "stroke-width": s3, "stroke-dasharray": 2 * s3 + "px," + s3 + "px" }).call(FV.stroke, o4.line.color);\n                  var c5 = a4.selectAll("path.point");\n                  zV.pointStyle(c5, o4, e3);\n                }\n              });\n            }\n            function R_t(e3, t3, r4) {\n              var n4 = t3[0].trace, i3 = r4.selectAll("path.point");\n              n4.selectedpoints ? zV.selectedPointStyle(i3, n4) : zV.pointStyle(i3, n4, e3);\n            }\n            z1e.exports = { style: I_t, styleOnSelect: R_t };\n          });\n          var qV = ye((hur, N1e) => {\n            "use strict";\n            var D_t = ho(), OV = Dr(), A_ = vf(), O1e = ka(), F_t = OV.fillText;\n            function z_t(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = i3[0].trace, o4 = a4.hoveron, s3 = [], l3;\n              return o4.indexOf("boxes") !== -1 && (s3 = s3.concat(q1e(e3, t3, r4, n4))), o4.indexOf("points") !== -1 && (l3 = B1e(e3, t3, r4)), n4 === "closest" ? l3 ? [l3] : s3 : (l3 && s3.push(l3), s3);\n            }\n            function q1e(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = e3.xa, o4 = e3.ya, s3 = i3[0].trace, l3 = i3[0].t, u4 = s3.type === "violin", c5, f4, h3, d3, v3, _2, b, p3, k4, E3, S2, L3 = l3.bdPos, x2, C3, M4 = l3.wHover, g3 = function(Pe) {\n                return h3.c2l(Pe.pos) + l3.bPos - h3.c2l(_2);\n              };\n              u4 && s3.side !== "both" ? (s3.side === "positive" && (k4 = function(Pe) {\n                var ge = g3(Pe);\n                return A_.inbox(ge, ge + M4, E3);\n              }, x2 = L3, C3 = 0), s3.side === "negative" && (k4 = function(Pe) {\n                var ge = g3(Pe);\n                return A_.inbox(ge - M4, ge, E3);\n              }, x2 = 0, C3 = L3)) : (k4 = function(Pe) {\n                var ge = g3(Pe);\n                return A_.inbox(ge - M4, ge + M4, E3);\n              }, x2 = C3 = L3);\n              var P3;\n              u4 ? P3 = function(Pe) {\n                return A_.inbox(Pe.span[0] - v3, Pe.span[1] - v3, E3);\n              } : P3 = function(Pe) {\n                return A_.inbox(Pe.min - v3, Pe.max - v3, E3);\n              }, s3.orientation === "h" ? (v3 = t3, _2 = r4, b = P3, p3 = k4, c5 = "y", h3 = o4, f4 = "x", d3 = a4) : (v3 = r4, _2 = t3, b = k4, p3 = P3, c5 = "x", h3 = a4, f4 = "y", d3 = o4);\n              var T3 = Math.min(1, L3 / Math.abs(h3.r2c(h3.range[1]) - h3.r2c(h3.range[0])));\n              E3 = e3.maxHoverDistance - T3, S2 = e3.maxSpikeDistance - T3;\n              function z3(Pe) {\n                return (b(Pe) + p3(Pe)) / 2;\n              }\n              var O3 = A_.getDistanceFunction(n4, b, p3, z3);\n              if (A_.getClosest(i3, O3, e3), e3.index === false) return [];\n              var V2 = i3[e3.index], G2 = s3.line.color, Z = (s3.marker || {}).color;\n              O1e.opacity(G2) && s3.line.width ? e3.color = G2 : O1e.opacity(Z) && s3.boxpoints ? e3.color = Z : e3.color = s3.fillcolor, e3[c5 + "0"] = h3.c2p(V2.pos + l3.bPos - C3, true), e3[c5 + "1"] = h3.c2p(V2.pos + l3.bPos + x2, true), e3[c5 + "LabelVal"] = V2.orig_p !== void 0 ? V2.orig_p : V2.pos;\n              var j3 = c5 + "Spike";\n              e3.spikeDistance = z3(V2) * S2 / E3, e3[j3] = h3.c2p(V2.pos, true);\n              var N2 = s3.boxmean || s3.sizemode === "sd" || (s3.meanline || {}).visible, H = s3.boxpoints || s3.points, te = H && N2 ? ["max", "uf", "q3", "med", "mean", "q1", "lf", "min"] : H && !N2 ? ["max", "uf", "q3", "med", "q1", "lf", "min"] : !H && N2 ? ["max", "q3", "med", "mean", "q1", "min"] : ["max", "q3", "med", "q1", "min"], oe = d3.range[1] < d3.range[0];\n              s3.orientation === (oe ? "v" : "h") && te.reverse();\n              for (var _e = e3.spikeDistance, Ee = e3[j3], Ce = [], me = 0; me < te.length; me++) {\n                var ie = te[me];\n                if (ie in V2) {\n                  var Se = V2[ie], Le = d3.c2p(Se, true), Ae = OV.extendFlat({}, e3);\n                  Ae.attr = ie, Ae[f4 + "0"] = Ae[f4 + "1"] = Le, Ae[f4 + "LabelVal"] = Se, Ae[f4 + "Label"] = (l3.labels ? l3.labels[ie] + " " : "") + D_t.hoverLabelText(d3, Se, s3[f4 + "hoverformat"]), Ae.hoverOnBox = true, ie === "mean" && "sd" in V2 && (s3.boxmean === "sd" || s3.sizemode === "sd") && (Ae[f4 + "err"] = V2.sd), Ae.hovertemplate = false, Ce.push(Ae);\n                }\n              }\n              e3.name = "", e3.spikeDistance = void 0, e3[j3] = void 0;\n              for (var Fe = 0; Fe < Ce.length; Fe++) Ce[Fe].attr !== "med" ? (Ce[Fe].name = "", Ce[Fe].spikeDistance = void 0, Ce[Fe][j3] = void 0) : (Ce[Fe].spikeDistance = _e, Ce[Fe][j3] = Ee);\n              return Ce;\n            }\n            function B1e(e3, t3, r4) {\n              for (var n4 = e3.cd, i3 = e3.xa, a4 = e3.ya, o4 = n4[0].trace, s3 = i3.c2p(t3), l3 = a4.c2p(r4), u4, c5 = function(P3) {\n                var T3 = Math.max(3, P3.mrc || 0);\n                return Math.max(Math.abs(i3.c2p(P3.x) - s3) - T3, 1 - 3 / T3);\n              }, f4 = function(P3) {\n                var T3 = Math.max(3, P3.mrc || 0);\n                return Math.max(Math.abs(a4.c2p(P3.y) - l3) - T3, 1 - 3 / T3);\n              }, h3 = A_.quadrature(c5, f4), d3 = false, v3, _2, b = 0; b < n4.length; b++) {\n                v3 = n4[b];\n                for (var p3 = 0; p3 < (v3.pts || []).length; p3++) {\n                  _2 = v3.pts[p3];\n                  var k4 = h3(_2);\n                  k4 <= e3.distance && (e3.distance = k4, d3 = [b, p3]);\n                }\n              }\n              if (!d3) return false;\n              v3 = n4[d3[0]], _2 = v3.pts[d3[1]];\n              var E3 = i3.c2p(_2.x, true), S2 = a4.c2p(_2.y, true), L3 = _2.mrc || 1;\n              u4 = OV.extendFlat({}, e3, { index: _2.i, color: (o4.marker || {}).color, name: o4.name, x0: E3 - L3, x1: E3 + L3, y0: S2 - L3, y1: S2 + L3, spikeDistance: e3.distance, hovertemplate: o4.hovertemplate });\n              var x2 = v3.orig_p, C3 = x2 !== void 0 ? x2 : v3.pos, M4;\n              o4.orientation === "h" ? (M4 = a4, u4.xLabelVal = _2.x, u4.yLabelVal = C3) : (M4 = i3, u4.xLabelVal = C3, u4.yLabelVal = _2.y);\n              var g3 = M4._id.charAt(0);\n              return u4[g3 + "Spike"] = M4.c2p(v3.pos, true), F_t(_2, o4, u4), u4;\n            }\n            N1e.exports = { hoverPoints: z_t, hoverOnBoxes: q1e, hoverOnPoints: B1e };\n          });\n          var V1e = ye((dur, U1e) => {\n            "use strict";\n            U1e.exports = function(t3, r4) {\n              return r4.hoverOnBox && (t3.hoverOnBox = r4.hoverOnBox), "xVal" in r4 && (t3.x = r4.xVal), "yVal" in r4 && (t3.y = r4.yVal), r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), t3;\n            };\n          });\n          var BV = ye((vur, G1e) => {\n            "use strict";\n            G1e.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3, l3;\n              if (r4 === false) for (s3 = 0; s3 < n4.length; s3++) for (l3 = 0; l3 < (n4[s3].pts || []).length; l3++) n4[s3].pts[l3].selected = 0;\n              else for (s3 = 0; s3 < n4.length; s3++) for (l3 = 0; l3 < (n4[s3].pts || []).length; l3++) {\n                var u4 = n4[s3].pts[l3], c5 = i3.c2p(u4.x), f4 = a4.c2p(u4.y);\n                r4.contains([c5, f4], null, u4.i, t3) ? (o4.push({ pointNumber: u4.i, x: i3.c2d(u4.x), y: a4.c2d(u4.y) }), u4.selected = 1) : u4.selected = 0;\n              }\n              return o4;\n            };\n          });\n          var j1e = ye((pur, H1e) => {\n            "use strict";\n            H1e.exports = { attributes: x4(), layoutAttributes: b4(), supplyDefaults: T4().supplyDefaults, crossTraceDefaults: T4().crossTraceDefaults, supplyLayoutDefaults: ZI().supplyLayoutDefaults, calc: RV(), crossTraceCalc: KI().crossTraceCalc, plot: JI().plot, style: $I().style, styleOnSelect: $I().styleOnSelect, hoverPoints: qV().hoverPoints, eventData: V1e(), selectPoints: BV(), moduleType: "trace", name: "box", basePlotModule: ph(), categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "boxLayout", "zoomScale"], meta: {} };\n          });\n          var X1e = ye((gur, W1e) => {\n            "use strict";\n            W1e.exports = j1e();\n          });\n          var PT = ye((mur, Y1e) => {\n            "use strict";\n            var O_t = Tu(), { extendFlat: Pp } = Ao(), q_t = Gl(), { axisHoverFormat: NV } = df(), B_t = ec(), { hovertemplateAttrs: N_t, templatefallbackAttrs: Z1e, texttemplateAttrs: U_t } = Ll(), n0 = pf();\n            Y1e.exports = Pp({ z: { valType: "data_array", editType: "calc" }, x: Pp({}, n0.x, { impliedEdits: { xtype: "array" } }), x0: Pp({}, n0.x0, { impliedEdits: { xtype: "scaled" } }), dx: Pp({}, n0.dx, { impliedEdits: { xtype: "scaled" } }), y: Pp({}, n0.y, { impliedEdits: { ytype: "array" } }), y0: Pp({}, n0.y0, { impliedEdits: { ytype: "scaled" } }), dy: Pp({}, n0.dy, { impliedEdits: { ytype: "scaled" } }), xperiod: Pp({}, n0.xperiod, { impliedEdits: { xtype: "scaled" } }), yperiod: Pp({}, n0.yperiod, { impliedEdits: { ytype: "scaled" } }), xperiod0: Pp({}, n0.xperiod0, { impliedEdits: { xtype: "scaled" } }), yperiod0: Pp({}, n0.yperiod0, { impliedEdits: { ytype: "scaled" } }), xperiodalignment: Pp({}, n0.xperiodalignment, { impliedEdits: { xtype: "scaled" } }), yperiodalignment: Pp({}, n0.yperiodalignment, { impliedEdits: { ytype: "scaled" } }), text: { valType: "data_array", editType: "calc" }, hovertext: { valType: "data_array", editType: "calc" }, transpose: { valType: "boolean", dflt: false, editType: "calc" }, xtype: { valType: "enumerated", values: ["array", "scaled"], editType: "calc+clearAxisTypes" }, ytype: { valType: "enumerated", values: ["array", "scaled"], editType: "calc+clearAxisTypes" }, zsmooth: { valType: "enumerated", values: ["fast", "best", false], dflt: false, editType: "calc" }, hoverongaps: { valType: "boolean", dflt: true, editType: "none" }, connectgaps: { valType: "boolean", editType: "calc" }, xgap: { valType: "number", dflt: 0, min: 0, editType: "plot" }, ygap: { valType: "number", dflt: 0, min: 0, editType: "plot" }, xhoverformat: NV("x"), yhoverformat: NV("y"), zhoverformat: NV("z", 1), hovertemplate: N_t(), hovertemplatefallback: Z1e(), texttemplate: U_t({ arrayOk: false, editType: "plot" }, { keys: ["x", "y", "z", "text"] }), texttemplatefallback: Z1e({ editType: "plot" }), textfont: B_t({ editType: "plot", autoSize: true, autoColor: true, colorEditType: "style" }), showlegend: Pp({}, q_t.showlegend, { dflt: false }), zorder: n0.zorder }, O_t("", { cLetter: "z", autoColorDflt: false }));\n          });\n          var e8 = ye((yur, J1e) => {\n            "use strict";\n            var V_t = Eo(), QI = Dr(), G_t = qa();\n            J1e.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = n4("z");\n              a4 = a4 || "x", o4 = o4 || "y";\n              var l3, u4;\n              if (s3 === void 0 || !s3.length) return 0;\n              if (QI.isArray1D(s3)) {\n                l3 = n4(a4), u4 = n4(o4);\n                var c5 = QI.minRowLength(l3), f4 = QI.minRowLength(u4);\n                if (c5 === 0 || f4 === 0) return 0;\n                r4._length = Math.min(c5, f4, s3.length);\n              } else {\n                if (l3 = K1e(a4, n4), u4 = K1e(o4, n4), !H_t(s3)) return 0;\n                n4("transpose"), r4._length = null;\n              }\n              var h3 = G_t.getComponentMethod("calendars", "handleTraceDefaults");\n              return h3(t3, r4, [a4, o4], i3), true;\n            };\n            function K1e(e3, t3) {\n              var r4 = t3(e3), n4 = r4 ? t3(e3 + "type", "array") : "scaled";\n              return n4 === "scaled" && (t3(e3 + "0"), t3("d" + e3)), r4;\n            }\n            function H_t(e3) {\n              for (var t3 = true, r4 = false, n4 = false, i3, a4 = 0; a4 < e3.length; a4++) {\n                if (i3 = e3[a4], !QI.isArrayOrTypedArray(i3)) {\n                  t3 = false;\n                  break;\n                }\n                i3.length > 0 && (r4 = true);\n                for (var o4 = 0; o4 < i3.length; o4++) if (V_t(i3[o4])) {\n                  n4 = true;\n                  break;\n                }\n              }\n              return t3 && r4 && n4;\n            }\n          });\n          var A4 = ye((_ur, Q1e) => {\n            "use strict";\n            var $1e = Dr();\n            Q1e.exports = function(t3, r4) {\n              t3("texttemplate"), t3("texttemplatefallback");\n              var n4 = $1e.extendFlat({}, r4.font, { color: "auto", size: "auto" });\n              $1e.coerceFont(t3, "textfont", n4);\n            };\n          });\n          var UV = ye((xur, e_e) => {\n            "use strict";\n            e_e.exports = function(t3, r4, n4) {\n              var i3 = n4("zsmooth");\n              i3 === false && (n4("xgap"), n4("ygap")), n4("zhoverformat");\n            };\n          });\n          var i_e = ye((bur, r_e) => {\n            "use strict";\n            var t_e = Dr(), j_t = e8(), W_t = A4(), X_t = Ig(), Z_t = UV(), Y_t = Qh(), K_t = PT();\n            r_e.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return t_e.coerce(t3, r4, K_t, s3, l3);\n              }\n              var o4 = j_t(t3, r4, a4, i3);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              X_t(t3, r4, i3, a4), a4("xhoverformat"), a4("yhoverformat"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), W_t(a4, i3), Z_t(t3, r4, a4, i3), a4("hoverongaps"), a4("connectgaps", t_e.isArray1D(r4.z) && r4.zsmooth !== false), Y_t(t3, r4, i3, a4, { prefix: "", cLetter: "z" }), a4("zorder");\n            };\n          });\n          var VV = ye((wur, n_e) => {\n            "use strict";\n            var IT = Eo();\n            n_e.exports = { count: function(e3, t3, r4) {\n              return r4[e3]++, 1;\n            }, sum: function(e3, t3, r4, n4) {\n              var i3 = n4[t3];\n              return IT(i3) ? (i3 = Number(i3), r4[e3] += i3, i3) : 0;\n            }, avg: function(e3, t3, r4, n4, i3) {\n              var a4 = n4[t3];\n              return IT(a4) && (a4 = Number(a4), r4[e3] += a4, i3[e3]++), 0;\n            }, min: function(e3, t3, r4, n4) {\n              var i3 = n4[t3];\n              if (IT(i3)) if (i3 = Number(i3), IT(r4[e3])) {\n                if (r4[e3] > i3) {\n                  var a4 = i3 - r4[e3];\n                  return r4[e3] = i3, a4;\n                }\n              } else return r4[e3] = i3, i3;\n              return 0;\n            }, max: function(e3, t3, r4, n4) {\n              var i3 = n4[t3];\n              if (IT(i3)) if (i3 = Number(i3), IT(r4[e3])) {\n                if (r4[e3] < i3) {\n                  var a4 = i3 - r4[e3];\n                  return r4[e3] = i3, a4;\n                }\n              } else return r4[e3] = i3, i3;\n              return 0;\n            } };\n          });\n          var GV = ye((Tur, a_e) => {\n            "use strict";\n            a_e.exports = { percent: function(e3, t3) {\n              for (var r4 = e3.length, n4 = 100 / t3, i3 = 0; i3 < r4; i3++) e3[i3] *= n4;\n            }, probability: function(e3, t3) {\n              for (var r4 = e3.length, n4 = 0; n4 < r4; n4++) e3[n4] /= t3;\n            }, density: function(e3, t3, r4, n4) {\n              var i3 = e3.length;\n              n4 = n4 || 1;\n              for (var a4 = 0; a4 < i3; a4++) e3[a4] *= r4[a4] * n4;\n            }, "probability density": function(e3, t3, r4, n4) {\n              var i3 = e3.length;\n              n4 && (t3 /= n4);\n              for (var a4 = 0; a4 < i3; a4++) e3[a4] *= r4[a4] / t3;\n            } };\n          });\n          var HV = ye((Aur, o_e) => {\n            "use strict";\n            o_e.exports = function(t3, r4) {\n              for (var n4 = t3.length, i3 = 0, a4 = 0; a4 < n4; a4++) r4[a4] ? (t3[a4] /= r4[a4], i3 += t3[a4]) : t3[a4] = null;\n              return i3;\n            };\n          });\n          var jV = ye((Sur, v_e) => {\n            "use strict";\n            var RT = fs(), o22 = RT.ONEAVGYEAR, s_e = RT.ONEAVGMONTH, r8 = RT.ONEDAY, l_e = RT.ONEHOUR, u_e = RT.ONEMIN, c_e = RT.ONESEC, f_e = ho().tickIncrement;\n            v_e.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = -1.1 * r4, s3 = -0.1 * r4, l3 = t3 - s3, u4 = n4[0], c5 = n4[1], f4 = Math.min(t8(u4 + s3, u4 + l3, i3, a4), t8(c5 + s3, c5 + l3, i3, a4)), h3 = Math.min(t8(u4 + o4, u4 + s3, i3, a4), t8(c5 + o4, c5 + s3, i3, a4)), d3, v3;\n              if (f4 > h3 && h3 < Math.abs(c5 - u4) / 4e3 ? (d3 = f4, v3 = false) : (d3 = Math.min(f4, h3), v3 = true), i3.type === "date" && d3 > r8) {\n                var _2 = d3 === o22 ? 1 : 6, b = d3 === o22 ? "M12" : "M1";\n                return function(p3, k4) {\n                  var E3 = i3.c2d(p3, o22, a4), S2 = E3.indexOf("-", _2);\n                  S2 > 0 && (E3 = E3.slice(0, S2));\n                  var L3 = i3.d2c(E3, 0, a4);\n                  if (L3 < p3) {\n                    var x2 = f_e(L3, b, false, a4);\n                    (L3 + x2) / 2 < p3 + t3 && (L3 = x2);\n                  }\n                  return k4 && v3 ? f_e(L3, b, true, a4) : L3;\n                };\n              }\n              return function(p3, k4) {\n                var E3 = d3 * Math.round(p3 / d3);\n                return E3 + d3 / 10 < p3 && E3 + d3 * 0.9 < p3 + t3 && (E3 += d3), k4 && v3 && (E3 -= d3), E3;\n              };\n            };\n            function t8(e3, t3, r4, n4) {\n              if (e3 * t3 <= 0) return 1 / 0;\n              for (var i3 = Math.abs(t3 - e3), a4 = r4.type === "date", o4 = h_e(i3, a4), s3 = 0; s3 < 10; s3++) {\n                var l3 = h_e(o4 * 80, a4);\n                if (o4 === l3) break;\n                if (J_t(l3, e3, t3, a4, r4, n4)) o4 = l3;\n                else break;\n              }\n              return o4;\n            }\n            function h_e(e3, t3) {\n              return t3 && e3 > c_e ? e3 > r8 ? e3 > o22 * 1.1 ? o22 : e3 > s_e * 1.1 ? s_e : r8 : e3 > l_e ? l_e : e3 > u_e ? u_e : c_e : Math.pow(10, Math.floor(Math.log(e3) / Math.LN10));\n            }\n            function J_t(e3, t3, r4, n4, i3, a4) {\n              if (n4 && e3 > r8) {\n                var o4 = d_e(t3, i3, a4), s3 = d_e(r4, i3, a4), l3 = e3 === o22 ? 0 : 1;\n                return o4[l3] !== s3[l3];\n              }\n              return Math.floor(r4 / e3) - Math.floor(t3 / e3) > 0.1;\n            }\n            function d_e(e3, t3, r4) {\n              var n4 = t3.c2d(e3, o22, r4).split("-");\n              return n4[0] === "" && (n4.unshift(), n4[0] = "-" + n4[0]), n4;\n            }\n          });\n          var ZV = ye((Mur, __e) => {\n            "use strict";\n            var WV = Eo(), Hv = Dr(), p_e = qa(), G0 = ho(), { hasColorscale: g_e } = pv(), m_e = gv(), $_t = g4(), y_e = VV(), Q_t = GV(), ext = HV(), txt = jV();\n            function rxt(e3, t3) {\n              var r4 = [], n4 = [], i3 = t3.orientation === "h", a4 = G0.getFromId(e3, i3 ? t3.yaxis : t3.xaxis), o4 = i3 ? "y" : "x", s3 = { x: "y", y: "x" }[o4], l3 = t3[o4 + "calendar"], u4 = t3.cumulative, c5, f4 = XV(e3, t3, a4, o4), h3 = f4[0], d3 = f4[1], v3 = typeof h3.size == "string", _2 = [], b = v3 ? _2 : h3, p3 = [], k4 = [], E3 = [], S2 = 0, L3 = t3.histnorm, x2 = t3.histfunc, C3 = L3.indexOf("density") !== -1, M4, g3, P3;\n              u4.enabled && C3 && (L3 = L3.replace(/ ?density$/, ""), C3 = false);\n              var T3 = x2 === "max" || x2 === "min", z3 = T3 ? null : 0, O3 = y_e.count, V2 = Q_t[L3], G2 = false, Z = function(ge) {\n                return a4.r2c(ge, 0, l3);\n              }, j3;\n              for (Hv.isArrayOrTypedArray(t3[s3]) && x2 !== "count" && (j3 = t3[s3], G2 = x2 === "avg", O3 = y_e[x2]), c5 = Z(h3.start), g3 = Z(h3.end) + (c5 - G0.tickIncrement(c5, h3.size, false, l3)) / 1e6; c5 < g3 && r4.length < 1e6 && (M4 = G0.tickIncrement(c5, h3.size, false, l3), r4.push((c5 + M4) / 2), n4.push(z3), E3.push([]), _2.push(c5), C3 && p3.push(1 / (M4 - c5)), G2 && k4.push(0), !(M4 <= c5)); ) c5 = M4;\n              _2.push(c5), !v3 && a4.type === "date" && (b = { start: Z(b.start), end: Z(b.end), size: b.size }), e3._fullLayout._roundFnOpts || (e3._fullLayout._roundFnOpts = {});\n              var N2 = t3["_" + o4 + "bingroup"], H = { leftGap: 1 / 0, rightGap: 1 / 0 };\n              N2 && (e3._fullLayout._roundFnOpts[N2] || (e3._fullLayout._roundFnOpts[N2] = H), H = e3._fullLayout._roundFnOpts[N2]);\n              var te = n4.length, oe = true, _e = H.leftGap, Ee = H.rightGap, Ce = {};\n              for (c5 = 0; c5 < d3.length; c5++) {\n                var me = d3[c5];\n                P3 = Hv.findBin(me, b), P3 >= 0 && P3 < te && (S2 += O3(P3, c5, n4, j3, k4), oe && E3[P3].length && me !== d3[E3[P3][0]] && (oe = false), E3[P3].push(c5), Ce[c5] = P3, _e = Math.min(_e, me - _2[P3]), Ee = Math.min(Ee, _2[P3 + 1] - me));\n              }\n              H.leftGap = _e, H.rightGap = Ee;\n              var ie;\n              oe || (ie = function(ge, Re) {\n                return function() {\n                  var ce = e3._fullLayout._roundFnOpts[N2];\n                  return txt(ce.leftGap, ce.rightGap, _2, a4, l3)(ge, Re);\n                };\n              }), G2 && (S2 = ext(n4, k4)), V2 && V2(n4, S2, p3), u4.enabled && axt(n4, u4.direction, u4.currentbin);\n              var Se = Math.min(r4.length, n4.length), Le = [], Ae = 0, Fe = Se - 1;\n              for (c5 = 0; c5 < Se; c5++) if (n4[c5]) {\n                Ae = c5;\n                break;\n              }\n              for (c5 = Se - 1; c5 >= Ae; c5--) if (n4[c5]) {\n                Fe = c5;\n                break;\n              }\n              for (c5 = Ae; c5 <= Fe; c5++) if (WV(r4[c5]) && WV(n4[c5])) {\n                var Pe = { p: r4[c5], s: n4[c5], b: 0 };\n                u4.enabled || (Pe.pts = E3[c5], oe ? Pe.ph0 = Pe.ph1 = E3[c5].length ? d3[E3[c5][0]] : r4[c5] : (t3._computePh = true, Pe.ph0 = ie(_2[c5]), Pe.ph1 = ie(_2[c5 + 1], true))), Le.push(Pe);\n              }\n              return Le.length === 1 && (Le[0].width1 = G0.tickIncrement(Le[0].p, h3.size, false, l3) - Le[0].p), g_e(t3, "marker") && m_e(e3, t3, { vals: t3.marker.color, containerStr: "marker", cLetter: "c" }), g_e(t3, "marker.line") && m_e(e3, t3, { vals: t3.marker.line.color, containerStr: "marker.line", cLetter: "c" }), $_t(Le, t3), Hv.isArrayOrTypedArray(t3.selectedpoints) && Hv.tagSelected(Le, t3, Ce), Le;\n            }\n            function XV(e3, t3, r4, n4, i3) {\n              var a4 = n4 + "bins", o4 = e3._fullLayout, s3 = t3["_" + n4 + "bingroup"], l3 = o4._histogramBinOpts[s3], u4 = o4.barmode === "overlay", c5, f4, h3, d3, v3, _2, b, p3 = function(me) {\n                return r4.r2c(me, 0, d3);\n              }, k4 = function(me) {\n                return r4.c2r(me, 0, d3);\n              }, E3 = r4.type === "date" ? function(me) {\n                return me || me === 0 ? Hv.cleanDate(me, null, d3) : null;\n              } : function(me) {\n                return WV(me) ? Number(me) : null;\n              };\n              function S2(me, ie, Se) {\n                ie[me + "Found"] ? (ie[me] = E3(ie[me]), ie[me] === null && (ie[me] = Se[me])) : (_2[me] = ie[me] = Se[me], Hv.nestedProperty(f4[0], a4 + "." + me).set(Se[me]));\n              }\n              if (t3["_" + n4 + "autoBinFinished"]) delete t3["_" + n4 + "autoBinFinished"];\n              else {\n                f4 = l3.traces;\n                var L3 = [], x2 = true, C3 = false, M4 = false;\n                for (c5 = 0; c5 < f4.length; c5++) if (h3 = f4[c5], h3.visible) {\n                  var g3 = l3.dirs[c5];\n                  v3 = h3["_" + g3 + "pos0"] = r4.makeCalcdata(h3, g3), L3 = Hv.concat(L3, v3), delete h3["_" + n4 + "autoBinFinished"], t3.visible === true && (x2 ? x2 = false : (delete h3._autoBin, h3["_" + n4 + "autoBinFinished"] = 1), p_e.traceIs(h3, "2dMap") && (C3 = true), h3.type === "histogram2dcontour" && (M4 = true));\n                }\n                d3 = f4[0][n4 + "calendar"];\n                var P3 = G0.autoBin(L3, r4, l3.nbins, C3, d3, l3.sizeFound && l3.size), T3 = f4[0]._autoBin = {};\n                if (_2 = T3[l3.dirs[0]] = {}, M4 && (l3.size || (P3.start = k4(G0.tickIncrement(p3(P3.start), P3.size, true, d3))), l3.end === void 0 && (P3.end = k4(G0.tickIncrement(p3(P3.end), P3.size, false, d3)))), u4 && !p_e.traceIs(t3, "2dMap") && P3._dataSpan === 0 && r4.type !== "category" && r4.type !== "multicategory" && t3.bingroup === "" && typeof t3.xbins == "undefined") {\n                  if (i3) return [P3, v3, true];\n                  P3 = ixt(e3, t3, r4, n4, a4);\n                }\n                b = h3.cumulative || {}, b.enabled && b.currentbin !== "include" && (b.direction === "decreasing" ? P3.start = k4(G0.tickIncrement(p3(P3.start), P3.size, true, d3)) : P3.end = k4(G0.tickIncrement(p3(P3.end), P3.size, false, d3))), l3.size = P3.size, l3.sizeFound || (_2.size = P3.size, Hv.nestedProperty(f4[0], a4 + ".size").set(P3.size)), S2("start", l3, P3), S2("end", l3, P3);\n              }\n              v3 = t3["_" + n4 + "pos0"], delete t3["_" + n4 + "pos0"];\n              var z3 = t3._input[a4] || {}, O3 = Hv.extendFlat({}, l3), V2 = l3.start, G2 = r4.r2l(z3.start), Z = G2 !== void 0;\n              if ((l3.startFound || Z) && G2 !== r4.r2l(V2)) {\n                var j3 = Z ? G2 : Hv.aggNums(Math.min, null, v3), N2 = { type: r4.type === "category" || r4.type === "multicategory" ? "linear" : r4.type, r2l: r4.r2l, dtick: l3.size, tick0: V2, calendar: d3, range: [j3, G0.tickIncrement(j3, l3.size, false, d3)].map(r4.l2r) }, H = G0.tickFirst(N2);\n                H > r4.r2l(j3) && (H = G0.tickIncrement(H, l3.size, true, d3)), O3.start = r4.l2r(H), Z || Hv.nestedProperty(t3, a4 + ".start").set(O3.start);\n              }\n              var te = l3.end, oe = r4.r2l(z3.end), _e = oe !== void 0;\n              if ((l3.endFound || _e) && oe !== r4.r2l(te)) {\n                var Ee = _e ? oe : Hv.aggNums(Math.max, null, v3);\n                O3.end = r4.l2r(Ee), _e || Hv.nestedProperty(t3, a4 + ".start").set(O3.end);\n              }\n              var Ce = "autobin" + n4;\n              return t3._input[Ce] === false && (t3._input[a4] = Hv.extendFlat({}, t3[a4] || {}), delete t3._input[Ce], delete t3[Ce]), [O3, v3];\n            }\n            function ixt(e3, t3, r4, n4, i3) {\n              var a4 = e3._fullLayout, o4 = nxt(e3, t3), s3 = false, l3 = 1 / 0, u4 = [t3], c5, f4, h3;\n              for (c5 = 0; c5 < o4.length; c5++) if (f4 = o4[c5], f4 === t3) s3 = true;\n              else if (!s3) h3 = a4._histogramBinOpts[f4["_" + n4 + "bingroup"]], l3 = Math.min(l3, h3.size || f4[i3].size);\n              else {\n                var d3 = XV(e3, f4, r4, n4, true), v3 = d3[0], _2 = d3[2];\n                f4["_" + n4 + "autoBinFinished"] = 1, f4["_" + n4 + "pos0"] = d3[1], _2 ? u4.push(f4) : l3 = Math.min(l3, v3.size);\n              }\n              var b = new Array(u4.length);\n              for (c5 = 0; c5 < u4.length; c5++) for (var p3 = u4[c5]["_" + n4 + "pos0"], k4 = 0; k4 < p3.length; k4++) if (p3[k4] !== void 0) {\n                b[c5] = p3[k4];\n                break;\n              }\n              for (isFinite(l3) || (l3 = Hv.distinctVals(b).minDiff), c5 = 0; c5 < u4.length; c5++) {\n                f4 = u4[c5];\n                var E3 = f4[n4 + "calendar"], S2 = { start: r4.c2r(b[c5] - l3 / 2, 0, E3), end: r4.c2r(b[c5] + l3 / 2, 0, E3), size: l3 };\n                f4._input[i3] = f4[i3] = S2, h3 = a4._histogramBinOpts[f4["_" + n4 + "bingroup"]], h3 && Hv.extendFlat(h3, S2);\n              }\n              return t3[i3];\n            }\n            function nxt(e3, t3) {\n              for (var r4 = t3.xaxis, n4 = t3.yaxis, i3 = t3.orientation, a4 = [], o4 = e3._fullData, s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3];\n                l3.type === "histogram" && l3.visible === true && l3.orientation === i3 && l3.xaxis === r4 && l3.yaxis === n4 && a4.push(l3);\n              }\n              return a4;\n            }\n            function axt(e3, t3, r4) {\n              var n4, i3, a4;\n              function o4(l3) {\n                a4 = e3[l3], e3[l3] /= 2;\n              }\n              function s3(l3) {\n                i3 = e3[l3], e3[l3] = a4 + i3 / 2, a4 += i3;\n              }\n              if (r4 === "half") if (t3 === "increasing") for (o4(0), n4 = 1; n4 < e3.length; n4++) s3(n4);\n              else for (o4(e3.length - 1), n4 = e3.length - 2; n4 >= 0; n4--) s3(n4);\n              else if (t3 === "increasing") {\n                for (n4 = 1; n4 < e3.length; n4++) e3[n4] += e3[n4 - 1];\n                r4 === "exclude" && (e3.unshift(0), e3.pop());\n              } else {\n                for (n4 = e3.length - 2; n4 >= 0; n4--) e3[n4] += e3[n4 + 1];\n                r4 === "exclude" && (e3.push(0), e3.shift());\n              }\n            }\n            __e.exports = { calc: rxt, calcAllAutoBins: XV };\n          });\n          var E_e = ye((Eur, M_e) => {\n            "use strict";\n            var x_e = Dr(), DT = ho(), b_e = VV(), oxt = GV(), sxt = HV(), lxt = jV(), w_e = ZV().calcAllAutoBins;\n            M_e.exports = function(t3, r4) {\n              var n4 = DT.getFromId(t3, r4.xaxis), i3 = DT.getFromId(t3, r4.yaxis), a4 = r4.xcalendar, o4 = r4.ycalendar, s3 = function(It) {\n                return n4.r2c(It, 0, a4);\n              }, l3 = function(It) {\n                return i3.r2c(It, 0, o4);\n              }, u4 = function(It) {\n                return n4.c2r(It, 0, a4);\n              }, c5 = function(It) {\n                return i3.c2r(It, 0, o4);\n              }, f4, h3, d3, v3, _2 = w_e(t3, r4, n4, "x"), b = _2[0], p3 = _2[1], k4 = w_e(t3, r4, i3, "y"), E3 = k4[0], S2 = k4[1], L3 = r4._length;\n              p3.length > L3 && p3.splice(L3, p3.length - L3), S2.length > L3 && S2.splice(L3, S2.length - L3);\n              var x2 = [], C3 = [], M4 = [], g3 = typeof b.size == "string", P3 = typeof E3.size == "string", T3 = [], z3 = [], O3 = g3 ? T3 : b, V2 = P3 ? z3 : E3, G2 = 0, Z = [], j3 = [], N2 = r4.histnorm, H = r4.histfunc, te = N2.indexOf("density") !== -1, oe = H === "max" || H === "min", _e = oe ? null : 0, Ee = b_e.count, Ce = oxt[N2], me = false, ie = [], Se = [], Le = "z" in r4 ? r4.z : "marker" in r4 && Array.isArray(r4.marker.color) ? r4.marker.color : "";\n              Le && H !== "count" && (me = H === "avg", Ee = b_e[H]);\n              var Ae = b.size, Fe = s3(b.start), Pe = s3(b.end) + (Fe - DT.tickIncrement(Fe, Ae, false, a4)) / 1e6;\n              for (f4 = Fe; f4 < Pe; f4 = DT.tickIncrement(f4, Ae, false, a4)) C3.push(_e), T3.push(f4), me && M4.push(0);\n              T3.push(f4);\n              var ge = C3.length, Re = (f4 - Fe) / ge, ce = u4(Fe + Re / 2), Ze = E3.size, ut = l3(E3.start), pt = l3(E3.end) + (ut - DT.tickIncrement(ut, Ze, false, o4)) / 1e6;\n              for (f4 = ut; f4 < pt; f4 = DT.tickIncrement(f4, Ze, false, o4)) {\n                x2.push(C3.slice()), z3.push(f4);\n                var Zt = new Array(ge);\n                for (h3 = 0; h3 < ge; h3++) Zt[h3] = [];\n                j3.push(Zt), me && Z.push(M4.slice());\n              }\n              z3.push(f4);\n              var st = x2.length, lt = (f4 - ut) / st, Gt = c5(ut + lt / 2);\n              te && (ie = T_e(C3.length, O3, Re, g3), Se = T_e(x2.length, V2, lt, P3)), !g3 && n4.type === "date" && (O3 = A_e(s3, O3)), !P3 && i3.type === "date" && (V2 = A_e(l3, V2));\n              var Nt = true, Jt = true, sr = new Array(ge), wr = new Array(st), cr = 1 / 0, $e = 1 / 0, St = 1 / 0, Qt = 1 / 0;\n              for (f4 = 0; f4 < L3; f4++) {\n                var Vt = p3[f4], _t = S2[f4];\n                d3 = x_e.findBin(Vt, O3), v3 = x_e.findBin(_t, V2), d3 >= 0 && d3 < ge && v3 >= 0 && v3 < st && (G2 += Ee(d3, f4, x2[v3], Le, Z[v3]), j3[v3][d3].push(f4), Nt && (sr[d3] === void 0 ? sr[d3] = Vt : sr[d3] !== Vt && (Nt = false)), Jt && (wr[v3] === void 0 ? wr[v3] = _t : wr[v3] !== _t && (Jt = false)), cr = Math.min(cr, Vt - T3[d3]), $e = Math.min($e, T3[d3 + 1] - Vt), St = Math.min(St, _t - z3[v3]), Qt = Math.min(Qt, z3[v3 + 1] - _t));\n              }\n              if (me) for (v3 = 0; v3 < st; v3++) G2 += sxt(x2[v3], Z[v3]);\n              if (Ce) for (v3 = 0; v3 < st; v3++) Ce(x2[v3], G2, ie, Se[v3]);\n              return { x: p3, xRanges: S_e(T3, Nt && sr, cr, $e, n4, a4), x0: ce, dx: Re, y: S2, yRanges: S_e(z3, Jt && wr, St, Qt, i3, o4), y0: Gt, dy: lt, z: x2, pts: j3 };\n            };\n            function T_e(e3, t3, r4, n4) {\n              var i3 = new Array(e3), a4;\n              if (n4) for (a4 = 0; a4 < e3; a4++) i3[a4] = 1 / (t3[a4 + 1] - t3[a4]);\n              else {\n                var o4 = 1 / r4;\n                for (a4 = 0; a4 < e3; a4++) i3[a4] = o4;\n              }\n              return i3;\n            }\n            function A_e(e3, t3) {\n              return { start: e3(t3.start), end: e3(t3.end), size: t3.size };\n            }\n            function S_e(e3, t3, r4, n4, i3, a4) {\n              var o4, s3 = e3.length - 1, l3 = new Array(s3), u4 = lxt(r4, n4, e3, i3, a4);\n              for (o4 = 0; o4 < s3; o4++) {\n                var c5 = (t3 || [])[o4];\n                l3[o4] = c5 === void 0 ? [u4(e3[o4]), u4(e3[o4 + 1], true)] : [c5, c5];\n              }\n              return l3;\n            }\n          });\n          var i8 = ye((kur, L_e) => {\n            "use strict";\n            var Im = Dr(), k_e = fs().BADNUM, C_e = Dg();\n            L_e.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = t3._length, l3 = r4.makeCalcdata(t3, i3), u4 = n4.makeCalcdata(t3, a4);\n              l3 = C_e(t3, r4, i3, l3).vals, u4 = C_e(t3, n4, a4, u4).vals;\n              var c5 = t3.text, f4 = c5 !== void 0 && Im.isArray1D(c5), h3 = t3.hovertext, d3 = h3 !== void 0 && Im.isArray1D(h3), v3, _2, b = Im.distinctVals(l3), p3 = b.vals, k4 = Im.distinctVals(u4), E3 = k4.vals, S2 = [], L3, x2, C3 = E3.length, M4 = p3.length;\n              for (v3 = 0; v3 < o4.length; v3++) S2[v3] = Im.init2dArray(C3, M4);\n              f4 && (L3 = Im.init2dArray(C3, M4)), d3 && (x2 = Im.init2dArray(C3, M4));\n              var g3 = Im.init2dArray(C3, M4);\n              for (v3 = 0; v3 < s3; v3++) if (l3[v3] !== k_e && u4[v3] !== k_e) {\n                var P3 = Im.findBin(l3[v3] + b.minDiff / 2, p3), T3 = Im.findBin(u4[v3] + k4.minDiff / 2, E3);\n                for (_2 = 0; _2 < o4.length; _2++) {\n                  var z3 = o4[_2], O3 = t3[z3], V2 = S2[_2];\n                  V2[T3][P3] = O3[v3], g3[T3][P3] = v3;\n                }\n                f4 && (L3[T3][P3] = c5[v3]), d3 && (x2[T3][P3] = h3[v3]);\n              }\n              for (t3["_" + i3] = p3, t3["_" + a4] = E3, _2 = 0; _2 < o4.length; _2++) t3["_" + o4[_2]] = S2[_2];\n              f4 && (t3._text = L3), d3 && (t3._hovertext = x2), r4 && r4.type === "category" && (t3["_" + i3 + "CategoryMap"] = p3.map(function(G2) {\n                return r4._categories[G2];\n              })), n4 && n4.type === "category" && (t3["_" + a4 + "CategoryMap"] = E3.map(function(G2) {\n                return n4._categories[G2];\n              })), t3._after2before = g3;\n            };\n          });\n          var a8 = ye((Cur, P_e) => {\n            "use strict";\n            var uxt = Eo(), cxt = Dr(), n8 = fs().BADNUM;\n            P_e.exports = function(t3, r4, n4, i3) {\n              var a4, o4, s3, l3, u4, c5;\n              function f4(p3) {\n                if (uxt(p3)) return +p3;\n              }\n              if (r4 && r4.transpose) {\n                for (a4 = 0, u4 = 0; u4 < t3.length; u4++) a4 = Math.max(a4, t3[u4].length);\n                if (a4 === 0) return false;\n                s3 = function(p3) {\n                  return p3.length;\n                }, l3 = function(p3, k4, E3) {\n                  return (p3[E3] || [])[k4];\n                };\n              } else a4 = t3.length, s3 = function(p3, k4) {\n                return p3[k4].length;\n              }, l3 = function(p3, k4, E3) {\n                return (p3[k4] || [])[E3];\n              };\n              var h3 = function(p3, k4, E3) {\n                return k4 === n8 || E3 === n8 ? n8 : l3(p3, k4, E3);\n              };\n              function d3(p3) {\n                if (r4 && r4.type !== "carpet" && r4.type !== "contourcarpet" && p3 && p3.type === "category" && r4["_" + p3._id.charAt(0)].length) {\n                  var k4 = p3._id.charAt(0), E3 = {}, S2 = r4["_" + k4 + "CategoryMap"] || r4[k4];\n                  for (u4 = 0; u4 < S2.length; u4++) E3[S2[u4]] = u4;\n                  return function(L3) {\n                    var x2 = E3[p3._categories[L3]];\n                    return x2 + 1 ? x2 : n8;\n                  };\n                } else return cxt.identity;\n              }\n              var v3 = d3(n4), _2 = d3(i3);\n              i3 && i3.type === "category" && (a4 = i3._categories.length);\n              var b = new Array(a4);\n              for (u4 = 0; u4 < a4; u4++) for (n4 && n4.type === "category" ? o4 = n4._categories.length : o4 = s3(t3, u4), b[u4] = new Array(o4), c5 = 0; c5 < o4; c5++) b[u4][c5] = f4(h3(t3, _2(u4), v3(c5)));\n              return b;\n            };\n          });\n          var o8 = ye((Lur, D_e) => {\n            "use strict";\n            var fxt = Dr(), I_e = 0.01, hxt = [[-1, 0], [1, 0], [0, -1], [0, 1]];\n            function dxt(e3) {\n              return 0.5 - 0.25 * Math.min(1, e3 * 0.5);\n            }\n            D_e.exports = function(t3, r4) {\n              var n4 = 1, i3;\n              for (R_e(t3, r4), i3 = 0; i3 < r4.length && !(r4[i3][2] < 4); i3++) ;\n              for (r4 = r4.slice(i3), i3 = 0; i3 < 100 && n4 > I_e; i3++) n4 = R_e(t3, r4, dxt(n4));\n              return n4 > I_e && fxt.log("interp2d didn\'t converge quickly", n4), t3;\n            };\n            function R_e(e3, t3, r4) {\n              var n4 = 0, i3, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3, _2, b;\n              for (s3 = 0; s3 < t3.length; s3++) {\n                for (i3 = t3[s3], a4 = i3[0], o4 = i3[1], v3 = e3[a4][o4], d3 = 0, h3 = 0, l3 = 0; l3 < 4; l3++) u4 = hxt[l3], c5 = e3[a4 + u4[0]], c5 && (f4 = c5[o4 + u4[1]], f4 !== void 0 && (d3 === 0 ? _2 = b = f4 : (_2 = Math.min(_2, f4), b = Math.max(b, f4)), h3++, d3 += f4));\n                if (h3 === 0) throw "iterateInterp2d order is wrong: no defined neighbors";\n                e3[a4][o4] = d3 / h3, v3 === void 0 ? h3 < 4 && (n4 = 1) : (e3[a4][o4] = (1 + r4) * e3[a4][o4] - r4 * v3, b > _2 && (n4 = Math.max(n4, Math.abs(e3[a4][o4] - v3) / (b - _2))));\n              }\n              return n4;\n            }\n          });\n          var s8 = ye((Pur, F_e) => {\n            "use strict";\n            var vxt = Dr().maxRowLength;\n            F_e.exports = function(t3) {\n              var r4 = [], n4 = {}, i3 = [], a4 = t3[0], o4 = [], s3 = [0, 0, 0], l3 = vxt(t3), u4, c5, f4, h3, d3, v3, _2, b;\n              for (c5 = 0; c5 < t3.length; c5++) for (u4 = o4, o4 = a4, a4 = t3[c5 + 1] || [], f4 = 0; f4 < l3; f4++) o4[f4] === void 0 && (v3 = (o4[f4 - 1] !== void 0 ? 1 : 0) + (o4[f4 + 1] !== void 0 ? 1 : 0) + (u4[f4] !== void 0 ? 1 : 0) + (a4[f4] !== void 0 ? 1 : 0), v3 ? (c5 === 0 && v3++, f4 === 0 && v3++, c5 === t3.length - 1 && v3++, f4 === o4.length - 1 && v3++, v3 < 4 && (n4[[c5, f4]] = [c5, f4, v3]), r4.push([c5, f4, v3])) : i3.push([c5, f4]));\n              for (; i3.length; ) {\n                for (_2 = {}, b = false, d3 = i3.length - 1; d3 >= 0; d3--) h3 = i3[d3], c5 = h3[0], f4 = h3[1], v3 = ((n4[[c5 - 1, f4]] || s3)[2] + (n4[[c5 + 1, f4]] || s3)[2] + (n4[[c5, f4 - 1]] || s3)[2] + (n4[[c5, f4 + 1]] || s3)[2]) / 20, v3 && (_2[h3] = [c5, f4, v3], i3.splice(d3, 1), b = true);\n                if (!b) throw "findEmpties iterated with no new neighbors";\n                for (h3 in _2) n4[h3] = _2[h3], r4.push(_2[h3]);\n              }\n              return r4.sort(function(p3, k4) {\n                return k4[2] - p3[2];\n              });\n            };\n          });\n          var YV = ye((Iur, q_e) => {\n            "use strict";\n            var z_e = qa(), O_e = Dr().isArrayOrTypedArray;\n            q_e.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = [], l3 = z_e.traceIs(t3, "contour"), u4 = z_e.traceIs(t3, "histogram"), c5, f4, h3, d3 = O_e(r4) && r4.length > 1;\n              if (d3 && !u4 && o4.type !== "category") {\n                var v3 = r4.length;\n                if (v3 <= a4) {\n                  if (l3) s3 = Array.from(r4).slice(0, a4);\n                  else if (a4 === 1) o4.type === "log" ? s3 = [0.5 * r4[0], 2 * r4[0]] : s3 = [r4[0] - 0.5, r4[0] + 0.5];\n                  else if (o4.type === "log") {\n                    for (s3 = [Math.pow(r4[0], 1.5) / Math.pow(r4[1], 0.5)], h3 = 1; h3 < v3; h3++) s3.push(Math.sqrt(r4[h3 - 1] * r4[h3]));\n                    s3.push(Math.pow(r4[v3 - 1], 1.5) / Math.pow(r4[v3 - 2], 0.5));\n                  } else {\n                    for (s3 = [1.5 * r4[0] - 0.5 * r4[1]], h3 = 1; h3 < v3; h3++) s3.push((r4[h3 - 1] + r4[h3]) * 0.5);\n                    s3.push(1.5 * r4[v3 - 1] - 0.5 * r4[v3 - 2]);\n                  }\n                  if (v3 < a4) {\n                    var _2 = s3[s3.length - 1], b;\n                    if (o4.type === "log") for (b = _2 / s3[s3.length - 2], h3 = v3; h3 < a4; h3++) _2 *= b, s3.push(_2);\n                    else for (b = _2 - s3[s3.length - 2], h3 = v3; h3 < a4; h3++) _2 += b, s3.push(_2);\n                  }\n                } else return l3 ? r4.slice(0, a4) : r4.slice(0, a4 + 1);\n              } else {\n                var p3 = t3[o4._id.charAt(0) + "calendar"];\n                if (u4) c5 = o4.r2c(n4, 0, p3);\n                else if (O_e(r4) && r4.length === 1) c5 = r4[0];\n                else if (n4 === void 0) c5 = 0;\n                else {\n                  var k4 = o4.type === "log" ? o4.d2c : o4.r2c;\n                  c5 = k4(n4, 0, p3);\n                }\n                for (f4 = i3 || 1, h3 = l3 ? 0 : -0.5; h3 < a4; h3++) s3.push(c5 + f4 * h3);\n              }\n              return s3;\n            };\n          });\n          var c8 = ye((Rur, V_e) => {\n            "use strict";\n            var B_e = qa(), KV = Dr(), l8 = ho(), N_e = Dg(), pxt = E_e(), gxt = gv(), mxt = i8(), yxt = a8(), _xt = o8(), xxt = s8(), u8 = YV(), JV = fs().BADNUM;\n            V_e.exports = function(t3, r4) {\n              var n4 = l8.getFromId(t3, r4.xaxis || "x"), i3 = l8.getFromId(t3, r4.yaxis || "y"), a4 = B_e.traceIs(r4, "contour"), o4 = B_e.traceIs(r4, "histogram"), s3 = a4 ? "best" : r4.zsmooth, l3, u4, c5, f4, h3, d3, v3, _2, b, p3, k4;\n              if (n4._minDtick = 0, i3._minDtick = 0, o4) k4 = pxt(t3, r4), f4 = k4.orig_x, l3 = k4.x, u4 = k4.x0, c5 = k4.dx, _2 = k4.orig_y, h3 = k4.y, d3 = k4.y0, v3 = k4.dy, b = k4.z;\n              else {\n                var E3 = r4.z;\n                KV.isArray1D(E3) ? (mxt(r4, n4, i3, "x", "y", ["z"]), l3 = r4._x, h3 = r4._y, E3 = r4._z) : (f4 = r4.x ? n4.makeCalcdata(r4, "x") : [], _2 = r4.y ? i3.makeCalcdata(r4, "y") : [], l3 = N_e(r4, n4, "x", f4).vals, h3 = N_e(r4, i3, "y", _2).vals, r4._x = l3, r4._y = h3), u4 = r4.x0, c5 = r4.dx, d3 = r4.y0, v3 = r4.dy, b = yxt(E3, r4, n4, i3);\n              }\n              (n4.rangebreaks || i3.rangebreaks) && (b = bxt(l3, h3, b), o4 || (l3 = U_e(l3), h3 = U_e(h3), r4._x = l3, r4._y = h3)), !o4 && (a4 || r4.connectgaps) && (r4._emptypoints = xxt(b), _xt(b, r4._emptypoints));\n              function S2(O3) {\n                s3 = r4._input.zsmooth = r4.zsmooth = false, KV.warn(\'cannot use zsmooth: "fast": \' + O3);\n              }\n              function L3(O3) {\n                if (O3.length > 1) {\n                  var V2 = (O3[O3.length - 1] - O3[0]) / (O3.length - 1), G2 = Math.abs(V2 / 100);\n                  for (p3 = 0; p3 < O3.length - 1; p3++) if (Math.abs(O3[p3 + 1] - O3[p3] - V2) > G2) return false;\n                }\n                return true;\n              }\n              r4._islinear = false, n4.type === "log" || i3.type === "log" ? s3 === "fast" && S2("log axis found") : L3(l3) ? L3(h3) ? r4._islinear = true : s3 === "fast" && S2("y scale is not linear") : s3 === "fast" && S2("x scale is not linear");\n              var x2 = KV.maxRowLength(b), C3 = r4.xtype === "scaled" ? "" : l3, M4 = u8(r4, C3, u4, c5, x2, n4), g3 = r4.ytype === "scaled" ? "" : h3, P3 = u8(r4, g3, d3, v3, b.length, i3);\n              r4._extremes[n4._id] = l8.findExtremes(n4, M4), r4._extremes[i3._id] = l8.findExtremes(i3, P3);\n              var T3 = { x: M4, y: P3, z: b, text: r4._text || r4.text, hovertext: r4._hovertext || r4.hovertext };\n              if (r4.xperiodalignment && f4 && (T3.orig_x = f4), r4.yperiodalignment && _2 && (T3.orig_y = _2), C3 && C3.length === M4.length - 1 && (T3.xCenter = C3), g3 && g3.length === P3.length - 1 && (T3.yCenter = g3), o4 && (T3.xRanges = k4.xRanges, T3.yRanges = k4.yRanges, T3.pts = k4.pts), a4 || gxt(t3, r4, { vals: b, cLetter: "z" }), a4 && r4.contours && r4.contours.coloring === "heatmap") {\n                var z3 = { type: r4.type === "contour" ? "heatmap" : "histogram2d", xcalendar: r4.xcalendar, ycalendar: r4.ycalendar };\n                T3.xfill = u8(z3, C3, u4, c5, x2, n4), T3.yfill = u8(z3, g3, d3, v3, b.length, i3);\n              }\n              return [T3];\n            };\n            function U_e(e3) {\n              for (var t3 = [], r4 = e3.length, n4 = 0; n4 < r4; n4++) {\n                var i3 = e3[n4];\n                i3 !== JV && t3.push(i3);\n              }\n              return t3;\n            }\n            function bxt(e3, t3, r4) {\n              for (var n4 = [], i3 = -1, a4 = 0; a4 < r4.length; a4++) if (t3[a4] !== JV) {\n                i3++, n4[i3] = [];\n                for (var o4 = 0; o4 < r4[a4].length; o4++) e3[o4] !== JV && n4[i3].push(r4[a4][o4]);\n              }\n              return n4;\n            }\n          });\n          var h8 = ye((f8) => {\n            "use strict";\n            f8.CSS_DECLARATIONS = [["image-rendering", "optimizeSpeed"], ["image-rendering", "-moz-crisp-edges"], ["image-rendering", "-o-crisp-edges"], ["image-rendering", "-webkit-optimize-contrast"], ["image-rendering", "optimize-contrast"], ["image-rendering", "crisp-edges"], ["image-rendering", "pixelated"]];\n            f8.STYLE = f8.CSS_DECLARATIONS.map(function(e3) {\n              return e3.join(": ") + "; ";\n            }).join("");\n          });\n          var QV = ye((Fur, H_e) => {\n            "use strict";\n            var G_e = h8(), wxt = So(), $V = Dr(), FT = null;\n            function Txt() {\n              if (FT !== null) return FT;\n              FT = false;\n              var e3 = $V.isSafari() || $V.isMacWKWebView() || $V.isIOS();\n              if (window.navigator.userAgent && !e3) {\n                var t3 = Array.from(G_e.CSS_DECLARATIONS).reverse(), r4 = window.CSS && window.CSS.supports || window.supportsCSS;\n                if (typeof r4 == "function") FT = t3.some(function(o4) {\n                  return r4.apply(null, o4);\n                });\n                else {\n                  var n4 = wxt.tester.append("image").attr("style", G_e.STYLE), i3 = window.getComputedStyle(n4.node()), a4 = i3.imageRendering;\n                  FT = t3.some(function(o4) {\n                    var s3 = o4[1];\n                    return a4 === s3 || a4 === s3.toLowerCase();\n                  }), n4.remove();\n                }\n              }\n              return FT;\n            }\n            H_e.exports = Txt;\n          });\n          var d8 = ye((zur, Q_e) => {\n            "use strict";\n            var j_e = Oa(), Axt = cd(), Sxt = qa(), Mxt = So(), Ext = ho(), H0 = Dr(), W_e = ru(), kxt = nI(), Cxt = ka(), Lxt = tc().extractOpts, Pxt = tc().makeColorScaleFuncFromTrace, Ixt = Wp(), Rxt = $h(), eG = Rxt.LINE_SPACING, Dxt = QV(), Fxt = h8().STYLE, J_e = "heatmap-label";\n            function $_e(e3) {\n              return e3.selectAll("g." + J_e);\n            }\n            function X_e(e3) {\n              $_e(e3).remove();\n            }\n            Q_e.exports = function(e3, t3, r4, n4) {\n              var i3 = t3.xaxis, a4 = t3.yaxis;\n              H0.makeTraceGroups(n4, r4, "hm").each(function(o4) {\n                var s3 = j_e.select(this), l3 = o4[0], u4 = l3.trace, c5 = u4.xgap || 0, f4 = u4.ygap || 0, h3 = l3.z, d3 = l3.x, v3 = l3.y, _2 = l3.xCenter, b = l3.yCenter, p3 = Sxt.traceIs(u4, "contour"), k4 = p3 ? "best" : u4.zsmooth, E3 = h3.length, S2 = H0.maxRowLength(h3), L3 = false, x2 = false, C3, M4, g3, P3, T3, z3, O3, V2;\n                for (z3 = 0; C3 === void 0 && z3 < d3.length - 1; ) C3 = i3.c2p(d3[z3]), z3++;\n                for (z3 = d3.length - 1; M4 === void 0 && z3 > 0; ) M4 = i3.c2p(d3[z3]), z3--;\n                for (M4 < C3 && (g3 = M4, M4 = C3, C3 = g3, L3 = true), z3 = 0; P3 === void 0 && z3 < v3.length - 1; ) P3 = a4.c2p(v3[z3]), z3++;\n                for (z3 = v3.length - 1; T3 === void 0 && z3 > 0; ) T3 = a4.c2p(v3[z3]), z3--;\n                T3 < P3 && (g3 = P3, P3 = T3, T3 = g3, x2 = true), p3 && (_2 = d3, b = v3, d3 = l3.xfill, v3 = l3.yfill);\n                var G2 = "default";\n                if (k4 ? G2 = k4 === "best" ? "smooth" : "fast" : u4._islinear && c5 === 0 && f4 === 0 && Dxt() && (G2 = "fast"), G2 !== "fast") {\n                  var Z = k4 === "best" ? 0 : 0.5;\n                  C3 = Math.max(-Z * i3._length, C3), M4 = Math.min((1 + Z) * i3._length, M4), P3 = Math.max(-Z * a4._length, P3), T3 = Math.min((1 + Z) * a4._length, T3);\n                }\n                var j3 = Math.round(M4 - C3), N2 = Math.round(T3 - P3), H = C3 >= i3._length || M4 <= 0 || P3 >= a4._length || T3 <= 0;\n                if (H) {\n                  var te = s3.selectAll("image").data([]);\n                  te.exit().remove(), X_e(s3);\n                  return;\n                }\n                var oe, _e;\n                G2 === "fast" ? (oe = S2, _e = E3) : (oe = j3, _e = N2);\n                var Ee = document.createElement("canvas");\n                Ee.width = oe, Ee.height = _e;\n                var Ce = Ee.getContext("2d", { willReadFrequently: true }), me = Pxt(u4, { noNumericCheck: true, returnArray: true }), ie, Se;\n                G2 === "fast" ? (ie = L3 ? function(fn) {\n                  return S2 - 1 - fn;\n                } : H0.identity, Se = x2 ? function(fn) {\n                  return E3 - 1 - fn;\n                } : H0.identity) : (ie = function(fn) {\n                  return H0.constrain(Math.round(i3.c2p(d3[fn]) - C3), 0, j3);\n                }, Se = function(fn) {\n                  return H0.constrain(Math.round(a4.c2p(v3[fn]) - P3), 0, N2);\n                });\n                var Le = Se(0), Ae = [Le, Le], Fe = L3 ? 0 : 1, Pe = x2 ? 0 : 1, ge = 0, Re = 0, ce = 0, Ze = 0, ut, pt, Zt, st, lt;\n                function Gt(fn, yn) {\n                  if (fn !== void 0) {\n                    var Sn = me(fn);\n                    return Sn[0] = Math.round(Sn[0]), Sn[1] = Math.round(Sn[1]), Sn[2] = Math.round(Sn[2]), ge += yn, Re += Sn[0] * yn, ce += Sn[1] * yn, Ze += Sn[2] * yn, Sn;\n                  }\n                  return [0, 0, 0, 0];\n                }\n                function Nt(fn, yn, Sn, Ba) {\n                  var ua = fn[Sn.bin0];\n                  if (ua === void 0) return Gt(void 0, 1);\n                  var ma = fn[Sn.bin1], Wa = yn[Sn.bin0], Fa = yn[Sn.bin1], Wo = ma - ua || 0, da = Wa - ua || 0, Wn;\n                  return ma === void 0 ? Fa === void 0 ? Wn = 0 : Wa === void 0 ? Wn = 2 * (Fa - ua) : Wn = (2 * Fa - Wa - ua) * 2 / 3 : Fa === void 0 ? Wa === void 0 ? Wn = 0 : Wn = (2 * ua - ma - Wa) * 2 / 3 : Wa === void 0 ? Wn = (2 * Fa - ma - ua) * 2 / 3 : Wn = Fa + ua - ma - Wa, Gt(ua + Sn.frac * Wo + Ba.frac * (da + Sn.frac * Wn));\n                }\n                if (G2 !== "default") {\n                  var Jt = 0, sr;\n                  try {\n                    sr = new Uint8Array(oe * _e * 4);\n                  } catch (fn) {\n                    sr = new Array(oe * _e * 4);\n                  }\n                  if (G2 === "smooth") {\n                    var wr = _2 || d3, cr = b || v3, $e = new Array(wr.length), St = new Array(cr.length), Qt = new Array(j3), Vt = _2 ? Y_e : Z_e, _t = b ? Y_e : Z_e, It, mt, er;\n                    for (z3 = 0; z3 < wr.length; z3++) $e[z3] = Math.round(i3.c2p(wr[z3]) - C3);\n                    for (z3 = 0; z3 < cr.length; z3++) St[z3] = Math.round(a4.c2p(cr[z3]) - P3);\n                    for (z3 = 0; z3 < j3; z3++) Qt[z3] = Vt(z3, $e);\n                    for (O3 = 0; O3 < N2; O3++) for (It = _t(O3, St), mt = h3[It.bin0], er = h3[It.bin1], z3 = 0; z3 < j3; z3++, Jt += 4) lt = Nt(mt, er, Qt[z3], It), K_e(sr, Jt, lt);\n                  } else for (O3 = 0; O3 < E3; O3++) for (st = h3[O3], Ae = Se(O3), z3 = 0; z3 < S2; z3++) lt = Gt(st[z3], 1), Jt = (Ae * S2 + ie(z3)) * 4, K_e(sr, Jt, lt);\n                  var lr = Ce.createImageData(oe, _e);\n                  try {\n                    lr.data.set(sr);\n                  } catch (fn) {\n                    var Tr = lr.data, Lr = Tr.length;\n                    for (O3 = 0; O3 < Lr; O3++) Tr[O3] = sr[O3];\n                  }\n                  Ce.putImageData(lr, 0, 0);\n                } else {\n                  var ti = Math.floor(c5 / 2), Br = Math.floor(f4 / 2);\n                  for (O3 = 0; O3 < E3; O3++) if (st = h3[O3], Ae.reverse(), Ae[Pe] = Se(O3 + 1), !(Ae[0] === Ae[1] || Ae[0] === void 0 || Ae[1] === void 0)) for (pt = ie(0), ut = [pt, pt], z3 = 0; z3 < S2; z3++) ut.reverse(), ut[Fe] = ie(z3 + 1), !(ut[0] === ut[1] || ut[0] === void 0 || ut[1] === void 0) && (Zt = st[z3], lt = Gt(Zt, (ut[1] - ut[0]) * (Ae[1] - Ae[0])), Ce.fillStyle = "rgba(" + lt.join(",") + ")", Ce.fillRect(ut[0] + ti, Ae[0] + Br, ut[1] - ut[0] - c5, Ae[1] - Ae[0] - f4));\n                }\n                Re = Math.round(Re / ge), ce = Math.round(ce / ge), Ze = Math.round(Ze / ge);\n                var Vr = Axt("rgb(" + Re + "," + ce + "," + Ze + ")");\n                e3._hmpixcount = (e3._hmpixcount || 0) + ge, e3._hmlumcount = (e3._hmlumcount || 0) + ge * Vr.getLuminance();\n                var dt = s3.selectAll("image").data(o4);\n                dt.enter().append("svg:image").attr({ xmlns: Ixt.svg, preserveAspectRatio: "none" }), dt.attr({ height: N2, width: j3, x: C3, y: P3, "xlink:href": Ee.toDataURL("image/png") }), G2 === "fast" && !k4 && dt.attr("style", Fxt), X_e(s3);\n                var Ge = u4.texttemplate;\n                if (Ge) {\n                  var Je = Lxt(u4), je = { type: "linear", range: [Je.min, Je.max], _separators: i3._separators, _numFormat: i3._numFormat }, tt = u4.type === "histogram2dcontour", xt = u4.type === "contour", Ie = xt ? 1 : 0, xe = xt ? E3 - 1 : E3, ke = xt ? 1 : 0, vt = xt ? S2 - 1 : S2, ir = [];\n                  for (z3 = Ie; z3 < xe; z3++) {\n                    var ar;\n                    if (xt) ar = l3.y[z3];\n                    else if (tt) {\n                      if (z3 === 0 || z3 === E3 - 1) continue;\n                      ar = l3.y[z3];\n                    } else if (l3.yCenter) ar = l3.yCenter[z3];\n                    else {\n                      if (z3 + 1 === E3 && l3.y[z3 + 1] === void 0) continue;\n                      ar = (l3.y[z3] + l3.y[z3 + 1]) / 2;\n                    }\n                    var vr = Math.round(a4.c2p(ar));\n                    if (!(0 > vr || vr > a4._length)) for (O3 = ke; O3 < vt; O3++) {\n                      var ii;\n                      if (xt) ii = l3.x[O3];\n                      else if (tt) {\n                        if (O3 === 0 || O3 === S2 - 1) continue;\n                        ii = l3.x[O3];\n                      } else if (l3.xCenter) ii = l3.xCenter[O3];\n                      else {\n                        if (O3 + 1 === S2 && l3.x[O3 + 1] === void 0) continue;\n                        ii = (l3.x[O3] + l3.x[O3 + 1]) / 2;\n                      }\n                      var pi = Math.round(i3.c2p(ii));\n                      if (!(0 > pi || pi > i3._length)) {\n                        var $r = kxt({ x: ii, y: ar }, u4, e3._fullLayout);\n                        $r.x = ii, $r.y = ar;\n                        var di = l3.z[z3][O3];\n                        di === void 0 ? ($r.z = "", $r.zLabel = "") : ($r.z = di, $r.zLabel = Ext.tickText(je, di, "hover").text);\n                        var ji = l3.text && l3.text[z3] && l3.text[z3][O3];\n                        (ji === void 0 || ji === false) && (ji = ""), $r.text = ji;\n                        var In = H0.texttemplateString({ data: [$r, u4._meta], fallback: u4.texttemplatefallback, labels: $r, locale: e3._fullLayout._d3locale, template: Ge });\n                        if (In) {\n                          var wi = In.split("<br>"), On = wi.length, qn = 0;\n                          for (V2 = 0; V2 < On; V2++) qn = Math.max(qn, wi[V2].length);\n                          ir.push({ l: On, c: qn, t: In, x: pi, y: vr, z: di });\n                        }\n                      }\n                    }\n                  }\n                  var Fn = u4.textfont, ra = Fn.size, la = e3._fullLayout.font.size;\n                  if (!ra || ra === "auto") {\n                    var Ut = 1 / 0, wt = 1 / 0, rr = 0, nr = 0;\n                    for (V2 = 0; V2 < ir.length; V2++) {\n                      var Er = ir[V2];\n                      if (rr = Math.max(rr, Er.l), nr = Math.max(nr, Er.c), V2 < ir.length - 1) {\n                        var Xr = ir[V2 + 1], ri = Math.abs(Xr.x - Er.x), Qr = Math.abs(Xr.y - Er.y);\n                        ri && (Ut = Math.min(Ut, ri)), Qr && (wt = Math.min(wt, Qr));\n                      }\n                    }\n                    !isFinite(Ut) || !isFinite(wt) ? ra = la : (Ut -= c5, wt -= f4, Ut /= nr, wt /= rr, Ut /= eG / 2, wt /= eG, ra = Math.min(Math.floor(Ut), Math.floor(wt), la));\n                  }\n                  if (ra <= 0 || !isFinite(ra)) return;\n                  var Oi = function(fn) {\n                    return fn.x;\n                  }, $i = function(fn) {\n                    return fn.y - ra * (fn.l * eG / 2 - 1);\n                  }, tn = $_e(s3).data(ir);\n                  tn.enter().append("g").classed(J_e, 1).append("text").attr("text-anchor", "middle").each(function(fn) {\n                    var yn = j_e.select(this), Sn = Fn.color;\n                    (!Sn || Sn === "auto") && (Sn = Cxt.contrast(fn.z === void 0 ? e3._fullLayout.plot_bgcolor : "rgba(" + me(fn.z).join() + ")")), yn.attr("data-notex", 1).call(W_e.positionText, Oi(fn), $i(fn)).call(Mxt.font, { family: Fn.family, size: ra, color: Sn, weight: Fn.weight, style: Fn.style, variant: Fn.variant, textcase: Fn.textcase, lineposition: Fn.lineposition, shadow: Fn.shadow }).text(fn.t).call(W_e.convertToTspans, e3);\n                  });\n                }\n              });\n            };\n            function Z_e(e3, t3) {\n              var r4 = t3.length - 2, n4 = H0.constrain(H0.findBin(e3, t3), 0, r4), i3 = t3[n4], a4 = t3[n4 + 1], o4 = H0.constrain(n4 + (e3 - i3) / (a4 - i3) - 0.5, 0, r4), s3 = Math.round(o4), l3 = Math.abs(o4 - s3);\n              return !o4 || o4 === r4 || !l3 ? { bin0: s3, bin1: s3, frac: 0 } : { bin0: s3, frac: l3, bin1: Math.round(s3 + l3 / (o4 - s3)) };\n            }\n            function Y_e(e3, t3) {\n              var r4 = t3.length - 1, n4 = H0.constrain(H0.findBin(e3, t3), 0, r4), i3 = t3[n4], a4 = t3[n4 + 1], o4 = (e3 - i3) / (a4 - i3) || 0;\n              return o4 <= 0 ? { bin0: n4, bin1: n4, frac: 0 } : o4 < 0.5 ? { bin0: n4, bin1: n4 + 1, frac: o4 } : { bin0: n4 + 1, bin1: n4, frac: 1 - o4 };\n            }\n            function K_e(e3, t3, r4) {\n              e3[t3] = r4[0], e3[t3 + 1] = r4[1], e3[t3 + 2] = r4[2], e3[t3 + 3] = Math.round(r4[3] * 255);\n            }\n          });\n          var S_ = ye((Our, exe) => {\n            "use strict";\n            exe.exports = { min: "zmin", max: "zmax" };\n          });\n          var v8 = ye((qur, txe) => {\n            "use strict";\n            var zxt = Oa();\n            txe.exports = function(t3) {\n              zxt.select(t3).selectAll(".hm image").style("opacity", function(r4) {\n                return r4.trace.opacity;\n              });\n            };\n          });\n          var g8 = ye((Bur, ixe) => {\n            "use strict";\n            var rxe = vf(), S4 = Dr(), p8 = S4.isArrayOrTypedArray, Oxt = ho(), qxt = tc().extractOpts;\n            ixe.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = a4.isContour, s3 = t3.cd[0], l3 = s3.trace, u4 = t3.xa, c5 = t3.ya, f4 = s3.x, h3 = s3.y, d3 = s3.z, v3 = s3.xCenter, _2 = s3.yCenter, b = s3.zmask, p3 = l3.zhoverformat, k4 = f4, E3 = h3, S2, L3, x2, C3;\n              if (t3.index !== false) {\n                try {\n                  x2 = Math.round(t3.index[1]), C3 = Math.round(t3.index[0]);\n                } catch (te) {\n                  S4.error("Error hovering on heatmap, pointNumber must be [row,col], found:", t3.index);\n                  return;\n                }\n                if (x2 < 0 || x2 >= d3[0].length || C3 < 0 || C3 > d3.length) return;\n              } else {\n                if (rxe.inbox(r4 - f4[0], r4 - f4[f4.length - 1], 0) > 0 || rxe.inbox(n4 - h3[0], n4 - h3[h3.length - 1], 0) > 0) return;\n                if (o4) {\n                  var M4;\n                  for (k4 = [2 * f4[0] - f4[1]], M4 = 1; M4 < f4.length; M4++) k4.push((f4[M4] + f4[M4 - 1]) / 2);\n                  for (k4.push([2 * f4[f4.length - 1] - f4[f4.length - 2]]), E3 = [2 * h3[0] - h3[1]], M4 = 1; M4 < h3.length; M4++) E3.push((h3[M4] + h3[M4 - 1]) / 2);\n                  E3.push([2 * h3[h3.length - 1] - h3[h3.length - 2]]);\n                }\n                x2 = Math.max(0, Math.min(k4.length - 2, S4.findBin(r4, k4))), C3 = Math.max(0, Math.min(E3.length - 2, S4.findBin(n4, E3)));\n              }\n              var g3 = u4.c2p(f4[x2]), P3 = u4.c2p(f4[x2 + 1]), T3 = c5.c2p(h3[C3]), z3 = c5.c2p(h3[C3 + 1]), O3, V2;\n              o4 ? (O3 = s3.orig_x || f4, V2 = s3.orig_y || h3, P3 = g3, S2 = O3[x2], z3 = T3, L3 = V2[C3]) : (O3 = s3.orig_x || v3 || f4, V2 = s3.orig_y || _2 || h3, S2 = v3 ? O3[x2] : (O3[x2] + O3[x2 + 1]) / 2, L3 = _2 ? V2[C3] : (V2[C3] + V2[C3 + 1]) / 2, u4 && u4.type === "category" && (S2 = f4[x2]), c5 && c5.type === "category" && (L3 = h3[C3]), l3.zsmooth && (g3 = P3 = u4.c2p(S2), T3 = z3 = c5.c2p(L3)));\n              var G2 = d3[C3][x2];\n              if (b && !b[C3][x2] && (G2 = void 0), !(G2 === void 0 && !l3.hoverongaps)) {\n                var Z;\n                p8(s3.hovertext) && p8(s3.hovertext[C3]) ? Z = s3.hovertext[C3][x2] : p8(s3.text) && p8(s3.text[C3]) && (Z = s3.text[C3][x2]);\n                var j3 = qxt(l3), N2 = { type: "linear", range: [j3.min, j3.max], hoverformat: p3, _separators: u4._separators, _numFormat: u4._numFormat }, H = Oxt.tickText(N2, G2, "hover").text;\n                return [S4.extendFlat(t3, { index: l3._after2before ? l3._after2before[C3][x2] : [C3, x2], distance: t3.maxHoverDistance, spikeDistance: t3.maxSpikeDistance, x0: g3, x1: P3, y0: T3, y1: z3, xLabelVal: S2, yLabelVal: L3, zLabelVal: G2, zLabel: H, text: Z })];\n              }\n            };\n          });\n          var axe = ye((Nur, nxe) => {\n            "use strict";\n            nxe.exports = { attributes: PT(), supplyDefaults: i_e(), calc: c8(), plot: d8(), colorbar: S_(), style: v8(), hoverPoints: g8(), moduleType: "trace", name: "heatmap", basePlotModule: ph(), categories: ["cartesian", "svg", "2dMap", "showLegend"], meta: {} };\n          });\n          var sxe = ye((Uur, oxe) => {\n            "use strict";\n            oxe.exports = axe();\n          });\n          var tG = ye((Vur, lxe) => {\n            "use strict";\n            lxe.exports = function(t3, r4) {\n              return { start: { valType: "any", editType: "calc" }, end: { valType: "any", editType: "calc" }, size: { valType: "any", editType: "calc" }, editType: "calc" };\n            };\n          });\n          var cxe = ye((Gur, uxe) => {\n            "use strict";\n            uxe.exports = { eventDataKeys: ["binNumber"] };\n          });\n          var m8 = ye((Hur, vxe) => {\n            "use strict";\n            var Ip = Lm(), fxe = df().axisHoverFormat, { hovertemplateAttrs: Bxt, texttemplateAttrs: Nxt, templatefallbackAttrs: hxe } = Ll(), rG = ec(), dxe = tG(), Uxt = cxe(), iG = Ao().extendFlat;\n            vxe.exports = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, xhoverformat: fxe("x"), yhoverformat: fxe("y"), text: iG({}, Ip.text, {}), hovertext: iG({}, Ip.hovertext, {}), orientation: Ip.orientation, histfunc: { valType: "enumerated", values: ["count", "sum", "avg", "min", "max"], dflt: "count", editType: "calc" }, histnorm: { valType: "enumerated", values: ["", "percent", "probability", "density", "probability density"], dflt: "", editType: "calc" }, cumulative: { enabled: { valType: "boolean", dflt: false, editType: "calc" }, direction: { valType: "enumerated", values: ["increasing", "decreasing"], dflt: "increasing", editType: "calc" }, currentbin: { valType: "enumerated", values: ["include", "exclude", "half"], dflt: "include", editType: "calc" }, editType: "calc" }, nbinsx: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, xbins: dxe("x", true), nbinsy: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, ybins: dxe("y", true), autobinx: { valType: "boolean", dflt: null, editType: "calc" }, autobiny: { valType: "boolean", dflt: null, editType: "calc" }, bingroup: { valType: "string", dflt: "", editType: "calc" }, hovertemplate: Bxt({}, { keys: Uxt.eventDataKeys }), hovertemplatefallback: hxe(), texttemplate: Nxt({ arrayOk: false, editType: "plot" }, { keys: ["label", "value"] }), texttemplatefallback: hxe({ editType: "plot" }), textposition: iG({}, Ip.textposition, { arrayOk: false }), textfont: rG({ arrayOk: false, editType: "plot", colorEditType: "style" }), outsidetextfont: rG({ arrayOk: false, editType: "plot", colorEditType: "style" }), insidetextfont: rG({ arrayOk: false, editType: "plot", colorEditType: "style" }), insidetextanchor: Ip.insidetextanchor, textangle: Ip.textangle, cliponaxis: Ip.cliponaxis, constraintext: Ip.constraintext, marker: Ip.marker, offsetgroup: Ip.offsetgroup, alignmentgroup: Ip.alignmentgroup, selected: Ip.selected, unselected: Ip.unselected, zorder: Ip.zorder };\n          });\n          var yxe = ye((jur, mxe) => {\n            "use strict";\n            var pxe = qa(), M4 = Dr(), gxe = ka(), Vxt = r0().handleText, Gxt = VI(), Hxt = m8();\n            mxe.exports = function(t3, r4, n4, i3) {\n              function a4(k4, E3) {\n                return M4.coerce(t3, r4, Hxt, k4, E3);\n              }\n              var o4 = a4("x"), s3 = a4("y"), l3 = a4("cumulative.enabled");\n              l3 && (a4("cumulative.direction"), a4("cumulative.currentbin")), a4("text");\n              var u4 = a4("textposition");\n              Vxt(t3, r4, i3, a4, u4, { moduleHasSelected: true, moduleHasUnselected: true, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("xhoverformat"), a4("yhoverformat");\n              var c5 = a4("orientation", s3 && !o4 ? "h" : "v"), f4 = c5 === "v" ? "x" : "y", h3 = c5 === "v" ? "y" : "x", d3 = o4 && s3 ? Math.min(M4.minRowLength(o4) && M4.minRowLength(s3)) : M4.minRowLength(r4[f4] || []);\n              if (!d3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = d3;\n              var v3 = pxe.getComponentMethod("calendars", "handleTraceDefaults");\n              v3(t3, r4, ["x", "y"], i3);\n              var _2 = r4[h3];\n              _2 && a4("histfunc"), a4("histnorm"), a4("autobin" + f4), Gxt(t3, r4, a4, n4, i3), M4.coerceSelectionMarkerOpacity(r4, a4);\n              var b = (r4.marker.line || {}).color, p3 = pxe.getComponentMethod("errorbars", "supplyDefaults");\n              p3(t3, r4, b || gxe.defaultLine, { axis: "y" }), p3(t3, r4, b || gxe.defaultLine, { axis: "x", inherit: "y" }), a4("zorder");\n            };\n          });\n          var _8 = ye((Wur, bxe) => {\n            "use strict";\n            var E4 = Dr(), jxt = hf(), y8 = qa().traceIs, Wxt = Hb(), Xxt = r0().validateCornerradius, _xe = E4.nestedProperty, nG = Nb().getAxisGroup, xxe = [{ aStr: { x: "xbins.start", y: "ybins.start" }, name: "start" }, { aStr: { x: "xbins.end", y: "ybins.end" }, name: "end" }, { aStr: { x: "xbins.size", y: "ybins.size" }, name: "size" }, { aStr: { x: "nbinsx", y: "nbinsy" }, name: "nbins" }], Zxt = ["x", "y"];\n            bxe.exports = function(t3, r4) {\n              var n4 = r4._histogramBinOpts = {}, i3 = [], a4 = {}, o4 = [], s3, l3, u4, c5, f4, h3, d3;\n              function v3(G2, Z) {\n                return E4.coerce(s3._input, s3, s3._module.attributes, G2, Z);\n              }\n              function _2(G2) {\n                return G2.orientation === "v" ? "x" : "y";\n              }\n              function b(G2, Z) {\n                var j3 = jxt.getFromTrace({ _fullLayout: r4 }, G2, Z);\n                return j3.type;\n              }\n              function p3(G2, Z, j3) {\n                var N2 = G2.uid + "__" + j3;\n                Z || (Z = N2);\n                var H = b(G2, j3), te = G2[j3 + "calendar"] || "", oe = n4[Z], _e = true;\n                oe && (H === oe.axType && te === oe.calendar ? (_e = false, oe.traces.push(G2), oe.dirs.push(j3)) : (Z = N2, H !== oe.axType && E4.warn(["Attempted to group the bins of trace", G2.index, "set on a", "type:" + H, "axis", "with bins on", "type:" + oe.axType, "axis."].join(" ")), te !== oe.calendar && E4.warn(["Attempted to group the bins of trace", G2.index, "set with a", te, "calendar", "with bins", oe.calendar ? "on a " + oe.calendar + " calendar" : "w/o a set calendar"].join(" ")))), _e && (n4[Z] = { traces: [G2], dirs: [j3], axType: H, calendar: G2[j3 + "calendar"] || "" }), G2["_" + j3 + "bingroup"] = Z;\n              }\n              for (f4 = 0; f4 < t3.length; f4++) if (s3 = t3[f4], y8(s3, "histogram")) {\n                if (i3.push(s3), delete s3._xautoBinFinished, delete s3._yautoBinFinished, s3.type === "histogram") {\n                  var k4 = v3("marker.cornerradius", r4.barcornerradius);\n                  s3.marker && (s3.marker.cornerradius = Xxt(k4));\n                }\n                y8(s3, "2dMap") || Wxt(s3._input, s3, r4, v3, r4.barmode);\n              }\n              var E3 = r4._alignmentOpts || {};\n              for (f4 = 0; f4 < i3.length; f4++) {\n                if (s3 = i3[f4], u4 = "", !y8(s3, "2dMap")) {\n                  if (c5 = _2(s3), r4.barmode === "group" && s3.alignmentgroup) {\n                    var S2 = s3[c5 + "axis"], L3 = nG(r4, S2) + s3.orientation;\n                    (E3[L3] || {})[s3.alignmentgroup] && (u4 = L3);\n                  }\n                  !u4 && r4.barmode !== "overlay" && (u4 = nG(r4, s3.xaxis) + nG(r4, s3.yaxis) + _2(s3));\n                }\n                u4 ? (a4[u4] || (a4[u4] = []), a4[u4].push(s3)) : o4.push(s3);\n              }\n              for (u4 in a4) {\n                if (l3 = a4[u4], l3.length === 1) {\n                  o4.push(l3[0]);\n                  continue;\n                }\n                var x2 = false;\n                for (l3.length && (s3 = l3[0], x2 = v3("bingroup")), u4 = x2 || u4, f4 = 0; f4 < l3.length; f4++) {\n                  s3 = l3[f4];\n                  var C3 = s3._input.bingroup;\n                  C3 && C3 !== u4 && E4.warn(["Trace", s3.index, "must match", "within bingroup", u4 + ".", "Ignoring its bingroup:", C3, "setting."].join(" ")), s3.bingroup = u4, p3(s3, u4, _2(s3));\n                }\n              }\n              for (f4 = 0; f4 < o4.length; f4++) {\n                s3 = o4[f4];\n                var M4 = v3("bingroup");\n                if (y8(s3, "2dMap")) for (d3 = 0; d3 < 2; d3++) {\n                  c5 = Zxt[d3];\n                  var g3 = v3(c5 + "bingroup", M4 ? M4 + "__" + c5 : null);\n                  p3(s3, g3, c5);\n                }\n                else p3(s3, M4, _2(s3));\n              }\n              for (u4 in n4) {\n                var P3 = n4[u4];\n                for (l3 = P3.traces, h3 = 0; h3 < xxe.length; h3++) {\n                  var T3 = xxe[h3], z3 = T3.name, O3, V2;\n                  if (!(z3 === "nbins" && P3.sizeFound)) {\n                    for (f4 = 0; f4 < l3.length; f4++) {\n                      if (s3 = l3[f4], c5 = P3.dirs[f4], O3 = T3.aStr[c5], _xe(s3._input, O3).get() !== void 0) {\n                        P3[z3] = v3(O3), P3[z3 + "Found"] = true;\n                        break;\n                      }\n                      V2 = (s3._autoBin || {})[c5] || {}, V2[z3] && _xe(s3, O3).set(V2[z3]);\n                    }\n                    if (z3 === "start" || z3 === "end") for (; f4 < l3.length; f4++) s3 = l3[f4], s3["_" + c5 + "bingroup"] && (V2 = (s3._autoBin || {})[c5] || {}, v3(O3, V2[z3]));\n                    z3 === "nbins" && !P3.sizeFound && !P3.nbinsFound && (s3 = l3[0], P3[z3] = v3(O3));\n                  }\n                }\n              }\n            };\n          });\n          var Txe = ye((Xur, wxe) => {\n            "use strict";\n            var Yxt = ET().hoverPoints, Kxt = ho().hoverLabelText;\n            wxe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = Yxt(t3, r4, n4, i3, a4);\n              if (o4) {\n                t3 = o4[0];\n                var s3 = t3.cd[t3.index], l3 = t3.cd[0].trace;\n                if (!l3.cumulative.enabled) {\n                  var u4 = l3.orientation === "h" ? "y" : "x";\n                  t3[u4 + "Label"] = Kxt(t3[u4 + "a"], [s3.ph0, s3.ph1], l3[u4 + "hoverformat"]);\n                }\n                return o4;\n              }\n            };\n          });\n          var aG = ye((Zur, Axe) => {\n            "use strict";\n            Axe.exports = function(t3, r4, n4, i3, a4) {\n              if (t3.x = "xVal" in r4 ? r4.xVal : r4.x, t3.y = "yVal" in r4 ? r4.yVal : r4.y, "zLabelVal" in r4 && (t3.z = r4.zLabelVal), r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), !(n4.cumulative || {}).enabled) {\n                var o4 = Array.isArray(a4) ? i3[0].pts[a4[0]][a4[1]] : i3[a4].pts;\n                t3.pointNumbers = o4, t3.binNumber = t3.pointNumber, delete t3.pointNumber, delete t3.pointIndex;\n                var s3;\n                if (n4._indexToPoints) {\n                  s3 = [];\n                  for (var l3 = 0; l3 < o4.length; l3++) s3 = s3.concat(n4._indexToPoints[o4[l3]]);\n                } else s3 = o4;\n                t3.pointIndices = s3;\n              }\n              return t3;\n            };\n          });\n          var Mxe = ye((Yur, Sxe) => {\n            "use strict";\n            Sxe.exports = { attributes: m8(), layoutAttributes: UI(), supplyDefaults: yxe(), crossTraceDefaults: _8(), supplyLayoutDefaults: SV(), calc: ZV().calc, crossTraceCalc: jb().crossTraceCalc, plot: n2().plot, layerName: "barlayer", style: N0().style, styleOnSelect: N0().styleOnSelect, colorbar: $d(), hoverPoints: Txe(), selectPoints: kT(), eventData: aG(), moduleType: "trace", name: "histogram", basePlotModule: ph(), categories: ["bar-like", "cartesian", "svg", "bar", "histogram", "oriented", "errorBarsOK", "showLegend"], meta: {} };\n          });\n          var kxe = ye((Kur, Exe) => {\n            "use strict";\n            Exe.exports = Mxe();\n          });\n          var b8 = ye((Jur, Pxe) => {\n            "use strict";\n            var Gg = m8(), Cxe = tG(), x8 = PT(), Jxt = Gl(), oG = df().axisHoverFormat, { hovertemplateAttrs: $xt, texttemplateAttrs: Qxt, templatefallbackAttrs: Lxe } = Ll(), ebt = Tu(), k4 = Ao().extendFlat;\n            Pxe.exports = k4({ x: Gg.x, y: Gg.y, z: { valType: "data_array", editType: "calc" }, marker: { color: { valType: "data_array", editType: "calc" }, editType: "calc" }, histnorm: Gg.histnorm, histfunc: Gg.histfunc, nbinsx: Gg.nbinsx, xbins: Cxe("x"), nbinsy: Gg.nbinsy, ybins: Cxe("y"), autobinx: Gg.autobinx, autobiny: Gg.autobiny, bingroup: k4({}, Gg.bingroup, {}), xbingroup: k4({}, Gg.bingroup, {}), ybingroup: k4({}, Gg.bingroup, {}), xgap: x8.xgap, ygap: x8.ygap, zsmooth: x8.zsmooth, xhoverformat: oG("x"), yhoverformat: oG("y"), zhoverformat: oG("z", 1), hovertemplate: $xt({}, { keys: ["z"] }), hovertemplatefallback: Lxe(), texttemplate: Qxt({ arrayOk: false, editType: "plot" }, { keys: ["z"] }), texttemplatefallback: Lxe({ editType: "plot" }), textfont: x8.textfont, showlegend: k4({}, Jxt.showlegend, { dflt: false }) }, ebt("", { cLetter: "z", autoColorDflt: false }));\n          });\n          var sG = ye(($ur, Rxe) => {\n            "use strict";\n            var tbt = qa(), Ixe = Dr();\n            Rxe.exports = function(t3, r4, n4, i3) {\n              var a4 = n4("x"), o4 = n4("y"), s3 = Ixe.minRowLength(a4), l3 = Ixe.minRowLength(o4);\n              if (!s3 || !l3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = Math.min(s3, l3);\n              var u4 = tbt.getComponentMethod("calendars", "handleTraceDefaults");\n              u4(t3, r4, ["x", "y"], i3);\n              var c5 = n4("z") || n4("marker.color");\n              c5 && n4("histfunc"), n4("histnorm"), n4("autobinx"), n4("autobiny");\n            };\n          });\n          var Fxe = ye((Qur, Dxe) => {\n            "use strict";\n            var rbt = Dr(), ibt = sG(), nbt = UV(), abt = Qh(), obt = A4(), sbt = b8();\n            Dxe.exports = function(t3, r4, n4, i3) {\n              function a4(o4, s3) {\n                return rbt.coerce(t3, r4, sbt, o4, s3);\n              }\n              ibt(t3, r4, a4, i3), r4.visible !== false && (nbt(t3, r4, a4, i3), abt(t3, r4, i3, a4, { prefix: "", cLetter: "z" }), a4("hovertemplate"), a4("hovertemplatefallback"), obt(a4, i3), a4("xhoverformat"), a4("yhoverformat"));\n            };\n          });\n          var qxe = ye((ecr, Oxe) => {\n            "use strict";\n            var lbt = g8(), zxe = ho().hoverLabelText;\n            Oxe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = lbt(t3, r4, n4, i3, a4);\n              if (o4) {\n                t3 = o4[0];\n                var s3 = t3.index, l3 = s3[0], u4 = s3[1], c5 = t3.cd[0], f4 = c5.trace, h3 = c5.xRanges[u4], d3 = c5.yRanges[l3];\n                return t3.xLabel = zxe(t3.xa, [h3[0], h3[1]], f4.xhoverformat), t3.yLabel = zxe(t3.ya, [d3[0], d3[1]], f4.yhoverformat), o4;\n              }\n            };\n          });\n          var Nxe = ye((tcr, Bxe) => {\n            "use strict";\n            Bxe.exports = { attributes: b8(), supplyDefaults: Fxe(), crossTraceDefaults: _8(), calc: c8(), plot: d8(), layerName: "heatmaplayer", colorbar: S_(), style: v8(), hoverPoints: qxe(), eventData: aG(), moduleType: "trace", name: "histogram2d", basePlotModule: ph(), categories: ["cartesian", "svg", "2dMap", "histogram", "showLegend"], meta: {} };\n          });\n          var Vxe = ye((rcr, Uxe) => {\n            "use strict";\n            Uxe.exports = Nxe();\n          });\n          var w8 = ye((icr, Gxe) => {\n            "use strict";\n            Gxe.exports = { COMPARISON_OPS: ["=", "!=", "<", ">=", ">", "<="], COMPARISON_OPS2: ["=", "<", ">=", ">", "<="], INTERVAL_OPS: ["[]", "()", "[)", "(]", "][", ")(", "](", ")["], SET_OPS: ["{}", "}{"], CONSTRAINT_REDUCTION: { "=": "=", "<": "<", "<=": "<", ">": ">", ">=": ">", "[]": "[]", "()": "[]", "[)": "[]", "(]": "[]", "][": "][", ")(": "][", "](": "][", ")[": "][" } };\n          });\n          var C4 = ye((ncr, Xxe) => {\n            "use strict";\n            var mh = PT(), T8 = pf(), jxe = df(), lG = jxe.axisHoverFormat, ubt = jxe.descriptionOnlyNumbers, cbt = Tu(), fbt = Pd().dash, hbt = ec(), zT = Ao().extendFlat, Wxe = w8(), dbt = Wxe.COMPARISON_OPS2, vbt = Wxe.INTERVAL_OPS, Hxe = T8.line;\n            Xxe.exports = zT({ z: mh.z, x: mh.x, x0: mh.x0, dx: mh.dx, y: mh.y, y0: mh.y0, dy: mh.dy, xperiod: mh.xperiod, yperiod: mh.yperiod, xperiod0: T8.xperiod0, yperiod0: T8.yperiod0, xperiodalignment: mh.xperiodalignment, yperiodalignment: mh.yperiodalignment, text: mh.text, hovertext: mh.hovertext, transpose: mh.transpose, xtype: mh.xtype, ytype: mh.ytype, xhoverformat: lG("x"), yhoverformat: lG("y"), zhoverformat: lG("z", 1), hovertemplate: mh.hovertemplate, hovertemplatefallback: mh.hovertemplatefallback, texttemplate: zT({}, mh.texttemplate, {}), texttemplatefallback: mh.texttemplatefallback, textfont: zT({}, mh.textfont, {}), hoverongaps: mh.hoverongaps, connectgaps: zT({}, mh.connectgaps, {}), fillcolor: { valType: "color", editType: "calc" }, autocontour: { valType: "boolean", dflt: true, editType: "calc", impliedEdits: { "contours.start": void 0, "contours.end": void 0, "contours.size": void 0 } }, ncontours: { valType: "integer", dflt: 15, min: 1, editType: "calc" }, contours: { type: { valType: "enumerated", values: ["levels", "constraint"], dflt: "levels", editType: "calc" }, start: { valType: "number", dflt: null, editType: "plot", impliedEdits: { "^autocontour": false } }, end: { valType: "number", dflt: null, editType: "plot", impliedEdits: { "^autocontour": false } }, size: { valType: "number", dflt: null, min: 0, editType: "plot", impliedEdits: { "^autocontour": false } }, coloring: { valType: "enumerated", values: ["fill", "heatmap", "lines", "none"], dflt: "fill", editType: "calc" }, showlines: { valType: "boolean", dflt: true, editType: "plot" }, showlabels: { valType: "boolean", dflt: false, editType: "plot" }, labelfont: hbt({ editType: "plot", colorEditType: "style" }), labelformat: { valType: "string", dflt: "", editType: "plot", description: ubt("contour label") }, operation: { valType: "enumerated", values: [].concat(dbt).concat(vbt), dflt: "=", editType: "calc" }, value: { valType: "any", dflt: 0, editType: "calc" }, editType: "calc", impliedEdits: { autocontour: false } }, line: { color: zT({}, Hxe.color, { editType: "style+colorbars" }), width: { valType: "number", min: 0, editType: "style+colorbars" }, dash: fbt, smoothing: zT({}, Hxe.smoothing, {}), editType: "plot" }, zorder: T8.zorder }, cbt("", { cLetter: "z", autoColorDflt: false, editTypeOverride: "calc" }));\n          });\n          var cG = ye((acr, Yxe) => {\n            "use strict";\n            var wv = b8(), Rm = C4(), pbt = Tu(), uG = df().axisHoverFormat, Zxe = Ao().extendFlat;\n            Yxe.exports = Zxe({ x: wv.x, y: wv.y, z: wv.z, marker: wv.marker, histnorm: wv.histnorm, histfunc: wv.histfunc, nbinsx: wv.nbinsx, xbins: wv.xbins, nbinsy: wv.nbinsy, ybins: wv.ybins, autobinx: wv.autobinx, autobiny: wv.autobiny, bingroup: wv.bingroup, xbingroup: wv.xbingroup, ybingroup: wv.ybingroup, autocontour: Rm.autocontour, ncontours: Rm.ncontours, contours: Rm.contours, line: { color: Rm.line.color, width: Zxe({}, Rm.line.width, { dflt: 0.5 }), dash: Rm.line.dash, smoothing: Rm.line.smoothing, editType: "plot" }, xhoverformat: uG("x"), yhoverformat: uG("y"), zhoverformat: uG("z", 1), hovertemplate: wv.hovertemplate, hovertemplatefallback: wv.hovertemplatefallback, texttemplate: Rm.texttemplate, texttemplatefallback: Rm.texttemplatefallback, textfont: Rm.textfont }, pbt("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var A8 = ye((ocr, Kxe) => {\n            "use strict";\n            Kxe.exports = function(t3, r4, n4, i3) {\n              var a4 = i3("contours.start"), o4 = i3("contours.end"), s3 = a4 === false || o4 === false, l3 = n4("contours.size"), u4;\n              s3 ? u4 = r4.autocontour = true : u4 = n4("autocontour", false), (u4 || !l3) && n4("ncontours");\n            };\n          });\n          var fG = ye((scr, Jxe) => {\n            "use strict";\n            var gbt = Dr();\n            Jxe.exports = function(t3, r4, n4, i3) {\n              i3 || (i3 = {});\n              var a4 = t3("contours.showlabels");\n              if (a4) {\n                var o4 = r4.font;\n                gbt.coerceFont(t3, "contours.labelfont", o4, { overrideDflt: { color: n4 } }), t3("contours.labelformat");\n              }\n              i3.hasHover !== false && t3("zhoverformat");\n            };\n          });\n          var S8 = ye((lcr, $xe) => {\n            "use strict";\n            var mbt = Qh(), ybt = fG();\n            $xe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = n4("contours.coloring"), s3, l3 = "";\n              o4 === "fill" && (s3 = n4("contours.showlines")), s3 !== false && (o4 !== "lines" && (l3 = n4("line.color", "#000")), n4("line.width", 0.5), n4("line.dash")), o4 !== "none" && (t3.showlegend !== true && (r4.showlegend = false), r4._dfltShowLegend = false, mbt(t3, r4, i3, n4, { prefix: "", cLetter: "z" })), n4("line.smoothing"), ybt(n4, i3, l3, a4);\n            };\n          });\n          var rbe = ye((ucr, tbe) => {\n            "use strict";\n            var Qxe = Dr(), _bt = sG(), xbt = A8(), bbt = S8(), wbt = A4(), ebe = cG();\n            tbe.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return Qxe.coerce(t3, r4, ebe, s3, l3);\n              }\n              function o4(s3) {\n                return Qxe.coerce2(t3, r4, ebe, s3);\n              }\n              _bt(t3, r4, a4, i3), r4.visible !== false && (xbt(t3, r4, a4, o4), bbt(t3, r4, a4, i3), a4("xhoverformat"), a4("yhoverformat"), a4("hovertemplate"), a4("hovertemplatefallback"), r4.contours && r4.contours.coloring === "heatmap" && wbt(a4, i3));\n            };\n          });\n          var vG = ye((ccr, nbe) => {\n            "use strict";\n            var dG = ho(), hG = Dr();\n            nbe.exports = function(t3, r4) {\n              var n4 = t3.contours;\n              if (t3.autocontour) {\n                var i3 = t3.zmin, a4 = t3.zmax;\n                (t3.zauto || i3 === void 0) && (i3 = hG.aggNums(Math.min, null, r4)), (t3.zauto || a4 === void 0) && (a4 = hG.aggNums(Math.max, null, r4));\n                var o4 = ibe(i3, a4, t3.ncontours);\n                n4.size = o4.dtick, n4.start = dG.tickFirst(o4), o4.range.reverse(), n4.end = dG.tickFirst(o4), n4.start === i3 && (n4.start += n4.size), n4.end === a4 && (n4.end -= n4.size), n4.start > n4.end && (n4.start = n4.end = (n4.start + n4.end) / 2), t3._input.contours || (t3._input.contours = {}), hG.extendFlat(t3._input.contours, { start: n4.start, end: n4.end, size: n4.size }), t3._input.autocontour = true;\n              } else if (n4.type !== "constraint") {\n                var s3 = n4.start, l3 = n4.end, u4 = t3._input.contours;\n                if (s3 > l3 && (n4.start = u4.start = l3, l3 = n4.end = u4.end = s3, s3 = n4.start), !(n4.size > 0)) {\n                  var c5;\n                  s3 === l3 ? c5 = 1 : c5 = ibe(s3, l3, t3.ncontours).dtick, u4.size = n4.size = c5;\n                }\n              }\n            };\n            function ibe(e3, t3, r4) {\n              var n4 = { type: "linear", range: [e3, t3] };\n              return dG.autoTicks(n4, (t3 - e3) / (r4 || 15)), n4;\n            }\n          });\n          var L4 = ye((fcr, abe) => {\n            "use strict";\n            abe.exports = function(t3) {\n              return t3.end + t3.size / 1e6;\n            };\n          });\n          var pG = ye((hcr, sbe) => {\n            "use strict";\n            var obe = tc(), Tbt = c8(), Abt = vG(), Sbt = L4();\n            sbe.exports = function(t3, r4) {\n              var n4 = Tbt(t3, r4), i3 = n4[0].z;\n              Abt(r4, i3);\n              var a4 = r4.contours, o4 = obe.extractOpts(r4), s3;\n              if (a4.coloring === "heatmap" && o4.auto && r4.autocontour === false) {\n                var l3 = a4.start, u4 = Sbt(a4), c5 = a4.size || 1, f4 = Math.floor((u4 - l3) / c5) + 1;\n                isFinite(c5) || (c5 = 1, f4 = 1);\n                var h3 = l3 - c5 / 2, d3 = h3 + f4 * c5;\n                s3 = [h3, d3];\n              } else s3 = i3;\n              return obe.calc(t3, r4, { vals: s3, cLetter: "z" }), n4;\n            };\n          });\n          var P4 = ye((dcr, lbe) => {\n            "use strict";\n            lbe.exports = { BOTTOMSTART: [1, 9, 13, 104, 713], TOPSTART: [4, 6, 7, 104, 713], LEFTSTART: [8, 12, 14, 208, 1114], RIGHTSTART: [2, 3, 11, 208, 1114], NEWDELTA: [null, [-1, 0], [0, -1], [-1, 0], [1, 0], null, [0, -1], [-1, 0], [0, 1], [0, 1], null, [0, 1], [1, 0], [1, 0], [0, -1]], CHOOSESADDLE: { 104: [4, 1], 208: [2, 8], 713: [7, 13], 1114: [11, 14] }, SADDLEREMAINDER: { 1: 4, 2: 8, 4: 1, 7: 13, 8: 2, 11: 14, 13: 7, 14: 11 }, LABELDISTANCE: 2, LABELINCREASE: 10, LABELMIN: 3, LABELMAX: 10, LABELOPTIMIZER: { EDGECOST: 1, ANGLECOST: 1, NEIGHBORCOST: 5, SAMELEVELFACTOR: 10, SAMELEVELDISTANCE: 5, MAXCOST: 100, INITIALSEARCHPOINTS: 10, ITERATIONS: 5 } };\n          });\n          var gG = ye((vcr, ube) => {\n            "use strict";\n            var M8 = P4();\n            ube.exports = function(t3) {\n              var r4 = t3[0].z, n4 = r4.length, i3 = r4[0].length, a4 = n4 === 2 || i3 === 2, o4, s3, l3, u4, c5, f4, h3, d3, v3;\n              for (s3 = 0; s3 < n4 - 1; s3++) for (u4 = [], s3 === 0 && (u4 = u4.concat(M8.BOTTOMSTART)), s3 === n4 - 2 && (u4 = u4.concat(M8.TOPSTART)), o4 = 0; o4 < i3 - 1; o4++) for (l3 = u4.slice(), o4 === 0 && (l3 = l3.concat(M8.LEFTSTART)), o4 === i3 - 2 && (l3 = l3.concat(M8.RIGHTSTART)), c5 = o4 + "," + s3, f4 = [[r4[s3][o4], r4[s3][o4 + 1]], [r4[s3 + 1][o4], r4[s3 + 1][o4 + 1]]], v3 = 0; v3 < t3.length; v3++) d3 = t3[v3], h3 = Mbt(d3.level, f4), h3 && (d3.crossings[c5] = h3, l3.indexOf(h3) !== -1 && (d3.starts.push([o4, s3]), a4 && l3.indexOf(h3, l3.indexOf(h3) + 1) !== -1 && d3.starts.push([o4, s3])));\n            };\n            function Mbt(e3, t3) {\n              var r4 = (t3[0][0] > e3 ? 0 : 1) + (t3[0][1] > e3 ? 0 : 2) + (t3[1][1] > e3 ? 0 : 4) + (t3[1][0] > e3 ? 0 : 8);\n              if (r4 === 5 || r4 === 10) {\n                var n4 = (t3[0][0] + t3[0][1] + t3[1][0] + t3[1][1]) / 4;\n                return e3 > n4 ? r4 === 5 ? 713 : 1114 : r4 === 5 ? 104 : 208;\n              }\n              return r4 === 15 ? 0 : r4;\n            }\n          });\n          var mG = ye((pcr, hbe) => {\n            "use strict";\n            var E8 = Dr(), OT = P4();\n            hbe.exports = function(t3, r4, n4) {\n              var i3, a4, o4, s3, l3;\n              for (r4 = r4 || 0.01, n4 = n4 || 0.01, o4 = 0; o4 < t3.length; o4++) {\n                for (s3 = t3[o4], l3 = 0; l3 < s3.starts.length; l3++) a4 = s3.starts[l3], cbe(s3, a4, "edge", r4, n4);\n                for (i3 = 0; Object.keys(s3.crossings).length && i3 < 1e4; ) i3++, a4 = Object.keys(s3.crossings)[0].split(",").map(Number), cbe(s3, a4, void 0, r4, n4);\n                i3 === 1e4 && E8.log("Infinite loop in contour?");\n              }\n            };\n            function I4(e3, t3, r4, n4) {\n              return Math.abs(e3[0] - t3[0]) < r4 && Math.abs(e3[1] - t3[1]) < n4;\n            }\n            function Ebt(e3, t3) {\n              var r4 = e3[2] - t3[2], n4 = e3[3] - t3[3];\n              return Math.sqrt(r4 * r4 + n4 * n4);\n            }\n            function cbe(e3, t3, r4, n4, i3) {\n              var a4 = t3.join(","), o4 = e3.crossings[a4], s3 = kbt(o4, r4, t3), l3 = [fbe(e3, t3, [-s3[0], -s3[1]])], u4 = e3.z.length, c5 = e3.z[0].length, f4 = t3.slice(), h3 = s3.slice(), d3;\n              for (d3 = 0; d3 < 1e4; d3++) {\n                if (o4 > 20 ? (o4 = OT.CHOOSESADDLE[o4][(s3[0] || s3[1]) < 0 ? 0 : 1], e3.crossings[a4] = OT.SADDLEREMAINDER[o4]) : delete e3.crossings[a4], s3 = OT.NEWDELTA[o4], !s3) {\n                  E8.log("Found bad marching index:", o4, t3, e3.level);\n                  break;\n                }\n                l3.push(fbe(e3, t3, s3)), t3[0] += s3[0], t3[1] += s3[1], a4 = t3.join(","), I4(l3[l3.length - 1], l3[l3.length - 2], n4, i3) && l3.pop();\n                var v3 = s3[0] && (t3[0] < 0 || t3[0] > c5 - 2) || s3[1] && (t3[1] < 0 || t3[1] > u4 - 2), _2 = t3[0] === f4[0] && t3[1] === f4[1] && s3[0] === h3[0] && s3[1] === h3[1];\n                if (_2 || r4 && v3) break;\n                o4 = e3.crossings[a4];\n              }\n              d3 === 1e4 && E8.log("Infinite loop in contour?");\n              var b = I4(l3[0], l3[l3.length - 1], n4, i3), p3 = 0, k4 = 0.2 * e3.smoothing, E3 = [], S2 = 0, L3, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2;\n              for (d3 = 1; d3 < l3.length; d3++) T3 = Ebt(l3[d3], l3[d3 - 1]), p3 += T3, E3.push(T3);\n              var Z = p3 / E3.length * k4;\n              function j3(te) {\n                return l3[te % l3.length];\n              }\n              for (d3 = l3.length - 2; d3 >= S2; d3--) if (L3 = E3[d3], L3 < Z) {\n                for (C3 = 0, x2 = d3 - 1; x2 >= S2 && L3 + E3[x2] < Z; x2--) L3 += E3[x2];\n                if (b && d3 === l3.length - 2) for (C3 = 0; C3 < x2 && L3 + E3[C3] < Z; C3++) L3 += E3[C3];\n                g3 = d3 - x2 + C3 + 1, P3 = Math.floor((d3 + x2 + C3 + 2) / 2), !b && d3 === l3.length - 2 ? M4 = l3[l3.length - 1] : !b && x2 === -1 ? M4 = l3[0] : g3 % 2 ? M4 = j3(P3) : M4 = [(j3(P3)[0] + j3(P3 + 1)[0]) / 2, (j3(P3)[1] + j3(P3 + 1)[1]) / 2], l3.splice(x2 + 1, d3 - x2 + 1, M4), d3 = x2 + 1, C3 && (S2 = C3), b && (d3 === l3.length - 2 ? l3[C3] = l3[l3.length - 1] : d3 === 0 && (l3[l3.length - 1] = l3[0]));\n              }\n              for (l3.splice(0, S2), d3 = 0; d3 < l3.length; d3++) l3[d3].length = 2;\n              if (!(l3.length < 2)) if (b) l3.pop(), e3.paths.push(l3);\n              else {\n                r4 || E8.log("Unclosed interior contour?", e3.level, f4.join(","), l3.join("L"));\n                var N2 = false;\n                for (z3 = 0; z3 < e3.edgepaths.length; z3++) if (V2 = e3.edgepaths[z3], !N2 && I4(V2[0], l3[l3.length - 1], n4, i3)) {\n                  l3.pop(), N2 = true;\n                  var H = false;\n                  for (O3 = 0; O3 < e3.edgepaths.length; O3++) if (G2 = e3.edgepaths[O3], I4(G2[G2.length - 1], l3[0], n4, i3)) {\n                    H = true, l3.shift(), e3.edgepaths.splice(z3, 1), O3 === z3 ? e3.paths.push(l3.concat(G2)) : (O3 > z3 && O3--, e3.edgepaths[O3] = G2.concat(l3, V2));\n                    break;\n                  }\n                  H || (e3.edgepaths[z3] = l3.concat(V2));\n                }\n                for (z3 = 0; z3 < e3.edgepaths.length && !N2; z3++) V2 = e3.edgepaths[z3], I4(V2[V2.length - 1], l3[0], n4, i3) && (l3.shift(), e3.edgepaths[z3] = V2.concat(l3), N2 = true);\n                N2 || e3.edgepaths.push(l3);\n              }\n            }\n            function kbt(e3, t3, r4) {\n              var n4 = 0, i3 = 0;\n              return e3 > 20 && t3 ? e3 === 208 || e3 === 1114 ? n4 = r4[0] === 0 ? 1 : -1 : i3 = r4[1] === 0 ? 1 : -1 : OT.BOTTOMSTART.indexOf(e3) !== -1 ? i3 = 1 : OT.LEFTSTART.indexOf(e3) !== -1 ? n4 = 1 : OT.TOPSTART.indexOf(e3) !== -1 ? i3 = -1 : n4 = -1, [n4, i3];\n            }\n            function fbe(e3, t3, r4) {\n              var n4 = t3[0] + Math.max(r4[0], 0), i3 = t3[1] + Math.max(r4[1], 0), a4 = e3.z[i3][n4], o4 = e3.xaxis, s3 = e3.yaxis;\n              if (r4[1]) {\n                var l3 = (e3.level - a4) / (e3.z[i3][n4 + 1] - a4), u4 = (l3 !== 1 ? (1 - l3) * o4.c2l(e3.x[n4]) : 0) + (l3 !== 0 ? l3 * o4.c2l(e3.x[n4 + 1]) : 0);\n                return [o4.c2p(o4.l2c(u4), true), s3.c2p(e3.y[i3], true), n4 + l3, i3];\n              } else {\n                var c5 = (e3.level - a4) / (e3.z[i3 + 1][n4] - a4), f4 = (c5 !== 1 ? (1 - c5) * s3.c2l(e3.y[i3]) : 0) + (c5 !== 0 ? c5 * s3.c2l(e3.y[i3 + 1]) : 0);\n                return [o4.c2p(e3.x[n4], true), s3.c2p(s3.l2c(f4), true), n4, i3 + c5];\n              }\n            }\n          });\n          var gbe = ye((gcr, pbe) => {\n            "use strict";\n            var yG = w8(), Cbt = Eo();\n            pbe.exports = { "[]": dbe("[]"), "][": dbe("]["), ">": _G(">"), "<": _G("<"), "=": _G("=") };\n            function vbe(e3, t3) {\n              var r4 = Array.isArray(t3), n4;\n              function i3(a4) {\n                return Cbt(a4) ? +a4 : null;\n              }\n              return yG.COMPARISON_OPS2.indexOf(e3) !== -1 ? n4 = i3(r4 ? t3[0] : t3) : yG.INTERVAL_OPS.indexOf(e3) !== -1 ? n4 = r4 ? [i3(t3[0]), i3(t3[1])] : [i3(t3), i3(t3)] : yG.SET_OPS.indexOf(e3) !== -1 && (n4 = r4 ? t3.map(i3) : [i3(t3)]), n4;\n            }\n            function dbe(e3) {\n              return function(t3) {\n                t3 = vbe(e3, t3);\n                var r4 = Math.min(t3[0], t3[1]), n4 = Math.max(t3[0], t3[1]);\n                return { start: r4, end: n4, size: n4 - r4 };\n              };\n            }\n            function _G(e3) {\n              return function(t3) {\n                return t3 = vbe(e3, t3), { start: t3, end: 1 / 0, size: 1 / 0 };\n              };\n            }\n          });\n          var xG = ye((mcr, ybe) => {\n            "use strict";\n            var mbe = Dr(), Lbt = gbe(), Pbt = L4();\n            ybe.exports = function(t3, r4, n4) {\n              for (var i3 = t3.type === "constraint" ? Lbt[t3._operation](t3.value) : t3, a4 = i3.size, o4 = [], s3 = Pbt(i3), l3 = n4.trace._carpetTrace, u4 = l3 ? { xaxis: l3.aaxis, yaxis: l3.baxis, x: n4.a, y: n4.b } : { xaxis: r4.xaxis, yaxis: r4.yaxis, x: n4.x, y: n4.y }, c5 = i3.start; c5 < s3; c5 += a4) if (o4.push(mbe.extendFlat({ level: c5, crossings: {}, starts: [], edgepaths: [], paths: [], z: n4.z, smoothing: n4.trace.line.smoothing }, u4)), o4.length > 1e3) {\n                mbe.warn("Too many contours, clipping at 1000", t3);\n                break;\n              }\n              return o4;\n            };\n          });\n          var bG = ye((ycr, xbe) => {\n            "use strict";\n            var qT = Dr();\n            xbe.exports = function(e3, t3) {\n              var r4, n4, i3, a4 = function(l3) {\n                return l3.reverse();\n              }, o4 = function(l3) {\n                return l3;\n              };\n              switch (t3) {\n                case "=":\n                case "<":\n                  return e3;\n                case ">":\n                  for (e3.length !== 1 && qT.warn("Contour data invalid for the specified inequality operation."), n4 = e3[0], r4 = 0; r4 < n4.edgepaths.length; r4++) n4.edgepaths[r4] = a4(n4.edgepaths[r4]);\n                  for (r4 = 0; r4 < n4.paths.length; r4++) n4.paths[r4] = a4(n4.paths[r4]);\n                  for (r4 = 0; r4 < n4.starts.length; r4++) n4.starts[r4] = a4(n4.starts[r4]);\n                  return e3;\n                case "][":\n                  var s3 = a4;\n                  a4 = o4, o4 = s3;\n                case "[]":\n                  for (e3.length !== 2 && qT.warn("Contour data invalid for the specified inequality range operation."), n4 = _be(e3[0]), i3 = _be(e3[1]), r4 = 0; r4 < n4.edgepaths.length; r4++) n4.edgepaths[r4] = a4(n4.edgepaths[r4]);\n                  for (r4 = 0; r4 < n4.paths.length; r4++) n4.paths[r4] = a4(n4.paths[r4]);\n                  for (r4 = 0; r4 < n4.starts.length; r4++) n4.starts[r4] = a4(n4.starts[r4]);\n                  for (; i3.edgepaths.length; ) n4.edgepaths.push(o4(i3.edgepaths.shift()));\n                  for (; i3.paths.length; ) n4.paths.push(o4(i3.paths.shift()));\n                  for (; i3.starts.length; ) n4.starts.push(o4(i3.starts.shift()));\n                  return [n4];\n              }\n            };\n            function _be(e3) {\n              return qT.extendFlat({}, e3, { edgepaths: qT.extendDeep([], e3.edgepaths), paths: qT.extendDeep([], e3.paths), starts: qT.extendDeep([], e3.starts) });\n            }\n          });\n          var wG = ye((_cr, bbe) => {\n            "use strict";\n            bbe.exports = function(e3, t3) {\n              var r4 = e3[0], n4 = r4.z, i3;\n              switch (t3.type) {\n                case "levels":\n                  var a4 = Math.min(n4[0][0], n4[0][1]);\n                  for (i3 = 0; i3 < e3.length; i3++) {\n                    var o4 = e3[i3];\n                    o4.prefixBoundary = !o4.edgepaths.length && (a4 > o4.level || o4.starts.length && a4 === o4.level);\n                  }\n                  break;\n                case "constraint":\n                  if (r4.prefixBoundary = false, r4.edgepaths.length) return;\n                  var s3 = r4.x.length, l3 = r4.y.length, u4 = -1 / 0, c5 = 1 / 0;\n                  for (i3 = 0; i3 < l3; i3++) c5 = Math.min(c5, n4[i3][0]), c5 = Math.min(c5, n4[i3][s3 - 1]), u4 = Math.max(u4, n4[i3][0]), u4 = Math.max(u4, n4[i3][s3 - 1]);\n                  for (i3 = 1; i3 < s3 - 1; i3++) c5 = Math.min(c5, n4[0][i3]), c5 = Math.min(c5, n4[l3 - 1][i3]), u4 = Math.max(u4, n4[0][i3]), u4 = Math.max(u4, n4[l3 - 1][i3]);\n                  var f4 = t3.value, h3, d3;\n                  switch (t3._operation) {\n                    case ">":\n                      f4 > u4 && (r4.prefixBoundary = true);\n                      break;\n                    case "<":\n                      (f4 < c5 || r4.starts.length && f4 === c5) && (r4.prefixBoundary = true);\n                      break;\n                    case "[]":\n                      h3 = Math.min(f4[0], f4[1]), d3 = Math.max(f4[0], f4[1]), (d3 < c5 || h3 > u4 || r4.starts.length && d3 === c5) && (r4.prefixBoundary = true);\n                      break;\n                    case "][":\n                      h3 = Math.min(f4[0], f4[1]), d3 = Math.max(f4[0], f4[1]), h3 < c5 && d3 > u4 && (r4.prefixBoundary = true);\n                      break;\n                  }\n                  break;\n              }\n            };\n          });\n          var k8 = ye((jv) => {\n            "use strict";\n            var D4 = Oa(), zd = Dr(), qy = So(), Ibt = tc(), Abe = ru(), wbe = ho(), Tbe = ym(), Rbt = d8(), Sbe = gG(), Mbe = mG(), Dbt = xG(), Fbt = bG(), Ebe = wG(), R4 = P4(), Dm = R4.LABELOPTIMIZER;\n            jv.plot = function(t3, r4, n4, i3) {\n              var a4 = r4.xaxis, o4 = r4.yaxis;\n              zd.makeTraceGroups(i3, n4, "contour").each(function(s3) {\n                var l3 = D4.select(this), u4 = s3[0], c5 = u4.trace, f4 = u4.x, h3 = u4.y, d3 = c5.contours, v3 = Dbt(d3, r4, u4), _2 = zd.ensureSingle(l3, "g", "heatmapcoloring"), b = [];\n                d3.coloring === "heatmap" && (b = [s3]), Rbt(t3, r4, b, _2), Sbe(v3), Mbe(v3);\n                var p3 = a4.c2p(f4[0], true), k4 = a4.c2p(f4[f4.length - 1], true), E3 = o4.c2p(h3[0], true), S2 = o4.c2p(h3[h3.length - 1], true), L3 = [[p3, S2], [k4, S2], [k4, E3], [p3, E3]], x2 = v3;\n                d3.type === "constraint" && (x2 = Fbt(v3, d3._operation)), zbt(l3, L3, d3), Obt(l3, x2, L3, d3), qbt(l3, v3, t3, u4, d3), Nbt(l3, r4, t3, u4, L3);\n              });\n            };\n            function zbt(e3, t3, r4) {\n              var n4 = zd.ensureSingle(e3, "g", "contourbg"), i3 = n4.selectAll("path").data(r4.coloring === "fill" ? [0] : []);\n              i3.enter().append("path"), i3.exit().remove(), i3.attr("d", "M" + t3.join("L") + "Z").style("stroke", "none");\n            }\n            function Obt(e3, t3, r4, n4) {\n              var i3 = n4.coloring === "fill" || n4.type === "constraint" && n4._operation !== "=", a4 = "M" + r4.join("L") + "Z";\n              i3 && Ebe(t3, n4);\n              var o4 = zd.ensureSingle(e3, "g", "contourfill"), s3 = o4.selectAll("path").data(i3 ? t3 : []);\n              s3.enter().append("path"), s3.exit().remove(), s3.each(function(l3) {\n                var u4 = (l3.prefixBoundary ? a4 : "") + kbe(l3, r4);\n                u4 ? D4.select(this).attr("d", u4).style("stroke", "none") : D4.select(this).remove();\n              });\n            }\n            function kbe(e3, t3) {\n              var r4 = "", n4 = 0, i3 = e3.edgepaths.map(function(p3, k4) {\n                return k4;\n              }), a4 = true, o4, s3, l3, u4, c5, f4;\n              function h3(p3) {\n                return Math.abs(p3[1] - t3[0][1]) < 0.01;\n              }\n              function d3(p3) {\n                return Math.abs(p3[1] - t3[2][1]) < 0.01;\n              }\n              function v3(p3) {\n                return Math.abs(p3[0] - t3[0][0]) < 0.01;\n              }\n              function _2(p3) {\n                return Math.abs(p3[0] - t3[2][0]) < 0.01;\n              }\n              for (; i3.length; ) {\n                for (f4 = qy.smoothopen(e3.edgepaths[n4], e3.smoothing), r4 += a4 ? f4 : f4.replace(/^M/, "L"), i3.splice(i3.indexOf(n4), 1), o4 = e3.edgepaths[n4][e3.edgepaths[n4].length - 1], u4 = -1, l3 = 0; l3 < 4; l3++) {\n                  if (!o4) {\n                    zd.log("Missing end?", n4, e3);\n                    break;\n                  }\n                  for (h3(o4) && !_2(o4) ? s3 = t3[1] : v3(o4) ? s3 = t3[0] : d3(o4) ? s3 = t3[3] : _2(o4) && (s3 = t3[2]), c5 = 0; c5 < e3.edgepaths.length; c5++) {\n                    var b = e3.edgepaths[c5][0];\n                    Math.abs(o4[0] - s3[0]) < 0.01 ? Math.abs(o4[0] - b[0]) < 0.01 && (b[1] - o4[1]) * (s3[1] - b[1]) >= 0 && (s3 = b, u4 = c5) : Math.abs(o4[1] - s3[1]) < 0.01 ? Math.abs(o4[1] - b[1]) < 0.01 && (b[0] - o4[0]) * (s3[0] - b[0]) >= 0 && (s3 = b, u4 = c5) : zd.log("endpt to newendpt is not vert. or horz.", o4, s3, b);\n                  }\n                  if (o4 = s3, u4 >= 0) break;\n                  r4 += "L" + s3;\n                }\n                if (u4 === e3.edgepaths.length) {\n                  zd.log("unclosed perimeter path");\n                  break;\n                }\n                n4 = u4, a4 = i3.indexOf(n4) === -1, a4 && (n4 = i3[0], r4 += "Z");\n              }\n              for (n4 = 0; n4 < e3.paths.length; n4++) r4 += qy.smoothclosed(e3.paths[n4], e3.smoothing);\n              return r4;\n            }\n            function qbt(e3, t3, r4, n4, i3) {\n              var a4 = r4._context.staticPlot, o4 = zd.ensureSingle(e3, "g", "contourlines"), s3 = i3.showlines !== false, l3 = i3.showlabels, u4 = s3 && l3, c5 = jv.createLines(o4, s3 || l3, t3, a4), f4 = jv.createLineClip(o4, u4, r4, n4.trace.uid), h3 = e3.selectAll("g.contourlabels").data(l3 ? [0] : []);\n              if (h3.exit().remove(), h3.enter().append("g").classed("contourlabels", true), l3) {\n                var d3 = [], v3 = [];\n                zd.clearLocationCache();\n                var _2 = jv.labelFormatter(r4, n4), b = qy.tester.append("text").attr("data-notex", 1).call(qy.font, i3.labelfont), p3 = t3[0].xaxis, k4 = t3[0].yaxis, E3 = p3._length, S2 = k4._length, L3 = p3.range, x2 = k4.range, C3 = zd.aggNums(Math.min, null, n4.x), M4 = zd.aggNums(Math.max, null, n4.x), g3 = zd.aggNums(Math.min, null, n4.y), P3 = zd.aggNums(Math.max, null, n4.y), T3 = Math.max(p3.c2p(C3, true), 0), z3 = Math.min(p3.c2p(M4, true), E3), O3 = Math.max(k4.c2p(P3, true), 0), V2 = Math.min(k4.c2p(g3, true), S2), G2 = {};\n                L3[0] < L3[1] ? (G2.left = T3, G2.right = z3) : (G2.left = z3, G2.right = T3), x2[0] < x2[1] ? (G2.top = O3, G2.bottom = V2) : (G2.top = V2, G2.bottom = O3), G2.middle = (G2.top + G2.bottom) / 2, G2.center = (G2.left + G2.right) / 2, d3.push([[G2.left, G2.top], [G2.right, G2.top], [G2.right, G2.bottom], [G2.left, G2.bottom]]);\n                var Z = Math.sqrt(E3 * E3 + S2 * S2), j3 = R4.LABELDISTANCE * Z / Math.max(1, t3.length / R4.LABELINCREASE);\n                c5.each(function(N2) {\n                  var H = jv.calcTextOpts(N2.level, _2, b, r4);\n                  D4.select(this).selectAll("path").each(function() {\n                    var te = this, oe = zd.getVisibleSegment(te, G2, H.height / 2);\n                    if (oe && !(oe.len < (H.width + H.height) * R4.LABELMIN)) for (var _e = Math.min(Math.ceil(oe.len / j3), R4.LABELMAX), Ee = 0; Ee < _e; Ee++) {\n                      var Ce = jv.findBestTextLocation(te, oe, H, v3, G2);\n                      if (!Ce) break;\n                      jv.addLabelData(Ce, H, v3, d3);\n                    }\n                  });\n                }), b.remove(), jv.drawLabels(h3, v3, r4, f4, u4 ? d3 : null);\n              }\n              l3 && !s3 && c5.remove();\n            }\n            jv.createLines = function(e3, t3, r4, n4) {\n              var i3 = r4[0].smoothing, a4 = e3.selectAll("g.contourlevel").data(t3 ? r4 : []);\n              if (a4.exit().remove(), a4.enter().append("g").classed("contourlevel", true), t3) {\n                var o4 = a4.selectAll("path.openline").data(function(l3) {\n                  return l3.pedgepaths || l3.edgepaths;\n                });\n                o4.exit().remove(), o4.enter().append("path").classed("openline", true), o4.attr("d", function(l3) {\n                  return qy.smoothopen(l3, i3);\n                }).style("stroke-miterlimit", 1).style("vector-effect", n4 ? "none" : "non-scaling-stroke");\n                var s3 = a4.selectAll("path.closedline").data(function(l3) {\n                  return l3.ppaths || l3.paths;\n                });\n                s3.exit().remove(), s3.enter().append("path").classed("closedline", true), s3.attr("d", function(l3) {\n                  return qy.smoothclosed(l3, i3);\n                }).style("stroke-miterlimit", 1).style("vector-effect", n4 ? "none" : "non-scaling-stroke");\n              }\n              return a4;\n            };\n            jv.createLineClip = function(e3, t3, r4, n4) {\n              var i3 = r4._fullLayout._clips, a4 = t3 ? "clipline" + n4 : null, o4 = i3.selectAll("#" + a4).data(t3 ? [0] : []);\n              return o4.exit().remove(), o4.enter().append("clipPath").classed("contourlineclip", true).attr("id", a4), qy.setClipUrl(e3, a4, r4), o4;\n            };\n            jv.labelFormatter = function(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3.trace, i3 = n4.contours, a4 = { type: "linear", _id: "ycontour", showexponent: "all", exponentformat: "B" };\n              if (i3.labelformat) a4.tickformat = i3.labelformat, Tbe(a4, r4);\n              else {\n                var o4 = Ibt.extractOpts(n4);\n                if (o4 && o4.colorbar && o4.colorbar._axis) a4 = o4.colorbar._axis;\n                else {\n                  if (i3.type === "constraint") {\n                    var s3 = i3.value;\n                    zd.isArrayOrTypedArray(s3) ? a4.range = [s3[0], s3[s3.length - 1]] : a4.range = [s3, s3];\n                  } else a4.range = [i3.start, i3.end], a4.nticks = (i3.end - i3.start) / i3.size;\n                  a4.range[0] === a4.range[1] && (a4.range[1] += a4.range[0] || 1), a4.nticks || (a4.nticks = 1e3), Tbe(a4, r4), wbe.prepTicks(a4), a4._tmin = null, a4._tmax = null;\n                }\n              }\n              return function(l3) {\n                return wbe.tickText(a4, l3).text;\n              };\n            };\n            jv.calcTextOpts = function(e3, t3, r4, n4) {\n              var i3 = t3(e3);\n              r4.text(i3).call(Abe.convertToTspans, n4);\n              var a4 = r4.node(), o4 = qy.bBox(a4, true);\n              return { text: i3, width: o4.width, height: o4.height, fontSize: +a4.style["font-size"].replace("px", ""), level: e3, dy: (o4.top + o4.bottom) / 2 };\n            };\n            jv.findBestTextLocation = function(e3, t3, r4, n4, i3) {\n              var a4 = r4.width, o4, s3, l3, u4, c5;\n              t3.isClosed ? (s3 = t3.len / Dm.INITIALSEARCHPOINTS, o4 = t3.min + s3 / 2, l3 = t3.max) : (s3 = (t3.len - a4) / (Dm.INITIALSEARCHPOINTS + 1), o4 = t3.min + s3 + a4 / 2, l3 = t3.max - (s3 + a4) / 2);\n              for (var f4 = 1 / 0, h3 = 0; h3 < Dm.ITERATIONS; h3++) {\n                for (var d3 = o4; d3 < l3; d3 += s3) {\n                  var v3 = zd.getTextLocation(e3, t3.total, d3, a4), _2 = Bbt(v3, r4, n4, i3);\n                  _2 < f4 && (f4 = _2, c5 = v3, u4 = d3);\n                }\n                if (f4 > Dm.MAXCOST * 2) break;\n                h3 && (s3 /= 2), o4 = u4 - s3 / 2, l3 = o4 + s3 * 1.5;\n              }\n              if (f4 <= Dm.MAXCOST) return c5;\n            };\n            function Bbt(e3, t3, r4, n4) {\n              var i3 = t3.width / 2, a4 = t3.height / 2, o4 = e3.x, s3 = e3.y, l3 = e3.theta, u4 = Math.cos(l3) * i3, c5 = Math.sin(l3) * i3, f4 = (o4 > n4.center ? n4.right - o4 : o4 - n4.left) / (u4 + Math.abs(Math.sin(l3) * a4)), h3 = (s3 > n4.middle ? n4.bottom - s3 : s3 - n4.top) / (Math.abs(c5) + Math.cos(l3) * a4);\n              if (f4 < 1 || h3 < 1) return 1 / 0;\n              var d3 = Dm.EDGECOST * (1 / (f4 - 1) + 1 / (h3 - 1));\n              d3 += Dm.ANGLECOST * l3 * l3;\n              for (var v3 = o4 - u4, _2 = s3 - c5, b = o4 + u4, p3 = s3 + c5, k4 = 0; k4 < r4.length; k4++) {\n                var E3 = r4[k4], S2 = Math.cos(E3.theta) * E3.width / 2, L3 = Math.sin(E3.theta) * E3.width / 2, x2 = zd.segmentDistance(v3, _2, b, p3, E3.x - S2, E3.y - L3, E3.x + S2, E3.y + L3) * 2 / (t3.height + E3.height), C3 = E3.level === t3.level, M4 = C3 ? Dm.SAMELEVELDISTANCE : 1;\n                if (x2 <= M4) return 1 / 0;\n                var g3 = Dm.NEIGHBORCOST * (C3 ? Dm.SAMELEVELFACTOR : 1);\n                d3 += g3 / (x2 - M4);\n              }\n              return d3;\n            }\n            jv.addLabelData = function(e3, t3, r4, n4) {\n              var i3 = t3.fontSize, a4 = t3.width + i3 / 3, o4 = Math.max(0, t3.height - i3 / 3), s3 = e3.x, l3 = e3.y, u4 = e3.theta, c5 = Math.sin(u4), f4 = Math.cos(u4), h3 = function(v3, _2) {\n                return [s3 + v3 * f4 - _2 * c5, l3 + v3 * c5 + _2 * f4];\n              }, d3 = [h3(-a4 / 2, -o4 / 2), h3(-a4 / 2, o4 / 2), h3(a4 / 2, o4 / 2), h3(a4 / 2, -o4 / 2)];\n              r4.push({ text: t3.text, x: s3, y: l3, dy: t3.dy, theta: u4, level: t3.level, width: a4, height: o4 }), n4.push(d3);\n            };\n            jv.drawLabels = function(e3, t3, r4, n4, i3) {\n              var a4 = e3.selectAll("text").data(t3, function(u4) {\n                return u4.text + "," + u4.x + "," + u4.y + "," + u4.theta;\n              });\n              if (a4.exit().remove(), a4.enter().append("text").attr({ "data-notex": 1, "text-anchor": "middle" }).each(function(u4) {\n                var c5 = u4.x + Math.sin(u4.theta) * u4.dy, f4 = u4.y - Math.cos(u4.theta) * u4.dy;\n                D4.select(this).text(u4.text).attr({ x: c5, y: f4, transform: "rotate(" + 180 * u4.theta / Math.PI + " " + c5 + " " + f4 + ")" }).call(Abe.convertToTspans, r4);\n              }), i3) {\n                for (var o4 = "", s3 = 0; s3 < i3.length; s3++) o4 += "M" + i3[s3].join("L") + "Z";\n                var l3 = zd.ensureSingle(n4, "path", "");\n                l3.attr("d", o4);\n              }\n            };\n            function Nbt(e3, t3, r4, n4, i3) {\n              var a4 = n4.trace, o4 = r4._fullLayout._clips, s3 = "clip" + a4.uid, l3 = o4.selectAll("#" + s3).data(a4.connectgaps ? [] : [0]);\n              if (l3.enter().append("clipPath").classed("contourclip", true).attr("id", s3), l3.exit().remove(), a4.connectgaps === false) {\n                var u4 = { level: 0.9, crossings: {}, starts: [], edgepaths: [], paths: [], xaxis: t3.xaxis, yaxis: t3.yaxis, x: n4.x, y: n4.y, z: Ubt(n4), smoothing: 0 };\n                Sbe([u4]), Mbe([u4]), Ebe([u4], { type: "levels" });\n                var c5 = zd.ensureSingle(l3, "path", "");\n                c5.attr("d", (u4.prefixBoundary ? "M" + i3.join("L") + "Z" : "") + kbe(u4, i3));\n              } else s3 = null;\n              qy.setClipUrl(e3, s3, r4);\n            }\n            function Ubt(e3) {\n              var t3 = e3.trace._emptypoints, r4 = [], n4 = e3.z.length, i3 = e3.z[0].length, a4, o4 = [], s3;\n              for (a4 = 0; a4 < i3; a4++) o4.push(1);\n              for (a4 = 0; a4 < n4; a4++) r4.push(o4.slice());\n              for (a4 = 0; a4 < t3.length; a4++) s3 = t3[a4], r4[s3[0]][s3[1]] = 0;\n              return e3.zmask = r4, r4;\n            }\n          });\n          var AG = ye((bcr, Cbe) => {\n            "use strict";\n            var Vbt = Oa(), TG = tc(), Gbt = L4();\n            Cbe.exports = function(t3) {\n              var r4 = t3.contours, n4 = r4.start, i3 = Gbt(r4), a4 = r4.size || 1, o4 = Math.floor((i3 - n4) / a4) + 1, s3 = r4.coloring === "lines" ? 0 : 1, l3 = TG.extractOpts(t3);\n              isFinite(a4) || (a4 = 1, o4 = 1);\n              var u4 = l3.reversescale ? TG.flipScale(l3.colorscale) : l3.colorscale, c5 = u4.length, f4 = new Array(c5), h3 = new Array(c5), d3, v3, _2 = l3.min, b = l3.max;\n              if (r4.coloring === "heatmap") {\n                for (v3 = 0; v3 < c5; v3++) d3 = u4[v3], f4[v3] = d3[0] * (b - _2) + _2, h3[v3] = d3[1];\n                var p3 = Vbt.extent([_2, b, r4.start, r4.start + a4 * (o4 - 1)]), k4 = p3[_2 < b ? 0 : 1], E3 = p3[_2 < b ? 1 : 0];\n                k4 !== _2 && (f4.splice(0, 0, k4), h3.splice(0, 0, h3[0])), E3 !== b && (f4.push(E3), h3.push(h3[h3.length - 1]));\n              } else {\n                var S2 = t3._input && typeof t3._input.zmin == "number" && typeof t3._input.zmax == "number";\n                for (S2 && (n4 <= _2 || i3 >= b) && (n4 <= _2 && (n4 = _2), i3 >= b && (i3 = b), o4 = Math.floor((i3 - n4) / a4) + 1, s3 = 0), v3 = 0; v3 < c5; v3++) d3 = u4[v3], f4[v3] = (d3[0] * (o4 + s3 - 1) - s3 / 2) * a4 + n4, h3[v3] = d3[1];\n                (S2 || t3.autocontour) && (f4[0] > _2 && (f4.unshift(_2), h3.unshift(h3[0])), f4[f4.length - 1] < b && (f4.push(b), h3.push(h3[h3.length - 1])));\n              }\n              return TG.makeColorScaleFunc({ domain: f4, range: h3 }, { noNumericCheck: true });\n            };\n          });\n          var L8 = ye((wcr, Pbe) => {\n            "use strict";\n            var C8 = Oa(), Lbe = So(), Hbt = v8(), jbt = AG();\n            Pbe.exports = function(t3) {\n              var r4 = C8.select(t3).selectAll("g.contour");\n              r4.style("opacity", function(n4) {\n                return n4[0].trace.opacity;\n              }), r4.each(function(n4) {\n                var i3 = C8.select(this), a4 = n4[0].trace, o4 = a4.contours, s3 = a4.line, l3 = o4.size || 1, u4 = o4.start, c5 = o4.type === "constraint", f4 = !c5 && o4.coloring === "lines", h3 = !c5 && o4.coloring === "fill", d3 = f4 || h3 ? jbt(a4) : null;\n                i3.selectAll("g.contourlevel").each(function(b) {\n                  C8.select(this).selectAll("path").call(Lbe.lineGroupStyle, s3.width, f4 ? d3(b.level) : s3.color, s3.dash);\n                });\n                var v3 = o4.labelfont;\n                if (i3.selectAll("g.contourlabels text").each(function(b) {\n                  Lbe.font(C8.select(this), { weight: v3.weight, style: v3.style, variant: v3.variant, textcase: v3.textcase, lineposition: v3.lineposition, shadow: v3.shadow, family: v3.family, size: v3.size, color: v3.color || (f4 ? d3(b.level) : s3.color) });\n                }), c5) i3.selectAll("g.contourfill path").style("fill", a4.fillcolor);\n                else if (h3) {\n                  var _2;\n                  i3.selectAll("g.contourfill path").style("fill", function(b) {\n                    return _2 === void 0 && (_2 = b.level), d3(b.level + 0.5 * l3);\n                  }), _2 === void 0 && (_2 = u4), i3.selectAll("g.contourbg path").style("fill", d3(_2 - 0.5 * l3));\n                }\n              }), Hbt(t3);\n            };\n          });\n          var P8 = ye((Tcr, Rbe) => {\n            "use strict";\n            var Ibe = tc(), Wbt = AG(), Xbt = L4();\n            function Zbt(e3, t3, r4) {\n              var n4 = t3.contours, i3 = t3.line, a4 = n4.size || 1, o4 = n4.coloring, s3 = Wbt(t3, { isColorbar: true });\n              if (o4 === "heatmap") {\n                var l3 = Ibe.extractOpts(t3);\n                r4._fillgradient = l3.reversescale ? Ibe.flipScale(l3.colorscale) : l3.colorscale, r4._zrange = [l3.min, l3.max];\n              } else o4 === "fill" && (r4._fillcolor = s3);\n              r4._line = { color: o4 === "lines" ? s3 : i3.color, width: n4.showlines !== false ? i3.width : 0, dash: i3.dash }, r4._levels = { start: n4.start, end: Xbt(n4), size: a4 };\n            }\n            Rbe.exports = { min: "zmin", max: "zmax", calc: Zbt };\n          });\n          var SG = ye((Acr, Dbe) => {\n            "use strict";\n            var I8 = ka(), Ybt = g8();\n            Dbe.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {}), a4.isContour = true;\n              var o4 = Ybt(t3, r4, n4, i3, a4);\n              return o4 && o4.forEach(function(s3) {\n                var l3 = s3.trace;\n                l3.contours.type === "constraint" && (l3.fillcolor && I8.opacity(l3.fillcolor) ? s3.color = I8.addOpacity(l3.fillcolor, 1) : l3.contours.showlines && I8.opacity(l3.line.color) && (s3.color = I8.addOpacity(l3.line.color, 1)));\n              }), o4;\n            };\n          });\n          var zbe = ye((Scr, Fbe) => {\n            "use strict";\n            Fbe.exports = { attributes: cG(), supplyDefaults: rbe(), crossTraceDefaults: _8(), calc: pG(), plot: k8().plot, layerName: "contourlayer", style: L8(), colorbar: P8(), hoverPoints: SG(), moduleType: "trace", name: "histogram2dcontour", basePlotModule: ph(), categories: ["cartesian", "svg", "2dMap", "contour", "histogram", "showLegend"], meta: {} };\n          });\n          var qbe = ye((Mcr, Obe) => {\n            "use strict";\n            Obe.exports = zbe();\n          });\n          var MG = ye((Ecr, Hbe) => {\n            "use strict";\n            var Bbe = Eo(), Kbt = fG(), Vbe = ka(), Nbe = Vbe.addOpacity, Jbt = Vbe.opacity, Gbe = w8(), Ube = Dr().isArrayOrTypedArray, $bt = Gbe.CONSTRAINT_REDUCTION, Qbt = Gbe.COMPARISON_OPS2;\n            Hbe.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = r4.contours, l3, u4, c5, f4 = n4("contours.operation");\n              if (s3._operation = $bt[f4], e2t(n4, s3), f4 === "=" ? l3 = s3.showlines = true : (l3 = n4("contours.showlines"), c5 = n4("fillcolor", Nbe((t3.line || {}).color || a4, 0.5))), l3) {\n                var h3 = c5 && Jbt(c5) ? Nbe(r4.fillcolor, 1) : a4;\n                u4 = n4("line.color", h3), n4("line.width", 2), n4("line.dash");\n              }\n              n4("line.smoothing"), Kbt(n4, i3, u4, o4);\n            };\n            function e2t(e3, t3) {\n              var r4;\n              Qbt.indexOf(t3.operation) === -1 ? (e3("contours.value", [0, 1]), Ube(t3.value) ? t3.value.length > 2 ? t3.value = t3.value.slice(2) : t3.length === 0 ? t3.value = [0, 1] : t3.length < 2 ? (r4 = parseFloat(t3.value[0]), t3.value = [r4, r4 + 1]) : t3.value = [parseFloat(t3.value[0]), parseFloat(t3.value[1])] : Bbe(t3.value) && (r4 = parseFloat(t3.value), t3.value = [r4, r4 + 1])) : (e3("contours.value", 0), Bbe(t3.value) || (Ube(t3.value) ? t3.value = parseFloat(t3.value[0]) : t3.value = 0));\n            }\n          });\n          var Xbe = ye((kcr, Wbe) => {\n            "use strict";\n            var EG = Dr(), t2t = e8(), r2t = Ig(), i2t = MG(), n2t = A8(), a2t = S8(), o2t = A4(), jbe = C4();\n            Wbe.exports = function(t3, r4, n4, i3) {\n              function a4(u4, c5) {\n                return EG.coerce(t3, r4, jbe, u4, c5);\n              }\n              function o4(u4) {\n                return EG.coerce2(t3, r4, jbe, u4);\n              }\n              var s3 = t2t(t3, r4, a4, i3);\n              if (!s3) {\n                r4.visible = false;\n                return;\n              }\n              r2t(t3, r4, i3, a4), a4("xhoverformat"), a4("yhoverformat"), a4("text"), a4("hovertext"), a4("hoverongaps"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var l3 = a4("contours.type") === "constraint";\n              a4("connectgaps", EG.isArray1D(r4.z)), l3 ? i2t(t3, r4, a4, i3, n4) : (n2t(t3, r4, a4, o4), a2t(t3, r4, a4, i3)), r4.contours && r4.contours.coloring === "heatmap" && o2t(a4, i3), a4("zorder");\n            };\n          });\n          var Ybe = ye((Ccr, Zbe) => {\n            "use strict";\n            Zbe.exports = { attributes: C4(), supplyDefaults: Xbe(), calc: pG(), plot: k8().plot, style: L8(), colorbar: P8(), hoverPoints: SG(), moduleType: "trace", name: "contour", basePlotModule: ph(), categories: ["cartesian", "svg", "2dMap", "contour", "showLegend"], meta: {} };\n          });\n          var Jbe = ye((Lcr, Kbe) => {\n            "use strict";\n            Kbe.exports = Ybe();\n          });\n          var kG = ye((Pcr, e2e) => {\n            "use strict";\n            var { hovertemplateAttrs: s2t, texttemplateAttrs: l2t, templatefallbackAttrs: $be } = Ll(), u2t = Cg(), a0 = pf(), c2t = Gl(), Qbe = Tu(), f2t = Pd().dash, M_ = Ao().extendFlat, j0 = a0.marker, F4 = a0.line, h2t = j0.line;\n            e2e.exports = { a: { valType: "data_array", editType: "calc" }, b: { valType: "data_array", editType: "calc" }, c: { valType: "data_array", editType: "calc" }, sum: { valType: "number", dflt: 0, min: 0, editType: "calc" }, mode: M_({}, a0.mode, { dflt: "markers" }), text: M_({}, a0.text, {}), texttemplate: l2t({ editType: "plot" }, { keys: ["a", "b", "c", "text"] }), texttemplatefallback: $be({ editType: "plot" }), hovertext: M_({}, a0.hovertext, {}), line: { color: F4.color, width: F4.width, dash: f2t, backoff: F4.backoff, shape: M_({}, F4.shape, { values: ["linear", "spline"] }), smoothing: F4.smoothing, editType: "calc" }, connectgaps: a0.connectgaps, cliponaxis: a0.cliponaxis, fill: M_({}, a0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: u2t(), marker: M_({ symbol: j0.symbol, opacity: j0.opacity, angle: j0.angle, angleref: j0.angleref, standoff: j0.standoff, maxdisplayed: j0.maxdisplayed, size: j0.size, sizeref: j0.sizeref, sizemin: j0.sizemin, sizemode: j0.sizemode, line: M_({ width: h2t.width, editType: "calc" }, Qbe("marker.line")), gradient: j0.gradient, editType: "calc" }, Qbe("marker")), textfont: a0.textfont, textposition: a0.textposition, selected: a0.selected, unselected: a0.unselected, hoverinfo: M_({}, c2t.hoverinfo, { flags: ["a", "b", "c", "text", "name"] }), hoveron: a0.hoveron, hovertemplate: s2t(), hovertemplatefallback: $be() };\n          });\n          var n2e = ye((Icr, i2e) => {\n            "use strict";\n            var t2e = Dr(), d2t = Sm(), BT = Ru(), v2t = $p(), p2t = R0(), r2e = tT(), g2t = D0(), m2t = Rg(), y2t = kG();\n            i2e.exports = function(t3, r4, n4, i3) {\n              function a4(h3, d3) {\n                return t2e.coerce(t3, r4, y2t, h3, d3);\n              }\n              var o4 = a4("a"), s3 = a4("b"), l3 = a4("c"), u4;\n              if (o4 ? (u4 = o4.length, s3 ? (u4 = Math.min(u4, s3.length), l3 && (u4 = Math.min(u4, l3.length))) : l3 ? u4 = Math.min(u4, l3.length) : u4 = 0) : s3 && l3 && (u4 = Math.min(s3.length, l3.length)), !u4) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = u4, a4("sum"), a4("text"), a4("hovertext"), r4.hoveron !== "fills" && (a4("hovertemplate"), a4("hovertemplatefallback"));\n              var c5 = u4 < d2t.PTS_LINESONLY ? "lines+markers" : "lines";\n              a4("mode", c5), BT.hasMarkers(r4) && v2t(t3, r4, n4, i3, a4, { gradient: true }), BT.hasLines(r4) && (p2t(t3, r4, n4, i3, a4, { backoff: true }), r2e(t3, r4, a4), a4("connectgaps")), BT.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), g2t(t3, r4, i3, a4));\n              var f4 = [];\n              (BT.hasMarkers(r4) || BT.hasText(r4)) && (a4("cliponaxis"), a4("marker.maxdisplayed"), f4.push("points")), a4("fill"), r4.fill !== "none" && (m2t(t3, r4, n4, a4), BT.hasLines(r4) || r2e(t3, r4, a4)), (r4.fill === "tonext" || r4.fill === "toself") && f4.push("fills"), a4("hoveron", f4.join("+") || "points"), t2e.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var o2e = ye((Rcr, a2e) => {\n            "use strict";\n            var CG = ho();\n            a2e.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.subplot]._subplot;\n              return i3.aLabel = CG.tickText(a4.aaxis, t3.a, true).text, i3.bLabel = CG.tickText(a4.baxis, t3.b, true).text, i3.cLabel = CG.tickText(a4.caxis, t3.c, true).text, i3;\n            };\n          });\n          var c2e = ye((Dcr, u2e) => {\n            "use strict";\n            var LG = Eo(), _2t = F0(), x2t = km(), b2t = z0(), w2t = O0().calcMarkerSize, s2e = ["a", "b", "c"], l2e = { a: ["b", "c"], b: ["a", "c"], c: ["a", "b"] };\n            u2e.exports = function(t3, r4) {\n              var n4 = t3._fullLayout[r4.subplot], i3 = n4.sum, a4 = r4.sum || i3, o4 = { a: r4.a, b: r4.b, c: r4.c }, s3 = r4.ids, l3, u4, c5, f4, h3, d3;\n              for (l3 = 0; l3 < s2e.length; l3++) if (c5 = s2e[l3], !o4[c5]) {\n                for (h3 = o4[l2e[c5][0]], d3 = o4[l2e[c5][1]], f4 = new Array(h3.length), u4 = 0; u4 < h3.length; u4++) f4[u4] = a4 - h3[u4] - d3[u4];\n                o4[c5] = f4;\n              }\n              var v3 = r4._length, _2 = new Array(v3), b, p3, k4, E3, S2, L3;\n              for (l3 = 0; l3 < v3; l3++) b = o4.a[l3], p3 = o4.b[l3], k4 = o4.c[l3], LG(b) && LG(p3) && LG(k4) ? (b = +b, p3 = +p3, k4 = +k4, E3 = i3 / (b + p3 + k4), E3 !== 1 && (b *= E3, p3 *= E3, k4 *= E3), L3 = b, S2 = k4 - p3, _2[l3] = { x: S2, y: L3, a: b, b: p3, c: k4 }, s3 && (_2[l3].id = s3[l3])) : _2[l3] = { x: false, y: false };\n              return w2t(r4, v3), _2t(t3, r4), x2t(_2, r4), b2t(_2, r4), _2;\n            };\n          });\n          var h2e = ye((Fcr, f2e) => {\n            "use strict";\n            var T2t = sT();\n            f2e.exports = function(t3, r4, n4) {\n              var i3 = r4.plotContainer;\n              i3.select(".scatterlayer").selectAll("*").remove();\n              for (var a4 = r4.xaxis, o4 = r4.yaxis, s3 = { xaxis: a4, yaxis: o4, plot: i3, layerClipId: r4._hasClipOnAxisFalse ? r4.clipIdRelative : null }, l3 = r4.layers.frontplot.select("g.scatterlayer"), u4 = 0; u4 < n4.length; u4++) {\n                var c5 = n4[u4];\n                c5.length && (c5[0].trace._xA = a4, c5[0].trace._yA = o4);\n              }\n              T2t(t3, s3, n4, l3);\n            };\n          });\n          var v2e = ye((zcr, d2e) => {\n            "use strict";\n            var A2t = fT();\n            d2e.exports = function(t3, r4, n4, i3) {\n              var a4 = A2t(t3, r4, n4, i3);\n              if (!a4 || a4[0].index === false) return;\n              var o4 = a4[0];\n              if (o4.index === void 0) {\n                var s3 = 1 - o4.y0 / t3.ya._length, l3 = t3.xa._length, u4 = l3 * s3 / 2, c5 = l3 - u4;\n                return o4.x0 = Math.max(Math.min(o4.x0, c5), u4), o4.x1 = Math.max(Math.min(o4.x1, c5), u4), a4;\n              }\n              var f4 = o4.cd[o4.index], h3 = o4.trace, d3 = o4.subplot;\n              o4.a = f4.a, o4.b = f4.b, o4.c = f4.c, o4.xLabelVal = void 0, o4.yLabelVal = void 0;\n              var v3 = {};\n              v3[h3.subplot] = { _subplot: d3 };\n              var _2 = h3._module.formatLabels(f4, h3, v3);\n              o4.aLabel = _2.aLabel, o4.bLabel = _2.bLabel, o4.cLabel = _2.cLabel;\n              var b = f4.hi || h3.hoverinfo, p3 = [];\n              function k4(S2, L3) {\n                p3.push(S2._hovertitle + ": " + L3);\n              }\n              if (!h3.hovertemplate) {\n                var E3 = b.split("+");\n                E3.indexOf("all") !== -1 && (E3 = ["a", "b", "c"]), E3.indexOf("a") !== -1 && k4(d3.aaxis, o4.aLabel), E3.indexOf("b") !== -1 && k4(d3.baxis, o4.bLabel), E3.indexOf("c") !== -1 && k4(d3.caxis, o4.cLabel);\n              }\n              return o4.extraText = p3.join("<br>"), o4.hovertemplate = h3.hovertemplate, a4;\n            };\n          });\n          var g2e = ye((Ocr, p2e) => {\n            "use strict";\n            p2e.exports = function(t3, r4, n4, i3, a4) {\n              if (r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), i3[a4]) {\n                var o4 = i3[a4];\n                t3.a = o4.a, t3.b = o4.b, t3.c = o4.c;\n              } else t3.a = r4.a, t3.b = r4.b, t3.c = r4.c;\n              return t3;\n            };\n          });\n          var E2e = ye((qcr, M2e) => {\n            "use strict";\n            var w2e = Oa(), S2t = cd(), PG = qa(), By = Dr(), Fm = By.strTranslate, R8 = By._, UT = ka(), D8 = So(), z4 = ym(), IG = Ao().extendFlat, M2t = Mc(), E_ = ho(), m2e = yv(), y2e = vf(), T2e = Eg(), _2e = T2e.freeMode, E2t = T2e.rectMode, RG = Eb(), k2t = Of().prepSelect, C2t = Of().selectOnClick, L2t = Of().clearOutline, P2t = Of().clearSelectionsCache, A2e = hd();\n            function S2e(e3, t3) {\n              this.id = e3.id, this.graphDiv = e3.graphDiv, this.init(t3), this.makeFramework(t3), this.updateFx(t3), this.aTickLayout = null, this.bTickLayout = null, this.cTickLayout = null;\n            }\n            M2e.exports = S2e;\n            var zm = S2e.prototype;\n            zm.init = function(e3) {\n              this.container = e3._ternarylayer, this.defs = e3._defs, this.layoutId = e3._uid, this.traceHash = {}, this.layers = {};\n            };\n            zm.plot = function(e3, t3) {\n              var r4 = this, n4 = t3[r4.id], i3 = t3._size;\n              r4._hasClipOnAxisFalse = false;\n              for (var a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4][0].trace;\n                if (o4.cliponaxis === false) {\n                  r4._hasClipOnAxisFalse = true;\n                  break;\n                }\n              }\n              r4.updateLayers(n4), r4.adjustLayout(n4, i3), M2t.generalUpdatePerTraceModule(r4.graphDiv, r4, e3, n4), r4.layers.plotbg.select("path").call(UT.fill, n4.bgcolor);\n            };\n            zm.makeFramework = function(e3) {\n              var t3 = this, r4 = t3.graphDiv, n4 = e3[t3.id], i3 = t3.clipId = "clip" + t3.layoutId + t3.id, a4 = t3.clipIdRelative = "clip-relative" + t3.layoutId + t3.id;\n              t3.clipDef = By.ensureSingleById(e3._clips, "clipPath", i3, function(o4) {\n                o4.append("path").attr("d", "M0,0Z");\n              }), t3.clipDefRelative = By.ensureSingleById(e3._clips, "clipPath", a4, function(o4) {\n                o4.append("path").attr("d", "M0,0Z");\n              }), t3.plotContainer = By.ensureSingle(t3.container, "g", t3.id), t3.updateLayers(n4), D8.setClipUrl(t3.layers.backplot, i3, r4), D8.setClipUrl(t3.layers.grids, i3, r4);\n            };\n            zm.updateFx = function(e3) {\n              e3._ternarylayer.selectAll("g.toplevel").style("cursor", e3.dragmode === "pan" ? "move" : "crosshair");\n            };\n            zm.updateLayers = function(e3) {\n              var t3 = this, r4 = t3.layers, n4 = ["draglayer", "plotbg", "backplot", "grids"];\n              e3.aaxis.layer === "below traces" && n4.push("aaxis", "aline"), e3.baxis.layer === "below traces" && n4.push("baxis", "bline"), e3.caxis.layer === "below traces" && n4.push("caxis", "cline"), n4.push("frontplot"), e3.aaxis.layer === "above traces" && n4.push("aaxis", "aline"), e3.baxis.layer === "above traces" && n4.push("baxis", "bline"), e3.caxis.layer === "above traces" && n4.push("caxis", "cline");\n              var i3 = t3.plotContainer.selectAll("g.toplevel").data(n4, String), a4 = ["agrid", "bgrid", "cgrid"];\n              i3.enter().append("g").attr("class", function(o4) {\n                return "toplevel " + o4;\n              }).each(function(o4) {\n                var s3 = w2e.select(this);\n                r4[o4] = s3, o4 === "frontplot" ? s3.append("g").classed("scatterlayer", true) : o4 === "backplot" ? s3.append("g").classed("maplayer", true) : o4 === "plotbg" ? s3.append("path").attr("d", "M0,0Z") : o4 === "aline" || o4 === "bline" || o4 === "cline" ? s3.append("path") : o4 === "grids" && a4.forEach(function(l3) {\n                  r4[l3] = s3.append("g").classed("grid " + l3, true);\n                });\n              }), i3.order();\n            };\n            var NT = Math.sqrt(4 / 3);\n            zm.adjustLayout = function(e3, t3) {\n              var r4 = this, n4 = e3.domain, i3 = (n4.x[0] + n4.x[1]) / 2, a4 = (n4.y[0] + n4.y[1]) / 2, o4 = n4.x[1] - n4.x[0], s3 = n4.y[1] - n4.y[0], l3 = o4 * t3.w, u4 = s3 * t3.h, c5 = e3.sum, f4 = e3.aaxis.min, h3 = e3.baxis.min, d3 = e3.caxis.min, v3, _2, b, p3, k4, E3;\n              l3 > NT * u4 ? (p3 = u4, b = p3 * NT) : (b = l3, p3 = b / NT), k4 = o4 * b / l3, E3 = s3 * p3 / u4, v3 = t3.l + t3.w * i3 - b / 2, _2 = t3.t + t3.h * (1 - a4) - p3 / 2, r4.x0 = v3, r4.y0 = _2, r4.w = b, r4.h = p3, r4.sum = c5, r4.xaxis = { type: "linear", range: [f4 + 2 * d3 - c5, c5 - f4 - 2 * h3], domain: [i3 - k4 / 2, i3 + k4 / 2], _id: "x" }, z4(r4.xaxis, r4.graphDiv._fullLayout), r4.xaxis.setScale(), r4.xaxis.isPtWithinRange = function(V2) {\n                return V2.a >= r4.aaxis.range[0] && V2.a <= r4.aaxis.range[1] && V2.b >= r4.baxis.range[1] && V2.b <= r4.baxis.range[0] && V2.c >= r4.caxis.range[1] && V2.c <= r4.caxis.range[0];\n              }, r4.yaxis = { type: "linear", range: [f4, c5 - h3 - d3], domain: [a4 - E3 / 2, a4 + E3 / 2], _id: "y" }, z4(r4.yaxis, r4.graphDiv._fullLayout), r4.yaxis.setScale(), r4.yaxis.isPtWithinRange = function() {\n                return true;\n              };\n              var S2 = r4.yaxis.domain[0], L3 = r4.aaxis = IG({}, e3.aaxis, { range: [f4, c5 - h3 - d3], side: "left", tickangle: (+e3.aaxis.tickangle || 0) - 30, domain: [S2, S2 + E3 * NT], anchor: "free", position: 0, _id: "y", _length: b });\n              z4(L3, r4.graphDiv._fullLayout), L3.setScale();\n              var x2 = r4.baxis = IG({}, e3.baxis, { range: [c5 - f4 - d3, h3], side: "bottom", domain: r4.xaxis.domain, anchor: "free", position: 0, _id: "x", _length: b });\n              z4(x2, r4.graphDiv._fullLayout), x2.setScale();\n              var C3 = r4.caxis = IG({}, e3.caxis, { range: [c5 - f4 - h3, d3], side: "right", tickangle: (+e3.caxis.tickangle || 0) + 30, domain: [S2, S2 + E3 * NT], anchor: "free", position: 0, _id: "y", _length: b });\n              z4(C3, r4.graphDiv._fullLayout), C3.setScale();\n              var M4 = "M" + v3 + "," + (_2 + p3) + "h" + b + "l-" + b / 2 + ",-" + p3 + "Z";\n              r4.clipDef.select("path").attr("d", M4), r4.layers.plotbg.select("path").attr("d", M4);\n              var g3 = "M0," + p3 + "h" + b + "l-" + b / 2 + ",-" + p3 + "Z";\n              r4.clipDefRelative.select("path").attr("d", g3);\n              var P3 = Fm(v3, _2);\n              r4.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", P3), r4.clipDefRelative.select("path").attr("transform", null);\n              var T3 = Fm(v3 - x2._offset, _2 + p3);\n              r4.layers.baxis.attr("transform", T3), r4.layers.bgrid.attr("transform", T3);\n              var z3 = Fm(v3 + b / 2, _2) + "rotate(30)" + Fm(0, -L3._offset);\n              r4.layers.aaxis.attr("transform", z3), r4.layers.agrid.attr("transform", z3);\n              var O3 = Fm(v3 + b / 2, _2) + "rotate(-30)" + Fm(0, -C3._offset);\n              r4.layers.caxis.attr("transform", O3), r4.layers.cgrid.attr("transform", O3), r4.drawAxes(true), r4.layers.aline.select("path").attr("d", L3.showline ? "M" + v3 + "," + (_2 + p3) + "l" + b / 2 + ",-" + p3 : "M0,0").call(UT.stroke, L3.linecolor || "#000").style("stroke-width", (L3.linewidth || 0) + "px"), r4.layers.bline.select("path").attr("d", x2.showline ? "M" + v3 + "," + (_2 + p3) + "h" + b : "M0,0").call(UT.stroke, x2.linecolor || "#000").style("stroke-width", (x2.linewidth || 0) + "px"), r4.layers.cline.select("path").attr("d", C3.showline ? "M" + (v3 + b / 2) + "," + _2 + "l" + b / 2 + "," + p3 : "M0,0").call(UT.stroke, C3.linecolor || "#000").style("stroke-width", (C3.linewidth || 0) + "px"), r4.graphDiv._context.staticPlot || r4.initInteractions(), D8.setClipUrl(r4.layers.frontplot, r4._hasClipOnAxisFalse ? null : r4.clipId, r4.graphDiv);\n            };\n            zm.drawAxes = function(e3) {\n              var t3 = this, r4 = t3.graphDiv, n4 = t3.id.slice(7) + "title", i3 = t3.layers, a4 = t3.aaxis, o4 = t3.baxis, s3 = t3.caxis;\n              if (t3.drawAx(a4), t3.drawAx(o4), t3.drawAx(s3), e3) {\n                var l3 = Math.max(a4.showticklabels ? a4.tickfont.size / 2 : 0, (s3.showticklabels ? s3.tickfont.size * 0.75 : 0) + (s3.ticks === "outside" ? s3.ticklen * 0.87 : 0)), u4 = (o4.showticklabels ? o4.tickfont.size : 0) + (o4.ticks === "outside" ? o4.ticklen : 0) + 3;\n                i3["a-title"] = RG.draw(r4, "a" + n4, { propContainer: a4, propName: t3.id + ".aaxis.title.text", placeholder: R8(r4, "Click to enter Component A title"), attributes: { x: t3.x0 + t3.w / 2, y: t3.y0 - a4.title.font.size / 3 - l3, "text-anchor": "middle" } }), i3["b-title"] = RG.draw(r4, "b" + n4, { propContainer: o4, propName: t3.id + ".baxis.title.text", placeholder: R8(r4, "Click to enter Component B title"), attributes: { x: t3.x0 - u4, y: t3.y0 + t3.h + o4.title.font.size * 0.83 + u4, "text-anchor": "middle" } }), i3["c-title"] = RG.draw(r4, "c" + n4, { propContainer: s3, propName: t3.id + ".caxis.title.text", placeholder: R8(r4, "Click to enter Component C title"), attributes: { x: t3.x0 + t3.w + u4, y: t3.y0 + t3.h + s3.title.font.size * 0.83 + u4, "text-anchor": "middle" } });\n              }\n            };\n            zm.drawAx = function(e3) {\n              var t3 = this, r4 = t3.graphDiv, n4 = e3._name, i3 = n4.charAt(0), a4 = e3._id, o4 = t3.layers[n4], s3 = 30, l3 = i3 + "tickLayout", u4 = I2t(e3);\n              t3[l3] !== u4 && (o4.selectAll("." + a4 + "tick").remove(), t3[l3] = u4), e3.setScale();\n              var c5 = E_.calcTicks(e3), f4 = E_.clipEnds(e3, c5), h3 = E_.makeTransTickFn(e3), d3 = E_.getTickSigns(e3)[2], v3 = By.deg2rad(s3), _2 = d3 * (e3.linewidth || 1) / 2, b = d3 * e3.ticklen, p3 = t3.w, k4 = t3.h, E3 = i3 === "b" ? "M0," + _2 + "l" + Math.sin(v3) * b + "," + Math.cos(v3) * b : "M" + _2 + ",0l" + Math.cos(v3) * b + "," + -Math.sin(v3) * b, S2 = { a: "M0,0l" + k4 + ",-" + p3 / 2, b: "M0,0l-" + p3 / 2 + ",-" + k4, c: "M0,0l-" + k4 + "," + p3 / 2 }[i3];\n              E_.drawTicks(r4, e3, { vals: e3.ticks === "inside" ? f4 : c5, layer: o4, path: E3, transFn: h3, crisp: false }), E_.drawGrid(r4, e3, { vals: f4, layer: t3.layers[i3 + "grid"], path: S2, transFn: h3, crisp: false }), E_.drawLabels(r4, e3, { vals: c5, layer: o4, transFn: h3, labelFns: E_.makeLabelFns(e3, 0, s3) });\n            };\n            function I2t(e3) {\n              return e3.ticks + String(e3.ticklen) + String(e3.showticklabels);\n            }\n            var yd = A2e.MINZOOM / 2 + 0.87, R2t = "m-0.87,.5h" + yd + "v3h-" + (yd + 5.2) + "l" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l2.6,1.5l-" + yd / 2 + "," + yd * 0.87 + "Z", D2t = "m0.87,.5h-" + yd + "v3h" + (yd + 5.2) + "l-" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l-2.6,1.5l" + yd / 2 + "," + yd * 0.87 + "Z", F2t = "m0,1l" + yd / 2 + "," + yd * 0.87 + "l2.6,-1.5l-" + (yd / 2 + 2.6) + ",-" + (yd * 0.87 + 4.5) + "l-" + (yd / 2 + 2.6) + "," + (yd * 0.87 + 4.5) + "l2.6,1.5l" + yd / 2 + ",-" + yd * 0.87 + "Z", z2t = "m0.5,0.5h5v-2h-5v-5h-2v5h-5v2h5v5h2Z", x2e = true;\n            zm.clearOutline = function() {\n              P2t(this.dragOptions), L2t(this.dragOptions.gd);\n            };\n            zm.initInteractions = function() {\n              var e3 = this, t3 = e3.layers.plotbg.select("path").node(), r4 = e3.graphDiv, n4 = r4._fullLayout._zoomlayer, i3, a4;\n              this.dragOptions = { element: t3, gd: r4, plotinfo: { id: e3.id, domain: r4._fullLayout[e3.id].domain, xaxis: e3.xaxis, yaxis: e3.yaxis }, subplot: e3.id, prepFn: function(T3, z3, O3) {\n                e3.dragOptions.xaxes = [e3.xaxis], e3.dragOptions.yaxes = [e3.yaxis], i3 = r4._fullLayout._invScaleX, a4 = r4._fullLayout._invScaleY;\n                var V2 = e3.dragOptions.dragmode = r4._fullLayout.dragmode;\n                _2e(V2) ? e3.dragOptions.minDrag = 1 : e3.dragOptions.minDrag = void 0, V2 === "zoom" ? (e3.dragOptions.moveFn = x2, e3.dragOptions.clickFn = p3, e3.dragOptions.doneFn = C3, k4(T3, z3, O3)) : V2 === "pan" ? (e3.dragOptions.moveFn = g3, e3.dragOptions.clickFn = p3, e3.dragOptions.doneFn = P3, M4(), e3.clearOutline(r4)) : (E2t(V2) || _2e(V2)) && k2t(T3, z3, O3, e3.dragOptions, V2);\n              } };\n              var o4, s3, l3, u4, c5, f4, h3, d3, v3, _2;\n              function b(T3) {\n                var z3 = {};\n                return z3[e3.id + ".aaxis.min"] = T3.a, z3[e3.id + ".baxis.min"] = T3.b, z3[e3.id + ".caxis.min"] = T3.c, z3;\n              }\n              function p3(T3, z3) {\n                var O3 = r4._fullLayout.clickmode;\n                b2e(r4), T3 === 2 && (r4.emit("plotly_doubleclick", null), PG.call("_guiRelayout", r4, b({ a: 0, b: 0, c: 0 }))), O3.indexOf("select") > -1 && T3 === 1 && C2t(z3, r4, [e3.xaxis], [e3.yaxis], e3.id, e3.dragOptions), O3.indexOf("event") > -1 && y2e.click(r4, z3, e3.id);\n              }\n              function k4(T3, z3, O3) {\n                var V2 = t3.getBoundingClientRect();\n                o4 = z3 - V2.left, s3 = O3 - V2.top, r4._fullLayout._calcInverseTransform(r4);\n                var G2 = r4._fullLayout._invTransform, Z = By.apply3DTransform(G2)(o4, s3);\n                o4 = Z[0], s3 = Z[1], l3 = { a: e3.aaxis.range[0], b: e3.baxis.range[1], c: e3.caxis.range[1] }, c5 = l3, u4 = e3.aaxis.range[1] - l3.a, f4 = S2t(e3.graphDiv._fullLayout[e3.id].bgcolor).getLuminance(), h3 = "M0," + e3.h + "L" + e3.w / 2 + ", 0L" + e3.w + "," + e3.h + "Z", d3 = false, v3 = n4.append("path").attr("class", "zoombox").attr("transform", Fm(e3.x0, e3.y0)).style({ fill: f4 > 0.2 ? "rgba(0,0,0,0)" : "rgba(255,255,255,0)", "stroke-width": 0 }).attr("d", h3), _2 = n4.append("path").attr("class", "zoombox-corners").attr("transform", Fm(e3.x0, e3.y0)).style({ fill: UT.background, stroke: UT.defaultLine, "stroke-width": 1, opacity: 0 }).attr("d", "M0,0Z"), e3.clearOutline(r4);\n              }\n              function E3(T3, z3) {\n                return 1 - z3 / e3.h;\n              }\n              function S2(T3, z3) {\n                return 1 - (T3 + (e3.h - z3) / Math.sqrt(3)) / e3.w;\n              }\n              function L3(T3, z3) {\n                return (T3 - (e3.h - z3) / Math.sqrt(3)) / e3.w;\n              }\n              function x2(T3, z3) {\n                var O3 = o4 + T3 * i3, V2 = s3 + z3 * a4, G2 = Math.max(0, Math.min(1, E3(o4, s3), E3(O3, V2))), Z = Math.max(0, Math.min(1, S2(o4, s3), S2(O3, V2))), j3 = Math.max(0, Math.min(1, L3(o4, s3), L3(O3, V2))), N2 = (G2 / 2 + j3) * e3.w, H = (1 - G2 / 2 - Z) * e3.w, te = (N2 + H) / 2, oe = H - N2, _e = (1 - G2) * e3.h, Ee = _e - oe / NT;\n                oe < A2e.MINZOOM ? (c5 = l3, v3.attr("d", h3), _2.attr("d", "M0,0Z")) : (c5 = { a: l3.a + G2 * u4, b: l3.b + Z * u4, c: l3.c + j3 * u4 }, v3.attr("d", h3 + "M" + N2 + "," + _e + "H" + H + "L" + te + "," + Ee + "L" + N2 + "," + _e + "Z"), _2.attr("d", "M" + o4 + "," + s3 + z2t + "M" + N2 + "," + _e + R2t + "M" + H + "," + _e + D2t + "M" + te + "," + Ee + F2t)), d3 || (v3.transition().style("fill", f4 > 0.2 ? "rgba(0,0,0,0.4)" : "rgba(255,255,255,0.3)").duration(200), _2.transition().style("opacity", 1).duration(200), d3 = true), r4.emit("plotly_relayouting", b(c5));\n              }\n              function C3() {\n                b2e(r4), c5 !== l3 && (PG.call("_guiRelayout", r4, b(c5)), x2e && r4.data && r4._context.showTips && (By.notifier(R8(r4, "Double-click to zoom back out"), "long"), x2e = false));\n              }\n              function M4() {\n                l3 = { a: e3.aaxis.range[0], b: e3.baxis.range[1], c: e3.caxis.range[1] }, c5 = l3;\n              }\n              function g3(T3, z3) {\n                var O3 = T3 / e3.xaxis._m, V2 = z3 / e3.yaxis._m;\n                c5 = { a: l3.a - V2, b: l3.b + (O3 + V2) / 2, c: l3.c - (O3 - V2) / 2 };\n                var G2 = [c5.a, c5.b, c5.c].sort(By.sorterAsc), Z = { a: G2.indexOf(c5.a), b: G2.indexOf(c5.b), c: G2.indexOf(c5.c) };\n                G2[0] < 0 && (G2[1] + G2[0] / 2 < 0 ? (G2[2] += G2[0] + G2[1], G2[0] = G2[1] = 0) : (G2[2] += G2[0] / 2, G2[1] += G2[0] / 2, G2[0] = 0), c5 = { a: G2[Z.a], b: G2[Z.b], c: G2[Z.c] }, z3 = (l3.a - c5.a) * e3.yaxis._m, T3 = (l3.c - c5.c - l3.b + c5.b) * e3.xaxis._m);\n                var j3 = Fm(e3.x0 + T3, e3.y0 + z3);\n                e3.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform", j3);\n                var N2 = Fm(-T3, -z3);\n                e3.clipDefRelative.select("path").attr("transform", N2), e3.aaxis.range = [c5.a, e3.sum - c5.b - c5.c], e3.baxis.range = [e3.sum - c5.a - c5.c, c5.b], e3.caxis.range = [e3.sum - c5.a - c5.b, c5.c], e3.drawAxes(false), e3._hasClipOnAxisFalse && e3.plotContainer.select(".scatterlayer").selectAll(".trace").call(D8.hideOutsideRangePoints, e3), r4.emit("plotly_relayouting", b(c5));\n              }\n              function P3() {\n                PG.call("_guiRelayout", r4, b(c5));\n              }\n              t3.onmousemove = function(T3) {\n                y2e.hover(r4, T3, e3.id), r4._fullLayout._lasthover = t3, r4._fullLayout._hoversubplot = e3.id;\n              }, t3.onmouseout = function(T3) {\n                r4._dragging || m2e.unhover(r4, T3);\n              }, m2e.init(this.dragOptions);\n            };\n            function b2e(e3) {\n              w2e.select(e3).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove();\n            }\n          });\n          var zG = ye((Bcr, k2e) => {\n            "use strict";\n            var O2t = Lh(), q2t = Cc().attributes, su = Rd(), B2t = mc().overrideAll, DG = Ao().extendFlat, FG = { title: { text: su.title.text, font: su.title.font }, color: su.color, tickmode: su.minor.tickmode, nticks: DG({}, su.nticks, { dflt: 6, min: 1 }), tick0: su.tick0, dtick: su.dtick, tickvals: su.tickvals, ticktext: su.ticktext, ticks: su.ticks, ticklen: su.ticklen, tickwidth: su.tickwidth, tickcolor: su.tickcolor, ticklabelstep: su.ticklabelstep, showticklabels: su.showticklabels, labelalias: su.labelalias, showtickprefix: su.showtickprefix, tickprefix: su.tickprefix, showticksuffix: su.showticksuffix, ticksuffix: su.ticksuffix, showexponent: su.showexponent, exponentformat: su.exponentformat, minexponent: su.minexponent, separatethousands: su.separatethousands, tickfont: su.tickfont, tickangle: su.tickangle, tickformat: su.tickformat, tickformatstops: su.tickformatstops, hoverformat: su.hoverformat, showline: DG({}, su.showline, { dflt: true }), linecolor: su.linecolor, linewidth: su.linewidth, showgrid: DG({}, su.showgrid, { dflt: true }), gridcolor: su.gridcolor, gridwidth: su.gridwidth, griddash: su.griddash, layer: su.layer, min: { valType: "number", dflt: 0, min: 0 } }, F8 = k2e.exports = B2t({ domain: q2t({ name: "ternary" }), bgcolor: { valType: "color", dflt: O2t.background }, sum: { valType: "number", dflt: 1, min: 0 }, aaxis: FG, baxis: FG, caxis: FG }, "plot", "from-root");\n            F8.uirevision = { valType: "any", editType: "none" };\n            F8.aaxis.uirevision = F8.baxis.uirevision = F8.caxis.uirevision = { valType: "any", editType: "none" };\n          });\n          var k_ = ye((Ncr, C2e) => {\n            "use strict";\n            var N2t = Dr(), U2t = vl(), V2t = Cc().defaults;\n            C2e.exports = function(t3, r4, n4, i3) {\n              var a4 = i3.type, o4 = i3.attributes, s3 = i3.handleDefaults, l3 = i3.partition || "x", u4 = r4._subplots[a4], c5 = u4.length, f4 = c5 && u4[0].replace(/\\d+$/, ""), h3, d3;\n              function v3(k4, E3) {\n                return N2t.coerce(h3, d3, o4, k4, E3);\n              }\n              for (var _2 = 0; _2 < c5; _2++) {\n                var b = u4[_2];\n                t3[b] ? h3 = t3[b] : h3 = t3[b] = {}, d3 = U2t.newContainer(r4, b, f4), i3.noUirevision || v3("uirevision", r4.uirevision);\n                var p3 = {};\n                p3[l3] = [_2 / c5, (_2 + 1) / c5], V2t(d3, r4, v3, p3), i3.id = b, s3(h3, d3, v3, i3);\n              }\n            };\n          });\n          var R2e = ye((Ucr, I2e) => {\n            "use strict";\n            var G2t = ka(), H2t = vl(), z8 = Dr(), j2t = k_(), W2t = e_(), X2t = t_(), Z2t = M3(), Y2t = bb(), K2t = t4(), P2e = zG(), L2e = ["aaxis", "baxis", "caxis"];\n            I2e.exports = function(t3, r4, n4) {\n              j2t(t3, r4, n4, { type: "ternary", attributes: P2e, handleDefaults: J2t, font: r4.font, paper_bgcolor: r4.paper_bgcolor });\n            };\n            function J2t(e3, t3, r4, n4) {\n              var i3 = r4("bgcolor"), a4 = r4("sum");\n              n4.bgColor = G2t.combine(i3, n4.paper_bgcolor);\n              for (var o4, s3, l3, u4 = 0; u4 < L2e.length; u4++) o4 = L2e[u4], s3 = e3[o4] || {}, l3 = H2t.newContainer(t3, o4), l3._name = o4, $2t(s3, l3, n4, t3);\n              var c5 = t3.aaxis, f4 = t3.baxis, h3 = t3.caxis;\n              c5.min + f4.min + h3.min >= a4 && (c5.min = 0, f4.min = 0, h3.min = 0, e3.aaxis && delete e3.aaxis.min, e3.baxis && delete e3.baxis.min, e3.caxis && delete e3.caxis.min);\n            }\n            function $2t(e3, t3, r4, n4) {\n              var i3 = P2e[t3._name];\n              function a4(d3, v3) {\n                return z8.coerce(e3, t3, i3, d3, v3);\n              }\n              a4("uirevision", n4.uirevision), t3.type = "linear";\n              var o4 = a4("color"), s3 = o4 !== i3.color.dflt ? o4 : r4.font.color, l3 = t3._name, u4 = l3.charAt(0).toUpperCase(), c5 = "Component " + u4, f4 = a4("title.text", c5);\n              t3._hovertitle = f4 === c5 ? f4 : u4, z8.coerceFont(a4, "title.font", r4.font, { overrideDflt: { size: z8.bigFont(r4.font.size), color: s3 } }), a4("min"), Y2t(e3, t3, a4, "linear"), X2t(e3, t3, a4, "linear"), W2t(e3, t3, a4, "linear", { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true }), Z2t(e3, t3, a4, { outerTicks: true });\n              var h3 = a4("showticklabels");\n              h3 && (z8.coerceFont(a4, "tickfont", r4.font, { overrideDflt: { color: s3 } }), a4("tickangle"), a4("tickformat")), K2t(e3, t3, a4, { dfltColor: o4, bgColor: r4.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: i3 }), a4("hoverformat"), a4("layer");\n            }\n          });\n          var D2e = ye((W0) => {\n            "use strict";\n            var Q2t = E2e(), ewt = Id().getSubplotCalcData, twt = Dr().counterRegex, VT = "ternary";\n            W0.name = VT;\n            var rwt = W0.attr = "subplot";\n            W0.idRoot = VT;\n            W0.idRegex = W0.attrRegex = twt(VT);\n            var iwt = W0.attributes = {};\n            iwt[rwt] = { valType: "subplotid", dflt: "ternary", editType: "calc" };\n            W0.layoutAttributes = zG();\n            W0.supplyLayoutDefaults = R2e();\n            W0.plot = function(t3) {\n              for (var r4 = t3._fullLayout, n4 = t3.calcdata, i3 = r4._subplots[VT], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = ewt(n4, VT, o4), l3 = r4[o4]._subplot;\n                l3 || (l3 = new Q2t({ id: o4, graphDiv: t3, container: r4._ternarylayer.node() }, r4), r4[o4]._subplot = l3), l3.plot(s3, r4, t3._promises);\n              }\n            };\n            W0.clean = function(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[VT] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = n4[o4]._subplot;\n                !t3[o4] && s3 && (s3.plotContainer.remove(), s3.clipDef.remove(), s3.clipDefRelative.remove(), s3.layers["a-title"].remove(), s3.layers["b-title"].remove(), s3.layers["c-title"].remove());\n              }\n            };\n            W0.updateFx = function(e3) {\n              var t3 = e3._fullLayout;\n              t3._ternarylayer.selectAll("g.toplevel").style("cursor", t3.dragmode === "pan" ? "move" : "crosshair");\n            };\n          });\n          var z2e = ye((Gcr, F2e) => {\n            "use strict";\n            F2e.exports = { attributes: kG(), supplyDefaults: n2e(), colorbar: $d(), formatLabels: o2e(), calc: c2e(), plot: h2e(), style: op().style, styleOnSelect: op().styleOnSelect, hoverPoints: v2e(), selectPoints: hT(), eventData: g2e(), moduleType: "trace", name: "scatterternary", basePlotModule: D2e(), categories: ["ternary", "symbols", "showLegend", "scatter-like"], meta: {} };\n          });\n          var q2e = ye((Hcr, O2e) => {\n            "use strict";\n            O2e.exports = z2e();\n          });\n          var OG = ye((jcr, N2e) => {\n            "use strict";\n            var Fh = x4(), GT = Ao().extendFlat, B2e = df().axisHoverFormat;\n            N2e.exports = { y: Fh.y, x: Fh.x, x0: Fh.x0, y0: Fh.y0, xhoverformat: B2e("x"), yhoverformat: B2e("y"), name: GT({}, Fh.name, {}), orientation: GT({}, Fh.orientation, {}), bandwidth: { valType: "number", min: 0, editType: "calc" }, scalegroup: { valType: "string", dflt: "", editType: "calc" }, scalemode: { valType: "enumerated", values: ["width", "count"], dflt: "width", editType: "calc" }, spanmode: { valType: "enumerated", values: ["soft", "hard", "manual"], dflt: "soft", editType: "calc" }, span: { valType: "info_array", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }], editType: "calc" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, dflt: 2, editType: "style" }, editType: "plot" }, fillcolor: Fh.fillcolor, points: GT({}, Fh.boxpoints, {}), jitter: GT({}, Fh.jitter, {}), pointpos: GT({}, Fh.pointpos, {}), width: GT({}, Fh.width, {}), marker: Fh.marker, text: Fh.text, hovertext: Fh.hovertext, hovertemplate: Fh.hovertemplate, hovertemplatefallback: Fh.hovertemplatefallback, quartilemethod: Fh.quartilemethod, box: { visible: { valType: "boolean", dflt: false, editType: "plot" }, width: { valType: "number", min: 0, max: 1, dflt: 0.25, editType: "plot" }, fillcolor: { valType: "color", editType: "style" }, line: { color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, editType: "style" }, editType: "style" }, editType: "plot" }, meanline: { visible: { valType: "boolean", dflt: false, editType: "plot" }, color: { valType: "color", editType: "style" }, width: { valType: "number", min: 0, editType: "style" }, editType: "plot" }, side: { valType: "enumerated", values: ["both", "positive", "negative"], dflt: "both", editType: "calc" }, offsetgroup: Fh.offsetgroup, alignmentgroup: Fh.alignmentgroup, selected: Fh.selected, unselected: Fh.unselected, hoveron: { valType: "flaglist", flags: ["violins", "points", "kde"], dflt: "violins+points+kde", extras: ["all"], editType: "style" }, zorder: Fh.zorder };\n          });\n          var NG = ye((Wcr, U2e) => {\n            "use strict";\n            var qG = b4(), BG = Dr().extendFlat;\n            U2e.exports = { violinmode: BG({}, qG.boxmode, {}), violingap: BG({}, qG.boxgap, {}), violingroupgap: BG({}, qG.boxgroupgap, {}) };\n          });\n          var W2e = ye((Xcr, j2e) => {\n            "use strict";\n            var V2e = Dr(), nwt = ka(), G2e = T4(), H2e = OG();\n            j2e.exports = function(t3, r4, n4, i3) {\n              function a4(L3, x2) {\n                return V2e.coerce(t3, r4, H2e, L3, x2);\n              }\n              function o4(L3, x2) {\n                return V2e.coerce2(t3, r4, H2e, L3, x2);\n              }\n              if (G2e.handleSampleDefaults(t3, r4, a4, i3), r4.visible !== false) {\n                a4("bandwidth"), a4("side");\n                var s3 = a4("width");\n                s3 || (a4("scalegroup", r4.name), a4("scalemode"));\n                var l3 = a4("span"), u4;\n                Array.isArray(l3) && (u4 = "manual"), a4("spanmode", u4);\n                var c5 = a4("line.color", (t3.marker || {}).color || n4), f4 = a4("line.width"), h3 = a4("fillcolor", nwt.addOpacity(r4.line.color, 0.5));\n                G2e.handlePointsDefaults(t3, r4, a4, { prefix: "" });\n                var d3 = o4("box.width"), v3 = o4("box.fillcolor", h3), _2 = o4("box.line.color", c5), b = o4("box.line.width", f4), p3 = a4("box.visible", !!(d3 || v3 || _2 || b));\n                p3 || (r4.box = { visible: false });\n                var k4 = o4("meanline.color", c5), E3 = o4("meanline.width", f4), S2 = a4("meanline.visible", !!(k4 || E3));\n                S2 || (r4.meanline = { visible: false }), a4("quartilemethod"), a4("zorder");\n              }\n            };\n          });\n          var Z2e = ye((Zcr, X2e) => {\n            "use strict";\n            var awt = Dr(), owt = NG(), swt = ZI();\n            X2e.exports = function(t3, r4, n4) {\n              function i3(a4, o4) {\n                return awt.coerce(t3, r4, owt, a4, o4);\n              }\n              swt._supply(t3, r4, n4, i3, "violin");\n            };\n          });\n          var O8 = ye((s22) => {\n            "use strict";\n            var lwt = Dr(), uwt = { gaussian: function(e3) {\n              return 1 / Math.sqrt(2 * Math.PI) * Math.exp(-0.5 * e3 * e3);\n            } };\n            s22.makeKDE = function(e3, t3, r4) {\n              var n4 = r4.length, i3 = uwt.gaussian, a4 = e3.bandwidth, o4 = 1 / (n4 * a4);\n              return function(s3) {\n                for (var l3 = 0, u4 = 0; u4 < n4; u4++) l3 += i3((s3 - r4[u4]) / a4);\n                return o4 * l3;\n              };\n            };\n            s22.getPositionOnKdePath = function(e3, t3, r4) {\n              var n4, i3;\n              t3.orientation === "h" ? (n4 = "y", i3 = "x") : (n4 = "x", i3 = "y");\n              var a4 = lwt.findPointOnPath(e3.path, r4, i3, { pathLength: e3.pathLength }), o4 = e3.posCenterPx, s3 = a4[n4], l3 = t3.side === "both" ? 2 * o4 - s3 : o4;\n              return [s3, l3];\n            };\n            s22.getKdeValue = function(e3, t3, r4) {\n              var n4 = e3.pts.map(s22.extractVal), i3 = s22.makeKDE(e3, t3, n4);\n              return i3(r4) / e3.posDensityScale;\n            };\n            s22.extractVal = function(e3) {\n              return e3.v;\n            };\n          });\n          var J2e = ye((Kcr, K2e) => {\n            "use strict";\n            var UG = Dr(), VG = ho(), cwt = RV(), Y2e = O8(), fwt = fs().BADNUM;\n            K2e.exports = function(t3, r4) {\n              var n4 = cwt(t3, r4);\n              if (n4[0].t.empty) return n4;\n              for (var i3 = t3._fullLayout, a4 = VG.getFromId(t3, r4[r4.orientation === "h" ? "xaxis" : "yaxis"]), o4 = 1 / 0, s3 = -1 / 0, l3 = 0, u4 = 0, c5 = 0; c5 < n4.length; c5++) {\n                var f4 = n4[c5], h3 = f4.pts.map(Y2e.extractVal), d3 = f4.bandwidth = dwt(r4, f4, h3), v3 = f4.span = vwt(r4, f4, a4, d3);\n                if (f4.min === f4.max && d3 === 0) v3 = f4.span = [f4.min, f4.max], f4.density = [{ v: 1, t: v3[0] }], f4.bandwidth = d3, l3 = Math.max(l3, 1);\n                else {\n                  var _2 = v3[1] - v3[0], b = Math.ceil(_2 / (d3 / 3)), p3 = _2 / b;\n                  if (!isFinite(p3) || !isFinite(b)) return UG.error("Something went wrong with computing the violin span"), n4[0].t.empty = true, n4;\n                  var k4 = Y2e.makeKDE(f4, r4, h3);\n                  f4.density = new Array(b + 1);\n                  for (var E3 = 0; E3 < f4.density.length; E3++) {\n                    var S2 = v3[0] + E3 * p3, L3 = k4(S2);\n                    f4.density[E3] = { v: L3, t: S2 }, l3 = Math.max(l3, L3);\n                  }\n                }\n                u4 = Math.max(u4, h3.length), o4 = Math.min(o4, v3[0]), s3 = Math.max(s3, v3[1]);\n              }\n              var x2 = VG.findExtremes(a4, [o4, s3], { padded: true });\n              if (r4._extremes[a4._id] = x2, r4.width) n4[0].t.maxKDE = l3;\n              else {\n                var C3 = i3._violinScaleGroupStats, M4 = r4.scalegroup, g3 = C3[M4];\n                g3 ? (g3.maxKDE = Math.max(g3.maxKDE, l3), g3.maxCount = Math.max(g3.maxCount, u4)) : C3[M4] = { maxKDE: l3, maxCount: u4 };\n              }\n              return n4[0].t.labels.kde = UG._(t3, "kde:"), n4;\n            };\n            function hwt(e3, t3, r4) {\n              var n4 = Math.min(t3, r4 / 1.349);\n              return 1.059 * n4 * Math.pow(e3, -0.2);\n            }\n            function dwt(e3, t3, r4) {\n              var n4 = t3.max - t3.min;\n              if (!n4) return e3.bandwidth ? e3.bandwidth : 0;\n              if (e3.bandwidth) return Math.max(e3.bandwidth, n4 / 1e4);\n              var i3 = r4.length, a4 = UG.stdev(r4, i3 - 1, t3.mean);\n              return Math.max(hwt(i3, a4, t3.q3 - t3.q1), n4 / 100);\n            }\n            function vwt(e3, t3, r4, n4) {\n              var i3 = e3.spanmode, a4 = e3.span || [], o4 = [t3.min, t3.max], s3 = [t3.min - 2 * n4, t3.max + 2 * n4], l3;\n              function u4(f4) {\n                var h3 = a4[f4], d3 = r4.type === "multicategory" ? r4.r2c(h3) : r4.d2c(h3, 0, e3[t3.valLetter + "calendar"]);\n                return d3 === fwt ? s3[f4] : d3;\n              }\n              i3 === "soft" ? l3 = s3 : i3 === "hard" ? l3 = o4 : l3 = [u4(0), u4(1)];\n              var c5 = { type: "linear", range: l3 };\n              return VG.setConvert(c5), c5.cleanRange(), l3;\n            }\n          });\n          var ewe = ye((Jcr, Q2e) => {\n            "use strict";\n            var pwt = KI().setPositionOffset, $2e = ["v", "h"];\n            Q2e.exports = function(t3, r4) {\n              for (var n4 = t3.calcdata, i3 = r4.xaxis, a4 = r4.yaxis, o4 = 0; o4 < $2e.length; o4++) {\n                for (var s3 = $2e[o4], l3 = s3 === "h" ? a4 : i3, u4 = [], c5 = 0; c5 < n4.length; c5++) {\n                  var f4 = n4[c5], h3 = f4[0].t, d3 = f4[0].trace;\n                  d3.visible === true && d3.type === "violin" && !h3.empty && d3.orientation === s3 && d3.xaxis === i3._id && d3.yaxis === a4._id && u4.push(c5);\n                }\n                pwt("violin", t3, u4, l3);\n              }\n            };\n          });\n          var rwe = ye(($cr, twe) => {\n            "use strict";\n            var GG = Oa(), HG = Dr(), gwt = So(), jG = JI(), mwt = yU(), ywt = O8();\n            twe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._context.staticPlot, o4 = t3._fullLayout, s3 = r4.xaxis, l3 = r4.yaxis;\n              function u4(c5, f4) {\n                var h3 = mwt(c5, { xaxis: s3, yaxis: l3, trace: f4, connectGaps: true, baseTolerance: 0.75, shape: "spline", simplify: true, linearized: true });\n                return gwt.smoothopen(h3[0], 1);\n              }\n              HG.makeTraceGroups(i3, n4, "trace violins").each(function(c5) {\n                var f4 = GG.select(this), h3 = c5[0], d3 = h3.t, v3 = h3.trace;\n                if (v3.visible !== true || d3.empty) {\n                  f4.remove();\n                  return;\n                }\n                var _2 = d3.bPos, b = d3.bdPos, p3 = r4[d3.valLetter + "axis"], k4 = r4[d3.posLetter + "axis"], E3 = v3.side === "both", S2 = E3 || v3.side === "positive", L3 = E3 || v3.side === "negative", x2 = f4.selectAll("path.violin").data(HG.identity);\n                x2.enter().append("path").style("vector-effect", a4 ? "none" : "non-scaling-stroke").attr("class", "violin"), x2.exit().remove(), x2.each(function(V2) {\n                  var G2 = GG.select(this), Z = V2.density, j3 = Z.length, N2 = k4.c2l(V2.pos + _2, true), H = k4.l2p(N2), te;\n                  if (v3.width) te = d3.maxKDE / b;\n                  else {\n                    var oe = o4._violinScaleGroupStats[v3.scalegroup];\n                    te = v3.scalemode === "count" ? oe.maxKDE / b * (oe.maxCount / V2.pts.length) : oe.maxKDE / b;\n                  }\n                  var _e, Ee, Ce, me, ie, Se, Le;\n                  if (S2) {\n                    for (Se = new Array(j3), me = 0; me < j3; me++) Le = Se[me] = {}, Le[d3.posLetter] = N2 + Z[me].v / te, Le[d3.valLetter] = p3.c2l(Z[me].t, true);\n                    _e = u4(Se, v3);\n                  }\n                  if (L3) {\n                    for (Se = new Array(j3), ie = 0, me = j3 - 1; ie < j3; ie++, me--) Le = Se[ie] = {}, Le[d3.posLetter] = N2 - Z[me].v / te, Le[d3.valLetter] = p3.c2l(Z[me].t, true);\n                    Ee = u4(Se, v3);\n                  }\n                  if (E3) Ce = _e + "L" + Ee.slice(1) + "Z";\n                  else {\n                    var Ae = [H, p3.c2p(Z[0].t)], Fe = [H, p3.c2p(Z[j3 - 1].t)];\n                    v3.orientation === "h" && (Ae.reverse(), Fe.reverse()), S2 ? Ce = "M" + Ae + "L" + _e.slice(1) + "L" + Fe : Ce = "M" + Fe + "L" + Ee.slice(1) + "L" + Ae;\n                  }\n                  G2.attr("d", Ce), V2.posCenterPx = H, V2.posDensityScale = te * b, V2.path = G2.node(), V2.pathLength = V2.path.getTotalLength() / (E3 ? 2 : 1);\n                });\n                var C3 = v3.box, M4 = C3.width, g3 = (C3.line || {}).width, P3, T3;\n                E3 ? (P3 = b * M4, T3 = 0) : S2 ? (P3 = [0, b * M4 / 2], T3 = g3 * { x: 1, y: -1 }[d3.posLetter]) : (P3 = [b * M4 / 2, 0], T3 = g3 * { x: -1, y: 1 }[d3.posLetter]), jG.plotBoxAndWhiskers(f4, { pos: k4, val: p3 }, v3, { bPos: _2, bdPos: P3, bPosPxOffset: T3 }), jG.plotBoxMean(f4, { pos: k4, val: p3 }, v3, { bPos: _2, bdPos: P3, bPosPxOffset: T3 });\n                var z3;\n                !v3.box.visible && v3.meanline.visible && (z3 = HG.identity);\n                var O3 = f4.selectAll("path.meanline").data(z3 || []);\n                O3.enter().append("path").attr("class", "meanline").style("fill", "none").style("vector-effect", a4 ? "none" : "non-scaling-stroke"), O3.exit().remove(), O3.each(function(V2) {\n                  var G2 = p3.c2p(V2.mean, true), Z = ywt.getPositionOnKdePath(V2, v3, G2);\n                  GG.select(this).attr("d", v3.orientation === "h" ? "M" + G2 + "," + Z[0] + "V" + Z[1] : "M" + Z[0] + "," + G2 + "H" + Z[1]);\n                }), jG.plotPoints(f4, { x: s3, y: l3 }, v3, d3);\n              });\n            };\n          });\n          var awe = ye((Qcr, nwe) => {\n            "use strict";\n            var iwe = Oa(), HT = ka(), _wt = op().stylePoints;\n            nwe.exports = function(t3) {\n              var r4 = iwe.select(t3).selectAll("g.trace.violins");\n              r4.style("opacity", function(n4) {\n                return n4[0].trace.opacity;\n              }), r4.each(function(n4) {\n                var i3 = n4[0].trace, a4 = iwe.select(this), o4 = i3.box || {}, s3 = o4.line || {}, l3 = i3.meanline || {}, u4 = l3.width;\n                a4.selectAll("path.violin").style("stroke-width", i3.line.width + "px").call(HT.stroke, i3.line.color).call(HT.fill, i3.fillcolor), a4.selectAll("path.box").style("stroke-width", s3.width + "px").call(HT.stroke, s3.color).call(HT.fill, o4.fillcolor);\n                var c5 = { "stroke-width": u4 + "px", "stroke-dasharray": 2 * u4 + "px," + u4 + "px" };\n                a4.selectAll("path.mean").style(c5).call(HT.stroke, l3.color), a4.selectAll("path.meanline").style(c5).call(HT.stroke, l3.color), _wt(a4, i3, t3);\n              });\n            };\n          });\n          var uwe = ye((efr, lwe) => {\n            "use strict";\n            var xwt = ka(), WG = Dr(), bwt = ho(), owe = qV(), swe = O8();\n            lwe.exports = function(t3, r4, n4, i3, a4) {\n              a4 || (a4 = {});\n              var o4 = a4.hoverLayer, s3 = t3.cd, l3 = s3[0].trace, u4 = l3.hoveron, c5 = u4.indexOf("violins") !== -1, f4 = u4.indexOf("kde") !== -1, h3 = [], d3, v3;\n              if (c5 || f4) {\n                var _2 = owe.hoverOnBoxes(t3, r4, n4, i3);\n                if (f4 && _2.length > 0) {\n                  var b = t3.xa, p3 = t3.ya, k4, E3, S2, L3, x2;\n                  l3.orientation === "h" ? (x2 = r4, k4 = "y", S2 = p3, E3 = "x", L3 = b) : (x2 = n4, k4 = "x", S2 = b, E3 = "y", L3 = p3);\n                  var C3 = s3[t3.index];\n                  if (x2 >= C3.span[0] && x2 <= C3.span[1]) {\n                    var M4 = WG.extendFlat({}, t3), g3 = L3.c2p(x2, true), P3 = swe.getKdeValue(C3, l3, x2), T3 = swe.getPositionOnKdePath(C3, l3, g3), z3 = S2._offset, O3 = S2._length;\n                    M4[k4 + "0"] = T3[0], M4[k4 + "1"] = T3[1], M4[E3 + "0"] = M4[E3 + "1"] = g3, M4[E3 + "Label"] = E3 + ": " + bwt.hoverLabelText(L3, x2, l3[E3 + "hoverformat"]) + ", " + s3[0].t.labels.kde + " " + P3.toFixed(3);\n                    for (var V2 = 0, G2 = 0; G2 < _2.length; G2++) if (_2[G2].attr === "med") {\n                      V2 = G2;\n                      break;\n                    }\n                    M4.spikeDistance = _2[V2].spikeDistance;\n                    var Z = k4 + "Spike";\n                    M4[Z] = _2[V2][Z], _2[V2].spikeDistance = void 0, _2[V2][Z] = void 0, M4.hovertemplate = false, h3.push(M4), v3 = {}, v3[k4 + "1"] = WG.constrain(z3 + T3[0], z3, z3 + O3), v3[k4 + "2"] = WG.constrain(z3 + T3[1], z3, z3 + O3), v3[E3 + "1"] = v3[E3 + "2"] = L3._offset + g3;\n                  }\n                }\n                c5 && (h3 = h3.concat(_2));\n              }\n              u4.indexOf("points") !== -1 && (d3 = owe.hoverOnPoints(t3, r4, n4));\n              var j3 = o4.selectAll(".violinline-" + l3.uid).data(v3 ? [0] : []);\n              return j3.enter().append("line").classed("violinline-" + l3.uid, true).attr("stroke-width", 1.5), j3.exit().remove(), j3.attr(v3).call(xwt.stroke, t3.color), i3 === "closest" ? d3 ? [d3] : h3 : (d3 && h3.push(d3), h3);\n            };\n          });\n          var fwe = ye((tfr, cwe) => {\n            "use strict";\n            cwe.exports = { attributes: OG(), layoutAttributes: NG(), supplyDefaults: W2e(), crossTraceDefaults: T4().crossTraceDefaults, supplyLayoutDefaults: Z2e(), calc: J2e(), crossTraceCalc: ewe(), plot: rwe(), style: awe(), styleOnSelect: op().styleOnSelect, hoverPoints: uwe(), selectPoints: BV(), moduleType: "trace", name: "violin", basePlotModule: ph(), categories: ["cartesian", "svg", "symbols", "oriented", "box-violin", "showLegend", "violinLayout", "zoomScale"], meta: {} };\n          });\n          var dwe = ye((rfr, hwe) => {\n            "use strict";\n            hwe.exports = fwe();\n          });\n          var pwe = ye((ifr, vwe) => {\n            "use strict";\n            vwe.exports = { eventDataKeys: ["percentInitial", "percentPrevious", "percentTotal"] };\n          });\n          var ZG = ye((nfr, _we) => {\n            "use strict";\n            var jc = Lm(), XG = pf().line, wwt = Gl(), gwe = df().axisHoverFormat, { hovertemplateAttrs: Twt, texttemplateAttrs: Awt, templatefallbackAttrs: mwe } = Ll(), ywe = pwe(), Ny = Ao().extendFlat, Swt = ka();\n            _we.exports = { x: jc.x, x0: jc.x0, dx: jc.dx, y: jc.y, y0: jc.y0, dy: jc.dy, xperiod: jc.xperiod, yperiod: jc.yperiod, xperiod0: jc.xperiod0, yperiod0: jc.yperiod0, xperiodalignment: jc.xperiodalignment, yperiodalignment: jc.yperiodalignment, xhoverformat: gwe("x"), yhoverformat: gwe("y"), hovertext: jc.hovertext, hovertemplate: Twt({}, { keys: ywe.eventDataKeys }), hovertemplatefallback: mwe(), hoverinfo: Ny({}, wwt.hoverinfo, { flags: ["name", "x", "y", "text", "percent initial", "percent previous", "percent total"] }), textinfo: { valType: "flaglist", flags: ["label", "text", "percent initial", "percent previous", "percent total", "value"], extras: ["none"], editType: "plot", arrayOk: false }, texttemplate: Awt({ editType: "plot" }, { keys: ywe.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: mwe({ editType: "plot" }), text: jc.text, textposition: jc.textposition, insidetextanchor: Ny({}, jc.insidetextanchor, { dflt: "middle" }), textangle: Ny({}, jc.textangle, { dflt: 0 }), textfont: jc.textfont, insidetextfont: jc.insidetextfont, outsidetextfont: jc.outsidetextfont, constraintext: jc.constraintext, cliponaxis: jc.cliponaxis, orientation: Ny({}, jc.orientation, {}), offset: Ny({}, jc.offset, { arrayOk: false }), width: Ny({}, jc.width, { arrayOk: false }), marker: Mwt(), connector: { fillcolor: { valType: "color", editType: "style" }, line: { color: Ny({}, XG.color, { dflt: Swt.defaultLine }), width: Ny({}, XG.width, { dflt: 0, editType: "plot" }), dash: XG.dash, editType: "style" }, visible: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, offsetgroup: jc.offsetgroup, alignmentgroup: jc.alignmentgroup, zorder: jc.zorder };\n            function Mwt() {\n              var e3 = Ny({}, jc.marker);\n              return delete e3.pattern, delete e3.cornerradius, e3;\n            }\n          });\n          var YG = ye((afr, xwe) => {\n            "use strict";\n            xwe.exports = { funnelmode: { valType: "enumerated", values: ["stack", "group", "overlay"], dflt: "stack", editType: "calc" }, funnelgap: { valType: "number", min: 0, max: 1, editType: "calc" }, funnelgroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" } };\n          });\n          var JG = ye((ofr, wwe) => {\n            "use strict";\n            var q8 = Dr(), Ewt = Hb(), kwt = r0().handleText, Cwt = eT(), Lwt = Ig(), bwe = ZG(), KG = ka();\n            function Pwt(e3, t3, r4, n4) {\n              function i3(f4, h3) {\n                return q8.coerce(e3, t3, bwe, f4, h3);\n              }\n              var a4 = Cwt(e3, t3, n4, i3);\n              if (!a4) {\n                t3.visible = false;\n                return;\n              }\n              Lwt(e3, t3, n4, i3), i3("xhoverformat"), i3("yhoverformat"), i3("orientation", t3.y && !t3.x ? "v" : "h"), i3("offset"), i3("width");\n              var o4 = i3("text");\n              i3("hovertext"), i3("hovertemplate"), i3("hovertemplatefallback");\n              var s3 = i3("textposition");\n              kwt(e3, t3, n4, i3, s3, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), t3.textposition !== "none" && !t3.texttemplate && i3("textinfo", q8.isArrayOrTypedArray(o4) ? "text+value" : "value");\n              var l3 = i3("marker.color", r4);\n              i3("marker.line.color", KG.defaultLine), i3("marker.line.width");\n              var u4 = i3("connector.visible");\n              if (u4) {\n                i3("connector.fillcolor", Iwt(l3));\n                var c5 = i3("connector.line.width");\n                c5 && (i3("connector.line.color"), i3("connector.line.dash"));\n              }\n              i3("zorder");\n            }\n            function Iwt(e3) {\n              var t3 = q8.isArrayOrTypedArray(e3) ? "#000" : e3;\n              return KG.addOpacity(t3, 0.5 * KG.opacity(t3));\n            }\n            function Rwt(e3, t3) {\n              var r4, n4;\n              function i3(o4) {\n                return q8.coerce(n4._input, n4, bwe, o4);\n              }\n              for (var a4 = 0; a4 < e3.length; a4++) n4 = e3[a4], n4.type === "funnel" && (r4 = n4._input, Ewt(r4, n4, t3, i3, t3.funnelmode));\n            }\n            wwe.exports = { supplyDefaults: Pwt, crossTraceDefaults: Rwt };\n          });\n          var Awe = ye((sfr, Twe) => {\n            "use strict";\n            var Dwt = Dr(), Fwt = YG();\n            Twe.exports = function(e3, t3, r4) {\n              var n4 = false;\n              function i3(s3, l3) {\n                return Dwt.coerce(e3, t3, Fwt, s3, l3);\n              }\n              for (var a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4];\n                if (o4.visible && o4.type === "funnel") {\n                  n4 = true;\n                  break;\n                }\n              }\n              n4 && (i3("funnelmode"), i3("funnelgap", 0.2), i3("funnelgroupgap"));\n            };\n          });\n          var Mwe = ye((lfr, Swe) => {\n            "use strict";\n            var jT = Dr();\n            Swe.exports = function(t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4++) t3[n4].i = n4;\n              jT.mergeArray(r4.text, t3, "tx"), jT.mergeArray(r4.hovertext, t3, "htx");\n              var i3 = r4.marker;\n              if (i3) {\n                jT.mergeArray(i3.opacity, t3, "mo"), jT.mergeArray(i3.color, t3, "mc");\n                var a4 = i3.line;\n                a4 && (jT.mergeArray(a4.color, t3, "mlc"), jT.mergeArrayCastPositive(a4.width, t3, "mlw"));\n              }\n            };\n          });\n          var Lwe = ye((ufr, Cwe) => {\n            "use strict";\n            var Ewe = ho(), kwe = Dg(), zwt = Mwe(), Owt = z0(), O4 = fs().BADNUM;\n            Cwe.exports = function(t3, r4) {\n              var n4 = Ewe.getFromId(t3, r4.xaxis || "x"), i3 = Ewe.getFromId(t3, r4.yaxis || "y"), a4, o4, s3, l3, u4, c5, f4, h3;\n              r4.orientation === "h" ? (a4 = n4.makeCalcdata(r4, "x"), s3 = i3.makeCalcdata(r4, "y"), l3 = kwe(r4, i3, "y", s3), u4 = !!r4.yperiodalignment, c5 = "y") : (a4 = i3.makeCalcdata(r4, "y"), s3 = n4.makeCalcdata(r4, "x"), l3 = kwe(r4, n4, "x", s3), u4 = !!r4.xperiodalignment, c5 = "x"), o4 = l3.vals;\n              var d3 = Math.min(o4.length, a4.length), v3 = new Array(d3);\n              for (r4._base = [], f4 = 0; f4 < d3; f4++) {\n                a4[f4] < 0 && (a4[f4] = O4);\n                var _2 = false;\n                a4[f4] !== O4 && f4 + 1 < d3 && a4[f4 + 1] !== O4 && (_2 = true), h3 = v3[f4] = { p: o4[f4], s: a4[f4], cNext: _2 }, r4._base[f4] = -0.5 * h3.s, u4 && (v3[f4].orig_p = s3[f4], v3[f4][c5 + "End"] = l3.ends[f4], v3[f4][c5 + "Start"] = l3.starts[f4]), r4.ids && (h3.id = String(r4.ids[f4])), f4 === 0 && (v3[0].vTotal = 0), v3[0].vTotal += $G(h3.s), h3.begR = $G(h3.s) / $G(v3[0].s);\n              }\n              var b;\n              for (f4 = 0; f4 < d3; f4++) h3 = v3[f4], h3.s !== O4 && (h3.sumR = h3.s / v3[0].vTotal, h3.difR = b !== void 0 ? h3.s / b : 1, b = h3.s);\n              return zwt(v3, r4), Owt(v3, r4), v3;\n            };\n            function $G(e3) {\n              return e3 === O4 ? 0 : e3;\n            }\n          });\n          var Rwe = ye((cfr, Iwe) => {\n            "use strict";\n            var Pwe = jb().setGroupPositions;\n            Iwe.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = t3._fullData, a4 = t3.calcdata, o4 = r4.xaxis, s3 = r4.yaxis, l3 = [], u4 = [], c5 = [], f4, h3;\n              for (h3 = 0; h3 < i3.length; h3++) {\n                var d3 = i3[h3], v3 = d3.orientation === "h";\n                d3.visible === true && d3.xaxis === o4._id && d3.yaxis === s3._id && d3.type === "funnel" && (f4 = a4[h3], v3 ? c5.push(f4) : u4.push(f4), l3.push(f4));\n              }\n              var _2 = { mode: n4.funnelmode, norm: n4.funnelnorm, gap: n4.funnelgap, groupgap: n4.funnelgroupgap };\n              for (Pwe(t3, o4, s3, u4, _2), Pwe(t3, s3, o4, c5, _2), h3 = 0; h3 < l3.length; h3++) {\n                f4 = l3[h3];\n                for (var b = 0; b < f4.length; b++) b + 1 < f4.length && (f4[b].nextP0 = f4[b + 1].p0, f4[b].nextS0 = f4[b + 1].s0, f4[b].nextP1 = f4[b + 1].p1, f4[b].nextS1 = f4[b + 1].s1);\n              }\n            };\n          });\n          var Owe = ye((ffr, zwe) => {\n            "use strict";\n            var B8 = Oa(), L_ = Dr(), Dwe = So(), C_ = fs().BADNUM, qwt = n2(), Bwt = bv().clearMinTextSize;\n            zwe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._fullLayout;\n              Bwt("funnel", a4), Nwt(t3, r4, n4, i3), Uwt(t3, r4, n4, i3), qwt.plot(t3, r4, n4, i3, { mode: a4.funnelmode, norm: a4.funnelmode, gap: a4.funnelgap, groupgap: a4.funnelgroupgap });\n            };\n            function Nwt(e3, t3, r4, n4) {\n              var i3 = t3.xaxis, a4 = t3.yaxis;\n              L_.makeTraceGroups(n4, r4, "trace bars").each(function(o4) {\n                var s3 = B8.select(this), l3 = o4[0].trace, u4 = L_.ensureSingle(s3, "g", "regions");\n                if (!l3.connector || !l3.connector.visible) {\n                  u4.remove();\n                  return;\n                }\n                var c5 = l3.orientation === "h", f4 = u4.selectAll("g.region").data(L_.identity);\n                f4.enter().append("g").classed("region", true), f4.exit().remove();\n                var h3 = f4.size();\n                f4.each(function(d3, v3) {\n                  if (!(v3 !== h3 - 1 && !d3.cNext)) {\n                    var _2 = Fwe(d3, i3, a4, c5), b = _2[0], p3 = _2[1], k4 = "";\n                    b[0] !== C_ && p3[0] !== C_ && b[1] !== C_ && p3[1] !== C_ && b[2] !== C_ && p3[2] !== C_ && b[3] !== C_ && p3[3] !== C_ && (c5 ? k4 += "M" + b[0] + "," + p3[1] + "L" + b[2] + "," + p3[2] + "H" + b[3] + "L" + b[1] + "," + p3[1] + "Z" : k4 += "M" + b[1] + "," + p3[1] + "L" + b[2] + "," + p3[3] + "V" + p3[2] + "L" + b[1] + "," + p3[0] + "Z"), k4 === "" && (k4 = "M0,0Z"), L_.ensureSingle(B8.select(this), "path").attr("d", k4).call(Dwe.setClipUrl, t3.layerClipId, e3);\n                  }\n                });\n              });\n            }\n            function Uwt(e3, t3, r4, n4) {\n              var i3 = t3.xaxis, a4 = t3.yaxis;\n              L_.makeTraceGroups(n4, r4, "trace bars").each(function(o4) {\n                var s3 = B8.select(this), l3 = o4[0].trace, u4 = L_.ensureSingle(s3, "g", "lines");\n                if (!l3.connector || !l3.connector.visible || !l3.connector.line.width) {\n                  u4.remove();\n                  return;\n                }\n                var c5 = l3.orientation === "h", f4 = u4.selectAll("g.line").data(L_.identity);\n                f4.enter().append("g").classed("line", true), f4.exit().remove();\n                var h3 = f4.size();\n                f4.each(function(d3, v3) {\n                  if (!(v3 !== h3 - 1 && !d3.cNext)) {\n                    var _2 = Fwe(d3, i3, a4, c5), b = _2[0], p3 = _2[1], k4 = "";\n                    b[3] !== void 0 && p3[3] !== void 0 && (c5 ? (k4 += "M" + b[0] + "," + p3[1] + "L" + b[2] + "," + p3[2], k4 += "M" + b[1] + "," + p3[1] + "L" + b[3] + "," + p3[2]) : (k4 += "M" + b[1] + "," + p3[1] + "L" + b[2] + "," + p3[3], k4 += "M" + b[1] + "," + p3[0] + "L" + b[2] + "," + p3[2])), k4 === "" && (k4 = "M0,0Z"), L_.ensureSingle(B8.select(this), "path").attr("d", k4).call(Dwe.setClipUrl, t3.layerClipId, e3);\n                  }\n                });\n              });\n            }\n            function Fwe(e3, t3, r4, n4) {\n              var i3 = [], a4 = [], o4 = n4 ? t3 : r4, s3 = n4 ? r4 : t3;\n              return i3[0] = o4.c2p(e3.s0, true), a4[0] = s3.c2p(e3.p0, true), i3[1] = o4.c2p(e3.s1, true), a4[1] = s3.c2p(e3.p1, true), i3[2] = o4.c2p(e3.nextS0, true), a4[2] = s3.c2p(e3.nextP0, true), i3[3] = o4.c2p(e3.nextS1, true), a4[3] = s3.c2p(e3.nextP1, true), n4 ? [i3, a4] : [a4, i3];\n            }\n          });\n          var Nwe = ye((hfr, Bwe) => {\n            "use strict";\n            var q4 = Oa(), qwe = So(), QG = ka(), Vwt = N1().DESELECTDIM, Gwt = N0(), Hwt = bv().resizeText, jwt = Gwt.styleTextPoints;\n            function Wwt(e3, t3, r4) {\n              var n4 = r4 || q4.select(e3).selectAll(\'g[class^="funnellayer"]\').selectAll("g.trace");\n              Hwt(e3, n4, "funnel"), n4.style("opacity", function(i3) {\n                return i3[0].trace.opacity;\n              }), n4.each(function(i3) {\n                var a4 = q4.select(this), o4 = i3[0].trace;\n                a4.selectAll(".point > path").each(function(s3) {\n                  if (!s3.isBlank) {\n                    var l3 = o4.marker;\n                    q4.select(this).call(QG.fill, s3.mc || l3.color).call(QG.stroke, s3.mlc || l3.line.color).call(qwe.dashLine, l3.line.dash, s3.mlw || l3.line.width).style("opacity", o4.selectedpoints && !s3.selected ? Vwt : 1);\n                  }\n                }), jwt(a4, o4, e3), a4.selectAll(".regions").each(function() {\n                  q4.select(this).selectAll("path").style("stroke-width", 0).call(QG.fill, o4.connector.fillcolor);\n                }), a4.selectAll(".lines").each(function() {\n                  var s3 = o4.connector.line;\n                  qwe.lineGroupStyle(q4.select(this).selectAll("path"), s3.width, s3.color, s3.dash);\n                });\n              });\n            }\n            Bwe.exports = { style: Wwt };\n          });\n          var Gwe = ye((dfr, Vwe) => {\n            "use strict";\n            var Uwe = ka().opacity, Xwt = ET().hoverOnBars, eH = Dr().formatPercent;\n            Vwe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = Xwt(t3, r4, n4, i3, a4);\n              if (o4) {\n                var s3 = o4.cd, l3 = s3[0].trace, u4 = l3.orientation === "h", c5 = o4.index, f4 = s3[c5], h3 = u4 ? "x" : "y";\n                o4[h3 + "LabelVal"] = f4.s, o4.percentInitial = f4.begR, o4.percentInitialLabel = eH(f4.begR, 1), o4.percentPrevious = f4.difR, o4.percentPreviousLabel = eH(f4.difR, 1), o4.percentTotal = f4.sumR, o4.percentTotalLabel = eH(f4.sumR, 1);\n                var d3 = f4.hi || l3.hoverinfo, v3 = [];\n                if (d3 && d3 !== "none" && d3 !== "skip") {\n                  var _2 = d3 === "all", b = d3.split("+"), p3 = function(k4) {\n                    return _2 || b.indexOf(k4) !== -1;\n                  };\n                  p3("percent initial") && v3.push(o4.percentInitialLabel + " of initial"), p3("percent previous") && v3.push(o4.percentPreviousLabel + " of previous"), p3("percent total") && v3.push(o4.percentTotalLabel + " of total");\n                }\n                return o4.extraText = v3.join("<br>"), o4.color = Zwt(l3, f4), [o4];\n              }\n            };\n            function Zwt(e3, t3) {\n              var r4 = e3.marker, n4 = t3.mc || r4.color, i3 = t3.mlc || r4.line.color, a4 = t3.mlw || r4.line.width;\n              if (Uwe(n4)) return n4;\n              if (Uwe(i3) && a4) return i3;\n            }\n          });\n          var jwe = ye((vfr, Hwe) => {\n            "use strict";\n            Hwe.exports = function(t3, r4) {\n              return t3.x = "xVal" in r4 ? r4.xVal : r4.x, t3.y = "yVal" in r4 ? r4.yVal : r4.y, "percentInitial" in r4 && (t3.percentInitial = r4.percentInitial), "percentPrevious" in r4 && (t3.percentPrevious = r4.percentPrevious), "percentTotal" in r4 && (t3.percentTotal = r4.percentTotal), r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), t3;\n            };\n          });\n          var Xwe = ye((pfr, Wwe) => {\n            "use strict";\n            Wwe.exports = { attributes: ZG(), layoutAttributes: YG(), supplyDefaults: JG().supplyDefaults, crossTraceDefaults: JG().crossTraceDefaults, supplyLayoutDefaults: Awe(), calc: Lwe(), crossTraceCalc: Rwe(), plot: Owe(), style: Nwe().style, hoverPoints: Gwe(), eventData: jwe(), selectPoints: kT(), moduleType: "trace", name: "funnel", basePlotModule: ph(), categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"], meta: {} };\n          });\n          var Ywe = ye((gfr, Zwe) => {\n            "use strict";\n            Zwe.exports = Xwe();\n          });\n          var Jwe = ye((mfr, Kwe) => {\n            "use strict";\n            Kwe.exports = { eventDataKeys: ["initial", "delta", "final"] };\n          });\n          var iH = ye((yfr, t3e) => {\n            "use strict";\n            var _c = Lm(), tH = pf().line, Ywt = Gl(), $we = df().axisHoverFormat, { hovertemplateAttrs: Kwt, texttemplateAttrs: Jwt, templatefallbackAttrs: Qwe } = Ll(), e3e = Jwe(), WT = Ao().extendFlat, $wt = ka();\n            function rH(e3) {\n              return { marker: { color: WT({}, _c.marker.color, { arrayOk: false, editType: "style" }), line: { color: WT({}, _c.marker.line.color, { arrayOk: false, editType: "style" }), width: WT({}, _c.marker.line.width, { arrayOk: false, editType: "style" }), editType: "style" }, editType: "style" }, editType: "style" };\n            }\n            t3e.exports = { measure: { valType: "data_array", dflt: [], editType: "calc" }, base: { valType: "number", dflt: null, arrayOk: false, editType: "calc" }, x: _c.x, x0: _c.x0, dx: _c.dx, y: _c.y, y0: _c.y0, dy: _c.dy, xperiod: _c.xperiod, yperiod: _c.yperiod, xperiod0: _c.xperiod0, yperiod0: _c.yperiod0, xperiodalignment: _c.xperiodalignment, yperiodalignment: _c.yperiodalignment, xhoverformat: $we("x"), yhoverformat: $we("y"), hovertext: _c.hovertext, hovertemplate: Kwt({}, { keys: e3e.eventDataKeys }), hovertemplatefallback: Qwe(), hoverinfo: WT({}, Ywt.hoverinfo, { flags: ["name", "x", "y", "text", "initial", "delta", "final"] }), textinfo: { valType: "flaglist", flags: ["label", "text", "initial", "delta", "final"], extras: ["none"], editType: "plot", arrayOk: false }, texttemplate: Jwt({ editType: "plot" }, { keys: e3e.eventDataKeys.concat(["label"]) }), texttemplatefallback: Qwe({ editType: "plot" }), text: _c.text, textposition: _c.textposition, insidetextanchor: _c.insidetextanchor, textangle: _c.textangle, textfont: _c.textfont, insidetextfont: _c.insidetextfont, outsidetextfont: _c.outsidetextfont, constraintext: _c.constraintext, cliponaxis: _c.cliponaxis, orientation: _c.orientation, offset: _c.offset, width: _c.width, increasing: rH("increasing"), decreasing: rH("decreasing"), totals: rH("intermediate sums and total"), connector: { line: { color: WT({}, tH.color, { dflt: $wt.defaultLine }), width: WT({}, tH.width, { editType: "plot" }), dash: tH.dash, editType: "plot" }, mode: { valType: "enumerated", values: ["spanning", "between"], dflt: "between", editType: "plot" }, visible: { valType: "boolean", dflt: true, editType: "plot" }, editType: "plot" }, offsetgroup: _c.offsetgroup, alignmentgroup: _c.alignmentgroup, zorder: _c.zorder };\n          });\n          var nH = ye((_fr, r3e) => {\n            "use strict";\n            r3e.exports = { waterfallmode: { valType: "enumerated", values: ["group", "overlay"], dflt: "group", editType: "calc" }, waterfallgap: { valType: "number", min: 0, max: 1, editType: "calc" }, waterfallgroupgap: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" } };\n          });\n          var XT = ye((xfr, i3e) => {\n            "use strict";\n            i3e.exports = { INCREASING: { COLOR: "#3D9970", SYMBOL: "\\u25B2" }, DECREASING: { COLOR: "#FF4136", SYMBOL: "\\u25BC" } };\n          });\n          var oH = ye((bfr, s3e) => {\n            "use strict";\n            var n3e = Dr(), Qwt = Hb(), e3t = r0().handleText, t3t = eT(), r3t = Ig(), a3e = iH(), i3t = ka(), o3e = XT(), n3t = o3e.INCREASING.COLOR, a3t = o3e.DECREASING.COLOR, o3t = "#4499FF";\n            function aH(e3, t3, r4) {\n              e3(t3 + ".marker.color", r4), e3(t3 + ".marker.line.color", i3t.defaultLine), e3(t3 + ".marker.line.width");\n            }\n            function s3t(e3, t3, r4, n4) {\n              function i3(u4, c5) {\n                return n3e.coerce(e3, t3, a3e, u4, c5);\n              }\n              var a4 = t3t(e3, t3, n4, i3);\n              if (!a4) {\n                t3.visible = false;\n                return;\n              }\n              r3t(e3, t3, n4, i3), i3("xhoverformat"), i3("yhoverformat"), i3("measure"), i3("orientation", t3.x && !t3.y ? "h" : "v"), i3("base"), i3("offset"), i3("width"), i3("text"), i3("hovertext"), i3("hovertemplate"), i3("hovertemplatefallback");\n              var o4 = i3("textposition");\n              e3t(e3, t3, n4, i3, o4, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: true, moduleHasCliponaxis: true, moduleHasTextangle: true, moduleHasInsideanchor: true }), t3.textposition !== "none" && (i3("texttemplate"), i3("texttemplatefallback"), t3.texttemplate || i3("textinfo")), aH(i3, "increasing", n3t), aH(i3, "decreasing", a3t), aH(i3, "totals", o3t);\n              var s3 = i3("connector.visible");\n              if (s3) {\n                i3("connector.mode");\n                var l3 = i3("connector.line.width");\n                l3 && (i3("connector.line.color"), i3("connector.line.dash"));\n              }\n              i3("zorder");\n            }\n            function l3t(e3, t3) {\n              var r4, n4;\n              function i3(o4) {\n                return n3e.coerce(n4._input, n4, a3e, o4);\n              }\n              if (t3.waterfallmode === "group") for (var a4 = 0; a4 < e3.length; a4++) n4 = e3[a4], r4 = n4._input, Qwt(r4, n4, t3, i3, t3.waterfallmode);\n            }\n            s3e.exports = { supplyDefaults: s3t, crossTraceDefaults: l3t };\n          });\n          var u3e = ye((wfr, l3e) => {\n            "use strict";\n            var u3t = Dr(), c3t = nH();\n            l3e.exports = function(e3, t3, r4) {\n              var n4 = false;\n              function i3(s3, l3) {\n                return u3t.coerce(e3, t3, c3t, s3, l3);\n              }\n              for (var a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4];\n                if (o4.visible && o4.type === "waterfall") {\n                  n4 = true;\n                  break;\n                }\n              }\n              n4 && (i3("waterfallmode"), i3("waterfallgap", 0.2), i3("waterfallgroupgap"));\n            };\n          });\n          var p3e = ye((Tfr, v3e) => {\n            "use strict";\n            var c3e = ho(), f3e = Dg(), h3e = Dr().mergeArray, f3t = z0(), d3e = fs().BADNUM;\n            function sH(e3) {\n              return e3 === "a" || e3 === "absolute";\n            }\n            function lH(e3) {\n              return e3 === "t" || e3 === "total";\n            }\n            v3e.exports = function(t3, r4) {\n              var n4 = c3e.getFromId(t3, r4.xaxis || "x"), i3 = c3e.getFromId(t3, r4.yaxis || "y"), a4, o4, s3, l3, u4, c5;\n              r4.orientation === "h" ? (a4 = n4.makeCalcdata(r4, "x"), s3 = i3.makeCalcdata(r4, "y"), l3 = f3e(r4, i3, "y", s3), u4 = !!r4.yperiodalignment, c5 = "y") : (a4 = i3.makeCalcdata(r4, "y"), s3 = n4.makeCalcdata(r4, "x"), l3 = f3e(r4, n4, "x", s3), u4 = !!r4.xperiodalignment, c5 = "x"), o4 = l3.vals;\n              for (var f4 = Math.min(o4.length, a4.length), h3 = new Array(f4), d3 = 0, v3, _2 = false, b = 0; b < f4; b++) {\n                var p3 = a4[b] || 0, k4 = false;\n                (a4[b] !== d3e || lH(r4.measure[b]) || sH(r4.measure[b])) && b + 1 < f4 && (a4[b + 1] !== d3e || lH(r4.measure[b + 1]) || sH(r4.measure[b + 1])) && (k4 = true);\n                var E3 = h3[b] = { i: b, p: o4[b], s: p3, rawS: p3, cNext: k4 };\n                sH(r4.measure[b]) ? (d3 = E3.s, E3.isSum = true, E3.dir = "totals", E3.s = d3) : lH(r4.measure[b]) ? (E3.isSum = true, E3.dir = "totals", E3.s = d3) : (E3.isSum = false, E3.dir = E3.rawS < 0 ? "decreasing" : "increasing", v3 = E3.s, E3.s = d3 + v3, d3 += v3), E3.dir === "totals" && (_2 = true), u4 && (h3[b].orig_p = s3[b], h3[b][c5 + "End"] = l3.ends[b], h3[b][c5 + "Start"] = l3.starts[b]), r4.ids && (E3.id = String(r4.ids[b])), E3.v = (r4.base || 0) + d3;\n              }\n              return h3.length && (h3[0].hasTotals = _2), h3e(r4.text, h3, "tx"), h3e(r4.hovertext, h3, "htx"), f3t(h3, r4), h3;\n            };\n          });\n          var y3e = ye((Afr, m3e) => {\n            "use strict";\n            var g3e = jb().setGroupPositions;\n            m3e.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = t3._fullData, a4 = t3.calcdata, o4 = r4.xaxis, s3 = r4.yaxis, l3 = [], u4 = [], c5 = [], f4, h3;\n              for (h3 = 0; h3 < i3.length; h3++) {\n                var d3 = i3[h3];\n                d3.visible === true && d3.xaxis === o4._id && d3.yaxis === s3._id && d3.type === "waterfall" && (f4 = a4[h3], d3.orientation === "h" ? c5.push(f4) : u4.push(f4), l3.push(f4));\n              }\n              var v3 = { mode: n4.waterfallmode, norm: n4.waterfallnorm, gap: n4.waterfallgap, groupgap: n4.waterfallgroupgap };\n              for (g3e(t3, o4, s3, u4, v3), g3e(t3, s3, o4, c5, v3), h3 = 0; h3 < l3.length; h3++) {\n                f4 = l3[h3];\n                for (var _2 = 0; _2 < f4.length; _2++) {\n                  var b = f4[_2];\n                  b.isSum === false && (b.s0 += _2 === 0 ? 0 : f4[_2 - 1].s), _2 + 1 < f4.length && (f4[_2].nextP0 = f4[_2 + 1].p0, f4[_2].nextS0 = f4[_2 + 1].s0);\n                }\n              }\n            };\n          });\n          var b3e = ye((Sfr, x3e) => {\n            "use strict";\n            var _3e = Oa(), N8 = Dr(), h3t = So(), ZT = fs().BADNUM, d3t = n2(), v3t = bv().clearMinTextSize;\n            x3e.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._fullLayout;\n              v3t("waterfall", a4), d3t.plot(t3, r4, n4, i3, { mode: a4.waterfallmode, norm: a4.waterfallmode, gap: a4.waterfallgap, groupgap: a4.waterfallgroupgap }), p3t(t3, r4, n4, i3);\n            };\n            function p3t(e3, t3, r4, n4) {\n              var i3 = t3.xaxis, a4 = t3.yaxis;\n              N8.makeTraceGroups(n4, r4, "trace bars").each(function(o4) {\n                var s3 = _3e.select(this), l3 = o4[0].trace, u4 = N8.ensureSingle(s3, "g", "lines");\n                if (!l3.connector || !l3.connector.visible) {\n                  u4.remove();\n                  return;\n                }\n                var c5 = l3.orientation === "h", f4 = l3.connector.mode, h3 = u4.selectAll("g.line").data(N8.identity);\n                h3.enter().append("g").classed("line", true), h3.exit().remove();\n                var d3 = h3.size();\n                h3.each(function(v3, _2) {\n                  if (!(_2 !== d3 - 1 && !v3.cNext)) {\n                    var b = g3t(v3, i3, a4, c5), p3 = b[0], k4 = b[1], E3 = "";\n                    p3[0] !== ZT && k4[0] !== ZT && p3[1] !== ZT && k4[1] !== ZT && (f4 === "spanning" && !v3.isSum && _2 > 0 && (c5 ? E3 += "M" + p3[0] + "," + k4[1] + "V" + k4[0] : E3 += "M" + p3[1] + "," + k4[0] + "H" + p3[0]), f4 !== "between" && (v3.isSum || _2 < d3 - 1) && (c5 ? E3 += "M" + p3[1] + "," + k4[0] + "V" + k4[1] : E3 += "M" + p3[0] + "," + k4[1] + "H" + p3[1]), p3[2] !== ZT && k4[2] !== ZT && (c5 ? E3 += "M" + p3[1] + "," + k4[1] + "V" + k4[2] : E3 += "M" + p3[1] + "," + k4[1] + "H" + p3[2])), E3 === "" && (E3 = "M0,0Z"), N8.ensureSingle(_3e.select(this), "path").attr("d", E3).call(h3t.setClipUrl, t3.layerClipId, e3);\n                  }\n                });\n              });\n            }\n            function g3t(e3, t3, r4, n4) {\n              var i3 = [], a4 = [], o4 = n4 ? t3 : r4, s3 = n4 ? r4 : t3;\n              return i3[0] = o4.c2p(e3.s0, true), a4[0] = s3.c2p(e3.p0, true), i3[1] = o4.c2p(e3.s1, true), a4[1] = s3.c2p(e3.p1, true), i3[2] = o4.c2p(e3.nextS0, true), a4[2] = s3.c2p(e3.nextP0, true), n4 ? [i3, a4] : [a4, i3];\n            }\n          });\n          var S3e = ye((Mfr, A3e) => {\n            "use strict";\n            var U8 = Oa(), w3e = So(), T3e = ka(), m3t = N1().DESELECTDIM, y3t = N0(), _3t = bv().resizeText, x3t = y3t.styleTextPoints;\n            function b3t(e3, t3, r4) {\n              var n4 = r4 || U8.select(e3).selectAll(\'g[class^="waterfalllayer"]\').selectAll("g.trace");\n              _3t(e3, n4, "waterfall"), n4.style("opacity", function(i3) {\n                return i3[0].trace.opacity;\n              }), n4.each(function(i3) {\n                var a4 = U8.select(this), o4 = i3[0].trace;\n                a4.selectAll(".point > path").each(function(s3) {\n                  if (!s3.isBlank) {\n                    var l3 = o4[s3.dir].marker;\n                    U8.select(this).call(T3e.fill, l3.color).call(T3e.stroke, l3.line.color).call(w3e.dashLine, l3.line.dash, l3.line.width).style("opacity", o4.selectedpoints && !s3.selected ? m3t : 1);\n                  }\n                }), x3t(a4, o4, e3), a4.selectAll(".lines").each(function() {\n                  var s3 = o4.connector.line;\n                  w3e.lineGroupStyle(U8.select(this).selectAll("path"), s3.width, s3.color, s3.dash);\n                });\n              });\n            }\n            A3e.exports = { style: b3t };\n          });\n          var L3e = ye((Efr, C3e) => {\n            "use strict";\n            var w3t = ho().hoverLabelText, M3e = ka().opacity, T3t = ET().hoverOnBars, E3e = XT(), k3e = { increasing: E3e.INCREASING.SYMBOL, decreasing: E3e.DECREASING.SYMBOL };\n            C3e.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = T3t(t3, r4, n4, i3, a4);\n              if (!o4) return;\n              var s3 = o4.cd, l3 = s3[0].trace, u4 = l3.orientation === "h", c5 = u4 ? "x" : "y", f4 = u4 ? t3.xa : t3.ya;\n              function h3(x2) {\n                return w3t(f4, x2, l3[c5 + "hoverformat"]);\n              }\n              var d3 = o4.index, v3 = s3[d3], _2 = v3.isSum ? v3.b + v3.s : v3.rawS;\n              o4.initial = v3.b + v3.s - _2, o4.delta = _2, o4.final = o4.initial + o4.delta;\n              var b = h3(Math.abs(o4.delta));\n              o4.deltaLabel = _2 < 0 ? "(" + b + ")" : b, o4.finalLabel = h3(o4.final), o4.initialLabel = h3(o4.initial);\n              var p3 = v3.hi || l3.hoverinfo, k4 = [];\n              if (p3 && p3 !== "none" && p3 !== "skip") {\n                var E3 = p3 === "all", S2 = p3.split("+"), L3 = function(x2) {\n                  return E3 || S2.indexOf(x2) !== -1;\n                };\n                v3.isSum || (L3("final") && (u4 ? !L3("x") : !L3("y")) && k4.push(o4.finalLabel), L3("delta") && (_2 < 0 ? k4.push(o4.deltaLabel + " " + k3e.decreasing) : k4.push(o4.deltaLabel + " " + k3e.increasing)), L3("initial") && k4.push("Initial: " + o4.initialLabel));\n              }\n              return k4.length && (o4.extraText = k4.join("<br>")), o4.color = A3t(l3, v3), [o4];\n            };\n            function A3t(e3, t3) {\n              var r4 = e3[t3.dir].marker, n4 = r4.color, i3 = r4.line.color, a4 = r4.line.width;\n              if (M3e(n4)) return n4;\n              if (M3e(i3) && a4) return i3;\n            }\n          });\n          var I3e = ye((kfr, P3e) => {\n            "use strict";\n            P3e.exports = function(t3, r4) {\n              return t3.x = "xVal" in r4 ? r4.xVal : r4.x, t3.y = "yVal" in r4 ? r4.yVal : r4.y, "initial" in r4 && (t3.initial = r4.initial), "delta" in r4 && (t3.delta = r4.delta), "final" in r4 && (t3.final = r4.final), r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), t3;\n            };\n          });\n          var D3e = ye((Cfr, R3e) => {\n            "use strict";\n            R3e.exports = { attributes: iH(), layoutAttributes: nH(), supplyDefaults: oH().supplyDefaults, crossTraceDefaults: oH().crossTraceDefaults, supplyLayoutDefaults: u3e(), calc: p3e(), crossTraceCalc: y3e(), plot: b3e(), style: S3e().style, hoverPoints: L3e(), eventData: I3e(), selectPoints: kT(), moduleType: "trace", name: "waterfall", basePlotModule: ph(), categories: ["bar-like", "cartesian", "svg", "oriented", "showLegend", "zoomScale"], meta: {} };\n          });\n          var z3e = ye((Lfr, F3e) => {\n            "use strict";\n            F3e.exports = D3e();\n          });\n          var YT = ye((Pfr, O3e) => {\n            "use strict";\n            O3e.exports = { colormodel: { rgb: { min: [0, 0, 0], max: [255, 255, 255], fmt: function(e3) {\n              return e3.slice(0, 3);\n            }, suffix: ["", "", ""] }, rgba: { min: [0, 0, 0, 0], max: [255, 255, 255, 1], fmt: function(e3) {\n              return e3.slice(0, 4);\n            }, suffix: ["", "", "", ""] }, rgba256: { colormodel: "rgba", zminDflt: [0, 0, 0, 0], zmaxDflt: [255, 255, 255, 255], min: [0, 0, 0, 0], max: [255, 255, 255, 1], fmt: function(e3) {\n              return e3.slice(0, 4);\n            }, suffix: ["", "", "", ""] }, hsl: { min: [0, 0, 0], max: [360, 100, 100], fmt: function(e3) {\n              var t3 = e3.slice(0, 3);\n              return t3[1] = t3[1] + "%", t3[2] = t3[2] + "%", t3;\n            }, suffix: ["\\xB0", "%", "%"] }, hsla: { min: [0, 0, 0, 0], max: [360, 100, 100, 1], fmt: function(e3) {\n              var t3 = e3.slice(0, 4);\n              return t3[1] = t3[1] + "%", t3[2] = t3[2] + "%", t3;\n            }, suffix: ["\\xB0", "%", "%", ""] } } };\n          });\n          var uH = ye((Ifr, B3e) => {\n            "use strict";\n            var S3t = Gl(), M3t = pf().zorder, { hovertemplateAttrs: E3t, templatefallbackAttrs: k3t } = Ll(), q3e = Ao().extendFlat, C3t = YT().colormodel, N4 = ["rgb", "rgba", "rgba256", "hsl", "hsla"], L3t = [], P3t = [];\n            for (KT = 0; KT < N4.length; KT++) B4 = C3t[N4[KT]], L3t.push("For the `" + N4[KT] + "` colormodel, it is [" + (B4.zminDflt || B4.min).join(", ") + "]."), P3t.push("For the `" + N4[KT] + "` colormodel, it is [" + (B4.zmaxDflt || B4.max).join(", ") + "].");\n            var B4, KT;\n            B3e.exports = q3e({ source: { valType: "string", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, colormodel: { valType: "enumerated", values: N4, editType: "calc" }, zsmooth: { valType: "enumerated", values: ["fast", false], dflt: false, editType: "plot" }, zmin: { valType: "info_array", items: [{ valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }], editType: "calc" }, zmax: { valType: "info_array", items: [{ valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }, { valType: "number", editType: "calc" }], editType: "calc" }, x0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, y0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dx: { valType: "number", dflt: 1, editType: "calc", description: "Set the pixel\'s horizontal size." }, dy: { valType: "number", dflt: 1, editType: "calc", description: "Set the pixel\'s vertical size" }, text: { valType: "data_array", editType: "plot" }, hovertext: { valType: "data_array", editType: "plot" }, hoverinfo: q3e({}, S3t.hoverinfo, { flags: ["x", "y", "z", "color", "name", "text"], dflt: "x+y+z+text+name" }), hovertemplate: E3t({}, { keys: ["z", "color", "colormodel"] }), hovertemplatefallback: k3t(), zorder: M3t });\n          });\n          var V3e = ye((Rfr, U3e) => {\n            "use strict";\n            var I3t = Dr(), R3t = uH(), N3e = YT(), D3t = Py().IMAGE_URL_PREFIX;\n            U3e.exports = function(t3, r4) {\n              function n4(o4, s3) {\n                return I3t.coerce(t3, r4, R3t, o4, s3);\n              }\n              n4("source"), r4.source && !r4.source.match(D3t) && delete r4.source, r4._hasSource = !!r4.source;\n              var i3 = n4("z");\n              if (r4._hasZ = !(i3 === void 0 || !i3.length || !i3[0] || !i3[0].length), !r4._hasZ && !r4._hasSource) {\n                r4.visible = false;\n                return;\n              }\n              n4("x0"), n4("y0"), n4("dx"), n4("dy");\n              var a4;\n              r4._hasZ ? (n4("colormodel", "rgb"), a4 = N3e.colormodel[r4.colormodel], n4("zmin", a4.zminDflt || a4.min), n4("zmax", a4.zmaxDflt || a4.max)) : r4._hasSource && (r4.colormodel = "rgba256", a4 = N3e.colormodel[r4.colormodel], r4.zmin = a4.zminDflt, r4.zmax = a4.zmaxDflt), n4("zsmooth"), n4("text"), n4("hovertext"), n4("hovertemplate"), n4("hovertemplatefallback"), r4._length = null, n4("zorder");\n            };\n          });\n          var Uy = ye((Dfr, cH) => {\n            typeof Object.create == "function" ? cH.exports = function(t3, r4) {\n              r4 && (t3.super_ = r4, t3.prototype = Object.create(r4.prototype, { constructor: { value: t3, enumerable: false, writable: true, configurable: true } }));\n            } : cH.exports = function(t3, r4) {\n              if (r4) {\n                t3.super_ = r4;\n                var n4 = function() {\n                };\n                n4.prototype = r4.prototype, t3.prototype = new n4(), t3.prototype.constructor = t3;\n              }\n            };\n          });\n          var fH = ye((Ffr, G3e) => {\n            G3e.exports = pb().EventEmitter;\n          });\n          var W3e = ye((V8) => {\n            "use strict";\n            V8.byteLength = z3t;\n            V8.toByteArray = q3t;\n            V8.fromByteArray = U3t;\n            var Om = [], X0 = [], F3t = typeof Uint8Array != "undefined" ? Uint8Array : Array, hH = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";\n            for (l22 = 0, H3e = hH.length; l22 < H3e; ++l22) Om[l22] = hH[l22], X0[hH.charCodeAt(l22)] = l22;\n            var l22, H3e;\n            X0[45] = 62;\n            X0[95] = 63;\n            function j3e(e3) {\n              var t3 = e3.length;\n              if (t3 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");\n              var r4 = e3.indexOf("=");\n              r4 === -1 && (r4 = t3);\n              var n4 = r4 === t3 ? 0 : 4 - r4 % 4;\n              return [r4, n4];\n            }\n            function z3t(e3) {\n              var t3 = j3e(e3), r4 = t3[0], n4 = t3[1];\n              return (r4 + n4) * 3 / 4 - n4;\n            }\n            function O3t(e3, t3, r4) {\n              return (t3 + r4) * 3 / 4 - r4;\n            }\n            function q3t(e3) {\n              var t3, r4 = j3e(e3), n4 = r4[0], i3 = r4[1], a4 = new F3t(O3t(e3, n4, i3)), o4 = 0, s3 = i3 > 0 ? n4 - 4 : n4, l3;\n              for (l3 = 0; l3 < s3; l3 += 4) t3 = X0[e3.charCodeAt(l3)] << 18 | X0[e3.charCodeAt(l3 + 1)] << 12 | X0[e3.charCodeAt(l3 + 2)] << 6 | X0[e3.charCodeAt(l3 + 3)], a4[o4++] = t3 >> 16 & 255, a4[o4++] = t3 >> 8 & 255, a4[o4++] = t3 & 255;\n              return i3 === 2 && (t3 = X0[e3.charCodeAt(l3)] << 2 | X0[e3.charCodeAt(l3 + 1)] >> 4, a4[o4++] = t3 & 255), i3 === 1 && (t3 = X0[e3.charCodeAt(l3)] << 10 | X0[e3.charCodeAt(l3 + 1)] << 4 | X0[e3.charCodeAt(l3 + 2)] >> 2, a4[o4++] = t3 >> 8 & 255, a4[o4++] = t3 & 255), a4;\n            }\n            function B3t(e3) {\n              return Om[e3 >> 18 & 63] + Om[e3 >> 12 & 63] + Om[e3 >> 6 & 63] + Om[e3 & 63];\n            }\n            function N3t(e3, t3, r4) {\n              for (var n4, i3 = [], a4 = t3; a4 < r4; a4 += 3) n4 = (e3[a4] << 16 & 16711680) + (e3[a4 + 1] << 8 & 65280) + (e3[a4 + 2] & 255), i3.push(B3t(n4));\n              return i3.join("");\n            }\n            function U3t(e3) {\n              for (var t3, r4 = e3.length, n4 = r4 % 3, i3 = [], a4 = 16383, o4 = 0, s3 = r4 - n4; o4 < s3; o4 += a4) i3.push(N3t(e3, o4, o4 + a4 > s3 ? s3 : o4 + a4));\n              return n4 === 1 ? (t3 = e3[r4 - 1], i3.push(Om[t3 >> 2] + Om[t3 << 4 & 63] + "==")) : n4 === 2 && (t3 = (e3[r4 - 2] << 8) + e3[r4 - 1], i3.push(Om[t3 >> 10] + Om[t3 >> 4 & 63] + Om[t3 << 2 & 63] + "=")), i3.join("");\n            }\n          });\n          var X3e = ye((dH) => {\n            dH.read = function(e3, t3, r4, n4, i3) {\n              var a4, o4, s3 = i3 * 8 - n4 - 1, l3 = (1 << s3) - 1, u4 = l3 >> 1, c5 = -7, f4 = r4 ? i3 - 1 : 0, h3 = r4 ? -1 : 1, d3 = e3[t3 + f4];\n              for (f4 += h3, a4 = d3 & (1 << -c5) - 1, d3 >>= -c5, c5 += s3; c5 > 0; a4 = a4 * 256 + e3[t3 + f4], f4 += h3, c5 -= 8) ;\n              for (o4 = a4 & (1 << -c5) - 1, a4 >>= -c5, c5 += n4; c5 > 0; o4 = o4 * 256 + e3[t3 + f4], f4 += h3, c5 -= 8) ;\n              if (a4 === 0) a4 = 1 - u4;\n              else {\n                if (a4 === l3) return o4 ? NaN : (d3 ? -1 : 1) * (1 / 0);\n                o4 = o4 + Math.pow(2, n4), a4 = a4 - u4;\n              }\n              return (d3 ? -1 : 1) * o4 * Math.pow(2, a4 - n4);\n            };\n            dH.write = function(e3, t3, r4, n4, i3, a4) {\n              var o4, s3, l3, u4 = a4 * 8 - i3 - 1, c5 = (1 << u4) - 1, f4 = c5 >> 1, h3 = i3 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, d3 = n4 ? 0 : a4 - 1, v3 = n4 ? 1 : -1, _2 = t3 < 0 || t3 === 0 && 1 / t3 < 0 ? 1 : 0;\n              for (t3 = Math.abs(t3), isNaN(t3) || t3 === 1 / 0 ? (s3 = isNaN(t3) ? 1 : 0, o4 = c5) : (o4 = Math.floor(Math.log(t3) / Math.LN2), t3 * (l3 = Math.pow(2, -o4)) < 1 && (o4--, l3 *= 2), o4 + f4 >= 1 ? t3 += h3 / l3 : t3 += h3 * Math.pow(2, 1 - f4), t3 * l3 >= 2 && (o4++, l3 /= 2), o4 + f4 >= c5 ? (s3 = 0, o4 = c5) : o4 + f4 >= 1 ? (s3 = (t3 * l3 - 1) * Math.pow(2, i3), o4 = o4 + f4) : (s3 = t3 * Math.pow(2, f4 - 1) * Math.pow(2, i3), o4 = 0)); i3 >= 8; e3[r4 + d3] = s3 & 255, d3 += v3, s3 /= 256, i3 -= 8) ;\n              for (o4 = o4 << i3 | s3, u4 += i3; u4 > 0; e3[r4 + d3] = o4 & 255, d3 += v3, o4 /= 256, u4 -= 8) ;\n              e3[r4 + d3 - v3] |= _2 * 128;\n            };\n          });\n          var c22 = ye((eA) => {\n            "use strict";\n            var vH = W3e(), $T = X3e(), Z3e = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;\n            eA.Buffer = ea;\n            eA.SlowBuffer = X3t;\n            eA.INSPECT_MAX_BYTES = 50;\n            var G8 = 2147483647;\n            eA.kMaxLength = G8;\n            ea.TYPED_ARRAY_SUPPORT = V3t();\n            !ea.TYPED_ARRAY_SUPPORT && typeof console != "undefined" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");\n            function V3t() {\n              try {\n                let e3 = new Uint8Array(1), t3 = { foo: function() {\n                  return 42;\n                } };\n                return Object.setPrototypeOf(t3, Uint8Array.prototype), Object.setPrototypeOf(e3, t3), e3.foo() === 42;\n              } catch (e3) {\n                return false;\n              }\n            }\n            Object.defineProperty(ea.prototype, "parent", { enumerable: true, get: function() {\n              if (ea.isBuffer(this)) return this.buffer;\n            } });\n            Object.defineProperty(ea.prototype, "offset", { enumerable: true, get: function() {\n              if (ea.isBuffer(this)) return this.byteOffset;\n            } });\n            function Vy(e3) {\n              if (e3 > G8) throw new RangeError(\'The value "\' + e3 + \'" is invalid for option "size"\');\n              let t3 = new Uint8Array(e3);\n              return Object.setPrototypeOf(t3, ea.prototype), t3;\n            }\n            function ea(e3, t3, r4) {\n              if (typeof e3 == "number") {\n                if (typeof t3 == "string") throw new TypeError(\'The "string" argument must be of type string. Received type number\');\n                return yH(e3);\n              }\n              return $3e(e3, t3, r4);\n            }\n            ea.poolSize = 8192;\n            function $3e(e3, t3, r4) {\n              if (typeof e3 == "string") return H3t(e3, t3);\n              if (ArrayBuffer.isView(e3)) return j3t(e3);\n              if (e3 == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e3);\n              if (qm(e3, ArrayBuffer) || e3 && qm(e3.buffer, ArrayBuffer) || typeof SharedArrayBuffer != "undefined" && (qm(e3, SharedArrayBuffer) || e3 && qm(e3.buffer, SharedArrayBuffer))) return gH(e3, t3, r4);\n              if (typeof e3 == "number") throw new TypeError(\'The "value" argument must not be of type number. Received type number\');\n              let n4 = e3.valueOf && e3.valueOf();\n              if (n4 != null && n4 !== e3) return ea.from(n4, t3, r4);\n              let i3 = W3t(e3);\n              if (i3) return i3;\n              if (typeof Symbol != "undefined" && Symbol.toPrimitive != null && typeof e3[Symbol.toPrimitive] == "function") return ea.from(e3[Symbol.toPrimitive]("string"), t3, r4);\n              throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e3);\n            }\n            ea.from = function(e3, t3, r4) {\n              return $3e(e3, t3, r4);\n            };\n            Object.setPrototypeOf(ea.prototype, Uint8Array.prototype);\n            Object.setPrototypeOf(ea, Uint8Array);\n            function Q3e(e3) {\n              if (typeof e3 != "number") throw new TypeError(\'"size" argument must be of type number\');\n              if (e3 < 0) throw new RangeError(\'The value "\' + e3 + \'" is invalid for option "size"\');\n            }\n            function G3t(e3, t3, r4) {\n              return Q3e(e3), e3 <= 0 ? Vy(e3) : t3 !== void 0 ? typeof r4 == "string" ? Vy(e3).fill(t3, r4) : Vy(e3).fill(t3) : Vy(e3);\n            }\n            ea.alloc = function(e3, t3, r4) {\n              return G3t(e3, t3, r4);\n            };\n            function yH(e3) {\n              return Q3e(e3), Vy(e3 < 0 ? 0 : _H(e3) | 0);\n            }\n            ea.allocUnsafe = function(e3) {\n              return yH(e3);\n            };\n            ea.allocUnsafeSlow = function(e3) {\n              return yH(e3);\n            };\n            function H3t(e3, t3) {\n              if ((typeof t3 != "string" || t3 === "") && (t3 = "utf8"), !ea.isEncoding(t3)) throw new TypeError("Unknown encoding: " + t3);\n              let r4 = eTe(e3, t3) | 0, n4 = Vy(r4), i3 = n4.write(e3, t3);\n              return i3 !== r4 && (n4 = n4.slice(0, i3)), n4;\n            }\n            function pH(e3) {\n              let t3 = e3.length < 0 ? 0 : _H(e3.length) | 0, r4 = Vy(t3);\n              for (let n4 = 0; n4 < t3; n4 += 1) r4[n4] = e3[n4] & 255;\n              return r4;\n            }\n            function j3t(e3) {\n              if (qm(e3, Uint8Array)) {\n                let t3 = new Uint8Array(e3);\n                return gH(t3.buffer, t3.byteOffset, t3.byteLength);\n              }\n              return pH(e3);\n            }\n            function gH(e3, t3, r4) {\n              if (t3 < 0 || e3.byteLength < t3) throw new RangeError(\'"offset" is outside of buffer bounds\');\n              if (e3.byteLength < t3 + (r4 || 0)) throw new RangeError(\'"length" is outside of buffer bounds\');\n              let n4;\n              return t3 === void 0 && r4 === void 0 ? n4 = new Uint8Array(e3) : r4 === void 0 ? n4 = new Uint8Array(e3, t3) : n4 = new Uint8Array(e3, t3, r4), Object.setPrototypeOf(n4, ea.prototype), n4;\n            }\n            function W3t(e3) {\n              if (ea.isBuffer(e3)) {\n                let t3 = _H(e3.length) | 0, r4 = Vy(t3);\n                return r4.length === 0 || e3.copy(r4, 0, 0, t3), r4;\n              }\n              if (e3.length !== void 0) return typeof e3.length != "number" || bH(e3.length) ? Vy(0) : pH(e3);\n              if (e3.type === "Buffer" && Array.isArray(e3.data)) return pH(e3.data);\n            }\n            function _H(e3) {\n              if (e3 >= G8) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + G8.toString(16) + " bytes");\n              return e3 | 0;\n            }\n            function X3t(e3) {\n              return +e3 != e3 && (e3 = 0), ea.alloc(+e3);\n            }\n            ea.isBuffer = function(t3) {\n              return t3 != null && t3._isBuffer === true && t3 !== ea.prototype;\n            };\n            ea.compare = function(t3, r4) {\n              if (qm(t3, Uint8Array) && (t3 = ea.from(t3, t3.offset, t3.byteLength)), qm(r4, Uint8Array) && (r4 = ea.from(r4, r4.offset, r4.byteLength)), !ea.isBuffer(t3) || !ea.isBuffer(r4)) throw new TypeError(\'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array\');\n              if (t3 === r4) return 0;\n              let n4 = t3.length, i3 = r4.length;\n              for (let a4 = 0, o4 = Math.min(n4, i3); a4 < o4; ++a4) if (t3[a4] !== r4[a4]) {\n                n4 = t3[a4], i3 = r4[a4];\n                break;\n              }\n              return n4 < i3 ? -1 : i3 < n4 ? 1 : 0;\n            };\n            ea.isEncoding = function(t3) {\n              switch (String(t3).toLowerCase()) {\n                case "hex":\n                case "utf8":\n                case "utf-8":\n                case "ascii":\n                case "latin1":\n                case "binary":\n                case "base64":\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                  return true;\n                default:\n                  return false;\n              }\n            };\n            ea.concat = function(t3, r4) {\n              if (!Array.isArray(t3)) throw new TypeError(\'"list" argument must be an Array of Buffers\');\n              if (t3.length === 0) return ea.alloc(0);\n              let n4;\n              if (r4 === void 0) for (r4 = 0, n4 = 0; n4 < t3.length; ++n4) r4 += t3[n4].length;\n              let i3 = ea.allocUnsafe(r4), a4 = 0;\n              for (n4 = 0; n4 < t3.length; ++n4) {\n                let o4 = t3[n4];\n                if (qm(o4, Uint8Array)) a4 + o4.length > i3.length ? (ea.isBuffer(o4) || (o4 = ea.from(o4)), o4.copy(i3, a4)) : Uint8Array.prototype.set.call(i3, o4, a4);\n                else if (ea.isBuffer(o4)) o4.copy(i3, a4);\n                else throw new TypeError(\'"list" argument must be an Array of Buffers\');\n                a4 += o4.length;\n              }\n              return i3;\n            };\n            function eTe(e3, t3) {\n              if (ea.isBuffer(e3)) return e3.length;\n              if (ArrayBuffer.isView(e3) || qm(e3, ArrayBuffer)) return e3.byteLength;\n              if (typeof e3 != "string") throw new TypeError(\'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type \' + typeof e3);\n              let r4 = e3.length, n4 = arguments.length > 2 && arguments[2] === true;\n              if (!n4 && r4 === 0) return 0;\n              let i3 = false;\n              for (; ; ) switch (t3) {\n                case "ascii":\n                case "latin1":\n                case "binary":\n                  return r4;\n                case "utf8":\n                case "utf-8":\n                  return mH(e3).length;\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                  return r4 * 2;\n                case "hex":\n                  return r4 >>> 1;\n                case "base64":\n                  return uTe(e3).length;\n                default:\n                  if (i3) return n4 ? -1 : mH(e3).length;\n                  t3 = ("" + t3).toLowerCase(), i3 = true;\n              }\n            }\n            ea.byteLength = eTe;\n            function Z3t(e3, t3, r4) {\n              let n4 = false;\n              if ((t3 === void 0 || t3 < 0) && (t3 = 0), t3 > this.length || ((r4 === void 0 || r4 > this.length) && (r4 = this.length), r4 <= 0) || (r4 >>>= 0, t3 >>>= 0, r4 <= t3)) return "";\n              for (e3 || (e3 = "utf8"); ; ) switch (e3) {\n                case "hex":\n                  return nTt(this, t3, r4);\n                case "utf8":\n                case "utf-8":\n                  return rTe(this, t3, r4);\n                case "ascii":\n                  return rTt(this, t3, r4);\n                case "latin1":\n                case "binary":\n                  return iTt(this, t3, r4);\n                case "base64":\n                  return eTt(this, t3, r4);\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                  return aTt(this, t3, r4);\n                default:\n                  if (n4) throw new TypeError("Unknown encoding: " + e3);\n                  e3 = (e3 + "").toLowerCase(), n4 = true;\n              }\n            }\n            ea.prototype._isBuffer = true;\n            function u22(e3, t3, r4) {\n              let n4 = e3[t3];\n              e3[t3] = e3[r4], e3[r4] = n4;\n            }\n            ea.prototype.swap16 = function() {\n              let t3 = this.length;\n              if (t3 % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");\n              for (let r4 = 0; r4 < t3; r4 += 2) u22(this, r4, r4 + 1);\n              return this;\n            };\n            ea.prototype.swap32 = function() {\n              let t3 = this.length;\n              if (t3 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");\n              for (let r4 = 0; r4 < t3; r4 += 4) u22(this, r4, r4 + 3), u22(this, r4 + 1, r4 + 2);\n              return this;\n            };\n            ea.prototype.swap64 = function() {\n              let t3 = this.length;\n              if (t3 % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");\n              for (let r4 = 0; r4 < t3; r4 += 8) u22(this, r4, r4 + 7), u22(this, r4 + 1, r4 + 6), u22(this, r4 + 2, r4 + 5), u22(this, r4 + 3, r4 + 4);\n              return this;\n            };\n            ea.prototype.toString = function() {\n              let t3 = this.length;\n              return t3 === 0 ? "" : arguments.length === 0 ? rTe(this, 0, t3) : Z3t.apply(this, arguments);\n            };\n            ea.prototype.toLocaleString = ea.prototype.toString;\n            ea.prototype.equals = function(t3) {\n              if (!ea.isBuffer(t3)) throw new TypeError("Argument must be a Buffer");\n              return this === t3 ? true : ea.compare(this, t3) === 0;\n            };\n            ea.prototype.inspect = function() {\n              let t3 = "", r4 = eA.INSPECT_MAX_BYTES;\n              return t3 = this.toString("hex", 0, r4).replace(/(.{2})/g, "$1 ").trim(), this.length > r4 && (t3 += " ... "), "<Buffer " + t3 + ">";\n            };\n            Z3e && (ea.prototype[Z3e] = ea.prototype.inspect);\n            ea.prototype.compare = function(t3, r4, n4, i3, a4) {\n              if (qm(t3, Uint8Array) && (t3 = ea.from(t3, t3.offset, t3.byteLength)), !ea.isBuffer(t3)) throw new TypeError(\'The "target" argument must be one of type Buffer or Uint8Array. Received type \' + typeof t3);\n              if (r4 === void 0 && (r4 = 0), n4 === void 0 && (n4 = t3 ? t3.length : 0), i3 === void 0 && (i3 = 0), a4 === void 0 && (a4 = this.length), r4 < 0 || n4 > t3.length || i3 < 0 || a4 > this.length) throw new RangeError("out of range index");\n              if (i3 >= a4 && r4 >= n4) return 0;\n              if (i3 >= a4) return -1;\n              if (r4 >= n4) return 1;\n              if (r4 >>>= 0, n4 >>>= 0, i3 >>>= 0, a4 >>>= 0, this === t3) return 0;\n              let o4 = a4 - i3, s3 = n4 - r4, l3 = Math.min(o4, s3), u4 = this.slice(i3, a4), c5 = t3.slice(r4, n4);\n              for (let f4 = 0; f4 < l3; ++f4) if (u4[f4] !== c5[f4]) {\n                o4 = u4[f4], s3 = c5[f4];\n                break;\n              }\n              return o4 < s3 ? -1 : s3 < o4 ? 1 : 0;\n            };\n            function tTe(e3, t3, r4, n4, i3) {\n              if (e3.length === 0) return -1;\n              if (typeof r4 == "string" ? (n4 = r4, r4 = 0) : r4 > 2147483647 ? r4 = 2147483647 : r4 < -2147483648 && (r4 = -2147483648), r4 = +r4, bH(r4) && (r4 = i3 ? 0 : e3.length - 1), r4 < 0 && (r4 = e3.length + r4), r4 >= e3.length) {\n                if (i3) return -1;\n                r4 = e3.length - 1;\n              } else if (r4 < 0) if (i3) r4 = 0;\n              else return -1;\n              if (typeof t3 == "string" && (t3 = ea.from(t3, n4)), ea.isBuffer(t3)) return t3.length === 0 ? -1 : Y3e(e3, t3, r4, n4, i3);\n              if (typeof t3 == "number") return t3 = t3 & 255, typeof Uint8Array.prototype.indexOf == "function" ? i3 ? Uint8Array.prototype.indexOf.call(e3, t3, r4) : Uint8Array.prototype.lastIndexOf.call(e3, t3, r4) : Y3e(e3, [t3], r4, n4, i3);\n              throw new TypeError("val must be string, number or Buffer");\n            }\n            function Y3e(e3, t3, r4, n4, i3) {\n              let a4 = 1, o4 = e3.length, s3 = t3.length;\n              if (n4 !== void 0 && (n4 = String(n4).toLowerCase(), n4 === "ucs2" || n4 === "ucs-2" || n4 === "utf16le" || n4 === "utf-16le")) {\n                if (e3.length < 2 || t3.length < 2) return -1;\n                a4 = 2, o4 /= 2, s3 /= 2, r4 /= 2;\n              }\n              function l3(c5, f4) {\n                return a4 === 1 ? c5[f4] : c5.readUInt16BE(f4 * a4);\n              }\n              let u4;\n              if (i3) {\n                let c5 = -1;\n                for (u4 = r4; u4 < o4; u4++) if (l3(e3, u4) === l3(t3, c5 === -1 ? 0 : u4 - c5)) {\n                  if (c5 === -1 && (c5 = u4), u4 - c5 + 1 === s3) return c5 * a4;\n                } else c5 !== -1 && (u4 -= u4 - c5), c5 = -1;\n              } else for (r4 + s3 > o4 && (r4 = o4 - s3), u4 = r4; u4 >= 0; u4--) {\n                let c5 = true;\n                for (let f4 = 0; f4 < s3; f4++) if (l3(e3, u4 + f4) !== l3(t3, f4)) {\n                  c5 = false;\n                  break;\n                }\n                if (c5) return u4;\n              }\n              return -1;\n            }\n            ea.prototype.includes = function(t3, r4, n4) {\n              return this.indexOf(t3, r4, n4) !== -1;\n            };\n            ea.prototype.indexOf = function(t3, r4, n4) {\n              return tTe(this, t3, r4, n4, true);\n            };\n            ea.prototype.lastIndexOf = function(t3, r4, n4) {\n              return tTe(this, t3, r4, n4, false);\n            };\n            function Y3t(e3, t3, r4, n4) {\n              r4 = Number(r4) || 0;\n              let i3 = e3.length - r4;\n              n4 ? (n4 = Number(n4), n4 > i3 && (n4 = i3)) : n4 = i3;\n              let a4 = t3.length;\n              n4 > a4 / 2 && (n4 = a4 / 2);\n              let o4;\n              for (o4 = 0; o4 < n4; ++o4) {\n                let s3 = parseInt(t3.substr(o4 * 2, 2), 16);\n                if (bH(s3)) return o4;\n                e3[r4 + o4] = s3;\n              }\n              return o4;\n            }\n            function K3t(e3, t3, r4, n4) {\n              return H8(mH(t3, e3.length - r4), e3, r4, n4);\n            }\n            function J3t(e3, t3, r4, n4) {\n              return H8(uTt(t3), e3, r4, n4);\n            }\n            function $3t(e3, t3, r4, n4) {\n              return H8(uTe(t3), e3, r4, n4);\n            }\n            function Q3t(e3, t3, r4, n4) {\n              return H8(cTt(t3, e3.length - r4), e3, r4, n4);\n            }\n            ea.prototype.write = function(t3, r4, n4, i3) {\n              if (r4 === void 0) i3 = "utf8", n4 = this.length, r4 = 0;\n              else if (n4 === void 0 && typeof r4 == "string") i3 = r4, n4 = this.length, r4 = 0;\n              else if (isFinite(r4)) r4 = r4 >>> 0, isFinite(n4) ? (n4 = n4 >>> 0, i3 === void 0 && (i3 = "utf8")) : (i3 = n4, n4 = void 0);\n              else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");\n              let a4 = this.length - r4;\n              if ((n4 === void 0 || n4 > a4) && (n4 = a4), t3.length > 0 && (n4 < 0 || r4 < 0) || r4 > this.length) throw new RangeError("Attempt to write outside buffer bounds");\n              i3 || (i3 = "utf8");\n              let o4 = false;\n              for (; ; ) switch (i3) {\n                case "hex":\n                  return Y3t(this, t3, r4, n4);\n                case "utf8":\n                case "utf-8":\n                  return K3t(this, t3, r4, n4);\n                case "ascii":\n                case "latin1":\n                case "binary":\n                  return J3t(this, t3, r4, n4);\n                case "base64":\n                  return $3t(this, t3, r4, n4);\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                  return Q3t(this, t3, r4, n4);\n                default:\n                  if (o4) throw new TypeError("Unknown encoding: " + i3);\n                  i3 = ("" + i3).toLowerCase(), o4 = true;\n              }\n            };\n            ea.prototype.toJSON = function() {\n              return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };\n            };\n            function eTt(e3, t3, r4) {\n              return t3 === 0 && r4 === e3.length ? vH.fromByteArray(e3) : vH.fromByteArray(e3.slice(t3, r4));\n            }\n            function rTe(e3, t3, r4) {\n              r4 = Math.min(e3.length, r4);\n              let n4 = [], i3 = t3;\n              for (; i3 < r4; ) {\n                let a4 = e3[i3], o4 = null, s3 = a4 > 239 ? 4 : a4 > 223 ? 3 : a4 > 191 ? 2 : 1;\n                if (i3 + s3 <= r4) {\n                  let l3, u4, c5, f4;\n                  switch (s3) {\n                    case 1:\n                      a4 < 128 && (o4 = a4);\n                      break;\n                    case 2:\n                      l3 = e3[i3 + 1], (l3 & 192) === 128 && (f4 = (a4 & 31) << 6 | l3 & 63, f4 > 127 && (o4 = f4));\n                      break;\n                    case 3:\n                      l3 = e3[i3 + 1], u4 = e3[i3 + 2], (l3 & 192) === 128 && (u4 & 192) === 128 && (f4 = (a4 & 15) << 12 | (l3 & 63) << 6 | u4 & 63, f4 > 2047 && (f4 < 55296 || f4 > 57343) && (o4 = f4));\n                      break;\n                    case 4:\n                      l3 = e3[i3 + 1], u4 = e3[i3 + 2], c5 = e3[i3 + 3], (l3 & 192) === 128 && (u4 & 192) === 128 && (c5 & 192) === 128 && (f4 = (a4 & 15) << 18 | (l3 & 63) << 12 | (u4 & 63) << 6 | c5 & 63, f4 > 65535 && f4 < 1114112 && (o4 = f4));\n                  }\n                }\n                o4 === null ? (o4 = 65533, s3 = 1) : o4 > 65535 && (o4 -= 65536, n4.push(o4 >>> 10 & 1023 | 55296), o4 = 56320 | o4 & 1023), n4.push(o4), i3 += s3;\n              }\n              return tTt(n4);\n            }\n            var K3e = 4096;\n            function tTt(e3) {\n              let t3 = e3.length;\n              if (t3 <= K3e) return String.fromCharCode.apply(String, e3);\n              let r4 = "", n4 = 0;\n              for (; n4 < t3; ) r4 += String.fromCharCode.apply(String, e3.slice(n4, n4 += K3e));\n              return r4;\n            }\n            function rTt(e3, t3, r4) {\n              let n4 = "";\n              r4 = Math.min(e3.length, r4);\n              for (let i3 = t3; i3 < r4; ++i3) n4 += String.fromCharCode(e3[i3] & 127);\n              return n4;\n            }\n            function iTt(e3, t3, r4) {\n              let n4 = "";\n              r4 = Math.min(e3.length, r4);\n              for (let i3 = t3; i3 < r4; ++i3) n4 += String.fromCharCode(e3[i3]);\n              return n4;\n            }\n            function nTt(e3, t3, r4) {\n              let n4 = e3.length;\n              (!t3 || t3 < 0) && (t3 = 0), (!r4 || r4 < 0 || r4 > n4) && (r4 = n4);\n              let i3 = "";\n              for (let a4 = t3; a4 < r4; ++a4) i3 += fTt[e3[a4]];\n              return i3;\n            }\n            function aTt(e3, t3, r4) {\n              let n4 = e3.slice(t3, r4), i3 = "";\n              for (let a4 = 0; a4 < n4.length - 1; a4 += 2) i3 += String.fromCharCode(n4[a4] + n4[a4 + 1] * 256);\n              return i3;\n            }\n            ea.prototype.slice = function(t3, r4) {\n              let n4 = this.length;\n              t3 = ~~t3, r4 = r4 === void 0 ? n4 : ~~r4, t3 < 0 ? (t3 += n4, t3 < 0 && (t3 = 0)) : t3 > n4 && (t3 = n4), r4 < 0 ? (r4 += n4, r4 < 0 && (r4 = 0)) : r4 > n4 && (r4 = n4), r4 < t3 && (r4 = t3);\n              let i3 = this.subarray(t3, r4);\n              return Object.setPrototypeOf(i3, ea.prototype), i3;\n            };\n            function ev(e3, t3, r4) {\n              if (e3 % 1 !== 0 || e3 < 0) throw new RangeError("offset is not uint");\n              if (e3 + t3 > r4) throw new RangeError("Trying to access beyond buffer length");\n            }\n            ea.prototype.readUintLE = ea.prototype.readUIntLE = function(t3, r4, n4) {\n              t3 = t3 >>> 0, r4 = r4 >>> 0, n4 || ev(t3, r4, this.length);\n              let i3 = this[t3], a4 = 1, o4 = 0;\n              for (; ++o4 < r4 && (a4 *= 256); ) i3 += this[t3 + o4] * a4;\n              return i3;\n            };\n            ea.prototype.readUintBE = ea.prototype.readUIntBE = function(t3, r4, n4) {\n              t3 = t3 >>> 0, r4 = r4 >>> 0, n4 || ev(t3, r4, this.length);\n              let i3 = this[t3 + --r4], a4 = 1;\n              for (; r4 > 0 && (a4 *= 256); ) i3 += this[t3 + --r4] * a4;\n              return i3;\n            };\n            ea.prototype.readUint8 = ea.prototype.readUInt8 = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 1, this.length), this[t3];\n            };\n            ea.prototype.readUint16LE = ea.prototype.readUInt16LE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 2, this.length), this[t3] | this[t3 + 1] << 8;\n            };\n            ea.prototype.readUint16BE = ea.prototype.readUInt16BE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 2, this.length), this[t3] << 8 | this[t3 + 1];\n            };\n            ea.prototype.readUint32LE = ea.prototype.readUInt32LE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), (this[t3] | this[t3 + 1] << 8 | this[t3 + 2] << 16) + this[t3 + 3] * 16777216;\n            };\n            ea.prototype.readUint32BE = ea.prototype.readUInt32BE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), this[t3] * 16777216 + (this[t3 + 1] << 16 | this[t3 + 2] << 8 | this[t3 + 3]);\n            };\n            ea.prototype.readBigUInt64LE = P_(function(t3) {\n              t3 = t3 >>> 0, QT(t3, "offset");\n              let r4 = this[t3], n4 = this[t3 + 7];\n              (r4 === void 0 || n4 === void 0) && U4(t3, this.length - 8);\n              let i3 = r4 + this[++t3] * 2 ** 8 + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 24, a4 = this[++t3] + this[++t3] * 2 ** 8 + this[++t3] * 2 ** 16 + n4 * 2 ** 24;\n              return BigInt(i3) + (BigInt(a4) << BigInt(32));\n            });\n            ea.prototype.readBigUInt64BE = P_(function(t3) {\n              t3 = t3 >>> 0, QT(t3, "offset");\n              let r4 = this[t3], n4 = this[t3 + 7];\n              (r4 === void 0 || n4 === void 0) && U4(t3, this.length - 8);\n              let i3 = r4 * 2 ** 24 + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 8 + this[++t3], a4 = this[++t3] * 2 ** 24 + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 8 + n4;\n              return (BigInt(i3) << BigInt(32)) + BigInt(a4);\n            });\n            ea.prototype.readIntLE = function(t3, r4, n4) {\n              t3 = t3 >>> 0, r4 = r4 >>> 0, n4 || ev(t3, r4, this.length);\n              let i3 = this[t3], a4 = 1, o4 = 0;\n              for (; ++o4 < r4 && (a4 *= 256); ) i3 += this[t3 + o4] * a4;\n              return a4 *= 128, i3 >= a4 && (i3 -= Math.pow(2, 8 * r4)), i3;\n            };\n            ea.prototype.readIntBE = function(t3, r4, n4) {\n              t3 = t3 >>> 0, r4 = r4 >>> 0, n4 || ev(t3, r4, this.length);\n              let i3 = r4, a4 = 1, o4 = this[t3 + --i3];\n              for (; i3 > 0 && (a4 *= 256); ) o4 += this[t3 + --i3] * a4;\n              return a4 *= 128, o4 >= a4 && (o4 -= Math.pow(2, 8 * r4)), o4;\n            };\n            ea.prototype.readInt8 = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 1, this.length), this[t3] & 128 ? (255 - this[t3] + 1) * -1 : this[t3];\n            };\n            ea.prototype.readInt16LE = function(t3, r4) {\n              t3 = t3 >>> 0, r4 || ev(t3, 2, this.length);\n              let n4 = this[t3] | this[t3 + 1] << 8;\n              return n4 & 32768 ? n4 | 4294901760 : n4;\n            };\n            ea.prototype.readInt16BE = function(t3, r4) {\n              t3 = t3 >>> 0, r4 || ev(t3, 2, this.length);\n              let n4 = this[t3 + 1] | this[t3] << 8;\n              return n4 & 32768 ? n4 | 4294901760 : n4;\n            };\n            ea.prototype.readInt32LE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), this[t3] | this[t3 + 1] << 8 | this[t3 + 2] << 16 | this[t3 + 3] << 24;\n            };\n            ea.prototype.readInt32BE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), this[t3] << 24 | this[t3 + 1] << 16 | this[t3 + 2] << 8 | this[t3 + 3];\n            };\n            ea.prototype.readBigInt64LE = P_(function(t3) {\n              t3 = t3 >>> 0, QT(t3, "offset");\n              let r4 = this[t3], n4 = this[t3 + 7];\n              (r4 === void 0 || n4 === void 0) && U4(t3, this.length - 8);\n              let i3 = this[t3 + 4] + this[t3 + 5] * 2 ** 8 + this[t3 + 6] * 2 ** 16 + (n4 << 24);\n              return (BigInt(i3) << BigInt(32)) + BigInt(r4 + this[++t3] * 2 ** 8 + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 24);\n            });\n            ea.prototype.readBigInt64BE = P_(function(t3) {\n              t3 = t3 >>> 0, QT(t3, "offset");\n              let r4 = this[t3], n4 = this[t3 + 7];\n              (r4 === void 0 || n4 === void 0) && U4(t3, this.length - 8);\n              let i3 = (r4 << 24) + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 8 + this[++t3];\n              return (BigInt(i3) << BigInt(32)) + BigInt(this[++t3] * 2 ** 24 + this[++t3] * 2 ** 16 + this[++t3] * 2 ** 8 + n4);\n            });\n            ea.prototype.readFloatLE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), $T.read(this, t3, true, 23, 4);\n            };\n            ea.prototype.readFloatBE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 4, this.length), $T.read(this, t3, false, 23, 4);\n            };\n            ea.prototype.readDoubleLE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 8, this.length), $T.read(this, t3, true, 52, 8);\n            };\n            ea.prototype.readDoubleBE = function(t3, r4) {\n              return t3 = t3 >>> 0, r4 || ev(t3, 8, this.length), $T.read(this, t3, false, 52, 8);\n            };\n            function Rp(e3, t3, r4, n4, i3, a4) {\n              if (!ea.isBuffer(e3)) throw new TypeError(\'"buffer" argument must be a Buffer instance\');\n              if (t3 > i3 || t3 < a4) throw new RangeError(\'"value" argument is out of bounds\');\n              if (r4 + n4 > e3.length) throw new RangeError("Index out of range");\n            }\n            ea.prototype.writeUintLE = ea.prototype.writeUIntLE = function(t3, r4, n4, i3) {\n              if (t3 = +t3, r4 = r4 >>> 0, n4 = n4 >>> 0, !i3) {\n                let s3 = Math.pow(2, 8 * n4) - 1;\n                Rp(this, t3, r4, n4, s3, 0);\n              }\n              let a4 = 1, o4 = 0;\n              for (this[r4] = t3 & 255; ++o4 < n4 && (a4 *= 256); ) this[r4 + o4] = t3 / a4 & 255;\n              return r4 + n4;\n            };\n            ea.prototype.writeUintBE = ea.prototype.writeUIntBE = function(t3, r4, n4, i3) {\n              if (t3 = +t3, r4 = r4 >>> 0, n4 = n4 >>> 0, !i3) {\n                let s3 = Math.pow(2, 8 * n4) - 1;\n                Rp(this, t3, r4, n4, s3, 0);\n              }\n              let a4 = n4 - 1, o4 = 1;\n              for (this[r4 + a4] = t3 & 255; --a4 >= 0 && (o4 *= 256); ) this[r4 + a4] = t3 / o4 & 255;\n              return r4 + n4;\n            };\n            ea.prototype.writeUint8 = ea.prototype.writeUInt8 = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 1, 255, 0), this[r4] = t3 & 255, r4 + 1;\n            };\n            ea.prototype.writeUint16LE = ea.prototype.writeUInt16LE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 2, 65535, 0), this[r4] = t3 & 255, this[r4 + 1] = t3 >>> 8, r4 + 2;\n            };\n            ea.prototype.writeUint16BE = ea.prototype.writeUInt16BE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 2, 65535, 0), this[r4] = t3 >>> 8, this[r4 + 1] = t3 & 255, r4 + 2;\n            };\n            ea.prototype.writeUint32LE = ea.prototype.writeUInt32LE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 4, 4294967295, 0), this[r4 + 3] = t3 >>> 24, this[r4 + 2] = t3 >>> 16, this[r4 + 1] = t3 >>> 8, this[r4] = t3 & 255, r4 + 4;\n            };\n            ea.prototype.writeUint32BE = ea.prototype.writeUInt32BE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 4, 4294967295, 0), this[r4] = t3 >>> 24, this[r4 + 1] = t3 >>> 16, this[r4 + 2] = t3 >>> 8, this[r4 + 3] = t3 & 255, r4 + 4;\n            };\n            function iTe(e3, t3, r4, n4, i3) {\n              lTe(t3, n4, i3, e3, r4, 7);\n              let a4 = Number(t3 & BigInt(4294967295));\n              e3[r4++] = a4, a4 = a4 >> 8, e3[r4++] = a4, a4 = a4 >> 8, e3[r4++] = a4, a4 = a4 >> 8, e3[r4++] = a4;\n              let o4 = Number(t3 >> BigInt(32) & BigInt(4294967295));\n              return e3[r4++] = o4, o4 = o4 >> 8, e3[r4++] = o4, o4 = o4 >> 8, e3[r4++] = o4, o4 = o4 >> 8, e3[r4++] = o4, r4;\n            }\n            function nTe(e3, t3, r4, n4, i3) {\n              lTe(t3, n4, i3, e3, r4, 7);\n              let a4 = Number(t3 & BigInt(4294967295));\n              e3[r4 + 7] = a4, a4 = a4 >> 8, e3[r4 + 6] = a4, a4 = a4 >> 8, e3[r4 + 5] = a4, a4 = a4 >> 8, e3[r4 + 4] = a4;\n              let o4 = Number(t3 >> BigInt(32) & BigInt(4294967295));\n              return e3[r4 + 3] = o4, o4 = o4 >> 8, e3[r4 + 2] = o4, o4 = o4 >> 8, e3[r4 + 1] = o4, o4 = o4 >> 8, e3[r4] = o4, r4 + 8;\n            }\n            ea.prototype.writeBigUInt64LE = P_(function(t3, r4 = 0) {\n              return iTe(this, t3, r4, BigInt(0), BigInt("0xffffffffffffffff"));\n            });\n            ea.prototype.writeBigUInt64BE = P_(function(t3, r4 = 0) {\n              return nTe(this, t3, r4, BigInt(0), BigInt("0xffffffffffffffff"));\n            });\n            ea.prototype.writeIntLE = function(t3, r4, n4, i3) {\n              if (t3 = +t3, r4 = r4 >>> 0, !i3) {\n                let l3 = Math.pow(2, 8 * n4 - 1);\n                Rp(this, t3, r4, n4, l3 - 1, -l3);\n              }\n              let a4 = 0, o4 = 1, s3 = 0;\n              for (this[r4] = t3 & 255; ++a4 < n4 && (o4 *= 256); ) t3 < 0 && s3 === 0 && this[r4 + a4 - 1] !== 0 && (s3 = 1), this[r4 + a4] = (t3 / o4 >> 0) - s3 & 255;\n              return r4 + n4;\n            };\n            ea.prototype.writeIntBE = function(t3, r4, n4, i3) {\n              if (t3 = +t3, r4 = r4 >>> 0, !i3) {\n                let l3 = Math.pow(2, 8 * n4 - 1);\n                Rp(this, t3, r4, n4, l3 - 1, -l3);\n              }\n              let a4 = n4 - 1, o4 = 1, s3 = 0;\n              for (this[r4 + a4] = t3 & 255; --a4 >= 0 && (o4 *= 256); ) t3 < 0 && s3 === 0 && this[r4 + a4 + 1] !== 0 && (s3 = 1), this[r4 + a4] = (t3 / o4 >> 0) - s3 & 255;\n              return r4 + n4;\n            };\n            ea.prototype.writeInt8 = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 1, 127, -128), t3 < 0 && (t3 = 255 + t3 + 1), this[r4] = t3 & 255, r4 + 1;\n            };\n            ea.prototype.writeInt16LE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 2, 32767, -32768), this[r4] = t3 & 255, this[r4 + 1] = t3 >>> 8, r4 + 2;\n            };\n            ea.prototype.writeInt16BE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 2, 32767, -32768), this[r4] = t3 >>> 8, this[r4 + 1] = t3 & 255, r4 + 2;\n            };\n            ea.prototype.writeInt32LE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 4, 2147483647, -2147483648), this[r4] = t3 & 255, this[r4 + 1] = t3 >>> 8, this[r4 + 2] = t3 >>> 16, this[r4 + 3] = t3 >>> 24, r4 + 4;\n            };\n            ea.prototype.writeInt32BE = function(t3, r4, n4) {\n              return t3 = +t3, r4 = r4 >>> 0, n4 || Rp(this, t3, r4, 4, 2147483647, -2147483648), t3 < 0 && (t3 = 4294967295 + t3 + 1), this[r4] = t3 >>> 24, this[r4 + 1] = t3 >>> 16, this[r4 + 2] = t3 >>> 8, this[r4 + 3] = t3 & 255, r4 + 4;\n            };\n            ea.prototype.writeBigInt64LE = P_(function(t3, r4 = 0) {\n              return iTe(this, t3, r4, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n            });\n            ea.prototype.writeBigInt64BE = P_(function(t3, r4 = 0) {\n              return nTe(this, t3, r4, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n            });\n            function aTe(e3, t3, r4, n4, i3, a4) {\n              if (r4 + n4 > e3.length) throw new RangeError("Index out of range");\n              if (r4 < 0) throw new RangeError("Index out of range");\n            }\n            function oTe(e3, t3, r4, n4, i3) {\n              return t3 = +t3, r4 = r4 >>> 0, i3 || aTe(e3, t3, r4, 4, 34028234663852886e22, -34028234663852886e22), $T.write(e3, t3, r4, n4, 23, 4), r4 + 4;\n            }\n            ea.prototype.writeFloatLE = function(t3, r4, n4) {\n              return oTe(this, t3, r4, true, n4);\n            };\n            ea.prototype.writeFloatBE = function(t3, r4, n4) {\n              return oTe(this, t3, r4, false, n4);\n            };\n            function sTe(e3, t3, r4, n4, i3) {\n              return t3 = +t3, r4 = r4 >>> 0, i3 || aTe(e3, t3, r4, 8, 17976931348623157e292, -17976931348623157e292), $T.write(e3, t3, r4, n4, 52, 8), r4 + 8;\n            }\n            ea.prototype.writeDoubleLE = function(t3, r4, n4) {\n              return sTe(this, t3, r4, true, n4);\n            };\n            ea.prototype.writeDoubleBE = function(t3, r4, n4) {\n              return sTe(this, t3, r4, false, n4);\n            };\n            ea.prototype.copy = function(t3, r4, n4, i3) {\n              if (!ea.isBuffer(t3)) throw new TypeError("argument should be a Buffer");\n              if (n4 || (n4 = 0), !i3 && i3 !== 0 && (i3 = this.length), r4 >= t3.length && (r4 = t3.length), r4 || (r4 = 0), i3 > 0 && i3 < n4 && (i3 = n4), i3 === n4 || t3.length === 0 || this.length === 0) return 0;\n              if (r4 < 0) throw new RangeError("targetStart out of bounds");\n              if (n4 < 0 || n4 >= this.length) throw new RangeError("Index out of range");\n              if (i3 < 0) throw new RangeError("sourceEnd out of bounds");\n              i3 > this.length && (i3 = this.length), t3.length - r4 < i3 - n4 && (i3 = t3.length - r4 + n4);\n              let a4 = i3 - n4;\n              return this === t3 && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(r4, n4, i3) : Uint8Array.prototype.set.call(t3, this.subarray(n4, i3), r4), a4;\n            };\n            ea.prototype.fill = function(t3, r4, n4, i3) {\n              if (typeof t3 == "string") {\n                if (typeof r4 == "string" ? (i3 = r4, r4 = 0, n4 = this.length) : typeof n4 == "string" && (i3 = n4, n4 = this.length), i3 !== void 0 && typeof i3 != "string") throw new TypeError("encoding must be a string");\n                if (typeof i3 == "string" && !ea.isEncoding(i3)) throw new TypeError("Unknown encoding: " + i3);\n                if (t3.length === 1) {\n                  let o4 = t3.charCodeAt(0);\n                  (i3 === "utf8" && o4 < 128 || i3 === "latin1") && (t3 = o4);\n                }\n              } else typeof t3 == "number" ? t3 = t3 & 255 : typeof t3 == "boolean" && (t3 = Number(t3));\n              if (r4 < 0 || this.length < r4 || this.length < n4) throw new RangeError("Out of range index");\n              if (n4 <= r4) return this;\n              r4 = r4 >>> 0, n4 = n4 === void 0 ? this.length : n4 >>> 0, t3 || (t3 = 0);\n              let a4;\n              if (typeof t3 == "number") for (a4 = r4; a4 < n4; ++a4) this[a4] = t3;\n              else {\n                let o4 = ea.isBuffer(t3) ? t3 : ea.from(t3, i3), s3 = o4.length;\n                if (s3 === 0) throw new TypeError(\'The value "\' + t3 + \'" is invalid for argument "value"\');\n                for (a4 = 0; a4 < n4 - r4; ++a4) this[a4 + r4] = o4[a4 % s3];\n              }\n              return this;\n            };\n            var JT = {};\n            function xH(e3, t3, r4) {\n              JT[e3] = class extends r4 {\n                constructor() {\n                  super(), Object.defineProperty(this, "message", { value: t3.apply(this, arguments), writable: true, configurable: true }), this.name = `${this.name} [${e3}]`, this.stack, delete this.name;\n                }\n                get code() {\n                  return e3;\n                }\n                set code(i3) {\n                  Object.defineProperty(this, "code", { configurable: true, enumerable: true, value: i3, writable: true });\n                }\n                toString() {\n                  return `${this.name} [${e3}]: ${this.message}`;\n                }\n              };\n            }\n            xH("ERR_BUFFER_OUT_OF_BOUNDS", function(e3) {\n              return e3 ? `${e3} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";\n            }, RangeError);\n            xH("ERR_INVALID_ARG_TYPE", function(e3, t3) {\n              return `The "${e3}" argument must be of type number. Received type ${typeof t3}`;\n            }, TypeError);\n            xH("ERR_OUT_OF_RANGE", function(e3, t3, r4) {\n              let n4 = `The value of "${e3}" is out of range.`, i3 = r4;\n              return Number.isInteger(r4) && Math.abs(r4) > 2 ** 32 ? i3 = J3e(String(r4)) : typeof r4 == "bigint" && (i3 = String(r4), (r4 > BigInt(2) ** BigInt(32) || r4 < -(BigInt(2) ** BigInt(32))) && (i3 = J3e(i3)), i3 += "n"), n4 += ` It must be ${t3}. Received ${i3}`, n4;\n            }, RangeError);\n            function J3e(e3) {\n              let t3 = "", r4 = e3.length, n4 = e3[0] === "-" ? 1 : 0;\n              for (; r4 >= n4 + 4; r4 -= 3) t3 = `_${e3.slice(r4 - 3, r4)}${t3}`;\n              return `${e3.slice(0, r4)}${t3}`;\n            }\n            function oTt(e3, t3, r4) {\n              QT(t3, "offset"), (e3[t3] === void 0 || e3[t3 + r4] === void 0) && U4(t3, e3.length - (r4 + 1));\n            }\n            function lTe(e3, t3, r4, n4, i3, a4) {\n              if (e3 > r4 || e3 < t3) {\n                let o4 = typeof t3 == "bigint" ? "n" : "", s3;\n                throw a4 > 3 ? t3 === 0 || t3 === BigInt(0) ? s3 = `>= 0${o4} and < 2${o4} ** ${(a4 + 1) * 8}${o4}` : s3 = `>= -(2${o4} ** ${(a4 + 1) * 8 - 1}${o4}) and < 2 ** ${(a4 + 1) * 8 - 1}${o4}` : s3 = `>= ${t3}${o4} and <= ${r4}${o4}`, new JT.ERR_OUT_OF_RANGE("value", s3, e3);\n              }\n              oTt(n4, i3, a4);\n            }\n            function QT(e3, t3) {\n              if (typeof e3 != "number") throw new JT.ERR_INVALID_ARG_TYPE(t3, "number", e3);\n            }\n            function U4(e3, t3, r4) {\n              throw Math.floor(e3) !== e3 ? (QT(e3, r4), new JT.ERR_OUT_OF_RANGE(r4 || "offset", "an integer", e3)) : t3 < 0 ? new JT.ERR_BUFFER_OUT_OF_BOUNDS() : new JT.ERR_OUT_OF_RANGE(r4 || "offset", `>= ${r4 ? 1 : 0} and <= ${t3}`, e3);\n            }\n            var sTt = /[^+/0-9A-Za-z-_]/g;\n            function lTt(e3) {\n              if (e3 = e3.split("=")[0], e3 = e3.trim().replace(sTt, ""), e3.length < 2) return "";\n              for (; e3.length % 4 !== 0; ) e3 = e3 + "=";\n              return e3;\n            }\n            function mH(e3, t3) {\n              t3 = t3 || 1 / 0;\n              let r4, n4 = e3.length, i3 = null, a4 = [];\n              for (let o4 = 0; o4 < n4; ++o4) {\n                if (r4 = e3.charCodeAt(o4), r4 > 55295 && r4 < 57344) {\n                  if (!i3) {\n                    if (r4 > 56319) {\n                      (t3 -= 3) > -1 && a4.push(239, 191, 189);\n                      continue;\n                    } else if (o4 + 1 === n4) {\n                      (t3 -= 3) > -1 && a4.push(239, 191, 189);\n                      continue;\n                    }\n                    i3 = r4;\n                    continue;\n                  }\n                  if (r4 < 56320) {\n                    (t3 -= 3) > -1 && a4.push(239, 191, 189), i3 = r4;\n                    continue;\n                  }\n                  r4 = (i3 - 55296 << 10 | r4 - 56320) + 65536;\n                } else i3 && (t3 -= 3) > -1 && a4.push(239, 191, 189);\n                if (i3 = null, r4 < 128) {\n                  if ((t3 -= 1) < 0) break;\n                  a4.push(r4);\n                } else if (r4 < 2048) {\n                  if ((t3 -= 2) < 0) break;\n                  a4.push(r4 >> 6 | 192, r4 & 63 | 128);\n                } else if (r4 < 65536) {\n                  if ((t3 -= 3) < 0) break;\n                  a4.push(r4 >> 12 | 224, r4 >> 6 & 63 | 128, r4 & 63 | 128);\n                } else if (r4 < 1114112) {\n                  if ((t3 -= 4) < 0) break;\n                  a4.push(r4 >> 18 | 240, r4 >> 12 & 63 | 128, r4 >> 6 & 63 | 128, r4 & 63 | 128);\n                } else throw new Error("Invalid code point");\n              }\n              return a4;\n            }\n            function uTt(e3) {\n              let t3 = [];\n              for (let r4 = 0; r4 < e3.length; ++r4) t3.push(e3.charCodeAt(r4) & 255);\n              return t3;\n            }\n            function cTt(e3, t3) {\n              let r4, n4, i3, a4 = [];\n              for (let o4 = 0; o4 < e3.length && !((t3 -= 2) < 0); ++o4) r4 = e3.charCodeAt(o4), n4 = r4 >> 8, i3 = r4 % 256, a4.push(i3), a4.push(n4);\n              return a4;\n            }\n            function uTe(e3) {\n              return vH.toByteArray(lTt(e3));\n            }\n            function H8(e3, t3, r4, n4) {\n              let i3;\n              for (i3 = 0; i3 < n4 && !(i3 + r4 >= t3.length || i3 >= e3.length); ++i3) t3[i3 + r4] = e3[i3];\n              return i3;\n            }\n            function qm(e3, t3) {\n              return e3 instanceof t3 || e3 != null && e3.constructor != null && e3.constructor.name != null && e3.constructor.name === t3.name;\n            }\n            function bH(e3) {\n              return e3 !== e3;\n            }\n            var fTt = (function() {\n              let e3 = "0123456789abcdef", t3 = new Array(256);\n              for (let r4 = 0; r4 < 16; ++r4) {\n                let n4 = r4 * 16;\n                for (let i3 = 0; i3 < 16; ++i3) t3[n4 + i3] = e3[r4] + e3[i3];\n              }\n              return t3;\n            })();\n            function P_(e3) {\n              return typeof BigInt == "undefined" ? hTt : e3;\n            }\n            function hTt() {\n              throw new Error("BigInt not supported");\n            }\n          });\n          var j8 = ye((Nfr, cTe) => {\n            "use strict";\n            cTe.exports = function() {\n              if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function") return false;\n              if (typeof Symbol.iterator == "symbol") return true;\n              var t3 = {}, r4 = /* @__PURE__ */ Symbol("test"), n4 = Object(r4);\n              if (typeof r4 == "string" || Object.prototype.toString.call(r4) !== "[object Symbol]" || Object.prototype.toString.call(n4) !== "[object Symbol]") return false;\n              var i3 = 42;\n              t3[r4] = i3;\n              for (var a4 in t3) return false;\n              if (typeof Object.keys == "function" && Object.keys(t3).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(t3).length !== 0) return false;\n              var o4 = Object.getOwnPropertySymbols(t3);\n              if (o4.length !== 1 || o4[0] !== r4 || !Object.prototype.propertyIsEnumerable.call(t3, r4)) return false;\n              if (typeof Object.getOwnPropertyDescriptor == "function") {\n                var s3 = Object.getOwnPropertyDescriptor(t3, r4);\n                if (s3.value !== i3 || s3.enumerable !== true) return false;\n              }\n              return true;\n            };\n          });\n          var V4 = ye((Ufr, fTe) => {\n            "use strict";\n            var dTt = j8();\n            fTe.exports = function() {\n              return dTt() && !!Symbol.toStringTag;\n            };\n          });\n          var wH = ye((Vfr, hTe) => {\n            "use strict";\n            hTe.exports = Object;\n          });\n          var vTe = ye((Gfr, dTe) => {\n            "use strict";\n            dTe.exports = Error;\n          });\n          var gTe = ye((Hfr, pTe) => {\n            "use strict";\n            pTe.exports = EvalError;\n          });\n          var yTe = ye((jfr, mTe) => {\n            "use strict";\n            mTe.exports = RangeError;\n          });\n          var xTe = ye((Wfr, _Te) => {\n            "use strict";\n            _Te.exports = ReferenceError;\n          });\n          var TH = ye((Xfr, bTe) => {\n            "use strict";\n            bTe.exports = SyntaxError;\n          });\n          var tA = ye((Zfr, wTe) => {\n            "use strict";\n            wTe.exports = TypeError;\n          });\n          var ATe = ye((Yfr, TTe) => {\n            "use strict";\n            TTe.exports = URIError;\n          });\n          var MTe = ye((Kfr, STe) => {\n            "use strict";\n            STe.exports = Math.abs;\n          });\n          var kTe = ye((Jfr, ETe) => {\n            "use strict";\n            ETe.exports = Math.floor;\n          });\n          var LTe = ye(($fr, CTe) => {\n            "use strict";\n            CTe.exports = Math.max;\n          });\n          var ITe = ye((Qfr, PTe) => {\n            "use strict";\n            PTe.exports = Math.min;\n          });\n          var DTe = ye((ehr, RTe) => {\n            "use strict";\n            RTe.exports = Math.pow;\n          });\n          var zTe = ye((thr, FTe) => {\n            "use strict";\n            FTe.exports = Math.round;\n          });\n          var qTe = ye((rhr, OTe) => {\n            "use strict";\n            OTe.exports = Number.isNaN || function(t3) {\n              return t3 !== t3;\n            };\n          });\n          var NTe = ye((ihr, BTe) => {\n            "use strict";\n            var vTt = qTe();\n            BTe.exports = function(t3) {\n              return vTt(t3) || t3 === 0 ? t3 : t3 < 0 ? -1 : 1;\n            };\n          });\n          var VTe = ye((nhr, UTe) => {\n            "use strict";\n            UTe.exports = Object.getOwnPropertyDescriptor;\n          });\n          var f22 = ye((ahr, GTe) => {\n            "use strict";\n            var W8 = VTe();\n            if (W8) try {\n              W8([], "length");\n            } catch (e3) {\n              W8 = null;\n            }\n            GTe.exports = W8;\n          });\n          var G4 = ye((ohr, HTe) => {\n            "use strict";\n            var X8 = Object.defineProperty || false;\n            if (X8) try {\n              X8({}, "a", { value: 1 });\n            } catch (e3) {\n              X8 = false;\n            }\n            HTe.exports = X8;\n          });\n          var XTe = ye((shr, WTe) => {\n            "use strict";\n            var jTe = typeof Symbol != "undefined" && Symbol, pTt = j8();\n            WTe.exports = function() {\n              return typeof jTe != "function" || typeof Symbol != "function" || typeof jTe("foo") != "symbol" || typeof /* @__PURE__ */ Symbol("bar") != "symbol" ? false : pTt();\n            };\n          });\n          var AH = ye((lhr, ZTe) => {\n            "use strict";\n            ZTe.exports = typeof Reflect != "undefined" && Reflect.getPrototypeOf || null;\n          });\n          var SH = ye((uhr, YTe) => {\n            "use strict";\n            var gTt = wH();\n            YTe.exports = gTt.getPrototypeOf || null;\n          });\n          var $Te = ye((chr, JTe) => {\n            "use strict";\n            var mTt = "Function.prototype.bind called on incompatible ", yTt = Object.prototype.toString, _Tt = Math.max, xTt = "[object Function]", KTe = function(t3, r4) {\n              for (var n4 = [], i3 = 0; i3 < t3.length; i3 += 1) n4[i3] = t3[i3];\n              for (var a4 = 0; a4 < r4.length; a4 += 1) n4[a4 + t3.length] = r4[a4];\n              return n4;\n            }, bTt = function(t3, r4) {\n              for (var n4 = [], i3 = r4 || 0, a4 = 0; i3 < t3.length; i3 += 1, a4 += 1) n4[a4] = t3[i3];\n              return n4;\n            }, wTt = function(e3, t3) {\n              for (var r4 = "", n4 = 0; n4 < e3.length; n4 += 1) r4 += e3[n4], n4 + 1 < e3.length && (r4 += t3);\n              return r4;\n            };\n            JTe.exports = function(t3) {\n              var r4 = this;\n              if (typeof r4 != "function" || yTt.apply(r4) !== xTt) throw new TypeError(mTt + r4);\n              for (var n4 = bTt(arguments, 1), i3, a4 = function() {\n                if (this instanceof i3) {\n                  var c5 = r4.apply(this, KTe(n4, arguments));\n                  return Object(c5) === c5 ? c5 : this;\n                }\n                return r4.apply(t3, KTe(n4, arguments));\n              }, o4 = _Tt(0, r4.length - n4.length), s3 = [], l3 = 0; l3 < o4; l3++) s3[l3] = "$" + l3;\n              if (i3 = Function("binder", "return function (" + wTt(s3, ",") + "){ return binder.apply(this,arguments); }")(a4), r4.prototype) {\n                var u4 = function() {\n                };\n                u4.prototype = r4.prototype, i3.prototype = new u4(), u4.prototype = null;\n              }\n              return i3;\n            };\n          });\n          var rA = ye((fhr, QTe) => {\n            "use strict";\n            var TTt = $Te();\n            QTe.exports = Function.prototype.bind || TTt;\n          });\n          var Z8 = ye((hhr, eAe) => {\n            "use strict";\n            eAe.exports = Function.prototype.call;\n          });\n          var MH = ye((dhr, tAe) => {\n            "use strict";\n            tAe.exports = Function.prototype.apply;\n          });\n          var iAe = ye((vhr, rAe) => {\n            "use strict";\n            rAe.exports = typeof Reflect != "undefined" && Reflect && Reflect.apply;\n          });\n          var aAe = ye((phr, nAe) => {\n            "use strict";\n            var ATt = rA(), STt = MH(), MTt = Z8(), ETt = iAe();\n            nAe.exports = ETt || ATt.call(MTt, STt);\n          });\n          var sAe = ye((ghr, oAe) => {\n            "use strict";\n            var kTt = rA(), CTt = tA(), LTt = Z8(), PTt = aAe();\n            oAe.exports = function(t3) {\n              if (t3.length < 1 || typeof t3[0] != "function") throw new CTt("a function is required");\n              return PTt(kTt, LTt, t3);\n            };\n          });\n          var dAe = ye((mhr, hAe) => {\n            "use strict";\n            var ITt = sAe(), lAe = f22(), cAe;\n            try {\n              cAe = [].__proto__ === Array.prototype;\n            } catch (e3) {\n              if (!e3 || typeof e3 != "object" || !("code" in e3) || e3.code !== "ERR_PROTO_ACCESS") throw e3;\n            }\n            var EH = !!cAe && lAe && lAe(Object.prototype, "__proto__"), fAe = Object, uAe = fAe.getPrototypeOf;\n            hAe.exports = EH && typeof EH.get == "function" ? ITt([EH.get]) : typeof uAe == "function" ? function(t3) {\n              return uAe(t3 == null ? t3 : fAe(t3));\n            } : false;\n          });\n          var yAe = ye((yhr, mAe) => {\n            "use strict";\n            var vAe = AH(), pAe = SH(), gAe = dAe();\n            mAe.exports = vAe ? function(t3) {\n              return vAe(t3);\n            } : pAe ? function(t3) {\n              if (!t3 || typeof t3 != "object" && typeof t3 != "function") throw new TypeError("getProto: not an object");\n              return pAe(t3);\n            } : gAe ? function(t3) {\n              return gAe(t3);\n            } : null;\n          });\n          var xAe = ye((_hr, _Ae) => {\n            "use strict";\n            var RTt = Function.prototype.call, DTt = Object.prototype.hasOwnProperty, FTt = rA();\n            _Ae.exports = FTt.call(RTt, DTt);\n          });\n          var J8 = ye((xhr, MAe) => {\n            "use strict";\n            var lu, zTt = wH(), OTt = vTe(), qTt = gTe(), BTt = yTe(), NTt = xTe(), oA = TH(), aA = tA(), UTt = ATe(), VTt = MTe(), GTt = kTe(), HTt = LTe(), jTt = ITe(), WTt = DTe(), XTt = zTe(), ZTt = NTe(), AAe = Function, kH = function(e3) {\n              try {\n                return AAe(\'"use strict"; return (\' + e3 + ").constructor;")();\n              } catch (t3) {\n              }\n            }, H4 = f22(), YTt = G4(), CH = function() {\n              throw new aA();\n            }, KTt = H4 ? (function() {\n              try {\n                return arguments.callee, CH;\n              } catch (e3) {\n                try {\n                  return H4(arguments, "callee").get;\n                } catch (t3) {\n                  return CH;\n                }\n              }\n            })() : CH, iA = XTe()(), tv = yAe(), JTt = SH(), $Tt = AH(), SAe = MH(), j4 = Z8(), nA = {}, QTt = typeof Uint8Array == "undefined" || !tv ? lu : tv(Uint8Array), h22 = { __proto__: null, "%AggregateError%": typeof AggregateError == "undefined" ? lu : AggregateError, "%Array%": Array, "%ArrayBuffer%": typeof ArrayBuffer == "undefined" ? lu : ArrayBuffer, "%ArrayIteratorPrototype%": iA && tv ? tv([][Symbol.iterator]()) : lu, "%AsyncFromSyncIteratorPrototype%": lu, "%AsyncFunction%": nA, "%AsyncGenerator%": nA, "%AsyncGeneratorFunction%": nA, "%AsyncIteratorPrototype%": nA, "%Atomics%": typeof Atomics == "undefined" ? lu : Atomics, "%BigInt%": typeof BigInt == "undefined" ? lu : BigInt, "%BigInt64Array%": typeof BigInt64Array == "undefined" ? lu : BigInt64Array, "%BigUint64Array%": typeof BigUint64Array == "undefined" ? lu : BigUint64Array, "%Boolean%": Boolean, "%DataView%": typeof DataView == "undefined" ? lu : DataView, "%Date%": Date, "%decodeURI%": decodeURI, "%decodeURIComponent%": decodeURIComponent, "%encodeURI%": encodeURI, "%encodeURIComponent%": encodeURIComponent, "%Error%": OTt, "%eval%": eval, "%EvalError%": qTt, "%Float16Array%": typeof Float16Array == "undefined" ? lu : Float16Array, "%Float32Array%": typeof Float32Array == "undefined" ? lu : Float32Array, "%Float64Array%": typeof Float64Array == "undefined" ? lu : Float64Array, "%FinalizationRegistry%": typeof FinalizationRegistry == "undefined" ? lu : FinalizationRegistry, "%Function%": AAe, "%GeneratorFunction%": nA, "%Int8Array%": typeof Int8Array == "undefined" ? lu : Int8Array, "%Int16Array%": typeof Int16Array == "undefined" ? lu : Int16Array, "%Int32Array%": typeof Int32Array == "undefined" ? lu : Int32Array, "%isFinite%": isFinite, "%isNaN%": isNaN, "%IteratorPrototype%": iA && tv ? tv(tv([][Symbol.iterator]())) : lu, "%JSON%": typeof JSON == "object" ? JSON : lu, "%Map%": typeof Map == "undefined" ? lu : Map, "%MapIteratorPrototype%": typeof Map == "undefined" || !iA || !tv ? lu : tv((/* @__PURE__ */ new Map())[Symbol.iterator]()), "%Math%": Math, "%Number%": Number, "%Object%": zTt, "%Object.getOwnPropertyDescriptor%": H4, "%parseFloat%": parseFloat, "%parseInt%": parseInt, "%Promise%": typeof Promise == "undefined" ? lu : Promise, "%Proxy%": typeof Proxy == "undefined" ? lu : Proxy, "%RangeError%": BTt, "%ReferenceError%": NTt, "%Reflect%": typeof Reflect == "undefined" ? lu : Reflect, "%RegExp%": RegExp, "%Set%": typeof Set == "undefined" ? lu : Set, "%SetIteratorPrototype%": typeof Set == "undefined" || !iA || !tv ? lu : tv((/* @__PURE__ */ new Set())[Symbol.iterator]()), "%SharedArrayBuffer%": typeof SharedArrayBuffer == "undefined" ? lu : SharedArrayBuffer, "%String%": String, "%StringIteratorPrototype%": iA && tv ? tv(""[Symbol.iterator]()) : lu, "%Symbol%": iA ? Symbol : lu, "%SyntaxError%": oA, "%ThrowTypeError%": KTt, "%TypedArray%": QTt, "%TypeError%": aA, "%Uint8Array%": typeof Uint8Array == "undefined" ? lu : Uint8Array, "%Uint8ClampedArray%": typeof Uint8ClampedArray == "undefined" ? lu : Uint8ClampedArray, "%Uint16Array%": typeof Uint16Array == "undefined" ? lu : Uint16Array, "%Uint32Array%": typeof Uint32Array == "undefined" ? lu : Uint32Array, "%URIError%": UTt, "%WeakMap%": typeof WeakMap == "undefined" ? lu : WeakMap, "%WeakRef%": typeof WeakRef == "undefined" ? lu : WeakRef, "%WeakSet%": typeof WeakSet == "undefined" ? lu : WeakSet, "%Function.prototype.call%": j4, "%Function.prototype.apply%": SAe, "%Object.defineProperty%": YTt, "%Object.getPrototypeOf%": JTt, "%Math.abs%": VTt, "%Math.floor%": GTt, "%Math.max%": HTt, "%Math.min%": jTt, "%Math.pow%": WTt, "%Math.round%": XTt, "%Math.sign%": ZTt, "%Reflect.getPrototypeOf%": $Tt };\n            if (tv) try {\n              null.error;\n            } catch (e3) {\n              bAe = tv(tv(e3)), h22["%Error.prototype%"] = bAe;\n            }\n            var bAe, eAt = function e3(t3) {\n              var r4;\n              if (t3 === "%AsyncFunction%") r4 = kH("async function () {}");\n              else if (t3 === "%GeneratorFunction%") r4 = kH("function* () {}");\n              else if (t3 === "%AsyncGeneratorFunction%") r4 = kH("async function* () {}");\n              else if (t3 === "%AsyncGenerator%") {\n                var n4 = e3("%AsyncGeneratorFunction%");\n                n4 && (r4 = n4.prototype);\n              } else if (t3 === "%AsyncIteratorPrototype%") {\n                var i3 = e3("%AsyncGenerator%");\n                i3 && tv && (r4 = tv(i3.prototype));\n              }\n              return h22[t3] = r4, r4;\n            }, wAe = { __proto__: null, "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], "%ArrayPrototype%": ["Array", "prototype"], "%ArrayProto_entries%": ["Array", "prototype", "entries"], "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], "%ArrayProto_keys%": ["Array", "prototype", "keys"], "%ArrayProto_values%": ["Array", "prototype", "values"], "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"], "%BooleanPrototype%": ["Boolean", "prototype"], "%DataViewPrototype%": ["DataView", "prototype"], "%DatePrototype%": ["Date", "prototype"], "%ErrorPrototype%": ["Error", "prototype"], "%EvalErrorPrototype%": ["EvalError", "prototype"], "%Float32ArrayPrototype%": ["Float32Array", "prototype"], "%Float64ArrayPrototype%": ["Float64Array", "prototype"], "%FunctionPrototype%": ["Function", "prototype"], "%Generator%": ["GeneratorFunction", "prototype"], "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], "%Int8ArrayPrototype%": ["Int8Array", "prototype"], "%Int16ArrayPrototype%": ["Int16Array", "prototype"], "%Int32ArrayPrototype%": ["Int32Array", "prototype"], "%JSONParse%": ["JSON", "parse"], "%JSONStringify%": ["JSON", "stringify"], "%MapPrototype%": ["Map", "prototype"], "%NumberPrototype%": ["Number", "prototype"], "%ObjectPrototype%": ["Object", "prototype"], "%ObjProto_toString%": ["Object", "prototype", "toString"], "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], "%PromisePrototype%": ["Promise", "prototype"], "%PromiseProto_then%": ["Promise", "prototype", "then"], "%Promise_all%": ["Promise", "all"], "%Promise_reject%": ["Promise", "reject"], "%Promise_resolve%": ["Promise", "resolve"], "%RangeErrorPrototype%": ["RangeError", "prototype"], "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], "%RegExpPrototype%": ["RegExp", "prototype"], "%SetPrototype%": ["Set", "prototype"], "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], "%StringPrototype%": ["String", "prototype"], "%SymbolPrototype%": ["Symbol", "prototype"], "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], "%TypedArrayPrototype%": ["TypedArray", "prototype"], "%TypeErrorPrototype%": ["TypeError", "prototype"], "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], "%URIErrorPrototype%": ["URIError", "prototype"], "%WeakMapPrototype%": ["WeakMap", "prototype"], "%WeakSetPrototype%": ["WeakSet", "prototype"] }, W4 = rA(), Y8 = xAe(), tAt = W4.call(j4, Array.prototype.concat), rAt = W4.call(SAe, Array.prototype.splice), TAe = W4.call(j4, String.prototype.replace), K8 = W4.call(j4, String.prototype.slice), iAt = W4.call(j4, RegExp.prototype.exec), nAt = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g, aAt = /\\\\(\\\\)?/g, oAt = function(t3) {\n              var r4 = K8(t3, 0, 1), n4 = K8(t3, -1);\n              if (r4 === "%" && n4 !== "%") throw new oA("invalid intrinsic syntax, expected closing `%`");\n              if (n4 === "%" && r4 !== "%") throw new oA("invalid intrinsic syntax, expected opening `%`");\n              var i3 = [];\n              return TAe(t3, nAt, function(a4, o4, s3, l3) {\n                i3[i3.length] = s3 ? TAe(l3, aAt, "$1") : o4 || a4;\n              }), i3;\n            }, sAt = function(t3, r4) {\n              var n4 = t3, i3;\n              if (Y8(wAe, n4) && (i3 = wAe[n4], n4 = "%" + i3[0] + "%"), Y8(h22, n4)) {\n                var a4 = h22[n4];\n                if (a4 === nA && (a4 = eAt(n4)), typeof a4 == "undefined" && !r4) throw new aA("intrinsic " + t3 + " exists, but is not available. Please file an issue!");\n                return { alias: i3, name: n4, value: a4 };\n              }\n              throw new oA("intrinsic " + t3 + " does not exist!");\n            };\n            MAe.exports = function(t3, r4) {\n              if (typeof t3 != "string" || t3.length === 0) throw new aA("intrinsic name must be a non-empty string");\n              if (arguments.length > 1 && typeof r4 != "boolean") throw new aA(\'"allowMissing" argument must be a boolean\');\n              if (iAt(/^%?[^%]*%?$/, t3) === null) throw new oA("`%` may not be present anywhere but at the beginning and end of the intrinsic name");\n              var n4 = oAt(t3), i3 = n4.length > 0 ? n4[0] : "", a4 = sAt("%" + i3 + "%", r4), o4 = a4.name, s3 = a4.value, l3 = false, u4 = a4.alias;\n              u4 && (i3 = u4[0], rAt(n4, tAt([0, 1], u4)));\n              for (var c5 = 1, f4 = true; c5 < n4.length; c5 += 1) {\n                var h3 = n4[c5], d3 = K8(h3, 0, 1), v3 = K8(h3, -1);\n                if ((d3 === \'"\' || d3 === "\'" || d3 === "`" || v3 === \'"\' || v3 === "\'" || v3 === "`") && d3 !== v3) throw new oA("property names with quotes must have matching quotes");\n                if ((h3 === "constructor" || !f4) && (l3 = true), i3 += "." + h3, o4 = "%" + i3 + "%", Y8(h22, o4)) s3 = h22[o4];\n                else if (s3 != null) {\n                  if (!(h3 in s3)) {\n                    if (!r4) throw new aA("base intrinsic for " + t3 + " exists, but the property is not available.");\n                    return;\n                  }\n                  if (H4 && c5 + 1 >= n4.length) {\n                    var _2 = H4(s3, h3);\n                    f4 = !!_2, f4 && "get" in _2 && !("originalValue" in _2.get) ? s3 = _2.get : s3 = s3[h3];\n                  } else f4 = Y8(s3, h3), s3 = s3[h3];\n                  f4 && !l3 && (h22[o4] = s3);\n                }\n              }\n              return s3;\n            };\n          });\n          var LAe = ye((bhr, CAe) => {\n            "use strict";\n            var EAe = G4(), lAt = TH(), sA = tA(), kAe = f22();\n            CAe.exports = function(t3, r4, n4) {\n              if (!t3 || typeof t3 != "object" && typeof t3 != "function") throw new sA("`obj` must be an object or a function`");\n              if (typeof r4 != "string" && typeof r4 != "symbol") throw new sA("`property` must be a string or a symbol`");\n              if (arguments.length > 3 && typeof arguments[3] != "boolean" && arguments[3] !== null) throw new sA("`nonEnumerable`, if provided, must be a boolean or null");\n              if (arguments.length > 4 && typeof arguments[4] != "boolean" && arguments[4] !== null) throw new sA("`nonWritable`, if provided, must be a boolean or null");\n              if (arguments.length > 5 && typeof arguments[5] != "boolean" && arguments[5] !== null) throw new sA("`nonConfigurable`, if provided, must be a boolean or null");\n              if (arguments.length > 6 && typeof arguments[6] != "boolean") throw new sA("`loose`, if provided, must be a boolean");\n              var i3 = arguments.length > 3 ? arguments[3] : null, a4 = arguments.length > 4 ? arguments[4] : null, o4 = arguments.length > 5 ? arguments[5] : null, s3 = arguments.length > 6 ? arguments[6] : false, l3 = !!kAe && kAe(t3, r4);\n              if (EAe) EAe(t3, r4, { configurable: o4 === null && l3 ? l3.configurable : !o4, enumerable: i3 === null && l3 ? l3.enumerable : !i3, value: n4, writable: a4 === null && l3 ? l3.writable : !a4 });\n              else if (s3 || !i3 && !a4 && !o4) t3[r4] = n4;\n              else throw new lAt("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");\n            };\n          });\n          var PH = ye((whr, IAe) => {\n            "use strict";\n            var LH = G4(), PAe = function() {\n              return !!LH;\n            };\n            PAe.hasArrayLengthDefineBug = function() {\n              if (!LH) return null;\n              try {\n                return LH([], "length", { value: 1 }).length !== 1;\n              } catch (t3) {\n                return true;\n              }\n            };\n            IAe.exports = PAe;\n          });\n          var OAe = ye((Thr, zAe) => {\n            "use strict";\n            var uAt = J8(), RAe = LAe(), cAt = PH()(), DAe = f22(), FAe = tA(), fAt = uAt("%Math.floor%");\n            zAe.exports = function(t3, r4) {\n              if (typeof t3 != "function") throw new FAe("`fn` is not a function");\n              if (typeof r4 != "number" || r4 < 0 || r4 > 4294967295 || fAt(r4) !== r4) throw new FAe("`length` must be a positive 32-bit integer");\n              var n4 = arguments.length > 2 && !!arguments[2], i3 = true, a4 = true;\n              if ("length" in t3 && DAe) {\n                var o4 = DAe(t3, "length");\n                o4 && !o4.configurable && (i3 = false), o4 && !o4.writable && (a4 = false);\n              }\n              return (i3 || a4 || !n4) && (cAt ? RAe(t3, "length", r4, true, true) : RAe(t3, "length", r4)), t3;\n            };\n          });\n          var X4 = ye((Ahr, $8) => {\n            "use strict";\n            var IH = rA(), Q8 = J8(), hAt = OAe(), dAt = tA(), NAe = Q8("%Function.prototype.apply%"), UAe = Q8("%Function.prototype.call%"), VAe = Q8("%Reflect.apply%", true) || IH.call(UAe, NAe), qAe = G4(), vAt = Q8("%Math.max%");\n            $8.exports = function(t3) {\n              if (typeof t3 != "function") throw new dAt("a function is required");\n              var r4 = VAe(IH, UAe, arguments);\n              return hAt(r4, 1 + vAt(0, t3.length - (arguments.length - 1)), true);\n            };\n            var BAe = function() {\n              return VAe(IH, NAe, arguments);\n            };\n            qAe ? qAe($8.exports, "apply", { value: BAe }) : $8.exports.apply = BAe;\n          });\n          var lA = ye((Shr, jAe) => {\n            "use strict";\n            var GAe = J8(), HAe = X4(), pAt = HAe(GAe("String.prototype.indexOf"));\n            jAe.exports = function(t3, r4) {\n              var n4 = GAe(t3, !!r4);\n              return typeof n4 == "function" && pAt(t3, ".prototype.") > -1 ? HAe(n4) : n4;\n            };\n          });\n          var ZAe = ye((Mhr, XAe) => {\n            "use strict";\n            var gAt = V4()(), mAt = lA(), RH = mAt("Object.prototype.toString"), eR = function(t3) {\n              return gAt && t3 && typeof t3 == "object" && Symbol.toStringTag in t3 ? false : RH(t3) === "[object Arguments]";\n            }, WAe = function(t3) {\n              return eR(t3) ? true : t3 !== null && typeof t3 == "object" && typeof t3.length == "number" && t3.length >= 0 && RH(t3) !== "[object Array]" && RH(t3.callee) === "[object Function]";\n            }, yAt = (function() {\n              return eR(arguments);\n            })();\n            eR.isLegacyArguments = WAe;\n            XAe.exports = yAt ? eR : WAe;\n          });\n          var JAe = ye((Ehr, KAe) => {\n            "use strict";\n            var _At = Object.prototype.toString, xAt = Function.prototype.toString, bAt = /^\\s*(?:function)?\\*/, YAe = V4()(), DH = Object.getPrototypeOf, wAt = function() {\n              if (!YAe) return false;\n              try {\n                return Function("return function*() {}")();\n              } catch (e3) {\n              }\n            }, FH;\n            KAe.exports = function(t3) {\n              if (typeof t3 != "function") return false;\n              if (bAt.test(xAt.call(t3))) return true;\n              if (!YAe) {\n                var r4 = _At.call(t3);\n                return r4 === "[object GeneratorFunction]";\n              }\n              if (!DH) return false;\n              if (typeof FH == "undefined") {\n                var n4 = wAt();\n                FH = n4 ? DH(n4) : false;\n              }\n              return DH(t3) === FH;\n            };\n          });\n          var t5e = ye((khr, e5e) => {\n            "use strict";\n            var QAe = Function.prototype.toString, uA = typeof Reflect == "object" && Reflect !== null && Reflect.apply, OH, tR;\n            if (typeof uA == "function" && typeof Object.defineProperty == "function") try {\n              OH = Object.defineProperty({}, "length", { get: function() {\n                throw tR;\n              } }), tR = {}, uA(function() {\n                throw 42;\n              }, null, OH);\n            } catch (e3) {\n              e3 !== tR && (uA = null);\n            }\n            else uA = null;\n            var TAt = /^\\s*class\\b/, qH = function(t3) {\n              try {\n                var r4 = QAe.call(t3);\n                return TAt.test(r4);\n              } catch (n4) {\n                return false;\n              }\n            }, zH = function(t3) {\n              try {\n                return qH(t3) ? false : (QAe.call(t3), true);\n              } catch (r4) {\n                return false;\n              }\n            }, rR = Object.prototype.toString, AAt = "[object Object]", SAt = "[object Function]", MAt = "[object GeneratorFunction]", EAt = "[object HTMLAllCollection]", kAt = "[object HTML document.all class]", CAt = "[object HTMLCollection]", LAt = typeof Symbol == "function" && !!Symbol.toStringTag, PAt = !(0 in [,]), BH = function() {\n              return false;\n            };\n            typeof document == "object" && ($Ae = document.all, rR.call($Ae) === rR.call(document.all) && (BH = function(t3) {\n              if ((PAt || !t3) && (typeof t3 == "undefined" || typeof t3 == "object")) try {\n                var r4 = rR.call(t3);\n                return (r4 === EAt || r4 === kAt || r4 === CAt || r4 === AAt) && t3("") == null;\n              } catch (n4) {\n              }\n              return false;\n            }));\n            var $Ae;\n            e5e.exports = uA ? function(t3) {\n              if (BH(t3)) return true;\n              if (!t3 || typeof t3 != "function" && typeof t3 != "object") return false;\n              try {\n                uA(t3, null, OH);\n              } catch (r4) {\n                if (r4 !== tR) return false;\n              }\n              return !qH(t3) && zH(t3);\n            } : function(t3) {\n              if (BH(t3)) return true;\n              if (!t3 || typeof t3 != "function" && typeof t3 != "object") return false;\n              if (LAt) return zH(t3);\n              if (qH(t3)) return false;\n              var r4 = rR.call(t3);\n              return r4 !== SAt && r4 !== MAt && !/^\\[object HTML/.test(r4) ? false : zH(t3);\n            };\n          });\n          var NH = ye((Chr, i5e) => {\n            "use strict";\n            var IAt = t5e(), RAt = Object.prototype.toString, r5e = Object.prototype.hasOwnProperty, DAt = function(t3, r4, n4) {\n              for (var i3 = 0, a4 = t3.length; i3 < a4; i3++) r5e.call(t3, i3) && (n4 == null ? r4(t3[i3], i3, t3) : r4.call(n4, t3[i3], i3, t3));\n            }, FAt = function(t3, r4, n4) {\n              for (var i3 = 0, a4 = t3.length; i3 < a4; i3++) n4 == null ? r4(t3.charAt(i3), i3, t3) : r4.call(n4, t3.charAt(i3), i3, t3);\n            }, zAt = function(t3, r4, n4) {\n              for (var i3 in t3) r5e.call(t3, i3) && (n4 == null ? r4(t3[i3], i3, t3) : r4.call(n4, t3[i3], i3, t3));\n            }, OAt = function(t3, r4, n4) {\n              if (!IAt(r4)) throw new TypeError("iterator must be a function");\n              var i3;\n              arguments.length >= 3 && (i3 = n4), RAt.call(t3) === "[object Array]" ? DAt(t3, r4, i3) : typeof t3 == "string" ? FAt(t3, r4, i3) : zAt(t3, r4, i3);\n            };\n            i5e.exports = OAt;\n          });\n          var VH = ye((Lhr, n5e) => {\n            "use strict";\n            var UH = ["BigInt64Array", "BigUint64Array", "Float32Array", "Float64Array", "Int16Array", "Int32Array", "Int8Array", "Uint16Array", "Uint32Array", "Uint8Array", "Uint8ClampedArray"], qAt = typeof globalThis == "undefined" ? window : globalThis;\n            n5e.exports = function() {\n              for (var t3 = [], r4 = 0; r4 < UH.length; r4++) typeof qAt[UH[r4]] == "function" && (t3[t3.length] = UH[r4]);\n              return t3;\n            };\n          });\n          var u5e = ye((Phr, l5e) => {\n            "use strict";\n            var nR = NH(), BAt = VH(), a5e = X4(), jH = lA(), iR = f22(), NAt = jH("Object.prototype.toString"), s5e = V4()(), o5e = typeof globalThis == "undefined" ? window : globalThis, HH = BAt(), WH = jH("String.prototype.slice"), GH = Object.getPrototypeOf, UAt = jH("Array.prototype.indexOf", true) || function(t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4 += 1) if (t3[n4] === r4) return n4;\n              return -1;\n            }, aR = { __proto__: null };\n            s5e && iR && GH ? nR(HH, function(e3) {\n              var t3 = new o5e[e3]();\n              if (Symbol.toStringTag in t3) {\n                var r4 = GH(t3), n4 = iR(r4, Symbol.toStringTag);\n                if (!n4) {\n                  var i3 = GH(r4);\n                  n4 = iR(i3, Symbol.toStringTag);\n                }\n                aR["$" + e3] = a5e(n4.get);\n              }\n            }) : nR(HH, function(e3) {\n              var t3 = new o5e[e3](), r4 = t3.slice || t3.set;\n              r4 && (aR["$" + e3] = a5e(r4));\n            });\n            var VAt = function(t3) {\n              var r4 = false;\n              return nR(aR, function(n4, i3) {\n                if (!r4) try {\n                  "$" + n4(t3) === i3 && (r4 = WH(i3, 1));\n                } catch (a4) {\n                }\n              }), r4;\n            }, GAt = function(t3) {\n              var r4 = false;\n              return nR(aR, function(n4, i3) {\n                if (!r4) try {\n                  n4(t3), r4 = WH(i3, 1);\n                } catch (a4) {\n                }\n              }), r4;\n            };\n            l5e.exports = function(t3) {\n              if (!t3 || typeof t3 != "object") return false;\n              if (!s5e) {\n                var r4 = WH(NAt(t3), 8, -1);\n                return UAt(HH, r4) > -1 ? r4 : r4 !== "Object" ? false : GAt(t3);\n              }\n              return iR ? VAt(t3) : null;\n            };\n          });\n          var p5e = ye((Ihr, v5e) => {\n            "use strict";\n            var c5e = NH(), HAt = VH(), ZH = lA(), jAt = ZH("Object.prototype.toString"), f5e = V4()(), oR = f22(), WAt = typeof globalThis == "undefined" ? window : globalThis, h5e = HAt(), XAt = ZH("Array.prototype.indexOf", true) || function(t3, r4) {\n              for (var n4 = 0; n4 < t3.length; n4 += 1) if (t3[n4] === r4) return n4;\n              return -1;\n            }, ZAt = ZH("String.prototype.slice"), d5e = {}, XH = Object.getPrototypeOf;\n            f5e && oR && XH && c5e(h5e, function(e3) {\n              var t3 = new WAt[e3]();\n              if (Symbol.toStringTag in t3) {\n                var r4 = XH(t3), n4 = oR(r4, Symbol.toStringTag);\n                if (!n4) {\n                  var i3 = XH(r4);\n                  n4 = oR(i3, Symbol.toStringTag);\n                }\n                d5e[e3] = n4.get;\n              }\n            });\n            var YAt = function(t3) {\n              var r4 = false;\n              return c5e(d5e, function(n4, i3) {\n                if (!r4) try {\n                  r4 = n4.call(t3) === i3;\n                } catch (a4) {\n                }\n              }), r4;\n            };\n            v5e.exports = function(t3) {\n              if (!t3 || typeof t3 != "object") return false;\n              if (!f5e || !(Symbol.toStringTag in t3)) {\n                var r4 = ZAt(jAt(t3), 8, -1);\n                return XAt(h5e, r4) > -1;\n              }\n              return oR ? YAt(t3) : false;\n            };\n          });\n          var JH = ye((uu) => {\n            "use strict";\n            var KAt = ZAe(), JAt = JAe(), Hg = u5e(), g5e = p5e();\n            function cA(e3) {\n              return e3.call.bind(e3);\n            }\n            var m5e = typeof BigInt != "undefined", y5e = typeof Symbol != "undefined", Z0 = cA(Object.prototype.toString), $At = cA(Number.prototype.valueOf), QAt = cA(String.prototype.valueOf), e5t = cA(Boolean.prototype.valueOf);\n            m5e && (_5e = cA(BigInt.prototype.valueOf));\n            var _5e;\n            y5e && (x5e = cA(Symbol.prototype.valueOf));\n            var x5e;\n            function Y4(e3, t3) {\n              if (typeof e3 != "object") return false;\n              try {\n                return t3(e3), true;\n              } catch (r4) {\n                return false;\n              }\n            }\n            uu.isArgumentsObject = KAt;\n            uu.isGeneratorFunction = JAt;\n            uu.isTypedArray = g5e;\n            function t5t(e3) {\n              return typeof Promise != "undefined" && e3 instanceof Promise || e3 !== null && typeof e3 == "object" && typeof e3.then == "function" && typeof e3.catch == "function";\n            }\n            uu.isPromise = t5t;\n            function r5t(e3) {\n              return typeof ArrayBuffer != "undefined" && ArrayBuffer.isView ? ArrayBuffer.isView(e3) : g5e(e3) || w5e(e3);\n            }\n            uu.isArrayBufferView = r5t;\n            function i5t(e3) {\n              return Hg(e3) === "Uint8Array";\n            }\n            uu.isUint8Array = i5t;\n            function n5t(e3) {\n              return Hg(e3) === "Uint8ClampedArray";\n            }\n            uu.isUint8ClampedArray = n5t;\n            function a5t(e3) {\n              return Hg(e3) === "Uint16Array";\n            }\n            uu.isUint16Array = a5t;\n            function o5t(e3) {\n              return Hg(e3) === "Uint32Array";\n            }\n            uu.isUint32Array = o5t;\n            function s5t(e3) {\n              return Hg(e3) === "Int8Array";\n            }\n            uu.isInt8Array = s5t;\n            function l5t(e3) {\n              return Hg(e3) === "Int16Array";\n            }\n            uu.isInt16Array = l5t;\n            function u5t(e3) {\n              return Hg(e3) === "Int32Array";\n            }\n            uu.isInt32Array = u5t;\n            function c5t(e3) {\n              return Hg(e3) === "Float32Array";\n            }\n            uu.isFloat32Array = c5t;\n            function f5t(e3) {\n              return Hg(e3) === "Float64Array";\n            }\n            uu.isFloat64Array = f5t;\n            function h5t(e3) {\n              return Hg(e3) === "BigInt64Array";\n            }\n            uu.isBigInt64Array = h5t;\n            function d5t(e3) {\n              return Hg(e3) === "BigUint64Array";\n            }\n            uu.isBigUint64Array = d5t;\n            function sR(e3) {\n              return Z0(e3) === "[object Map]";\n            }\n            sR.working = typeof Map != "undefined" && sR(/* @__PURE__ */ new Map());\n            function v5t(e3) {\n              return typeof Map == "undefined" ? false : sR.working ? sR(e3) : e3 instanceof Map;\n            }\n            uu.isMap = v5t;\n            function lR(e3) {\n              return Z0(e3) === "[object Set]";\n            }\n            lR.working = typeof Set != "undefined" && lR(/* @__PURE__ */ new Set());\n            function p5t(e3) {\n              return typeof Set == "undefined" ? false : lR.working ? lR(e3) : e3 instanceof Set;\n            }\n            uu.isSet = p5t;\n            function uR(e3) {\n              return Z0(e3) === "[object WeakMap]";\n            }\n            uR.working = typeof WeakMap != "undefined" && uR(/* @__PURE__ */ new WeakMap());\n            function g5t(e3) {\n              return typeof WeakMap == "undefined" ? false : uR.working ? uR(e3) : e3 instanceof WeakMap;\n            }\n            uu.isWeakMap = g5t;\n            function KH(e3) {\n              return Z0(e3) === "[object WeakSet]";\n            }\n            KH.working = typeof WeakSet != "undefined" && KH(/* @__PURE__ */ new WeakSet());\n            function m5t(e3) {\n              return KH(e3);\n            }\n            uu.isWeakSet = m5t;\n            function cR(e3) {\n              return Z0(e3) === "[object ArrayBuffer]";\n            }\n            cR.working = typeof ArrayBuffer != "undefined" && cR(new ArrayBuffer());\n            function b5e(e3) {\n              return typeof ArrayBuffer == "undefined" ? false : cR.working ? cR(e3) : e3 instanceof ArrayBuffer;\n            }\n            uu.isArrayBuffer = b5e;\n            function fR(e3) {\n              return Z0(e3) === "[object DataView]";\n            }\n            fR.working = typeof ArrayBuffer != "undefined" && typeof DataView != "undefined" && fR(new DataView(new ArrayBuffer(1), 0, 1));\n            function w5e(e3) {\n              return typeof DataView == "undefined" ? false : fR.working ? fR(e3) : e3 instanceof DataView;\n            }\n            uu.isDataView = w5e;\n            var YH = typeof SharedArrayBuffer != "undefined" ? SharedArrayBuffer : void 0;\n            function Z4(e3) {\n              return Z0(e3) === "[object SharedArrayBuffer]";\n            }\n            function T5e(e3) {\n              return typeof YH == "undefined" ? false : (typeof Z4.working == "undefined" && (Z4.working = Z4(new YH())), Z4.working ? Z4(e3) : e3 instanceof YH);\n            }\n            uu.isSharedArrayBuffer = T5e;\n            function y5t(e3) {\n              return Z0(e3) === "[object AsyncFunction]";\n            }\n            uu.isAsyncFunction = y5t;\n            function _5t(e3) {\n              return Z0(e3) === "[object Map Iterator]";\n            }\n            uu.isMapIterator = _5t;\n            function x5t(e3) {\n              return Z0(e3) === "[object Set Iterator]";\n            }\n            uu.isSetIterator = x5t;\n            function b5t(e3) {\n              return Z0(e3) === "[object Generator]";\n            }\n            uu.isGeneratorObject = b5t;\n            function w5t(e3) {\n              return Z0(e3) === "[object WebAssembly.Module]";\n            }\n            uu.isWebAssemblyCompiledModule = w5t;\n            function A5e(e3) {\n              return Y4(e3, $At);\n            }\n            uu.isNumberObject = A5e;\n            function S5e(e3) {\n              return Y4(e3, QAt);\n            }\n            uu.isStringObject = S5e;\n            function M5e(e3) {\n              return Y4(e3, e5t);\n            }\n            uu.isBooleanObject = M5e;\n            function E5e(e3) {\n              return m5e && Y4(e3, _5e);\n            }\n            uu.isBigIntObject = E5e;\n            function k5e(e3) {\n              return y5e && Y4(e3, x5e);\n            }\n            uu.isSymbolObject = k5e;\n            function T5t(e3) {\n              return A5e(e3) || S5e(e3) || M5e(e3) || E5e(e3) || k5e(e3);\n            }\n            uu.isBoxedPrimitive = T5t;\n            function A5t(e3) {\n              return typeof Uint8Array != "undefined" && (b5e(e3) || T5e(e3));\n            }\n            uu.isAnyArrayBuffer = A5t;\n            ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(e3) {\n              Object.defineProperty(uu, e3, { enumerable: false, value: function() {\n                throw new Error(e3 + " is not supported in userland");\n              } });\n            });\n          });\n          var $H = ye((Dhr, C5e) => {\n            C5e.exports = function(t3) {\n              return t3 && typeof t3 == "object" && typeof t3.copy == "function" && typeof t3.fill == "function" && typeof t3.readUInt8 == "function";\n            };\n          });\n          var nj = ye((cu) => {\n            var L5e = Object.getOwnPropertyDescriptors || function(t3) {\n              for (var r4 = Object.keys(t3), n4 = {}, i3 = 0; i3 < r4.length; i3++) n4[r4[i3]] = Object.getOwnPropertyDescriptor(t3, r4[i3]);\n              return n4;\n            }, S5t = /%[sdj%]/g;\n            cu.format = function(e3) {\n              if (!yR(e3)) {\n                for (var t3 = [], r4 = 0; r4 < arguments.length; r4++) t3.push(I_(arguments[r4]));\n                return t3.join(" ");\n              }\n              for (var r4 = 1, n4 = arguments, i3 = n4.length, a4 = String(e3).replace(S5t, function(s3) {\n                if (s3 === "%%") return "%";\n                if (r4 >= i3) return s3;\n                switch (s3) {\n                  case "%s":\n                    return String(n4[r4++]);\n                  case "%d":\n                    return Number(n4[r4++]);\n                  case "%j":\n                    try {\n                      return JSON.stringify(n4[r4++]);\n                    } catch (l3) {\n                      return "[Circular]";\n                    }\n                  default:\n                    return s3;\n                }\n              }), o4 = n4[r4]; r4 < i3; o4 = n4[++r4]) mR(o4) || !fA(o4) ? a4 += " " + o4 : a4 += " " + I_(o4);\n              return a4;\n            };\n            cu.deprecate = function(e3, t3) {\n              if (typeof process != "undefined" && process.noDeprecation === true) return e3;\n              if (typeof process == "undefined") return function() {\n                return cu.deprecate(e3, t3).apply(this, arguments);\n              };\n              var r4 = false;\n              function n4() {\n                if (!r4) {\n                  if (process.throwDeprecation) throw new Error(t3);\n                  process.traceDeprecation ? console.trace(t3) : console.error(t3), r4 = true;\n                }\n                return e3.apply(this, arguments);\n              }\n              return n4;\n            };\n            var hR = {}, P5e = /^$/;\n            dR = "false", dR = dR.replace(/[|\\\\{}()[\\]^$+?.]/g, "\\\\$&").replace(/\\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), P5e = new RegExp("^" + dR + "$", "i");\n            var dR;\n            cu.debuglog = function(e3) {\n              if (e3 = e3.toUpperCase(), !hR[e3]) if (P5e.test(e3)) {\n                var t3 = process.pid;\n                hR[e3] = function() {\n                  var r4 = cu.format.apply(cu, arguments);\n                  console.error("%s %d: %s", e3, t3, r4);\n                };\n              } else hR[e3] = function() {\n              };\n              return hR[e3];\n            };\n            function I_(e3, t3) {\n              var r4 = { seen: [], stylize: E5t };\n              return arguments.length >= 3 && (r4.depth = arguments[2]), arguments.length >= 4 && (r4.colors = arguments[3]), rj(t3) ? r4.showHidden = t3 : t3 && cu._extend(r4, t3), v22(r4.showHidden) && (r4.showHidden = false), v22(r4.depth) && (r4.depth = 2), v22(r4.colors) && (r4.colors = false), v22(r4.customInspect) && (r4.customInspect = true), r4.colors && (r4.stylize = M5t), pR(r4, e3, r4.depth);\n            }\n            cu.inspect = I_;\n            I_.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] };\n            I_.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" };\n            function M5t(e3, t3) {\n              var r4 = I_.styles[t3];\n              return r4 ? "\\x1B[" + I_.colors[r4][0] + "m" + e3 + "\\x1B[" + I_.colors[r4][1] + "m" : e3;\n            }\n            function E5t(e3, t3) {\n              return e3;\n            }\n            function k5t(e3) {\n              var t3 = {};\n              return e3.forEach(function(r4, n4) {\n                t3[r4] = true;\n              }), t3;\n            }\n            function pR(e3, t3, r4) {\n              if (e3.customInspect && t3 && vR(t3.inspect) && t3.inspect !== cu.inspect && !(t3.constructor && t3.constructor.prototype === t3)) {\n                var n4 = t3.inspect(r4, e3);\n                return yR(n4) || (n4 = pR(e3, n4, r4)), n4;\n              }\n              var i3 = C5t(e3, t3);\n              if (i3) return i3;\n              var a4 = Object.keys(t3), o4 = k5t(a4);\n              if (e3.showHidden && (a4 = Object.getOwnPropertyNames(t3)), J4(t3) && (a4.indexOf("message") >= 0 || a4.indexOf("description") >= 0)) return QH(t3);\n              if (a4.length === 0) {\n                if (vR(t3)) {\n                  var s3 = t3.name ? ": " + t3.name : "";\n                  return e3.stylize("[Function" + s3 + "]", "special");\n                }\n                if (K4(t3)) return e3.stylize(RegExp.prototype.toString.call(t3), "regexp");\n                if (gR(t3)) return e3.stylize(Date.prototype.toString.call(t3), "date");\n                if (J4(t3)) return QH(t3);\n              }\n              var l3 = "", u4 = false, c5 = ["{", "}"];\n              if (I5e(t3) && (u4 = true, c5 = ["[", "]"]), vR(t3)) {\n                var f4 = t3.name ? ": " + t3.name : "";\n                l3 = " [Function" + f4 + "]";\n              }\n              if (K4(t3) && (l3 = " " + RegExp.prototype.toString.call(t3)), gR(t3) && (l3 = " " + Date.prototype.toUTCString.call(t3)), J4(t3) && (l3 = " " + QH(t3)), a4.length === 0 && (!u4 || t3.length == 0)) return c5[0] + l3 + c5[1];\n              if (r4 < 0) return K4(t3) ? e3.stylize(RegExp.prototype.toString.call(t3), "regexp") : e3.stylize("[Object]", "special");\n              e3.seen.push(t3);\n              var h3;\n              return u4 ? h3 = L5t(e3, t3, r4, o4, a4) : h3 = a4.map(function(d3) {\n                return tj(e3, t3, r4, o4, d3, u4);\n              }), e3.seen.pop(), P5t(h3, l3, c5);\n            }\n            function C5t(e3, t3) {\n              if (v22(t3)) return e3.stylize("undefined", "undefined");\n              if (yR(t3)) {\n                var r4 = "\'" + JSON.stringify(t3).replace(/^"|"$/g, "").replace(/\'/g, "\\\\\'").replace(/\\\\"/g, \'"\') + "\'";\n                return e3.stylize(r4, "string");\n              }\n              if (R5e(t3)) return e3.stylize("" + t3, "number");\n              if (rj(t3)) return e3.stylize("" + t3, "boolean");\n              if (mR(t3)) return e3.stylize("null", "null");\n            }\n            function QH(e3) {\n              return "[" + Error.prototype.toString.call(e3) + "]";\n            }\n            function L5t(e3, t3, r4, n4, i3) {\n              for (var a4 = [], o4 = 0, s3 = t3.length; o4 < s3; ++o4) D5e(t3, String(o4)) ? a4.push(tj(e3, t3, r4, n4, String(o4), true)) : a4.push("");\n              return i3.forEach(function(l3) {\n                l3.match(/^\\d+$/) || a4.push(tj(e3, t3, r4, n4, l3, true));\n              }), a4;\n            }\n            function tj(e3, t3, r4, n4, i3, a4) {\n              var o4, s3, l3;\n              if (l3 = Object.getOwnPropertyDescriptor(t3, i3) || { value: t3[i3] }, l3.get ? l3.set ? s3 = e3.stylize("[Getter/Setter]", "special") : s3 = e3.stylize("[Getter]", "special") : l3.set && (s3 = e3.stylize("[Setter]", "special")), D5e(n4, i3) || (o4 = "[" + i3 + "]"), s3 || (e3.seen.indexOf(l3.value) < 0 ? (mR(r4) ? s3 = pR(e3, l3.value, null) : s3 = pR(e3, l3.value, r4 - 1), s3.indexOf(`\n`) > -1 && (a4 ? s3 = s3.split(`\n`).map(function(u4) {\n                return "  " + u4;\n              }).join(`\n`).slice(2) : s3 = `\n` + s3.split(`\n`).map(function(u4) {\n                return "   " + u4;\n              }).join(`\n`))) : s3 = e3.stylize("[Circular]", "special")), v22(o4)) {\n                if (a4 && i3.match(/^\\d+$/)) return s3;\n                o4 = JSON.stringify("" + i3), o4.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (o4 = o4.slice(1, -1), o4 = e3.stylize(o4, "name")) : (o4 = o4.replace(/\'/g, "\\\\\'").replace(/\\\\"/g, \'"\').replace(/(^"|"$)/g, "\'"), o4 = e3.stylize(o4, "string"));\n              }\n              return o4 + ": " + s3;\n            }\n            function P5t(e3, t3, r4) {\n              var n4 = 0, i3 = e3.reduce(function(a4, o4) {\n                return n4++, o4.indexOf(`\n`) >= 0 && n4++, a4 + o4.replace(/\\u001b\\[\\d\\d?m/g, "").length + 1;\n              }, 0);\n              return i3 > 60 ? r4[0] + (t3 === "" ? "" : t3 + `\n `) + " " + e3.join(`,\n  `) + " " + r4[1] : r4[0] + t3 + " " + e3.join(", ") + " " + r4[1];\n            }\n            cu.types = JH();\n            function I5e(e3) {\n              return Array.isArray(e3);\n            }\n            cu.isArray = I5e;\n            function rj(e3) {\n              return typeof e3 == "boolean";\n            }\n            cu.isBoolean = rj;\n            function mR(e3) {\n              return e3 === null;\n            }\n            cu.isNull = mR;\n            function I5t(e3) {\n              return e3 == null;\n            }\n            cu.isNullOrUndefined = I5t;\n            function R5e(e3) {\n              return typeof e3 == "number";\n            }\n            cu.isNumber = R5e;\n            function yR(e3) {\n              return typeof e3 == "string";\n            }\n            cu.isString = yR;\n            function R5t(e3) {\n              return typeof e3 == "symbol";\n            }\n            cu.isSymbol = R5t;\n            function v22(e3) {\n              return e3 === void 0;\n            }\n            cu.isUndefined = v22;\n            function K4(e3) {\n              return fA(e3) && ij(e3) === "[object RegExp]";\n            }\n            cu.isRegExp = K4;\n            cu.types.isRegExp = K4;\n            function fA(e3) {\n              return typeof e3 == "object" && e3 !== null;\n            }\n            cu.isObject = fA;\n            function gR(e3) {\n              return fA(e3) && ij(e3) === "[object Date]";\n            }\n            cu.isDate = gR;\n            cu.types.isDate = gR;\n            function J4(e3) {\n              return fA(e3) && (ij(e3) === "[object Error]" || e3 instanceof Error);\n            }\n            cu.isError = J4;\n            cu.types.isNativeError = J4;\n            function vR(e3) {\n              return typeof e3 == "function";\n            }\n            cu.isFunction = vR;\n            function D5t(e3) {\n              return e3 === null || typeof e3 == "boolean" || typeof e3 == "number" || typeof e3 == "string" || typeof e3 == "symbol" || typeof e3 == "undefined";\n            }\n            cu.isPrimitive = D5t;\n            cu.isBuffer = $H();\n            function ij(e3) {\n              return Object.prototype.toString.call(e3);\n            }\n            function ej(e3) {\n              return e3 < 10 ? "0" + e3.toString(10) : e3.toString(10);\n            }\n            var F5t = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];\n            function z5t() {\n              var e3 = /* @__PURE__ */ new Date(), t3 = [ej(e3.getHours()), ej(e3.getMinutes()), ej(e3.getSeconds())].join(":");\n              return [e3.getDate(), F5t[e3.getMonth()], t3].join(" ");\n            }\n            cu.log = function() {\n              console.log("%s - %s", z5t(), cu.format.apply(cu, arguments));\n            };\n            cu.inherits = Uy();\n            cu._extend = function(e3, t3) {\n              if (!t3 || !fA(t3)) return e3;\n              for (var r4 = Object.keys(t3), n4 = r4.length; n4--; ) e3[r4[n4]] = t3[r4[n4]];\n              return e3;\n            };\n            function D5e(e3, t3) {\n              return Object.prototype.hasOwnProperty.call(e3, t3);\n            }\n            var d22 = typeof Symbol != "undefined" ? /* @__PURE__ */ Symbol("util.promisify.custom") : void 0;\n            cu.promisify = function(t3) {\n              if (typeof t3 != "function") throw new TypeError(\'The "original" argument must be of type Function\');\n              if (d22 && t3[d22]) {\n                var r4 = t3[d22];\n                if (typeof r4 != "function") throw new TypeError(\'The "util.promisify.custom" argument must be of type Function\');\n                return Object.defineProperty(r4, d22, { value: r4, enumerable: false, writable: false, configurable: true }), r4;\n              }\n              function r4() {\n                for (var n4, i3, a4 = new Promise(function(l3, u4) {\n                  n4 = l3, i3 = u4;\n                }), o4 = [], s3 = 0; s3 < arguments.length; s3++) o4.push(arguments[s3]);\n                o4.push(function(l3, u4) {\n                  l3 ? i3(l3) : n4(u4);\n                });\n                try {\n                  t3.apply(this, o4);\n                } catch (l3) {\n                  i3(l3);\n                }\n                return a4;\n              }\n              return Object.setPrototypeOf(r4, Object.getPrototypeOf(t3)), d22 && Object.defineProperty(r4, d22, { value: r4, enumerable: false, writable: false, configurable: true }), Object.defineProperties(r4, L5e(t3));\n            };\n            cu.promisify.custom = d22;\n            function O5t(e3, t3) {\n              if (!e3) {\n                var r4 = new Error("Promise was rejected with a falsy value");\n                r4.reason = e3, e3 = r4;\n              }\n              return t3(e3);\n            }\n            function q5t(e3) {\n              if (typeof e3 != "function") throw new TypeError(\'The "original" argument must be of type Function\');\n              function t3() {\n                for (var r4 = [], n4 = 0; n4 < arguments.length; n4++) r4.push(arguments[n4]);\n                var i3 = r4.pop();\n                if (typeof i3 != "function") throw new TypeError("The last argument must be of type Function");\n                var a4 = this, o4 = function() {\n                  return i3.apply(a4, arguments);\n                };\n                e3.apply(this, r4).then(function(s3) {\n                  process.nextTick(o4.bind(null, null, s3));\n                }, function(s3) {\n                  process.nextTick(O5t.bind(null, s3, o4));\n                });\n              }\n              return Object.setPrototypeOf(t3, Object.getPrototypeOf(e3)), Object.defineProperties(t3, L5e(e3)), t3;\n            }\n            cu.callbackify = q5t;\n          });\n          var q5e = ye((zhr, O5e) => {\n            "use strict";\n            function F5e(e3, t3) {\n              var r4 = Object.keys(e3);\n              if (Object.getOwnPropertySymbols) {\n                var n4 = Object.getOwnPropertySymbols(e3);\n                t3 && (n4 = n4.filter(function(i3) {\n                  return Object.getOwnPropertyDescriptor(e3, i3).enumerable;\n                })), r4.push.apply(r4, n4);\n              }\n              return r4;\n            }\n            function B5t(e3) {\n              for (var t3 = 1; t3 < arguments.length; t3++) {\n                var r4 = arguments[t3] != null ? arguments[t3] : {};\n                t3 % 2 ? F5e(Object(r4), true).forEach(function(n4) {\n                  N5t(e3, n4, r4[n4]);\n                }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e3, Object.getOwnPropertyDescriptors(r4)) : F5e(Object(r4)).forEach(function(n4) {\n                  Object.defineProperty(e3, n4, Object.getOwnPropertyDescriptor(r4, n4));\n                });\n              }\n              return e3;\n            }\n            function N5t(e3, t3, r4) {\n              return t3 in e3 ? Object.defineProperty(e3, t3, { value: r4, enumerable: true, configurable: true, writable: true }) : e3[t3] = r4, e3;\n            }\n            function U5t(e3, t3) {\n              if (!(e3 instanceof t3)) throw new TypeError("Cannot call a class as a function");\n            }\n            function z5e(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                n4.enumerable = n4.enumerable || false, n4.configurable = true, "value" in n4 && (n4.writable = true), Object.defineProperty(e3, n4.key, n4);\n              }\n            }\n            function V5t(e3, t3, r4) {\n              return t3 && z5e(e3.prototype, t3), r4 && z5e(e3, r4), e3;\n            }\n            var G5t = c22(), _R = G5t.Buffer, H5t = nj(), aj = H5t.inspect, j5t = aj && aj.custom || "inspect";\n            function W5t(e3, t3, r4) {\n              _R.prototype.copy.call(e3, t3, r4);\n            }\n            O5e.exports = (function() {\n              function e3() {\n                U5t(this, e3), this.head = null, this.tail = null, this.length = 0;\n              }\n              return V5t(e3, [{ key: "push", value: function(r4) {\n                var n4 = { data: r4, next: null };\n                this.length > 0 ? this.tail.next = n4 : this.head = n4, this.tail = n4, ++this.length;\n              } }, { key: "unshift", value: function(r4) {\n                var n4 = { data: r4, next: this.head };\n                this.length === 0 && (this.tail = n4), this.head = n4, ++this.length;\n              } }, { key: "shift", value: function() {\n                if (this.length !== 0) {\n                  var r4 = this.head.data;\n                  return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, r4;\n                }\n              } }, { key: "clear", value: function() {\n                this.head = this.tail = null, this.length = 0;\n              } }, { key: "join", value: function(r4) {\n                if (this.length === 0) return "";\n                for (var n4 = this.head, i3 = "" + n4.data; n4 = n4.next; ) i3 += r4 + n4.data;\n                return i3;\n              } }, { key: "concat", value: function(r4) {\n                if (this.length === 0) return _R.alloc(0);\n                for (var n4 = _R.allocUnsafe(r4 >>> 0), i3 = this.head, a4 = 0; i3; ) W5t(i3.data, n4, a4), a4 += i3.data.length, i3 = i3.next;\n                return n4;\n              } }, { key: "consume", value: function(r4, n4) {\n                var i3;\n                return r4 < this.head.data.length ? (i3 = this.head.data.slice(0, r4), this.head.data = this.head.data.slice(r4)) : r4 === this.head.data.length ? i3 = this.shift() : i3 = n4 ? this._getString(r4) : this._getBuffer(r4), i3;\n              } }, { key: "first", value: function() {\n                return this.head.data;\n              } }, { key: "_getString", value: function(r4) {\n                var n4 = this.head, i3 = 1, a4 = n4.data;\n                for (r4 -= a4.length; n4 = n4.next; ) {\n                  var o4 = n4.data, s3 = r4 > o4.length ? o4.length : r4;\n                  if (s3 === o4.length ? a4 += o4 : a4 += o4.slice(0, r4), r4 -= s3, r4 === 0) {\n                    s3 === o4.length ? (++i3, n4.next ? this.head = n4.next : this.head = this.tail = null) : (this.head = n4, n4.data = o4.slice(s3));\n                    break;\n                  }\n                  ++i3;\n                }\n                return this.length -= i3, a4;\n              } }, { key: "_getBuffer", value: function(r4) {\n                var n4 = _R.allocUnsafe(r4), i3 = this.head, a4 = 1;\n                for (i3.data.copy(n4), r4 -= i3.data.length; i3 = i3.next; ) {\n                  var o4 = i3.data, s3 = r4 > o4.length ? o4.length : r4;\n                  if (o4.copy(n4, n4.length - r4, 0, s3), r4 -= s3, r4 === 0) {\n                    s3 === o4.length ? (++a4, i3.next ? this.head = i3.next : this.head = this.tail = null) : (this.head = i3, i3.data = o4.slice(s3));\n                    break;\n                  }\n                  ++a4;\n                }\n                return this.length -= a4, n4;\n              } }, { key: j5t, value: function(r4, n4) {\n                return aj(this, B5t({}, n4, { depth: 0, customInspect: false }));\n              } }]), e3;\n            })();\n          });\n          var sj = ye((Ohr, N5e) => {\n            "use strict";\n            function X5t(e3, t3) {\n              var r4 = this, n4 = this._readableState && this._readableState.destroyed, i3 = this._writableState && this._writableState.destroyed;\n              return n4 || i3 ? (t3 ? t3(e3) : e3 && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = true, process.nextTick(oj, this, e3)) : process.nextTick(oj, this, e3)), this) : (this._readableState && (this._readableState.destroyed = true), this._writableState && (this._writableState.destroyed = true), this._destroy(e3 || null, function(a4) {\n                !t3 && a4 ? r4._writableState ? r4._writableState.errorEmitted ? process.nextTick(xR, r4) : (r4._writableState.errorEmitted = true, process.nextTick(B5e, r4, a4)) : process.nextTick(B5e, r4, a4) : t3 ? (process.nextTick(xR, r4), t3(a4)) : process.nextTick(xR, r4);\n              }), this);\n            }\n            function B5e(e3, t3) {\n              oj(e3, t3), xR(e3);\n            }\n            function xR(e3) {\n              e3._writableState && !e3._writableState.emitClose || e3._readableState && !e3._readableState.emitClose || e3.emit("close");\n            }\n            function Z5t() {\n              this._readableState && (this._readableState.destroyed = false, this._readableState.reading = false, this._readableState.ended = false, this._readableState.endEmitted = false), this._writableState && (this._writableState.destroyed = false, this._writableState.ended = false, this._writableState.ending = false, this._writableState.finalCalled = false, this._writableState.prefinished = false, this._writableState.finished = false, this._writableState.errorEmitted = false);\n            }\n            function oj(e3, t3) {\n              e3.emit("error", t3);\n            }\n            function Y5t(e3, t3) {\n              var r4 = e3._readableState, n4 = e3._writableState;\n              r4 && r4.autoDestroy || n4 && n4.autoDestroy ? e3.destroy(t3) : e3.emit("error", t3);\n            }\n            N5e.exports = { destroy: X5t, undestroy: Z5t, errorOrDestroy: Y5t };\n          });\n          var p22 = ye((qhr, G5e) => {\n            "use strict";\n            function K5t(e3, t3) {\n              e3.prototype = Object.create(t3.prototype), e3.prototype.constructor = e3, e3.__proto__ = t3;\n            }\n            var V5e = {};\n            function Y0(e3, t3, r4) {\n              r4 || (r4 = Error);\n              function n4(a4, o4, s3) {\n                return typeof t3 == "string" ? t3 : t3(a4, o4, s3);\n              }\n              var i3 = (function(a4) {\n                K5t(o4, a4);\n                function o4(s3, l3, u4) {\n                  return a4.call(this, n4(s3, l3, u4)) || this;\n                }\n                return o4;\n              })(r4);\n              i3.prototype.name = r4.name, i3.prototype.code = e3, V5e[e3] = i3;\n            }\n            function U5e(e3, t3) {\n              if (Array.isArray(e3)) {\n                var r4 = e3.length;\n                return e3 = e3.map(function(n4) {\n                  return String(n4);\n                }), r4 > 2 ? "one of ".concat(t3, " ").concat(e3.slice(0, r4 - 1).join(", "), ", or ") + e3[r4 - 1] : r4 === 2 ? "one of ".concat(t3, " ").concat(e3[0], " or ").concat(e3[1]) : "of ".concat(t3, " ").concat(e3[0]);\n              } else return "of ".concat(t3, " ").concat(String(e3));\n            }\n            function J5t(e3, t3, r4) {\n              return e3.substr(!r4 || r4 < 0 ? 0 : +r4, t3.length) === t3;\n            }\n            function $5t(e3, t3, r4) {\n              return (r4 === void 0 || r4 > e3.length) && (r4 = e3.length), e3.substring(r4 - t3.length, r4) === t3;\n            }\n            function Q5t(e3, t3, r4) {\n              return typeof r4 != "number" && (r4 = 0), r4 + t3.length > e3.length ? false : e3.indexOf(t3, r4) !== -1;\n            }\n            Y0("ERR_INVALID_OPT_VALUE", function(e3, t3) {\n              return \'The value "\' + t3 + \'" is invalid for option "\' + e3 + \'"\';\n            }, TypeError);\n            Y0("ERR_INVALID_ARG_TYPE", function(e3, t3, r4) {\n              var n4;\n              typeof t3 == "string" && J5t(t3, "not ") ? (n4 = "must not be", t3 = t3.replace(/^not /, "")) : n4 = "must be";\n              var i3;\n              if ($5t(e3, " argument")) i3 = "The ".concat(e3, " ").concat(n4, " ").concat(U5e(t3, "type"));\n              else {\n                var a4 = Q5t(e3, ".") ? "property" : "argument";\n                i3 = \'The "\'.concat(e3, \'" \').concat(a4, " ").concat(n4, " ").concat(U5e(t3, "type"));\n              }\n              return i3 += ". Received type ".concat(typeof r4), i3;\n            }, TypeError);\n            Y0("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");\n            Y0("ERR_METHOD_NOT_IMPLEMENTED", function(e3) {\n              return "The " + e3 + " method is not implemented";\n            });\n            Y0("ERR_STREAM_PREMATURE_CLOSE", "Premature close");\n            Y0("ERR_STREAM_DESTROYED", function(e3) {\n              return "Cannot call " + e3 + " after a stream was destroyed";\n            });\n            Y0("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");\n            Y0("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");\n            Y0("ERR_STREAM_WRITE_AFTER_END", "write after end");\n            Y0("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);\n            Y0("ERR_UNKNOWN_ENCODING", function(e3) {\n              return "Unknown encoding: " + e3;\n            }, TypeError);\n            Y0("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");\n            G5e.exports.codes = V5e;\n          });\n          var lj = ye((Bhr, H5e) => {\n            "use strict";\n            var eSt = p22().codes.ERR_INVALID_OPT_VALUE;\n            function tSt(e3, t3, r4) {\n              return e3.highWaterMark != null ? e3.highWaterMark : t3 ? e3[r4] : null;\n            }\n            function rSt(e3, t3, r4, n4) {\n              var i3 = tSt(t3, n4, r4);\n              if (i3 != null) {\n                if (!(isFinite(i3) && Math.floor(i3) === i3) || i3 < 0) {\n                  var a4 = n4 ? r4 : "highWaterMark";\n                  throw new eSt(a4, i3);\n                }\n                return Math.floor(i3);\n              }\n              return e3.objectMode ? 16 : 16 * 1024;\n            }\n            H5e.exports = { getHighWaterMark: rSt };\n          });\n          var W5e = ye((Nhr, j5e) => {\n            j5e.exports = iSt;\n            function iSt(e3, t3) {\n              if (uj("noDeprecation")) return e3;\n              var r4 = false;\n              function n4() {\n                if (!r4) {\n                  if (uj("throwDeprecation")) throw new Error(t3);\n                  uj("traceDeprecation") ? console.trace(t3) : console.warn(t3), r4 = true;\n                }\n                return e3.apply(this, arguments);\n              }\n              return n4;\n            }\n            function uj(e3) {\n              try {\n                if (!window.localStorage) return false;\n              } catch (r4) {\n                return false;\n              }\n              var t3 = window.localStorage[e3];\n              return t3 == null ? false : String(t3).toLowerCase() === "true";\n            }\n          });\n          var hj = ye((Uhr, $5e) => {\n            "use strict";\n            $5e.exports = zh;\n            function Z5e(e3) {\n              var t3 = this;\n              this.next = null, this.entry = null, this.finish = function() {\n                LSt(t3, e3);\n              };\n            }\n            var hA;\n            zh.WritableState = Q4;\n            var nSt = { deprecate: W5e() }, Y5e = fH(), wR = c22().Buffer, aSt = window.Uint8Array || function() {\n            };\n            function oSt(e3) {\n              return wR.from(e3);\n            }\n            function sSt(e3) {\n              return wR.isBuffer(e3) || e3 instanceof aSt;\n            }\n            var fj = sj(), lSt = lj(), uSt = lSt.getHighWaterMark, R_ = p22().codes, cSt = R_.ERR_INVALID_ARG_TYPE, fSt = R_.ERR_METHOD_NOT_IMPLEMENTED, hSt = R_.ERR_MULTIPLE_CALLBACK, dSt = R_.ERR_STREAM_CANNOT_PIPE, vSt = R_.ERR_STREAM_DESTROYED, pSt = R_.ERR_STREAM_NULL_VALUES, gSt = R_.ERR_STREAM_WRITE_AFTER_END, mSt = R_.ERR_UNKNOWN_ENCODING, dA = fj.errorOrDestroy;\n            Uy()(zh, Y5e);\n            function ySt() {\n            }\n            function Q4(e3, t3, r4) {\n              hA = hA || g2(), e3 = e3 || {}, typeof r4 != "boolean" && (r4 = t3 instanceof hA), this.objectMode = !!e3.objectMode, r4 && (this.objectMode = this.objectMode || !!e3.writableObjectMode), this.highWaterMark = uSt(this, e3, "writableHighWaterMark", r4), this.finalCalled = false, this.needDrain = false, this.ending = false, this.ended = false, this.finished = false, this.destroyed = false;\n              var n4 = e3.decodeStrings === false;\n              this.decodeStrings = !n4, this.defaultEncoding = e3.defaultEncoding || "utf8", this.length = 0, this.writing = false, this.corked = 0, this.sync = true, this.bufferProcessing = false, this.onwrite = function(i3) {\n                SSt(t3, i3);\n              }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = false, this.errorEmitted = false, this.emitClose = e3.emitClose !== false, this.autoDestroy = !!e3.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new Z5e(this);\n            }\n            Q4.prototype.getBuffer = function() {\n              for (var t3 = this.bufferedRequest, r4 = []; t3; ) r4.push(t3), t3 = t3.next;\n              return r4;\n            };\n            (function() {\n              try {\n                Object.defineProperty(Q4.prototype, "buffer", { get: nSt.deprecate(function() {\n                  return this.getBuffer();\n                }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });\n              } catch (e3) {\n              }\n            })();\n            var bR;\n            typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (bR = Function.prototype[Symbol.hasInstance], Object.defineProperty(zh, Symbol.hasInstance, { value: function(t3) {\n              return bR.call(this, t3) ? true : this !== zh ? false : t3 && t3._writableState instanceof Q4;\n            } })) : bR = function(t3) {\n              return t3 instanceof this;\n            };\n            function zh(e3) {\n              hA = hA || g2();\n              var t3 = this instanceof hA;\n              if (!t3 && !bR.call(zh, this)) return new zh(e3);\n              this._writableState = new Q4(e3, this, t3), this.writable = true, e3 && (typeof e3.write == "function" && (this._write = e3.write), typeof e3.writev == "function" && (this._writev = e3.writev), typeof e3.destroy == "function" && (this._destroy = e3.destroy), typeof e3.final == "function" && (this._final = e3.final)), Y5e.call(this);\n            }\n            zh.prototype.pipe = function() {\n              dA(this, new dSt());\n            };\n            function _St(e3, t3) {\n              var r4 = new gSt();\n              dA(e3, r4), process.nextTick(t3, r4);\n            }\n            function xSt(e3, t3, r4, n4) {\n              var i3;\n              return r4 === null ? i3 = new pSt() : typeof r4 != "string" && !t3.objectMode && (i3 = new cSt("chunk", ["string", "Buffer"], r4)), i3 ? (dA(e3, i3), process.nextTick(n4, i3), false) : true;\n            }\n            zh.prototype.write = function(e3, t3, r4) {\n              var n4 = this._writableState, i3 = false, a4 = !n4.objectMode && sSt(e3);\n              return a4 && !wR.isBuffer(e3) && (e3 = oSt(e3)), typeof t3 == "function" && (r4 = t3, t3 = null), a4 ? t3 = "buffer" : t3 || (t3 = n4.defaultEncoding), typeof r4 != "function" && (r4 = ySt), n4.ending ? _St(this, r4) : (a4 || xSt(this, n4, e3, r4)) && (n4.pendingcb++, i3 = wSt(this, n4, a4, e3, t3, r4)), i3;\n            };\n            zh.prototype.cork = function() {\n              this._writableState.corked++;\n            };\n            zh.prototype.uncork = function() {\n              var e3 = this._writableState;\n              e3.corked && (e3.corked--, !e3.writing && !e3.corked && !e3.bufferProcessing && e3.bufferedRequest && K5e(this, e3));\n            };\n            zh.prototype.setDefaultEncoding = function(t3) {\n              if (typeof t3 == "string" && (t3 = t3.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((t3 + "").toLowerCase()) > -1)) throw new mSt(t3);\n              return this._writableState.defaultEncoding = t3, this;\n            };\n            Object.defineProperty(zh.prototype, "writableBuffer", { enumerable: false, get: function() {\n              return this._writableState && this._writableState.getBuffer();\n            } });\n            function bSt(e3, t3, r4) {\n              return !e3.objectMode && e3.decodeStrings !== false && typeof t3 == "string" && (t3 = wR.from(t3, r4)), t3;\n            }\n            Object.defineProperty(zh.prototype, "writableHighWaterMark", { enumerable: false, get: function() {\n              return this._writableState.highWaterMark;\n            } });\n            function wSt(e3, t3, r4, n4, i3, a4) {\n              if (!r4) {\n                var o4 = bSt(t3, n4, i3);\n                n4 !== o4 && (r4 = true, i3 = "buffer", n4 = o4);\n              }\n              var s3 = t3.objectMode ? 1 : n4.length;\n              t3.length += s3;\n              var l3 = t3.length < t3.highWaterMark;\n              if (l3 || (t3.needDrain = true), t3.writing || t3.corked) {\n                var u4 = t3.lastBufferedRequest;\n                t3.lastBufferedRequest = { chunk: n4, encoding: i3, isBuf: r4, callback: a4, next: null }, u4 ? u4.next = t3.lastBufferedRequest : t3.bufferedRequest = t3.lastBufferedRequest, t3.bufferedRequestCount += 1;\n              } else cj(e3, t3, false, s3, n4, i3, a4);\n              return l3;\n            }\n            function cj(e3, t3, r4, n4, i3, a4, o4) {\n              t3.writelen = n4, t3.writecb = o4, t3.writing = true, t3.sync = true, t3.destroyed ? t3.onwrite(new vSt("write")) : r4 ? e3._writev(i3, t3.onwrite) : e3._write(i3, a4, t3.onwrite), t3.sync = false;\n            }\n            function TSt(e3, t3, r4, n4, i3) {\n              --t3.pendingcb, r4 ? (process.nextTick(i3, n4), process.nextTick($4, e3, t3), e3._writableState.errorEmitted = true, dA(e3, n4)) : (i3(n4), e3._writableState.errorEmitted = true, dA(e3, n4), $4(e3, t3));\n            }\n            function ASt(e3) {\n              e3.writing = false, e3.writecb = null, e3.length -= e3.writelen, e3.writelen = 0;\n            }\n            function SSt(e3, t3) {\n              var r4 = e3._writableState, n4 = r4.sync, i3 = r4.writecb;\n              if (typeof i3 != "function") throw new hSt();\n              if (ASt(r4), t3) TSt(e3, r4, n4, t3, i3);\n              else {\n                var a4 = J5e(r4) || e3.destroyed;\n                !a4 && !r4.corked && !r4.bufferProcessing && r4.bufferedRequest && K5e(e3, r4), n4 ? process.nextTick(X5e, e3, r4, a4, i3) : X5e(e3, r4, a4, i3);\n              }\n            }\n            function X5e(e3, t3, r4, n4) {\n              r4 || MSt(e3, t3), t3.pendingcb--, n4(), $4(e3, t3);\n            }\n            function MSt(e3, t3) {\n              t3.length === 0 && t3.needDrain && (t3.needDrain = false, e3.emit("drain"));\n            }\n            function K5e(e3, t3) {\n              t3.bufferProcessing = true;\n              var r4 = t3.bufferedRequest;\n              if (e3._writev && r4 && r4.next) {\n                var n4 = t3.bufferedRequestCount, i3 = new Array(n4), a4 = t3.corkedRequestsFree;\n                a4.entry = r4;\n                for (var o4 = 0, s3 = true; r4; ) i3[o4] = r4, r4.isBuf || (s3 = false), r4 = r4.next, o4 += 1;\n                i3.allBuffers = s3, cj(e3, t3, true, t3.length, i3, "", a4.finish), t3.pendingcb++, t3.lastBufferedRequest = null, a4.next ? (t3.corkedRequestsFree = a4.next, a4.next = null) : t3.corkedRequestsFree = new Z5e(t3), t3.bufferedRequestCount = 0;\n              } else {\n                for (; r4; ) {\n                  var l3 = r4.chunk, u4 = r4.encoding, c5 = r4.callback, f4 = t3.objectMode ? 1 : l3.length;\n                  if (cj(e3, t3, false, f4, l3, u4, c5), r4 = r4.next, t3.bufferedRequestCount--, t3.writing) break;\n                }\n                r4 === null && (t3.lastBufferedRequest = null);\n              }\n              t3.bufferedRequest = r4, t3.bufferProcessing = false;\n            }\n            zh.prototype._write = function(e3, t3, r4) {\n              r4(new fSt("_write()"));\n            };\n            zh.prototype._writev = null;\n            zh.prototype.end = function(e3, t3, r4) {\n              var n4 = this._writableState;\n              return typeof e3 == "function" ? (r4 = e3, e3 = null, t3 = null) : typeof t3 == "function" && (r4 = t3, t3 = null), e3 != null && this.write(e3, t3), n4.corked && (n4.corked = 1, this.uncork()), n4.ending || CSt(this, n4, r4), this;\n            };\n            Object.defineProperty(zh.prototype, "writableLength", { enumerable: false, get: function() {\n              return this._writableState.length;\n            } });\n            function J5e(e3) {\n              return e3.ending && e3.length === 0 && e3.bufferedRequest === null && !e3.finished && !e3.writing;\n            }\n            function ESt(e3, t3) {\n              e3._final(function(r4) {\n                t3.pendingcb--, r4 && dA(e3, r4), t3.prefinished = true, e3.emit("prefinish"), $4(e3, t3);\n              });\n            }\n            function kSt(e3, t3) {\n              !t3.prefinished && !t3.finalCalled && (typeof e3._final == "function" && !t3.destroyed ? (t3.pendingcb++, t3.finalCalled = true, process.nextTick(ESt, e3, t3)) : (t3.prefinished = true, e3.emit("prefinish")));\n            }\n            function $4(e3, t3) {\n              var r4 = J5e(t3);\n              if (r4 && (kSt(e3, t3), t3.pendingcb === 0 && (t3.finished = true, e3.emit("finish"), t3.autoDestroy))) {\n                var n4 = e3._readableState;\n                (!n4 || n4.autoDestroy && n4.endEmitted) && e3.destroy();\n              }\n              return r4;\n            }\n            function CSt(e3, t3, r4) {\n              t3.ending = true, $4(e3, t3), r4 && (t3.finished ? process.nextTick(r4) : e3.once("finish", r4)), t3.ended = true, e3.writable = false;\n            }\n            function LSt(e3, t3, r4) {\n              var n4 = e3.entry;\n              for (e3.entry = null; n4; ) {\n                var i3 = n4.callback;\n                t3.pendingcb--, i3(r4), n4 = n4.next;\n              }\n              t3.corkedRequestsFree.next = e3;\n            }\n            Object.defineProperty(zh.prototype, "destroyed", { enumerable: false, get: function() {\n              return this._writableState === void 0 ? false : this._writableState.destroyed;\n            }, set: function(t3) {\n              this._writableState && (this._writableState.destroyed = t3);\n            } });\n            zh.prototype.destroy = fj.destroy;\n            zh.prototype._undestroy = fj.undestroy;\n            zh.prototype._destroy = function(e3, t3) {\n              t3(e3);\n            };\n          });\n          var g2 = ye((Vhr, eSe) => {\n            "use strict";\n            var PSt = Object.keys || function(e3) {\n              var t3 = [];\n              for (var r4 in e3) t3.push(r4);\n              return t3;\n            };\n            eSe.exports = Bm;\n            var Q5e = pj(), vj = hj();\n            Uy()(Bm, Q5e);\n            for (dj = PSt(vj.prototype), TR = 0; TR < dj.length; TR++) AR = dj[TR], Bm.prototype[AR] || (Bm.prototype[AR] = vj.prototype[AR]);\n            var dj, AR, TR;\n            function Bm(e3) {\n              if (!(this instanceof Bm)) return new Bm(e3);\n              Q5e.call(this, e3), vj.call(this, e3), this.allowHalfOpen = true, e3 && (e3.readable === false && (this.readable = false), e3.writable === false && (this.writable = false), e3.allowHalfOpen === false && (this.allowHalfOpen = false, this.once("end", ISt)));\n            }\n            Object.defineProperty(Bm.prototype, "writableHighWaterMark", { enumerable: false, get: function() {\n              return this._writableState.highWaterMark;\n            } });\n            Object.defineProperty(Bm.prototype, "writableBuffer", { enumerable: false, get: function() {\n              return this._writableState && this._writableState.getBuffer();\n            } });\n            Object.defineProperty(Bm.prototype, "writableLength", { enumerable: false, get: function() {\n              return this._writableState.length;\n            } });\n            function ISt() {\n              this._writableState.ended || process.nextTick(RSt, this);\n            }\n            function RSt(e3) {\n              e3.end();\n            }\n            Object.defineProperty(Bm.prototype, "destroyed", { enumerable: false, get: function() {\n              return this._readableState === void 0 || this._writableState === void 0 ? false : this._readableState.destroyed && this._writableState.destroyed;\n            }, set: function(t3) {\n              this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = t3, this._writableState.destroyed = t3);\n            } });\n          });\n          var iSe = ye((gj, rSe) => {\n            var SR = c22(), Nm = SR.Buffer;\n            function tSe(e3, t3) {\n              for (var r4 in e3) t3[r4] = e3[r4];\n            }\n            Nm.from && Nm.alloc && Nm.allocUnsafe && Nm.allocUnsafeSlow ? rSe.exports = SR : (tSe(SR, gj), gj.Buffer = m22);\n            function m22(e3, t3, r4) {\n              return Nm(e3, t3, r4);\n            }\n            m22.prototype = Object.create(Nm.prototype);\n            tSe(Nm, m22);\n            m22.from = function(e3, t3, r4) {\n              if (typeof e3 == "number") throw new TypeError("Argument must not be a number");\n              return Nm(e3, t3, r4);\n            };\n            m22.alloc = function(e3, t3, r4) {\n              if (typeof e3 != "number") throw new TypeError("Argument must be a number");\n              var n4 = Nm(e3);\n              return t3 !== void 0 ? typeof r4 == "string" ? n4.fill(t3, r4) : n4.fill(t3) : n4.fill(0), n4;\n            };\n            m22.allocUnsafe = function(e3) {\n              if (typeof e3 != "number") throw new TypeError("Argument must be a number");\n              return Nm(e3);\n            };\n            m22.allocUnsafeSlow = function(e3) {\n              if (typeof e3 != "number") throw new TypeError("Argument must be a number");\n              return SR.SlowBuffer(e3);\n            };\n          });\n          var _j = ye((aSe) => {\n            "use strict";\n            var yj = iSe().Buffer, nSe = yj.isEncoding || function(e3) {\n              switch (e3 = "" + e3, e3 && e3.toLowerCase()) {\n                case "hex":\n                case "utf8":\n                case "utf-8":\n                case "ascii":\n                case "binary":\n                case "base64":\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                case "raw":\n                  return true;\n                default:\n                  return false;\n              }\n            };\n            function DSt(e3) {\n              if (!e3) return "utf8";\n              for (var t3; ; ) switch (e3) {\n                case "utf8":\n                case "utf-8":\n                  return "utf8";\n                case "ucs2":\n                case "ucs-2":\n                case "utf16le":\n                case "utf-16le":\n                  return "utf16le";\n                case "latin1":\n                case "binary":\n                  return "latin1";\n                case "base64":\n                case "ascii":\n                case "hex":\n                  return e3;\n                default:\n                  if (t3) return;\n                  e3 = ("" + e3).toLowerCase(), t3 = true;\n              }\n            }\n            function FSt(e3) {\n              var t3 = DSt(e3);\n              if (typeof t3 != "string" && (yj.isEncoding === nSe || !nSe(e3))) throw new Error("Unknown encoding: " + e3);\n              return t3 || e3;\n            }\n            aSe.StringDecoder = eE;\n            function eE(e3) {\n              this.encoding = FSt(e3);\n              var t3;\n              switch (this.encoding) {\n                case "utf16le":\n                  this.text = USt, this.end = VSt, t3 = 4;\n                  break;\n                case "utf8":\n                  this.fillLast = qSt, t3 = 4;\n                  break;\n                case "base64":\n                  this.text = GSt, this.end = HSt, t3 = 3;\n                  break;\n                default:\n                  this.write = jSt, this.end = WSt;\n                  return;\n              }\n              this.lastNeed = 0, this.lastTotal = 0, this.lastChar = yj.allocUnsafe(t3);\n            }\n            eE.prototype.write = function(e3) {\n              if (e3.length === 0) return "";\n              var t3, r4;\n              if (this.lastNeed) {\n                if (t3 = this.fillLast(e3), t3 === void 0) return "";\n                r4 = this.lastNeed, this.lastNeed = 0;\n              } else r4 = 0;\n              return r4 < e3.length ? t3 ? t3 + this.text(e3, r4) : this.text(e3, r4) : t3 || "";\n            };\n            eE.prototype.end = NSt;\n            eE.prototype.text = BSt;\n            eE.prototype.fillLast = function(e3) {\n              if (this.lastNeed <= e3.length) return e3.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);\n              e3.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, e3.length), this.lastNeed -= e3.length;\n            };\n            function mj(e3) {\n              return e3 <= 127 ? 0 : e3 >> 5 === 6 ? 2 : e3 >> 4 === 14 ? 3 : e3 >> 3 === 30 ? 4 : e3 >> 6 === 2 ? -1 : -2;\n            }\n            function zSt(e3, t3, r4) {\n              var n4 = t3.length - 1;\n              if (n4 < r4) return 0;\n              var i3 = mj(t3[n4]);\n              return i3 >= 0 ? (i3 > 0 && (e3.lastNeed = i3 - 1), i3) : --n4 < r4 || i3 === -2 ? 0 : (i3 = mj(t3[n4]), i3 >= 0 ? (i3 > 0 && (e3.lastNeed = i3 - 2), i3) : --n4 < r4 || i3 === -2 ? 0 : (i3 = mj(t3[n4]), i3 >= 0 ? (i3 > 0 && (i3 === 2 ? i3 = 0 : e3.lastNeed = i3 - 3), i3) : 0));\n            }\n            function OSt(e3, t3, r4) {\n              if ((t3[0] & 192) !== 128) return e3.lastNeed = 0, "\\uFFFD";\n              if (e3.lastNeed > 1 && t3.length > 1) {\n                if ((t3[1] & 192) !== 128) return e3.lastNeed = 1, "\\uFFFD";\n                if (e3.lastNeed > 2 && t3.length > 2 && (t3[2] & 192) !== 128) return e3.lastNeed = 2, "\\uFFFD";\n              }\n            }\n            function qSt(e3) {\n              var t3 = this.lastTotal - this.lastNeed, r4 = OSt(this, e3, t3);\n              if (r4 !== void 0) return r4;\n              if (this.lastNeed <= e3.length) return e3.copy(this.lastChar, t3, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);\n              e3.copy(this.lastChar, t3, 0, e3.length), this.lastNeed -= e3.length;\n            }\n            function BSt(e3, t3) {\n              var r4 = zSt(this, e3, t3);\n              if (!this.lastNeed) return e3.toString("utf8", t3);\n              this.lastTotal = r4;\n              var n4 = e3.length - (r4 - this.lastNeed);\n              return e3.copy(this.lastChar, 0, n4), e3.toString("utf8", t3, n4);\n            }\n            function NSt(e3) {\n              var t3 = e3 && e3.length ? this.write(e3) : "";\n              return this.lastNeed ? t3 + "\\uFFFD" : t3;\n            }\n            function USt(e3, t3) {\n              if ((e3.length - t3) % 2 === 0) {\n                var r4 = e3.toString("utf16le", t3);\n                if (r4) {\n                  var n4 = r4.charCodeAt(r4.length - 1);\n                  if (n4 >= 55296 && n4 <= 56319) return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = e3[e3.length - 2], this.lastChar[1] = e3[e3.length - 1], r4.slice(0, -1);\n                }\n                return r4;\n              }\n              return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = e3[e3.length - 1], e3.toString("utf16le", t3, e3.length - 1);\n            }\n            function VSt(e3) {\n              var t3 = e3 && e3.length ? this.write(e3) : "";\n              if (this.lastNeed) {\n                var r4 = this.lastTotal - this.lastNeed;\n                return t3 + this.lastChar.toString("utf16le", 0, r4);\n              }\n              return t3;\n            }\n            function GSt(e3, t3) {\n              var r4 = (e3.length - t3) % 3;\n              return r4 === 0 ? e3.toString("base64", t3) : (this.lastNeed = 3 - r4, this.lastTotal = 3, r4 === 1 ? this.lastChar[0] = e3[e3.length - 1] : (this.lastChar[0] = e3[e3.length - 2], this.lastChar[1] = e3[e3.length - 1]), e3.toString("base64", t3, e3.length - r4));\n            }\n            function HSt(e3) {\n              var t3 = e3 && e3.length ? this.write(e3) : "";\n              return this.lastNeed ? t3 + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : t3;\n            }\n            function jSt(e3) {\n              return e3.toString(this.encoding);\n            }\n            function WSt(e3) {\n              return e3 && e3.length ? this.write(e3) : "";\n            }\n          });\n          var MR = ye((Hhr, lSe) => {\n            "use strict";\n            var oSe = p22().codes.ERR_STREAM_PREMATURE_CLOSE;\n            function XSt(e3) {\n              var t3 = false;\n              return function() {\n                if (!t3) {\n                  t3 = true;\n                  for (var r4 = arguments.length, n4 = new Array(r4), i3 = 0; i3 < r4; i3++) n4[i3] = arguments[i3];\n                  e3.apply(this, n4);\n                }\n              };\n            }\n            function ZSt() {\n            }\n            function YSt(e3) {\n              return e3.setHeader && typeof e3.abort == "function";\n            }\n            function sSe(e3, t3, r4) {\n              if (typeof t3 == "function") return sSe(e3, null, t3);\n              t3 || (t3 = {}), r4 = XSt(r4 || ZSt);\n              var n4 = t3.readable || t3.readable !== false && e3.readable, i3 = t3.writable || t3.writable !== false && e3.writable, a4 = function() {\n                e3.writable || s3();\n              }, o4 = e3._writableState && e3._writableState.finished, s3 = function() {\n                i3 = false, o4 = true, n4 || r4.call(e3);\n              }, l3 = e3._readableState && e3._readableState.endEmitted, u4 = function() {\n                n4 = false, l3 = true, i3 || r4.call(e3);\n              }, c5 = function(v3) {\n                r4.call(e3, v3);\n              }, f4 = function() {\n                var v3;\n                if (n4 && !l3) return (!e3._readableState || !e3._readableState.ended) && (v3 = new oSe()), r4.call(e3, v3);\n                if (i3 && !o4) return (!e3._writableState || !e3._writableState.ended) && (v3 = new oSe()), r4.call(e3, v3);\n              }, h3 = function() {\n                e3.req.on("finish", s3);\n              };\n              return YSt(e3) ? (e3.on("complete", s3), e3.on("abort", f4), e3.req ? h3() : e3.on("request", h3)) : i3 && !e3._writableState && (e3.on("end", a4), e3.on("close", a4)), e3.on("end", u4), e3.on("finish", s3), t3.error !== false && e3.on("error", c5), e3.on("close", f4), function() {\n                e3.removeListener("complete", s3), e3.removeListener("abort", f4), e3.removeListener("request", h3), e3.req && e3.req.removeListener("finish", s3), e3.removeListener("end", a4), e3.removeListener("close", a4), e3.removeListener("finish", s3), e3.removeListener("end", u4), e3.removeListener("error", c5), e3.removeListener("close", f4);\n              };\n            }\n            lSe.exports = sSe;\n          });\n          var cSe = ye((jhr, uSe) => {\n            "use strict";\n            var ER;\n            function D_(e3, t3, r4) {\n              return t3 in e3 ? Object.defineProperty(e3, t3, { value: r4, enumerable: true, configurable: true, writable: true }) : e3[t3] = r4, e3;\n            }\n            var KSt = MR(), F_ = /* @__PURE__ */ Symbol("lastResolve"), y22 = /* @__PURE__ */ Symbol("lastReject"), tE = /* @__PURE__ */ Symbol("error"), kR = /* @__PURE__ */ Symbol("ended"), _2 = /* @__PURE__ */ Symbol("lastPromise"), xj = /* @__PURE__ */ Symbol("handlePromise"), x2 = /* @__PURE__ */ Symbol("stream");\n            function z_(e3, t3) {\n              return { value: e3, done: t3 };\n            }\n            function JSt(e3) {\n              var t3 = e3[F_];\n              if (t3 !== null) {\n                var r4 = e3[x2].read();\n                r4 !== null && (e3[_2] = null, e3[F_] = null, e3[y22] = null, t3(z_(r4, false)));\n              }\n            }\n            function $St(e3) {\n              process.nextTick(JSt, e3);\n            }\n            function QSt(e3, t3) {\n              return function(r4, n4) {\n                e3.then(function() {\n                  if (t3[kR]) {\n                    r4(z_(void 0, true));\n                    return;\n                  }\n                  t3[xj](r4, n4);\n                }, n4);\n              };\n            }\n            var eMt = Object.getPrototypeOf(function() {\n            }), tMt = Object.setPrototypeOf((ER = { get stream() {\n              return this[x2];\n            }, next: function() {\n              var t3 = this, r4 = this[tE];\n              if (r4 !== null) return Promise.reject(r4);\n              if (this[kR]) return Promise.resolve(z_(void 0, true));\n              if (this[x2].destroyed) return new Promise(function(o4, s3) {\n                process.nextTick(function() {\n                  t3[tE] ? s3(t3[tE]) : o4(z_(void 0, true));\n                });\n              });\n              var n4 = this[_2], i3;\n              if (n4) i3 = new Promise(QSt(n4, this));\n              else {\n                var a4 = this[x2].read();\n                if (a4 !== null) return Promise.resolve(z_(a4, false));\n                i3 = new Promise(this[xj]);\n              }\n              return this[_2] = i3, i3;\n            } }, D_(ER, Symbol.asyncIterator, function() {\n              return this;\n            }), D_(ER, "return", function() {\n              var t3 = this;\n              return new Promise(function(r4, n4) {\n                t3[x2].destroy(null, function(i3) {\n                  if (i3) {\n                    n4(i3);\n                    return;\n                  }\n                  r4(z_(void 0, true));\n                });\n              });\n            }), ER), eMt), rMt = function(t3) {\n              var r4, n4 = Object.create(tMt, (r4 = {}, D_(r4, x2, { value: t3, writable: true }), D_(r4, F_, { value: null, writable: true }), D_(r4, y22, { value: null, writable: true }), D_(r4, tE, { value: null, writable: true }), D_(r4, kR, { value: t3._readableState.endEmitted, writable: true }), D_(r4, xj, { value: function(a4, o4) {\n                var s3 = n4[x2].read();\n                s3 ? (n4[_2] = null, n4[F_] = null, n4[y22] = null, a4(z_(s3, false))) : (n4[F_] = a4, n4[y22] = o4);\n              }, writable: true }), r4));\n              return n4[_2] = null, KSt(t3, function(i3) {\n                if (i3 && i3.code !== "ERR_STREAM_PREMATURE_CLOSE") {\n                  var a4 = n4[y22];\n                  a4 !== null && (n4[_2] = null, n4[F_] = null, n4[y22] = null, a4(i3)), n4[tE] = i3;\n                  return;\n                }\n                var o4 = n4[F_];\n                o4 !== null && (n4[_2] = null, n4[F_] = null, n4[y22] = null, o4(z_(void 0, true))), n4[kR] = true;\n              }), t3.on("readable", $St.bind(null, n4)), n4;\n            };\n            uSe.exports = rMt;\n          });\n          var hSe = ye((Whr, fSe) => {\n            fSe.exports = function() {\n              throw new Error("Readable.from is not available in the browser");\n            };\n          });\n          var pj = ye((Zhr, wSe) => {\n            "use strict";\n            wSe.exports = Bu;\n            var vA;\n            Bu.ReadableState = gSe;\n            var Xhr = pb().EventEmitter, pSe = function(t3, r4) {\n              return t3.listeners(r4).length;\n            }, iE = fH(), CR = c22().Buffer, iMt = window.Uint8Array || function() {\n            };\n            function nMt(e3) {\n              return CR.from(e3);\n            }\n            function aMt(e3) {\n              return CR.isBuffer(e3) || e3 instanceof iMt;\n            }\n            var bj = nj(), nu;\n            bj && bj.debuglog ? nu = bj.debuglog("stream") : nu = function() {\n            };\n            var oMt = q5e(), kj = sj(), sMt = lj(), lMt = sMt.getHighWaterMark, LR = p22().codes, uMt = LR.ERR_INVALID_ARG_TYPE, cMt = LR.ERR_STREAM_PUSH_AFTER_EOF, fMt = LR.ERR_METHOD_NOT_IMPLEMENTED, hMt = LR.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, pA, wj, Tj;\n            Uy()(Bu, iE);\n            var rE = kj.errorOrDestroy, Aj = ["error", "close", "destroy", "pause", "resume"];\n            function dMt(e3, t3, r4) {\n              if (typeof e3.prependListener == "function") return e3.prependListener(t3, r4);\n              !e3._events || !e3._events[t3] ? e3.on(t3, r4) : Array.isArray(e3._events[t3]) ? e3._events[t3].unshift(r4) : e3._events[t3] = [r4, e3._events[t3]];\n            }\n            function gSe(e3, t3, r4) {\n              vA = vA || g2(), e3 = e3 || {}, typeof r4 != "boolean" && (r4 = t3 instanceof vA), this.objectMode = !!e3.objectMode, r4 && (this.objectMode = this.objectMode || !!e3.readableObjectMode), this.highWaterMark = lMt(this, e3, "readableHighWaterMark", r4), this.buffer = new oMt(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = false, this.endEmitted = false, this.reading = false, this.sync = true, this.needReadable = false, this.emittedReadable = false, this.readableListening = false, this.resumeScheduled = false, this.paused = true, this.emitClose = e3.emitClose !== false, this.autoDestroy = !!e3.autoDestroy, this.destroyed = false, this.defaultEncoding = e3.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = false, this.decoder = null, this.encoding = null, e3.encoding && (pA || (pA = _j().StringDecoder), this.decoder = new pA(e3.encoding), this.encoding = e3.encoding);\n            }\n            function Bu(e3) {\n              if (vA = vA || g2(), !(this instanceof Bu)) return new Bu(e3);\n              var t3 = this instanceof vA;\n              this._readableState = new gSe(e3, this, t3), this.readable = true, e3 && (typeof e3.read == "function" && (this._read = e3.read), typeof e3.destroy == "function" && (this._destroy = e3.destroy)), iE.call(this);\n            }\n            Object.defineProperty(Bu.prototype, "destroyed", { enumerable: false, get: function() {\n              return this._readableState === void 0 ? false : this._readableState.destroyed;\n            }, set: function(t3) {\n              this._readableState && (this._readableState.destroyed = t3);\n            } });\n            Bu.prototype.destroy = kj.destroy;\n            Bu.prototype._undestroy = kj.undestroy;\n            Bu.prototype._destroy = function(e3, t3) {\n              t3(e3);\n            };\n            Bu.prototype.push = function(e3, t3) {\n              var r4 = this._readableState, n4;\n              return r4.objectMode ? n4 = true : typeof e3 == "string" && (t3 = t3 || r4.defaultEncoding, t3 !== r4.encoding && (e3 = CR.from(e3, t3), t3 = ""), n4 = true), mSe(this, e3, t3, false, n4);\n            };\n            Bu.prototype.unshift = function(e3) {\n              return mSe(this, e3, null, true, false);\n            };\n            function mSe(e3, t3, r4, n4, i3) {\n              nu("readableAddChunk", t3);\n              var a4 = e3._readableState;\n              if (t3 === null) a4.reading = false, gMt(e3, a4);\n              else {\n                var o4;\n                if (i3 || (o4 = vMt(a4, t3)), o4) rE(e3, o4);\n                else if (a4.objectMode || t3 && t3.length > 0) if (typeof t3 != "string" && !a4.objectMode && Object.getPrototypeOf(t3) !== CR.prototype && (t3 = nMt(t3)), n4) a4.endEmitted ? rE(e3, new hMt()) : Sj(e3, a4, t3, true);\n                else if (a4.ended) rE(e3, new cMt());\n                else {\n                  if (a4.destroyed) return false;\n                  a4.reading = false, a4.decoder && !r4 ? (t3 = a4.decoder.write(t3), a4.objectMode || t3.length !== 0 ? Sj(e3, a4, t3, false) : Ej(e3, a4)) : Sj(e3, a4, t3, false);\n                }\n                else n4 || (a4.reading = false, Ej(e3, a4));\n              }\n              return !a4.ended && (a4.length < a4.highWaterMark || a4.length === 0);\n            }\n            function Sj(e3, t3, r4, n4) {\n              t3.flowing && t3.length === 0 && !t3.sync ? (t3.awaitDrain = 0, e3.emit("data", r4)) : (t3.length += t3.objectMode ? 1 : r4.length, n4 ? t3.buffer.unshift(r4) : t3.buffer.push(r4), t3.needReadable && PR(e3)), Ej(e3, t3);\n            }\n            function vMt(e3, t3) {\n              var r4;\n              return !aMt(t3) && typeof t3 != "string" && t3 !== void 0 && !e3.objectMode && (r4 = new uMt("chunk", ["string", "Buffer", "Uint8Array"], t3)), r4;\n            }\n            Bu.prototype.isPaused = function() {\n              return this._readableState.flowing === false;\n            };\n            Bu.prototype.setEncoding = function(e3) {\n              pA || (pA = _j().StringDecoder);\n              var t3 = new pA(e3);\n              this._readableState.decoder = t3, this._readableState.encoding = this._readableState.decoder.encoding;\n              for (var r4 = this._readableState.buffer.head, n4 = ""; r4 !== null; ) n4 += t3.write(r4.data), r4 = r4.next;\n              return this._readableState.buffer.clear(), n4 !== "" && this._readableState.buffer.push(n4), this._readableState.length = n4.length, this;\n            };\n            var dSe = 1073741824;\n            function pMt(e3) {\n              return e3 >= dSe ? e3 = dSe : (e3--, e3 |= e3 >>> 1, e3 |= e3 >>> 2, e3 |= e3 >>> 4, e3 |= e3 >>> 8, e3 |= e3 >>> 16, e3++), e3;\n            }\n            function vSe(e3, t3) {\n              return e3 <= 0 || t3.length === 0 && t3.ended ? 0 : t3.objectMode ? 1 : e3 !== e3 ? t3.flowing && t3.length ? t3.buffer.head.data.length : t3.length : (e3 > t3.highWaterMark && (t3.highWaterMark = pMt(e3)), e3 <= t3.length ? e3 : t3.ended ? t3.length : (t3.needReadable = true, 0));\n            }\n            Bu.prototype.read = function(e3) {\n              nu("read", e3), e3 = parseInt(e3, 10);\n              var t3 = this._readableState, r4 = e3;\n              if (e3 !== 0 && (t3.emittedReadable = false), e3 === 0 && t3.needReadable && ((t3.highWaterMark !== 0 ? t3.length >= t3.highWaterMark : t3.length > 0) || t3.ended)) return nu("read: emitReadable", t3.length, t3.ended), t3.length === 0 && t3.ended ? Mj(this) : PR(this), null;\n              if (e3 = vSe(e3, t3), e3 === 0 && t3.ended) return t3.length === 0 && Mj(this), null;\n              var n4 = t3.needReadable;\n              nu("need readable", n4), (t3.length === 0 || t3.length - e3 < t3.highWaterMark) && (n4 = true, nu("length less than watermark", n4)), t3.ended || t3.reading ? (n4 = false, nu("reading or ended", n4)) : n4 && (nu("do read"), t3.reading = true, t3.sync = true, t3.length === 0 && (t3.needReadable = true), this._read(t3.highWaterMark), t3.sync = false, t3.reading || (e3 = vSe(r4, t3)));\n              var i3;\n              return e3 > 0 ? i3 = xSe(e3, t3) : i3 = null, i3 === null ? (t3.needReadable = t3.length <= t3.highWaterMark, e3 = 0) : (t3.length -= e3, t3.awaitDrain = 0), t3.length === 0 && (t3.ended || (t3.needReadable = true), r4 !== e3 && t3.ended && Mj(this)), i3 !== null && this.emit("data", i3), i3;\n            };\n            function gMt(e3, t3) {\n              if (nu("onEofChunk"), !t3.ended) {\n                if (t3.decoder) {\n                  var r4 = t3.decoder.end();\n                  r4 && r4.length && (t3.buffer.push(r4), t3.length += t3.objectMode ? 1 : r4.length);\n                }\n                t3.ended = true, t3.sync ? PR(e3) : (t3.needReadable = false, t3.emittedReadable || (t3.emittedReadable = true, ySe(e3)));\n              }\n            }\n            function PR(e3) {\n              var t3 = e3._readableState;\n              nu("emitReadable", t3.needReadable, t3.emittedReadable), t3.needReadable = false, t3.emittedReadable || (nu("emitReadable", t3.flowing), t3.emittedReadable = true, process.nextTick(ySe, e3));\n            }\n            function ySe(e3) {\n              var t3 = e3._readableState;\n              nu("emitReadable_", t3.destroyed, t3.length, t3.ended), !t3.destroyed && (t3.length || t3.ended) && (e3.emit("readable"), t3.emittedReadable = false), t3.needReadable = !t3.flowing && !t3.ended && t3.length <= t3.highWaterMark, Cj(e3);\n            }\n            function Ej(e3, t3) {\n              t3.readingMore || (t3.readingMore = true, process.nextTick(mMt, e3, t3));\n            }\n            function mMt(e3, t3) {\n              for (; !t3.reading && !t3.ended && (t3.length < t3.highWaterMark || t3.flowing && t3.length === 0); ) {\n                var r4 = t3.length;\n                if (nu("maybeReadMore read 0"), e3.read(0), r4 === t3.length) break;\n              }\n              t3.readingMore = false;\n            }\n            Bu.prototype._read = function(e3) {\n              rE(this, new fMt("_read()"));\n            };\n            Bu.prototype.pipe = function(e3, t3) {\n              var r4 = this, n4 = this._readableState;\n              switch (n4.pipesCount) {\n                case 0:\n                  n4.pipes = e3;\n                  break;\n                case 1:\n                  n4.pipes = [n4.pipes, e3];\n                  break;\n                default:\n                  n4.pipes.push(e3);\n                  break;\n              }\n              n4.pipesCount += 1, nu("pipe count=%d opts=%j", n4.pipesCount, t3);\n              var i3 = (!t3 || t3.end !== false) && e3 !== process.stdout && e3 !== process.stderr, a4 = i3 ? s3 : _2;\n              n4.endEmitted ? process.nextTick(a4) : r4.once("end", a4), e3.on("unpipe", o4);\n              function o4(b, p3) {\n                nu("onunpipe"), b === r4 && p3 && p3.hasUnpiped === false && (p3.hasUnpiped = true, c5());\n              }\n              function s3() {\n                nu("onend"), e3.end();\n              }\n              var l3 = yMt(r4);\n              e3.on("drain", l3);\n              var u4 = false;\n              function c5() {\n                nu("cleanup"), e3.removeListener("close", d3), e3.removeListener("finish", v3), e3.removeListener("drain", l3), e3.removeListener("error", h3), e3.removeListener("unpipe", o4), r4.removeListener("end", s3), r4.removeListener("end", _2), r4.removeListener("data", f4), u4 = true, n4.awaitDrain && (!e3._writableState || e3._writableState.needDrain) && l3();\n              }\n              r4.on("data", f4);\n              function f4(b) {\n                nu("ondata");\n                var p3 = e3.write(b);\n                nu("dest.write", p3), p3 === false && ((n4.pipesCount === 1 && n4.pipes === e3 || n4.pipesCount > 1 && bSe(n4.pipes, e3) !== -1) && !u4 && (nu("false write response, pause", n4.awaitDrain), n4.awaitDrain++), r4.pause());\n              }\n              function h3(b) {\n                nu("onerror", b), _2(), e3.removeListener("error", h3), pSe(e3, "error") === 0 && rE(e3, b);\n              }\n              dMt(e3, "error", h3);\n              function d3() {\n                e3.removeListener("finish", v3), _2();\n              }\n              e3.once("close", d3);\n              function v3() {\n                nu("onfinish"), e3.removeListener("close", d3), _2();\n              }\n              e3.once("finish", v3);\n              function _2() {\n                nu("unpipe"), r4.unpipe(e3);\n              }\n              return e3.emit("pipe", r4), n4.flowing || (nu("pipe resume"), r4.resume()), e3;\n            };\n            function yMt(e3) {\n              return function() {\n                var r4 = e3._readableState;\n                nu("pipeOnDrain", r4.awaitDrain), r4.awaitDrain && r4.awaitDrain--, r4.awaitDrain === 0 && pSe(e3, "data") && (r4.flowing = true, Cj(e3));\n              };\n            }\n            Bu.prototype.unpipe = function(e3) {\n              var t3 = this._readableState, r4 = { hasUnpiped: false };\n              if (t3.pipesCount === 0) return this;\n              if (t3.pipesCount === 1) return e3 && e3 !== t3.pipes ? this : (e3 || (e3 = t3.pipes), t3.pipes = null, t3.pipesCount = 0, t3.flowing = false, e3 && e3.emit("unpipe", this, r4), this);\n              if (!e3) {\n                var n4 = t3.pipes, i3 = t3.pipesCount;\n                t3.pipes = null, t3.pipesCount = 0, t3.flowing = false;\n                for (var a4 = 0; a4 < i3; a4++) n4[a4].emit("unpipe", this, { hasUnpiped: false });\n                return this;\n              }\n              var o4 = bSe(t3.pipes, e3);\n              return o4 === -1 ? this : (t3.pipes.splice(o4, 1), t3.pipesCount -= 1, t3.pipesCount === 1 && (t3.pipes = t3.pipes[0]), e3.emit("unpipe", this, r4), this);\n            };\n            Bu.prototype.on = function(e3, t3) {\n              var r4 = iE.prototype.on.call(this, e3, t3), n4 = this._readableState;\n              return e3 === "data" ? (n4.readableListening = this.listenerCount("readable") > 0, n4.flowing !== false && this.resume()) : e3 === "readable" && !n4.endEmitted && !n4.readableListening && (n4.readableListening = n4.needReadable = true, n4.flowing = false, n4.emittedReadable = false, nu("on readable", n4.length, n4.reading), n4.length ? PR(this) : n4.reading || process.nextTick(_Mt, this)), r4;\n            };\n            Bu.prototype.addListener = Bu.prototype.on;\n            Bu.prototype.removeListener = function(e3, t3) {\n              var r4 = iE.prototype.removeListener.call(this, e3, t3);\n              return e3 === "readable" && process.nextTick(_Se, this), r4;\n            };\n            Bu.prototype.removeAllListeners = function(e3) {\n              var t3 = iE.prototype.removeAllListeners.apply(this, arguments);\n              return (e3 === "readable" || e3 === void 0) && process.nextTick(_Se, this), t3;\n            };\n            function _Se(e3) {\n              var t3 = e3._readableState;\n              t3.readableListening = e3.listenerCount("readable") > 0, t3.resumeScheduled && !t3.paused ? t3.flowing = true : e3.listenerCount("data") > 0 && e3.resume();\n            }\n            function _Mt(e3) {\n              nu("readable nexttick read 0"), e3.read(0);\n            }\n            Bu.prototype.resume = function() {\n              var e3 = this._readableState;\n              return e3.flowing || (nu("resume"), e3.flowing = !e3.readableListening, xMt(this, e3)), e3.paused = false, this;\n            };\n            function xMt(e3, t3) {\n              t3.resumeScheduled || (t3.resumeScheduled = true, process.nextTick(bMt, e3, t3));\n            }\n            function bMt(e3, t3) {\n              nu("resume", t3.reading), t3.reading || e3.read(0), t3.resumeScheduled = false, e3.emit("resume"), Cj(e3), t3.flowing && !t3.reading && e3.read(0);\n            }\n            Bu.prototype.pause = function() {\n              return nu("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== false && (nu("pause"), this._readableState.flowing = false, this.emit("pause")), this._readableState.paused = true, this;\n            };\n            function Cj(e3) {\n              var t3 = e3._readableState;\n              for (nu("flow", t3.flowing); t3.flowing && e3.read() !== null; ) ;\n            }\n            Bu.prototype.wrap = function(e3) {\n              var t3 = this, r4 = this._readableState, n4 = false;\n              e3.on("end", function() {\n                if (nu("wrapped end"), r4.decoder && !r4.ended) {\n                  var o4 = r4.decoder.end();\n                  o4 && o4.length && t3.push(o4);\n                }\n                t3.push(null);\n              }), e3.on("data", function(o4) {\n                if (nu("wrapped data"), r4.decoder && (o4 = r4.decoder.write(o4)), !(r4.objectMode && o4 == null) && !(!r4.objectMode && (!o4 || !o4.length))) {\n                  var s3 = t3.push(o4);\n                  s3 || (n4 = true, e3.pause());\n                }\n              });\n              for (var i3 in e3) this[i3] === void 0 && typeof e3[i3] == "function" && (this[i3] = /* @__PURE__ */ (function(s3) {\n                return function() {\n                  return e3[s3].apply(e3, arguments);\n                };\n              })(i3));\n              for (var a4 = 0; a4 < Aj.length; a4++) e3.on(Aj[a4], this.emit.bind(this, Aj[a4]));\n              return this._read = function(o4) {\n                nu("wrapped _read", o4), n4 && (n4 = false, e3.resume());\n              }, this;\n            };\n            typeof Symbol == "function" && (Bu.prototype[Symbol.asyncIterator] = function() {\n              return wj === void 0 && (wj = cSe()), wj(this);\n            });\n            Object.defineProperty(Bu.prototype, "readableHighWaterMark", { enumerable: false, get: function() {\n              return this._readableState.highWaterMark;\n            } });\n            Object.defineProperty(Bu.prototype, "readableBuffer", { enumerable: false, get: function() {\n              return this._readableState && this._readableState.buffer;\n            } });\n            Object.defineProperty(Bu.prototype, "readableFlowing", { enumerable: false, get: function() {\n              return this._readableState.flowing;\n            }, set: function(t3) {\n              this._readableState && (this._readableState.flowing = t3);\n            } });\n            Bu._fromList = xSe;\n            Object.defineProperty(Bu.prototype, "readableLength", { enumerable: false, get: function() {\n              return this._readableState.length;\n            } });\n            function xSe(e3, t3) {\n              if (t3.length === 0) return null;\n              var r4;\n              return t3.objectMode ? r4 = t3.buffer.shift() : !e3 || e3 >= t3.length ? (t3.decoder ? r4 = t3.buffer.join("") : t3.buffer.length === 1 ? r4 = t3.buffer.first() : r4 = t3.buffer.concat(t3.length), t3.buffer.clear()) : r4 = t3.buffer.consume(e3, t3.decoder), r4;\n            }\n            function Mj(e3) {\n              var t3 = e3._readableState;\n              nu("endReadable", t3.endEmitted), t3.endEmitted || (t3.ended = true, process.nextTick(wMt, t3, e3));\n            }\n            function wMt(e3, t3) {\n              if (nu("endReadableNT", e3.endEmitted, e3.length), !e3.endEmitted && e3.length === 0 && (e3.endEmitted = true, t3.readable = false, t3.emit("end"), e3.autoDestroy)) {\n                var r4 = t3._writableState;\n                (!r4 || r4.autoDestroy && r4.finished) && t3.destroy();\n              }\n            }\n            typeof Symbol == "function" && (Bu.from = function(e3, t3) {\n              return Tj === void 0 && (Tj = hSe()), Tj(Bu, e3, t3);\n            });\n            function bSe(e3, t3) {\n              for (var r4 = 0, n4 = e3.length; r4 < n4; r4++) if (e3[r4] === t3) return r4;\n              return -1;\n            }\n          });\n          var Lj = ye((Yhr, ASe) => {\n            "use strict";\n            ASe.exports = Gy;\n            var IR = p22().codes, TMt = IR.ERR_METHOD_NOT_IMPLEMENTED, AMt = IR.ERR_MULTIPLE_CALLBACK, SMt = IR.ERR_TRANSFORM_ALREADY_TRANSFORMING, MMt = IR.ERR_TRANSFORM_WITH_LENGTH_0, RR = g2();\n            Uy()(Gy, RR);\n            function EMt(e3, t3) {\n              var r4 = this._transformState;\n              r4.transforming = false;\n              var n4 = r4.writecb;\n              if (n4 === null) return this.emit("error", new AMt());\n              r4.writechunk = null, r4.writecb = null, t3 != null && this.push(t3), n4(e3);\n              var i3 = this._readableState;\n              i3.reading = false, (i3.needReadable || i3.length < i3.highWaterMark) && this._read(i3.highWaterMark);\n            }\n            function Gy(e3) {\n              if (!(this instanceof Gy)) return new Gy(e3);\n              RR.call(this, e3), this._transformState = { afterTransform: EMt.bind(this), needTransform: false, transforming: false, writecb: null, writechunk: null, writeencoding: null }, this._readableState.needReadable = true, this._readableState.sync = false, e3 && (typeof e3.transform == "function" && (this._transform = e3.transform), typeof e3.flush == "function" && (this._flush = e3.flush)), this.on("prefinish", kMt);\n            }\n            function kMt() {\n              var e3 = this;\n              typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(t3, r4) {\n                TSe(e3, t3, r4);\n              }) : TSe(this, null, null);\n            }\n            Gy.prototype.push = function(e3, t3) {\n              return this._transformState.needTransform = false, RR.prototype.push.call(this, e3, t3);\n            };\n            Gy.prototype._transform = function(e3, t3, r4) {\n              r4(new TMt("_transform()"));\n            };\n            Gy.prototype._write = function(e3, t3, r4) {\n              var n4 = this._transformState;\n              if (n4.writecb = r4, n4.writechunk = e3, n4.writeencoding = t3, !n4.transforming) {\n                var i3 = this._readableState;\n                (n4.needTransform || i3.needReadable || i3.length < i3.highWaterMark) && this._read(i3.highWaterMark);\n              }\n            };\n            Gy.prototype._read = function(e3) {\n              var t3 = this._transformState;\n              t3.writechunk !== null && !t3.transforming ? (t3.transforming = true, this._transform(t3.writechunk, t3.writeencoding, t3.afterTransform)) : t3.needTransform = true;\n            };\n            Gy.prototype._destroy = function(e3, t3) {\n              RR.prototype._destroy.call(this, e3, function(r4) {\n                t3(r4);\n              });\n            };\n            function TSe(e3, t3, r4) {\n              if (t3) return e3.emit("error", t3);\n              if (r4 != null && e3.push(r4), e3._writableState.length) throw new MMt();\n              if (e3._transformState.transforming) throw new SMt();\n              return e3.push(null);\n            }\n          });\n          var ESe = ye((Khr, MSe) => {\n            "use strict";\n            MSe.exports = nE;\n            var SSe = Lj();\n            Uy()(nE, SSe);\n            function nE(e3) {\n              if (!(this instanceof nE)) return new nE(e3);\n              SSe.call(this, e3);\n            }\n            nE.prototype._transform = function(e3, t3, r4) {\n              r4(null, e3);\n            };\n          });\n          var ISe = ye((Jhr, PSe) => {\n            "use strict";\n            var Pj;\n            function CMt(e3) {\n              var t3 = false;\n              return function() {\n                t3 || (t3 = true, e3.apply(void 0, arguments));\n              };\n            }\n            var LSe = p22().codes, LMt = LSe.ERR_MISSING_ARGS, PMt = LSe.ERR_STREAM_DESTROYED;\n            function kSe(e3) {\n              if (e3) throw e3;\n            }\n            function IMt(e3) {\n              return e3.setHeader && typeof e3.abort == "function";\n            }\n            function RMt(e3, t3, r4, n4) {\n              n4 = CMt(n4);\n              var i3 = false;\n              e3.on("close", function() {\n                i3 = true;\n              }), Pj === void 0 && (Pj = MR()), Pj(e3, { readable: t3, writable: r4 }, function(o4) {\n                if (o4) return n4(o4);\n                i3 = true, n4();\n              });\n              var a4 = false;\n              return function(o4) {\n                if (!i3 && !a4) {\n                  if (a4 = true, IMt(e3)) return e3.abort();\n                  if (typeof e3.destroy == "function") return e3.destroy();\n                  n4(o4 || new PMt("pipe"));\n                }\n              };\n            }\n            function CSe(e3) {\n              e3();\n            }\n            function DMt(e3, t3) {\n              return e3.pipe(t3);\n            }\n            function FMt(e3) {\n              return !e3.length || typeof e3[e3.length - 1] != "function" ? kSe : e3.pop();\n            }\n            function zMt() {\n              for (var e3 = arguments.length, t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = arguments[r4];\n              var n4 = FMt(t3);\n              if (Array.isArray(t3[0]) && (t3 = t3[0]), t3.length < 2) throw new LMt("streams");\n              var i3, a4 = t3.map(function(o4, s3) {\n                var l3 = s3 < t3.length - 1, u4 = s3 > 0;\n                return RMt(o4, l3, u4, function(c5) {\n                  i3 || (i3 = c5), c5 && a4.forEach(CSe), !l3 && (a4.forEach(CSe), n4(i3));\n                });\n              });\n              return t3.reduce(DMt);\n            }\n            PSe.exports = zMt;\n          });\n          var DSe = ye(($hr, RSe) => {\n            RSe.exports = K0;\n            var Ij = pb().EventEmitter, OMt = Uy();\n            OMt(K0, Ij);\n            K0.Readable = pj();\n            K0.Writable = hj();\n            K0.Duplex = g2();\n            K0.Transform = Lj();\n            K0.PassThrough = ESe();\n            K0.finished = MR();\n            K0.pipeline = ISe();\n            K0.Stream = K0;\n            function K0() {\n              Ij.call(this);\n            }\n            K0.prototype.pipe = function(e3, t3) {\n              var r4 = this;\n              function n4(c5) {\n                e3.writable && e3.write(c5) === false && r4.pause && r4.pause();\n              }\n              r4.on("data", n4);\n              function i3() {\n                r4.readable && r4.resume && r4.resume();\n              }\n              e3.on("drain", i3), !e3._isStdio && (!t3 || t3.end !== false) && (r4.on("end", o4), r4.on("close", s3));\n              var a4 = false;\n              function o4() {\n                a4 || (a4 = true, e3.end());\n              }\n              function s3() {\n                a4 || (a4 = true, typeof e3.destroy == "function" && e3.destroy());\n              }\n              function l3(c5) {\n                if (u4(), Ij.listenerCount(this, "error") === 0) throw c5;\n              }\n              r4.on("error", l3), e3.on("error", l3);\n              function u4() {\n                r4.removeListener("data", n4), e3.removeListener("drain", i3), r4.removeListener("end", o4), r4.removeListener("close", s3), r4.removeListener("error", l3), e3.removeListener("error", l3), r4.removeListener("end", u4), r4.removeListener("close", u4), e3.removeListener("close", u4);\n              }\n              return r4.on("end", u4), r4.on("close", u4), e3.on("close", u4), e3.emit("pipe", r4), e3;\n            };\n          });\n          var mA = ye((fu) => {\n            var FSe = Object.getOwnPropertyDescriptors || function(t3) {\n              for (var r4 = Object.keys(t3), n4 = {}, i3 = 0; i3 < r4.length; i3++) n4[r4[i3]] = Object.getOwnPropertyDescriptor(t3, r4[i3]);\n              return n4;\n            }, qMt = /%[sdj%]/g;\n            fu.format = function(e3) {\n              if (!NR(e3)) {\n                for (var t3 = [], r4 = 0; r4 < arguments.length; r4++) t3.push(O_(arguments[r4]));\n                return t3.join(" ");\n              }\n              for (var r4 = 1, n4 = arguments, i3 = n4.length, a4 = String(e3).replace(qMt, function(s3) {\n                if (s3 === "%%") return "%";\n                if (r4 >= i3) return s3;\n                switch (s3) {\n                  case "%s":\n                    return String(n4[r4++]);\n                  case "%d":\n                    return Number(n4[r4++]);\n                  case "%j":\n                    try {\n                      return JSON.stringify(n4[r4++]);\n                    } catch (l3) {\n                      return "[Circular]";\n                    }\n                  default:\n                    return s3;\n                }\n              }), o4 = n4[r4]; r4 < i3; o4 = n4[++r4]) BR(o4) || !gA(o4) ? a4 += " " + o4 : a4 += " " + O_(o4);\n              return a4;\n            };\n            fu.deprecate = function(e3, t3) {\n              if (typeof process != "undefined" && process.noDeprecation === true) return e3;\n              if (typeof process == "undefined") return function() {\n                return fu.deprecate(e3, t3).apply(this, arguments);\n              };\n              var r4 = false;\n              function n4() {\n                if (!r4) {\n                  if (process.throwDeprecation) throw new Error(t3);\n                  process.traceDeprecation ? console.trace(t3) : console.error(t3), r4 = true;\n                }\n                return e3.apply(this, arguments);\n              }\n              return n4;\n            };\n            var DR = {}, zSe = /^$/;\n            FR = "false", FR = FR.replace(/[|\\\\{}()[\\]^$+?.]/g, "\\\\$&").replace(/\\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), zSe = new RegExp("^" + FR + "$", "i");\n            var FR;\n            fu.debuglog = function(e3) {\n              if (e3 = e3.toUpperCase(), !DR[e3]) if (zSe.test(e3)) {\n                var t3 = process.pid;\n                DR[e3] = function() {\n                  var r4 = fu.format.apply(fu, arguments);\n                  console.error("%s %d: %s", e3, t3, r4);\n                };\n              } else DR[e3] = function() {\n              };\n              return DR[e3];\n            };\n            function O_(e3, t3) {\n              var r4 = { seen: [], stylize: NMt };\n              return arguments.length >= 3 && (r4.depth = arguments[2]), arguments.length >= 4 && (r4.colors = arguments[3]), zj(t3) ? r4.showHidden = t3 : t3 && fu._extend(r4, t3), w22(r4.showHidden) && (r4.showHidden = false), w22(r4.depth) && (r4.depth = 2), w22(r4.colors) && (r4.colors = false), w22(r4.customInspect) && (r4.customInspect = true), r4.colors && (r4.stylize = BMt), OR(r4, e3, r4.depth);\n            }\n            fu.inspect = O_;\n            O_.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] };\n            O_.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" };\n            function BMt(e3, t3) {\n              var r4 = O_.styles[t3];\n              return r4 ? "\\x1B[" + O_.colors[r4][0] + "m" + e3 + "\\x1B[" + O_.colors[r4][1] + "m" : e3;\n            }\n            function NMt(e3, t3) {\n              return e3;\n            }\n            function UMt(e3) {\n              var t3 = {};\n              return e3.forEach(function(r4, n4) {\n                t3[r4] = true;\n              }), t3;\n            }\n            function OR(e3, t3, r4) {\n              if (e3.customInspect && t3 && zR(t3.inspect) && t3.inspect !== fu.inspect && !(t3.constructor && t3.constructor.prototype === t3)) {\n                var n4 = t3.inspect(r4, e3);\n                return NR(n4) || (n4 = OR(e3, n4, r4)), n4;\n              }\n              var i3 = VMt(e3, t3);\n              if (i3) return i3;\n              var a4 = Object.keys(t3), o4 = UMt(a4);\n              if (e3.showHidden && (a4 = Object.getOwnPropertyNames(t3)), oE(t3) && (a4.indexOf("message") >= 0 || a4.indexOf("description") >= 0)) return Rj(t3);\n              if (a4.length === 0) {\n                if (zR(t3)) {\n                  var s3 = t3.name ? ": " + t3.name : "";\n                  return e3.stylize("[Function" + s3 + "]", "special");\n                }\n                if (aE(t3)) return e3.stylize(RegExp.prototype.toString.call(t3), "regexp");\n                if (qR(t3)) return e3.stylize(Date.prototype.toString.call(t3), "date");\n                if (oE(t3)) return Rj(t3);\n              }\n              var l3 = "", u4 = false, c5 = ["{", "}"];\n              if (OSe(t3) && (u4 = true, c5 = ["[", "]"]), zR(t3)) {\n                var f4 = t3.name ? ": " + t3.name : "";\n                l3 = " [Function" + f4 + "]";\n              }\n              if (aE(t3) && (l3 = " " + RegExp.prototype.toString.call(t3)), qR(t3) && (l3 = " " + Date.prototype.toUTCString.call(t3)), oE(t3) && (l3 = " " + Rj(t3)), a4.length === 0 && (!u4 || t3.length == 0)) return c5[0] + l3 + c5[1];\n              if (r4 < 0) return aE(t3) ? e3.stylize(RegExp.prototype.toString.call(t3), "regexp") : e3.stylize("[Object]", "special");\n              e3.seen.push(t3);\n              var h3;\n              return u4 ? h3 = GMt(e3, t3, r4, o4, a4) : h3 = a4.map(function(d3) {\n                return Fj(e3, t3, r4, o4, d3, u4);\n              }), e3.seen.pop(), HMt(h3, l3, c5);\n            }\n            function VMt(e3, t3) {\n              if (w22(t3)) return e3.stylize("undefined", "undefined");\n              if (NR(t3)) {\n                var r4 = "\'" + JSON.stringify(t3).replace(/^"|"$/g, "").replace(/\'/g, "\\\\\'").replace(/\\\\"/g, \'"\') + "\'";\n                return e3.stylize(r4, "string");\n              }\n              if (qSe(t3)) return e3.stylize("" + t3, "number");\n              if (zj(t3)) return e3.stylize("" + t3, "boolean");\n              if (BR(t3)) return e3.stylize("null", "null");\n            }\n            function Rj(e3) {\n              return "[" + Error.prototype.toString.call(e3) + "]";\n            }\n            function GMt(e3, t3, r4, n4, i3) {\n              for (var a4 = [], o4 = 0, s3 = t3.length; o4 < s3; ++o4) BSe(t3, String(o4)) ? a4.push(Fj(e3, t3, r4, n4, String(o4), true)) : a4.push("");\n              return i3.forEach(function(l3) {\n                l3.match(/^\\d+$/) || a4.push(Fj(e3, t3, r4, n4, l3, true));\n              }), a4;\n            }\n            function Fj(e3, t3, r4, n4, i3, a4) {\n              var o4, s3, l3;\n              if (l3 = Object.getOwnPropertyDescriptor(t3, i3) || { value: t3[i3] }, l3.get ? l3.set ? s3 = e3.stylize("[Getter/Setter]", "special") : s3 = e3.stylize("[Getter]", "special") : l3.set && (s3 = e3.stylize("[Setter]", "special")), BSe(n4, i3) || (o4 = "[" + i3 + "]"), s3 || (e3.seen.indexOf(l3.value) < 0 ? (BR(r4) ? s3 = OR(e3, l3.value, null) : s3 = OR(e3, l3.value, r4 - 1), s3.indexOf(`\n`) > -1 && (a4 ? s3 = s3.split(`\n`).map(function(u4) {\n                return "  " + u4;\n              }).join(`\n`).slice(2) : s3 = `\n` + s3.split(`\n`).map(function(u4) {\n                return "   " + u4;\n              }).join(`\n`))) : s3 = e3.stylize("[Circular]", "special")), w22(o4)) {\n                if (a4 && i3.match(/^\\d+$/)) return s3;\n                o4 = JSON.stringify("" + i3), o4.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (o4 = o4.slice(1, -1), o4 = e3.stylize(o4, "name")) : (o4 = o4.replace(/\'/g, "\\\\\'").replace(/\\\\"/g, \'"\').replace(/(^"|"$)/g, "\'"), o4 = e3.stylize(o4, "string"));\n              }\n              return o4 + ": " + s3;\n            }\n            function HMt(e3, t3, r4) {\n              var n4 = 0, i3 = e3.reduce(function(a4, o4) {\n                return n4++, o4.indexOf(`\n`) >= 0 && n4++, a4 + o4.replace(/\\u001b\\[\\d\\d?m/g, "").length + 1;\n              }, 0);\n              return i3 > 60 ? r4[0] + (t3 === "" ? "" : t3 + `\n `) + " " + e3.join(`,\n  `) + " " + r4[1] : r4[0] + t3 + " " + e3.join(", ") + " " + r4[1];\n            }\n            fu.types = JH();\n            function OSe(e3) {\n              return Array.isArray(e3);\n            }\n            fu.isArray = OSe;\n            function zj(e3) {\n              return typeof e3 == "boolean";\n            }\n            fu.isBoolean = zj;\n            function BR(e3) {\n              return e3 === null;\n            }\n            fu.isNull = BR;\n            function jMt(e3) {\n              return e3 == null;\n            }\n            fu.isNullOrUndefined = jMt;\n            function qSe(e3) {\n              return typeof e3 == "number";\n            }\n            fu.isNumber = qSe;\n            function NR(e3) {\n              return typeof e3 == "string";\n            }\n            fu.isString = NR;\n            function WMt(e3) {\n              return typeof e3 == "symbol";\n            }\n            fu.isSymbol = WMt;\n            function w22(e3) {\n              return e3 === void 0;\n            }\n            fu.isUndefined = w22;\n            function aE(e3) {\n              return gA(e3) && Oj(e3) === "[object RegExp]";\n            }\n            fu.isRegExp = aE;\n            fu.types.isRegExp = aE;\n            function gA(e3) {\n              return typeof e3 == "object" && e3 !== null;\n            }\n            fu.isObject = gA;\n            function qR(e3) {\n              return gA(e3) && Oj(e3) === "[object Date]";\n            }\n            fu.isDate = qR;\n            fu.types.isDate = qR;\n            function oE(e3) {\n              return gA(e3) && (Oj(e3) === "[object Error]" || e3 instanceof Error);\n            }\n            fu.isError = oE;\n            fu.types.isNativeError = oE;\n            function zR(e3) {\n              return typeof e3 == "function";\n            }\n            fu.isFunction = zR;\n            function XMt(e3) {\n              return e3 === null || typeof e3 == "boolean" || typeof e3 == "number" || typeof e3 == "string" || typeof e3 == "symbol" || typeof e3 == "undefined";\n            }\n            fu.isPrimitive = XMt;\n            fu.isBuffer = $H();\n            function Oj(e3) {\n              return Object.prototype.toString.call(e3);\n            }\n            function Dj(e3) {\n              return e3 < 10 ? "0" + e3.toString(10) : e3.toString(10);\n            }\n            var ZMt = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];\n            function YMt() {\n              var e3 = /* @__PURE__ */ new Date(), t3 = [Dj(e3.getHours()), Dj(e3.getMinutes()), Dj(e3.getSeconds())].join(":");\n              return [e3.getDate(), ZMt[e3.getMonth()], t3].join(" ");\n            }\n            fu.log = function() {\n              console.log("%s - %s", YMt(), fu.format.apply(fu, arguments));\n            };\n            fu.inherits = Uy();\n            fu._extend = function(e3, t3) {\n              if (!t3 || !gA(t3)) return e3;\n              for (var r4 = Object.keys(t3), n4 = r4.length; n4--; ) e3[r4[n4]] = t3[r4[n4]];\n              return e3;\n            };\n            function BSe(e3, t3) {\n              return Object.prototype.hasOwnProperty.call(e3, t3);\n            }\n            var b2 = typeof Symbol != "undefined" ? /* @__PURE__ */ Symbol("util.promisify.custom") : void 0;\n            fu.promisify = function(t3) {\n              if (typeof t3 != "function") throw new TypeError(\'The "original" argument must be of type Function\');\n              if (b2 && t3[b2]) {\n                var r4 = t3[b2];\n                if (typeof r4 != "function") throw new TypeError(\'The "util.promisify.custom" argument must be of type Function\');\n                return Object.defineProperty(r4, b2, { value: r4, enumerable: false, writable: false, configurable: true }), r4;\n              }\n              function r4() {\n                for (var n4, i3, a4 = new Promise(function(l3, u4) {\n                  n4 = l3, i3 = u4;\n                }), o4 = [], s3 = 0; s3 < arguments.length; s3++) o4.push(arguments[s3]);\n                o4.push(function(l3, u4) {\n                  l3 ? i3(l3) : n4(u4);\n                });\n                try {\n                  t3.apply(this, o4);\n                } catch (l3) {\n                  i3(l3);\n                }\n                return a4;\n              }\n              return Object.setPrototypeOf(r4, Object.getPrototypeOf(t3)), b2 && Object.defineProperty(r4, b2, { value: r4, enumerable: false, writable: false, configurable: true }), Object.defineProperties(r4, FSe(t3));\n            };\n            fu.promisify.custom = b2;\n            function KMt(e3, t3) {\n              if (!e3) {\n                var r4 = new Error("Promise was rejected with a falsy value");\n                r4.reason = e3, e3 = r4;\n              }\n              return t3(e3);\n            }\n            function JMt(e3) {\n              if (typeof e3 != "function") throw new TypeError(\'The "original" argument must be of type Function\');\n              function t3() {\n                for (var r4 = [], n4 = 0; n4 < arguments.length; n4++) r4.push(arguments[n4]);\n                var i3 = r4.pop();\n                if (typeof i3 != "function") throw new TypeError("The last argument must be of type Function");\n                var a4 = this, o4 = function() {\n                  return i3.apply(a4, arguments);\n                };\n                e3.apply(this, r4).then(function(s3) {\n                  process.nextTick(o4.bind(null, null, s3));\n                }, function(s3) {\n                  process.nextTick(KMt.bind(null, s3, o4));\n                });\n              }\n              return Object.setPrototypeOf(t3, Object.getPrototypeOf(e3)), Object.defineProperties(t3, FSe(e3)), t3;\n            }\n            fu.callbackify = JMt;\n          });\n          var Nj = ye((edr, GSe) => {\n            "use strict";\n            function q_(e3) {\n              "@babel/helpers - typeof";\n              return q_ = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t3) {\n                return typeof t3;\n              } : function(t3) {\n                return t3 && typeof Symbol == "function" && t3.constructor === Symbol && t3 !== Symbol.prototype ? "symbol" : typeof t3;\n              }, q_(e3);\n            }\n            function NSe(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                n4.enumerable = n4.enumerable || false, n4.configurable = true, "value" in n4 && (n4.writable = true), Object.defineProperty(e3, QMt(n4.key), n4);\n              }\n            }\n            function $Mt(e3, t3, r4) {\n              return t3 && NSe(e3.prototype, t3), r4 && NSe(e3, r4), Object.defineProperty(e3, "prototype", { writable: false }), e3;\n            }\n            function QMt(e3) {\n              var t3 = e4t(e3, "string");\n              return q_(t3) === "symbol" ? t3 : String(t3);\n            }\n            function e4t(e3, t3) {\n              if (q_(e3) !== "object" || e3 === null) return e3;\n              var r4 = e3[Symbol.toPrimitive];\n              if (r4 !== void 0) {\n                var n4 = r4.call(e3, t3 || "default");\n                if (q_(n4) !== "object") return n4;\n                throw new TypeError("@@toPrimitive must return a primitive value.");\n              }\n              return (t3 === "string" ? String : Number)(e3);\n            }\n            function t4t(e3, t3) {\n              if (!(e3 instanceof t3)) throw new TypeError("Cannot call a class as a function");\n            }\n            function r4t(e3, t3) {\n              if (typeof t3 != "function" && t3 !== null) throw new TypeError("Super expression must either be null or a function");\n              e3.prototype = Object.create(t3 && t3.prototype, { constructor: { value: e3, writable: true, configurable: true } }), Object.defineProperty(e3, "prototype", { writable: false }), t3 && Bj(e3, t3);\n            }\n            function Bj(e3, t3) {\n              return Bj = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n4, i3) {\n                return n4.__proto__ = i3, n4;\n              }, Bj(e3, t3);\n            }\n            function i4t(e3) {\n              var t3 = o4t();\n              return function() {\n                var n4 = UR(e3), i3;\n                if (t3) {\n                  var a4 = UR(this).constructor;\n                  i3 = Reflect.construct(n4, arguments, a4);\n                } else i3 = n4.apply(this, arguments);\n                return n4t(this, i3);\n              };\n            }\n            function n4t(e3, t3) {\n              if (t3 && (q_(t3) === "object" || typeof t3 == "function")) return t3;\n              if (t3 !== void 0) throw new TypeError("Derived constructors may only return object or undefined");\n              return a4t(e3);\n            }\n            function a4t(e3) {\n              if (e3 === void 0) throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called");\n              return e3;\n            }\n            function o4t() {\n              if (typeof Reflect == "undefined" || !Reflect.construct || Reflect.construct.sham) return false;\n              if (typeof Proxy == "function") return true;\n              try {\n                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {\n                })), true;\n              } catch (e3) {\n                return false;\n              }\n            }\n            function UR(e3) {\n              return UR = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r4) {\n                return r4.__proto__ || Object.getPrototypeOf(r4);\n              }, UR(e3);\n            }\n            var VSe = {}, yA, qj;\n            function sE(e3, t3, r4) {\n              r4 || (r4 = Error);\n              function n4(a4, o4, s3) {\n                return typeof t3 == "string" ? t3 : t3(a4, o4, s3);\n              }\n              var i3 = (function(a4) {\n                r4t(s3, a4);\n                var o4 = i4t(s3);\n                function s3(l3, u4, c5) {\n                  var f4;\n                  return t4t(this, s3), f4 = o4.call(this, n4(l3, u4, c5)), f4.code = e3, f4;\n                }\n                return $Mt(s3);\n              })(r4);\n              VSe[e3] = i3;\n            }\n            function USe(e3, t3) {\n              if (Array.isArray(e3)) {\n                var r4 = e3.length;\n                return e3 = e3.map(function(n4) {\n                  return String(n4);\n                }), r4 > 2 ? "one of ".concat(t3, " ").concat(e3.slice(0, r4 - 1).join(", "), ", or ") + e3[r4 - 1] : r4 === 2 ? "one of ".concat(t3, " ").concat(e3[0], " or ").concat(e3[1]) : "of ".concat(t3, " ").concat(e3[0]);\n              } else return "of ".concat(t3, " ").concat(String(e3));\n            }\n            function s4t(e3, t3, r4) {\n              return e3.substr(!r4 || r4 < 0 ? 0 : +r4, t3.length) === t3;\n            }\n            function l4t(e3, t3, r4) {\n              return (r4 === void 0 || r4 > e3.length) && (r4 = e3.length), e3.substring(r4 - t3.length, r4) === t3;\n            }\n            function u4t(e3, t3, r4) {\n              return typeof r4 != "number" && (r4 = 0), r4 + t3.length > e3.length ? false : e3.indexOf(t3, r4) !== -1;\n            }\n            sE("ERR_AMBIGUOUS_ARGUMENT", \'The "%s" argument is ambiguous. %s\', TypeError);\n            sE("ERR_INVALID_ARG_TYPE", function(e3, t3, r4) {\n              yA === void 0 && (yA = lE()), yA(typeof e3 == "string", "\'name\' must be a string");\n              var n4;\n              typeof t3 == "string" && s4t(t3, "not ") ? (n4 = "must not be", t3 = t3.replace(/^not /, "")) : n4 = "must be";\n              var i3;\n              if (l4t(e3, " argument")) i3 = "The ".concat(e3, " ").concat(n4, " ").concat(USe(t3, "type"));\n              else {\n                var a4 = u4t(e3, ".") ? "property" : "argument";\n                i3 = \'The "\'.concat(e3, \'" \').concat(a4, " ").concat(n4, " ").concat(USe(t3, "type"));\n              }\n              return i3 += ". Received type ".concat(q_(r4)), i3;\n            }, TypeError);\n            sE("ERR_INVALID_ARG_VALUE", function(e3, t3) {\n              var r4 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";\n              qj === void 0 && (qj = mA());\n              var n4 = qj.inspect(t3);\n              return n4.length > 128 && (n4 = "".concat(n4.slice(0, 128), "...")), "The argument \'".concat(e3, "\' ").concat(r4, ". Received ").concat(n4);\n            }, TypeError, RangeError);\n            sE("ERR_INVALID_RETURN_VALUE", function(e3, t3, r4) {\n              var n4;\n              return r4 && r4.constructor && r4.constructor.name ? n4 = "instance of ".concat(r4.constructor.name) : n4 = "type ".concat(q_(r4)), "Expected ".concat(e3, \' to be returned from the "\').concat(t3, \'"\') + " function but got ".concat(n4, ".");\n            }, TypeError);\n            sE("ERR_MISSING_ARGS", function() {\n              for (var e3 = arguments.length, t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = arguments[r4];\n              yA === void 0 && (yA = lE()), yA(t3.length > 0, "At least one arg needs to be specified");\n              var n4 = "The ", i3 = t3.length;\n              switch (t3 = t3.map(function(a4) {\n                return \'"\'.concat(a4, \'"\');\n              }), i3) {\n                case 1:\n                  n4 += "".concat(t3[0], " argument");\n                  break;\n                case 2:\n                  n4 += "".concat(t3[0], " and ").concat(t3[1], " arguments");\n                  break;\n                default:\n                  n4 += t3.slice(0, i3 - 1).join(", "), n4 += ", and ".concat(t3[i3 - 1], " arguments");\n                  break;\n              }\n              return "".concat(n4, " must be specified");\n            }, TypeError);\n            GSe.exports.codes = VSe;\n          });\n          var QSe = ye((tdr, $Se) => {\n            "use strict";\n            function HSe(e3, t3) {\n              var r4 = Object.keys(e3);\n              if (Object.getOwnPropertySymbols) {\n                var n4 = Object.getOwnPropertySymbols(e3);\n                t3 && (n4 = n4.filter(function(i3) {\n                  return Object.getOwnPropertyDescriptor(e3, i3).enumerable;\n                })), r4.push.apply(r4, n4);\n              }\n              return r4;\n            }\n            function jSe(e3) {\n              for (var t3 = 1; t3 < arguments.length; t3++) {\n                var r4 = arguments[t3] != null ? arguments[t3] : {};\n                t3 % 2 ? HSe(Object(r4), true).forEach(function(n4) {\n                  c4t(e3, n4, r4[n4]);\n                }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e3, Object.getOwnPropertyDescriptors(r4)) : HSe(Object(r4)).forEach(function(n4) {\n                  Object.defineProperty(e3, n4, Object.getOwnPropertyDescriptor(r4, n4));\n                });\n              }\n              return e3;\n            }\n            function c4t(e3, t3, r4) {\n              return t3 = YSe(t3), t3 in e3 ? Object.defineProperty(e3, t3, { value: r4, enumerable: true, configurable: true, writable: true }) : e3[t3] = r4, e3;\n            }\n            function f4t(e3, t3) {\n              if (!(e3 instanceof t3)) throw new TypeError("Cannot call a class as a function");\n            }\n            function WSe(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                n4.enumerable = n4.enumerable || false, n4.configurable = true, "value" in n4 && (n4.writable = true), Object.defineProperty(e3, YSe(n4.key), n4);\n              }\n            }\n            function h4t(e3, t3, r4) {\n              return t3 && WSe(e3.prototype, t3), r4 && WSe(e3, r4), Object.defineProperty(e3, "prototype", { writable: false }), e3;\n            }\n            function YSe(e3) {\n              var t3 = d4t(e3, "string");\n              return Dp(t3) === "symbol" ? t3 : String(t3);\n            }\n            function d4t(e3, t3) {\n              if (Dp(e3) !== "object" || e3 === null) return e3;\n              var r4 = e3[Symbol.toPrimitive];\n              if (r4 !== void 0) {\n                var n4 = r4.call(e3, t3 || "default");\n                if (Dp(n4) !== "object") return n4;\n                throw new TypeError("@@toPrimitive must return a primitive value.");\n              }\n              return (t3 === "string" ? String : Number)(e3);\n            }\n            function v4t(e3, t3) {\n              if (typeof t3 != "function" && t3 !== null) throw new TypeError("Super expression must either be null or a function");\n              e3.prototype = Object.create(t3 && t3.prototype, { constructor: { value: e3, writable: true, configurable: true } }), Object.defineProperty(e3, "prototype", { writable: false }), t3 && hE(e3, t3);\n            }\n            function p4t(e3) {\n              var t3 = JSe();\n              return function() {\n                var n4 = dE(e3), i3;\n                if (t3) {\n                  var a4 = dE(this).constructor;\n                  i3 = Reflect.construct(n4, arguments, a4);\n                } else i3 = n4.apply(this, arguments);\n                return KSe(this, i3);\n              };\n            }\n            function KSe(e3, t3) {\n              if (t3 && (Dp(t3) === "object" || typeof t3 == "function")) return t3;\n              if (t3 !== void 0) throw new TypeError("Derived constructors may only return object or undefined");\n              return Uj(e3);\n            }\n            function Uj(e3) {\n              if (e3 === void 0) throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called");\n              return e3;\n            }\n            function Vj(e3) {\n              var t3 = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;\n              return Vj = function(n4) {\n                if (n4 === null || !g4t(n4)) return n4;\n                if (typeof n4 != "function") throw new TypeError("Super expression must either be null or a function");\n                if (typeof t3 != "undefined") {\n                  if (t3.has(n4)) return t3.get(n4);\n                  t3.set(n4, i3);\n                }\n                function i3() {\n                  return VR(n4, arguments, dE(this).constructor);\n                }\n                return i3.prototype = Object.create(n4.prototype, { constructor: { value: i3, enumerable: false, writable: true, configurable: true } }), hE(i3, n4);\n              }, Vj(e3);\n            }\n            function VR(e3, t3, r4) {\n              return JSe() ? VR = Reflect.construct.bind() : VR = function(i3, a4, o4) {\n                var s3 = [null];\n                s3.push.apply(s3, a4);\n                var l3 = Function.bind.apply(i3, s3), u4 = new l3();\n                return o4 && hE(u4, o4.prototype), u4;\n              }, VR.apply(null, arguments);\n            }\n            function JSe() {\n              if (typeof Reflect == "undefined" || !Reflect.construct || Reflect.construct.sham) return false;\n              if (typeof Proxy == "function") return true;\n              try {\n                return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {\n                })), true;\n              } catch (e3) {\n                return false;\n              }\n            }\n            function g4t(e3) {\n              return Function.toString.call(e3).indexOf("[native code]") !== -1;\n            }\n            function hE(e3, t3) {\n              return hE = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n4, i3) {\n                return n4.__proto__ = i3, n4;\n              }, hE(e3, t3);\n            }\n            function dE(e3) {\n              return dE = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(r4) {\n                return r4.__proto__ || Object.getPrototypeOf(r4);\n              }, dE(e3);\n            }\n            function Dp(e3) {\n              "@babel/helpers - typeof";\n              return Dp = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t3) {\n                return typeof t3;\n              } : function(t3) {\n                return t3 && typeof Symbol == "function" && t3.constructor === Symbol && t3 !== Symbol.prototype ? "symbol" : typeof t3;\n              }, Dp(e3);\n            }\n            var m4t = mA(), Gj = m4t.inspect, y4t = Nj(), _4t = y4t.codes.ERR_INVALID_ARG_TYPE;\n            function XSe(e3, t3, r4) {\n              return (r4 === void 0 || r4 > e3.length) && (r4 = e3.length), e3.substring(r4 - t3.length, r4) === t3;\n            }\n            function x4t(e3, t3) {\n              if (t3 = Math.floor(t3), e3.length == 0 || t3 == 0) return "";\n              var r4 = e3.length * t3;\n              for (t3 = Math.floor(Math.log(t3) / Math.log(2)); t3; ) e3 += e3, t3--;\n              return e3 += e3.substring(0, r4 - e3.length), e3;\n            }\n            var jg = "", uE = "", cE = "", Tv = "", T22 = { deepStrictEqual: "Expected values to be strictly deep-equal:", strictEqual: "Expected values to be strictly equal:", strictEqualObject: \'Expected "actual" to be reference-equal to "expected":\', deepEqual: "Expected values to be loosely deep-equal:", equal: "Expected values to be loosely equal:", notDeepStrictEqual: \'Expected "actual" not to be strictly deep-equal to:\', notStrictEqual: \'Expected "actual" to be strictly unequal to:\', notStrictEqualObject: \'Expected "actual" not to be reference-equal to "expected":\', notDeepEqual: \'Expected "actual" not to be loosely deep-equal to:\', notEqual: \'Expected "actual" to be loosely unequal to:\', notIdentical: "Values identical but not reference-equal:" }, b4t = 10;\n            function ZSe(e3) {\n              var t3 = Object.keys(e3), r4 = Object.create(Object.getPrototypeOf(e3));\n              return t3.forEach(function(n4) {\n                r4[n4] = e3[n4];\n              }), Object.defineProperty(r4, "message", { value: e3.message }), r4;\n            }\n            function fE(e3) {\n              return Gj(e3, { compact: false, customInspect: false, depth: 1e3, maxArrayLength: 1 / 0, showHidden: false, breakLength: 1 / 0, showProxy: false, sorted: true, getters: true });\n            }\n            function w4t(e3, t3, r4) {\n              var n4 = "", i3 = "", a4 = 0, o4 = "", s3 = false, l3 = fE(e3), u4 = l3.split(`\n`), c5 = fE(t3).split(`\n`), f4 = 0, h3 = "";\n              if (r4 === "strictEqual" && Dp(e3) === "object" && Dp(t3) === "object" && e3 !== null && t3 !== null && (r4 = "strictEqualObject"), u4.length === 1 && c5.length === 1 && u4[0] !== c5[0]) {\n                var d3 = u4[0].length + c5[0].length;\n                if (d3 <= b4t) {\n                  if ((Dp(e3) !== "object" || e3 === null) && (Dp(t3) !== "object" || t3 === null) && (e3 !== 0 || t3 !== 0)) return "".concat(T22[r4], `\n\n`) + "".concat(u4[0], " !== ").concat(c5[0], `\n`);\n                } else if (r4 !== "strictEqualObject") {\n                  var v3 = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;\n                  if (d3 < v3) {\n                    for (; u4[0][f4] === c5[0][f4]; ) f4++;\n                    f4 > 2 && (h3 = `\n  `.concat(x4t(" ", f4), "^"), f4 = 0);\n                  }\n                }\n              }\n              for (var _2 = u4[u4.length - 1], b = c5[c5.length - 1]; _2 === b && (f4++ < 2 ? o4 = `\n  `.concat(_2).concat(o4) : n4 = _2, u4.pop(), c5.pop(), !(u4.length === 0 || c5.length === 0)); ) _2 = u4[u4.length - 1], b = c5[c5.length - 1];\n              var p3 = Math.max(u4.length, c5.length);\n              if (p3 === 0) {\n                var k4 = l3.split(`\n`);\n                if (k4.length > 30) for (k4[26] = "".concat(jg, "...").concat(Tv); k4.length > 27; ) k4.pop();\n                return "".concat(T22.notIdentical, `\n\n`).concat(k4.join(`\n`), `\n`);\n              }\n              f4 > 3 && (o4 = `\n`.concat(jg, "...").concat(Tv).concat(o4), s3 = true), n4 !== "" && (o4 = `\n  `.concat(n4).concat(o4), n4 = "");\n              var E3 = 0, S2 = T22[r4] + `\n`.concat(uE, "+ actual").concat(Tv, " ").concat(cE, "- expected").concat(Tv), L3 = " ".concat(jg, "...").concat(Tv, " Lines skipped");\n              for (f4 = 0; f4 < p3; f4++) {\n                var x2 = f4 - a4;\n                if (u4.length < f4 + 1) x2 > 1 && f4 > 2 && (x2 > 4 ? (i3 += `\n`.concat(jg, "...").concat(Tv), s3 = true) : x2 > 3 && (i3 += `\n  `.concat(c5[f4 - 2]), E3++), i3 += `\n  `.concat(c5[f4 - 1]), E3++), a4 = f4, n4 += `\n`.concat(cE, "-").concat(Tv, " ").concat(c5[f4]), E3++;\n                else if (c5.length < f4 + 1) x2 > 1 && f4 > 2 && (x2 > 4 ? (i3 += `\n`.concat(jg, "...").concat(Tv), s3 = true) : x2 > 3 && (i3 += `\n  `.concat(u4[f4 - 2]), E3++), i3 += `\n  `.concat(u4[f4 - 1]), E3++), a4 = f4, i3 += `\n`.concat(uE, "+").concat(Tv, " ").concat(u4[f4]), E3++;\n                else {\n                  var C3 = c5[f4], M4 = u4[f4], g3 = M4 !== C3 && (!XSe(M4, ",") || M4.slice(0, -1) !== C3);\n                  g3 && XSe(C3, ",") && C3.slice(0, -1) === M4 && (g3 = false, M4 += ","), g3 ? (x2 > 1 && f4 > 2 && (x2 > 4 ? (i3 += `\n`.concat(jg, "...").concat(Tv), s3 = true) : x2 > 3 && (i3 += `\n  `.concat(u4[f4 - 2]), E3++), i3 += `\n  `.concat(u4[f4 - 1]), E3++), a4 = f4, i3 += `\n`.concat(uE, "+").concat(Tv, " ").concat(M4), n4 += `\n`.concat(cE, "-").concat(Tv, " ").concat(C3), E3 += 2) : (i3 += n4, n4 = "", (x2 === 1 || f4 === 0) && (i3 += `\n  `.concat(M4), E3++));\n                }\n                if (E3 > 20 && f4 < p3 - 2) return "".concat(S2).concat(L3, `\n`).concat(i3, `\n`).concat(jg, "...").concat(Tv).concat(n4, `\n`) + "".concat(jg, "...").concat(Tv);\n              }\n              return "".concat(S2).concat(s3 ? L3 : "", `\n`).concat(i3).concat(n4).concat(o4).concat(h3);\n            }\n            var T4t = (function(e3, t3) {\n              v4t(n4, e3);\n              var r4 = p4t(n4);\n              function n4(i3) {\n                var a4;\n                if (f4t(this, n4), Dp(i3) !== "object" || i3 === null) throw new _4t("options", "Object", i3);\n                var o4 = i3.message, s3 = i3.operator, l3 = i3.stackStartFn, u4 = i3.actual, c5 = i3.expected, f4 = Error.stackTraceLimit;\n                if (Error.stackTraceLimit = 0, o4 != null) a4 = r4.call(this, String(o4));\n                else if (process.stderr && process.stderr.isTTY && (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1 ? (jg = "\\x1B[34m", uE = "\\x1B[32m", Tv = "\\x1B[39m", cE = "\\x1B[31m") : (jg = "", uE = "", Tv = "", cE = "")), Dp(u4) === "object" && u4 !== null && Dp(c5) === "object" && c5 !== null && "stack" in u4 && u4 instanceof Error && "stack" in c5 && c5 instanceof Error && (u4 = ZSe(u4), c5 = ZSe(c5)), s3 === "deepStrictEqual" || s3 === "strictEqual") a4 = r4.call(this, w4t(u4, c5, s3));\n                else if (s3 === "notDeepStrictEqual" || s3 === "notStrictEqual") {\n                  var h3 = T22[s3], d3 = fE(u4).split(`\n`);\n                  if (s3 === "notStrictEqual" && Dp(u4) === "object" && u4 !== null && (h3 = T22.notStrictEqualObject), d3.length > 30) for (d3[26] = "".concat(jg, "...").concat(Tv); d3.length > 27; ) d3.pop();\n                  d3.length === 1 ? a4 = r4.call(this, "".concat(h3, " ").concat(d3[0])) : a4 = r4.call(this, "".concat(h3, `\n\n`).concat(d3.join(`\n`), `\n`));\n                } else {\n                  var v3 = fE(u4), _2 = "", b = T22[s3];\n                  s3 === "notDeepEqual" || s3 === "notEqual" ? (v3 = "".concat(T22[s3], `\n\n`).concat(v3), v3.length > 1024 && (v3 = "".concat(v3.slice(0, 1021), "..."))) : (_2 = "".concat(fE(c5)), v3.length > 512 && (v3 = "".concat(v3.slice(0, 509), "...")), _2.length > 512 && (_2 = "".concat(_2.slice(0, 509), "...")), s3 === "deepEqual" || s3 === "equal" ? v3 = "".concat(b, `\n\n`).concat(v3, `\n\nshould equal\n\n`) : _2 = " ".concat(s3, " ").concat(_2)), a4 = r4.call(this, "".concat(v3).concat(_2));\n                }\n                return Error.stackTraceLimit = f4, a4.generatedMessage = !o4, Object.defineProperty(Uj(a4), "name", { value: "AssertionError [ERR_ASSERTION]", enumerable: false, writable: true, configurable: true }), a4.code = "ERR_ASSERTION", a4.actual = u4, a4.expected = c5, a4.operator = s3, Error.captureStackTrace && Error.captureStackTrace(Uj(a4), l3), a4.stack, a4.name = "AssertionError", KSe(a4);\n              }\n              return h4t(n4, [{ key: "toString", value: function() {\n                return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);\n              } }, { key: t3, value: function(a4, o4) {\n                return Gj(this, jSe(jSe({}, o4), {}, { customInspect: false, depth: 0 }));\n              } }]), n4;\n            })(Vj(Error), Gj.custom);\n            $Se.exports = T4t;\n          });\n          var Hj = ye((rdr, tMe) => {\n            "use strict";\n            var eMe = Object.prototype.toString;\n            tMe.exports = function(t3) {\n              var r4 = eMe.call(t3), n4 = r4 === "[object Arguments]";\n              return n4 || (n4 = r4 !== "[object Array]" && t3 !== null && typeof t3 == "object" && typeof t3.length == "number" && t3.length >= 0 && eMe.call(t3.callee) === "[object Function]"), n4;\n            };\n          });\n          var cMe = ye((idr, uMe) => {\n            "use strict";\n            var lMe;\n            Object.keys || (vE = Object.prototype.hasOwnProperty, jj = Object.prototype.toString, rMe = Hj(), Wj = Object.prototype.propertyIsEnumerable, iMe = !Wj.call({ toString: null }, "toString"), nMe = Wj.call(function() {\n            }, "prototype"), pE = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"], GR = function(e3) {\n              var t3 = e3.constructor;\n              return t3 && t3.prototype === e3;\n            }, aMe = { $applicationCache: true, $console: true, $external: true, $frame: true, $frameElement: true, $frames: true, $innerHeight: true, $innerWidth: true, $onmozfullscreenchange: true, $onmozfullscreenerror: true, $outerHeight: true, $outerWidth: true, $pageXOffset: true, $pageYOffset: true, $parent: true, $scrollLeft: true, $scrollTop: true, $scrollX: true, $scrollY: true, $self: true, $webkitIndexedDB: true, $webkitStorageInfo: true, $window: true }, oMe = (function() {\n              if (typeof window == "undefined") return false;\n              for (var e3 in window) try {\n                if (!aMe["$" + e3] && vE.call(window, e3) && window[e3] !== null && typeof window[e3] == "object") try {\n                  GR(window[e3]);\n                } catch (t3) {\n                  return true;\n                }\n              } catch (t3) {\n                return true;\n              }\n              return false;\n            })(), sMe = function(e3) {\n              if (typeof window == "undefined" || !oMe) return GR(e3);\n              try {\n                return GR(e3);\n              } catch (t3) {\n                return false;\n              }\n            }, lMe = function(t3) {\n              var r4 = t3 !== null && typeof t3 == "object", n4 = jj.call(t3) === "[object Function]", i3 = rMe(t3), a4 = r4 && jj.call(t3) === "[object String]", o4 = [];\n              if (!r4 && !n4 && !i3) throw new TypeError("Object.keys called on a non-object");\n              var s3 = nMe && n4;\n              if (a4 && t3.length > 0 && !vE.call(t3, 0)) for (var l3 = 0; l3 < t3.length; ++l3) o4.push(String(l3));\n              if (i3 && t3.length > 0) for (var u4 = 0; u4 < t3.length; ++u4) o4.push(String(u4));\n              else for (var c5 in t3) !(s3 && c5 === "prototype") && vE.call(t3, c5) && o4.push(String(c5));\n              if (iMe) for (var f4 = sMe(t3), h3 = 0; h3 < pE.length; ++h3) !(f4 && pE[h3] === "constructor") && vE.call(t3, pE[h3]) && o4.push(pE[h3]);\n              return o4;\n            });\n            var vE, jj, rMe, Wj, iMe, nMe, pE, GR, aMe, oMe, sMe;\n            uMe.exports = lMe;\n          });\n          var Xj = ye((ndr, dMe) => {\n            "use strict";\n            var A4t = Array.prototype.slice, S4t = Hj(), fMe = Object.keys, HR = fMe ? function(t3) {\n              return fMe(t3);\n            } : cMe(), hMe = Object.keys;\n            HR.shim = function() {\n              if (Object.keys) {\n                var t3 = (function() {\n                  var r4 = Object.keys(arguments);\n                  return r4 && r4.length === arguments.length;\n                })(1, 2);\n                t3 || (Object.keys = function(n4) {\n                  return S4t(n4) ? hMe(A4t.call(n4)) : hMe(n4);\n                });\n              } else Object.keys = HR;\n              return Object.keys || HR;\n            };\n            dMe.exports = HR;\n          });\n          var _Me = ye((adr, yMe) => {\n            "use strict";\n            var M4t = Xj(), gMe = j8()(), mMe = lA(), vMe = Object, E4t = mMe("Array.prototype.push"), pMe = mMe("Object.prototype.propertyIsEnumerable"), k4t = gMe ? Object.getOwnPropertySymbols : null;\n            yMe.exports = function(t3, r4) {\n              if (t3 == null) throw new TypeError("target must be an object");\n              var n4 = vMe(t3);\n              if (arguments.length === 1) return n4;\n              for (var i3 = 1; i3 < arguments.length; ++i3) {\n                var a4 = vMe(arguments[i3]), o4 = M4t(a4), s3 = gMe && (Object.getOwnPropertySymbols || k4t);\n                if (s3) for (var l3 = s3(a4), u4 = 0; u4 < l3.length; ++u4) {\n                  var c5 = l3[u4];\n                  pMe(a4, c5) && E4t(o4, c5);\n                }\n                for (var f4 = 0; f4 < o4.length; ++f4) {\n                  var h3 = o4[f4];\n                  if (pMe(a4, h3)) {\n                    var d3 = a4[h3];\n                    n4[h3] = d3;\n                  }\n                }\n              }\n              return n4;\n            };\n          });\n          var bMe = ye((odr, xMe) => {\n            "use strict";\n            var Zj = _Me(), C4t = function() {\n              if (!Object.assign) return false;\n              for (var e3 = "abcdefghijklmnopqrst", t3 = e3.split(""), r4 = {}, n4 = 0; n4 < t3.length; ++n4) r4[t3[n4]] = t3[n4];\n              var i3 = Object.assign({}, r4), a4 = "";\n              for (var o4 in i3) a4 += o4;\n              return e3 !== a4;\n            }, L4t = function() {\n              if (!Object.assign || !Object.preventExtensions) return false;\n              var e3 = Object.preventExtensions({ 1: 2 });\n              try {\n                Object.assign(e3, "xy");\n              } catch (t3) {\n                return e3[1] === "y";\n              }\n              return false;\n            };\n            xMe.exports = function() {\n              return !Object.assign || C4t() || L4t() ? Zj : Object.assign;\n            };\n          });\n          var Yj = ye((sdr, TMe) => {\n            "use strict";\n            var wMe = function(e3) {\n              return e3 !== e3;\n            };\n            TMe.exports = function(t3, r4) {\n              return t3 === 0 && r4 === 0 ? 1 / t3 === 1 / r4 : !!(t3 === r4 || wMe(t3) && wMe(r4));\n            };\n          });\n          var jR = ye((ldr, AMe) => {\n            "use strict";\n            var P4t = Yj();\n            AMe.exports = function() {\n              return typeof Object.is == "function" ? Object.is : P4t;\n            };\n          });\n          var gE = ye((udr, kMe) => {\n            "use strict";\n            var I4t = Xj(), R4t = typeof Symbol == "function" && typeof /* @__PURE__ */ Symbol("foo") == "symbol", D4t = Object.prototype.toString, F4t = Array.prototype.concat, SMe = Object.defineProperty, z4t = function(e3) {\n              return typeof e3 == "function" && D4t.call(e3) === "[object Function]";\n            }, O4t = PH()(), MMe = SMe && O4t, q4t = function(e3, t3, r4, n4) {\n              if (t3 in e3) {\n                if (n4 === true) {\n                  if (e3[t3] === r4) return;\n                } else if (!z4t(n4) || !n4()) return;\n              }\n              MMe ? SMe(e3, t3, { configurable: true, enumerable: false, value: r4, writable: true }) : e3[t3] = r4;\n            }, EMe = function(e3, t3) {\n              var r4 = arguments.length > 2 ? arguments[2] : {}, n4 = I4t(t3);\n              R4t && (n4 = F4t.call(n4, Object.getOwnPropertySymbols(t3)));\n              for (var i3 = 0; i3 < n4.length; i3 += 1) q4t(e3, n4[i3], t3[n4[i3]], r4[n4[i3]]);\n            };\n            EMe.supportsDescriptors = !!MMe;\n            kMe.exports = EMe;\n          });\n          var LMe = ye((cdr, CMe) => {\n            "use strict";\n            var B4t = jR(), N4t = gE();\n            CMe.exports = function() {\n              var t3 = B4t();\n              return N4t(Object, { is: t3 }, { is: function() {\n                return Object.is !== t3;\n              } }), t3;\n            };\n          });\n          var DMe = ye((fdr, RMe) => {\n            "use strict";\n            var U4t = gE(), V4t = X4(), G4t = Yj(), PMe = jR(), H4t = LMe(), IMe = V4t(PMe(), Object);\n            U4t(IMe, { getPolyfill: PMe, implementation: G4t, shim: H4t });\n            RMe.exports = IMe;\n          });\n          var Kj = ye((hdr, FMe) => {\n            "use strict";\n            FMe.exports = function(t3) {\n              return t3 !== t3;\n            };\n          });\n          var Jj = ye((ddr, zMe) => {\n            "use strict";\n            var j4t = Kj();\n            zMe.exports = function() {\n              return Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a") ? Number.isNaN : j4t;\n            };\n          });\n          var qMe = ye((vdr, OMe) => {\n            "use strict";\n            var W4t = gE(), X4t = Jj();\n            OMe.exports = function() {\n              var t3 = X4t();\n              return W4t(Number, { isNaN: t3 }, { isNaN: function() {\n                return Number.isNaN !== t3;\n              } }), t3;\n            };\n          });\n          var VMe = ye((pdr, UMe) => {\n            "use strict";\n            var Z4t = X4(), Y4t = gE(), K4t = Kj(), BMe = Jj(), J4t = qMe(), NMe = Z4t(BMe(), Number);\n            Y4t(NMe, { getPolyfill: BMe, implementation: K4t, shim: J4t });\n            UMe.exports = NMe;\n          });\n          var l4e = ye((gdr, s4e) => {\n            "use strict";\n            function GMe(e3, t3) {\n              return tEt(e3) || eEt(e3, t3) || Q4t(e3, t3) || $4t();\n            }\n            function $4t() {\n              throw new TypeError(`Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);\n            }\n            function Q4t(e3, t3) {\n              if (e3) {\n                if (typeof e3 == "string") return HMe(e3, t3);\n                var r4 = Object.prototype.toString.call(e3).slice(8, -1);\n                if (r4 === "Object" && e3.constructor && (r4 = e3.constructor.name), r4 === "Map" || r4 === "Set") return Array.from(e3);\n                if (r4 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r4)) return HMe(e3, t3);\n              }\n            }\n            function HMe(e3, t3) {\n              (t3 == null || t3 > e3.length) && (t3 = e3.length);\n              for (var r4 = 0, n4 = new Array(t3); r4 < t3; r4++) n4[r4] = e3[r4];\n              return n4;\n            }\n            function eEt(e3, t3) {\n              var r4 = e3 == null ? null : typeof Symbol != "undefined" && e3[Symbol.iterator] || e3["@@iterator"];\n              if (r4 != null) {\n                var n4, i3, a4, o4, s3 = [], l3 = true, u4 = false;\n                try {\n                  if (a4 = (r4 = r4.call(e3)).next, t3 === 0) {\n                    if (Object(r4) !== r4) return;\n                    l3 = false;\n                  } else for (; !(l3 = (n4 = a4.call(r4)).done) && (s3.push(n4.value), s3.length !== t3); l3 = true) ;\n                } catch (c5) {\n                  u4 = true, i3 = c5;\n                } finally {\n                  try {\n                    if (!l3 && r4.return != null && (o4 = r4.return(), Object(o4) !== o4)) return;\n                  } finally {\n                    if (u4) throw i3;\n                  }\n                }\n                return s3;\n              }\n            }\n            function tEt(e3) {\n              if (Array.isArray(e3)) return e3;\n            }\n            function J0(e3) {\n              "@babel/helpers - typeof";\n              return J0 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t3) {\n                return typeof t3;\n              } : function(t3) {\n                return t3 && typeof Symbol == "function" && t3.constructor === Symbol && t3 !== Symbol.prototype ? "symbol" : typeof t3;\n              }, J0(e3);\n            }\n            var rEt = /a/g.flags !== void 0, $R = function(t3) {\n              var r4 = [];\n              return t3.forEach(function(n4) {\n                return r4.push(n4);\n              }), r4;\n            }, jMe = function(t3) {\n              var r4 = [];\n              return t3.forEach(function(n4, i3) {\n                return r4.push([i3, n4]);\n              }), r4;\n            }, r4e = Object.is ? Object.is : DMe(), KR = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {\n              return [];\n            }, $j = Number.isNaN ? Number.isNaN : VMe();\n            function eW(e3) {\n              return e3.call.bind(e3);\n            }\n            var yE = eW(Object.prototype.hasOwnProperty), JR = eW(Object.prototype.propertyIsEnumerable), WMe = eW(Object.prototype.toString), sp = mA().types, iEt = sp.isAnyArrayBuffer, nEt = sp.isArrayBufferView, XMe = sp.isDate, WR = sp.isMap, ZMe = sp.isRegExp, XR = sp.isSet, aEt = sp.isNativeError, oEt = sp.isBoxedPrimitive, YMe = sp.isNumberObject, KMe = sp.isStringObject, JMe = sp.isBooleanObject, $Me = sp.isBigIntObject, sEt = sp.isSymbolObject, lEt = sp.isFloat32Array, uEt = sp.isFloat64Array;\n            function cEt(e3) {\n              if (e3.length === 0 || e3.length > 10) return true;\n              for (var t3 = 0; t3 < e3.length; t3++) {\n                var r4 = e3.charCodeAt(t3);\n                if (r4 < 48 || r4 > 57) return true;\n              }\n              return e3.length === 10 && e3 >= Math.pow(2, 32);\n            }\n            function ZR(e3) {\n              return Object.keys(e3).filter(cEt).concat(KR(e3).filter(Object.prototype.propertyIsEnumerable.bind(e3)));\n            }\n            function i4e(e3, t3) {\n              if (e3 === t3) return 0;\n              for (var r4 = e3.length, n4 = t3.length, i3 = 0, a4 = Math.min(r4, n4); i3 < a4; ++i3) if (e3[i3] !== t3[i3]) {\n                r4 = e3[i3], n4 = t3[i3];\n                break;\n              }\n              return r4 < n4 ? -1 : n4 < r4 ? 1 : 0;\n            }\n            var YR = void 0, fEt = true, hEt = false, Qj = 0, tW = 1, n4e = 2, a4e = 3;\n            function dEt(e3, t3) {\n              return rEt ? e3.source === t3.source && e3.flags === t3.flags : RegExp.prototype.toString.call(e3) === RegExp.prototype.toString.call(t3);\n            }\n            function vEt(e3, t3) {\n              if (e3.byteLength !== t3.byteLength) return false;\n              for (var r4 = 0; r4 < e3.byteLength; r4++) if (e3[r4] !== t3[r4]) return false;\n              return true;\n            }\n            function pEt(e3, t3) {\n              return e3.byteLength !== t3.byteLength ? false : i4e(new Uint8Array(e3.buffer, e3.byteOffset, e3.byteLength), new Uint8Array(t3.buffer, t3.byteOffset, t3.byteLength)) === 0;\n            }\n            function gEt(e3, t3) {\n              return e3.byteLength === t3.byteLength && i4e(new Uint8Array(e3), new Uint8Array(t3)) === 0;\n            }\n            function mEt(e3, t3) {\n              return YMe(e3) ? YMe(t3) && r4e(Number.prototype.valueOf.call(e3), Number.prototype.valueOf.call(t3)) : KMe(e3) ? KMe(t3) && String.prototype.valueOf.call(e3) === String.prototype.valueOf.call(t3) : JMe(e3) ? JMe(t3) && Boolean.prototype.valueOf.call(e3) === Boolean.prototype.valueOf.call(t3) : $Me(e3) ? $Me(t3) && BigInt.prototype.valueOf.call(e3) === BigInt.prototype.valueOf.call(t3) : sEt(t3) && Symbol.prototype.valueOf.call(e3) === Symbol.prototype.valueOf.call(t3);\n            }\n            function $0(e3, t3, r4, n4) {\n              if (e3 === t3) return e3 !== 0 ? true : r4 ? r4e(e3, t3) : true;\n              if (r4) {\n                if (J0(e3) !== "object") return typeof e3 == "number" && $j(e3) && $j(t3);\n                if (J0(t3) !== "object" || e3 === null || t3 === null || Object.getPrototypeOf(e3) !== Object.getPrototypeOf(t3)) return false;\n              } else {\n                if (e3 === null || J0(e3) !== "object") return t3 === null || J0(t3) !== "object" ? e3 == t3 : false;\n                if (t3 === null || J0(t3) !== "object") return false;\n              }\n              var i3 = WMe(e3), a4 = WMe(t3);\n              if (i3 !== a4) return false;\n              if (Array.isArray(e3)) {\n                if (e3.length !== t3.length) return false;\n                var o4 = ZR(e3, YR), s3 = ZR(t3, YR);\n                return o4.length !== s3.length ? false : mE(e3, t3, r4, n4, tW, o4);\n              }\n              if (i3 === "[object Object]" && (!WR(e3) && WR(t3) || !XR(e3) && XR(t3))) return false;\n              if (XMe(e3)) {\n                if (!XMe(t3) || Date.prototype.getTime.call(e3) !== Date.prototype.getTime.call(t3)) return false;\n              } else if (ZMe(e3)) {\n                if (!ZMe(t3) || !dEt(e3, t3)) return false;\n              } else if (aEt(e3) || e3 instanceof Error) {\n                if (e3.message !== t3.message || e3.name !== t3.name) return false;\n              } else if (nEt(e3)) {\n                if (!r4 && (lEt(e3) || uEt(e3))) {\n                  if (!vEt(e3, t3)) return false;\n                } else if (!pEt(e3, t3)) return false;\n                var l3 = ZR(e3, YR), u4 = ZR(t3, YR);\n                return l3.length !== u4.length ? false : mE(e3, t3, r4, n4, Qj, l3);\n              } else {\n                if (XR(e3)) return !XR(t3) || e3.size !== t3.size ? false : mE(e3, t3, r4, n4, n4e);\n                if (WR(e3)) return !WR(t3) || e3.size !== t3.size ? false : mE(e3, t3, r4, n4, a4e);\n                if (iEt(e3)) {\n                  if (!gEt(e3, t3)) return false;\n                } else if (oEt(e3) && !mEt(e3, t3)) return false;\n              }\n              return mE(e3, t3, r4, n4, Qj);\n            }\n            function QMe(e3, t3) {\n              return t3.filter(function(r4) {\n                return JR(e3, r4);\n              });\n            }\n            function mE(e3, t3, r4, n4, i3, a4) {\n              if (arguments.length === 5) {\n                a4 = Object.keys(e3);\n                var o4 = Object.keys(t3);\n                if (a4.length !== o4.length) return false;\n              }\n              for (var s3 = 0; s3 < a4.length; s3++) if (!yE(t3, a4[s3])) return false;\n              if (r4 && arguments.length === 5) {\n                var l3 = KR(e3);\n                if (l3.length !== 0) {\n                  var u4 = 0;\n                  for (s3 = 0; s3 < l3.length; s3++) {\n                    var c5 = l3[s3];\n                    if (JR(e3, c5)) {\n                      if (!JR(t3, c5)) return false;\n                      a4.push(c5), u4++;\n                    } else if (JR(t3, c5)) return false;\n                  }\n                  var f4 = KR(t3);\n                  if (l3.length !== f4.length && QMe(t3, f4).length !== u4) return false;\n                } else {\n                  var h3 = KR(t3);\n                  if (h3.length !== 0 && QMe(t3, h3).length !== 0) return false;\n                }\n              }\n              if (a4.length === 0 && (i3 === Qj || i3 === tW && e3.length === 0 || e3.size === 0)) return true;\n              if (n4 === void 0) n4 = { val1: /* @__PURE__ */ new Map(), val2: /* @__PURE__ */ new Map(), position: 0 };\n              else {\n                var d3 = n4.val1.get(e3);\n                if (d3 !== void 0) {\n                  var v3 = n4.val2.get(t3);\n                  if (v3 !== void 0) return d3 === v3;\n                }\n                n4.position++;\n              }\n              n4.val1.set(e3, n4.position), n4.val2.set(t3, n4.position);\n              var _2 = wEt(e3, t3, r4, a4, n4, i3);\n              return n4.val1.delete(e3), n4.val2.delete(t3), _2;\n            }\n            function e4e(e3, t3, r4, n4) {\n              for (var i3 = $R(e3), a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                if ($0(t3, o4, r4, n4)) return e3.delete(o4), true;\n              }\n              return false;\n            }\n            function o4e(e3) {\n              switch (J0(e3)) {\n                case "undefined":\n                  return null;\n                case "object":\n                  return;\n                case "symbol":\n                  return false;\n                case "string":\n                  e3 = +e3;\n                case "number":\n                  if ($j(e3)) return false;\n              }\n              return true;\n            }\n            function yEt(e3, t3, r4) {\n              var n4 = o4e(r4);\n              return n4 != null ? n4 : t3.has(n4) && !e3.has(n4);\n            }\n            function _Et(e3, t3, r4, n4, i3) {\n              var a4 = o4e(r4);\n              if (a4 != null) return a4;\n              var o4 = t3.get(a4);\n              return o4 === void 0 && !t3.has(a4) || !$0(n4, o4, false, i3) ? false : !e3.has(a4) && $0(n4, o4, false, i3);\n            }\n            function xEt(e3, t3, r4, n4) {\n              for (var i3 = null, a4 = $R(e3), o4 = 0; o4 < a4.length; o4++) {\n                var s3 = a4[o4];\n                if (J0(s3) === "object" && s3 !== null) i3 === null && (i3 = /* @__PURE__ */ new Set()), i3.add(s3);\n                else if (!t3.has(s3)) {\n                  if (r4 || !yEt(e3, t3, s3)) return false;\n                  i3 === null && (i3 = /* @__PURE__ */ new Set()), i3.add(s3);\n                }\n              }\n              if (i3 !== null) {\n                for (var l3 = $R(t3), u4 = 0; u4 < l3.length; u4++) {\n                  var c5 = l3[u4];\n                  if (J0(c5) === "object" && c5 !== null) {\n                    if (!e4e(i3, c5, r4, n4)) return false;\n                  } else if (!r4 && !e3.has(c5) && !e4e(i3, c5, r4, n4)) return false;\n                }\n                return i3.size === 0;\n              }\n              return true;\n            }\n            function t4e(e3, t3, r4, n4, i3, a4) {\n              for (var o4 = $R(e3), s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3];\n                if ($0(r4, l3, i3, a4) && $0(n4, t3.get(l3), i3, a4)) return e3.delete(l3), true;\n              }\n              return false;\n            }\n            function bEt(e3, t3, r4, n4) {\n              for (var i3 = null, a4 = jMe(e3), o4 = 0; o4 < a4.length; o4++) {\n                var s3 = GMe(a4[o4], 2), l3 = s3[0], u4 = s3[1];\n                if (J0(l3) === "object" && l3 !== null) i3 === null && (i3 = /* @__PURE__ */ new Set()), i3.add(l3);\n                else {\n                  var c5 = t3.get(l3);\n                  if (c5 === void 0 && !t3.has(l3) || !$0(u4, c5, r4, n4)) {\n                    if (r4 || !_Et(e3, t3, l3, u4, n4)) return false;\n                    i3 === null && (i3 = /* @__PURE__ */ new Set()), i3.add(l3);\n                  }\n                }\n              }\n              if (i3 !== null) {\n                for (var f4 = jMe(t3), h3 = 0; h3 < f4.length; h3++) {\n                  var d3 = GMe(f4[h3], 2), v3 = d3[0], _2 = d3[1];\n                  if (J0(v3) === "object" && v3 !== null) {\n                    if (!t4e(i3, e3, v3, _2, r4, n4)) return false;\n                  } else if (!r4 && (!e3.has(v3) || !$0(e3.get(v3), _2, false, n4)) && !t4e(i3, e3, v3, _2, false, n4)) return false;\n                }\n                return i3.size === 0;\n              }\n              return true;\n            }\n            function wEt(e3, t3, r4, n4, i3, a4) {\n              var o4 = 0;\n              if (a4 === n4e) {\n                if (!xEt(e3, t3, r4, i3)) return false;\n              } else if (a4 === a4e) {\n                if (!bEt(e3, t3, r4, i3)) return false;\n              } else if (a4 === tW) for (; o4 < e3.length; o4++) if (yE(e3, o4)) {\n                if (!yE(t3, o4) || !$0(e3[o4], t3[o4], r4, i3)) return false;\n              } else {\n                if (yE(t3, o4)) return false;\n                for (var s3 = Object.keys(e3); o4 < s3.length; o4++) {\n                  var l3 = s3[o4];\n                  if (!yE(t3, l3) || !$0(e3[l3], t3[l3], r4, i3)) return false;\n                }\n                return s3.length === Object.keys(t3).length;\n              }\n              for (o4 = 0; o4 < n4.length; o4++) {\n                var u4 = n4[o4];\n                if (!$0(e3[u4], t3[u4], r4, i3)) return false;\n              }\n              return true;\n            }\n            function TEt(e3, t3) {\n              return $0(e3, t3, hEt);\n            }\n            function AEt(e3, t3) {\n              return $0(e3, t3, fEt);\n            }\n            s4e.exports = { isDeepEqual: TEt, isDeepStrictEqual: AEt };\n          });\n          var lE = ye((mdr, M4e) => {\n            "use strict";\n            function Wg(e3) {\n              "@babel/helpers - typeof";\n              return Wg = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t3) {\n                return typeof t3;\n              } : function(t3) {\n                return t3 && typeof Symbol == "function" && t3.constructor === Symbol && t3 !== Symbol.prototype ? "symbol" : typeof t3;\n              }, Wg(e3);\n            }\n            function u4e(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4];\n                n4.enumerable = n4.enumerable || false, n4.configurable = true, "value" in n4 && (n4.writable = true), Object.defineProperty(e3, MEt(n4.key), n4);\n              }\n            }\n            function SEt(e3, t3, r4) {\n              return t3 && u4e(e3.prototype, t3), r4 && u4e(e3, r4), Object.defineProperty(e3, "prototype", { writable: false }), e3;\n            }\n            function MEt(e3) {\n              var t3 = EEt(e3, "string");\n              return Wg(t3) === "symbol" ? t3 : String(t3);\n            }\n            function EEt(e3, t3) {\n              if (Wg(e3) !== "object" || e3 === null) return e3;\n              var r4 = e3[Symbol.toPrimitive];\n              if (r4 !== void 0) {\n                var n4 = r4.call(e3, t3 || "default");\n                if (Wg(n4) !== "object") return n4;\n                throw new TypeError("@@toPrimitive must return a primitive value.");\n              }\n              return (t3 === "string" ? String : Number)(e3);\n            }\n            function kEt(e3, t3) {\n              if (!(e3 instanceof t3)) throw new TypeError("Cannot call a class as a function");\n            }\n            var CEt = Nj(), _E = CEt.codes, c4e = _E.ERR_AMBIGUOUS_ARGUMENT, _A = _E.ERR_INVALID_ARG_TYPE, LEt = _E.ERR_INVALID_ARG_VALUE, PEt = _E.ERR_INVALID_RETURN_VALUE, N_ = _E.ERR_MISSING_ARGS, U_ = QSe(), IEt = mA(), QR = IEt.inspect, v4e = mA().types, REt = v4e.isPromise, eD = v4e.isRegExp, DEt = bMe()(), p4e = jR()(), tD = lA()("RegExp.prototype.test"), B_, rD;\n            function xE() {\n              var e3 = l4e();\n              B_ = e3.isDeepEqual, rD = e3.isDeepStrictEqual;\n            }\n            var f4e = false, Ef = M4e.exports = rW, iD = {};\n            function Xg(e3) {\n              throw e3.message instanceof Error ? e3.message : new U_(e3);\n            }\n            function g4e(e3, t3, r4, n4, i3) {\n              var a4 = arguments.length, o4;\n              if (a4 === 0) o4 = "Failed";\n              else if (a4 === 1) r4 = e3, e3 = void 0;\n              else {\n                if (f4e === false) {\n                  f4e = true;\n                  var s3 = process.emitWarning ? process.emitWarning : console.warn.bind(console);\n                  s3("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");\n                }\n                a4 === 2 && (n4 = "!=");\n              }\n              if (r4 instanceof Error) throw r4;\n              var l3 = { actual: e3, expected: t3, operator: n4 === void 0 ? "fail" : n4, stackStartFn: i3 || g4e };\n              r4 !== void 0 && (l3.message = r4);\n              var u4 = new U_(l3);\n              throw o4 && (u4.message = o4, u4.generatedMessage = true), u4;\n            }\n            Ef.fail = g4e;\n            Ef.AssertionError = U_;\n            function m4e(e3, t3, r4, n4) {\n              if (!r4) {\n                var i3 = false;\n                if (t3 === 0) i3 = true, n4 = "No value argument passed to `assert.ok()`";\n                else if (n4 instanceof Error) throw n4;\n                var a4 = new U_({ actual: r4, expected: true, message: n4, operator: "==", stackStartFn: e3 });\n                throw a4.generatedMessage = i3, a4;\n              }\n            }\n            function rW() {\n              for (var e3 = arguments.length, t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = arguments[r4];\n              m4e.apply(void 0, [rW, t3.length].concat(t3));\n            }\n            Ef.ok = rW;\n            Ef.equal = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              t3 != r4 && Xg({ actual: t3, expected: r4, message: n4, operator: "==", stackStartFn: e3 });\n            };\n            Ef.notEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              t3 == r4 && Xg({ actual: t3, expected: r4, message: n4, operator: "!=", stackStartFn: e3 });\n            };\n            Ef.deepEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              B_ === void 0 && xE(), B_(t3, r4) || Xg({ actual: t3, expected: r4, message: n4, operator: "deepEqual", stackStartFn: e3 });\n            };\n            Ef.notDeepEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              B_ === void 0 && xE(), B_(t3, r4) && Xg({ actual: t3, expected: r4, message: n4, operator: "notDeepEqual", stackStartFn: e3 });\n            };\n            Ef.deepStrictEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              B_ === void 0 && xE(), rD(t3, r4) || Xg({ actual: t3, expected: r4, message: n4, operator: "deepStrictEqual", stackStartFn: e3 });\n            };\n            Ef.notDeepStrictEqual = y4e;\n            function y4e(e3, t3, r4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              B_ === void 0 && xE(), rD(e3, t3) && Xg({ actual: e3, expected: t3, message: r4, operator: "notDeepStrictEqual", stackStartFn: y4e });\n            }\n            Ef.strictEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              p4e(t3, r4) || Xg({ actual: t3, expected: r4, message: n4, operator: "strictEqual", stackStartFn: e3 });\n            };\n            Ef.notStrictEqual = function e3(t3, r4, n4) {\n              if (arguments.length < 2) throw new N_("actual", "expected");\n              p4e(t3, r4) && Xg({ actual: t3, expected: r4, message: n4, operator: "notStrictEqual", stackStartFn: e3 });\n            };\n            var h4e = SEt(function e3(t3, r4, n4) {\n              var i3 = this;\n              kEt(this, e3), r4.forEach(function(a4) {\n                a4 in t3 && (n4 !== void 0 && typeof n4[a4] == "string" && eD(t3[a4]) && tD(t3[a4], n4[a4]) ? i3[a4] = n4[a4] : i3[a4] = t3[a4]);\n              });\n            });\n            function FEt(e3, t3, r4, n4, i3, a4) {\n              if (!(r4 in e3) || !rD(e3[r4], t3[r4])) {\n                if (!n4) {\n                  var o4 = new h4e(e3, i3), s3 = new h4e(t3, i3, e3), l3 = new U_({ actual: o4, expected: s3, operator: "deepStrictEqual", stackStartFn: a4 });\n                  throw l3.actual = e3, l3.expected = t3, l3.operator = a4.name, l3;\n                }\n                Xg({ actual: e3, expected: t3, message: n4, operator: a4.name, stackStartFn: a4 });\n              }\n            }\n            function _4e(e3, t3, r4, n4) {\n              if (typeof t3 != "function") {\n                if (eD(t3)) return tD(t3, e3);\n                if (arguments.length === 2) throw new _A("expected", ["Function", "RegExp"], t3);\n                if (Wg(e3) !== "object" || e3 === null) {\n                  var i3 = new U_({ actual: e3, expected: t3, message: r4, operator: "deepStrictEqual", stackStartFn: n4 });\n                  throw i3.operator = n4.name, i3;\n                }\n                var a4 = Object.keys(t3);\n                if (t3 instanceof Error) a4.push("name", "message");\n                else if (a4.length === 0) throw new LEt("error", t3, "may not be an empty object");\n                return B_ === void 0 && xE(), a4.forEach(function(o4) {\n                  typeof e3[o4] == "string" && eD(t3[o4]) && tD(t3[o4], e3[o4]) || FEt(e3, t3, o4, r4, a4, n4);\n                }), true;\n              }\n              return t3.prototype !== void 0 && e3 instanceof t3 ? true : Error.isPrototypeOf(t3) ? false : t3.call({}, e3) === true;\n            }\n            function x4e(e3) {\n              if (typeof e3 != "function") throw new _A("fn", "Function", e3);\n              try {\n                e3();\n              } catch (t3) {\n                return t3;\n              }\n              return iD;\n            }\n            function d4e(e3) {\n              return REt(e3) || e3 !== null && Wg(e3) === "object" && typeof e3.then == "function" && typeof e3.catch == "function";\n            }\n            function b4e(e3) {\n              return Promise.resolve().then(function() {\n                var t3;\n                if (typeof e3 == "function") {\n                  if (t3 = e3(), !d4e(t3)) throw new PEt("instance of Promise", "promiseFn", t3);\n                } else if (d4e(e3)) t3 = e3;\n                else throw new _A("promiseFn", ["Function", "Promise"], e3);\n                return Promise.resolve().then(function() {\n                  return t3;\n                }).then(function() {\n                  return iD;\n                }).catch(function(r4) {\n                  return r4;\n                });\n              });\n            }\n            function w4e(e3, t3, r4, n4) {\n              if (typeof r4 == "string") {\n                if (arguments.length === 4) throw new _A("error", ["Object", "Error", "Function", "RegExp"], r4);\n                if (Wg(t3) === "object" && t3 !== null) {\n                  if (t3.message === r4) throw new c4e("error/message", \'The error message "\'.concat(t3.message, \'" is identical to the message.\'));\n                } else if (t3 === r4) throw new c4e("error/message", \'The error "\'.concat(t3, \'" is identical to the message.\'));\n                n4 = r4, r4 = void 0;\n              } else if (r4 != null && Wg(r4) !== "object" && typeof r4 != "function") throw new _A("error", ["Object", "Error", "Function", "RegExp"], r4);\n              if (t3 === iD) {\n                var i3 = "";\n                r4 && r4.name && (i3 += " (".concat(r4.name, ")")), i3 += n4 ? ": ".concat(n4) : ".";\n                var a4 = e3.name === "rejects" ? "rejection" : "exception";\n                Xg({ actual: void 0, expected: r4, operator: e3.name, message: "Missing expected ".concat(a4).concat(i3), stackStartFn: e3 });\n              }\n              if (r4 && !_4e(t3, r4, n4, e3)) throw t3;\n            }\n            function T4e(e3, t3, r4, n4) {\n              if (t3 !== iD) {\n                if (typeof r4 == "string" && (n4 = r4, r4 = void 0), !r4 || _4e(t3, r4)) {\n                  var i3 = n4 ? ": ".concat(n4) : ".", a4 = e3.name === "doesNotReject" ? "rejection" : "exception";\n                  Xg({ actual: t3, expected: r4, operator: e3.name, message: "Got unwanted ".concat(a4).concat(i3, `\n`) + \'Actual message: "\'.concat(t3 && t3.message, \'"\'), stackStartFn: e3 });\n                }\n                throw t3;\n              }\n            }\n            Ef.throws = function e3(t3) {\n              for (var r4 = arguments.length, n4 = new Array(r4 > 1 ? r4 - 1 : 0), i3 = 1; i3 < r4; i3++) n4[i3 - 1] = arguments[i3];\n              w4e.apply(void 0, [e3, x4e(t3)].concat(n4));\n            };\n            Ef.rejects = function e3(t3) {\n              for (var r4 = arguments.length, n4 = new Array(r4 > 1 ? r4 - 1 : 0), i3 = 1; i3 < r4; i3++) n4[i3 - 1] = arguments[i3];\n              return b4e(t3).then(function(a4) {\n                return w4e.apply(void 0, [e3, a4].concat(n4));\n              });\n            };\n            Ef.doesNotThrow = function e3(t3) {\n              for (var r4 = arguments.length, n4 = new Array(r4 > 1 ? r4 - 1 : 0), i3 = 1; i3 < r4; i3++) n4[i3 - 1] = arguments[i3];\n              T4e.apply(void 0, [e3, x4e(t3)].concat(n4));\n            };\n            Ef.doesNotReject = function e3(t3) {\n              for (var r4 = arguments.length, n4 = new Array(r4 > 1 ? r4 - 1 : 0), i3 = 1; i3 < r4; i3++) n4[i3 - 1] = arguments[i3];\n              return b4e(t3).then(function(a4) {\n                return T4e.apply(void 0, [e3, a4].concat(n4));\n              });\n            };\n            Ef.ifError = function e3(t3) {\n              if (t3 != null) {\n                var r4 = "ifError got unwanted exception: ";\n                Wg(t3) === "object" && typeof t3.message == "string" ? t3.message.length === 0 && t3.constructor ? r4 += t3.constructor.name : r4 += t3.message : r4 += QR(t3);\n                var n4 = new U_({ actual: t3, expected: null, operator: "ifError", message: r4, stackStartFn: e3 }), i3 = t3.stack;\n                if (typeof i3 == "string") {\n                  var a4 = i3.split(`\n`);\n                  a4.shift();\n                  for (var o4 = n4.stack.split(`\n`), s3 = 0; s3 < a4.length; s3++) {\n                    var l3 = o4.indexOf(a4[s3]);\n                    if (l3 !== -1) {\n                      o4 = o4.slice(0, l3);\n                      break;\n                    }\n                  }\n                  n4.stack = "".concat(o4.join(`\n`), `\n`).concat(a4.join(`\n`));\n                }\n                throw n4;\n              }\n            };\n            function A4e(e3, t3, r4, n4, i3) {\n              if (!eD(t3)) throw new _A("regexp", "RegExp", t3);\n              var a4 = i3 === "match";\n              if (typeof e3 != "string" || tD(t3, e3) !== a4) {\n                if (r4 instanceof Error) throw r4;\n                var o4 = !r4;\n                r4 = r4 || (typeof e3 != "string" ? \'The "string" argument must be of type string. Received type \' + "".concat(Wg(e3), " (").concat(QR(e3), ")") : (a4 ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(QR(t3), `. Input:\n\n`).concat(QR(e3), `\n`));\n                var s3 = new U_({ actual: e3, expected: t3, message: r4, operator: i3, stackStartFn: n4 });\n                throw s3.generatedMessage = o4, s3;\n              }\n            }\n            Ef.match = function e3(t3, r4, n4) {\n              A4e(t3, r4, n4, e3, "match");\n            };\n            Ef.doesNotMatch = function e3(t3, r4, n4) {\n              A4e(t3, r4, n4, e3, "doesNotMatch");\n            };\n            function S4e() {\n              for (var e3 = arguments.length, t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = arguments[r4];\n              m4e.apply(void 0, [S4e, t3.length].concat(t3));\n            }\n            Ef.strict = DEt(S4e, Ef, { equal: Ef.strictEqual, deepEqual: Ef.deepStrictEqual, notEqual: Ef.notStrictEqual, notDeepEqual: Ef.notDeepStrictEqual });\n            Ef.strict.strict = Ef.strict;\n          });\n          var k4e = ye((ydr, E4e) => {\n            var bE = 1e3, wE = bE * 60, TE = wE * 60, AE = TE * 24, zEt = AE * 365.25;\n            E4e.exports = function(e3, t3) {\n              t3 = t3 || {};\n              var r4 = typeof e3;\n              if (r4 === "string" && e3.length > 0) return OEt(e3);\n              if (r4 === "number" && isNaN(e3) === false) return t3.long ? BEt(e3) : qEt(e3);\n              throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(e3));\n            };\n            function OEt(e3) {\n              if (e3 = String(e3), !(e3.length > 100)) {\n                var t3 = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(e3);\n                if (t3) {\n                  var r4 = parseFloat(t3[1]), n4 = (t3[2] || "ms").toLowerCase();\n                  switch (n4) {\n                    case "years":\n                    case "year":\n                    case "yrs":\n                    case "yr":\n                    case "y":\n                      return r4 * zEt;\n                    case "days":\n                    case "day":\n                    case "d":\n                      return r4 * AE;\n                    case "hours":\n                    case "hour":\n                    case "hrs":\n                    case "hr":\n                    case "h":\n                      return r4 * TE;\n                    case "minutes":\n                    case "minute":\n                    case "mins":\n                    case "min":\n                    case "m":\n                      return r4 * wE;\n                    case "seconds":\n                    case "second":\n                    case "secs":\n                    case "sec":\n                    case "s":\n                      return r4 * bE;\n                    case "milliseconds":\n                    case "millisecond":\n                    case "msecs":\n                    case "msec":\n                    case "ms":\n                      return r4;\n                    default:\n                      return;\n                  }\n                }\n              }\n            }\n            function qEt(e3) {\n              return e3 >= AE ? Math.round(e3 / AE) + "d" : e3 >= TE ? Math.round(e3 / TE) + "h" : e3 >= wE ? Math.round(e3 / wE) + "m" : e3 >= bE ? Math.round(e3 / bE) + "s" : e3 + "ms";\n            }\n            function BEt(e3) {\n              return nD(e3, AE, "day") || nD(e3, TE, "hour") || nD(e3, wE, "minute") || nD(e3, bE, "second") || e3 + " ms";\n            }\n            function nD(e3, t3, r4) {\n              if (!(e3 < t3)) return e3 < t3 * 1.5 ? Math.floor(e3 / t3) + " " + r4 : Math.ceil(e3 / t3) + " " + r4 + "s";\n            }\n          });\n          var L4e = ye((Lc, C4e) => {\n            Lc = C4e.exports = nW.debug = nW.default = nW;\n            Lc.coerce = HEt;\n            Lc.disable = VEt;\n            Lc.enable = UEt;\n            Lc.enabled = GEt;\n            Lc.humanize = k4e();\n            Lc.names = [];\n            Lc.skips = [];\n            Lc.formatters = {};\n            var iW;\n            function NEt(e3) {\n              var t3 = 0, r4;\n              for (r4 in e3) t3 = (t3 << 5) - t3 + e3.charCodeAt(r4), t3 |= 0;\n              return Lc.colors[Math.abs(t3) % Lc.colors.length];\n            }\n            function nW(e3) {\n              function t3() {\n                if (t3.enabled) {\n                  var r4 = t3, n4 = +/* @__PURE__ */ new Date(), i3 = n4 - (iW || n4);\n                  r4.diff = i3, r4.prev = iW, r4.curr = n4, iW = n4;\n                  for (var a4 = new Array(arguments.length), o4 = 0; o4 < a4.length; o4++) a4[o4] = arguments[o4];\n                  a4[0] = Lc.coerce(a4[0]), typeof a4[0] != "string" && a4.unshift("%O");\n                  var s3 = 0;\n                  a4[0] = a4[0].replace(/%([a-zA-Z%])/g, function(u4, c5) {\n                    if (u4 === "%%") return u4;\n                    s3++;\n                    var f4 = Lc.formatters[c5];\n                    if (typeof f4 == "function") {\n                      var h3 = a4[s3];\n                      u4 = f4.call(r4, h3), a4.splice(s3, 1), s3--;\n                    }\n                    return u4;\n                  }), Lc.formatArgs.call(r4, a4);\n                  var l3 = t3.log || Lc.log || console.log.bind(console);\n                  l3.apply(r4, a4);\n                }\n              }\n              return t3.namespace = e3, t3.enabled = Lc.enabled(e3), t3.useColors = Lc.useColors(), t3.color = NEt(e3), typeof Lc.init == "function" && Lc.init(t3), t3;\n            }\n            function UEt(e3) {\n              Lc.save(e3), Lc.names = [], Lc.skips = [];\n              for (var t3 = (typeof e3 == "string" ? e3 : "").split(/[\\s,]+/), r4 = t3.length, n4 = 0; n4 < r4; n4++) t3[n4] && (e3 = t3[n4].replace(/\\*/g, ".*?"), e3[0] === "-" ? Lc.skips.push(new RegExp("^" + e3.substr(1) + "$")) : Lc.names.push(new RegExp("^" + e3 + "$")));\n            }\n            function VEt() {\n              Lc.enable("");\n            }\n            function GEt(e3) {\n              var t3, r4;\n              for (t3 = 0, r4 = Lc.skips.length; t3 < r4; t3++) if (Lc.skips[t3].test(e3)) return false;\n              for (t3 = 0, r4 = Lc.names.length; t3 < r4; t3++) if (Lc.names[t3].test(e3)) return true;\n              return false;\n            }\n            function HEt(e3) {\n              return e3 instanceof Error ? e3.stack || e3.message : e3;\n            }\n          });\n          var R4e = ye((lp, I4e) => {\n            lp = I4e.exports = L4e();\n            lp.log = XEt;\n            lp.formatArgs = WEt;\n            lp.save = ZEt;\n            lp.load = P4e;\n            lp.useColors = jEt;\n            lp.storage = typeof chrome != "undefined" && typeof chrome.storage != "undefined" ? chrome.storage.local : YEt();\n            lp.colors = ["lightseagreen", "forestgreen", "goldenrod", "dodgerblue", "darkorchid", "crimson"];\n            function jEt() {\n              return typeof window != "undefined" && window.process && window.process.type === "renderer" ? true : typeof document != "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window != "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator != "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator != "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/);\n            }\n            lp.formatters.j = function(e3) {\n              try {\n                return JSON.stringify(e3);\n              } catch (t3) {\n                return "[UnexpectedJSONParseError]: " + t3.message;\n              }\n            };\n            function WEt(e3) {\n              var t3 = this.useColors;\n              if (e3[0] = (t3 ? "%c" : "") + this.namespace + (t3 ? " %c" : " ") + e3[0] + (t3 ? "%c " : " ") + "+" + lp.humanize(this.diff), !!t3) {\n                var r4 = "color: " + this.color;\n                e3.splice(1, 0, r4, "color: inherit");\n                var n4 = 0, i3 = 0;\n                e3[0].replace(/%[a-zA-Z%]/g, function(a4) {\n                  a4 !== "%%" && (n4++, a4 === "%c" && (i3 = n4));\n                }), e3.splice(i3, 0, r4);\n              }\n            }\n            function XEt() {\n              return typeof console == "object" && console.log && Function.prototype.apply.call(console.log, console, arguments);\n            }\n            function ZEt(e3) {\n              try {\n                e3 == null ? lp.storage.removeItem("debug") : lp.storage.debug = e3;\n              } catch (t3) {\n              }\n            }\n            function P4e() {\n              var e3;\n              try {\n                e3 = lp.storage.debug;\n              } catch (t3) {\n              }\n              return !e3 && typeof process != "undefined" && "env" in process && (e3 = process.env.DEBUG), e3;\n            }\n            lp.enable(P4e());\n            function YEt() {\n              try {\n                return window.localStorage;\n              } catch (e3) {\n              }\n            }\n          });\n          var U4e = ye((_dr, N4e) => {\n            var xA = lE(), V_ = R4e()("stream-parser");\n            N4e.exports = JEt;\n            var F4e = -1, aD = 0, KEt = 1, z4e = 2;\n            function JEt(e3) {\n              var t3 = e3 && typeof e3._transform == "function", r4 = e3 && typeof e3._write == "function";\n              if (!t3 && !r4) throw new Error("must pass a Writable or Transform stream in");\n              V_("extending Parser into stream"), e3._bytes = $Et, e3._skipBytes = QEt, t3 && (e3._passthrough = ekt), t3 ? e3._transform = rkt : e3._write = tkt;\n            }\n            function SE(e3) {\n              V_("initializing parser stream"), e3._parserBytesLeft = 0, e3._parserBuffers = [], e3._parserBuffered = 0, e3._parserState = F4e, e3._parserCallback = null, typeof e3.push == "function" && (e3._parserOutput = e3.push.bind(e3)), e3._parserInit = true;\n            }\n            function $Et(e3, t3) {\n              xA(!this._parserCallback, \'there is already a "callback" set!\'), xA(isFinite(e3) && e3 > 0, \'can only buffer a finite number of bytes > 0, got "\' + e3 + \'"\'), this._parserInit || SE(this), V_("buffering %o bytes", e3), this._parserBytesLeft = e3, this._parserCallback = t3, this._parserState = aD;\n            }\n            function QEt(e3, t3) {\n              xA(!this._parserCallback, \'there is already a "callback" set!\'), xA(e3 > 0, \'can only skip > 0 bytes, got "\' + e3 + \'"\'), this._parserInit || SE(this), V_("skipping %o bytes", e3), this._parserBytesLeft = e3, this._parserCallback = t3, this._parserState = KEt;\n            }\n            function ekt(e3, t3) {\n              xA(!this._parserCallback, \'There is already a "callback" set!\'), xA(e3 > 0, \'can only pass through > 0 bytes, got "\' + e3 + \'"\'), this._parserInit || SE(this), V_("passing through %o bytes", e3), this._parserBytesLeft = e3, this._parserCallback = t3, this._parserState = z4e;\n            }\n            function tkt(e3, t3, r4) {\n              this._parserInit || SE(this), V_("write(%o bytes)", e3.length), typeof t3 == "function" && (r4 = t3), q4e(this, e3, null, r4);\n            }\n            function rkt(e3, t3, r4) {\n              this._parserInit || SE(this), V_("transform(%o bytes)", e3.length), typeof t3 != "function" && (t3 = this._parserOutput), q4e(this, e3, t3, r4);\n            }\n            function O4e(e3, t3, r4, n4) {\n              return e3._parserBytesLeft <= 0 ? n4(new Error("got data but not currently parsing anything")) : t3.length <= e3._parserBytesLeft ? function() {\n                return D4e(e3, t3, r4, n4);\n              } : function() {\n                var i3 = t3.slice(0, e3._parserBytesLeft);\n                return D4e(e3, i3, r4, function(a4) {\n                  if (a4) return n4(a4);\n                  if (t3.length > i3.length) return function() {\n                    return O4e(e3, t3.slice(i3.length), r4, n4);\n                  };\n                });\n              };\n            }\n            function D4e(e3, t3, r4, n4) {\n              if (e3._parserBytesLeft -= t3.length, V_("%o bytes left for stream piece", e3._parserBytesLeft), e3._parserState === aD ? (e3._parserBuffers.push(t3), e3._parserBuffered += t3.length) : e3._parserState === z4e && r4(t3), e3._parserBytesLeft === 0) {\n                var i3 = e3._parserCallback;\n                if (i3 && e3._parserState === aD && e3._parserBuffers.length > 1 && (t3 = Buffer.concat(e3._parserBuffers, e3._parserBuffered)), e3._parserState !== aD && (t3 = null), e3._parserCallback = null, e3._parserBuffered = 0, e3._parserState = F4e, e3._parserBuffers.splice(0), i3) {\n                  var a4 = [];\n                  t3 && a4.push(t3), r4 && a4.push(r4);\n                  var o4 = i3.length > a4.length;\n                  o4 && a4.push(B4e(n4));\n                  var s3 = i3.apply(e3, a4);\n                  if (!o4 || n4 === s3) return n4;\n                }\n              } else return n4;\n            }\n            var q4e = B4e(O4e);\n            function B4e(e3) {\n              return function() {\n                for (var t3 = e3.apply(this, arguments); typeof t3 == "function"; ) t3 = t3();\n                return t3;\n              };\n            }\n          });\n          var rc = ye((Hy) => {\n            "use strict";\n            var V4e = DSe().Transform, ikt = U4e();\n            function ME() {\n              V4e.call(this, { readableObjectMode: true });\n            }\n            ME.prototype = Object.create(V4e.prototype);\n            ME.prototype.constructor = ME;\n            ikt(ME.prototype);\n            Hy.ParserStream = ME;\n            Hy.sliceEq = function(e3, t3, r4) {\n              for (var n4 = t3, i3 = 0; i3 < r4.length; ) if (e3[n4++] !== r4[i3++]) return false;\n              return true;\n            };\n            Hy.str2arr = function(e3, t3) {\n              var r4 = [], n4 = 0;\n              if (t3 && t3 === "hex") for (; n4 < e3.length; ) r4.push(parseInt(e3.slice(n4, n4 + 2), 16)), n4 += 2;\n              else for (; n4 < e3.length; n4++) r4.push(e3.charCodeAt(n4) & 255);\n              return r4;\n            };\n            Hy.readUInt16LE = function(e3, t3) {\n              return e3[t3] | e3[t3 + 1] << 8;\n            };\n            Hy.readUInt16BE = function(e3, t3) {\n              return e3[t3 + 1] | e3[t3] << 8;\n            };\n            Hy.readUInt32LE = function(e3, t3) {\n              return e3[t3] | e3[t3 + 1] << 8 | e3[t3 + 2] << 16 | e3[t3 + 3] * 16777216;\n            };\n            Hy.readUInt32BE = function(e3, t3) {\n              return e3[t3 + 3] | e3[t3 + 2] << 8 | e3[t3 + 1] << 16 | e3[t3] * 16777216;\n            };\n            function oD(e3, t3, r4) {\n              Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack || "", this.name = this.constructor.name, this.message = e3, t3 && (this.code = t3), r4 && (this.statusCode = r4);\n            }\n            oD.prototype = Object.create(Error.prototype);\n            oD.prototype.constructor = oD;\n            Hy.ProbeError = oD;\n          });\n          var G4e = ye((bdr, sD) => {\n            "use strict";\n            var bA = rc().readUInt16BE, oW = rc().readUInt32BE;\n            function EE(e3, t3) {\n              if (e3.length < 4 + t3) return null;\n              var r4 = oW(e3, t3);\n              return e3.length < r4 + t3 || r4 < 8 ? null : { boxtype: String.fromCharCode.apply(null, e3.slice(t3 + 4, t3 + 8)), data: e3.slice(t3 + 8, t3 + r4), end: t3 + r4 };\n            }\n            sD.exports.unbox = EE;\n            function nkt(e3, t3) {\n              for (var r4 = 0; ; ) {\n                var n4 = EE(e3, r4);\n                if (!n4) break;\n                switch (n4.boxtype) {\n                  case "ispe":\n                    t3.sizes.push({ width: oW(n4.data, 4), height: oW(n4.data, 8) });\n                    break;\n                  case "irot":\n                    t3.transforms.push({ type: "irot", value: n4.data[0] & 3 });\n                    break;\n                  case "imir":\n                    t3.transforms.push({ type: "imir", value: n4.data[0] & 1 });\n                    break;\n                }\n                r4 = n4.end;\n              }\n            }\n            function aW(e3, t3, r4) {\n              for (var n4 = 0, i3 = 0; i3 < r4; i3++) n4 = n4 * 256 + (e3[t3 + i3] || 0);\n              return n4;\n            }\n            function akt(e3, t3) {\n              for (var r4 = e3[4] >> 4 & 15, n4 = e3[4] & 15, i3 = e3[5] >> 4 & 15, a4 = bA(e3, 6), o4 = 8, s3 = 0; s3 < a4; s3++) {\n                var l3 = bA(e3, o4);\n                o4 += 2;\n                var u4 = bA(e3, o4);\n                o4 += 2;\n                var c5 = aW(e3, o4, i3);\n                o4 += i3;\n                var f4 = bA(e3, o4);\n                if (o4 += 2, u4 === 0 && f4 === 1) {\n                  var h3 = aW(e3, o4, r4), d3 = aW(e3, o4 + r4, n4);\n                  t3.item_loc[l3] = { length: d3, offset: h3 + c5 };\n                }\n                o4 += f4 * (r4 + n4);\n              }\n            }\n            function okt(e3, t3) {\n              for (var r4 = bA(e3, 4), n4 = 6, i3 = 0; i3 < r4; i3++) {\n                var a4 = EE(e3, n4);\n                if (!a4) break;\n                if (a4.boxtype === "infe") {\n                  for (var o4 = bA(a4.data, 4), s3 = "", l3 = 8; l3 < a4.data.length && a4.data[l3]; l3++) s3 += String.fromCharCode(a4.data[l3]);\n                  t3.item_inf[s3] = o4;\n                }\n                n4 = a4.end;\n              }\n            }\n            function skt(e3, t3) {\n              for (var r4 = 0; ; ) {\n                var n4 = EE(e3, r4);\n                if (!n4) break;\n                n4.boxtype === "ipco" && nkt(n4.data, t3), r4 = n4.end;\n              }\n            }\n            function lkt(e3, t3) {\n              for (var r4 = 4; ; ) {\n                var n4 = EE(e3, r4);\n                if (!n4) break;\n                n4.boxtype === "iprp" && skt(n4.data, t3), n4.boxtype === "iloc" && akt(n4.data, t3), n4.boxtype === "iinf" && okt(n4.data, t3), r4 = n4.end;\n              }\n            }\n            function ukt(e3) {\n              var t3 = e3.reduce(function(i3, a4) {\n                return i3.width > a4.width || i3.width === a4.width && i3.height > a4.height ? i3 : a4;\n              }), r4 = e3.reduce(function(i3, a4) {\n                return i3.height > a4.height || i3.height === a4.height && i3.width > a4.width ? i3 : a4;\n              }), n4;\n              return t3.width > r4.height || t3.width === r4.height && t3.height > r4.width ? n4 = t3 : n4 = r4, n4;\n            }\n            sD.exports.readSizeFromMeta = function(e3) {\n              var t3 = { sizes: [], transforms: [], item_inf: {}, item_loc: {} };\n              if (lkt(e3, t3), !!t3.sizes.length) {\n                var r4 = ukt(t3.sizes), n4 = 1;\n                t3.transforms.forEach(function(a4) {\n                  var o4 = { 1: 6, 2: 5, 3: 8, 4: 7, 5: 4, 6: 3, 7: 2, 8: 1 }, s3 = { 1: 4, 2: 3, 3: 2, 4: 1, 5: 6, 6: 5, 7: 8, 8: 7 };\n                  if (a4.type === "imir" && (a4.value === 0 ? n4 = s3[n4] : (n4 = s3[n4], n4 = o4[n4], n4 = o4[n4])), a4.type === "irot") for (var l3 = 0; l3 < a4.value; l3++) n4 = o4[n4];\n                });\n                var i3 = null;\n                return t3.item_inf.Exif && (i3 = t3.item_loc[t3.item_inf.Exif]), { width: r4.width, height: r4.height, orientation: t3.transforms.length ? n4 : null, variants: t3.sizes, exif_location: i3 };\n              }\n            };\n            sD.exports.getMimeType = function(e3) {\n              var t3 = String.fromCharCode.apply(null, e3.slice(0, 4)), r4 = {};\n              r4[t3] = true;\n              for (var n4 = 8; n4 < e3.length; n4 += 4) r4[String.fromCharCode.apply(null, e3.slice(n4, n4 + 4))] = true;\n              if (!(!r4.mif1 && !r4.msf1 && !r4.miaf)) return t3 === "avif" || t3 === "avis" || t3 === "avio" ? { type: "avif", mime: "image/avif" } : t3 === "heic" || t3 === "heix" ? { type: "heic", mime: "image/heic" } : t3 === "hevc" || t3 === "hevx" ? { type: "heic", mime: "image/heic-sequence" } : r4.avif || r4.avis ? { type: "avif", mime: "image/avif" } : r4.heic || r4.heix || r4.hevc || r4.hevx || r4.heis ? r4.msf1 ? { type: "heif", mime: "image/heif-sequence" } : { type: "heif", mime: "image/heif" } : { type: "avif", mime: "image/avif" };\n            };\n          });\n          var uD = ye((wdr, sW) => {\n            "use strict";\n            function lD(e3, t3) {\n              var r4 = new Error(e3);\n              return r4.code = t3, r4;\n            }\n            function ckt(e3) {\n              try {\n                return decodeURIComponent(escape(e3));\n              } catch (t3) {\n                return e3;\n              }\n            }\n            function jy(e3, t3, r4) {\n              this.input = e3.subarray(t3, r4), this.start = t3;\n              var n4 = String.fromCharCode.apply(null, this.input.subarray(0, 4));\n              if (n4 !== "II*\\0" && n4 !== "MM\\0*") throw lD("invalid TIFF signature", "EBADDATA");\n              this.big_endian = n4[0] === "M";\n            }\n            jy.prototype.each = function(e3) {\n              this.aborted = false;\n              var t3 = this.read_uint32(4);\n              for (this.ifds_to_read = [{ id: 0, offset: t3 }]; this.ifds_to_read.length > 0 && !this.aborted; ) {\n                var r4 = this.ifds_to_read.shift();\n                r4.offset && this.scan_ifd(r4.id, r4.offset, e3);\n              }\n            };\n            jy.prototype.read_uint16 = function(e3) {\n              var t3 = this.input;\n              if (e3 + 2 > t3.length) throw lD("unexpected EOF", "EBADDATA");\n              return this.big_endian ? t3[e3] * 256 + t3[e3 + 1] : t3[e3] + t3[e3 + 1] * 256;\n            };\n            jy.prototype.read_uint32 = function(e3) {\n              var t3 = this.input;\n              if (e3 + 4 > t3.length) throw lD("unexpected EOF", "EBADDATA");\n              return this.big_endian ? t3[e3] * 16777216 + t3[e3 + 1] * 65536 + t3[e3 + 2] * 256 + t3[e3 + 3] : t3[e3] + t3[e3 + 1] * 256 + t3[e3 + 2] * 65536 + t3[e3 + 3] * 16777216;\n            };\n            jy.prototype.is_subifd_link = function(e3, t3) {\n              return e3 === 0 && t3 === 34665 || e3 === 0 && t3 === 34853 || e3 === 34665 && t3 === 40965;\n            };\n            jy.prototype.exif_format_length = function(e3) {\n              switch (e3) {\n                case 1:\n                case 2:\n                case 6:\n                case 7:\n                  return 1;\n                case 3:\n                case 8:\n                  return 2;\n                case 4:\n                case 9:\n                case 11:\n                  return 4;\n                case 5:\n                case 10:\n                case 12:\n                  return 8;\n                default:\n                  return 0;\n              }\n            };\n            jy.prototype.exif_format_read = function(e3, t3) {\n              var r4;\n              switch (e3) {\n                case 1:\n                case 2:\n                  return r4 = this.input[t3], r4;\n                case 6:\n                  return r4 = this.input[t3], r4 | (r4 & 128) * 33554430;\n                case 3:\n                  return r4 = this.read_uint16(t3), r4;\n                case 8:\n                  return r4 = this.read_uint16(t3), r4 | (r4 & 32768) * 131070;\n                case 4:\n                  return r4 = this.read_uint32(t3), r4;\n                case 9:\n                  return r4 = this.read_uint32(t3), r4 | 0;\n                case 5:\n                case 10:\n                case 11:\n                case 12:\n                  return null;\n                case 7:\n                  return null;\n                default:\n                  return null;\n              }\n            };\n            jy.prototype.scan_ifd = function(e3, t3, r4) {\n              var n4 = this.read_uint16(t3);\n              t3 += 2;\n              for (var i3 = 0; i3 < n4; i3++) {\n                var a4 = this.read_uint16(t3), o4 = this.read_uint16(t3 + 2), s3 = this.read_uint32(t3 + 4), l3 = this.exif_format_length(o4), u4 = s3 * l3, c5 = u4 <= 4 ? t3 + 8 : this.read_uint32(t3 + 8), f4 = false;\n                if (c5 + u4 > this.input.length) throw lD("unexpected EOF", "EBADDATA");\n                for (var h3 = [], d3 = c5, v3 = 0; v3 < s3; v3++, d3 += l3) {\n                  var _2 = this.exif_format_read(o4, d3);\n                  if (_2 === null) {\n                    h3 = null;\n                    break;\n                  }\n                  h3.push(_2);\n                }\n                Array.isArray(h3) && o4 === 2 && (h3 = ckt(String.fromCharCode.apply(null, h3)), h3 && h3[h3.length - 1] === "\\0" && (h3 = h3.slice(0, -1))), this.is_subifd_link(e3, a4) && Array.isArray(h3) && Number.isInteger(h3[0]) && h3[0] > 0 && (this.ifds_to_read.push({ id: a4, offset: h3[0] }), f4 = true);\n                var b = { is_big_endian: this.big_endian, ifd: e3, tag: a4, format: o4, count: s3, entry_offset: t3 + this.start, data_length: u4, data_offset: c5 + this.start, value: h3, is_subifd_link: f4 };\n                if (r4(b) === false) {\n                  this.aborted = true;\n                  return;\n                }\n                t3 += 12;\n              }\n              e3 === 0 && this.ifds_to_read.push({ id: 1, offset: this.read_uint32(t3) });\n            };\n            sW.exports.ExifParser = jy;\n            sW.exports.get_orientation = function(e3) {\n              var t3 = 0;\n              try {\n                return new jy(e3, 0, e3.length).each(function(r4) {\n                  if (r4.ifd === 0 && r4.tag === 274 && Array.isArray(r4.value)) return t3 = r4.value[0], false;\n                }), t3;\n              } catch (r4) {\n                return -1;\n              }\n            };\n          });\n          var j4e = ye((Tdr, H4e) => {\n            "use strict";\n            var fkt = rc().str2arr, hkt = rc().sliceEq, dkt = rc().readUInt32BE, cD = G4e(), vkt = uD(), pkt = fkt("ftyp");\n            H4e.exports = function(e3) {\n              if (hkt(e3, 4, pkt)) {\n                var t3 = cD.unbox(e3, 0);\n                if (t3) {\n                  var r4 = cD.getMimeType(t3.data);\n                  if (r4) {\n                    for (var n4, i3 = t3.end; ; ) {\n                      var a4 = cD.unbox(e3, i3);\n                      if (!a4) break;\n                      if (i3 = a4.end, a4.boxtype === "mdat") return;\n                      if (a4.boxtype === "meta") {\n                        n4 = a4.data;\n                        break;\n                      }\n                    }\n                    if (n4) {\n                      var o4 = cD.readSizeFromMeta(n4);\n                      if (o4) {\n                        var s3 = { width: o4.width, height: o4.height, type: r4.type, mime: r4.mime, wUnits: "px", hUnits: "px" };\n                        if (o4.variants.length > 1 && (s3.variants = o4.variants), o4.orientation && (s3.orientation = o4.orientation), o4.exif_location && o4.exif_location.offset + o4.exif_location.length <= e3.length) {\n                          var l3 = dkt(e3, o4.exif_location.offset), u4 = e3.slice(o4.exif_location.offset + l3 + 4, o4.exif_location.offset + o4.exif_location.length), c5 = vkt.get_orientation(u4);\n                          c5 > 0 && (s3.orientation = c5);\n                        }\n                        return s3;\n                      }\n                    }\n                  }\n                }\n              }\n            };\n          });\n          var Z4e = ye((Adr, X4e) => {\n            "use strict";\n            var gkt = rc().str2arr, mkt = rc().sliceEq, W4e = rc().readUInt16LE, ykt = gkt("BM");\n            X4e.exports = function(e3) {\n              if (!(e3.length < 26) && mkt(e3, 0, ykt)) return { width: W4e(e3, 18), height: W4e(e3, 22), type: "bmp", mime: "image/bmp", wUnits: "px", hUnits: "px" };\n            };\n          });\n          var Q4e = ye((Sdr, $4e) => {\n            "use strict";\n            var J4e = rc().str2arr, Y4e = rc().sliceEq, K4e = rc().readUInt16LE, _kt = J4e("GIF87a"), xkt = J4e("GIF89a");\n            $4e.exports = function(e3) {\n              if (!(e3.length < 10) && !(!Y4e(e3, 0, _kt) && !Y4e(e3, 0, xkt))) return { width: K4e(e3, 6), height: K4e(e3, 8), type: "gif", mime: "image/gif", wUnits: "px", hUnits: "px" };\n            };\n          });\n          var rEe = ye((Mdr, tEe) => {\n            "use strict";\n            var lW = rc().readUInt16LE, bkt = 0, wkt = 1, eEe = 16;\n            tEe.exports = function(e3) {\n              var t3 = lW(e3, 0), r4 = lW(e3, 2), n4 = lW(e3, 4);\n              if (!(t3 !== bkt || r4 !== wkt || !n4)) {\n                for (var i3 = [], a4 = { width: 0, height: 0 }, o4 = 0; o4 < n4; o4++) {\n                  var s3 = e3[6 + eEe * o4] || 256, l3 = e3[6 + eEe * o4 + 1] || 256, u4 = { width: s3, height: l3 };\n                  i3.push(u4), (s3 > a4.width || l3 > a4.height) && (a4 = u4);\n                }\n                return { width: a4.width, height: a4.height, variants: i3, type: "ico", mime: "image/x-icon", wUnits: "px", hUnits: "px" };\n              }\n            };\n          });\n          var nEe = ye((Edr, iEe) => {\n            "use strict";\n            var uW = rc().readUInt16BE, Tkt = rc().str2arr, Akt = rc().sliceEq, Skt = uD(), Mkt = Tkt("Exif\\0\\0");\n            iEe.exports = function(e3) {\n              if (!(e3.length < 2) && !(e3[0] !== 255 || e3[1] !== 216 || e3[2] !== 255)) for (var t3 = 2; ; ) {\n                for (; ; ) {\n                  if (e3.length - t3 < 2) return;\n                  if (e3[t3++] === 255) break;\n                }\n                for (var r4 = e3[t3++], n4; r4 === 255; ) r4 = e3[t3++];\n                if (208 <= r4 && r4 <= 217 || r4 === 1) n4 = 0;\n                else if (192 <= r4 && r4 <= 254) {\n                  if (e3.length - t3 < 2) return;\n                  n4 = uW(e3, t3) - 2, t3 += 2;\n                } else return;\n                if (r4 === 217 || r4 === 218) return;\n                var i3;\n                if (r4 === 225 && n4 >= 10 && Akt(e3, t3, Mkt) && (i3 = Skt.get_orientation(e3.slice(t3 + 6, t3 + n4))), n4 >= 5 && 192 <= r4 && r4 <= 207 && r4 !== 196 && r4 !== 200 && r4 !== 204) {\n                  if (e3.length - t3 < n4) return;\n                  var a4 = { width: uW(e3, t3 + 3), height: uW(e3, t3 + 1), type: "jpg", mime: "image/jpeg", wUnits: "px", hUnits: "px" };\n                  return i3 > 0 && (a4.orientation = i3), a4;\n                }\n                t3 += n4;\n              }\n            };\n          });\n          var uEe = ye((kdr, lEe) => {\n            "use strict";\n            var sEe = rc().str2arr, aEe = rc().sliceEq, oEe = rc().readUInt32BE, Ekt = sEe(`\\x89PNG\\r\n\n`), kkt = sEe("IHDR");\n            lEe.exports = function(e3) {\n              if (!(e3.length < 24) && aEe(e3, 0, Ekt) && aEe(e3, 12, kkt)) return { width: oEe(e3, 16), height: oEe(e3, 20), type: "png", mime: "image/png", wUnits: "px", hUnits: "px" };\n            };\n          });\n          var hEe = ye((Cdr, fEe) => {\n            "use strict";\n            var Ckt = rc().str2arr, Lkt = rc().sliceEq, cEe = rc().readUInt32BE, Pkt = Ckt("8BPS\\0");\n            fEe.exports = function(e3) {\n              if (!(e3.length < 22) && Lkt(e3, 0, Pkt)) return { width: cEe(e3, 18), height: cEe(e3, 14), type: "psd", mime: "image/vnd.adobe.photoshop", wUnits: "px", hUnits: "px" };\n            };\n          });\n          var pEe = ye((Ldr, vEe) => {\n            "use strict";\n            function Ikt(e3) {\n              return e3 === 32 || e3 === 9 || e3 === 13 || e3 === 10;\n            }\n            function wA(e3) {\n              return typeof e3 == "number" && isFinite(e3) && e3 > 0;\n            }\n            function Rkt(e3) {\n              var t3 = 0, r4 = e3.length;\n              for (e3[0] === 239 && e3[1] === 187 && e3[2] === 191 && (t3 = 3); t3 < r4 && Ikt(e3[t3]); ) t3++;\n              return t3 === r4 ? false : e3[t3] === 60;\n            }\n            var Dkt = /<[-_.:a-zA-Z0-9][^>]*>/, Fkt = /^<([-_.:a-zA-Z0-9]+:)?svg\\s/, zkt = /[^-]\\bwidth="([^%]+?)"|[^-]\\bwidth=\'([^%]+?)\'/, Okt = /\\bheight="([^%]+?)"|\\bheight=\'([^%]+?)\'/, qkt = /\\bview[bB]ox="(.+?)"|\\bview[bB]ox=\'(.+?)\'/, dEe = /in$|mm$|cm$|pt$|pc$|px$|em$|ex$/;\n            function Bkt(e3) {\n              var t3 = e3.match(zkt), r4 = e3.match(Okt), n4 = e3.match(qkt);\n              return { width: t3 && (t3[1] || t3[2]), height: r4 && (r4[1] || r4[2]), viewbox: n4 && (n4[1] || n4[2]) };\n            }\n            function Um(e3) {\n              return dEe.test(e3) ? e3.match(dEe)[0] : "px";\n            }\n            vEe.exports = function(e3) {\n              if (Rkt(e3)) {\n                for (var t3 = "", r4 = 0; r4 < e3.length; r4++) t3 += String.fromCharCode(e3[r4]);\n                var n4 = (t3.match(Dkt) || [""])[0];\n                if (Fkt.test(n4)) {\n                  var i3 = Bkt(n4), a4 = parseFloat(i3.width), o4 = parseFloat(i3.height);\n                  if (i3.width && i3.height) return !wA(a4) || !wA(o4) ? void 0 : { width: a4, height: o4, type: "svg", mime: "image/svg+xml", wUnits: Um(i3.width), hUnits: Um(i3.height) };\n                  var s3 = (i3.viewbox || "").split(" "), l3 = { width: s3[2], height: s3[3] }, u4 = parseFloat(l3.width), c5 = parseFloat(l3.height);\n                  if (!(!wA(u4) || !wA(c5)) && Um(l3.width) === Um(l3.height)) {\n                    var f4 = u4 / c5;\n                    return i3.width ? wA(a4) ? { width: a4, height: a4 / f4, type: "svg", mime: "image/svg+xml", wUnits: Um(i3.width), hUnits: Um(i3.width) } : void 0 : i3.height ? wA(o4) ? { width: o4 * f4, height: o4, type: "svg", mime: "image/svg+xml", wUnits: Um(i3.height), hUnits: Um(i3.height) } : void 0 : { width: u4, height: c5, type: "svg", mime: "image/svg+xml", wUnits: Um(l3.width), hUnits: Um(l3.height) };\n                  }\n                }\n              }\n            };\n          });\n          var xEe = ye((Pdr, _Ee) => {\n            "use strict";\n            var yEe = rc().str2arr, gEe = rc().sliceEq, Nkt = rc().readUInt16LE, Ukt = rc().readUInt16BE, Vkt = rc().readUInt32LE, Gkt = rc().readUInt32BE, Hkt = yEe("II*\\0"), jkt = yEe("MM\\0*");\n            function fD(e3, t3, r4) {\n              return r4 ? Ukt(e3, t3) : Nkt(e3, t3);\n            }\n            function cW(e3, t3, r4) {\n              return r4 ? Gkt(e3, t3) : Vkt(e3, t3);\n            }\n            function mEe(e3, t3, r4) {\n              var n4 = fD(e3, t3 + 2, r4), i3 = cW(e3, t3 + 4, r4);\n              return i3 !== 1 || n4 !== 3 && n4 !== 4 ? null : n4 === 3 ? fD(e3, t3 + 8, r4) : cW(e3, t3 + 8, r4);\n            }\n            _Ee.exports = function(e3) {\n              if (!(e3.length < 8) && !(!gEe(e3, 0, Hkt) && !gEe(e3, 0, jkt))) {\n                var t3 = e3[0] === 77, r4 = cW(e3, 4, t3) - 8;\n                if (!(r4 < 0)) {\n                  var n4 = r4 + 8;\n                  if (!(e3.length - n4 < 2)) {\n                    var i3 = fD(e3, n4 + 0, t3) * 12;\n                    if (!(i3 <= 0) && (n4 += 2, !(e3.length - n4 < i3))) {\n                      var a4, o4, s3, l3;\n                      for (a4 = 0; a4 < i3; a4 += 12) l3 = fD(e3, n4 + a4, t3), l3 === 256 ? o4 = mEe(e3, n4 + a4, t3) : l3 === 257 && (s3 = mEe(e3, n4 + a4, t3));\n                      if (o4 && s3) return { width: o4, height: s3, type: "tiff", mime: "image/tiff", wUnits: "px", hUnits: "px" };\n                    }\n                  }\n                }\n              }\n            };\n          });\n          var SEe = ye((Idr, AEe) => {\n            "use strict";\n            var TEe = rc().str2arr, bEe = rc().sliceEq, wEe = rc().readUInt16LE, fW = rc().readUInt32LE, Wkt = uD(), Xkt = TEe("RIFF"), Zkt = TEe("WEBP");\n            function Ykt(e3, t3) {\n              if (!(e3[t3 + 3] !== 157 || e3[t3 + 4] !== 1 || e3[t3 + 5] !== 42)) return { width: wEe(e3, t3 + 6) & 16383, height: wEe(e3, t3 + 8) & 16383, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };\n            }\n            function Kkt(e3, t3) {\n              if (e3[t3] === 47) {\n                var r4 = fW(e3, t3 + 1);\n                return { width: (r4 & 16383) + 1, height: (r4 >> 14 & 16383) + 1, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };\n              }\n            }\n            function Jkt(e3, t3) {\n              return { width: (e3[t3 + 6] << 16 | e3[t3 + 5] << 8 | e3[t3 + 4]) + 1, height: (e3[t3 + 9] << t3 | e3[t3 + 8] << 8 | e3[t3 + 7]) + 1, type: "webp", mime: "image/webp", wUnits: "px", hUnits: "px" };\n            }\n            AEe.exports = function(e3) {\n              if (!(e3.length < 16) && !(!bEe(e3, 0, Xkt) && !bEe(e3, 8, Zkt))) {\n                var t3 = 12, r4 = null, n4 = 0, i3 = fW(e3, 4) + 8;\n                if (!(i3 > e3.length)) {\n                  for (; t3 + 8 < i3; ) {\n                    if (e3[t3] === 0) {\n                      t3++;\n                      continue;\n                    }\n                    var a4 = String.fromCharCode.apply(null, e3.slice(t3, t3 + 4)), o4 = fW(e3, t3 + 4);\n                    a4 === "VP8 " && o4 >= 10 ? r4 = r4 || Ykt(e3, t3 + 8) : a4 === "VP8L" && o4 >= 9 ? r4 = r4 || Kkt(e3, t3 + 8) : a4 === "VP8X" && o4 >= 10 ? r4 = r4 || Jkt(e3, t3 + 8) : a4 === "EXIF" && (n4 = Wkt.get_orientation(e3.slice(t3 + 8, t3 + 8 + o4)), t3 = 1 / 0), t3 += 8 + o4;\n                  }\n                  if (r4) return n4 > 0 && (r4.orientation = n4), r4;\n                }\n              }\n            };\n          });\n          var EEe = ye((Rdr, MEe) => {\n            "use strict";\n            MEe.exports = { avif: j4e(), bmp: Z4e(), gif: Q4e(), ico: rEe(), jpeg: nEe(), png: uEe(), psd: hEe(), svg: pEe(), tiff: xEe(), webp: SEe() };\n          });\n          var kEe = ye((Ddr, dW) => {\n            "use strict";\n            var hW = EEe();\n            function $kt(e3) {\n              for (var t3 = Object.keys(hW), r4 = 0; r4 < t3.length; r4++) {\n                var n4 = hW[t3[r4]](e3);\n                if (n4) return n4;\n              }\n              return null;\n            }\n            dW.exports = function(t3) {\n              return $kt(t3);\n            };\n            dW.exports.parsers = hW;\n          });\n          var LEe = ye((CEe) => {\n            "use strict";\n            var Qkt = kEe(), eCt = Py().IMAGE_URL_PREFIX, tCt = c22().Buffer;\n            CEe.getImageSize = function(e3) {\n              var t3 = e3.replace(eCt, ""), r4 = new tCt(t3, "base64");\n              return Qkt(r4);\n            };\n          });\n          var REe = ye((zdr, IEe) => {\n            "use strict";\n            var PEe = Dr(), rCt = YT(), iCt = Eo(), hD = ho(), nCt = Dr().maxRowLength, aCt = LEe().getImageSize;\n            IEe.exports = function(t3, r4) {\n              var n4, i3;\n              if (r4._hasZ) n4 = r4.z.length, i3 = nCt(r4.z);\n              else if (r4._hasSource) {\n                var a4 = aCt(r4.source);\n                n4 = a4.height, i3 = a4.width;\n              }\n              var o4 = hD.getFromId(t3, r4.xaxis || "x"), s3 = hD.getFromId(t3, r4.yaxis || "y"), l3 = o4.d2c(r4.x0) - r4.dx / 2, u4 = s3.d2c(r4.y0) - r4.dy / 2, c5, f4 = [l3, l3 + i3 * r4.dx], h3 = [u4, u4 + n4 * r4.dy];\n              if (o4 && o4.type === "log") for (c5 = 0; c5 < i3; c5++) f4.push(l3 + c5 * r4.dx);\n              if (s3 && s3.type === "log") for (c5 = 0; c5 < n4; c5++) h3.push(u4 + c5 * r4.dy);\n              r4._extremes[o4._id] = hD.findExtremes(o4, f4), r4._extremes[s3._id] = hD.findExtremes(s3, h3), r4._scaler = lCt(r4);\n              var d3 = { x0: l3, y0: u4, z: r4.z, w: i3, h: n4 };\n              return [d3];\n            };\n            function oCt(e3, t3, r4, n4) {\n              return function(i3) {\n                return PEe.constrain((i3 - e3) * t3, r4, n4);\n              };\n            }\n            function sCt(e3, t3) {\n              return function(r4) {\n                return PEe.constrain(r4, e3, t3);\n              };\n            }\n            function lCt(e3) {\n              var t3 = rCt.colormodel[e3.colormodel], r4 = t3.colormodel || e3.colormodel, n4 = r4.length;\n              e3._sArray = [];\n              for (var i3 = 0; i3 < n4; i3++) t3.min[i3] !== e3.zmin[i3] || t3.max[i3] !== e3.zmax[i3] ? e3._sArray.push(oCt(e3.zmin[i3], (t3.max[i3] - t3.min[i3]) / (e3.zmax[i3] - e3.zmin[i3]), t3.min[i3], t3.max[i3])) : e3._sArray.push(sCt(t3.min[i3], t3.max[i3]));\n              return function(a4) {\n                for (var o4 = a4.slice(0, n4), s3 = 0; s3 < n4; s3++) {\n                  var l3 = o4[s3];\n                  if (!iCt(l3)) return false;\n                  o4[s3] = e3._sArray[s3](l3);\n                }\n                return o4;\n              };\n            }\n          });\n          var zEe = ye((Odr, FEe) => {\n            "use strict";\n            var uCt = Oa(), A22 = Dr(), DEe = A22.strTranslate, cCt = Wp(), fCt = YT(), hCt = QV(), dCt = h8().STYLE;\n            FEe.exports = function(t3, r4, n4, i3) {\n              var a4 = r4.xaxis, o4 = r4.yaxis, s3 = !t3._context._exportedPlot && hCt();\n              A22.makeTraceGroups(i3, n4, "im").each(function(l3) {\n                var u4 = uCt.select(this), c5 = l3[0], f4 = c5.trace, h3 = (f4.zsmooth === "fast" || f4.zsmooth === false && s3) && !f4._hasZ && f4._hasSource && a4.type === "linear" && o4.type === "linear";\n                f4._realImage = h3;\n                var d3 = c5.z, v3 = c5.x0, _2 = c5.y0, b = c5.w, p3 = c5.h, k4 = f4.dx, E3 = f4.dy, S2, L3, x2, C3, M4, g3;\n                for (g3 = 0; S2 === void 0 && g3 < b; ) S2 = a4.c2p(v3 + g3 * k4), g3++;\n                for (g3 = b; L3 === void 0 && g3 > 0; ) L3 = a4.c2p(v3 + g3 * k4), g3--;\n                for (g3 = 0; C3 === void 0 && g3 < p3; ) C3 = o4.c2p(_2 + g3 * E3), g3++;\n                for (g3 = p3; M4 === void 0 && g3 > 0; ) M4 = o4.c2p(_2 + g3 * E3), g3--;\n                if (L3 < S2 && (x2 = L3, L3 = S2, S2 = x2), M4 < C3 && (x2 = C3, C3 = M4, M4 = x2), !h3) {\n                  var P3 = 0.5;\n                  S2 = Math.max(-P3 * a4._length, S2), L3 = Math.min((1 + P3) * a4._length, L3), C3 = Math.max(-P3 * o4._length, C3), M4 = Math.min((1 + P3) * o4._length, M4);\n                }\n                var T3 = Math.round(L3 - S2), z3 = Math.round(M4 - C3), O3 = T3 <= 0 || z3 <= 0;\n                if (O3) {\n                  var V2 = u4.selectAll("image").data([]);\n                  V2.exit().remove();\n                  return;\n                }\n                function G2(me) {\n                  var ie = document.createElement("canvas");\n                  ie.width = T3, ie.height = z3;\n                  var Se = ie.getContext("2d", { willReadFrequently: true }), Le = function(st) {\n                    return A22.constrain(Math.round(a4.c2p(v3 + st * k4) - S2), 0, T3);\n                  }, Ae = function(st) {\n                    return A22.constrain(Math.round(o4.c2p(_2 + st * E3) - C3), 0, z3);\n                  }, Fe = fCt.colormodel[f4.colormodel], Pe = Fe.colormodel || f4.colormodel, ge = Fe.fmt, Re;\n                  for (g3 = 0; g3 < c5.w; g3++) {\n                    var ce = Le(g3), Ze = Le(g3 + 1);\n                    if (!(Ze === ce || isNaN(Ze) || isNaN(ce))) for (var ut = 0; ut < c5.h; ut++) {\n                      var pt = Ae(ut), Zt = Ae(ut + 1);\n                      Zt === pt || isNaN(Zt) || isNaN(pt) || !me(g3, ut) || (Re = f4._scaler(me(g3, ut)), Re ? Se.fillStyle = Pe + "(" + ge(Re).join(",") + ")" : Se.fillStyle = "rgba(0,0,0,0)", Se.fillRect(ce, pt, Ze - ce, Zt - pt));\n                    }\n                  }\n                  return ie;\n                }\n                var Z = u4.selectAll("image").data([l3]);\n                Z.enter().append("svg:image").attr({ xmlns: cCt.svg, preserveAspectRatio: "none" }), Z.exit().remove();\n                var j3 = f4.zsmooth === false ? dCt : "";\n                if (h3) {\n                  var N2 = A22.simpleMap(a4.range, a4.r2l), H = A22.simpleMap(o4.range, o4.r2l), te = N2[1] < N2[0], oe = H[1] > H[0];\n                  if (te || oe) {\n                    var _e = S2 + T3 / 2, Ee = C3 + z3 / 2;\n                    j3 += "transform:" + DEe(_e + "px", Ee + "px") + "scale(" + (te ? -1 : 1) + "," + (oe ? -1 : 1) + ")" + DEe(-_e + "px", -Ee + "px") + ";";\n                  }\n                }\n                Z.attr("style", j3);\n                var Ce = new Promise(function(me) {\n                  if (f4._hasZ) me();\n                  else if (f4._hasSource) if (f4._canvas && f4._canvas.el.width === b && f4._canvas.el.height === p3 && f4._canvas.source === f4.source) me();\n                  else {\n                    var ie = document.createElement("canvas");\n                    ie.width = b, ie.height = p3;\n                    var Se = ie.getContext("2d", { willReadFrequently: true });\n                    f4._image = f4._image || new Image();\n                    var Le = f4._image;\n                    Le.onload = function() {\n                      Se.drawImage(Le, 0, 0), f4._canvas = { el: ie, source: f4.source }, me();\n                    }, Le.setAttribute("src", f4.source);\n                  }\n                }).then(function() {\n                  var me, ie;\n                  if (f4._hasZ) ie = G2(function(Ae, Fe) {\n                    var Pe = d3[Fe][Ae];\n                    return A22.isTypedArray(Pe) && (Pe = Array.from(Pe)), Pe;\n                  }), me = ie.toDataURL("image/png");\n                  else if (f4._hasSource) if (h3) me = f4.source;\n                  else {\n                    var Se = f4._canvas.el.getContext("2d", { willReadFrequently: true }), Le = Se.getImageData(0, 0, b, p3).data;\n                    ie = G2(function(Ae, Fe) {\n                      var Pe = 4 * (Fe * b + Ae);\n                      return [Le[Pe], Le[Pe + 1], Le[Pe + 2], Le[Pe + 3]];\n                    }), me = ie.toDataURL("image/png");\n                  }\n                  Z.attr({ "xlink:href": me, height: z3, width: T3, x: S2, y: C3 });\n                });\n                t3._promises.push(Ce);\n              });\n            };\n          });\n          var qEe = ye((qdr, OEe) => {\n            "use strict";\n            var vCt = Oa();\n            OEe.exports = function(t3) {\n              vCt.select(t3).selectAll(".im image").style("opacity", function(r4) {\n                return r4[0].trace.opacity;\n              });\n            };\n          });\n          var VEe = ye((Bdr, UEe) => {\n            "use strict";\n            var BEe = vf(), NEe = Dr(), dD = NEe.isArrayOrTypedArray, pCt = YT();\n            UEe.exports = function(t3, r4, n4) {\n              var i3 = t3.cd[0], a4 = i3.trace, o4 = t3.xa, s3 = t3.ya;\n              if (!(BEe.inbox(r4 - i3.x0, r4 - (i3.x0 + i3.w * a4.dx), 0) > 0 || BEe.inbox(n4 - i3.y0, n4 - (i3.y0 + i3.h * a4.dy), 0) > 0)) {\n                var l3 = Math.floor((r4 - i3.x0) / a4.dx), u4 = Math.floor(Math.abs(n4 - i3.y0) / a4.dy), c5;\n                if (a4._hasZ ? c5 = i3.z[u4][l3] : a4._hasSource && (c5 = a4._canvas.el.getContext("2d", { willReadFrequently: true }).getImageData(l3, u4, 1, 1).data), !!c5) {\n                  var f4 = i3.hi || a4.hoverinfo, h3;\n                  if (f4) {\n                    var d3 = f4.split("+");\n                    d3.indexOf("all") !== -1 && (d3 = ["color"]), d3.indexOf("color") !== -1 && (h3 = true);\n                  }\n                  var v3 = pCt.colormodel[a4.colormodel], _2 = v3.colormodel || a4.colormodel, b = _2.length, p3 = a4._scaler(c5), k4 = v3.suffix, E3 = [];\n                  (a4.hovertemplate || h3) && (E3.push("[" + [p3[0] + k4[0], p3[1] + k4[1], p3[2] + k4[2]].join(", ")), b === 4 && E3.push(", " + p3[3] + k4[3]), E3.push("]"), E3 = E3.join(""), t3.extraText = _2.toUpperCase() + ": " + E3);\n                  var S2;\n                  dD(a4.hovertext) && dD(a4.hovertext[u4]) ? S2 = a4.hovertext[u4][l3] : dD(a4.text) && dD(a4.text[u4]) && (S2 = a4.text[u4][l3]);\n                  var L3 = s3.c2p(i3.y0 + (u4 + 0.5) * a4.dy), x2 = i3.x0 + (l3 + 0.5) * a4.dx, C3 = i3.y0 + (u4 + 0.5) * a4.dy, M4 = "[" + c5.slice(0, a4.colormodel.length).join(", ") + "]";\n                  return [NEe.extendFlat(t3, { index: [u4, l3], x0: o4.c2p(i3.x0 + l3 * a4.dx), x1: o4.c2p(i3.x0 + (l3 + 1) * a4.dx), y0: L3, y1: L3, color: p3, xVal: x2, xLabelVal: x2, yVal: C3, yLabelVal: C3, zLabelVal: M4, text: S2, hovertemplateLabels: { zLabel: M4, colorLabel: E3, "color[0]Label": p3[0] + k4[0], "color[1]Label": p3[1] + k4[1], "color[2]Label": p3[2] + k4[2], "color[3]Label": p3[3] + k4[3] } })];\n                }\n              }\n            };\n          });\n          var HEe = ye((Ndr, GEe) => {\n            "use strict";\n            GEe.exports = function(t3, r4) {\n              return "xVal" in r4 && (t3.x = r4.xVal), "yVal" in r4 && (t3.y = r4.yVal), r4.xa && (t3.xaxis = r4.xa), r4.ya && (t3.yaxis = r4.ya), t3.color = r4.color, t3.colormodel = r4.trace.colormodel, t3.z || (t3.z = r4.color), t3;\n            };\n          });\n          var WEe = ye((Udr, jEe) => {\n            "use strict";\n            jEe.exports = { attributes: uH(), supplyDefaults: V3e(), calc: REe(), plot: zEe(), style: qEe(), hoverPoints: VEe(), eventData: HEe(), moduleType: "trace", name: "image", basePlotModule: ph(), categories: ["cartesian", "svg", "2dMap", "noSortingByValue"], animatable: false, meta: {} };\n          });\n          var ZEe = ye((Vdr, XEe) => {\n            "use strict";\n            XEe.exports = WEe();\n          });\n          var M2 = ye((Gdr, KEe) => {\n            "use strict";\n            var vW = Gl(), gCt = Cc().attributes, mCt = ec(), yCt = Lh(), { hovertemplateAttrs: _Ct, texttemplateAttrs: xCt, templatefallbackAttrs: YEe } = Ll(), S2 = Ao().extendFlat, bCt = Pd().pattern, vD = mCt({ editType: "plot", arrayOk: true, colorEditType: "plot" });\n            KEe.exports = { labels: { valType: "data_array", editType: "calc" }, label0: { valType: "number", dflt: 0, editType: "calc" }, dlabel: { valType: "number", dflt: 1, editType: "calc" }, values: { valType: "data_array", editType: "calc" }, marker: { colors: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: yCt.defaultLine, arrayOk: true, editType: "style" }, width: { valType: "number", min: 0, dflt: 0, arrayOk: true, editType: "style" }, editType: "calc" }, pattern: bCt, editType: "calc" }, text: { valType: "data_array", editType: "plot" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "style" }, scalegroup: { valType: "string", dflt: "", editType: "calc" }, textinfo: { valType: "flaglist", flags: ["label", "text", "value", "percent"], extras: ["none"], editType: "calc" }, hoverinfo: S2({}, vW.hoverinfo, { flags: ["label", "text", "value", "percent", "name"] }), hovertemplate: _Ct({}, { keys: ["label", "color", "value", "percent", "text"] }), hovertemplatefallback: YEe(), texttemplate: xCt({ editType: "plot" }, { keys: ["label", "color", "value", "percent", "text"] }), texttemplatefallback: YEe({ editType: "plot" }), textposition: { valType: "enumerated", values: ["inside", "outside", "auto", "none"], dflt: "auto", arrayOk: true, editType: "plot" }, textfont: S2({}, vD, {}), insidetextorientation: { valType: "enumerated", values: ["horizontal", "radial", "tangential", "auto"], dflt: "auto", editType: "plot" }, insidetextfont: S2({}, vD, {}), outsidetextfont: S2({}, vD, {}), automargin: { valType: "boolean", dflt: false, editType: "plot" }, showlegend: S2({}, vW.showlegend, { arrayOk: true }), legend: S2({}, vW.legend, { arrayOk: true }), title: { text: { valType: "string", dflt: "", editType: "plot" }, font: S2({}, vD, {}), position: { valType: "enumerated", values: ["top left", "top center", "top right", "middle center", "bottom left", "bottom center", "bottom right"], editType: "plot" }, editType: "plot" }, domain: gCt({ name: "pie", trace: true, editType: "calc" }), hole: { valType: "number", min: 0, max: 1, dflt: 0, editType: "calc" }, sort: { valType: "boolean", dflt: true, editType: "calc" }, direction: { valType: "enumerated", values: ["clockwise", "counterclockwise"], dflt: "counterclockwise", editType: "calc" }, rotation: { valType: "angle", dflt: 0, editType: "calc" }, pull: { valType: "number", min: 0, max: 1, dflt: 0, arrayOk: true, editType: "calc" } };\n          });\n          var E2 = ye((Hdr, QEe) => {\n            "use strict";\n            var wCt = Eo(), kE = Dr(), TCt = M2(), ACt = Cc().defaults, SCt = r0().handleText, MCt = Dr().coercePattern;\n            function JEe(e3, t3) {\n              var r4 = kE.isArrayOrTypedArray(e3), n4 = kE.isArrayOrTypedArray(t3), i3 = Math.min(r4 ? e3.length : 1 / 0, n4 ? t3.length : 1 / 0);\n              if (isFinite(i3) || (i3 = 0), i3 && n4) {\n                for (var a4, o4 = 0; o4 < i3; o4++) {\n                  var s3 = t3[o4];\n                  if (wCt(s3) && s3 > 0) {\n                    a4 = true;\n                    break;\n                  }\n                }\n                a4 || (i3 = 0);\n              }\n              return { hasLabels: r4, hasValues: n4, len: i3 };\n            }\n            function $Ee(e3, t3, r4, n4, i3) {\n              var a4 = n4("marker.line.width");\n              a4 && n4("marker.line.color", i3 ? void 0 : r4.paper_bgcolor);\n              var o4 = n4("marker.colors");\n              MCt(n4, "marker.pattern", o4), e3.marker && !t3.marker.pattern.fgcolor && (t3.marker.pattern.fgcolor = e3.marker.colors), t3.marker.pattern.bgcolor || (t3.marker.pattern.bgcolor = r4.paper_bgcolor);\n            }\n            function ECt(e3, t3, r4, n4) {\n              function i3(k4, E3) {\n                return kE.coerce(e3, t3, TCt, k4, E3);\n              }\n              var a4 = i3("labels"), o4 = i3("values"), s3 = JEe(a4, o4), l3 = s3.len;\n              if (t3._hasLabels = s3.hasLabels, t3._hasValues = s3.hasValues, !t3._hasLabels && t3._hasValues && (i3("label0"), i3("dlabel")), !l3) {\n                t3.visible = false;\n                return;\n              }\n              t3._length = l3, $Ee(e3, t3, n4, i3, true), i3("scalegroup");\n              var u4 = i3("text"), c5 = i3("texttemplate");\n              i3("texttemplatefallback");\n              var f4;\n              if (c5 || (f4 = i3("textinfo", kE.isArrayOrTypedArray(u4) ? "text+percent" : "percent")), i3("hovertext"), i3("hovertemplate"), i3("hovertemplatefallback"), c5 || f4 && f4 !== "none") {\n                var h3 = i3("textposition");\n                SCt(e3, t3, n4, i3, h3, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false });\n                var d3 = Array.isArray(h3) || h3 === "auto", v3 = d3 || h3 === "outside";\n                v3 && i3("automargin"), (h3 === "inside" || h3 === "auto" || Array.isArray(h3)) && i3("insidetextorientation");\n              } else f4 === "none" && i3("textposition", "none");\n              ACt(t3, n4, i3);\n              var _2 = i3("hole"), b = i3("title.text");\n              if (b) {\n                var p3 = i3("title.position", _2 ? "middle center" : "top center");\n                !_2 && p3 === "middle center" && (t3.title.position = "top center"), kE.coerceFont(i3, "title.font", n4.font);\n              }\n              i3("sort"), i3("direction"), i3("rotation"), i3("pull");\n            }\n            QEe.exports = { handleLabelsAndValues: JEe, handleMarkerDefaults: $Ee, supplyDefaults: ECt };\n          });\n          var pD = ye((jdr, eke) => {\n            "use strict";\n            eke.exports = { hiddenlabels: { valType: "data_array", editType: "calc" }, piecolorway: { valType: "colorlist", editType: "calc" }, extendpiecolors: { valType: "boolean", dflt: true, editType: "calc" } };\n          });\n          var rke = ye((Wdr, tke) => {\n            "use strict";\n            var kCt = Dr(), CCt = pD();\n            tke.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return kCt.coerce(t3, r4, CCt, i3, a4);\n              }\n              n4("hiddenlabels"), n4("piecolorway", r4.colorway), n4("extendpiecolors");\n            };\n          });\n          var TA = ye((Xdr, ake) => {\n            "use strict";\n            var LCt = Eo(), pW = cd(), PCt = ka(), ICt = {};\n            function RCt(e3, t3) {\n              var r4 = [], n4 = e3._fullLayout, i3 = n4.hiddenlabels || [], a4 = t3.labels, o4 = t3.marker.colors || [], s3 = t3.values, l3 = t3._length, u4 = t3._hasValues && l3, c5, f4;\n              if (t3.dlabel) for (a4 = new Array(l3), c5 = 0; c5 < l3; c5++) a4[c5] = String(t3.label0 + c5 * t3.dlabel);\n              var h3 = {}, d3 = ike(n4["_" + t3.type + "colormap"]), v3 = 0, _2 = false;\n              for (c5 = 0; c5 < l3; c5++) {\n                var b, p3, k4;\n                if (u4) {\n                  if (b = s3[c5], !LCt(b)) continue;\n                  b = +b;\n                } else b = 1;\n                p3 = a4[c5], (p3 === void 0 || p3 === "") && (p3 = c5), p3 = String(p3);\n                var E3 = h3[p3];\n                E3 === void 0 ? (h3[p3] = r4.length, k4 = i3.indexOf(p3) !== -1, k4 || (v3 += b), r4.push({ v: b, label: p3, color: d3(o4[c5], p3), i: c5, pts: [c5], hidden: k4 })) : (_2 = true, f4 = r4[E3], f4.v += b, f4.pts.push(c5), f4.hidden || (v3 += b), f4.color === false && o4[c5] && (f4.color = d3(o4[c5], p3)));\n              }\n              r4 = r4.filter(function(L3) {\n                return L3.v >= 0;\n              });\n              var S2 = t3.type === "funnelarea" ? _2 : t3.sort;\n              return S2 && r4.sort(function(L3, x2) {\n                return x2.v - L3.v;\n              }), r4[0] && (r4[0].vTotal = v3), r4;\n            }\n            function ike(e3) {\n              return function(r4, n4) {\n                return !r4 || (r4 = pW(r4), !r4.isValid()) ? false : (r4 = PCt.addOpacity(r4, r4.getAlpha()), e3[n4] || (e3[n4] = r4), r4);\n              };\n            }\n            function DCt(e3, t3) {\n              var r4 = (t3 || {}).type;\n              r4 || (r4 = "pie");\n              var n4 = e3._fullLayout, i3 = e3.calcdata, a4 = n4[r4 + "colorway"], o4 = n4["_" + r4 + "colormap"];\n              n4["extend" + r4 + "colors"] && (a4 = nke(a4, ICt));\n              for (var s3 = 0, l3 = 0; l3 < i3.length; l3++) {\n                var u4 = i3[l3], c5 = u4[0].trace.type;\n                if (c5 === r4) for (var f4 = 0; f4 < u4.length; f4++) {\n                  var h3 = u4[f4];\n                  h3.color === false && (o4[h3.label] ? h3.color = o4[h3.label] : (o4[h3.label] = h3.color = a4[s3 % a4.length], s3++));\n                }\n              }\n            }\n            function nke(e3, t3) {\n              var r4, n4 = JSON.stringify(e3), i3 = t3[n4];\n              if (!i3) {\n                for (i3 = e3.slice(), r4 = 0; r4 < e3.length; r4++) i3.push(pW(e3[r4]).lighten(20).toHexString());\n                for (r4 = 0; r4 < e3.length; r4++) i3.push(pW(e3[r4]).darken(20).toHexString());\n                t3[n4] = i3;\n              }\n              return i3;\n            }\n            ake.exports = { calc: RCt, crossTraceCalc: DCt, makePullColorFn: ike, generateExtendedColors: nke };\n          });\n          var ske = ye((Zdr, oke) => {\n            "use strict";\n            var FCt = ip().appendArrayMultiPointValues;\n            oke.exports = function(t3, r4) {\n              var n4 = { curveNumber: r4.index, pointNumbers: t3.pts, data: r4._input, fullData: r4, label: t3.label, color: t3.color, value: t3.v, percent: t3.percent, text: t3.text, bbox: t3.bbox, v: t3.v };\n              return t3.pts.length === 1 && (n4.pointNumber = n4.i = t3.pts[0]), FCt(n4, r4, t3.pts), r4.type === "funnelarea" && (delete n4.v, delete n4.i), n4;\n            };\n          });\n          var _D = ye((Ydr, kke) => {\n            "use strict";\n            var Fp = Oa(), zCt = Mc(), gD = vf(), dke = ka(), Wy = So(), rv = Dr(), OCt = rv.strScale, lke = rv.strTranslate, gW = ru(), vke = bv(), qCt = vke.recordMinTextSize, BCt = vke.clearMinTextSize, pke = e22().TEXTPAD, ns = l_(), mD = ske(), uke = Dr().isValidTextValue;\n            function NCt(e3, t3) {\n              var r4 = e3._context.staticPlot, n4 = e3._fullLayout, i3 = n4._size;\n              BCt("pie", n4), yke(t3, e3), Ske(t3, i3);\n              var a4 = rv.makeTraceGroups(n4._pielayer, t3, "trace").each(function(o4) {\n                var s3 = Fp.select(this), l3 = o4[0], u4 = l3.trace;\n                YCt(o4), s3.attr("stroke-linejoin", "round"), s3.each(function() {\n                  var c5 = Fp.select(this).selectAll("g.slice").data(o4);\n                  c5.enter().append("g").classed("slice", true), c5.exit().remove();\n                  var f4 = [[[], []], [[], []]], h3 = false;\n                  c5.each(function(S2, L3) {\n                    if (S2.hidden) {\n                      Fp.select(this).selectAll("path,g").remove();\n                      return;\n                    }\n                    S2.pointNumber = S2.i, S2.curveNumber = u4.index, f4[S2.pxmid[1] < 0 ? 0 : 1][S2.pxmid[0] < 0 ? 0 : 1].push(S2);\n                    var x2 = l3.cx, C3 = l3.cy, M4 = Fp.select(this), g3 = M4.selectAll("path.surface").data([S2]);\n                    if (g3.enter().append("path").classed("surface", true).style({ "pointer-events": r4 ? "none" : "all" }), M4.call(gke, e3, o4), u4.pull) {\n                      var P3 = +ns.castOption(u4.pull, S2.pts) || 0;\n                      P3 > 0 && (x2 += P3 * S2.pxmid[0], C3 += P3 * S2.pxmid[1]);\n                    }\n                    S2.cxFinal = x2, S2.cyFinal = C3;\n                    function T3(N2, H, te, oe) {\n                      var _e = oe * (H[0] - N2[0]), Ee = oe * (H[1] - N2[1]);\n                      return "a" + oe * l3.r + "," + oe * l3.r + " 0 " + S2.largeArc + (te ? " 1 " : " 0 ") + _e + "," + Ee;\n                    }\n                    var z3 = u4.hole;\n                    if (S2.v === l3.vTotal) {\n                      var O3 = "M" + (x2 + S2.px0[0]) + "," + (C3 + S2.px0[1]) + T3(S2.px0, S2.pxmid, true, 1) + T3(S2.pxmid, S2.px0, true, 1) + "Z";\n                      z3 ? g3.attr("d", "M" + (x2 + z3 * S2.px0[0]) + "," + (C3 + z3 * S2.px0[1]) + T3(S2.px0, S2.pxmid, false, z3) + T3(S2.pxmid, S2.px0, false, z3) + "Z" + O3) : g3.attr("d", O3);\n                    } else {\n                      var V2 = T3(S2.px0, S2.px1, true, 1);\n                      if (z3) {\n                        var G2 = 1 - z3;\n                        g3.attr("d", "M" + (x2 + z3 * S2.px1[0]) + "," + (C3 + z3 * S2.px1[1]) + T3(S2.px1, S2.px0, false, z3) + "l" + G2 * S2.px0[0] + "," + G2 * S2.px0[1] + V2 + "Z");\n                      } else g3.attr("d", "M" + x2 + "," + C3 + "l" + S2.px0[0] + "," + S2.px0[1] + V2 + "Z");\n                    }\n                    Mke(e3, S2, l3);\n                    var Z = ns.castOption(u4.textposition, S2.pts), j3 = M4.selectAll("g.slicetext").data(S2.text && Z !== "none" ? [0] : []);\n                    j3.enter().append("g").classed("slicetext", true), j3.exit().remove(), j3.each(function() {\n                      var N2 = rv.ensureSingle(Fp.select(this), "text", "", function(ie) {\n                        ie.attr("data-notex", 1);\n                      }), H = rv.ensureUniformFontSize(e3, Z === "outside" ? VCt(u4, S2, n4.font) : mke(u4, S2, n4.font));\n                      N2.text(S2.text).attr({ class: "slicetext", transform: "", "text-anchor": "middle" }).call(Wy.font, H).call(gW.convertToTspans, e3);\n                      var te = Wy.bBox(N2.node()), oe;\n                      if (Z === "outside") oe = hke(te, S2);\n                      else if (oe = _ke(te, S2, l3), Z === "auto" && oe.scale < 1) {\n                        var _e = rv.ensureUniformFontSize(e3, u4.outsidetextfont);\n                        N2.call(Wy.font, _e), te = Wy.bBox(N2.node()), oe = hke(te, S2);\n                      }\n                      var Ee = oe.textPosAngle, Ce = Ee === void 0 ? S2.pxmid : yD(l3.r, Ee);\n                      if (oe.targetX = x2 + Ce[0] * oe.rCenter + (oe.x || 0), oe.targetY = C3 + Ce[1] * oe.rCenter + (oe.y || 0), Eke(oe, te), oe.outside) {\n                        var me = oe.targetY;\n                        S2.yLabelMin = me - te.height / 2, S2.yLabelMid = me, S2.yLabelMax = me + te.height / 2, S2.labelExtraX = 0, S2.labelExtraY = 0, h3 = true;\n                      }\n                      oe.fontSize = H.size, qCt(u4.type, oe, n4), o4[L3].transform = oe, rv.setTransormAndDisplay(N2, oe);\n                    });\n                  });\n                  var d3 = Fp.select(this).selectAll("g.titletext").data(u4.title.text ? [0] : []);\n                  if (d3.enter().append("g").classed("titletext", true), d3.exit().remove(), d3.each(function() {\n                    var S2 = rv.ensureSingle(Fp.select(this), "text", "", function(C3) {\n                      C3.attr("data-notex", 1);\n                    }), L3 = u4.title.text;\n                    u4._meta && (L3 = rv.templateString(L3, u4._meta)), S2.text(L3).attr({ class: "titletext", transform: "", "text-anchor": "middle" }).call(Wy.font, u4.title.font).call(gW.convertToTspans, e3);\n                    var x2;\n                    u4.title.position === "middle center" ? x2 = jCt(l3) : x2 = Tke(l3, i3), S2.attr("transform", lke(x2.x, x2.y) + OCt(Math.min(1, x2.scale)) + lke(x2.tx, x2.ty));\n                  }), h3 && XCt(f4, u4), UCt(c5, u4), h3 && u4.automargin) {\n                    var v3 = Wy.bBox(s3.node()), _2 = u4.domain, b = i3.w * (_2.x[1] - _2.x[0]), p3 = i3.h * (_2.y[1] - _2.y[0]), k4 = (0.5 * b - l3.r) / i3.w, E3 = (0.5 * p3 - l3.r) / i3.h;\n                    zCt.autoMargin(e3, "pie." + u4.uid + ".automargin", { xl: _2.x[0] - k4, xr: _2.x[1] + k4, yb: _2.y[0] - E3, yt: _2.y[1] + E3, l: Math.max(l3.cx - l3.r - v3.left, 0), r: Math.max(v3.right - (l3.cx + l3.r), 0), b: Math.max(v3.bottom - (l3.cy + l3.r), 0), t: Math.max(l3.cy - l3.r - v3.top, 0), pad: 5 });\n                  }\n                });\n              });\n              setTimeout(function() {\n                a4.selectAll("tspan").each(function() {\n                  var o4 = Fp.select(this);\n                  o4.attr("dy") && o4.attr("dy", o4.attr("dy"));\n                });\n              }, 0);\n            }\n            function UCt(e3, t3) {\n              e3.each(function(r4) {\n                var n4 = Fp.select(this);\n                if (!r4.labelExtraX && !r4.labelExtraY) {\n                  n4.select("path.textline").remove();\n                  return;\n                }\n                var i3 = n4.select("g.slicetext text");\n                r4.transform.targetX += r4.labelExtraX, r4.transform.targetY += r4.labelExtraY, rv.setTransormAndDisplay(i3, r4.transform);\n                var a4 = r4.cxFinal + r4.pxmid[0], o4 = r4.cyFinal + r4.pxmid[1], s3 = "M" + a4 + "," + o4, l3 = (r4.yLabelMax - r4.yLabelMin) * (r4.pxmid[0] < 0 ? -1 : 1) / 4;\n                if (r4.labelExtraX) {\n                  var u4 = r4.labelExtraX * r4.pxmid[1] / r4.pxmid[0], c5 = r4.yLabelMid + r4.labelExtraY - (r4.cyFinal + r4.pxmid[1]);\n                  Math.abs(u4) > Math.abs(c5) ? s3 += "l" + c5 * r4.pxmid[0] / r4.pxmid[1] + "," + c5 + "H" + (a4 + r4.labelExtraX + l3) : s3 += "l" + r4.labelExtraX + "," + u4 + "v" + (c5 - u4) + "h" + l3;\n                } else s3 += "V" + (r4.yLabelMid + r4.labelExtraY) + "h" + l3;\n                rv.ensureSingle(n4, "path", "textline").call(dke.stroke, t3.outsidetextfont.color).attr({ "stroke-width": Math.min(2, t3.outsidetextfont.size / 8), d: s3, fill: "none" });\n              });\n            }\n            function gke(e3, t3, r4) {\n              var n4 = r4[0], i3 = n4.cx, a4 = n4.cy, o4 = n4.trace, s3 = o4.type === "funnelarea";\n              "_hasHoverLabel" in o4 || (o4._hasHoverLabel = false), "_hasHoverEvent" in o4 || (o4._hasHoverEvent = false), e3.on("mouseover", function(l3) {\n                var u4 = t3._fullLayout, c5 = t3._fullData[o4.index];\n                if (!(t3._dragging || u4.hovermode === false)) {\n                  var f4 = c5.hoverinfo;\n                  if (Array.isArray(f4) && (f4 = gD.castHoverinfo({ hoverinfo: [ns.castOption(f4, l3.pts)], _module: o4._module }, u4, 0)), f4 === "all" && (f4 = "label+text+value+percent+name"), c5.hovertemplate || f4 !== "none" && f4 !== "skip" && f4) {\n                    var h3 = l3.rInscribed || 0, d3 = i3 + l3.pxmid[0] * (1 - h3), v3 = a4 + l3.pxmid[1] * (1 - h3), _2 = u4.separators, b = [];\n                    if (f4 && f4.indexOf("label") !== -1 && b.push(l3.label), l3.text = ns.castOption(c5.hovertext || c5.text, l3.pts), f4 && f4.indexOf("text") !== -1) {\n                      var p3 = l3.text;\n                      rv.isValidTextValue(p3) && b.push(p3);\n                    }\n                    l3.value = l3.v, l3.valueLabel = ns.formatPieValue(l3.v, _2), f4 && f4.indexOf("value") !== -1 && b.push(l3.valueLabel), l3.percent = l3.v / n4.vTotal, l3.percentLabel = ns.formatPiePercent(l3.percent, _2), f4 && f4.indexOf("percent") !== -1 && b.push(l3.percentLabel);\n                    var k4 = c5.hoverlabel, E3 = k4.font, S2 = [];\n                    gD.loneHover({ trace: o4, x0: d3 - h3 * n4.r, x1: d3 + h3 * n4.r, y: v3, _x0: s3 ? i3 + l3.TL[0] : d3 - h3 * n4.r, _x1: s3 ? i3 + l3.TR[0] : d3 + h3 * n4.r, _y0: s3 ? a4 + l3.TL[1] : v3 - h3 * n4.r, _y1: s3 ? a4 + l3.BL[1] : v3 + h3 * n4.r, text: b.join("<br>"), name: c5.hovertemplate || f4.indexOf("name") !== -1 ? c5.name : void 0, idealAlign: l3.pxmid[0] < 0 ? "left" : "right", color: ns.castOption(k4.bgcolor, l3.pts) || l3.color, borderColor: ns.castOption(k4.bordercolor, l3.pts), fontFamily: ns.castOption(E3.family, l3.pts), fontSize: ns.castOption(E3.size, l3.pts), fontColor: ns.castOption(E3.color, l3.pts), nameLength: ns.castOption(k4.namelength, l3.pts), textAlign: ns.castOption(k4.align, l3.pts), hovertemplate: ns.castOption(c5.hovertemplate, l3.pts), hovertemplateLabels: l3, eventData: [mD(l3, c5)] }, { container: u4._hoverlayer.node(), outerContainer: u4._paper.node(), gd: t3, inOut_bbox: S2 }), l3.bbox = S2[0], o4._hasHoverLabel = true;\n                  }\n                  o4._hasHoverEvent = true, t3.emit("plotly_hover", { points: [mD(l3, c5)], event: Fp.event });\n                }\n              }), e3.on("mouseout", function(l3) {\n                var u4 = t3._fullLayout, c5 = t3._fullData[o4.index], f4 = Fp.select(this).datum();\n                o4._hasHoverEvent && (l3.originalEvent = Fp.event, t3.emit("plotly_unhover", { points: [mD(f4, c5)], event: Fp.event }), o4._hasHoverEvent = false), o4._hasHoverLabel && (gD.loneUnhover(u4._hoverlayer.node()), o4._hasHoverLabel = false);\n              }), e3.on("click", function(l3) {\n                var u4 = t3._fullLayout, c5 = t3._fullData[o4.index];\n                t3._dragging || u4.hovermode === false || (t3._hoverdata = [mD(l3, c5)], gD.click(t3, Fp.event));\n              });\n            }\n            function VCt(e3, t3, r4) {\n              var n4 = ns.castOption(e3.outsidetextfont.color, t3.pts) || ns.castOption(e3.textfont.color, t3.pts) || r4.color, i3 = ns.castOption(e3.outsidetextfont.family, t3.pts) || ns.castOption(e3.textfont.family, t3.pts) || r4.family, a4 = ns.castOption(e3.outsidetextfont.size, t3.pts) || ns.castOption(e3.textfont.size, t3.pts) || r4.size, o4 = ns.castOption(e3.outsidetextfont.weight, t3.pts) || ns.castOption(e3.textfont.weight, t3.pts) || r4.weight, s3 = ns.castOption(e3.outsidetextfont.style, t3.pts) || ns.castOption(e3.textfont.style, t3.pts) || r4.style, l3 = ns.castOption(e3.outsidetextfont.variant, t3.pts) || ns.castOption(e3.textfont.variant, t3.pts) || r4.variant, u4 = ns.castOption(e3.outsidetextfont.textcase, t3.pts) || ns.castOption(e3.textfont.textcase, t3.pts) || r4.textcase, c5 = ns.castOption(e3.outsidetextfont.lineposition, t3.pts) || ns.castOption(e3.textfont.lineposition, t3.pts) || r4.lineposition, f4 = ns.castOption(e3.outsidetextfont.shadow, t3.pts) || ns.castOption(e3.textfont.shadow, t3.pts) || r4.shadow;\n              return { color: n4, family: i3, size: a4, weight: o4, style: s3, variant: l3, textcase: u4, lineposition: c5, shadow: f4 };\n            }\n            function mke(e3, t3, r4) {\n              var n4 = ns.castOption(e3.insidetextfont.color, t3.pts);\n              !n4 && e3._input.textfont && (n4 = ns.castOption(e3._input.textfont.color, t3.pts));\n              var i3 = ns.castOption(e3.insidetextfont.family, t3.pts) || ns.castOption(e3.textfont.family, t3.pts) || r4.family, a4 = ns.castOption(e3.insidetextfont.size, t3.pts) || ns.castOption(e3.textfont.size, t3.pts) || r4.size, o4 = ns.castOption(e3.insidetextfont.weight, t3.pts) || ns.castOption(e3.textfont.weight, t3.pts) || r4.weight, s3 = ns.castOption(e3.insidetextfont.style, t3.pts) || ns.castOption(e3.textfont.style, t3.pts) || r4.style, l3 = ns.castOption(e3.insidetextfont.variant, t3.pts) || ns.castOption(e3.textfont.variant, t3.pts) || r4.variant, u4 = ns.castOption(e3.insidetextfont.textcase, t3.pts) || ns.castOption(e3.textfont.textcase, t3.pts) || r4.textcase, c5 = ns.castOption(e3.insidetextfont.lineposition, t3.pts) || ns.castOption(e3.textfont.lineposition, t3.pts) || r4.lineposition, f4 = ns.castOption(e3.insidetextfont.shadow, t3.pts) || ns.castOption(e3.textfont.shadow, t3.pts) || r4.shadow;\n              return { color: n4 || dke.contrast(t3.color), family: i3, size: a4, weight: o4, style: s3, variant: l3, textcase: u4, lineposition: c5, shadow: f4 };\n            }\n            function yke(e3, t3) {\n              for (var r4, n4, i3 = 0; i3 < e3.length; i3++) if (r4 = e3[i3][0], n4 = r4.trace, n4.title.text) {\n                var a4 = n4.title.text;\n                n4._meta && (a4 = rv.templateString(a4, n4._meta));\n                var o4 = Wy.tester.append("text").attr("data-notex", 1).text(a4).call(Wy.font, n4.title.font).call(gW.convertToTspans, t3), s3 = Wy.bBox(o4.node(), true);\n                r4.titleBox = { width: s3.width, height: s3.height }, o4.remove();\n              }\n            }\n            function _ke(e3, t3, r4) {\n              var n4 = r4.r || t3.rpx1, i3 = t3.rInscribed, a4 = t3.startangle === t3.stopangle;\n              if (a4) return { rCenter: 1 - i3, scale: 0, rotate: 0, textPosAngle: 0 };\n              var o4 = t3.ring, s3 = o4 === 1 && Math.abs(t3.startangle - t3.stopangle) === Math.PI * 2, l3 = t3.halfangle, u4 = t3.midangle, c5 = r4.trace.insidetextorientation, f4 = c5 === "horizontal", h3 = c5 === "tangential", d3 = c5 === "radial", v3 = c5 === "auto", _2 = [], b;\n              if (!v3) {\n                var p3 = function(M4, g3) {\n                  if (GCt(t3, M4)) {\n                    var P3 = Math.abs(M4 - t3.startangle), T3 = Math.abs(M4 - t3.stopangle), z3 = P3 < T3 ? P3 : T3;\n                    g3 === "tan" ? b = fke(e3, n4, o4, z3, 0) : b = cke(e3, n4, o4, z3, Math.PI / 2), b.textPosAngle = M4, _2.push(b);\n                  }\n                }, k4;\n                if (f4 || h3) {\n                  for (k4 = 4; k4 >= -4; k4 -= 2) p3(Math.PI * k4, "tan");\n                  for (k4 = 4; k4 >= -4; k4 -= 2) p3(Math.PI * (k4 + 1), "tan");\n                }\n                if (f4 || d3) {\n                  for (k4 = 4; k4 >= -4; k4 -= 2) p3(Math.PI * (k4 + 1.5), "rad");\n                  for (k4 = 4; k4 >= -4; k4 -= 2) p3(Math.PI * (k4 + 0.5), "rad");\n                }\n              }\n              if (s3 || v3 || f4) {\n                var E3 = Math.sqrt(e3.width * e3.width + e3.height * e3.height);\n                if (b = { scale: i3 * n4 * 2 / E3, rCenter: 1 - i3, rotate: 0 }, b.textPosAngle = (t3.startangle + t3.stopangle) / 2, b.scale >= 1) return b;\n                _2.push(b);\n              }\n              (v3 || d3) && (b = cke(e3, n4, o4, l3, u4), b.textPosAngle = (t3.startangle + t3.stopangle) / 2, _2.push(b)), (v3 || h3) && (b = fke(e3, n4, o4, l3, u4), b.textPosAngle = (t3.startangle + t3.stopangle) / 2, _2.push(b));\n              for (var S2 = 0, L3 = 0, x2 = 0; x2 < _2.length; x2++) {\n                var C3 = _2[x2].scale;\n                if (L3 < C3 && (L3 = C3, S2 = x2), !v3 && L3 >= 1) break;\n              }\n              return _2[S2];\n            }\n            function GCt(e3, t3) {\n              var r4 = e3.startangle, n4 = e3.stopangle;\n              return r4 > t3 && t3 > n4 || r4 < t3 && t3 < n4;\n            }\n            function cke(e3, t3, r4, n4, i3) {\n              t3 = Math.max(0, t3 - 2 * pke);\n              var a4 = e3.width / e3.height, o4 = wke(a4, n4, t3, r4);\n              return { scale: o4 * 2 / e3.height, rCenter: xke(a4, o4 / t3), rotate: bke(i3) };\n            }\n            function fke(e3, t3, r4, n4, i3) {\n              t3 = Math.max(0, t3 - 2 * pke);\n              var a4 = e3.height / e3.width, o4 = wke(a4, n4, t3, r4);\n              return { scale: o4 * 2 / e3.width, rCenter: xke(a4, o4 / t3), rotate: bke(i3 + Math.PI / 2) };\n            }\n            function xke(e3, t3) {\n              return Math.cos(t3) - e3 * t3;\n            }\n            function bke(e3) {\n              return (180 / Math.PI * e3 + 720) % 180 - 90;\n            }\n            function wke(e3, t3, r4, n4) {\n              var i3 = e3 + 1 / (2 * Math.tan(t3));\n              return r4 * Math.min(1 / (Math.sqrt(i3 * i3 + 0.5) + i3), n4 / (Math.sqrt(e3 * e3 + n4 / 2) + e3));\n            }\n            function HCt(e3, t3) {\n              return e3.v === t3.vTotal && !t3.trace.hole ? 1 : Math.min(1 / (1 + 1 / Math.sin(e3.halfangle)), e3.ring / 2);\n            }\n            function hke(e3, t3) {\n              var r4 = t3.pxmid[0], n4 = t3.pxmid[1], i3 = e3.width / 2, a4 = e3.height / 2;\n              return r4 < 0 && (i3 *= -1), n4 < 0 && (a4 *= -1), { scale: 1, rCenter: 1, rotate: 0, x: i3 + Math.abs(a4) * (i3 > 0 ? 1 : -1) / 2, y: a4 / (1 + r4 * r4 / (n4 * n4)), outside: true };\n            }\n            function jCt(e3) {\n              var t3 = Math.sqrt(e3.titleBox.width * e3.titleBox.width + e3.titleBox.height * e3.titleBox.height);\n              return { x: e3.cx, y: e3.cy, scale: e3.trace.hole * e3.r * 2 / t3, tx: 0, ty: -e3.titleBox.height / 2 + e3.trace.title.font.size };\n            }\n            function Tke(e3, t3) {\n              var r4 = 1, n4 = 1, i3, a4 = e3.trace, o4 = { x: e3.cx, y: e3.cy }, s3 = { tx: 0, ty: 0 };\n              s3.ty += a4.title.font.size, i3 = Ake(a4), a4.title.position.indexOf("top") !== -1 ? (o4.y -= (1 + i3) * e3.r, s3.ty -= e3.titleBox.height) : a4.title.position.indexOf("bottom") !== -1 && (o4.y += (1 + i3) * e3.r);\n              var l3 = WCt(e3.r, e3.trace.aspectratio), u4 = t3.w * (a4.domain.x[1] - a4.domain.x[0]) / 2;\n              return a4.title.position.indexOf("left") !== -1 ? (u4 = u4 + l3, o4.x -= (1 + i3) * l3, s3.tx += e3.titleBox.width / 2) : a4.title.position.indexOf("center") !== -1 ? u4 *= 2 : a4.title.position.indexOf("right") !== -1 && (u4 = u4 + l3, o4.x += (1 + i3) * l3, s3.tx -= e3.titleBox.width / 2), r4 = u4 / e3.titleBox.width, n4 = mW(e3, t3) / e3.titleBox.height, { x: o4.x, y: o4.y, scale: Math.min(r4, n4), tx: s3.tx, ty: s3.ty };\n            }\n            function WCt(e3, t3) {\n              return e3 / (t3 === void 0 ? 1 : t3);\n            }\n            function mW(e3, t3) {\n              var r4 = e3.trace, n4 = t3.h * (r4.domain.y[1] - r4.domain.y[0]);\n              return Math.min(e3.titleBox.height, n4 / 2);\n            }\n            function Ake(e3) {\n              var t3 = e3.pull;\n              if (!t3) return 0;\n              var r4;\n              if (rv.isArrayOrTypedArray(t3)) for (t3 = 0, r4 = 0; r4 < e3.pull.length; r4++) e3.pull[r4] > t3 && (t3 = e3.pull[r4]);\n              return t3;\n            }\n            function XCt(e3, t3) {\n              var r4, n4, i3, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3;\n              function _2(E3, S2) {\n                return E3.pxmid[1] - S2.pxmid[1];\n              }\n              function b(E3, S2) {\n                return S2.pxmid[1] - E3.pxmid[1];\n              }\n              function p3(E3, S2) {\n                S2 || (S2 = {});\n                var L3 = S2.labelExtraY + (n4 ? S2.yLabelMax : S2.yLabelMin), x2 = n4 ? E3.yLabelMin : E3.yLabelMax, C3 = n4 ? E3.yLabelMax : E3.yLabelMin, M4 = E3.cyFinal + o4(E3.px0[1], E3.px1[1]), g3 = L3 - x2, P3, T3, z3, O3, V2, G2;\n                if (g3 * l3 > 0 && (E3.labelExtraY = g3), !!rv.isArrayOrTypedArray(t3.pull)) for (T3 = 0; T3 < f4.length; T3++) z3 = f4[T3], !(z3 === E3 || (ns.castOption(t3.pull, E3.pts) || 0) >= (ns.castOption(t3.pull, z3.pts) || 0)) && ((E3.pxmid[1] - z3.pxmid[1]) * l3 > 0 ? (O3 = z3.cyFinal + o4(z3.px0[1], z3.px1[1]), g3 = O3 - x2 - E3.labelExtraY, g3 * l3 > 0 && (E3.labelExtraY += g3)) : (C3 + E3.labelExtraY - M4) * l3 > 0 && (P3 = 3 * s3 * Math.abs(T3 - f4.indexOf(E3)), V2 = z3.cxFinal + a4(z3.px0[0], z3.px1[0]), G2 = V2 + P3 - (E3.cxFinal + E3.pxmid[0]) - E3.labelExtraX, G2 * s3 > 0 && (E3.labelExtraX += G2)));\n              }\n              for (n4 = 0; n4 < 2; n4++) for (i3 = n4 ? _2 : b, o4 = n4 ? Math.max : Math.min, l3 = n4 ? 1 : -1, r4 = 0; r4 < 2; r4++) {\n                for (a4 = r4 ? Math.max : Math.min, s3 = r4 ? 1 : -1, u4 = e3[n4][r4], u4.sort(i3), c5 = e3[1 - n4][r4], f4 = c5.concat(u4), d3 = [], h3 = 0; h3 < u4.length; h3++) u4[h3].yLabelMid !== void 0 && d3.push(u4[h3]);\n                for (v3 = false, h3 = 0; n4 && h3 < c5.length; h3++) if (c5[h3].yLabelMid !== void 0) {\n                  v3 = c5[h3];\n                  break;\n                }\n                for (h3 = 0; h3 < d3.length; h3++) {\n                  var k4 = h3 && d3[h3 - 1];\n                  v3 && !h3 && (k4 = v3), p3(d3[h3], k4);\n                }\n              }\n            }\n            function Ske(e3, t3) {\n              for (var r4 = [], n4 = 0; n4 < e3.length; n4++) {\n                var i3 = e3[n4][0], a4 = i3.trace, o4 = a4.domain, s3 = t3.w * (o4.x[1] - o4.x[0]), l3 = t3.h * (o4.y[1] - o4.y[0]);\n                a4.title.text && a4.title.position !== "middle center" && (l3 -= mW(i3, t3));\n                var u4 = s3 / 2, c5 = l3 / 2;\n                a4.type === "funnelarea" && !a4.scalegroup && (c5 /= a4.aspectratio), i3.r = Math.min(u4, c5) / (1 + Ake(a4)), i3.cx = t3.l + t3.w * (a4.domain.x[1] + a4.domain.x[0]) / 2, i3.cy = t3.t + t3.h * (1 - a4.domain.y[0]) - l3 / 2, a4.title.text && a4.title.position.indexOf("bottom") !== -1 && (i3.cy -= mW(i3, t3)), a4.scalegroup && r4.indexOf(a4.scalegroup) === -1 && r4.push(a4.scalegroup);\n              }\n              ZCt(e3, r4);\n            }\n            function ZCt(e3, t3) {\n              for (var r4, n4, i3, a4 = 0; a4 < t3.length; a4++) {\n                var o4 = 1 / 0, s3 = t3[a4];\n                for (n4 = 0; n4 < e3.length; n4++) if (r4 = e3[n4][0], i3 = r4.trace, i3.scalegroup === s3) {\n                  var l3;\n                  if (i3.type === "pie") l3 = r4.r * r4.r;\n                  else if (i3.type === "funnelarea") {\n                    var u4, c5;\n                    i3.aspectratio > 1 ? (u4 = r4.r, c5 = u4 / i3.aspectratio) : (c5 = r4.r, u4 = c5 * i3.aspectratio), u4 *= (1 + i3.baseratio) / 2, l3 = u4 * c5;\n                  }\n                  o4 = Math.min(o4, l3 / r4.vTotal);\n                }\n                for (n4 = 0; n4 < e3.length; n4++) if (r4 = e3[n4][0], i3 = r4.trace, i3.scalegroup === s3) {\n                  var f4 = o4 * r4.vTotal;\n                  i3.type === "funnelarea" && (f4 /= (1 + i3.baseratio) / 2, f4 /= i3.aspectratio), r4.r = Math.sqrt(f4);\n                }\n              }\n            }\n            function YCt(e3) {\n              var t3 = e3[0], r4 = t3.r, n4 = t3.trace, i3 = ns.getRotationAngle(n4.rotation), a4 = 2 * Math.PI / t3.vTotal, o4 = "px0", s3 = "px1", l3, u4, c5;\n              if (n4.direction === "counterclockwise") {\n                for (l3 = 0; l3 < e3.length && e3[l3].hidden; l3++) ;\n                if (l3 === e3.length) return;\n                i3 += a4 * e3[l3].v, a4 *= -1, o4 = "px1", s3 = "px0";\n              }\n              for (c5 = yD(r4, i3), l3 = 0; l3 < e3.length; l3++) u4 = e3[l3], !u4.hidden && (u4[o4] = c5, u4.startangle = i3, i3 += a4 * u4.v / 2, u4.pxmid = yD(r4, i3), u4.midangle = i3, i3 += a4 * u4.v / 2, c5 = yD(r4, i3), u4.stopangle = i3, u4[s3] = c5, u4.largeArc = u4.v > t3.vTotal / 2 ? 1 : 0, u4.halfangle = Math.PI * Math.min(u4.v / t3.vTotal, 0.5), u4.ring = 1 - n4.hole, u4.rInscribed = HCt(u4, t3));\n            }\n            function yD(e3, t3) {\n              return [e3 * Math.sin(t3), -e3 * Math.cos(t3)];\n            }\n            function Mke(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = r4.trace, a4 = i3.texttemplate, o4 = i3.textinfo;\n              if (!a4 && o4 && o4 !== "none") {\n                var s3 = o4.split("+"), l3 = function(S2) {\n                  return s3.indexOf(S2) !== -1;\n                }, u4 = l3("label"), c5 = l3("text"), f4 = l3("value"), h3 = l3("percent"), d3 = n4.separators, v3;\n                if (v3 = u4 ? [t3.label] : [], c5) {\n                  var _2 = ns.getFirstFilled(i3.text, t3.pts);\n                  uke(_2) && v3.push(_2);\n                }\n                f4 && v3.push(ns.formatPieValue(t3.v, d3)), h3 && v3.push(ns.formatPiePercent(t3.v / r4.vTotal, d3)), t3.text = v3.join("<br>");\n              }\n              function b(S2) {\n                return { label: S2.label, value: S2.v, valueLabel: ns.formatPieValue(S2.v, n4.separators), percent: S2.v / r4.vTotal, percentLabel: ns.formatPiePercent(S2.v / r4.vTotal, n4.separators), color: S2.color, text: S2.text, customdata: rv.castOption(i3, S2.i, "customdata") };\n              }\n              if (a4) {\n                var p3 = rv.castOption(i3, t3.i, "texttemplate");\n                if (!p3) t3.text = "";\n                else {\n                  var k4 = b(t3), E3 = ns.getFirstFilled(i3.text, t3.pts);\n                  (uke(E3) || E3 === "") && (k4.text = E3), t3.text = rv.texttemplateString({ data: [k4, i3._meta], fallback: i3.texttemplatefallback, labels: k4, locale: e3._fullLayout._d3locale, template: p3 });\n                }\n              }\n            }\n            function Eke(e3, t3) {\n              var r4 = e3.rotate * Math.PI / 180, n4 = Math.cos(r4), i3 = Math.sin(r4), a4 = (t3.left + t3.right) / 2, o4 = (t3.top + t3.bottom) / 2;\n              e3.textX = a4 * n4 - o4 * i3, e3.textY = a4 * i3 + o4 * n4, e3.noCenter = true;\n            }\n            kke.exports = { plot: NCt, formatSliceLabel: Mke, transformInsideText: _ke, determineInsideTextFont: mke, positionTitleOutside: Tke, prerenderTitles: yke, layoutAreas: Ske, attachFxHandlers: gke, computeTransform: Eke };\n          });\n          var Pke = ye((Kdr, Lke) => {\n            "use strict";\n            var Cke = Oa(), KCt = B3(), JCt = bv().resizeText;\n            Lke.exports = function(t3) {\n              var r4 = t3._fullLayout._pielayer.selectAll(".trace");\n              JCt(t3, r4, "pie"), r4.each(function(n4) {\n                var i3 = n4[0], a4 = i3.trace, o4 = Cke.select(this);\n                o4.style({ opacity: a4.opacity }), o4.selectAll("path.surface").each(function(s3) {\n                  Cke.select(this).call(KCt, s3, a4, t3);\n                });\n              });\n            };\n          });\n          var Rke = ye((AA) => {\n            "use strict";\n            var Ike = Mc();\n            AA.name = "pie";\n            AA.plot = function(e3, t3, r4, n4) {\n              Ike.plotBasePlot(AA.name, e3, t3, r4, n4);\n            };\n            AA.clean = function(e3, t3, r4, n4) {\n              Ike.cleanBasePlot(AA.name, e3, t3, r4, n4);\n            };\n          });\n          var Fke = ye(($dr, Dke) => {\n            "use strict";\n            Dke.exports = { attributes: M2(), supplyDefaults: E2().supplyDefaults, supplyLayoutDefaults: rke(), layoutAttributes: pD(), calc: TA().calc, crossTraceCalc: TA().crossTraceCalc, plot: _D().plot, style: Pke(), styleOne: B3(), moduleType: "trace", name: "pie", basePlotModule: Rke(), categories: ["pie-like", "pie", "showLegend"], meta: {} };\n          });\n          var Oke = ye((Qdr, zke) => {\n            "use strict";\n            zke.exports = Fke();\n          });\n          var Bke = ye((SA) => {\n            "use strict";\n            var qke = Mc();\n            SA.name = "sunburst";\n            SA.plot = function(e3, t3, r4, n4) {\n              qke.plotBasePlot(SA.name, e3, t3, r4, n4);\n            };\n            SA.clean = function(e3, t3, r4, n4) {\n              qke.cleanBasePlot(SA.name, e3, t3, r4, n4);\n            };\n          });\n          var yW = ye((tvr, Nke) => {\n            "use strict";\n            Nke.exports = { CLICK_TRANSITION_TIME: 750, CLICK_TRANSITION_EASING: "linear", eventDataKeys: ["currentPath", "root", "entry", "percentRoot", "percentEntry", "percentParent"] };\n          });\n          var LE = ye((rvr, Gke) => {\n            "use strict";\n            var $Ct = Gl(), { hovertemplateAttrs: QCt, texttemplateAttrs: e6t, templatefallbackAttrs: Uke } = Ll(), t6t = Tu(), r6t = Cc().attributes, Xy = M2(), Vke = yW(), CE = Ao().extendFlat, i6t = Pd().pattern;\n            Gke.exports = { labels: { valType: "data_array", editType: "calc" }, parents: { valType: "data_array", editType: "calc" }, values: { valType: "data_array", editType: "calc" }, branchvalues: { valType: "enumerated", values: ["remainder", "total"], dflt: "remainder", editType: "calc" }, count: { valType: "flaglist", flags: ["branches", "leaves"], dflt: "leaves", editType: "calc" }, level: { valType: "any", editType: "plot", anim: true }, maxdepth: { valType: "integer", editType: "plot", dflt: -1 }, marker: CE({ colors: { valType: "data_array", editType: "calc" }, line: { color: CE({}, Xy.marker.line.color, { dflt: null }), width: CE({}, Xy.marker.line.width, { dflt: 1 }), editType: "calc" }, pattern: i6t, editType: "calc" }, t6t("marker", { colorAttr: "colors", anim: false })), leaf: { opacity: { valType: "number", editType: "style", min: 0, max: 1 }, editType: "plot" }, text: Xy.text, textinfo: { valType: "flaglist", flags: ["label", "text", "value", "current path", "percent root", "percent entry", "percent parent"], extras: ["none"], editType: "plot" }, texttemplate: e6t({ editType: "plot" }, { keys: Vke.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: Uke({ editType: "plot" }), hovertext: Xy.hovertext, hoverinfo: CE({}, $Ct.hoverinfo, { flags: ["label", "text", "value", "name", "current path", "percent root", "percent entry", "percent parent"], dflt: "label+text+value+name" }), hovertemplate: QCt({}, { keys: Vke.eventDataKeys }), hovertemplatefallback: Uke(), textfont: Xy.textfont, insidetextorientation: Xy.insidetextorientation, insidetextfont: Xy.insidetextfont, outsidetextfont: CE({}, Xy.outsidetextfont, {}), rotation: { valType: "angle", dflt: 0, editType: "plot" }, sort: Xy.sort, root: { color: { valType: "color", editType: "calc", dflt: "rgba(0,0,0,0)" }, editType: "calc" }, domain: r6t({ name: "sunburst", trace: true, editType: "calc" }) };\n          });\n          var _W = ye((ivr, Hke) => {\n            "use strict";\n            Hke.exports = { sunburstcolorway: { valType: "colorlist", editType: "calc" }, extendsunburstcolors: { valType: "boolean", dflt: true, editType: "calc" } };\n          });\n          var Zke = ye((nvr, Xke) => {\n            "use strict";\n            var jke = Dr(), n6t = LE(), a6t = Cc().defaults, o6t = r0().handleText, s6t = E2().handleMarkerDefaults, Wke = tc(), l6t = Wke.hasColorscale, u6t = Wke.handleDefaults;\n            Xke.exports = function(t3, r4, n4, i3) {\n              function a4(h3, d3) {\n                return jke.coerce(t3, r4, n6t, h3, d3);\n              }\n              var o4 = a4("labels"), s3 = a4("parents");\n              if (!o4 || !o4.length || !s3 || !s3.length) {\n                r4.visible = false;\n                return;\n              }\n              var l3 = a4("values");\n              l3 && l3.length ? a4("branchvalues") : a4("count"), a4("level"), a4("maxdepth"), s6t(t3, r4, i3, a4);\n              var u4 = r4._hasColorscale = l6t(t3, "marker", "colors") || (t3.marker || {}).coloraxis;\n              u4 && u6t(t3, r4, i3, a4, { prefix: "marker.", cLetter: "c" }), a4("leaf.opacity", u4 ? 1 : 0.7);\n              var c5 = a4("text");\n              a4("texttemplate"), a4("texttemplatefallback"), r4.texttemplate || a4("textinfo", jke.isArrayOrTypedArray(c5) ? "text+label" : "label"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var f4 = "auto";\n              o6t(t3, r4, i3, a4, f4, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a4("insidetextorientation"), a4("sort"), a4("rotation"), a4("root.color"), a6t(r4, i3, a4), r4._length = null;\n            };\n          });\n          var Kke = ye((avr, Yke) => {\n            "use strict";\n            var c6t = Dr(), f6t = _W();\n            Yke.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return c6t.coerce(t3, r4, f6t, i3, a4);\n              }\n              n4("sunburstcolorway", r4.colorway), n4("extendsunburstcolors");\n            };\n          });\n          var PE = ye((xD, Jke) => {\n            (function(e3, t3) {\n              typeof xD == "object" && typeof Jke != "undefined" ? t3(xD) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(xD, function(e3) {\n              "use strict";\n              function t3(je, tt) {\n                return je.parent === tt.parent ? 1 : 2;\n              }\n              function r4(je) {\n                return je.reduce(n4, 0) / je.length;\n              }\n              function n4(je, tt) {\n                return je + tt.x;\n              }\n              function i3(je) {\n                return 1 + je.reduce(a4, 0);\n              }\n              function a4(je, tt) {\n                return Math.max(je, tt.y);\n              }\n              function o4(je) {\n                for (var tt; tt = je.children; ) je = tt[0];\n                return je;\n              }\n              function s3(je) {\n                for (var tt; tt = je.children; ) je = tt[tt.length - 1];\n                return je;\n              }\n              function l3() {\n                var je = t3, tt = 1, xt = 1, Ie = false;\n                function xe(ke) {\n                  var vt, ir = 0;\n                  ke.eachAfter(function($r) {\n                    var di = $r.children;\n                    di ? ($r.x = r4(di), $r.y = i3(di)) : ($r.x = vt ? ir += je($r, vt) : 0, $r.y = 0, vt = $r);\n                  });\n                  var ar = o4(ke), vr = s3(ke), ii = ar.x - je(ar, vr) / 2, pi = vr.x + je(vr, ar) / 2;\n                  return ke.eachAfter(Ie ? function($r) {\n                    $r.x = ($r.x - ke.x) * tt, $r.y = (ke.y - $r.y) * xt;\n                  } : function($r) {\n                    $r.x = ($r.x - ii) / (pi - ii) * tt, $r.y = (1 - (ke.y ? $r.y / ke.y : 1)) * xt;\n                  });\n                }\n                return xe.separation = function(ke) {\n                  return arguments.length ? (je = ke, xe) : je;\n                }, xe.size = function(ke) {\n                  return arguments.length ? (Ie = false, tt = +ke[0], xt = +ke[1], xe) : Ie ? null : [tt, xt];\n                }, xe.nodeSize = function(ke) {\n                  return arguments.length ? (Ie = true, tt = +ke[0], xt = +ke[1], xe) : Ie ? [tt, xt] : null;\n                }, xe;\n              }\n              function u4(je) {\n                var tt = 0, xt = je.children, Ie = xt && xt.length;\n                if (!Ie) tt = 1;\n                else for (; --Ie >= 0; ) tt += xt[Ie].value;\n                je.value = tt;\n              }\n              function c5() {\n                return this.eachAfter(u4);\n              }\n              function f4(je) {\n                var tt = this, xt, Ie = [tt], xe, ke, vt;\n                do\n                  for (xt = Ie.reverse(), Ie = []; tt = xt.pop(); ) if (je(tt), xe = tt.children, xe) for (ke = 0, vt = xe.length; ke < vt; ++ke) Ie.push(xe[ke]);\n                while (Ie.length);\n                return this;\n              }\n              function h3(je) {\n                for (var tt = this, xt = [tt], Ie, xe; tt = xt.pop(); ) if (je(tt), Ie = tt.children, Ie) for (xe = Ie.length - 1; xe >= 0; --xe) xt.push(Ie[xe]);\n                return this;\n              }\n              function d3(je) {\n                for (var tt = this, xt = [tt], Ie = [], xe, ke, vt; tt = xt.pop(); ) if (Ie.push(tt), xe = tt.children, xe) for (ke = 0, vt = xe.length; ke < vt; ++ke) xt.push(xe[ke]);\n                for (; tt = Ie.pop(); ) je(tt);\n                return this;\n              }\n              function v3(je) {\n                return this.eachAfter(function(tt) {\n                  for (var xt = +je(tt.data) || 0, Ie = tt.children, xe = Ie && Ie.length; --xe >= 0; ) xt += Ie[xe].value;\n                  tt.value = xt;\n                });\n              }\n              function _2(je) {\n                return this.eachBefore(function(tt) {\n                  tt.children && tt.children.sort(je);\n                });\n              }\n              function b(je) {\n                for (var tt = this, xt = p3(tt, je), Ie = [tt]; tt !== xt; ) tt = tt.parent, Ie.push(tt);\n                for (var xe = Ie.length; je !== xt; ) Ie.splice(xe, 0, je), je = je.parent;\n                return Ie;\n              }\n              function p3(je, tt) {\n                if (je === tt) return je;\n                var xt = je.ancestors(), Ie = tt.ancestors(), xe = null;\n                for (je = xt.pop(), tt = Ie.pop(); je === tt; ) xe = je, je = xt.pop(), tt = Ie.pop();\n                return xe;\n              }\n              function k4() {\n                for (var je = this, tt = [je]; je = je.parent; ) tt.push(je);\n                return tt;\n              }\n              function E3() {\n                var je = [];\n                return this.each(function(tt) {\n                  je.push(tt);\n                }), je;\n              }\n              function S2() {\n                var je = [];\n                return this.eachBefore(function(tt) {\n                  tt.children || je.push(tt);\n                }), je;\n              }\n              function L3() {\n                var je = this, tt = [];\n                return je.each(function(xt) {\n                  xt !== je && tt.push({ source: xt.parent, target: xt });\n                }), tt;\n              }\n              function x2(je, tt) {\n                var xt = new T3(je), Ie = +je.value && (xt.value = je.value), xe, ke = [xt], vt, ir, ar, vr;\n                for (tt == null && (tt = M4); xe = ke.pop(); ) if (Ie && (xe.value = +xe.data.value), (ir = tt(xe.data)) && (vr = ir.length)) for (xe.children = new Array(vr), ar = vr - 1; ar >= 0; --ar) ke.push(vt = xe.children[ar] = new T3(ir[ar])), vt.parent = xe, vt.depth = xe.depth + 1;\n                return xt.eachBefore(P3);\n              }\n              function C3() {\n                return x2(this).eachBefore(g3);\n              }\n              function M4(je) {\n                return je.children;\n              }\n              function g3(je) {\n                je.data = je.data.data;\n              }\n              function P3(je) {\n                var tt = 0;\n                do\n                  je.height = tt;\n                while ((je = je.parent) && je.height < ++tt);\n              }\n              function T3(je) {\n                this.data = je, this.depth = this.height = 0, this.parent = null;\n              }\n              T3.prototype = x2.prototype = { constructor: T3, count: c5, each: f4, eachAfter: d3, eachBefore: h3, sum: v3, sort: _2, path: b, ancestors: k4, descendants: E3, leaves: S2, links: L3, copy: C3 };\n              var z3 = Array.prototype.slice;\n              function O3(je) {\n                for (var tt = je.length, xt, Ie; tt; ) Ie = Math.random() * tt-- | 0, xt = je[tt], je[tt] = je[Ie], je[Ie] = xt;\n                return je;\n              }\n              function V2(je) {\n                for (var tt = 0, xt = (je = O3(z3.call(je))).length, Ie = [], xe, ke; tt < xt; ) xe = je[tt], ke && j3(ke, xe) ? ++tt : (ke = H(Ie = G2(Ie, xe)), tt = 0);\n                return ke;\n              }\n              function G2(je, tt) {\n                var xt, Ie;\n                if (N2(tt, je)) return [tt];\n                for (xt = 0; xt < je.length; ++xt) if (Z(tt, je[xt]) && N2(oe(je[xt], tt), je)) return [je[xt], tt];\n                for (xt = 0; xt < je.length - 1; ++xt) for (Ie = xt + 1; Ie < je.length; ++Ie) if (Z(oe(je[xt], je[Ie]), tt) && Z(oe(je[xt], tt), je[Ie]) && Z(oe(je[Ie], tt), je[xt]) && N2(_e(je[xt], je[Ie], tt), je)) return [je[xt], je[Ie], tt];\n                throw new Error();\n              }\n              function Z(je, tt) {\n                var xt = je.r - tt.r, Ie = tt.x - je.x, xe = tt.y - je.y;\n                return xt < 0 || xt * xt < Ie * Ie + xe * xe;\n              }\n              function j3(je, tt) {\n                var xt = je.r - tt.r + 1e-6, Ie = tt.x - je.x, xe = tt.y - je.y;\n                return xt > 0 && xt * xt > Ie * Ie + xe * xe;\n              }\n              function N2(je, tt) {\n                for (var xt = 0; xt < tt.length; ++xt) if (!j3(je, tt[xt])) return false;\n                return true;\n              }\n              function H(je) {\n                switch (je.length) {\n                  case 1:\n                    return te(je[0]);\n                  case 2:\n                    return oe(je[0], je[1]);\n                  case 3:\n                    return _e(je[0], je[1], je[2]);\n                }\n              }\n              function te(je) {\n                return { x: je.x, y: je.y, r: je.r };\n              }\n              function oe(je, tt) {\n                var xt = je.x, Ie = je.y, xe = je.r, ke = tt.x, vt = tt.y, ir = tt.r, ar = ke - xt, vr = vt - Ie, ii = ir - xe, pi = Math.sqrt(ar * ar + vr * vr);\n                return { x: (xt + ke + ar / pi * ii) / 2, y: (Ie + vt + vr / pi * ii) / 2, r: (pi + xe + ir) / 2 };\n              }\n              function _e(je, tt, xt) {\n                var Ie = je.x, xe = je.y, ke = je.r, vt = tt.x, ir = tt.y, ar = tt.r, vr = xt.x, ii = xt.y, pi = xt.r, $r = Ie - vt, di = Ie - vr, ji = xe - ir, In = xe - ii, wi = ar - ke, On = pi - ke, qn = Ie * Ie + xe * xe - ke * ke, Fn = qn - vt * vt - ir * ir + ar * ar, ra = qn - vr * vr - ii * ii + pi * pi, la = di * ji - $r * In, Ut = (ji * ra - In * Fn) / (la * 2) - Ie, wt = (In * wi - ji * On) / la, rr = (di * Fn - $r * ra) / (la * 2) - xe, nr = ($r * On - di * wi) / la, Er = wt * wt + nr * nr - 1, Xr = 2 * (ke + Ut * wt + rr * nr), ri = Ut * Ut + rr * rr - ke * ke, Qr = -(Er ? (Xr + Math.sqrt(Xr * Xr - 4 * Er * ri)) / (2 * Er) : ri / Xr);\n                return { x: Ie + Ut + wt * Qr, y: xe + rr + nr * Qr, r: Qr };\n              }\n              function Ee(je, tt, xt) {\n                var Ie = je.x - tt.x, xe, ke, vt = je.y - tt.y, ir, ar, vr = Ie * Ie + vt * vt;\n                vr ? (ke = tt.r + xt.r, ke *= ke, ar = je.r + xt.r, ar *= ar, ke > ar ? (xe = (vr + ar - ke) / (2 * vr), ir = Math.sqrt(Math.max(0, ar / vr - xe * xe)), xt.x = je.x - xe * Ie - ir * vt, xt.y = je.y - xe * vt + ir * Ie) : (xe = (vr + ke - ar) / (2 * vr), ir = Math.sqrt(Math.max(0, ke / vr - xe * xe)), xt.x = tt.x + xe * Ie - ir * vt, xt.y = tt.y + xe * vt + ir * Ie)) : (xt.x = tt.x + xt.r, xt.y = tt.y);\n              }\n              function Ce(je, tt) {\n                var xt = je.r + tt.r - 1e-6, Ie = tt.x - je.x, xe = tt.y - je.y;\n                return xt > 0 && xt * xt > Ie * Ie + xe * xe;\n              }\n              function me(je) {\n                var tt = je._, xt = je.next._, Ie = tt.r + xt.r, xe = (tt.x * xt.r + xt.x * tt.r) / Ie, ke = (tt.y * xt.r + xt.y * tt.r) / Ie;\n                return xe * xe + ke * ke;\n              }\n              function ie(je) {\n                this._ = je, this.next = null, this.previous = null;\n              }\n              function Se(je) {\n                if (!(xe = je.length)) return 0;\n                var tt, xt, Ie, xe, ke, vt, ir, ar, vr, ii, pi;\n                if (tt = je[0], tt.x = 0, tt.y = 0, !(xe > 1)) return tt.r;\n                if (xt = je[1], tt.x = -xt.r, xt.x = tt.r, xt.y = 0, !(xe > 2)) return tt.r + xt.r;\n                Ee(xt, tt, Ie = je[2]), tt = new ie(tt), xt = new ie(xt), Ie = new ie(Ie), tt.next = Ie.previous = xt, xt.next = tt.previous = Ie, Ie.next = xt.previous = tt;\n                e: for (ir = 3; ir < xe; ++ir) {\n                  Ee(tt._, xt._, Ie = je[ir]), Ie = new ie(Ie), ar = xt.next, vr = tt.previous, ii = xt._.r, pi = tt._.r;\n                  do\n                    if (ii <= pi) {\n                      if (Ce(ar._, Ie._)) {\n                        xt = ar, tt.next = xt, xt.previous = tt, --ir;\n                        continue e;\n                      }\n                      ii += ar._.r, ar = ar.next;\n                    } else {\n                      if (Ce(vr._, Ie._)) {\n                        tt = vr, tt.next = xt, xt.previous = tt, --ir;\n                        continue e;\n                      }\n                      pi += vr._.r, vr = vr.previous;\n                    }\n                  while (ar !== vr.next);\n                  for (Ie.previous = tt, Ie.next = xt, tt.next = xt.previous = xt = Ie, ke = me(tt); (Ie = Ie.next) !== xt; ) (vt = me(Ie)) < ke && (tt = Ie, ke = vt);\n                  xt = tt.next;\n                }\n                for (tt = [xt._], Ie = xt; (Ie = Ie.next) !== xt; ) tt.push(Ie._);\n                for (Ie = V2(tt), ir = 0; ir < xe; ++ir) tt = je[ir], tt.x -= Ie.x, tt.y -= Ie.y;\n                return Ie.r;\n              }\n              function Le(je) {\n                return Se(je), je;\n              }\n              function Ae(je) {\n                return je == null ? null : Fe(je);\n              }\n              function Fe(je) {\n                if (typeof je != "function") throw new Error();\n                return je;\n              }\n              function Pe() {\n                return 0;\n              }\n              function ge(je) {\n                return function() {\n                  return je;\n                };\n              }\n              function Re(je) {\n                return Math.sqrt(je.value);\n              }\n              function ce() {\n                var je = null, tt = 1, xt = 1, Ie = Pe;\n                function xe(ke) {\n                  return ke.x = tt / 2, ke.y = xt / 2, je ? ke.eachBefore(Ze(je)).eachAfter(ut(Ie, 0.5)).eachBefore(pt(1)) : ke.eachBefore(Ze(Re)).eachAfter(ut(Pe, 1)).eachAfter(ut(Ie, ke.r / Math.min(tt, xt))).eachBefore(pt(Math.min(tt, xt) / (2 * ke.r))), ke;\n                }\n                return xe.radius = function(ke) {\n                  return arguments.length ? (je = Ae(ke), xe) : je;\n                }, xe.size = function(ke) {\n                  return arguments.length ? (tt = +ke[0], xt = +ke[1], xe) : [tt, xt];\n                }, xe.padding = function(ke) {\n                  return arguments.length ? (Ie = typeof ke == "function" ? ke : ge(+ke), xe) : Ie;\n                }, xe;\n              }\n              function Ze(je) {\n                return function(tt) {\n                  tt.children || (tt.r = Math.max(0, +je(tt) || 0));\n                };\n              }\n              function ut(je, tt) {\n                return function(xt) {\n                  if (Ie = xt.children) {\n                    var Ie, xe, ke = Ie.length, vt = je(xt) * tt || 0, ir;\n                    if (vt) for (xe = 0; xe < ke; ++xe) Ie[xe].r += vt;\n                    if (ir = Se(Ie), vt) for (xe = 0; xe < ke; ++xe) Ie[xe].r -= vt;\n                    xt.r = ir + vt;\n                  }\n                };\n              }\n              function pt(je) {\n                return function(tt) {\n                  var xt = tt.parent;\n                  tt.r *= je, xt && (tt.x = xt.x + je * tt.x, tt.y = xt.y + je * tt.y);\n                };\n              }\n              function Zt(je) {\n                je.x0 = Math.round(je.x0), je.y0 = Math.round(je.y0), je.x1 = Math.round(je.x1), je.y1 = Math.round(je.y1);\n              }\n              function st(je, tt, xt, Ie, xe) {\n                for (var ke = je.children, vt, ir = -1, ar = ke.length, vr = je.value && (Ie - tt) / je.value; ++ir < ar; ) vt = ke[ir], vt.y0 = xt, vt.y1 = xe, vt.x0 = tt, vt.x1 = tt += vt.value * vr;\n              }\n              function lt() {\n                var je = 1, tt = 1, xt = 0, Ie = false;\n                function xe(vt) {\n                  var ir = vt.height + 1;\n                  return vt.x0 = vt.y0 = xt, vt.x1 = je, vt.y1 = tt / ir, vt.eachBefore(ke(tt, ir)), Ie && vt.eachBefore(Zt), vt;\n                }\n                function ke(vt, ir) {\n                  return function(ar) {\n                    ar.children && st(ar, ar.x0, vt * (ar.depth + 1) / ir, ar.x1, vt * (ar.depth + 2) / ir);\n                    var vr = ar.x0, ii = ar.y0, pi = ar.x1 - xt, $r = ar.y1 - xt;\n                    pi < vr && (vr = pi = (vr + pi) / 2), $r < ii && (ii = $r = (ii + $r) / 2), ar.x0 = vr, ar.y0 = ii, ar.x1 = pi, ar.y1 = $r;\n                  };\n                }\n                return xe.round = function(vt) {\n                  return arguments.length ? (Ie = !!vt, xe) : Ie;\n                }, xe.size = function(vt) {\n                  return arguments.length ? (je = +vt[0], tt = +vt[1], xe) : [je, tt];\n                }, xe.padding = function(vt) {\n                  return arguments.length ? (xt = +vt, xe) : xt;\n                }, xe;\n              }\n              var Gt = "$", Nt = { depth: -1 }, Jt = {};\n              function sr(je) {\n                return je.id;\n              }\n              function wr(je) {\n                return je.parentId;\n              }\n              function cr() {\n                var je = sr, tt = wr;\n                function xt(Ie) {\n                  var xe, ke, vt = Ie.length, ir, ar, vr, ii = new Array(vt), pi, $r, di = {};\n                  for (ke = 0; ke < vt; ++ke) xe = Ie[ke], vr = ii[ke] = new T3(xe), (pi = je(xe, ke, Ie)) != null && (pi += "") && ($r = Gt + (vr.id = pi), di[$r] = $r in di ? Jt : vr);\n                  for (ke = 0; ke < vt; ++ke) if (vr = ii[ke], pi = tt(Ie[ke], ke, Ie), pi == null || !(pi += "")) {\n                    if (ir) throw new Error("multiple roots");\n                    ir = vr;\n                  } else {\n                    if (ar = di[Gt + pi], !ar) throw new Error("missing: " + pi);\n                    if (ar === Jt) throw new Error("ambiguous: " + pi);\n                    ar.children ? ar.children.push(vr) : ar.children = [vr], vr.parent = ar;\n                  }\n                  if (!ir) throw new Error("no root");\n                  if (ir.parent = Nt, ir.eachBefore(function(ji) {\n                    ji.depth = ji.parent.depth + 1, --vt;\n                  }).eachBefore(P3), ir.parent = null, vt > 0) throw new Error("cycle");\n                  return ir;\n                }\n                return xt.id = function(Ie) {\n                  return arguments.length ? (je = Fe(Ie), xt) : je;\n                }, xt.parentId = function(Ie) {\n                  return arguments.length ? (tt = Fe(Ie), xt) : tt;\n                }, xt;\n              }\n              function $e(je, tt) {\n                return je.parent === tt.parent ? 1 : 2;\n              }\n              function St(je) {\n                var tt = je.children;\n                return tt ? tt[0] : je.t;\n              }\n              function Qt(je) {\n                var tt = je.children;\n                return tt ? tt[tt.length - 1] : je.t;\n              }\n              function Vt(je, tt, xt) {\n                var Ie = xt / (tt.i - je.i);\n                tt.c -= Ie, tt.s += xt, je.c += Ie, tt.z += xt, tt.m += xt;\n              }\n              function _t(je) {\n                for (var tt = 0, xt = 0, Ie = je.children, xe = Ie.length, ke; --xe >= 0; ) ke = Ie[xe], ke.z += tt, ke.m += tt, tt += ke.s + (xt += ke.c);\n              }\n              function It(je, tt, xt) {\n                return je.a.parent === tt.parent ? je.a : xt;\n              }\n              function mt(je, tt) {\n                this._ = je, this.parent = null, this.children = null, this.A = null, this.a = this, this.z = 0, this.m = 0, this.c = 0, this.s = 0, this.t = null, this.i = tt;\n              }\n              mt.prototype = Object.create(T3.prototype);\n              function er(je) {\n                for (var tt = new mt(je, 0), xt, Ie = [tt], xe, ke, vt, ir; xt = Ie.pop(); ) if (ke = xt._.children) for (xt.children = new Array(ir = ke.length), vt = ir - 1; vt >= 0; --vt) Ie.push(xe = xt.children[vt] = new mt(ke[vt], vt)), xe.parent = xt;\n                return (tt.parent = new mt(null, 0)).children = [tt], tt;\n              }\n              function lr() {\n                var je = $e, tt = 1, xt = 1, Ie = null;\n                function xe(vr) {\n                  var ii = er(vr);\n                  if (ii.eachAfter(ke), ii.parent.m = -ii.z, ii.eachBefore(vt), Ie) vr.eachBefore(ar);\n                  else {\n                    var pi = vr, $r = vr, di = vr;\n                    vr.eachBefore(function(qn) {\n                      qn.x < pi.x && (pi = qn), qn.x > $r.x && ($r = qn), qn.depth > di.depth && (di = qn);\n                    });\n                    var ji = pi === $r ? 1 : je(pi, $r) / 2, In = ji - pi.x, wi = tt / ($r.x + ji + In), On = xt / (di.depth || 1);\n                    vr.eachBefore(function(qn) {\n                      qn.x = (qn.x + In) * wi, qn.y = qn.depth * On;\n                    });\n                  }\n                  return vr;\n                }\n                function ke(vr) {\n                  var ii = vr.children, pi = vr.parent.children, $r = vr.i ? pi[vr.i - 1] : null;\n                  if (ii) {\n                    _t(vr);\n                    var di = (ii[0].z + ii[ii.length - 1].z) / 2;\n                    $r ? (vr.z = $r.z + je(vr._, $r._), vr.m = vr.z - di) : vr.z = di;\n                  } else $r && (vr.z = $r.z + je(vr._, $r._));\n                  vr.parent.A = ir(vr, $r, vr.parent.A || pi[0]);\n                }\n                function vt(vr) {\n                  vr._.x = vr.z + vr.parent.m, vr.m += vr.parent.m;\n                }\n                function ir(vr, ii, pi) {\n                  if (ii) {\n                    for (var $r = vr, di = vr, ji = ii, In = $r.parent.children[0], wi = $r.m, On = di.m, qn = ji.m, Fn = In.m, ra; ji = Qt(ji), $r = St($r), ji && $r; ) In = St(In), di = Qt(di), di.a = vr, ra = ji.z + qn - $r.z - wi + je(ji._, $r._), ra > 0 && (Vt(It(ji, vr, pi), vr, ra), wi += ra, On += ra), qn += ji.m, wi += $r.m, Fn += In.m, On += di.m;\n                    ji && !Qt(di) && (di.t = ji, di.m += qn - On), $r && !St(In) && (In.t = $r, In.m += wi - Fn, pi = vr);\n                  }\n                  return pi;\n                }\n                function ar(vr) {\n                  vr.x *= tt, vr.y = vr.depth * xt;\n                }\n                return xe.separation = function(vr) {\n                  return arguments.length ? (je = vr, xe) : je;\n                }, xe.size = function(vr) {\n                  return arguments.length ? (Ie = false, tt = +vr[0], xt = +vr[1], xe) : Ie ? null : [tt, xt];\n                }, xe.nodeSize = function(vr) {\n                  return arguments.length ? (Ie = true, tt = +vr[0], xt = +vr[1], xe) : Ie ? [tt, xt] : null;\n                }, xe;\n              }\n              function Tr(je, tt, xt, Ie, xe) {\n                for (var ke = je.children, vt, ir = -1, ar = ke.length, vr = je.value && (xe - xt) / je.value; ++ir < ar; ) vt = ke[ir], vt.x0 = tt, vt.x1 = Ie, vt.y0 = xt, vt.y1 = xt += vt.value * vr;\n              }\n              var Lr = (1 + Math.sqrt(5)) / 2;\n              function ti(je, tt, xt, Ie, xe, ke) {\n                for (var vt = [], ir = tt.children, ar, vr, ii = 0, pi = 0, $r = ir.length, di, ji, In = tt.value, wi, On, qn, Fn, ra, la, Ut; ii < $r; ) {\n                  di = xe - xt, ji = ke - Ie;\n                  do\n                    wi = ir[pi++].value;\n                  while (!wi && pi < $r);\n                  for (On = qn = wi, la = Math.max(ji / di, di / ji) / (In * je), Ut = wi * wi * la, ra = Math.max(qn / Ut, Ut / On); pi < $r; ++pi) {\n                    if (wi += vr = ir[pi].value, vr < On && (On = vr), vr > qn && (qn = vr), Ut = wi * wi * la, Fn = Math.max(qn / Ut, Ut / On), Fn > ra) {\n                      wi -= vr;\n                      break;\n                    }\n                    ra = Fn;\n                  }\n                  vt.push(ar = { value: wi, dice: di < ji, children: ir.slice(ii, pi) }), ar.dice ? st(ar, xt, Ie, xe, In ? Ie += ji * wi / In : ke) : Tr(ar, xt, Ie, In ? xt += di * wi / In : xe, ke), In -= wi, ii = pi;\n                }\n                return vt;\n              }\n              var Br = (function je(tt) {\n                function xt(Ie, xe, ke, vt, ir) {\n                  ti(tt, Ie, xe, ke, vt, ir);\n                }\n                return xt.ratio = function(Ie) {\n                  return je((Ie = +Ie) > 1 ? Ie : 1);\n                }, xt;\n              })(Lr);\n              function Vr() {\n                var je = Br, tt = false, xt = 1, Ie = 1, xe = [0], ke = Pe, vt = Pe, ir = Pe, ar = Pe, vr = Pe;\n                function ii($r) {\n                  return $r.x0 = $r.y0 = 0, $r.x1 = xt, $r.y1 = Ie, $r.eachBefore(pi), xe = [0], tt && $r.eachBefore(Zt), $r;\n                }\n                function pi($r) {\n                  var di = xe[$r.depth], ji = $r.x0 + di, In = $r.y0 + di, wi = $r.x1 - di, On = $r.y1 - di;\n                  wi < ji && (ji = wi = (ji + wi) / 2), On < In && (In = On = (In + On) / 2), $r.x0 = ji, $r.y0 = In, $r.x1 = wi, $r.y1 = On, $r.children && (di = xe[$r.depth + 1] = ke($r) / 2, ji += vr($r) - di, In += vt($r) - di, wi -= ir($r) - di, On -= ar($r) - di, wi < ji && (ji = wi = (ji + wi) / 2), On < In && (In = On = (In + On) / 2), je($r, ji, In, wi, On));\n                }\n                return ii.round = function($r) {\n                  return arguments.length ? (tt = !!$r, ii) : tt;\n                }, ii.size = function($r) {\n                  return arguments.length ? (xt = +$r[0], Ie = +$r[1], ii) : [xt, Ie];\n                }, ii.tile = function($r) {\n                  return arguments.length ? (je = Fe($r), ii) : je;\n                }, ii.padding = function($r) {\n                  return arguments.length ? ii.paddingInner($r).paddingOuter($r) : ii.paddingInner();\n                }, ii.paddingInner = function($r) {\n                  return arguments.length ? (ke = typeof $r == "function" ? $r : ge(+$r), ii) : ke;\n                }, ii.paddingOuter = function($r) {\n                  return arguments.length ? ii.paddingTop($r).paddingRight($r).paddingBottom($r).paddingLeft($r) : ii.paddingTop();\n                }, ii.paddingTop = function($r) {\n                  return arguments.length ? (vt = typeof $r == "function" ? $r : ge(+$r), ii) : vt;\n                }, ii.paddingRight = function($r) {\n                  return arguments.length ? (ir = typeof $r == "function" ? $r : ge(+$r), ii) : ir;\n                }, ii.paddingBottom = function($r) {\n                  return arguments.length ? (ar = typeof $r == "function" ? $r : ge(+$r), ii) : ar;\n                }, ii.paddingLeft = function($r) {\n                  return arguments.length ? (vr = typeof $r == "function" ? $r : ge(+$r), ii) : vr;\n                }, ii;\n              }\n              function dt(je, tt, xt, Ie, xe) {\n                var ke = je.children, vt, ir = ke.length, ar, vr = new Array(ir + 1);\n                for (vr[0] = ar = vt = 0; vt < ir; ++vt) vr[vt + 1] = ar += ke[vt].value;\n                ii(0, ir, je.value, tt, xt, Ie, xe);\n                function ii(pi, $r, di, ji, In, wi, On) {\n                  if (pi >= $r - 1) {\n                    var qn = ke[pi];\n                    qn.x0 = ji, qn.y0 = In, qn.x1 = wi, qn.y1 = On;\n                    return;\n                  }\n                  for (var Fn = vr[pi], ra = di / 2 + Fn, la = pi + 1, Ut = $r - 1; la < Ut; ) {\n                    var wt = la + Ut >>> 1;\n                    vr[wt] < ra ? la = wt + 1 : Ut = wt;\n                  }\n                  ra - vr[la - 1] < vr[la] - ra && pi + 1 < la && --la;\n                  var rr = vr[la] - Fn, nr = di - rr;\n                  if (wi - ji > On - In) {\n                    var Er = (ji * nr + wi * rr) / di;\n                    ii(pi, la, rr, ji, In, Er, On), ii(la, $r, nr, Er, In, wi, On);\n                  } else {\n                    var Xr = (In * nr + On * rr) / di;\n                    ii(pi, la, rr, ji, In, wi, Xr), ii(la, $r, nr, ji, Xr, wi, On);\n                  }\n                }\n              }\n              function Ge(je, tt, xt, Ie, xe) {\n                (je.depth & 1 ? Tr : st)(je, tt, xt, Ie, xe);\n              }\n              var Je = (function je(tt) {\n                function xt(Ie, xe, ke, vt, ir) {\n                  if ((ar = Ie._squarify) && ar.ratio === tt) for (var ar, vr, ii, pi, $r = -1, di, ji = ar.length, In = Ie.value; ++$r < ji; ) {\n                    for (vr = ar[$r], ii = vr.children, pi = vr.value = 0, di = ii.length; pi < di; ++pi) vr.value += ii[pi].value;\n                    vr.dice ? st(vr, xe, ke, vt, ke += (ir - ke) * vr.value / In) : Tr(vr, xe, ke, xe += (vt - xe) * vr.value / In, ir), In -= vr.value;\n                  }\n                  else Ie._squarify = ar = ti(tt, Ie, xe, ke, vt, ir), ar.ratio = tt;\n                }\n                return xt.ratio = function(Ie) {\n                  return je((Ie = +Ie) > 1 ? Ie : 1);\n                }, xt;\n              })(Lr);\n              e3.cluster = l3, e3.hierarchy = x2, e3.pack = ce, e3.packEnclose = V2, e3.packSiblings = Le, e3.partition = lt, e3.stratify = cr, e3.tree = lr, e3.treemap = Vr, e3.treemapBinary = dt, e3.treemapDice = st, e3.treemapResquarify = Je, e3.treemapSlice = Tr, e3.treemapSliceDice = Ge, e3.treemapSquarify = Br, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var RE = ye((IE) => {\n            "use strict";\n            var $ke = PE(), h6t = Eo(), MA = Dr(), d6t = tc().makeColorScaleFuncFromTrace, v6t = TA().makePullColorFn, p6t = TA().generateExtendedColors, g6t = tc().calc, m6t = fs().ALMOST_EQUAL, y6t = {}, _6t = {}, x6t = {};\n            IE.calc = function(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3.ids, i3 = MA.isArrayOrTypedArray(n4), a4 = t3.labels, o4 = t3.parents, s3 = t3.values, l3 = MA.isArrayOrTypedArray(s3), u4 = [], c5 = {}, f4 = {}, h3 = function(j3, N2) {\n                c5[j3] ? c5[j3].push(N2) : c5[j3] = [N2], f4[N2] = 1;\n              }, d3 = function(j3) {\n                return j3 || typeof j3 == "number";\n              }, v3 = function(j3) {\n                return !l3 || h6t(s3[j3]) && s3[j3] >= 0;\n              }, _2, b, p3;\n              i3 ? (_2 = Math.min(n4.length, o4.length), b = function(j3) {\n                return d3(n4[j3]) && v3(j3);\n              }, p3 = function(j3) {\n                return String(n4[j3]);\n              }) : (_2 = Math.min(a4.length, o4.length), b = function(j3) {\n                return d3(a4[j3]) && v3(j3);\n              }, p3 = function(j3) {\n                return String(a4[j3]);\n              }), l3 && (_2 = Math.min(_2, s3.length));\n              for (var k4 = 0; k4 < _2; k4++) if (b(k4)) {\n                var E3 = p3(k4), S2 = d3(o4[k4]) ? String(o4[k4]) : "", L3 = { i: k4, id: E3, pid: S2, label: d3(a4[k4]) ? String(a4[k4]) : "" };\n                l3 && (L3.v = +s3[k4]), u4.push(L3), h3(S2, E3);\n              }\n              if (c5[""]) {\n                if (c5[""].length > 1) {\n                  for (var M4 = MA.randstr(), g3 = 0; g3 < u4.length; g3++) u4[g3].pid === "" && (u4[g3].pid = M4);\n                  u4.unshift({ hasMultipleRoots: true, id: M4, pid: "", label: "" });\n                }\n              } else {\n                var x2 = [], C3;\n                for (C3 in c5) f4[C3] || x2.push(C3);\n                if (x2.length === 1) C3 = x2[0], u4.unshift({ hasImpliedRoot: true, id: C3, pid: "", label: C3 });\n                else return MA.warn(["Multiple implied roots, cannot build", t3.type, "hierarchy of", t3.name + ".", "These roots include:", x2.join(", ")].join(" "));\n              }\n              var P3;\n              try {\n                P3 = $ke.stratify().id(function(j3) {\n                  return j3.id;\n                }).parentId(function(j3) {\n                  return j3.pid;\n                })(u4);\n              } catch (j3) {\n                return MA.warn(["Failed to build", t3.type, "hierarchy of", t3.name + ".", "Error:", j3.message].join(" "));\n              }\n              var T3 = $ke.hierarchy(P3), z3 = false;\n              if (l3) switch (t3.branchvalues) {\n                case "remainder":\n                  T3.sum(function(j3) {\n                    return j3.data.v;\n                  });\n                  break;\n                case "total":\n                  T3.each(function(j3) {\n                    var N2 = j3.data.data, H = N2.v;\n                    if (j3.children) {\n                      var te = j3.children.reduce(function(oe, _e) {\n                        return oe + _e.data.data.v;\n                      }, 0);\n                      if ((N2.hasImpliedRoot || N2.hasMultipleRoots) && (H = te), H < te * m6t) return z3 = true, MA.warn(["Total value for node", j3.data.data.id, "of", t3.name, "is smaller than the sum of its children.", `\nparent value =`, H, `\nchildren sum =`, te].join(" "));\n                    }\n                    j3.value = H;\n                  });\n                  break;\n              }\n              else Qke(T3, t3, { branches: t3.count.indexOf("branches") !== -1, leaves: t3.count.indexOf("leaves") !== -1 });\n              if (!z3) {\n                t3.sort && T3.sort(function(j3, N2) {\n                  return N2.value - j3.value;\n                });\n                var O3, V2, G2 = t3.marker.colors || [], Z = !!G2.length;\n                return t3._hasColorscale ? (Z || (G2 = l3 ? t3.values : t3._values), g6t(e3, t3, { vals: G2, containerStr: "marker", cLetter: "c" }), V2 = d6t(t3.marker)) : O3 = v6t(r4["_" + t3.type + "colormap"]), T3.each(function(j3) {\n                  var N2 = j3.data.data;\n                  N2.color = t3._hasColorscale ? V2(G2[N2.i]) : O3(G2[N2.i], N2.id);\n                }), u4[0].hierarchy = T3, u4;\n              }\n            };\n            IE._runCrossTraceCalc = function(e3, t3) {\n              var r4 = t3._fullLayout, n4 = t3.calcdata, i3 = r4[e3 + "colorway"], a4 = r4["_" + e3 + "colormap"];\n              r4["extend" + e3 + "colors"] && (i3 = p6t(i3, e3 === "icicle" ? x6t : e3 === "treemap" ? _6t : y6t));\n              var o4 = 0, s3;\n              function l3(h3) {\n                var d3 = h3.data.data, v3 = d3.id;\n                d3.color === false && (a4[v3] ? d3.color = a4[v3] : h3.parent ? h3.parent.parent ? d3.color = h3.parent.data.data.color : (a4[v3] = d3.color = i3[o4 % i3.length], o4++) : d3.color = s3);\n              }\n              for (var u4 = 0; u4 < n4.length; u4++) {\n                var c5 = n4[u4], f4 = c5[0];\n                f4.trace.type === e3 && f4.hierarchy && (s3 = f4.trace.root.color, f4.hierarchy.each(l3));\n              }\n            };\n            IE.crossTraceCalc = function(e3) {\n              return IE._runCrossTraceCalc("sunburst", e3);\n            };\n            function Qke(e3, t3, r4) {\n              var n4 = 0, i3 = e3.children;\n              if (i3) {\n                for (var a4 = i3.length, o4 = 0; o4 < a4; o4++) n4 += Qke(i3[o4], t3, r4);\n                r4.branches && n4++;\n              } else r4.leaves && n4++;\n              return e3.value = e3.data.data.value = n4, t3._values || (t3._values = []), t3._values[e3.data.data.i] = n4, n4;\n            }\n          });\n          function Zy(e3, t3, r4) {\n            e3.prototype = t3.prototype = r4, r4.constructor = e3;\n          }\n          function G_(e3, t3) {\n            var r4 = Object.create(e3.prototype);\n            for (var n4 in t3) r4[n4] = t3[n4];\n            return r4;\n          }\n          var bD = gu(() => {\n          });\n          function Gm() {\n          }\n          function tCe() {\n            return this.rgb().formatHex();\n          }\n          function k6t() {\n            return this.rgb().formatHex8();\n          }\n          function C6t() {\n            return lCe(this).formatHsl();\n          }\n          function rCe() {\n            return this.rgb().formatRgb();\n          }\n          function j_(e3) {\n            var t3, r4;\n            return e3 = (e3 + "").trim().toLowerCase(), (t3 = b6t.exec(e3)) ? (r4 = t3[1].length, t3 = parseInt(t3[1], 16), r4 === 6 ? iCe(t3) : r4 === 3 ? new _d(t3 >> 8 & 15 | t3 >> 4 & 240, t3 >> 4 & 15 | t3 & 240, (t3 & 15) << 4 | t3 & 15, 1) : r4 === 8 ? wD(t3 >> 24 & 255, t3 >> 16 & 255, t3 >> 8 & 255, (t3 & 255) / 255) : r4 === 4 ? wD(t3 >> 12 & 15 | t3 >> 8 & 240, t3 >> 8 & 15 | t3 >> 4 & 240, t3 >> 4 & 15 | t3 & 240, ((t3 & 15) << 4 | t3 & 15) / 255) : null) : (t3 = w6t.exec(e3)) ? new _d(t3[1], t3[2], t3[3], 1) : (t3 = T6t.exec(e3)) ? new _d(t3[1] * 255 / 100, t3[2] * 255 / 100, t3[3] * 255 / 100, 1) : (t3 = A6t.exec(e3)) ? wD(t3[1], t3[2], t3[3], t3[4]) : (t3 = S6t.exec(e3)) ? wD(t3[1] * 255 / 100, t3[2] * 255 / 100, t3[3] * 255 / 100, t3[4]) : (t3 = M6t.exec(e3)) ? oCe(t3[1], t3[2] / 100, t3[3] / 100, 1) : (t3 = E6t.exec(e3)) ? oCe(t3[1], t3[2] / 100, t3[3] / 100, t3[4]) : eCe.hasOwnProperty(e3) ? iCe(eCe[e3]) : e3 === "transparent" ? new _d(NaN, NaN, NaN, 0) : null;\n          }\n          function iCe(e3) {\n            return new _d(e3 >> 16 & 255, e3 >> 8 & 255, e3 & 255, 1);\n          }\n          function wD(e3, t3, r4, n4) {\n            return n4 <= 0 && (e3 = t3 = r4 = NaN), new _d(e3, t3, r4, n4);\n          }\n          function FE(e3) {\n            return e3 instanceof Gm || (e3 = j_(e3)), e3 ? (e3 = e3.rgb(), new _d(e3.r, e3.g, e3.b, e3.opacity)) : new _d();\n          }\n          function kA(e3, t3, r4, n4) {\n            return arguments.length === 1 ? FE(e3) : new _d(e3, t3, r4, n4 == null ? 1 : n4);\n          }\n          function _d(e3, t3, r4, n4) {\n            this.r = +e3, this.g = +t3, this.b = +r4, this.opacity = +n4;\n          }\n          function nCe() {\n            return `#${k22(this.r)}${k22(this.g)}${k22(this.b)}`;\n          }\n          function L6t() {\n            return `#${k22(this.r)}${k22(this.g)}${k22(this.b)}${k22((isNaN(this.opacity) ? 1 : this.opacity) * 255)}`;\n          }\n          function aCe() {\n            let e3 = AD(this.opacity);\n            return `${e3 === 1 ? "rgb(" : "rgba("}${C22(this.r)}, ${C22(this.g)}, ${C22(this.b)}${e3 === 1 ? ")" : `, ${e3})`}`;\n          }\n          function AD(e3) {\n            return isNaN(e3) ? 1 : Math.max(0, Math.min(1, e3));\n          }\n          function C22(e3) {\n            return Math.max(0, Math.min(255, Math.round(e3) || 0));\n          }\n          function k22(e3) {\n            return e3 = C22(e3), (e3 < 16 ? "0" : "") + e3.toString(16);\n          }\n          function oCe(e3, t3, r4, n4) {\n            return n4 <= 0 ? e3 = t3 = r4 = NaN : r4 <= 0 || r4 >= 1 ? e3 = t3 = NaN : t3 <= 0 && (e3 = NaN), new Zg(e3, t3, r4, n4);\n          }\n          function lCe(e3) {\n            if (e3 instanceof Zg) return new Zg(e3.h, e3.s, e3.l, e3.opacity);\n            if (e3 instanceof Gm || (e3 = j_(e3)), !e3) return new Zg();\n            if (e3 instanceof Zg) return e3;\n            e3 = e3.rgb();\n            var t3 = e3.r / 255, r4 = e3.g / 255, n4 = e3.b / 255, i3 = Math.min(t3, r4, n4), a4 = Math.max(t3, r4, n4), o4 = NaN, s3 = a4 - i3, l3 = (a4 + i3) / 2;\n            return s3 ? (t3 === a4 ? o4 = (r4 - n4) / s3 + (r4 < n4) * 6 : r4 === a4 ? o4 = (n4 - t3) / s3 + 2 : o4 = (t3 - r4) / s3 + 4, s3 /= l3 < 0.5 ? a4 + i3 : 2 - a4 - i3, o4 *= 60) : s3 = l3 > 0 && l3 < 1 ? 0 : o4, new Zg(o4, s3, l3, e3.opacity);\n          }\n          function zE(e3, t3, r4, n4) {\n            return arguments.length === 1 ? lCe(e3) : new Zg(e3, t3, r4, n4 == null ? 1 : n4);\n          }\n          function Zg(e3, t3, r4, n4) {\n            this.h = +e3, this.s = +t3, this.l = +r4, this.opacity = +n4;\n          }\n          function sCe(e3) {\n            return e3 = (e3 || 0) % 360, e3 < 0 ? e3 + 360 : e3;\n          }\n          function TD(e3) {\n            return Math.max(0, Math.min(1, e3 || 0));\n          }\n          function xW(e3, t3, r4) {\n            return (e3 < 60 ? t3 + (r4 - t3) * e3 / 60 : e3 < 180 ? r4 : e3 < 240 ? t3 + (r4 - t3) * (240 - e3) / 60 : t3) * 255;\n          }\n          var H_, L2, EA, DE, Vm, b6t, w6t, T6t, A6t, S6t, M6t, E6t, eCe, SD = gu(() => {\n            bD();\n            H_ = 0.7, L2 = 1 / H_, EA = "\\\\s*([+-]?\\\\d+)\\\\s*", DE = "\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)\\\\s*", Vm = "\\\\s*([+-]?(?:\\\\d*\\\\.)?\\\\d+(?:[eE][+-]?\\\\d+)?)%\\\\s*", b6t = /^#([0-9a-f]{3,8})$/, w6t = new RegExp(`^rgb\\\\(${EA},${EA},${EA}\\\\)$`), T6t = new RegExp(`^rgb\\\\(${Vm},${Vm},${Vm}\\\\)$`), A6t = new RegExp(`^rgba\\\\(${EA},${EA},${EA},${DE}\\\\)$`), S6t = new RegExp(`^rgba\\\\(${Vm},${Vm},${Vm},${DE}\\\\)$`), M6t = new RegExp(`^hsl\\\\(${DE},${Vm},${Vm}\\\\)$`), E6t = new RegExp(`^hsla\\\\(${DE},${Vm},${Vm},${DE}\\\\)$`), eCe = { aliceblue: 15792383, antiquewhite: 16444375, aqua: 65535, aquamarine: 8388564, azure: 15794175, beige: 16119260, bisque: 16770244, black: 0, blanchedalmond: 16772045, blue: 255, blueviolet: 9055202, brown: 10824234, burlywood: 14596231, cadetblue: 6266528, chartreuse: 8388352, chocolate: 13789470, coral: 16744272, cornflowerblue: 6591981, cornsilk: 16775388, crimson: 14423100, cyan: 65535, darkblue: 139, darkcyan: 35723, darkgoldenrod: 12092939, darkgray: 11119017, darkgreen: 25600, darkgrey: 11119017, darkkhaki: 12433259, darkmagenta: 9109643, darkolivegreen: 5597999, darkorange: 16747520, darkorchid: 10040012, darkred: 9109504, darksalmon: 15308410, darkseagreen: 9419919, darkslateblue: 4734347, darkslategray: 3100495, darkslategrey: 3100495, darkturquoise: 52945, darkviolet: 9699539, deeppink: 16716947, deepskyblue: 49151, dimgray: 6908265, dimgrey: 6908265, dodgerblue: 2003199, firebrick: 11674146, floralwhite: 16775920, forestgreen: 2263842, fuchsia: 16711935, gainsboro: 14474460, ghostwhite: 16316671, gold: 16766720, goldenrod: 14329120, gray: 8421504, green: 32768, greenyellow: 11403055, grey: 8421504, honeydew: 15794160, hotpink: 16738740, indianred: 13458524, indigo: 4915330, ivory: 16777200, khaki: 15787660, lavender: 15132410, lavenderblush: 16773365, lawngreen: 8190976, lemonchiffon: 16775885, lightblue: 11393254, lightcoral: 15761536, lightcyan: 14745599, lightgoldenrodyellow: 16448210, lightgray: 13882323, lightgreen: 9498256, lightgrey: 13882323, lightpink: 16758465, lightsalmon: 16752762, lightseagreen: 2142890, lightskyblue: 8900346, lightslategray: 7833753, lightslategrey: 7833753, lightsteelblue: 11584734, lightyellow: 16777184, lime: 65280, limegreen: 3329330, linen: 16445670, magenta: 16711935, maroon: 8388608, mediumaquamarine: 6737322, mediumblue: 205, mediumorchid: 12211667, mediumpurple: 9662683, mediumseagreen: 3978097, mediumslateblue: 8087790, mediumspringgreen: 64154, mediumturquoise: 4772300, mediumvioletred: 13047173, midnightblue: 1644912, mintcream: 16121850, mistyrose: 16770273, moccasin: 16770229, navajowhite: 16768685, navy: 128, oldlace: 16643558, olive: 8421376, olivedrab: 7048739, orange: 16753920, orangered: 16729344, orchid: 14315734, palegoldenrod: 15657130, palegreen: 10025880, paleturquoise: 11529966, palevioletred: 14381203, papayawhip: 16773077, peachpuff: 16767673, peru: 13468991, pink: 16761035, plum: 14524637, powderblue: 11591910, purple: 8388736, rebeccapurple: 6697881, red: 16711680, rosybrown: 12357519, royalblue: 4286945, saddlebrown: 9127187, salmon: 16416882, sandybrown: 16032864, seagreen: 3050327, seashell: 16774638, sienna: 10506797, silver: 12632256, skyblue: 8900331, slateblue: 6970061, slategray: 7372944, slategrey: 7372944, snow: 16775930, springgreen: 65407, steelblue: 4620980, tan: 13808780, teal: 32896, thistle: 14204888, tomato: 16737095, turquoise: 4251856, violet: 15631086, wheat: 16113331, white: 16777215, whitesmoke: 16119285, yellow: 16776960, yellowgreen: 10145074 };\n            Zy(Gm, j_, { copy(e3) {\n              return Object.assign(new this.constructor(), this, e3);\n            }, displayable() {\n              return this.rgb().displayable();\n            }, hex: tCe, formatHex: tCe, formatHex8: k6t, formatHsl: C6t, formatRgb: rCe, toString: rCe });\n            Zy(_d, kA, G_(Gm, { brighter(e3) {\n              return e3 = e3 == null ? L2 : Math.pow(L2, e3), new _d(this.r * e3, this.g * e3, this.b * e3, this.opacity);\n            }, darker(e3) {\n              return e3 = e3 == null ? H_ : Math.pow(H_, e3), new _d(this.r * e3, this.g * e3, this.b * e3, this.opacity);\n            }, rgb() {\n              return this;\n            }, clamp() {\n              return new _d(C22(this.r), C22(this.g), C22(this.b), AD(this.opacity));\n            }, displayable() {\n              return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;\n            }, hex: nCe, formatHex: nCe, formatHex8: L6t, formatRgb: aCe, toString: aCe }));\n            Zy(Zg, zE, G_(Gm, { brighter(e3) {\n              return e3 = e3 == null ? L2 : Math.pow(L2, e3), new Zg(this.h, this.s, this.l * e3, this.opacity);\n            }, darker(e3) {\n              return e3 = e3 == null ? H_ : Math.pow(H_, e3), new Zg(this.h, this.s, this.l * e3, this.opacity);\n            }, rgb() {\n              var e3 = this.h % 360 + (this.h < 0) * 360, t3 = isNaN(e3) || isNaN(this.s) ? 0 : this.s, r4 = this.l, n4 = r4 + (r4 < 0.5 ? r4 : 1 - r4) * t3, i3 = 2 * r4 - n4;\n              return new _d(xW(e3 >= 240 ? e3 - 240 : e3 + 120, i3, n4), xW(e3, i3, n4), xW(e3 < 120 ? e3 + 240 : e3 - 120, i3, n4), this.opacity);\n            }, clamp() {\n              return new Zg(sCe(this.h), TD(this.s), TD(this.l), AD(this.opacity));\n            }, displayable() {\n              return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;\n            }, formatHsl() {\n              let e3 = AD(this.opacity);\n              return `${e3 === 1 ? "hsl(" : "hsla("}${sCe(this.h)}, ${TD(this.s) * 100}%, ${TD(this.l) * 100}%${e3 === 1 ? ")" : `, ${e3})`}`;\n            } }));\n          });\n          var MD, ED, bW = gu(() => {\n            MD = Math.PI / 180, ED = 180 / Math.PI;\n          });\n          function vCe(e3) {\n            if (e3 instanceof Hm) return new Hm(e3.l, e3.a, e3.b, e3.opacity);\n            if (e3 instanceof Yy) return pCe(e3);\n            e3 instanceof _d || (e3 = FE(e3));\n            var t3 = SW(e3.r), r4 = SW(e3.g), n4 = SW(e3.b), i3 = wW((0.2225045 * t3 + 0.7168786 * r4 + 0.0606169 * n4) / cCe), a4, o4;\n            return t3 === r4 && r4 === n4 ? a4 = o4 = i3 : (a4 = wW((0.4360747 * t3 + 0.3850649 * r4 + 0.1430804 * n4) / uCe), o4 = wW((0.0139322 * t3 + 0.0971045 * r4 + 0.7141733 * n4) / fCe)), new Hm(116 * i3 - 16, 500 * (a4 - i3), 200 * (i3 - o4), e3.opacity);\n          }\n          function LA(e3, t3, r4, n4) {\n            return arguments.length === 1 ? vCe(e3) : new Hm(e3, t3, r4, n4 == null ? 1 : n4);\n          }\n          function Hm(e3, t3, r4, n4) {\n            this.l = +e3, this.a = +t3, this.b = +r4, this.opacity = +n4;\n          }\n          function wW(e3) {\n            return e3 > P6t ? Math.pow(e3, 1 / 3) : e3 / dCe + hCe;\n          }\n          function TW(e3) {\n            return e3 > CA ? e3 * e3 * e3 : dCe * (e3 - hCe);\n          }\n          function AW(e3) {\n            return 255 * (e3 <= 31308e-7 ? 12.92 * e3 : 1.055 * Math.pow(e3, 1 / 2.4) - 0.055);\n          }\n          function SW(e3) {\n            return (e3 /= 255) <= 0.04045 ? e3 / 12.92 : Math.pow((e3 + 0.055) / 1.055, 2.4);\n          }\n          function I6t(e3) {\n            if (e3 instanceof Yy) return new Yy(e3.h, e3.c, e3.l, e3.opacity);\n            if (e3 instanceof Hm || (e3 = vCe(e3)), e3.a === 0 && e3.b === 0) return new Yy(NaN, 0 < e3.l && e3.l < 100 ? 0 : NaN, e3.l, e3.opacity);\n            var t3 = Math.atan2(e3.b, e3.a) * ED;\n            return new Yy(t3 < 0 ? t3 + 360 : t3, Math.sqrt(e3.a * e3.a + e3.b * e3.b), e3.l, e3.opacity);\n          }\n          function OE(e3, t3, r4, n4) {\n            return arguments.length === 1 ? I6t(e3) : new Yy(e3, t3, r4, n4 == null ? 1 : n4);\n          }\n          function Yy(e3, t3, r4, n4) {\n            this.h = +e3, this.c = +t3, this.l = +r4, this.opacity = +n4;\n          }\n          function pCe(e3) {\n            if (isNaN(e3.h)) return new Hm(e3.l, 0, 0, e3.opacity);\n            var t3 = e3.h * MD;\n            return new Hm(e3.l, Math.cos(t3) * e3.c, Math.sin(t3) * e3.c, e3.opacity);\n          }\n          var kD, uCe, cCe, fCe, hCe, CA, dCe, P6t, gCe = gu(() => {\n            bD();\n            SD();\n            bW();\n            kD = 18, uCe = 0.96422, cCe = 1, fCe = 0.82521, hCe = 4 / 29, CA = 6 / 29, dCe = 3 * CA * CA, P6t = CA * CA * CA;\n            Zy(Hm, LA, G_(Gm, { brighter(e3) {\n              return new Hm(this.l + kD * (e3 == null ? 1 : e3), this.a, this.b, this.opacity);\n            }, darker(e3) {\n              return new Hm(this.l - kD * (e3 == null ? 1 : e3), this.a, this.b, this.opacity);\n            }, rgb() {\n              var e3 = (this.l + 16) / 116, t3 = isNaN(this.a) ? e3 : e3 + this.a / 500, r4 = isNaN(this.b) ? e3 : e3 - this.b / 200;\n              return t3 = uCe * TW(t3), e3 = cCe * TW(e3), r4 = fCe * TW(r4), new _d(AW(3.1338561 * t3 - 1.6168667 * e3 - 0.4906146 * r4), AW(-0.9787684 * t3 + 1.9161415 * e3 + 0.033454 * r4), AW(0.0719453 * t3 - 0.2289914 * e3 + 1.4052427 * r4), this.opacity);\n            } }));\n            Zy(Yy, OE, G_(Gm, { brighter(e3) {\n              return new Yy(this.h, this.c, this.l + kD * (e3 == null ? 1 : e3), this.opacity);\n            }, darker(e3) {\n              return new Yy(this.h, this.c, this.l - kD * (e3 == null ? 1 : e3), this.opacity);\n            }, rgb() {\n              return pCe(this).rgb();\n            } }));\n          });\n          function R6t(e3) {\n            if (e3 instanceof P2) return new P2(e3.h, e3.s, e3.l, e3.opacity);\n            e3 instanceof _d || (e3 = FE(e3));\n            var t3 = e3.r / 255, r4 = e3.g / 255, n4 = e3.b / 255, i3 = (_Ce * n4 + mCe * t3 - yCe * r4) / (_Ce + mCe - yCe), a4 = n4 - i3, o4 = (qE * (r4 - i3) - EW * a4) / CD, s3 = Math.sqrt(o4 * o4 + a4 * a4) / (qE * i3 * (1 - i3)), l3 = s3 ? Math.atan2(o4, a4) * ED - 120 : NaN;\n            return new P2(l3 < 0 ? l3 + 360 : l3, s3, i3, e3.opacity);\n          }\n          function PA(e3, t3, r4, n4) {\n            return arguments.length === 1 ? R6t(e3) : new P2(e3, t3, r4, n4 == null ? 1 : n4);\n          }\n          function P2(e3, t3, r4, n4) {\n            this.h = +e3, this.s = +t3, this.l = +r4, this.opacity = +n4;\n          }\n          var xCe, MW, EW, CD, qE, mCe, yCe, _Ce, bCe = gu(() => {\n            bD();\n            SD();\n            bW();\n            xCe = -0.14861, MW = 1.78277, EW = -0.29227, CD = -0.90649, qE = 1.97294, mCe = qE * CD, yCe = qE * MW, _Ce = MW * EW - CD * xCe;\n            Zy(P2, PA, G_(Gm, { brighter(e3) {\n              return e3 = e3 == null ? L2 : Math.pow(L2, e3), new P2(this.h, this.s, this.l * e3, this.opacity);\n            }, darker(e3) {\n              return e3 = e3 == null ? H_ : Math.pow(H_, e3), new P2(this.h, this.s, this.l * e3, this.opacity);\n            }, rgb() {\n              var e3 = isNaN(this.h) ? 0 : (this.h + 120) * MD, t3 = +this.l, r4 = isNaN(this.s) ? 0 : this.s * t3 * (1 - t3), n4 = Math.cos(e3), i3 = Math.sin(e3);\n              return new _d(255 * (t3 + r4 * (xCe * n4 + MW * i3)), 255 * (t3 + r4 * (EW * n4 + CD * i3)), 255 * (t3 + r4 * (qE * n4)), this.opacity);\n            } }));\n          });\n          var I2 = gu(() => {\n            SD();\n            gCe();\n            bCe();\n          });\n          function kW(e3, t3, r4, n4, i3) {\n            var a4 = e3 * e3, o4 = a4 * e3;\n            return ((1 - 3 * e3 + 3 * a4 - o4) * t3 + (4 - 6 * a4 + 3 * o4) * r4 + (1 + 3 * e3 + 3 * a4 - 3 * o4) * n4 + o4 * i3) / 6;\n          }\n          function LD(e3) {\n            var t3 = e3.length - 1;\n            return function(r4) {\n              var n4 = r4 <= 0 ? r4 = 0 : r4 >= 1 ? (r4 = 1, t3 - 1) : Math.floor(r4 * t3), i3 = e3[n4], a4 = e3[n4 + 1], o4 = n4 > 0 ? e3[n4 - 1] : 2 * i3 - a4, s3 = n4 < t3 - 1 ? e3[n4 + 2] : 2 * a4 - i3;\n              return kW((r4 - n4 / t3) * t3, o4, i3, a4, s3);\n            };\n          }\n          var PD = gu(() => {\n          });\n          function ID(e3) {\n            var t3 = e3.length;\n            return function(r4) {\n              var n4 = Math.floor(((r4 %= 1) < 0 ? ++r4 : r4) * t3), i3 = e3[(n4 + t3 - 1) % t3], a4 = e3[n4 % t3], o4 = e3[(n4 + 1) % t3], s3 = e3[(n4 + 2) % t3];\n              return kW((r4 - n4 / t3) * t3, i3, a4, o4, s3);\n            };\n          }\n          var CW = gu(() => {\n            PD();\n          });\n          var IA, LW = gu(() => {\n            IA = (e3) => () => e3;\n          });\n          function wCe(e3, t3) {\n            return function(r4) {\n              return e3 + r4 * t3;\n            };\n          }\n          function D6t(e3, t3, r4) {\n            return e3 = Math.pow(e3, r4), t3 = Math.pow(t3, r4) - e3, r4 = 1 / r4, function(n4) {\n              return Math.pow(e3 + n4 * t3, r4);\n            };\n          }\n          function W_(e3, t3) {\n            var r4 = t3 - e3;\n            return r4 ? wCe(e3, r4 > 180 || r4 < -180 ? r4 - 360 * Math.round(r4 / 360) : r4) : IA(isNaN(e3) ? t3 : e3);\n          }\n          function TCe(e3) {\n            return (e3 = +e3) == 1 ? $f : function(t3, r4) {\n              return r4 - t3 ? D6t(t3, r4, e3) : IA(isNaN(t3) ? r4 : t3);\n            };\n          }\n          function $f(e3, t3) {\n            var r4 = t3 - e3;\n            return r4 ? wCe(e3, r4) : IA(isNaN(e3) ? t3 : e3);\n          }\n          var R2 = gu(() => {\n            LW();\n          });\n          function ACe(e3) {\n            return function(t3) {\n              var r4 = t3.length, n4 = new Array(r4), i3 = new Array(r4), a4 = new Array(r4), o4, s3;\n              for (o4 = 0; o4 < r4; ++o4) s3 = kA(t3[o4]), n4[o4] = s3.r || 0, i3[o4] = s3.g || 0, a4[o4] = s3.b || 0;\n              return n4 = e3(n4), i3 = e3(i3), a4 = e3(a4), s3.opacity = 1, function(l3) {\n                return s3.r = n4(l3), s3.g = i3(l3), s3.b = a4(l3), s3 + "";\n              };\n            };\n          }\n          var BE, SCe, MCe, PW = gu(() => {\n            I2();\n            PD();\n            CW();\n            R2();\n            BE = (function e3(t3) {\n              var r4 = TCe(t3);\n              function n4(i3, a4) {\n                var o4 = r4((i3 = kA(i3)).r, (a4 = kA(a4)).r), s3 = r4(i3.g, a4.g), l3 = r4(i3.b, a4.b), u4 = $f(i3.opacity, a4.opacity);\n                return function(c5) {\n                  return i3.r = o4(c5), i3.g = s3(c5), i3.b = l3(c5), i3.opacity = u4(c5), i3 + "";\n                };\n              }\n              return n4.gamma = e3, n4;\n            })(1);\n            SCe = ACe(LD), MCe = ACe(ID);\n          });\n          function RA(e3, t3) {\n            t3 || (t3 = []);\n            var r4 = e3 ? Math.min(t3.length, e3.length) : 0, n4 = t3.slice(), i3;\n            return function(a4) {\n              for (i3 = 0; i3 < r4; ++i3) n4[i3] = e3[i3] * (1 - a4) + t3[i3] * a4;\n              return n4;\n            };\n          }\n          function RD(e3) {\n            return ArrayBuffer.isView(e3) && !(e3 instanceof DataView);\n          }\n          var DD = gu(() => {\n          });\n          function ECe(e3, t3) {\n            return (RD(t3) ? RA : IW)(e3, t3);\n          }\n          function IW(e3, t3) {\n            var r4 = t3 ? t3.length : 0, n4 = e3 ? Math.min(r4, e3.length) : 0, i3 = new Array(n4), a4 = new Array(r4), o4;\n            for (o4 = 0; o4 < n4; ++o4) i3[o4] = X_(e3[o4], t3[o4]);\n            for (; o4 < r4; ++o4) a4[o4] = t3[o4];\n            return function(s3) {\n              for (o4 = 0; o4 < n4; ++o4) a4[o4] = i3[o4](s3);\n              return a4;\n            };\n          }\n          var RW = gu(() => {\n            NE();\n            DD();\n          });\n          function FD(e3, t3) {\n            var r4 = /* @__PURE__ */ new Date();\n            return e3 = +e3, t3 = +t3, function(n4) {\n              return r4.setTime(e3 * (1 - n4) + t3 * n4), r4;\n            };\n          }\n          var DW = gu(() => {\n          });\n          function zp(e3, t3) {\n            return e3 = +e3, t3 = +t3, function(r4) {\n              return e3 * (1 - r4) + t3 * r4;\n            };\n          }\n          var UE = gu(() => {\n          });\n          function zD(e3, t3) {\n            var r4 = {}, n4 = {}, i3;\n            (e3 === null || typeof e3 != "object") && (e3 = {}), (t3 === null || typeof t3 != "object") && (t3 = {});\n            for (i3 in t3) i3 in e3 ? r4[i3] = X_(e3[i3], t3[i3]) : n4[i3] = t3[i3];\n            return function(a4) {\n              for (i3 in r4) n4[i3] = r4[i3](a4);\n              return n4;\n            };\n          }\n          var FW = gu(() => {\n            NE();\n          });\n          function F6t(e3) {\n            return function() {\n              return e3;\n            };\n          }\n          function z6t(e3) {\n            return function(t3) {\n              return e3(t3) + "";\n            };\n          }\n          function OD(e3, t3) {\n            var r4 = OW.lastIndex = zW.lastIndex = 0, n4, i3, a4, o4 = -1, s3 = [], l3 = [];\n            for (e3 = e3 + "", t3 = t3 + ""; (n4 = OW.exec(e3)) && (i3 = zW.exec(t3)); ) (a4 = i3.index) > r4 && (a4 = t3.slice(r4, a4), s3[o4] ? s3[o4] += a4 : s3[++o4] = a4), (n4 = n4[0]) === (i3 = i3[0]) ? s3[o4] ? s3[o4] += i3 : s3[++o4] = i3 : (s3[++o4] = null, l3.push({ i: o4, x: zp(n4, i3) })), r4 = zW.lastIndex;\n            return r4 < t3.length && (a4 = t3.slice(r4), s3[o4] ? s3[o4] += a4 : s3[++o4] = a4), s3.length < 2 ? l3[0] ? z6t(l3[0].x) : F6t(t3) : (t3 = l3.length, function(u4) {\n              for (var c5 = 0, f4; c5 < t3; ++c5) s3[(f4 = l3[c5]).i] = f4.x(u4);\n              return s3.join("");\n            });\n          }\n          var OW, zW, qW = gu(() => {\n            UE();\n            OW = /[-+]?(?:\\d+\\.?\\d*|\\.?\\d+)(?:[eE][-+]?\\d+)?/g, zW = new RegExp(OW.source, "g");\n          });\n          function X_(e3, t3) {\n            var r4 = typeof t3, n4;\n            return t3 == null || r4 === "boolean" ? IA(t3) : (r4 === "number" ? zp : r4 === "string" ? (n4 = j_(t3)) ? (t3 = n4, BE) : OD : t3 instanceof j_ ? BE : t3 instanceof Date ? FD : RD(t3) ? RA : Array.isArray(t3) ? IW : typeof t3.valueOf != "function" && typeof t3.toString != "function" || isNaN(t3) ? zD : zp)(e3, t3);\n          }\n          var NE = gu(() => {\n            I2();\n            PW();\n            RW();\n            DW();\n            UE();\n            FW();\n            qW();\n            LW();\n            DD();\n          });\n          function kCe(e3) {\n            var t3 = e3.length;\n            return function(r4) {\n              return e3[Math.max(0, Math.min(t3 - 1, Math.floor(r4 * t3)))];\n            };\n          }\n          var CCe = gu(() => {\n          });\n          function LCe(e3, t3) {\n            var r4 = W_(+e3, +t3);\n            return function(n4) {\n              var i3 = r4(n4);\n              return i3 - 360 * Math.floor(i3 / 360);\n            };\n          }\n          var PCe = gu(() => {\n            R2();\n          });\n          function ICe(e3, t3) {\n            return e3 = +e3, t3 = +t3, function(r4) {\n              return Math.round(e3 * (1 - r4) + t3 * r4);\n            };\n          }\n          var RCe = gu(() => {\n          });\n          function BW(e3, t3, r4, n4, i3, a4) {\n            var o4, s3, l3;\n            return (o4 = Math.sqrt(e3 * e3 + t3 * t3)) && (e3 /= o4, t3 /= o4), (l3 = e3 * r4 + t3 * n4) && (r4 -= e3 * l3, n4 -= t3 * l3), (s3 = Math.sqrt(r4 * r4 + n4 * n4)) && (r4 /= s3, n4 /= s3, l3 /= s3), e3 * n4 < t3 * r4 && (e3 = -e3, t3 = -t3, l3 = -l3, o4 = -o4), { translateX: i3, translateY: a4, rotate: Math.atan2(t3, e3) * DCe, skewX: Math.atan(l3) * DCe, scaleX: o4, scaleY: s3 };\n          }\n          var DCe, qD, FCe = gu(() => {\n            DCe = 180 / Math.PI, qD = { translateX: 0, translateY: 0, rotate: 0, skewX: 0, scaleX: 1, scaleY: 1 };\n          });\n          function zCe(e3) {\n            let t3 = new (typeof DOMMatrix == "function" ? DOMMatrix : WebKitCSSMatrix)(e3 + "");\n            return t3.isIdentity ? qD : BW(t3.a, t3.b, t3.c, t3.d, t3.e, t3.f);\n          }\n          function OCe(e3) {\n            return e3 == null ? qD : (BD || (BD = document.createElementNS("http://www.w3.org/2000/svg", "g")), BD.setAttribute("transform", e3), (e3 = BD.transform.baseVal.consolidate()) ? (e3 = e3.matrix, BW(e3.a, e3.b, e3.c, e3.d, e3.e, e3.f)) : qD);\n          }\n          var BD, qCe = gu(() => {\n            FCe();\n          });\n          function BCe(e3, t3, r4, n4) {\n            function i3(u4) {\n              return u4.length ? u4.pop() + " " : "";\n            }\n            function a4(u4, c5, f4, h3, d3, v3) {\n              if (u4 !== f4 || c5 !== h3) {\n                var _2 = d3.push("translate(", null, t3, null, r4);\n                v3.push({ i: _2 - 4, x: zp(u4, f4) }, { i: _2 - 2, x: zp(c5, h3) });\n              } else (f4 || h3) && d3.push("translate(" + f4 + t3 + h3 + r4);\n            }\n            function o4(u4, c5, f4, h3) {\n              u4 !== c5 ? (u4 - c5 > 180 ? c5 += 360 : c5 - u4 > 180 && (u4 += 360), h3.push({ i: f4.push(i3(f4) + "rotate(", null, n4) - 2, x: zp(u4, c5) })) : c5 && f4.push(i3(f4) + "rotate(" + c5 + n4);\n            }\n            function s3(u4, c5, f4, h3) {\n              u4 !== c5 ? h3.push({ i: f4.push(i3(f4) + "skewX(", null, n4) - 2, x: zp(u4, c5) }) : c5 && f4.push(i3(f4) + "skewX(" + c5 + n4);\n            }\n            function l3(u4, c5, f4, h3, d3, v3) {\n              if (u4 !== f4 || c5 !== h3) {\n                var _2 = d3.push(i3(d3) + "scale(", null, ",", null, ")");\n                v3.push({ i: _2 - 4, x: zp(u4, f4) }, { i: _2 - 2, x: zp(c5, h3) });\n              } else (f4 !== 1 || h3 !== 1) && d3.push(i3(d3) + "scale(" + f4 + "," + h3 + ")");\n            }\n            return function(u4, c5) {\n              var f4 = [], h3 = [];\n              return u4 = e3(u4), c5 = e3(c5), a4(u4.translateX, u4.translateY, c5.translateX, c5.translateY, f4, h3), o4(u4.rotate, c5.rotate, f4, h3), s3(u4.skewX, c5.skewX, f4, h3), l3(u4.scaleX, u4.scaleY, c5.scaleX, c5.scaleY, f4, h3), u4 = c5 = null, function(d3) {\n                for (var v3 = -1, _2 = h3.length, b; ++v3 < _2; ) f4[(b = h3[v3]).i] = b.x(d3);\n                return f4.join("");\n              };\n            };\n          }\n          var NCe, UCe, VCe = gu(() => {\n            UE();\n            qCe();\n            NCe = BCe(zCe, "px, ", "px)", "deg)"), UCe = BCe(OCe, ", ", ")", ")");\n          });\n          function GCe(e3) {\n            return ((e3 = Math.exp(e3)) + 1 / e3) / 2;\n          }\n          function q6t(e3) {\n            return ((e3 = Math.exp(e3)) - 1 / e3) / 2;\n          }\n          function B6t(e3) {\n            return ((e3 = Math.exp(2 * e3)) - 1) / (e3 + 1);\n          }\n          var O6t, HCe, jCe = gu(() => {\n            O6t = 1e-12;\n            HCe = (function e3(t3, r4, n4) {\n              function i3(a4, o4) {\n                var s3 = a4[0], l3 = a4[1], u4 = a4[2], c5 = o4[0], f4 = o4[1], h3 = o4[2], d3 = c5 - s3, v3 = f4 - l3, _2 = d3 * d3 + v3 * v3, b, p3;\n                if (_2 < O6t) p3 = Math.log(h3 / u4) / t3, b = function(C3) {\n                  return [s3 + C3 * d3, l3 + C3 * v3, u4 * Math.exp(t3 * C3 * p3)];\n                };\n                else {\n                  var k4 = Math.sqrt(_2), E3 = (h3 * h3 - u4 * u4 + n4 * _2) / (2 * u4 * r4 * k4), S2 = (h3 * h3 - u4 * u4 - n4 * _2) / (2 * h3 * r4 * k4), L3 = Math.log(Math.sqrt(E3 * E3 + 1) - E3), x2 = Math.log(Math.sqrt(S2 * S2 + 1) - S2);\n                  p3 = (x2 - L3) / t3, b = function(C3) {\n                    var M4 = C3 * p3, g3 = GCe(L3), P3 = u4 / (r4 * k4) * (g3 * B6t(t3 * M4 + L3) - q6t(L3));\n                    return [s3 + P3 * d3, l3 + P3 * v3, u4 * g3 / GCe(t3 * M4 + L3)];\n                  };\n                }\n                return b.duration = p3 * 1e3 * t3 / Math.SQRT2, b;\n              }\n              return i3.rho = function(a4) {\n                var o4 = Math.max(1e-3, +a4), s3 = o4 * o4, l3 = s3 * s3;\n                return e3(o4, s3, l3);\n              }, i3;\n            })(Math.SQRT2, 2, 4);\n          });\n          function WCe(e3) {\n            return function(t3, r4) {\n              var n4 = e3((t3 = zE(t3)).h, (r4 = zE(r4)).h), i3 = $f(t3.s, r4.s), a4 = $f(t3.l, r4.l), o4 = $f(t3.opacity, r4.opacity);\n              return function(s3) {\n                return t3.h = n4(s3), t3.s = i3(s3), t3.l = a4(s3), t3.opacity = o4(s3), t3 + "";\n              };\n            };\n          }\n          var XCe, ZCe, YCe = gu(() => {\n            I2();\n            R2();\n            XCe = WCe(W_), ZCe = WCe($f);\n          });\n          function NW(e3, t3) {\n            var r4 = $f((e3 = LA(e3)).l, (t3 = LA(t3)).l), n4 = $f(e3.a, t3.a), i3 = $f(e3.b, t3.b), a4 = $f(e3.opacity, t3.opacity);\n            return function(o4) {\n              return e3.l = r4(o4), e3.a = n4(o4), e3.b = i3(o4), e3.opacity = a4(o4), e3 + "";\n            };\n          }\n          var KCe = gu(() => {\n            I2();\n            R2();\n          });\n          function JCe(e3) {\n            return function(t3, r4) {\n              var n4 = e3((t3 = OE(t3)).h, (r4 = OE(r4)).h), i3 = $f(t3.c, r4.c), a4 = $f(t3.l, r4.l), o4 = $f(t3.opacity, r4.opacity);\n              return function(s3) {\n                return t3.h = n4(s3), t3.c = i3(s3), t3.l = a4(s3), t3.opacity = o4(s3), t3 + "";\n              };\n            };\n          }\n          var $Ce, QCe, e6e = gu(() => {\n            I2();\n            R2();\n            $Ce = JCe(W_), QCe = JCe($f);\n          });\n          function t6e(e3) {\n            return (function t3(r4) {\n              r4 = +r4;\n              function n4(i3, a4) {\n                var o4 = e3((i3 = PA(i3)).h, (a4 = PA(a4)).h), s3 = $f(i3.s, a4.s), l3 = $f(i3.l, a4.l), u4 = $f(i3.opacity, a4.opacity);\n                return function(c5) {\n                  return i3.h = o4(c5), i3.s = s3(c5), i3.l = l3(Math.pow(c5, r4)), i3.opacity = u4(c5), i3 + "";\n                };\n              }\n              return n4.gamma = t3, n4;\n            })(1);\n          }\n          var r6e, i6e, n6e = gu(() => {\n            I2();\n            R2();\n            r6e = t6e(W_), i6e = t6e($f);\n          });\n          function UW(e3, t3) {\n            t3 === void 0 && (t3 = e3, e3 = X_);\n            for (var r4 = 0, n4 = t3.length - 1, i3 = t3[0], a4 = new Array(n4 < 0 ? 0 : n4); r4 < n4; ) a4[r4] = e3(i3, i3 = t3[++r4]);\n            return function(o4) {\n              var s3 = Math.max(0, Math.min(n4 - 1, Math.floor(o4 *= n4)));\n              return a4[s3](o4 - s3);\n            };\n          }\n          var a6e = gu(() => {\n            NE();\n          });\n          function o6e(e3, t3) {\n            for (var r4 = new Array(t3), n4 = 0; n4 < t3; ++n4) r4[n4] = e3(n4 / (t3 - 1));\n            return r4;\n          }\n          var s6e = gu(() => {\n          });\n          var D22 = {};\n          cee(D22, { interpolate: () => X_, interpolateArray: () => ECe, interpolateBasis: () => LD, interpolateBasisClosed: () => ID, interpolateCubehelix: () => r6e, interpolateCubehelixLong: () => i6e, interpolateDate: () => FD, interpolateDiscrete: () => kCe, interpolateHcl: () => $Ce, interpolateHclLong: () => QCe, interpolateHsl: () => XCe, interpolateHslLong: () => ZCe, interpolateHue: () => LCe, interpolateLab: () => NW, interpolateNumber: () => zp, interpolateNumberArray: () => RA, interpolateObject: () => zD, interpolateRgb: () => BE, interpolateRgbBasis: () => SCe, interpolateRgbBasisClosed: () => MCe, interpolateRound: () => ICe, interpolateString: () => OD, interpolateTransformCss: () => NCe, interpolateTransformSvg: () => UCe, interpolateZoom: () => HCe, piecewise: () => UW, quantize: () => o6e });\n          var F2 = gu(() => {\n            NE();\n            RW();\n            PD();\n            CW();\n            DW();\n            CCe();\n            PCe();\n            UE();\n            DD();\n            FW();\n            RCe();\n            qW();\n            VCe();\n            jCe();\n            PW();\n            YCe();\n            KCe();\n            e6e();\n            n6e();\n            a6e();\n            s6e();\n          });\n          var ND = ye((Ypr, l6e) => {\n            "use strict";\n            var N6t = So(), U6t = ka();\n            l6e.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = r4.data.data, s3 = o4.i, l3 = a4 || o4.color;\n              if (s3 >= 0) {\n                r4.i = o4.i;\n                var u4 = n4.marker;\n                u4.pattern ? (!u4.colors || !u4.pattern.shape) && (u4.color = l3, r4.color = l3) : (u4.color = l3, r4.color = l3), N6t.pointStyle(t3, n4, i3, r4);\n              } else U6t.fill(t3, l3);\n            };\n          });\n          var VW = ye((Kpr, d6e) => {\n            "use strict";\n            var u6e = Oa(), c6e = ka(), f6e = Dr(), V6t = bv().resizeText, G6t = ND();\n            function H6t(e3) {\n              var t3 = e3._fullLayout._sunburstlayer.selectAll(".trace");\n              V6t(e3, t3, "sunburst"), t3.each(function(r4) {\n                var n4 = u6e.select(this), i3 = r4[0], a4 = i3.trace;\n                n4.style("opacity", a4.opacity), n4.selectAll("path.surface").each(function(o4) {\n                  u6e.select(this).call(h6e, o4, a4, e3);\n                });\n              });\n            }\n            function h6e(e3, t3, r4, n4) {\n              var i3 = t3.data.data, a4 = !t3.children, o4 = i3.i, s3 = f6e.castOption(r4, o4, "marker.line.color") || c6e.defaultLine, l3 = f6e.castOption(r4, o4, "marker.line.width") || 0;\n              e3.call(G6t, t3, r4, n4).style("stroke-width", l3).call(c6e.stroke, s3).style("opacity", a4 ? r4.leaf.opacity : null);\n            }\n            d6e.exports = { style: H6t, styleOne: h6e };\n          });\n          var Ky = ye((Bs) => {\n            "use strict";\n            var z22 = Dr(), j6t = ka(), W6t = Sg(), v6e = l_();\n            Bs.findEntryWithLevel = function(e3, t3) {\n              var r4;\n              return t3 && e3.eachAfter(function(n4) {\n                if (Bs.getPtId(n4) === t3) return r4 = n4.copy();\n              }), r4 || e3;\n            };\n            Bs.findEntryWithChild = function(e3, t3) {\n              var r4;\n              return e3.eachAfter(function(n4) {\n                for (var i3 = n4.children || [], a4 = 0; a4 < i3.length; a4++) {\n                  var o4 = i3[a4];\n                  if (Bs.getPtId(o4) === t3) return r4 = n4.copy();\n                }\n              }), r4 || e3;\n            };\n            Bs.isEntry = function(e3) {\n              return !e3.parent;\n            };\n            Bs.isLeaf = function(e3) {\n              return !e3.children;\n            };\n            Bs.getPtId = function(e3) {\n              return e3.data.data.id;\n            };\n            Bs.getPtLabel = function(e3) {\n              return e3.data.data.label;\n            };\n            Bs.getValue = function(e3) {\n              return e3.value;\n            };\n            Bs.isHierarchyRoot = function(e3) {\n              return p6e(e3) === "";\n            };\n            Bs.setSliceCursor = function(e3, t3, r4) {\n              var n4 = r4.isTransitioning;\n              if (!n4) {\n                var i3 = e3.datum();\n                n4 = r4.hideOnRoot && Bs.isHierarchyRoot(i3) || r4.hideOnLeaves && Bs.isLeaf(i3);\n              }\n              W6t(e3, n4 ? null : "pointer");\n            };\n            function X6t(e3, t3, r4) {\n              return { color: Bs.getOutsideTextFontKey("color", e3, t3, r4), family: Bs.getOutsideTextFontKey("family", e3, t3, r4), size: Bs.getOutsideTextFontKey("size", e3, t3, r4), weight: Bs.getOutsideTextFontKey("weight", e3, t3, r4), style: Bs.getOutsideTextFontKey("style", e3, t3, r4), variant: Bs.getOutsideTextFontKey("variant", e3, t3, r4), textcase: Bs.getOutsideTextFontKey("textcase", e3, t3, r4), lineposition: Bs.getOutsideTextFontKey("lineposition", e3, t3, r4), shadow: Bs.getOutsideTextFontKey("shadow", e3, t3, r4) };\n            }\n            function Z6t(e3, t3, r4, n4) {\n              var i3 = (n4 || {}).onPathbar, a4 = t3.data.data, o4 = a4.i, s3 = z22.castOption(e3, o4, (i3 ? "pathbar.textfont" : "insidetextfont") + ".color");\n              return !s3 && e3._input.textfont && (s3 = z22.castOption(e3._input, o4, "textfont.color")), { color: s3 || j6t.contrast(a4.color), family: Bs.getInsideTextFontKey("family", e3, t3, r4, n4), size: Bs.getInsideTextFontKey("size", e3, t3, r4, n4), weight: Bs.getInsideTextFontKey("weight", e3, t3, r4, n4), style: Bs.getInsideTextFontKey("style", e3, t3, r4, n4), variant: Bs.getInsideTextFontKey("variant", e3, t3, r4, n4), textcase: Bs.getInsideTextFontKey("textcase", e3, t3, r4, n4), lineposition: Bs.getInsideTextFontKey("lineposition", e3, t3, r4, n4), shadow: Bs.getInsideTextFontKey("shadow", e3, t3, r4, n4) };\n            }\n            Bs.getInsideTextFontKey = function(e3, t3, r4, n4, i3) {\n              var a4 = (i3 || {}).onPathbar, o4 = a4 ? "pathbar.textfont" : "insidetextfont", s3 = r4.data.data.i;\n              return z22.castOption(t3, s3, o4 + "." + e3) || z22.castOption(t3, s3, "textfont." + e3) || n4.size;\n            };\n            Bs.getOutsideTextFontKey = function(e3, t3, r4, n4) {\n              var i3 = r4.data.data.i;\n              return z22.castOption(t3, i3, "outsidetextfont." + e3) || z22.castOption(t3, i3, "textfont." + e3) || n4.size;\n            };\n            Bs.isOutsideText = function(e3, t3) {\n              return !e3._hasColorscale && Bs.isHierarchyRoot(t3);\n            };\n            Bs.determineTextFont = function(e3, t3, r4, n4) {\n              return Bs.isOutsideText(e3, t3) ? X6t(e3, t3, r4) : Z6t(e3, t3, r4, n4);\n            };\n            Bs.hasTransition = function(e3) {\n              return !!(e3 && e3.duration > 0);\n            };\n            Bs.getMaxDepth = function(e3) {\n              return e3.maxdepth >= 0 ? e3.maxdepth : 1 / 0;\n            };\n            Bs.isHeader = function(e3, t3) {\n              return !(Bs.isLeaf(e3) || e3.depth === t3._maxDepth - 1);\n            };\n            function p6e(e3) {\n              return e3.data.data.pid;\n            }\n            Bs.getParent = function(e3, t3) {\n              return Bs.findEntryWithLevel(e3, p6e(t3));\n            };\n            Bs.listPath = function(e3, t3) {\n              var r4 = e3.parent;\n              if (!r4) return [];\n              var n4 = t3 ? [r4.data[t3]] : [r4];\n              return Bs.listPath(r4, t3).concat(n4);\n            };\n            Bs.getPath = function(e3) {\n              return Bs.listPath(e3, "label").join("/") + "/";\n            };\n            Bs.formatValue = v6e.formatPieValue;\n            Bs.formatPercent = function(e3, t3) {\n              var r4 = z22.formatPercent(e3, 0);\n              return r4 === "0%" && (r4 = v6e.formatPiePercent(e3, t3)), r4;\n            };\n          });\n          var HE = ye(($pr, y6e) => {\n            "use strict";\n            var DA = Oa(), g6e = qa(), Y6t = ip().appendArrayPointValue, VE = vf(), m6e = Dr(), K6t = _3(), rd = Ky(), J6t = l_(), $6t = J6t.formatPieValue;\n            y6e.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = i3[0], s3 = o4.trace, l3 = o4.hierarchy, u4 = s3.type === "sunburst", c5 = s3.type === "treemap" || s3.type === "icicle";\n              "_hasHoverLabel" in s3 || (s3._hasHoverLabel = false), "_hasHoverEvent" in s3 || (s3._hasHoverEvent = false);\n              var f4 = function(v3) {\n                var _2 = n4._fullLayout;\n                if (!(n4._dragging || _2.hovermode === false)) {\n                  var b = n4._fullData[s3.index], p3 = v3.data.data, k4 = p3.i, E3 = rd.isHierarchyRoot(v3), S2 = rd.getParent(l3, v3), L3 = rd.getValue(v3), x2 = function(Ee) {\n                    return m6e.castOption(b, k4, Ee);\n                  }, C3 = x2("hovertemplate"), M4 = VE.castHoverinfo(b, _2, k4), g3 = _2.separators, P3;\n                  if (C3 || M4 && M4 !== "none" && M4 !== "skip") {\n                    var T3, z3;\n                    u4 && (T3 = o4.cx + v3.pxmid[0] * (1 - v3.rInscribed), z3 = o4.cy + v3.pxmid[1] * (1 - v3.rInscribed)), c5 && (T3 = v3._hoverX, z3 = v3._hoverY);\n                    var O3 = {}, V2 = [], G2 = [], Z = function(Ee) {\n                      return V2.indexOf(Ee) !== -1;\n                    };\n                    M4 && (V2 = M4 === "all" ? b._module.attributes.hoverinfo.flags : M4.split("+")), O3.label = p3.label, Z("label") && O3.label && G2.push(O3.label), p3.hasOwnProperty("v") && (O3.value = p3.v, O3.valueLabel = $6t(O3.value, g3), Z("value") && G2.push(O3.valueLabel)), O3.currentPath = v3.currentPath = rd.getPath(v3.data), Z("current path") && !E3 && G2.push(O3.currentPath);\n                    var j3, N2 = [], H = function() {\n                      N2.indexOf(j3) === -1 && (G2.push(j3), N2.push(j3));\n                    };\n                    O3.percentParent = v3.percentParent = L3 / rd.getValue(S2), O3.parent = v3.parentString = rd.getPtLabel(S2), Z("percent parent") && (j3 = rd.formatPercent(O3.percentParent, g3) + " of " + O3.parent, H()), O3.percentEntry = v3.percentEntry = L3 / rd.getValue(r4), O3.entry = v3.entry = rd.getPtLabel(r4), Z("percent entry") && !E3 && !v3.onPathbar && (j3 = rd.formatPercent(O3.percentEntry, g3) + " of " + O3.entry, H()), O3.percentRoot = v3.percentRoot = L3 / rd.getValue(l3), O3.root = v3.root = rd.getPtLabel(l3), Z("percent root") && !E3 && (j3 = rd.formatPercent(O3.percentRoot, g3) + " of " + O3.root, H()), O3.text = x2("hovertext") || x2("text"), Z("text") && (j3 = O3.text, m6e.isValidTextValue(j3) && G2.push(j3)), P3 = [GE(v3, b, a4.eventDataKeys)];\n                    var te = { trace: b, y: z3, _x0: v3._x0, _x1: v3._x1, _y0: v3._y0, _y1: v3._y1, text: G2.join("<br>"), name: C3 || Z("name") ? b.name : void 0, color: x2("hoverlabel.bgcolor") || p3.color, borderColor: x2("hoverlabel.bordercolor"), fontFamily: x2("hoverlabel.font.family"), fontSize: x2("hoverlabel.font.size"), fontColor: x2("hoverlabel.font.color"), fontWeight: x2("hoverlabel.font.weight"), fontStyle: x2("hoverlabel.font.style"), fontVariant: x2("hoverlabel.font.variant"), nameLength: x2("hoverlabel.namelength"), textAlign: x2("hoverlabel.align"), hovertemplate: C3, hovertemplateLabels: O3, eventData: P3 };\n                    u4 && (te.x0 = T3 - v3.rInscribed * v3.rpx1, te.x1 = T3 + v3.rInscribed * v3.rpx1, te.idealAlign = v3.pxmid[0] < 0 ? "left" : "right"), c5 && (te.x = T3, te.idealAlign = T3 < 0 ? "left" : "right");\n                    var oe = [];\n                    VE.loneHover(te, { container: _2._hoverlayer.node(), outerContainer: _2._paper.node(), gd: n4, inOut_bbox: oe }), P3[0].bbox = oe[0], s3._hasHoverLabel = true;\n                  }\n                  if (c5) {\n                    var _e = t3.select("path.surface");\n                    a4.styleOne(_e, v3, b, n4, { hovered: true });\n                  }\n                  s3._hasHoverEvent = true, n4.emit("plotly_hover", { points: P3 || [GE(v3, b, a4.eventDataKeys)], event: DA.event });\n                }\n              }, h3 = function(v3) {\n                var _2 = n4._fullLayout, b = n4._fullData[s3.index], p3 = DA.select(this).datum();\n                if (s3._hasHoverEvent && (v3.originalEvent = DA.event, n4.emit("plotly_unhover", { points: [GE(p3, b, a4.eventDataKeys)], event: DA.event }), s3._hasHoverEvent = false), s3._hasHoverLabel && (VE.loneUnhover(_2._hoverlayer.node()), s3._hasHoverLabel = false), c5) {\n                  var k4 = t3.select("path.surface");\n                  a4.styleOne(k4, p3, b, n4, { hovered: false });\n                }\n              }, d3 = function(v3) {\n                var _2 = n4._fullLayout, b = n4._fullData[s3.index], p3 = u4 && (rd.isHierarchyRoot(v3) || rd.isLeaf(v3)), k4 = rd.getPtId(v3), E3 = rd.isEntry(v3) ? rd.findEntryWithChild(l3, k4) : rd.findEntryWithLevel(l3, k4), S2 = rd.getPtId(E3), L3 = { points: [GE(v3, b, a4.eventDataKeys)], event: DA.event };\n                p3 || (L3.nextLevel = S2);\n                var x2 = K6t.triggerHandler(n4, "plotly_" + s3.type + "click", L3);\n                if (x2 !== false && _2.hovermode && (n4._hoverdata = [GE(v3, b, a4.eventDataKeys)], VE.click(n4, DA.event)), !p3 && x2 !== false && !n4._dragging && !n4._transitioning) {\n                  g6e.call("_storeDirectGUIEdit", b, _2._tracePreGUI[b.uid], { level: b.level });\n                  var C3 = { data: [{ level: S2 }], traces: [s3.index] }, M4 = { frame: { redraw: false, duration: a4.transitionTime }, transition: { duration: a4.transitionTime, easing: a4.transitionEasing }, mode: "immediate", fromcurrent: true };\n                  VE.loneUnhover(_2._hoverlayer.node()), g6e.call("animate", n4, C3, M4);\n                }\n              };\n              t3.on("mouseover", f4), t3.on("mouseout", h3), t3.on("click", d3);\n            };\n            function GE(e3, t3, r4) {\n              for (var n4 = e3.data.data, i3 = { curveNumber: t3.index, pointNumber: n4.i, data: t3._input, fullData: t3 }, a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4];\n                o4 in e3 && (i3[o4] = e3[o4]);\n              }\n              return "parentString" in e3 && !rd.isHierarchyRoot(e3) && (i3.parent = e3.parentString), Y6t(i3, t3, n4.i), i3;\n            }\n          });\n          var VD = ye((UD) => {\n            "use strict";\n            var jE = Oa(), Q6t = PE(), Yg = (F2(), ob(D22)).interpolate, _6e = So(), Av = Dr(), eLt = ru(), T6e = bv(), x6e = T6e.recordMinTextSize, tLt = T6e.clearMinTextSize, A6e = _D(), rLt = l_().getRotationAngle, iLt = A6e.computeTransform, nLt = A6e.transformInsideText, aLt = VW().styleOne, oLt = N0().resizeText, sLt = HE(), GW = yW(), Rl = Ky();\n            UD.plot = function(e3, t3, r4, n4) {\n              var i3 = e3._fullLayout, a4 = i3._sunburstlayer, o4, s3, l3 = !r4, u4 = !i3.uniformtext.mode && Rl.hasTransition(r4);\n              if (tLt("sunburst", i3), o4 = a4.selectAll("g.trace.sunburst").data(t3, function(f4) {\n                return f4[0].trace.uid;\n              }), o4.enter().append("g").classed("trace", true).classed("sunburst", true).attr("stroke-linejoin", "round"), o4.order(), u4) {\n                n4 && (s3 = n4());\n                var c5 = jE.transition().duration(r4.duration).ease(r4.easing).each("end", function() {\n                  s3 && s3();\n                }).each("interrupt", function() {\n                  s3 && s3();\n                });\n                c5.each(function() {\n                  a4.selectAll("g.trace").each(function(f4) {\n                    b6e(e3, f4, this, r4);\n                  });\n                });\n              } else o4.each(function(f4) {\n                b6e(e3, f4, this, r4);\n              }), i3.uniformtext.mode && oLt(e3, i3._sunburstlayer.selectAll(".trace"), "sunburst");\n              l3 && o4.exit().remove();\n            };\n            function b6e(e3, t3, r4, n4) {\n              var i3 = e3._context.staticPlot, a4 = e3._fullLayout, o4 = !a4.uniformtext.mode && Rl.hasTransition(n4), s3 = jE.select(r4), l3 = s3.selectAll("g.slice"), u4 = t3[0], c5 = u4.trace, f4 = u4.hierarchy, h3 = Rl.findEntryWithLevel(f4, c5.level), d3 = Rl.getMaxDepth(c5), v3 = a4._size, _2 = c5.domain, b = v3.w * (_2.x[1] - _2.x[0]), p3 = v3.h * (_2.y[1] - _2.y[0]), k4 = 0.5 * Math.min(b, p3), E3 = u4.cx = v3.l + v3.w * (_2.x[1] + _2.x[0]) / 2, S2 = u4.cy = v3.t + v3.h * (1 - _2.y[0]) - p3 / 2;\n              if (!h3) return l3.remove();\n              var L3 = null, x2 = {};\n              o4 && l3.each(function(me) {\n                x2[Rl.getPtId(me)] = { rpx0: me.rpx0, rpx1: me.rpx1, x0: me.x0, x1: me.x1, transform: me.transform }, !L3 && Rl.isEntry(me) && (L3 = me);\n              });\n              var C3 = lLt(h3).descendants(), M4 = h3.height + 1, g3 = 0, P3 = d3;\n              u4.hasMultipleRoots && Rl.isHierarchyRoot(h3) && (C3 = C3.slice(1), M4 -= 1, g3 = 1, P3 += 1), C3 = C3.filter(function(me) {\n                return me.y1 <= P3;\n              });\n              var T3 = rLt(c5.rotation);\n              T3 && C3.forEach(function(me) {\n                me.x0 += T3, me.x1 += T3;\n              });\n              var z3 = Math.min(M4, d3), O3 = function(me) {\n                return (me - g3) / z3 * k4;\n              }, V2 = function(me, ie) {\n                return [me * Math.cos(ie), -me * Math.sin(ie)];\n              }, G2 = function(me) {\n                return Av.pathAnnulus(me.rpx0, me.rpx1, me.x0, me.x1, E3, S2);\n              }, Z = function(me) {\n                return E3 + w6e(me)[0] * (me.transform.rCenter || 0) + (me.transform.x || 0);\n              }, j3 = function(me) {\n                return S2 + w6e(me)[1] * (me.transform.rCenter || 0) + (me.transform.y || 0);\n              };\n              l3 = l3.data(C3, Rl.getPtId), l3.enter().append("g").classed("slice", true), o4 ? l3.exit().transition().each(function() {\n                var me = jE.select(this), ie = me.select("path.surface");\n                ie.transition().attrTween("d", function(Le) {\n                  var Ae = oe(Le);\n                  return function(Fe) {\n                    return G2(Ae(Fe));\n                  };\n                });\n                var Se = me.select("g.slicetext");\n                Se.attr("opacity", 0);\n              }).remove() : l3.exit().remove(), l3.order();\n              var N2 = null;\n              if (o4 && L3) {\n                var H = Rl.getPtId(L3);\n                l3.each(function(me) {\n                  N2 === null && Rl.getPtId(me) === H && (N2 = me.x1);\n                });\n              }\n              var te = l3;\n              o4 && (te = te.transition().each("end", function() {\n                var me = jE.select(this);\n                Rl.setSliceCursor(me, e3, { hideOnRoot: true, hideOnLeaves: true, isTransitioning: false });\n              })), te.each(function(me) {\n                var ie = jE.select(this), Se = Av.ensureSingle(ie, "path", "surface", function(Re) {\n                  Re.style("pointer-events", i3 ? "none" : "all");\n                });\n                me.rpx0 = O3(me.y0), me.rpx1 = O3(me.y1), me.xmid = (me.x0 + me.x1) / 2, me.pxmid = V2(me.rpx1, me.xmid), me.midangle = -(me.xmid - Math.PI / 2), me.startangle = -(me.x0 - Math.PI / 2), me.stopangle = -(me.x1 - Math.PI / 2), me.halfangle = 0.5 * Math.min(Av.angleDelta(me.x0, me.x1) || Math.PI, Math.PI), me.ring = 1 - me.rpx0 / me.rpx1, me.rInscribed = uLt(me, c5), o4 ? Se.transition().attrTween("d", function(Re) {\n                  var ce = _e(Re);\n                  return function(Ze) {\n                    return G2(ce(Ze));\n                  };\n                }) : Se.attr("d", G2), ie.call(sLt, h3, e3, t3, { eventDataKeys: GW.eventDataKeys, transitionTime: GW.CLICK_TRANSITION_TIME, transitionEasing: GW.CLICK_TRANSITION_EASING }).call(Rl.setSliceCursor, e3, { hideOnRoot: true, hideOnLeaves: true, isTransitioning: e3._transitioning }), Se.call(aLt, me, c5, e3);\n                var Le = Av.ensureSingle(ie, "g", "slicetext"), Ae = Av.ensureSingle(Le, "text", "", function(Re) {\n                  Re.attr("data-notex", 1);\n                }), Fe = Av.ensureUniformFontSize(e3, Rl.determineTextFont(c5, me, a4.font));\n                Ae.text(UD.formatSliceLabel(me, h3, c5, t3, a4)).classed("slicetext", true).attr("text-anchor", "middle").call(_6e.font, Fe).call(eLt.convertToTspans, e3);\n                var Pe = _6e.bBox(Ae.node());\n                me.transform = nLt(Pe, me, u4), me.transform.targetX = Z(me), me.transform.targetY = j3(me);\n                var ge = function(Re, ce) {\n                  var Ze = Re.transform;\n                  return iLt(Ze, ce), Ze.fontSize = Fe.size, x6e(c5.type, Ze, a4), Av.getTextTransform(Ze);\n                };\n                o4 ? Ae.transition().attrTween("transform", function(Re) {\n                  var ce = Ee(Re);\n                  return function(Ze) {\n                    return ge(ce(Ze), Pe);\n                  };\n                }) : Ae.attr("transform", ge(me, Pe));\n              });\n              function oe(me) {\n                var ie = Rl.getPtId(me), Se = x2[ie], Le = x2[Rl.getPtId(h3)], Ae;\n                if (Le) {\n                  var Fe = (me.x1 > Le.x1 ? 2 * Math.PI : 0) + T3;\n                  Ae = me.rpx1 < Le.rpx1 ? { x0: me.x0, x1: me.x1, rpx0: 0, rpx1: 0 } : { x0: Fe, x1: Fe, rpx0: me.rpx0, rpx1: me.rpx1 };\n                } else {\n                  var Pe, ge = Rl.getPtId(me.parent);\n                  l3.each(function(pt) {\n                    if (Rl.getPtId(pt) === ge) return Pe = pt;\n                  });\n                  var Re = Pe.children, ce;\n                  Re.forEach(function(pt, Zt) {\n                    if (Rl.getPtId(pt) === ie) return ce = Zt;\n                  });\n                  var Ze = Re.length, ut = Yg(Pe.x0, Pe.x1);\n                  Ae = { rpx0: k4, rpx1: k4, x0: ut(ce / Ze), x1: ut((ce + 1) / Ze) };\n                }\n                return Yg(Se, Ae);\n              }\n              function _e(me) {\n                var ie = x2[Rl.getPtId(me)], Se, Le = { x0: me.x0, x1: me.x1, rpx0: me.rpx0, rpx1: me.rpx1 };\n                if (ie) Se = ie;\n                else if (L3) if (me.parent) if (N2) {\n                  var Ae = (me.x1 > N2 ? 2 * Math.PI : 0) + T3;\n                  Se = { x0: Ae, x1: Ae };\n                } else Se = { rpx0: k4, rpx1: k4 }, Av.extendFlat(Se, Ce(me));\n                else Se = { rpx0: 0, rpx1: 0 };\n                else Se = { x0: T3, x1: T3 };\n                return Yg(Se, Le);\n              }\n              function Ee(me) {\n                var ie = x2[Rl.getPtId(me)], Se, Le = me.transform;\n                if (ie) Se = ie;\n                else if (Se = { rpx1: me.rpx1, transform: { textPosAngle: Le.textPosAngle, scale: 0, rotate: Le.rotate, rCenter: Le.rCenter, x: Le.x, y: Le.y } }, L3) if (me.parent) if (N2) {\n                  var Ae = me.x1 > N2 ? 2 * Math.PI : 0;\n                  Se.x0 = Se.x1 = Ae;\n                } else Av.extendFlat(Se, Ce(me));\n                else Se.x0 = Se.x1 = T3;\n                else Se.x0 = Se.x1 = T3;\n                var Fe = Yg(Se.transform.textPosAngle, me.transform.textPosAngle), Pe = Yg(Se.rpx1, me.rpx1), ge = Yg(Se.x0, me.x0), Re = Yg(Se.x1, me.x1), ce = Yg(Se.transform.scale, Le.scale), Ze = Yg(Se.transform.rotate, Le.rotate), ut = Le.rCenter === 0 ? 3 : Se.transform.rCenter === 0 ? 1 / 3 : 1, pt = Yg(Se.transform.rCenter, Le.rCenter), Zt = function(st) {\n                  return pt(Math.pow(st, ut));\n                };\n                return function(st) {\n                  var lt = Pe(st), Gt = ge(st), Nt = Re(st), Jt = Zt(st), sr = V2(lt, (Gt + Nt) / 2), wr = Fe(st), cr = { pxmid: sr, rpx1: lt, transform: { textPosAngle: wr, rCenter: Jt, x: Le.x, y: Le.y } };\n                  return x6e(c5.type, Le, a4), { transform: { targetX: Z(cr), targetY: j3(cr), scale: ce(st), rotate: Ze(st), rCenter: Jt } };\n                };\n              }\n              function Ce(me) {\n                var ie = me.parent, Se = x2[Rl.getPtId(ie)], Le = {};\n                if (Se) {\n                  var Ae = ie.children, Fe = Ae.indexOf(me), Pe = Ae.length, ge = Yg(Se.x0, Se.x1);\n                  Le.x0 = ge(Fe / Pe), Le.x1 = ge(Fe / Pe);\n                } else Le.x0 = Le.x1 = 0;\n                return Le;\n              }\n            }\n            function lLt(e3) {\n              return Q6t.partition().size([2 * Math.PI, e3.height + 1])(e3);\n            }\n            UD.formatSliceLabel = function(e3, t3, r4, n4, i3) {\n              var a4 = r4.texttemplate, o4 = r4.textinfo;\n              if (!a4 && (!o4 || o4 === "none")) return "";\n              var s3 = i3.separators, l3 = n4[0], u4 = e3.data.data, c5 = l3.hierarchy, f4 = Rl.isHierarchyRoot(e3), h3 = Rl.getParent(c5, e3), d3 = Rl.getValue(e3);\n              if (!a4) {\n                var v3 = o4.split("+"), _2 = function(g3) {\n                  return v3.indexOf(g3) !== -1;\n                }, b = [], p3;\n                if (_2("label") && u4.label && b.push(u4.label), u4.hasOwnProperty("v") && _2("value") && b.push(Rl.formatValue(u4.v, s3)), !f4) {\n                  _2("current path") && b.push(Rl.getPath(e3.data));\n                  var k4 = 0;\n                  _2("percent parent") && k4++, _2("percent entry") && k4++, _2("percent root") && k4++;\n                  var E3 = k4 > 1;\n                  if (k4) {\n                    var S2, L3 = function(g3) {\n                      p3 = Rl.formatPercent(S2, s3), E3 && (p3 += " of " + g3), b.push(p3);\n                    };\n                    _2("percent parent") && !f4 && (S2 = d3 / Rl.getValue(h3), L3("parent")), _2("percent entry") && (S2 = d3 / Rl.getValue(t3), L3("entry")), _2("percent root") && (S2 = d3 / Rl.getValue(c5), L3("root"));\n                  }\n                }\n                return _2("text") && (p3 = Av.castOption(r4, u4.i, "text"), Av.isValidTextValue(p3) && b.push(p3)), b.join("<br>");\n              }\n              var x2 = Av.castOption(r4, u4.i, "texttemplate");\n              if (!x2) return "";\n              var C3 = {};\n              u4.label && (C3.label = u4.label), u4.hasOwnProperty("v") && (C3.value = u4.v, C3.valueLabel = Rl.formatValue(u4.v, s3)), C3.currentPath = Rl.getPath(e3.data), f4 || (C3.percentParent = d3 / Rl.getValue(h3), C3.percentParentLabel = Rl.formatPercent(C3.percentParent, s3), C3.parent = Rl.getPtLabel(h3)), C3.percentEntry = d3 / Rl.getValue(t3), C3.percentEntryLabel = Rl.formatPercent(C3.percentEntry, s3), C3.entry = Rl.getPtLabel(t3), C3.percentRoot = d3 / Rl.getValue(c5), C3.percentRootLabel = Rl.formatPercent(C3.percentRoot, s3), C3.root = Rl.getPtLabel(c5), u4.hasOwnProperty("color") && (C3.color = u4.color);\n              var M4 = Av.castOption(r4, u4.i, "text");\n              return (Av.isValidTextValue(M4) || M4 === "") && (C3.text = M4), C3.customdata = Av.castOption(r4, u4.i, "customdata"), Av.texttemplateString({ data: [C3, r4._meta], fallback: r4.texttemplatefallback, labels: C3, locale: i3._d3locale, template: x2 });\n            };\n            function uLt(e3) {\n              return e3.rpx0 === 0 && Av.isFullCircle([e3.x0, e3.x1]) ? 1 : Math.max(0, Math.min(1 / (1 + 1 / Math.sin(e3.halfangle)), e3.ring / 2));\n            }\n            function w6e(e3) {\n              return cLt(e3.rpx1, e3.transform.textPosAngle);\n            }\n            function cLt(e3, t3) {\n              return [e3 * Math.sin(t3), -e3 * Math.cos(t3)];\n            }\n          });\n          var M6e = ye((e0r, S6e) => {\n            "use strict";\n            S6e.exports = { moduleType: "trace", name: "sunburst", basePlotModule: Bke(), categories: [], animatable: true, attributes: LE(), layoutAttributes: _W(), supplyDefaults: Zke(), supplyLayoutDefaults: Kke(), calc: RE().calc, crossTraceCalc: RE().crossTraceCalc, plot: VD().plot, style: VW().style, colorbar: $d(), meta: {} };\n          });\n          var k6e = ye((t0r, E6e) => {\n            "use strict";\n            E6e.exports = M6e();\n          });\n          var L6e = ye((FA) => {\n            "use strict";\n            var C6e = Mc();\n            FA.name = "treemap";\n            FA.plot = function(e3, t3, r4, n4) {\n              C6e.plotBasePlot(FA.name, e3, t3, r4, n4);\n            };\n            FA.clean = function(e3, t3, r4, n4) {\n              C6e.cleanBasePlot(FA.name, e3, t3, r4, n4);\n            };\n          });\n          var O2 = ye((i0r, P6e) => {\n            "use strict";\n            P6e.exports = { CLICK_TRANSITION_TIME: 750, CLICK_TRANSITION_EASING: "poly", eventDataKeys: ["currentPath", "root", "entry", "percentRoot", "percentEntry", "percentParent"], gapWithPathbar: 1 };\n          });\n          var GD = ye((n0r, D6e) => {\n            "use strict";\n            var { hovertemplateAttrs: fLt, texttemplateAttrs: hLt, templatefallbackAttrs: I6e } = Ll(), dLt = Tu(), vLt = Cc().attributes, q2 = M2(), Q0 = LE(), R6e = O2(), HW = Ao().extendFlat, pLt = Pd().pattern;\n            D6e.exports = { labels: Q0.labels, parents: Q0.parents, values: Q0.values, branchvalues: Q0.branchvalues, count: Q0.count, level: Q0.level, maxdepth: Q0.maxdepth, tiling: { packing: { valType: "enumerated", values: ["squarify", "binary", "dice", "slice", "slice-dice", "dice-slice"], dflt: "squarify", editType: "plot" }, squarifyratio: { valType: "number", min: 1, dflt: 1, editType: "plot" }, flip: { valType: "flaglist", flags: ["x", "y"], dflt: "", editType: "plot" }, pad: { valType: "number", min: 0, dflt: 3, editType: "plot" }, editType: "calc" }, marker: HW({ pad: { t: { valType: "number", min: 0, editType: "plot" }, l: { valType: "number", min: 0, editType: "plot" }, r: { valType: "number", min: 0, editType: "plot" }, b: { valType: "number", min: 0, editType: "plot" }, editType: "calc" }, colors: Q0.marker.colors, pattern: pLt, depthfade: { valType: "enumerated", values: [true, false, "reversed"], editType: "style" }, line: Q0.marker.line, cornerradius: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, dLt("marker", { colorAttr: "colors", anim: false })), pathbar: { visible: { valType: "boolean", dflt: true, editType: "plot" }, side: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, edgeshape: { valType: "enumerated", values: [">", "<", "|", "/", "\\\\"], dflt: ">", editType: "plot" }, thickness: { valType: "number", min: 12, editType: "plot" }, textfont: HW({}, q2.textfont, {}), editType: "calc" }, text: q2.text, textinfo: Q0.textinfo, texttemplate: hLt({ editType: "plot" }, { keys: R6e.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: I6e({ editType: "plot" }), hovertext: q2.hovertext, hoverinfo: Q0.hoverinfo, hovertemplate: fLt({}, { keys: R6e.eventDataKeys }), hovertemplatefallback: I6e(), textfont: q2.textfont, insidetextfont: q2.insidetextfont, outsidetextfont: HW({}, q2.outsidetextfont, {}), textposition: { valType: "enumerated", values: ["top left", "top center", "top right", "middle left", "middle center", "middle right", "bottom left", "bottom center", "bottom right"], dflt: "top left", editType: "plot" }, sort: q2.sort, root: Q0.root, domain: vLt({ name: "treemap", trace: true, editType: "calc" }) };\n          });\n          var jW = ye((a0r, F6e) => {\n            "use strict";\n            F6e.exports = { treemapcolorway: { valType: "colorlist", editType: "calc" }, extendtreemapcolors: { valType: "boolean", dflt: true, editType: "calc" } };\n          });\n          var B6e = ye((o0r, q6e) => {\n            "use strict";\n            var z6e = Dr(), gLt = GD(), mLt = ka(), yLt = Cc().defaults, _Lt = r0().handleText, xLt = e22().TEXTPAD, bLt = E2().handleMarkerDefaults, O6e = tc(), wLt = O6e.hasColorscale, TLt = O6e.handleDefaults;\n            q6e.exports = function(t3, r4, n4, i3) {\n              function a4(b, p3) {\n                return z6e.coerce(t3, r4, gLt, b, p3);\n              }\n              var o4 = a4("labels"), s3 = a4("parents");\n              if (!o4 || !o4.length || !s3 || !s3.length) {\n                r4.visible = false;\n                return;\n              }\n              var l3 = a4("values");\n              l3 && l3.length ? a4("branchvalues") : a4("count"), a4("level"), a4("maxdepth");\n              var u4 = a4("tiling.packing");\n              u4 === "squarify" && a4("tiling.squarifyratio"), a4("tiling.flip"), a4("tiling.pad");\n              var c5 = a4("text");\n              a4("texttemplate"), a4("texttemplatefallback"), r4.texttemplate || a4("textinfo", z6e.isArrayOrTypedArray(c5) ? "text+label" : "label"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var f4 = a4("pathbar.visible"), h3 = "auto";\n              _Lt(t3, r4, i3, a4, h3, { hasPathbar: f4, moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a4("textposition");\n              var d3 = r4.textposition.indexOf("bottom") !== -1;\n              bLt(t3, r4, i3, a4);\n              var v3 = r4._hasColorscale = wLt(t3, "marker", "colors") || (t3.marker || {}).coloraxis;\n              v3 ? TLt(t3, r4, i3, a4, { prefix: "marker.", cLetter: "c" }) : a4("marker.depthfade", !(r4.marker.colors || []).length);\n              var _2 = r4.textfont.size * 2;\n              a4("marker.pad.t", d3 ? _2 / 4 : _2), a4("marker.pad.l", _2 / 4), a4("marker.pad.r", _2 / 4), a4("marker.pad.b", d3 ? _2 : _2 / 4), a4("marker.cornerradius"), r4._hovered = { marker: { line: { width: 2, color: mLt.contrast(i3.paper_bgcolor) } } }, f4 && (a4("pathbar.thickness", r4.pathbar.textfont.size + 2 * xLt), a4("pathbar.side"), a4("pathbar.edgeshape")), a4("sort"), a4("root.color"), yLt(r4, i3, a4), r4._length = null;\n            };\n          });\n          var U6e = ye((s0r, N6e) => {\n            "use strict";\n            var ALt = Dr(), SLt = jW();\n            N6e.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return ALt.coerce(t3, r4, SLt, i3, a4);\n              }\n              n4("treemapcolorway", r4.colorway), n4("extendtreemapcolors");\n            };\n          });\n          var XW = ye((WW) => {\n            "use strict";\n            var V6e = RE();\n            WW.calc = function(e3, t3) {\n              return V6e.calc(e3, t3);\n            };\n            WW.crossTraceCalc = function(e3) {\n              return V6e._runCrossTraceCalc("treemap", e3);\n            };\n          });\n          var ZW = ye((u0r, G6e) => {\n            "use strict";\n            G6e.exports = function e3(t3, r4, n4) {\n              var i3;\n              n4.swapXY && (i3 = t3.x0, t3.x0 = t3.y0, t3.y0 = i3, i3 = t3.x1, t3.x1 = t3.y1, t3.y1 = i3), n4.flipX && (i3 = t3.x0, t3.x0 = r4[0] - t3.x1, t3.x1 = r4[0] - i3), n4.flipY && (i3 = t3.y0, t3.y0 = r4[1] - t3.y1, t3.y1 = r4[1] - i3);\n              var a4 = t3.children;\n              if (a4) for (var o4 = 0; o4 < a4.length; o4++) e3(a4[o4], r4, n4);\n            };\n          });\n          var YW = ye((c0r, H6e) => {\n            "use strict";\n            var zA = PE(), MLt = ZW();\n            H6e.exports = function(t3, r4, n4) {\n              var i3 = n4.flipX, a4 = n4.flipY, o4 = n4.packing === "dice-slice", s3 = n4.pad[a4 ? "bottom" : "top"], l3 = n4.pad[i3 ? "right" : "left"], u4 = n4.pad[i3 ? "left" : "right"], c5 = n4.pad[a4 ? "top" : "bottom"], f4;\n              o4 && (f4 = l3, l3 = s3, s3 = f4, f4 = u4, u4 = c5, c5 = f4);\n              var h3 = zA.treemap().tile(ELt(n4.packing, n4.squarifyratio)).paddingInner(n4.pad.inner).paddingLeft(l3).paddingRight(u4).paddingTop(s3).paddingBottom(c5).size(o4 ? [r4[1], r4[0]] : r4)(t3);\n              return (o4 || i3 || a4) && MLt(h3, r4, { swapXY: o4, flipX: i3, flipY: a4 }), h3;\n            };\n            function ELt(e3, t3) {\n              switch (e3) {\n                case "squarify":\n                  return zA.treemapSquarify.ratio(t3);\n                case "binary":\n                  return zA.treemapBinary;\n                case "dice":\n                  return zA.treemapDice;\n                case "slice":\n                  return zA.treemapSlice;\n                default:\n                  return zA.treemapSliceDice;\n              }\n            }\n          });\n          var HD = ye((f0r, Z6e) => {\n            "use strict";\n            var j6e = Oa(), OA = ka(), W6e = Dr(), KW = Ky(), kLt = bv().resizeText, CLt = ND();\n            function LLt(e3) {\n              var t3 = e3._fullLayout._treemaplayer.selectAll(".trace");\n              kLt(e3, t3, "treemap"), t3.each(function(r4) {\n                var n4 = j6e.select(this), i3 = r4[0], a4 = i3.trace;\n                n4.style("opacity", a4.opacity), n4.selectAll("path.surface").each(function(o4) {\n                  j6e.select(this).call(X6e, o4, a4, e3, { hovered: false });\n                });\n              });\n            }\n            function X6e(e3, t3, r4, n4, i3) {\n              var a4 = (i3 || {}).hovered, o4 = t3.data.data, s3 = o4.i, l3, u4, c5 = o4.color, f4 = KW.isHierarchyRoot(t3), h3 = 1;\n              if (a4) l3 = r4._hovered.marker.line.color, u4 = r4._hovered.marker.line.width;\n              else if (f4 && c5 === r4.root.color) h3 = 100, l3 = "rgba(0,0,0,0)", u4 = 0;\n              else if (l3 = W6e.castOption(r4, s3, "marker.line.color") || OA.defaultLine, u4 = W6e.castOption(r4, s3, "marker.line.width") || 0, !r4._hasColorscale && !t3.onPathbar) {\n                var d3 = r4.marker.depthfade;\n                if (d3) {\n                  var v3 = OA.combine(OA.addOpacity(r4._backgroundColor, 0.75), c5), _2;\n                  if (d3 === true) {\n                    var b = KW.getMaxDepth(r4);\n                    isFinite(b) ? KW.isLeaf(t3) ? _2 = 0 : _2 = r4._maxVisibleLayers - (t3.data.depth - r4._entryDepth) : _2 = t3.data.height + 1;\n                  } else _2 = t3.data.depth - r4._entryDepth, r4._atRootLevel || _2++;\n                  if (_2 > 0) for (var p3 = 0; p3 < _2; p3++) {\n                    var k4 = 0.5 * p3 / _2;\n                    c5 = OA.combine(OA.addOpacity(v3, k4), c5);\n                  }\n                }\n              }\n              e3.call(CLt, t3, r4, n4, c5).style("stroke-width", u4).call(OA.stroke, l3).style("opacity", h3);\n            }\n            Z6e.exports = { style: LLt, styleOne: X6e };\n          });\n          var Q6e = ye((h0r, $6e) => {\n            "use strict";\n            var Y6e = Oa(), jD = Dr(), K6e = So(), PLt = ru(), ILt = YW(), J6e = HD().styleOne, JW = O2(), qA = Ky(), RLt = HE(), $W = true;\n            $6e.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = a4.barDifY, s3 = a4.width, l3 = a4.height, u4 = a4.viewX, c5 = a4.viewY, f4 = a4.pathSlice, h3 = a4.toMoveInsideSlice, d3 = a4.strTransform, v3 = a4.hasTransition, _2 = a4.handleSlicesExit, b = a4.makeUpdateSliceInterpolator, p3 = a4.makeUpdateTextInterpolator, k4 = {}, E3 = t3._context.staticPlot, S2 = t3._fullLayout, L3 = r4[0], x2 = L3.trace, C3 = L3.hierarchy, M4 = s3 / x2._entryDepth, g3 = qA.listPath(n4.data, "id"), P3 = ILt(C3.copy(), [s3, l3], { packing: "dice", pad: { inner: 0, top: 0, left: 0, right: 0, bottom: 0 } }).descendants();\n              P3 = P3.filter(function(z3) {\n                var O3 = g3.indexOf(z3.data.id);\n                return O3 === -1 ? false : (z3.x0 = M4 * O3, z3.x1 = M4 * (O3 + 1), z3.y0 = o4, z3.y1 = o4 + l3, z3.onPathbar = true, true);\n              }), P3.reverse(), i3 = i3.data(P3, qA.getPtId), i3.enter().append("g").classed("pathbar", true), _2(i3, $W, k4, [s3, l3], f4), i3.order();\n              var T3 = i3;\n              v3 && (T3 = T3.transition().each("end", function() {\n                var z3 = Y6e.select(this);\n                qA.setSliceCursor(z3, t3, { hideOnRoot: false, hideOnLeaves: false, isTransitioning: false });\n              })), T3.each(function(z3) {\n                z3._x0 = u4(z3.x0), z3._x1 = u4(z3.x1), z3._y0 = c5(z3.y0), z3._y1 = c5(z3.y1), z3._hoverX = u4(z3.x1 - Math.min(s3, l3) / 2), z3._hoverY = c5(z3.y1 - l3 / 2);\n                var O3 = Y6e.select(this), V2 = jD.ensureSingle(O3, "path", "surface", function(N2) {\n                  N2.style("pointer-events", E3 ? "none" : "all");\n                });\n                v3 ? V2.transition().attrTween("d", function(N2) {\n                  var H = b(N2, $W, k4, [s3, l3]);\n                  return function(te) {\n                    return f4(H(te));\n                  };\n                }) : V2.attr("d", f4), O3.call(RLt, n4, t3, r4, { styleOne: J6e, eventDataKeys: JW.eventDataKeys, transitionTime: JW.CLICK_TRANSITION_TIME, transitionEasing: JW.CLICK_TRANSITION_EASING }).call(qA.setSliceCursor, t3, { hideOnRoot: false, hideOnLeaves: false, isTransitioning: t3._transitioning }), V2.call(J6e, z3, x2, t3, { hovered: false }), z3._text = (qA.getPtLabel(z3) || "").split("<br>").join(" ") || "";\n                var G2 = jD.ensureSingle(O3, "g", "slicetext"), Z = jD.ensureSingle(G2, "text", "", function(N2) {\n                  N2.attr("data-notex", 1);\n                }), j3 = jD.ensureUniformFontSize(t3, qA.determineTextFont(x2, z3, S2.font, { onPathbar: true }));\n                Z.text(z3._text || " ").classed("slicetext", true).attr("text-anchor", "start").call(K6e.font, j3).call(PLt.convertToTspans, t3), z3.textBB = K6e.bBox(Z.node()), z3.transform = h3(z3, { fontSize: j3.size, onPathbar: true }), z3.transform.fontSize = j3.size, v3 ? Z.transition().attrTween("transform", function(N2) {\n                  var H = p3(N2, $W, k4, [s3, l3]);\n                  return function(te) {\n                    return d3(H(te));\n                  };\n                }) : Z.attr("transform", d3(z3));\n              });\n            };\n          });\n          var iLe = ye((d0r, rLe) => {\n            "use strict";\n            var eLe = Oa(), QW = (F2(), ob(D22)).interpolate, Z_ = Ky(), WE = Dr(), tLe = e22().TEXTPAD, DLt = n2(), FLt = DLt.toMoveInsideBar, zLt = bv(), eX = zLt.recordMinTextSize, OLt = O2(), qLt = Q6e();\n            function B22(e3) {\n              return Z_.isHierarchyRoot(e3) ? "" : Z_.getPtId(e3);\n            }\n            rLe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = t3._fullLayout, s3 = r4[0], l3 = s3.trace, u4 = l3.type, c5 = u4 === "icicle", f4 = s3.hierarchy, h3 = Z_.findEntryWithLevel(f4, l3.level), d3 = eLe.select(n4), v3 = d3.selectAll("g.pathbar"), _2 = d3.selectAll("g.slice");\n              if (!h3) {\n                v3.remove(), _2.remove();\n                return;\n              }\n              var b = Z_.isHierarchyRoot(h3), p3 = !o4.uniformtext.mode && Z_.hasTransition(i3), k4 = Z_.getMaxDepth(l3), E3 = function($e) {\n                return $e.data.depth - h3.data.depth < k4;\n              }, S2 = o4._size, L3 = l3.domain, x2 = S2.w * (L3.x[1] - L3.x[0]), C3 = S2.h * (L3.y[1] - L3.y[0]), M4 = x2, g3 = l3.pathbar.thickness, P3 = l3.marker.line.width + OLt.gapWithPathbar, T3 = l3.pathbar.visible ? l3.pathbar.side.indexOf("bottom") > -1 ? C3 + P3 : -(g3 + P3) : 0, z3 = { x0: M4, x1: M4, y0: T3, y1: T3 + g3 }, O3 = function($e, St, Qt) {\n                var Vt = l3.tiling.pad, _t = function(lr) {\n                  return lr - Vt <= St.x0;\n                }, It = function(lr) {\n                  return lr + Vt >= St.x1;\n                }, mt = function(lr) {\n                  return lr - Vt <= St.y0;\n                }, er = function(lr) {\n                  return lr + Vt >= St.y1;\n                };\n                return $e.x0 === St.x0 && $e.x1 === St.x1 && $e.y0 === St.y0 && $e.y1 === St.y1 ? { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 } : { x0: _t($e.x0 - Vt) ? 0 : It($e.x0 - Vt) ? Qt[0] : $e.x0, x1: _t($e.x1 + Vt) ? 0 : It($e.x1 + Vt) ? Qt[0] : $e.x1, y0: mt($e.y0 - Vt) ? 0 : er($e.y0 - Vt) ? Qt[1] : $e.y0, y1: mt($e.y1 + Vt) ? 0 : er($e.y1 + Vt) ? Qt[1] : $e.y1 };\n              }, V2 = null, G2 = {}, Z = {}, j3 = null, N2 = function($e, St) {\n                return St ? G2[B22($e)] : Z[B22($e)];\n              }, H = function($e, St, Qt, Vt) {\n                if (St) return G2[B22(f4)] || z3;\n                var _t = Z[l3.level] || Qt;\n                return E3($e) ? O3($e, _t, Vt) : {};\n              };\n              s3.hasMultipleRoots && b && k4++, l3._maxDepth = k4, l3._backgroundColor = o4.paper_bgcolor, l3._entryDepth = h3.data.depth, l3._atRootLevel = b;\n              var te = -x2 / 2 + S2.l + S2.w * (L3.x[1] + L3.x[0]) / 2, oe = -C3 / 2 + S2.t + S2.h * (1 - (L3.y[1] + L3.y[0]) / 2), _e = function($e) {\n                return te + $e;\n              }, Ee = function($e) {\n                return oe + $e;\n              }, Ce = Ee(0), me = _e(0), ie = function($e) {\n                return me + $e;\n              }, Se = function($e) {\n                return Ce + $e;\n              };\n              function Le($e, St) {\n                return $e + "," + St;\n              }\n              var Ae = ie(0), Fe = function($e) {\n                $e.x = Math.max(Ae, $e.x);\n              }, Pe = l3.pathbar.edgeshape, ge = function($e) {\n                var St = ie(Math.max(Math.min($e.x0, $e.x0), 0)), Qt = ie(Math.min(Math.max($e.x1, $e.x1), M4)), Vt = Se($e.y0), _t = Se($e.y1), It = g3 / 2, mt = {}, er = {};\n                mt.x = St, er.x = Qt, mt.y = er.y = (Vt + _t) / 2;\n                var lr = { x: St, y: Vt }, Tr = { x: Qt, y: Vt }, Lr = { x: Qt, y: _t }, ti = { x: St, y: _t };\n                return Pe === ">" ? (lr.x -= It, Tr.x -= It, Lr.x -= It, ti.x -= It) : Pe === "/" ? (Lr.x -= It, ti.x -= It, mt.x -= It / 2, er.x -= It / 2) : Pe === "\\\\" ? (lr.x -= It, Tr.x -= It, mt.x -= It / 2, er.x -= It / 2) : Pe === "<" && (mt.x -= It, er.x -= It), Fe(lr), Fe(ti), Fe(mt), Fe(Tr), Fe(Lr), Fe(er), "M" + Le(lr.x, lr.y) + "L" + Le(Tr.x, Tr.y) + "L" + Le(er.x, er.y) + "L" + Le(Lr.x, Lr.y) + "L" + Le(ti.x, ti.y) + "L" + Le(mt.x, mt.y) + "Z";\n              }, Re = l3[c5 ? "tiling" : "marker"].pad, ce = function($e) {\n                return l3.textposition.indexOf($e) !== -1;\n              }, Ze = ce("top"), ut = ce("left"), pt = ce("right"), Zt = ce("bottom"), st = function($e) {\n                var St = _e($e.x0), Qt = _e($e.x1), Vt = Ee($e.y0), _t = Ee($e.y1), It = Qt - St, mt = _t - Vt;\n                if (!It || !mt) return "";\n                var er = l3.marker.cornerradius || 0, lr = Math.min(er, It / 2, mt / 2);\n                lr && $e.data && $e.data.data && $e.data.data.label && (Ze && (lr = Math.min(lr, Re.t)), ut && (lr = Math.min(lr, Re.l)), pt && (lr = Math.min(lr, Re.r)), Zt && (lr = Math.min(lr, Re.b)));\n                var Tr = function(Lr, ti) {\n                  return lr ? "a" + Le(lr, lr) + " 0 0 1 " + Le(Lr, ti) : "";\n                };\n                return "M" + Le(St, Vt + lr) + Tr(lr, -lr) + "L" + Le(Qt - lr, Vt) + Tr(lr, lr) + "L" + Le(Qt, _t - lr) + Tr(-lr, lr) + "L" + Le(St + lr, _t) + Tr(-lr, -lr) + "Z";\n              }, lt = function($e, St) {\n                var Qt = $e.x0, Vt = $e.x1, _t = $e.y0, It = $e.y1, mt = $e.textBB, er = Ze || St.isHeader && !Zt, lr = er ? "start" : Zt ? "end" : "middle", Tr = ce("right"), Lr = ce("left") || St.onPathbar, ti = Lr ? -1 : Tr ? 1 : 0;\n                if (St.isHeader) {\n                  if (Qt += (c5 ? Re : Re.l) - tLe, Vt -= (c5 ? Re : Re.r) - tLe, Qt >= Vt) {\n                    var Br = (Qt + Vt) / 2;\n                    Qt = Br, Vt = Br;\n                  }\n                  var Vr;\n                  Zt ? (Vr = It - (c5 ? Re : Re.b), _t < Vr && Vr < It && (_t = Vr)) : (Vr = _t + (c5 ? Re : Re.t), _t < Vr && Vr < It && (It = Vr));\n                }\n                var dt = FLt(Qt, Vt, _t, It, mt, { isHorizontal: false, constrained: true, angle: 0, anchor: lr, leftToRight: ti });\n                return dt.fontSize = St.fontSize, dt.targetX = _e(dt.targetX), dt.targetY = Ee(dt.targetY), isNaN(dt.targetX) || isNaN(dt.targetY) ? {} : (Qt !== Vt && _t !== It && eX(l3.type, dt, o4), { scale: dt.scale, rotate: dt.rotate, textX: dt.textX, textY: dt.textY, anchorX: dt.anchorX, anchorY: dt.anchorY, targetX: dt.targetX, targetY: dt.targetY });\n              }, Gt = function($e, St) {\n                for (var Qt, Vt = 0, _t = $e; !Qt && Vt < k4; ) Vt++, _t = _t.parent, _t ? Qt = N2(_t, St) : Vt = k4;\n                return Qt || {};\n              }, Nt = function($e, St, Qt, Vt) {\n                var _t = N2($e, St), It;\n                if (St) It = z3;\n                else {\n                  var mt = N2(h3, St);\n                  mt ? It = O3($e, mt, Vt) : It = {};\n                }\n                return QW(_t, It);\n              }, Jt = function($e, St, Qt, Vt, _t) {\n                var It = N2($e, St), mt;\n                if (It) mt = It;\n                else if (St) mt = z3;\n                else if (V2) if ($e.parent) {\n                  var er = j3 || Qt;\n                  er && !St ? mt = O3($e, er, Vt) : (mt = {}, WE.extendFlat(mt, Gt($e, St)));\n                } else mt = WE.extendFlat({}, $e), c5 && (_t.orientation === "h" ? _t.flipX ? mt.x0 = $e.x1 : mt.x1 = 0 : _t.flipY ? mt.y0 = $e.y1 : mt.y1 = 0);\n                else mt = {};\n                return QW(mt, { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 });\n              }, sr = function($e, St, Qt, Vt) {\n                var _t = N2($e, St), It = {}, mt = H($e, St, Qt, Vt);\n                WE.extendFlat(It, { transform: lt({ x0: mt.x0, x1: mt.x1, y0: mt.y0, y1: mt.y1, textBB: $e.textBB, _text: $e._text }, { isHeader: Z_.isHeader($e, l3) }) }), _t ? It = _t : $e.parent && WE.extendFlat(It, Gt($e, St));\n                var er = $e.transform;\n                return $e.x0 !== $e.x1 && $e.y0 !== $e.y1 && eX(l3.type, er, o4), QW(It, { transform: { scale: er.scale, rotate: er.rotate, textX: er.textX, textY: er.textY, anchorX: er.anchorX, anchorY: er.anchorY, targetX: er.targetX, targetY: er.targetY } });\n              }, wr = function($e, St, Qt, Vt, _t) {\n                var It = Vt[0], mt = Vt[1];\n                p3 ? $e.exit().transition().each(function() {\n                  var er = eLe.select(this), lr = er.select("path.surface");\n                  lr.transition().attrTween("d", function(Lr) {\n                    var ti = Nt(Lr, St, Qt, [It, mt]);\n                    return function(Br) {\n                      return _t(ti(Br));\n                    };\n                  });\n                  var Tr = er.select("g.slicetext");\n                  Tr.attr("opacity", 0);\n                }).remove() : $e.exit().remove();\n              }, cr = function($e) {\n                var St = $e.transform;\n                return $e.x0 !== $e.x1 && $e.y0 !== $e.y1 && eX(l3.type, St, o4), WE.getTextTransform({ textX: St.textX, textY: St.textY, anchorX: St.anchorX, anchorY: St.anchorY, targetX: St.targetX, targetY: St.targetY, scale: St.scale, rotate: St.rotate });\n              };\n              p3 && (v3.each(function($e) {\n                G2[B22($e)] = { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 }, $e.transform && (G2[B22($e)].transform = { textX: $e.transform.textX, textY: $e.transform.textY, anchorX: $e.transform.anchorX, anchorY: $e.transform.anchorY, targetX: $e.transform.targetX, targetY: $e.transform.targetY, scale: $e.transform.scale, rotate: $e.transform.rotate });\n              }), _2.each(function($e) {\n                Z[B22($e)] = { x0: $e.x0, x1: $e.x1, y0: $e.y0, y1: $e.y1 }, $e.transform && (Z[B22($e)].transform = { textX: $e.transform.textX, textY: $e.transform.textY, anchorX: $e.transform.anchorX, anchorY: $e.transform.anchorY, targetX: $e.transform.targetX, targetY: $e.transform.targetY, scale: $e.transform.scale, rotate: $e.transform.rotate }), !V2 && Z_.isEntry($e) && (V2 = $e);\n              })), j3 = a4(t3, r4, h3, _2, { width: x2, height: C3, viewX: _e, viewY: Ee, pathSlice: st, toMoveInsideSlice: lt, prevEntry: V2, makeUpdateSliceInterpolator: Jt, makeUpdateTextInterpolator: sr, handleSlicesExit: wr, hasTransition: p3, strTransform: cr }), l3.pathbar.visible ? qLt(t3, r4, h3, v3, { barDifY: T3, width: M4, height: g3, viewX: ie, viewY: Se, pathSlice: ge, toMoveInsideSlice: lt, makeUpdateSliceInterpolator: Jt, makeUpdateTextInterpolator: sr, handleSlicesExit: wr, hasTransition: p3, strTransform: cr }) : v3.remove();\n            };\n          });\n          var tX = ye((v0r, aLe) => {\n            "use strict";\n            var BLt = Oa(), NLt = Ky(), ULt = bv(), VLt = ULt.clearMinTextSize, GLt = N0().resizeText, nLe = iLe();\n            aLe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = a4.type, s3 = a4.drawDescendants, l3 = t3._fullLayout, u4 = l3["_" + o4 + "layer"], c5, f4, h3 = !n4;\n              if (VLt(o4, l3), c5 = u4.selectAll("g.trace." + o4).data(r4, function(v3) {\n                return v3[0].trace.uid;\n              }), c5.enter().append("g").classed("trace", true).classed(o4, true), c5.order(), !l3.uniformtext.mode && NLt.hasTransition(n4)) {\n                i3 && (f4 = i3());\n                var d3 = BLt.transition().duration(n4.duration).ease(n4.easing).each("end", function() {\n                  f4 && f4();\n                }).each("interrupt", function() {\n                  f4 && f4();\n                });\n                d3.each(function() {\n                  u4.selectAll("g.trace").each(function(v3) {\n                    nLe(t3, v3, this, n4, s3);\n                  });\n                });\n              } else c5.each(function(v3) {\n                nLe(t3, v3, this, n4, s3);\n              }), l3.uniformtext.mode && GLt(t3, u4.selectAll(".trace"), o4);\n              h3 && c5.exit().remove();\n            };\n          });\n          var cLe = ye((p0r, uLe) => {\n            "use strict";\n            var oLe = Oa(), WD = Dr(), sLe = So(), HLt = ru(), jLt = YW(), lLe = HD().styleOne, rX = O2(), Y_ = Ky(), WLt = HE(), XLt = VD().formatSliceLabel, iX = false;\n            uLe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = a4.width, s3 = a4.height, l3 = a4.viewX, u4 = a4.viewY, c5 = a4.pathSlice, f4 = a4.toMoveInsideSlice, h3 = a4.strTransform, d3 = a4.hasTransition, v3 = a4.handleSlicesExit, _2 = a4.makeUpdateSliceInterpolator, b = a4.makeUpdateTextInterpolator, p3 = a4.prevEntry, k4 = {}, E3 = t3._context.staticPlot, S2 = t3._fullLayout, L3 = r4[0], x2 = L3.trace, C3 = x2.textposition.indexOf("left") !== -1, M4 = x2.textposition.indexOf("right") !== -1, g3 = x2.textposition.indexOf("bottom") !== -1, P3 = !g3 && !x2.marker.pad.t || g3 && !x2.marker.pad.b, T3 = jLt(n4, [o4, s3], { packing: x2.tiling.packing, squarifyratio: x2.tiling.squarifyratio, flipX: x2.tiling.flip.indexOf("x") > -1, flipY: x2.tiling.flip.indexOf("y") > -1, pad: { inner: x2.tiling.pad, top: x2.marker.pad.t, left: x2.marker.pad.l, right: x2.marker.pad.r, bottom: x2.marker.pad.b } }), z3 = T3.descendants(), O3 = 1 / 0, V2 = -1 / 0;\n              z3.forEach(function(H) {\n                var te = H.depth;\n                te >= x2._maxDepth ? (H.x0 = H.x1 = (H.x0 + H.x1) / 2, H.y0 = H.y1 = (H.y0 + H.y1) / 2) : (O3 = Math.min(O3, te), V2 = Math.max(V2, te));\n              }), i3 = i3.data(z3, Y_.getPtId), x2._maxVisibleLayers = isFinite(V2) ? V2 - O3 + 1 : 0, i3.enter().append("g").classed("slice", true), v3(i3, iX, k4, [o4, s3], c5), i3.order();\n              var G2 = null;\n              if (d3 && p3) {\n                var Z = Y_.getPtId(p3);\n                i3.each(function(H) {\n                  G2 === null && Y_.getPtId(H) === Z && (G2 = { x0: H.x0, x1: H.x1, y0: H.y0, y1: H.y1 });\n                });\n              }\n              var j3 = function() {\n                return G2 || { x0: 0, x1: o4, y0: 0, y1: s3 };\n              }, N2 = i3;\n              return d3 && (N2 = N2.transition().each("end", function() {\n                var H = oLe.select(this);\n                Y_.setSliceCursor(H, t3, { hideOnRoot: true, hideOnLeaves: false, isTransitioning: false });\n              })), N2.each(function(H) {\n                var te = Y_.isHeader(H, x2);\n                H._x0 = l3(H.x0), H._x1 = l3(H.x1), H._y0 = u4(H.y0), H._y1 = u4(H.y1), H._hoverX = l3(H.x1 - x2.marker.pad.r), H._hoverY = u4(g3 ? H.y1 - x2.marker.pad.b / 2 : H.y0 + x2.marker.pad.t / 2);\n                var oe = oLe.select(this), _e = WD.ensureSingle(oe, "path", "surface", function(Le) {\n                  Le.style("pointer-events", E3 ? "none" : "all");\n                });\n                d3 ? _e.transition().attrTween("d", function(Le) {\n                  var Ae = _2(Le, iX, j3(), [o4, s3]);\n                  return function(Fe) {\n                    return c5(Ae(Fe));\n                  };\n                }) : _e.attr("d", c5), oe.call(WLt, n4, t3, r4, { styleOne: lLe, eventDataKeys: rX.eventDataKeys, transitionTime: rX.CLICK_TRANSITION_TIME, transitionEasing: rX.CLICK_TRANSITION_EASING }).call(Y_.setSliceCursor, t3, { isTransitioning: t3._transitioning }), _e.call(lLe, H, x2, t3, { hovered: false }), H.x0 === H.x1 || H.y0 === H.y1 ? H._text = "" : te ? H._text = P3 ? "" : Y_.getPtLabel(H) || "" : H._text = XLt(H, n4, x2, r4, S2) || "";\n                var Ee = WD.ensureSingle(oe, "g", "slicetext"), Ce = WD.ensureSingle(Ee, "text", "", function(Le) {\n                  Le.attr("data-notex", 1);\n                }), me = WD.ensureUniformFontSize(t3, Y_.determineTextFont(x2, H, S2.font)), ie = H._text || " ", Se = te && ie.indexOf("<br>") === -1;\n                Ce.text(ie).classed("slicetext", true).attr("text-anchor", M4 ? "end" : C3 || Se ? "start" : "middle").call(sLe.font, me).call(HLt.convertToTspans, t3), H.textBB = sLe.bBox(Ce.node()), H.transform = f4(H, { fontSize: me.size, isHeader: te }), H.transform.fontSize = me.size, d3 ? Ce.transition().attrTween("transform", function(Le) {\n                  var Ae = b(Le, iX, j3(), [o4, s3]);\n                  return function(Fe) {\n                    return h3(Ae(Fe));\n                  };\n                }) : Ce.attr("transform", h3(H));\n              }), G2;\n            };\n          });\n          var hLe = ye((g0r, fLe) => {\n            "use strict";\n            var ZLt = tX(), YLt = cLe();\n            fLe.exports = function(t3, r4, n4, i3) {\n              return ZLt(t3, r4, n4, i3, { type: "treemap", drawDescendants: YLt });\n            };\n          });\n          var vLe = ye((m0r, dLe) => {\n            "use strict";\n            dLe.exports = { moduleType: "trace", name: "treemap", basePlotModule: L6e(), categories: [], animatable: true, attributes: GD(), layoutAttributes: jW(), supplyDefaults: B6e(), supplyLayoutDefaults: U6e(), calc: XW().calc, crossTraceCalc: XW().crossTraceCalc, plot: hLe(), style: HD().style, colorbar: $d(), meta: {} };\n          });\n          var gLe = ye((y0r, pLe) => {\n            "use strict";\n            pLe.exports = vLe();\n          });\n          var yLe = ye((BA) => {\n            "use strict";\n            var mLe = Mc();\n            BA.name = "icicle";\n            BA.plot = function(e3, t3, r4, n4) {\n              mLe.plotBasePlot(BA.name, e3, t3, r4, n4);\n            };\n            BA.clean = function(e3, t3, r4, n4) {\n              mLe.cleanBasePlot(BA.name, e3, t3, r4, n4);\n            };\n          });\n          var nX = ye((x0r, bLe) => {\n            "use strict";\n            var { hovertemplateAttrs: KLt, texttemplateAttrs: JLt, templatefallbackAttrs: _Le } = Ll(), $Lt = Tu(), QLt = Cc().attributes, XE = M2(), o0 = LE(), XD = GD(), xLe = O2(), ePt = Ao().extendFlat, tPt = Pd().pattern;\n            bLe.exports = { labels: o0.labels, parents: o0.parents, values: o0.values, branchvalues: o0.branchvalues, count: o0.count, level: o0.level, maxdepth: o0.maxdepth, tiling: { orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h", editType: "plot" }, flip: XD.tiling.flip, pad: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, marker: ePt({ colors: o0.marker.colors, line: o0.marker.line, pattern: tPt, editType: "calc" }, $Lt("marker", { colorAttr: "colors", anim: false })), leaf: o0.leaf, pathbar: XD.pathbar, text: XE.text, textinfo: o0.textinfo, texttemplate: JLt({ editType: "plot" }, { keys: xLe.eventDataKeys.concat(["label", "value"]) }), texttemplatefallback: _Le({ editType: "plot" }), hovertext: XE.hovertext, hoverinfo: o0.hoverinfo, hovertemplate: KLt({}, { keys: xLe.eventDataKeys }), hovertemplatefallback: _Le(), textfont: XE.textfont, insidetextfont: XE.insidetextfont, outsidetextfont: XD.outsidetextfont, textposition: XD.textposition, sort: XE.sort, root: o0.root, domain: QLt({ name: "icicle", trace: true, editType: "calc" }) };\n          });\n          var aX = ye((b0r, wLe) => {\n            "use strict";\n            wLe.exports = { iciclecolorway: { valType: "colorlist", editType: "calc" }, extendiciclecolors: { valType: "boolean", dflt: true, editType: "calc" } };\n          });\n          var MLe = ye((w0r, SLe) => {\n            "use strict";\n            var TLe = Dr(), rPt = nX(), iPt = ka(), nPt = Cc().defaults, aPt = r0().handleText, oPt = e22().TEXTPAD, sPt = E2().handleMarkerDefaults, ALe = tc(), lPt = ALe.hasColorscale, uPt = ALe.handleDefaults;\n            SLe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return TLe.coerce(t3, r4, rPt, d3, v3);\n              }\n              var o4 = a4("labels"), s3 = a4("parents");\n              if (!o4 || !o4.length || !s3 || !s3.length) {\n                r4.visible = false;\n                return;\n              }\n              var l3 = a4("values");\n              l3 && l3.length ? a4("branchvalues") : a4("count"), a4("level"), a4("maxdepth"), a4("tiling.orientation"), a4("tiling.flip"), a4("tiling.pad");\n              var u4 = a4("text");\n              a4("texttemplate"), a4("texttemplatefallback"), r4.texttemplate || a4("textinfo", TLe.isArrayOrTypedArray(u4) ? "text+label" : "label"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var c5 = a4("pathbar.visible"), f4 = "auto";\n              aPt(t3, r4, i3, a4, f4, { hasPathbar: c5, moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false }), a4("textposition"), sPt(t3, r4, i3, a4);\n              var h3 = r4._hasColorscale = lPt(t3, "marker", "colors") || (t3.marker || {}).coloraxis;\n              h3 && uPt(t3, r4, i3, a4, { prefix: "marker.", cLetter: "c" }), a4("leaf.opacity", h3 ? 1 : 0.7), r4._hovered = { marker: { line: { width: 2, color: iPt.contrast(i3.paper_bgcolor) } } }, c5 && (a4("pathbar.thickness", r4.pathbar.textfont.size + 2 * oPt), a4("pathbar.side"), a4("pathbar.edgeshape")), a4("sort"), a4("root.color"), nPt(r4, i3, a4), r4._length = null;\n            };\n          });\n          var kLe = ye((T0r, ELe) => {\n            "use strict";\n            var cPt = Dr(), fPt = aX();\n            ELe.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return cPt.coerce(t3, r4, fPt, i3, a4);\n              }\n              n4("iciclecolorway", r4.colorway), n4("extendiciclecolors");\n            };\n          });\n          var sX = ye((oX) => {\n            "use strict";\n            var CLe = RE();\n            oX.calc = function(e3, t3) {\n              return CLe.calc(e3, t3);\n            };\n            oX.crossTraceCalc = function(e3) {\n              return CLe._runCrossTraceCalc("icicle", e3);\n            };\n          });\n          var PLe = ye((S0r, LLe) => {\n            "use strict";\n            var hPt = PE(), dPt = ZW();\n            LLe.exports = function(t3, r4, n4) {\n              var i3 = n4.flipX, a4 = n4.flipY, o4 = n4.orientation === "h", s3 = n4.maxDepth, l3 = r4[0], u4 = r4[1];\n              s3 && (l3 = (t3.height + 1) * r4[0] / Math.min(t3.height + 1, s3), u4 = (t3.height + 1) * r4[1] / Math.min(t3.height + 1, s3));\n              var c5 = hPt.partition().padding(n4.pad.inner).size(o4 ? [r4[1], l3] : [r4[0], u4])(t3);\n              return (o4 || i3 || a4) && dPt(c5, r4, { swapXY: o4, flipX: i3, flipY: a4 }), c5;\n            };\n          });\n          var lX = ye((M0r, zLe) => {\n            "use strict";\n            var ILe = Oa(), RLe = ka(), DLe = Dr(), vPt = bv().resizeText, pPt = ND();\n            function gPt(e3) {\n              var t3 = e3._fullLayout._iciclelayer.selectAll(".trace");\n              vPt(e3, t3, "icicle"), t3.each(function(r4) {\n                var n4 = ILe.select(this), i3 = r4[0], a4 = i3.trace;\n                n4.style("opacity", a4.opacity), n4.selectAll("path.surface").each(function(o4) {\n                  ILe.select(this).call(FLe, o4, a4, e3);\n                });\n              });\n            }\n            function FLe(e3, t3, r4, n4) {\n              var i3 = t3.data.data, a4 = !t3.children, o4 = i3.i, s3 = DLe.castOption(r4, o4, "marker.line.color") || RLe.defaultLine, l3 = DLe.castOption(r4, o4, "marker.line.width") || 0;\n              e3.call(pPt, t3, r4, n4).style("stroke-width", l3).call(RLe.stroke, s3).style("opacity", a4 ? r4.leaf.opacity : null);\n            }\n            zLe.exports = { style: gPt, styleOne: FLe };\n          });\n          var ULe = ye((E0r, NLe) => {\n            "use strict";\n            var OLe = Oa(), ZD = Dr(), qLe = So(), mPt = ru(), yPt = PLe(), BLe = lX().styleOne, uX = O2(), NA = Ky(), _Pt = HE(), xPt = VD().formatSliceLabel, cX = false;\n            NLe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = a4.width, s3 = a4.height, l3 = a4.viewX, u4 = a4.viewY, c5 = a4.pathSlice, f4 = a4.toMoveInsideSlice, h3 = a4.strTransform, d3 = a4.hasTransition, v3 = a4.handleSlicesExit, _2 = a4.makeUpdateSliceInterpolator, b = a4.makeUpdateTextInterpolator, p3 = a4.prevEntry, k4 = {}, E3 = t3._context.staticPlot, S2 = t3._fullLayout, L3 = r4[0], x2 = L3.trace, C3 = x2.textposition.indexOf("left") !== -1, M4 = x2.textposition.indexOf("right") !== -1, g3 = x2.textposition.indexOf("bottom") !== -1, P3 = yPt(n4, [o4, s3], { flipX: x2.tiling.flip.indexOf("x") > -1, flipY: x2.tiling.flip.indexOf("y") > -1, orientation: x2.tiling.orientation, pad: { inner: x2.tiling.pad }, maxDepth: x2._maxDepth }), T3 = P3.descendants(), z3 = 1 / 0, O3 = -1 / 0;\n              T3.forEach(function(N2) {\n                var H = N2.depth;\n                H >= x2._maxDepth ? (N2.x0 = N2.x1 = (N2.x0 + N2.x1) / 2, N2.y0 = N2.y1 = (N2.y0 + N2.y1) / 2) : (z3 = Math.min(z3, H), O3 = Math.max(O3, H));\n              }), i3 = i3.data(T3, NA.getPtId), x2._maxVisibleLayers = isFinite(O3) ? O3 - z3 + 1 : 0, i3.enter().append("g").classed("slice", true), v3(i3, cX, k4, [o4, s3], c5), i3.order();\n              var V2 = null;\n              if (d3 && p3) {\n                var G2 = NA.getPtId(p3);\n                i3.each(function(N2) {\n                  V2 === null && NA.getPtId(N2) === G2 && (V2 = { x0: N2.x0, x1: N2.x1, y0: N2.y0, y1: N2.y1 });\n                });\n              }\n              var Z = function() {\n                return V2 || { x0: 0, x1: o4, y0: 0, y1: s3 };\n              }, j3 = i3;\n              return d3 && (j3 = j3.transition().each("end", function() {\n                var N2 = OLe.select(this);\n                NA.setSliceCursor(N2, t3, { hideOnRoot: true, hideOnLeaves: false, isTransitioning: false });\n              })), j3.each(function(N2) {\n                N2._x0 = l3(N2.x0), N2._x1 = l3(N2.x1), N2._y0 = u4(N2.y0), N2._y1 = u4(N2.y1), N2._hoverX = l3(N2.x1 - x2.tiling.pad), N2._hoverY = u4(g3 ? N2.y1 - x2.tiling.pad / 2 : N2.y0 + x2.tiling.pad / 2);\n                var H = OLe.select(this), te = ZD.ensureSingle(H, "path", "surface", function(Ce) {\n                  Ce.style("pointer-events", E3 ? "none" : "all");\n                });\n                d3 ? te.transition().attrTween("d", function(Ce) {\n                  var me = _2(Ce, cX, Z(), [o4, s3], { orientation: x2.tiling.orientation, flipX: x2.tiling.flip.indexOf("x") > -1, flipY: x2.tiling.flip.indexOf("y") > -1 });\n                  return function(ie) {\n                    return c5(me(ie));\n                  };\n                }) : te.attr("d", c5), H.call(_Pt, n4, t3, r4, { styleOne: BLe, eventDataKeys: uX.eventDataKeys, transitionTime: uX.CLICK_TRANSITION_TIME, transitionEasing: uX.CLICK_TRANSITION_EASING }).call(NA.setSliceCursor, t3, { isTransitioning: t3._transitioning }), te.call(BLe, N2, x2, t3, { hovered: false }), N2.x0 === N2.x1 || N2.y0 === N2.y1 ? N2._text = "" : N2._text = xPt(N2, n4, x2, r4, S2) || "";\n                var oe = ZD.ensureSingle(H, "g", "slicetext"), _e = ZD.ensureSingle(oe, "text", "", function(Ce) {\n                  Ce.attr("data-notex", 1);\n                }), Ee = ZD.ensureUniformFontSize(t3, NA.determineTextFont(x2, N2, S2.font));\n                _e.text(N2._text || " ").classed("slicetext", true).attr("text-anchor", M4 ? "end" : C3 ? "start" : "middle").call(qLe.font, Ee).call(mPt.convertToTspans, t3), N2.textBB = qLe.bBox(_e.node()), N2.transform = f4(N2, { fontSize: Ee.size }), N2.transform.fontSize = Ee.size, d3 ? _e.transition().attrTween("transform", function(Ce) {\n                  var me = b(Ce, cX, Z(), [o4, s3]);\n                  return function(ie) {\n                    return h3(me(ie));\n                  };\n                }) : _e.attr("transform", h3(N2));\n              }), V2;\n            };\n          });\n          var GLe = ye((k0r, VLe) => {\n            "use strict";\n            var bPt = tX(), wPt = ULe();\n            VLe.exports = function(t3, r4, n4, i3) {\n              return bPt(t3, r4, n4, i3, { type: "icicle", drawDescendants: wPt });\n            };\n          });\n          var jLe = ye((C0r, HLe) => {\n            "use strict";\n            HLe.exports = { moduleType: "trace", name: "icicle", basePlotModule: yLe(), categories: [], animatable: true, attributes: nX(), layoutAttributes: aX(), supplyDefaults: MLe(), supplyLayoutDefaults: kLe(), calc: sX().calc, crossTraceCalc: sX().crossTraceCalc, plot: GLe(), style: lX().style, colorbar: $d(), meta: {} };\n          });\n          var XLe = ye((L0r, WLe) => {\n            "use strict";\n            WLe.exports = jLe();\n          });\n          var YLe = ye((UA) => {\n            "use strict";\n            var ZLe = Mc();\n            UA.name = "funnelarea";\n            UA.plot = function(e3, t3, r4, n4) {\n              ZLe.plotBasePlot(UA.name, e3, t3, r4, n4);\n            };\n            UA.clean = function(e3, t3, r4, n4) {\n              ZLe.cleanBasePlot(UA.name, e3, t3, r4, n4);\n            };\n          });\n          var fX = ye((I0r, JLe) => {\n            "use strict";\n            var iv = M2(), TPt = Gl(), APt = Cc().attributes, { hovertemplateAttrs: SPt, texttemplateAttrs: MPt, templatefallbackAttrs: KLe } = Ll(), N2 = Ao().extendFlat;\n            JLe.exports = { labels: iv.labels, label0: iv.label0, dlabel: iv.dlabel, values: iv.values, marker: { colors: iv.marker.colors, line: { color: N2({}, iv.marker.line.color, { dflt: null }), width: N2({}, iv.marker.line.width, { dflt: 1 }), editType: "calc" }, pattern: iv.marker.pattern, editType: "calc" }, text: iv.text, hovertext: iv.hovertext, scalegroup: N2({}, iv.scalegroup, {}), textinfo: N2({}, iv.textinfo, { flags: ["label", "text", "value", "percent"] }), texttemplate: MPt({ editType: "plot" }, { keys: ["label", "color", "value", "text", "percent"] }), texttemplatefallback: KLe({ editType: "plot" }), hoverinfo: N2({}, TPt.hoverinfo, { flags: ["label", "text", "value", "percent", "name"] }), hovertemplate: SPt({}, { keys: ["label", "color", "value", "text", "percent"] }), hovertemplatefallback: KLe(), textposition: N2({}, iv.textposition, { values: ["inside", "none"], dflt: "inside" }), textfont: iv.textfont, insidetextfont: iv.insidetextfont, title: { text: iv.title.text, font: iv.title.font, position: N2({}, iv.title.position, { values: ["top left", "top center", "top right"], dflt: "top center" }), editType: "plot" }, domain: APt({ name: "funnelarea", trace: true, editType: "calc" }), aspectratio: { valType: "number", min: 0, dflt: 1, editType: "plot" }, baseratio: { valType: "number", min: 0, max: 1, dflt: 0.333, editType: "plot" } };\n          });\n          var hX = ye((R0r, $Le) => {\n            "use strict";\n            var EPt = pD().hiddenlabels;\n            $Le.exports = { hiddenlabels: EPt, funnelareacolorway: { valType: "colorlist", editType: "calc" }, extendfunnelareacolors: { valType: "boolean", dflt: true, editType: "calc" } };\n          });\n          var tPe = ye((D0r, ePe) => {\n            "use strict";\n            var QLe = Dr(), kPt = fX(), CPt = Cc().defaults, LPt = r0().handleText, PPt = E2().handleLabelsAndValues, IPt = E2().handleMarkerDefaults;\n            ePe.exports = function(t3, r4, n4, i3) {\n              function a4(_2, b) {\n                return QLe.coerce(t3, r4, kPt, _2, b);\n              }\n              var o4 = a4("labels"), s3 = a4("values"), l3 = PPt(o4, s3), u4 = l3.len;\n              if (r4._hasLabels = l3.hasLabels, r4._hasValues = l3.hasValues, !r4._hasLabels && r4._hasValues && (a4("label0"), a4("dlabel")), !u4) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = u4, IPt(t3, r4, i3, a4), a4("scalegroup");\n              var c5 = a4("text"), f4 = a4("texttemplate");\n              a4("texttemplatefallback");\n              var h3;\n              if (f4 || (h3 = a4("textinfo", Array.isArray(c5) ? "text+percent" : "percent")), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), f4 || h3 && h3 !== "none") {\n                var d3 = a4("textposition");\n                LPt(t3, r4, i3, a4, d3, { moduleHasSelected: false, moduleHasUnselected: false, moduleHasConstrain: false, moduleHasCliponaxis: false, moduleHasTextangle: false, moduleHasInsideanchor: false });\n              } else h3 === "none" && a4("textposition", "none");\n              CPt(r4, i3, a4);\n              var v3 = a4("title.text");\n              v3 && (a4("title.position"), QLe.coerceFont(a4, "title.font", i3.font)), a4("aspectratio"), a4("baseratio");\n            };\n          });\n          var iPe = ye((F0r, rPe) => {\n            "use strict";\n            var RPt = Dr(), DPt = hX();\n            rPe.exports = function(t3, r4) {\n              function n4(i3, a4) {\n                return RPt.coerce(t3, r4, DPt, i3, a4);\n              }\n              n4("hiddenlabels"), n4("funnelareacolorway", r4.colorway), n4("extendfunnelareacolors");\n            };\n          });\n          var dX = ye((z0r, aPe) => {\n            "use strict";\n            var nPe = TA();\n            function FPt(e3, t3) {\n              return nPe.calc(e3, t3);\n            }\n            function zPt(e3) {\n              nPe.crossTraceCalc(e3, { type: "funnelarea" });\n            }\n            aPe.exports = { calc: FPt, crossTraceCalc: zPt };\n          });\n          var cPe = ye((O0r, uPe) => {\n            "use strict";\n            var U2 = Oa(), vX = So(), K_ = Dr(), OPt = K_.strScale, oPe = K_.strTranslate, sPe = ru(), qPt = n2(), BPt = qPt.toMoveInsideBar, lPe = bv(), NPt = lPe.recordMinTextSize, UPt = lPe.clearMinTextSize, VPt = l_(), VA = _D(), GPt = VA.attachFxHandlers, HPt = VA.determineInsideTextFont, jPt = VA.layoutAreas, WPt = VA.prerenderTitles, XPt = VA.positionTitleOutside, ZPt = VA.formatSliceLabel;\n            uPe.exports = function(t3, r4) {\n              var n4 = t3._context.staticPlot, i3 = t3._fullLayout;\n              UPt("funnelarea", i3), WPt(r4, t3), jPt(r4, i3._size), K_.makeTraceGroups(i3._funnelarealayer, r4, "trace").each(function(a4) {\n                var o4 = U2.select(this), s3 = a4[0], l3 = s3.trace;\n                KPt(a4), o4.each(function() {\n                  var u4 = U2.select(this).selectAll("g.slice").data(a4);\n                  u4.enter().append("g").classed("slice", true), u4.exit().remove(), u4.each(function(f4, h3) {\n                    if (f4.hidden) {\n                      U2.select(this).selectAll("path,g").remove();\n                      return;\n                    }\n                    f4.pointNumber = f4.i, f4.curveNumber = l3.index;\n                    var d3 = s3.cx, v3 = s3.cy, _2 = U2.select(this), b = _2.selectAll("path.surface").data([f4]);\n                    b.enter().append("path").classed("surface", true).style({ "pointer-events": n4 ? "none" : "all" }), _2.call(GPt, t3, a4);\n                    var p3 = "M" + (d3 + f4.TR[0]) + "," + (v3 + f4.TR[1]) + pX(f4.TR, f4.BR) + pX(f4.BR, f4.BL) + pX(f4.BL, f4.TL) + "Z";\n                    b.attr("d", p3), ZPt(t3, f4, s3);\n                    var k4 = VPt.castOption(l3.textposition, f4.pts), E3 = _2.selectAll("g.slicetext").data(f4.text && k4 !== "none" ? [0] : []);\n                    E3.enter().append("g").classed("slicetext", true), E3.exit().remove(), E3.each(function() {\n                      var S2 = K_.ensureSingle(U2.select(this), "text", "", function(z3) {\n                        z3.attr("data-notex", 1);\n                      }), L3 = K_.ensureUniformFontSize(t3, HPt(l3, f4, i3.font));\n                      S2.text(f4.text).attr({ class: "slicetext", transform: "", "text-anchor": "middle" }).call(vX.font, L3).call(sPe.convertToTspans, t3);\n                      var x2 = vX.bBox(S2.node()), C3, M4, g3, P3 = Math.min(f4.BL[1], f4.BR[1]) + v3, T3 = Math.max(f4.TL[1], f4.TR[1]) + v3;\n                      M4 = Math.max(f4.TL[0], f4.BL[0]) + d3, g3 = Math.min(f4.TR[0], f4.BR[0]) + d3, C3 = BPt(M4, g3, P3, T3, x2, { isHorizontal: true, constrained: true, angle: 0, anchor: "middle" }), C3.fontSize = L3.size, NPt(l3.type, C3, i3), a4[h3].transform = C3, K_.setTransormAndDisplay(S2, C3);\n                    });\n                  });\n                  var c5 = U2.select(this).selectAll("g.titletext").data(l3.title.text ? [0] : []);\n                  c5.enter().append("g").classed("titletext", true), c5.exit().remove(), c5.each(function() {\n                    var f4 = K_.ensureSingle(U2.select(this), "text", "", function(v3) {\n                      v3.attr("data-notex", 1);\n                    }), h3 = l3.title.text;\n                    l3._meta && (h3 = K_.templateString(h3, l3._meta)), f4.text(h3).attr({ class: "titletext", transform: "", "text-anchor": "middle" }).call(vX.font, l3.title.font).call(sPe.convertToTspans, t3);\n                    var d3 = XPt(s3, i3._size);\n                    f4.attr("transform", oPe(d3.x, d3.y) + OPt(Math.min(1, d3.scale)) + oPe(d3.tx, d3.ty));\n                  });\n                });\n              });\n            };\n            function pX(e3, t3) {\n              var r4 = t3[0] - e3[0], n4 = t3[1] - e3[1];\n              return "l" + r4 + "," + n4;\n            }\n            function YPt(e3, t3) {\n              return [0.5 * (e3[0] + t3[0]), 0.5 * (e3[1] + t3[1])];\n            }\n            function KPt(e3) {\n              if (!e3.length) return;\n              var t3 = e3[0], r4 = t3.trace, n4 = r4.aspectratio, i3 = r4.baseratio;\n              i3 > 0.999 && (i3 = 0.999);\n              var a4 = Math.pow(i3, 2), o4 = t3.vTotal, s3 = o4 * a4 / (1 - a4), l3 = o4, u4 = s3 / o4;\n              function c5() {\n                var O3 = Math.sqrt(u4);\n                return { x: O3, y: -O3 };\n              }\n              function f4() {\n                var O3 = c5();\n                return [O3.x, O3.y];\n              }\n              var h3, d3 = [];\n              d3.push(f4());\n              var v3, _2;\n              for (v3 = e3.length - 1; v3 > -1; v3--) if (_2 = e3[v3], !_2.hidden) {\n                var b = _2.v / l3;\n                u4 += b, d3.push(f4());\n              }\n              var p3 = 1 / 0, k4 = -1 / 0;\n              for (v3 = 0; v3 < d3.length; v3++) h3 = d3[v3], p3 = Math.min(p3, h3[1]), k4 = Math.max(k4, h3[1]);\n              for (v3 = 0; v3 < d3.length; v3++) d3[v3][1] -= (k4 + p3) / 2;\n              var E3 = d3[d3.length - 1][0], S2 = t3.r, L3 = (k4 - p3) / 2, x2 = S2 / E3, C3 = S2 / L3 * n4;\n              for (t3.r = C3 * L3, v3 = 0; v3 < d3.length; v3++) d3[v3][0] *= x2, d3[v3][1] *= C3;\n              h3 = d3[0];\n              var M4 = [-h3[0], h3[1]], g3 = [h3[0], h3[1]], P3 = 0;\n              for (v3 = e3.length - 1; v3 > -1; v3--) if (_2 = e3[v3], !_2.hidden) {\n                P3 += 1;\n                var T3 = d3[P3][0], z3 = d3[P3][1];\n                _2.TL = [-T3, z3], _2.TR = [T3, z3], _2.BL = M4, _2.BR = g3, _2.pxmid = YPt(_2.TR, _2.BR), M4 = _2.TL, g3 = _2.TR;\n              }\n            }\n          });\n          var dPe = ye((q0r, hPe) => {\n            "use strict";\n            var fPe = Oa(), JPt = B3(), $Pt = bv().resizeText;\n            hPe.exports = function(t3) {\n              var r4 = t3._fullLayout._funnelarealayer.selectAll(".trace");\n              $Pt(t3, r4, "funnelarea"), r4.each(function(n4) {\n                var i3 = n4[0], a4 = i3.trace, o4 = fPe.select(this);\n                o4.style({ opacity: a4.opacity }), o4.selectAll("path.surface").each(function(s3) {\n                  fPe.select(this).call(JPt, s3, a4, t3);\n                });\n              });\n            };\n          });\n          var pPe = ye((B0r, vPe) => {\n            "use strict";\n            vPe.exports = { moduleType: "trace", name: "funnelarea", basePlotModule: YLe(), categories: ["pie-like", "funnelarea", "showLegend"], attributes: fX(), layoutAttributes: hX(), supplyDefaults: tPe(), supplyLayoutDefaults: iPe(), calc: dX().calc, crossTraceCalc: dX().crossTraceCalc, plot: cPe(), style: dPe(), styleOne: B3(), meta: {} };\n          });\n          var mPe = ye((N0r, gPe) => {\n            "use strict";\n            gPe.exports = pPe();\n          });\n          var Od = ye((U0r, yPe) => {\n            (function() {\n              var e3 = { 24: function(i3) {\n                var a4 = { left: 0, top: 0 };\n                i3.exports = o4;\n                function o4(l3, u4, c5) {\n                  u4 = u4 || l3.currentTarget || l3.srcElement, Array.isArray(c5) || (c5 = [0, 0]);\n                  var f4 = l3.clientX || 0, h3 = l3.clientY || 0, d3 = s3(u4);\n                  return c5[0] = f4 - d3.left, c5[1] = h3 - d3.top, c5;\n                }\n                function s3(l3) {\n                  return l3 === window || l3 === document || l3 === document.body ? a4 : l3.getBoundingClientRect();\n                }\n              }, 109: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = l3[0], f4 = l3[2], h3 = s3[0] - c5, d3 = s3[2] - f4, v3 = Math.sin(u4), _2 = Math.cos(u4);\n                  return o4[0] = c5 + d3 * v3 + h3 * _2, o4[1] = s3[1], o4[2] = f4 + d3 * _2 - h3 * v3, o4;\n                }\n              }, 160: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = Math.max(s3[0], l3[0]), o4[1] = Math.max(s3[1], l3[1]), o4[2] = Math.max(s3[2], l3[2]), o4[3] = Math.max(s3[3], l3[3]), o4;\n                }\n              }, 216: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  for (var l3 = {}, u4 = 0; u4 < o4.length; ++u4) for (var c5 = o4[u4].name, f4 = c5.split("."), h3 = l3, d3 = 0; d3 < f4.length; ++d3) {\n                    var v3 = f4[d3].split("[");\n                    if (v3.length > 1) {\n                      v3[0] in h3 || (h3[v3[0]] = []), h3 = h3[v3[0]];\n                      for (var _2 = 1; _2 < v3.length; ++_2) {\n                        var b = parseInt(v3[_2]);\n                        _2 < v3.length - 1 || d3 < f4.length - 1 ? (b in h3 || (_2 < v3.length - 1 ? h3[b] = [] : h3[b] = {}), h3 = h3[b]) : s3 ? h3[b] = u4 : h3[b] = o4[u4].type;\n                      }\n                    } else d3 < f4.length - 1 ? (v3[0] in h3 || (h3[v3[0]] = {}), h3 = h3[v3[0]]) : s3 ? h3[v3[0]] = u4 : h3[v3[0]] = o4[u4].type;\n                  }\n                  return l3;\n                }\n              }, 236: function(i3, a4, o4) {\n                var s3 = o4(8284);\n                i3.exports = l3;\n                function l3() {\n                  var u4 = {};\n                  return function(c5) {\n                    if ((typeof c5 != "object" || c5 === null) && typeof c5 != "function") throw new Error("Weakmap-shim: Key must be object");\n                    var f4 = c5.valueOf(u4);\n                    return f4 && f4.identity === u4 ? f4 : s3(c5, u4);\n                  };\n                }\n              }, 244: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] * s3[0] + o4[1] * s3[1] + o4[2] * s3[2];\n                }\n              }, 264: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = l3[0], d3 = l3[1], v3 = l3[2], _2 = l3[3], b = _2 * u4 + d3 * f4 - v3 * c5, p3 = _2 * c5 + v3 * u4 - h3 * f4, k4 = _2 * f4 + h3 * c5 - d3 * u4, E3 = -h3 * u4 - d3 * c5 - v3 * f4;\n                  return o4[0] = b * _2 + E3 * -h3 + p3 * -v3 - k4 * -d3, o4[1] = p3 * _2 + E3 * -d3 + k4 * -h3 - b * -v3, o4[2] = k4 * _2 + E3 * -v3 + b * -d3 - p3 * -h3, o4;\n                }\n              }, 332: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = z3;\n                var s3 = o4(1755), l3 = o4(6867), u4 = o4(1125), c5 = o4(7842), f4 = o4(1318), h3 = o4(946), d3 = o4(5838), v3 = o4(1278), _2 = o4(3637);\n                function b(O3) {\n                  var V2 = h3(O3);\n                  return [v3(V2, -1 / 0), v3(V2, 1 / 0)];\n                }\n                function p3(O3, V2) {\n                  for (var G2 = new Array(V2.length), Z = 0; Z < V2.length; ++Z) {\n                    var j3 = V2[Z], N2 = O3[j3[0]], H = O3[j3[1]];\n                    G2[Z] = [v3(Math.min(N2[0], H[0]), -1 / 0), v3(Math.min(N2[1], H[1]), -1 / 0), v3(Math.max(N2[0], H[0]), 1 / 0), v3(Math.max(N2[1], H[1]), 1 / 0)];\n                  }\n                  return G2;\n                }\n                function k4(O3) {\n                  for (var V2 = new Array(O3.length), G2 = 0; G2 < O3.length; ++G2) {\n                    var Z = O3[G2];\n                    V2[G2] = [v3(Z[0], -1 / 0), v3(Z[1], -1 / 0), v3(Z[0], 1 / 0), v3(Z[1], 1 / 0)];\n                  }\n                  return V2;\n                }\n                function E3(O3, V2, G2) {\n                  var Z = [];\n                  return l3(G2, function(j3, N2) {\n                    var H = V2[j3], te = V2[N2];\n                    if (!(H[0] === te[0] || H[0] === te[1] || H[1] === te[0] || H[1] === te[1])) {\n                      var oe = O3[H[0]], _e = O3[H[1]], Ee = O3[te[0]], Ce = O3[te[1]];\n                      u4(oe, _e, Ee, Ce) && Z.push([j3, N2]);\n                    }\n                  }), Z;\n                }\n                function S2(O3, V2, G2, Z) {\n                  var j3 = [];\n                  return l3(G2, Z, function(N2, H) {\n                    var te = V2[N2];\n                    if (!(te[0] === H || te[1] === H)) {\n                      var oe = O3[H], _e = O3[te[0]], Ee = O3[te[1]];\n                      u4(_e, Ee, oe, oe) && j3.push([N2, H]);\n                    }\n                  }), j3;\n                }\n                function L3(O3, V2, G2, Z, j3) {\n                  var N2, H, te = O3.map(function(pt) {\n                    return [c5(pt[0]), c5(pt[1])];\n                  });\n                  for (N2 = 0; N2 < G2.length; ++N2) {\n                    var oe = G2[N2];\n                    H = oe[0];\n                    var _e = oe[1], Ee = V2[H], Ce = V2[_e], me = _2(d3(O3[Ee[0]]), d3(O3[Ee[1]]), d3(O3[Ce[0]]), d3(O3[Ce[1]]));\n                    if (me) {\n                      var ie = O3.length;\n                      O3.push([h3(me[0]), h3(me[1])]), te.push(me), Z.push([H, ie], [_e, ie]);\n                    }\n                  }\n                  for (Z.sort(function(pt, Zt) {\n                    if (pt[0] !== Zt[0]) return pt[0] - Zt[0];\n                    var st = te[pt[1]], lt = te[Zt[1]];\n                    return f4(st[0], lt[0]) || f4(st[1], lt[1]);\n                  }), N2 = Z.length - 1; N2 >= 0; --N2) {\n                    var Se = Z[N2];\n                    H = Se[0];\n                    var Le = V2[H], Ae = Le[0], Fe = Le[1], Pe = O3[Ae], ge = O3[Fe];\n                    if ((Pe[0] - ge[0] || Pe[1] - ge[1]) < 0) {\n                      var Re = Ae;\n                      Ae = Fe, Fe = Re;\n                    }\n                    Le[0] = Ae;\n                    var ce = Le[1] = Se[1], Ze;\n                    for (j3 && (Ze = Le[2]); N2 > 0 && Z[N2 - 1][0] === H; ) {\n                      var Se = Z[--N2], ut = Se[1];\n                      j3 ? V2.push([ce, ut, Ze]) : V2.push([ce, ut]), ce = ut;\n                    }\n                    j3 ? V2.push([ce, Fe, Ze]) : V2.push([ce, Fe]);\n                  }\n                  return te;\n                }\n                function x2(O3, V2, G2) {\n                  for (var Z = V2.length, j3 = new s3(Z), N2 = [], H = 0; H < V2.length; ++H) {\n                    var te = V2[H], oe = b(te[0]), _e = b(te[1]);\n                    N2.push([v3(oe[0], -1 / 0), v3(_e[0], -1 / 0), v3(oe[1], 1 / 0), v3(_e[1], 1 / 0)]);\n                  }\n                  l3(N2, function(Se, Le) {\n                    j3.link(Se, Le);\n                  });\n                  for (var Ee = true, Ce = new Array(Z), H = 0; H < Z; ++H) {\n                    var me = j3.find(H);\n                    me !== H && (Ee = false, O3[me] = [Math.min(O3[H][0], O3[me][0]), Math.min(O3[H][1], O3[me][1])]);\n                  }\n                  if (Ee) return null;\n                  for (var ie = 0, H = 0; H < Z; ++H) {\n                    var me = j3.find(H);\n                    me === H ? (Ce[H] = ie, O3[ie++] = O3[H]) : Ce[H] = -1;\n                  }\n                  O3.length = ie;\n                  for (var H = 0; H < Z; ++H) Ce[H] < 0 && (Ce[H] = Ce[j3.find(H)]);\n                  return Ce;\n                }\n                function C3(O3, V2) {\n                  return O3[0] - V2[0] || O3[1] - V2[1];\n                }\n                function M4(O3, V2) {\n                  var G2 = O3[0] - V2[0] || O3[1] - V2[1];\n                  return G2 || (O3[2] < V2[2] ? -1 : O3[2] > V2[2] ? 1 : 0);\n                }\n                function g3(O3, V2, G2) {\n                  if (O3.length !== 0) {\n                    if (V2) for (var Z = 0; Z < O3.length; ++Z) {\n                      var j3 = O3[Z], N2 = V2[j3[0]], H = V2[j3[1]];\n                      j3[0] = Math.min(N2, H), j3[1] = Math.max(N2, H);\n                    }\n                    else for (var Z = 0; Z < O3.length; ++Z) {\n                      var j3 = O3[Z], N2 = j3[0], H = j3[1];\n                      j3[0] = Math.min(N2, H), j3[1] = Math.max(N2, H);\n                    }\n                    G2 ? O3.sort(M4) : O3.sort(C3);\n                    for (var te = 1, Z = 1; Z < O3.length; ++Z) {\n                      var oe = O3[Z - 1], _e = O3[Z];\n                      _e[0] === oe[0] && _e[1] === oe[1] && (!G2 || _e[2] === oe[2]) || (O3[te++] = _e);\n                    }\n                    O3.length = te;\n                  }\n                }\n                function P3(O3, V2, G2) {\n                  var Z = x2(O3, [], k4(O3));\n                  return g3(V2, Z, G2), !!Z;\n                }\n                function T3(O3, V2, G2) {\n                  var Z = p3(O3, V2), j3 = E3(O3, V2, Z), N2 = k4(O3), H = S2(O3, V2, Z, N2), te = L3(O3, V2, j3, H, G2), oe = x2(O3, te, N2);\n                  return g3(V2, oe, G2), oe ? true : j3.length > 0 || H.length > 0;\n                }\n                function z3(O3, V2, G2) {\n                  var Z;\n                  if (G2) {\n                    Z = V2;\n                    for (var j3 = new Array(V2.length), N2 = 0; N2 < V2.length; ++N2) {\n                      var H = V2[N2];\n                      j3[N2] = [H[0], H[1], G2[N2]];\n                    }\n                    V2 = j3;\n                  }\n                  for (var te = P3(O3, V2, !!G2); T3(O3, V2, !!G2); ) te = true;\n                  if (G2 && te) {\n                    Z.length = 0, G2.length = 0;\n                    for (var N2 = 0; N2 < V2.length; ++N2) {\n                      var H = V2[N2];\n                      Z.push([H[0], H[1]]), G2.push(H[2]);\n                    }\n                  }\n                  return te;\n                }\n              }, 351: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(4687);\n                function l3(u4, c5) {\n                  c5 || (c5 = u4, u4 = window);\n                  var f4 = 0, h3 = 0, d3 = 0, v3 = { shift: false, alt: false, control: false, meta: false }, _2 = false;\n                  function b(T3) {\n                    var z3 = false;\n                    return "altKey" in T3 && (z3 = z3 || T3.altKey !== v3.alt, v3.alt = !!T3.altKey), "shiftKey" in T3 && (z3 = z3 || T3.shiftKey !== v3.shift, v3.shift = !!T3.shiftKey), "ctrlKey" in T3 && (z3 = z3 || T3.ctrlKey !== v3.control, v3.control = !!T3.ctrlKey), "metaKey" in T3 && (z3 = z3 || T3.metaKey !== v3.meta, v3.meta = !!T3.metaKey), z3;\n                  }\n                  function p3(T3, z3) {\n                    var O3 = s3.x(z3), V2 = s3.y(z3);\n                    "buttons" in z3 && (T3 = z3.buttons | 0), (T3 !== f4 || O3 !== h3 || V2 !== d3 || b(z3)) && (f4 = T3 | 0, h3 = O3 || 0, d3 = V2 || 0, c5 && c5(f4, h3, d3, v3));\n                  }\n                  function k4(T3) {\n                    p3(0, T3);\n                  }\n                  function E3() {\n                    (f4 || h3 || d3 || v3.shift || v3.alt || v3.meta || v3.control) && (h3 = d3 = 0, f4 = 0, v3.shift = v3.alt = v3.control = v3.meta = false, c5 && c5(0, 0, 0, v3));\n                  }\n                  function S2(T3) {\n                    b(T3) && c5 && c5(f4, h3, d3, v3);\n                  }\n                  function L3(T3) {\n                    s3.buttons(T3) === 0 ? p3(0, T3) : p3(f4, T3);\n                  }\n                  function x2(T3) {\n                    p3(f4 | s3.buttons(T3), T3);\n                  }\n                  function C3(T3) {\n                    p3(f4 & ~s3.buttons(T3), T3);\n                  }\n                  function M4() {\n                    _2 || (_2 = true, u4.addEventListener("mousemove", L3), u4.addEventListener("mousedown", x2), u4.addEventListener("mouseup", C3), u4.addEventListener("mouseleave", k4), u4.addEventListener("mouseenter", k4), u4.addEventListener("mouseout", k4), u4.addEventListener("mouseover", k4), u4.addEventListener("blur", E3), u4.addEventListener("keyup", S2), u4.addEventListener("keydown", S2), u4.addEventListener("keypress", S2), u4 !== window && (window.addEventListener("blur", E3), window.addEventListener("keyup", S2), window.addEventListener("keydown", S2), window.addEventListener("keypress", S2)));\n                  }\n                  function g3() {\n                    _2 && (_2 = false, u4.removeEventListener("mousemove", L3), u4.removeEventListener("mousedown", x2), u4.removeEventListener("mouseup", C3), u4.removeEventListener("mouseleave", k4), u4.removeEventListener("mouseenter", k4), u4.removeEventListener("mouseout", k4), u4.removeEventListener("mouseover", k4), u4.removeEventListener("blur", E3), u4.removeEventListener("keyup", S2), u4.removeEventListener("keydown", S2), u4.removeEventListener("keypress", S2), u4 !== window && (window.removeEventListener("blur", E3), window.removeEventListener("keyup", S2), window.removeEventListener("keydown", S2), window.removeEventListener("keypress", S2)));\n                  }\n                  M4();\n                  var P3 = { element: u4 };\n                  return Object.defineProperties(P3, { enabled: { get: function() {\n                    return _2;\n                  }, set: function(T3) {\n                    T3 ? M4() : g3();\n                  }, enumerable: true }, buttons: { get: function() {\n                    return f4;\n                  }, enumerable: true }, x: { get: function() {\n                    return h3;\n                  }, enumerable: true }, y: { get: function() {\n                    return d3;\n                  }, enumerable: true }, mods: { get: function() {\n                    return v3;\n                  }, enumerable: true } }), P3;\n                }\n              }, 395: function(i3) {\n                function a4(o4, s3, l3) {\n                  return o4 * (1 - l3) + s3 * l3;\n                }\n                i3.exports = a4;\n              }, 446: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(7640), l3 = {};\n                function u4(c5) {\n                  var f4 = c5.order, h3 = c5.dtype, d3 = [f4, h3], v3 = d3.join(":"), _2 = l3[v3];\n                  return _2 || (l3[v3] = _2 = s3(f4, h3)), _2(c5), c5;\n                }\n                i3.exports = u4;\n              }, 483: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = o4[0], l3 = o4[1], u4 = o4[2], c5 = o4[3];\n                  return s3 * s3 + l3 * l3 + u4 * u4 + c5 * c5;\n                }\n              }, 492: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2];\n                  return o4[0] = u4 * l3[0] + c5 * l3[3] + f4 * l3[6], o4[1] = u4 * l3[1] + c5 * l3[4] + f4 * l3[7], o4[2] = u4 * l3[2] + c5 * l3[5] + f4 * l3[8], o4;\n                }\n              }, 501: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = E3;\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(1879).n, c5 = [0, 0, 0], f4 = [0, 0, 0], h3 = [0, 0, 0], d3 = [0, 0, 0], v3 = [1, 1];\n                function _2(S2) {\n                  return S2[0] = S2[1] = S2[2] = 0, S2;\n                }\n                function b(S2, L3) {\n                  return S2[0] = L3[0], S2[1] = L3[1], S2[2] = L3[2], S2;\n                }\n                function p3(S2, L3, x2, C3, M4, g3, P3, T3) {\n                  this.gl = S2, this.vertBuffer = L3, this.vao = x2, this.shader = C3, this.tickCount = M4, this.tickOffset = g3, this.gridCount = P3, this.gridOffset = T3;\n                }\n                var k4 = p3.prototype;\n                k4.bind = function(S2, L3, x2) {\n                  this.shader.bind(), this.shader.uniforms.model = S2, this.shader.uniforms.view = L3, this.shader.uniforms.projection = x2, v3[0] = this.gl.drawingBufferWidth, v3[1] = this.gl.drawingBufferHeight, this.shader.uniforms.screenShape = v3, this.vao.bind();\n                }, k4.unbind = function() {\n                  this.vao.unbind();\n                }, k4.drawAxisLine = function(S2, L3, x2, C3, M4) {\n                  var g3 = _2(f4);\n                  this.shader.uniforms.majorAxis = f4, g3[S2] = L3[1][S2] - L3[0][S2], this.shader.uniforms.minorAxis = g3;\n                  var P3 = b(d3, x2);\n                  P3[S2] += L3[0][S2], this.shader.uniforms.offset = P3, this.shader.uniforms.lineWidth = M4, this.shader.uniforms.color = C3;\n                  var T3 = _2(h3);\n                  T3[(S2 + 2) % 3] = 1, this.shader.uniforms.screenAxis = T3, this.vao.draw(this.gl.TRIANGLES, 6);\n                  var T3 = _2(h3);\n                  T3[(S2 + 1) % 3] = 1, this.shader.uniforms.screenAxis = T3, this.vao.draw(this.gl.TRIANGLES, 6);\n                }, k4.drawAxisTicks = function(S2, L3, x2, C3, M4) {\n                  if (this.tickCount[S2]) {\n                    var g3 = _2(c5);\n                    g3[S2] = 1, this.shader.uniforms.majorAxis = g3, this.shader.uniforms.offset = L3, this.shader.uniforms.minorAxis = x2, this.shader.uniforms.color = C3, this.shader.uniforms.lineWidth = M4;\n                    var P3 = _2(h3);\n                    P3[S2] = 1, this.shader.uniforms.screenAxis = P3, this.vao.draw(this.gl.TRIANGLES, this.tickCount[S2], this.tickOffset[S2]);\n                  }\n                }, k4.drawGrid = function(S2, L3, x2, C3, M4, g3) {\n                  if (this.gridCount[S2]) {\n                    var P3 = _2(f4);\n                    P3[L3] = x2[1][L3] - x2[0][L3], this.shader.uniforms.minorAxis = P3;\n                    var T3 = b(d3, C3);\n                    T3[L3] += x2[0][L3], this.shader.uniforms.offset = T3;\n                    var z3 = _2(c5);\n                    z3[S2] = 1, this.shader.uniforms.majorAxis = z3;\n                    var O3 = _2(h3);\n                    O3[S2] = 1, this.shader.uniforms.screenAxis = O3, this.shader.uniforms.lineWidth = g3, this.shader.uniforms.color = M4, this.vao.draw(this.gl.TRIANGLES, this.gridCount[S2], this.gridOffset[S2]);\n                  }\n                }, k4.drawZero = function(S2, L3, x2, C3, M4, g3) {\n                  var P3 = _2(f4);\n                  this.shader.uniforms.majorAxis = P3, P3[S2] = x2[1][S2] - x2[0][S2], this.shader.uniforms.minorAxis = P3;\n                  var T3 = b(d3, C3);\n                  T3[S2] += x2[0][S2], this.shader.uniforms.offset = T3;\n                  var z3 = _2(h3);\n                  z3[L3] = 1, this.shader.uniforms.screenAxis = z3, this.shader.uniforms.lineWidth = g3, this.shader.uniforms.color = M4, this.vao.draw(this.gl.TRIANGLES, 6);\n                }, k4.dispose = function() {\n                  this.vao.dispose(), this.vertBuffer.dispose(), this.shader.dispose();\n                };\n                function E3(S2, L3, x2) {\n                  var C3 = [], M4 = [0, 0, 0], g3 = [0, 0, 0], P3 = [0, 0, 0], T3 = [0, 0, 0];\n                  C3.push(0, 0, 1, 0, 1, 1, 0, 0, -1, 0, 0, -1, 0, 1, 1, 0, 1, -1);\n                  for (var z3 = 0; z3 < 3; ++z3) {\n                    for (var G2 = C3.length / 3 | 0, O3 = 0; O3 < x2[z3].length; ++O3) {\n                      var V2 = +x2[z3][O3].x;\n                      C3.push(V2, 0, 1, V2, 1, 1, V2, 0, -1, V2, 0, -1, V2, 1, 1, V2, 1, -1);\n                    }\n                    var j3 = C3.length / 3 | 0;\n                    M4[z3] = G2, g3[z3] = j3 - G2;\n                    for (var G2 = C3.length / 3 | 0, Z = 0; Z < x2[z3].length; ++Z) {\n                      var V2 = +x2[z3][Z].x;\n                      C3.push(V2, 0, 1, V2, 1, 1, V2, 0, -1, V2, 0, -1, V2, 1, 1, V2, 1, -1);\n                    }\n                    var j3 = C3.length / 3 | 0;\n                    P3[z3] = G2, T3[z3] = j3 - G2;\n                  }\n                  var N2 = s3(S2, new Float32Array(C3)), H = l3(S2, [{ buffer: N2, type: S2.FLOAT, size: 3, stride: 0, offset: 0 }]), te = u4(S2);\n                  return te.attributes.position.location = 0, new p3(S2, N2, H, te, g3, M4, T3, P3);\n                }\n              }, 544: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5572);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  for (var f4 = u4.length, h3 = new Array(f4), d3 = 0; d3 < f4; ++d3) h3[d3] = s3(u4[d3], c5[d3]);\n                  return h3;\n                }\n              }, 606: function(i3, a4, o4) {\n                var s3 = o4(236);\n                i3.exports = l3;\n                function l3() {\n                  var u4 = s3();\n                  return { get: function(c5, f4) {\n                    var h3 = u4(c5);\n                    return h3.hasOwnProperty("value") ? h3.value : f4;\n                  }, set: function(c5, f4) {\n                    return u4(c5).value = f4, this;\n                  }, has: function(c5) {\n                    return "value" in u4(c5);\n                  }, delete: function(c5) {\n                    return delete u4(c5).value;\n                  } };\n                }\n              }, 614: function(i3, a4, o4) {\n                var s3 = o4(3236), l3 = s3([`precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn\'t (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n//   segment + 0 top vertex\n//   segment + 1 perimeter vertex a+1\n//   segment + 2 perimeter vertex a\n//   segment + 3 center base vertex\n//   segment + 4 perimeter vertex a\n//   segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {\n\n  const float segmentCount = 8.0;\n\n  float index = rawIndex - floor(rawIndex /\n    (segmentCount * 6.0)) *\n    (segmentCount * 6.0);\n\n  float segment = floor(0.001 + index/6.0);\n  float segmentIndex = index - (segment*6.0);\n\n  normal = -normalize(d);\n\n  if (segmentIndex > 2.99 && segmentIndex < 3.01) {\n    return mix(vec3(0.0), -d, coneOffset);\n  }\n\n  float nextAngle = (\n    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||\n    (segmentIndex > 4.99 &&  segmentIndex < 5.01)\n  ) ? 1.0 : 0.0;\n  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n  vec3 v1 = mix(d, vec3(0.0), coneOffset);\n  vec3 v2 = v1 - d;\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d)*0.25;\n  vec3 y = v * sin(angle) * length(d)*0.25;\n  vec3 v3 = v2 + x + y;\n  if (segmentIndex < 3.0) {\n    vec3 tx = u * sin(angle);\n    vec3 ty = v * -cos(angle);\n    vec3 tangent = tx + ty;\n    normal = normalize(cross(v3 - v1, tangent));\n  }\n\n  if (segmentIndex == 0.0) {\n    return mix(d, vec3(0.0), coneOffset);\n  }\n  return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\n\nuniform float vectorScale, coneScale, coneOffset;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 eyePosition, lightPosition;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  // Scale the vector magnitude to stay constant with\n  // model & view changes.\n  vec3 normal;\n  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal);\n  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * conePosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  // vec4 m_position  = model * vec4(conePosition, 1.0);\n  vec4 t_position  = view * conePosition;\n  gl_Position      = projection * t_position;\n\n  f_color          = color;\n  f_data           = conePosition.xyz;\n  f_position       = position.xyz;\n  f_uv             = uv;\n}\n`]), u4 = s3([`#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = f_color * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * opacity;\n}\n`]), c5 = s3([`precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn\'t (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n//   segment + 0 top vertex\n//   segment + 1 perimeter vertex a+1\n//   segment + 2 perimeter vertex a\n//   segment + 3 center base vertex\n//   segment + 4 perimeter vertex a\n//   segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float rawIndex, float coneOffset, out vec3 normal) {\n\n  const float segmentCount = 8.0;\n\n  float index = rawIndex - floor(rawIndex /\n    (segmentCount * 6.0)) *\n    (segmentCount * 6.0);\n\n  float segment = floor(0.001 + index/6.0);\n  float segmentIndex = index - (segment*6.0);\n\n  normal = -normalize(d);\n\n  if (segmentIndex > 2.99 && segmentIndex < 3.01) {\n    return mix(vec3(0.0), -d, coneOffset);\n  }\n\n  float nextAngle = (\n    (segmentIndex > 0.99 &&  segmentIndex < 1.01) ||\n    (segmentIndex > 4.99 &&  segmentIndex < 5.01)\n  ) ? 1.0 : 0.0;\n  float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n  vec3 v1 = mix(d, vec3(0.0), coneOffset);\n  vec3 v2 = v1 - d;\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d)*0.25;\n  vec3 y = v * sin(angle) * length(d)*0.25;\n  vec3 v3 = v2 + x + y;\n  if (segmentIndex < 3.0) {\n    vec3 tx = u * sin(angle);\n    vec3 ty = v * -cos(angle);\n    vec3 tangent = tx + ty;\n    normal = normalize(cross(v3 - v1, tangent));\n  }\n\n  if (segmentIndex == 0.0) {\n    return mix(d, vec3(0.0), coneOffset);\n  }\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform float vectorScale, coneScale, coneOffset;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  vec3 normal;\n  vec3 XYZ = getConePosition(mat3(model) * ((vectorScale * coneScale) * vector.xyz), position.w, coneOffset, normal);\n  vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n  gl_Position = projection * (view * conePosition);\n  f_id        = id;\n  f_position  = position.xyz;\n}\n`]), f4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}`]);\n                a4.meshShader = { vertex: l3, fragment: u4, attributes: [{ name: "position", type: "vec4" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "vector", type: "vec3" }] }, a4.pickShader = { vertex: c5, fragment: f4, attributes: [{ name: "position", type: "vec4" }, { name: "id", type: "vec4" }, { name: "vector", type: "vec3" }] };\n              }, 620: function(i3) {\n                i3.exports = ["precision", "highp", "mediump", "lowp", "attribute", "const", "uniform", "varying", "break", "continue", "do", "for", "while", "if", "else", "in", "out", "inout", "float", "int", "uint", "void", "bool", "true", "false", "discard", "return", "mat2", "mat3", "mat4", "vec2", "vec3", "vec4", "ivec2", "ivec3", "ivec4", "bvec2", "bvec3", "bvec4", "sampler1D", "sampler2D", "sampler3D", "samplerCube", "sampler1DShadow", "sampler2DShadow", "struct", "asm", "class", "union", "enum", "typedef", "template", "this", "packed", "goto", "switch", "default", "inline", "noinline", "volatile", "public", "static", "extern", "external", "interface", "long", "short", "double", "half", "fixed", "unsigned", "input", "output", "hvec2", "hvec3", "hvec4", "dvec2", "dvec3", "dvec4", "fvec2", "fvec3", "fvec4", "sampler2DRect", "sampler3DRect", "sampler2DRectShadow", "sizeof", "cast", "namespace", "using"];\n              }, 665: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3202);\n                i3.exports = f4;\n                var l3 = 96;\n                function u4(h3, d3) {\n                  var v3 = s3(getComputedStyle(h3).getPropertyValue(d3));\n                  return v3[0] * f4(v3[1], h3);\n                }\n                function c5(h3, d3) {\n                  var v3 = document.createElement("div");\n                  v3.style["font-size"] = "128" + h3, d3.appendChild(v3);\n                  var _2 = u4(v3, "font-size") / 128;\n                  return d3.removeChild(v3), _2;\n                }\n                function f4(h3, d3) {\n                  switch (d3 = d3 || document.body, h3 = (h3 || "px").trim().toLowerCase(), (d3 === window || d3 === document) && (d3 = document.body), h3) {\n                    case "%":\n                      return d3.clientHeight / 100;\n                    case "ch":\n                    case "ex":\n                      return c5(h3, d3);\n                    case "em":\n                      return u4(d3, "font-size");\n                    case "rem":\n                      return u4(document.body, "font-size");\n                    case "vw":\n                      return window.innerWidth / 100;\n                    case "vh":\n                      return window.innerHeight / 100;\n                    case "vmin":\n                      return Math.min(window.innerWidth, window.innerHeight) / 100;\n                    case "vmax":\n                      return Math.max(window.innerWidth, window.innerHeight) / 100;\n                    case "in":\n                      return l3;\n                    case "cm":\n                      return l3 / 2.54;\n                    case "mm":\n                      return l3 / 25.4;\n                    case "pt":\n                      return l3 / 72;\n                    case "pc":\n                      return l3 / 6;\n                  }\n                  return 1;\n                }\n              }, 727: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2962), l3 = 6;\n                function u4(S2) {\n                  var L3 = S2 === 2 ? h3 : S2 === 3 ? d3 : S2 === 4 ? v3 : S2 === 5 ? _2 : b;\n                  return S2 < 6 ? L3(s3[S2]) : L3(s3);\n                }\n                function c5() {\n                  return [[0]];\n                }\n                function f4(S2, L3) {\n                  return [[L3[0]], [S2[0][0]]];\n                }\n                function h3(S2) {\n                  return function(x2, C3) {\n                    return [S2([[+C3[0], +x2[0][1]], [+C3[1], +x2[1][1]]]), S2([[+x2[0][0], +C3[0]], [+x2[1][0], +C3[1]]]), S2(x2)];\n                  };\n                }\n                function d3(S2) {\n                  return function(x2, C3) {\n                    return [S2([[+C3[0], +x2[0][1], +x2[0][2]], [+C3[1], +x2[1][1], +x2[1][2]], [+C3[2], +x2[2][1], +x2[2][2]]]), S2([[+x2[0][0], +C3[0], +x2[0][2]], [+x2[1][0], +C3[1], +x2[1][2]], [+x2[2][0], +C3[2], +x2[2][2]]]), S2([[+x2[0][0], +x2[0][1], +C3[0]], [+x2[1][0], +x2[1][1], +C3[1]], [+x2[2][0], +x2[2][1], +C3[2]]]), S2(x2)];\n                  };\n                }\n                function v3(S2) {\n                  return function(x2, C3) {\n                    return [S2([[+C3[0], +x2[0][1], +x2[0][2], +x2[0][3]], [+C3[1], +x2[1][1], +x2[1][2], +x2[1][3]], [+C3[2], +x2[2][1], +x2[2][2], +x2[2][3]], [+C3[3], +x2[3][1], +x2[3][2], +x2[3][3]]]), S2([[+x2[0][0], +C3[0], +x2[0][2], +x2[0][3]], [+x2[1][0], +C3[1], +x2[1][2], +x2[1][3]], [+x2[2][0], +C3[2], +x2[2][2], +x2[2][3]], [+x2[3][0], +C3[3], +x2[3][2], +x2[3][3]]]), S2([[+x2[0][0], +x2[0][1], +C3[0], +x2[0][3]], [+x2[1][0], +x2[1][1], +C3[1], +x2[1][3]], [+x2[2][0], +x2[2][1], +C3[2], +x2[2][3]], [+x2[3][0], +x2[3][1], +C3[3], +x2[3][3]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +C3[0]], [+x2[1][0], +x2[1][1], +x2[1][2], +C3[1]], [+x2[2][0], +x2[2][1], +x2[2][2], +C3[2]], [+x2[3][0], +x2[3][1], +x2[3][2], +C3[3]]]), S2(x2)];\n                  };\n                }\n                function _2(S2) {\n                  return function(x2, C3) {\n                    return [S2([[+C3[0], +x2[0][1], +x2[0][2], +x2[0][3], +x2[0][4]], [+C3[1], +x2[1][1], +x2[1][2], +x2[1][3], +x2[1][4]], [+C3[2], +x2[2][1], +x2[2][2], +x2[2][3], +x2[2][4]], [+C3[3], +x2[3][1], +x2[3][2], +x2[3][3], +x2[3][4]], [+C3[4], +x2[4][1], +x2[4][2], +x2[4][3], +x2[4][4]]]), S2([[+x2[0][0], +C3[0], +x2[0][2], +x2[0][3], +x2[0][4]], [+x2[1][0], +C3[1], +x2[1][2], +x2[1][3], +x2[1][4]], [+x2[2][0], +C3[2], +x2[2][2], +x2[2][3], +x2[2][4]], [+x2[3][0], +C3[3], +x2[3][2], +x2[3][3], +x2[3][4]], [+x2[4][0], +C3[4], +x2[4][2], +x2[4][3], +x2[4][4]]]), S2([[+x2[0][0], +x2[0][1], +C3[0], +x2[0][3], +x2[0][4]], [+x2[1][0], +x2[1][1], +C3[1], +x2[1][3], +x2[1][4]], [+x2[2][0], +x2[2][1], +C3[2], +x2[2][3], +x2[2][4]], [+x2[3][0], +x2[3][1], +C3[3], +x2[3][3], +x2[3][4]], [+x2[4][0], +x2[4][1], +C3[4], +x2[4][3], +x2[4][4]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +C3[0], +x2[0][4]], [+x2[1][0], +x2[1][1], +x2[1][2], +C3[1], +x2[1][4]], [+x2[2][0], +x2[2][1], +x2[2][2], +C3[2], +x2[2][4]], [+x2[3][0], +x2[3][1], +x2[3][2], +C3[3], +x2[3][4]], [+x2[4][0], +x2[4][1], +x2[4][2], +C3[4], +x2[4][4]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +x2[0][3], +C3[0]], [+x2[1][0], +x2[1][1], +x2[1][2], +x2[1][3], +C3[1]], [+x2[2][0], +x2[2][1], +x2[2][2], +x2[2][3], +C3[2]], [+x2[3][0], +x2[3][1], +x2[3][2], +x2[3][3], +C3[3]], [+x2[4][0], +x2[4][1], +x2[4][2], +x2[4][3], +C3[4]]]), S2(x2)];\n                  };\n                }\n                function b(S2) {\n                  return function(x2, C3) {\n                    return [S2([[+C3[0], +x2[0][1], +x2[0][2], +x2[0][3], +x2[0][4], +x2[0][5]], [+C3[1], +x2[1][1], +x2[1][2], +x2[1][3], +x2[1][4], +x2[1][5]], [+C3[2], +x2[2][1], +x2[2][2], +x2[2][3], +x2[2][4], +x2[2][5]], [+C3[3], +x2[3][1], +x2[3][2], +x2[3][3], +x2[3][4], +x2[3][5]], [+C3[4], +x2[4][1], +x2[4][2], +x2[4][3], +x2[4][4], +x2[4][5]], [+C3[5], +x2[5][1], +x2[5][2], +x2[5][3], +x2[5][4], +x2[5][5]]]), S2([[+x2[0][0], +C3[0], +x2[0][2], +x2[0][3], +x2[0][4], +x2[0][5]], [+x2[1][0], +C3[1], +x2[1][2], +x2[1][3], +x2[1][4], +x2[1][5]], [+x2[2][0], +C3[2], +x2[2][2], +x2[2][3], +x2[2][4], +x2[2][5]], [+x2[3][0], +C3[3], +x2[3][2], +x2[3][3], +x2[3][4], +x2[3][5]], [+x2[4][0], +C3[4], +x2[4][2], +x2[4][3], +x2[4][4], +x2[4][5]], [+x2[5][0], +C3[5], +x2[5][2], +x2[5][3], +x2[5][4], +x2[5][5]]]), S2([[+x2[0][0], +x2[0][1], +C3[0], +x2[0][3], +x2[0][4], +x2[0][5]], [+x2[1][0], +x2[1][1], +C3[1], +x2[1][3], +x2[1][4], +x2[1][5]], [+x2[2][0], +x2[2][1], +C3[2], +x2[2][3], +x2[2][4], +x2[2][5]], [+x2[3][0], +x2[3][1], +C3[3], +x2[3][3], +x2[3][4], +x2[3][5]], [+x2[4][0], +x2[4][1], +C3[4], +x2[4][3], +x2[4][4], +x2[4][5]], [+x2[5][0], +x2[5][1], +C3[5], +x2[5][3], +x2[5][4], +x2[5][5]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +C3[0], +x2[0][4], +x2[0][5]], [+x2[1][0], +x2[1][1], +x2[1][2], +C3[1], +x2[1][4], +x2[1][5]], [+x2[2][0], +x2[2][1], +x2[2][2], +C3[2], +x2[2][4], +x2[2][5]], [+x2[3][0], +x2[3][1], +x2[3][2], +C3[3], +x2[3][4], +x2[3][5]], [+x2[4][0], +x2[4][1], +x2[4][2], +C3[4], +x2[4][4], +x2[4][5]], [+x2[5][0], +x2[5][1], +x2[5][2], +C3[5], +x2[5][4], +x2[5][5]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +x2[0][3], +C3[0], +x2[0][5]], [+x2[1][0], +x2[1][1], +x2[1][2], +x2[1][3], +C3[1], +x2[1][5]], [+x2[2][0], +x2[2][1], +x2[2][2], +x2[2][3], +C3[2], +x2[2][5]], [+x2[3][0], +x2[3][1], +x2[3][2], +x2[3][3], +C3[3], +x2[3][5]], [+x2[4][0], +x2[4][1], +x2[4][2], +x2[4][3], +C3[4], +x2[4][5]], [+x2[5][0], +x2[5][1], +x2[5][2], +x2[5][3], +C3[5], +x2[5][5]]]), S2([[+x2[0][0], +x2[0][1], +x2[0][2], +x2[0][3], +x2[0][4], +C3[0]], [+x2[1][0], +x2[1][1], +x2[1][2], +x2[1][3], +x2[1][4], +C3[1]], [+x2[2][0], +x2[2][1], +x2[2][2], +x2[2][3], +x2[2][4], +C3[2]], [+x2[3][0], +x2[3][1], +x2[3][2], +x2[3][3], +x2[3][4], +C3[3]], [+x2[4][0], +x2[4][1], +x2[4][2], +x2[4][3], +x2[4][4], +C3[4]], [+x2[5][0], +x2[5][1], +x2[5][2], +x2[5][3], +x2[5][4], +C3[5]]]), S2(x2)];\n                  };\n                }\n                var p3 = [c5, f4];\n                function k4(S2, L3, x2, C3, M4, g3, P3, T3) {\n                  return function(O3, V2) {\n                    switch (O3.length) {\n                      case 0:\n                        return S2(O3, V2);\n                      case 1:\n                        return L3(O3, V2);\n                      case 2:\n                        return x2(O3, V2);\n                      case 3:\n                        return C3(O3, V2);\n                      case 4:\n                        return M4(O3, V2);\n                      case 5:\n                        return g3(O3, V2);\n                    }\n                    var G2 = P3[O3.length];\n                    return G2 || (G2 = P3[O3.length] = T3(O3.length)), G2(O3, V2);\n                  };\n                }\n                function E3() {\n                  for (; p3.length < l3; ) p3.push(u4(p3.length));\n                  i3.exports = k4.apply(void 0, p3.concat([p3, u4]));\n                  for (var S2 = 0; S2 < l3; ++S2) i3.exports[S2] = p3[S2];\n                }\n                E3();\n              }, 737: function(i3) {\n                i3.exports = { 0: "NONE", 1: "ONE", 2: "LINE_LOOP", 3: "LINE_STRIP", 4: "TRIANGLES", 5: "TRIANGLE_STRIP", 6: "TRIANGLE_FAN", 256: "DEPTH_BUFFER_BIT", 512: "NEVER", 513: "LESS", 514: "EQUAL", 515: "LEQUAL", 516: "GREATER", 517: "NOTEQUAL", 518: "GEQUAL", 519: "ALWAYS", 768: "SRC_COLOR", 769: "ONE_MINUS_SRC_COLOR", 770: "SRC_ALPHA", 771: "ONE_MINUS_SRC_ALPHA", 772: "DST_ALPHA", 773: "ONE_MINUS_DST_ALPHA", 774: "DST_COLOR", 775: "ONE_MINUS_DST_COLOR", 776: "SRC_ALPHA_SATURATE", 1024: "STENCIL_BUFFER_BIT", 1028: "FRONT", 1029: "BACK", 1032: "FRONT_AND_BACK", 1280: "INVALID_ENUM", 1281: "INVALID_VALUE", 1282: "INVALID_OPERATION", 1285: "OUT_OF_MEMORY", 1286: "INVALID_FRAMEBUFFER_OPERATION", 2304: "CW", 2305: "CCW", 2849: "LINE_WIDTH", 2884: "CULL_FACE", 2885: "CULL_FACE_MODE", 2886: "FRONT_FACE", 2928: "DEPTH_RANGE", 2929: "DEPTH_TEST", 2930: "DEPTH_WRITEMASK", 2931: "DEPTH_CLEAR_VALUE", 2932: "DEPTH_FUNC", 2960: "STENCIL_TEST", 2961: "STENCIL_CLEAR_VALUE", 2962: "STENCIL_FUNC", 2963: "STENCIL_VALUE_MASK", 2964: "STENCIL_FAIL", 2965: "STENCIL_PASS_DEPTH_FAIL", 2966: "STENCIL_PASS_DEPTH_PASS", 2967: "STENCIL_REF", 2968: "STENCIL_WRITEMASK", 2978: "VIEWPORT", 3024: "DITHER", 3042: "BLEND", 3088: "SCISSOR_BOX", 3089: "SCISSOR_TEST", 3106: "COLOR_CLEAR_VALUE", 3107: "COLOR_WRITEMASK", 3317: "UNPACK_ALIGNMENT", 3333: "PACK_ALIGNMENT", 3379: "MAX_TEXTURE_SIZE", 3386: "MAX_VIEWPORT_DIMS", 3408: "SUBPIXEL_BITS", 3410: "RED_BITS", 3411: "GREEN_BITS", 3412: "BLUE_BITS", 3413: "ALPHA_BITS", 3414: "DEPTH_BITS", 3415: "STENCIL_BITS", 3553: "TEXTURE_2D", 4352: "DONT_CARE", 4353: "FASTEST", 4354: "NICEST", 5120: "BYTE", 5121: "UNSIGNED_BYTE", 5122: "SHORT", 5123: "UNSIGNED_SHORT", 5124: "INT", 5125: "UNSIGNED_INT", 5126: "FLOAT", 5386: "INVERT", 5890: "TEXTURE", 6401: "STENCIL_INDEX", 6402: "DEPTH_COMPONENT", 6406: "ALPHA", 6407: "RGB", 6408: "RGBA", 6409: "LUMINANCE", 6410: "LUMINANCE_ALPHA", 7680: "KEEP", 7681: "REPLACE", 7682: "INCR", 7683: "DECR", 7936: "VENDOR", 7937: "RENDERER", 7938: "VERSION", 9728: "NEAREST", 9729: "LINEAR", 9984: "NEAREST_MIPMAP_NEAREST", 9985: "LINEAR_MIPMAP_NEAREST", 9986: "NEAREST_MIPMAP_LINEAR", 9987: "LINEAR_MIPMAP_LINEAR", 10240: "TEXTURE_MAG_FILTER", 10241: "TEXTURE_MIN_FILTER", 10242: "TEXTURE_WRAP_S", 10243: "TEXTURE_WRAP_T", 10497: "REPEAT", 10752: "POLYGON_OFFSET_UNITS", 16384: "COLOR_BUFFER_BIT", 32769: "CONSTANT_COLOR", 32770: "ONE_MINUS_CONSTANT_COLOR", 32771: "CONSTANT_ALPHA", 32772: "ONE_MINUS_CONSTANT_ALPHA", 32773: "BLEND_COLOR", 32774: "FUNC_ADD", 32777: "BLEND_EQUATION_RGB", 32778: "FUNC_SUBTRACT", 32779: "FUNC_REVERSE_SUBTRACT", 32819: "UNSIGNED_SHORT_4_4_4_4", 32820: "UNSIGNED_SHORT_5_5_5_1", 32823: "POLYGON_OFFSET_FILL", 32824: "POLYGON_OFFSET_FACTOR", 32854: "RGBA4", 32855: "RGB5_A1", 32873: "TEXTURE_BINDING_2D", 32926: "SAMPLE_ALPHA_TO_COVERAGE", 32928: "SAMPLE_COVERAGE", 32936: "SAMPLE_BUFFERS", 32937: "SAMPLES", 32938: "SAMPLE_COVERAGE_VALUE", 32939: "SAMPLE_COVERAGE_INVERT", 32968: "BLEND_DST_RGB", 32969: "BLEND_SRC_RGB", 32970: "BLEND_DST_ALPHA", 32971: "BLEND_SRC_ALPHA", 33071: "CLAMP_TO_EDGE", 33170: "GENERATE_MIPMAP_HINT", 33189: "DEPTH_COMPONENT16", 33306: "DEPTH_STENCIL_ATTACHMENT", 33635: "UNSIGNED_SHORT_5_6_5", 33648: "MIRRORED_REPEAT", 33901: "ALIASED_POINT_SIZE_RANGE", 33902: "ALIASED_LINE_WIDTH_RANGE", 33984: "TEXTURE0", 33985: "TEXTURE1", 33986: "TEXTURE2", 33987: "TEXTURE3", 33988: "TEXTURE4", 33989: "TEXTURE5", 33990: "TEXTURE6", 33991: "TEXTURE7", 33992: "TEXTURE8", 33993: "TEXTURE9", 33994: "TEXTURE10", 33995: "TEXTURE11", 33996: "TEXTURE12", 33997: "TEXTURE13", 33998: "TEXTURE14", 33999: "TEXTURE15", 34e3: "TEXTURE16", 34001: "TEXTURE17", 34002: "TEXTURE18", 34003: "TEXTURE19", 34004: "TEXTURE20", 34005: "TEXTURE21", 34006: "TEXTURE22", 34007: "TEXTURE23", 34008: "TEXTURE24", 34009: "TEXTURE25", 34010: "TEXTURE26", 34011: "TEXTURE27", 34012: "TEXTURE28", 34013: "TEXTURE29", 34014: "TEXTURE30", 34015: "TEXTURE31", 34016: "ACTIVE_TEXTURE", 34024: "MAX_RENDERBUFFER_SIZE", 34041: "DEPTH_STENCIL", 34055: "INCR_WRAP", 34056: "DECR_WRAP", 34067: "TEXTURE_CUBE_MAP", 34068: "TEXTURE_BINDING_CUBE_MAP", 34069: "TEXTURE_CUBE_MAP_POSITIVE_X", 34070: "TEXTURE_CUBE_MAP_NEGATIVE_X", 34071: "TEXTURE_CUBE_MAP_POSITIVE_Y", 34072: "TEXTURE_CUBE_MAP_NEGATIVE_Y", 34073: "TEXTURE_CUBE_MAP_POSITIVE_Z", 34074: "TEXTURE_CUBE_MAP_NEGATIVE_Z", 34076: "MAX_CUBE_MAP_TEXTURE_SIZE", 34338: "VERTEX_ATTRIB_ARRAY_ENABLED", 34339: "VERTEX_ATTRIB_ARRAY_SIZE", 34340: "VERTEX_ATTRIB_ARRAY_STRIDE", 34341: "VERTEX_ATTRIB_ARRAY_TYPE", 34342: "CURRENT_VERTEX_ATTRIB", 34373: "VERTEX_ATTRIB_ARRAY_POINTER", 34466: "NUM_COMPRESSED_TEXTURE_FORMATS", 34467: "COMPRESSED_TEXTURE_FORMATS", 34660: "BUFFER_SIZE", 34661: "BUFFER_USAGE", 34816: "STENCIL_BACK_FUNC", 34817: "STENCIL_BACK_FAIL", 34818: "STENCIL_BACK_PASS_DEPTH_FAIL", 34819: "STENCIL_BACK_PASS_DEPTH_PASS", 34877: "BLEND_EQUATION_ALPHA", 34921: "MAX_VERTEX_ATTRIBS", 34922: "VERTEX_ATTRIB_ARRAY_NORMALIZED", 34930: "MAX_TEXTURE_IMAGE_UNITS", 34962: "ARRAY_BUFFER", 34963: "ELEMENT_ARRAY_BUFFER", 34964: "ARRAY_BUFFER_BINDING", 34965: "ELEMENT_ARRAY_BUFFER_BINDING", 34975: "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING", 35040: "STREAM_DRAW", 35044: "STATIC_DRAW", 35048: "DYNAMIC_DRAW", 35632: "FRAGMENT_SHADER", 35633: "VERTEX_SHADER", 35660: "MAX_VERTEX_TEXTURE_IMAGE_UNITS", 35661: "MAX_COMBINED_TEXTURE_IMAGE_UNITS", 35663: "SHADER_TYPE", 35664: "FLOAT_VEC2", 35665: "FLOAT_VEC3", 35666: "FLOAT_VEC4", 35667: "INT_VEC2", 35668: "INT_VEC3", 35669: "INT_VEC4", 35670: "BOOL", 35671: "BOOL_VEC2", 35672: "BOOL_VEC3", 35673: "BOOL_VEC4", 35674: "FLOAT_MAT2", 35675: "FLOAT_MAT3", 35676: "FLOAT_MAT4", 35678: "SAMPLER_2D", 35680: "SAMPLER_CUBE", 35712: "DELETE_STATUS", 35713: "COMPILE_STATUS", 35714: "LINK_STATUS", 35715: "VALIDATE_STATUS", 35716: "INFO_LOG_LENGTH", 35717: "ATTACHED_SHADERS", 35718: "ACTIVE_UNIFORMS", 35719: "ACTIVE_UNIFORM_MAX_LENGTH", 35720: "SHADER_SOURCE_LENGTH", 35721: "ACTIVE_ATTRIBUTES", 35722: "ACTIVE_ATTRIBUTE_MAX_LENGTH", 35724: "SHADING_LANGUAGE_VERSION", 35725: "CURRENT_PROGRAM", 36003: "STENCIL_BACK_REF", 36004: "STENCIL_BACK_VALUE_MASK", 36005: "STENCIL_BACK_WRITEMASK", 36006: "FRAMEBUFFER_BINDING", 36007: "RENDERBUFFER_BINDING", 36048: "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE", 36049: "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME", 36050: "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL", 36051: "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE", 36053: "FRAMEBUFFER_COMPLETE", 36054: "FRAMEBUFFER_INCOMPLETE_ATTACHMENT", 36055: "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT", 36057: "FRAMEBUFFER_INCOMPLETE_DIMENSIONS", 36061: "FRAMEBUFFER_UNSUPPORTED", 36064: "COLOR_ATTACHMENT0", 36096: "DEPTH_ATTACHMENT", 36128: "STENCIL_ATTACHMENT", 36160: "FRAMEBUFFER", 36161: "RENDERBUFFER", 36162: "RENDERBUFFER_WIDTH", 36163: "RENDERBUFFER_HEIGHT", 36164: "RENDERBUFFER_INTERNAL_FORMAT", 36168: "STENCIL_INDEX8", 36176: "RENDERBUFFER_RED_SIZE", 36177: "RENDERBUFFER_GREEN_SIZE", 36178: "RENDERBUFFER_BLUE_SIZE", 36179: "RENDERBUFFER_ALPHA_SIZE", 36180: "RENDERBUFFER_DEPTH_SIZE", 36181: "RENDERBUFFER_STENCIL_SIZE", 36194: "RGB565", 36336: "LOW_FLOAT", 36337: "MEDIUM_FLOAT", 36338: "HIGH_FLOAT", 36339: "LOW_INT", 36340: "MEDIUM_INT", 36341: "HIGH_INT", 36346: "SHADER_COMPILER", 36347: "MAX_VERTEX_UNIFORM_VECTORS", 36348: "MAX_VARYING_VECTORS", 36349: "MAX_FRAGMENT_UNIFORM_VECTORS", 37440: "UNPACK_FLIP_Y_WEBGL", 37441: "UNPACK_PREMULTIPLY_ALPHA_WEBGL", 37442: "CONTEXT_LOST_WEBGL", 37443: "UNPACK_COLORSPACE_CONVERSION_WEBGL", 37444: "BROWSER_DEFAULT_WEBGL" };\n              }, 781: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(3349);\n                function l3(u4, c5) {\n                  var f4 = [];\n                  return c5 = +c5 || 0, s3(u4.hi(u4.shape[0] - 1), f4, c5), f4;\n                }\n              }, 783: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = s3[0], f4 = s3[1], h3 = s3[2], d3 = s3[3], v3 = l3[0], _2 = l3[1], b = l3[2], p3 = l3[3], k4, E3, S2, L3, x2;\n                  return E3 = c5 * v3 + f4 * _2 + h3 * b + d3 * p3, E3 < 0 && (E3 = -E3, v3 = -v3, _2 = -_2, b = -b, p3 = -p3), 1 - E3 > 1e-6 ? (k4 = Math.acos(E3), S2 = Math.sin(k4), L3 = Math.sin((1 - u4) * k4) / S2, x2 = Math.sin(u4 * k4) / S2) : (L3 = 1 - u4, x2 = u4), o4[0] = L3 * c5 + x2 * v3, o4[1] = L3 * f4 + x2 * _2, o4[2] = L3 * h3 + x2 * b, o4[3] = L3 * d3 + x2 * p3, o4;\n                }\n              }, 799: function(i3, a4, o4) {\n                var s3 = o4(3236), l3 = o4(9405), u4 = s3([`precision mediump float;\n#define GLSLIFY 1\nattribute vec2 position;\nvarying vec2 uv;\nvoid main() {\n  uv = position;\n  gl_Position = vec4(position, 0, 1);\n}`]), c5 = s3([`precision mediump float;\n#define GLSLIFY 1\n\nuniform sampler2D accumBuffer;\nvarying vec2 uv;\n\nvoid main() {\n  vec4 accum = texture2D(accumBuffer, 0.5 * (uv + 1.0));\n  gl_FragColor = min(vec4(1,1,1,1), accum);\n}`]);\n                i3.exports = function(f4) {\n                  return l3(f4, u4, c5, null, [{ name: "position", type: "vec2" }]);\n                };\n              }, 811: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = 1 / s3[0], o4[1] = 1 / s3[1], o4[2] = 1 / s3[2], o4;\n                }\n              }, 840: function(i3, a4, o4) {\n                var s3 = o4(3236), l3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, normal;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model\n           , view\n           , projection\n           , inverseModel;\nuniform vec3 eyePosition\n           , lightPosition;\n\nvarying vec3 f_normal\n           , f_lightDirection\n           , f_eyeDirection\n           , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvec4 project(vec3 p) {\n  return projection * (view * (model * vec4(p, 1.0)));\n}\n\nvoid main() {\n  gl_Position      = project(position);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * vec4(position , 1.0);\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal  = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  f_color          = color;\n  f_data           = position;\n  f_uv             = uv;\n}\n`]), u4 = s3([`#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\n//#pragma glslify: beckmann = require(glsl-specular-beckmann) // used in gl-surface3d\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n            , fresnel\n            , kambient\n            , kdiffuse\n            , kspecular;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n           , f_lightDirection\n           , f_eyeDirection\n           , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (f_color.a == 0.0 ||\n    outOfRange(clipBounds[0], clipBounds[1], f_data)\n  ) discard;\n\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  //float specular = max(0.0, beckmann(L, V, N, roughness)); // used in gl-surface3d\n\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = vec4(f_color.rgb, 1.0) * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * f_color.a;\n}\n`]), c5 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\n\nuniform mat4 model, view, projection;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  f_color = color;\n  f_data  = position;\n  f_uv    = uv;\n}`]), f4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec3 f_data;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_data)) discard;\n\n  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}`]), h3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 uv;\nattribute float pointSize;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0.0, 0.0 ,0.0 ,0.0);\n  } else {\n    gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  }\n  gl_PointSize = pointSize;\n  f_color = color;\n  f_uv = uv;\n}`]), d3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nuniform sampler2D texture;\nuniform float opacity;\n\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  vec2 pointR = gl_PointCoord.xy - vec2(0.5, 0.5);\n  if(dot(pointR, pointR) > 0.25) {\n    discard;\n  }\n  gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}`]), v3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n  f_id        = id;\n  f_position  = position;\n}`]), _2 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}`]), b = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3  position;\nattribute float pointSize;\nattribute vec4  id;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n  } else {\n    gl_Position  = projection * (view * (model * vec4(position, 1.0)));\n    gl_PointSize = pointSize;\n  }\n  f_id         = id;\n  f_position   = position;\n}`]), p3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\n\nvoid main() {\n  gl_Position = projection * (view * (model * vec4(position, 1.0)));\n}`]), k4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nuniform vec3 contourColor;\n\nvoid main() {\n  gl_FragColor = vec4(contourColor, 1.0);\n}\n`]);\n                a4.meshShader = { vertex: l3, fragment: u4, attributes: [{ name: "position", type: "vec3" }, { name: "normal", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }] }, a4.wireShader = { vertex: c5, fragment: f4, attributes: [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }] }, a4.pointShader = { vertex: h3, fragment: d3, attributes: [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "pointSize", type: "float" }] }, a4.pickShader = { vertex: v3, fragment: _2, attributes: [{ name: "position", type: "vec3" }, { name: "id", type: "vec4" }] }, a4.pointPickShader = { vertex: b, fragment: _2, attributes: [{ name: "position", type: "vec3" }, { name: "pointSize", type: "float" }, { name: "id", type: "vec4" }] }, a4.contourShader = { vertex: p3, fragment: k4, attributes: [{ name: "position", type: "vec3" }] };\n              }, 855: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = { init: E3, sweepBipartite: x2, sweepComplete: C3, scanBipartite: M4, scanComplete: g3 };\n                var s3 = o4(1888), l3 = o4(8828), u4 = o4(4192), c5 = 1 << 28, f4 = 1024, h3 = s3.mallocInt32(f4), d3 = s3.mallocInt32(f4), v3 = s3.mallocInt32(f4), _2 = s3.mallocInt32(f4), b = s3.mallocInt32(f4), p3 = s3.mallocInt32(f4), k4 = s3.mallocDouble(f4 * 8);\n                function E3(P3) {\n                  var T3 = l3.nextPow2(P3);\n                  h3.length < T3 && (s3.free(h3), h3 = s3.mallocInt32(T3)), d3.length < T3 && (s3.free(d3), d3 = s3.mallocInt32(T3)), v3.length < T3 && (s3.free(v3), v3 = s3.mallocInt32(T3)), _2.length < T3 && (s3.free(_2), _2 = s3.mallocInt32(T3)), b.length < T3 && (s3.free(b), b = s3.mallocInt32(T3)), p3.length < T3 && (s3.free(p3), p3 = s3.mallocInt32(T3));\n                  var z3 = 8 * T3;\n                  k4.length < z3 && (s3.free(k4), k4 = s3.mallocDouble(z3));\n                }\n                function S2(P3, T3, z3, O3) {\n                  var V2 = T3[O3], G2 = P3[z3 - 1];\n                  P3[V2] = G2, T3[G2] = V2;\n                }\n                function L3(P3, T3, z3, O3) {\n                  P3[z3] = O3, T3[O3] = z3;\n                }\n                function x2(P3, T3, z3, O3, V2, G2, Z, j3, N2, H) {\n                  for (var te = 0, oe = 2 * P3, _e = P3 - 1, Ee = oe - 1, Ce = z3; Ce < O3; ++Ce) {\n                    var me = G2[Ce], ie = oe * Ce;\n                    k4[te++] = V2[ie + _e], k4[te++] = -(me + 1), k4[te++] = V2[ie + Ee], k4[te++] = me;\n                  }\n                  for (var Ce = Z; Ce < j3; ++Ce) {\n                    var me = H[Ce] + c5, Se = oe * Ce;\n                    k4[te++] = N2[Se + _e], k4[te++] = -me, k4[te++] = N2[Se + Ee], k4[te++] = me;\n                  }\n                  var Le = te >>> 1;\n                  u4(k4, Le);\n                  for (var Ae = 0, Fe = 0, Ce = 0; Ce < Le; ++Ce) {\n                    var Pe = k4[2 * Ce + 1] | 0;\n                    if (Pe >= c5) Pe = Pe - c5 | 0, S2(v3, _2, Fe--, Pe);\n                    else if (Pe >= 0) S2(h3, d3, Ae--, Pe);\n                    else if (Pe <= -c5) {\n                      Pe = -Pe - c5 | 0;\n                      for (var ge = 0; ge < Ae; ++ge) {\n                        var Re = T3(h3[ge], Pe);\n                        if (Re !== void 0) return Re;\n                      }\n                      L3(v3, _2, Fe++, Pe);\n                    } else {\n                      Pe = -Pe - 1 | 0;\n                      for (var ge = 0; ge < Fe; ++ge) {\n                        var Re = T3(Pe, v3[ge]);\n                        if (Re !== void 0) return Re;\n                      }\n                      L3(h3, d3, Ae++, Pe);\n                    }\n                  }\n                }\n                function C3(P3, T3, z3, O3, V2, G2, Z, j3, N2, H) {\n                  for (var te = 0, oe = 2 * P3, _e = P3 - 1, Ee = oe - 1, Ce = z3; Ce < O3; ++Ce) {\n                    var me = G2[Ce] + 1 << 1, ie = oe * Ce;\n                    k4[te++] = V2[ie + _e], k4[te++] = -me, k4[te++] = V2[ie + Ee], k4[te++] = me;\n                  }\n                  for (var Ce = Z; Ce < j3; ++Ce) {\n                    var me = H[Ce] + 1 << 1, Se = oe * Ce;\n                    k4[te++] = N2[Se + _e], k4[te++] = -me | 1, k4[te++] = N2[Se + Ee], k4[te++] = me | 1;\n                  }\n                  var Le = te >>> 1;\n                  u4(k4, Le);\n                  for (var Ae = 0, Fe = 0, Pe = 0, Ce = 0; Ce < Le; ++Ce) {\n                    var ge = k4[2 * Ce + 1] | 0, Re = ge & 1;\n                    if (Ce < Le - 1 && ge >> 1 === k4[2 * Ce + 3] >> 1 && (Re = 2, Ce += 1), ge < 0) {\n                      for (var ce = -(ge >> 1) - 1, Ze = 0; Ze < Pe; ++Ze) {\n                        var ut = T3(b[Ze], ce);\n                        if (ut !== void 0) return ut;\n                      }\n                      if (Re !== 0) for (var Ze = 0; Ze < Ae; ++Ze) {\n                        var ut = T3(h3[Ze], ce);\n                        if (ut !== void 0) return ut;\n                      }\n                      if (Re !== 1) for (var Ze = 0; Ze < Fe; ++Ze) {\n                        var ut = T3(v3[Ze], ce);\n                        if (ut !== void 0) return ut;\n                      }\n                      Re === 0 ? L3(h3, d3, Ae++, ce) : Re === 1 ? L3(v3, _2, Fe++, ce) : Re === 2 && L3(b, p3, Pe++, ce);\n                    } else {\n                      var ce = (ge >> 1) - 1;\n                      Re === 0 ? S2(h3, d3, Ae--, ce) : Re === 1 ? S2(v3, _2, Fe--, ce) : Re === 2 && S2(b, p3, Pe--, ce);\n                    }\n                  }\n                }\n                function M4(P3, T3, z3, O3, V2, G2, Z, j3, N2, H, te, oe) {\n                  var _e = 0, Ee = 2 * P3, Ce = T3, me = T3 + P3, ie = 1, Se = 1;\n                  O3 ? Se = c5 : ie = c5;\n                  for (var Le = V2; Le < G2; ++Le) {\n                    var Ae = Le + ie, Fe = Ee * Le;\n                    k4[_e++] = Z[Fe + Ce], k4[_e++] = -Ae, k4[_e++] = Z[Fe + me], k4[_e++] = Ae;\n                  }\n                  for (var Le = N2; Le < H; ++Le) {\n                    var Ae = Le + Se, Pe = Ee * Le;\n                    k4[_e++] = te[Pe + Ce], k4[_e++] = -Ae;\n                  }\n                  var ge = _e >>> 1;\n                  u4(k4, ge);\n                  for (var Re = 0, Le = 0; Le < ge; ++Le) {\n                    var ce = k4[2 * Le + 1] | 0;\n                    if (ce < 0) {\n                      var Ae = -ce, Ze = false;\n                      if (Ae >= c5 ? (Ze = !O3, Ae -= c5) : (Ze = !!O3, Ae -= 1), Ze) L3(h3, d3, Re++, Ae);\n                      else {\n                        var ut = oe[Ae], pt = Ee * Ae, Zt = te[pt + T3 + 1], st = te[pt + T3 + 1 + P3];\n                        e: for (var lt = 0; lt < Re; ++lt) {\n                          var Gt = h3[lt], Nt = Ee * Gt;\n                          if (!(st < Z[Nt + T3 + 1] || Z[Nt + T3 + 1 + P3] < Zt)) {\n                            for (var Jt = T3 + 2; Jt < P3; ++Jt) if (te[pt + Jt + P3] < Z[Nt + Jt] || Z[Nt + Jt + P3] < te[pt + Jt]) continue e;\n                            var sr = j3[Gt], wr;\n                            if (O3 ? wr = z3(ut, sr) : wr = z3(sr, ut), wr !== void 0) return wr;\n                          }\n                        }\n                      }\n                    } else S2(h3, d3, Re--, ce - ie);\n                  }\n                }\n                function g3(P3, T3, z3, O3, V2, G2, Z, j3, N2, H, te) {\n                  for (var oe = 0, _e = 2 * P3, Ee = T3, Ce = T3 + P3, me = O3; me < V2; ++me) {\n                    var ie = me + c5, Se = _e * me;\n                    k4[oe++] = G2[Se + Ee], k4[oe++] = -ie, k4[oe++] = G2[Se + Ce], k4[oe++] = ie;\n                  }\n                  for (var me = j3; me < N2; ++me) {\n                    var ie = me + 1, Le = _e * me;\n                    k4[oe++] = H[Le + Ee], k4[oe++] = -ie;\n                  }\n                  var Ae = oe >>> 1;\n                  u4(k4, Ae);\n                  for (var Fe = 0, me = 0; me < Ae; ++me) {\n                    var Pe = k4[2 * me + 1] | 0;\n                    if (Pe < 0) {\n                      var ie = -Pe;\n                      if (ie >= c5) h3[Fe++] = ie - c5;\n                      else {\n                        ie -= 1;\n                        var ge = te[ie], Re = _e * ie, ce = H[Re + T3 + 1], Ze = H[Re + T3 + 1 + P3];\n                        e: for (var ut = 0; ut < Fe; ++ut) {\n                          var pt = h3[ut], Zt = Z[pt];\n                          if (Zt === ge) break;\n                          var st = _e * pt;\n                          if (!(Ze < G2[st + T3 + 1] || G2[st + T3 + 1 + P3] < ce)) {\n                            for (var lt = T3 + 2; lt < P3; ++lt) if (H[Re + lt + P3] < G2[st + lt] || G2[st + lt + P3] < H[Re + lt]) continue e;\n                            var Gt = z3(Zt, ge);\n                            if (Gt !== void 0) return Gt;\n                          }\n                        }\n                      }\n                    } else {\n                      for (var ie = Pe - c5, ut = Fe - 1; ut >= 0; --ut) if (h3[ut] === ie) {\n                        for (var lt = ut + 1; lt < Fe; ++lt) h3[lt - 1] = h3[lt];\n                        break;\n                      }\n                      --Fe;\n                    }\n                  }\n                }\n              }, 868: function(i3, a4, o4) {\n                i3.exports = o4(1387);\n              }, 869: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2651), l3 = o4(5716);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  var h3 = l3(c5), d3 = l3(f4);\n                  if (h3 === 0) return [s3(0), s3(1)];\n                  if (d3 === 0) return [s3(0), s3(0)];\n                  d3 < 0 && (c5 = c5.neg(), f4 = f4.neg());\n                  var v3 = c5.gcd(f4);\n                  return v3.cmpn(1) ? [c5.div(v3), f4.div(v3)] : [c5, f4];\n                }\n              }, 870: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1433);\n                function l3(c5) {\n                  this.gl = c5, this._elements = null, this._attributes = null, this._elementsType = c5.UNSIGNED_SHORT;\n                }\n                l3.prototype.bind = function() {\n                  s3(this.gl, this._elements, this._attributes);\n                }, l3.prototype.update = function(c5, f4, h3) {\n                  this._elements = f4, this._attributes = c5, this._elementsType = h3 || this.gl.UNSIGNED_SHORT;\n                }, l3.prototype.dispose = function() {\n                }, l3.prototype.unbind = function() {\n                }, l3.prototype.draw = function(c5, f4, h3) {\n                  h3 = h3 || 0;\n                  var d3 = this.gl;\n                  this._elements ? d3.drawElements(c5, f4, this._elementsType, h3) : d3.drawArrays(c5, h3, f4);\n                };\n                function u4(c5) {\n                  return new l3(c5);\n                }\n                i3.exports = u4;\n              }, 946: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1369), l3 = o4(4025);\n                i3.exports = u4;\n                function u4(c5) {\n                  var f4 = c5[0], h3 = c5[1];\n                  if (f4.cmpn(0) === 0) return 0;\n                  var d3 = f4.abs().divmod(h3.abs()), v3 = d3.div, _2 = s3(v3), b = d3.mod, p3 = f4.negative !== h3.negative ? -1 : 1;\n                  if (b.cmpn(0) === 0) return p3 * _2;\n                  if (_2) {\n                    var k4 = l3(_2) + 4, E3 = s3(b.ushln(k4).divRound(h3));\n                    return p3 * (_2 + E3 * Math.pow(2, -k4));\n                  } else {\n                    var S2 = h3.bitLength() - b.bitLength() + 53, E3 = s3(b.ushln(S2).divRound(h3));\n                    return S2 < 1023 ? p3 * E3 * Math.pow(2, -S2) : (E3 *= Math.pow(2, -1023), p3 * E3 * Math.pow(2, 1023 - S2));\n                  }\n                }\n              }, 990: function(i3, a4, o4) {\n                var s3 = o4(9405), l3 = o4(3236), u4 = l3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute vec3 f;\nattribute vec3 normal;\n\nuniform vec3 objectOffset;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 lightPosition, eyePosition;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  vec3 localCoordinate = vec3(uv.zw, f.x);\n  worldCoordinate = objectOffset + localCoordinate;\n  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));\n  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(localCoordinate, 1.0);\n  vec4 clipPosition = projection * (view * worldPosition);\n  gl_Position = clipPosition;\n  kill = f.y;\n  value = f.z;\n  planeCoordinate = uv.xy;\n\n  vColor = texture2D(colormap, vec2(value, value));\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * worldPosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  lightDirection = lightPosition - cameraCoordinate.xyz;\n  eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  surfaceNormal  = normalize((vec4(normal,0) * inverseModel).xyz);\n}\n`]), c5 = l3([`precision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat beckmannSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness) {\n  return beckmannDistribution(dot(surfaceNormal, normalize(lightDirection + viewDirection)), roughness);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 lowerBound, upperBound;\nuniform float contourTint;\nuniform vec4 contourColor;\nuniform sampler2D colormap;\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform float vertexColor;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  if (\n    kill > 0.0 ||\n    vColor.a == 0.0 ||\n    outOfRange(clipBounds[0], clipBounds[1], worldCoordinate)\n  ) discard;\n\n  vec3 N = normalize(surfaceNormal);\n  vec3 V = normalize(eyeDirection);\n  vec3 L = normalize(lightDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = max(beckmannSpecular(L, V, N, roughness), 0.);\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  //decide how to interpolate color \\u2014 in vertex or in fragment\n  vec4 surfaceColor =\n    step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) +\n    step(.5, vertexColor) * vColor;\n\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;\n}\n`]), f4 = l3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute float f;\n\nuniform vec3 objectOffset;\nuniform mat3 permutation;\nuniform mat4 model, view, projection;\nuniform float height, zOffset;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n  vec3 dataCoordinate = permutation * vec3(uv.xy, height);\n  worldCoordinate = objectOffset + dataCoordinate;\n  mat4 objectOffsetTranslation = mat4(1.0) + mat4(vec4(0), vec4(0), vec4(0), vec4(objectOffset, 0));\n  vec4 worldPosition = (model * objectOffsetTranslation) * vec4(dataCoordinate, 1.0);\n\n  vec4 clipPosition = projection * (view * worldPosition);\n  clipPosition.z += zOffset;\n\n  gl_Position = clipPosition;\n  value = f + objectOffset.z;\n  kill = -1.0;\n  planeCoordinate = uv.zw;\n\n  vColor = texture2D(colormap, vec2(value, value));\n\n  //Don\'t do lighting for contours\n  surfaceNormal   = vec3(1,0,0);\n  eyeDirection    = vec3(0,1,0);\n  lightDirection  = vec3(0,0,1);\n}\n`]), h3 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec2 shape;\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 surfaceNormal;\n\nvec2 splitFloat(float v) {\n  float vh = 255.0 * v;\n  float upper = floor(vh);\n  float lower = fract(vh);\n  return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);\n}\n\nvoid main() {\n  if ((kill > 0.0) ||\n      (outOfRange(clipBounds[0], clipBounds[1], worldCoordinate))) discard;\n\n  vec2 ux = splitFloat(planeCoordinate.x / shape.x);\n  vec2 uy = splitFloat(planeCoordinate.y / shape.y);\n  gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));\n}\n`]);\n                a4.createShader = function(d3) {\n                  var v3 = s3(d3, u4, c5, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "vec3" }, { name: "normal", type: "vec3" }]);\n                  return v3.attributes.uv.location = 0, v3.attributes.f.location = 1, v3.attributes.normal.location = 2, v3;\n                }, a4.createPickShader = function(d3) {\n                  var v3 = s3(d3, u4, h3, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "vec3" }, { name: "normal", type: "vec3" }]);\n                  return v3.attributes.uv.location = 0, v3.attributes.f.location = 1, v3.attributes.normal.location = 2, v3;\n                }, a4.createContourShader = function(d3) {\n                  var v3 = s3(d3, f4, c5, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "float" }]);\n                  return v3.attributes.uv.location = 0, v3.attributes.f.location = 1, v3;\n                }, a4.createPickContourShader = function(d3) {\n                  var v3 = s3(d3, f4, h3, null, [{ name: "uv", type: "vec4" }, { name: "f", type: "float" }]);\n                  return v3.attributes.uv.location = 0, v3.attributes.f.location = 1, v3;\n                };\n              }, 1085: function(i3, a4, o4) {\n                var s3 = o4(1371);\n                i3.exports = l3;\n                function l3(u4, c5, f4) {\n                  c5 = typeof c5 == "number" ? c5 : 1, f4 = f4 || ": ";\n                  var h3 = u4.split(/\\r?\\n/), d3 = String(h3.length + c5 - 1).length;\n                  return h3.map(function(v3, _2) {\n                    var b = _2 + c5, p3 = String(b).length, k4 = s3(b, d3 - p3);\n                    return k4 + f4 + v3;\n                  }).join(`\n`);\n                }\n              }, 1091: function(i3) {\n                i3.exports = a4;\n                function a4() {\n                  var o4 = new Float32Array(3);\n                  return o4[0] = 0, o4[1] = 0, o4[2] = 0, o4;\n                }\n              }, 1125: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(3250)[3];\n                function l3(c5, f4, h3, d3) {\n                  for (var v3 = 0; v3 < 2; ++v3) {\n                    var _2 = c5[v3], b = f4[v3], p3 = Math.min(_2, b), k4 = Math.max(_2, b), E3 = h3[v3], S2 = d3[v3], L3 = Math.min(E3, S2), x2 = Math.max(E3, S2);\n                    if (x2 < p3 || k4 < L3) return false;\n                  }\n                  return true;\n                }\n                function u4(c5, f4, h3, d3) {\n                  var v3 = s3(c5, h3, d3), _2 = s3(f4, h3, d3);\n                  if (v3 > 0 && _2 > 0 || v3 < 0 && _2 < 0) return false;\n                  var b = s3(h3, c5, f4), p3 = s3(d3, c5, f4);\n                  return b > 0 && p3 > 0 || b < 0 && p3 < 0 ? false : v3 === 0 && _2 === 0 && b === 0 && p3 === 0 ? l3(c5, f4, h3, d3) : true;\n                }\n              }, 1278: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2361), l3 = Math.pow(2, -1074), u4 = -1 >>> 0;\n                i3.exports = c5;\n                function c5(f4, h3) {\n                  if (isNaN(f4) || isNaN(h3)) return NaN;\n                  if (f4 === h3) return f4;\n                  if (f4 === 0) return h3 < 0 ? -l3 : l3;\n                  var d3 = s3.hi(f4), v3 = s3.lo(f4);\n                  return h3 > f4 == f4 > 0 ? v3 === u4 ? (d3 += 1, v3 = 0) : v3 += 1 : v3 === 0 ? (v3 = u4, d3 -= 1) : v3 -= 1, s3.pack(v3, d3);\n                }\n              }, 1283: function(i3, a4, o4) {\n                var s3 = o4(9405), l3 = o4(3236), u4 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform vec4 highlightId;\nuniform float highlightScale;\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float scale = 1.0;\n    if(distance(highlightId, id) < 0.0001) {\n      scale = highlightScale;\n    }\n\n    vec4 worldPosition = model * vec4(position, 1);\n    vec4 viewPosition = view * worldPosition;\n    viewPosition = viewPosition / viewPosition.w;\n    vec4 clipPosition = projection * (viewPosition + scale * vec4(glyph.x, -glyph.y, 0, 0));\n\n    gl_Position = clipPosition;\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = position;\n  }\n}`]), c5 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float highlightScale, pixelRatio;\nuniform vec4 highlightId;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float scale = pixelRatio;\n    if(distance(highlightId.bgr, id.bgr) < 0.001) {\n      scale *= highlightScale;\n    }\n\n    vec4 worldPosition = model * vec4(position, 1.0);\n    vec4 viewPosition = view * worldPosition;\n    vec4 clipPosition = projection * viewPosition;\n    clipPosition /= clipPosition.w;\n\n    gl_Position = clipPosition + vec4(screenSize * scale * vec2(glyph.x, -glyph.y), 0.0, 0.0);\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = position;\n  }\n}`]), f4 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nattribute vec3 position;\nattribute vec4 color;\nattribute vec2 glyph;\nattribute vec4 id;\n\nuniform float highlightScale;\nuniform vec4 highlightId;\nuniform vec3 axes[2];\nuniform mat4 model, view, projection;\nuniform vec2 screenSize;\nuniform vec3 clipBounds[2];\nuniform float scale, pixelRatio;\n\nvarying vec4 interpColor;\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], position)) {\n\n    gl_Position = vec4(0,0,0,0);\n  } else {\n    float lscale = pixelRatio * scale;\n    if(distance(highlightId, id) < 0.0001) {\n      lscale *= highlightScale;\n    }\n\n    vec4 clipCenter   = projection * (view * (model * vec4(position, 1)));\n    vec3 dataPosition = position + 0.5*lscale*(axes[0] * glyph.x + axes[1] * glyph.y) * clipCenter.w * screenSize.y;\n    vec4 clipPosition = projection * (view * (model * vec4(dataPosition, 1)));\n\n    gl_Position = clipPosition;\n    interpColor = color;\n    pickId = id;\n    dataCoordinate = dataPosition;\n  }\n}\n`]), h3 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float opacity;\n\nvarying vec4 interpColor;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (\n    outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate) ||\n    interpColor.a * opacity == 0.\n  ) discard;\n  gl_FragColor = interpColor * opacity;\n}\n`]), d3 = l3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 fragClipBounds[2];\nuniform float pickGroup;\n\nvarying vec4 pickId;\nvarying vec3 dataCoordinate;\n\nvoid main() {\n  if (outOfRange(fragClipBounds[0], fragClipBounds[1], dataCoordinate)) discard;\n\n  gl_FragColor = vec4(pickGroup, pickId.bgr);\n}`]), v3 = [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "glyph", type: "vec2" }, { name: "id", type: "vec4" }], _2 = { vertex: u4, fragment: h3, attributes: v3 }, b = { vertex: c5, fragment: h3, attributes: v3 }, p3 = { vertex: f4, fragment: h3, attributes: v3 }, k4 = { vertex: u4, fragment: d3, attributes: v3 }, E3 = { vertex: c5, fragment: d3, attributes: v3 }, S2 = { vertex: f4, fragment: d3, attributes: v3 };\n                function L3(x2, C3) {\n                  var M4 = s3(x2, C3), g3 = M4.attributes;\n                  return g3.position.location = 0, g3.color.location = 1, g3.glyph.location = 2, g3.id.location = 3, M4;\n                }\n                a4.createPerspective = function(x2) {\n                  return L3(x2, _2);\n                }, a4.createOrtho = function(x2) {\n                  return L3(x2, b);\n                }, a4.createProject = function(x2) {\n                  return L3(x2, p3);\n                }, a4.createPickPerspective = function(x2) {\n                  return L3(x2, k4);\n                }, a4.createPickOrtho = function(x2) {\n                  return L3(x2, E3);\n                }, a4.createPickProject = function(x2) {\n                  return L3(x2, S2);\n                };\n              }, 1303: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(3250);\n                function l3(c5, f4) {\n                  var h3, d3;\n                  if (f4[0][0] < f4[1][0]) h3 = f4[0], d3 = f4[1];\n                  else if (f4[0][0] > f4[1][0]) h3 = f4[1], d3 = f4[0];\n                  else {\n                    var v3 = Math.min(c5[0][1], c5[1][1]), _2 = Math.max(c5[0][1], c5[1][1]), b = Math.min(f4[0][1], f4[1][1]), p3 = Math.max(f4[0][1], f4[1][1]);\n                    return _2 < b ? _2 - b : v3 > p3 ? v3 - p3 : _2 - p3;\n                  }\n                  var k4, E3;\n                  c5[0][1] < c5[1][1] ? (k4 = c5[0], E3 = c5[1]) : (k4 = c5[1], E3 = c5[0]);\n                  var S2 = s3(d3, h3, k4);\n                  return S2 || (S2 = s3(d3, h3, E3), S2) ? S2 : E3 - d3;\n                }\n                function u4(c5, f4) {\n                  var h3, d3;\n                  if (f4[0][0] < f4[1][0]) h3 = f4[0], d3 = f4[1];\n                  else if (f4[0][0] > f4[1][0]) h3 = f4[1], d3 = f4[0];\n                  else return l3(f4, c5);\n                  var v3, _2;\n                  if (c5[0][0] < c5[1][0]) v3 = c5[0], _2 = c5[1];\n                  else if (c5[0][0] > c5[1][0]) v3 = c5[1], _2 = c5[0];\n                  else return -l3(c5, f4);\n                  var b = s3(h3, d3, _2), p3 = s3(h3, d3, v3);\n                  if (b < 0) {\n                    if (p3 <= 0) return b;\n                  } else if (b > 0) {\n                    if (p3 >= 0) return b;\n                  } else if (p3) return p3;\n                  if (b = s3(_2, v3, d3), p3 = s3(_2, v3, h3), b < 0) {\n                    if (p3 <= 0) return b;\n                  } else if (b > 0) {\n                    if (p3 >= 0) return b;\n                  } else if (p3) return p3;\n                  return d3[0] - _2[0];\n                }\n              }, 1318: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0].mul(s3[1]).cmp(s3[0].mul(o4[1]));\n                }\n              }, 1338: function(i3) {\n                "use strict";\n                function a4(l3, u4, c5) {\n                  var f4 = l3[c5] | 0;\n                  if (f4 <= 0) return [];\n                  var h3 = new Array(f4), d3;\n                  if (c5 === l3.length - 1) for (d3 = 0; d3 < f4; ++d3) h3[d3] = u4;\n                  else for (d3 = 0; d3 < f4; ++d3) h3[d3] = a4(l3, u4, c5 + 1);\n                  return h3;\n                }\n                function o4(l3, u4) {\n                  var c5, f4;\n                  for (c5 = new Array(l3), f4 = 0; f4 < l3; ++f4) c5[f4] = u4;\n                  return c5;\n                }\n                function s3(l3, u4) {\n                  switch (typeof u4 == "undefined" && (u4 = 0), typeof l3) {\n                    case "number":\n                      if (l3 > 0) return o4(l3 | 0, u4);\n                      break;\n                    case "object":\n                      if (typeof l3.length == "number") return a4(l3, u4, 0);\n                      break;\n                  }\n                  return [];\n                }\n                i3.exports = s3;\n              }, 1369: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5716);\n                i3.exports = l3;\n                function l3(u4) {\n                  var c5 = u4.length, f4 = u4.words, h3 = 0;\n                  if (c5 === 1) h3 = f4[0];\n                  else if (c5 === 2) h3 = f4[0] + f4[1] * 67108864;\n                  else for (var d3 = 0; d3 < c5; d3++) {\n                    var v3 = f4[d3];\n                    h3 += v3 * Math.pow(67108864, d3);\n                  }\n                  return s3(u4) * h3;\n                }\n              }, 1371: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3233);\n                i3.exports = function(u4, c5, f4) {\n                  return f4 = typeof f4 != "undefined" ? f4 + "" : " ", s3(f4, c5) + u4;\n                };\n              }, 1373: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] / l3[0], o4[1] = s3[1] / l3[1], o4[2] = s3[2] / l3[2], o4[3] = s3[3] / l3[3], o4;\n                }\n              }, 1387: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = o4[0], l3 = o4[1], u4 = o4[2];\n                  return Math.sqrt(s3 * s3 + l3 * l3 + u4 * u4);\n                }\n              }, 1433: function(i3) {\n                "use strict";\n                function a4(o4, s3, l3) {\n                  s3 ? s3.bind() : o4.bindBuffer(o4.ELEMENT_ARRAY_BUFFER, null);\n                  var u4 = o4.getParameter(o4.MAX_VERTEX_ATTRIBS) | 0;\n                  if (l3) {\n                    if (l3.length > u4) throw new Error("gl-vao: Too many vertex attributes");\n                    for (var c5 = 0; c5 < l3.length; ++c5) {\n                      var f4 = l3[c5];\n                      if (f4.buffer) {\n                        var h3 = f4.buffer, d3 = f4.size || 4, v3 = f4.type || o4.FLOAT, _2 = !!f4.normalized, b = f4.stride || 0, p3 = f4.offset || 0;\n                        h3.bind(), o4.enableVertexAttribArray(c5), o4.vertexAttribPointer(c5, d3, v3, _2, b, p3);\n                      } else {\n                        if (typeof f4 == "number") o4.vertexAttrib1f(c5, f4);\n                        else if (f4.length === 1) o4.vertexAttrib1f(c5, f4[0]);\n                        else if (f4.length === 2) o4.vertexAttrib2f(c5, f4[0], f4[1]);\n                        else if (f4.length === 3) o4.vertexAttrib3f(c5, f4[0], f4[1], f4[2]);\n                        else if (f4.length === 4) o4.vertexAttrib4f(c5, f4[0], f4[1], f4[2], f4[3]);\n                        else throw new Error("gl-vao: Invalid vertex attribute");\n                        o4.disableVertexAttribArray(c5);\n                      }\n                    }\n                    for (; c5 < u4; ++c5) o4.disableVertexAttribArray(c5);\n                  } else {\n                    o4.bindBuffer(o4.ARRAY_BUFFER, null);\n                    for (var c5 = 0; c5 < u4; ++c5) o4.disableVertexAttribArray(c5);\n                  }\n                }\n                i3.exports = a4;\n              }, 1463: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  return o4[0] = s3, o4[1] = l3, o4[2] = u4, o4;\n                }\n              }, 1493: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3236), l3 = o4(9405), u4 = s3([`precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, color;\nattribute float weight;\n\nuniform mat4 model, view, projection;\nuniform vec3 coordinates[3];\nuniform vec4 colors[3];\nuniform vec2 screenShape;\nuniform float lineWidth;\n\nvarying vec4 fragColor;\n\nvoid main() {\n  vec3 vertexPosition = mix(coordinates[0],\n    mix(coordinates[2], coordinates[1], 0.5 * (position + 1.0)), abs(position));\n\n  vec4 clipPos = projection * (view * (model * vec4(vertexPosition, 1.0)));\n  vec2 clipOffset = (projection * (view * (model * vec4(color, 0.0)))).xy;\n  vec2 delta = weight * clipOffset * screenShape;\n  vec2 lineOffset = normalize(vec2(delta.y, -delta.x)) / screenShape;\n\n  gl_Position   = vec4(clipPos.xy + clipPos.w * 0.5 * lineWidth * lineOffset, clipPos.z, clipPos.w);\n  fragColor     = color.x * colors[0] + color.y * colors[1] + color.z * colors[2];\n}\n`]), c5 = s3([`precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor;\n\nvoid main() {\n  gl_FragColor = fragColor;\n}`]);\n                i3.exports = function(f4) {\n                  return l3(f4, u4, c5, null, [{ name: "position", type: "vec3" }, { name: "color", type: "vec3" }, { name: "weight", type: "float" }]);\n                };\n              }, 1498: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = -s3[0], o4[1] = -s3[1], o4[2] = -s3[2], o4[3] = -s3[3], o4;\n                }\n              }, 1533: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(6859);\n                i3.exports = l3;\n                function l3(u4) {\n                  return u4 && typeof u4 == "object" && !!u4.words;\n                }\n              }, 1538: function(i3) {\n                (function() {\n                  "use strict";\n                  if (typeof ses != "undefined" && ses.ok && !ses.ok()) return;\n                  function o4(T3) {\n                    T3.permitHostObjects___ && T3.permitHostObjects___(o4);\n                  }\n                  typeof ses != "undefined" && (ses.weakMapPermitHostObjects = o4);\n                  var s3 = false;\n                  if (typeof WeakMap == "function") {\n                    var l3 = WeakMap;\n                    if (!(typeof navigator != "undefined" && /Firefox/.test(navigator.userAgent))) {\n                      var u4 = new l3(), c5 = Object.freeze({});\n                      if (u4.set(c5, 1), u4.get(c5) !== 1) s3 = true;\n                      else {\n                        i3.exports = WeakMap;\n                        return;\n                      }\n                    }\n                  }\n                  var f4 = Object.prototype.hasOwnProperty, h3 = Object.getOwnPropertyNames, d3 = Object.defineProperty, v3 = Object.isExtensible, _2 = "weakmap:", b = _2 + "ident:" + Math.random() + "___";\n                  if (typeof crypto != "undefined" && typeof crypto.getRandomValues == "function" && typeof ArrayBuffer == "function" && typeof Uint8Array == "function") {\n                    var p3 = new ArrayBuffer(25), k4 = new Uint8Array(p3);\n                    crypto.getRandomValues(k4), b = _2 + "rand:" + Array.prototype.map.call(k4, function(T3) {\n                      return (T3 % 36).toString(36);\n                    }).join("") + "___";\n                  }\n                  function E3(T3) {\n                    return !(T3.substr(0, _2.length) == _2 && T3.substr(T3.length - 3) === "___");\n                  }\n                  if (d3(Object, "getOwnPropertyNames", { value: function(z3) {\n                    return h3(z3).filter(E3);\n                  } }), "getPropertyNames" in Object) {\n                    var S2 = Object.getPropertyNames;\n                    d3(Object, "getPropertyNames", { value: function(z3) {\n                      return S2(z3).filter(E3);\n                    } });\n                  }\n                  function L3(T3) {\n                    if (T3 !== Object(T3)) throw new TypeError("Not an object: " + T3);\n                    var z3 = T3[b];\n                    if (z3 && z3.key === T3) return z3;\n                    if (v3(T3)) {\n                      z3 = { key: T3 };\n                      try {\n                        return d3(T3, b, { value: z3, writable: false, enumerable: false, configurable: false }), z3;\n                      } catch (O3) {\n                        return;\n                      }\n                    }\n                  }\n                  (function() {\n                    var T3 = Object.freeze;\n                    d3(Object, "freeze", { value: function(G2) {\n                      return L3(G2), T3(G2);\n                    } });\n                    var z3 = Object.seal;\n                    d3(Object, "seal", { value: function(G2) {\n                      return L3(G2), z3(G2);\n                    } });\n                    var O3 = Object.preventExtensions;\n                    d3(Object, "preventExtensions", { value: function(G2) {\n                      return L3(G2), O3(G2);\n                    } });\n                  })();\n                  function x2(T3) {\n                    return T3.prototype = null, Object.freeze(T3);\n                  }\n                  var C3 = false;\n                  function M4() {\n                    !C3 && typeof console != "undefined" && (C3 = true, console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future."));\n                  }\n                  var g3 = 0, P3 = function() {\n                    this instanceof P3 || M4();\n                    var T3 = [], z3 = [], O3 = g3++;\n                    function V2(N2, H) {\n                      var te, oe = L3(N2);\n                      return oe ? O3 in oe ? oe[O3] : H : (te = T3.indexOf(N2), te >= 0 ? z3[te] : H);\n                    }\n                    function G2(N2) {\n                      var H = L3(N2);\n                      return H ? O3 in H : T3.indexOf(N2) >= 0;\n                    }\n                    function Z(N2, H) {\n                      var te, oe = L3(N2);\n                      return oe ? oe[O3] = H : (te = T3.indexOf(N2), te >= 0 ? z3[te] = H : (te = T3.length, z3[te] = H, T3[te] = N2)), this;\n                    }\n                    function j3(N2) {\n                      var H = L3(N2), te, oe;\n                      return H ? O3 in H && delete H[O3] : (te = T3.indexOf(N2), te < 0 ? false : (oe = T3.length - 1, T3[te] = void 0, z3[te] = z3[oe], T3[te] = T3[oe], T3.length = oe, z3.length = oe, true));\n                    }\n                    return Object.create(P3.prototype, { get___: { value: x2(V2) }, has___: { value: x2(G2) }, set___: { value: x2(Z) }, delete___: { value: x2(j3) } });\n                  };\n                  P3.prototype = Object.create(Object.prototype, { get: { value: function(z3, O3) {\n                    return this.get___(z3, O3);\n                  }, writable: true, configurable: true }, has: { value: function(z3) {\n                    return this.has___(z3);\n                  }, writable: true, configurable: true }, set: { value: function(z3, O3) {\n                    return this.set___(z3, O3);\n                  }, writable: true, configurable: true }, delete: { value: function(z3) {\n                    return this.delete___(z3);\n                  }, writable: true, configurable: true } }), typeof l3 == "function" ? (function() {\n                    s3 && typeof Proxy != "undefined" && (Proxy = void 0);\n                    function T3() {\n                      this instanceof P3 || M4();\n                      var z3 = new l3(), O3 = void 0, V2 = false;\n                      function G2(H, te) {\n                        return O3 ? z3.has(H) ? z3.get(H) : O3.get___(H, te) : z3.get(H, te);\n                      }\n                      function Z(H) {\n                        return z3.has(H) || (O3 ? O3.has___(H) : false);\n                      }\n                      var j3;\n                      s3 ? j3 = function(H, te) {\n                        return z3.set(H, te), z3.has(H) || (O3 || (O3 = new P3()), O3.set(H, te)), this;\n                      } : j3 = function(H, te) {\n                        if (V2) try {\n                          z3.set(H, te);\n                        } catch (oe) {\n                          O3 || (O3 = new P3()), O3.set___(H, te);\n                        }\n                        else z3.set(H, te);\n                        return this;\n                      };\n                      function N2(H) {\n                        var te = !!z3.delete(H);\n                        return O3 && O3.delete___(H) || te;\n                      }\n                      return Object.create(P3.prototype, { get___: { value: x2(G2) }, has___: { value: x2(Z) }, set___: { value: x2(j3) }, delete___: { value: x2(N2) }, permitHostObjects___: { value: x2(function(H) {\n                        if (H === o4) V2 = true;\n                        else throw new Error("bogus call to permitHostObjects___");\n                      }) } });\n                    }\n                    T3.prototype = P3.prototype, i3.exports = T3, Object.defineProperty(WeakMap.prototype, "constructor", { value: WeakMap, enumerable: false, configurable: true, writable: true });\n                  })() : (typeof Proxy != "undefined" && (Proxy = void 0), i3.exports = P3);\n                })();\n              }, 1570: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                var a4 = [function() {\n                  function l3(c5, f4, h3, d3) {\n                    for (var v3 = Math.min(h3, d3) | 0, _2 = Math.max(h3, d3) | 0, b = c5[2 * v3], p3 = c5[2 * v3 + 1]; b < p3; ) {\n                      var k4 = b + p3 >> 1, E3 = f4[2 * k4 + 1];\n                      if (E3 === _2) return k4;\n                      _2 < E3 ? p3 = k4 : b = k4 + 1;\n                    }\n                    return b;\n                  }\n                  function u4(c5, f4, h3, d3) {\n                    for (var v3 = c5.length, _2 = [], b = 0; b < v3; ++b) var p3 = c5[b], k4 = p3.length;\n                    return _2;\n                  }\n                  return u4;\n                }, function() {\n                  function l3(c5, f4, h3, d3) {\n                    for (var v3 = Math.min(h3, d3) | 0, _2 = Math.max(h3, d3) | 0, b = c5[2 * v3], p3 = c5[2 * v3 + 1]; b < p3; ) {\n                      var k4 = b + p3 >> 1, E3 = f4[2 * k4 + 1];\n                      if (E3 === _2) return k4;\n                      _2 < E3 ? p3 = k4 : b = k4 + 1;\n                    }\n                    return b;\n                  }\n                  function u4(c5, f4, h3, d3) {\n                    for (var v3 = c5.length, _2 = [], b = 0; b < v3; ++b) {\n                      var p3 = c5[b], k4 = p3.length;\n                      if (k4 === 2) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1);\n                        if (E3 === 0 || E3 === 3) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[0])]);\n                            break;\n                          case 3:\n                            break;\n                        }\n                      }\n                    }\n                    return _2;\n                  }\n                  return u4;\n                }, function() {\n                  function l3(c5, f4, h3, d3) {\n                    for (var v3 = Math.min(h3, d3) | 0, _2 = Math.max(h3, d3) | 0, b = c5[2 * v3], p3 = c5[2 * v3 + 1]; b < p3; ) {\n                      var k4 = b + p3 >> 1, E3 = f4[2 * k4 + 1];\n                      if (E3 === _2) return k4;\n                      _2 < E3 ? p3 = k4 : b = k4 + 1;\n                    }\n                    return b;\n                  }\n                  function u4(c5, f4, h3, d3) {\n                    for (var v3 = c5.length, _2 = [], b = 0; b < v3; ++b) {\n                      var p3 = c5[b], k4 = p3.length;\n                      if (k4 === 3) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1) + (d3[p3[2]] << 2);\n                        if (E3 === 0 || E3 === 7) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[1], p3[2])]);\n                            break;\n                          case 3:\n                            _2.push([l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[1], p3[2])]);\n                            break;\n                          case 4:\n                            _2.push([l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[2], p3[0])]);\n                            break;\n                          case 5:\n                            _2.push([l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 6:\n                            _2.push([l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[2], p3[0])]);\n                            break;\n                          case 7:\n                            break;\n                        }\n                      } else if (k4 === 2) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1);\n                        if (E3 === 0 || E3 === 3) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[0])]);\n                            break;\n                          case 3:\n                            break;\n                        }\n                      }\n                    }\n                    return _2;\n                  }\n                  return u4;\n                }, function() {\n                  function l3(c5, f4, h3, d3) {\n                    for (var v3 = Math.min(h3, d3) | 0, _2 = Math.max(h3, d3) | 0, b = c5[2 * v3], p3 = c5[2 * v3 + 1]; b < p3; ) {\n                      var k4 = b + p3 >> 1, E3 = f4[2 * k4 + 1];\n                      if (E3 === _2) return k4;\n                      _2 < E3 ? p3 = k4 : b = k4 + 1;\n                    }\n                    return b;\n                  }\n                  function u4(c5, f4, h3, d3) {\n                    for (var v3 = c5.length, _2 = [], b = 0; b < v3; ++b) {\n                      var p3 = c5[b], k4 = p3.length;\n                      if (k4 === 4) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1) + (d3[p3[2]] << 2) + (d3[p3[3]] << 3);\n                        if (E3 === 0 || E3 === 15) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[1]), l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[0], p3[3])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[2]), l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[1], p3[3])]);\n                            break;\n                          case 3:\n                            _2.push([l3(h3, f4, p3[1], p3[2]), l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[0], p3[3])], [l3(h3, f4, p3[1], p3[3]), l3(h3, f4, p3[1], p3[2]), l3(h3, f4, p3[0], p3[3])]);\n                            break;\n                          case 4:\n                            _2.push([l3(h3, f4, p3[2], p3[0]), l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[2], p3[3])]);\n                            break;\n                          case 5:\n                            _2.push([l3(h3, f4, p3[0], p3[1]), l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[0], p3[3])], [l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[2], p3[3]), l3(h3, f4, p3[0], p3[3])]);\n                            break;\n                          case 6:\n                            _2.push([l3(h3, f4, p3[2], p3[0]), l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[1], p3[3])], [l3(h3, f4, p3[2], p3[3]), l3(h3, f4, p3[2], p3[0]), l3(h3, f4, p3[1], p3[3])]);\n                            break;\n                          case 7:\n                            _2.push([l3(h3, f4, p3[0], p3[3]), l3(h3, f4, p3[1], p3[3]), l3(h3, f4, p3[2], p3[3])]);\n                            break;\n                          case 8:\n                            _2.push([l3(h3, f4, p3[3], p3[1]), l3(h3, f4, p3[3], p3[0]), l3(h3, f4, p3[3], p3[2])]);\n                            break;\n                          case 9:\n                            _2.push([l3(h3, f4, p3[3], p3[1]), l3(h3, f4, p3[0], p3[1]), l3(h3, f4, p3[0], p3[2])], [l3(h3, f4, p3[3], p3[2]), l3(h3, f4, p3[3], p3[1]), l3(h3, f4, p3[0], p3[2])]);\n                            break;\n                          case 10:\n                            _2.push([l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[3], p3[0]), l3(h3, f4, p3[1], p3[2])], [l3(h3, f4, p3[3], p3[0]), l3(h3, f4, p3[3], p3[2]), l3(h3, f4, p3[1], p3[2])]);\n                            break;\n                          case 11:\n                            _2.push([l3(h3, f4, p3[1], p3[2]), l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[3], p3[2])]);\n                            break;\n                          case 12:\n                            _2.push([l3(h3, f4, p3[3], p3[0]), l3(h3, f4, p3[2], p3[0]), l3(h3, f4, p3[2], p3[1])], [l3(h3, f4, p3[3], p3[1]), l3(h3, f4, p3[3], p3[0]), l3(h3, f4, p3[2], p3[1])]);\n                            break;\n                          case 13:\n                            _2.push([l3(h3, f4, p3[0], p3[1]), l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[3], p3[1])]);\n                            break;\n                          case 14:\n                            _2.push([l3(h3, f4, p3[2], p3[0]), l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[3], p3[0])]);\n                            break;\n                          case 15:\n                            break;\n                        }\n                      } else if (k4 === 3) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1) + (d3[p3[2]] << 2);\n                        if (E3 === 0 || E3 === 7) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[1], p3[2])]);\n                            break;\n                          case 3:\n                            _2.push([l3(h3, f4, p3[0], p3[2]), l3(h3, f4, p3[1], p3[2])]);\n                            break;\n                          case 4:\n                            _2.push([l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[2], p3[0])]);\n                            break;\n                          case 5:\n                            _2.push([l3(h3, f4, p3[2], p3[1]), l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 6:\n                            _2.push([l3(h3, f4, p3[1], p3[0]), l3(h3, f4, p3[2], p3[0])]);\n                            break;\n                          case 7:\n                            break;\n                        }\n                      } else if (k4 === 2) {\n                        var E3 = (d3[p3[0]] << 0) + (d3[p3[1]] << 1);\n                        if (E3 === 0 || E3 === 3) continue;\n                        switch (E3) {\n                          case 0:\n                            break;\n                          case 1:\n                            _2.push([l3(h3, f4, p3[0], p3[1])]);\n                            break;\n                          case 2:\n                            _2.push([l3(h3, f4, p3[1], p3[0])]);\n                            break;\n                          case 3:\n                            break;\n                        }\n                      }\n                    }\n                    return _2;\n                  }\n                  return u4;\n                }];\n                function o4(s3) {\n                  return a4[s3]();\n                }\n              }, 1682: function(i3) {\n                "use strict";\n                function a4(l3, u4) {\n                  for (var c5 = 1, f4 = l3.length, h3 = l3[0], d3 = l3[0], v3 = 1; v3 < f4; ++v3) if (d3 = h3, h3 = l3[v3], u4(h3, d3)) {\n                    if (v3 === c5) {\n                      c5++;\n                      continue;\n                    }\n                    l3[c5++] = h3;\n                  }\n                  return l3.length = c5, l3;\n                }\n                function o4(l3) {\n                  for (var u4 = 1, c5 = l3.length, f4 = l3[0], h3 = l3[0], d3 = 1; d3 < c5; ++d3, h3 = f4) if (h3 = f4, f4 = l3[d3], f4 !== h3) {\n                    if (d3 === u4) {\n                      u4++;\n                      continue;\n                    }\n                    l3[u4++] = f4;\n                  }\n                  return l3.length = u4, l3;\n                }\n                function s3(l3, u4, c5) {\n                  return l3.length === 0 ? l3 : u4 ? (c5 || l3.sort(u4), a4(l3, u4)) : (c5 || l3.sort(), o4(l3));\n                }\n                i3.exports = s3;\n              }, 1755: function(i3) {\n                "use strict";\n                "use restrict";\n                i3.exports = a4;\n                function a4(s3) {\n                  this.roots = new Array(s3), this.ranks = new Array(s3);\n                  for (var l3 = 0; l3 < s3; ++l3) this.roots[l3] = l3, this.ranks[l3] = 0;\n                }\n                var o4 = a4.prototype;\n                Object.defineProperty(o4, "length", { get: function() {\n                  return this.roots.length;\n                } }), o4.makeSet = function() {\n                  var s3 = this.roots.length;\n                  return this.roots.push(s3), this.ranks.push(0), s3;\n                }, o4.find = function(s3) {\n                  for (var l3 = s3, u4 = this.roots; u4[s3] !== s3; ) s3 = u4[s3];\n                  for (; u4[l3] !== s3; ) {\n                    var c5 = u4[l3];\n                    u4[l3] = s3, l3 = c5;\n                  }\n                  return s3;\n                }, o4.link = function(s3, l3) {\n                  var u4 = this.find(s3), c5 = this.find(l3);\n                  if (u4 !== c5) {\n                    var f4 = this.ranks, h3 = this.roots, d3 = f4[u4], v3 = f4[c5];\n                    d3 < v3 ? h3[u4] = c5 : v3 < d3 ? h3[c5] = u4 : (h3[c5] = u4, ++f4[u4]);\n                  }\n                };\n              }, 1811: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2478), l3 = o4(7442), u4 = o4(7608), c5 = o4(5567), f4 = o4(2408), h3 = o4(7089), d3 = o4(6582), v3 = o4(7656), _2 = o4(2504), b = o4(3536), p3 = [0, 0, 0];\n                i3.exports = L3;\n                function k4(x2) {\n                  this._components = x2.slice(), this._time = [0], this.prevMatrix = x2.slice(), this.nextMatrix = x2.slice(), this.computedMatrix = x2.slice(), this.computedInverse = x2.slice(), this.computedEye = [0, 0, 0], this.computedUp = [0, 0, 0], this.computedCenter = [0, 0, 0], this.computedRadius = [0], this._limits = [-1 / 0, 1 / 0];\n                }\n                var E3 = k4.prototype;\n                E3.recalcMatrix = function(x2) {\n                  var C3 = this._time, M4 = s3.le(C3, x2), g3 = this.computedMatrix;\n                  if (!(M4 < 0)) {\n                    var P3 = this._components;\n                    if (M4 === C3.length - 1) for (var T3 = 16 * M4, z3 = 0; z3 < 16; ++z3) g3[z3] = P3[T3++];\n                    else {\n                      for (var O3 = C3[M4 + 1] - C3[M4], T3 = 16 * M4, V2 = this.prevMatrix, G2 = true, z3 = 0; z3 < 16; ++z3) V2[z3] = P3[T3++];\n                      for (var Z = this.nextMatrix, z3 = 0; z3 < 16; ++z3) Z[z3] = P3[T3++], G2 = G2 && V2[z3] === Z[z3];\n                      if (O3 < 1e-6 || G2) for (var z3 = 0; z3 < 16; ++z3) g3[z3] = V2[z3];\n                      else l3(g3, V2, Z, (x2 - C3[M4]) / O3);\n                    }\n                    var j3 = this.computedUp;\n                    j3[0] = g3[1], j3[1] = g3[5], j3[2] = g3[9], b(j3, j3);\n                    var N2 = this.computedInverse;\n                    u4(N2, g3);\n                    var H = this.computedEye, te = N2[15];\n                    H[0] = N2[12] / te, H[1] = N2[13] / te, H[2] = N2[14] / te;\n                    for (var oe = this.computedCenter, _e = Math.exp(this.computedRadius[0]), z3 = 0; z3 < 3; ++z3) oe[z3] = H[z3] - g3[2 + 4 * z3] * _e;\n                  }\n                }, E3.idle = function(x2) {\n                  if (!(x2 < this.lastT())) {\n                    for (var C3 = this._components, M4 = C3.length - 16, g3 = 0; g3 < 16; ++g3) C3.push(C3[M4++]);\n                    this._time.push(x2);\n                  }\n                }, E3.flush = function(x2) {\n                  var C3 = s3.gt(this._time, x2) - 2;\n                  C3 < 0 || (this._time.splice(0, C3), this._components.splice(0, 16 * C3));\n                }, E3.lastT = function() {\n                  return this._time[this._time.length - 1];\n                }, E3.lookAt = function(x2, C3, M4, g3) {\n                  this.recalcMatrix(x2), C3 = C3 || this.computedEye, M4 = M4 || p3, g3 = g3 || this.computedUp, this.setMatrix(x2, d3(this.computedMatrix, C3, M4, g3));\n                  for (var P3 = 0, T3 = 0; T3 < 3; ++T3) P3 += Math.pow(M4[T3] - C3[T3], 2);\n                  P3 = Math.log(Math.sqrt(P3)), this.computedRadius[0] = P3;\n                }, E3.rotate = function(x2, C3, M4, g3) {\n                  this.recalcMatrix(x2);\n                  var P3 = this.computedInverse;\n                  C3 && f4(P3, P3, C3), M4 && c5(P3, P3, M4), g3 && h3(P3, P3, g3), this.setMatrix(x2, u4(this.computedMatrix, P3));\n                };\n                var S2 = [0, 0, 0];\n                E3.pan = function(x2, C3, M4, g3) {\n                  S2[0] = -(C3 || 0), S2[1] = -(M4 || 0), S2[2] = -(g3 || 0), this.recalcMatrix(x2);\n                  var P3 = this.computedInverse;\n                  v3(P3, P3, S2), this.setMatrix(x2, u4(P3, P3));\n                }, E3.translate = function(x2, C3, M4, g3) {\n                  S2[0] = C3 || 0, S2[1] = M4 || 0, S2[2] = g3 || 0, this.recalcMatrix(x2);\n                  var P3 = this.computedMatrix;\n                  v3(P3, P3, S2), this.setMatrix(x2, P3);\n                }, E3.setMatrix = function(x2, C3) {\n                  if (!(x2 < this.lastT())) {\n                    this._time.push(x2);\n                    for (var M4 = 0; M4 < 16; ++M4) this._components.push(C3[M4]);\n                  }\n                }, E3.setDistance = function(x2, C3) {\n                  this.computedRadius[0] = C3;\n                }, E3.setDistanceLimits = function(x2, C3) {\n                  var M4 = this._limits;\n                  M4[0] = x2, M4[1] = C3;\n                }, E3.getDistanceLimits = function(x2) {\n                  var C3 = this._limits;\n                  return x2 ? (x2[0] = C3[0], x2[1] = C3[1], x2) : C3;\n                };\n                function L3(x2) {\n                  x2 = x2 || {};\n                  var C3 = x2.matrix || [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                  return new k4(C3);\n                }\n              }, 1848: function(i3, a4, o4) {\n                var s3 = o4(4905), l3 = o4(6468);\n                i3.exports = u4;\n                function u4(c5) {\n                  for (var f4 = Array.isArray(c5) ? c5 : s3(c5), h3 = 0; h3 < f4.length; h3++) {\n                    var d3 = f4[h3];\n                    if (d3.type === "preprocessor") {\n                      var v3 = d3.data.match(/\\#define\\s+SHADER_NAME(_B64)?\\s+(.+)$/);\n                      if (v3 && v3[2]) {\n                        var _2 = v3[1], b = v3[2];\n                        return (_2 ? l3(b) : b).trim();\n                      }\n                    }\n                  }\n                }\n              }, 1879: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3236), l3 = o4(9405), u4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\nuniform vec3 offset, majorAxis, minorAxis, screenAxis;\nuniform float lineWidth;\nuniform vec2 screenShape;\n\nvec3 project(vec3 p) {\n  vec4 pp = projection * (view * (model * vec4(p, 1.0)));\n  return pp.xyz / max(pp.w, 0.0001);\n}\n\nvoid main() {\n  vec3 major = position.x * majorAxis;\n  vec3 minor = position.y * minorAxis;\n\n  vec3 vPosition = major + minor + offset;\n  vec3 pPosition = project(vPosition);\n  vec3 offset = project(vPosition + screenAxis * position.z);\n\n  vec2 screen = normalize((offset - pPosition).xy * screenShape) / screenShape;\n\n  gl_Position = vec4(pPosition + vec3(0.5 * screen * lineWidth, 0), 1.0);\n}\n`]), c5 = s3([`precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 color;\nvoid main() {\n  gl_FragColor = color;\n}`]);\n                a4.n = function(_2) {\n                  return l3(_2, u4, c5, null, [{ name: "position", type: "vec3" }]);\n                };\n                var f4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\nuniform vec3 offset, axis, alignDir, alignOpt;\nuniform float scale, angle, pixelScale;\nuniform vec2 resolution;\n\nvec3 project(vec3 p) {\n  vec4 pp = projection * (view * (model * vec4(p, 1.0)));\n  return pp.xyz / max(pp.w, 0.0001);\n}\n\nfloat computeViewAngle(vec3 a, vec3 b) {\n  vec3 A = project(a);\n  vec3 B = project(b);\n\n  return atan(\n    (B.y - A.y) * resolution.y,\n    (B.x - A.x) * resolution.x\n  );\n}\n\nconst float PI = 3.141592;\nconst float TWO_PI = 2.0 * PI;\nconst float HALF_PI = 0.5 * PI;\nconst float ONE_AND_HALF_PI = 1.5 * PI;\n\nint option = int(floor(alignOpt.x + 0.001));\nfloat hv_ratio =       alignOpt.y;\nbool enableAlign =    (alignOpt.z != 0.0);\n\nfloat mod_angle(float a) {\n  return mod(a, PI);\n}\n\nfloat positive_angle(float a) {\n  return mod_angle((a < 0.0) ?\n    a + TWO_PI :\n    a\n  );\n}\n\nfloat look_upwards(float a) {\n  float b = positive_angle(a);\n  return ((b > HALF_PI) && (b <= ONE_AND_HALF_PI)) ?\n    b - PI :\n    b;\n}\n\nfloat look_horizontal_or_vertical(float a, float ratio) {\n  // ratio controls the ratio between being horizontal to (vertical + horizontal)\n  // if ratio is set to 0.5 then it is 50%, 50%.\n  // when using a higher ratio e.g. 0.75 the result would\n  // likely be more horizontal than vertical.\n\n  float b = positive_angle(a);\n\n  return\n    (b < (      ratio) * HALF_PI) ? 0.0 :\n    (b < (2.0 - ratio) * HALF_PI) ? -HALF_PI :\n    (b < (2.0 + ratio) * HALF_PI) ? 0.0 :\n    (b < (4.0 - ratio) * HALF_PI) ? HALF_PI :\n                                    0.0;\n}\n\nfloat roundTo(float a, float b) {\n  return float(b * floor((a + 0.5 * b) / b));\n}\n\nfloat look_round_n_directions(float a, int n) {\n  float b = positive_angle(a);\n  float div = TWO_PI / float(n);\n  float c = roundTo(b, div);\n  return look_upwards(c);\n}\n\nfloat applyAlignOption(float rawAngle, float delta) {\n  return\n    (option >  2) ? look_round_n_directions(rawAngle + delta, option) :       // option 3-n: round to n directions\n    (option == 2) ? look_horizontal_or_vertical(rawAngle + delta, hv_ratio) : // horizontal or vertical\n    (option == 1) ? rawAngle + delta :       // use free angle, and flip to align with one direction of the axis\n    (option == 0) ? look_upwards(rawAngle) : // use free angle, and stay upwards\n    (option ==-1) ? 0.0 :                    // useful for backward compatibility, all texts remains horizontal\n                    rawAngle;                // otherwise return back raw input angle\n}\n\nbool isAxisTitle = (axis.x == 0.0) &&\n                   (axis.y == 0.0) &&\n                   (axis.z == 0.0);\n\nvoid main() {\n  //Compute world offset\n  float axisDistance = position.z;\n  vec3 dataPosition = axisDistance * axis + offset;\n\n  float beta = angle; // i.e. user defined attributes for each tick\n\n  float axisAngle;\n  float clipAngle;\n  float flip;\n\n  if (enableAlign) {\n    axisAngle = (isAxisTitle) ? HALF_PI :\n                      computeViewAngle(dataPosition, dataPosition + axis);\n    clipAngle = computeViewAngle(dataPosition, dataPosition + alignDir);\n\n    axisAngle += (sin(axisAngle) < 0.0) ? PI : 0.0;\n    clipAngle += (sin(clipAngle) < 0.0) ? PI : 0.0;\n\n    flip = (dot(vec2(cos(axisAngle), sin(axisAngle)),\n                vec2(sin(clipAngle),-cos(clipAngle))) > 0.0) ? 1.0 : 0.0;\n\n    beta += applyAlignOption(clipAngle, flip * PI);\n  }\n\n  //Compute plane offset\n  vec2 planeCoord = position.xy * pixelScale;\n\n  mat2 planeXform = scale * mat2(\n     cos(beta), sin(beta),\n    -sin(beta), cos(beta)\n  );\n\n  vec2 viewOffset = 2.0 * planeXform * planeCoord / resolution;\n\n  //Compute clip position\n  vec3 clipPosition = project(dataPosition);\n\n  //Apply text offset in clip coordinates\n  clipPosition += vec3(viewOffset, 0.0);\n\n  //Done\n  gl_Position = vec4(clipPosition, 1.0);\n}\n`]), h3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 color;\nvoid main() {\n  gl_FragColor = color;\n}`]);\n                a4.Q = function(_2) {\n                  return l3(_2, f4, h3, null, [{ name: "position", type: "vec3" }]);\n                };\n                var d3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec3 normal;\n\nuniform mat4 model, view, projection;\nuniform vec3 enable;\nuniform vec3 bounds[2];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n\n  vec3 signAxis = sign(bounds[1] - bounds[0]);\n\n  vec3 realNormal = signAxis * normal;\n\n  if(dot(realNormal, enable) > 0.0) {\n    vec3 minRange = min(bounds[0], bounds[1]);\n    vec3 maxRange = max(bounds[0], bounds[1]);\n    vec3 nPosition = mix(minRange, maxRange, 0.5 * (position + 1.0));\n    gl_Position = projection * (view * (model * vec4(nPosition, 1.0)));\n  } else {\n    gl_Position = vec4(0,0,0,0);\n  }\n\n  colorChannel = abs(realNormal);\n}\n`]), v3 = s3([`precision highp float;\n#define GLSLIFY 1\n\nuniform vec4 colors[3];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n  gl_FragColor = colorChannel.x * colors[0] +\n                 colorChannel.y * colors[1] +\n                 colorChannel.z * colors[2];\n}`]);\n                a4.bg = function(_2) {\n                  return l3(_2, d3, v3, null, [{ name: "position", type: "vec3" }, { name: "normal", type: "vec3" }]);\n                };\n              }, 1888: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8828), l3 = o4(1338), u4 = o4(4793).hp;\n                o4.g.__TYPEDARRAY_POOL || (o4.g.__TYPEDARRAY_POOL = { UINT8: l3([32, 0]), UINT16: l3([32, 0]), UINT32: l3([32, 0]), BIGUINT64: l3([32, 0]), INT8: l3([32, 0]), INT16: l3([32, 0]), INT32: l3([32, 0]), BIGINT64: l3([32, 0]), FLOAT: l3([32, 0]), DOUBLE: l3([32, 0]), DATA: l3([32, 0]), UINT8C: l3([32, 0]), BUFFER: l3([32, 0]) });\n                var c5 = typeof Uint8ClampedArray != "undefined", f4 = typeof BigUint64Array != "undefined", h3 = typeof BigInt64Array != "undefined", d3 = o4.g.__TYPEDARRAY_POOL;\n                d3.UINT8C || (d3.UINT8C = l3([32, 0])), d3.BIGUINT64 || (d3.BIGUINT64 = l3([32, 0])), d3.BIGINT64 || (d3.BIGINT64 = l3([32, 0])), d3.BUFFER || (d3.BUFFER = l3([32, 0]));\n                var v3 = d3.DATA, _2 = d3.BUFFER;\n                a4.free = function(j3) {\n                  if (u4.isBuffer(j3)) _2[s3.log2(j3.length)].push(j3);\n                  else {\n                    if (Object.prototype.toString.call(j3) !== "[object ArrayBuffer]" && (j3 = j3.buffer), !j3) return;\n                    var N2 = j3.length || j3.byteLength, H = s3.log2(N2) | 0;\n                    v3[H].push(j3);\n                  }\n                };\n                function b(Z) {\n                  if (Z) {\n                    var j3 = Z.length || Z.byteLength, N2 = s3.log2(j3);\n                    v3[N2].push(Z);\n                  }\n                }\n                function p3(Z) {\n                  b(Z.buffer);\n                }\n                a4.freeUint8 = a4.freeUint16 = a4.freeUint32 = a4.freeBigUint64 = a4.freeInt8 = a4.freeInt16 = a4.freeInt32 = a4.freeBigInt64 = a4.freeFloat32 = a4.freeFloat = a4.freeFloat64 = a4.freeDouble = a4.freeUint8Clamped = a4.freeDataView = p3, a4.freeArrayBuffer = b, a4.freeBuffer = function(j3) {\n                  _2[s3.log2(j3.length)].push(j3);\n                }, a4.malloc = function(j3, N2) {\n                  if (N2 === void 0 || N2 === "arraybuffer") return k4(j3);\n                  switch (N2) {\n                    case "uint8":\n                      return E3(j3);\n                    case "uint16":\n                      return S2(j3);\n                    case "uint32":\n                      return L3(j3);\n                    case "int8":\n                      return x2(j3);\n                    case "int16":\n                      return C3(j3);\n                    case "int32":\n                      return M4(j3);\n                    case "float":\n                    case "float32":\n                      return g3(j3);\n                    case "double":\n                    case "float64":\n                      return P3(j3);\n                    case "uint8_clamped":\n                      return T3(j3);\n                    case "bigint64":\n                      return O3(j3);\n                    case "biguint64":\n                      return z3(j3);\n                    case "buffer":\n                      return G2(j3);\n                    case "data":\n                    case "dataview":\n                      return V2(j3);\n                    default:\n                      return null;\n                  }\n                  return null;\n                };\n                function k4(j3) {\n                  var j3 = s3.nextPow2(j3), N2 = s3.log2(j3), H = v3[N2];\n                  return H.length > 0 ? H.pop() : new ArrayBuffer(j3);\n                }\n                a4.mallocArrayBuffer = k4;\n                function E3(Z) {\n                  return new Uint8Array(k4(Z), 0, Z);\n                }\n                a4.mallocUint8 = E3;\n                function S2(Z) {\n                  return new Uint16Array(k4(2 * Z), 0, Z);\n                }\n                a4.mallocUint16 = S2;\n                function L3(Z) {\n                  return new Uint32Array(k4(4 * Z), 0, Z);\n                }\n                a4.mallocUint32 = L3;\n                function x2(Z) {\n                  return new Int8Array(k4(Z), 0, Z);\n                }\n                a4.mallocInt8 = x2;\n                function C3(Z) {\n                  return new Int16Array(k4(2 * Z), 0, Z);\n                }\n                a4.mallocInt16 = C3;\n                function M4(Z) {\n                  return new Int32Array(k4(4 * Z), 0, Z);\n                }\n                a4.mallocInt32 = M4;\n                function g3(Z) {\n                  return new Float32Array(k4(4 * Z), 0, Z);\n                }\n                a4.mallocFloat32 = a4.mallocFloat = g3;\n                function P3(Z) {\n                  return new Float64Array(k4(8 * Z), 0, Z);\n                }\n                a4.mallocFloat64 = a4.mallocDouble = P3;\n                function T3(Z) {\n                  return c5 ? new Uint8ClampedArray(k4(Z), 0, Z) : E3(Z);\n                }\n                a4.mallocUint8Clamped = T3;\n                function z3(Z) {\n                  return f4 ? new BigUint64Array(k4(8 * Z), 0, Z) : null;\n                }\n                a4.mallocBigUint64 = z3;\n                function O3(Z) {\n                  return h3 ? new BigInt64Array(k4(8 * Z), 0, Z) : null;\n                }\n                a4.mallocBigInt64 = O3;\n                function V2(Z) {\n                  return new DataView(k4(Z), 0, Z);\n                }\n                a4.mallocDataView = V2;\n                function G2(Z) {\n                  Z = s3.nextPow2(Z);\n                  var j3 = s3.log2(Z), N2 = _2[j3];\n                  return N2.length > 0 ? N2.pop() : new u4(Z);\n                }\n                a4.mallocBuffer = G2, a4.clearCache = function() {\n                  for (var j3 = 0; j3 < 32; ++j3) d3.UINT8[j3].length = 0, d3.UINT16[j3].length = 0, d3.UINT32[j3].length = 0, d3.INT8[j3].length = 0, d3.INT16[j3].length = 0, d3.INT32[j3].length = 0, d3.FLOAT[j3].length = 0, d3.DOUBLE[j3].length = 0, d3.BIGUINT64[j3].length = 0, d3.BIGINT64[j3].length = 0, d3.UINT8C[j3].length = 0, v3[j3].length = 0, _2[j3].length = 0;\n                };\n              }, 1903: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = new Float32Array(16);\n                  return s3[0] = o4[0], s3[1] = o4[1], s3[2] = o4[2], s3[3] = o4[3], s3[4] = o4[4], s3[5] = o4[5], s3[6] = o4[6], s3[7] = o4[7], s3[8] = o4[8], s3[9] = o4[9], s3[10] = o4[10], s3[11] = o4[11], s3[12] = o4[12], s3[13] = o4[13], s3[14] = o4[14], s3[15] = o4[15], s3;\n                }\n              }, 1944: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5250), l3 = o4(8210);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  for (var h3 = s3(c5[0], f4[0]), d3 = 1; d3 < c5.length; ++d3) h3 = l3(h3, s3(c5[d3], f4[d3]));\n                  return h3;\n                }\n              }, 1964: function(i3, a4, o4) {\n                i3.exports = { alpha_shape: o4(3502), convex_hull: o4(7352), delaunay_triangulate: o4(7642), gl_cone3d: o4(6405), gl_error3d: o4(9165), gl_line3d: o4(5714), gl_mesh3d: o4(7201), gl_plot3d: o4(4100), gl_scatter3d: o4(8418), gl_streamtube3d: o4(7815), gl_surface3d: o4(9499), ndarray: o4(9618), ndarray_linear_interpolate: o4(4317) };\n              }, 2014: function(i3, a4, o4) {\n                "use strict";\n                "use restrict";\n                var s3 = o4(3105), l3 = o4(4623);\n                function u4(g3) {\n                  for (var P3 = 0, T3 = Math.max, z3 = 0, O3 = g3.length; z3 < O3; ++z3) P3 = T3(P3, g3[z3].length);\n                  return P3 - 1;\n                }\n                a4.dimension = u4;\n                function c5(g3) {\n                  for (var P3 = -1, T3 = Math.max, z3 = 0, O3 = g3.length; z3 < O3; ++z3) for (var V2 = g3[z3], G2 = 0, Z = V2.length; G2 < Z; ++G2) P3 = T3(P3, V2[G2]);\n                  return P3 + 1;\n                }\n                a4.countVertices = c5;\n                function f4(g3) {\n                  for (var P3 = new Array(g3.length), T3 = 0, z3 = g3.length; T3 < z3; ++T3) P3[T3] = g3[T3].slice(0);\n                  return P3;\n                }\n                a4.cloneCells = f4;\n                function h3(g3, P3) {\n                  var T3 = g3.length, z3 = g3.length - P3.length, O3 = Math.min;\n                  if (z3) return z3;\n                  switch (T3) {\n                    case 0:\n                      return 0;\n                    case 1:\n                      return g3[0] - P3[0];\n                    case 2:\n                      var N2 = g3[0] + g3[1] - P3[0] - P3[1];\n                      return N2 || O3(g3[0], g3[1]) - O3(P3[0], P3[1]);\n                    case 3:\n                      var V2 = g3[0] + g3[1], G2 = P3[0] + P3[1];\n                      if (N2 = V2 + g3[2] - (G2 + P3[2]), N2) return N2;\n                      var Z = O3(g3[0], g3[1]), j3 = O3(P3[0], P3[1]), N2 = O3(Z, g3[2]) - O3(j3, P3[2]);\n                      return N2 || O3(Z + g3[2], V2) - O3(j3 + P3[2], G2);\n                    default:\n                      var H = g3.slice(0);\n                      H.sort();\n                      var te = P3.slice(0);\n                      te.sort();\n                      for (var oe = 0; oe < T3; ++oe) if (z3 = H[oe] - te[oe], z3) return z3;\n                      return 0;\n                  }\n                }\n                a4.compareCells = h3;\n                function d3(g3, P3) {\n                  return h3(g3[0], P3[0]);\n                }\n                function v3(g3, P3) {\n                  if (P3) {\n                    for (var T3 = g3.length, z3 = new Array(T3), O3 = 0; O3 < T3; ++O3) z3[O3] = [g3[O3], P3[O3]];\n                    z3.sort(d3);\n                    for (var O3 = 0; O3 < T3; ++O3) g3[O3] = z3[O3][0], P3[O3] = z3[O3][1];\n                    return g3;\n                  } else return g3.sort(h3), g3;\n                }\n                a4.normalize = v3;\n                function _2(g3) {\n                  if (g3.length === 0) return [];\n                  for (var P3 = 1, T3 = g3.length, z3 = 1; z3 < T3; ++z3) {\n                    var O3 = g3[z3];\n                    if (h3(O3, g3[z3 - 1])) {\n                      if (z3 === P3) {\n                        P3++;\n                        continue;\n                      }\n                      g3[P3++] = O3;\n                    }\n                  }\n                  return g3.length = P3, g3;\n                }\n                a4.unique = _2;\n                function b(g3, P3) {\n                  for (var T3 = 0, z3 = g3.length - 1, O3 = -1; T3 <= z3; ) {\n                    var V2 = T3 + z3 >> 1, G2 = h3(g3[V2], P3);\n                    G2 <= 0 ? (G2 === 0 && (O3 = V2), T3 = V2 + 1) : G2 > 0 && (z3 = V2 - 1);\n                  }\n                  return O3;\n                }\n                a4.findCell = b;\n                function p3(g3, P3) {\n                  for (var T3 = new Array(g3.length), z3 = 0, O3 = T3.length; z3 < O3; ++z3) T3[z3] = [];\n                  for (var V2 = [], z3 = 0, G2 = P3.length; z3 < G2; ++z3) for (var Z = P3[z3], j3 = Z.length, N2 = 1, H = 1 << j3; N2 < H; ++N2) {\n                    V2.length = s3.popCount(N2);\n                    for (var te = 0, oe = 0; oe < j3; ++oe) N2 & 1 << oe && (V2[te++] = Z[oe]);\n                    var _e = b(g3, V2);\n                    if (!(_e < 0)) for (; T3[_e++].push(z3), !(_e >= g3.length || h3(g3[_e], V2) !== 0); ) ;\n                  }\n                  return T3;\n                }\n                a4.incidence = p3;\n                function k4(g3, P3) {\n                  if (!P3) return p3(_2(S2(g3, 0)), g3, 0);\n                  for (var T3 = new Array(P3), z3 = 0; z3 < P3; ++z3) T3[z3] = [];\n                  for (var z3 = 0, O3 = g3.length; z3 < O3; ++z3) for (var V2 = g3[z3], G2 = 0, Z = V2.length; G2 < Z; ++G2) T3[V2[G2]].push(z3);\n                  return T3;\n                }\n                a4.dual = k4;\n                function E3(g3) {\n                  for (var P3 = [], T3 = 0, z3 = g3.length; T3 < z3; ++T3) for (var O3 = g3[T3], V2 = O3.length | 0, G2 = 1, Z = 1 << V2; G2 < Z; ++G2) {\n                    for (var j3 = [], N2 = 0; N2 < V2; ++N2) G2 >>> N2 & 1 && j3.push(O3[N2]);\n                    P3.push(j3);\n                  }\n                  return v3(P3);\n                }\n                a4.explode = E3;\n                function S2(g3, P3) {\n                  if (P3 < 0) return [];\n                  for (var T3 = [], z3 = (1 << P3 + 1) - 1, O3 = 0; O3 < g3.length; ++O3) for (var V2 = g3[O3], G2 = z3; G2 < 1 << V2.length; G2 = s3.nextCombination(G2)) {\n                    for (var Z = new Array(P3 + 1), j3 = 0, N2 = 0; N2 < V2.length; ++N2) G2 & 1 << N2 && (Z[j3++] = V2[N2]);\n                    T3.push(Z);\n                  }\n                  return v3(T3);\n                }\n                a4.skeleton = S2;\n                function L3(g3) {\n                  for (var P3 = [], T3 = 0, z3 = g3.length; T3 < z3; ++T3) for (var O3 = g3[T3], V2 = 0, G2 = O3.length; V2 < G2; ++V2) {\n                    for (var Z = new Array(O3.length - 1), j3 = 0, N2 = 0; j3 < G2; ++j3) j3 !== V2 && (Z[N2++] = O3[j3]);\n                    P3.push(Z);\n                  }\n                  return v3(P3);\n                }\n                a4.boundary = L3;\n                function x2(g3, P3) {\n                  for (var T3 = new l3(P3), z3 = 0; z3 < g3.length; ++z3) for (var O3 = g3[z3], V2 = 0; V2 < O3.length; ++V2) for (var G2 = V2 + 1; G2 < O3.length; ++G2) T3.link(O3[V2], O3[G2]);\n                  for (var Z = [], j3 = T3.ranks, z3 = 0; z3 < j3.length; ++z3) j3[z3] = -1;\n                  for (var z3 = 0; z3 < g3.length; ++z3) {\n                    var N2 = T3.find(g3[z3][0]);\n                    j3[N2] < 0 ? (j3[N2] = Z.length, Z.push([g3[z3].slice(0)])) : Z[j3[N2]].push(g3[z3].slice(0));\n                  }\n                  return Z;\n                }\n                function C3(g3) {\n                  for (var P3 = _2(v3(S2(g3, 0))), T3 = new l3(P3.length), z3 = 0; z3 < g3.length; ++z3) for (var O3 = g3[z3], V2 = 0; V2 < O3.length; ++V2) for (var G2 = b(P3, [O3[V2]]), Z = V2 + 1; Z < O3.length; ++Z) T3.link(G2, b(P3, [O3[Z]]));\n                  for (var j3 = [], N2 = T3.ranks, z3 = 0; z3 < N2.length; ++z3) N2[z3] = -1;\n                  for (var z3 = 0; z3 < g3.length; ++z3) {\n                    var H = T3.find(b(P3, [g3[z3][0]]));\n                    N2[H] < 0 ? (N2[H] = j3.length, j3.push([g3[z3].slice(0)])) : j3[N2[H]].push(g3[z3].slice(0));\n                  }\n                  return j3;\n                }\n                function M4(g3, P3) {\n                  return P3 ? x2(g3, P3) : C3(g3);\n                }\n                a4.connectedComponents = M4;\n              }, 2095: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = b;\n                var s3 = o4(3134), l3 = o4(3088), u4 = o4(5085), c5 = o4(5250), f4 = o4(8210), h3 = o4(1682), d3 = o4(5609);\n                function v3(p3, k4) {\n                  for (var E3 = new Array(p3), S2 = 0; S2 < p3; ++S2) E3[S2] = k4;\n                  return E3;\n                }\n                function _2(p3) {\n                  for (var k4 = new Array(p3), E3 = 0; E3 < p3; ++E3) k4[E3] = [];\n                  return k4;\n                }\n                function b(p3, k4) {\n                  var Re = d3(p3, k4);\n                  p3 = Re[0], k4 = Re[1];\n                  for (var E3 = k4.length, S2 = p3.length, L3 = s3(p3, k4.length), x2 = 0; x2 < E3; ++x2) if (L3[x2].length % 2 === 1) throw new Error("planar-graph-to-polyline: graph must be manifold");\n                  var C3 = l3(p3, k4);\n                  function M4(lt) {\n                    for (var Gt = lt.length, Nt = [0], Jt = 0; Jt < Gt; ++Jt) {\n                      var sr = k4[lt[Jt]], wr = k4[lt[(Jt + 1) % Gt]], cr = c5(-sr[0], sr[1]), $e = c5(-sr[0], wr[1]), St = c5(wr[0], sr[1]), Qt = c5(wr[0], wr[1]);\n                      Nt = f4(Nt, f4(f4(cr, $e), f4(St, Qt)));\n                    }\n                    return Nt[Nt.length - 1] > 0;\n                  }\n                  C3 = C3.filter(M4);\n                  for (var g3 = C3.length, P3 = new Array(g3), T3 = new Array(g3), x2 = 0; x2 < g3; ++x2) {\n                    P3[x2] = x2;\n                    var z3 = new Array(g3), O3 = C3[x2].map(function(Gt) {\n                      return k4[Gt];\n                    }), V2 = u4([O3]), G2 = 0;\n                    e: for (var Z = 0; Z < g3; ++Z) if (z3[Z] = 0, x2 !== Z) {\n                      for (var j3 = C3[Z], N2 = j3.length, H = 0; H < N2; ++H) {\n                        var te = V2(k4[j3[H]]);\n                        if (te !== 0) {\n                          te < 0 && (z3[Z] = 1, G2 += 1);\n                          continue e;\n                        }\n                      }\n                      z3[Z] = 1, G2 += 1;\n                    }\n                    T3[x2] = [G2, x2, z3];\n                  }\n                  T3.sort(function(lt, Gt) {\n                    return Gt[0] - lt[0];\n                  });\n                  for (var x2 = 0; x2 < g3; ++x2) for (var z3 = T3[x2], oe = z3[1], _e = z3[2], Z = 0; Z < g3; ++Z) _e[Z] && (P3[Z] = oe);\n                  for (var Ee = _2(g3), x2 = 0; x2 < g3; ++x2) Ee[x2].push(P3[x2]), Ee[P3[x2]].push(x2);\n                  for (var Ce = {}, me = v3(E3, false), x2 = 0; x2 < g3; ++x2) for (var j3 = C3[x2], N2 = j3.length, Z = 0; Z < N2; ++Z) {\n                    var ie = j3[Z], Se = j3[(Z + 1) % N2], Le = Math.min(ie, Se) + ":" + Math.max(ie, Se);\n                    if (Le in Ce) {\n                      var Ae = Ce[Le];\n                      Ee[Ae].push(x2), Ee[x2].push(Ae), me[ie] = me[Se] = true;\n                    } else Ce[Le] = x2;\n                  }\n                  function Fe(lt) {\n                    for (var Gt = lt.length, Nt = 0; Nt < Gt; ++Nt) if (!me[lt[Nt]]) return false;\n                    return true;\n                  }\n                  for (var Pe = [], ge = v3(g3, -1), x2 = 0; x2 < g3; ++x2) P3[x2] === x2 && !Fe(C3[x2]) ? (Pe.push(x2), ge[x2] = 0) : ge[x2] = -1;\n                  for (var Re = []; Pe.length > 0; ) {\n                    var ce = Pe.pop(), Ze = Ee[ce];\n                    h3(Ze, function(lt, Gt) {\n                      return lt - Gt;\n                    });\n                    var ut = Ze.length, pt = ge[ce], Zt;\n                    if (pt === 0) {\n                      var j3 = C3[ce];\n                      Zt = [j3];\n                    }\n                    for (var x2 = 0; x2 < ut; ++x2) {\n                      var st = Ze[x2];\n                      if (!(ge[st] >= 0) && (ge[st] = pt ^ 1, Pe.push(st), pt === 0)) {\n                        var j3 = C3[st];\n                        Fe(j3) || (j3.reverse(), Zt.push(j3));\n                      }\n                    }\n                    pt === 0 && Re.push(Zt);\n                  }\n                  return Re;\n                }\n              }, 2145: function(i3, a4) {\n                "use strict";\n                a4.uniforms = u4, a4.attributes = c5;\n                var o4 = { FLOAT: "float", FLOAT_VEC2: "vec2", FLOAT_VEC3: "vec3", FLOAT_VEC4: "vec4", INT: "int", INT_VEC2: "ivec2", INT_VEC3: "ivec3", INT_VEC4: "ivec4", BOOL: "bool", BOOL_VEC2: "bvec2", BOOL_VEC3: "bvec3", BOOL_VEC4: "bvec4", FLOAT_MAT2: "mat2", FLOAT_MAT3: "mat3", FLOAT_MAT4: "mat4", SAMPLER_2D: "sampler2D", SAMPLER_CUBE: "samplerCube" }, s3 = null;\n                function l3(f4, h3) {\n                  if (!s3) {\n                    var d3 = Object.keys(o4);\n                    s3 = {};\n                    for (var v3 = 0; v3 < d3.length; ++v3) {\n                      var _2 = d3[v3];\n                      s3[f4[_2]] = o4[_2];\n                    }\n                  }\n                  return s3[h3];\n                }\n                function u4(f4, h3) {\n                  for (var d3 = f4.getProgramParameter(h3, f4.ACTIVE_UNIFORMS), v3 = [], _2 = 0; _2 < d3; ++_2) {\n                    var b = f4.getActiveUniform(h3, _2);\n                    if (b) {\n                      var p3 = l3(f4, b.type);\n                      if (b.size > 1) for (var k4 = 0; k4 < b.size; ++k4) v3.push({ name: b.name.replace("[0]", "[" + k4 + "]"), type: p3 });\n                      else v3.push({ name: b.name, type: p3 });\n                    }\n                  }\n                  return v3;\n                }\n                function c5(f4, h3) {\n                  for (var d3 = f4.getProgramParameter(h3, f4.ACTIVE_ATTRIBUTES), v3 = [], _2 = 0; _2 < d3; ++_2) {\n                    var b = f4.getActiveAttrib(h3, _2);\n                    b && v3.push({ name: b.name, type: l3(f4, b.type) });\n                  }\n                  return v3;\n                }\n              }, 2229: function(i3, a4, o4) {\n                i3.exports = o4(6843);\n              }, 2260: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(7766);\n                i3.exports = C3;\n                var l3 = null, u4, c5, f4, h3;\n                function d3(M4) {\n                  var g3 = M4.getParameter(M4.FRAMEBUFFER_BINDING), P3 = M4.getParameter(M4.RENDERBUFFER_BINDING), T3 = M4.getParameter(M4.TEXTURE_BINDING_2D);\n                  return [g3, P3, T3];\n                }\n                function v3(M4, g3) {\n                  M4.bindFramebuffer(M4.FRAMEBUFFER, g3[0]), M4.bindRenderbuffer(M4.RENDERBUFFER, g3[1]), M4.bindTexture(M4.TEXTURE_2D, g3[2]);\n                }\n                function _2(M4, g3) {\n                  var P3 = M4.getParameter(g3.MAX_COLOR_ATTACHMENTS_WEBGL);\n                  l3 = new Array(P3 + 1);\n                  for (var T3 = 0; T3 <= P3; ++T3) {\n                    for (var z3 = new Array(P3), O3 = 0; O3 < T3; ++O3) z3[O3] = M4.COLOR_ATTACHMENT0 + O3;\n                    for (var O3 = T3; O3 < P3; ++O3) z3[O3] = M4.NONE;\n                    l3[T3] = z3;\n                  }\n                }\n                function b(M4) {\n                  switch (M4) {\n                    case u4:\n                      throw new Error("gl-fbo: Framebuffer unsupported");\n                    case c5:\n                      throw new Error("gl-fbo: Framebuffer incomplete attachment");\n                    case f4:\n                      throw new Error("gl-fbo: Framebuffer incomplete dimensions");\n                    case h3:\n                      throw new Error("gl-fbo: Framebuffer incomplete missing attachment");\n                    default:\n                      throw new Error("gl-fbo: Framebuffer failed for unspecified reason");\n                  }\n                }\n                function p3(M4, g3, P3, T3, z3, O3) {\n                  if (!T3) return null;\n                  var V2 = s3(M4, g3, P3, z3, T3);\n                  return V2.magFilter = M4.NEAREST, V2.minFilter = M4.NEAREST, V2.mipSamples = 1, V2.bind(), M4.framebufferTexture2D(M4.FRAMEBUFFER, O3, M4.TEXTURE_2D, V2.handle, 0), V2;\n                }\n                function k4(M4, g3, P3, T3, z3) {\n                  var O3 = M4.createRenderbuffer();\n                  return M4.bindRenderbuffer(M4.RENDERBUFFER, O3), M4.renderbufferStorage(M4.RENDERBUFFER, T3, g3, P3), M4.framebufferRenderbuffer(M4.FRAMEBUFFER, z3, M4.RENDERBUFFER, O3), O3;\n                }\n                function E3(M4) {\n                  var g3 = d3(M4.gl), P3 = M4.gl, T3 = M4.handle = P3.createFramebuffer(), z3 = M4._shape[0], O3 = M4._shape[1], V2 = M4.color.length, G2 = M4._ext, Z = M4._useStencil, j3 = M4._useDepth, N2 = M4._colorType;\n                  P3.bindFramebuffer(P3.FRAMEBUFFER, T3);\n                  for (var H = 0; H < V2; ++H) M4.color[H] = p3(P3, z3, O3, N2, P3.RGBA, P3.COLOR_ATTACHMENT0 + H);\n                  V2 === 0 ? (M4._color_rb = k4(P3, z3, O3, P3.RGBA4, P3.COLOR_ATTACHMENT0), G2 && G2.drawBuffersWEBGL(l3[0])) : V2 > 1 && G2.drawBuffersWEBGL(l3[V2]);\n                  var te = P3.getExtension("WEBGL_depth_texture");\n                  te ? Z ? M4.depth = p3(P3, z3, O3, te.UNSIGNED_INT_24_8_WEBGL, P3.DEPTH_STENCIL, P3.DEPTH_STENCIL_ATTACHMENT) : j3 && (M4.depth = p3(P3, z3, O3, P3.UNSIGNED_SHORT, P3.DEPTH_COMPONENT, P3.DEPTH_ATTACHMENT)) : j3 && Z ? M4._depth_rb = k4(P3, z3, O3, P3.DEPTH_STENCIL, P3.DEPTH_STENCIL_ATTACHMENT) : j3 ? M4._depth_rb = k4(P3, z3, O3, P3.DEPTH_COMPONENT16, P3.DEPTH_ATTACHMENT) : Z && (M4._depth_rb = k4(P3, z3, O3, P3.STENCIL_INDEX, P3.STENCIL_ATTACHMENT));\n                  var oe = P3.checkFramebufferStatus(P3.FRAMEBUFFER);\n                  if (oe !== P3.FRAMEBUFFER_COMPLETE) {\n                    M4._destroyed = true, P3.bindFramebuffer(P3.FRAMEBUFFER, null), P3.deleteFramebuffer(M4.handle), M4.handle = null, M4.depth && (M4.depth.dispose(), M4.depth = null), M4._depth_rb && (P3.deleteRenderbuffer(M4._depth_rb), M4._depth_rb = null);\n                    for (var H = 0; H < M4.color.length; ++H) M4.color[H].dispose(), M4.color[H] = null;\n                    M4._color_rb && (P3.deleteRenderbuffer(M4._color_rb), M4._color_rb = null), v3(P3, g3), b(oe);\n                  }\n                  v3(P3, g3);\n                }\n                function S2(M4, g3, P3, T3, z3, O3, V2, G2) {\n                  this.gl = M4, this._shape = [g3 | 0, P3 | 0], this._destroyed = false, this._ext = G2, this.color = new Array(z3);\n                  for (var Z = 0; Z < z3; ++Z) this.color[Z] = null;\n                  this._color_rb = null, this.depth = null, this._depth_rb = null, this._colorType = T3, this._useDepth = O3, this._useStencil = V2;\n                  var j3 = this, N2 = [g3 | 0, P3 | 0];\n                  Object.defineProperties(N2, { 0: { get: function() {\n                    return j3._shape[0];\n                  }, set: function(H) {\n                    return j3.width = H;\n                  } }, 1: { get: function() {\n                    return j3._shape[1];\n                  }, set: function(H) {\n                    return j3.height = H;\n                  } } }), this._shapeVector = N2, E3(this);\n                }\n                var L3 = S2.prototype;\n                function x2(M4, g3, P3) {\n                  if (M4._destroyed) throw new Error("gl-fbo: Can\'t resize destroyed FBO");\n                  if (!(M4._shape[0] === g3 && M4._shape[1] === P3)) {\n                    var T3 = M4.gl, z3 = T3.getParameter(T3.MAX_RENDERBUFFER_SIZE);\n                    if (g3 < 0 || g3 > z3 || P3 < 0 || P3 > z3) throw new Error("gl-fbo: Can\'t resize FBO, invalid dimensions");\n                    M4._shape[0] = g3, M4._shape[1] = P3;\n                    for (var O3 = d3(T3), V2 = 0; V2 < M4.color.length; ++V2) M4.color[V2].shape = M4._shape;\n                    M4._color_rb && (T3.bindRenderbuffer(T3.RENDERBUFFER, M4._color_rb), T3.renderbufferStorage(T3.RENDERBUFFER, T3.RGBA4, M4._shape[0], M4._shape[1])), M4.depth && (M4.depth.shape = M4._shape), M4._depth_rb && (T3.bindRenderbuffer(T3.RENDERBUFFER, M4._depth_rb), M4._useDepth && M4._useStencil ? T3.renderbufferStorage(T3.RENDERBUFFER, T3.DEPTH_STENCIL, M4._shape[0], M4._shape[1]) : M4._useDepth ? T3.renderbufferStorage(T3.RENDERBUFFER, T3.DEPTH_COMPONENT16, M4._shape[0], M4._shape[1]) : M4._useStencil && T3.renderbufferStorage(T3.RENDERBUFFER, T3.STENCIL_INDEX, M4._shape[0], M4._shape[1])), T3.bindFramebuffer(T3.FRAMEBUFFER, M4.handle);\n                    var G2 = T3.checkFramebufferStatus(T3.FRAMEBUFFER);\n                    G2 !== T3.FRAMEBUFFER_COMPLETE && (M4.dispose(), v3(T3, O3), b(G2)), v3(T3, O3);\n                  }\n                }\n                Object.defineProperties(L3, { shape: { get: function() {\n                  return this._destroyed ? [0, 0] : this._shapeVector;\n                }, set: function(M4) {\n                  if (Array.isArray(M4) || (M4 = [M4 | 0, M4 | 0]), M4.length !== 2) throw new Error("gl-fbo: Shape vector must be length 2");\n                  var g3 = M4[0] | 0, P3 = M4[1] | 0;\n                  return x2(this, g3, P3), [g3, P3];\n                }, enumerable: false }, width: { get: function() {\n                  return this._destroyed ? 0 : this._shape[0];\n                }, set: function(M4) {\n                  return M4 = M4 | 0, x2(this, M4, this._shape[1]), M4;\n                }, enumerable: false }, height: { get: function() {\n                  return this._destroyed ? 0 : this._shape[1];\n                }, set: function(M4) {\n                  return M4 = M4 | 0, x2(this, this._shape[0], M4), M4;\n                }, enumerable: false } }), L3.bind = function() {\n                  if (!this._destroyed) {\n                    var M4 = this.gl;\n                    M4.bindFramebuffer(M4.FRAMEBUFFER, this.handle), M4.viewport(0, 0, this._shape[0], this._shape[1]);\n                  }\n                }, L3.dispose = function() {\n                  if (!this._destroyed) {\n                    this._destroyed = true;\n                    var M4 = this.gl;\n                    M4.deleteFramebuffer(this.handle), this.handle = null, this.depth && (this.depth.dispose(), this.depth = null), this._depth_rb && (M4.deleteRenderbuffer(this._depth_rb), this._depth_rb = null);\n                    for (var g3 = 0; g3 < this.color.length; ++g3) this.color[g3].dispose(), this.color[g3] = null;\n                    this._color_rb && (M4.deleteRenderbuffer(this._color_rb), this._color_rb = null);\n                  }\n                };\n                function C3(M4, g3, P3, T3) {\n                  u4 || (u4 = M4.FRAMEBUFFER_UNSUPPORTED, c5 = M4.FRAMEBUFFER_INCOMPLETE_ATTACHMENT, f4 = M4.FRAMEBUFFER_INCOMPLETE_DIMENSIONS, h3 = M4.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);\n                  var z3 = M4.getExtension("WEBGL_draw_buffers");\n                  if (!l3 && z3 && _2(M4, z3), Array.isArray(g3) && (T3 = P3, P3 = g3[1] | 0, g3 = g3[0] | 0), typeof g3 != "number") throw new Error("gl-fbo: Missing shape parameter");\n                  var O3 = M4.getParameter(M4.MAX_RENDERBUFFER_SIZE);\n                  if (g3 < 0 || g3 > O3 || P3 < 0 || P3 > O3) throw new Error("gl-fbo: Parameters are too large for FBO");\n                  T3 = T3 || {};\n                  var V2 = 1;\n                  if ("color" in T3) {\n                    if (V2 = Math.max(T3.color | 0, 0), V2 < 0) throw new Error("gl-fbo: Must specify a nonnegative number of colors");\n                    if (V2 > 1) if (z3) {\n                      if (V2 > M4.getParameter(z3.MAX_COLOR_ATTACHMENTS_WEBGL)) throw new Error("gl-fbo: Context does not support " + V2 + " draw buffers");\n                    } else throw new Error("gl-fbo: Multiple draw buffer extension not supported");\n                  }\n                  var G2 = M4.UNSIGNED_BYTE, Z = M4.getExtension("OES_texture_float");\n                  if (T3.float && V2 > 0) {\n                    if (!Z) throw new Error("gl-fbo: Context does not support floating point textures");\n                    G2 = M4.FLOAT;\n                  } else T3.preferFloat && V2 > 0 && Z && (G2 = M4.FLOAT);\n                  var j3 = true;\n                  "depth" in T3 && (j3 = !!T3.depth);\n                  var N2 = false;\n                  return "stencil" in T3 && (N2 = !!T3.stencil), new S2(M4, g3, P3, G2, V2, j3, N2, z3);\n                }\n              }, 2272: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2646)[4], l3 = o4(2478);\n                i3.exports = c5;\n                function u4(f4, h3, d3, v3, _2, b) {\n                  var p3 = h3.opposite(v3, _2);\n                  if (!(p3 < 0)) {\n                    if (_2 < v3) {\n                      var k4 = v3;\n                      v3 = _2, _2 = k4, k4 = b, b = p3, p3 = k4;\n                    }\n                    h3.isConstraint(v3, _2) || s3(f4[v3], f4[_2], f4[b], f4[p3]) < 0 && d3.push(v3, _2);\n                  }\n                }\n                function c5(f4, h3) {\n                  for (var d3 = [], v3 = f4.length, _2 = h3.stars, b = 0; b < v3; ++b) for (var p3 = _2[b], k4 = 1; k4 < p3.length; k4 += 2) {\n                    var E3 = p3[k4];\n                    if (!(E3 < b) && !h3.isConstraint(b, E3)) {\n                      for (var S2 = p3[k4 - 1], L3 = -1, x2 = 1; x2 < p3.length; x2 += 2) if (p3[x2 - 1] === E3) {\n                        L3 = p3[x2];\n                        break;\n                      }\n                      L3 < 0 || s3(f4[b], f4[E3], f4[S2], f4[L3]) < 0 && d3.push(b, E3);\n                    }\n                  }\n                  for (; d3.length > 0; ) {\n                    for (var E3 = d3.pop(), b = d3.pop(), S2 = -1, L3 = -1, p3 = _2[b], C3 = 1; C3 < p3.length; C3 += 2) {\n                      var M4 = p3[C3 - 1], g3 = p3[C3];\n                      M4 === E3 ? L3 = g3 : g3 === E3 && (S2 = M4);\n                    }\n                    S2 < 0 || L3 < 0 || s3(f4[b], f4[E3], f4[S2], f4[L3]) >= 0 || (h3.flip(b, E3), u4(f4, h3, d3, S2, b, L3), u4(f4, h3, d3, b, L3, S2), u4(f4, h3, d3, L3, E3, S2), u4(f4, h3, d3, E3, S2, L3));\n                  }\n                }\n              }, 2334: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = Math.min(s3[0], l3[0]), o4[1] = Math.min(s3[1], l3[1]), o4[2] = Math.min(s3[2], l3[2]), o4[3] = Math.min(s3[3], l3[3]), o4;\n                }\n              }, 2335: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = new Float32Array(4);\n                  return s3[0] = o4[0], s3[1] = o4[1], s3[2] = o4[2], s3[3] = o4[3], s3;\n                }\n              }, 2361: function(i3) {\n                var a4 = false;\n                if (typeof Float64Array != "undefined") {\n                  var o4 = new Float64Array(1), s3 = new Uint32Array(o4.buffer);\n                  if (o4[0] = 1, a4 = true, s3[1] === 1072693248) {\n                    let k4 = function(L3, x2) {\n                      return s3[0] = L3, s3[1] = x2, o4[0];\n                    }, E3 = function(L3) {\n                      return o4[0] = L3, s3[0];\n                    }, S2 = function(L3) {\n                      return o4[0] = L3, s3[1];\n                    };\n                    var u4 = k4, c5 = E3, f4 = S2;\n                    i3.exports = function(x2) {\n                      return o4[0] = x2, [s3[0], s3[1]];\n                    }, i3.exports.pack = k4, i3.exports.lo = E3, i3.exports.hi = S2;\n                  } else if (s3[0] === 1072693248) {\n                    let k4 = function(L3, x2) {\n                      return s3[1] = L3, s3[0] = x2, o4[0];\n                    }, E3 = function(L3) {\n                      return o4[0] = L3, s3[1];\n                    }, S2 = function(L3) {\n                      return o4[0] = L3, s3[0];\n                    };\n                    var h3 = k4, d3 = E3, v3 = S2;\n                    i3.exports = function(x2) {\n                      return o4[0] = x2, [s3[1], s3[0]];\n                    }, i3.exports.pack = k4, i3.exports.lo = E3, i3.exports.hi = S2;\n                  } else a4 = false;\n                }\n                if (!a4) {\n                  let k4 = function(L3, x2) {\n                    return l3.writeUInt32LE(L3, 0, true), l3.writeUInt32LE(x2, 4, true), l3.readDoubleLE(0, true);\n                  }, E3 = function(L3) {\n                    return l3.writeDoubleLE(L3, 0, true), l3.readUInt32LE(0, true);\n                  }, S2 = function(L3) {\n                    return l3.writeDoubleLE(L3, 0, true), l3.readUInt32LE(4, true);\n                  };\n                  var _2 = k4, b = E3, p3 = S2, l3 = new Buffer(8);\n                  i3.exports = function(x2) {\n                    return l3.writeDoubleLE(x2, 0, true), [l3.readUInt32LE(0, true), l3.readUInt32LE(4, true)];\n                  }, i3.exports.pack = k4, i3.exports.lo = E3, i3.exports.hi = S2;\n                }\n                i3.exports.sign = function(k4) {\n                  return i3.exports.hi(k4) >>> 31;\n                }, i3.exports.exponent = function(k4) {\n                  var E3 = i3.exports.hi(k4);\n                  return (E3 << 1 >>> 21) - 1023;\n                }, i3.exports.fraction = function(k4) {\n                  var E3 = i3.exports.lo(k4), S2 = i3.exports.hi(k4), L3 = S2 & (1 << 20) - 1;\n                  return S2 & 2146435072 && (L3 += 1048576), [E3, L3];\n                }, i3.exports.denormalized = function(k4) {\n                  var E3 = i3.exports.hi(k4);\n                  return !(E3 & 2146435072);\n                };\n              }, 2408: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = Math.sin(l3), c5 = Math.cos(l3), f4 = s3[0], h3 = s3[1], d3 = s3[2], v3 = s3[3], _2 = s3[8], b = s3[9], p3 = s3[10], k4 = s3[11];\n                  return s3 !== o4 && (o4[4] = s3[4], o4[5] = s3[5], o4[6] = s3[6], o4[7] = s3[7], o4[12] = s3[12], o4[13] = s3[13], o4[14] = s3[14], o4[15] = s3[15]), o4[0] = f4 * c5 - _2 * u4, o4[1] = h3 * c5 - b * u4, o4[2] = d3 * c5 - p3 * u4, o4[3] = v3 * c5 - k4 * u4, o4[8] = f4 * u4 + _2 * c5, o4[9] = h3 * u4 + b * c5, o4[10] = d3 * u4 + p3 * c5, o4[11] = v3 * u4 + k4 * c5, o4;\n                }\n              }, 2419: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4) {\n                  for (var s3 = 1, l3 = 1; l3 < o4.length; ++l3) for (var u4 = 0; u4 < l3; ++u4) if (o4[l3] < o4[u4]) s3 = -s3;\n                  else if (o4[u4] === o4[l3]) return 0;\n                  return s3;\n                }\n              }, 2447: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = Math.round(s3[0]), o4[1] = Math.round(s3[1]), o4[2] = Math.round(s3[2]), o4;\n                }\n              }, 2455: function(i3, a4) {\n                "use strict";\n                function o4() {\n                  function u4(h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2) {\n                    for (var C3 = 2 * h3, M4 = _2, g3 = C3 * _2; M4 < b; ++M4, g3 += C3) {\n                      var P3 = p3[d3 + g3], T3 = p3[d3 + g3 + h3], z3 = k4[M4];\n                      e: for (var O3 = E3, V2 = C3 * E3; O3 < S2; ++O3, V2 += C3) {\n                        var G2 = L3[d3 + V2], Z = L3[d3 + V2 + h3], j3 = x2[O3];\n                        if (!(Z < P3 || T3 < G2)) {\n                          for (var N2 = d3 + 1; N2 < h3; ++N2) {\n                            var H = p3[N2 + g3], te = p3[N2 + h3 + g3], oe = L3[N2 + V2], _e = L3[N2 + h3 + V2];\n                            if (te < oe || _e < H) continue e;\n                          }\n                          var Ee = v3(z3, j3);\n                          if (Ee !== void 0) return Ee;\n                        }\n                      }\n                    }\n                  }\n                  function c5(h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2) {\n                    for (var C3 = 2 * h3, M4 = E3, g3 = C3 * E3; M4 < S2; ++M4, g3 += C3) {\n                      var P3 = L3[d3 + g3], T3 = L3[d3 + g3 + h3], z3 = x2[M4];\n                      e: for (var O3 = _2, V2 = C3 * _2; O3 < b; ++O3, V2 += C3) {\n                        var G2 = p3[d3 + V2], Z = p3[d3 + V2 + h3], j3 = k4[O3];\n                        if (!(T3 < G2 || Z < P3)) {\n                          for (var N2 = d3 + 1; N2 < h3; ++N2) {\n                            var H = p3[N2 + V2], te = p3[N2 + h3 + V2], oe = L3[N2 + g3], _e = L3[N2 + h3 + g3];\n                            if (te < oe || _e < H) continue e;\n                          }\n                          var Ee = v3(j3, z3);\n                          if (Ee !== void 0) return Ee;\n                        }\n                      }\n                    }\n                  }\n                  function f4(h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2) {\n                    return b - _2 > S2 - E3 ? u4(h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2) : c5(h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2);\n                  }\n                  return f4;\n                }\n                function s3() {\n                  function u4(v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4) {\n                    for (var g3 = 2 * v3, P3 = p3, T3 = g3 * p3; P3 < k4; ++P3, T3 += g3) {\n                      var z3 = E3[_2 + T3], O3 = E3[_2 + T3 + v3], V2 = S2[P3];\n                      e: for (var G2 = L3, Z = g3 * L3; G2 < x2; ++G2, Z += g3) {\n                        var j3 = C3[_2 + Z], N2 = M4[G2];\n                        if (!(j3 <= z3 || O3 < j3)) {\n                          for (var H = _2 + 1; H < v3; ++H) {\n                            var te = E3[H + T3], oe = E3[H + v3 + T3], _e = C3[H + Z], Ee = C3[H + v3 + Z];\n                            if (oe < _e || Ee < te) continue e;\n                          }\n                          var Ce = b(N2, V2);\n                          if (Ce !== void 0) return Ce;\n                        }\n                      }\n                    }\n                  }\n                  function c5(v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4) {\n                    for (var g3 = 2 * v3, P3 = p3, T3 = g3 * p3; P3 < k4; ++P3, T3 += g3) {\n                      var z3 = E3[_2 + T3], O3 = E3[_2 + T3 + v3], V2 = S2[P3];\n                      e: for (var G2 = L3, Z = g3 * L3; G2 < x2; ++G2, Z += g3) {\n                        var j3 = C3[_2 + Z], N2 = M4[G2];\n                        if (!(j3 < z3 || O3 < j3)) {\n                          for (var H = _2 + 1; H < v3; ++H) {\n                            var te = E3[H + T3], oe = E3[H + v3 + T3], _e = C3[H + Z], Ee = C3[H + v3 + Z];\n                            if (oe < _e || Ee < te) continue e;\n                          }\n                          var Ce = b(V2, N2);\n                          if (Ce !== void 0) return Ce;\n                        }\n                      }\n                    }\n                  }\n                  function f4(v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4) {\n                    for (var g3 = 2 * v3, P3 = L3, T3 = g3 * L3; P3 < x2; ++P3, T3 += g3) {\n                      var z3 = C3[_2 + T3], O3 = M4[P3];\n                      e: for (var V2 = p3, G2 = g3 * p3; V2 < k4; ++V2, G2 += g3) {\n                        var Z = E3[_2 + G2], j3 = E3[_2 + G2 + v3], N2 = S2[V2];\n                        if (!(z3 <= Z || j3 < z3)) {\n                          for (var H = _2 + 1; H < v3; ++H) {\n                            var te = E3[H + G2], oe = E3[H + v3 + G2], _e = C3[H + T3], Ee = C3[H + v3 + T3];\n                            if (oe < _e || Ee < te) continue e;\n                          }\n                          var Ce = b(O3, N2);\n                          if (Ce !== void 0) return Ce;\n                        }\n                      }\n                    }\n                  }\n                  function h3(v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4) {\n                    for (var g3 = 2 * v3, P3 = L3, T3 = g3 * L3; P3 < x2; ++P3, T3 += g3) {\n                      var z3 = C3[_2 + T3], O3 = M4[P3];\n                      e: for (var V2 = p3, G2 = g3 * p3; V2 < k4; ++V2, G2 += g3) {\n                        var Z = E3[_2 + G2], j3 = E3[_2 + G2 + v3], N2 = S2[V2];\n                        if (!(z3 < Z || j3 < z3)) {\n                          for (var H = _2 + 1; H < v3; ++H) {\n                            var te = E3[H + G2], oe = E3[H + v3 + G2], _e = C3[H + T3], Ee = C3[H + v3 + T3];\n                            if (oe < _e || Ee < te) continue e;\n                          }\n                          var Ce = b(N2, O3);\n                          if (Ce !== void 0) return Ce;\n                        }\n                      }\n                    }\n                  }\n                  function d3(v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4, g3) {\n                    return E3 - k4 > C3 - x2 ? p3 ? u4(v3, _2, b, k4, E3, S2, L3, x2, C3, M4, g3) : c5(v3, _2, b, k4, E3, S2, L3, x2, C3, M4, g3) : p3 ? f4(v3, _2, b, k4, E3, S2, L3, x2, C3, M4, g3) : h3(v3, _2, b, k4, E3, S2, L3, x2, C3, M4, g3);\n                  }\n                  return d3;\n                }\n                function l3(u4) {\n                  return u4 ? o4() : s3();\n                }\n                a4.partial = l3(false), a4.full = l3(true);\n              }, 2478: function(i3) {\n                "use strict";\n                function a4(f4, h3, d3, v3, _2) {\n                  for (var b = _2 + 1; v3 <= _2; ) {\n                    var p3 = v3 + _2 >>> 1, k4 = f4[p3], E3 = d3 !== void 0 ? d3(k4, h3) : k4 - h3;\n                    E3 >= 0 ? (b = p3, _2 = p3 - 1) : v3 = p3 + 1;\n                  }\n                  return b;\n                }\n                function o4(f4, h3, d3, v3, _2) {\n                  for (var b = _2 + 1; v3 <= _2; ) {\n                    var p3 = v3 + _2 >>> 1, k4 = f4[p3], E3 = d3 !== void 0 ? d3(k4, h3) : k4 - h3;\n                    E3 > 0 ? (b = p3, _2 = p3 - 1) : v3 = p3 + 1;\n                  }\n                  return b;\n                }\n                function s3(f4, h3, d3, v3, _2) {\n                  for (var b = v3 - 1; v3 <= _2; ) {\n                    var p3 = v3 + _2 >>> 1, k4 = f4[p3], E3 = d3 !== void 0 ? d3(k4, h3) : k4 - h3;\n                    E3 < 0 ? (b = p3, v3 = p3 + 1) : _2 = p3 - 1;\n                  }\n                  return b;\n                }\n                function l3(f4, h3, d3, v3, _2) {\n                  for (var b = v3 - 1; v3 <= _2; ) {\n                    var p3 = v3 + _2 >>> 1, k4 = f4[p3], E3 = d3 !== void 0 ? d3(k4, h3) : k4 - h3;\n                    E3 <= 0 ? (b = p3, v3 = p3 + 1) : _2 = p3 - 1;\n                  }\n                  return b;\n                }\n                function u4(f4, h3, d3, v3, _2) {\n                  for (; v3 <= _2; ) {\n                    var b = v3 + _2 >>> 1, p3 = f4[b], k4 = d3 !== void 0 ? d3(p3, h3) : p3 - h3;\n                    if (k4 === 0) return b;\n                    k4 <= 0 ? v3 = b + 1 : _2 = b - 1;\n                  }\n                  return -1;\n                }\n                function c5(f4, h3, d3, v3, _2, b) {\n                  return typeof d3 == "function" ? b(f4, h3, d3, v3 === void 0 ? 0 : v3 | 0, _2 === void 0 ? f4.length - 1 : _2 | 0) : b(f4, h3, void 0, d3 === void 0 ? 0 : d3 | 0, v3 === void 0 ? f4.length - 1 : v3 | 0);\n                }\n                i3.exports = { ge: function(f4, h3, d3, v3, _2) {\n                  return c5(f4, h3, d3, v3, _2, a4);\n                }, gt: function(f4, h3, d3, v3, _2) {\n                  return c5(f4, h3, d3, v3, _2, o4);\n                }, lt: function(f4, h3, d3, v3, _2) {\n                  return c5(f4, h3, d3, v3, _2, s3);\n                }, le: function(f4, h3, d3, v3, _2) {\n                  return c5(f4, h3, d3, v3, _2, l3);\n                }, eq: function(f4, h3, d3, v3, _2) {\n                  return c5(f4, h3, d3, v3, _2, u4);\n                } };\n              }, 2504: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = l3[0], c5 = l3[1], f4 = l3[2];\n                  return o4[0] = s3[0] * u4, o4[1] = s3[1] * u4, o4[2] = s3[2] * u4, o4[3] = s3[3] * u4, o4[4] = s3[4] * c5, o4[5] = s3[5] * c5, o4[6] = s3[6] * c5, o4[7] = s3[7] * c5, o4[8] = s3[8] * f4, o4[9] = s3[9] * f4, o4[10] = s3[10] * f4, o4[11] = s3[11] * f4, o4[12] = s3[12], o4[13] = s3[13], o4[14] = s3[14], o4[15] = s3[15], o4;\n                }\n              }, 2538: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8902), l3 = o4(5542), u4 = o4(2272), c5 = o4(5023);\n                i3.exports = _2;\n                function f4(b) {\n                  return [Math.min(b[0], b[1]), Math.max(b[0], b[1])];\n                }\n                function h3(b, p3) {\n                  return b[0] - p3[0] || b[1] - p3[1];\n                }\n                function d3(b) {\n                  return b.map(f4).sort(h3);\n                }\n                function v3(b, p3, k4) {\n                  return p3 in b ? b[p3] : k4;\n                }\n                function _2(b, p3, k4) {\n                  Array.isArray(p3) ? (k4 = k4 || {}, p3 = p3 || []) : (k4 = p3 || {}, p3 = []);\n                  var E3 = !!v3(k4, "delaunay", true), S2 = !!v3(k4, "interior", true), L3 = !!v3(k4, "exterior", true), x2 = !!v3(k4, "infinity", false);\n                  if (!S2 && !L3 || b.length === 0) return [];\n                  var C3 = s3(b, p3);\n                  if (E3 || S2 !== L3 || x2) {\n                    for (var M4 = l3(b.length, d3(p3)), g3 = 0; g3 < C3.length; ++g3) {\n                      var P3 = C3[g3];\n                      M4.addTriangle(P3[0], P3[1], P3[2]);\n                    }\n                    return E3 && u4(b, M4), L3 ? S2 ? x2 ? c5(M4, 0, x2) : M4.cells() : c5(M4, 1, x2) : c5(M4, -1);\n                  } else return C3;\n                }\n              }, 2573: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = s3[0], f4 = s3[1], h3 = s3[2], d3 = s3[3];\n                  return o4[0] = c5 + u4 * (l3[0] - c5), o4[1] = f4 + u4 * (l3[1] - f4), o4[2] = h3 + u4 * (l3[2] - h3), o4[3] = d3 + u4 * (l3[3] - d3), o4;\n                }\n              }, 2613: function(i3) {\n                i3.exports = 1e-6;\n              }, 2640: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1888);\n                i3.exports = c5;\n                var l3 = { "false,0,1": function(h3, d3, v3, _2, b) {\n                  return function(k4, E3, S2, L3) {\n                    var x2 = k4.shape[0] | 0, C3 = k4.shape[1] | 0, M4 = k4.data, g3 = k4.offset | 0, P3 = k4.stride[0] | 0, T3 = k4.stride[1] | 0, z3 = g3, O3, V2 = -P3 | 0, G2 = 0, Z = -T3 | 0, j3 = 0, N2 = -P3 - T3 | 0, H = 0, te = P3 | 0, oe = T3 - P3 * x2 | 0, _e = 0, Ee = 0, Ce = 0, me = 2 * x2 | 0, ie = _2(me), Se = _2(me), Le = 0, Ae = 0, Fe = -1, Pe = -1, ge = 0, Re = -x2 | 0, ce = x2 | 0, Ze = 0, ut = -x2 - 1 | 0, pt = x2 - 1 | 0, Zt = 0, st = 0, lt = 0;\n                    for (_e = 0; _e < x2; ++_e) ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te;\n                    if (z3 += oe, C3 > 0) {\n                      if (Ee = 1, ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te, x2 > 0) for (_e = 1, O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), ge = ie[Le + Fe], Ze = ie[Le + Re], Zt = ie[Le + ut], (Ae !== ge || Ae !== Ze || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, ge, Ze, Zt, E3, S2, L3), st = Se[Le] = Ce++), Le += 1, z3 += te, _e = 2; _e < x2; ++_e) O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), ge = ie[Le + Fe], Ze = ie[Le + Re], Zt = ie[Le + ut], (Ae !== ge || Ae !== Ze || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, ge, Ze, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== ge && d3(Se[Le + Fe], st, H, G2, Zt, ge, E3, S2, L3)), Le += 1, z3 += te;\n                      for (z3 += oe, Le = 0, lt = Fe, Fe = Pe, Pe = lt, lt = Re, Re = ce, ce = lt, lt = ut, ut = pt, pt = lt, Ee = 2; Ee < C3; ++Ee) {\n                        if (ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te, x2 > 0) for (_e = 1, O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), ge = ie[Le + Fe], Ze = ie[Le + Re], Zt = ie[Le + ut], (Ae !== ge || Ae !== Ze || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, ge, Ze, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== Ze && d3(Se[Le + Re], st, j3, H, Ze, Zt, E3, S2, L3)), Le += 1, z3 += te, _e = 2; _e < x2; ++_e) O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), ge = ie[Le + Fe], Ze = ie[Le + Re], Zt = ie[Le + ut], (Ae !== ge || Ae !== Ze || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, ge, Ze, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== Ze && d3(Se[Le + Re], st, j3, H, Ze, Zt, E3, S2, L3), Zt !== ge && d3(Se[Le + Fe], st, H, G2, Zt, ge, E3, S2, L3)), Le += 1, z3 += te;\n                        Ee & 1 && (Le = 0), lt = Fe, Fe = Pe, Pe = lt, lt = Re, Re = ce, ce = lt, lt = ut, ut = pt, pt = lt, z3 += oe;\n                      }\n                    }\n                    b(Se), b(ie);\n                  };\n                }, "false,1,0": function(h3, d3, v3, _2, b) {\n                  return function(k4, E3, S2, L3) {\n                    var x2 = k4.shape[0] | 0, C3 = k4.shape[1] | 0, M4 = k4.data, g3 = k4.offset | 0, P3 = k4.stride[0] | 0, T3 = k4.stride[1] | 0, z3 = g3, O3, V2 = -P3 | 0, G2 = 0, Z = -T3 | 0, j3 = 0, N2 = -P3 - T3 | 0, H = 0, te = T3 | 0, oe = P3 - T3 * C3 | 0, _e = 0, Ee = 0, Ce = 0, me = 2 * C3 | 0, ie = _2(me), Se = _2(me), Le = 0, Ae = 0, Fe = -1, Pe = -1, ge = 0, Re = -C3 | 0, ce = C3 | 0, Ze = 0, ut = -C3 - 1 | 0, pt = C3 - 1 | 0, Zt = 0, st = 0, lt = 0;\n                    for (Ee = 0; Ee < C3; ++Ee) ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te;\n                    if (z3 += oe, x2 > 0) {\n                      if (_e = 1, ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te, C3 > 0) for (Ee = 1, O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), Ze = ie[Le + Re], ge = ie[Le + Fe], Zt = ie[Le + ut], (Ae !== Ze || Ae !== ge || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, Ze, ge, Zt, E3, S2, L3), st = Se[Le] = Ce++), Le += 1, z3 += te, Ee = 2; Ee < C3; ++Ee) O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), Ze = ie[Le + Re], ge = ie[Le + Fe], Zt = ie[Le + ut], (Ae !== Ze || Ae !== ge || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, Ze, ge, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== ge && d3(Se[Le + Fe], st, j3, H, ge, Zt, E3, S2, L3)), Le += 1, z3 += te;\n                      for (z3 += oe, Le = 0, lt = Re, Re = ce, ce = lt, lt = Fe, Fe = Pe, Pe = lt, lt = ut, ut = pt, pt = lt, _e = 2; _e < x2; ++_e) {\n                        if (ie[Le++] = v3(M4[z3], E3, S2, L3), z3 += te, C3 > 0) for (Ee = 1, O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), Ze = ie[Le + Re], ge = ie[Le + Fe], Zt = ie[Le + ut], (Ae !== Ze || Ae !== ge || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, Ze, ge, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== Ze && d3(Se[Le + Re], st, H, G2, Zt, Ze, E3, S2, L3)), Le += 1, z3 += te, Ee = 2; Ee < C3; ++Ee) O3 = M4[z3], Ae = ie[Le] = v3(O3, E3, S2, L3), Ze = ie[Le + Re], ge = ie[Le + Fe], Zt = ie[Le + ut], (Ae !== Ze || Ae !== ge || Ae !== Zt) && (G2 = M4[z3 + V2], j3 = M4[z3 + Z], H = M4[z3 + N2], h3(_e, Ee, O3, G2, j3, H, Ae, Ze, ge, Zt, E3, S2, L3), st = Se[Le] = Ce++, Zt !== ge && d3(Se[Le + Fe], st, j3, H, ge, Zt, E3, S2, L3), Zt !== Ze && d3(Se[Le + Re], st, H, G2, Zt, Ze, E3, S2, L3)), Le += 1, z3 += te;\n                        _e & 1 && (Le = 0), lt = Re, Re = ce, ce = lt, lt = Fe, Fe = Pe, Pe = lt, lt = ut, ut = pt, pt = lt, z3 += oe;\n                      }\n                    }\n                    b(Se), b(ie);\n                  };\n                } };\n                function u4(f4, h3, d3, v3, _2, b) {\n                  var p3 = [b, _2].join(","), k4 = l3[p3];\n                  return k4(f4, h3, d3, s3.mallocUint32, s3.freeUint32);\n                }\n                function c5(f4) {\n                  function h3(E3) {\n                    throw new Error("ndarray-extract-contour: " + E3);\n                  }\n                  typeof f4 != "object" && h3("Must specify arguments");\n                  var d3 = f4.order;\n                  Array.isArray(d3) || h3("Must specify order");\n                  var v3 = f4.arrayArguments || 1;\n                  v3 < 1 && h3("Must have at least one array argument");\n                  var _2 = f4.scalarArguments || 0;\n                  _2 < 0 && h3("Scalar arg count must be > 0"), typeof f4.vertex != "function" && h3("Must specify vertex creation function"), typeof f4.cell != "function" && h3("Must specify cell creation function"), typeof f4.phase != "function" && h3("Must specify phase function");\n                  for (var b = f4.getters || [], p3 = new Array(v3), k4 = 0; k4 < v3; ++k4) b.indexOf(k4) >= 0 ? p3[k4] = true : p3[k4] = false;\n                  return u4(f4.vertex, f4.cell, f4.phase, _2, d3, p3);\n                }\n              }, 2642: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(727);\n                function l3(c5) {\n                  for (var f4 = 0, h3 = 0; h3 < c5.length; ++h3) f4 += c5[h3];\n                  return f4;\n                }\n                function u4(c5, f4) {\n                  for (var h3 = f4.length, d3 = new Array(h3 + 1), v3 = 0; v3 < h3; ++v3) {\n                    for (var _2 = new Array(h3 + 1), b = 0; b <= h3; ++b) _2[b] = c5[b][v3];\n                    d3[v3] = _2;\n                  }\n                  d3[h3] = new Array(h3 + 1);\n                  for (var v3 = 0; v3 <= h3; ++v3) d3[h3][v3] = 1;\n                  for (var p3 = new Array(h3 + 1), v3 = 0; v3 < h3; ++v3) p3[v3] = f4[v3];\n                  p3[h3] = 1;\n                  var k4 = s3(d3, p3), E3 = l3(k4[h3 + 1]);\n                  E3 === 0 && (E3 = 1);\n                  for (var S2 = new Array(h3 + 1), v3 = 0; v3 <= h3; ++v3) S2[v3] = l3(k4[v3]) / E3;\n                  return S2;\n                }\n              }, 2646: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5250), l3 = o4(8210), u4 = o4(8545), c5 = o4(3012), f4 = 6;\n                function h3(M4) {\n                  var g3 = M4 === 3 ? b : M4 === 4 ? p3 : M4 === 5 ? k4 : E3;\n                  return g3(l3, u4, s3, c5);\n                }\n                function d3() {\n                  return 0;\n                }\n                function v3() {\n                  return 0;\n                }\n                function _2() {\n                  return 0;\n                }\n                function b(M4, g3, P3, T3) {\n                  function z3(O3, V2, G2) {\n                    var Z = P3(O3[0], O3[0]), j3 = T3(Z, V2[0]), N2 = T3(Z, G2[0]), H = P3(V2[0], V2[0]), te = T3(H, O3[0]), oe = T3(H, G2[0]), _e = P3(G2[0], G2[0]), Ee = T3(_e, O3[0]), Ce = T3(_e, V2[0]), me = M4(g3(Ce, oe), g3(te, j3)), ie = g3(Ee, N2), Se = g3(me, ie);\n                    return Se[Se.length - 1];\n                  }\n                  return z3;\n                }\n                function p3(M4, g3, P3, T3) {\n                  function z3(O3, V2, G2, Z) {\n                    var j3 = M4(P3(O3[0], O3[0]), P3(O3[1], O3[1])), N2 = T3(j3, V2[0]), H = T3(j3, G2[0]), te = T3(j3, Z[0]), oe = M4(P3(V2[0], V2[0]), P3(V2[1], V2[1])), _e = T3(oe, O3[0]), Ee = T3(oe, G2[0]), Ce = T3(oe, Z[0]), me = M4(P3(G2[0], G2[0]), P3(G2[1], G2[1])), ie = T3(me, O3[0]), Se = T3(me, V2[0]), Le = T3(me, Z[0]), Ae = M4(P3(Z[0], Z[0]), P3(Z[1], Z[1])), Fe = T3(Ae, O3[0]), Pe = T3(Ae, V2[0]), ge = T3(Ae, G2[0]), Re = M4(M4(T3(g3(ge, Le), V2[1]), M4(T3(g3(Pe, Ce), -G2[1]), T3(g3(Se, Ee), Z[1]))), M4(T3(g3(Pe, Ce), O3[1]), M4(T3(g3(Fe, te), -V2[1]), T3(g3(_e, N2), Z[1])))), ce = M4(M4(T3(g3(ge, Le), O3[1]), M4(T3(g3(Fe, te), -G2[1]), T3(g3(ie, H), Z[1]))), M4(T3(g3(Se, Ee), O3[1]), M4(T3(g3(ie, H), -V2[1]), T3(g3(_e, N2), G2[1])))), Ze = g3(Re, ce);\n                    return Ze[Ze.length - 1];\n                  }\n                  return z3;\n                }\n                function k4(M4, g3, P3, T3) {\n                  function z3(O3, V2, G2, Z, j3) {\n                    var N2 = M4(P3(O3[0], O3[0]), M4(P3(O3[1], O3[1]), P3(O3[2], O3[2]))), H = T3(N2, V2[0]), te = T3(N2, G2[0]), oe = T3(N2, Z[0]), _e = T3(N2, j3[0]), Ee = M4(P3(V2[0], V2[0]), M4(P3(V2[1], V2[1]), P3(V2[2], V2[2]))), Ce = T3(Ee, O3[0]), me = T3(Ee, G2[0]), ie = T3(Ee, Z[0]), Se = T3(Ee, j3[0]), Le = M4(P3(G2[0], G2[0]), M4(P3(G2[1], G2[1]), P3(G2[2], G2[2]))), Ae = T3(Le, O3[0]), Fe = T3(Le, V2[0]), Pe = T3(Le, Z[0]), ge = T3(Le, j3[0]), Re = M4(P3(Z[0], Z[0]), M4(P3(Z[1], Z[1]), P3(Z[2], Z[2]))), ce = T3(Re, O3[0]), Ze = T3(Re, V2[0]), ut = T3(Re, G2[0]), pt = T3(Re, j3[0]), Zt = M4(P3(j3[0], j3[0]), M4(P3(j3[1], j3[1]), P3(j3[2], j3[2]))), st = T3(Zt, O3[0]), lt = T3(Zt, V2[0]), Gt = T3(Zt, G2[0]), Nt = T3(Zt, Z[0]), Jt = M4(M4(M4(T3(M4(T3(g3(Nt, pt), G2[1]), M4(T3(g3(Gt, ge), -Z[1]), T3(g3(ut, Pe), j3[1]))), V2[2]), M4(T3(M4(T3(g3(Nt, pt), V2[1]), M4(T3(g3(lt, Se), -Z[1]), T3(g3(Ze, ie), j3[1]))), -G2[2]), T3(M4(T3(g3(Gt, ge), V2[1]), M4(T3(g3(lt, Se), -G2[1]), T3(g3(Fe, me), j3[1]))), Z[2]))), M4(T3(M4(T3(g3(ut, Pe), V2[1]), M4(T3(g3(Ze, ie), -G2[1]), T3(g3(Fe, me), Z[1]))), -j3[2]), M4(T3(M4(T3(g3(Nt, pt), V2[1]), M4(T3(g3(lt, Se), -Z[1]), T3(g3(Ze, ie), j3[1]))), O3[2]), T3(M4(T3(g3(Nt, pt), O3[1]), M4(T3(g3(st, _e), -Z[1]), T3(g3(ce, oe), j3[1]))), -V2[2])))), M4(M4(T3(M4(T3(g3(lt, Se), O3[1]), M4(T3(g3(st, _e), -V2[1]), T3(g3(Ce, H), j3[1]))), Z[2]), M4(T3(M4(T3(g3(Ze, ie), O3[1]), M4(T3(g3(ce, oe), -V2[1]), T3(g3(Ce, H), Z[1]))), -j3[2]), T3(M4(T3(g3(ut, Pe), V2[1]), M4(T3(g3(Ze, ie), -G2[1]), T3(g3(Fe, me), Z[1]))), O3[2]))), M4(T3(M4(T3(g3(ut, Pe), O3[1]), M4(T3(g3(ce, oe), -G2[1]), T3(g3(Ae, te), Z[1]))), -V2[2]), M4(T3(M4(T3(g3(Ze, ie), O3[1]), M4(T3(g3(ce, oe), -V2[1]), T3(g3(Ce, H), Z[1]))), G2[2]), T3(M4(T3(g3(Fe, me), O3[1]), M4(T3(g3(Ae, te), -V2[1]), T3(g3(Ce, H), G2[1]))), -Z[2]))))), sr = M4(M4(M4(T3(M4(T3(g3(Nt, pt), G2[1]), M4(T3(g3(Gt, ge), -Z[1]), T3(g3(ut, Pe), j3[1]))), O3[2]), T3(M4(T3(g3(Nt, pt), O3[1]), M4(T3(g3(st, _e), -Z[1]), T3(g3(ce, oe), j3[1]))), -G2[2])), M4(T3(M4(T3(g3(Gt, ge), O3[1]), M4(T3(g3(st, _e), -G2[1]), T3(g3(Ae, te), j3[1]))), Z[2]), T3(M4(T3(g3(ut, Pe), O3[1]), M4(T3(g3(ce, oe), -G2[1]), T3(g3(Ae, te), Z[1]))), -j3[2]))), M4(M4(T3(M4(T3(g3(Gt, ge), V2[1]), M4(T3(g3(lt, Se), -G2[1]), T3(g3(Fe, me), j3[1]))), O3[2]), T3(M4(T3(g3(Gt, ge), O3[1]), M4(T3(g3(st, _e), -G2[1]), T3(g3(Ae, te), j3[1]))), -V2[2])), M4(T3(M4(T3(g3(lt, Se), O3[1]), M4(T3(g3(st, _e), -V2[1]), T3(g3(Ce, H), j3[1]))), G2[2]), T3(M4(T3(g3(Fe, me), O3[1]), M4(T3(g3(Ae, te), -V2[1]), T3(g3(Ce, H), G2[1]))), -j3[2])))), wr = g3(Jt, sr);\n                    return wr[wr.length - 1];\n                  }\n                  return z3;\n                }\n                function E3(M4, g3, P3, T3) {\n                  function z3(O3, V2, G2, Z, j3, N2) {\n                    var H = M4(M4(P3(O3[0], O3[0]), P3(O3[1], O3[1])), M4(P3(O3[2], O3[2]), P3(O3[3], O3[3]))), te = T3(H, V2[0]), oe = T3(H, G2[0]), _e = T3(H, Z[0]), Ee = T3(H, j3[0]), Ce = T3(H, N2[0]), me = M4(M4(P3(V2[0], V2[0]), P3(V2[1], V2[1])), M4(P3(V2[2], V2[2]), P3(V2[3], V2[3]))), ie = T3(me, O3[0]), Se = T3(me, G2[0]), Le = T3(me, Z[0]), Ae = T3(me, j3[0]), Fe = T3(me, N2[0]), Pe = M4(M4(P3(G2[0], G2[0]), P3(G2[1], G2[1])), M4(P3(G2[2], G2[2]), P3(G2[3], G2[3]))), ge = T3(Pe, O3[0]), Re = T3(Pe, V2[0]), ce = T3(Pe, Z[0]), Ze = T3(Pe, j3[0]), ut = T3(Pe, N2[0]), pt = M4(M4(P3(Z[0], Z[0]), P3(Z[1], Z[1])), M4(P3(Z[2], Z[2]), P3(Z[3], Z[3]))), Zt = T3(pt, O3[0]), st = T3(pt, V2[0]), lt = T3(pt, G2[0]), Gt = T3(pt, j3[0]), Nt = T3(pt, N2[0]), Jt = M4(M4(P3(j3[0], j3[0]), P3(j3[1], j3[1])), M4(P3(j3[2], j3[2]), P3(j3[3], j3[3]))), sr = T3(Jt, O3[0]), wr = T3(Jt, V2[0]), cr = T3(Jt, G2[0]), $e = T3(Jt, Z[0]), St = T3(Jt, N2[0]), Qt = M4(M4(P3(N2[0], N2[0]), P3(N2[1], N2[1])), M4(P3(N2[2], N2[2]), P3(N2[3], N2[3]))), Vt = T3(Qt, O3[0]), _t = T3(Qt, V2[0]), It = T3(Qt, G2[0]), mt = T3(Qt, Z[0]), er = T3(Qt, j3[0]), lr = M4(M4(M4(T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), G2[2]), T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), -N2[2]))), V2[3]), M4(T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), V2[2]), T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), -N2[2]))), -G2[3]), T3(M4(M4(T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), V2[2]), T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), j3[2]), T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), -N2[2]))), Z[3]))), M4(M4(T3(M4(M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), V2[2]), T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), Z[2]), T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), -N2[2]))), -j3[3]), T3(M4(M4(T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), V2[2]), T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), -G2[2])), M4(T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), Z[2]), T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), -j3[2]))), N2[3])), M4(T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), V2[2]), T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), -N2[2]))), O3[3]), T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -N2[2]))), -V2[3])))), M4(M4(M4(T3(M4(M4(T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), j3[2]), T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), -N2[2]))), Z[3]), T3(M4(M4(T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), O3[2]), T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), Z[2]), T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), -N2[2]))), -j3[3])), M4(T3(M4(M4(T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), O3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -V2[2])), M4(T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), Z[2]), T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), -j3[2]))), N2[3]), T3(M4(M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), V2[2]), T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), Z[2]), T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), -N2[2]))), O3[3]))), M4(M4(T3(M4(M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), O3[2]), T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), Z[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -N2[2]))), -V2[3]), T3(M4(M4(T3(M4(T3(g3(mt, Nt), V2[1]), M4(T3(g3(_t, Fe), -Z[1]), T3(g3(st, Le), N2[1]))), O3[2]), T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), Z[2]), T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), -N2[2]))), G2[3])), M4(T3(M4(M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), O3[2]), T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -N2[2]))), -Z[3]), T3(M4(M4(T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), O3[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -V2[2])), M4(T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -Z[2]))), N2[3]))))), Tr = M4(M4(M4(T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), G2[2]), T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), -N2[2]))), O3[3]), M4(T3(M4(M4(T3(M4(T3(g3(er, St), Z[1]), M4(T3(g3(mt, Nt), -j3[1]), T3(g3($e, Gt), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -Z[2])), M4(T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), j3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -N2[2]))), -G2[3]), T3(M4(M4(T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), j3[2]), T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), -N2[2]))), Z[3]))), M4(M4(T3(M4(M4(T3(M4(T3(g3(mt, Nt), G2[1]), M4(T3(g3(It, ut), -Z[1]), T3(g3(lt, ce), N2[1]))), O3[2]), T3(M4(T3(g3(mt, Nt), O3[1]), M4(T3(g3(Vt, Ce), -Z[1]), T3(g3(Zt, _e), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), Z[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -N2[2]))), -j3[3]), T3(M4(M4(T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), O3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -G2[2])), M4(T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), Z[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -j3[2]))), N2[3])), M4(T3(M4(M4(T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), V2[2]), T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), j3[2]), T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), -N2[2]))), O3[3]), T3(M4(M4(T3(M4(T3(g3(er, St), G2[1]), M4(T3(g3(It, ut), -j3[1]), T3(g3(cr, Ze), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -G2[2])), M4(T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), j3[2]), T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), -N2[2]))), -V2[3])))), M4(M4(M4(T3(M4(M4(T3(M4(T3(g3(er, St), V2[1]), M4(T3(g3(_t, Fe), -j3[1]), T3(g3(wr, Ae), N2[1]))), O3[2]), T3(M4(T3(g3(er, St), O3[1]), M4(T3(g3(Vt, Ce), -j3[1]), T3(g3(sr, Ee), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), j3[2]), T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), -N2[2]))), G2[3]), T3(M4(M4(T3(M4(T3(g3(It, ut), V2[1]), M4(T3(g3(_t, Fe), -G2[1]), T3(g3(Re, Se), N2[1]))), O3[2]), T3(M4(T3(g3(It, ut), O3[1]), M4(T3(g3(Vt, Ce), -G2[1]), T3(g3(ge, oe), N2[1]))), -V2[2])), M4(T3(M4(T3(g3(_t, Fe), O3[1]), M4(T3(g3(Vt, Ce), -V2[1]), T3(g3(ie, te), N2[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -N2[2]))), -j3[3])), M4(T3(M4(M4(T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), O3[2]), T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), -V2[2])), M4(T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -j3[2]))), N2[3]), T3(M4(M4(T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), V2[2]), T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), -G2[2])), M4(T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), Z[2]), T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), -j3[2]))), O3[3]))), M4(M4(T3(M4(M4(T3(M4(T3(g3($e, Gt), G2[1]), M4(T3(g3(cr, Ze), -Z[1]), T3(g3(lt, ce), j3[1]))), O3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -G2[2])), M4(T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), Z[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -j3[2]))), -V2[3]), T3(M4(M4(T3(M4(T3(g3($e, Gt), V2[1]), M4(T3(g3(wr, Ae), -Z[1]), T3(g3(st, Le), j3[1]))), O3[2]), T3(M4(T3(g3($e, Gt), O3[1]), M4(T3(g3(sr, Ee), -Z[1]), T3(g3(Zt, _e), j3[1]))), -V2[2])), M4(T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), Z[2]), T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), -j3[2]))), G2[3])), M4(T3(M4(M4(T3(M4(T3(g3(cr, Ze), V2[1]), M4(T3(g3(wr, Ae), -G2[1]), T3(g3(Re, Se), j3[1]))), O3[2]), T3(M4(T3(g3(cr, Ze), O3[1]), M4(T3(g3(sr, Ee), -G2[1]), T3(g3(ge, oe), j3[1]))), -V2[2])), M4(T3(M4(T3(g3(wr, Ae), O3[1]), M4(T3(g3(sr, Ee), -V2[1]), T3(g3(ie, te), j3[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -j3[2]))), -Z[3]), T3(M4(M4(T3(M4(T3(g3(lt, ce), V2[1]), M4(T3(g3(st, Le), -G2[1]), T3(g3(Re, Se), Z[1]))), O3[2]), T3(M4(T3(g3(lt, ce), O3[1]), M4(T3(g3(Zt, _e), -G2[1]), T3(g3(ge, oe), Z[1]))), -V2[2])), M4(T3(M4(T3(g3(st, Le), O3[1]), M4(T3(g3(Zt, _e), -V2[1]), T3(g3(ie, te), Z[1]))), G2[2]), T3(M4(T3(g3(Re, Se), O3[1]), M4(T3(g3(ge, oe), -V2[1]), T3(g3(ie, te), G2[1]))), -Z[2]))), j3[3]))))), Lr = g3(lr, Tr);\n                    return Lr[Lr.length - 1];\n                  }\n                  return z3;\n                }\n                var S2 = [d3, v3, _2];\n                function L3(M4) {\n                  var g3 = S2[M4.length];\n                  return g3 || (g3 = S2[M4.length] = h3(M4.length)), g3.apply(void 0, M4);\n                }\n                function x2(M4, g3, P3, T3, z3, O3, V2, G2) {\n                  function Z(j3, N2, H, te, oe, _e) {\n                    switch (arguments.length) {\n                      case 0:\n                      case 1:\n                        return 0;\n                      case 2:\n                        return T3(j3, N2);\n                      case 3:\n                        return z3(j3, N2, H);\n                      case 4:\n                        return O3(j3, N2, H, te);\n                      case 5:\n                        return V2(j3, N2, H, te, oe);\n                      case 6:\n                        return G2(j3, N2, H, te, oe, _e);\n                    }\n                    for (var Ee = new Array(arguments.length), Ce = 0; Ce < arguments.length; ++Ce) Ee[Ce] = arguments[Ce];\n                    return M4(Ee);\n                  }\n                  return Z;\n                }\n                function C3() {\n                  for (; S2.length <= f4; ) S2.push(h3(S2.length));\n                  i3.exports = x2.apply(void 0, [L3].concat(S2));\n                  for (var M4 = 0; M4 <= f4; ++M4) i3.exports[M4] = S2[M4];\n                }\n                C3();\n              }, 2651: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(6859), l3 = o4(2361);\n                i3.exports = u4;\n                function u4(c5) {\n                  var f4 = l3.exponent(c5);\n                  return f4 < 52 ? new s3(c5) : new s3(c5 * Math.pow(2, 52 - f4)).ushln(f4 - 52);\n                }\n              }, 2652: function(i3, a4, o4) {\n                var s3 = o4(4335), l3 = o4(6864), u4 = o4(1903), c5 = o4(9921), f4 = o4(7608), h3 = o4(5665), d3 = { length: o4(1387), normalize: o4(3536), dot: o4(244), cross: o4(5911) }, v3 = l3(), _2 = l3(), b = [0, 0, 0, 0], p3 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]], k4 = [0, 0, 0];\n                i3.exports = function(C3, M4, g3, P3, T3, z3) {\n                  if (M4 || (M4 = [0, 0, 0]), g3 || (g3 = [0, 0, 0]), P3 || (P3 = [0, 0, 0]), T3 || (T3 = [0, 0, 0, 1]), z3 || (z3 = [0, 0, 0, 1]), !s3(v3, C3) || (u4(_2, v3), _2[3] = 0, _2[7] = 0, _2[11] = 0, _2[15] = 1, Math.abs(c5(_2) < 1e-8))) return false;\n                  var O3 = v3[3], V2 = v3[7], G2 = v3[11], Z = v3[12], j3 = v3[13], N2 = v3[14], H = v3[15];\n                  if (O3 !== 0 || V2 !== 0 || G2 !== 0) {\n                    b[0] = O3, b[1] = V2, b[2] = G2, b[3] = H;\n                    var te = f4(_2, _2);\n                    if (!te) return false;\n                    h3(_2, _2), E3(T3, b, _2);\n                  } else T3[0] = T3[1] = T3[2] = 0, T3[3] = 1;\n                  if (M4[0] = Z, M4[1] = j3, M4[2] = N2, S2(p3, v3), g3[0] = d3.length(p3[0]), d3.normalize(p3[0], p3[0]), P3[0] = d3.dot(p3[0], p3[1]), L3(p3[1], p3[1], p3[0], 1, -P3[0]), g3[1] = d3.length(p3[1]), d3.normalize(p3[1], p3[1]), P3[0] /= g3[1], P3[1] = d3.dot(p3[0], p3[2]), L3(p3[2], p3[2], p3[0], 1, -P3[1]), P3[2] = d3.dot(p3[1], p3[2]), L3(p3[2], p3[2], p3[1], 1, -P3[2]), g3[2] = d3.length(p3[2]), d3.normalize(p3[2], p3[2]), P3[1] /= g3[2], P3[2] /= g3[2], d3.cross(k4, p3[1], p3[2]), d3.dot(p3[0], k4) < 0) for (var oe = 0; oe < 3; oe++) g3[oe] *= -1, p3[oe][0] *= -1, p3[oe][1] *= -1, p3[oe][2] *= -1;\n                  return z3[0] = 0.5 * Math.sqrt(Math.max(1 + p3[0][0] - p3[1][1] - p3[2][2], 0)), z3[1] = 0.5 * Math.sqrt(Math.max(1 - p3[0][0] + p3[1][1] - p3[2][2], 0)), z3[2] = 0.5 * Math.sqrt(Math.max(1 - p3[0][0] - p3[1][1] + p3[2][2], 0)), z3[3] = 0.5 * Math.sqrt(Math.max(1 + p3[0][0] + p3[1][1] + p3[2][2], 0)), p3[2][1] > p3[1][2] && (z3[0] = -z3[0]), p3[0][2] > p3[2][0] && (z3[1] = -z3[1]), p3[1][0] > p3[0][1] && (z3[2] = -z3[2]), true;\n                };\n                function E3(x2, C3, M4) {\n                  var g3 = C3[0], P3 = C3[1], T3 = C3[2], z3 = C3[3];\n                  return x2[0] = M4[0] * g3 + M4[4] * P3 + M4[8] * T3 + M4[12] * z3, x2[1] = M4[1] * g3 + M4[5] * P3 + M4[9] * T3 + M4[13] * z3, x2[2] = M4[2] * g3 + M4[6] * P3 + M4[10] * T3 + M4[14] * z3, x2[3] = M4[3] * g3 + M4[7] * P3 + M4[11] * T3 + M4[15] * z3, x2;\n                }\n                function S2(x2, C3) {\n                  x2[0][0] = C3[0], x2[0][1] = C3[1], x2[0][2] = C3[2], x2[1][0] = C3[4], x2[1][1] = C3[5], x2[1][2] = C3[6], x2[2][0] = C3[8], x2[2][1] = C3[9], x2[2][2] = C3[10];\n                }\n                function L3(x2, C3, M4, g3, P3) {\n                  x2[0] = C3[0] * g3 + M4[0] * P3, x2[1] = C3[1] * g3 + M4[1] * P3, x2[2] = C3[2] * g3 + M4[2] * P3;\n                }\n              }, 2653: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3865);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  for (var f4 = u4.length, h3 = new Array(f4), d3 = 0; d3 < f4; ++d3) h3[d3] = s3(u4[d3], c5[d3]);\n                  return h3;\n                }\n              }, 2681: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = Math.floor(s3[0]), o4[1] = Math.floor(s3[1]), o4[2] = Math.floor(s3[2]), o4;\n                }\n              }, 2690: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = f4;\n                var s3 = o4(8954), l3 = o4(3952);\n                function u4(h3, d3) {\n                  for (var v3 = h3.length, _2 = new Array(v3), b = 0; b < d3.length; ++b) _2[b] = h3[d3[b]];\n                  for (var p3 = d3.length, b = 0; b < v3; ++b) d3.indexOf(b) < 0 && (_2[p3++] = h3[b]);\n                  return _2;\n                }\n                function c5(h3, d3) {\n                  for (var v3 = h3.length, _2 = d3.length, b = 0; b < v3; ++b) for (var p3 = h3[b], k4 = 0; k4 < p3.length; ++k4) {\n                    var E3 = p3[k4];\n                    if (E3 < _2) p3[k4] = d3[E3];\n                    else {\n                      E3 = E3 - _2;\n                      for (var S2 = 0; S2 < _2; ++S2) E3 >= d3[S2] && (E3 += 1);\n                      p3[k4] = E3;\n                    }\n                  }\n                  return h3;\n                }\n                function f4(h3, d3) {\n                  try {\n                    return s3(h3, true);\n                  } catch (p3) {\n                    var v3 = l3(h3);\n                    if (v3.length <= d3) return [];\n                    var _2 = u4(h3, v3), b = s3(_2, true);\n                    return c5(b, v3);\n                  }\n                }\n              }, 2762: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1888), l3 = o4(5298), u4 = o4(9618), c5 = ["uint8", "uint8_clamped", "uint16", "uint32", "int8", "int16", "int32", "float32"];\n                function f4(p3, k4, E3, S2, L3) {\n                  this.gl = p3, this.type = k4, this.handle = E3, this.length = S2, this.usage = L3;\n                }\n                var h3 = f4.prototype;\n                h3.bind = function() {\n                  this.gl.bindBuffer(this.type, this.handle);\n                }, h3.unbind = function() {\n                  this.gl.bindBuffer(this.type, null);\n                }, h3.dispose = function() {\n                  this.gl.deleteBuffer(this.handle);\n                };\n                function d3(p3, k4, E3, S2, L3, x2) {\n                  var C3 = L3.length * L3.BYTES_PER_ELEMENT;\n                  if (x2 < 0) return p3.bufferData(k4, L3, S2), C3;\n                  if (C3 + x2 > E3) throw new Error("gl-buffer: If resizing buffer, must not specify offset");\n                  return p3.bufferSubData(k4, x2, L3), E3;\n                }\n                function v3(p3, k4) {\n                  for (var E3 = s3.malloc(p3.length, k4), S2 = p3.length, L3 = 0; L3 < S2; ++L3) E3[L3] = p3[L3];\n                  return E3;\n                }\n                function _2(p3, k4) {\n                  for (var E3 = 1, S2 = k4.length - 1; S2 >= 0; --S2) {\n                    if (k4[S2] !== E3) return false;\n                    E3 *= p3[S2];\n                  }\n                  return true;\n                }\n                h3.update = function(p3, k4) {\n                  if (typeof k4 != "number" && (k4 = -1), this.bind(), typeof p3 == "object" && typeof p3.shape != "undefined") {\n                    var E3 = p3.dtype;\n                    if (c5.indexOf(E3) < 0 && (E3 = "float32"), this.type === this.gl.ELEMENT_ARRAY_BUFFER) {\n                      var S2 = gl.getExtension("OES_element_index_uint");\n                      S2 && E3 !== "uint16" ? E3 = "uint32" : E3 = "uint16";\n                    }\n                    if (E3 === p3.dtype && _2(p3.shape, p3.stride)) p3.offset === 0 && p3.data.length === p3.shape[0] ? this.length = d3(this.gl, this.type, this.length, this.usage, p3.data, k4) : this.length = d3(this.gl, this.type, this.length, this.usage, p3.data.subarray(p3.offset, p3.shape[0]), k4);\n                    else {\n                      var L3 = s3.malloc(p3.size, E3), x2 = u4(L3, p3.shape);\n                      l3.assign(x2, p3), k4 < 0 ? this.length = d3(this.gl, this.type, this.length, this.usage, L3, k4) : this.length = d3(this.gl, this.type, this.length, this.usage, L3.subarray(0, p3.size), k4), s3.free(L3);\n                    }\n                  } else if (Array.isArray(p3)) {\n                    var C3;\n                    this.type === this.gl.ELEMENT_ARRAY_BUFFER ? C3 = v3(p3, "uint16") : C3 = v3(p3, "float32"), k4 < 0 ? this.length = d3(this.gl, this.type, this.length, this.usage, C3, k4) : this.length = d3(this.gl, this.type, this.length, this.usage, C3.subarray(0, p3.length), k4), s3.free(C3);\n                  } else if (typeof p3 == "object" && typeof p3.length == "number") this.length = d3(this.gl, this.type, this.length, this.usage, p3, k4);\n                  else if (typeof p3 == "number" || p3 === void 0) {\n                    if (k4 >= 0) throw new Error("gl-buffer: Cannot specify offset when resizing buffer");\n                    p3 = p3 | 0, p3 <= 0 && (p3 = 1), this.gl.bufferData(this.type, p3 | 0, this.usage), this.length = p3;\n                  } else throw new Error("gl-buffer: Invalid data type");\n                };\n                function b(p3, k4, E3, S2) {\n                  if (E3 = E3 || p3.ARRAY_BUFFER, S2 = S2 || p3.DYNAMIC_DRAW, E3 !== p3.ARRAY_BUFFER && E3 !== p3.ELEMENT_ARRAY_BUFFER) throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER");\n                  if (S2 !== p3.DYNAMIC_DRAW && S2 !== p3.STATIC_DRAW && S2 !== p3.STREAM_DRAW) throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW");\n                  var L3 = p3.createBuffer(), x2 = new f4(p3, E3, L3, 0, S2);\n                  return x2.update(k4), x2;\n                }\n                i3.exports = b;\n              }, 2825: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = new Float32Array(3);\n                  return u4[0] = o4, u4[1] = s3, u4[2] = l3, u4;\n                }\n              }, 2931: function(i3, a4, o4) {\n                i3.exports = { EPSILON: o4(2613), create: o4(1091), clone: o4(3126), angle: o4(8192), fromValues: o4(2825), copy: o4(3990), set: o4(1463), equals: o4(9922), exactEquals: o4(9265), add: o4(5632), subtract: o4(6843), sub: o4(2229), multiply: o4(5847), mul: o4(4505), divide: o4(6690), div: o4(4008), min: o4(8107), max: o4(7417), floor: o4(2681), ceil: o4(9226), round: o4(2447), scale: o4(6621), scaleAndAdd: o4(8489), distance: o4(7056), dist: o4(5455), squaredDistance: o4(2953), sqrDist: o4(6141), length: o4(1387), len: o4(868), squaredLength: o4(3066), sqrLen: o4(5486), negate: o4(5093), inverse: o4(811), normalize: o4(3536), dot: o4(244), cross: o4(5911), lerp: o4(6658), random: o4(7636), transformMat4: o4(5673), transformMat3: o4(492), transformQuat: o4(264), rotateX: o4(6894), rotateY: o4(109), rotateZ: o4(8692), forEach: o4(5137) };\n              }, 2933: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = s3[0], o4[1] = s3[1], o4[2] = s3[2], o4[3] = s3[3], o4;\n                }\n              }, 2953: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0] - o4[0], u4 = s3[1] - o4[1], c5 = s3[2] - o4[2];\n                  return l3 * l3 + u4 * u4 + c5 * c5;\n                }\n              }, 2962: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5250), l3 = o4(8210), u4 = o4(3012), c5 = o4(7004), f4 = 6;\n                function h3(S2, L3, x2, C3) {\n                  return function(g3) {\n                    return C3(S2(x2(g3[0][0], g3[1][1]), x2(-g3[0][1], g3[1][0])));\n                  };\n                }\n                function d3(S2, L3, x2, C3) {\n                  return function(g3) {\n                    return C3(S2(L3(S2(x2(g3[1][1], g3[2][2]), x2(-g3[1][2], g3[2][1])), g3[0][0]), S2(L3(S2(x2(g3[1][0], g3[2][2]), x2(-g3[1][2], g3[2][0])), -g3[0][1]), L3(S2(x2(g3[1][0], g3[2][1]), x2(-g3[1][1], g3[2][0])), g3[0][2]))));\n                  };\n                }\n                function v3(S2, L3, x2, C3) {\n                  return function(g3) {\n                    return C3(S2(S2(L3(S2(L3(S2(x2(g3[2][2], g3[3][3]), x2(-g3[2][3], g3[3][2])), g3[1][1]), S2(L3(S2(x2(g3[2][1], g3[3][3]), x2(-g3[2][3], g3[3][1])), -g3[1][2]), L3(S2(x2(g3[2][1], g3[3][2]), x2(-g3[2][2], g3[3][1])), g3[1][3]))), g3[0][0]), L3(S2(L3(S2(x2(g3[2][2], g3[3][3]), x2(-g3[2][3], g3[3][2])), g3[1][0]), S2(L3(S2(x2(g3[2][0], g3[3][3]), x2(-g3[2][3], g3[3][0])), -g3[1][2]), L3(S2(x2(g3[2][0], g3[3][2]), x2(-g3[2][2], g3[3][0])), g3[1][3]))), -g3[0][1])), S2(L3(S2(L3(S2(x2(g3[2][1], g3[3][3]), x2(-g3[2][3], g3[3][1])), g3[1][0]), S2(L3(S2(x2(g3[2][0], g3[3][3]), x2(-g3[2][3], g3[3][0])), -g3[1][1]), L3(S2(x2(g3[2][0], g3[3][1]), x2(-g3[2][1], g3[3][0])), g3[1][3]))), g3[0][2]), L3(S2(L3(S2(x2(g3[2][1], g3[3][2]), x2(-g3[2][2], g3[3][1])), g3[1][0]), S2(L3(S2(x2(g3[2][0], g3[3][2]), x2(-g3[2][2], g3[3][0])), -g3[1][1]), L3(S2(x2(g3[2][0], g3[3][1]), x2(-g3[2][1], g3[3][0])), g3[1][2]))), -g3[0][3]))));\n                  };\n                }\n                function _2(S2, L3, x2, C3) {\n                  return function(g3) {\n                    return C3(S2(S2(L3(S2(S2(L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][2]), S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), -g3[2][3]), L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][4]))), g3[1][1]), L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), -g3[2][3]), L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), g3[2][4]))), -g3[1][2])), S2(L3(S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), -g3[2][2]), L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][4]))), g3[1][3]), L3(S2(L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), -g3[2][2]), L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][3]))), -g3[1][4]))), g3[0][0]), L3(S2(S2(L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][2]), S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), -g3[2][3]), L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][4]))), g3[1][0]), L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][3]), L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), g3[2][4]))), -g3[1][2])), S2(L3(S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][2]), L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), g3[2][4]))), g3[1][3]), L3(S2(L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), -g3[2][2]), L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), g3[2][3]))), -g3[1][4]))), -g3[0][1])), S2(L3(S2(S2(L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), -g3[2][3]), L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), g3[2][4]))), g3[1][0]), L3(S2(L3(S2(x2(g3[3][3], g3[4][4]), x2(-g3[3][4], g3[4][3])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][3]), L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), g3[2][4]))), -g3[1][1])), S2(L3(S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][4]))), g3[1][3]), L3(S2(L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][3]))), -g3[1][4]))), g3[0][2]), S2(L3(S2(S2(L3(S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), -g3[2][2]), L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][4]))), g3[1][0]), L3(S2(L3(S2(x2(g3[3][2], g3[4][4]), x2(-g3[3][4], g3[4][2])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][2]), L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), g3[2][4]))), -g3[1][1])), S2(L3(S2(L3(S2(x2(g3[3][1], g3[4][4]), x2(-g3[3][4], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][4]), x2(-g3[3][4], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][4]))), g3[1][2]), L3(S2(L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][2]))), -g3[1][4]))), -g3[0][3]), L3(S2(S2(L3(S2(L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][1]), S2(L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), -g3[2][2]), L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][3]))), g3[1][0]), L3(S2(L3(S2(x2(g3[3][2], g3[4][3]), x2(-g3[3][3], g3[4][2])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), -g3[2][2]), L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), g3[2][3]))), -g3[1][1])), S2(L3(S2(L3(S2(x2(g3[3][1], g3[4][3]), x2(-g3[3][3], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][3]), x2(-g3[3][3], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][3]))), g3[1][2]), L3(S2(L3(S2(x2(g3[3][1], g3[4][2]), x2(-g3[3][2], g3[4][1])), g3[2][0]), S2(L3(S2(x2(g3[3][0], g3[4][2]), x2(-g3[3][2], g3[4][0])), -g3[2][1]), L3(S2(x2(g3[3][0], g3[4][1]), x2(-g3[3][1], g3[4][0])), g3[2][2]))), -g3[1][3]))), g3[0][4])))));\n                  };\n                }\n                function b(S2) {\n                  var L3 = S2 === 2 ? h3 : S2 === 3 ? d3 : S2 === 4 ? v3 : S2 === 5 ? _2 : void 0;\n                  return L3(l3, u4, s3, c5);\n                }\n                var p3 = [function() {\n                  return [0];\n                }, function(L3) {\n                  return [L3[0][0]];\n                }];\n                function k4(S2, L3, x2, C3, M4, g3, P3, T3) {\n                  return function(O3) {\n                    switch (O3.length) {\n                      case 0:\n                        return S2(O3);\n                      case 1:\n                        return L3(O3);\n                      case 2:\n                        return x2(O3);\n                      case 3:\n                        return C3(O3);\n                      case 4:\n                        return M4(O3);\n                      case 5:\n                        return g3(O3);\n                    }\n                    var V2 = P3[O3.length];\n                    return V2 || (V2 = P3[O3.length] = T3(O3.length)), V2(O3);\n                  };\n                }\n                function E3() {\n                  for (; p3.length < f4; ) p3.push(b(p3.length));\n                  i3.exports = k4.apply(void 0, p3.concat([p3, b]));\n                  for (var S2 = 0; S2 < p3.length; ++S2) i3.exports[S2] = p3[S2];\n                }\n                E3();\n              }, 2992: function(i3, a4, o4) {\n                var s3 = o4(3387).sprintf, l3 = o4(5171), u4 = o4(1848), c5 = o4(1085);\n                i3.exports = f4;\n                function f4(h3, d3, v3) {\n                  "use strict";\n                  var _2 = u4(d3) || "of unknown name (see npm glsl-shader-name)", b = "unknown type";\n                  v3 !== void 0 && (b = v3 === l3.FRAGMENT_SHADER ? "fragment" : "vertex");\n                  for (var p3 = s3(`Error compiling %s shader %s:\n`, b, _2), k4 = s3("%s%s", p3, h3), E3 = h3.split(`\n`), S2 = {}, L3 = 0; L3 < E3.length; L3++) {\n                    var x2 = E3[L3];\n                    if (!(x2 === "" || x2 === "\\0")) {\n                      var C3 = parseInt(x2.split(":")[2]);\n                      if (isNaN(C3)) throw new Error(s3("Could not parse error: %s", x2));\n                      S2[C3] = x2;\n                    }\n                  }\n                  for (var M4 = c5(d3).split(`\n`), L3 = 0; L3 < M4.length; L3++) if (!(!S2[L3 + 3] && !S2[L3 + 2] && !S2[L3 + 1])) {\n                    var g3 = M4[L3];\n                    if (p3 += g3 + `\n`, S2[L3 + 1]) {\n                      var P3 = S2[L3 + 1];\n                      P3 = P3.substr(P3.split(":", 3).join(":").length + 1).trim(), p3 += s3(`^^^ %s\n\n`, P3);\n                    }\n                  }\n                  return { long: p3.trim(), short: k4.trim() };\n                }\n              }, 3012: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5250), l3 = o4(9362);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  var h3 = c5.length;\n                  if (h3 === 1) {\n                    var d3 = s3(c5[0], f4);\n                    return d3[0] ? d3 : [d3[1]];\n                  }\n                  var v3 = new Array(2 * h3), _2 = [0.1, 0.1], b = [0.1, 0.1], p3 = 0;\n                  s3(c5[0], f4, _2), _2[0] && (v3[p3++] = _2[0]);\n                  for (var k4 = 1; k4 < h3; ++k4) {\n                    s3(c5[k4], f4, b);\n                    var E3 = _2[1];\n                    l3(E3, b[0], _2), _2[0] && (v3[p3++] = _2[0]);\n                    var S2 = b[1], L3 = _2[1], x2 = S2 + L3, C3 = x2 - S2, M4 = L3 - C3;\n                    _2[1] = x2, M4 && (v3[p3++] = M4);\n                  }\n                  return _2[1] && (v3[p3++] = _2[1]), p3 === 0 && (v3[p3++] = 0), v3.length = p3, v3;\n                }\n              }, 3025: function(i3, a4, o4) {\n                i3.exports = o4.g.performance && o4.g.performance.now ? function() {\n                  return performance.now();\n                } : Date.now || function() {\n                  return +/* @__PURE__ */ new Date();\n                };\n              }, 3066: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = o4[0], l3 = o4[1], u4 = o4[2];\n                  return s3 * s3 + l3 * l3 + u4 * u4;\n                }\n              }, 3088: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(3140);\n                function l3(u4, c5) {\n                  for (var f4 = c5.length | 0, h3 = u4.length, d3 = [new Array(f4), new Array(f4)], v3 = 0; v3 < f4; ++v3) d3[0][v3] = [], d3[1][v3] = [];\n                  for (var v3 = 0; v3 < h3; ++v3) {\n                    var _2 = u4[v3];\n                    d3[0][_2[0]].push(_2), d3[1][_2[1]].push(_2);\n                  }\n                  for (var b = [], v3 = 0; v3 < f4; ++v3) d3[0][v3].length + d3[1][v3].length === 0 && b.push([v3]);\n                  function p3(g3, P3) {\n                    var T3 = d3[P3][g3[P3]];\n                    T3.splice(T3.indexOf(g3), 1);\n                  }\n                  function k4(g3, P3, T3) {\n                    for (var z3, O3, V2, G2 = 0; G2 < 2; ++G2) if (d3[G2][P3].length > 0) {\n                      z3 = d3[G2][P3][0], V2 = G2;\n                      break;\n                    }\n                    O3 = z3[V2 ^ 1];\n                    for (var Z = 0; Z < 2; ++Z) for (var j3 = d3[Z][P3], N2 = 0; N2 < j3.length; ++N2) {\n                      var H = j3[N2], te = H[Z ^ 1], oe = s3(c5[g3], c5[P3], c5[O3], c5[te]);\n                      oe > 0 && (z3 = H, O3 = te, V2 = Z);\n                    }\n                    return T3 || z3 && p3(z3, V2), O3;\n                  }\n                  function E3(g3, P3) {\n                    var T3 = d3[P3][g3][0], z3 = [g3];\n                    p3(T3, P3);\n                    for (var O3 = T3[P3 ^ 1], V2 = P3; ; ) {\n                      for (; O3 !== g3; ) z3.push(O3), O3 = k4(z3[z3.length - 2], O3, false);\n                      if (d3[0][g3].length + d3[1][g3].length === 0) break;\n                      var G2 = z3[z3.length - 1], Z = g3, j3 = z3[1], N2 = k4(G2, Z, true);\n                      if (s3(c5[G2], c5[Z], c5[j3], c5[N2]) < 0) break;\n                      z3.push(g3), O3 = k4(G2, Z);\n                    }\n                    return z3;\n                  }\n                  function S2(g3, P3) {\n                    return P3[1] === P3[P3.length - 1];\n                  }\n                  for (var v3 = 0; v3 < f4; ++v3) for (var L3 = 0; L3 < 2; ++L3) {\n                    for (var x2 = []; d3[L3][v3].length > 0; ) {\n                      var C3 = d3[0][v3].length, M4 = E3(v3, L3);\n                      S2(x2, M4) ? x2.push.apply(x2, M4) : (x2.length > 0 && b.push(x2), x2 = M4);\n                    }\n                    x2.length > 0 && b.push(x2);\n                  }\n                  return b;\n                }\n              }, 3090: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(3250)[3];\n                function l3(u4) {\n                  var c5 = u4.length;\n                  if (c5 < 3) {\n                    for (var k4 = new Array(c5), f4 = 0; f4 < c5; ++f4) k4[f4] = f4;\n                    return c5 === 2 && u4[0][0] === u4[1][0] && u4[0][1] === u4[1][1] ? [0] : k4;\n                  }\n                  for (var h3 = new Array(c5), f4 = 0; f4 < c5; ++f4) h3[f4] = f4;\n                  h3.sort(function(x2, C3) {\n                    var M4 = u4[x2][0] - u4[C3][0];\n                    return M4 || u4[x2][1] - u4[C3][1];\n                  });\n                  for (var d3 = [h3[0], h3[1]], v3 = [h3[0], h3[1]], f4 = 2; f4 < c5; ++f4) {\n                    for (var _2 = h3[f4], b = u4[_2], p3 = d3.length; p3 > 1 && s3(u4[d3[p3 - 2]], u4[d3[p3 - 1]], b) <= 0; ) p3 -= 1, d3.pop();\n                    for (d3.push(_2), p3 = v3.length; p3 > 1 && s3(u4[v3[p3 - 2]], u4[v3[p3 - 1]], b) >= 0; ) p3 -= 1, v3.pop();\n                    v3.push(_2);\n                  }\n                  for (var k4 = new Array(v3.length + d3.length - 2), E3 = 0, f4 = 0, S2 = d3.length; f4 < S2; ++f4) k4[E3++] = d3[f4];\n                  for (var L3 = v3.length - 2; L3 > 0; --L3) k4[E3++] = v3[L3];\n                  return k4;\n                }\n              }, 3105: function(i3, a4) {\n                "use strict";\n                "use restrict";\n                var o4 = 32;\n                a4.INT_BITS = o4, a4.INT_MAX = 2147483647, a4.INT_MIN = -1 << o4 - 1, a4.sign = function(u4) {\n                  return (u4 > 0) - (u4 < 0);\n                }, a4.abs = function(u4) {\n                  var c5 = u4 >> o4 - 1;\n                  return (u4 ^ c5) - c5;\n                }, a4.min = function(u4, c5) {\n                  return c5 ^ (u4 ^ c5) & -(u4 < c5);\n                }, a4.max = function(u4, c5) {\n                  return u4 ^ (u4 ^ c5) & -(u4 < c5);\n                }, a4.isPow2 = function(u4) {\n                  return !(u4 & u4 - 1) && !!u4;\n                }, a4.log2 = function(u4) {\n                  var c5, f4;\n                  return c5 = (u4 > 65535) << 4, u4 >>>= c5, f4 = (u4 > 255) << 3, u4 >>>= f4, c5 |= f4, f4 = (u4 > 15) << 2, u4 >>>= f4, c5 |= f4, f4 = (u4 > 3) << 1, u4 >>>= f4, c5 |= f4, c5 | u4 >> 1;\n                }, a4.log10 = function(u4) {\n                  return u4 >= 1e9 ? 9 : u4 >= 1e8 ? 8 : u4 >= 1e7 ? 7 : u4 >= 1e6 ? 6 : u4 >= 1e5 ? 5 : u4 >= 1e4 ? 4 : u4 >= 1e3 ? 3 : u4 >= 100 ? 2 : u4 >= 10 ? 1 : 0;\n                }, a4.popCount = function(u4) {\n                  return u4 = u4 - (u4 >>> 1 & 1431655765), u4 = (u4 & 858993459) + (u4 >>> 2 & 858993459), (u4 + (u4 >>> 4) & 252645135) * 16843009 >>> 24;\n                };\n                function s3(u4) {\n                  var c5 = 32;\n                  return u4 &= -u4, u4 && c5--, u4 & 65535 && (c5 -= 16), u4 & 16711935 && (c5 -= 8), u4 & 252645135 && (c5 -= 4), u4 & 858993459 && (c5 -= 2), u4 & 1431655765 && (c5 -= 1), c5;\n                }\n                a4.countTrailingZeros = s3, a4.nextPow2 = function(u4) {\n                  return u4 += u4 === 0, --u4, u4 |= u4 >>> 1, u4 |= u4 >>> 2, u4 |= u4 >>> 4, u4 |= u4 >>> 8, u4 |= u4 >>> 16, u4 + 1;\n                }, a4.prevPow2 = function(u4) {\n                  return u4 |= u4 >>> 1, u4 |= u4 >>> 2, u4 |= u4 >>> 4, u4 |= u4 >>> 8, u4 |= u4 >>> 16, u4 - (u4 >>> 1);\n                }, a4.parity = function(u4) {\n                  return u4 ^= u4 >>> 16, u4 ^= u4 >>> 8, u4 ^= u4 >>> 4, u4 &= 15, 27030 >>> u4 & 1;\n                };\n                var l3 = new Array(256);\n                (function(u4) {\n                  for (var c5 = 0; c5 < 256; ++c5) {\n                    var f4 = c5, h3 = c5, d3 = 7;\n                    for (f4 >>>= 1; f4; f4 >>>= 1) h3 <<= 1, h3 |= f4 & 1, --d3;\n                    u4[c5] = h3 << d3 & 255;\n                  }\n                })(l3), a4.reverse = function(u4) {\n                  return l3[u4 & 255] << 24 | l3[u4 >>> 8 & 255] << 16 | l3[u4 >>> 16 & 255] << 8 | l3[u4 >>> 24 & 255];\n                }, a4.interleave2 = function(u4, c5) {\n                  return u4 &= 65535, u4 = (u4 | u4 << 8) & 16711935, u4 = (u4 | u4 << 4) & 252645135, u4 = (u4 | u4 << 2) & 858993459, u4 = (u4 | u4 << 1) & 1431655765, c5 &= 65535, c5 = (c5 | c5 << 8) & 16711935, c5 = (c5 | c5 << 4) & 252645135, c5 = (c5 | c5 << 2) & 858993459, c5 = (c5 | c5 << 1) & 1431655765, u4 | c5 << 1;\n                }, a4.deinterleave2 = function(u4, c5) {\n                  return u4 = u4 >>> c5 & 1431655765, u4 = (u4 | u4 >>> 1) & 858993459, u4 = (u4 | u4 >>> 2) & 252645135, u4 = (u4 | u4 >>> 4) & 16711935, u4 = (u4 | u4 >>> 16) & 65535, u4 << 16 >> 16;\n                }, a4.interleave3 = function(u4, c5, f4) {\n                  return u4 &= 1023, u4 = (u4 | u4 << 16) & 4278190335, u4 = (u4 | u4 << 8) & 251719695, u4 = (u4 | u4 << 4) & 3272356035, u4 = (u4 | u4 << 2) & 1227133513, c5 &= 1023, c5 = (c5 | c5 << 16) & 4278190335, c5 = (c5 | c5 << 8) & 251719695, c5 = (c5 | c5 << 4) & 3272356035, c5 = (c5 | c5 << 2) & 1227133513, u4 |= c5 << 1, f4 &= 1023, f4 = (f4 | f4 << 16) & 4278190335, f4 = (f4 | f4 << 8) & 251719695, f4 = (f4 | f4 << 4) & 3272356035, f4 = (f4 | f4 << 2) & 1227133513, u4 | f4 << 2;\n                }, a4.deinterleave3 = function(u4, c5) {\n                  return u4 = u4 >>> c5 & 1227133513, u4 = (u4 | u4 >>> 2) & 3272356035, u4 = (u4 | u4 >>> 4) & 251719695, u4 = (u4 | u4 >>> 8) & 4278190335, u4 = (u4 | u4 >>> 16) & 1023, u4 << 22 >> 22;\n                }, a4.nextCombination = function(u4) {\n                  var c5 = u4 | u4 - 1;\n                  return c5 + 1 | (~c5 & -~c5) - 1 >>> s3(u4) + 1;\n                };\n              }, 3126: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = new Float32Array(3);\n                  return s3[0] = o4[0], s3[1] = o4[1], s3[2] = o4[2], s3;\n                }\n              }, 3134: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(1682);\n                function l3(u4, c5) {\n                  var f4 = u4.length;\n                  if (typeof c5 != "number") {\n                    c5 = 0;\n                    for (var h3 = 0; h3 < f4; ++h3) {\n                      var d3 = u4[h3];\n                      c5 = Math.max(c5, d3[0], d3[1]);\n                    }\n                    c5 = (c5 | 0) + 1;\n                  }\n                  c5 = c5 | 0;\n                  for (var v3 = new Array(c5), h3 = 0; h3 < c5; ++h3) v3[h3] = [];\n                  for (var h3 = 0; h3 < f4; ++h3) {\n                    var d3 = u4[h3];\n                    v3[d3[0]].push(d3[1]), v3[d3[1]].push(d3[0]);\n                  }\n                  for (var _2 = 0; _2 < c5; ++_2) s3(v3[_2], function(b, p3) {\n                    return b - p3;\n                  });\n                  return v3;\n                }\n              }, 3140: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = d3;\n                var s3 = o4(3250), l3 = o4(8572), u4 = o4(9362), c5 = o4(5382), f4 = o4(8210);\n                function h3(v3, _2, b) {\n                  var p3 = u4(v3[0], -_2[0]), k4 = u4(v3[1], -_2[1]), E3 = u4(b[0], -_2[0]), S2 = u4(b[1], -_2[1]), L3 = f4(c5(p3, E3), c5(k4, S2));\n                  return L3[L3.length - 1] >= 0;\n                }\n                function d3(v3, _2, b, p3) {\n                  var k4 = s3(_2, b, p3);\n                  if (k4 === 0) {\n                    var E3 = l3(s3(v3, _2, b)), S2 = l3(s3(v3, _2, p3));\n                    if (E3 === S2) {\n                      if (E3 === 0) {\n                        var L3 = h3(v3, _2, b), x2 = h3(v3, _2, p3);\n                        return L3 === x2 ? 0 : L3 ? 1 : -1;\n                      }\n                      return 0;\n                    } else {\n                      if (S2 === 0) return E3 > 0 || h3(v3, _2, p3) ? -1 : 1;\n                      if (E3 === 0) return S2 > 0 || h3(v3, _2, b) ? 1 : -1;\n                    }\n                    return l3(S2 - E3);\n                  }\n                  var C3 = s3(v3, _2, b);\n                  if (C3 > 0) return k4 > 0 && s3(v3, _2, p3) > 0 ? 1 : -1;\n                  if (C3 < 0) return k4 > 0 || s3(v3, _2, p3) > 0 ? 1 : -1;\n                  var M4 = s3(v3, _2, p3);\n                  return M4 > 0 || h3(v3, _2, b) ? 1 : -1;\n                }\n              }, 3202: function(i3) {\n                i3.exports = function(o4, s3) {\n                  s3 || (s3 = [0, ""]), o4 = String(o4);\n                  var l3 = parseFloat(o4, 10);\n                  return s3[0] = l3, s3[1] = o4.match(/[\\d.\\-\\+]*\\s*(.*)/)[1] || "", s3;\n                };\n              }, 3233: function(i3) {\n                "use strict";\n                var a4 = "", o4;\n                i3.exports = s3;\n                function s3(l3, u4) {\n                  if (typeof l3 != "string") throw new TypeError("expected a string");\n                  if (u4 === 1) return l3;\n                  if (u4 === 2) return l3 + l3;\n                  var c5 = l3.length * u4;\n                  if (o4 !== l3 || typeof o4 == "undefined") o4 = l3, a4 = "";\n                  else if (a4.length >= c5) return a4.substr(0, c5);\n                  for (; c5 > a4.length && u4 > 1; ) u4 & 1 && (a4 += l3), u4 >>= 1, l3 += l3;\n                  return a4 += l3, a4 = a4.substr(0, c5), a4;\n                }\n              }, 3236: function(i3) {\n                i3.exports = function(a4) {\n                  typeof a4 == "string" && (a4 = [a4]);\n                  for (var o4 = [].slice.call(arguments, 1), s3 = [], l3 = 0; l3 < a4.length - 1; l3++) s3.push(a4[l3], o4[l3] || "");\n                  return s3.push(a4[l3]), s3.join("");\n                };\n              }, 3250: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5250), l3 = o4(8210), u4 = o4(3012), c5 = o4(8545), f4 = 5, h3 = 11102230246251565e-32, d3 = (3 + 16 * h3) * h3, v3 = (7 + 56 * h3) * h3;\n                function _2(g3, P3, T3, z3) {\n                  return function(V2, G2, Z) {\n                    var j3 = g3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0]))), N2 = g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), H = z3(j3, N2);\n                    return H[H.length - 1];\n                  };\n                }\n                function b(g3, P3, T3, z3) {\n                  return function(V2, G2, Z, j3) {\n                    var N2 = g3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), G2[2]), g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), -Z[2]), T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), j3[2]))), g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), j3[2])))), H = g3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -Z[2]), T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), j3[2]))), g3(T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), Z[2])))), te = z3(N2, H);\n                    return te[te.length - 1];\n                  };\n                }\n                function p3(g3, P3, T3, z3) {\n                  return function(V2, G2, Z, j3, N2) {\n                    var H = g3(g3(g3(T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), Z[2]), g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), -j3[2]), T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), N2[2]))), G2[3]), g3(T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), G2[2]), g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), -j3[2]), T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), N2[2]))), -Z[3]), T3(g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), G2[2]), g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), -Z[2]), T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), N2[2]))), j3[3]))), g3(T3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), G2[2]), g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), -Z[2]), T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), j3[2]))), -N2[3]), g3(T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), G2[2]), g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), -j3[2]), T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), N2[2]))), V2[3]), T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -j3[2]), T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), N2[2]))), -G2[3])))), g3(g3(T3(g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), N2[2]))), j3[3]), g3(T3(g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), j3[2]))), -N2[3]), T3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), G2[2]), g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), -Z[2]), T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), j3[2]))), V2[3]))), g3(T3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -Z[2]), T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), j3[2]))), -G2[3]), g3(T3(g3(T3(g3(P3(G2[1], j3[0]), P3(-j3[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), j3[2]))), Z[3]), T3(g3(T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), Z[2]))), -j3[3]))))), te = g3(g3(g3(T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), Z[2]), g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), -j3[2]), T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), N2[2]))), V2[3]), T3(g3(T3(g3(P3(j3[1], N2[0]), P3(-N2[1], j3[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -j3[2]), T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), N2[2]))), -Z[3])), g3(T3(g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -Z[2]), T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), N2[2]))), j3[3]), T3(g3(T3(g3(P3(Z[1], j3[0]), P3(-j3[1], Z[0])), V2[2]), g3(T3(g3(P3(V2[1], j3[0]), P3(-j3[1], V2[0])), -Z[2]), T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), j3[2]))), -N2[3]))), g3(g3(T3(g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), G2[2]), g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), -Z[2]), T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), N2[2]))), V2[3]), T3(g3(T3(g3(P3(Z[1], N2[0]), P3(-N2[1], Z[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -Z[2]), T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), N2[2]))), -G2[3])), g3(T3(g3(T3(g3(P3(G2[1], N2[0]), P3(-N2[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], N2[0]), P3(-N2[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), N2[2]))), Z[3]), T3(g3(T3(g3(P3(G2[1], Z[0]), P3(-Z[1], G2[0])), V2[2]), g3(T3(g3(P3(V2[1], Z[0]), P3(-Z[1], V2[0])), -G2[2]), T3(g3(P3(V2[1], G2[0]), P3(-G2[1], V2[0])), Z[2]))), -N2[3])))), oe = z3(H, te);\n                    return oe[oe.length - 1];\n                  };\n                }\n                function k4(g3) {\n                  var P3 = g3 === 3 ? _2 : g3 === 4 ? b : p3;\n                  return P3(l3, s3, u4, c5);\n                }\n                var E3 = k4(3), S2 = k4(4), L3 = [function() {\n                  return 0;\n                }, function() {\n                  return 0;\n                }, function(P3, T3) {\n                  return T3[0] - P3[0];\n                }, function(P3, T3, z3) {\n                  var O3 = (P3[1] - z3[1]) * (T3[0] - z3[0]), V2 = (P3[0] - z3[0]) * (T3[1] - z3[1]), G2 = O3 - V2, Z;\n                  if (O3 > 0) {\n                    if (V2 <= 0) return G2;\n                    Z = O3 + V2;\n                  } else if (O3 < 0) {\n                    if (V2 >= 0) return G2;\n                    Z = -(O3 + V2);\n                  } else return G2;\n                  var j3 = d3 * Z;\n                  return G2 >= j3 || G2 <= -j3 ? G2 : E3(P3, T3, z3);\n                }, function(P3, T3, z3, O3) {\n                  var V2 = P3[0] - O3[0], G2 = T3[0] - O3[0], Z = z3[0] - O3[0], j3 = P3[1] - O3[1], N2 = T3[1] - O3[1], H = z3[1] - O3[1], te = P3[2] - O3[2], oe = T3[2] - O3[2], _e = z3[2] - O3[2], Ee = G2 * H, Ce = Z * N2, me = Z * j3, ie = V2 * H, Se = V2 * N2, Le = G2 * j3, Ae = te * (Ee - Ce) + oe * (me - ie) + _e * (Se - Le), Fe = (Math.abs(Ee) + Math.abs(Ce)) * Math.abs(te) + (Math.abs(me) + Math.abs(ie)) * Math.abs(oe) + (Math.abs(Se) + Math.abs(Le)) * Math.abs(_e), Pe = v3 * Fe;\n                  return Ae > Pe || -Ae > Pe ? Ae : S2(P3, T3, z3, O3);\n                }];\n                function x2(g3) {\n                  var P3 = L3[g3.length];\n                  return P3 || (P3 = L3[g3.length] = k4(g3.length)), P3.apply(void 0, g3);\n                }\n                function C3(g3, P3, T3, z3, O3, V2, G2) {\n                  return function(j3, N2, H, te, oe) {\n                    switch (arguments.length) {\n                      case 0:\n                      case 1:\n                        return 0;\n                      case 2:\n                        return z3(j3, N2);\n                      case 3:\n                        return O3(j3, N2, H);\n                      case 4:\n                        return V2(j3, N2, H, te);\n                      case 5:\n                        return G2(j3, N2, H, te, oe);\n                    }\n                    for (var _e = new Array(arguments.length), Ee = 0; Ee < arguments.length; ++Ee) _e[Ee] = arguments[Ee];\n                    return g3(_e);\n                  };\n                }\n                function M4() {\n                  for (; L3.length <= f4; ) L3.push(k4(L3.length));\n                  i3.exports = C3.apply(void 0, [x2].concat(L3));\n                  for (var g3 = 0; g3 <= f4; ++g3) i3.exports[g3] = L3[g3];\n                }\n                M4();\n              }, 3327: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(216), l3 = o4(8866);\n                i3.exports = f4;\n                function u4(h3) {\n                  return function() {\n                    return h3;\n                  };\n                }\n                function c5(h3, d3) {\n                  for (var v3 = new Array(h3), _2 = 0; _2 < h3; ++_2) v3[_2] = d3;\n                  return v3;\n                }\n                function f4(h3, d3, v3, _2) {\n                  function b(C3) {\n                    return function(M4, g3, P3) {\n                      return M4.getUniform(g3.program, P3[C3]);\n                    };\n                  }\n                  function p3(C3) {\n                    return function(g3) {\n                      for (var P3 = k4("", C3), T3 = 0; T3 < P3.length; ++T3) {\n                        var z3 = P3[T3], O3 = z3[0], V2 = z3[1];\n                        if (_2[V2]) {\n                          var G2 = g3;\n                          if (typeof O3 == "string" && (O3.indexOf(".") === 0 || O3.indexOf("[") === 0)) {\n                            var Z = O3;\n                            if (O3.indexOf(".") === 0 && (Z = O3.slice(1)), Z.indexOf("]") === Z.length - 1) {\n                              var j3 = Z.indexOf("["), N2 = Z.slice(0, j3), H = Z.slice(j3 + 1, Z.length - 1);\n                              G2 = N2 ? g3[N2][H] : g3[H];\n                            } else G2 = g3[Z];\n                          }\n                          var te = v3[V2].type, oe;\n                          switch (te) {\n                            case "bool":\n                            case "int":\n                            case "sampler2D":\n                            case "samplerCube":\n                              h3.uniform1i(_2[V2], G2);\n                              break;\n                            case "float":\n                              h3.uniform1f(_2[V2], G2);\n                              break;\n                            default:\n                              var _e = te.indexOf("vec");\n                              if (0 <= _e && _e <= 1 && te.length === 4 + _e) {\n                                if (oe = te.charCodeAt(te.length - 1) - 48, oe < 2 || oe > 4) throw new l3("", "Invalid data type");\n                                switch (te.charAt(0)) {\n                                  case "b":\n                                  case "i":\n                                    h3["uniform" + oe + "iv"](_2[V2], G2);\n                                    break;\n                                  case "v":\n                                    h3["uniform" + oe + "fv"](_2[V2], G2);\n                                    break;\n                                  default:\n                                    throw new l3("", "Unrecognized data type for vector " + name + ": " + te);\n                                }\n                              } else if (te.indexOf("mat") === 0 && te.length === 4) {\n                                if (oe = te.charCodeAt(te.length - 1) - 48, oe < 2 || oe > 4) throw new l3("", "Invalid uniform dimension type for matrix " + name + ": " + te);\n                                h3["uniformMatrix" + oe + "fv"](_2[V2], false, G2);\n                                break;\n                              } else throw new l3("", "Unknown uniform data type for " + name + ": " + te);\n                          }\n                        }\n                      }\n                    };\n                  }\n                  function k4(C3, M4) {\n                    if (typeof M4 != "object") return [[C3, M4]];\n                    var g3 = [];\n                    for (var P3 in M4) {\n                      var T3 = M4[P3], z3 = C3;\n                      parseInt(P3) + "" === P3 ? z3 += "[" + P3 + "]" : z3 += "." + P3, typeof T3 == "object" ? g3.push.apply(g3, k4(z3, T3)) : g3.push([z3, T3]);\n                    }\n                    return g3;\n                  }\n                  function E3(C3) {\n                    switch (C3) {\n                      case "bool":\n                        return false;\n                      case "int":\n                      case "sampler2D":\n                      case "samplerCube":\n                        return 0;\n                      case "float":\n                        return 0;\n                      default:\n                        var M4 = C3.indexOf("vec");\n                        if (0 <= M4 && M4 <= 1 && C3.length === 4 + M4) {\n                          var g3 = C3.charCodeAt(C3.length - 1) - 48;\n                          if (g3 < 2 || g3 > 4) throw new l3("", "Invalid data type");\n                          return C3.charAt(0) === "b" ? c5(g3, false) : c5(g3, 0);\n                        } else if (C3.indexOf("mat") === 0 && C3.length === 4) {\n                          var g3 = C3.charCodeAt(C3.length - 1) - 48;\n                          if (g3 < 2 || g3 > 4) throw new l3("", "Invalid uniform dimension type for matrix " + name + ": " + C3);\n                          return c5(g3 * g3, 0);\n                        } else throw new l3("", "Unknown uniform data type for " + name + ": " + C3);\n                    }\n                  }\n                  function S2(C3, M4, g3) {\n                    if (typeof g3 == "object") {\n                      var P3 = L3(g3);\n                      Object.defineProperty(C3, M4, { get: u4(P3), set: p3(g3), enumerable: true, configurable: false });\n                    } else _2[g3] ? Object.defineProperty(C3, M4, { get: b(g3), set: p3(g3), enumerable: true, configurable: false }) : C3[M4] = E3(v3[g3].type);\n                  }\n                  function L3(C3) {\n                    var M4;\n                    if (Array.isArray(C3)) {\n                      M4 = new Array(C3.length);\n                      for (var g3 = 0; g3 < C3.length; ++g3) S2(M4, g3, C3[g3]);\n                    } else {\n                      M4 = {};\n                      for (var P3 in C3) S2(M4, P3, C3[P3]);\n                    }\n                    return M4;\n                  }\n                  var x2 = s3(v3, true);\n                  return { get: u4(L3(x2)), set: p3(x2), enumerable: true, configurable: true };\n                }\n              }, 3349: function(i3) {\n                "use strict";\n                function a4() {\n                  return function(f4, h3, d3, v3, _2, b) {\n                    var p3 = f4[0], k4 = d3[0], E3 = [0], S2 = k4;\n                    v3 |= 0;\n                    var L3 = 0, x2 = k4;\n                    for (L3 = 0; L3 < p3; ++L3) {\n                      {\n                        var C3 = h3[v3] - b, M4 = h3[v3 + S2] - b;\n                        C3 >= 0 != M4 >= 0 && _2.push(E3[0] + 0.5 + 0.5 * (C3 + M4) / (C3 - M4));\n                      }\n                      v3 += x2, ++E3[0];\n                    }\n                  };\n                }\n                function o4() {\n                  return a4();\n                }\n                var s3 = o4;\n                function l3(f4) {\n                  var h3 = {};\n                  return function(v3, _2, b) {\n                    var p3 = v3.dtype, k4 = v3.order, E3 = [p3, k4.join()].join(), S2 = h3[E3];\n                    return S2 || (h3[E3] = S2 = f4([p3, k4])), S2(v3.shape.slice(0), v3.data, v3.stride, v3.offset | 0, _2, b);\n                  };\n                }\n                function u4(f4) {\n                  return l3(s3.bind(void 0, f4));\n                }\n                function c5(f4) {\n                  return u4({ funcName: f4.funcName });\n                }\n                i3.exports = c5({ funcName: "zeroCrossings" });\n              }, 3352: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2478), l3 = 0, u4 = 1, c5 = 2;\n                i3.exports = P3;\n                function f4(T3, z3, O3, V2, G2) {\n                  this.mid = T3, this.left = z3, this.right = O3, this.leftPoints = V2, this.rightPoints = G2, this.count = (z3 ? z3.count : 0) + (O3 ? O3.count : 0) + V2.length;\n                }\n                var h3 = f4.prototype;\n                function d3(T3, z3) {\n                  T3.mid = z3.mid, T3.left = z3.left, T3.right = z3.right, T3.leftPoints = z3.leftPoints, T3.rightPoints = z3.rightPoints, T3.count = z3.count;\n                }\n                function v3(T3, z3) {\n                  var O3 = C3(z3);\n                  T3.mid = O3.mid, T3.left = O3.left, T3.right = O3.right, T3.leftPoints = O3.leftPoints, T3.rightPoints = O3.rightPoints, T3.count = O3.count;\n                }\n                function _2(T3, z3) {\n                  var O3 = T3.intervals([]);\n                  O3.push(z3), v3(T3, O3);\n                }\n                function b(T3, z3) {\n                  var O3 = T3.intervals([]), V2 = O3.indexOf(z3);\n                  return V2 < 0 ? l3 : (O3.splice(V2, 1), v3(T3, O3), u4);\n                }\n                h3.intervals = function(T3) {\n                  return T3.push.apply(T3, this.leftPoints), this.left && this.left.intervals(T3), this.right && this.right.intervals(T3), T3;\n                }, h3.insert = function(T3) {\n                  var z3 = this.count - this.leftPoints.length;\n                  if (this.count += 1, T3[1] < this.mid) this.left ? 4 * (this.left.count + 1) > 3 * (z3 + 1) ? _2(this, T3) : this.left.insert(T3) : this.left = C3([T3]);\n                  else if (T3[0] > this.mid) this.right ? 4 * (this.right.count + 1) > 3 * (z3 + 1) ? _2(this, T3) : this.right.insert(T3) : this.right = C3([T3]);\n                  else {\n                    var O3 = s3.ge(this.leftPoints, T3, L3), V2 = s3.ge(this.rightPoints, T3, x2);\n                    this.leftPoints.splice(O3, 0, T3), this.rightPoints.splice(V2, 0, T3);\n                  }\n                }, h3.remove = function(T3) {\n                  var z3 = this.count - this.leftPoints;\n                  if (T3[1] < this.mid) {\n                    if (!this.left) return l3;\n                    var O3 = this.right ? this.right.count : 0;\n                    if (4 * O3 > 3 * (z3 - 1)) return b(this, T3);\n                    var V2 = this.left.remove(T3);\n                    return V2 === c5 ? (this.left = null, this.count -= 1, u4) : (V2 === u4 && (this.count -= 1), V2);\n                  } else if (T3[0] > this.mid) {\n                    if (!this.right) return l3;\n                    var G2 = this.left ? this.left.count : 0;\n                    if (4 * G2 > 3 * (z3 - 1)) return b(this, T3);\n                    var V2 = this.right.remove(T3);\n                    return V2 === c5 ? (this.right = null, this.count -= 1, u4) : (V2 === u4 && (this.count -= 1), V2);\n                  } else {\n                    if (this.count === 1) return this.leftPoints[0] === T3 ? c5 : l3;\n                    if (this.leftPoints.length === 1 && this.leftPoints[0] === T3) {\n                      if (this.left && this.right) {\n                        for (var Z = this, j3 = this.left; j3.right; ) Z = j3, j3 = j3.right;\n                        if (Z === this) j3.right = this.right;\n                        else {\n                          var N2 = this.left, V2 = this.right;\n                          Z.count -= j3.count, Z.right = j3.left, j3.left = N2, j3.right = V2;\n                        }\n                        d3(this, j3), this.count = (this.left ? this.left.count : 0) + (this.right ? this.right.count : 0) + this.leftPoints.length;\n                      } else this.left ? d3(this, this.left) : d3(this, this.right);\n                      return u4;\n                    }\n                    for (var N2 = s3.ge(this.leftPoints, T3, L3); N2 < this.leftPoints.length && this.leftPoints[N2][0] === T3[0]; ++N2) if (this.leftPoints[N2] === T3) {\n                      this.count -= 1, this.leftPoints.splice(N2, 1);\n                      for (var V2 = s3.ge(this.rightPoints, T3, x2); V2 < this.rightPoints.length && this.rightPoints[V2][1] === T3[1]; ++V2) if (this.rightPoints[V2] === T3) return this.rightPoints.splice(V2, 1), u4;\n                    }\n                    return l3;\n                  }\n                };\n                function p3(T3, z3, O3) {\n                  for (var V2 = 0; V2 < T3.length && T3[V2][0] <= z3; ++V2) {\n                    var G2 = O3(T3[V2]);\n                    if (G2) return G2;\n                  }\n                }\n                function k4(T3, z3, O3) {\n                  for (var V2 = T3.length - 1; V2 >= 0 && T3[V2][1] >= z3; --V2) {\n                    var G2 = O3(T3[V2]);\n                    if (G2) return G2;\n                  }\n                }\n                function E3(T3, z3) {\n                  for (var O3 = 0; O3 < T3.length; ++O3) {\n                    var V2 = z3(T3[O3]);\n                    if (V2) return V2;\n                  }\n                }\n                h3.queryPoint = function(T3, z3) {\n                  if (T3 < this.mid) {\n                    if (this.left) {\n                      var O3 = this.left.queryPoint(T3, z3);\n                      if (O3) return O3;\n                    }\n                    return p3(this.leftPoints, T3, z3);\n                  } else if (T3 > this.mid) {\n                    if (this.right) {\n                      var O3 = this.right.queryPoint(T3, z3);\n                      if (O3) return O3;\n                    }\n                    return k4(this.rightPoints, T3, z3);\n                  } else return E3(this.leftPoints, z3);\n                }, h3.queryInterval = function(T3, z3, O3) {\n                  if (T3 < this.mid && this.left) {\n                    var V2 = this.left.queryInterval(T3, z3, O3);\n                    if (V2) return V2;\n                  }\n                  if (z3 > this.mid && this.right) {\n                    var V2 = this.right.queryInterval(T3, z3, O3);\n                    if (V2) return V2;\n                  }\n                  return z3 < this.mid ? p3(this.leftPoints, z3, O3) : T3 > this.mid ? k4(this.rightPoints, T3, O3) : E3(this.leftPoints, O3);\n                };\n                function S2(T3, z3) {\n                  return T3 - z3;\n                }\n                function L3(T3, z3) {\n                  var O3 = T3[0] - z3[0];\n                  return O3 || T3[1] - z3[1];\n                }\n                function x2(T3, z3) {\n                  var O3 = T3[1] - z3[1];\n                  return O3 || T3[0] - z3[0];\n                }\n                function C3(T3) {\n                  if (T3.length === 0) return null;\n                  for (var z3 = [], O3 = 0; O3 < T3.length; ++O3) z3.push(T3[O3][0], T3[O3][1]);\n                  z3.sort(S2);\n                  for (var V2 = z3[z3.length >> 1], G2 = [], Z = [], j3 = [], O3 = 0; O3 < T3.length; ++O3) {\n                    var N2 = T3[O3];\n                    N2[1] < V2 ? G2.push(N2) : V2 < N2[0] ? Z.push(N2) : j3.push(N2);\n                  }\n                  var H = j3, te = j3.slice();\n                  return H.sort(L3), te.sort(x2), new f4(V2, C3(G2), C3(Z), H, te);\n                }\n                function M4(T3) {\n                  this.root = T3;\n                }\n                var g3 = M4.prototype;\n                g3.insert = function(T3) {\n                  this.root ? this.root.insert(T3) : this.root = new f4(T3[0], null, null, [T3], [T3]);\n                }, g3.remove = function(T3) {\n                  if (this.root) {\n                    var z3 = this.root.remove(T3);\n                    return z3 === c5 && (this.root = null), z3 !== l3;\n                  }\n                  return false;\n                }, g3.queryPoint = function(T3, z3) {\n                  if (this.root) return this.root.queryPoint(T3, z3);\n                }, g3.queryInterval = function(T3, z3, O3) {\n                  if (T3 <= z3 && this.root) return this.root.queryInterval(T3, z3, O3);\n                }, Object.defineProperty(g3, "count", { get: function() {\n                  return this.root ? this.root.count : 0;\n                } }), Object.defineProperty(g3, "intervals", { get: function() {\n                  return this.root ? this.root.intervals([]) : [];\n                } });\n                function P3(T3) {\n                  return !T3 || T3.length === 0 ? new M4(null) : new M4(C3(T3));\n                }\n              }, 3387: function(i3, a4, o4) {\n                var s3;\n                (function() {\n                  "use strict";\n                  var l3 = { not_string: /[^s]/, not_bool: /[^t]/, not_type: /[^T]/, not_primitive: /[^v]/, number: /[diefg]/, numeric_arg: /[bcdiefguxX]/, json: /[j]/, not_json: /[^j]/, text: /^[^\\x25]+/, modulo: /^\\x25{2}/, placeholder: /^\\x25(?:([1-9]\\d*)\\$|\\(([^)]+)\\))?(\\+)?(0|\'[^$])?(-)?(\\d+)?(?:\\.(\\d+))?([b-gijostTuvxX])/, key: /^([a-z_][a-z_\\d]*)/i, key_access: /^\\.([a-z_][a-z_\\d]*)/i, index_access: /^\\[(\\d+)\\]/, sign: /^[+-]/ };\n                  function u4(v3) {\n                    return f4(d3(v3), arguments);\n                  }\n                  function c5(v3, _2) {\n                    return u4.apply(null, [v3].concat(_2 || []));\n                  }\n                  function f4(v3, _2) {\n                    var b = 1, p3 = v3.length, k4, E3 = "", S2, L3, x2, C3, M4, g3, P3, T3;\n                    for (S2 = 0; S2 < p3; S2++) if (typeof v3[S2] == "string") E3 += v3[S2];\n                    else if (typeof v3[S2] == "object") {\n                      if (x2 = v3[S2], x2.keys) for (k4 = _2[b], L3 = 0; L3 < x2.keys.length; L3++) {\n                        if (k4 == null) throw new Error(u4(\'[sprintf] Cannot access property "%s" of undefined value "%s"\', x2.keys[L3], x2.keys[L3 - 1]));\n                        k4 = k4[x2.keys[L3]];\n                      }\n                      else x2.param_no ? k4 = _2[x2.param_no] : k4 = _2[b++];\n                      if (l3.not_type.test(x2.type) && l3.not_primitive.test(x2.type) && k4 instanceof Function && (k4 = k4()), l3.numeric_arg.test(x2.type) && typeof k4 != "number" && isNaN(k4)) throw new TypeError(u4("[sprintf] expecting number but found %T", k4));\n                      switch (l3.number.test(x2.type) && (P3 = k4 >= 0), x2.type) {\n                        case "b":\n                          k4 = parseInt(k4, 10).toString(2);\n                          break;\n                        case "c":\n                          k4 = String.fromCharCode(parseInt(k4, 10));\n                          break;\n                        case "d":\n                        case "i":\n                          k4 = parseInt(k4, 10);\n                          break;\n                        case "j":\n                          k4 = JSON.stringify(k4, null, x2.width ? parseInt(x2.width) : 0);\n                          break;\n                        case "e":\n                          k4 = x2.precision ? parseFloat(k4).toExponential(x2.precision) : parseFloat(k4).toExponential();\n                          break;\n                        case "f":\n                          k4 = x2.precision ? parseFloat(k4).toFixed(x2.precision) : parseFloat(k4);\n                          break;\n                        case "g":\n                          k4 = x2.precision ? String(Number(k4.toPrecision(x2.precision))) : parseFloat(k4);\n                          break;\n                        case "o":\n                          k4 = (parseInt(k4, 10) >>> 0).toString(8);\n                          break;\n                        case "s":\n                          k4 = String(k4), k4 = x2.precision ? k4.substring(0, x2.precision) : k4;\n                          break;\n                        case "t":\n                          k4 = String(!!k4), k4 = x2.precision ? k4.substring(0, x2.precision) : k4;\n                          break;\n                        case "T":\n                          k4 = Object.prototype.toString.call(k4).slice(8, -1).toLowerCase(), k4 = x2.precision ? k4.substring(0, x2.precision) : k4;\n                          break;\n                        case "u":\n                          k4 = parseInt(k4, 10) >>> 0;\n                          break;\n                        case "v":\n                          k4 = k4.valueOf(), k4 = x2.precision ? k4.substring(0, x2.precision) : k4;\n                          break;\n                        case "x":\n                          k4 = (parseInt(k4, 10) >>> 0).toString(16);\n                          break;\n                        case "X":\n                          k4 = (parseInt(k4, 10) >>> 0).toString(16).toUpperCase();\n                          break;\n                      }\n                      l3.json.test(x2.type) ? E3 += k4 : (l3.number.test(x2.type) && (!P3 || x2.sign) ? (T3 = P3 ? "+" : "-", k4 = k4.toString().replace(l3.sign, "")) : T3 = "", M4 = x2.pad_char ? x2.pad_char === "0" ? "0" : x2.pad_char.charAt(1) : " ", g3 = x2.width - (T3 + k4).length, C3 = x2.width && g3 > 0 ? M4.repeat(g3) : "", E3 += x2.align ? T3 + k4 + C3 : M4 === "0" ? T3 + C3 + k4 : C3 + T3 + k4);\n                    }\n                    return E3;\n                  }\n                  var h3 = /* @__PURE__ */ Object.create(null);\n                  function d3(v3) {\n                    if (h3[v3]) return h3[v3];\n                    for (var _2 = v3, b, p3 = [], k4 = 0; _2; ) {\n                      if ((b = l3.text.exec(_2)) !== null) p3.push(b[0]);\n                      else if ((b = l3.modulo.exec(_2)) !== null) p3.push("%");\n                      else if ((b = l3.placeholder.exec(_2)) !== null) {\n                        if (b[2]) {\n                          k4 |= 1;\n                          var E3 = [], S2 = b[2], L3 = [];\n                          if ((L3 = l3.key.exec(S2)) !== null) for (E3.push(L3[1]); (S2 = S2.substring(L3[0].length)) !== ""; ) if ((L3 = l3.key_access.exec(S2)) !== null) E3.push(L3[1]);\n                          else if ((L3 = l3.index_access.exec(S2)) !== null) E3.push(L3[1]);\n                          else throw new SyntaxError("[sprintf] failed to parse named argument key");\n                          else throw new SyntaxError("[sprintf] failed to parse named argument key");\n                          b[2] = E3;\n                        } else k4 |= 2;\n                        if (k4 === 3) throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");\n                        p3.push({ placeholder: b[0], param_no: b[1], keys: b[2], sign: b[3], pad_char: b[4], align: b[5], width: b[6], precision: b[7], type: b[8] });\n                      } else throw new SyntaxError("[sprintf] unexpected placeholder");\n                      _2 = _2.substring(b[0].length);\n                    }\n                    return h3[v3] = p3;\n                  }\n                  a4.sprintf = u4, a4.vsprintf = c5, typeof window != "undefined" && (window.sprintf = u4, window.vsprintf = c5, s3 = function() {\n                    return { sprintf: u4, vsprintf: c5 };\n                  }.call(a4, o4, a4, i3), s3 !== void 0 && (i3.exports = s3));\n                })();\n              }, 3390: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = new Float32Array(4);\n                  return c5[0] = o4, c5[1] = s3, c5[2] = l3, c5[3] = u4, c5;\n                }\n              }, 3436: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3236), l3 = o4(9405), u4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, offset;\nattribute vec4 color;\nuniform mat4 model, view, projection;\nuniform float capSize;\nvarying vec4 fragColor;\nvarying vec3 fragPosition;\n\nvoid main() {\n  vec4 worldPosition  = model * vec4(position, 1.0);\n  worldPosition       = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);\n  gl_Position         = projection * (view * worldPosition);\n  fragColor           = color;\n  fragPosition        = position;\n}`]), c5 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float opacity;\nvarying vec3 fragPosition;\nvarying vec4 fragColor;\n\nvoid main() {\n  if (\n    outOfRange(clipBounds[0], clipBounds[1], fragPosition) ||\n    fragColor.a * opacity == 0.\n  ) discard;\n\n  gl_FragColor = opacity * fragColor;\n}`]);\n                i3.exports = function(f4) {\n                  return l3(f4, u4, c5, null, [{ name: "position", type: "vec3" }, { name: "color", type: "vec4" }, { name: "offset", type: "vec3" }]);\n                };\n              }, 3502: function(i3, a4, o4) {\n                i3.exports = u4;\n                var s3 = o4(5995), l3 = o4(9127);\n                function u4(c5, f4) {\n                  return l3(s3(c5, f4));\n                }\n              }, 3508: function(i3, a4, o4) {\n                var s3 = o4(6852);\n                s3 = s3.slice().filter(function(l3) {\n                  return !/^(gl\\_|texture)/.test(l3);\n                }), i3.exports = s3.concat(["gl_VertexID", "gl_InstanceID", "gl_Position", "gl_PointSize", "gl_FragCoord", "gl_FrontFacing", "gl_FragDepth", "gl_PointCoord", "gl_MaxVertexAttribs", "gl_MaxVertexUniformVectors", "gl_MaxVertexOutputVectors", "gl_MaxFragmentInputVectors", "gl_MaxVertexTextureImageUnits", "gl_MaxCombinedTextureImageUnits", "gl_MaxTextureImageUnits", "gl_MaxFragmentUniformVectors", "gl_MaxDrawBuffers", "gl_MinProgramTexelOffset", "gl_MaxProgramTexelOffset", "gl_DepthRangeParameters", "gl_DepthRange", "trunc", "round", "roundEven", "isnan", "isinf", "floatBitsToInt", "floatBitsToUint", "intBitsToFloat", "uintBitsToFloat", "packSnorm2x16", "unpackSnorm2x16", "packUnorm2x16", "unpackUnorm2x16", "packHalf2x16", "unpackHalf2x16", "outerProduct", "transpose", "determinant", "inverse", "texture", "textureSize", "textureProj", "textureLod", "textureOffset", "texelFetch", "texelFetchOffset", "textureProjOffset", "textureLodOffset", "textureProjLod", "textureProjLodOffset", "textureGrad", "textureGradOffset", "textureProjGrad", "textureProjGradOffset"]);\n              }, 3536: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0], u4 = s3[1], c5 = s3[2], f4 = l3 * l3 + u4 * u4 + c5 * c5;\n                  return f4 > 0 && (f4 = 1 / Math.sqrt(f4), o4[0] = s3[0] * f4, o4[1] = s3[1] * f4, o4[2] = s3[2] * f4), o4;\n                }\n              }, 3545: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = f4;\n                var s3 = o4(8105), l3 = s3("lo<p0"), u4 = 8;\n                function c5(h3, d3, v3, _2, b, p3) {\n                  for (var k4 = 2 * h3, E3 = k4 * (v3 + 1) + d3, S2 = v3 + 1; S2 < _2; ++S2, E3 += k4) for (var L3 = b[E3], x2 = S2, C3 = k4 * (S2 - 1); x2 > v3 && b[C3 + d3] > L3; --x2, C3 -= k4) {\n                    for (var M4 = C3, g3 = C3 + k4, P3 = 0; P3 < k4; ++P3, ++M4, ++g3) {\n                      var T3 = b[M4];\n                      b[M4] = b[g3], b[g3] = T3;\n                    }\n                    var z3 = p3[x2];\n                    p3[x2] = p3[x2 - 1], p3[x2 - 1] = z3;\n                  }\n                }\n                function f4(h3, d3, v3, _2, b, p3) {\n                  if (_2 <= v3 + 1) return v3;\n                  for (var k4 = v3, E3 = _2, S2 = _2 + v3 >>> 1, L3 = 2 * h3, x2 = S2, C3 = b[L3 * S2 + d3]; k4 < E3; ) {\n                    if (E3 - k4 < u4) {\n                      c5(h3, d3, k4, E3, b, p3), C3 = b[L3 * S2 + d3];\n                      break;\n                    }\n                    var M4 = E3 - k4, g3 = Math.random() * M4 + k4 | 0, P3 = b[L3 * g3 + d3], T3 = Math.random() * M4 + k4 | 0, z3 = b[L3 * T3 + d3], O3 = Math.random() * M4 + k4 | 0, V2 = b[L3 * O3 + d3];\n                    P3 <= z3 ? V2 >= z3 ? (x2 = T3, C3 = z3) : P3 >= V2 ? (x2 = g3, C3 = P3) : (x2 = O3, C3 = V2) : z3 >= V2 ? (x2 = T3, C3 = z3) : V2 >= P3 ? (x2 = g3, C3 = P3) : (x2 = O3, C3 = V2);\n                    for (var j3 = L3 * (E3 - 1), N2 = L3 * x2, G2 = 0; G2 < L3; ++G2, ++j3, ++N2) {\n                      var Z = b[j3];\n                      b[j3] = b[N2], b[N2] = Z;\n                    }\n                    var H = p3[E3 - 1];\n                    p3[E3 - 1] = p3[x2], p3[x2] = H, x2 = l3(h3, d3, k4, E3 - 1, b, p3, C3);\n                    for (var j3 = L3 * (E3 - 1), N2 = L3 * x2, G2 = 0; G2 < L3; ++G2, ++j3, ++N2) {\n                      var Z = b[j3];\n                      b[j3] = b[N2], b[N2] = Z;\n                    }\n                    var H = p3[E3 - 1];\n                    if (p3[E3 - 1] = p3[x2], p3[x2] = H, S2 < x2) {\n                      for (E3 = x2 - 1; k4 < E3 && b[L3 * (E3 - 1) + d3] === C3; ) E3 -= 1;\n                      E3 += 1;\n                    } else if (x2 < S2) for (k4 = x2 + 1; k4 < E3 && b[L3 * k4 + d3] === C3; ) k4 += 1;\n                    else break;\n                  }\n                  return l3(h3, d3, v3, S2, b, p3, b[L3 * S2 + d3]);\n                }\n              }, 3576: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] * l3[0], o4[1] = s3[1] * l3[1], o4[2] = s3[2] * l3[2], o4[3] = s3[3] * l3[3], o4;\n                }\n              }, 3589: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = _2;\n                var s3 = o4(2260), l3 = o4(1888), u4 = o4(9618), c5 = o4(8828).nextPow2, f4 = function(b, p3, k4) {\n                  for (var E3 = 1e8, S2 = -1, L3 = -1, x2 = b.shape[0], C3 = b.shape[1], M4 = 0; M4 < x2; M4++) for (var g3 = 0; g3 < C3; g3++) {\n                    var P3 = b.get(M4, g3, 0), T3 = b.get(M4, g3, 1), z3 = b.get(M4, g3, 2), O3 = b.get(M4, g3, 3);\n                    if (P3 < 255 || T3 < 255 || z3 < 255 || O3 < 255) {\n                      var V2 = p3 - M4, G2 = k4 - g3, Z = V2 * V2 + G2 * G2;\n                      Z < E3 && (E3 = Z, S2 = M4, L3 = g3);\n                    }\n                  }\n                  return [S2, L3, E3];\n                };\n                function h3(b, p3, k4, E3, S2) {\n                  this.coord = [b, p3], this.id = k4, this.value = E3, this.distance = S2;\n                }\n                function d3(b, p3, k4) {\n                  this.gl = b, this.fbo = p3, this.buffer = k4, this._readTimeout = null;\n                  var E3 = this;\n                  this._readCallback = function() {\n                    E3.gl && (p3.bind(), b.readPixels(0, 0, p3.shape[0], p3.shape[1], b.RGBA, b.UNSIGNED_BYTE, E3.buffer), E3._readTimeout = null);\n                  };\n                }\n                var v3 = d3.prototype;\n                Object.defineProperty(v3, "shape", { get: function() {\n                  return this.gl ? this.fbo.shape.slice() : [0, 0];\n                }, set: function(b) {\n                  if (this.gl) {\n                    this.fbo.shape = b;\n                    var p3 = this.fbo.shape[0], k4 = this.fbo.shape[1];\n                    if (k4 * p3 * 4 > this.buffer.length) {\n                      l3.free(this.buffer);\n                      for (var E3 = this.buffer = l3.mallocUint8(c5(k4 * p3 * 4)), S2 = 0; S2 < k4 * p3 * 4; ++S2) E3[S2] = 255;\n                    }\n                    return b;\n                  }\n                } }), v3.begin = function() {\n                  var b = this.gl, p3 = this.shape;\n                  b && (this.fbo.bind(), b.clearColor(1, 1, 1, 1), b.clear(b.COLOR_BUFFER_BIT | b.DEPTH_BUFFER_BIT));\n                }, v3.end = function() {\n                  var b = this.gl;\n                  b && (b.bindFramebuffer(b.FRAMEBUFFER, null), this._readTimeout || clearTimeout(this._readTimeout), this._readTimeout = setTimeout(this._readCallback, 1));\n                }, v3.query = function(b, p3, k4) {\n                  if (!this.gl) return null;\n                  var E3 = this.fbo.shape.slice();\n                  b = b | 0, p3 = p3 | 0, typeof k4 != "number" && (k4 = 1);\n                  var S2 = Math.min(Math.max(b - k4, 0), E3[0]) | 0, L3 = Math.min(Math.max(b + k4, 0), E3[0]) | 0, x2 = Math.min(Math.max(p3 - k4, 0), E3[1]) | 0, C3 = Math.min(Math.max(p3 + k4, 0), E3[1]) | 0;\n                  if (L3 <= S2 || C3 <= x2) return null;\n                  var M4 = [L3 - S2, C3 - x2], g3 = u4(this.buffer, [M4[0], M4[1], 4], [4, E3[0] * 4, 1], 4 * (S2 + E3[0] * x2)), P3 = f4(g3.hi(M4[0], M4[1], 1), k4, k4), T3 = P3[0], z3 = P3[1];\n                  if (T3 < 0 || Math.pow(this.radius, 2) < P3[2]) return null;\n                  var O3 = g3.get(T3, z3, 0), V2 = g3.get(T3, z3, 1), G2 = g3.get(T3, z3, 2), Z = g3.get(T3, z3, 3);\n                  return new h3(T3 + S2 | 0, z3 + x2 | 0, O3, [V2, G2, Z], Math.sqrt(P3[2]));\n                }, v3.dispose = function() {\n                  this.gl && (this.fbo.dispose(), l3.free(this.buffer), this.gl = null, this._readTimeout && clearTimeout(this._readTimeout));\n                };\n                function _2(b, p3) {\n                  var k4 = p3[0], E3 = p3[1], S2 = {}, L3 = s3(b, k4, E3, S2), x2 = l3.mallocUint8(k4 * E3 * 4);\n                  return new d3(b, L3, x2);\n                }\n              }, 3628: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1338), l3 = o4(727);\n                function u4(h3, d3) {\n                  for (var v3 = 0, _2 = h3.length, b = 0; b < _2; ++b) v3 += h3[b] * d3[b];\n                  return v3;\n                }\n                function c5(h3) {\n                  var d3 = h3.length;\n                  if (d3 === 0) return [];\n                  var v3 = h3[0].length, _2 = s3([h3.length + 1, h3.length + 1], 1), b = s3([h3.length + 1], 1);\n                  _2[d3][d3] = 0;\n                  for (var p3 = 0; p3 < d3; ++p3) {\n                    for (var k4 = 0; k4 <= p3; ++k4) _2[k4][p3] = _2[p3][k4] = 2 * u4(h3[p3], h3[k4]);\n                    b[p3] = u4(h3[p3], h3[p3]);\n                  }\n                  for (var E3 = l3(_2, b), S2 = 0, L3 = E3[d3 + 1], p3 = 0; p3 < L3.length; ++p3) S2 += L3[p3];\n                  for (var x2 = new Array(d3), p3 = 0; p3 < d3; ++p3) {\n                    for (var L3 = E3[p3], C3 = 0, k4 = 0; k4 < L3.length; ++k4) C3 += L3[k4];\n                    x2[p3] = C3 / S2;\n                  }\n                  return x2;\n                }\n                function f4(h3) {\n                  if (h3.length === 0) return [];\n                  for (var d3 = h3[0].length, v3 = s3([d3]), _2 = c5(h3), b = 0; b < h3.length; ++b) for (var p3 = 0; p3 < d3; ++p3) v3[p3] += h3[b][p3] * _2[b];\n                  return v3;\n                }\n                f4.barycenetric = c5, i3.exports = f4;\n              }, 3637: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = _2;\n                var s3 = o4(6504), l3 = o4(8697), u4 = o4(5572), c5 = o4(7721), f4 = o4(544), h3 = o4(2653), d3 = o4(8987);\n                function v3(b, p3) {\n                  return u4(s3(b[0], p3[1]), s3(b[1], p3[0]));\n                }\n                function _2(b, p3, k4, E3) {\n                  var S2 = f4(p3, b), L3 = f4(E3, k4), x2 = v3(S2, L3);\n                  if (c5(x2) === 0) return null;\n                  var C3 = f4(b, k4), M4 = v3(L3, C3), g3 = l3(M4, x2), P3 = d3(S2, g3), T3 = h3(b, P3);\n                  return T3;\n                }\n              }, 3642: function(i3) {\n                i3.exports = { jet: [{ index: 0, rgb: [0, 0, 131] }, { index: 0.125, rgb: [0, 60, 170] }, { index: 0.375, rgb: [5, 255, 255] }, { index: 0.625, rgb: [255, 255, 0] }, { index: 0.875, rgb: [250, 0, 0] }, { index: 1, rgb: [128, 0, 0] }], hsv: [{ index: 0, rgb: [255, 0, 0] }, { index: 0.169, rgb: [253, 255, 2] }, { index: 0.173, rgb: [247, 255, 2] }, { index: 0.337, rgb: [0, 252, 4] }, { index: 0.341, rgb: [0, 252, 10] }, { index: 0.506, rgb: [1, 249, 255] }, { index: 0.671, rgb: [2, 0, 253] }, { index: 0.675, rgb: [8, 0, 253] }, { index: 0.839, rgb: [255, 0, 251] }, { index: 0.843, rgb: [255, 0, 245] }, { index: 1, rgb: [255, 0, 6] }], hot: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.3, rgb: [230, 0, 0] }, { index: 0.6, rgb: [255, 210, 0] }, { index: 1, rgb: [255, 255, 255] }], spring: [{ index: 0, rgb: [255, 0, 255] }, { index: 1, rgb: [255, 255, 0] }], summer: [{ index: 0, rgb: [0, 128, 102] }, { index: 1, rgb: [255, 255, 102] }], autumn: [{ index: 0, rgb: [255, 0, 0] }, { index: 1, rgb: [255, 255, 0] }], winter: [{ index: 0, rgb: [0, 0, 255] }, { index: 1, rgb: [0, 255, 128] }], bone: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.376, rgb: [84, 84, 116] }, { index: 0.753, rgb: [169, 200, 200] }, { index: 1, rgb: [255, 255, 255] }], copper: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.804, rgb: [255, 160, 102] }, { index: 1, rgb: [255, 199, 127] }], greys: [{ index: 0, rgb: [0, 0, 0] }, { index: 1, rgb: [255, 255, 255] }], yignbu: [{ index: 0, rgb: [8, 29, 88] }, { index: 0.125, rgb: [37, 52, 148] }, { index: 0.25, rgb: [34, 94, 168] }, { index: 0.375, rgb: [29, 145, 192] }, { index: 0.5, rgb: [65, 182, 196] }, { index: 0.625, rgb: [127, 205, 187] }, { index: 0.75, rgb: [199, 233, 180] }, { index: 0.875, rgb: [237, 248, 217] }, { index: 1, rgb: [255, 255, 217] }], greens: [{ index: 0, rgb: [0, 68, 27] }, { index: 0.125, rgb: [0, 109, 44] }, { index: 0.25, rgb: [35, 139, 69] }, { index: 0.375, rgb: [65, 171, 93] }, { index: 0.5, rgb: [116, 196, 118] }, { index: 0.625, rgb: [161, 217, 155] }, { index: 0.75, rgb: [199, 233, 192] }, { index: 0.875, rgb: [229, 245, 224] }, { index: 1, rgb: [247, 252, 245] }], yiorrd: [{ index: 0, rgb: [128, 0, 38] }, { index: 0.125, rgb: [189, 0, 38] }, { index: 0.25, rgb: [227, 26, 28] }, { index: 0.375, rgb: [252, 78, 42] }, { index: 0.5, rgb: [253, 141, 60] }, { index: 0.625, rgb: [254, 178, 76] }, { index: 0.75, rgb: [254, 217, 118] }, { index: 0.875, rgb: [255, 237, 160] }, { index: 1, rgb: [255, 255, 204] }], bluered: [{ index: 0, rgb: [0, 0, 255] }, { index: 1, rgb: [255, 0, 0] }], rdbu: [{ index: 0, rgb: [5, 10, 172] }, { index: 0.35, rgb: [106, 137, 247] }, { index: 0.5, rgb: [190, 190, 190] }, { index: 0.6, rgb: [220, 170, 132] }, { index: 0.7, rgb: [230, 145, 90] }, { index: 1, rgb: [178, 10, 28] }], picnic: [{ index: 0, rgb: [0, 0, 255] }, { index: 0.1, rgb: [51, 153, 255] }, { index: 0.2, rgb: [102, 204, 255] }, { index: 0.3, rgb: [153, 204, 255] }, { index: 0.4, rgb: [204, 204, 255] }, { index: 0.5, rgb: [255, 255, 255] }, { index: 0.6, rgb: [255, 204, 255] }, { index: 0.7, rgb: [255, 153, 255] }, { index: 0.8, rgb: [255, 102, 204] }, { index: 0.9, rgb: [255, 102, 102] }, { index: 1, rgb: [255, 0, 0] }], rainbow: [{ index: 0, rgb: [150, 0, 90] }, { index: 0.125, rgb: [0, 0, 200] }, { index: 0.25, rgb: [0, 25, 255] }, { index: 0.375, rgb: [0, 152, 255] }, { index: 0.5, rgb: [44, 255, 150] }, { index: 0.625, rgb: [151, 255, 0] }, { index: 0.75, rgb: [255, 234, 0] }, { index: 0.875, rgb: [255, 111, 0] }, { index: 1, rgb: [255, 0, 0] }], portland: [{ index: 0, rgb: [12, 51, 131] }, { index: 0.25, rgb: [10, 136, 186] }, { index: 0.5, rgb: [242, 211, 56] }, { index: 0.75, rgb: [242, 143, 56] }, { index: 1, rgb: [217, 30, 30] }], blackbody: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.2, rgb: [230, 0, 0] }, { index: 0.4, rgb: [230, 210, 0] }, { index: 0.7, rgb: [255, 255, 255] }, { index: 1, rgb: [160, 200, 255] }], earth: [{ index: 0, rgb: [0, 0, 130] }, { index: 0.1, rgb: [0, 180, 180] }, { index: 0.2, rgb: [40, 210, 40] }, { index: 0.4, rgb: [230, 230, 50] }, { index: 0.6, rgb: [120, 70, 20] }, { index: 1, rgb: [255, 255, 255] }], electric: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.15, rgb: [30, 0, 100] }, { index: 0.4, rgb: [120, 0, 100] }, { index: 0.6, rgb: [160, 90, 0] }, { index: 0.8, rgb: [230, 200, 0] }, { index: 1, rgb: [255, 250, 220] }], alpha: [{ index: 0, rgb: [255, 255, 255, 0] }, { index: 1, rgb: [255, 255, 255, 1] }], viridis: [{ index: 0, rgb: [68, 1, 84] }, { index: 0.13, rgb: [71, 44, 122] }, { index: 0.25, rgb: [59, 81, 139] }, { index: 0.38, rgb: [44, 113, 142] }, { index: 0.5, rgb: [33, 144, 141] }, { index: 0.63, rgb: [39, 173, 129] }, { index: 0.75, rgb: [92, 200, 99] }, { index: 0.88, rgb: [170, 220, 50] }, { index: 1, rgb: [253, 231, 37] }], inferno: [{ index: 0, rgb: [0, 0, 4] }, { index: 0.13, rgb: [31, 12, 72] }, { index: 0.25, rgb: [85, 15, 109] }, { index: 0.38, rgb: [136, 34, 106] }, { index: 0.5, rgb: [186, 54, 85] }, { index: 0.63, rgb: [227, 89, 51] }, { index: 0.75, rgb: [249, 140, 10] }, { index: 0.88, rgb: [249, 201, 50] }, { index: 1, rgb: [252, 255, 164] }], magma: [{ index: 0, rgb: [0, 0, 4] }, { index: 0.13, rgb: [28, 16, 68] }, { index: 0.25, rgb: [79, 18, 123] }, { index: 0.38, rgb: [129, 37, 129] }, { index: 0.5, rgb: [181, 54, 122] }, { index: 0.63, rgb: [229, 80, 100] }, { index: 0.75, rgb: [251, 135, 97] }, { index: 0.88, rgb: [254, 194, 135] }, { index: 1, rgb: [252, 253, 191] }], plasma: [{ index: 0, rgb: [13, 8, 135] }, { index: 0.13, rgb: [75, 3, 161] }, { index: 0.25, rgb: [125, 3, 168] }, { index: 0.38, rgb: [168, 34, 150] }, { index: 0.5, rgb: [203, 70, 121] }, { index: 0.63, rgb: [229, 107, 93] }, { index: 0.75, rgb: [248, 148, 65] }, { index: 0.88, rgb: [253, 195, 40] }, { index: 1, rgb: [240, 249, 33] }], warm: [{ index: 0, rgb: [125, 0, 179] }, { index: 0.13, rgb: [172, 0, 187] }, { index: 0.25, rgb: [219, 0, 170] }, { index: 0.38, rgb: [255, 0, 130] }, { index: 0.5, rgb: [255, 63, 74] }, { index: 0.63, rgb: [255, 123, 0] }, { index: 0.75, rgb: [234, 176, 0] }, { index: 0.88, rgb: [190, 228, 0] }, { index: 1, rgb: [147, 255, 0] }], cool: [{ index: 0, rgb: [125, 0, 179] }, { index: 0.13, rgb: [116, 0, 218] }, { index: 0.25, rgb: [98, 74, 237] }, { index: 0.38, rgb: [68, 146, 231] }, { index: 0.5, rgb: [0, 204, 197] }, { index: 0.63, rgb: [0, 247, 146] }, { index: 0.75, rgb: [0, 255, 88] }, { index: 0.88, rgb: [40, 255, 8] }, { index: 1, rgb: [147, 255, 0] }], "rainbow-soft": [{ index: 0, rgb: [125, 0, 179] }, { index: 0.1, rgb: [199, 0, 180] }, { index: 0.2, rgb: [255, 0, 121] }, { index: 0.3, rgb: [255, 108, 0] }, { index: 0.4, rgb: [222, 194, 0] }, { index: 0.5, rgb: [150, 255, 0] }, { index: 0.6, rgb: [0, 255, 55] }, { index: 0.7, rgb: [0, 246, 150] }, { index: 0.8, rgb: [50, 167, 222] }, { index: 0.9, rgb: [103, 51, 235] }, { index: 1, rgb: [124, 0, 186] }], bathymetry: [{ index: 0, rgb: [40, 26, 44] }, { index: 0.13, rgb: [59, 49, 90] }, { index: 0.25, rgb: [64, 76, 139] }, { index: 0.38, rgb: [63, 110, 151] }, { index: 0.5, rgb: [72, 142, 158] }, { index: 0.63, rgb: [85, 174, 163] }, { index: 0.75, rgb: [120, 206, 163] }, { index: 0.88, rgb: [187, 230, 172] }, { index: 1, rgb: [253, 254, 204] }], cdom: [{ index: 0, rgb: [47, 15, 62] }, { index: 0.13, rgb: [87, 23, 86] }, { index: 0.25, rgb: [130, 28, 99] }, { index: 0.38, rgb: [171, 41, 96] }, { index: 0.5, rgb: [206, 67, 86] }, { index: 0.63, rgb: [230, 106, 84] }, { index: 0.75, rgb: [242, 149, 103] }, { index: 0.88, rgb: [249, 193, 135] }, { index: 1, rgb: [254, 237, 176] }], chlorophyll: [{ index: 0, rgb: [18, 36, 20] }, { index: 0.13, rgb: [25, 63, 41] }, { index: 0.25, rgb: [24, 91, 59] }, { index: 0.38, rgb: [13, 119, 72] }, { index: 0.5, rgb: [18, 148, 80] }, { index: 0.63, rgb: [80, 173, 89] }, { index: 0.75, rgb: [132, 196, 122] }, { index: 0.88, rgb: [175, 221, 162] }, { index: 1, rgb: [215, 249, 208] }], density: [{ index: 0, rgb: [54, 14, 36] }, { index: 0.13, rgb: [89, 23, 80] }, { index: 0.25, rgb: [110, 45, 132] }, { index: 0.38, rgb: [120, 77, 178] }, { index: 0.5, rgb: [120, 113, 213] }, { index: 0.63, rgb: [115, 151, 228] }, { index: 0.75, rgb: [134, 185, 227] }, { index: 0.88, rgb: [177, 214, 227] }, { index: 1, rgb: [230, 241, 241] }], "freesurface-blue": [{ index: 0, rgb: [30, 4, 110] }, { index: 0.13, rgb: [47, 14, 176] }, { index: 0.25, rgb: [41, 45, 236] }, { index: 0.38, rgb: [25, 99, 212] }, { index: 0.5, rgb: [68, 131, 200] }, { index: 0.63, rgb: [114, 156, 197] }, { index: 0.75, rgb: [157, 181, 203] }, { index: 0.88, rgb: [200, 208, 216] }, { index: 1, rgb: [241, 237, 236] }], "freesurface-red": [{ index: 0, rgb: [60, 9, 18] }, { index: 0.13, rgb: [100, 17, 27] }, { index: 0.25, rgb: [142, 20, 29] }, { index: 0.38, rgb: [177, 43, 27] }, { index: 0.5, rgb: [192, 87, 63] }, { index: 0.63, rgb: [205, 125, 105] }, { index: 0.75, rgb: [216, 162, 148] }, { index: 0.88, rgb: [227, 199, 193] }, { index: 1, rgb: [241, 237, 236] }], oxygen: [{ index: 0, rgb: [64, 5, 5] }, { index: 0.13, rgb: [106, 6, 15] }, { index: 0.25, rgb: [144, 26, 7] }, { index: 0.38, rgb: [168, 64, 3] }, { index: 0.5, rgb: [188, 100, 4] }, { index: 0.63, rgb: [206, 136, 11] }, { index: 0.75, rgb: [220, 174, 25] }, { index: 0.88, rgb: [231, 215, 44] }, { index: 1, rgb: [248, 254, 105] }], par: [{ index: 0, rgb: [51, 20, 24] }, { index: 0.13, rgb: [90, 32, 35] }, { index: 0.25, rgb: [129, 44, 34] }, { index: 0.38, rgb: [159, 68, 25] }, { index: 0.5, rgb: [182, 99, 19] }, { index: 0.63, rgb: [199, 134, 22] }, { index: 0.75, rgb: [212, 171, 35] }, { index: 0.88, rgb: [221, 210, 54] }, { index: 1, rgb: [225, 253, 75] }], phase: [{ index: 0, rgb: [145, 105, 18] }, { index: 0.13, rgb: [184, 71, 38] }, { index: 0.25, rgb: [186, 58, 115] }, { index: 0.38, rgb: [160, 71, 185] }, { index: 0.5, rgb: [110, 97, 218] }, { index: 0.63, rgb: [50, 123, 164] }, { index: 0.75, rgb: [31, 131, 110] }, { index: 0.88, rgb: [77, 129, 34] }, { index: 1, rgb: [145, 105, 18] }], salinity: [{ index: 0, rgb: [42, 24, 108] }, { index: 0.13, rgb: [33, 50, 162] }, { index: 0.25, rgb: [15, 90, 145] }, { index: 0.38, rgb: [40, 118, 137] }, { index: 0.5, rgb: [59, 146, 135] }, { index: 0.63, rgb: [79, 175, 126] }, { index: 0.75, rgb: [120, 203, 104] }, { index: 0.88, rgb: [193, 221, 100] }, { index: 1, rgb: [253, 239, 154] }], temperature: [{ index: 0, rgb: [4, 35, 51] }, { index: 0.13, rgb: [23, 51, 122] }, { index: 0.25, rgb: [85, 59, 157] }, { index: 0.38, rgb: [129, 79, 143] }, { index: 0.5, rgb: [175, 95, 130] }, { index: 0.63, rgb: [222, 112, 101] }, { index: 0.75, rgb: [249, 146, 66] }, { index: 0.88, rgb: [249, 196, 65] }, { index: 1, rgb: [232, 250, 91] }], turbidity: [{ index: 0, rgb: [34, 31, 27] }, { index: 0.13, rgb: [65, 50, 41] }, { index: 0.25, rgb: [98, 69, 52] }, { index: 0.38, rgb: [131, 89, 57] }, { index: 0.5, rgb: [161, 112, 59] }, { index: 0.63, rgb: [185, 140, 66] }, { index: 0.75, rgb: [202, 174, 88] }, { index: 0.88, rgb: [216, 209, 126] }, { index: 1, rgb: [233, 246, 171] }], "velocity-blue": [{ index: 0, rgb: [17, 32, 64] }, { index: 0.13, rgb: [35, 52, 116] }, { index: 0.25, rgb: [29, 81, 156] }, { index: 0.38, rgb: [31, 113, 162] }, { index: 0.5, rgb: [50, 144, 169] }, { index: 0.63, rgb: [87, 173, 176] }, { index: 0.75, rgb: [149, 196, 189] }, { index: 0.88, rgb: [203, 221, 211] }, { index: 1, rgb: [254, 251, 230] }], "velocity-green": [{ index: 0, rgb: [23, 35, 19] }, { index: 0.13, rgb: [24, 64, 38] }, { index: 0.25, rgb: [11, 95, 45] }, { index: 0.38, rgb: [39, 123, 35] }, { index: 0.5, rgb: [95, 146, 12] }, { index: 0.63, rgb: [152, 165, 18] }, { index: 0.75, rgb: [201, 186, 69] }, { index: 0.88, rgb: [233, 216, 137] }, { index: 1, rgb: [255, 253, 205] }], cubehelix: [{ index: 0, rgb: [0, 0, 0] }, { index: 0.07, rgb: [22, 5, 59] }, { index: 0.13, rgb: [60, 4, 105] }, { index: 0.2, rgb: [109, 1, 135] }, { index: 0.27, rgb: [161, 0, 147] }, { index: 0.33, rgb: [210, 2, 142] }, { index: 0.4, rgb: [251, 11, 123] }, { index: 0.47, rgb: [255, 29, 97] }, { index: 0.53, rgb: [255, 54, 69] }, { index: 0.6, rgb: [255, 85, 46] }, { index: 0.67, rgb: [255, 120, 34] }, { index: 0.73, rgb: [255, 157, 37] }, { index: 0.8, rgb: [241, 191, 57] }, { index: 0.87, rgb: [224, 220, 93] }, { index: 0.93, rgb: [218, 241, 142] }, { index: 1, rgb: [227, 253, 198] }] };\n              }, 3711: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = d3;\n                var s3 = o4(2640), l3 = o4(781), u4 = { "2d": function(v3, _2, b) {\n                  var p3 = v3({ order: _2, scalarArguments: 3, getters: b === "generic" ? [0] : void 0, phase: function(E3, S2, L3, x2) {\n                    return E3 > x2 | 0;\n                  }, vertex: function(E3, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2) {\n                    var Z = (g3 << 0) + (P3 << 1) + (T3 << 2) + (z3 << 3) | 0;\n                    if (!(Z === 0 || Z === 15)) switch (Z) {\n                      case 0:\n                        O3.push([E3 - 0.5, S2 - 0.5]);\n                        break;\n                      case 1:\n                        O3.push([E3 - 0.25 - 0.25 * (x2 + L3 - 2 * G2) / (L3 - x2), S2 - 0.25 - 0.25 * (C3 + L3 - 2 * G2) / (L3 - C3)]);\n                        break;\n                      case 2:\n                        O3.push([E3 - 0.75 - 0.25 * (-x2 - L3 + 2 * G2) / (x2 - L3), S2 - 0.25 - 0.25 * (M4 + x2 - 2 * G2) / (x2 - M4)]);\n                        break;\n                      case 3:\n                        O3.push([E3 - 0.5, S2 - 0.5 - 0.5 * (C3 + L3 + M4 + x2 - 4 * G2) / (L3 - C3 + x2 - M4)]);\n                        break;\n                      case 4:\n                        O3.push([E3 - 0.25 - 0.25 * (M4 + C3 - 2 * G2) / (C3 - M4), S2 - 0.75 - 0.25 * (-C3 - L3 + 2 * G2) / (C3 - L3)]);\n                        break;\n                      case 5:\n                        O3.push([E3 - 0.5 - 0.5 * (x2 + L3 + M4 + C3 - 4 * G2) / (L3 - x2 + C3 - M4), S2 - 0.5]);\n                        break;\n                      case 6:\n                        O3.push([E3 - 0.5 - 0.25 * (-x2 - L3 + M4 + C3) / (x2 - L3 + C3 - M4), S2 - 0.5 - 0.25 * (-C3 - L3 + M4 + x2) / (C3 - L3 + x2 - M4)]);\n                        break;\n                      case 7:\n                        O3.push([E3 - 0.75 - 0.25 * (M4 + C3 - 2 * G2) / (C3 - M4), S2 - 0.75 - 0.25 * (M4 + x2 - 2 * G2) / (x2 - M4)]);\n                        break;\n                      case 8:\n                        O3.push([E3 - 0.75 - 0.25 * (-M4 - C3 + 2 * G2) / (M4 - C3), S2 - 0.75 - 0.25 * (-M4 - x2 + 2 * G2) / (M4 - x2)]);\n                        break;\n                      case 9:\n                        O3.push([E3 - 0.5 - 0.25 * (x2 + L3 + -M4 - C3) / (L3 - x2 + M4 - C3), S2 - 0.5 - 0.25 * (C3 + L3 + -M4 - x2) / (L3 - C3 + M4 - x2)]);\n                        break;\n                      case 10:\n                        O3.push([E3 - 0.5 - 0.5 * (-x2 - L3 + -M4 - C3 + 4 * G2) / (x2 - L3 + M4 - C3), S2 - 0.5]);\n                        break;\n                      case 11:\n                        O3.push([E3 - 0.25 - 0.25 * (-M4 - C3 + 2 * G2) / (M4 - C3), S2 - 0.75 - 0.25 * (C3 + L3 - 2 * G2) / (L3 - C3)]);\n                        break;\n                      case 12:\n                        O3.push([E3 - 0.5, S2 - 0.5 - 0.5 * (-C3 - L3 + -M4 - x2 + 4 * G2) / (C3 - L3 + M4 - x2)]);\n                        break;\n                      case 13:\n                        O3.push([E3 - 0.75 - 0.25 * (x2 + L3 - 2 * G2) / (L3 - x2), S2 - 0.25 - 0.25 * (-M4 - x2 + 2 * G2) / (M4 - x2)]);\n                        break;\n                      case 14:\n                        O3.push([E3 - 0.25 - 0.25 * (-x2 - L3 + 2 * G2) / (x2 - L3), S2 - 0.25 - 0.25 * (-C3 - L3 + 2 * G2) / (C3 - L3)]);\n                        break;\n                      case 15:\n                        O3.push([E3 - 0.5, S2 - 0.5]);\n                        break;\n                    }\n                  }, cell: function(E3, S2, L3, x2, C3, M4, g3, P3, T3) {\n                    C3 ? P3.push([E3, S2]) : P3.push([S2, E3]);\n                  } });\n                  return function(k4, E3) {\n                    var S2 = [], L3 = [];\n                    return p3(k4, S2, L3, E3), { positions: S2, cells: L3 };\n                  };\n                } };\n                function c5(v3, _2) {\n                  var b = v3.length + "d", p3 = u4[b];\n                  if (p3) return p3(s3, v3, _2);\n                }\n                function f4(v3, _2) {\n                  for (var b = l3(v3, _2), p3 = b.length, k4 = new Array(p3), E3 = new Array(p3), S2 = 0; S2 < p3; ++S2) k4[S2] = [b[S2]], E3[S2] = [S2];\n                  return { positions: k4, cells: E3 };\n                }\n                var h3 = {};\n                function d3(v3, k4) {\n                  if (v3.dimension <= 0) return { positions: [], cells: [] };\n                  if (v3.dimension === 1) return f4(v3, k4);\n                  var b = v3.order.join() + "-" + v3.dtype, p3 = h3[b], k4 = +k4 || 0;\n                  return p3 || (p3 = h3[b] = c5(v3.order, v3.dtype)), p3(v3, k4);\n                }\n              }, 3750: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] * s3[0] + o4[1] * s3[1] + o4[2] * s3[2] + o4[3] * s3[3];\n                }\n              }, 3778: function(i3, a4) {\n                a4.read = function(o4, s3, l3, u4, c5) {\n                  var f4, h3, d3 = c5 * 8 - u4 - 1, v3 = (1 << d3) - 1, _2 = v3 >> 1, b = -7, p3 = l3 ? c5 - 1 : 0, k4 = l3 ? -1 : 1, E3 = o4[s3 + p3];\n                  for (p3 += k4, f4 = E3 & (1 << -b) - 1, E3 >>= -b, b += d3; b > 0; f4 = f4 * 256 + o4[s3 + p3], p3 += k4, b -= 8) ;\n                  for (h3 = f4 & (1 << -b) - 1, f4 >>= -b, b += u4; b > 0; h3 = h3 * 256 + o4[s3 + p3], p3 += k4, b -= 8) ;\n                  if (f4 === 0) f4 = 1 - _2;\n                  else {\n                    if (f4 === v3) return h3 ? NaN : (E3 ? -1 : 1) * (1 / 0);\n                    h3 = h3 + Math.pow(2, u4), f4 = f4 - _2;\n                  }\n                  return (E3 ? -1 : 1) * h3 * Math.pow(2, f4 - u4);\n                }, a4.write = function(o4, s3, l3, u4, c5, f4) {\n                  var h3, d3, v3, _2 = f4 * 8 - c5 - 1, b = (1 << _2) - 1, p3 = b >> 1, k4 = c5 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, E3 = u4 ? 0 : f4 - 1, S2 = u4 ? 1 : -1, L3 = s3 < 0 || s3 === 0 && 1 / s3 < 0 ? 1 : 0;\n                  for (s3 = Math.abs(s3), isNaN(s3) || s3 === 1 / 0 ? (d3 = isNaN(s3) ? 1 : 0, h3 = b) : (h3 = Math.floor(Math.log(s3) / Math.LN2), s3 * (v3 = Math.pow(2, -h3)) < 1 && (h3--, v3 *= 2), h3 + p3 >= 1 ? s3 += k4 / v3 : s3 += k4 * Math.pow(2, 1 - p3), s3 * v3 >= 2 && (h3++, v3 /= 2), h3 + p3 >= b ? (d3 = 0, h3 = b) : h3 + p3 >= 1 ? (d3 = (s3 * v3 - 1) * Math.pow(2, c5), h3 = h3 + p3) : (d3 = s3 * Math.pow(2, p3 - 1) * Math.pow(2, c5), h3 = 0)); c5 >= 8; o4[l3 + E3] = d3 & 255, E3 += S2, d3 /= 256, c5 -= 8) ;\n                  for (h3 = h3 << c5 | d3, _2 += c5; _2 > 0; o4[l3 + E3] = h3 & 255, E3 += S2, h3 /= 256, _2 -= 8) ;\n                  o4[l3 + E3 - S2] |= L3 * 128;\n                };\n              }, 3788: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8507), l3 = o4(2419);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  return s3(c5, f4) || l3(c5) - l3(f4);\n                }\n              }, 3837: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = O3;\n                var s3 = o4(4935), l3 = o4(501), u4 = o4(5304), c5 = o4(6429), f4 = o4(6444), h3 = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), d3 = ArrayBuffer, v3 = DataView;\n                function _2(V2) {\n                  return d3.isView(V2) && !(V2 instanceof v3);\n                }\n                function b(V2) {\n                  return Array.isArray(V2) || _2(V2);\n                }\n                function p3(V2, G2) {\n                  return V2[0] = G2[0], V2[1] = G2[1], V2[2] = G2[2], V2;\n                }\n                function k4(V2) {\n                  this.gl = V2, this.pixelRatio = 1, this.bounds = [[-10, -10, -10], [10, 10, 10]], this.ticks = [[], [], []], this.autoTicks = true, this.tickSpacing = [1, 1, 1], this.tickEnable = [true, true, true], this.tickFont = ["sans-serif", "sans-serif", "sans-serif"], this.tickFontStyle = ["normal", "normal", "normal"], this.tickFontWeight = ["normal", "normal", "normal"], this.tickFontVariant = ["normal", "normal", "normal"], this.tickSize = [12, 12, 12], this.tickAngle = [0, 0, 0], this.tickAlign = ["auto", "auto", "auto"], this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.tickPad = [10, 10, 10], this.lastCubeProps = { cubeEdges: [0, 0, 0], axis: [0, 0, 0] }, this.labels = ["x", "y", "z"], this.labelEnable = [true, true, true], this.labelFont = ["sans-serif", "sans-serif", "sans-serif"], this.labelFontStyle = ["normal", "normal", "normal"], this.labelFontWeight = ["normal", "normal", "normal"], this.labelFontVariant = ["normal", "normal", "normal"], this.labelSize = [20, 20, 20], this.labelAngle = [0, 0, 0], this.labelAlign = ["auto", "auto", "auto"], this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.labelPad = [10, 10, 10], this.lineEnable = [true, true, true], this.lineMirror = [false, false, false], this.lineWidth = [1, 1, 1], this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.lineTickEnable = [true, true, true], this.lineTickMirror = [false, false, false], this.lineTickLength = [0, 0, 0], this.lineTickWidth = [1, 1, 1], this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.gridEnable = [true, true, true], this.gridWidth = [1, 1, 1], this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroEnable = [true, true, true], this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroLineWidth = [2, 2, 2], this.backgroundEnable = [false, false, false], this.backgroundColor = [[0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5]], this._firstInit = true, this._text = null, this._lines = null, this._background = u4(V2);\n                }\n                var E3 = k4.prototype;\n                E3.update = function(V2) {\n                  V2 = V2 || {};\n                  function G2(Ae, Fe, Pe) {\n                    if (Pe in V2) {\n                      var ge = V2[Pe], Re = this[Pe], ce;\n                      (Ae ? b(ge) && b(ge[0]) : b(ge)) ? this[Pe] = ce = [Fe(ge[0]), Fe(ge[1]), Fe(ge[2])] : this[Pe] = ce = [Fe(ge), Fe(ge), Fe(ge)];\n                      for (var Ze = 0; Ze < 3; ++Ze) if (ce[Ze] !== Re[Ze]) return true;\n                    }\n                    return false;\n                  }\n                  var Z = G2.bind(this, false, Number), j3 = G2.bind(this, false, Boolean), N2 = G2.bind(this, false, String), H = G2.bind(this, true, function(Ae) {\n                    if (b(Ae)) {\n                      if (Ae.length === 3) return [+Ae[0], +Ae[1], +Ae[2], 1];\n                      if (Ae.length === 4) return [+Ae[0], +Ae[1], +Ae[2], +Ae[3]];\n                    }\n                    return [0, 0, 0, 1];\n                  }), te, oe = false, _e = false;\n                  if ("bounds" in V2) for (var Ee = V2.bounds, Ce = 0; Ce < 2; ++Ce) for (var me = 0; me < 3; ++me) Ee[Ce][me] !== this.bounds[Ce][me] && (_e = true), this.bounds[Ce][me] = Ee[Ce][me];\n                  if ("ticks" in V2) {\n                    te = V2.ticks, oe = true, this.autoTicks = false;\n                    for (var Ce = 0; Ce < 3; ++Ce) this.tickSpacing[Ce] = 0;\n                  } else Z("tickSpacing") && (this.autoTicks = true, _e = true);\n                  if (this._firstInit && ("ticks" in V2 || "tickSpacing" in V2 || (this.autoTicks = true), _e = true, oe = true, this._firstInit = false), _e && this.autoTicks && (te = f4.create(this.bounds, this.tickSpacing), oe = true), oe) {\n                    for (var Ce = 0; Ce < 3; ++Ce) te[Ce].sort(function(Fe, Pe) {\n                      return Fe.x - Pe.x;\n                    });\n                    f4.equal(te, this.ticks) ? oe = false : this.ticks = te;\n                  }\n                  j3("tickEnable"), N2("tickFont") && (oe = true), N2("tickFontStyle") && (oe = true), N2("tickFontWeight") && (oe = true), N2("tickFontVariant") && (oe = true), Z("tickSize"), Z("tickAngle"), Z("tickPad"), H("tickColor");\n                  var ie = N2("labels");\n                  N2("labelFont") && (ie = true), N2("labelFontStyle") && (ie = true), N2("labelFontWeight") && (ie = true), N2("labelFontVariant") && (ie = true), j3("labelEnable"), Z("labelSize"), Z("labelPad"), H("labelColor"), j3("lineEnable"), j3("lineMirror"), Z("lineWidth"), H("lineColor"), j3("lineTickEnable"), j3("lineTickMirror"), Z("lineTickLength"), Z("lineTickWidth"), H("lineTickColor"), j3("gridEnable"), Z("gridWidth"), H("gridColor"), j3("zeroEnable"), H("zeroLineColor"), Z("zeroLineWidth"), j3("backgroundEnable"), H("backgroundColor");\n                  var Se = [{ family: this.labelFont[0], style: this.labelFontStyle[0], weight: this.labelFontWeight[0], variant: this.labelFontVariant[0] }, { family: this.labelFont[1], style: this.labelFontStyle[1], weight: this.labelFontWeight[1], variant: this.labelFontVariant[1] }, { family: this.labelFont[2], style: this.labelFontStyle[2], weight: this.labelFontWeight[2], variant: this.labelFontVariant[2] }], Le = [{ family: this.tickFont[0], style: this.tickFontStyle[0], weight: this.tickFontWeight[0], variant: this.tickFontVariant[0] }, { family: this.tickFont[1], style: this.tickFontStyle[1], weight: this.tickFontWeight[1], variant: this.tickFontVariant[1] }, { family: this.tickFont[2], style: this.tickFontStyle[2], weight: this.tickFontWeight[2], variant: this.tickFontVariant[2] }];\n                  this._text ? this._text && (ie || oe) && this._text.update(this.bounds, this.labels, Se, this.ticks, Le) : this._text = s3(this.gl, this.bounds, this.labels, Se, this.ticks, Le), this._lines && oe && (this._lines.dispose(), this._lines = null), this._lines || (this._lines = l3(this.gl, this.bounds, this.ticks));\n                };\n                function S2() {\n                  this.primalOffset = [0, 0, 0], this.primalMinor = [0, 0, 0], this.mirrorOffset = [0, 0, 0], this.mirrorMinor = [0, 0, 0];\n                }\n                var L3 = [new S2(), new S2(), new S2()];\n                function x2(V2, G2, Z, j3, N2) {\n                  for (var H = V2.primalOffset, te = V2.primalMinor, oe = V2.mirrorOffset, _e = V2.mirrorMinor, Ee = j3[G2], Ce = 0; Ce < 3; ++Ce) if (G2 !== Ce) {\n                    var me = H, ie = oe, Se = te, Le = _e;\n                    Ee & 1 << Ce && (me = oe, ie = H, Se = _e, Le = te), me[Ce] = Z[0][Ce], ie[Ce] = Z[1][Ce], N2[Ce] > 0 ? (Se[Ce] = -1, Le[Ce] = 0) : (Se[Ce] = 0, Le[Ce] = 1);\n                  }\n                }\n                var C3 = [0, 0, 0], M4 = { model: h3, view: h3, projection: h3, _ortho: false };\n                E3.isOpaque = function() {\n                  return true;\n                }, E3.isTransparent = function() {\n                  return false;\n                }, E3.drawTransparent = function(V2) {\n                };\n                var g3 = 0, P3 = [0, 0, 0], T3 = [0, 0, 0], z3 = [0, 0, 0];\n                E3.draw = function(V2) {\n                  V2 = V2 || M4;\n                  for (var Pe = this.gl, G2 = V2.model || h3, Z = V2.view || h3, j3 = V2.projection || h3, N2 = this.bounds, H = V2._ortho || false, te = c5(G2, Z, j3, N2, H), oe = te.cubeEdges, _e = te.axis, Ee = Z[12], Ce = Z[13], me = Z[14], ie = Z[15], Se = H ? 2 : 1, Le = Se * this.pixelRatio * (j3[3] * Ee + j3[7] * Ce + j3[11] * me + j3[15] * ie) / Pe.drawingBufferHeight, Ae = 0; Ae < 3; ++Ae) this.lastCubeProps.cubeEdges[Ae] = oe[Ae], this.lastCubeProps.axis[Ae] = _e[Ae];\n                  for (var Fe = L3, Ae = 0; Ae < 3; ++Ae) x2(L3[Ae], Ae, this.bounds, oe, _e);\n                  for (var Pe = this.gl, ge = C3, Ae = 0; Ae < 3; ++Ae) this.backgroundEnable[Ae] ? ge[Ae] = _e[Ae] : ge[Ae] = 0;\n                  this._background.draw(G2, Z, j3, N2, ge, this.backgroundColor), this._lines.bind(G2, Z, j3, this);\n                  for (var Ae = 0; Ae < 3; ++Ae) {\n                    var Re = [0, 0, 0];\n                    _e[Ae] > 0 ? Re[Ae] = N2[1][Ae] : Re[Ae] = N2[0][Ae];\n                    for (var ce = 0; ce < 2; ++ce) {\n                      var Ze = (Ae + 1 + ce) % 3, ut = (Ae + 1 + (ce ^ 1)) % 3;\n                      this.gridEnable[Ze] && this._lines.drawGrid(Ze, ut, this.bounds, Re, this.gridColor[Ze], this.gridWidth[Ze] * this.pixelRatio);\n                    }\n                    for (var ce = 0; ce < 2; ++ce) {\n                      var Ze = (Ae + 1 + ce) % 3, ut = (Ae + 1 + (ce ^ 1)) % 3;\n                      this.zeroEnable[ut] && Math.min(N2[0][ut], N2[1][ut]) <= 0 && Math.max(N2[0][ut], N2[1][ut]) >= 0 && this._lines.drawZero(Ze, ut, this.bounds, Re, this.zeroLineColor[ut], this.zeroLineWidth[ut] * this.pixelRatio);\n                    }\n                  }\n                  for (var Ae = 0; Ae < 3; ++Ae) {\n                    this.lineEnable[Ae] && this._lines.drawAxisLine(Ae, this.bounds, Fe[Ae].primalOffset, this.lineColor[Ae], this.lineWidth[Ae] * this.pixelRatio), this.lineMirror[Ae] && this._lines.drawAxisLine(Ae, this.bounds, Fe[Ae].mirrorOffset, this.lineColor[Ae], this.lineWidth[Ae] * this.pixelRatio);\n                    for (var pt = p3(P3, Fe[Ae].primalMinor), Zt = p3(T3, Fe[Ae].mirrorMinor), st = this.lineTickLength, ce = 0; ce < 3; ++ce) {\n                      var lt = Le / G2[5 * ce];\n                      pt[ce] *= st[ce] * lt, Zt[ce] *= st[ce] * lt;\n                    }\n                    this.lineTickEnable[Ae] && this._lines.drawAxisTicks(Ae, Fe[Ae].primalOffset, pt, this.lineTickColor[Ae], this.lineTickWidth[Ae] * this.pixelRatio), this.lineTickMirror[Ae] && this._lines.drawAxisTicks(Ae, Fe[Ae].mirrorOffset, Zt, this.lineTickColor[Ae], this.lineTickWidth[Ae] * this.pixelRatio);\n                  }\n                  this._lines.unbind(), this._text.bind(G2, Z, j3, this.pixelRatio);\n                  var Gt, Nt = 0.5, Jt, sr;\n                  function wr(_t) {\n                    sr = [0, 0, 0], sr[_t] = 1;\n                  }\n                  function cr(_t, It, mt) {\n                    var er = (_t + 1) % 3, lr = (_t + 2) % 3, Tr = It[er], Lr = It[lr], ti = mt[er], Br = mt[lr];\n                    if (Tr > 0 && Br > 0) {\n                      wr(er);\n                      return;\n                    } else if (Tr > 0 && Br < 0) {\n                      wr(er);\n                      return;\n                    } else if (Tr < 0 && Br > 0) {\n                      wr(er);\n                      return;\n                    } else if (Tr < 0 && Br < 0) {\n                      wr(er);\n                      return;\n                    } else if (Lr > 0 && ti > 0) {\n                      wr(lr);\n                      return;\n                    } else if (Lr > 0 && ti < 0) {\n                      wr(lr);\n                      return;\n                    } else if (Lr < 0 && ti > 0) {\n                      wr(lr);\n                      return;\n                    } else if (Lr < 0 && ti < 0) {\n                      wr(lr);\n                      return;\n                    }\n                  }\n                  for (var Ae = 0; Ae < 3; ++Ae) {\n                    for (var $e = Fe[Ae].primalMinor, St = Fe[Ae].mirrorMinor, Qt = p3(z3, Fe[Ae].primalOffset), ce = 0; ce < 3; ++ce) this.lineTickEnable[Ae] && (Qt[ce] += Le * $e[ce] * Math.max(this.lineTickLength[ce], 0) / G2[5 * ce]);\n                    var Vt = [0, 0, 0];\n                    if (Vt[Ae] = 1, this.tickEnable[Ae]) {\n                      this.tickAngle[Ae] === -3600 ? (this.tickAngle[Ae] = 0, this.tickAlign[Ae] = "auto") : this.tickAlign[Ae] = -1, Jt = 1, Gt = [this.tickAlign[Ae], Nt, Jt], Gt[0] === "auto" ? Gt[0] = g3 : Gt[0] = parseInt("" + Gt[0]), sr = [0, 0, 0], cr(Ae, $e, St);\n                      for (var ce = 0; ce < 3; ++ce) Qt[ce] += Le * $e[ce] * this.tickPad[ce] / G2[5 * ce];\n                      this._text.drawTicks(Ae, this.tickSize[Ae], this.tickAngle[Ae], Qt, this.tickColor[Ae], Vt, sr, Gt);\n                    }\n                    if (this.labelEnable[Ae]) {\n                      Jt = 0, sr = [0, 0, 0], this.labels[Ae].length > 4 && (wr(Ae), Jt = 1), Gt = [this.labelAlign[Ae], Nt, Jt], Gt[0] === "auto" ? Gt[0] = g3 : Gt[0] = parseInt("" + Gt[0]);\n                      for (var ce = 0; ce < 3; ++ce) Qt[ce] += Le * $e[ce] * this.labelPad[ce] / G2[5 * ce];\n                      Qt[Ae] += 0.5 * (N2[0][Ae] + N2[1][Ae]), this._text.drawLabel(Ae, this.labelSize[Ae], this.labelAngle[Ae], Qt, this.labelColor[Ae], [0, 0, 0], sr, Gt);\n                    }\n                  }\n                  this._text.unbind();\n                }, E3.dispose = function() {\n                  this._text.dispose(), this._lines.dispose(), this._background.dispose(), this._lines = null, this._text = null, this._background = null, this.gl = null;\n                };\n                function O3(V2, G2) {\n                  var Z = new k4(V2);\n                  return Z.update(G2), Z;\n                }\n              }, 3840: function(i3) {\n                "use strict";\n                i3.exports = L3;\n                var a4 = 0, o4 = 1;\n                function s3(x2, C3, M4, g3, P3, T3) {\n                  this._color = x2, this.key = C3, this.value = M4, this.left = g3, this.right = P3, this._count = T3;\n                }\n                function l3(x2) {\n                  return new s3(x2._color, x2.key, x2.value, x2.left, x2.right, x2._count);\n                }\n                function u4(x2, C3) {\n                  return new s3(x2, C3.key, C3.value, C3.left, C3.right, C3._count);\n                }\n                function c5(x2) {\n                  x2._count = 1 + (x2.left ? x2.left._count : 0) + (x2.right ? x2.right._count : 0);\n                }\n                function f4(x2, C3) {\n                  this._compare = x2, this.root = C3;\n                }\n                var h3 = f4.prototype;\n                Object.defineProperty(h3, "keys", { get: function() {\n                  var x2 = [];\n                  return this.forEach(function(C3, M4) {\n                    x2.push(C3);\n                  }), x2;\n                } }), Object.defineProperty(h3, "values", { get: function() {\n                  var x2 = [];\n                  return this.forEach(function(C3, M4) {\n                    x2.push(M4);\n                  }), x2;\n                } }), Object.defineProperty(h3, "length", { get: function() {\n                  return this.root ? this.root._count : 0;\n                } }), h3.insert = function(x2, C3) {\n                  for (var M4 = this._compare, g3 = this.root, P3 = [], T3 = []; g3; ) {\n                    var z3 = M4(x2, g3.key);\n                    P3.push(g3), T3.push(z3), z3 <= 0 ? g3 = g3.left : g3 = g3.right;\n                  }\n                  P3.push(new s3(a4, x2, C3, null, null, 1));\n                  for (var O3 = P3.length - 2; O3 >= 0; --O3) {\n                    var g3 = P3[O3];\n                    T3[O3] <= 0 ? P3[O3] = new s3(g3._color, g3.key, g3.value, P3[O3 + 1], g3.right, g3._count + 1) : P3[O3] = new s3(g3._color, g3.key, g3.value, g3.left, P3[O3 + 1], g3._count + 1);\n                  }\n                  for (var O3 = P3.length - 1; O3 > 1; --O3) {\n                    var V2 = P3[O3 - 1], g3 = P3[O3];\n                    if (V2._color === o4 || g3._color === o4) break;\n                    var G2 = P3[O3 - 2];\n                    if (G2.left === V2) if (V2.left === g3) {\n                      var Z = G2.right;\n                      if (Z && Z._color === a4) V2._color = o4, G2.right = u4(o4, Z), G2._color = a4, O3 -= 1;\n                      else {\n                        if (G2._color = a4, G2.left = V2.right, V2._color = o4, V2.right = G2, P3[O3 - 2] = V2, P3[O3 - 1] = g3, c5(G2), c5(V2), O3 >= 3) {\n                          var j3 = P3[O3 - 3];\n                          j3.left === G2 ? j3.left = V2 : j3.right = V2;\n                        }\n                        break;\n                      }\n                    } else {\n                      var Z = G2.right;\n                      if (Z && Z._color === a4) V2._color = o4, G2.right = u4(o4, Z), G2._color = a4, O3 -= 1;\n                      else {\n                        if (V2.right = g3.left, G2._color = a4, G2.left = g3.right, g3._color = o4, g3.left = V2, g3.right = G2, P3[O3 - 2] = g3, P3[O3 - 1] = V2, c5(G2), c5(V2), c5(g3), O3 >= 3) {\n                          var j3 = P3[O3 - 3];\n                          j3.left === G2 ? j3.left = g3 : j3.right = g3;\n                        }\n                        break;\n                      }\n                    }\n                    else if (V2.right === g3) {\n                      var Z = G2.left;\n                      if (Z && Z._color === a4) V2._color = o4, G2.left = u4(o4, Z), G2._color = a4, O3 -= 1;\n                      else {\n                        if (G2._color = a4, G2.right = V2.left, V2._color = o4, V2.left = G2, P3[O3 - 2] = V2, P3[O3 - 1] = g3, c5(G2), c5(V2), O3 >= 3) {\n                          var j3 = P3[O3 - 3];\n                          j3.right === G2 ? j3.right = V2 : j3.left = V2;\n                        }\n                        break;\n                      }\n                    } else {\n                      var Z = G2.left;\n                      if (Z && Z._color === a4) V2._color = o4, G2.left = u4(o4, Z), G2._color = a4, O3 -= 1;\n                      else {\n                        if (V2.left = g3.right, G2._color = a4, G2.right = g3.left, g3._color = o4, g3.right = V2, g3.left = G2, P3[O3 - 2] = g3, P3[O3 - 1] = V2, c5(G2), c5(V2), c5(g3), O3 >= 3) {\n                          var j3 = P3[O3 - 3];\n                          j3.right === G2 ? j3.right = g3 : j3.left = g3;\n                        }\n                        break;\n                      }\n                    }\n                  }\n                  return P3[0]._color = o4, new f4(M4, P3[0]);\n                };\n                function d3(x2, C3) {\n                  if (C3.left) {\n                    var M4 = d3(x2, C3.left);\n                    if (M4) return M4;\n                  }\n                  var M4 = x2(C3.key, C3.value);\n                  if (M4) return M4;\n                  if (C3.right) return d3(x2, C3.right);\n                }\n                function v3(x2, C3, M4, g3) {\n                  var P3 = C3(x2, g3.key);\n                  if (P3 <= 0) {\n                    if (g3.left) {\n                      var T3 = v3(x2, C3, M4, g3.left);\n                      if (T3) return T3;\n                    }\n                    var T3 = M4(g3.key, g3.value);\n                    if (T3) return T3;\n                  }\n                  if (g3.right) return v3(x2, C3, M4, g3.right);\n                }\n                function _2(x2, C3, M4, g3, P3) {\n                  var T3 = M4(x2, P3.key), z3 = M4(C3, P3.key), O3;\n                  if (T3 <= 0 && (P3.left && (O3 = _2(x2, C3, M4, g3, P3.left), O3) || z3 > 0 && (O3 = g3(P3.key, P3.value), O3))) return O3;\n                  if (z3 > 0 && P3.right) return _2(x2, C3, M4, g3, P3.right);\n                }\n                h3.forEach = function(C3, M4, g3) {\n                  if (this.root) switch (arguments.length) {\n                    case 1:\n                      return d3(C3, this.root);\n                    case 2:\n                      return v3(M4, this._compare, C3, this.root);\n                    case 3:\n                      return this._compare(M4, g3) >= 0 ? void 0 : _2(M4, g3, this._compare, C3, this.root);\n                  }\n                }, Object.defineProperty(h3, "begin", { get: function() {\n                  for (var x2 = [], C3 = this.root; C3; ) x2.push(C3), C3 = C3.left;\n                  return new b(this, x2);\n                } }), Object.defineProperty(h3, "end", { get: function() {\n                  for (var x2 = [], C3 = this.root; C3; ) x2.push(C3), C3 = C3.right;\n                  return new b(this, x2);\n                } }), h3.at = function(x2) {\n                  if (x2 < 0) return new b(this, []);\n                  for (var C3 = this.root, M4 = []; ; ) {\n                    if (M4.push(C3), C3.left) {\n                      if (x2 < C3.left._count) {\n                        C3 = C3.left;\n                        continue;\n                      }\n                      x2 -= C3.left._count;\n                    }\n                    if (!x2) return new b(this, M4);\n                    if (x2 -= 1, C3.right) {\n                      if (x2 >= C3.right._count) break;\n                      C3 = C3.right;\n                    } else break;\n                  }\n                  return new b(this, []);\n                }, h3.ge = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root, g3 = [], P3 = 0; M4; ) {\n                    var T3 = C3(x2, M4.key);\n                    g3.push(M4), T3 <= 0 && (P3 = g3.length), T3 <= 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                  return g3.length = P3, new b(this, g3);\n                }, h3.gt = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root, g3 = [], P3 = 0; M4; ) {\n                    var T3 = C3(x2, M4.key);\n                    g3.push(M4), T3 < 0 && (P3 = g3.length), T3 < 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                  return g3.length = P3, new b(this, g3);\n                }, h3.lt = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root, g3 = [], P3 = 0; M4; ) {\n                    var T3 = C3(x2, M4.key);\n                    g3.push(M4), T3 > 0 && (P3 = g3.length), T3 <= 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                  return g3.length = P3, new b(this, g3);\n                }, h3.le = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root, g3 = [], P3 = 0; M4; ) {\n                    var T3 = C3(x2, M4.key);\n                    g3.push(M4), T3 >= 0 && (P3 = g3.length), T3 < 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                  return g3.length = P3, new b(this, g3);\n                }, h3.find = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root, g3 = []; M4; ) {\n                    var P3 = C3(x2, M4.key);\n                    if (g3.push(M4), P3 === 0) return new b(this, g3);\n                    P3 <= 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                  return new b(this, []);\n                }, h3.remove = function(x2) {\n                  var C3 = this.find(x2);\n                  return C3 ? C3.remove() : this;\n                }, h3.get = function(x2) {\n                  for (var C3 = this._compare, M4 = this.root; M4; ) {\n                    var g3 = C3(x2, M4.key);\n                    if (g3 === 0) return M4.value;\n                    g3 <= 0 ? M4 = M4.left : M4 = M4.right;\n                  }\n                };\n                function b(x2, C3) {\n                  this.tree = x2, this._stack = C3;\n                }\n                var p3 = b.prototype;\n                Object.defineProperty(p3, "valid", { get: function() {\n                  return this._stack.length > 0;\n                } }), Object.defineProperty(p3, "node", { get: function() {\n                  return this._stack.length > 0 ? this._stack[this._stack.length - 1] : null;\n                }, enumerable: true }), p3.clone = function() {\n                  return new b(this.tree, this._stack.slice());\n                };\n                function k4(x2, C3) {\n                  x2.key = C3.key, x2.value = C3.value, x2.left = C3.left, x2.right = C3.right, x2._color = C3._color, x2._count = C3._count;\n                }\n                function E3(x2) {\n                  for (var C3, M4, g3, P3, T3 = x2.length - 1; T3 >= 0; --T3) {\n                    if (C3 = x2[T3], T3 === 0) {\n                      C3._color = o4;\n                      return;\n                    }\n                    if (M4 = x2[T3 - 1], M4.left === C3) {\n                      if (g3 = M4.right, g3.right && g3.right._color === a4) {\n                        if (g3 = M4.right = l3(g3), P3 = g3.right = l3(g3.right), M4.right = g3.left, g3.left = M4, g3.right = P3, g3._color = M4._color, C3._color = o4, M4._color = o4, P3._color = o4, c5(M4), c5(g3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.left === M4 ? z3.left = g3 : z3.right = g3;\n                        }\n                        x2[T3 - 1] = g3;\n                        return;\n                      } else if (g3.left && g3.left._color === a4) {\n                        if (g3 = M4.right = l3(g3), P3 = g3.left = l3(g3.left), M4.right = P3.left, g3.left = P3.right, P3.left = M4, P3.right = g3, P3._color = M4._color, M4._color = o4, g3._color = o4, C3._color = o4, c5(M4), c5(g3), c5(P3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.left === M4 ? z3.left = P3 : z3.right = P3;\n                        }\n                        x2[T3 - 1] = P3;\n                        return;\n                      }\n                      if (g3._color === o4) if (M4._color === a4) {\n                        M4._color = o4, M4.right = u4(a4, g3);\n                        return;\n                      } else {\n                        M4.right = u4(a4, g3);\n                        continue;\n                      }\n                      else {\n                        if (g3 = l3(g3), M4.right = g3.left, g3.left = M4, g3._color = M4._color, M4._color = a4, c5(M4), c5(g3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.left === M4 ? z3.left = g3 : z3.right = g3;\n                        }\n                        x2[T3 - 1] = g3, x2[T3] = M4, T3 + 1 < x2.length ? x2[T3 + 1] = C3 : x2.push(C3), T3 = T3 + 2;\n                      }\n                    } else {\n                      if (g3 = M4.left, g3.left && g3.left._color === a4) {\n                        if (g3 = M4.left = l3(g3), P3 = g3.left = l3(g3.left), M4.left = g3.right, g3.right = M4, g3.left = P3, g3._color = M4._color, C3._color = o4, M4._color = o4, P3._color = o4, c5(M4), c5(g3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.right === M4 ? z3.right = g3 : z3.left = g3;\n                        }\n                        x2[T3 - 1] = g3;\n                        return;\n                      } else if (g3.right && g3.right._color === a4) {\n                        if (g3 = M4.left = l3(g3), P3 = g3.right = l3(g3.right), M4.left = P3.right, g3.right = P3.left, P3.right = M4, P3.left = g3, P3._color = M4._color, M4._color = o4, g3._color = o4, C3._color = o4, c5(M4), c5(g3), c5(P3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.right === M4 ? z3.right = P3 : z3.left = P3;\n                        }\n                        x2[T3 - 1] = P3;\n                        return;\n                      }\n                      if (g3._color === o4) if (M4._color === a4) {\n                        M4._color = o4, M4.left = u4(a4, g3);\n                        return;\n                      } else {\n                        M4.left = u4(a4, g3);\n                        continue;\n                      }\n                      else {\n                        if (g3 = l3(g3), M4.left = g3.right, g3.right = M4, g3._color = M4._color, M4._color = a4, c5(M4), c5(g3), T3 > 1) {\n                          var z3 = x2[T3 - 2];\n                          z3.right === M4 ? z3.right = g3 : z3.left = g3;\n                        }\n                        x2[T3 - 1] = g3, x2[T3] = M4, T3 + 1 < x2.length ? x2[T3 + 1] = C3 : x2.push(C3), T3 = T3 + 2;\n                      }\n                    }\n                  }\n                }\n                p3.remove = function() {\n                  var x2 = this._stack;\n                  if (x2.length === 0) return this.tree;\n                  var C3 = new Array(x2.length), M4 = x2[x2.length - 1];\n                  C3[C3.length - 1] = new s3(M4._color, M4.key, M4.value, M4.left, M4.right, M4._count);\n                  for (var g3 = x2.length - 2; g3 >= 0; --g3) {\n                    var M4 = x2[g3];\n                    M4.left === x2[g3 + 1] ? C3[g3] = new s3(M4._color, M4.key, M4.value, C3[g3 + 1], M4.right, M4._count) : C3[g3] = new s3(M4._color, M4.key, M4.value, M4.left, C3[g3 + 1], M4._count);\n                  }\n                  if (M4 = C3[C3.length - 1], M4.left && M4.right) {\n                    var P3 = C3.length;\n                    for (M4 = M4.left; M4.right; ) C3.push(M4), M4 = M4.right;\n                    var T3 = C3[P3 - 1];\n                    C3.push(new s3(M4._color, T3.key, T3.value, M4.left, M4.right, M4._count)), C3[P3 - 1].key = M4.key, C3[P3 - 1].value = M4.value;\n                    for (var g3 = C3.length - 2; g3 >= P3; --g3) M4 = C3[g3], C3[g3] = new s3(M4._color, M4.key, M4.value, M4.left, C3[g3 + 1], M4._count);\n                    C3[P3 - 1].left = C3[P3];\n                  }\n                  if (M4 = C3[C3.length - 1], M4._color === a4) {\n                    var z3 = C3[C3.length - 2];\n                    z3.left === M4 ? z3.left = null : z3.right === M4 && (z3.right = null), C3.pop();\n                    for (var g3 = 0; g3 < C3.length; ++g3) C3[g3]._count--;\n                    return new f4(this.tree._compare, C3[0]);\n                  } else if (M4.left || M4.right) {\n                    M4.left ? k4(M4, M4.left) : M4.right && k4(M4, M4.right), M4._color = o4;\n                    for (var g3 = 0; g3 < C3.length - 1; ++g3) C3[g3]._count--;\n                    return new f4(this.tree._compare, C3[0]);\n                  } else {\n                    if (C3.length === 1) return new f4(this.tree._compare, null);\n                    for (var g3 = 0; g3 < C3.length; ++g3) C3[g3]._count--;\n                    var O3 = C3[C3.length - 2];\n                    E3(C3), O3.left === M4 ? O3.left = null : O3.right = null;\n                  }\n                  return new f4(this.tree._compare, C3[0]);\n                }, Object.defineProperty(p3, "key", { get: function() {\n                  if (this._stack.length > 0) return this._stack[this._stack.length - 1].key;\n                }, enumerable: true }), Object.defineProperty(p3, "value", { get: function() {\n                  if (this._stack.length > 0) return this._stack[this._stack.length - 1].value;\n                }, enumerable: true }), Object.defineProperty(p3, "index", { get: function() {\n                  var x2 = 0, C3 = this._stack;\n                  if (C3.length === 0) {\n                    var M4 = this.tree.root;\n                    return M4 ? M4._count : 0;\n                  } else C3[C3.length - 1].left && (x2 = C3[C3.length - 1].left._count);\n                  for (var g3 = C3.length - 2; g3 >= 0; --g3) C3[g3 + 1] === C3[g3].right && (++x2, C3[g3].left && (x2 += C3[g3].left._count));\n                  return x2;\n                }, enumerable: true }), p3.next = function() {\n                  var x2 = this._stack;\n                  if (x2.length !== 0) {\n                    var C3 = x2[x2.length - 1];\n                    if (C3.right) for (C3 = C3.right; C3; ) x2.push(C3), C3 = C3.left;\n                    else for (x2.pop(); x2.length > 0 && x2[x2.length - 1].right === C3; ) C3 = x2[x2.length - 1], x2.pop();\n                  }\n                }, Object.defineProperty(p3, "hasNext", { get: function() {\n                  var x2 = this._stack;\n                  if (x2.length === 0) return false;\n                  if (x2[x2.length - 1].right) return true;\n                  for (var C3 = x2.length - 1; C3 > 0; --C3) if (x2[C3 - 1].left === x2[C3]) return true;\n                  return false;\n                } }), p3.update = function(x2) {\n                  var C3 = this._stack;\n                  if (C3.length === 0) throw new Error("Can\'t update empty node!");\n                  var M4 = new Array(C3.length), g3 = C3[C3.length - 1];\n                  M4[M4.length - 1] = new s3(g3._color, g3.key, x2, g3.left, g3.right, g3._count);\n                  for (var P3 = C3.length - 2; P3 >= 0; --P3) g3 = C3[P3], g3.left === C3[P3 + 1] ? M4[P3] = new s3(g3._color, g3.key, g3.value, M4[P3 + 1], g3.right, g3._count) : M4[P3] = new s3(g3._color, g3.key, g3.value, g3.left, M4[P3 + 1], g3._count);\n                  return new f4(this.tree._compare, M4[0]);\n                }, p3.prev = function() {\n                  var x2 = this._stack;\n                  if (x2.length !== 0) {\n                    var C3 = x2[x2.length - 1];\n                    if (C3.left) for (C3 = C3.left; C3; ) x2.push(C3), C3 = C3.right;\n                    else for (x2.pop(); x2.length > 0 && x2[x2.length - 1].left === C3; ) C3 = x2[x2.length - 1], x2.pop();\n                  }\n                }, Object.defineProperty(p3, "hasPrev", { get: function() {\n                  var x2 = this._stack;\n                  if (x2.length === 0) return false;\n                  if (x2[x2.length - 1].left) return true;\n                  for (var C3 = x2.length - 1; C3 > 0; --C3) if (x2[C3 - 1].right === x2[C3]) return true;\n                  return false;\n                } });\n                function S2(x2, C3) {\n                  return x2 < C3 ? -1 : x2 > C3 ? 1 : 0;\n                }\n                function L3(x2) {\n                  return new f4(x2 || S2, null);\n                }\n              }, 3865: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(869);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  return s3(u4[0].mul(c5[1]).add(c5[0].mul(u4[1])), u4[1].mul(c5[1]));\n                }\n              }, 3952: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(3250);\n                function l3(c5, f4) {\n                  for (var h3 = new Array(f4 + 1), d3 = 0; d3 < c5.length; ++d3) h3[d3] = c5[d3];\n                  for (var d3 = 0; d3 <= c5.length; ++d3) {\n                    for (var v3 = c5.length; v3 <= f4; ++v3) {\n                      for (var _2 = new Array(f4), b = 0; b < f4; ++b) _2[b] = Math.pow(v3 + 1 - d3, b);\n                      h3[v3] = _2;\n                    }\n                    var p3 = s3.apply(void 0, h3);\n                    if (p3) return true;\n                  }\n                  return false;\n                }\n                function u4(c5) {\n                  var f4 = c5.length;\n                  if (f4 === 0) return [];\n                  if (f4 === 1) return [0];\n                  for (var h3 = c5[0].length, d3 = [c5[0]], v3 = [0], _2 = 1; _2 < f4; ++_2) {\n                    if (d3.push(c5[_2]), !l3(d3, h3)) {\n                      d3.pop();\n                      continue;\n                    }\n                    if (v3.push(_2), v3.length === h3 + 1) return v3;\n                  }\n                  return v3;\n                }\n              }, 3990: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = s3[0], o4[1] = s3[1], o4[2] = s3[2], o4;\n                }\n              }, 4008: function(i3, a4, o4) {\n                i3.exports = o4(6690);\n              }, 4025: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2361), l3 = o4(8828).countTrailingZeros;\n                i3.exports = u4;\n                function u4(c5) {\n                  var f4 = l3(s3.lo(c5));\n                  if (f4 < 32) return f4;\n                  var h3 = l3(s3.hi(c5));\n                  return h3 > 20 ? 52 : h3 + 32;\n                }\n              }, 4040: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4, c5, f4, h3) {\n                  var d3 = 1 / (s3 - l3), v3 = 1 / (u4 - c5), _2 = 1 / (f4 - h3);\n                  return o4[0] = -2 * d3, o4[1] = 0, o4[2] = 0, o4[3] = 0, o4[4] = 0, o4[5] = -2 * v3, o4[6] = 0, o4[7] = 0, o4[8] = 0, o4[9] = 0, o4[10] = 2 * _2, o4[11] = 0, o4[12] = (s3 + l3) * d3, o4[13] = (c5 + u4) * v3, o4[14] = (h3 + f4) * _2, o4[15] = 1, o4;\n                }\n              }, 4041: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = l3[0], d3 = l3[1], v3 = l3[2], _2 = l3[3], b = _2 * u4 + d3 * f4 - v3 * c5, p3 = _2 * c5 + v3 * u4 - h3 * f4, k4 = _2 * f4 + h3 * c5 - d3 * u4, E3 = -h3 * u4 - d3 * c5 - v3 * f4;\n                  return o4[0] = b * _2 + E3 * -h3 + p3 * -v3 - k4 * -d3, o4[1] = p3 * _2 + E3 * -d3 + k4 * -h3 - b * -v3, o4[2] = k4 * _2 + E3 * -v3 + b * -d3 - p3 * -h3, o4[3] = s3[3], o4;\n                }\n              }, 4081: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4, c5, f4, h3, d3, v3, _2) {\n                  var b = s3 + f4 + _2;\n                  if (p3 > 0) {\n                    var p3 = Math.sqrt(b + 1);\n                    o4[0] = 0.5 * (h3 - v3) / p3, o4[1] = 0.5 * (d3 - u4) / p3, o4[2] = 0.5 * (l3 - f4) / p3, o4[3] = 0.5 * p3;\n                  } else {\n                    var k4 = Math.max(s3, f4, _2), p3 = Math.sqrt(2 * k4 - b + 1);\n                    s3 >= k4 ? (o4[0] = 0.5 * p3, o4[1] = 0.5 * (c5 + l3) / p3, o4[2] = 0.5 * (d3 + u4) / p3, o4[3] = 0.5 * (h3 - v3) / p3) : f4 >= k4 ? (o4[0] = 0.5 * (l3 + c5) / p3, o4[1] = 0.5 * p3, o4[2] = 0.5 * (v3 + h3) / p3, o4[3] = 0.5 * (d3 - u4) / p3) : (o4[0] = 0.5 * (u4 + d3) / p3, o4[1] = 0.5 * (h3 + v3) / p3, o4[2] = 0.5 * p3, o4[3] = 0.5 * (l3 - c5) / p3);\n                  }\n                  return o4;\n                }\n              }, 4100: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(4437), l3 = o4(3837), u4 = o4(5445), c5 = o4(4449), f4 = o4(3589), h3 = o4(2260), d3 = o4(7169), v3 = o4(351), _2 = o4(4772), b = o4(4040), p3 = o4(799), k4 = o4(9216)({ tablet: true, featureDetect: true });\n                i3.exports = { createScene: C3, createCamera: s3 };\n                function E3() {\n                  this.mouse = [-1, -1], this.screen = null, this.distance = 1 / 0, this.index = null, this.dataCoordinate = null, this.dataPosition = null, this.object = null, this.data = null;\n                }\n                function S2(g3, P3) {\n                  var T3 = null;\n                  try {\n                    T3 = g3.getContext("webgl", P3), T3 || (T3 = g3.getContext("experimental-webgl", P3));\n                  } catch (z3) {\n                    return null;\n                  }\n                  return T3;\n                }\n                function L3(g3) {\n                  var P3 = Math.round(Math.log(Math.abs(g3)) / Math.log(10));\n                  if (P3 < 0) {\n                    var T3 = Math.round(Math.pow(10, -P3));\n                    return Math.ceil(g3 * T3) / T3;\n                  } else if (P3 > 0) {\n                    var T3 = Math.round(Math.pow(10, P3));\n                    return Math.ceil(g3 / T3) * T3;\n                  }\n                  return Math.ceil(g3);\n                }\n                function x2(g3) {\n                  return typeof g3 == "boolean" ? g3 : true;\n                }\n                function C3(g3) {\n                  g3 = g3 || {}, g3.camera = g3.camera || {};\n                  var P3 = g3.canvas;\n                  if (!P3) if (P3 = document.createElement("canvas"), g3.container) {\n                    var T3 = g3.container;\n                    T3.appendChild(P3);\n                  } else document.body.appendChild(P3);\n                  var z3 = g3.gl;\n                  if (z3 || (g3.glOptions && (k4 = !!g3.glOptions.preserveDrawingBuffer), z3 = S2(P3, g3.glOptions || { premultipliedAlpha: true, antialias: true, preserveDrawingBuffer: k4 })), !z3) throw new Error("webgl not supported");\n                  var O3 = g3.bounds || [[-10, -10, -10], [10, 10, 10]], V2 = new E3(), G2 = h3(z3, z3.drawingBufferWidth, z3.drawingBufferHeight, { preferFloat: !k4 }), Z = p3(z3), j3 = g3.cameraObject && g3.cameraObject._ortho === true || g3.camera.projection && g3.camera.projection.type === "orthographic" || false, N2 = { eye: g3.camera.eye || [2, 0, 0], center: g3.camera.center || [0, 0, 0], up: g3.camera.up || [0, 1, 0], zoomMin: g3.camera.zoomMax || 0.1, zoomMax: g3.camera.zoomMin || 100, mode: g3.camera.mode || "turntable", _ortho: j3 }, H = g3.axes || {}, te = l3(z3, H);\n                  te.enable = !H.disable;\n                  var oe = g3.spikes || {}, _e = c5(z3, oe), Ee = [], Ce = [], me = [], ie = [], Se = true, Pe = true, Le = new Array(16), Ae = new Array(16), Fe = { view: null, projection: Le, model: Ae, _ortho: false }, Pe = true, ge = [z3.drawingBufferWidth, z3.drawingBufferHeight], Re = g3.cameraObject || s3(P3, N2), ce = { gl: z3, contextLost: false, pixelRatio: g3.pixelRatio || 1, canvas: P3, selection: V2, camera: Re, axes: te, axesPixels: null, spikes: _e, bounds: O3, objects: Ee, shape: ge, aspect: g3.aspectRatio || [1, 1, 1], pickRadius: g3.pickRadius || 10, zNear: g3.zNear || 0.01, zFar: g3.zFar || 1e3, fovy: g3.fovy || Math.PI / 4, clearColor: g3.clearColor || [0, 0, 0, 0], autoResize: x2(g3.autoResize), autoBounds: x2(g3.autoBounds), autoScale: !!g3.autoScale, autoCenter: x2(g3.autoCenter), clipToBounds: x2(g3.clipToBounds), snapToData: !!g3.snapToData, onselect: g3.onselect || null, onrender: g3.onrender || null, onclick: g3.onclick || null, cameraParams: Fe, oncontextloss: null, mouseListener: null, _stopped: false, getAspectratio: function() {\n                    return { x: this.aspect[0], y: this.aspect[1], z: this.aspect[2] };\n                  }, setAspectratio: function(sr) {\n                    this.aspect[0] = sr.x, this.aspect[1] = sr.y, this.aspect[2] = sr.z, Pe = true;\n                  }, setBounds: function(sr, wr) {\n                    this.bounds[0][sr] = wr.min, this.bounds[1][sr] = wr.max;\n                  }, setClearColor: function(sr) {\n                    this.clearColor = sr;\n                  }, clearRGBA: function() {\n                    this.gl.clearColor(this.clearColor[0], this.clearColor[1], this.clearColor[2], this.clearColor[3]), this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);\n                  } }, Ze = [z3.drawingBufferWidth / ce.pixelRatio | 0, z3.drawingBufferHeight / ce.pixelRatio | 0];\n                  function ut() {\n                    if (!ce._stopped && ce.autoResize) {\n                      var sr = P3.parentNode, wr = 1, cr = 1;\n                      sr && sr !== document.body ? (wr = sr.clientWidth, cr = sr.clientHeight) : (wr = window.innerWidth, cr = window.innerHeight);\n                      var $e = Math.ceil(wr * ce.pixelRatio) | 0, St = Math.ceil(cr * ce.pixelRatio) | 0;\n                      if ($e !== P3.width || St !== P3.height) {\n                        P3.width = $e, P3.height = St;\n                        var Qt = P3.style;\n                        Qt.position = Qt.position || "absolute", Qt.left = "0px", Qt.top = "0px", Qt.width = wr + "px", Qt.height = cr + "px", Se = true;\n                      }\n                    }\n                  }\n                  ce.autoResize && ut(), window.addEventListener("resize", ut);\n                  function pt() {\n                    for (var sr = Ee.length, wr = ie.length, cr = 0; cr < wr; ++cr) me[cr] = 0;\n                    e: for (var cr = 0; cr < sr; ++cr) {\n                      var $e = Ee[cr], St = $e.pickSlots;\n                      if (!St) {\n                        Ce[cr] = -1;\n                        continue;\n                      }\n                      for (var Qt = 0; Qt < wr; ++Qt) if (me[Qt] + St < 255) {\n                        Ce[cr] = Qt, $e.setPickBase(me[Qt] + 1), me[Qt] += St;\n                        continue e;\n                      }\n                      var Vt = f4(z3, ge);\n                      Ce[cr] = wr, ie.push(Vt), me.push(St), $e.setPickBase(1), wr += 1;\n                    }\n                    for (; wr > 0 && me[wr - 1] === 0; ) me.pop(), ie.pop().dispose();\n                  }\n                  ce.update = function(sr) {\n                    ce._stopped || (sr = sr || {}, Se = true, Pe = true);\n                  }, ce.add = function(sr) {\n                    ce._stopped || (sr.axes = te, Ee.push(sr), Ce.push(-1), Se = true, Pe = true, pt());\n                  }, ce.remove = function(sr) {\n                    if (!ce._stopped) {\n                      var wr = Ee.indexOf(sr);\n                      wr < 0 || (Ee.splice(wr, 1), Ce.pop(), Se = true, Pe = true, pt());\n                    }\n                  }, ce.dispose = function() {\n                    if (!ce._stopped && (ce._stopped = true, window.removeEventListener("resize", ut), P3.removeEventListener("webglcontextlost", Zt), ce.mouseListener.enabled = false, !ce.contextLost)) {\n                      te.dispose(), _e.dispose();\n                      for (var sr = 0; sr < Ee.length; ++sr) Ee[sr].dispose();\n                      G2.dispose();\n                      for (var sr = 0; sr < ie.length; ++sr) ie[sr].dispose();\n                      Z.dispose(), z3 = null, te = null, _e = null, Ee = [];\n                    }\n                  }, ce._mouseRotating = false, ce._prevButtons = 0, ce.enableMouseListeners = function() {\n                    ce.mouseListener = v3(P3, function(sr, wr, cr) {\n                      if (!ce._stopped) {\n                        var $e = ie.length, St = Ee.length, Qt = V2.object;\n                        V2.distance = 1 / 0, V2.mouse[0] = wr, V2.mouse[1] = cr, V2.object = null, V2.screen = null, V2.dataCoordinate = V2.dataPosition = null;\n                        var Vt = false;\n                        if (sr && ce._prevButtons) ce._mouseRotating = true;\n                        else {\n                          ce._mouseRotating && (Pe = true), ce._mouseRotating = false;\n                          for (var _t = 0; _t < $e; ++_t) {\n                            var It = ie[_t].query(wr, Ze[1] - cr - 1, ce.pickRadius);\n                            if (It) {\n                              if (It.distance > V2.distance) continue;\n                              for (var mt = 0; mt < St; ++mt) {\n                                var er = Ee[mt];\n                                if (Ce[mt] === _t) {\n                                  var lr = er.pick(It);\n                                  lr && (V2.buttons = sr, V2.screen = It.coord, V2.distance = It.distance, V2.object = er, V2.index = lr.distance, V2.dataPosition = lr.position, V2.dataCoordinate = lr.dataCoordinate, V2.data = lr, Vt = true);\n                                }\n                              }\n                            }\n                          }\n                        }\n                        Qt && Qt !== V2.object && (Qt.highlight && Qt.highlight(null), Se = true), V2.object && (V2.object.highlight && V2.object.highlight(V2.data), Se = true), Vt = Vt || V2.object !== Qt, Vt && ce.onselect && ce.onselect(V2), sr & 1 && !(ce._prevButtons & 1) && ce.onclick && ce.onclick(V2), ce._prevButtons = sr;\n                      }\n                    });\n                  };\n                  function Zt() {\n                    if (ce.contextLost) return true;\n                    z3.isContextLost() && (ce.contextLost = true, ce.mouseListener.enabled = false, ce.selection.object = null, ce.oncontextloss && ce.oncontextloss());\n                  }\n                  P3.addEventListener("webglcontextlost", Zt);\n                  function st() {\n                    if (!Zt()) {\n                      z3.colorMask(true, true, true, true), z3.depthMask(true), z3.disable(z3.BLEND), z3.enable(z3.DEPTH_TEST), z3.depthFunc(z3.LEQUAL);\n                      for (var sr = Ee.length, wr = ie.length, cr = 0; cr < wr; ++cr) {\n                        var $e = ie[cr];\n                        $e.shape = Ze, $e.begin();\n                        for (var St = 0; St < sr; ++St) if (Ce[St] === cr) {\n                          var Qt = Ee[St];\n                          Qt.drawPick && (Qt.pixelRatio = 1, Qt.drawPick(Fe));\n                        }\n                        $e.end();\n                      }\n                    }\n                  }\n                  var lt = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], Gt = [lt[0].slice(), lt[1].slice()];\n                  function Nt() {\n                    if (!Zt()) {\n                      ut();\n                      var sr = ce.camera.tick();\n                      Fe.view = ce.camera.matrix, Se = Se || sr, Pe = Pe || sr, te.pixelRatio = ce.pixelRatio, _e.pixelRatio = ce.pixelRatio;\n                      var wr = Ee.length, cr = lt[0], $e = lt[1];\n                      cr[0] = cr[1] = cr[2] = 1 / 0, $e[0] = $e[1] = $e[2] = -1 / 0;\n                      for (var St = 0; St < wr; ++St) {\n                        var Qt = Ee[St];\n                        Qt.pixelRatio = ce.pixelRatio, Qt.axes = ce.axes, Se = Se || !!Qt.dirty, Pe = Pe || !!Qt.dirty;\n                        var Vt = Qt.bounds;\n                        if (Vt) for (var _t = Vt[0], It = Vt[1], mt = 0; mt < 3; ++mt) cr[mt] = Math.min(cr[mt], _t[mt]), $e[mt] = Math.max($e[mt], It[mt]);\n                      }\n                      var er = ce.bounds;\n                      if (ce.autoBounds) for (var mt = 0; mt < 3; ++mt) {\n                        if ($e[mt] < cr[mt]) cr[mt] = -1, $e[mt] = 1;\n                        else {\n                          cr[mt] === $e[mt] && (cr[mt] -= 1, $e[mt] += 1);\n                          var lr = 0.05 * ($e[mt] - cr[mt]);\n                          cr[mt] = cr[mt] - lr, $e[mt] = $e[mt] + lr;\n                        }\n                        er[0][mt] = cr[mt], er[1][mt] = $e[mt];\n                      }\n                      for (var Tr = false, mt = 0; mt < 3; ++mt) Tr = Tr || Gt[0][mt] !== er[0][mt] || Gt[1][mt] !== er[1][mt], Gt[0][mt] = er[0][mt], Gt[1][mt] = er[1][mt];\n                      if (Pe = Pe || Tr, Se = Se || Tr, !!Se) {\n                        if (Tr) {\n                          for (var Lr = [0, 0, 0], St = 0; St < 3; ++St) Lr[St] = L3((er[1][St] - er[0][St]) / 10);\n                          te.autoTicks ? te.update({ bounds: er, tickSpacing: Lr }) : te.update({ bounds: er });\n                        }\n                        var ti = z3.drawingBufferWidth, Br = z3.drawingBufferHeight;\n                        ge[0] = ti, ge[1] = Br, Ze[0] = Math.max(ti / ce.pixelRatio, 1) | 0, Ze[1] = Math.max(Br / ce.pixelRatio, 1) | 0, M4(ce, j3);\n                        for (var St = 0; St < wr; ++St) {\n                          var Qt = Ee[St];\n                          Qt.axesBounds = er, ce.clipToBounds && (Qt.clipBounds = er);\n                        }\n                        V2.object && (ce.snapToData ? _e.position = V2.dataCoordinate : _e.position = V2.dataPosition, _e.bounds = er), Pe && (Pe = false, st()), ce.axesPixels = u4(ce.axes, Fe, ti, Br), ce.onrender && ce.onrender(), z3.bindFramebuffer(z3.FRAMEBUFFER, null), z3.viewport(0, 0, ti, Br), ce.clearRGBA(), z3.depthMask(true), z3.colorMask(true, true, true, true), z3.enable(z3.DEPTH_TEST), z3.depthFunc(z3.LEQUAL), z3.disable(z3.BLEND), z3.disable(z3.CULL_FACE);\n                        var Vr = false;\n                        te.enable && (Vr = Vr || te.isTransparent(), te.draw(Fe)), _e.axes = te, V2.object && _e.draw(Fe), z3.disable(z3.CULL_FACE);\n                        for (var St = 0; St < wr; ++St) {\n                          var Qt = Ee[St];\n                          Qt.axes = te, Qt.pixelRatio = ce.pixelRatio, Qt.isOpaque && Qt.isOpaque() && Qt.draw(Fe), Qt.isTransparent && Qt.isTransparent() && (Vr = true);\n                        }\n                        if (Vr) {\n                          G2.shape = ge, G2.bind(), z3.clear(z3.DEPTH_BUFFER_BIT), z3.colorMask(false, false, false, false), z3.depthMask(true), z3.depthFunc(z3.LESS), te.enable && te.isTransparent() && te.drawTransparent(Fe);\n                          for (var St = 0; St < wr; ++St) {\n                            var Qt = Ee[St];\n                            Qt.isOpaque && Qt.isOpaque() && Qt.draw(Fe);\n                          }\n                          z3.enable(z3.BLEND), z3.blendEquation(z3.FUNC_ADD), z3.blendFunc(z3.ONE, z3.ONE_MINUS_SRC_ALPHA), z3.colorMask(true, true, true, true), z3.depthMask(false), z3.clearColor(0, 0, 0, 0), z3.clear(z3.COLOR_BUFFER_BIT), te.isTransparent() && te.drawTransparent(Fe);\n                          for (var St = 0; St < wr; ++St) {\n                            var Qt = Ee[St];\n                            Qt.isTransparent && Qt.isTransparent() && Qt.drawTransparent(Fe);\n                          }\n                          z3.bindFramebuffer(z3.FRAMEBUFFER, null), z3.blendFunc(z3.ONE, z3.ONE_MINUS_SRC_ALPHA), z3.disable(z3.DEPTH_TEST), Z.bind(), G2.color[0].bind(0), Z.uniforms.accumBuffer = 0, d3(z3), z3.disable(z3.BLEND);\n                        }\n                        Se = false;\n                        for (var St = 0; St < wr; ++St) Ee[St].dirty = false;\n                      }\n                    }\n                  }\n                  function Jt() {\n                    ce._stopped || ce.contextLost || (Nt(), requestAnimationFrame(Jt));\n                  }\n                  return ce.enableMouseListeners(), Jt(), ce.redraw = function() {\n                    ce._stopped || (Se = true, Nt());\n                  }, ce;\n                }\n                function M4(g3, P3) {\n                  var T3 = g3.bounds, z3 = g3.cameraParams, O3 = z3.projection, V2 = z3.model, G2 = g3.gl.drawingBufferWidth, Z = g3.gl.drawingBufferHeight, j3 = g3.zNear, N2 = g3.zFar, H = g3.fovy, te = G2 / Z;\n                  P3 ? (b(O3, -te, te, -1, 1, j3, N2), z3._ortho = true) : (_2(O3, H, te, j3, N2), z3._ortho = false);\n                  for (var oe = 0; oe < 16; ++oe) V2[oe] = 0;\n                  V2[15] = 1;\n                  for (var _e = 0, oe = 0; oe < 3; ++oe) _e = Math.max(_e, T3[1][oe] - T3[0][oe]);\n                  for (var oe = 0; oe < 3; ++oe) g3.autoScale ? V2[5 * oe] = g3.aspect[oe] / (T3[1][oe] - T3[0][oe]) : V2[5 * oe] = 1 / _e, g3.autoCenter && (V2[12 + oe] = -V2[5 * oe] * 0.5 * (T3[0][oe] + T3[1][oe]));\n                }\n              }, 4192: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                var a4 = 32;\n                function o4(_2, b) {\n                  b <= 4 * a4 ? s3(0, b - 1, _2) : v3(0, b - 1, _2);\n                }\n                function s3(_2, b, p3) {\n                  for (var k4 = 2 * (_2 + 1), E3 = _2 + 1; E3 <= b; ++E3) {\n                    for (var S2 = p3[k4++], L3 = p3[k4++], x2 = E3, C3 = k4 - 2; x2-- > _2; ) {\n                      var M4 = p3[C3 - 2], g3 = p3[C3 - 1];\n                      if (M4 < S2) break;\n                      if (M4 === S2 && g3 < L3) break;\n                      p3[C3] = M4, p3[C3 + 1] = g3, C3 -= 2;\n                    }\n                    p3[C3] = S2, p3[C3 + 1] = L3;\n                  }\n                }\n                function l3(_2, b, p3) {\n                  _2 *= 2, b *= 2;\n                  var k4 = p3[_2], E3 = p3[_2 + 1];\n                  p3[_2] = p3[b], p3[_2 + 1] = p3[b + 1], p3[b] = k4, p3[b + 1] = E3;\n                }\n                function u4(_2, b, p3) {\n                  _2 *= 2, b *= 2, p3[_2] = p3[b], p3[_2 + 1] = p3[b + 1];\n                }\n                function c5(_2, b, p3, k4) {\n                  _2 *= 2, b *= 2, p3 *= 2;\n                  var E3 = k4[_2], S2 = k4[_2 + 1];\n                  k4[_2] = k4[b], k4[_2 + 1] = k4[b + 1], k4[b] = k4[p3], k4[b + 1] = k4[p3 + 1], k4[p3] = E3, k4[p3 + 1] = S2;\n                }\n                function f4(_2, b, p3, k4, E3) {\n                  _2 *= 2, b *= 2, E3[_2] = E3[b], E3[b] = p3, E3[_2 + 1] = E3[b + 1], E3[b + 1] = k4;\n                }\n                function h3(_2, b, p3) {\n                  _2 *= 2, b *= 2;\n                  var k4 = p3[_2], E3 = p3[b];\n                  return k4 < E3 ? false : k4 === E3 ? p3[_2 + 1] > p3[b + 1] : true;\n                }\n                function d3(_2, b, p3, k4) {\n                  _2 *= 2;\n                  var E3 = k4[_2];\n                  return E3 < b ? true : E3 === b ? k4[_2 + 1] < p3 : false;\n                }\n                function v3(_2, b, p3) {\n                  var k4 = (b - _2 + 1) / 6 | 0, E3 = _2 + k4, S2 = b - k4, L3 = _2 + b >> 1, x2 = L3 - k4, C3 = L3 + k4, M4 = E3, g3 = x2, P3 = L3, T3 = C3, z3 = S2, O3 = _2 + 1, V2 = b - 1, G2 = 0;\n                  h3(M4, g3, p3) && (G2 = M4, M4 = g3, g3 = G2), h3(T3, z3, p3) && (G2 = T3, T3 = z3, z3 = G2), h3(M4, P3, p3) && (G2 = M4, M4 = P3, P3 = G2), h3(g3, P3, p3) && (G2 = g3, g3 = P3, P3 = G2), h3(M4, T3, p3) && (G2 = M4, M4 = T3, T3 = G2), h3(P3, T3, p3) && (G2 = P3, P3 = T3, T3 = G2), h3(g3, z3, p3) && (G2 = g3, g3 = z3, z3 = G2), h3(g3, P3, p3) && (G2 = g3, g3 = P3, P3 = G2), h3(T3, z3, p3) && (G2 = T3, T3 = z3, z3 = G2);\n                  for (var Z = p3[2 * g3], j3 = p3[2 * g3 + 1], N2 = p3[2 * T3], H = p3[2 * T3 + 1], te = 2 * M4, oe = 2 * P3, _e = 2 * z3, Ee = 2 * E3, Ce = 2 * L3, me = 2 * S2, ie = 0; ie < 2; ++ie) {\n                    var Se = p3[te + ie], Le = p3[oe + ie], Ae = p3[_e + ie];\n                    p3[Ee + ie] = Se, p3[Ce + ie] = Le, p3[me + ie] = Ae;\n                  }\n                  u4(x2, _2, p3), u4(C3, b, p3);\n                  for (var Fe = O3; Fe <= V2; ++Fe) if (d3(Fe, Z, j3, p3)) Fe !== O3 && l3(Fe, O3, p3), ++O3;\n                  else if (!d3(Fe, N2, H, p3)) for (; ; ) if (d3(V2, N2, H, p3)) {\n                    d3(V2, Z, j3, p3) ? (c5(Fe, O3, V2, p3), ++O3, --V2) : (l3(Fe, V2, p3), --V2);\n                    break;\n                  } else {\n                    if (--V2 < Fe) break;\n                    continue;\n                  }\n                  f4(_2, O3 - 1, Z, j3, p3), f4(b, V2 + 1, N2, H, p3), O3 - 2 - _2 <= a4 ? s3(_2, O3 - 2, p3) : v3(_2, O3 - 2, p3), b - (V2 + 2) <= a4 ? s3(V2 + 2, b, p3) : v3(V2 + 2, b, p3), V2 - O3 <= a4 ? s3(O3, V2, p3) : v3(O3, V2, p3);\n                }\n              }, 4209: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = p3;\n                var s3 = o4(2478), l3 = o4(3840), u4 = o4(3250), c5 = o4(1303);\n                function f4(k4, E3, S2) {\n                  this.slabs = k4, this.coordinates = E3, this.horizontal = S2;\n                }\n                var h3 = f4.prototype;\n                function d3(k4, E3) {\n                  return k4.y - E3;\n                }\n                function v3(k4, E3) {\n                  for (var S2 = null; k4; ) {\n                    var L3 = k4.key, x2, C3;\n                    L3[0][0] < L3[1][0] ? (x2 = L3[0], C3 = L3[1]) : (x2 = L3[1], C3 = L3[0]);\n                    var M4 = u4(x2, C3, E3);\n                    if (M4 < 0) k4 = k4.left;\n                    else if (M4 > 0) if (E3[0] !== L3[1][0]) S2 = k4, k4 = k4.right;\n                    else {\n                      var g3 = v3(k4.right, E3);\n                      if (g3) return g3;\n                      k4 = k4.left;\n                    }\n                    else {\n                      if (E3[0] !== L3[1][0]) return k4;\n                      var g3 = v3(k4.right, E3);\n                      if (g3) return g3;\n                      k4 = k4.left;\n                    }\n                  }\n                  return S2;\n                }\n                h3.castUp = function(k4) {\n                  var E3 = s3.le(this.coordinates, k4[0]);\n                  if (E3 < 0) return -1;\n                  var S2 = this.slabs[E3], L3 = v3(this.slabs[E3], k4), x2 = -1;\n                  if (L3 && (x2 = L3.value), this.coordinates[E3] === k4[0]) {\n                    var C3 = null;\n                    if (L3 && (C3 = L3.key), E3 > 0) {\n                      var M4 = v3(this.slabs[E3 - 1], k4);\n                      M4 && (C3 ? c5(M4.key, C3) > 0 && (C3 = M4.key, x2 = M4.value) : (x2 = M4.value, C3 = M4.key));\n                    }\n                    var g3 = this.horizontal[E3];\n                    if (g3.length > 0) {\n                      var P3 = s3.ge(g3, k4[1], d3);\n                      if (P3 < g3.length) {\n                        var T3 = g3[P3];\n                        if (k4[1] === T3.y) {\n                          if (T3.closed) return T3.index;\n                          for (; P3 < g3.length - 1 && g3[P3 + 1].y === k4[1]; ) if (P3 = P3 + 1, T3 = g3[P3], T3.closed) return T3.index;\n                          if (T3.y === k4[1] && !T3.start) {\n                            if (P3 = P3 + 1, P3 >= g3.length) return x2;\n                            T3 = g3[P3];\n                          }\n                        }\n                        if (T3.start) if (C3) {\n                          var z3 = u4(C3[0], C3[1], [k4[0], T3.y]);\n                          C3[0][0] > C3[1][0] && (z3 = -z3), z3 > 0 && (x2 = T3.index);\n                        } else x2 = T3.index;\n                        else T3.y !== k4[1] && (x2 = T3.index);\n                      }\n                    }\n                  }\n                  return x2;\n                };\n                function _2(k4, E3, S2, L3) {\n                  this.y = k4, this.index = E3, this.start = S2, this.closed = L3;\n                }\n                function b(k4, E3, S2, L3) {\n                  this.x = k4, this.segment = E3, this.create = S2, this.index = L3;\n                }\n                function p3(k4) {\n                  for (var E3 = k4.length, S2 = 2 * E3, L3 = new Array(S2), x2 = 0; x2 < E3; ++x2) {\n                    var C3 = k4[x2], M4 = C3[0][0] < C3[1][0];\n                    L3[2 * x2] = new b(C3[0][0], C3, M4, x2), L3[2 * x2 + 1] = new b(C3[1][0], C3, !M4, x2);\n                  }\n                  L3.sort(function(j3, N2) {\n                    var H = j3.x - N2.x;\n                    return H || (H = j3.create - N2.create, H) ? H : Math.min(j3.segment[0][1], j3.segment[1][1]) - Math.min(N2.segment[0][1], N2.segment[1][1]);\n                  });\n                  for (var g3 = l3(c5), P3 = [], T3 = [], z3 = [], O3 = -1 / 0, x2 = 0; x2 < S2; ) {\n                    for (var V2 = L3[x2].x, G2 = []; x2 < S2; ) {\n                      var Z = L3[x2];\n                      if (Z.x !== V2) break;\n                      x2 += 1, Z.segment[0][0] === Z.x && Z.segment[1][0] === Z.x ? Z.create && (Z.segment[0][1] < Z.segment[1][1] ? (G2.push(new _2(Z.segment[0][1], Z.index, true, true)), G2.push(new _2(Z.segment[1][1], Z.index, false, false))) : (G2.push(new _2(Z.segment[1][1], Z.index, true, false)), G2.push(new _2(Z.segment[0][1], Z.index, false, true)))) : Z.create ? g3 = g3.insert(Z.segment, Z.index) : g3 = g3.remove(Z.segment);\n                    }\n                    P3.push(g3.root), T3.push(V2), z3.push(G2);\n                  }\n                  return new f4(P3, T3, z3);\n                }\n              }, 4317: function(i3) {\n                "use strict";\n                function a4(c5, f4) {\n                  var h3 = Math.floor(f4), d3 = f4 - h3, v3 = 0 <= h3 && h3 < c5.shape[0], _2 = 0 <= h3 + 1 && h3 + 1 < c5.shape[0], b = v3 ? +c5.get(h3) : 0, p3 = _2 ? +c5.get(h3 + 1) : 0;\n                  return (1 - d3) * b + d3 * p3;\n                }\n                function o4(c5, f4, h3) {\n                  var d3 = Math.floor(f4), v3 = f4 - d3, _2 = 0 <= d3 && d3 < c5.shape[0], b = 0 <= d3 + 1 && d3 + 1 < c5.shape[0], p3 = Math.floor(h3), k4 = h3 - p3, E3 = 0 <= p3 && p3 < c5.shape[1], S2 = 0 <= p3 + 1 && p3 + 1 < c5.shape[1], L3 = _2 && E3 ? c5.get(d3, p3) : 0, x2 = _2 && S2 ? c5.get(d3, p3 + 1) : 0, C3 = b && E3 ? c5.get(d3 + 1, p3) : 0, M4 = b && S2 ? c5.get(d3 + 1, p3 + 1) : 0;\n                  return (1 - k4) * ((1 - v3) * L3 + v3 * C3) + k4 * ((1 - v3) * x2 + v3 * M4);\n                }\n                function s3(c5, f4, h3, d3) {\n                  var v3 = Math.floor(f4), _2 = f4 - v3, b = 0 <= v3 && v3 < c5.shape[0], p3 = 0 <= v3 + 1 && v3 + 1 < c5.shape[0], k4 = Math.floor(h3), E3 = h3 - k4, S2 = 0 <= k4 && k4 < c5.shape[1], L3 = 0 <= k4 + 1 && k4 + 1 < c5.shape[1], x2 = Math.floor(d3), C3 = d3 - x2, M4 = 0 <= x2 && x2 < c5.shape[2], g3 = 0 <= x2 + 1 && x2 + 1 < c5.shape[2], P3 = b && S2 && M4 ? c5.get(v3, k4, x2) : 0, T3 = b && L3 && M4 ? c5.get(v3, k4 + 1, x2) : 0, z3 = p3 && S2 && M4 ? c5.get(v3 + 1, k4, x2) : 0, O3 = p3 && L3 && M4 ? c5.get(v3 + 1, k4 + 1, x2) : 0, V2 = b && S2 && g3 ? c5.get(v3, k4, x2 + 1) : 0, G2 = b && L3 && g3 ? c5.get(v3, k4 + 1, x2 + 1) : 0, Z = p3 && S2 && g3 ? c5.get(v3 + 1, k4, x2 + 1) : 0, j3 = p3 && L3 && g3 ? c5.get(v3 + 1, k4 + 1, x2 + 1) : 0;\n                  return (1 - C3) * ((1 - E3) * ((1 - _2) * P3 + _2 * z3) + E3 * ((1 - _2) * T3 + _2 * O3)) + C3 * ((1 - E3) * ((1 - _2) * V2 + _2 * Z) + E3 * ((1 - _2) * G2 + _2 * j3));\n                }\n                function l3(c5) {\n                  var f4 = c5.shape.length | 0, h3 = new Array(f4), d3 = new Array(f4), v3 = new Array(f4), _2 = new Array(f4), b, p3;\n                  for (b = 0; b < f4; ++b) p3 = +arguments[b + 1], h3[b] = Math.floor(p3), d3[b] = p3 - h3[b], v3[b] = 0 <= h3[b] && h3[b] < c5.shape[b], _2[b] = 0 <= h3[b] + 1 && h3[b] + 1 < c5.shape[b];\n                  var k4 = 0, E3, S2, L3;\n                  e: for (b = 0; b < 1 << f4; ++b) {\n                    for (S2 = 1, L3 = c5.offset, E3 = 0; E3 < f4; ++E3) if (b & 1 << E3) {\n                      if (!_2[E3]) continue e;\n                      S2 *= d3[E3], L3 += c5.stride[E3] * (h3[E3] + 1);\n                    } else {\n                      if (!v3[E3]) continue e;\n                      S2 *= 1 - d3[E3], L3 += c5.stride[E3] * h3[E3];\n                    }\n                    k4 += S2 * c5.data[L3];\n                  }\n                  return k4;\n                }\n                function u4(c5, f4, h3, d3) {\n                  switch (c5.shape.length) {\n                    case 0:\n                      return 0;\n                    case 1:\n                      return a4(c5, f4);\n                    case 2:\n                      return o4(c5, f4, h3);\n                    case 3:\n                      return s3(c5, f4, h3, d3);\n                    default:\n                      return l3.apply(void 0, arguments);\n                  }\n                }\n                i3.exports = u4, i3.exports.d1 = a4, i3.exports.d2 = o4, i3.exports.d3 = s3;\n              }, 4335: function(i3) {\n                i3.exports = function(o4, s3) {\n                  var l3 = s3[15];\n                  if (l3 === 0) return false;\n                  for (var u4 = 1 / l3, c5 = 0; c5 < 16; c5++) o4[c5] = s3[c5] * u4;\n                  return true;\n                };\n              }, 4359: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = c5;\n                var s3 = o4(7718), l3 = null, u4 = null;\n                typeof document != "undefined" && (l3 = document.createElement("canvas"), l3.width = 8192, l3.height = 1024, u4 = l3.getContext("2d"));\n                function c5(f4, h3) {\n                  return (typeof h3 != "object" || h3 === null) && (h3 = {}), s3(f4, h3.canvas || l3, h3.context || u4, h3);\n                }\n              }, 4361: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] + l3[0], o4[1] = s3[1] + l3[1], o4[2] = s3[2] + l3[2], o4[3] = s3[3] + l3[3], o4;\n                }\n              }, 4437: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = d3;\n                var s3 = o4(3025), l3 = o4(6296), u4 = o4(351), c5 = o4(8512), f4 = o4(24), h3 = o4(7520);\n                function d3(v3, _2) {\n                  v3 = v3 || document.body, _2 = _2 || {};\n                  var b = [0.01, 1 / 0];\n                  "distanceLimits" in _2 && (b[0] = _2.distanceLimits[0], b[1] = _2.distanceLimits[1]), "zoomMin" in _2 && (b[0] = _2.zoomMin), "zoomMax" in _2 && (b[1] = _2.zoomMax);\n                  var p3 = l3({ center: _2.center || [0, 0, 0], up: _2.up || [0, 1, 0], eye: _2.eye || [0, 0, 10], mode: _2.mode || "orbit", distanceLimits: b }), k4 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], E3 = 0, S2 = v3.clientWidth, L3 = v3.clientHeight, x2 = { keyBindingMode: "rotate", enableWheel: true, view: p3, element: v3, delay: _2.delay || 16, rotateSpeed: _2.rotateSpeed || 1, zoomSpeed: _2.zoomSpeed || 1, translateSpeed: _2.translateSpeed || 1, flipX: !!_2.flipX, flipY: !!_2.flipY, modes: p3.modes, _ortho: _2._ortho || _2.projection && _2.projection.type === "orthographic" || false, tick: function() {\n                    var C3 = s3(), M4 = this.delay, g3 = C3 - 2 * M4;\n                    p3.idle(C3 - M4), p3.recalcMatrix(g3), p3.flush(C3 - (100 + M4 * 2));\n                    for (var P3 = true, T3 = p3.computedMatrix, z3 = 0; z3 < 16; ++z3) P3 = P3 && k4[z3] === T3[z3], k4[z3] = T3[z3];\n                    var O3 = v3.clientWidth === S2 && v3.clientHeight === L3;\n                    return S2 = v3.clientWidth, L3 = v3.clientHeight, P3 ? !O3 : (E3 = Math.exp(p3.computedRadius[0]), true);\n                  }, lookAt: function(C3, M4, g3) {\n                    p3.lookAt(p3.lastT(), C3, M4, g3);\n                  }, rotate: function(C3, M4, g3) {\n                    p3.rotate(p3.lastT(), C3, M4, g3);\n                  }, pan: function(C3, M4, g3) {\n                    p3.pan(p3.lastT(), C3, M4, g3);\n                  }, translate: function(C3, M4, g3) {\n                    p3.translate(p3.lastT(), C3, M4, g3);\n                  } };\n                  return Object.defineProperties(x2, { matrix: { get: function() {\n                    return p3.computedMatrix;\n                  }, set: function(C3) {\n                    return p3.setMatrix(p3.lastT(), C3), p3.computedMatrix;\n                  }, enumerable: true }, mode: { get: function() {\n                    return p3.getMode();\n                  }, set: function(C3) {\n                    var M4 = p3.computedUp.slice(), g3 = p3.computedEye.slice(), P3 = p3.computedCenter.slice();\n                    if (p3.setMode(C3), C3 === "turntable") {\n                      var T3 = s3();\n                      p3._active.lookAt(T3, g3, P3, M4), p3._active.lookAt(T3 + 500, g3, P3, [0, 0, 1]), p3._active.flush(T3);\n                    }\n                    return p3.getMode();\n                  }, enumerable: true }, center: { get: function() {\n                    return p3.computedCenter;\n                  }, set: function(C3) {\n                    return p3.lookAt(p3.lastT(), null, C3), p3.computedCenter;\n                  }, enumerable: true }, eye: { get: function() {\n                    return p3.computedEye;\n                  }, set: function(C3) {\n                    return p3.lookAt(p3.lastT(), C3), p3.computedEye;\n                  }, enumerable: true }, up: { get: function() {\n                    return p3.computedUp;\n                  }, set: function(C3) {\n                    return p3.lookAt(p3.lastT(), null, null, C3), p3.computedUp;\n                  }, enumerable: true }, distance: { get: function() {\n                    return E3;\n                  }, set: function(C3) {\n                    return p3.setDistance(p3.lastT(), C3), C3;\n                  }, enumerable: true }, distanceLimits: { get: function() {\n                    return p3.getDistanceLimits(b);\n                  }, set: function(C3) {\n                    return p3.setDistanceLimits(C3), C3;\n                  }, enumerable: true } }), v3.addEventListener("contextmenu", function(C3) {\n                    return C3.preventDefault(), false;\n                  }), x2._lastX = -1, x2._lastY = -1, x2._lastMods = { shift: false, control: false, alt: false, meta: false }, x2.enableMouseListeners = function() {\n                    x2.mouseListener = u4(v3, C3), v3.addEventListener("touchstart", function(M4) {\n                      var g3 = f4(M4.changedTouches[0], v3);\n                      C3(0, g3[0], g3[1], x2._lastMods), C3(1, g3[0], g3[1], x2._lastMods);\n                    }, h3 ? { passive: true } : false), v3.addEventListener("touchmove", function(M4) {\n                      var g3 = f4(M4.changedTouches[0], v3);\n                      C3(1, g3[0], g3[1], x2._lastMods), M4.preventDefault();\n                    }, h3 ? { passive: false } : false), v3.addEventListener("touchend", function(M4) {\n                      C3(0, x2._lastX, x2._lastY, x2._lastMods);\n                    }, h3 ? { passive: true } : false);\n                    function C3(M4, g3, P3, T3) {\n                      var z3 = x2.keyBindingMode;\n                      if (z3 !== false) {\n                        var O3 = z3 === "rotate", V2 = z3 === "pan", G2 = z3 === "zoom", Z = !!T3.control, j3 = !!T3.alt, N2 = !!T3.shift, H = !!(M4 & 1), te = !!(M4 & 2), oe = !!(M4 & 4), _e = 1 / v3.clientHeight, Ee = _e * (g3 - x2._lastX), Ce = _e * (P3 - x2._lastY), me = x2.flipX ? 1 : -1, ie = x2.flipY ? 1 : -1, Se = Math.PI * x2.rotateSpeed, Le = s3();\n                        if (x2._lastX !== -1 && x2._lastY !== -1 && ((O3 && H && !Z && !j3 && !N2 || H && !Z && !j3 && N2) && p3.rotate(Le, me * Se * Ee, -ie * Se * Ce, 0), (V2 && H && !Z && !j3 && !N2 || te || H && Z && !j3 && !N2) && p3.pan(Le, -x2.translateSpeed * Ee * E3, x2.translateSpeed * Ce * E3, 0), G2 && H && !Z && !j3 && !N2 || oe || H && !Z && j3 && !N2)) {\n                          var Ae = -x2.zoomSpeed * Ce / window.innerHeight * (Le - p3.lastT()) * 100;\n                          p3.pan(Le, 0, 0, E3 * (Math.exp(Ae) - 1));\n                        }\n                        return x2._lastX = g3, x2._lastY = P3, x2._lastMods = T3, true;\n                      }\n                    }\n                    x2.wheelListener = c5(v3, function(M4, g3) {\n                      if (x2.keyBindingMode !== false && x2.enableWheel) {\n                        var P3 = x2.flipX ? 1 : -1, T3 = x2.flipY ? 1 : -1, z3 = s3();\n                        if (Math.abs(M4) > Math.abs(g3)) p3.rotate(z3, 0, 0, -M4 * P3 * Math.PI * x2.rotateSpeed / window.innerWidth);\n                        else if (!x2._ortho) {\n                          var O3 = -x2.zoomSpeed * T3 * g3 / window.innerHeight * (z3 - p3.lastT()) / 20;\n                          p3.pan(z3, 0, 0, E3 * (Math.exp(O3) - 1));\n                        }\n                      }\n                    }, true);\n                  }, x2.enableMouseListeners(), x2;\n                }\n              }, 4449: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(1493);\n                i3.exports = b;\n                var c5 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                function f4(p3, k4, E3, S2) {\n                  this.gl = p3, this.buffer = k4, this.vao = E3, this.shader = S2, this.pixelRatio = 1, this.bounds = [[-1e3, -1e3, -1e3], [1e3, 1e3, 1e3]], this.position = [0, 0, 0], this.lineWidth = [2, 2, 2], this.colors = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.enabled = [true, true, true], this.drawSides = [true, true, true], this.axes = null;\n                }\n                var h3 = f4.prototype, d3 = [0, 0, 0], v3 = [0, 0, 0], _2 = [0, 0];\n                h3.isTransparent = function() {\n                  return false;\n                }, h3.drawTransparent = function(p3) {\n                }, h3.draw = function(p3) {\n                  var k4 = this.gl, E3 = this.vao, S2 = this.shader;\n                  E3.bind(), S2.bind();\n                  var L3 = p3.model || c5, x2 = p3.view || c5, C3 = p3.projection || c5, M4;\n                  this.axes && (M4 = this.axes.lastCubeProps.axis);\n                  for (var g3 = d3, P3 = v3, T3 = 0; T3 < 3; ++T3) M4 && M4[T3] < 0 ? (g3[T3] = this.bounds[0][T3], P3[T3] = this.bounds[1][T3]) : (g3[T3] = this.bounds[1][T3], P3[T3] = this.bounds[0][T3]);\n                  _2[0] = k4.drawingBufferWidth, _2[1] = k4.drawingBufferHeight, S2.uniforms.model = L3, S2.uniforms.view = x2, S2.uniforms.projection = C3, S2.uniforms.coordinates = [this.position, g3, P3], S2.uniforms.colors = this.colors, S2.uniforms.screenShape = _2;\n                  for (var T3 = 0; T3 < 3; ++T3) S2.uniforms.lineWidth = this.lineWidth[T3] * this.pixelRatio, this.enabled[T3] && (E3.draw(k4.TRIANGLES, 6, 6 * T3), this.drawSides[T3] && E3.draw(k4.TRIANGLES, 12, 18 + 12 * T3));\n                  E3.unbind();\n                }, h3.update = function(p3) {\n                  p3 && ("bounds" in p3 && (this.bounds = p3.bounds), "position" in p3 && (this.position = p3.position), "lineWidth" in p3 && (this.lineWidth = p3.lineWidth), "colors" in p3 && (this.colors = p3.colors), "enabled" in p3 && (this.enabled = p3.enabled), "drawSides" in p3 && (this.drawSides = p3.drawSides));\n                }, h3.dispose = function() {\n                  this.vao.dispose(), this.buffer.dispose(), this.shader.dispose();\n                };\n                function b(p3, k4) {\n                  var E3 = [];\n                  function S2(g3, P3, T3, z3, O3, V2) {\n                    var G2 = [g3, P3, T3, 0, 0, 0, 1];\n                    G2[z3 + 3] = 1, G2[z3] = O3, E3.push.apply(E3, G2), G2[6] = -1, E3.push.apply(E3, G2), G2[z3] = V2, E3.push.apply(E3, G2), E3.push.apply(E3, G2), G2[6] = 1, E3.push.apply(E3, G2), G2[z3] = O3, E3.push.apply(E3, G2);\n                  }\n                  S2(0, 0, 0, 0, 0, 1), S2(0, 0, 0, 1, 0, 1), S2(0, 0, 0, 2, 0, 1), S2(1, 0, 0, 1, -1, 1), S2(1, 0, 0, 2, -1, 1), S2(0, 1, 0, 0, -1, 1), S2(0, 1, 0, 2, -1, 1), S2(0, 0, 1, 0, -1, 1), S2(0, 0, 1, 1, -1, 1);\n                  var L3 = s3(p3, E3), x2 = l3(p3, [{ type: p3.FLOAT, buffer: L3, size: 3, offset: 0, stride: 28 }, { type: p3.FLOAT, buffer: L3, size: 3, offset: 12, stride: 28 }, { type: p3.FLOAT, buffer: L3, size: 1, offset: 24, stride: 28 }]), C3 = u4(p3);\n                  C3.attributes.position.location = 0, C3.attributes.color.location = 1, C3.attributes.weight.location = 2;\n                  var M4 = new f4(p3, L3, x2, C3);\n                  return M4.update(k4), M4;\n                }\n              }, 4494: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = 1 / s3[0], o4[1] = 1 / s3[1], o4[2] = 1 / s3[2], o4[3] = 1 / s3[3], o4;\n                }\n              }, 4505: function(i3, a4, o4) {\n                i3.exports = o4(5847);\n              }, 4578: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4, c5) {\n                  return o4[0] = s3, o4[1] = l3, o4[2] = u4, o4[3] = c5, o4;\n                }\n              }, 4623: function(i3) {\n                "use strict";\n                "use restrict";\n                i3.exports = a4;\n                function a4(o4) {\n                  this.roots = new Array(o4), this.ranks = new Array(o4);\n                  for (var s3 = 0; s3 < o4; ++s3) this.roots[s3] = s3, this.ranks[s3] = 0;\n                }\n                a4.prototype.length = function() {\n                  return this.roots.length;\n                }, a4.prototype.makeSet = function() {\n                  var o4 = this.roots.length;\n                  return this.roots.push(o4), this.ranks.push(0), o4;\n                }, a4.prototype.find = function(o4) {\n                  for (var s3 = this.roots; s3[o4] !== o4; ) {\n                    var l3 = s3[o4];\n                    s3[o4] = s3[l3], o4 = l3;\n                  }\n                  return o4;\n                }, a4.prototype.link = function(o4, s3) {\n                  var l3 = this.find(o4), u4 = this.find(s3);\n                  if (l3 !== u4) {\n                    var c5 = this.ranks, f4 = this.roots, h3 = c5[l3], d3 = c5[u4];\n                    h3 < d3 ? f4[l3] = u4 : d3 < h3 ? f4[u4] = l3 : (f4[u4] = l3, ++c5[l3]);\n                  }\n                };\n              }, 4687: function(i3, a4) {\n                "use strict";\n                function o4(c5) {\n                  if (typeof c5 == "object") {\n                    if ("buttons" in c5) return c5.buttons;\n                    if ("which" in c5) {\n                      var f4 = c5.which;\n                      if (f4 === 2) return 4;\n                      if (f4 === 3) return 2;\n                      if (f4 > 0) return 1 << f4 - 1;\n                    } else if ("button" in c5) {\n                      var f4 = c5.button;\n                      if (f4 === 1) return 4;\n                      if (f4 === 2) return 2;\n                      if (f4 >= 0) return 1 << f4;\n                    }\n                  }\n                  return 0;\n                }\n                a4.buttons = o4;\n                function s3(c5) {\n                  return c5.target || c5.srcElement || window;\n                }\n                a4.element = s3;\n                function l3(c5) {\n                  if (typeof c5 == "object") {\n                    if ("offsetX" in c5) return c5.offsetX;\n                    var f4 = s3(c5), h3 = f4.getBoundingClientRect();\n                    return c5.clientX - h3.left;\n                  }\n                  return 0;\n                }\n                a4.x = l3;\n                function u4(c5) {\n                  if (typeof c5 == "object") {\n                    if ("offsetY" in c5) return c5.offsetY;\n                    var f4 = s3(c5), h3 = f4.getBoundingClientRect();\n                    return c5.clientY - h3.top;\n                  }\n                  return 0;\n                }\n                a4.y = u4;\n              }, 4691: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0] - o4[0], u4 = s3[1] - o4[1], c5 = s3[2] - o4[2], f4 = s3[3] - o4[3];\n                  return Math.sqrt(l3 * l3 + u4 * u4 + c5 * c5 + f4 * f4);\n                }\n              }, 4750: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(3090);\n                function l3(u4) {\n                  var c5 = s3(u4), f4 = c5.length;\n                  if (f4 <= 2) return [];\n                  for (var h3 = new Array(f4), d3 = c5[f4 - 1], v3 = 0; v3 < f4; ++v3) {\n                    var _2 = c5[v3];\n                    h3[v3] = [d3, _2], d3 = _2;\n                  }\n                  return h3;\n                }\n              }, 4769: function(i3) {\n                "use strict";\n                function a4(s3, l3, u4, c5, f4, h3) {\n                  var d3 = 6 * f4 * f4 - 6 * f4, v3 = 3 * f4 * f4 - 4 * f4 + 1, _2 = -6 * f4 * f4 + 6 * f4, b = 3 * f4 * f4 - 2 * f4;\n                  if (s3.length) {\n                    h3 || (h3 = new Array(s3.length));\n                    for (var p3 = s3.length - 1; p3 >= 0; --p3) h3[p3] = d3 * s3[p3] + v3 * l3[p3] + _2 * u4[p3] + b * c5[p3];\n                    return h3;\n                  }\n                  return d3 * s3 + v3 * l3 + _2 * u4[p3] + b * c5;\n                }\n                function o4(s3, l3, u4, c5, f4, h3) {\n                  var d3 = f4 - 1, v3 = f4 * f4, _2 = d3 * d3, b = (1 + 2 * f4) * _2, p3 = f4 * _2, k4 = v3 * (3 - 2 * f4), E3 = v3 * d3;\n                  if (s3.length) {\n                    h3 || (h3 = new Array(s3.length));\n                    for (var S2 = s3.length - 1; S2 >= 0; --S2) h3[S2] = b * s3[S2] + p3 * l3[S2] + k4 * u4[S2] + E3 * c5[S2];\n                    return h3;\n                  }\n                  return b * s3 + p3 * l3 + k4 * u4 + E3 * c5;\n                }\n                i3.exports = o4, i3.exports.derivative = a4;\n              }, 4772: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4, c5) {\n                  var f4 = 1 / Math.tan(s3 / 2), h3 = 1 / (u4 - c5);\n                  return o4[0] = f4 / l3, o4[1] = 0, o4[2] = 0, o4[3] = 0, o4[4] = 0, o4[5] = f4, o4[6] = 0, o4[7] = 0, o4[8] = 0, o4[9] = 0, o4[10] = (c5 + u4) * h3, o4[11] = -1, o4[12] = 0, o4[13] = 0, o4[14] = 2 * c5 * u4 * h3, o4[15] = 0, o4;\n                }\n              }, 4793: function(i3, a4, o4) {\n                "use strict";\n                var s3;\n                function l3(Ie, xe) {\n                  if (!(Ie instanceof xe)) throw new TypeError("Cannot call a class as a function");\n                }\n                function u4(Ie, xe) {\n                  for (var ke = 0; ke < xe.length; ke++) {\n                    var vt = xe[ke];\n                    vt.enumerable = vt.enumerable || false, vt.configurable = true, "value" in vt && (vt.writable = true), Object.defineProperty(Ie, f4(vt.key), vt);\n                  }\n                }\n                function c5(Ie, xe, ke) {\n                  return xe && u4(Ie.prototype, xe), ke && u4(Ie, ke), Object.defineProperty(Ie, "prototype", { writable: false }), Ie;\n                }\n                function f4(Ie) {\n                  var xe = h3(Ie, "string");\n                  return S2(xe) == "symbol" ? xe : xe + "";\n                }\n                function h3(Ie, xe) {\n                  if (S2(Ie) != "object" || !Ie) return Ie;\n                  var ke = Ie[Symbol.toPrimitive];\n                  if (ke !== void 0) {\n                    var vt = ke.call(Ie, xe || "default");\n                    if (S2(vt) != "object") return vt;\n                    throw new TypeError("@@toPrimitive must return a primitive value.");\n                  }\n                  return (xe === "string" ? String : Number)(Ie);\n                }\n                function d3(Ie, xe, ke) {\n                  return xe = p3(xe), v3(Ie, b() ? Reflect.construct(xe, ke || [], p3(Ie).constructor) : xe.apply(Ie, ke));\n                }\n                function v3(Ie, xe) {\n                  if (xe && (S2(xe) == "object" || typeof xe == "function")) return xe;\n                  if (xe !== void 0) throw new TypeError("Derived constructors may only return object or undefined");\n                  return _2(Ie);\n                }\n                function _2(Ie) {\n                  if (Ie === void 0) throw new ReferenceError("this hasn\'t been initialised - super() hasn\'t been called");\n                  return Ie;\n                }\n                function b() {\n                  try {\n                    var Ie = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {\n                    }));\n                  } catch (xe) {\n                  }\n                  return (b = function() {\n                    return !!Ie;\n                  })();\n                }\n                function p3(Ie) {\n                  return p3 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(xe) {\n                    return xe.__proto__ || Object.getPrototypeOf(xe);\n                  }, p3(Ie);\n                }\n                function k4(Ie, xe) {\n                  if (typeof xe != "function" && xe !== null) throw new TypeError("Super expression must either be null or a function");\n                  Ie.prototype = Object.create(xe && xe.prototype, { constructor: { value: Ie, writable: true, configurable: true } }), Object.defineProperty(Ie, "prototype", { writable: false }), xe && E3(Ie, xe);\n                }\n                function E3(Ie, xe) {\n                  return E3 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(ke, vt) {\n                    return ke.__proto__ = vt, ke;\n                  }, E3(Ie, xe);\n                }\n                function S2(Ie) {\n                  "@babel/helpers - typeof";\n                  return S2 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(xe) {\n                    return typeof xe;\n                  } : function(xe) {\n                    return xe && typeof Symbol == "function" && xe.constructor === Symbol && xe !== Symbol.prototype ? "symbol" : typeof xe;\n                  }, S2(Ie);\n                }\n                var L3 = o4(7507), x2 = o4(3778), C3 = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;\n                a4.hp = T3, s3 = _e, a4.IS = 50;\n                var M4 = 2147483647;\n                s3 = M4, T3.TYPED_ARRAY_SUPPORT = g3(), !T3.TYPED_ARRAY_SUPPORT && typeof console != "undefined" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");\n                function g3() {\n                  try {\n                    var Ie = new Uint8Array(1), xe = { foo: function() {\n                      return 42;\n                    } };\n                    return Object.setPrototypeOf(xe, Uint8Array.prototype), Object.setPrototypeOf(Ie, xe), Ie.foo() === 42;\n                  } catch (ke) {\n                    return false;\n                  }\n                }\n                Object.defineProperty(T3.prototype, "parent", { enumerable: true, get: function() {\n                  if (T3.isBuffer(this)) return this.buffer;\n                } }), Object.defineProperty(T3.prototype, "offset", { enumerable: true, get: function() {\n                  if (T3.isBuffer(this)) return this.byteOffset;\n                } });\n                function P3(Ie) {\n                  if (Ie > M4) throw new RangeError(\'The value "\' + Ie + \'" is invalid for option "size"\');\n                  var xe = new Uint8Array(Ie);\n                  return Object.setPrototypeOf(xe, T3.prototype), xe;\n                }\n                function T3(Ie, xe, ke) {\n                  if (typeof Ie == "number") {\n                    if (typeof xe == "string") throw new TypeError(\'The "string" argument must be of type string. Received type number\');\n                    return G2(Ie);\n                  }\n                  return z3(Ie, xe, ke);\n                }\n                T3.poolSize = 8192;\n                function z3(Ie, xe, ke) {\n                  if (typeof Ie == "string") return Z(Ie, xe);\n                  if (ArrayBuffer.isView(Ie)) return N2(Ie);\n                  if (Ie == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + S2(Ie));\n                  if (Ge(Ie, ArrayBuffer) || Ie && Ge(Ie.buffer, ArrayBuffer) || typeof SharedArrayBuffer != "undefined" && (Ge(Ie, SharedArrayBuffer) || Ie && Ge(Ie.buffer, SharedArrayBuffer))) return H(Ie, xe, ke);\n                  if (typeof Ie == "number") throw new TypeError(\'The "value" argument must not be of type number. Received type number\');\n                  var vt = Ie.valueOf && Ie.valueOf();\n                  if (vt != null && vt !== Ie) return T3.from(vt, xe, ke);\n                  var ir = te(Ie);\n                  if (ir) return ir;\n                  if (typeof Symbol != "undefined" && Symbol.toPrimitive != null && typeof Ie[Symbol.toPrimitive] == "function") return T3.from(Ie[Symbol.toPrimitive]("string"), xe, ke);\n                  throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + S2(Ie));\n                }\n                T3.from = function(Ie, xe, ke) {\n                  return z3(Ie, xe, ke);\n                }, Object.setPrototypeOf(T3.prototype, Uint8Array.prototype), Object.setPrototypeOf(T3, Uint8Array);\n                function O3(Ie) {\n                  if (typeof Ie != "number") throw new TypeError(\'"size" argument must be of type number\');\n                  if (Ie < 0) throw new RangeError(\'The value "\' + Ie + \'" is invalid for option "size"\');\n                }\n                function V2(Ie, xe, ke) {\n                  return O3(Ie), Ie <= 0 ? P3(Ie) : xe !== void 0 ? typeof ke == "string" ? P3(Ie).fill(xe, ke) : P3(Ie).fill(xe) : P3(Ie);\n                }\n                T3.alloc = function(Ie, xe, ke) {\n                  return V2(Ie, xe, ke);\n                };\n                function G2(Ie) {\n                  return O3(Ie), P3(Ie < 0 ? 0 : oe(Ie) | 0);\n                }\n                T3.allocUnsafe = function(Ie) {\n                  return G2(Ie);\n                }, T3.allocUnsafeSlow = function(Ie) {\n                  return G2(Ie);\n                };\n                function Z(Ie, xe) {\n                  if ((typeof xe != "string" || xe === "") && (xe = "utf8"), !T3.isEncoding(xe)) throw new TypeError("Unknown encoding: " + xe);\n                  var ke = Ee(Ie, xe) | 0, vt = P3(ke), ir = vt.write(Ie, xe);\n                  return ir !== ke && (vt = vt.slice(0, ir)), vt;\n                }\n                function j3(Ie) {\n                  for (var xe = Ie.length < 0 ? 0 : oe(Ie.length) | 0, ke = P3(xe), vt = 0; vt < xe; vt += 1) ke[vt] = Ie[vt] & 255;\n                  return ke;\n                }\n                function N2(Ie) {\n                  if (Ge(Ie, Uint8Array)) {\n                    var xe = new Uint8Array(Ie);\n                    return H(xe.buffer, xe.byteOffset, xe.byteLength);\n                  }\n                  return j3(Ie);\n                }\n                function H(Ie, xe, ke) {\n                  if (xe < 0 || Ie.byteLength < xe) throw new RangeError(\'"offset" is outside of buffer bounds\');\n                  if (Ie.byteLength < xe + (ke || 0)) throw new RangeError(\'"length" is outside of buffer bounds\');\n                  var vt;\n                  return xe === void 0 && ke === void 0 ? vt = new Uint8Array(Ie) : ke === void 0 ? vt = new Uint8Array(Ie, xe) : vt = new Uint8Array(Ie, xe, ke), Object.setPrototypeOf(vt, T3.prototype), vt;\n                }\n                function te(Ie) {\n                  if (T3.isBuffer(Ie)) {\n                    var xe = oe(Ie.length) | 0, ke = P3(xe);\n                    return ke.length === 0 || Ie.copy(ke, 0, 0, xe), ke;\n                  }\n                  if (Ie.length !== void 0) return typeof Ie.length != "number" || Je(Ie.length) ? P3(0) : j3(Ie);\n                  if (Ie.type === "Buffer" && Array.isArray(Ie.data)) return j3(Ie.data);\n                }\n                function oe(Ie) {\n                  if (Ie >= M4) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + M4.toString(16) + " bytes");\n                  return Ie | 0;\n                }\n                function _e(Ie) {\n                  return +Ie != Ie && (Ie = 0), T3.alloc(+Ie);\n                }\n                T3.isBuffer = function(xe) {\n                  return xe != null && xe._isBuffer === true && xe !== T3.prototype;\n                }, T3.compare = function(xe, ke) {\n                  if (Ge(xe, Uint8Array) && (xe = T3.from(xe, xe.offset, xe.byteLength)), Ge(ke, Uint8Array) && (ke = T3.from(ke, ke.offset, ke.byteLength)), !T3.isBuffer(xe) || !T3.isBuffer(ke)) throw new TypeError(\'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array\');\n                  if (xe === ke) return 0;\n                  for (var vt = xe.length, ir = ke.length, ar = 0, vr = Math.min(vt, ir); ar < vr; ++ar) if (xe[ar] !== ke[ar]) {\n                    vt = xe[ar], ir = ke[ar];\n                    break;\n                  }\n                  return vt < ir ? -1 : ir < vt ? 1 : 0;\n                }, T3.isEncoding = function(xe) {\n                  switch (String(xe).toLowerCase()) {\n                    case "hex":\n                    case "utf8":\n                    case "utf-8":\n                    case "ascii":\n                    case "latin1":\n                    case "binary":\n                    case "base64":\n                    case "ucs2":\n                    case "ucs-2":\n                    case "utf16le":\n                    case "utf-16le":\n                      return true;\n                    default:\n                      return false;\n                  }\n                }, T3.concat = function(xe, ke) {\n                  if (!Array.isArray(xe)) throw new TypeError(\'"list" argument must be an Array of Buffers\');\n                  if (xe.length === 0) return T3.alloc(0);\n                  var vt;\n                  if (ke === void 0) for (ke = 0, vt = 0; vt < xe.length; ++vt) ke += xe[vt].length;\n                  var ir = T3.allocUnsafe(ke), ar = 0;\n                  for (vt = 0; vt < xe.length; ++vt) {\n                    var vr = xe[vt];\n                    if (Ge(vr, Uint8Array)) ar + vr.length > ir.length ? (T3.isBuffer(vr) || (vr = T3.from(vr)), vr.copy(ir, ar)) : Uint8Array.prototype.set.call(ir, vr, ar);\n                    else if (T3.isBuffer(vr)) vr.copy(ir, ar);\n                    else throw new TypeError(\'"list" argument must be an Array of Buffers\');\n                    ar += vr.length;\n                  }\n                  return ir;\n                };\n                function Ee(Ie, xe) {\n                  if (T3.isBuffer(Ie)) return Ie.length;\n                  if (ArrayBuffer.isView(Ie) || Ge(Ie, ArrayBuffer)) return Ie.byteLength;\n                  if (typeof Ie != "string") throw new TypeError(\'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type \' + S2(Ie));\n                  var ke = Ie.length, vt = arguments.length > 2 && arguments[2] === true;\n                  if (!vt && ke === 0) return 0;\n                  for (var ir = false; ; ) switch (xe) {\n                    case "ascii":\n                    case "latin1":\n                    case "binary":\n                      return ke;\n                    case "utf8":\n                    case "utf-8":\n                      return Lr(Ie).length;\n                    case "ucs2":\n                    case "ucs-2":\n                    case "utf16le":\n                    case "utf-16le":\n                      return ke * 2;\n                    case "hex":\n                      return ke >>> 1;\n                    case "base64":\n                      return Vr(Ie).length;\n                    default:\n                      if (ir) return vt ? -1 : Lr(Ie).length;\n                      xe = ("" + xe).toLowerCase(), ir = true;\n                  }\n                }\n                T3.byteLength = Ee;\n                function Ce(Ie, xe, ke) {\n                  var vt = false;\n                  if ((xe === void 0 || xe < 0) && (xe = 0), xe > this.length || ((ke === void 0 || ke > this.length) && (ke = this.length), ke <= 0) || (ke >>>= 0, xe >>>= 0, ke <= xe)) return "";\n                  for (Ie || (Ie = "utf8"); ; ) switch (Ie) {\n                    case "hex":\n                      return st(this, xe, ke);\n                    case "utf8":\n                    case "utf-8":\n                      return ce(this, xe, ke);\n                    case "ascii":\n                      return pt(this, xe, ke);\n                    case "latin1":\n                    case "binary":\n                      return Zt(this, xe, ke);\n                    case "base64":\n                      return Re(this, xe, ke);\n                    case "ucs2":\n                    case "ucs-2":\n                    case "utf16le":\n                    case "utf-16le":\n                      return lt(this, xe, ke);\n                    default:\n                      if (vt) throw new TypeError("Unknown encoding: " + Ie);\n                      Ie = (Ie + "").toLowerCase(), vt = true;\n                  }\n                }\n                T3.prototype._isBuffer = true;\n                function me(Ie, xe, ke) {\n                  var vt = Ie[xe];\n                  Ie[xe] = Ie[ke], Ie[ke] = vt;\n                }\n                T3.prototype.swap16 = function() {\n                  var xe = this.length;\n                  if (xe % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");\n                  for (var ke = 0; ke < xe; ke += 2) me(this, ke, ke + 1);\n                  return this;\n                }, T3.prototype.swap32 = function() {\n                  var xe = this.length;\n                  if (xe % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");\n                  for (var ke = 0; ke < xe; ke += 4) me(this, ke, ke + 3), me(this, ke + 1, ke + 2);\n                  return this;\n                }, T3.prototype.swap64 = function() {\n                  var xe = this.length;\n                  if (xe % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");\n                  for (var ke = 0; ke < xe; ke += 8) me(this, ke, ke + 7), me(this, ke + 1, ke + 6), me(this, ke + 2, ke + 5), me(this, ke + 3, ke + 4);\n                  return this;\n                }, T3.prototype.toString = function() {\n                  var xe = this.length;\n                  return xe === 0 ? "" : arguments.length === 0 ? ce(this, 0, xe) : Ce.apply(this, arguments);\n                }, T3.prototype.toLocaleString = T3.prototype.toString, T3.prototype.equals = function(xe) {\n                  if (!T3.isBuffer(xe)) throw new TypeError("Argument must be a Buffer");\n                  return this === xe ? true : T3.compare(this, xe) === 0;\n                }, T3.prototype.inspect = function() {\n                  var xe = "", ke = a4.IS;\n                  return xe = this.toString("hex", 0, ke).replace(/(.{2})/g, "$1 ").trim(), this.length > ke && (xe += " ... "), "<Buffer " + xe + ">";\n                }, C3 && (T3.prototype[C3] = T3.prototype.inspect), T3.prototype.compare = function(xe, ke, vt, ir, ar) {\n                  if (Ge(xe, Uint8Array) && (xe = T3.from(xe, xe.offset, xe.byteLength)), !T3.isBuffer(xe)) throw new TypeError(\'The "target" argument must be one of type Buffer or Uint8Array. Received type \' + S2(xe));\n                  if (ke === void 0 && (ke = 0), vt === void 0 && (vt = xe ? xe.length : 0), ir === void 0 && (ir = 0), ar === void 0 && (ar = this.length), ke < 0 || vt > xe.length || ir < 0 || ar > this.length) throw new RangeError("out of range index");\n                  if (ir >= ar && ke >= vt) return 0;\n                  if (ir >= ar) return -1;\n                  if (ke >= vt) return 1;\n                  if (ke >>>= 0, vt >>>= 0, ir >>>= 0, ar >>>= 0, this === xe) return 0;\n                  for (var vr = ar - ir, ii = vt - ke, pi = Math.min(vr, ii), $r = this.slice(ir, ar), di = xe.slice(ke, vt), ji = 0; ji < pi; ++ji) if ($r[ji] !== di[ji]) {\n                    vr = $r[ji], ii = di[ji];\n                    break;\n                  }\n                  return vr < ii ? -1 : ii < vr ? 1 : 0;\n                };\n                function ie(Ie, xe, ke, vt, ir) {\n                  if (Ie.length === 0) return -1;\n                  if (typeof ke == "string" ? (vt = ke, ke = 0) : ke > 2147483647 ? ke = 2147483647 : ke < -2147483648 && (ke = -2147483648), ke = +ke, Je(ke) && (ke = ir ? 0 : Ie.length - 1), ke < 0 && (ke = Ie.length + ke), ke >= Ie.length) {\n                    if (ir) return -1;\n                    ke = Ie.length - 1;\n                  } else if (ke < 0) if (ir) ke = 0;\n                  else return -1;\n                  if (typeof xe == "string" && (xe = T3.from(xe, vt)), T3.isBuffer(xe)) return xe.length === 0 ? -1 : Se(Ie, xe, ke, vt, ir);\n                  if (typeof xe == "number") return xe = xe & 255, typeof Uint8Array.prototype.indexOf == "function" ? ir ? Uint8Array.prototype.indexOf.call(Ie, xe, ke) : Uint8Array.prototype.lastIndexOf.call(Ie, xe, ke) : Se(Ie, [xe], ke, vt, ir);\n                  throw new TypeError("val must be string, number or Buffer");\n                }\n                function Se(Ie, xe, ke, vt, ir) {\n                  var ar = 1, vr = Ie.length, ii = xe.length;\n                  if (vt !== void 0 && (vt = String(vt).toLowerCase(), vt === "ucs2" || vt === "ucs-2" || vt === "utf16le" || vt === "utf-16le")) {\n                    if (Ie.length < 2 || xe.length < 2) return -1;\n                    ar = 2, vr /= 2, ii /= 2, ke /= 2;\n                  }\n                  function pi(wi, On) {\n                    return ar === 1 ? wi[On] : wi.readUInt16BE(On * ar);\n                  }\n                  var $r;\n                  if (ir) {\n                    var di = -1;\n                    for ($r = ke; $r < vr; $r++) if (pi(Ie, $r) === pi(xe, di === -1 ? 0 : $r - di)) {\n                      if (di === -1 && (di = $r), $r - di + 1 === ii) return di * ar;\n                    } else di !== -1 && ($r -= $r - di), di = -1;\n                  } else for (ke + ii > vr && (ke = vr - ii), $r = ke; $r >= 0; $r--) {\n                    for (var ji = true, In = 0; In < ii; In++) if (pi(Ie, $r + In) !== pi(xe, In)) {\n                      ji = false;\n                      break;\n                    }\n                    if (ji) return $r;\n                  }\n                  return -1;\n                }\n                T3.prototype.includes = function(xe, ke, vt) {\n                  return this.indexOf(xe, ke, vt) !== -1;\n                }, T3.prototype.indexOf = function(xe, ke, vt) {\n                  return ie(this, xe, ke, vt, true);\n                }, T3.prototype.lastIndexOf = function(xe, ke, vt) {\n                  return ie(this, xe, ke, vt, false);\n                };\n                function Le(Ie, xe, ke, vt) {\n                  ke = Number(ke) || 0;\n                  var ir = Ie.length - ke;\n                  vt ? (vt = Number(vt), vt > ir && (vt = ir)) : vt = ir;\n                  var ar = xe.length;\n                  vt > ar / 2 && (vt = ar / 2);\n                  var vr;\n                  for (vr = 0; vr < vt; ++vr) {\n                    var ii = parseInt(xe.substr(vr * 2, 2), 16);\n                    if (Je(ii)) return vr;\n                    Ie[ke + vr] = ii;\n                  }\n                  return vr;\n                }\n                function Ae(Ie, xe, ke, vt) {\n                  return dt(Lr(xe, Ie.length - ke), Ie, ke, vt);\n                }\n                function Fe(Ie, xe, ke, vt) {\n                  return dt(ti(xe), Ie, ke, vt);\n                }\n                function Pe(Ie, xe, ke, vt) {\n                  return dt(Vr(xe), Ie, ke, vt);\n                }\n                function ge(Ie, xe, ke, vt) {\n                  return dt(Br(xe, Ie.length - ke), Ie, ke, vt);\n                }\n                T3.prototype.write = function(xe, ke, vt, ir) {\n                  if (ke === void 0) ir = "utf8", vt = this.length, ke = 0;\n                  else if (vt === void 0 && typeof ke == "string") ir = ke, vt = this.length, ke = 0;\n                  else if (isFinite(ke)) ke = ke >>> 0, isFinite(vt) ? (vt = vt >>> 0, ir === void 0 && (ir = "utf8")) : (ir = vt, vt = void 0);\n                  else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");\n                  var ar = this.length - ke;\n                  if ((vt === void 0 || vt > ar) && (vt = ar), xe.length > 0 && (vt < 0 || ke < 0) || ke > this.length) throw new RangeError("Attempt to write outside buffer bounds");\n                  ir || (ir = "utf8");\n                  for (var vr = false; ; ) switch (ir) {\n                    case "hex":\n                      return Le(this, xe, ke, vt);\n                    case "utf8":\n                    case "utf-8":\n                      return Ae(this, xe, ke, vt);\n                    case "ascii":\n                    case "latin1":\n                    case "binary":\n                      return Fe(this, xe, ke, vt);\n                    case "base64":\n                      return Pe(this, xe, ke, vt);\n                    case "ucs2":\n                    case "ucs-2":\n                    case "utf16le":\n                    case "utf-16le":\n                      return ge(this, xe, ke, vt);\n                    default:\n                      if (vr) throw new TypeError("Unknown encoding: " + ir);\n                      ir = ("" + ir).toLowerCase(), vr = true;\n                  }\n                }, T3.prototype.toJSON = function() {\n                  return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };\n                };\n                function Re(Ie, xe, ke) {\n                  return xe === 0 && ke === Ie.length ? L3.fromByteArray(Ie) : L3.fromByteArray(Ie.slice(xe, ke));\n                }\n                function ce(Ie, xe, ke) {\n                  ke = Math.min(Ie.length, ke);\n                  for (var vt = [], ir = xe; ir < ke; ) {\n                    var ar = Ie[ir], vr = null, ii = ar > 239 ? 4 : ar > 223 ? 3 : ar > 191 ? 2 : 1;\n                    if (ir + ii <= ke) {\n                      var pi = void 0, $r = void 0, di = void 0, ji = void 0;\n                      switch (ii) {\n                        case 1:\n                          ar < 128 && (vr = ar);\n                          break;\n                        case 2:\n                          pi = Ie[ir + 1], (pi & 192) === 128 && (ji = (ar & 31) << 6 | pi & 63, ji > 127 && (vr = ji));\n                          break;\n                        case 3:\n                          pi = Ie[ir + 1], $r = Ie[ir + 2], (pi & 192) === 128 && ($r & 192) === 128 && (ji = (ar & 15) << 12 | (pi & 63) << 6 | $r & 63, ji > 2047 && (ji < 55296 || ji > 57343) && (vr = ji));\n                          break;\n                        case 4:\n                          pi = Ie[ir + 1], $r = Ie[ir + 2], di = Ie[ir + 3], (pi & 192) === 128 && ($r & 192) === 128 && (di & 192) === 128 && (ji = (ar & 15) << 18 | (pi & 63) << 12 | ($r & 63) << 6 | di & 63, ji > 65535 && ji < 1114112 && (vr = ji));\n                      }\n                    }\n                    vr === null ? (vr = 65533, ii = 1) : vr > 65535 && (vr -= 65536, vt.push(vr >>> 10 & 1023 | 55296), vr = 56320 | vr & 1023), vt.push(vr), ir += ii;\n                  }\n                  return ut(vt);\n                }\n                var Ze = 4096;\n                function ut(Ie) {\n                  var xe = Ie.length;\n                  if (xe <= Ze) return String.fromCharCode.apply(String, Ie);\n                  for (var ke = "", vt = 0; vt < xe; ) ke += String.fromCharCode.apply(String, Ie.slice(vt, vt += Ze));\n                  return ke;\n                }\n                function pt(Ie, xe, ke) {\n                  var vt = "";\n                  ke = Math.min(Ie.length, ke);\n                  for (var ir = xe; ir < ke; ++ir) vt += String.fromCharCode(Ie[ir] & 127);\n                  return vt;\n                }\n                function Zt(Ie, xe, ke) {\n                  var vt = "";\n                  ke = Math.min(Ie.length, ke);\n                  for (var ir = xe; ir < ke; ++ir) vt += String.fromCharCode(Ie[ir]);\n                  return vt;\n                }\n                function st(Ie, xe, ke) {\n                  var vt = Ie.length;\n                  (!xe || xe < 0) && (xe = 0), (!ke || ke < 0 || ke > vt) && (ke = vt);\n                  for (var ir = "", ar = xe; ar < ke; ++ar) ir += je[Ie[ar]];\n                  return ir;\n                }\n                function lt(Ie, xe, ke) {\n                  for (var vt = Ie.slice(xe, ke), ir = "", ar = 0; ar < vt.length - 1; ar += 2) ir += String.fromCharCode(vt[ar] + vt[ar + 1] * 256);\n                  return ir;\n                }\n                T3.prototype.slice = function(xe, ke) {\n                  var vt = this.length;\n                  xe = ~~xe, ke = ke === void 0 ? vt : ~~ke, xe < 0 ? (xe += vt, xe < 0 && (xe = 0)) : xe > vt && (xe = vt), ke < 0 ? (ke += vt, ke < 0 && (ke = 0)) : ke > vt && (ke = vt), ke < xe && (ke = xe);\n                  var ir = this.subarray(xe, ke);\n                  return Object.setPrototypeOf(ir, T3.prototype), ir;\n                };\n                function Gt(Ie, xe, ke) {\n                  if (Ie % 1 !== 0 || Ie < 0) throw new RangeError("offset is not uint");\n                  if (Ie + xe > ke) throw new RangeError("Trying to access beyond buffer length");\n                }\n                T3.prototype.readUintLE = T3.prototype.readUIntLE = function(xe, ke, vt) {\n                  xe = xe >>> 0, ke = ke >>> 0, vt || Gt(xe, ke, this.length);\n                  for (var ir = this[xe], ar = 1, vr = 0; ++vr < ke && (ar *= 256); ) ir += this[xe + vr] * ar;\n                  return ir;\n                }, T3.prototype.readUintBE = T3.prototype.readUIntBE = function(xe, ke, vt) {\n                  xe = xe >>> 0, ke = ke >>> 0, vt || Gt(xe, ke, this.length);\n                  for (var ir = this[xe + --ke], ar = 1; ke > 0 && (ar *= 256); ) ir += this[xe + --ke] * ar;\n                  return ir;\n                }, T3.prototype.readUint8 = T3.prototype.readUInt8 = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 1, this.length), this[xe];\n                }, T3.prototype.readUint16LE = T3.prototype.readUInt16LE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 2, this.length), this[xe] | this[xe + 1] << 8;\n                }, T3.prototype.readUint16BE = T3.prototype.readUInt16BE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 2, this.length), this[xe] << 8 | this[xe + 1];\n                }, T3.prototype.readUint32LE = T3.prototype.readUInt32LE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), (this[xe] | this[xe + 1] << 8 | this[xe + 2] << 16) + this[xe + 3] * 16777216;\n                }, T3.prototype.readUint32BE = T3.prototype.readUInt32BE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), this[xe] * 16777216 + (this[xe + 1] << 16 | this[xe + 2] << 8 | this[xe + 3]);\n                }, T3.prototype.readBigUInt64LE = tt(function(xe) {\n                  xe = xe >>> 0, mt(xe, "offset");\n                  var ke = this[xe], vt = this[xe + 7];\n                  (ke === void 0 || vt === void 0) && er(xe, this.length - 8);\n                  var ir = ke + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 24), ar = this[++xe] + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + vt * Math.pow(2, 24);\n                  return BigInt(ir) + (BigInt(ar) << BigInt(32));\n                }), T3.prototype.readBigUInt64BE = tt(function(xe) {\n                  xe = xe >>> 0, mt(xe, "offset");\n                  var ke = this[xe], vt = this[xe + 7];\n                  (ke === void 0 || vt === void 0) && er(xe, this.length - 8);\n                  var ir = ke * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + this[++xe], ar = this[++xe] * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + vt;\n                  return (BigInt(ir) << BigInt(32)) + BigInt(ar);\n                }), T3.prototype.readIntLE = function(xe, ke, vt) {\n                  xe = xe >>> 0, ke = ke >>> 0, vt || Gt(xe, ke, this.length);\n                  for (var ir = this[xe], ar = 1, vr = 0; ++vr < ke && (ar *= 256); ) ir += this[xe + vr] * ar;\n                  return ar *= 128, ir >= ar && (ir -= Math.pow(2, 8 * ke)), ir;\n                }, T3.prototype.readIntBE = function(xe, ke, vt) {\n                  xe = xe >>> 0, ke = ke >>> 0, vt || Gt(xe, ke, this.length);\n                  for (var ir = ke, ar = 1, vr = this[xe + --ir]; ir > 0 && (ar *= 256); ) vr += this[xe + --ir] * ar;\n                  return ar *= 128, vr >= ar && (vr -= Math.pow(2, 8 * ke)), vr;\n                }, T3.prototype.readInt8 = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 1, this.length), this[xe] & 128 ? (255 - this[xe] + 1) * -1 : this[xe];\n                }, T3.prototype.readInt16LE = function(xe, ke) {\n                  xe = xe >>> 0, ke || Gt(xe, 2, this.length);\n                  var vt = this[xe] | this[xe + 1] << 8;\n                  return vt & 32768 ? vt | 4294901760 : vt;\n                }, T3.prototype.readInt16BE = function(xe, ke) {\n                  xe = xe >>> 0, ke || Gt(xe, 2, this.length);\n                  var vt = this[xe + 1] | this[xe] << 8;\n                  return vt & 32768 ? vt | 4294901760 : vt;\n                }, T3.prototype.readInt32LE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), this[xe] | this[xe + 1] << 8 | this[xe + 2] << 16 | this[xe + 3] << 24;\n                }, T3.prototype.readInt32BE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), this[xe] << 24 | this[xe + 1] << 16 | this[xe + 2] << 8 | this[xe + 3];\n                }, T3.prototype.readBigInt64LE = tt(function(xe) {\n                  xe = xe >>> 0, mt(xe, "offset");\n                  var ke = this[xe], vt = this[xe + 7];\n                  (ke === void 0 || vt === void 0) && er(xe, this.length - 8);\n                  var ir = this[xe + 4] + this[xe + 5] * Math.pow(2, 8) + this[xe + 6] * Math.pow(2, 16) + (vt << 24);\n                  return (BigInt(ir) << BigInt(32)) + BigInt(ke + this[++xe] * Math.pow(2, 8) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 24));\n                }), T3.prototype.readBigInt64BE = tt(function(xe) {\n                  xe = xe >>> 0, mt(xe, "offset");\n                  var ke = this[xe], vt = this[xe + 7];\n                  (ke === void 0 || vt === void 0) && er(xe, this.length - 8);\n                  var ir = (ke << 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + this[++xe];\n                  return (BigInt(ir) << BigInt(32)) + BigInt(this[++xe] * Math.pow(2, 24) + this[++xe] * Math.pow(2, 16) + this[++xe] * Math.pow(2, 8) + vt);\n                }), T3.prototype.readFloatLE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), x2.read(this, xe, true, 23, 4);\n                }, T3.prototype.readFloatBE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 4, this.length), x2.read(this, xe, false, 23, 4);\n                }, T3.prototype.readDoubleLE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 8, this.length), x2.read(this, xe, true, 52, 8);\n                }, T3.prototype.readDoubleBE = function(xe, ke) {\n                  return xe = xe >>> 0, ke || Gt(xe, 8, this.length), x2.read(this, xe, false, 52, 8);\n                };\n                function Nt(Ie, xe, ke, vt, ir, ar) {\n                  if (!T3.isBuffer(Ie)) throw new TypeError(\'"buffer" argument must be a Buffer instance\');\n                  if (xe > ir || xe < ar) throw new RangeError(\'"value" argument is out of bounds\');\n                  if (ke + vt > Ie.length) throw new RangeError("Index out of range");\n                }\n                T3.prototype.writeUintLE = T3.prototype.writeUIntLE = function(xe, ke, vt, ir) {\n                  if (xe = +xe, ke = ke >>> 0, vt = vt >>> 0, !ir) {\n                    var ar = Math.pow(2, 8 * vt) - 1;\n                    Nt(this, xe, ke, vt, ar, 0);\n                  }\n                  var vr = 1, ii = 0;\n                  for (this[ke] = xe & 255; ++ii < vt && (vr *= 256); ) this[ke + ii] = xe / vr & 255;\n                  return ke + vt;\n                }, T3.prototype.writeUintBE = T3.prototype.writeUIntBE = function(xe, ke, vt, ir) {\n                  if (xe = +xe, ke = ke >>> 0, vt = vt >>> 0, !ir) {\n                    var ar = Math.pow(2, 8 * vt) - 1;\n                    Nt(this, xe, ke, vt, ar, 0);\n                  }\n                  var vr = vt - 1, ii = 1;\n                  for (this[ke + vr] = xe & 255; --vr >= 0 && (ii *= 256); ) this[ke + vr] = xe / ii & 255;\n                  return ke + vt;\n                }, T3.prototype.writeUint8 = T3.prototype.writeUInt8 = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 1, 255, 0), this[ke] = xe & 255, ke + 1;\n                }, T3.prototype.writeUint16LE = T3.prototype.writeUInt16LE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 65535, 0), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, ke + 2;\n                }, T3.prototype.writeUint16BE = T3.prototype.writeUInt16BE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 65535, 0), this[ke] = xe >>> 8, this[ke + 1] = xe & 255, ke + 2;\n                }, T3.prototype.writeUint32LE = T3.prototype.writeUInt32LE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 4294967295, 0), this[ke + 3] = xe >>> 24, this[ke + 2] = xe >>> 16, this[ke + 1] = xe >>> 8, this[ke] = xe & 255, ke + 4;\n                }, T3.prototype.writeUint32BE = T3.prototype.writeUInt32BE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 4294967295, 0), this[ke] = xe >>> 24, this[ke + 1] = xe >>> 16, this[ke + 2] = xe >>> 8, this[ke + 3] = xe & 255, ke + 4;\n                };\n                function Jt(Ie, xe, ke, vt, ir) {\n                  It(xe, vt, ir, Ie, ke, 7);\n                  var ar = Number(xe & BigInt(4294967295));\n                  Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar, ar = ar >> 8, Ie[ke++] = ar;\n                  var vr = Number(xe >> BigInt(32) & BigInt(4294967295));\n                  return Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, vr = vr >> 8, Ie[ke++] = vr, ke;\n                }\n                function sr(Ie, xe, ke, vt, ir) {\n                  It(xe, vt, ir, Ie, ke, 7);\n                  var ar = Number(xe & BigInt(4294967295));\n                  Ie[ke + 7] = ar, ar = ar >> 8, Ie[ke + 6] = ar, ar = ar >> 8, Ie[ke + 5] = ar, ar = ar >> 8, Ie[ke + 4] = ar;\n                  var vr = Number(xe >> BigInt(32) & BigInt(4294967295));\n                  return Ie[ke + 3] = vr, vr = vr >> 8, Ie[ke + 2] = vr, vr = vr >> 8, Ie[ke + 1] = vr, vr = vr >> 8, Ie[ke] = vr, ke + 8;\n                }\n                T3.prototype.writeBigUInt64LE = tt(function(xe) {\n                  var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;\n                  return Jt(this, xe, ke, BigInt(0), BigInt("0xffffffffffffffff"));\n                }), T3.prototype.writeBigUInt64BE = tt(function(xe) {\n                  var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;\n                  return sr(this, xe, ke, BigInt(0), BigInt("0xffffffffffffffff"));\n                }), T3.prototype.writeIntLE = function(xe, ke, vt, ir) {\n                  if (xe = +xe, ke = ke >>> 0, !ir) {\n                    var ar = Math.pow(2, 8 * vt - 1);\n                    Nt(this, xe, ke, vt, ar - 1, -ar);\n                  }\n                  var vr = 0, ii = 1, pi = 0;\n                  for (this[ke] = xe & 255; ++vr < vt && (ii *= 256); ) xe < 0 && pi === 0 && this[ke + vr - 1] !== 0 && (pi = 1), this[ke + vr] = (xe / ii >> 0) - pi & 255;\n                  return ke + vt;\n                }, T3.prototype.writeIntBE = function(xe, ke, vt, ir) {\n                  if (xe = +xe, ke = ke >>> 0, !ir) {\n                    var ar = Math.pow(2, 8 * vt - 1);\n                    Nt(this, xe, ke, vt, ar - 1, -ar);\n                  }\n                  var vr = vt - 1, ii = 1, pi = 0;\n                  for (this[ke + vr] = xe & 255; --vr >= 0 && (ii *= 256); ) xe < 0 && pi === 0 && this[ke + vr + 1] !== 0 && (pi = 1), this[ke + vr] = (xe / ii >> 0) - pi & 255;\n                  return ke + vt;\n                }, T3.prototype.writeInt8 = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 1, 127, -128), xe < 0 && (xe = 255 + xe + 1), this[ke] = xe & 255, ke + 1;\n                }, T3.prototype.writeInt16LE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 32767, -32768), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, ke + 2;\n                }, T3.prototype.writeInt16BE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 2, 32767, -32768), this[ke] = xe >>> 8, this[ke + 1] = xe & 255, ke + 2;\n                }, T3.prototype.writeInt32LE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 2147483647, -2147483648), this[ke] = xe & 255, this[ke + 1] = xe >>> 8, this[ke + 2] = xe >>> 16, this[ke + 3] = xe >>> 24, ke + 4;\n                }, T3.prototype.writeInt32BE = function(xe, ke, vt) {\n                  return xe = +xe, ke = ke >>> 0, vt || Nt(this, xe, ke, 4, 2147483647, -2147483648), xe < 0 && (xe = 4294967295 + xe + 1), this[ke] = xe >>> 24, this[ke + 1] = xe >>> 16, this[ke + 2] = xe >>> 8, this[ke + 3] = xe & 255, ke + 4;\n                }, T3.prototype.writeBigInt64LE = tt(function(xe) {\n                  var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;\n                  return Jt(this, xe, ke, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n                }), T3.prototype.writeBigInt64BE = tt(function(xe) {\n                  var ke = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;\n                  return sr(this, xe, ke, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));\n                });\n                function wr(Ie, xe, ke, vt, ir, ar) {\n                  if (ke + vt > Ie.length) throw new RangeError("Index out of range");\n                  if (ke < 0) throw new RangeError("Index out of range");\n                }\n                function cr(Ie, xe, ke, vt, ir) {\n                  return xe = +xe, ke = ke >>> 0, ir || wr(Ie, xe, ke, 4, 34028234663852886e22, -34028234663852886e22), x2.write(Ie, xe, ke, vt, 23, 4), ke + 4;\n                }\n                T3.prototype.writeFloatLE = function(xe, ke, vt) {\n                  return cr(this, xe, ke, true, vt);\n                }, T3.prototype.writeFloatBE = function(xe, ke, vt) {\n                  return cr(this, xe, ke, false, vt);\n                };\n                function $e(Ie, xe, ke, vt, ir) {\n                  return xe = +xe, ke = ke >>> 0, ir || wr(Ie, xe, ke, 8, 17976931348623157e292, -17976931348623157e292), x2.write(Ie, xe, ke, vt, 52, 8), ke + 8;\n                }\n                T3.prototype.writeDoubleLE = function(xe, ke, vt) {\n                  return $e(this, xe, ke, true, vt);\n                }, T3.prototype.writeDoubleBE = function(xe, ke, vt) {\n                  return $e(this, xe, ke, false, vt);\n                }, T3.prototype.copy = function(xe, ke, vt, ir) {\n                  if (!T3.isBuffer(xe)) throw new TypeError("argument should be a Buffer");\n                  if (vt || (vt = 0), !ir && ir !== 0 && (ir = this.length), ke >= xe.length && (ke = xe.length), ke || (ke = 0), ir > 0 && ir < vt && (ir = vt), ir === vt || xe.length === 0 || this.length === 0) return 0;\n                  if (ke < 0) throw new RangeError("targetStart out of bounds");\n                  if (vt < 0 || vt >= this.length) throw new RangeError("Index out of range");\n                  if (ir < 0) throw new RangeError("sourceEnd out of bounds");\n                  ir > this.length && (ir = this.length), xe.length - ke < ir - vt && (ir = xe.length - ke + vt);\n                  var ar = ir - vt;\n                  return this === xe && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(ke, vt, ir) : Uint8Array.prototype.set.call(xe, this.subarray(vt, ir), ke), ar;\n                }, T3.prototype.fill = function(xe, ke, vt, ir) {\n                  if (typeof xe == "string") {\n                    if (typeof ke == "string" ? (ir = ke, ke = 0, vt = this.length) : typeof vt == "string" && (ir = vt, vt = this.length), ir !== void 0 && typeof ir != "string") throw new TypeError("encoding must be a string");\n                    if (typeof ir == "string" && !T3.isEncoding(ir)) throw new TypeError("Unknown encoding: " + ir);\n                    if (xe.length === 1) {\n                      var ar = xe.charCodeAt(0);\n                      (ir === "utf8" && ar < 128 || ir === "latin1") && (xe = ar);\n                    }\n                  } else typeof xe == "number" ? xe = xe & 255 : typeof xe == "boolean" && (xe = Number(xe));\n                  if (ke < 0 || this.length < ke || this.length < vt) throw new RangeError("Out of range index");\n                  if (vt <= ke) return this;\n                  ke = ke >>> 0, vt = vt === void 0 ? this.length : vt >>> 0, xe || (xe = 0);\n                  var vr;\n                  if (typeof xe == "number") for (vr = ke; vr < vt; ++vr) this[vr] = xe;\n                  else {\n                    var ii = T3.isBuffer(xe) ? xe : T3.from(xe, ir), pi = ii.length;\n                    if (pi === 0) throw new TypeError(\'The value "\' + xe + \'" is invalid for argument "value"\');\n                    for (vr = 0; vr < vt - ke; ++vr) this[vr + ke] = ii[vr % pi];\n                  }\n                  return this;\n                };\n                var St = {};\n                function Qt(Ie, xe, ke) {\n                  St[Ie] = (function(vt) {\n                    function ir() {\n                      var ar;\n                      return l3(this, ir), ar = d3(this, ir), Object.defineProperty(ar, "message", { value: xe.apply(ar, arguments), writable: true, configurable: true }), ar.name = "".concat(ar.name, " [").concat(Ie, "]"), ar.stack, delete ar.name, ar;\n                    }\n                    return k4(ir, vt), c5(ir, [{ key: "code", get: function() {\n                      return Ie;\n                    }, set: function(vr) {\n                      Object.defineProperty(this, "code", { configurable: true, enumerable: true, value: vr, writable: true });\n                    } }, { key: "toString", value: function() {\n                      return "".concat(this.name, " [").concat(Ie, "]: ").concat(this.message);\n                    } }]);\n                  })(ke);\n                }\n                Qt("ERR_BUFFER_OUT_OF_BOUNDS", function(Ie) {\n                  return Ie ? "".concat(Ie, " is outside of buffer bounds") : "Attempt to access memory outside buffer bounds";\n                }, RangeError), Qt("ERR_INVALID_ARG_TYPE", function(Ie, xe) {\n                  return \'The "\'.concat(Ie, \'" argument must be of type number. Received type \').concat(S2(xe));\n                }, TypeError), Qt("ERR_OUT_OF_RANGE", function(Ie, xe, ke) {\n                  var vt = \'The value of "\'.concat(Ie, \'" is out of range.\'), ir = ke;\n                  return Number.isInteger(ke) && Math.abs(ke) > Math.pow(2, 32) ? ir = Vt(String(ke)) : typeof ke == "bigint" && (ir = String(ke), (ke > Math.pow(BigInt(2), BigInt(32)) || ke < -Math.pow(BigInt(2), BigInt(32))) && (ir = Vt(ir)), ir += "n"), vt += " It must be ".concat(xe, ". Received ").concat(ir), vt;\n                }, RangeError);\n                function Vt(Ie) {\n                  for (var xe = "", ke = Ie.length, vt = Ie[0] === "-" ? 1 : 0; ke >= vt + 4; ke -= 3) xe = "_".concat(Ie.slice(ke - 3, ke)).concat(xe);\n                  return "".concat(Ie.slice(0, ke)).concat(xe);\n                }\n                function _t(Ie, xe, ke) {\n                  mt(xe, "offset"), (Ie[xe] === void 0 || Ie[xe + ke] === void 0) && er(xe, Ie.length - (ke + 1));\n                }\n                function It(Ie, xe, ke, vt, ir, ar) {\n                  if (Ie > ke || Ie < xe) {\n                    var vr = typeof xe == "bigint" ? "n" : "", ii;\n                    throw ar > 3 ? xe === 0 || xe === BigInt(0) ? ii = ">= 0".concat(vr, " and < 2").concat(vr, " ** ").concat((ar + 1) * 8).concat(vr) : ii = ">= -(2".concat(vr, " ** ").concat((ar + 1) * 8 - 1).concat(vr, ") and < 2 ** ") + "".concat((ar + 1) * 8 - 1).concat(vr) : ii = ">= ".concat(xe).concat(vr, " and <= ").concat(ke).concat(vr), new St.ERR_OUT_OF_RANGE("value", ii, Ie);\n                  }\n                  _t(vt, ir, ar);\n                }\n                function mt(Ie, xe) {\n                  if (typeof Ie != "number") throw new St.ERR_INVALID_ARG_TYPE(xe, "number", Ie);\n                }\n                function er(Ie, xe, ke) {\n                  throw Math.floor(Ie) !== Ie ? (mt(Ie, ke), new St.ERR_OUT_OF_RANGE(ke || "offset", "an integer", Ie)) : xe < 0 ? new St.ERR_BUFFER_OUT_OF_BOUNDS() : new St.ERR_OUT_OF_RANGE(ke || "offset", ">= ".concat(ke ? 1 : 0, " and <= ").concat(xe), Ie);\n                }\n                var lr = /[^+/0-9A-Za-z-_]/g;\n                function Tr(Ie) {\n                  if (Ie = Ie.split("=")[0], Ie = Ie.trim().replace(lr, ""), Ie.length < 2) return "";\n                  for (; Ie.length % 4 !== 0; ) Ie = Ie + "=";\n                  return Ie;\n                }\n                function Lr(Ie, xe) {\n                  xe = xe || 1 / 0;\n                  for (var ke, vt = Ie.length, ir = null, ar = [], vr = 0; vr < vt; ++vr) {\n                    if (ke = Ie.charCodeAt(vr), ke > 55295 && ke < 57344) {\n                      if (!ir) {\n                        if (ke > 56319) {\n                          (xe -= 3) > -1 && ar.push(239, 191, 189);\n                          continue;\n                        } else if (vr + 1 === vt) {\n                          (xe -= 3) > -1 && ar.push(239, 191, 189);\n                          continue;\n                        }\n                        ir = ke;\n                        continue;\n                      }\n                      if (ke < 56320) {\n                        (xe -= 3) > -1 && ar.push(239, 191, 189), ir = ke;\n                        continue;\n                      }\n                      ke = (ir - 55296 << 10 | ke - 56320) + 65536;\n                    } else ir && (xe -= 3) > -1 && ar.push(239, 191, 189);\n                    if (ir = null, ke < 128) {\n                      if ((xe -= 1) < 0) break;\n                      ar.push(ke);\n                    } else if (ke < 2048) {\n                      if ((xe -= 2) < 0) break;\n                      ar.push(ke >> 6 | 192, ke & 63 | 128);\n                    } else if (ke < 65536) {\n                      if ((xe -= 3) < 0) break;\n                      ar.push(ke >> 12 | 224, ke >> 6 & 63 | 128, ke & 63 | 128);\n                    } else if (ke < 1114112) {\n                      if ((xe -= 4) < 0) break;\n                      ar.push(ke >> 18 | 240, ke >> 12 & 63 | 128, ke >> 6 & 63 | 128, ke & 63 | 128);\n                    } else throw new Error("Invalid code point");\n                  }\n                  return ar;\n                }\n                function ti(Ie) {\n                  for (var xe = [], ke = 0; ke < Ie.length; ++ke) xe.push(Ie.charCodeAt(ke) & 255);\n                  return xe;\n                }\n                function Br(Ie, xe) {\n                  for (var ke, vt, ir, ar = [], vr = 0; vr < Ie.length && !((xe -= 2) < 0); ++vr) ke = Ie.charCodeAt(vr), vt = ke >> 8, ir = ke % 256, ar.push(ir), ar.push(vt);\n                  return ar;\n                }\n                function Vr(Ie) {\n                  return L3.toByteArray(Tr(Ie));\n                }\n                function dt(Ie, xe, ke, vt) {\n                  var ir;\n                  for (ir = 0; ir < vt && !(ir + ke >= xe.length || ir >= Ie.length); ++ir) xe[ir + ke] = Ie[ir];\n                  return ir;\n                }\n                function Ge(Ie, xe) {\n                  return Ie instanceof xe || Ie != null && Ie.constructor != null && Ie.constructor.name != null && Ie.constructor.name === xe.name;\n                }\n                function Je(Ie) {\n                  return Ie !== Ie;\n                }\n                var je = (function() {\n                  for (var Ie = "0123456789abcdef", xe = new Array(256), ke = 0; ke < 16; ++ke) for (var vt = ke * 16, ir = 0; ir < 16; ++ir) xe[vt + ir] = Ie[ke] + Ie[ir];\n                  return xe;\n                })();\n                function tt(Ie) {\n                  return typeof BigInt == "undefined" ? xt : Ie;\n                }\n                function xt() {\n                  throw new Error("BigInt not supported");\n                }\n              }, 4844: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  return o4[0] = s3[0] + l3[0] * u4, o4[1] = s3[1] + l3[1] * u4, o4[2] = s3[2] + l3[2] * u4, o4[3] = s3[3] + l3[3] * u4, o4;\n                }\n              }, 4905: function(i3, a4, o4) {\n                var s3 = o4(5874);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  var f4 = s3(c5), h3 = [];\n                  return h3 = h3.concat(f4(u4)), h3 = h3.concat(f4(null)), h3;\n                }\n              }, 4935: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = k4;\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(4359), c5 = o4(1879).Q, f4 = window || process.global || {}, h3 = f4.__TEXT_CACHE || {};\n                f4.__TEXT_CACHE = {};\n                var d3 = 3;\n                function v3(E3, S2, L3, x2) {\n                  this.gl = E3, this.shader = S2, this.buffer = L3, this.vao = x2, this.tickOffset = this.tickCount = this.labelOffset = this.labelCount = null;\n                }\n                var _2 = v3.prototype, b = [0, 0];\n                _2.bind = function(E3, S2, L3, x2) {\n                  this.vao.bind(), this.shader.bind();\n                  var C3 = this.shader.uniforms;\n                  C3.model = E3, C3.view = S2, C3.projection = L3, C3.pixelScale = x2, b[0] = this.gl.drawingBufferWidth, b[1] = this.gl.drawingBufferHeight, this.shader.uniforms.resolution = b;\n                }, _2.unbind = function() {\n                  this.vao.unbind();\n                }, _2.update = function(E3, S2, L3, x2, C3) {\n                  var M4 = [];\n                  function g3(H, te, oe, _e, Ee, Ce) {\n                    var me = [oe.style, oe.weight, oe.variant, oe.family].join("_"), ie = h3[me];\n                    ie || (ie = h3[me] = {});\n                    var Se = ie[te];\n                    Se || (Se = ie[te] = p3(te, { triangles: true, font: oe.family, fontStyle: oe.style, fontWeight: oe.weight, fontVariant: oe.variant, textAlign: "center", textBaseline: "middle", lineSpacing: Ee, styletags: Ce }));\n                    for (var Le = (_e || 12) / 12, Ae = Se.positions, Fe = Se.cells, Pe = 0, ge = Fe.length; Pe < ge; ++Pe) for (var Re = Fe[Pe], ce = 2; ce >= 0; --ce) {\n                      var Ze = Ae[Re[ce]];\n                      M4.push(Le * Ze[0], -Le * Ze[1], H);\n                    }\n                  }\n                  for (var P3 = [0, 0, 0], T3 = [0, 0, 0], z3 = [0, 0, 0], O3 = [0, 0, 0], V2 = 1.25, G2 = { breaklines: true, bolds: true, italics: true, subscripts: true, superscripts: true }, Z = 0; Z < 3; ++Z) {\n                    z3[Z] = M4.length / d3 | 0, g3(0.5 * (E3[0][Z] + E3[1][Z]), S2[Z], L3[Z], 12, V2, G2), O3[Z] = (M4.length / d3 | 0) - z3[Z], P3[Z] = M4.length / d3 | 0;\n                    for (var j3 = 0; j3 < x2[Z].length; ++j3) if (x2[Z][j3].text) {\n                      var N2 = { family: x2[Z][j3].font || C3[Z].family, style: C3[Z].fontStyle || C3[Z].style, weight: C3[Z].fontWeight || C3[Z].weight, variant: C3[Z].fontVariant || C3[Z].variant };\n                      g3(x2[Z][j3].x, x2[Z][j3].text, N2, x2[Z][j3].fontSize || 12, V2, G2);\n                    }\n                    T3[Z] = (M4.length / d3 | 0) - P3[Z];\n                  }\n                  this.buffer.update(M4), this.tickOffset = P3, this.tickCount = T3, this.labelOffset = z3, this.labelCount = O3;\n                }, _2.drawTicks = function(E3, S2, L3, x2, C3, M4, g3, P3) {\n                  this.tickCount[E3] && (this.shader.uniforms.axis = M4, this.shader.uniforms.color = C3, this.shader.uniforms.angle = L3, this.shader.uniforms.scale = S2, this.shader.uniforms.offset = x2, this.shader.uniforms.alignDir = g3, this.shader.uniforms.alignOpt = P3, this.vao.draw(this.gl.TRIANGLES, this.tickCount[E3], this.tickOffset[E3]));\n                }, _2.drawLabel = function(E3, S2, L3, x2, C3, M4, g3, P3) {\n                  this.labelCount[E3] && (this.shader.uniforms.axis = M4, this.shader.uniforms.color = C3, this.shader.uniforms.angle = L3, this.shader.uniforms.scale = S2, this.shader.uniforms.offset = x2, this.shader.uniforms.alignDir = g3, this.shader.uniforms.alignOpt = P3, this.vao.draw(this.gl.TRIANGLES, this.labelCount[E3], this.labelOffset[E3]));\n                }, _2.dispose = function() {\n                  this.shader.dispose(), this.vao.dispose(), this.buffer.dispose();\n                };\n                function p3(E3, S2) {\n                  try {\n                    return u4(E3, S2);\n                  } catch (L3) {\n                    return console.warn(\'error vectorizing text:"\' + E3 + \'" error:\', L3), { cells: [], positions: [] };\n                  }\n                }\n                function k4(E3, S2, L3, x2, C3, M4) {\n                  var g3 = s3(E3), P3 = l3(E3, [{ buffer: g3, size: 3 }]), T3 = c5(E3);\n                  T3.attributes.position.location = 0;\n                  var z3 = new v3(E3, T3, g3, P3);\n                  return z3.update(S2, L3, x2, C3, M4), z3;\n                }\n              }, 5023: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2478);\n                i3.exports = d3;\n                function l3(v3, _2, b, p3, k4, E3, S2) {\n                  this.cells = v3, this.neighbor = _2, this.flags = p3, this.constraint = b, this.active = k4, this.next = E3, this.boundary = S2;\n                }\n                var u4 = l3.prototype;\n                function c5(v3, _2) {\n                  return v3[0] - _2[0] || v3[1] - _2[1] || v3[2] - _2[2];\n                }\n                u4.locate = /* @__PURE__ */ (function() {\n                  var v3 = [0, 0, 0];\n                  return function(_2, b, p3) {\n                    var k4 = _2, E3 = b, S2 = p3;\n                    return b < p3 ? b < _2 && (k4 = b, E3 = p3, S2 = _2) : p3 < _2 && (k4 = p3, E3 = _2, S2 = b), k4 < 0 ? -1 : (v3[0] = k4, v3[1] = E3, v3[2] = S2, s3.eq(this.cells, v3, c5));\n                  };\n                })();\n                function f4(v3, _2) {\n                  for (var b = v3.cells(), p3 = b.length, k4 = 0; k4 < p3; ++k4) {\n                    var E3 = b[k4], S2 = E3[0], L3 = E3[1], x2 = E3[2];\n                    L3 < x2 ? L3 < S2 && (E3[0] = L3, E3[1] = x2, E3[2] = S2) : x2 < S2 && (E3[0] = x2, E3[1] = S2, E3[2] = L3);\n                  }\n                  b.sort(c5);\n                  for (var C3 = new Array(p3), k4 = 0; k4 < C3.length; ++k4) C3[k4] = 0;\n                  var M4 = [], g3 = [], P3 = new Array(3 * p3), T3 = new Array(3 * p3), z3 = null;\n                  _2 && (z3 = []);\n                  for (var O3 = new l3(b, P3, T3, C3, M4, g3, z3), k4 = 0; k4 < p3; ++k4) for (var E3 = b[k4], V2 = 0; V2 < 3; ++V2) {\n                    var S2 = E3[V2], L3 = E3[(V2 + 1) % 3], G2 = P3[3 * k4 + V2] = O3.locate(L3, S2, v3.opposite(L3, S2)), Z = T3[3 * k4 + V2] = v3.isConstraint(S2, L3);\n                    G2 < 0 && (Z ? g3.push(k4) : (M4.push(k4), C3[k4] = 1), _2 && z3.push([L3, S2, -1]));\n                  }\n                  return O3;\n                }\n                function h3(v3, _2, b) {\n                  for (var p3 = 0, k4 = 0; k4 < v3.length; ++k4) _2[k4] === b && (v3[p3++] = v3[k4]);\n                  return v3.length = p3, v3;\n                }\n                function d3(v3, _2, b) {\n                  var p3 = f4(v3, b);\n                  if (_2 === 0) return b ? p3.cells.concat(p3.boundary) : p3.cells;\n                  for (var k4 = 1, E3 = p3.active, S2 = p3.next, L3 = p3.flags, x2 = p3.cells, C3 = p3.constraint, M4 = p3.neighbor; E3.length > 0 || S2.length > 0; ) {\n                    for (; E3.length > 0; ) {\n                      var g3 = E3.pop();\n                      if (L3[g3] !== -k4) {\n                        L3[g3] = k4;\n                        for (var P3 = x2[g3], T3 = 0; T3 < 3; ++T3) {\n                          var z3 = M4[3 * g3 + T3];\n                          z3 >= 0 && L3[z3] === 0 && (C3[3 * g3 + T3] ? S2.push(z3) : (E3.push(z3), L3[z3] = k4));\n                        }\n                      }\n                    }\n                    var O3 = S2;\n                    S2 = E3, E3 = O3, S2.length = 0, k4 = -k4;\n                  }\n                  var V2 = h3(x2, L3, _2);\n                  return b ? V2.concat(p3.boundary) : V2;\n                }\n              }, 5033: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3 || 0, c5 = l3 || 1;\n                  return [[o4[12] + o4[0], o4[13] + o4[1], o4[14] + o4[2], o4[15] + o4[3]], [o4[12] - o4[0], o4[13] - o4[1], o4[14] - o4[2], o4[15] - o4[3]], [o4[12] + o4[4], o4[13] + o4[5], o4[14] + o4[6], o4[15] + o4[7]], [o4[12] - o4[4], o4[13] - o4[5], o4[14] - o4[6], o4[15] - o4[7]], [u4 * o4[12] + o4[8], u4 * o4[13] + o4[9], u4 * o4[14] + o4[10], u4 * o4[15] + o4[11]], [c5 * o4[12] - o4[8], c5 * o4[13] - o4[9], c5 * o4[14] - o4[10], c5 * o4[15] - o4[11]]];\n                }\n              }, 5085: function(i3, a4, o4) {\n                i3.exports = k4;\n                var s3 = o4(3250)[3], l3 = o4(4209), u4 = o4(3352), c5 = o4(2478);\n                function f4() {\n                  return true;\n                }\n                function h3(E3) {\n                  return function(S2, L3) {\n                    var x2 = E3[S2];\n                    return x2 ? !!x2.queryPoint(L3, f4) : false;\n                  };\n                }\n                function d3(E3) {\n                  for (var S2 = {}, L3 = 0; L3 < E3.length; ++L3) {\n                    var x2 = E3[L3], C3 = x2[0][0], M4 = x2[0][1], g3 = x2[1][1], P3 = [Math.min(M4, g3), Math.max(M4, g3)];\n                    C3 in S2 ? S2[C3].push(P3) : S2[C3] = [P3];\n                  }\n                  for (var T3 = {}, z3 = Object.keys(S2), L3 = 0; L3 < z3.length; ++L3) {\n                    var O3 = S2[z3[L3]];\n                    T3[z3[L3]] = u4(O3);\n                  }\n                  return h3(T3);\n                }\n                function v3(E3, S2) {\n                  return function(L3) {\n                    var x2 = c5.le(S2, L3[0]);\n                    if (x2 < 0) return 1;\n                    var C3 = E3[x2];\n                    if (!C3) if (x2 > 0 && S2[x2] === L3[0]) C3 = E3[x2 - 1];\n                    else return 1;\n                    for (var M4 = 1; C3; ) {\n                      var g3 = C3.key, P3 = s3(L3, g3[0], g3[1]);\n                      if (g3[0][0] < g3[1][0]) if (P3 < 0) C3 = C3.left;\n                      else if (P3 > 0) M4 = -1, C3 = C3.right;\n                      else return 0;\n                      else if (P3 > 0) C3 = C3.left;\n                      else if (P3 < 0) M4 = 1, C3 = C3.right;\n                      else return 0;\n                    }\n                    return M4;\n                  };\n                }\n                function _2(E3) {\n                  return 1;\n                }\n                function b(E3) {\n                  return function(L3) {\n                    return E3(L3[0], L3[1]) ? 0 : 1;\n                  };\n                }\n                function p3(E3, S2) {\n                  return function(x2) {\n                    return E3(x2[0], x2[1]) ? 0 : S2(x2);\n                  };\n                }\n                function k4(E3) {\n                  for (var S2 = E3.length, L3 = [], x2 = [], C3 = 0, M4 = 0; M4 < S2; ++M4) for (var g3 = E3[M4], P3 = g3.length, T3 = P3 - 1, z3 = 0; z3 < P3; T3 = z3++) {\n                    var O3 = g3[T3], V2 = g3[z3];\n                    O3[0] === V2[0] ? x2.push([O3, V2]) : L3.push([O3, V2]);\n                  }\n                  if (L3.length === 0) return x2.length === 0 ? _2 : b(d3(x2));\n                  var G2 = l3(L3), Z = v3(G2.slabs, G2.coordinates);\n                  return x2.length === 0 ? Z : p3(d3(x2), Z);\n                }\n              }, 5091: function(i3, a4, o4) {\n                "use strict";\n                a4.shader = k4, a4.program = E3;\n                var s3 = o4(8866), l3 = o4(2992), u4 = typeof WeakMap == "undefined" ? o4(606) : WeakMap, c5 = new u4(), f4 = 0;\n                function h3(S2, L3, x2, C3, M4, g3, P3) {\n                  this.id = S2, this.src = L3, this.type = x2, this.shader = C3, this.count = g3, this.programs = [], this.cache = P3;\n                }\n                h3.prototype.dispose = function() {\n                  if (--this.count === 0) {\n                    for (var S2 = this.cache, L3 = S2.gl, x2 = this.programs, C3 = 0, M4 = x2.length; C3 < M4; ++C3) {\n                      var g3 = S2.programs[x2[C3]];\n                      g3 && (delete S2.programs[C3], L3.deleteProgram(g3));\n                    }\n                    L3.deleteShader(this.shader), delete S2.shaders[this.type === L3.FRAGMENT_SHADER | 0][this.src];\n                  }\n                };\n                function d3(S2) {\n                  this.gl = S2, this.shaders = [{}, {}], this.programs = {};\n                }\n                var v3 = d3.prototype;\n                function _2(S2, L3, x2) {\n                  var C3 = S2.createShader(L3);\n                  if (S2.shaderSource(C3, x2), S2.compileShader(C3), !S2.getShaderParameter(C3, S2.COMPILE_STATUS)) {\n                    var M4 = S2.getShaderInfoLog(C3);\n                    try {\n                      var g3 = l3(M4, x2, L3);\n                    } catch (P3) {\n                      throw console.warn("Failed to format compiler error: " + P3), new s3(M4, `Error compiling shader:\n` + M4);\n                    }\n                    throw new s3(M4, g3.short, g3.long);\n                  }\n                  return C3;\n                }\n                v3.getShaderReference = function(S2, L3) {\n                  var x2 = this.gl, C3 = this.shaders[S2 === x2.FRAGMENT_SHADER | 0], M4 = C3[L3];\n                  if (!M4 || !x2.isShader(M4.shader)) {\n                    var g3 = _2(x2, S2, L3);\n                    M4 = C3[L3] = new h3(f4++, L3, S2, g3, [], 1, this);\n                  } else M4.count += 1;\n                  return M4;\n                };\n                function b(S2, L3, x2, C3, M4) {\n                  var g3 = S2.createProgram();\n                  S2.attachShader(g3, L3), S2.attachShader(g3, x2);\n                  for (var P3 = 0; P3 < C3.length; ++P3) S2.bindAttribLocation(g3, M4[P3], C3[P3]);\n                  if (S2.linkProgram(g3), !S2.getProgramParameter(g3, S2.LINK_STATUS)) {\n                    var T3 = S2.getProgramInfoLog(g3);\n                    throw new s3(T3, "Error linking program: " + T3);\n                  }\n                  return g3;\n                }\n                v3.getProgram = function(S2, L3, x2, C3) {\n                  var M4 = [S2.id, L3.id, x2.join(":"), C3.join(":")].join("@"), g3 = this.programs[M4];\n                  return (!g3 || !this.gl.isProgram(g3)) && (this.programs[M4] = g3 = b(this.gl, S2.shader, L3.shader, x2, C3), S2.programs.push(M4), L3.programs.push(M4)), g3;\n                };\n                function p3(S2) {\n                  var L3 = c5.get(S2);\n                  return L3 || (L3 = new d3(S2), c5.set(S2, L3)), L3;\n                }\n                function k4(S2, L3, x2) {\n                  return p3(S2).getShaderReference(L3, x2);\n                }\n                function E3(S2, L3, x2, C3, M4) {\n                  return p3(S2).getProgram(L3, x2, C3, M4);\n                }\n              }, 5093: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = -s3[0], o4[1] = -s3[1], o4[2] = -s3[2], o4;\n                }\n              }, 5137: function(i3, a4, o4) {\n                i3.exports = l3;\n                var s3 = o4(1091)();\n                function l3(u4, c5, f4, h3, d3, v3) {\n                  var _2, b;\n                  for (c5 || (c5 = 3), f4 || (f4 = 0), h3 ? b = Math.min(h3 * c5 + f4, u4.length) : b = u4.length, _2 = f4; _2 < b; _2 += c5) s3[0] = u4[_2], s3[1] = u4[_2 + 1], s3[2] = u4[_2 + 2], d3(s3, s3, v3), u4[_2] = s3[0], u4[_2 + 1] = s3[1], u4[_2 + 2] = s3[2];\n                  return u4;\n                }\n              }, 5171: function(i3, a4, o4) {\n                var s3 = o4(737);\n                i3.exports = function(u4) {\n                  return s3[u4];\n                };\n              }, 5177: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0], u4 = s3[1], c5 = s3[2], f4 = s3[3], h3 = l3 * l3 + u4 * u4 + c5 * c5 + f4 * f4;\n                  return h3 > 0 && (h3 = 1 / Math.sqrt(h3), o4[0] = l3 * h3, o4[1] = u4 * h3, o4[2] = c5 * h3, o4[3] = f4 * h3), o4;\n                }\n              }, 5202: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1944), l3 = o4(8210);\n                i3.exports = f4, i3.exports.positive = h3, i3.exports.negative = d3;\n                function u4(v3, _2) {\n                  var b = l3(s3(v3, _2), [_2[_2.length - 1]]);\n                  return b[b.length - 1];\n                }\n                function c5(v3, _2, b, p3) {\n                  var k4 = p3 - _2, E3 = -_2 / k4;\n                  E3 < 0 ? E3 = 0 : E3 > 1 && (E3 = 1);\n                  for (var S2 = 1 - E3, L3 = v3.length, x2 = new Array(L3), C3 = 0; C3 < L3; ++C3) x2[C3] = E3 * v3[C3] + S2 * b[C3];\n                  return x2;\n                }\n                function f4(v3, _2) {\n                  for (var b = [], p3 = [], k4 = u4(v3[v3.length - 1], _2), E3 = v3[v3.length - 1], S2 = v3[0], L3 = 0; L3 < v3.length; ++L3, E3 = S2) {\n                    S2 = v3[L3];\n                    var x2 = u4(S2, _2);\n                    if (k4 < 0 && x2 > 0 || k4 > 0 && x2 < 0) {\n                      var C3 = c5(E3, x2, S2, k4);\n                      b.push(C3), p3.push(C3.slice());\n                    }\n                    x2 < 0 ? p3.push(S2.slice()) : x2 > 0 ? b.push(S2.slice()) : (b.push(S2.slice()), p3.push(S2.slice())), k4 = x2;\n                  }\n                  return { positive: b, negative: p3 };\n                }\n                function h3(v3, _2) {\n                  for (var b = [], p3 = u4(v3[v3.length - 1], _2), k4 = v3[v3.length - 1], E3 = v3[0], S2 = 0; S2 < v3.length; ++S2, k4 = E3) {\n                    E3 = v3[S2];\n                    var L3 = u4(E3, _2);\n                    (p3 < 0 && L3 > 0 || p3 > 0 && L3 < 0) && b.push(c5(k4, L3, E3, p3)), L3 >= 0 && b.push(E3.slice()), p3 = L3;\n                  }\n                  return b;\n                }\n                function d3(v3, _2) {\n                  for (var b = [], p3 = u4(v3[v3.length - 1], _2), k4 = v3[v3.length - 1], E3 = v3[0], S2 = 0; S2 < v3.length; ++S2, k4 = E3) {\n                    E3 = v3[S2];\n                    var L3 = u4(E3, _2);\n                    (p3 < 0 && L3 > 0 || p3 > 0 && L3 < 0) && b.push(c5(k4, L3, E3, p3)), L3 <= 0 && b.push(E3.slice()), p3 = L3;\n                  }\n                  return b;\n                }\n              }, 5219: function(i3) {\n                "use strict";\n                i3.exports = function(a4) {\n                  for (var o4 = a4.length, s3, l3 = 0; l3 < o4; l3++) if (s3 = a4.charCodeAt(l3), (s3 < 9 || s3 > 13) && s3 !== 32 && s3 !== 133 && s3 !== 160 && s3 !== 5760 && s3 !== 6158 && (s3 < 8192 || s3 > 8205) && s3 !== 8232 && s3 !== 8233 && s3 !== 8239 && s3 !== 8287 && s3 !== 8288 && s3 !== 12288 && s3 !== 65279) return false;\n                  return true;\n                };\n              }, 5250: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                var a4 = +(Math.pow(2, 27) + 1);\n                function o4(s3, l3, u4) {\n                  var c5 = s3 * l3, f4 = a4 * s3, h3 = f4 - s3, d3 = f4 - h3, v3 = s3 - d3, _2 = a4 * l3, b = _2 - l3, p3 = _2 - b, k4 = l3 - p3, E3 = c5 - d3 * p3, S2 = E3 - v3 * p3, L3 = S2 - d3 * k4, x2 = v3 * k4 - L3;\n                  return u4 ? (u4[0] = x2, u4[1] = c5, u4) : [x2, c5];\n                }\n              }, 5298: function(i3, a4) {\n                "use strict";\n                var o4 = { "float64,2,1,0": function() {\n                  return function(v3, _2, b, p3, k4) {\n                    var E3 = v3[0], S2 = v3[1], L3 = v3[2], x2 = b[0], C3 = b[1], M4 = b[2];\n                    p3 |= 0;\n                    var g3 = 0, P3 = 0, T3 = 0, z3 = M4, O3 = C3 - L3 * M4, V2 = x2 - S2 * C3;\n                    for (T3 = 0; T3 < E3; ++T3) {\n                      for (P3 = 0; P3 < S2; ++P3) {\n                        for (g3 = 0; g3 < L3; ++g3) _2[p3] /= k4, p3 += z3;\n                        p3 += O3;\n                      }\n                      p3 += V2;\n                    }\n                  };\n                }, "uint8,2,0,1,float64,2,1,0": function() {\n                  return function(v3, _2, b, p3, k4, E3, S2, L3) {\n                    var x2 = v3[0], C3 = v3[1], M4 = v3[2], g3 = b[0], P3 = b[1], T3 = b[2], z3 = E3[0], O3 = E3[1], V2 = E3[2];\n                    p3 |= 0, S2 |= 0;\n                    for (var G2 = p3, Z = S2, j3 = v3[0] | 0; j3 > 0; ) {\n                      j3 < 64 ? (x2 = j3, j3 = 0) : (x2 = 64, j3 -= 64);\n                      for (var N2 = v3[1] | 0; N2 > 0; ) {\n                        N2 < 64 ? (C3 = N2, N2 = 0) : (C3 = 64, N2 -= 64), p3 = G2 + j3 * g3 + N2 * P3, S2 = Z + j3 * z3 + N2 * O3;\n                        var H = 0, te = 0, oe = 0, _e = T3, Ee = g3 - M4 * T3, Ce = P3 - x2 * g3, me = V2, ie = z3 - M4 * V2, Se = O3 - x2 * z3;\n                        for (oe = 0; oe < C3; ++oe) {\n                          for (te = 0; te < x2; ++te) {\n                            for (H = 0; H < M4; ++H) _2[p3] = k4[S2] * L3, p3 += _e, S2 += me;\n                            p3 += Ee, S2 += ie;\n                          }\n                          p3 += Ce, S2 += Se;\n                        }\n                      }\n                    }\n                  };\n                }, "float32,1,0,float32,1,0": function() {\n                  return function(v3, _2, b, p3, k4, E3, S2) {\n                    var L3 = v3[0], x2 = v3[1], C3 = b[0], M4 = b[1], g3 = E3[0], P3 = E3[1];\n                    p3 |= 0, S2 |= 0;\n                    var T3 = 0, z3 = 0, O3 = M4, V2 = C3 - x2 * M4, G2 = P3, Z = g3 - x2 * P3;\n                    for (z3 = 0; z3 < L3; ++z3) {\n                      for (T3 = 0; T3 < x2; ++T3) _2[p3] = k4[S2], p3 += O3, S2 += G2;\n                      p3 += V2, S2 += Z;\n                    }\n                  };\n                }, "float32,1,0,float32,0,1": function() {\n                  return function(v3, _2, b, p3, k4, E3, S2) {\n                    var L3 = v3[0], x2 = v3[1], C3 = b[0], M4 = b[1], g3 = E3[0], P3 = E3[1];\n                    p3 |= 0, S2 |= 0;\n                    for (var T3 = p3, z3 = S2, O3 = v3[1] | 0; O3 > 0; ) {\n                      O3 < 64 ? (x2 = O3, O3 = 0) : (x2 = 64, O3 -= 64);\n                      for (var V2 = v3[0] | 0; V2 > 0; ) {\n                        V2 < 64 ? (L3 = V2, V2 = 0) : (L3 = 64, V2 -= 64), p3 = T3 + O3 * M4 + V2 * C3, S2 = z3 + O3 * P3 + V2 * g3;\n                        var G2 = 0, Z = 0, j3 = M4, N2 = C3 - x2 * M4, H = P3, te = g3 - x2 * P3;\n                        for (Z = 0; Z < L3; ++Z) {\n                          for (G2 = 0; G2 < x2; ++G2) _2[p3] = k4[S2], p3 += j3, S2 += H;\n                          p3 += N2, S2 += te;\n                        }\n                      }\n                    }\n                  };\n                }, "uint8,2,0,1,uint8,1,2,0": function() {\n                  return function(v3, _2, b, p3, k4, E3, S2) {\n                    var L3 = v3[0], x2 = v3[1], C3 = v3[2], M4 = b[0], g3 = b[1], P3 = b[2], T3 = E3[0], z3 = E3[1], O3 = E3[2];\n                    p3 |= 0, S2 |= 0;\n                    for (var V2 = p3, G2 = S2, Z = v3[2] | 0; Z > 0; ) {\n                      Z < 64 ? (C3 = Z, Z = 0) : (C3 = 64, Z -= 64);\n                      for (var j3 = v3[0] | 0; j3 > 0; ) {\n                        j3 < 64 ? (L3 = j3, j3 = 0) : (L3 = 64, j3 -= 64);\n                        for (var N2 = v3[1] | 0; N2 > 0; ) {\n                          N2 < 64 ? (x2 = N2, N2 = 0) : (x2 = 64, N2 -= 64), p3 = V2 + Z * P3 + j3 * M4 + N2 * g3, S2 = G2 + Z * O3 + j3 * T3 + N2 * z3;\n                          var H = 0, te = 0, oe = 0, _e = P3, Ee = M4 - C3 * P3, Ce = g3 - L3 * M4, me = O3, ie = T3 - C3 * O3, Se = z3 - L3 * T3;\n                          for (oe = 0; oe < x2; ++oe) {\n                            for (te = 0; te < L3; ++te) {\n                              for (H = 0; H < C3; ++H) _2[p3] = k4[S2], p3 += _e, S2 += me;\n                              p3 += Ee, S2 += ie;\n                            }\n                            p3 += Ce, S2 += Se;\n                          }\n                        }\n                      }\n                    }\n                  };\n                }, "uint8,2,0,1,array,2,0,1": function() {\n                  return function(v3, _2, b, p3, k4, E3, S2) {\n                    var L3 = v3[0], x2 = v3[1], C3 = v3[2], M4 = b[0], g3 = b[1], P3 = b[2], T3 = E3[0], z3 = E3[1], O3 = E3[2];\n                    p3 |= 0, S2 |= 0;\n                    var V2 = 0, G2 = 0, Z = 0, j3 = P3, N2 = M4 - C3 * P3, H = g3 - L3 * M4, te = O3, oe = T3 - C3 * O3, _e = z3 - L3 * T3;\n                    for (Z = 0; Z < x2; ++Z) {\n                      for (G2 = 0; G2 < L3; ++G2) {\n                        for (V2 = 0; V2 < C3; ++V2) _2[p3] = k4[S2], p3 += j3, S2 += te;\n                        p3 += N2, S2 += oe;\n                      }\n                      p3 += H, S2 += _e;\n                    }\n                  };\n                } };\n                function s3(d3, v3) {\n                  var _2 = v3.join(","), b = o4[_2];\n                  return b();\n                }\n                var l3 = s3, u4 = { mul: function(d3) {\n                  var v3 = {};\n                  return function(b, p3, k4) {\n                    var E3 = b.dtype, S2 = b.order, L3 = p3.dtype, x2 = p3.order, C3 = k4.dtype, M4 = k4.order, g3 = [E3, S2.join(), L3, x2.join(), C3, M4.join()].join(), P3 = v3[g3];\n                    return P3 || (v3[g3] = P3 = d3([E3, S2, L3, x2, C3, M4])), P3(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3.data, p3.stride, p3.offset | 0, k4.data, k4.stride, k4.offset | 0);\n                  };\n                }, muls: function(d3) {\n                  var v3 = {};\n                  return function(b, p3, k4) {\n                    var E3 = b.dtype, S2 = b.order, L3 = p3.dtype, x2 = p3.order, C3 = [E3, S2.join(), L3, x2.join()].join(), M4 = v3[C3];\n                    return M4 || (v3[C3] = M4 = d3([E3, S2, L3, x2])), M4(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3.data, p3.stride, p3.offset | 0, k4);\n                  };\n                }, mulseq: function(d3) {\n                  var v3 = {};\n                  return function(b, p3) {\n                    var k4 = b.dtype, E3 = b.order, S2 = [k4, E3.join()].join(), L3 = v3[S2];\n                    return L3 || (v3[S2] = L3 = d3([k4, E3])), L3(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3);\n                  };\n                }, div: function(d3) {\n                  var v3 = {};\n                  return function(b, p3, k4) {\n                    var E3 = b.dtype, S2 = b.order, L3 = p3.dtype, x2 = p3.order, C3 = k4.dtype, M4 = k4.order, g3 = [E3, S2.join(), L3, x2.join(), C3, M4.join()].join(), P3 = v3[g3];\n                    return P3 || (v3[g3] = P3 = d3([E3, S2, L3, x2, C3, M4])), P3(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3.data, p3.stride, p3.offset | 0, k4.data, k4.stride, k4.offset | 0);\n                  };\n                }, divs: function(d3) {\n                  var v3 = {};\n                  return function(b, p3, k4) {\n                    var E3 = b.dtype, S2 = b.order, L3 = p3.dtype, x2 = p3.order, C3 = [E3, S2.join(), L3, x2.join()].join(), M4 = v3[C3];\n                    return M4 || (v3[C3] = M4 = d3([E3, S2, L3, x2])), M4(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3.data, p3.stride, p3.offset | 0, k4);\n                  };\n                }, divseq: function(d3) {\n                  var v3 = {};\n                  return function(b, p3) {\n                    var k4 = b.dtype, E3 = b.order, S2 = [k4, E3.join()].join(), L3 = v3[S2];\n                    return L3 || (v3[S2] = L3 = d3([k4, E3])), L3(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3);\n                  };\n                }, assign: function(d3) {\n                  var v3 = {};\n                  return function(b, p3) {\n                    var k4 = b.dtype, E3 = b.order, S2 = p3.dtype, L3 = p3.order, x2 = [k4, E3.join(), S2, L3.join()].join(), C3 = v3[x2];\n                    return C3 || (v3[x2] = C3 = d3([k4, E3, S2, L3])), C3(b.shape.slice(0), b.data, b.stride, b.offset | 0, p3.data, p3.stride, p3.offset | 0);\n                  };\n                } };\n                function c5(d3) {\n                  var v3 = u4[d3.funcName];\n                  return v3(l3.bind(void 0, d3));\n                }\n                function f4(d3) {\n                  return c5({ funcName: d3.funcName });\n                }\n                var h3 = { mul: "*", div: "/" };\n                (function() {\n                  for (var d3 in h3) a4[d3] = f4({ funcName: d3 }), a4[d3 + "s"] = f4({ funcName: d3 + "s" }), a4[d3 + "seq"] = f4({ funcName: d3 + "seq" });\n                })(), a4.assign = f4({ funcName: "assign" });\n              }, 5304: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = h3;\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(1879).bg;\n                function c5(d3, v3, _2, b) {\n                  this.gl = d3, this.buffer = v3, this.vao = _2, this.shader = b;\n                }\n                var f4 = c5.prototype;\n                f4.draw = function(d3, v3, _2, b, p3, k4) {\n                  for (var E3 = false, S2 = 0; S2 < 3; ++S2) E3 = E3 || p3[S2];\n                  if (E3) {\n                    var L3 = this.gl;\n                    L3.enable(L3.POLYGON_OFFSET_FILL), L3.polygonOffset(1, 2), this.shader.bind(), this.shader.uniforms = { model: d3, view: v3, projection: _2, bounds: b, enable: p3, colors: k4 }, this.vao.bind(), this.vao.draw(this.gl.TRIANGLES, 36), this.vao.unbind(), L3.disable(L3.POLYGON_OFFSET_FILL);\n                  }\n                }, f4.dispose = function() {\n                  this.vao.dispose(), this.buffer.dispose(), this.shader.dispose();\n                };\n                function h3(d3) {\n                  for (var v3 = [], _2 = [], b = 0, p3 = 0; p3 < 3; ++p3) for (var k4 = (p3 + 1) % 3, E3 = (p3 + 2) % 3, S2 = [0, 0, 0], L3 = [0, 0, 0], x2 = -1; x2 <= 1; x2 += 2) {\n                    _2.push(b, b + 2, b + 1, b + 1, b + 2, b + 3), S2[p3] = x2, L3[p3] = x2;\n                    for (var C3 = -1; C3 <= 1; C3 += 2) {\n                      S2[k4] = C3;\n                      for (var M4 = -1; M4 <= 1; M4 += 2) S2[E3] = M4, v3.push(S2[0], S2[1], S2[2], L3[0], L3[1], L3[2]), b += 1;\n                    }\n                    var g3 = k4;\n                    k4 = E3, E3 = g3;\n                  }\n                  var P3 = s3(d3, new Float32Array(v3)), T3 = s3(d3, new Uint16Array(_2), d3.ELEMENT_ARRAY_BUFFER), z3 = l3(d3, [{ buffer: P3, type: d3.FLOAT, size: 3, offset: 0, stride: 24 }, { buffer: P3, type: d3.FLOAT, size: 3, offset: 12, stride: 24 }], T3), O3 = u4(d3);\n                  return O3.attributes.position.location = 0, O3.attributes.normal.location = 1, new c5(d3, P3, z3, O3);\n                }\n              }, 5352: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = s3[3];\n                  return o4[0] = l3[0] * u4 + l3[4] * c5 + l3[8] * f4 + l3[12] * h3, o4[1] = l3[1] * u4 + l3[5] * c5 + l3[9] * f4 + l3[13] * h3, o4[2] = l3[2] * u4 + l3[6] * c5 + l3[10] * f4 + l3[14] * h3, o4[3] = l3[3] * u4 + l3[7] * c5 + l3[11] * f4 + l3[15] * h3, o4;\n                }\n              }, 5382: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8210), l3 = o4(3012);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  if (c5.length === 1) return l3(f4, c5[0]);\n                  if (f4.length === 1) return l3(c5, f4[0]);\n                  if (c5.length === 0 || f4.length === 0) return [0];\n                  var h3 = [0];\n                  if (c5.length < f4.length) for (var d3 = 0; d3 < c5.length; ++d3) h3 = s3(h3, l3(f4, c5[d3]));\n                  else for (var d3 = 0; d3 < f4.length; ++d3) h3 = s3(h3, l3(c5, f4[d3]));\n                  return h3;\n                }\n              }, 5445: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = L3;\n                var s3 = o4(5033), l3 = o4(5202), u4 = o4(6429), c5 = o4(6760), f4 = o4(5665), h3 = o4(5352), d3 = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]), v3 = new Float32Array(16);\n                function _2(x2, C3, M4) {\n                  this.lo = x2, this.hi = C3, this.pixelsPerDataUnit = M4;\n                }\n                var b = [0, 0, 0, 1], p3 = [0, 0, 0, 1];\n                function k4(x2, C3, M4, g3, P3) {\n                  for (var T3 = 0; T3 < 3; ++T3) {\n                    for (var z3 = b, O3 = p3, V2 = 0; V2 < 3; ++V2) O3[V2] = z3[V2] = M4[V2];\n                    O3[3] = z3[3] = 1, O3[T3] += 1, h3(O3, O3, C3), O3[3] < 0 && (x2[T3] = 1 / 0), z3[T3] -= 1, h3(z3, z3, C3), z3[3] < 0 && (x2[T3] = 1 / 0);\n                    var G2 = (z3[0] / z3[3] - O3[0] / O3[3]) * g3, Z = (z3[1] / z3[3] - O3[1] / O3[3]) * P3;\n                    x2[T3] = 0.25 * Math.sqrt(G2 * G2 + Z * Z);\n                  }\n                  return x2;\n                }\n                var E3 = [new _2(1 / 0, -1 / 0, 1 / 0), new _2(1 / 0, -1 / 0, 1 / 0), new _2(1 / 0, -1 / 0, 1 / 0)], S2 = [0, 0, 0];\n                function L3(x2, C3, M4, g3, Z) {\n                  var T3 = C3.model || d3, z3 = C3.view || d3, O3 = C3.projection || d3, V2 = C3._ortho || false, G2 = x2.bounds, Z = Z || u4(T3, z3, O3, G2, V2), j3 = Z.axis;\n                  c5(v3, z3, T3), c5(v3, O3, v3);\n                  for (var N2 = E3, H = 0; H < 3; ++H) N2[H].lo = 1 / 0, N2[H].hi = -1 / 0, N2[H].pixelsPerDataUnit = 1 / 0;\n                  var te = s3(f4(v3, v3));\n                  f4(v3, v3);\n                  for (var oe = 0; oe < 3; ++oe) {\n                    var _e = (oe + 1) % 3, Ee = (oe + 2) % 3, Ce = S2;\n                    e: for (var H = 0; H < 2; ++H) {\n                      var me = [];\n                      if (j3[oe] < 0 != !!H) {\n                        Ce[oe] = G2[H][oe];\n                        for (var ie = 0; ie < 2; ++ie) {\n                          Ce[_e] = G2[ie ^ H][_e];\n                          for (var Se = 0; Se < 2; ++Se) Ce[Ee] = G2[Se ^ ie ^ H][Ee], me.push(Ce.slice());\n                        }\n                        for (var Le = V2 ? 5 : 4, ie = Le; ie === Le; ++ie) {\n                          if (me.length === 0) continue e;\n                          me = l3.positive(me, te[ie]);\n                        }\n                        for (var ie = 0; ie < me.length; ++ie) for (var Ee = me[ie], Ae = k4(S2, v3, Ee, M4, g3), Se = 0; Se < 3; ++Se) N2[Se].lo = Math.min(N2[Se].lo, Ee[Se]), N2[Se].hi = Math.max(N2[Se].hi, Ee[Se]), Se !== oe && (N2[Se].pixelsPerDataUnit = Math.min(N2[Se].pixelsPerDataUnit, Math.abs(Ae[Se])));\n                      }\n                    }\n                  }\n                  return N2;\n                }\n              }, 5455: function(i3, a4, o4) {\n                i3.exports = o4(7056);\n              }, 5486: function(i3, a4, o4) {\n                i3.exports = o4(3066);\n              }, 5542: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2478);\n                i3.exports = f4;\n                function l3(h3, d3) {\n                  this.stars = h3, this.edges = d3;\n                }\n                var u4 = l3.prototype;\n                function c5(h3, d3, v3) {\n                  for (var _2 = 1, b = h3.length; _2 < b; _2 += 2) if (h3[_2 - 1] === d3 && h3[_2] === v3) {\n                    h3[_2 - 1] = h3[b - 2], h3[_2] = h3[b - 1], h3.length = b - 2;\n                    return;\n                  }\n                }\n                u4.isConstraint = /* @__PURE__ */ (function() {\n                  var h3 = [0, 0];\n                  function d3(v3, _2) {\n                    return v3[0] - _2[0] || v3[1] - _2[1];\n                  }\n                  return function(v3, _2) {\n                    return h3[0] = Math.min(v3, _2), h3[1] = Math.max(v3, _2), s3.eq(this.edges, h3, d3) >= 0;\n                  };\n                })(), u4.removeTriangle = function(h3, d3, v3) {\n                  var _2 = this.stars;\n                  c5(_2[h3], d3, v3), c5(_2[d3], v3, h3), c5(_2[v3], h3, d3);\n                }, u4.addTriangle = function(h3, d3, v3) {\n                  var _2 = this.stars;\n                  _2[h3].push(d3, v3), _2[d3].push(v3, h3), _2[v3].push(h3, d3);\n                }, u4.opposite = function(h3, d3) {\n                  for (var v3 = this.stars[d3], _2 = 1, b = v3.length; _2 < b; _2 += 2) if (v3[_2] === h3) return v3[_2 - 1];\n                  return -1;\n                }, u4.flip = function(h3, d3) {\n                  var v3 = this.opposite(h3, d3), _2 = this.opposite(d3, h3);\n                  this.removeTriangle(h3, d3, v3), this.removeTriangle(d3, h3, _2), this.addTriangle(h3, _2, v3), this.addTriangle(d3, v3, _2);\n                }, u4.edges = function() {\n                  for (var h3 = this.stars, d3 = [], v3 = 0, _2 = h3.length; v3 < _2; ++v3) for (var b = h3[v3], p3 = 0, k4 = b.length; p3 < k4; p3 += 2) d3.push([b[p3], b[p3 + 1]]);\n                  return d3;\n                }, u4.cells = function() {\n                  for (var h3 = this.stars, d3 = [], v3 = 0, _2 = h3.length; v3 < _2; ++v3) for (var b = h3[v3], p3 = 0, k4 = b.length; p3 < k4; p3 += 2) {\n                    var E3 = b[p3], S2 = b[p3 + 1];\n                    v3 < Math.min(E3, S2) && d3.push([v3, E3, S2]);\n                  }\n                  return d3;\n                };\n                function f4(h3, d3) {\n                  for (var v3 = new Array(h3), _2 = 0; _2 < h3; ++_2) v3[_2] = [];\n                  return new l3(v3, d3);\n                }\n              }, 5567: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = Math.sin(l3), c5 = Math.cos(l3), f4 = s3[4], h3 = s3[5], d3 = s3[6], v3 = s3[7], _2 = s3[8], b = s3[9], p3 = s3[10], k4 = s3[11];\n                  return s3 !== o4 && (o4[0] = s3[0], o4[1] = s3[1], o4[2] = s3[2], o4[3] = s3[3], o4[12] = s3[12], o4[13] = s3[13], o4[14] = s3[14], o4[15] = s3[15]), o4[4] = f4 * c5 + _2 * u4, o4[5] = h3 * c5 + b * u4, o4[6] = d3 * c5 + p3 * u4, o4[7] = v3 * c5 + k4 * u4, o4[8] = _2 * c5 - f4 * u4, o4[9] = b * c5 - h3 * u4, o4[10] = p3 * c5 - d3 * u4, o4[11] = k4 * c5 - v3 * u4, o4;\n                }\n              }, 5572: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(869);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  return s3(u4[0].mul(c5[1]).sub(u4[1].mul(c5[0])), u4[1].mul(c5[1]));\n                }\n              }, 5609: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(3134);\n                function l3(u4, c5) {\n                  for (var f4 = s3(u4, c5.length), h3 = new Array(c5.length), d3 = new Array(c5.length), v3 = [], _2 = 0; _2 < c5.length; ++_2) {\n                    var b = f4[_2].length;\n                    d3[_2] = b, h3[_2] = true, b <= 1 && v3.push(_2);\n                  }\n                  for (; v3.length > 0; ) {\n                    var p3 = v3.pop();\n                    h3[p3] = false;\n                    for (var k4 = f4[p3], _2 = 0; _2 < k4.length; ++_2) {\n                      var E3 = k4[_2];\n                      --d3[E3] === 0 && v3.push(E3);\n                    }\n                  }\n                  for (var S2 = new Array(c5.length), L3 = [], _2 = 0; _2 < c5.length; ++_2) if (h3[_2]) {\n                    var p3 = L3.length;\n                    S2[_2] = p3, L3.push(c5[_2]);\n                  } else S2[_2] = -1;\n                  for (var x2 = [], _2 = 0; _2 < u4.length; ++_2) {\n                    var C3 = u4[_2];\n                    h3[C3[0]] && h3[C3[1]] && x2.push([S2[C3[0]], S2[C3[1]]]);\n                  }\n                  return [x2, L3];\n                }\n              }, 5632: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] + l3[0], o4[1] = s3[1] + l3[1], o4[2] = s3[2] + l3[2], o4;\n                }\n              }, 5665: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  if (o4 === s3) {\n                    var l3 = s3[1], u4 = s3[2], c5 = s3[3], f4 = s3[6], h3 = s3[7], d3 = s3[11];\n                    o4[1] = s3[4], o4[2] = s3[8], o4[3] = s3[12], o4[4] = l3, o4[6] = s3[9], o4[7] = s3[13], o4[8] = u4, o4[9] = f4, o4[11] = s3[14], o4[12] = c5, o4[13] = h3, o4[14] = d3;\n                  } else o4[0] = s3[0], o4[1] = s3[4], o4[2] = s3[8], o4[3] = s3[12], o4[4] = s3[1], o4[5] = s3[5], o4[6] = s3[9], o4[7] = s3[13], o4[8] = s3[2], o4[9] = s3[6], o4[10] = s3[10], o4[11] = s3[14], o4[12] = s3[3], o4[13] = s3[7], o4[14] = s3[11], o4[15] = s3[15];\n                  return o4;\n                }\n              }, 5673: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = l3[3] * u4 + l3[7] * c5 + l3[11] * f4 + l3[15];\n                  return h3 = h3 || 1, o4[0] = (l3[0] * u4 + l3[4] * c5 + l3[8] * f4 + l3[12]) / h3, o4[1] = (l3[1] * u4 + l3[5] * c5 + l3[9] * f4 + l3[13]) / h3, o4[2] = (l3[2] * u4 + l3[6] * c5 + l3[10] * f4 + l3[14]) / h3, o4;\n                }\n              }, 5714: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = M4;\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(7766), c5 = new Uint8Array(4), f4 = new Float32Array(c5.buffer);\n                function h3(g3, P3, T3, z3) {\n                  return c5[0] = z3, c5[1] = T3, c5[2] = P3, c5[3] = g3, f4[0];\n                }\n                var d3 = o4(2478), v3 = o4(9618), _2 = o4(7319), b = _2.createShader, p3 = _2.createPickShader, k4 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                function E3(g3, P3) {\n                  for (var T3 = 0, z3 = 0; z3 < 3; ++z3) {\n                    var O3 = g3[z3] - P3[z3];\n                    T3 += O3 * O3;\n                  }\n                  return Math.sqrt(T3);\n                }\n                function S2(g3) {\n                  for (var P3 = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], T3 = 0; T3 < 3; ++T3) P3[0][T3] = Math.max(g3[0][T3], P3[0][T3]), P3[1][T3] = Math.min(g3[1][T3], P3[1][T3]);\n                  return P3;\n                }\n                function L3(g3, P3, T3, z3) {\n                  this.arcLength = g3, this.position = P3, this.index = T3, this.dataCoordinate = z3;\n                }\n                function x2(g3, P3, T3, z3, O3, V2) {\n                  this.gl = g3, this.shader = P3, this.pickShader = T3, this.buffer = z3, this.vao = O3, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.points = [], this.arcLength = [], this.vertexCount = 0, this.bounds = [[0, 0, 0], [0, 0, 0]], this.pickId = 0, this.lineWidth = 1, this.texture = V2, this.dashScale = 1, this.opacity = 1, this.hasAlpha = false, this.dirty = true, this.pixelRatio = 1;\n                }\n                var C3 = x2.prototype;\n                C3.isTransparent = function() {\n                  return this.hasAlpha;\n                }, C3.isOpaque = function() {\n                  return !this.hasAlpha;\n                }, C3.pickSlots = 1, C3.setPickBase = function(g3) {\n                  this.pickId = g3;\n                }, C3.drawTransparent = C3.draw = function(g3) {\n                  if (this.vertexCount) {\n                    var P3 = this.gl, T3 = this.shader, z3 = this.vao;\n                    T3.bind(), T3.uniforms = { model: g3.model || k4, view: g3.view || k4, projection: g3.projection || k4, clipBounds: S2(this.clipBounds), dashTexture: this.texture.bind(), dashScale: this.dashScale / this.arcLength[this.arcLength.length - 1], opacity: this.opacity, screenShape: [P3.drawingBufferWidth, P3.drawingBufferHeight], pixelRatio: this.pixelRatio }, z3.bind(), z3.draw(P3.TRIANGLE_STRIP, this.vertexCount), z3.unbind();\n                  }\n                }, C3.drawPick = function(g3) {\n                  if (this.vertexCount) {\n                    var P3 = this.gl, T3 = this.pickShader, z3 = this.vao;\n                    T3.bind(), T3.uniforms = { model: g3.model || k4, view: g3.view || k4, projection: g3.projection || k4, pickId: this.pickId, clipBounds: S2(this.clipBounds), screenShape: [P3.drawingBufferWidth, P3.drawingBufferHeight], pixelRatio: this.pixelRatio }, z3.bind(), z3.draw(P3.TRIANGLE_STRIP, this.vertexCount), z3.unbind();\n                  }\n                }, C3.update = function(g3) {\n                  var P3, T3;\n                  this.dirty = true;\n                  var z3 = !!g3.connectGaps;\n                  "dashScale" in g3 && (this.dashScale = g3.dashScale), this.hasAlpha = false, "opacity" in g3 && (this.opacity = +g3.opacity, this.opacity < 1 && (this.hasAlpha = true));\n                  var O3 = [], V2 = [], G2 = [], Z = 0, j3 = 0, N2 = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], H = g3.position || g3.positions;\n                  if (H) {\n                    var te = g3.color || g3.colors || [0, 0, 0, 1], oe = g3.lineWidth || 1, _e = false;\n                    e: for (P3 = 1; P3 < H.length; ++P3) {\n                      var Ee = H[P3 - 1], Ce = H[P3];\n                      for (V2.push(Z), G2.push(Ee.slice()), T3 = 0; T3 < 3; ++T3) {\n                        if (isNaN(Ee[T3]) || isNaN(Ce[T3]) || !isFinite(Ee[T3]) || !isFinite(Ce[T3])) {\n                          if (!z3 && O3.length > 0) {\n                            for (var me = 0; me < 24; ++me) O3.push(O3[O3.length - 12]);\n                            j3 += 2, _e = true;\n                          }\n                          continue e;\n                        }\n                        N2[0][T3] = Math.min(N2[0][T3], Ee[T3], Ce[T3]), N2[1][T3] = Math.max(N2[1][T3], Ee[T3], Ce[T3]);\n                      }\n                      var ie, Se;\n                      Array.isArray(te[0]) ? (ie = te.length > P3 - 1 ? te[P3 - 1] : te.length > 0 ? te[te.length - 1] : [0, 0, 0, 1], Se = te.length > P3 ? te[P3] : te.length > 0 ? te[te.length - 1] : [0, 0, 0, 1]) : ie = Se = te, ie.length === 3 && (ie = [ie[0], ie[1], ie[2], 1]), Se.length === 3 && (Se = [Se[0], Se[1], Se[2], 1]), !this.hasAlpha && ie[3] < 1 && (this.hasAlpha = true);\n                      var Le;\n                      Array.isArray(oe) ? Le = oe.length > P3 - 1 ? oe[P3 - 1] : oe.length > 0 ? oe[oe.length - 1] : [0, 0, 0, 1] : Le = oe;\n                      var Ae = Z;\n                      if (Z += E3(Ee, Ce), _e) {\n                        for (T3 = 0; T3 < 2; ++T3) O3.push(Ee[0], Ee[1], Ee[2], Ce[0], Ce[1], Ce[2], Ae, Le, ie[0], ie[1], ie[2], ie[3]);\n                        j3 += 2, _e = false;\n                      }\n                      O3.push(Ee[0], Ee[1], Ee[2], Ce[0], Ce[1], Ce[2], Ae, Le, ie[0], ie[1], ie[2], ie[3], Ee[0], Ee[1], Ee[2], Ce[0], Ce[1], Ce[2], Ae, -Le, ie[0], ie[1], ie[2], ie[3], Ce[0], Ce[1], Ce[2], Ee[0], Ee[1], Ee[2], Z, -Le, Se[0], Se[1], Se[2], Se[3], Ce[0], Ce[1], Ce[2], Ee[0], Ee[1], Ee[2], Z, Le, Se[0], Se[1], Se[2], Se[3]), j3 += 4;\n                    }\n                  }\n                  if (this.buffer.update(O3), V2.push(Z), G2.push(H[H.length - 1].slice()), this.bounds = N2, this.vertexCount = j3, this.points = G2, this.arcLength = V2, "dashes" in g3) {\n                    var Fe = g3.dashes, Pe = Fe.slice();\n                    for (Pe.unshift(0), P3 = 1; P3 < Pe.length; ++P3) Pe[P3] = Pe[P3 - 1] + Pe[P3];\n                    var ge = v3(new Array(256 * 4), [256, 1, 4]);\n                    for (P3 = 0; P3 < 256; ++P3) {\n                      for (T3 = 0; T3 < 4; ++T3) ge.set(P3, 0, T3, 0);\n                      d3.le(Pe, Pe[Pe.length - 1] * P3 / 255) & 1 ? ge.set(P3, 0, 0, 0) : ge.set(P3, 0, 0, 255);\n                    }\n                    this.texture.setPixels(ge);\n                  }\n                }, C3.dispose = function() {\n                  this.shader.dispose(), this.vao.dispose(), this.buffer.dispose();\n                }, C3.pick = function(g3) {\n                  if (!g3 || g3.id !== this.pickId) return null;\n                  var P3 = h3(g3.value[0], g3.value[1], g3.value[2], 0), T3 = d3.le(this.arcLength, P3);\n                  if (T3 < 0) return null;\n                  if (T3 === this.arcLength.length - 1) return new L3(this.arcLength[this.arcLength.length - 1], this.points[this.points.length - 1].slice(), T3);\n                  for (var z3 = this.points[T3], O3 = this.points[Math.min(T3 + 1, this.points.length - 1)], V2 = (P3 - this.arcLength[T3]) / (this.arcLength[T3 + 1] - this.arcLength[T3]), G2 = 1 - V2, Z = [0, 0, 0], j3 = 0; j3 < 3; ++j3) Z[j3] = G2 * z3[j3] + V2 * O3[j3];\n                  var N2 = Math.min(V2 < 0.5 ? T3 : T3 + 1, this.points.length - 1);\n                  return new L3(P3, Z, N2, this.points[N2]);\n                };\n                function M4(g3) {\n                  var P3 = g3.gl || g3.scene && g3.scene.gl, T3 = b(P3);\n                  T3.attributes.position.location = 0, T3.attributes.nextPosition.location = 1, T3.attributes.arcLength.location = 2, T3.attributes.lineWidth.location = 3, T3.attributes.color.location = 4;\n                  var z3 = p3(P3);\n                  z3.attributes.position.location = 0, z3.attributes.nextPosition.location = 1, z3.attributes.arcLength.location = 2, z3.attributes.lineWidth.location = 3, z3.attributes.color.location = 4;\n                  for (var O3 = s3(P3), V2 = l3(P3, [{ buffer: O3, size: 3, offset: 0, stride: 48 }, { buffer: O3, size: 3, offset: 12, stride: 48 }, { buffer: O3, size: 1, offset: 24, stride: 48 }, { buffer: O3, size: 1, offset: 28, stride: 48 }, { buffer: O3, size: 4, offset: 32, stride: 48 }]), G2 = v3(new Array(256 * 4), [256, 1, 4]), Z = 0; Z < 1024; ++Z) G2.data[Z] = 255;\n                  var j3 = u4(P3, G2);\n                  j3.wrap = P3.REPEAT;\n                  var N2 = new x2(P3, T3, z3, O3, V2, j3);\n                  return N2.update(g3), N2;\n                }\n              }, 5716: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(6859);\n                i3.exports = l3;\n                function l3(u4) {\n                  return u4.cmp(new s3(0));\n                }\n              }, 5721: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4) {\n                  for (var s3 = 0, l3 = 0, u4 = 1; u4 < o4.length; ++u4) o4[u4][0] < o4[s3][0] && (s3 = u4), o4[u4][0] > o4[l3][0] && (l3 = u4);\n                  return s3 < l3 ? [[s3], [l3]] : s3 > l3 ? [[l3], [s3]] : [[s3]];\n                }\n              }, 5771: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8507), l3 = o4(3788), u4 = o4(2419);\n                i3.exports = c5;\n                function c5(f4) {\n                  f4.sort(l3);\n                  for (var h3 = f4.length, d3 = 0, v3 = 0; v3 < h3; ++v3) {\n                    var _2 = f4[v3], b = u4(_2);\n                    if (b !== 0) {\n                      if (d3 > 0) {\n                        var p3 = f4[d3 - 1];\n                        if (s3(_2, p3) === 0 && u4(p3) !== b) {\n                          d3 -= 1;\n                          continue;\n                        }\n                      }\n                      f4[d3++] = _2;\n                    }\n                  }\n                  return f4.length = d3, f4;\n                }\n              }, 5838: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = l3;\n                var s3 = o4(7842);\n                function l3(u4) {\n                  for (var c5 = new Array(u4.length), f4 = 0; f4 < u4.length; ++f4) c5[f4] = s3(u4[f4]);\n                  return c5;\n                }\n              }, 5847: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] * l3[0], o4[1] = s3[1] * l3[1], o4[2] = s3[2] * l3[2], o4;\n                }\n              }, 5874: function(i3, a4, o4) {\n                i3.exports = T3;\n                var s3 = o4(620), l3 = o4(7827), u4 = o4(6852), c5 = o4(7932), f4 = o4(3508), h3 = 999, d3 = 9999, v3 = 0, _2 = 1, b = 2, p3 = 3, k4 = 4, E3 = 5, S2 = 6, L3 = 7, x2 = 8, C3 = 9, M4 = 10, g3 = 11, P3 = ["block-comment", "line-comment", "preprocessor", "operator", "integer", "float", "ident", "builtin", "keyword", "whitespace", "eof", "integer"];\n                function T3(z3) {\n                  var O3 = 0, V2 = 0, G2 = h3, Z, j3, N2 = [], H = [], te = 0, oe = 0, _e = 1, Ee = 0, Ce = 0, me = false, ie = false, Se = "", Le;\n                  z3 = z3 || {};\n                  var Ae = u4, Fe = s3;\n                  z3.version === "300 es" && (Ae = f4, Fe = c5);\n                  for (var Pe = {}, ge = {}, O3 = 0; O3 < Ae.length; O3++) Pe[Ae[O3]] = true;\n                  for (var O3 = 0; O3 < Fe.length; O3++) ge[Fe[O3]] = true;\n                  return function($e) {\n                    return H = [], $e !== null ? ce($e) : Ze();\n                  };\n                  function Re($e) {\n                    $e.length && H.push({ type: P3[G2], data: $e, position: Ce, line: _e, column: Ee });\n                  }\n                  function ce($e) {\n                    O3 = 0, $e.toString && ($e = $e.toString()), Se += $e.replace(/\\r\\n/g, `\n`), Le = Se.length;\n                    for (var St; Z = Se[O3], O3 < Le; ) {\n                      switch (St = O3, G2) {\n                        case v3:\n                          O3 = lt();\n                          break;\n                        case _2:\n                          O3 = st();\n                          break;\n                        case b:\n                          O3 = Zt();\n                          break;\n                        case p3:\n                          O3 = Gt();\n                          break;\n                        case k4:\n                          O3 = sr();\n                          break;\n                        case g3:\n                          O3 = Jt();\n                          break;\n                        case E3:\n                          O3 = wr();\n                          break;\n                        case d3:\n                          O3 = cr();\n                          break;\n                        case C3:\n                          O3 = pt();\n                          break;\n                        case h3:\n                          O3 = ut();\n                          break;\n                      }\n                      if (St !== O3) switch (Se[St]) {\n                        case `\n`:\n                          Ee = 0, ++_e;\n                          break;\n                        default:\n                          ++Ee;\n                          break;\n                      }\n                    }\n                    return V2 += O3, Se = Se.slice(O3), H;\n                  }\n                  function Ze($e) {\n                    return N2.length && Re(N2.join("")), G2 = M4, Re("(eof)"), H;\n                  }\n                  function ut() {\n                    return N2 = N2.length ? [] : N2, j3 === "/" && Z === "*" ? (Ce = V2 + O3 - 1, G2 = v3, j3 = Z, O3 + 1) : j3 === "/" && Z === "/" ? (Ce = V2 + O3 - 1, G2 = _2, j3 = Z, O3 + 1) : Z === "#" ? (G2 = b, Ce = V2 + O3, O3) : /\\s/.test(Z) ? (G2 = C3, Ce = V2 + O3, O3) : (me = /\\d/.test(Z), ie = /[^\\w_]/.test(Z), Ce = V2 + O3, G2 = me ? k4 : ie ? p3 : d3, O3);\n                  }\n                  function pt() {\n                    return /[^\\s]/g.test(Z) ? (Re(N2.join("")), G2 = h3, O3) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function Zt() {\n                    return (Z === "\\r" || Z === `\n`) && j3 !== "\\\\" ? (Re(N2.join("")), G2 = h3, O3) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function st() {\n                    return Zt();\n                  }\n                  function lt() {\n                    return Z === "/" && j3 === "*" ? (N2.push(Z), Re(N2.join("")), G2 = h3, O3 + 1) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function Gt() {\n                    if (j3 === "." && /\\d/.test(Z)) return G2 = E3, O3;\n                    if (j3 === "/" && Z === "*") return G2 = v3, O3;\n                    if (j3 === "/" && Z === "/") return G2 = _2, O3;\n                    if (Z === "." && N2.length) {\n                      for (; Nt(N2); ) ;\n                      return G2 = E3, O3;\n                    }\n                    if (Z === ";" || Z === ")" || Z === "(") {\n                      if (N2.length) for (; Nt(N2); ) ;\n                      return Re(Z), G2 = h3, O3 + 1;\n                    }\n                    var $e = N2.length === 2 && Z !== "=";\n                    if (/[\\w_\\d\\s]/.test(Z) || $e) {\n                      for (; Nt(N2); ) ;\n                      return G2 = h3, O3;\n                    }\n                    return N2.push(Z), j3 = Z, O3 + 1;\n                  }\n                  function Nt($e) {\n                    var St = 0, Qt, Vt;\n                    do {\n                      if (Qt = l3.indexOf($e.slice(0, $e.length + St).join("")), Vt = l3[Qt], Qt === -1) {\n                        if (St-- + $e.length > 0) continue;\n                        Vt = $e.slice(0, 1).join("");\n                      }\n                      return Re(Vt), Ce += Vt.length, N2 = N2.slice(Vt.length), N2.length;\n                    } while (true);\n                  }\n                  function Jt() {\n                    return /[^a-fA-F0-9]/.test(Z) ? (Re(N2.join("")), G2 = h3, O3) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function sr() {\n                    return Z === "." || /[eE]/.test(Z) ? (N2.push(Z), G2 = E3, j3 = Z, O3 + 1) : Z === "x" && N2.length === 1 && N2[0] === "0" ? (G2 = g3, N2.push(Z), j3 = Z, O3 + 1) : /[^\\d]/.test(Z) ? (Re(N2.join("")), G2 = h3, O3) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function wr() {\n                    return Z === "f" && (N2.push(Z), j3 = Z, O3 += 1), /[eE]/.test(Z) || (Z === "-" || Z === "+") && /[eE]/.test(j3) ? (N2.push(Z), j3 = Z, O3 + 1) : /[^\\d]/.test(Z) ? (Re(N2.join("")), G2 = h3, O3) : (N2.push(Z), j3 = Z, O3 + 1);\n                  }\n                  function cr() {\n                    if (/[^\\d\\w_]/.test(Z)) {\n                      var $e = N2.join("");\n                      return ge[$e] ? G2 = x2 : Pe[$e] ? G2 = L3 : G2 = S2, Re(N2.join("")), G2 = h3, O3;\n                    }\n                    return N2.push(Z), j3 = Z, O3 + 1;\n                  }\n                }\n              }, 5878: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = c5;\n                var s3 = o4(3250), l3 = o4(2014);\n                function u4(f4, h3, d3) {\n                  var v3 = Math.abs(s3(f4, h3, d3)), _2 = Math.sqrt(Math.pow(h3[0] - d3[0], 2) + Math.pow(h3[1] - d3[1], 2));\n                  return v3 / _2;\n                }\n                function c5(f4, h3, d3) {\n                  for (var v3 = h3.length, _2 = f4.length, b = new Array(v3), p3 = new Array(v3), k4 = new Array(v3), E3 = new Array(v3), S2 = 0; S2 < v3; ++S2) b[S2] = p3[S2] = -1, k4[S2] = 1 / 0, E3[S2] = false;\n                  for (var S2 = 0; S2 < _2; ++S2) {\n                    var L3 = f4[S2];\n                    if (L3.length !== 2) throw new Error("Input must be a graph");\n                    var x2 = L3[1], C3 = L3[0];\n                    p3[C3] !== -1 ? p3[C3] = -2 : p3[C3] = x2, b[x2] !== -1 ? b[x2] = -2 : b[x2] = C3;\n                  }\n                  function M4(ie) {\n                    if (E3[ie]) return 1 / 0;\n                    var Se = b[ie], Le = p3[ie];\n                    return Se < 0 || Le < 0 ? 1 / 0 : u4(h3[ie], h3[Se], h3[Le]);\n                  }\n                  function g3(ie, Se) {\n                    var Le = j3[ie], Ae = j3[Se];\n                    j3[ie] = Ae, j3[Se] = Le, N2[Le] = Se, N2[Ae] = ie;\n                  }\n                  function P3(ie) {\n                    return k4[j3[ie]];\n                  }\n                  function T3(ie) {\n                    return ie & 1 ? ie - 1 >> 1 : (ie >> 1) - 1;\n                  }\n                  function z3(ie) {\n                    for (var Se = P3(ie); ; ) {\n                      var Le = Se, Ae = 2 * ie + 1, Fe = 2 * (ie + 1), Pe = ie;\n                      if (Ae < te) {\n                        var ge = P3(Ae);\n                        ge < Le && (Pe = Ae, Le = ge);\n                      }\n                      if (Fe < te) {\n                        var Re = P3(Fe);\n                        Re < Le && (Pe = Fe);\n                      }\n                      if (Pe === ie) return ie;\n                      g3(ie, Pe), ie = Pe;\n                    }\n                  }\n                  function O3(ie) {\n                    for (var Se = P3(ie); ie > 0; ) {\n                      var Le = T3(ie);\n                      if (Le >= 0) {\n                        var Ae = P3(Le);\n                        if (Se < Ae) {\n                          g3(ie, Le), ie = Le;\n                          continue;\n                        }\n                      }\n                      return ie;\n                    }\n                  }\n                  function V2() {\n                    if (te > 0) {\n                      var ie = j3[0];\n                      return g3(0, te - 1), te -= 1, z3(0), ie;\n                    }\n                    return -1;\n                  }\n                  function G2(ie, Se) {\n                    var Le = j3[ie];\n                    return k4[Le] === Se ? ie : (k4[Le] = -1 / 0, O3(ie), V2(), k4[Le] = Se, te += 1, O3(te - 1));\n                  }\n                  function Z(ie) {\n                    if (!E3[ie]) {\n                      E3[ie] = true;\n                      var Se = b[ie], Le = p3[ie];\n                      b[Le] >= 0 && (b[Le] = Se), p3[Se] >= 0 && (p3[Se] = Le), N2[Se] >= 0 && G2(N2[Se], M4(Se)), N2[Le] >= 0 && G2(N2[Le], M4(Le));\n                    }\n                  }\n                  for (var j3 = [], N2 = new Array(v3), S2 = 0; S2 < v3; ++S2) {\n                    var H = k4[S2] = M4(S2);\n                    H < 1 / 0 ? (N2[S2] = j3.length, j3.push(S2)) : N2[S2] = -1;\n                  }\n                  for (var te = j3.length, S2 = te >> 1; S2 >= 0; --S2) z3(S2);\n                  for (; ; ) {\n                    var oe = V2();\n                    if (oe < 0 || k4[oe] > d3) break;\n                    Z(oe);\n                  }\n                  for (var _e = [], S2 = 0; S2 < v3; ++S2) E3[S2] || (N2[S2] = _e.length, _e.push(h3[S2].slice()));\n                  var Ee = _e.length;\n                  function Ce(ie, Se) {\n                    if (ie[Se] < 0) return Se;\n                    var Le = Se, Ae = Se;\n                    do {\n                      var Fe = ie[Ae];\n                      if (!E3[Ae] || Fe < 0 || Fe === Ae || (Ae = Fe, Fe = ie[Ae], !E3[Ae] || Fe < 0 || Fe === Ae)) break;\n                      Ae = Fe, Le = ie[Le];\n                    } while (Le !== Ae);\n                    for (var Pe = Se; Pe !== Ae; Pe = ie[Pe]) ie[Pe] = Ae;\n                    return Ae;\n                  }\n                  var me = [];\n                  return f4.forEach(function(ie) {\n                    var Se = Ce(b, ie[0]), Le = Ce(p3, ie[1]);\n                    if (Se >= 0 && Le >= 0 && Se !== Le) {\n                      var Ae = N2[Se], Fe = N2[Le];\n                      Ae !== Fe && me.push([Ae, Fe]);\n                    }\n                  }), l3.unique(l3.normalize(me)), { positions: _e, edges: me };\n                }\n              }, 5911: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = l3[0], d3 = l3[1], v3 = l3[2];\n                  return o4[0] = c5 * v3 - f4 * d3, o4[1] = f4 * h3 - u4 * v3, o4[2] = u4 * d3 - c5 * h3, o4;\n                }\n              }, 5964: function(i3) {\n                "use strict";\n                i3.exports = function(a4) {\n                  return !a4 && a4 !== 0 ? "" : a4.toString();\n                };\n              }, 5995: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(7642), l3 = o4(6037);\n                function u4(c5, f4) {\n                  return s3(f4).filter(function(h3) {\n                    for (var d3 = new Array(h3.length), v3 = 0; v3 < h3.length; ++v3) d3[v3] = f4[h3[v3]];\n                    return l3(d3) * c5 < 1;\n                  });\n                }\n              }, 6037: function(i3, a4, o4) {\n                i3.exports = l3;\n                var s3 = o4(3628);\n                function l3(u4) {\n                  for (var c5 = s3(u4), f4 = 0, h3 = 0; h3 < u4.length; ++h3) for (var d3 = u4[h3], v3 = 0; v3 < c5.length; ++v3) f4 += Math.pow(d3[v3] - c5[v3], 2);\n                  return Math.sqrt(f4 / u4.length);\n                }\n              }, 6079: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = u4[0], f4 = u4[1], h3 = u4[2], d3 = Math.sqrt(c5 * c5 + f4 * f4 + h3 * h3), v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3, V2, G2, Z, j3, N2, H, te, oe;\n                  return Math.abs(d3) < 1e-6 ? null : (d3 = 1 / d3, c5 *= d3, f4 *= d3, h3 *= d3, v3 = Math.sin(l3), _2 = Math.cos(l3), b = 1 - _2, p3 = s3[0], k4 = s3[1], E3 = s3[2], S2 = s3[3], L3 = s3[4], x2 = s3[5], C3 = s3[6], M4 = s3[7], g3 = s3[8], P3 = s3[9], T3 = s3[10], z3 = s3[11], O3 = c5 * c5 * b + _2, V2 = f4 * c5 * b + h3 * v3, G2 = h3 * c5 * b - f4 * v3, Z = c5 * f4 * b - h3 * v3, j3 = f4 * f4 * b + _2, N2 = h3 * f4 * b + c5 * v3, H = c5 * h3 * b + f4 * v3, te = f4 * h3 * b - c5 * v3, oe = h3 * h3 * b + _2, o4[0] = p3 * O3 + L3 * V2 + g3 * G2, o4[1] = k4 * O3 + x2 * V2 + P3 * G2, o4[2] = E3 * O3 + C3 * V2 + T3 * G2, o4[3] = S2 * O3 + M4 * V2 + z3 * G2, o4[4] = p3 * Z + L3 * j3 + g3 * N2, o4[5] = k4 * Z + x2 * j3 + P3 * N2, o4[6] = E3 * Z + C3 * j3 + T3 * N2, o4[7] = S2 * Z + M4 * j3 + z3 * N2, o4[8] = p3 * H + L3 * te + g3 * oe, o4[9] = k4 * H + x2 * te + P3 * oe, o4[10] = E3 * H + C3 * te + T3 * oe, o4[11] = S2 * H + M4 * te + z3 * oe, s3 !== o4 && (o4[12] = s3[12], o4[13] = s3[13], o4[14] = s3[14], o4[15] = s3[15]), o4);\n                }\n              }, 6141: function(i3, a4, o4) {\n                i3.exports = o4(2953);\n              }, 6199: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1338), l3 = { zero: function(L3, x2, C3, M4) {\n                  var g3 = L3[0], P3 = C3[0];\n                  M4 |= 0;\n                  var T3 = 0, z3 = P3;\n                  for (T3 = 0; T3 < g3; ++T3) x2[M4] = 0, M4 += z3;\n                }, fdTemplate1: function(L3, x2, C3, M4, g3, P3, T3) {\n                  var z3 = L3[0], O3 = C3[0], V2 = P3[0], G2 = -1 * O3, Z = O3;\n                  M4 |= 0, T3 |= 0;\n                  var j3 = 0, N2 = O3, H = V2;\n                  for (j3 = 0; j3 < z3; ++j3) g3[T3] = 0.5 * (x2[M4 + G2] - x2[M4 + Z]), M4 += N2, T3 += H;\n                }, fdTemplate2: function(L3, x2, C3, M4, g3, P3, T3, z3, O3, V2) {\n                  var G2 = L3[0], Z = L3[1], j3 = C3[0], N2 = C3[1], H = P3[0], te = P3[1], oe = O3[0], _e = O3[1], Ee = -1 * j3, Ce = j3, me = -1 * N2, ie = N2;\n                  M4 |= 0, T3 |= 0, V2 |= 0;\n                  var Se = 0, Le = 0, Ae = N2, Fe = j3 - Z * N2, Pe = te, ge = H - Z * te, Re = _e, ce = oe - Z * _e;\n                  for (Le = 0; Le < G2; ++Le) {\n                    for (Se = 0; Se < Z; ++Se) g3[T3] = 0.5 * (x2[M4 + Ee] - x2[M4 + Ce]), z3[V2] = 0.5 * (x2[M4 + me] - x2[M4 + ie]), M4 += Ae, T3 += Pe, V2 += Re;\n                    M4 += Fe, T3 += ge, V2 += ce;\n                  }\n                } }, u4 = { cdiff: function(L3) {\n                  var x2 = {};\n                  return function(M4, g3, P3) {\n                    var T3 = M4.dtype, z3 = M4.order, O3 = g3.dtype, V2 = g3.order, G2 = P3.dtype, Z = P3.order, j3 = [T3, z3.join(), O3, V2.join(), G2, Z.join()].join(), N2 = x2[j3];\n                    return N2 || (x2[j3] = N2 = L3([T3, z3, O3, V2, G2, Z])), N2(M4.shape.slice(0), M4.data, M4.stride, M4.offset | 0, g3.data, g3.stride, g3.offset | 0, P3.data, P3.stride, P3.offset | 0);\n                  };\n                }, zero: function(L3) {\n                  var x2 = {};\n                  return function(M4) {\n                    var g3 = M4.dtype, P3 = M4.order, T3 = [g3, P3.join()].join(), z3 = x2[T3];\n                    return z3 || (x2[T3] = z3 = L3([g3, P3])), z3(M4.shape.slice(0), M4.data, M4.stride, M4.offset | 0);\n                  };\n                }, fdTemplate1: function(L3) {\n                  var x2 = {};\n                  return function(M4, g3) {\n                    var P3 = M4.dtype, T3 = M4.order, z3 = g3.dtype, O3 = g3.order, V2 = [P3, T3.join(), z3, O3.join()].join(), G2 = x2[V2];\n                    return G2 || (x2[V2] = G2 = L3([P3, T3, z3, O3])), G2(M4.shape.slice(0), M4.data, M4.stride, M4.offset | 0, g3.data, g3.stride, g3.offset | 0);\n                  };\n                }, fdTemplate2: function(L3) {\n                  var x2 = {};\n                  return function(M4, g3, P3) {\n                    var T3 = M4.dtype, z3 = M4.order, O3 = g3.dtype, V2 = g3.order, G2 = P3.dtype, Z = P3.order, j3 = [T3, z3.join(), O3, V2.join(), G2, Z.join()].join(), N2 = x2[j3];\n                    return N2 || (x2[j3] = N2 = L3([T3, z3, O3, V2, G2, Z])), N2(M4.shape.slice(0), M4.data, M4.stride, M4.offset | 0, g3.data, g3.stride, g3.offset | 0, P3.data, P3.stride, P3.offset | 0);\n                  };\n                } };\n                function c5(L3) {\n                  var x2 = u4[L3.funcName];\n                  return x2(f4.bind(void 0, L3));\n                }\n                function f4(L3) {\n                  return l3[L3.funcName];\n                }\n                function h3(L3) {\n                  return c5({ funcName: L3.funcName });\n                }\n                var d3 = {}, v3 = {}, _2 = { body: "", args: [], thisVars: [], localVars: [] }, b = h3({ funcName: "cdiff" }), p3 = h3({ funcName: "zero" });\n                function k4(L3) {\n                  return L3 in d3 ? d3[L3] : d3[L3] = h3({ funcName: "fdTemplate" + L3 });\n                }\n                function E3(L3, x2, C3, M4) {\n                  return function(g3, P3) {\n                    var T3 = P3.shape.slice();\n                    return T3[0] > 2 && T3[1] > 2 && M4(P3.pick(-1, -1).lo(1, 1).hi(T3[0] - 2, T3[1] - 2), g3.pick(-1, -1, 0).lo(1, 1).hi(T3[0] - 2, T3[1] - 2), g3.pick(-1, -1, 1).lo(1, 1).hi(T3[0] - 2, T3[1] - 2)), T3[1] > 2 && (C3(P3.pick(0, -1).lo(1).hi(T3[1] - 2), g3.pick(0, -1, 1).lo(1).hi(T3[1] - 2)), x2(g3.pick(0, -1, 0).lo(1).hi(T3[1] - 2))), T3[1] > 2 && (C3(P3.pick(T3[0] - 1, -1).lo(1).hi(T3[1] - 2), g3.pick(T3[0] - 1, -1, 1).lo(1).hi(T3[1] - 2)), x2(g3.pick(T3[0] - 1, -1, 0).lo(1).hi(T3[1] - 2))), T3[0] > 2 && (C3(P3.pick(-1, 0).lo(1).hi(T3[0] - 2), g3.pick(-1, 0, 0).lo(1).hi(T3[0] - 2)), x2(g3.pick(-1, 0, 1).lo(1).hi(T3[0] - 2))), T3[0] > 2 && (C3(P3.pick(-1, T3[1] - 1).lo(1).hi(T3[0] - 2), g3.pick(-1, T3[1] - 1, 0).lo(1).hi(T3[0] - 2)), x2(g3.pick(-1, T3[1] - 1, 1).lo(1).hi(T3[0] - 2))), g3.set(0, 0, 0, 0), g3.set(0, 0, 1, 0), g3.set(T3[0] - 1, 0, 0, 0), g3.set(T3[0] - 1, 0, 1, 0), g3.set(0, T3[1] - 1, 0, 0), g3.set(0, T3[1] - 1, 1, 0), g3.set(T3[0] - 1, T3[1] - 1, 0, 0), g3.set(T3[0] - 1, T3[1] - 1, 1, 0), g3;\n                  };\n                }\n                function S2(L3) {\n                  var x2 = L3.join(), T3 = v3[x2];\n                  if (T3) return T3;\n                  for (var C3 = L3.length, M4 = [b, p3], g3 = 1; g3 <= C3; ++g3) M4.push(k4(g3));\n                  var P3 = E3, T3 = P3.apply(void 0, M4);\n                  return v3[x2] = T3, T3;\n                }\n                i3.exports = function(x2, C3, M4) {\n                  if (Array.isArray(M4) || (typeof M4 == "string" ? M4 = s3(C3.dimension, M4) : M4 = s3(C3.dimension, "clamp")), C3.size === 0) return x2;\n                  if (C3.dimension === 0) return x2.set(0), x2;\n                  var g3 = S2(M4);\n                  return g3(x2, C3);\n                };\n              }, 6204: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3, l3, u4, c5 = o4.length, f4 = 0;\n                  for (s3 = 0; s3 < c5; ++s3) f4 += o4[s3].length;\n                  var h3 = new Array(f4), d3 = 0;\n                  for (s3 = 0; s3 < c5; ++s3) {\n                    var v3 = o4[s3], _2 = v3.length;\n                    for (l3 = 0; l3 < _2; ++l3) {\n                      var b = h3[d3++] = new Array(_2 - 1), p3 = 0;\n                      for (u4 = 0; u4 < _2; ++u4) u4 !== l3 && (b[p3++] = v3[u4]);\n                      if (l3 & 1) {\n                        var k4 = b[1];\n                        b[1] = b[0], b[0] = k4;\n                      }\n                    }\n                  }\n                  return h3;\n                }\n              }, 6296: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = h3;\n                var s3 = o4(7261), l3 = o4(9977), u4 = o4(1811);\n                function c5(d3, v3) {\n                  this._controllerNames = Object.keys(d3), this._controllerList = this._controllerNames.map(function(_2) {\n                    return d3[_2];\n                  }), this._mode = v3, this._active = d3[v3], this._active || (this._mode = "turntable", this._active = d3.turntable), this.modes = this._controllerNames, this.computedMatrix = this._active.computedMatrix, this.computedEye = this._active.computedEye, this.computedUp = this._active.computedUp, this.computedCenter = this._active.computedCenter, this.computedRadius = this._active.computedRadius;\n                }\n                var f4 = c5.prototype;\n                f4.flush = function(d3) {\n                  for (var v3 = this._controllerList, _2 = 0; _2 < v3.length; ++_2) v3[_2].flush(d3);\n                }, f4.idle = function(d3) {\n                  for (var v3 = this._controllerList, _2 = 0; _2 < v3.length; ++_2) v3[_2].idle(d3);\n                }, f4.lookAt = function(d3, v3, _2, b) {\n                  for (var p3 = this._controllerList, k4 = 0; k4 < p3.length; ++k4) p3[k4].lookAt(d3, v3, _2, b);\n                }, f4.rotate = function(d3, v3, _2, b) {\n                  for (var p3 = this._controllerList, k4 = 0; k4 < p3.length; ++k4) p3[k4].rotate(d3, v3, _2, b);\n                }, f4.pan = function(d3, v3, _2, b) {\n                  for (var p3 = this._controllerList, k4 = 0; k4 < p3.length; ++k4) p3[k4].pan(d3, v3, _2, b);\n                }, f4.translate = function(d3, v3, _2, b) {\n                  for (var p3 = this._controllerList, k4 = 0; k4 < p3.length; ++k4) p3[k4].translate(d3, v3, _2, b);\n                }, f4.setMatrix = function(d3, v3) {\n                  for (var _2 = this._controllerList, b = 0; b < _2.length; ++b) _2[b].setMatrix(d3, v3);\n                }, f4.setDistanceLimits = function(d3, v3) {\n                  for (var _2 = this._controllerList, b = 0; b < _2.length; ++b) _2[b].setDistanceLimits(d3, v3);\n                }, f4.setDistance = function(d3, v3) {\n                  for (var _2 = this._controllerList, b = 0; b < _2.length; ++b) _2[b].setDistance(d3, v3);\n                }, f4.recalcMatrix = function(d3) {\n                  this._active.recalcMatrix(d3);\n                }, f4.getDistance = function(d3) {\n                  return this._active.getDistance(d3);\n                }, f4.getDistanceLimits = function(d3) {\n                  return this._active.getDistanceLimits(d3);\n                }, f4.lastT = function() {\n                  return this._active.lastT();\n                }, f4.setMode = function(d3) {\n                  if (d3 !== this._mode) {\n                    var v3 = this._controllerNames.indexOf(d3);\n                    if (!(v3 < 0)) {\n                      var _2 = this._active, b = this._controllerList[v3], p3 = Math.max(_2.lastT(), b.lastT());\n                      _2.recalcMatrix(p3), b.setMatrix(p3, _2.computedMatrix), this._active = b, this._mode = d3, this.computedMatrix = this._active.computedMatrix, this.computedEye = this._active.computedEye, this.computedUp = this._active.computedUp, this.computedCenter = this._active.computedCenter, this.computedRadius = this._active.computedRadius;\n                    }\n                  }\n                }, f4.getMode = function() {\n                  return this._mode;\n                };\n                function h3(d3) {\n                  d3 = d3 || {};\n                  var v3 = d3.eye || [0, 0, 1], _2 = d3.center || [0, 0, 0], b = d3.up || [0, 1, 0], p3 = d3.distanceLimits || [0, 1 / 0], k4 = d3.mode || "turntable", E3 = s3(), S2 = l3(), L3 = u4();\n                  return E3.setDistanceLimits(p3[0], p3[1]), E3.lookAt(0, v3, _2, b), S2.setDistanceLimits(p3[0], p3[1]), S2.lookAt(0, v3, _2, b), L3.setDistanceLimits(p3[0], p3[1]), L3.lookAt(0, v3, _2, b), new c5({ turntable: E3, orbit: S2, matrix: L3 }, k4);\n                }\n              }, 6330: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1533);\n                i3.exports = l3;\n                function l3(u4) {\n                  return Array.isArray(u4) && u4.length === 2 && s3(u4[0]) && s3(u4[1]);\n                }\n              }, 6405: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2931);\n                i3.exports = function(u4, c5) {\n                  var f4 = u4.positions, h3 = u4.vectors, d3 = { positions: [], vertexIntensity: [], vertexIntensityBounds: u4.vertexIntensityBounds, vectors: [], cells: [], coneOffset: u4.coneOffset, colormap: u4.colormap };\n                  if (u4.positions.length === 0) return c5 && (c5[0] = [0, 0, 0], c5[1] = [0, 0, 0]), d3;\n                  for (var v3 = 0, _2 = 1 / 0, b = -1 / 0, p3 = 1 / 0, k4 = -1 / 0, E3 = 1 / 0, S2 = -1 / 0, L3 = null, x2 = null, C3 = [], M4 = 1 / 0, g3 = false, P3 = u4.coneSizemode === "raw", T3 = 0; T3 < f4.length; T3++) {\n                    var z3 = f4[T3];\n                    _2 = Math.min(z3[0], _2), b = Math.max(z3[0], b), p3 = Math.min(z3[1], p3), k4 = Math.max(z3[1], k4), E3 = Math.min(z3[2], E3), S2 = Math.max(z3[2], S2);\n                    var O3 = h3[T3];\n                    if (s3.length(O3) > v3 && (v3 = s3.length(O3)), T3 && !P3) {\n                      var V2 = 2 * s3.distance(L3, z3) / (s3.length(x2) + s3.length(O3));\n                      V2 ? (M4 = Math.min(M4, V2), g3 = false) : g3 = true;\n                    }\n                    g3 || (L3 = z3, x2 = O3), C3.push(O3);\n                  }\n                  var G2 = [_2, p3, E3], Z = [b, k4, S2];\n                  c5 && (c5[0] = G2, c5[1] = Z), v3 === 0 && (v3 = 1);\n                  var j3 = 1 / v3;\n                  isFinite(M4) || (M4 = 1), d3.vectorScale = M4;\n                  var N2 = u4.coneSize || (P3 ? 1 : 0.5);\n                  u4.absoluteConeSize && (N2 = u4.absoluteConeSize * j3), d3.coneScale = N2;\n                  for (var T3 = 0, H = 0; T3 < f4.length; T3++) for (var z3 = f4[T3], te = z3[0], oe = z3[1], _e = z3[2], Ee = C3[T3], Ce = s3.length(Ee) * j3, me = 0, ie = 8; me < ie; me++) {\n                    d3.positions.push([te, oe, _e, H++]), d3.positions.push([te, oe, _e, H++]), d3.positions.push([te, oe, _e, H++]), d3.positions.push([te, oe, _e, H++]), d3.positions.push([te, oe, _e, H++]), d3.positions.push([te, oe, _e, H++]), d3.vectors.push(Ee), d3.vectors.push(Ee), d3.vectors.push(Ee), d3.vectors.push(Ee), d3.vectors.push(Ee), d3.vectors.push(Ee), d3.vertexIntensity.push(Ce, Ce, Ce), d3.vertexIntensity.push(Ce, Ce, Ce);\n                    var Se = d3.positions.length;\n                    d3.cells.push([Se - 6, Se - 5, Se - 4], [Se - 3, Se - 2, Se - 1]);\n                  }\n                  return d3;\n                };\n                var l3 = o4(614);\n                i3.exports.createMesh = o4(9060), i3.exports.createConeMesh = function(u4, c5) {\n                  return i3.exports.createMesh(u4, c5, { shaders: l3, traceType: "cone" });\n                };\n              }, 6429: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = x2;\n                var s3 = o4(8828), l3 = o4(6760), u4 = o4(5202), c5 = o4(3250), f4 = new Array(16), h3 = new Array(8), d3 = new Array(8), v3 = new Array(3), _2 = [0, 0, 0];\n                (function() {\n                  for (var C3 = 0; C3 < 8; ++C3) h3[C3] = [1, 1, 1, 1], d3[C3] = [1, 1, 1];\n                })();\n                function b(C3, M4, g3) {\n                  for (var P3 = 0; P3 < 4; ++P3) {\n                    C3[P3] = g3[12 + P3];\n                    for (var T3 = 0; T3 < 3; ++T3) C3[P3] += M4[T3] * g3[4 * T3 + P3];\n                  }\n                }\n                var p3 = [[0, 0, 1, 0, 0], [0, 0, -1, 1, 0], [0, -1, 0, 1, 0], [0, 1, 0, 1, 0], [-1, 0, 0, 1, 0], [1, 0, 0, 1, 0]];\n                function k4(C3) {\n                  for (var M4 = 0; M4 < p3.length; ++M4) if (C3 = u4.positive(C3, p3[M4]), C3.length < 3) return 0;\n                  for (var g3 = C3[0], P3 = g3[0] / g3[3], T3 = g3[1] / g3[3], z3 = 0, M4 = 1; M4 + 1 < C3.length; ++M4) {\n                    var O3 = C3[M4], V2 = C3[M4 + 1], G2 = O3[0] / O3[3], Z = O3[1] / O3[3], j3 = V2[0] / V2[3], N2 = V2[1] / V2[3], H = G2 - P3, te = Z - T3, oe = j3 - P3, _e = N2 - T3;\n                    z3 += Math.abs(H * _e - te * oe);\n                  }\n                  return z3;\n                }\n                var E3 = [1, 1, 1], S2 = [0, 0, 0], L3 = { cubeEdges: E3, axis: S2 };\n                function x2(C3, M4, g3, P3, T3) {\n                  l3(f4, M4, C3), l3(f4, g3, f4);\n                  for (var z3 = 0, O3 = 0; O3 < 2; ++O3) {\n                    v3[2] = P3[O3][2];\n                    for (var V2 = 0; V2 < 2; ++V2) {\n                      v3[1] = P3[V2][1];\n                      for (var G2 = 0; G2 < 2; ++G2) v3[0] = P3[G2][0], b(h3[z3], v3, f4), z3 += 1;\n                    }\n                  }\n                  for (var Z = -1, O3 = 0; O3 < 8; ++O3) {\n                    for (var j3 = h3[O3][3], N2 = 0; N2 < 3; ++N2) d3[O3][N2] = h3[O3][N2] / j3;\n                    T3 && (d3[O3][2] *= -1), j3 < 0 && (Z < 0 || d3[O3][2] < d3[Z][2]) && (Z = O3);\n                  }\n                  if (Z < 0) {\n                    Z = 0;\n                    for (var H = 0; H < 3; ++H) {\n                      for (var te = (H + 2) % 3, oe = (H + 1) % 3, _e = -1, Ee = -1, Ce = 0; Ce < 2; ++Ce) {\n                        var me = Ce << H, ie = me + (Ce << te) + (1 - Ce << oe), Se = me + (1 - Ce << te) + (Ce << oe);\n                        c5(d3[me], d3[ie], d3[Se], _2) < 0 || (Ce ? _e = 1 : Ee = 1);\n                      }\n                      if (_e < 0 || Ee < 0) {\n                        Ee > _e && (Z |= 1 << H);\n                        continue;\n                      }\n                      for (var Ce = 0; Ce < 2; ++Ce) {\n                        var me = Ce << H, ie = me + (Ce << te) + (1 - Ce << oe), Se = me + (1 - Ce << te) + (Ce << oe), Le = k4([h3[me], h3[ie], h3[Se], h3[me + (1 << te) + (1 << oe)]]);\n                        Ce ? _e = Le : Ee = Le;\n                      }\n                      if (Ee > _e) {\n                        Z |= 1 << H;\n                        continue;\n                      }\n                    }\n                  }\n                  for (var Ae = 7 ^ Z, Fe = -1, O3 = 0; O3 < 8; ++O3) O3 === Z || O3 === Ae || (Fe < 0 || d3[Fe][1] > d3[O3][1]) && (Fe = O3);\n                  for (var Pe = -1, O3 = 0; O3 < 3; ++O3) {\n                    var ge = Fe ^ 1 << O3;\n                    if (!(ge === Z || ge === Ae)) {\n                      Pe < 0 && (Pe = ge);\n                      var oe = d3[ge];\n                      oe[0] < d3[Pe][0] && (Pe = ge);\n                    }\n                  }\n                  for (var Re = -1, O3 = 0; O3 < 3; ++O3) {\n                    var ge = Fe ^ 1 << O3;\n                    if (!(ge === Z || ge === Ae || ge === Pe)) {\n                      Re < 0 && (Re = ge);\n                      var oe = d3[ge];\n                      oe[0] > d3[Re][0] && (Re = ge);\n                    }\n                  }\n                  var ce = E3;\n                  ce[0] = ce[1] = ce[2] = 0, ce[s3.log2(Pe ^ Fe)] = Fe & Pe, ce[s3.log2(Fe ^ Re)] = Fe & Re;\n                  var Ze = Re ^ 7;\n                  Ze === Z || Ze === Ae ? (Ze = Pe ^ 7, ce[s3.log2(Re ^ Ze)] = Ze & Re) : ce[s3.log2(Pe ^ Ze)] = Ze & Pe;\n                  for (var ut = S2, pt = Z, H = 0; H < 3; ++H) pt & 1 << H ? ut[H] = -1 : ut[H] = 1;\n                  return L3;\n                }\n              }, 6444: function(i3, a4) {\n                "use strict";\n                a4.create = s3, a4.equal = l3;\n                function o4(u4, c5) {\n                  var f4 = u4 + "", h3 = f4.indexOf("."), d3 = 0;\n                  h3 >= 0 && (d3 = f4.length - h3 - 1);\n                  var v3 = Math.pow(10, d3), _2 = Math.round(u4 * c5 * v3), b = _2 + "";\n                  if (b.indexOf("e") >= 0) return b;\n                  var p3 = _2 / v3, k4 = _2 % v3;\n                  _2 < 0 ? (p3 = -Math.ceil(p3) | 0, k4 = -k4 | 0) : (p3 = Math.floor(p3) | 0, k4 = k4 | 0);\n                  var E3 = "" + p3;\n                  if (_2 < 0 && (E3 = "-" + E3), d3) {\n                    for (var S2 = "" + k4; S2.length < d3; ) S2 = "0" + S2;\n                    return E3 + "." + S2;\n                  } else return E3;\n                }\n                function s3(u4, c5) {\n                  for (var f4 = [], h3 = 0; h3 < 3; ++h3) {\n                    for (var d3 = [], v3 = 0.5 * (u4[0][h3] + u4[1][h3]), _2 = 0; _2 * c5[h3] <= u4[1][h3]; ++_2) d3.push({ x: _2 * c5[h3], text: o4(c5[h3], _2) });\n                    for (var _2 = -1; _2 * c5[h3] >= u4[0][h3]; --_2) d3.push({ x: _2 * c5[h3], text: o4(c5[h3], _2) });\n                    f4.push(d3);\n                  }\n                  return f4;\n                }\n                function l3(u4, c5) {\n                  for (var f4 = 0; f4 < 3; ++f4) {\n                    if (u4[f4].length !== c5[f4].length) return false;\n                    for (var h3 = 0; h3 < u4[f4].length; ++h3) {\n                      var d3 = u4[f4][h3], v3 = c5[f4][h3];\n                      if (d3.x !== v3.x || d3.text !== v3.text || d3.font !== v3.font || d3.fontColor !== v3.fontColor || d3.fontSize !== v3.fontSize || d3.dx !== v3.dx || d3.dy !== v3.dy) return false;\n                    }\n                  }\n                  return true;\n                }\n              }, 6468: function(i3) {\n                i3.exports = function(o4) {\n                  return atob(o4);\n                };\n              }, 6504: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(869);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  return s3(u4[0].mul(c5[0]), u4[1].mul(c5[1]));\n                }\n              }, 6582: function(i3, a4, o4) {\n                var s3 = o4(7894);\n                i3.exports = l3;\n                function l3(u4, c5, f4, h3) {\n                  var d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3 = c5[0], M4 = c5[1], g3 = c5[2], P3 = h3[0], T3 = h3[1], z3 = h3[2], O3 = f4[0], V2 = f4[1], G2 = f4[2];\n                  return Math.abs(C3 - O3) < 1e-6 && Math.abs(M4 - V2) < 1e-6 && Math.abs(g3 - G2) < 1e-6 ? s3(u4) : (E3 = C3 - O3, S2 = M4 - V2, L3 = g3 - G2, x2 = 1 / Math.sqrt(E3 * E3 + S2 * S2 + L3 * L3), E3 *= x2, S2 *= x2, L3 *= x2, d3 = T3 * L3 - z3 * S2, v3 = z3 * E3 - P3 * L3, _2 = P3 * S2 - T3 * E3, x2 = Math.sqrt(d3 * d3 + v3 * v3 + _2 * _2), x2 ? (x2 = 1 / x2, d3 *= x2, v3 *= x2, _2 *= x2) : (d3 = 0, v3 = 0, _2 = 0), b = S2 * _2 - L3 * v3, p3 = L3 * d3 - E3 * _2, k4 = E3 * v3 - S2 * d3, x2 = Math.sqrt(b * b + p3 * p3 + k4 * k4), x2 ? (x2 = 1 / x2, b *= x2, p3 *= x2, k4 *= x2) : (b = 0, p3 = 0, k4 = 0), u4[0] = d3, u4[1] = b, u4[2] = E3, u4[3] = 0, u4[4] = v3, u4[5] = p3, u4[6] = S2, u4[7] = 0, u4[8] = _2, u4[9] = k4, u4[10] = L3, u4[11] = 0, u4[12] = -(d3 * C3 + v3 * M4 + _2 * g3), u4[13] = -(b * C3 + p3 * M4 + k4 * g3), u4[14] = -(E3 * C3 + S2 * M4 + L3 * g3), u4[15] = 1, u4);\n                }\n              }, 6621: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] * l3, o4[1] = s3[1] * l3, o4[2] = s3[2] * l3, o4;\n                }\n              }, 6658: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = s3[0], f4 = s3[1], h3 = s3[2];\n                  return o4[0] = c5 + u4 * (l3[0] - c5), o4[1] = f4 + u4 * (l3[1] - f4), o4[2] = h3 + u4 * (l3[2] - h3), o4;\n                }\n              }, 6690: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] / l3[0], o4[1] = s3[1] / l3[1], o4[2] = s3[2] / l3[2], o4;\n                }\n              }, 6729: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3642), l3 = o4(395);\n                i3.exports = u4;\n                function u4(d3) {\n                  var v3, _2, b, p3, k4, E3, S2, L3, g3, x2, C3;\n                  if (d3 || (d3 = {}), L3 = (d3.nshades || 72) - 1, S2 = d3.format || "hex", E3 = d3.colormap, E3 || (E3 = "jet"), typeof E3 == "string") {\n                    if (E3 = E3.toLowerCase(), !s3[E3]) throw Error(E3 + " not a supported colorscale");\n                    k4 = s3[E3];\n                  } else if (Array.isArray(E3)) k4 = E3.slice();\n                  else throw Error("unsupported colormap option", E3);\n                  if (k4.length > L3 + 1) throw new Error(E3 + " map requires nshades to be at least size " + k4.length);\n                  Array.isArray(d3.alpha) ? d3.alpha.length !== 2 ? x2 = [1, 1] : x2 = d3.alpha.slice() : typeof d3.alpha == "number" ? x2 = [d3.alpha, d3.alpha] : x2 = [1, 1], v3 = k4.map(function(z3) {\n                    return Math.round(z3.index * L3);\n                  }), x2[0] = Math.min(Math.max(x2[0], 0), 1), x2[1] = Math.min(Math.max(x2[1], 0), 1);\n                  var M4 = k4.map(function(z3, O3) {\n                    var V2 = k4[O3].index, G2 = k4[O3].rgb.slice();\n                    return G2.length === 4 && G2[3] >= 0 && G2[3] <= 1 || (G2[3] = x2[0] + (x2[1] - x2[0]) * V2), G2;\n                  }), g3 = [];\n                  for (C3 = 0; C3 < v3.length - 1; ++C3) {\n                    p3 = v3[C3 + 1] - v3[C3], _2 = M4[C3], b = M4[C3 + 1];\n                    for (var P3 = 0; P3 < p3; P3++) {\n                      var T3 = P3 / p3;\n                      g3.push([Math.round(l3(_2[0], b[0], T3)), Math.round(l3(_2[1], b[1], T3)), Math.round(l3(_2[2], b[2], T3)), l3(_2[3], b[3], T3)]);\n                    }\n                  }\n                  return g3.push(k4[k4.length - 1].rgb.concat(x2[1])), S2 === "hex" ? g3 = g3.map(f4) : S2 === "rgbaString" ? g3 = g3.map(h3) : S2 === "float" && (g3 = g3.map(c5)), g3;\n                }\n                function c5(d3) {\n                  return [d3[0] / 255, d3[1] / 255, d3[2] / 255, d3[3]];\n                }\n                function f4(d3) {\n                  for (var v3, _2 = "#", b = 0; b < 3; ++b) v3 = d3[b], v3 = v3.toString(16), _2 += ("00" + v3).substr(v3.length);\n                  return _2;\n                }\n                function h3(d3) {\n                  return "rgba(" + d3.join(",") + ")";\n                }\n              }, 6740: function(i3, a4, o4) {\n                var s3 = o4(3236), l3 = s3([`precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn\'t (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n  float segmentCount = 8.0;\n\n  float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d);\n  vec3 y = v * sin(angle) * length(d);\n  vec3 v3 = x + y;\n\n  normal = normalize(v3);\n\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\n\nuniform float vectorScale, tubeScale;\nuniform mat4 model, view, projection, inverseModel;\nuniform vec3 eyePosition, lightPosition;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  // Scale the vector magnitude to stay constant with\n  // model & view changes.\n  vec3 normal;\n  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  //Lighting geometry parameters\n  vec4 cameraCoordinate = view * tubePosition;\n  cameraCoordinate.xyz /= cameraCoordinate.w;\n  f_lightDirection = lightPosition - cameraCoordinate.xyz;\n  f_eyeDirection   = eyePosition - cameraCoordinate.xyz;\n  f_normal = normalize((vec4(normal, 0.0) * inverseModel).xyz);\n\n  // vec4 m_position  = model * vec4(tubePosition, 1.0);\n  vec4 t_position  = view * tubePosition;\n  gl_Position      = projection * t_position;\n\n  f_color          = color;\n  f_data           = tubePosition.xyz;\n  f_position       = position.xyz;\n  f_uv             = uv;\n}\n`]), u4 = s3([`#extension GL_OES_standard_derivatives : enable\n\nprecision highp float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n  float NdotH = max(x, 0.0001);\n  float cos2Alpha = NdotH * NdotH;\n  float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n  float roughness2 = roughness * roughness;\n  float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n  return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n  vec3 lightDirection,\n  vec3 viewDirection,\n  vec3 surfaceNormal,\n  float roughness,\n  float fresnel) {\n\n  float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n  float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n  //Half angle vector\n  vec3 H = normalize(lightDirection + viewDirection);\n\n  //Geometric term\n  float NdotH = max(dot(surfaceNormal, H), 0.0);\n  float VdotH = max(dot(viewDirection, H), 0.000001);\n  float LdotH = max(dot(lightDirection, H), 0.000001);\n  float G1 = (2.0 * NdotH * VdotN) / VdotH;\n  float G2 = (2.0 * NdotH * LdotN) / LdotH;\n  float G = min(1.0, min(G1, G2));\n  \n  //Distribution term\n  float D = beckmannDistribution(NdotH, roughness);\n\n  //Fresnel term\n  float F = pow(1.0 - VdotN, fresnel);\n\n  //Multiply terms and done\n  return  G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness, fresnel, kambient, kdiffuse, kspecular, opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal, f_lightDirection, f_eyeDirection, f_data, f_position;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n  vec3 N = normalize(f_normal);\n  vec3 L = normalize(f_lightDirection);\n  vec3 V = normalize(f_eyeDirection);\n\n  if(gl_FrontFacing) {\n    N = -N;\n  }\n\n  float specular = min(1.0, max(0.0, cookTorranceSpecular(L, V, N, roughness, fresnel)));\n  float diffuse  = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n  vec4 surfaceColor = f_color * texture2D(texture, f_uv);\n  vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular,  1.0);\n\n  gl_FragColor = litColor * opacity;\n}\n`]), c5 = s3([`precision highp float;\n\nprecision highp float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n  // Return up-vector for only-z vector.\n  // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn\'t (0,0,0).\n  // From the above if-statement we have ||a|| > 0  U  ||b|| > 0.\n  // Assign z = 0, x = -b, y = a:\n  // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n  if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n    return normalize(vec3(-v.y, v.x, 0.0));\n  } else {\n    return normalize(vec3(0.0, v.z, -v.y));\n  }\n}\n\n// Calculate the tube vertex and normal at the given index.\n//\n// The returned vertex is for a tube ring with its center at origin, radius of length(d), pointing in the direction of d.\n//\n// Each tube segment is made up of a ring of vertices.\n// These vertices are used to make up the triangles of the tube by connecting them together in the vertex array.\n// The indexes of tube segments run from 0 to 8.\n//\nvec3 getTubePosition(vec3 d, float index, out vec3 normal) {\n  float segmentCount = 8.0;\n\n  float angle = 2.0 * 3.14159 * (index / segmentCount);\n\n  vec3 u = getOrthogonalVector(d);\n  vec3 v = normalize(cross(u, d));\n\n  vec3 x = u * cos(angle) * length(d);\n  vec3 y = v * sin(angle) * length(d);\n  vec3 v3 = x + y;\n\n  normal = normalize(v3);\n\n  return v3;\n}\n\nattribute vec4 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform float tubeScale;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  vec3 normal;\n  vec3 XYZ = getTubePosition(mat3(model) * (tubeScale * vector.w * normalize(vector.xyz)), position.w, normal);\n  vec4 tubePosition = model * vec4(position.xyz, 1.0) + vec4(XYZ, 0.0);\n\n  gl_Position = projection * (view * tubePosition);\n  f_id        = id;\n  f_position  = position.xyz;\n}\n`]), f4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3  clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], f_position)) discard;\n\n  gl_FragColor = vec4(pickId, f_id.xyz);\n}`]);\n                a4.meshShader = { vertex: l3, fragment: u4, attributes: [{ name: "position", type: "vec4" }, { name: "color", type: "vec4" }, { name: "uv", type: "vec2" }, { name: "vector", type: "vec4" }] }, a4.pickShader = { vertex: c5, fragment: f4, attributes: [{ name: "position", type: "vec4" }, { name: "id", type: "vec4" }, { name: "vector", type: "vec4" }] };\n              }, 6743: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = s3[3], d3 = u4 + u4, v3 = c5 + c5, _2 = f4 + f4, b = u4 * d3, p3 = u4 * v3, k4 = u4 * _2, E3 = c5 * v3, S2 = c5 * _2, L3 = f4 * _2, x2 = h3 * d3, C3 = h3 * v3, M4 = h3 * _2;\n                  return o4[0] = 1 - (E3 + L3), o4[1] = p3 + M4, o4[2] = k4 - C3, o4[3] = 0, o4[4] = p3 - M4, o4[5] = 1 - (b + L3), o4[6] = S2 + x2, o4[7] = 0, o4[8] = k4 + C3, o4[9] = S2 - x2, o4[10] = 1 - (b + E3), o4[11] = 0, o4[12] = l3[0], o4[13] = l3[1], o4[14] = l3[2], o4[15] = 1, o4;\n                }\n              }, 6760: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = s3[0], c5 = s3[1], f4 = s3[2], h3 = s3[3], d3 = s3[4], v3 = s3[5], _2 = s3[6], b = s3[7], p3 = s3[8], k4 = s3[9], E3 = s3[10], S2 = s3[11], L3 = s3[12], x2 = s3[13], C3 = s3[14], M4 = s3[15], g3 = l3[0], P3 = l3[1], T3 = l3[2], z3 = l3[3];\n                  return o4[0] = g3 * u4 + P3 * d3 + T3 * p3 + z3 * L3, o4[1] = g3 * c5 + P3 * v3 + T3 * k4 + z3 * x2, o4[2] = g3 * f4 + P3 * _2 + T3 * E3 + z3 * C3, o4[3] = g3 * h3 + P3 * b + T3 * S2 + z3 * M4, g3 = l3[4], P3 = l3[5], T3 = l3[6], z3 = l3[7], o4[4] = g3 * u4 + P3 * d3 + T3 * p3 + z3 * L3, o4[5] = g3 * c5 + P3 * v3 + T3 * k4 + z3 * x2, o4[6] = g3 * f4 + P3 * _2 + T3 * E3 + z3 * C3, o4[7] = g3 * h3 + P3 * b + T3 * S2 + z3 * M4, g3 = l3[8], P3 = l3[9], T3 = l3[10], z3 = l3[11], o4[8] = g3 * u4 + P3 * d3 + T3 * p3 + z3 * L3, o4[9] = g3 * c5 + P3 * v3 + T3 * k4 + z3 * x2, o4[10] = g3 * f4 + P3 * _2 + T3 * E3 + z3 * C3, o4[11] = g3 * h3 + P3 * b + T3 * S2 + z3 * M4, g3 = l3[12], P3 = l3[13], T3 = l3[14], z3 = l3[15], o4[12] = g3 * u4 + P3 * d3 + T3 * p3 + z3 * L3, o4[13] = g3 * c5 + P3 * v3 + T3 * k4 + z3 * x2, o4[14] = g3 * f4 + P3 * _2 + T3 * E3 + z3 * C3, o4[15] = g3 * h3 + P3 * b + T3 * S2 + z3 * M4, o4;\n                }\n              }, 6768: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(6859);\n                i3.exports = l3;\n                function l3(u4) {\n                  return new s3(u4);\n                }\n              }, 6803: function(i3, a4, o4) {\n                "use strict";\n                var s3, l3 = o4(8828), u4 = o4(1755);\n                function c5(P3) {\n                  for (var T3 = 0, z3 = Math.max, O3 = 0, V2 = P3.length; O3 < V2; ++O3) T3 = z3(T3, P3[O3].length);\n                  return T3 - 1;\n                }\n                s3 = c5;\n                function f4(P3) {\n                  for (var T3 = -1, z3 = Math.max, O3 = 0, V2 = P3.length; O3 < V2; ++O3) for (var G2 = P3[O3], Z = 0, j3 = G2.length; Z < j3; ++Z) T3 = z3(T3, G2[Z]);\n                  return T3 + 1;\n                }\n                s3 = f4;\n                function h3(P3) {\n                  for (var T3 = new Array(P3.length), z3 = 0, O3 = P3.length; z3 < O3; ++z3) T3[z3] = P3[z3].slice(0);\n                  return T3;\n                }\n                s3 = h3;\n                function d3(P3, T3) {\n                  var z3 = P3.length, O3 = P3.length - T3.length, V2 = Math.min;\n                  if (O3) return O3;\n                  switch (z3) {\n                    case 0:\n                      return 0;\n                    case 1:\n                      return P3[0] - T3[0];\n                    case 2:\n                      var H = P3[0] + P3[1] - T3[0] - T3[1];\n                      return H || V2(P3[0], P3[1]) - V2(T3[0], T3[1]);\n                    case 3:\n                      var G2 = P3[0] + P3[1], Z = T3[0] + T3[1];\n                      if (H = G2 + P3[2] - (Z + T3[2]), H) return H;\n                      var j3 = V2(P3[0], P3[1]), N2 = V2(T3[0], T3[1]), H = V2(j3, P3[2]) - V2(N2, T3[2]);\n                      return H || V2(j3 + P3[2], G2) - V2(N2 + T3[2], Z);\n                    default:\n                      var te = P3.slice(0);\n                      te.sort();\n                      var oe = T3.slice(0);\n                      oe.sort();\n                      for (var _e = 0; _e < z3; ++_e) if (O3 = te[_e] - oe[_e], O3) return O3;\n                      return 0;\n                  }\n                }\n                a4.Fw = d3;\n                function v3(P3, T3) {\n                  return d3(P3[0], T3[0]);\n                }\n                function _2(P3, T3) {\n                  if (T3) {\n                    for (var z3 = P3.length, O3 = new Array(z3), V2 = 0; V2 < z3; ++V2) O3[V2] = [P3[V2], T3[V2]];\n                    O3.sort(v3);\n                    for (var V2 = 0; V2 < z3; ++V2) P3[V2] = O3[V2][0], T3[V2] = O3[V2][1];\n                    return P3;\n                  } else return P3.sort(d3), P3;\n                }\n                s3 = _2;\n                function b(P3) {\n                  if (P3.length === 0) return [];\n                  for (var T3 = 1, z3 = P3.length, O3 = 1; O3 < z3; ++O3) {\n                    var V2 = P3[O3];\n                    if (d3(V2, P3[O3 - 1])) {\n                      if (O3 === T3) {\n                        T3++;\n                        continue;\n                      }\n                      P3[T3++] = V2;\n                    }\n                  }\n                  return P3.length = T3, P3;\n                }\n                s3 = b;\n                function p3(P3, T3) {\n                  for (var z3 = 0, O3 = P3.length - 1, V2 = -1; z3 <= O3; ) {\n                    var G2 = z3 + O3 >> 1, Z = d3(P3[G2], T3);\n                    Z <= 0 ? (Z === 0 && (V2 = G2), z3 = G2 + 1) : Z > 0 && (O3 = G2 - 1);\n                  }\n                  return V2;\n                }\n                s3 = p3;\n                function k4(P3, T3) {\n                  for (var z3 = new Array(P3.length), O3 = 0, V2 = z3.length; O3 < V2; ++O3) z3[O3] = [];\n                  for (var G2 = [], O3 = 0, Z = T3.length; O3 < Z; ++O3) for (var j3 = T3[O3], N2 = j3.length, H = 1, te = 1 << N2; H < te; ++H) {\n                    G2.length = l3.popCount(H);\n                    for (var oe = 0, _e = 0; _e < N2; ++_e) H & 1 << _e && (G2[oe++] = j3[_e]);\n                    var Ee = p3(P3, G2);\n                    if (!(Ee < 0)) for (; z3[Ee++].push(O3), !(Ee >= P3.length || d3(P3[Ee], G2) !== 0); ) ;\n                  }\n                  return z3;\n                }\n                s3 = k4;\n                function E3(P3, T3) {\n                  if (!T3) return k4(b(L3(P3, 0)), P3, 0);\n                  for (var z3 = new Array(T3), O3 = 0; O3 < T3; ++O3) z3[O3] = [];\n                  for (var O3 = 0, V2 = P3.length; O3 < V2; ++O3) for (var G2 = P3[O3], Z = 0, j3 = G2.length; Z < j3; ++Z) z3[G2[Z]].push(O3);\n                  return z3;\n                }\n                s3 = E3;\n                function S2(P3) {\n                  for (var T3 = [], z3 = 0, O3 = P3.length; z3 < O3; ++z3) for (var V2 = P3[z3], G2 = V2.length | 0, Z = 1, j3 = 1 << G2; Z < j3; ++Z) {\n                    for (var N2 = [], H = 0; H < G2; ++H) Z >>> H & 1 && N2.push(V2[H]);\n                    T3.push(N2);\n                  }\n                  return _2(T3);\n                }\n                s3 = S2;\n                function L3(P3, T3) {\n                  if (T3 < 0) return [];\n                  for (var z3 = [], O3 = (1 << T3 + 1) - 1, V2 = 0; V2 < P3.length; ++V2) for (var G2 = P3[V2], Z = O3; Z < 1 << G2.length; Z = l3.nextCombination(Z)) {\n                    for (var j3 = new Array(T3 + 1), N2 = 0, H = 0; H < G2.length; ++H) Z & 1 << H && (j3[N2++] = G2[H]);\n                    z3.push(j3);\n                  }\n                  return _2(z3);\n                }\n                s3 = L3;\n                function x2(P3) {\n                  for (var T3 = [], z3 = 0, O3 = P3.length; z3 < O3; ++z3) for (var V2 = P3[z3], G2 = 0, Z = V2.length; G2 < Z; ++G2) {\n                    for (var j3 = new Array(V2.length - 1), N2 = 0, H = 0; N2 < Z; ++N2) N2 !== G2 && (j3[H++] = V2[N2]);\n                    T3.push(j3);\n                  }\n                  return _2(T3);\n                }\n                s3 = x2;\n                function C3(P3, T3) {\n                  for (var z3 = new u4(T3), O3 = 0; O3 < P3.length; ++O3) for (var V2 = P3[O3], G2 = 0; G2 < V2.length; ++G2) for (var Z = G2 + 1; Z < V2.length; ++Z) z3.link(V2[G2], V2[Z]);\n                  for (var j3 = [], N2 = z3.ranks, O3 = 0; O3 < N2.length; ++O3) N2[O3] = -1;\n                  for (var O3 = 0; O3 < P3.length; ++O3) {\n                    var H = z3.find(P3[O3][0]);\n                    N2[H] < 0 ? (N2[H] = j3.length, j3.push([P3[O3].slice(0)])) : j3[N2[H]].push(P3[O3].slice(0));\n                  }\n                  return j3;\n                }\n                function M4(P3) {\n                  for (var T3 = b(_2(L3(P3, 0))), z3 = new u4(T3.length), O3 = 0; O3 < P3.length; ++O3) for (var V2 = P3[O3], G2 = 0; G2 < V2.length; ++G2) for (var Z = p3(T3, [V2[G2]]), j3 = G2 + 1; j3 < V2.length; ++j3) z3.link(Z, p3(T3, [V2[j3]]));\n                  for (var N2 = [], H = z3.ranks, O3 = 0; O3 < H.length; ++O3) H[O3] = -1;\n                  for (var O3 = 0; O3 < P3.length; ++O3) {\n                    var te = z3.find(p3(T3, [P3[O3][0]]));\n                    H[te] < 0 ? (H[te] = N2.length, N2.push([P3[O3].slice(0)])) : N2[H[te]].push(P3[O3].slice(0));\n                  }\n                  return N2;\n                }\n                function g3(P3, T3) {\n                  return T3 ? C3(P3, T3) : M4(P3);\n                }\n                s3 = g3;\n              }, 6808: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = o4[0], l3 = o4[1], u4 = o4[2], c5 = o4[3];\n                  return Math.sqrt(s3 * s3 + l3 * l3 + u4 * u4 + c5 * c5);\n                }\n              }, 6843: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] - l3[0], o4[1] = s3[1] - l3[1], o4[2] = s3[2] - l3[2], o4;\n                }\n              }, 6852: function(i3) {\n                i3.exports = ["abs", "acos", "all", "any", "asin", "atan", "ceil", "clamp", "cos", "cross", "dFdx", "dFdy", "degrees", "distance", "dot", "equal", "exp", "exp2", "faceforward", "floor", "fract", "gl_BackColor", "gl_BackLightModelProduct", "gl_BackLightProduct", "gl_BackMaterial", "gl_BackSecondaryColor", "gl_ClipPlane", "gl_ClipVertex", "gl_Color", "gl_DepthRange", "gl_DepthRangeParameters", "gl_EyePlaneQ", "gl_EyePlaneR", "gl_EyePlaneS", "gl_EyePlaneT", "gl_Fog", "gl_FogCoord", "gl_FogFragCoord", "gl_FogParameters", "gl_FragColor", "gl_FragCoord", "gl_FragData", "gl_FragDepth", "gl_FragDepthEXT", "gl_FrontColor", "gl_FrontFacing", "gl_FrontLightModelProduct", "gl_FrontLightProduct", "gl_FrontMaterial", "gl_FrontSecondaryColor", "gl_LightModel", "gl_LightModelParameters", "gl_LightModelProducts", "gl_LightProducts", "gl_LightSource", "gl_LightSourceParameters", "gl_MaterialParameters", "gl_MaxClipPlanes", "gl_MaxCombinedTextureImageUnits", "gl_MaxDrawBuffers", "gl_MaxFragmentUniformComponents", "gl_MaxLights", "gl_MaxTextureCoords", "gl_MaxTextureImageUnits", "gl_MaxTextureUnits", "gl_MaxVaryingFloats", "gl_MaxVertexAttribs", "gl_MaxVertexTextureImageUnits", "gl_MaxVertexUniformComponents", "gl_ModelViewMatrix", "gl_ModelViewMatrixInverse", "gl_ModelViewMatrixInverseTranspose", "gl_ModelViewMatrixTranspose", "gl_ModelViewProjectionMatrix", "gl_ModelViewProjectionMatrixInverse", "gl_ModelViewProjectionMatrixInverseTranspose", "gl_ModelViewProjectionMatrixTranspose", "gl_MultiTexCoord0", "gl_MultiTexCoord1", "gl_MultiTexCoord2", "gl_MultiTexCoord3", "gl_MultiTexCoord4", "gl_MultiTexCoord5", "gl_MultiTexCoord6", "gl_MultiTexCoord7", "gl_Normal", "gl_NormalMatrix", "gl_NormalScale", "gl_ObjectPlaneQ", "gl_ObjectPlaneR", "gl_ObjectPlaneS", "gl_ObjectPlaneT", "gl_Point", "gl_PointCoord", "gl_PointParameters", "gl_PointSize", "gl_Position", "gl_ProjectionMatrix", "gl_ProjectionMatrixInverse", "gl_ProjectionMatrixInverseTranspose", "gl_ProjectionMatrixTranspose", "gl_SecondaryColor", "gl_TexCoord", "gl_TextureEnvColor", "gl_TextureMatrix", "gl_TextureMatrixInverse", "gl_TextureMatrixInverseTranspose", "gl_TextureMatrixTranspose", "gl_Vertex", "greaterThan", "greaterThanEqual", "inversesqrt", "length", "lessThan", "lessThanEqual", "log", "log2", "matrixCompMult", "max", "min", "mix", "mod", "normalize", "not", "notEqual", "pow", "radians", "reflect", "refract", "sign", "sin", "smoothstep", "sqrt", "step", "tan", "texture2D", "texture2DLod", "texture2DProj", "texture2DProjLod", "textureCube", "textureCubeLod", "texture2DLodEXT", "texture2DProjLodEXT", "textureCubeLodEXT", "texture2DGradEXT", "texture2DProjGradEXT", "textureCubeGradEXT"];\n              }, 6859: function(i3, a4, o4) {\n                i3 = o4.nmd(i3), (function(s3, l3) {\n                  "use strict";\n                  function u4(j3, N2) {\n                    if (!j3) throw new Error(N2 || "Assertion failed");\n                  }\n                  function c5(j3, N2) {\n                    j3.super_ = N2;\n                    var H = function() {\n                    };\n                    H.prototype = N2.prototype, j3.prototype = new H(), j3.prototype.constructor = j3;\n                  }\n                  function f4(j3, N2, H) {\n                    if (f4.isBN(j3)) return j3;\n                    this.negative = 0, this.words = null, this.length = 0, this.red = null, j3 !== null && ((N2 === "le" || N2 === "be") && (H = N2, N2 = 10), this._init(j3 || 0, N2 || 10, H || "be"));\n                  }\n                  typeof s3 == "object" ? s3.exports = f4 : l3.BN = f4, f4.BN = f4, f4.wordSize = 26;\n                  var h3;\n                  try {\n                    typeof window != "undefined" && typeof window.Buffer != "undefined" ? h3 = window.Buffer : h3 = o4(7790).Buffer;\n                  } catch (j3) {\n                  }\n                  f4.isBN = function(N2) {\n                    return N2 instanceof f4 ? true : N2 !== null && typeof N2 == "object" && N2.constructor.wordSize === f4.wordSize && Array.isArray(N2.words);\n                  }, f4.max = function(N2, H) {\n                    return N2.cmp(H) > 0 ? N2 : H;\n                  }, f4.min = function(N2, H) {\n                    return N2.cmp(H) < 0 ? N2 : H;\n                  }, f4.prototype._init = function(N2, H, te) {\n                    if (typeof N2 == "number") return this._initNumber(N2, H, te);\n                    if (typeof N2 == "object") return this._initArray(N2, H, te);\n                    H === "hex" && (H = 16), u4(H === (H | 0) && H >= 2 && H <= 36), N2 = N2.toString().replace(/\\s+/g, "");\n                    var oe = 0;\n                    N2[0] === "-" && (oe++, this.negative = 1), oe < N2.length && (H === 16 ? this._parseHex(N2, oe, te) : (this._parseBase(N2, H, oe), te === "le" && this._initArray(this.toArray(), H, te)));\n                  }, f4.prototype._initNumber = function(N2, H, te) {\n                    N2 < 0 && (this.negative = 1, N2 = -N2), N2 < 67108864 ? (this.words = [N2 & 67108863], this.length = 1) : N2 < 4503599627370496 ? (this.words = [N2 & 67108863, N2 / 67108864 & 67108863], this.length = 2) : (u4(N2 < 9007199254740992), this.words = [N2 & 67108863, N2 / 67108864 & 67108863, 1], this.length = 3), te === "le" && this._initArray(this.toArray(), H, te);\n                  }, f4.prototype._initArray = function(N2, H, te) {\n                    if (u4(typeof N2.length == "number"), N2.length <= 0) return this.words = [0], this.length = 1, this;\n                    this.length = Math.ceil(N2.length / 3), this.words = new Array(this.length);\n                    for (var oe = 0; oe < this.length; oe++) this.words[oe] = 0;\n                    var _e, Ee, Ce = 0;\n                    if (te === "be") for (oe = N2.length - 1, _e = 0; oe >= 0; oe -= 3) Ee = N2[oe] | N2[oe - 1] << 8 | N2[oe - 2] << 16, this.words[_e] |= Ee << Ce & 67108863, this.words[_e + 1] = Ee >>> 26 - Ce & 67108863, Ce += 24, Ce >= 26 && (Ce -= 26, _e++);\n                    else if (te === "le") for (oe = 0, _e = 0; oe < N2.length; oe += 3) Ee = N2[oe] | N2[oe + 1] << 8 | N2[oe + 2] << 16, this.words[_e] |= Ee << Ce & 67108863, this.words[_e + 1] = Ee >>> 26 - Ce & 67108863, Ce += 24, Ce >= 26 && (Ce -= 26, _e++);\n                    return this.strip();\n                  };\n                  function d3(j3, N2) {\n                    var H = j3.charCodeAt(N2);\n                    return H >= 65 && H <= 70 ? H - 55 : H >= 97 && H <= 102 ? H - 87 : H - 48 & 15;\n                  }\n                  function v3(j3, N2, H) {\n                    var te = d3(j3, H);\n                    return H - 1 >= N2 && (te |= d3(j3, H - 1) << 4), te;\n                  }\n                  f4.prototype._parseHex = function(N2, H, te) {\n                    this.length = Math.ceil((N2.length - H) / 6), this.words = new Array(this.length);\n                    for (var oe = 0; oe < this.length; oe++) this.words[oe] = 0;\n                    var _e = 0, Ee = 0, Ce;\n                    if (te === "be") for (oe = N2.length - 1; oe >= H; oe -= 2) Ce = v3(N2, H, oe) << _e, this.words[Ee] |= Ce & 67108863, _e >= 18 ? (_e -= 18, Ee += 1, this.words[Ee] |= Ce >>> 26) : _e += 8;\n                    else {\n                      var me = N2.length - H;\n                      for (oe = me % 2 === 0 ? H + 1 : H; oe < N2.length; oe += 2) Ce = v3(N2, H, oe) << _e, this.words[Ee] |= Ce & 67108863, _e >= 18 ? (_e -= 18, Ee += 1, this.words[Ee] |= Ce >>> 26) : _e += 8;\n                    }\n                    this.strip();\n                  };\n                  function _2(j3, N2, H, te) {\n                    for (var oe = 0, _e = Math.min(j3.length, H), Ee = N2; Ee < _e; Ee++) {\n                      var Ce = j3.charCodeAt(Ee) - 48;\n                      oe *= te, Ce >= 49 ? oe += Ce - 49 + 10 : Ce >= 17 ? oe += Ce - 17 + 10 : oe += Ce;\n                    }\n                    return oe;\n                  }\n                  f4.prototype._parseBase = function(N2, H, te) {\n                    this.words = [0], this.length = 1;\n                    for (var oe = 0, _e = 1; _e <= 67108863; _e *= H) oe++;\n                    oe--, _e = _e / H | 0;\n                    for (var Ee = N2.length - te, Ce = Ee % oe, me = Math.min(Ee, Ee - Ce) + te, ie = 0, Se = te; Se < me; Se += oe) ie = _2(N2, Se, Se + oe, H), this.imuln(_e), this.words[0] + ie < 67108864 ? this.words[0] += ie : this._iaddn(ie);\n                    if (Ce !== 0) {\n                      var Le = 1;\n                      for (ie = _2(N2, Se, N2.length, H), Se = 0; Se < Ce; Se++) Le *= H;\n                      this.imuln(Le), this.words[0] + ie < 67108864 ? this.words[0] += ie : this._iaddn(ie);\n                    }\n                    this.strip();\n                  }, f4.prototype.copy = function(N2) {\n                    N2.words = new Array(this.length);\n                    for (var H = 0; H < this.length; H++) N2.words[H] = this.words[H];\n                    N2.length = this.length, N2.negative = this.negative, N2.red = this.red;\n                  }, f4.prototype.clone = function() {\n                    var N2 = new f4(null);\n                    return this.copy(N2), N2;\n                  }, f4.prototype._expand = function(N2) {\n                    for (; this.length < N2; ) this.words[this.length++] = 0;\n                    return this;\n                  }, f4.prototype.strip = function() {\n                    for (; this.length > 1 && this.words[this.length - 1] === 0; ) this.length--;\n                    return this._normSign();\n                  }, f4.prototype._normSign = function() {\n                    return this.length === 1 && this.words[0] === 0 && (this.negative = 0), this;\n                  }, f4.prototype.inspect = function() {\n                    return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";\n                  };\n                  var b = ["", "0", "00", "000", "0000", "00000", "000000", "0000000", "00000000", "000000000", "0000000000", "00000000000", "000000000000", "0000000000000", "00000000000000", "000000000000000", "0000000000000000", "00000000000000000", "000000000000000000", "0000000000000000000", "00000000000000000000", "000000000000000000000", "0000000000000000000000", "00000000000000000000000", "000000000000000000000000", "0000000000000000000000000"], p3 = [0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], k4 = [0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216, 43046721, 1e7, 19487171, 35831808, 62748517, 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64e6, 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149, 243e5, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176];\n                  f4.prototype.toString = function(N2, H) {\n                    N2 = N2 || 10, H = H | 0 || 1;\n                    var te;\n                    if (N2 === 16 || N2 === "hex") {\n                      te = "";\n                      for (var oe = 0, _e = 0, Ee = 0; Ee < this.length; Ee++) {\n                        var Ce = this.words[Ee], me = ((Ce << oe | _e) & 16777215).toString(16);\n                        _e = Ce >>> 24 - oe & 16777215, _e !== 0 || Ee !== this.length - 1 ? te = b[6 - me.length] + me + te : te = me + te, oe += 2, oe >= 26 && (oe -= 26, Ee--);\n                      }\n                      for (_e !== 0 && (te = _e.toString(16) + te); te.length % H !== 0; ) te = "0" + te;\n                      return this.negative !== 0 && (te = "-" + te), te;\n                    }\n                    if (N2 === (N2 | 0) && N2 >= 2 && N2 <= 36) {\n                      var ie = p3[N2], Se = k4[N2];\n                      te = "";\n                      var Le = this.clone();\n                      for (Le.negative = 0; !Le.isZero(); ) {\n                        var Ae = Le.modn(Se).toString(N2);\n                        Le = Le.idivn(Se), Le.isZero() ? te = Ae + te : te = b[ie - Ae.length] + Ae + te;\n                      }\n                      for (this.isZero() && (te = "0" + te); te.length % H !== 0; ) te = "0" + te;\n                      return this.negative !== 0 && (te = "-" + te), te;\n                    }\n                    u4(false, "Base should be between 2 and 36");\n                  }, f4.prototype.toNumber = function() {\n                    var N2 = this.words[0];\n                    return this.length === 2 ? N2 += this.words[1] * 67108864 : this.length === 3 && this.words[2] === 1 ? N2 += 4503599627370496 + this.words[1] * 67108864 : this.length > 2 && u4(false, "Number can only safely store up to 53 bits"), this.negative !== 0 ? -N2 : N2;\n                  }, f4.prototype.toJSON = function() {\n                    return this.toString(16);\n                  }, f4.prototype.toBuffer = function(N2, H) {\n                    return u4(typeof h3 != "undefined"), this.toArrayLike(h3, N2, H);\n                  }, f4.prototype.toArray = function(N2, H) {\n                    return this.toArrayLike(Array, N2, H);\n                  }, f4.prototype.toArrayLike = function(N2, H, te) {\n                    var oe = this.byteLength(), _e = te || Math.max(1, oe);\n                    u4(oe <= _e, "byte array longer than desired length"), u4(_e > 0, "Requested array length <= 0"), this.strip();\n                    var Ee = H === "le", Ce = new N2(_e), me, ie, Se = this.clone();\n                    if (Ee) {\n                      for (ie = 0; !Se.isZero(); ie++) me = Se.andln(255), Se.iushrn(8), Ce[ie] = me;\n                      for (; ie < _e; ie++) Ce[ie] = 0;\n                    } else {\n                      for (ie = 0; ie < _e - oe; ie++) Ce[ie] = 0;\n                      for (ie = 0; !Se.isZero(); ie++) me = Se.andln(255), Se.iushrn(8), Ce[_e - ie - 1] = me;\n                    }\n                    return Ce;\n                  }, Math.clz32 ? f4.prototype._countBits = function(N2) {\n                    return 32 - Math.clz32(N2);\n                  } : f4.prototype._countBits = function(N2) {\n                    var H = N2, te = 0;\n                    return H >= 4096 && (te += 13, H >>>= 13), H >= 64 && (te += 7, H >>>= 7), H >= 8 && (te += 4, H >>>= 4), H >= 2 && (te += 2, H >>>= 2), te + H;\n                  }, f4.prototype._zeroBits = function(N2) {\n                    if (N2 === 0) return 26;\n                    var H = N2, te = 0;\n                    return (H & 8191) === 0 && (te += 13, H >>>= 13), (H & 127) === 0 && (te += 7, H >>>= 7), (H & 15) === 0 && (te += 4, H >>>= 4), (H & 3) === 0 && (te += 2, H >>>= 2), (H & 1) === 0 && te++, te;\n                  }, f4.prototype.bitLength = function() {\n                    var N2 = this.words[this.length - 1], H = this._countBits(N2);\n                    return (this.length - 1) * 26 + H;\n                  };\n                  function E3(j3) {\n                    for (var N2 = new Array(j3.bitLength()), H = 0; H < N2.length; H++) {\n                      var te = H / 26 | 0, oe = H % 26;\n                      N2[H] = (j3.words[te] & 1 << oe) >>> oe;\n                    }\n                    return N2;\n                  }\n                  f4.prototype.zeroBits = function() {\n                    if (this.isZero()) return 0;\n                    for (var N2 = 0, H = 0; H < this.length; H++) {\n                      var te = this._zeroBits(this.words[H]);\n                      if (N2 += te, te !== 26) break;\n                    }\n                    return N2;\n                  }, f4.prototype.byteLength = function() {\n                    return Math.ceil(this.bitLength() / 8);\n                  }, f4.prototype.toTwos = function(N2) {\n                    return this.negative !== 0 ? this.abs().inotn(N2).iaddn(1) : this.clone();\n                  }, f4.prototype.fromTwos = function(N2) {\n                    return this.testn(N2 - 1) ? this.notn(N2).iaddn(1).ineg() : this.clone();\n                  }, f4.prototype.isNeg = function() {\n                    return this.negative !== 0;\n                  }, f4.prototype.neg = function() {\n                    return this.clone().ineg();\n                  }, f4.prototype.ineg = function() {\n                    return this.isZero() || (this.negative ^= 1), this;\n                  }, f4.prototype.iuor = function(N2) {\n                    for (; this.length < N2.length; ) this.words[this.length++] = 0;\n                    for (var H = 0; H < N2.length; H++) this.words[H] = this.words[H] | N2.words[H];\n                    return this.strip();\n                  }, f4.prototype.ior = function(N2) {\n                    return u4((this.negative | N2.negative) === 0), this.iuor(N2);\n                  }, f4.prototype.or = function(N2) {\n                    return this.length > N2.length ? this.clone().ior(N2) : N2.clone().ior(this);\n                  }, f4.prototype.uor = function(N2) {\n                    return this.length > N2.length ? this.clone().iuor(N2) : N2.clone().iuor(this);\n                  }, f4.prototype.iuand = function(N2) {\n                    var H;\n                    this.length > N2.length ? H = N2 : H = this;\n                    for (var te = 0; te < H.length; te++) this.words[te] = this.words[te] & N2.words[te];\n                    return this.length = H.length, this.strip();\n                  }, f4.prototype.iand = function(N2) {\n                    return u4((this.negative | N2.negative) === 0), this.iuand(N2);\n                  }, f4.prototype.and = function(N2) {\n                    return this.length > N2.length ? this.clone().iand(N2) : N2.clone().iand(this);\n                  }, f4.prototype.uand = function(N2) {\n                    return this.length > N2.length ? this.clone().iuand(N2) : N2.clone().iuand(this);\n                  }, f4.prototype.iuxor = function(N2) {\n                    var H, te;\n                    this.length > N2.length ? (H = this, te = N2) : (H = N2, te = this);\n                    for (var oe = 0; oe < te.length; oe++) this.words[oe] = H.words[oe] ^ te.words[oe];\n                    if (this !== H) for (; oe < H.length; oe++) this.words[oe] = H.words[oe];\n                    return this.length = H.length, this.strip();\n                  }, f4.prototype.ixor = function(N2) {\n                    return u4((this.negative | N2.negative) === 0), this.iuxor(N2);\n                  }, f4.prototype.xor = function(N2) {\n                    return this.length > N2.length ? this.clone().ixor(N2) : N2.clone().ixor(this);\n                  }, f4.prototype.uxor = function(N2) {\n                    return this.length > N2.length ? this.clone().iuxor(N2) : N2.clone().iuxor(this);\n                  }, f4.prototype.inotn = function(N2) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var H = Math.ceil(N2 / 26) | 0, te = N2 % 26;\n                    this._expand(H), te > 0 && H--;\n                    for (var oe = 0; oe < H; oe++) this.words[oe] = ~this.words[oe] & 67108863;\n                    return te > 0 && (this.words[oe] = ~this.words[oe] & 67108863 >> 26 - te), this.strip();\n                  }, f4.prototype.notn = function(N2) {\n                    return this.clone().inotn(N2);\n                  }, f4.prototype.setn = function(N2, H) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var te = N2 / 26 | 0, oe = N2 % 26;\n                    return this._expand(te + 1), H ? this.words[te] = this.words[te] | 1 << oe : this.words[te] = this.words[te] & ~(1 << oe), this.strip();\n                  }, f4.prototype.iadd = function(N2) {\n                    var H;\n                    if (this.negative !== 0 && N2.negative === 0) return this.negative = 0, H = this.isub(N2), this.negative ^= 1, this._normSign();\n                    if (this.negative === 0 && N2.negative !== 0) return N2.negative = 0, H = this.isub(N2), N2.negative = 1, H._normSign();\n                    var te, oe;\n                    this.length > N2.length ? (te = this, oe = N2) : (te = N2, oe = this);\n                    for (var _e = 0, Ee = 0; Ee < oe.length; Ee++) H = (te.words[Ee] | 0) + (oe.words[Ee] | 0) + _e, this.words[Ee] = H & 67108863, _e = H >>> 26;\n                    for (; _e !== 0 && Ee < te.length; Ee++) H = (te.words[Ee] | 0) + _e, this.words[Ee] = H & 67108863, _e = H >>> 26;\n                    if (this.length = te.length, _e !== 0) this.words[this.length] = _e, this.length++;\n                    else if (te !== this) for (; Ee < te.length; Ee++) this.words[Ee] = te.words[Ee];\n                    return this;\n                  }, f4.prototype.add = function(N2) {\n                    var H;\n                    return N2.negative !== 0 && this.negative === 0 ? (N2.negative = 0, H = this.sub(N2), N2.negative ^= 1, H) : N2.negative === 0 && this.negative !== 0 ? (this.negative = 0, H = N2.sub(this), this.negative = 1, H) : this.length > N2.length ? this.clone().iadd(N2) : N2.clone().iadd(this);\n                  }, f4.prototype.isub = function(N2) {\n                    if (N2.negative !== 0) {\n                      N2.negative = 0;\n                      var H = this.iadd(N2);\n                      return N2.negative = 1, H._normSign();\n                    } else if (this.negative !== 0) return this.negative = 0, this.iadd(N2), this.negative = 1, this._normSign();\n                    var te = this.cmp(N2);\n                    if (te === 0) return this.negative = 0, this.length = 1, this.words[0] = 0, this;\n                    var oe, _e;\n                    te > 0 ? (oe = this, _e = N2) : (oe = N2, _e = this);\n                    for (var Ee = 0, Ce = 0; Ce < _e.length; Ce++) H = (oe.words[Ce] | 0) - (_e.words[Ce] | 0) + Ee, Ee = H >> 26, this.words[Ce] = H & 67108863;\n                    for (; Ee !== 0 && Ce < oe.length; Ce++) H = (oe.words[Ce] | 0) + Ee, Ee = H >> 26, this.words[Ce] = H & 67108863;\n                    if (Ee === 0 && Ce < oe.length && oe !== this) for (; Ce < oe.length; Ce++) this.words[Ce] = oe.words[Ce];\n                    return this.length = Math.max(this.length, Ce), oe !== this && (this.negative = 1), this.strip();\n                  }, f4.prototype.sub = function(N2) {\n                    return this.clone().isub(N2);\n                  };\n                  function S2(j3, N2, H) {\n                    H.negative = N2.negative ^ j3.negative;\n                    var te = j3.length + N2.length | 0;\n                    H.length = te, te = te - 1 | 0;\n                    var oe = j3.words[0] | 0, _e = N2.words[0] | 0, Ee = oe * _e, Ce = Ee & 67108863, me = Ee / 67108864 | 0;\n                    H.words[0] = Ce;\n                    for (var ie = 1; ie < te; ie++) {\n                      for (var Se = me >>> 26, Le = me & 67108863, Ae = Math.min(ie, N2.length - 1), Fe = Math.max(0, ie - j3.length + 1); Fe <= Ae; Fe++) {\n                        var Pe = ie - Fe | 0;\n                        oe = j3.words[Pe] | 0, _e = N2.words[Fe] | 0, Ee = oe * _e + Le, Se += Ee / 67108864 | 0, Le = Ee & 67108863;\n                      }\n                      H.words[ie] = Le | 0, me = Se | 0;\n                    }\n                    return me !== 0 ? H.words[ie] = me | 0 : H.length--, H.strip();\n                  }\n                  var L3 = function(N2, H, te) {\n                    var oe = N2.words, _e = H.words, Ee = te.words, Ce = 0, me, ie, Se, Le = oe[0] | 0, Ae = Le & 8191, Fe = Le >>> 13, Pe = oe[1] | 0, ge = Pe & 8191, Re = Pe >>> 13, ce = oe[2] | 0, Ze = ce & 8191, ut = ce >>> 13, pt = oe[3] | 0, Zt = pt & 8191, st = pt >>> 13, lt = oe[4] | 0, Gt = lt & 8191, Nt = lt >>> 13, Jt = oe[5] | 0, sr = Jt & 8191, wr = Jt >>> 13, cr = oe[6] | 0, $e = cr & 8191, St = cr >>> 13, Qt = oe[7] | 0, Vt = Qt & 8191, _t = Qt >>> 13, It = oe[8] | 0, mt = It & 8191, er = It >>> 13, lr = oe[9] | 0, Tr = lr & 8191, Lr = lr >>> 13, ti = _e[0] | 0, Br = ti & 8191, Vr = ti >>> 13, dt = _e[1] | 0, Ge = dt & 8191, Je = dt >>> 13, je = _e[2] | 0, tt = je & 8191, xt = je >>> 13, Ie = _e[3] | 0, xe = Ie & 8191, ke = Ie >>> 13, vt = _e[4] | 0, ir = vt & 8191, ar = vt >>> 13, vr = _e[5] | 0, ii = vr & 8191, pi = vr >>> 13, $r = _e[6] | 0, di = $r & 8191, ji = $r >>> 13, In = _e[7] | 0, wi = In & 8191, On = In >>> 13, qn = _e[8] | 0, Fn = qn & 8191, ra = qn >>> 13, la = _e[9] | 0, Ut = la & 8191, wt = la >>> 13;\n                    te.negative = N2.negative ^ H.negative, te.length = 19, me = Math.imul(Ae, Br), ie = Math.imul(Ae, Vr), ie = ie + Math.imul(Fe, Br) | 0, Se = Math.imul(Fe, Vr);\n                    var rr = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (rr >>> 26) | 0, rr &= 67108863, me = Math.imul(ge, Br), ie = Math.imul(ge, Vr), ie = ie + Math.imul(Re, Br) | 0, Se = Math.imul(Re, Vr), me = me + Math.imul(Ae, Ge) | 0, ie = ie + Math.imul(Ae, Je) | 0, ie = ie + Math.imul(Fe, Ge) | 0, Se = Se + Math.imul(Fe, Je) | 0;\n                    var nr = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (nr >>> 26) | 0, nr &= 67108863, me = Math.imul(Ze, Br), ie = Math.imul(Ze, Vr), ie = ie + Math.imul(ut, Br) | 0, Se = Math.imul(ut, Vr), me = me + Math.imul(ge, Ge) | 0, ie = ie + Math.imul(ge, Je) | 0, ie = ie + Math.imul(Re, Ge) | 0, Se = Se + Math.imul(Re, Je) | 0, me = me + Math.imul(Ae, tt) | 0, ie = ie + Math.imul(Ae, xt) | 0, ie = ie + Math.imul(Fe, tt) | 0, Se = Se + Math.imul(Fe, xt) | 0;\n                    var Er = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Er >>> 26) | 0, Er &= 67108863, me = Math.imul(Zt, Br), ie = Math.imul(Zt, Vr), ie = ie + Math.imul(st, Br) | 0, Se = Math.imul(st, Vr), me = me + Math.imul(Ze, Ge) | 0, ie = ie + Math.imul(Ze, Je) | 0, ie = ie + Math.imul(ut, Ge) | 0, Se = Se + Math.imul(ut, Je) | 0, me = me + Math.imul(ge, tt) | 0, ie = ie + Math.imul(ge, xt) | 0, ie = ie + Math.imul(Re, tt) | 0, Se = Se + Math.imul(Re, xt) | 0, me = me + Math.imul(Ae, xe) | 0, ie = ie + Math.imul(Ae, ke) | 0, ie = ie + Math.imul(Fe, xe) | 0, Se = Se + Math.imul(Fe, ke) | 0;\n                    var Xr = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Xr >>> 26) | 0, Xr &= 67108863, me = Math.imul(Gt, Br), ie = Math.imul(Gt, Vr), ie = ie + Math.imul(Nt, Br) | 0, Se = Math.imul(Nt, Vr), me = me + Math.imul(Zt, Ge) | 0, ie = ie + Math.imul(Zt, Je) | 0, ie = ie + Math.imul(st, Ge) | 0, Se = Se + Math.imul(st, Je) | 0, me = me + Math.imul(Ze, tt) | 0, ie = ie + Math.imul(Ze, xt) | 0, ie = ie + Math.imul(ut, tt) | 0, Se = Se + Math.imul(ut, xt) | 0, me = me + Math.imul(ge, xe) | 0, ie = ie + Math.imul(ge, ke) | 0, ie = ie + Math.imul(Re, xe) | 0, Se = Se + Math.imul(Re, ke) | 0, me = me + Math.imul(Ae, ir) | 0, ie = ie + Math.imul(Ae, ar) | 0, ie = ie + Math.imul(Fe, ir) | 0, Se = Se + Math.imul(Fe, ar) | 0;\n                    var ri = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (ri >>> 26) | 0, ri &= 67108863, me = Math.imul(sr, Br), ie = Math.imul(sr, Vr), ie = ie + Math.imul(wr, Br) | 0, Se = Math.imul(wr, Vr), me = me + Math.imul(Gt, Ge) | 0, ie = ie + Math.imul(Gt, Je) | 0, ie = ie + Math.imul(Nt, Ge) | 0, Se = Se + Math.imul(Nt, Je) | 0, me = me + Math.imul(Zt, tt) | 0, ie = ie + Math.imul(Zt, xt) | 0, ie = ie + Math.imul(st, tt) | 0, Se = Se + Math.imul(st, xt) | 0, me = me + Math.imul(Ze, xe) | 0, ie = ie + Math.imul(Ze, ke) | 0, ie = ie + Math.imul(ut, xe) | 0, Se = Se + Math.imul(ut, ke) | 0, me = me + Math.imul(ge, ir) | 0, ie = ie + Math.imul(ge, ar) | 0, ie = ie + Math.imul(Re, ir) | 0, Se = Se + Math.imul(Re, ar) | 0, me = me + Math.imul(Ae, ii) | 0, ie = ie + Math.imul(Ae, pi) | 0, ie = ie + Math.imul(Fe, ii) | 0, Se = Se + Math.imul(Fe, pi) | 0;\n                    var Qr = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Qr >>> 26) | 0, Qr &= 67108863, me = Math.imul($e, Br), ie = Math.imul($e, Vr), ie = ie + Math.imul(St, Br) | 0, Se = Math.imul(St, Vr), me = me + Math.imul(sr, Ge) | 0, ie = ie + Math.imul(sr, Je) | 0, ie = ie + Math.imul(wr, Ge) | 0, Se = Se + Math.imul(wr, Je) | 0, me = me + Math.imul(Gt, tt) | 0, ie = ie + Math.imul(Gt, xt) | 0, ie = ie + Math.imul(Nt, tt) | 0, Se = Se + Math.imul(Nt, xt) | 0, me = me + Math.imul(Zt, xe) | 0, ie = ie + Math.imul(Zt, ke) | 0, ie = ie + Math.imul(st, xe) | 0, Se = Se + Math.imul(st, ke) | 0, me = me + Math.imul(Ze, ir) | 0, ie = ie + Math.imul(Ze, ar) | 0, ie = ie + Math.imul(ut, ir) | 0, Se = Se + Math.imul(ut, ar) | 0, me = me + Math.imul(ge, ii) | 0, ie = ie + Math.imul(ge, pi) | 0, ie = ie + Math.imul(Re, ii) | 0, Se = Se + Math.imul(Re, pi) | 0, me = me + Math.imul(Ae, di) | 0, ie = ie + Math.imul(Ae, ji) | 0, ie = ie + Math.imul(Fe, di) | 0, Se = Se + Math.imul(Fe, ji) | 0;\n                    var Oi = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Oi >>> 26) | 0, Oi &= 67108863, me = Math.imul(Vt, Br), ie = Math.imul(Vt, Vr), ie = ie + Math.imul(_t, Br) | 0, Se = Math.imul(_t, Vr), me = me + Math.imul($e, Ge) | 0, ie = ie + Math.imul($e, Je) | 0, ie = ie + Math.imul(St, Ge) | 0, Se = Se + Math.imul(St, Je) | 0, me = me + Math.imul(sr, tt) | 0, ie = ie + Math.imul(sr, xt) | 0, ie = ie + Math.imul(wr, tt) | 0, Se = Se + Math.imul(wr, xt) | 0, me = me + Math.imul(Gt, xe) | 0, ie = ie + Math.imul(Gt, ke) | 0, ie = ie + Math.imul(Nt, xe) | 0, Se = Se + Math.imul(Nt, ke) | 0, me = me + Math.imul(Zt, ir) | 0, ie = ie + Math.imul(Zt, ar) | 0, ie = ie + Math.imul(st, ir) | 0, Se = Se + Math.imul(st, ar) | 0, me = me + Math.imul(Ze, ii) | 0, ie = ie + Math.imul(Ze, pi) | 0, ie = ie + Math.imul(ut, ii) | 0, Se = Se + Math.imul(ut, pi) | 0, me = me + Math.imul(ge, di) | 0, ie = ie + Math.imul(ge, ji) | 0, ie = ie + Math.imul(Re, di) | 0, Se = Se + Math.imul(Re, ji) | 0, me = me + Math.imul(Ae, wi) | 0, ie = ie + Math.imul(Ae, On) | 0, ie = ie + Math.imul(Fe, wi) | 0, Se = Se + Math.imul(Fe, On) | 0;\n                    var $i = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + ($i >>> 26) | 0, $i &= 67108863, me = Math.imul(mt, Br), ie = Math.imul(mt, Vr), ie = ie + Math.imul(er, Br) | 0, Se = Math.imul(er, Vr), me = me + Math.imul(Vt, Ge) | 0, ie = ie + Math.imul(Vt, Je) | 0, ie = ie + Math.imul(_t, Ge) | 0, Se = Se + Math.imul(_t, Je) | 0, me = me + Math.imul($e, tt) | 0, ie = ie + Math.imul($e, xt) | 0, ie = ie + Math.imul(St, tt) | 0, Se = Se + Math.imul(St, xt) | 0, me = me + Math.imul(sr, xe) | 0, ie = ie + Math.imul(sr, ke) | 0, ie = ie + Math.imul(wr, xe) | 0, Se = Se + Math.imul(wr, ke) | 0, me = me + Math.imul(Gt, ir) | 0, ie = ie + Math.imul(Gt, ar) | 0, ie = ie + Math.imul(Nt, ir) | 0, Se = Se + Math.imul(Nt, ar) | 0, me = me + Math.imul(Zt, ii) | 0, ie = ie + Math.imul(Zt, pi) | 0, ie = ie + Math.imul(st, ii) | 0, Se = Se + Math.imul(st, pi) | 0, me = me + Math.imul(Ze, di) | 0, ie = ie + Math.imul(Ze, ji) | 0, ie = ie + Math.imul(ut, di) | 0, Se = Se + Math.imul(ut, ji) | 0, me = me + Math.imul(ge, wi) | 0, ie = ie + Math.imul(ge, On) | 0, ie = ie + Math.imul(Re, wi) | 0, Se = Se + Math.imul(Re, On) | 0, me = me + Math.imul(Ae, Fn) | 0, ie = ie + Math.imul(Ae, ra) | 0, ie = ie + Math.imul(Fe, Fn) | 0, Se = Se + Math.imul(Fe, ra) | 0;\n                    var tn = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (tn >>> 26) | 0, tn &= 67108863, me = Math.imul(Tr, Br), ie = Math.imul(Tr, Vr), ie = ie + Math.imul(Lr, Br) | 0, Se = Math.imul(Lr, Vr), me = me + Math.imul(mt, Ge) | 0, ie = ie + Math.imul(mt, Je) | 0, ie = ie + Math.imul(er, Ge) | 0, Se = Se + Math.imul(er, Je) | 0, me = me + Math.imul(Vt, tt) | 0, ie = ie + Math.imul(Vt, xt) | 0, ie = ie + Math.imul(_t, tt) | 0, Se = Se + Math.imul(_t, xt) | 0, me = me + Math.imul($e, xe) | 0, ie = ie + Math.imul($e, ke) | 0, ie = ie + Math.imul(St, xe) | 0, Se = Se + Math.imul(St, ke) | 0, me = me + Math.imul(sr, ir) | 0, ie = ie + Math.imul(sr, ar) | 0, ie = ie + Math.imul(wr, ir) | 0, Se = Se + Math.imul(wr, ar) | 0, me = me + Math.imul(Gt, ii) | 0, ie = ie + Math.imul(Gt, pi) | 0, ie = ie + Math.imul(Nt, ii) | 0, Se = Se + Math.imul(Nt, pi) | 0, me = me + Math.imul(Zt, di) | 0, ie = ie + Math.imul(Zt, ji) | 0, ie = ie + Math.imul(st, di) | 0, Se = Se + Math.imul(st, ji) | 0, me = me + Math.imul(Ze, wi) | 0, ie = ie + Math.imul(Ze, On) | 0, ie = ie + Math.imul(ut, wi) | 0, Se = Se + Math.imul(ut, On) | 0, me = me + Math.imul(ge, Fn) | 0, ie = ie + Math.imul(ge, ra) | 0, ie = ie + Math.imul(Re, Fn) | 0, Se = Se + Math.imul(Re, ra) | 0, me = me + Math.imul(Ae, Ut) | 0, ie = ie + Math.imul(Ae, wt) | 0, ie = ie + Math.imul(Fe, Ut) | 0, Se = Se + Math.imul(Fe, wt) | 0;\n                    var fn = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (fn >>> 26) | 0, fn &= 67108863, me = Math.imul(Tr, Ge), ie = Math.imul(Tr, Je), ie = ie + Math.imul(Lr, Ge) | 0, Se = Math.imul(Lr, Je), me = me + Math.imul(mt, tt) | 0, ie = ie + Math.imul(mt, xt) | 0, ie = ie + Math.imul(er, tt) | 0, Se = Se + Math.imul(er, xt) | 0, me = me + Math.imul(Vt, xe) | 0, ie = ie + Math.imul(Vt, ke) | 0, ie = ie + Math.imul(_t, xe) | 0, Se = Se + Math.imul(_t, ke) | 0, me = me + Math.imul($e, ir) | 0, ie = ie + Math.imul($e, ar) | 0, ie = ie + Math.imul(St, ir) | 0, Se = Se + Math.imul(St, ar) | 0, me = me + Math.imul(sr, ii) | 0, ie = ie + Math.imul(sr, pi) | 0, ie = ie + Math.imul(wr, ii) | 0, Se = Se + Math.imul(wr, pi) | 0, me = me + Math.imul(Gt, di) | 0, ie = ie + Math.imul(Gt, ji) | 0, ie = ie + Math.imul(Nt, di) | 0, Se = Se + Math.imul(Nt, ji) | 0, me = me + Math.imul(Zt, wi) | 0, ie = ie + Math.imul(Zt, On) | 0, ie = ie + Math.imul(st, wi) | 0, Se = Se + Math.imul(st, On) | 0, me = me + Math.imul(Ze, Fn) | 0, ie = ie + Math.imul(Ze, ra) | 0, ie = ie + Math.imul(ut, Fn) | 0, Se = Se + Math.imul(ut, ra) | 0, me = me + Math.imul(ge, Ut) | 0, ie = ie + Math.imul(ge, wt) | 0, ie = ie + Math.imul(Re, Ut) | 0, Se = Se + Math.imul(Re, wt) | 0;\n                    var yn = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (yn >>> 26) | 0, yn &= 67108863, me = Math.imul(Tr, tt), ie = Math.imul(Tr, xt), ie = ie + Math.imul(Lr, tt) | 0, Se = Math.imul(Lr, xt), me = me + Math.imul(mt, xe) | 0, ie = ie + Math.imul(mt, ke) | 0, ie = ie + Math.imul(er, xe) | 0, Se = Se + Math.imul(er, ke) | 0, me = me + Math.imul(Vt, ir) | 0, ie = ie + Math.imul(Vt, ar) | 0, ie = ie + Math.imul(_t, ir) | 0, Se = Se + Math.imul(_t, ar) | 0, me = me + Math.imul($e, ii) | 0, ie = ie + Math.imul($e, pi) | 0, ie = ie + Math.imul(St, ii) | 0, Se = Se + Math.imul(St, pi) | 0, me = me + Math.imul(sr, di) | 0, ie = ie + Math.imul(sr, ji) | 0, ie = ie + Math.imul(wr, di) | 0, Se = Se + Math.imul(wr, ji) | 0, me = me + Math.imul(Gt, wi) | 0, ie = ie + Math.imul(Gt, On) | 0, ie = ie + Math.imul(Nt, wi) | 0, Se = Se + Math.imul(Nt, On) | 0, me = me + Math.imul(Zt, Fn) | 0, ie = ie + Math.imul(Zt, ra) | 0, ie = ie + Math.imul(st, Fn) | 0, Se = Se + Math.imul(st, ra) | 0, me = me + Math.imul(Ze, Ut) | 0, ie = ie + Math.imul(Ze, wt) | 0, ie = ie + Math.imul(ut, Ut) | 0, Se = Se + Math.imul(ut, wt) | 0;\n                    var Sn = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Sn >>> 26) | 0, Sn &= 67108863, me = Math.imul(Tr, xe), ie = Math.imul(Tr, ke), ie = ie + Math.imul(Lr, xe) | 0, Se = Math.imul(Lr, ke), me = me + Math.imul(mt, ir) | 0, ie = ie + Math.imul(mt, ar) | 0, ie = ie + Math.imul(er, ir) | 0, Se = Se + Math.imul(er, ar) | 0, me = me + Math.imul(Vt, ii) | 0, ie = ie + Math.imul(Vt, pi) | 0, ie = ie + Math.imul(_t, ii) | 0, Se = Se + Math.imul(_t, pi) | 0, me = me + Math.imul($e, di) | 0, ie = ie + Math.imul($e, ji) | 0, ie = ie + Math.imul(St, di) | 0, Se = Se + Math.imul(St, ji) | 0, me = me + Math.imul(sr, wi) | 0, ie = ie + Math.imul(sr, On) | 0, ie = ie + Math.imul(wr, wi) | 0, Se = Se + Math.imul(wr, On) | 0, me = me + Math.imul(Gt, Fn) | 0, ie = ie + Math.imul(Gt, ra) | 0, ie = ie + Math.imul(Nt, Fn) | 0, Se = Se + Math.imul(Nt, ra) | 0, me = me + Math.imul(Zt, Ut) | 0, ie = ie + Math.imul(Zt, wt) | 0, ie = ie + Math.imul(st, Ut) | 0, Se = Se + Math.imul(st, wt) | 0;\n                    var Ba = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Ba >>> 26) | 0, Ba &= 67108863, me = Math.imul(Tr, ir), ie = Math.imul(Tr, ar), ie = ie + Math.imul(Lr, ir) | 0, Se = Math.imul(Lr, ar), me = me + Math.imul(mt, ii) | 0, ie = ie + Math.imul(mt, pi) | 0, ie = ie + Math.imul(er, ii) | 0, Se = Se + Math.imul(er, pi) | 0, me = me + Math.imul(Vt, di) | 0, ie = ie + Math.imul(Vt, ji) | 0, ie = ie + Math.imul(_t, di) | 0, Se = Se + Math.imul(_t, ji) | 0, me = me + Math.imul($e, wi) | 0, ie = ie + Math.imul($e, On) | 0, ie = ie + Math.imul(St, wi) | 0, Se = Se + Math.imul(St, On) | 0, me = me + Math.imul(sr, Fn) | 0, ie = ie + Math.imul(sr, ra) | 0, ie = ie + Math.imul(wr, Fn) | 0, Se = Se + Math.imul(wr, ra) | 0, me = me + Math.imul(Gt, Ut) | 0, ie = ie + Math.imul(Gt, wt) | 0, ie = ie + Math.imul(Nt, Ut) | 0, Se = Se + Math.imul(Nt, wt) | 0;\n                    var ua = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (ua >>> 26) | 0, ua &= 67108863, me = Math.imul(Tr, ii), ie = Math.imul(Tr, pi), ie = ie + Math.imul(Lr, ii) | 0, Se = Math.imul(Lr, pi), me = me + Math.imul(mt, di) | 0, ie = ie + Math.imul(mt, ji) | 0, ie = ie + Math.imul(er, di) | 0, Se = Se + Math.imul(er, ji) | 0, me = me + Math.imul(Vt, wi) | 0, ie = ie + Math.imul(Vt, On) | 0, ie = ie + Math.imul(_t, wi) | 0, Se = Se + Math.imul(_t, On) | 0, me = me + Math.imul($e, Fn) | 0, ie = ie + Math.imul($e, ra) | 0, ie = ie + Math.imul(St, Fn) | 0, Se = Se + Math.imul(St, ra) | 0, me = me + Math.imul(sr, Ut) | 0, ie = ie + Math.imul(sr, wt) | 0, ie = ie + Math.imul(wr, Ut) | 0, Se = Se + Math.imul(wr, wt) | 0;\n                    var ma = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (ma >>> 26) | 0, ma &= 67108863, me = Math.imul(Tr, di), ie = Math.imul(Tr, ji), ie = ie + Math.imul(Lr, di) | 0, Se = Math.imul(Lr, ji), me = me + Math.imul(mt, wi) | 0, ie = ie + Math.imul(mt, On) | 0, ie = ie + Math.imul(er, wi) | 0, Se = Se + Math.imul(er, On) | 0, me = me + Math.imul(Vt, Fn) | 0, ie = ie + Math.imul(Vt, ra) | 0, ie = ie + Math.imul(_t, Fn) | 0, Se = Se + Math.imul(_t, ra) | 0, me = me + Math.imul($e, Ut) | 0, ie = ie + Math.imul($e, wt) | 0, ie = ie + Math.imul(St, Ut) | 0, Se = Se + Math.imul(St, wt) | 0;\n                    var Wa = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Wa >>> 26) | 0, Wa &= 67108863, me = Math.imul(Tr, wi), ie = Math.imul(Tr, On), ie = ie + Math.imul(Lr, wi) | 0, Se = Math.imul(Lr, On), me = me + Math.imul(mt, Fn) | 0, ie = ie + Math.imul(mt, ra) | 0, ie = ie + Math.imul(er, Fn) | 0, Se = Se + Math.imul(er, ra) | 0, me = me + Math.imul(Vt, Ut) | 0, ie = ie + Math.imul(Vt, wt) | 0, ie = ie + Math.imul(_t, Ut) | 0, Se = Se + Math.imul(_t, wt) | 0;\n                    var Fa = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Fa >>> 26) | 0, Fa &= 67108863, me = Math.imul(Tr, Fn), ie = Math.imul(Tr, ra), ie = ie + Math.imul(Lr, Fn) | 0, Se = Math.imul(Lr, ra), me = me + Math.imul(mt, Ut) | 0, ie = ie + Math.imul(mt, wt) | 0, ie = ie + Math.imul(er, Ut) | 0, Se = Se + Math.imul(er, wt) | 0;\n                    var Wo = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    Ce = (Se + (ie >>> 13) | 0) + (Wo >>> 26) | 0, Wo &= 67108863, me = Math.imul(Tr, Ut), ie = Math.imul(Tr, wt), ie = ie + Math.imul(Lr, Ut) | 0, Se = Math.imul(Lr, wt);\n                    var da = (Ce + me | 0) + ((ie & 8191) << 13) | 0;\n                    return Ce = (Se + (ie >>> 13) | 0) + (da >>> 26) | 0, da &= 67108863, Ee[0] = rr, Ee[1] = nr, Ee[2] = Er, Ee[3] = Xr, Ee[4] = ri, Ee[5] = Qr, Ee[6] = Oi, Ee[7] = $i, Ee[8] = tn, Ee[9] = fn, Ee[10] = yn, Ee[11] = Sn, Ee[12] = Ba, Ee[13] = ua, Ee[14] = ma, Ee[15] = Wa, Ee[16] = Fa, Ee[17] = Wo, Ee[18] = da, Ce !== 0 && (Ee[19] = Ce, te.length++), te;\n                  };\n                  Math.imul || (L3 = S2);\n                  function x2(j3, N2, H) {\n                    H.negative = N2.negative ^ j3.negative, H.length = j3.length + N2.length;\n                    for (var te = 0, oe = 0, _e = 0; _e < H.length - 1; _e++) {\n                      var Ee = oe;\n                      oe = 0;\n                      for (var Ce = te & 67108863, me = Math.min(_e, N2.length - 1), ie = Math.max(0, _e - j3.length + 1); ie <= me; ie++) {\n                        var Se = _e - ie, Le = j3.words[Se] | 0, Ae = N2.words[ie] | 0, Fe = Le * Ae, Pe = Fe & 67108863;\n                        Ee = Ee + (Fe / 67108864 | 0) | 0, Pe = Pe + Ce | 0, Ce = Pe & 67108863, Ee = Ee + (Pe >>> 26) | 0, oe += Ee >>> 26, Ee &= 67108863;\n                      }\n                      H.words[_e] = Ce, te = Ee, Ee = oe;\n                    }\n                    return te !== 0 ? H.words[_e] = te : H.length--, H.strip();\n                  }\n                  function C3(j3, N2, H) {\n                    var te = new M4();\n                    return te.mulp(j3, N2, H);\n                  }\n                  f4.prototype.mulTo = function(N2, H) {\n                    var te, oe = this.length + N2.length;\n                    return this.length === 10 && N2.length === 10 ? te = L3(this, N2, H) : oe < 63 ? te = S2(this, N2, H) : oe < 1024 ? te = x2(this, N2, H) : te = C3(this, N2, H), te;\n                  };\n                  function M4(j3, N2) {\n                    this.x = j3, this.y = N2;\n                  }\n                  M4.prototype.makeRBT = function(N2) {\n                    for (var H = new Array(N2), te = f4.prototype._countBits(N2) - 1, oe = 0; oe < N2; oe++) H[oe] = this.revBin(oe, te, N2);\n                    return H;\n                  }, M4.prototype.revBin = function(N2, H, te) {\n                    if (N2 === 0 || N2 === te - 1) return N2;\n                    for (var oe = 0, _e = 0; _e < H; _e++) oe |= (N2 & 1) << H - _e - 1, N2 >>= 1;\n                    return oe;\n                  }, M4.prototype.permute = function(N2, H, te, oe, _e, Ee) {\n                    for (var Ce = 0; Ce < Ee; Ce++) oe[Ce] = H[N2[Ce]], _e[Ce] = te[N2[Ce]];\n                  }, M4.prototype.transform = function(N2, H, te, oe, _e, Ee) {\n                    this.permute(Ee, N2, H, te, oe, _e);\n                    for (var Ce = 1; Ce < _e; Ce <<= 1) for (var me = Ce << 1, ie = Math.cos(2 * Math.PI / me), Se = Math.sin(2 * Math.PI / me), Le = 0; Le < _e; Le += me) for (var Ae = ie, Fe = Se, Pe = 0; Pe < Ce; Pe++) {\n                      var ge = te[Le + Pe], Re = oe[Le + Pe], ce = te[Le + Pe + Ce], Ze = oe[Le + Pe + Ce], ut = Ae * ce - Fe * Ze;\n                      Ze = Ae * Ze + Fe * ce, ce = ut, te[Le + Pe] = ge + ce, oe[Le + Pe] = Re + Ze, te[Le + Pe + Ce] = ge - ce, oe[Le + Pe + Ce] = Re - Ze, Pe !== me && (ut = ie * Ae - Se * Fe, Fe = ie * Fe + Se * Ae, Ae = ut);\n                    }\n                  }, M4.prototype.guessLen13b = function(N2, H) {\n                    var te = Math.max(H, N2) | 1, oe = te & 1, _e = 0;\n                    for (te = te / 2 | 0; te; te = te >>> 1) _e++;\n                    return 1 << _e + 1 + oe;\n                  }, M4.prototype.conjugate = function(N2, H, te) {\n                    if (!(te <= 1)) for (var oe = 0; oe < te / 2; oe++) {\n                      var _e = N2[oe];\n                      N2[oe] = N2[te - oe - 1], N2[te - oe - 1] = _e, _e = H[oe], H[oe] = -H[te - oe - 1], H[te - oe - 1] = -_e;\n                    }\n                  }, M4.prototype.normalize13b = function(N2, H) {\n                    for (var te = 0, oe = 0; oe < H / 2; oe++) {\n                      var _e = Math.round(N2[2 * oe + 1] / H) * 8192 + Math.round(N2[2 * oe] / H) + te;\n                      N2[oe] = _e & 67108863, _e < 67108864 ? te = 0 : te = _e / 67108864 | 0;\n                    }\n                    return N2;\n                  }, M4.prototype.convert13b = function(N2, H, te, oe) {\n                    for (var _e = 0, Ee = 0; Ee < H; Ee++) _e = _e + (N2[Ee] | 0), te[2 * Ee] = _e & 8191, _e = _e >>> 13, te[2 * Ee + 1] = _e & 8191, _e = _e >>> 13;\n                    for (Ee = 2 * H; Ee < oe; ++Ee) te[Ee] = 0;\n                    u4(_e === 0), u4((_e & -8192) === 0);\n                  }, M4.prototype.stub = function(N2) {\n                    for (var H = new Array(N2), te = 0; te < N2; te++) H[te] = 0;\n                    return H;\n                  }, M4.prototype.mulp = function(N2, H, te) {\n                    var oe = 2 * this.guessLen13b(N2.length, H.length), _e = this.makeRBT(oe), Ee = this.stub(oe), Ce = new Array(oe), me = new Array(oe), ie = new Array(oe), Se = new Array(oe), Le = new Array(oe), Ae = new Array(oe), Fe = te.words;\n                    Fe.length = oe, this.convert13b(N2.words, N2.length, Ce, oe), this.convert13b(H.words, H.length, Se, oe), this.transform(Ce, Ee, me, ie, oe, _e), this.transform(Se, Ee, Le, Ae, oe, _e);\n                    for (var Pe = 0; Pe < oe; Pe++) {\n                      var ge = me[Pe] * Le[Pe] - ie[Pe] * Ae[Pe];\n                      ie[Pe] = me[Pe] * Ae[Pe] + ie[Pe] * Le[Pe], me[Pe] = ge;\n                    }\n                    return this.conjugate(me, ie, oe), this.transform(me, ie, Fe, Ee, oe, _e), this.conjugate(Fe, Ee, oe), this.normalize13b(Fe, oe), te.negative = N2.negative ^ H.negative, te.length = N2.length + H.length, te.strip();\n                  }, f4.prototype.mul = function(N2) {\n                    var H = new f4(null);\n                    return H.words = new Array(this.length + N2.length), this.mulTo(N2, H);\n                  }, f4.prototype.mulf = function(N2) {\n                    var H = new f4(null);\n                    return H.words = new Array(this.length + N2.length), C3(this, N2, H);\n                  }, f4.prototype.imul = function(N2) {\n                    return this.clone().mulTo(N2, this);\n                  }, f4.prototype.imuln = function(N2) {\n                    u4(typeof N2 == "number"), u4(N2 < 67108864);\n                    for (var H = 0, te = 0; te < this.length; te++) {\n                      var oe = (this.words[te] | 0) * N2, _e = (oe & 67108863) + (H & 67108863);\n                      H >>= 26, H += oe / 67108864 | 0, H += _e >>> 26, this.words[te] = _e & 67108863;\n                    }\n                    return H !== 0 && (this.words[te] = H, this.length++), this;\n                  }, f4.prototype.muln = function(N2) {\n                    return this.clone().imuln(N2);\n                  }, f4.prototype.sqr = function() {\n                    return this.mul(this);\n                  }, f4.prototype.isqr = function() {\n                    return this.imul(this.clone());\n                  }, f4.prototype.pow = function(N2) {\n                    var H = E3(N2);\n                    if (H.length === 0) return new f4(1);\n                    for (var te = this, oe = 0; oe < H.length && H[oe] === 0; oe++, te = te.sqr()) ;\n                    if (++oe < H.length) for (var _e = te.sqr(); oe < H.length; oe++, _e = _e.sqr()) H[oe] !== 0 && (te = te.mul(_e));\n                    return te;\n                  }, f4.prototype.iushln = function(N2) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var H = N2 % 26, te = (N2 - H) / 26, oe = 67108863 >>> 26 - H << 26 - H, _e;\n                    if (H !== 0) {\n                      var Ee = 0;\n                      for (_e = 0; _e < this.length; _e++) {\n                        var Ce = this.words[_e] & oe, me = (this.words[_e] | 0) - Ce << H;\n                        this.words[_e] = me | Ee, Ee = Ce >>> 26 - H;\n                      }\n                      Ee && (this.words[_e] = Ee, this.length++);\n                    }\n                    if (te !== 0) {\n                      for (_e = this.length - 1; _e >= 0; _e--) this.words[_e + te] = this.words[_e];\n                      for (_e = 0; _e < te; _e++) this.words[_e] = 0;\n                      this.length += te;\n                    }\n                    return this.strip();\n                  }, f4.prototype.ishln = function(N2) {\n                    return u4(this.negative === 0), this.iushln(N2);\n                  }, f4.prototype.iushrn = function(N2, H, te) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var oe;\n                    H ? oe = (H - H % 26) / 26 : oe = 0;\n                    var _e = N2 % 26, Ee = Math.min((N2 - _e) / 26, this.length), Ce = 67108863 ^ 67108863 >>> _e << _e, me = te;\n                    if (oe -= Ee, oe = Math.max(0, oe), me) {\n                      for (var ie = 0; ie < Ee; ie++) me.words[ie] = this.words[ie];\n                      me.length = Ee;\n                    }\n                    if (Ee !== 0) if (this.length > Ee) for (this.length -= Ee, ie = 0; ie < this.length; ie++) this.words[ie] = this.words[ie + Ee];\n                    else this.words[0] = 0, this.length = 1;\n                    var Se = 0;\n                    for (ie = this.length - 1; ie >= 0 && (Se !== 0 || ie >= oe); ie--) {\n                      var Le = this.words[ie] | 0;\n                      this.words[ie] = Se << 26 - _e | Le >>> _e, Se = Le & Ce;\n                    }\n                    return me && Se !== 0 && (me.words[me.length++] = Se), this.length === 0 && (this.words[0] = 0, this.length = 1), this.strip();\n                  }, f4.prototype.ishrn = function(N2, H, te) {\n                    return u4(this.negative === 0), this.iushrn(N2, H, te);\n                  }, f4.prototype.shln = function(N2) {\n                    return this.clone().ishln(N2);\n                  }, f4.prototype.ushln = function(N2) {\n                    return this.clone().iushln(N2);\n                  }, f4.prototype.shrn = function(N2) {\n                    return this.clone().ishrn(N2);\n                  }, f4.prototype.ushrn = function(N2) {\n                    return this.clone().iushrn(N2);\n                  }, f4.prototype.testn = function(N2) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var H = N2 % 26, te = (N2 - H) / 26, oe = 1 << H;\n                    if (this.length <= te) return false;\n                    var _e = this.words[te];\n                    return !!(_e & oe);\n                  }, f4.prototype.imaskn = function(N2) {\n                    u4(typeof N2 == "number" && N2 >= 0);\n                    var H = N2 % 26, te = (N2 - H) / 26;\n                    if (u4(this.negative === 0, "imaskn works only with positive numbers"), this.length <= te) return this;\n                    if (H !== 0 && te++, this.length = Math.min(te, this.length), H !== 0) {\n                      var oe = 67108863 ^ 67108863 >>> H << H;\n                      this.words[this.length - 1] &= oe;\n                    }\n                    return this.strip();\n                  }, f4.prototype.maskn = function(N2) {\n                    return this.clone().imaskn(N2);\n                  }, f4.prototype.iaddn = function(N2) {\n                    return u4(typeof N2 == "number"), u4(N2 < 67108864), N2 < 0 ? this.isubn(-N2) : this.negative !== 0 ? this.length === 1 && (this.words[0] | 0) < N2 ? (this.words[0] = N2 - (this.words[0] | 0), this.negative = 0, this) : (this.negative = 0, this.isubn(N2), this.negative = 1, this) : this._iaddn(N2);\n                  }, f4.prototype._iaddn = function(N2) {\n                    this.words[0] += N2;\n                    for (var H = 0; H < this.length && this.words[H] >= 67108864; H++) this.words[H] -= 67108864, H === this.length - 1 ? this.words[H + 1] = 1 : this.words[H + 1]++;\n                    return this.length = Math.max(this.length, H + 1), this;\n                  }, f4.prototype.isubn = function(N2) {\n                    if (u4(typeof N2 == "number"), u4(N2 < 67108864), N2 < 0) return this.iaddn(-N2);\n                    if (this.negative !== 0) return this.negative = 0, this.iaddn(N2), this.negative = 1, this;\n                    if (this.words[0] -= N2, this.length === 1 && this.words[0] < 0) this.words[0] = -this.words[0], this.negative = 1;\n                    else for (var H = 0; H < this.length && this.words[H] < 0; H++) this.words[H] += 67108864, this.words[H + 1] -= 1;\n                    return this.strip();\n                  }, f4.prototype.addn = function(N2) {\n                    return this.clone().iaddn(N2);\n                  }, f4.prototype.subn = function(N2) {\n                    return this.clone().isubn(N2);\n                  }, f4.prototype.iabs = function() {\n                    return this.negative = 0, this;\n                  }, f4.prototype.abs = function() {\n                    return this.clone().iabs();\n                  }, f4.prototype._ishlnsubmul = function(N2, H, te) {\n                    var oe = N2.length + te, _e;\n                    this._expand(oe);\n                    var Ee, Ce = 0;\n                    for (_e = 0; _e < N2.length; _e++) {\n                      Ee = (this.words[_e + te] | 0) + Ce;\n                      var me = (N2.words[_e] | 0) * H;\n                      Ee -= me & 67108863, Ce = (Ee >> 26) - (me / 67108864 | 0), this.words[_e + te] = Ee & 67108863;\n                    }\n                    for (; _e < this.length - te; _e++) Ee = (this.words[_e + te] | 0) + Ce, Ce = Ee >> 26, this.words[_e + te] = Ee & 67108863;\n                    if (Ce === 0) return this.strip();\n                    for (u4(Ce === -1), Ce = 0, _e = 0; _e < this.length; _e++) Ee = -(this.words[_e] | 0) + Ce, Ce = Ee >> 26, this.words[_e] = Ee & 67108863;\n                    return this.negative = 1, this.strip();\n                  }, f4.prototype._wordDiv = function(N2, H) {\n                    var te = this.length - N2.length, oe = this.clone(), _e = N2, Ee = _e.words[_e.length - 1] | 0, Ce = this._countBits(Ee);\n                    te = 26 - Ce, te !== 0 && (_e = _e.ushln(te), oe.iushln(te), Ee = _e.words[_e.length - 1] | 0);\n                    var me = oe.length - _e.length, ie;\n                    if (H !== "mod") {\n                      ie = new f4(null), ie.length = me + 1, ie.words = new Array(ie.length);\n                      for (var Se = 0; Se < ie.length; Se++) ie.words[Se] = 0;\n                    }\n                    var Le = oe.clone()._ishlnsubmul(_e, 1, me);\n                    Le.negative === 0 && (oe = Le, ie && (ie.words[me] = 1));\n                    for (var Ae = me - 1; Ae >= 0; Ae--) {\n                      var Fe = (oe.words[_e.length + Ae] | 0) * 67108864 + (oe.words[_e.length + Ae - 1] | 0);\n                      for (Fe = Math.min(Fe / Ee | 0, 67108863), oe._ishlnsubmul(_e, Fe, Ae); oe.negative !== 0; ) Fe--, oe.negative = 0, oe._ishlnsubmul(_e, 1, Ae), oe.isZero() || (oe.negative ^= 1);\n                      ie && (ie.words[Ae] = Fe);\n                    }\n                    return ie && ie.strip(), oe.strip(), H !== "div" && te !== 0 && oe.iushrn(te), { div: ie || null, mod: oe };\n                  }, f4.prototype.divmod = function(N2, H, te) {\n                    if (u4(!N2.isZero()), this.isZero()) return { div: new f4(0), mod: new f4(0) };\n                    var oe, _e, Ee;\n                    return this.negative !== 0 && N2.negative === 0 ? (Ee = this.neg().divmod(N2, H), H !== "mod" && (oe = Ee.div.neg()), H !== "div" && (_e = Ee.mod.neg(), te && _e.negative !== 0 && _e.iadd(N2)), { div: oe, mod: _e }) : this.negative === 0 && N2.negative !== 0 ? (Ee = this.divmod(N2.neg(), H), H !== "mod" && (oe = Ee.div.neg()), { div: oe, mod: Ee.mod }) : (this.negative & N2.negative) !== 0 ? (Ee = this.neg().divmod(N2.neg(), H), H !== "div" && (_e = Ee.mod.neg(), te && _e.negative !== 0 && _e.isub(N2)), { div: Ee.div, mod: _e }) : N2.length > this.length || this.cmp(N2) < 0 ? { div: new f4(0), mod: this } : N2.length === 1 ? H === "div" ? { div: this.divn(N2.words[0]), mod: null } : H === "mod" ? { div: null, mod: new f4(this.modn(N2.words[0])) } : { div: this.divn(N2.words[0]), mod: new f4(this.modn(N2.words[0])) } : this._wordDiv(N2, H);\n                  }, f4.prototype.div = function(N2) {\n                    return this.divmod(N2, "div", false).div;\n                  }, f4.prototype.mod = function(N2) {\n                    return this.divmod(N2, "mod", false).mod;\n                  }, f4.prototype.umod = function(N2) {\n                    return this.divmod(N2, "mod", true).mod;\n                  }, f4.prototype.divRound = function(N2) {\n                    var H = this.divmod(N2);\n                    if (H.mod.isZero()) return H.div;\n                    var te = H.div.negative !== 0 ? H.mod.isub(N2) : H.mod, oe = N2.ushrn(1), _e = N2.andln(1), Ee = te.cmp(oe);\n                    return Ee < 0 || _e === 1 && Ee === 0 ? H.div : H.div.negative !== 0 ? H.div.isubn(1) : H.div.iaddn(1);\n                  }, f4.prototype.modn = function(N2) {\n                    u4(N2 <= 67108863);\n                    for (var H = (1 << 26) % N2, te = 0, oe = this.length - 1; oe >= 0; oe--) te = (H * te + (this.words[oe] | 0)) % N2;\n                    return te;\n                  }, f4.prototype.idivn = function(N2) {\n                    u4(N2 <= 67108863);\n                    for (var H = 0, te = this.length - 1; te >= 0; te--) {\n                      var oe = (this.words[te] | 0) + H * 67108864;\n                      this.words[te] = oe / N2 | 0, H = oe % N2;\n                    }\n                    return this.strip();\n                  }, f4.prototype.divn = function(N2) {\n                    return this.clone().idivn(N2);\n                  }, f4.prototype.egcd = function(N2) {\n                    u4(N2.negative === 0), u4(!N2.isZero());\n                    var H = this, te = N2.clone();\n                    H.negative !== 0 ? H = H.umod(N2) : H = H.clone();\n                    for (var oe = new f4(1), _e = new f4(0), Ee = new f4(0), Ce = new f4(1), me = 0; H.isEven() && te.isEven(); ) H.iushrn(1), te.iushrn(1), ++me;\n                    for (var ie = te.clone(), Se = H.clone(); !H.isZero(); ) {\n                      for (var Le = 0, Ae = 1; (H.words[0] & Ae) === 0 && Le < 26; ++Le, Ae <<= 1) ;\n                      if (Le > 0) for (H.iushrn(Le); Le-- > 0; ) (oe.isOdd() || _e.isOdd()) && (oe.iadd(ie), _e.isub(Se)), oe.iushrn(1), _e.iushrn(1);\n                      for (var Fe = 0, Pe = 1; (te.words[0] & Pe) === 0 && Fe < 26; ++Fe, Pe <<= 1) ;\n                      if (Fe > 0) for (te.iushrn(Fe); Fe-- > 0; ) (Ee.isOdd() || Ce.isOdd()) && (Ee.iadd(ie), Ce.isub(Se)), Ee.iushrn(1), Ce.iushrn(1);\n                      H.cmp(te) >= 0 ? (H.isub(te), oe.isub(Ee), _e.isub(Ce)) : (te.isub(H), Ee.isub(oe), Ce.isub(_e));\n                    }\n                    return { a: Ee, b: Ce, gcd: te.iushln(me) };\n                  }, f4.prototype._invmp = function(N2) {\n                    u4(N2.negative === 0), u4(!N2.isZero());\n                    var H = this, te = N2.clone();\n                    H.negative !== 0 ? H = H.umod(N2) : H = H.clone();\n                    for (var oe = new f4(1), _e = new f4(0), Ee = te.clone(); H.cmpn(1) > 0 && te.cmpn(1) > 0; ) {\n                      for (var Ce = 0, me = 1; (H.words[0] & me) === 0 && Ce < 26; ++Ce, me <<= 1) ;\n                      if (Ce > 0) for (H.iushrn(Ce); Ce-- > 0; ) oe.isOdd() && oe.iadd(Ee), oe.iushrn(1);\n                      for (var ie = 0, Se = 1; (te.words[0] & Se) === 0 && ie < 26; ++ie, Se <<= 1) ;\n                      if (ie > 0) for (te.iushrn(ie); ie-- > 0; ) _e.isOdd() && _e.iadd(Ee), _e.iushrn(1);\n                      H.cmp(te) >= 0 ? (H.isub(te), oe.isub(_e)) : (te.isub(H), _e.isub(oe));\n                    }\n                    var Le;\n                    return H.cmpn(1) === 0 ? Le = oe : Le = _e, Le.cmpn(0) < 0 && Le.iadd(N2), Le;\n                  }, f4.prototype.gcd = function(N2) {\n                    if (this.isZero()) return N2.abs();\n                    if (N2.isZero()) return this.abs();\n                    var H = this.clone(), te = N2.clone();\n                    H.negative = 0, te.negative = 0;\n                    for (var oe = 0; H.isEven() && te.isEven(); oe++) H.iushrn(1), te.iushrn(1);\n                    do {\n                      for (; H.isEven(); ) H.iushrn(1);\n                      for (; te.isEven(); ) te.iushrn(1);\n                      var _e = H.cmp(te);\n                      if (_e < 0) {\n                        var Ee = H;\n                        H = te, te = Ee;\n                      } else if (_e === 0 || te.cmpn(1) === 0) break;\n                      H.isub(te);\n                    } while (true);\n                    return te.iushln(oe);\n                  }, f4.prototype.invm = function(N2) {\n                    return this.egcd(N2).a.umod(N2);\n                  }, f4.prototype.isEven = function() {\n                    return (this.words[0] & 1) === 0;\n                  }, f4.prototype.isOdd = function() {\n                    return (this.words[0] & 1) === 1;\n                  }, f4.prototype.andln = function(N2) {\n                    return this.words[0] & N2;\n                  }, f4.prototype.bincn = function(N2) {\n                    u4(typeof N2 == "number");\n                    var H = N2 % 26, te = (N2 - H) / 26, oe = 1 << H;\n                    if (this.length <= te) return this._expand(te + 1), this.words[te] |= oe, this;\n                    for (var _e = oe, Ee = te; _e !== 0 && Ee < this.length; Ee++) {\n                      var Ce = this.words[Ee] | 0;\n                      Ce += _e, _e = Ce >>> 26, Ce &= 67108863, this.words[Ee] = Ce;\n                    }\n                    return _e !== 0 && (this.words[Ee] = _e, this.length++), this;\n                  }, f4.prototype.isZero = function() {\n                    return this.length === 1 && this.words[0] === 0;\n                  }, f4.prototype.cmpn = function(N2) {\n                    var H = N2 < 0;\n                    if (this.negative !== 0 && !H) return -1;\n                    if (this.negative === 0 && H) return 1;\n                    this.strip();\n                    var te;\n                    if (this.length > 1) te = 1;\n                    else {\n                      H && (N2 = -N2), u4(N2 <= 67108863, "Number is too big");\n                      var oe = this.words[0] | 0;\n                      te = oe === N2 ? 0 : oe < N2 ? -1 : 1;\n                    }\n                    return this.negative !== 0 ? -te | 0 : te;\n                  }, f4.prototype.cmp = function(N2) {\n                    if (this.negative !== 0 && N2.negative === 0) return -1;\n                    if (this.negative === 0 && N2.negative !== 0) return 1;\n                    var H = this.ucmp(N2);\n                    return this.negative !== 0 ? -H | 0 : H;\n                  }, f4.prototype.ucmp = function(N2) {\n                    if (this.length > N2.length) return 1;\n                    if (this.length < N2.length) return -1;\n                    for (var H = 0, te = this.length - 1; te >= 0; te--) {\n                      var oe = this.words[te] | 0, _e = N2.words[te] | 0;\n                      if (oe !== _e) {\n                        oe < _e ? H = -1 : oe > _e && (H = 1);\n                        break;\n                      }\n                    }\n                    return H;\n                  }, f4.prototype.gtn = function(N2) {\n                    return this.cmpn(N2) === 1;\n                  }, f4.prototype.gt = function(N2) {\n                    return this.cmp(N2) === 1;\n                  }, f4.prototype.gten = function(N2) {\n                    return this.cmpn(N2) >= 0;\n                  }, f4.prototype.gte = function(N2) {\n                    return this.cmp(N2) >= 0;\n                  }, f4.prototype.ltn = function(N2) {\n                    return this.cmpn(N2) === -1;\n                  }, f4.prototype.lt = function(N2) {\n                    return this.cmp(N2) === -1;\n                  }, f4.prototype.lten = function(N2) {\n                    return this.cmpn(N2) <= 0;\n                  }, f4.prototype.lte = function(N2) {\n                    return this.cmp(N2) <= 0;\n                  }, f4.prototype.eqn = function(N2) {\n                    return this.cmpn(N2) === 0;\n                  }, f4.prototype.eq = function(N2) {\n                    return this.cmp(N2) === 0;\n                  }, f4.red = function(N2) {\n                    return new G2(N2);\n                  }, f4.prototype.toRed = function(N2) {\n                    return u4(!this.red, "Already a number in reduction context"), u4(this.negative === 0, "red works only with positives"), N2.convertTo(this)._forceRed(N2);\n                  }, f4.prototype.fromRed = function() {\n                    return u4(this.red, "fromRed works only with numbers in reduction context"), this.red.convertFrom(this);\n                  }, f4.prototype._forceRed = function(N2) {\n                    return this.red = N2, this;\n                  }, f4.prototype.forceRed = function(N2) {\n                    return u4(!this.red, "Already a number in reduction context"), this._forceRed(N2);\n                  }, f4.prototype.redAdd = function(N2) {\n                    return u4(this.red, "redAdd works only with red numbers"), this.red.add(this, N2);\n                  }, f4.prototype.redIAdd = function(N2) {\n                    return u4(this.red, "redIAdd works only with red numbers"), this.red.iadd(this, N2);\n                  }, f4.prototype.redSub = function(N2) {\n                    return u4(this.red, "redSub works only with red numbers"), this.red.sub(this, N2);\n                  }, f4.prototype.redISub = function(N2) {\n                    return u4(this.red, "redISub works only with red numbers"), this.red.isub(this, N2);\n                  }, f4.prototype.redShl = function(N2) {\n                    return u4(this.red, "redShl works only with red numbers"), this.red.shl(this, N2);\n                  }, f4.prototype.redMul = function(N2) {\n                    return u4(this.red, "redMul works only with red numbers"), this.red._verify2(this, N2), this.red.mul(this, N2);\n                  }, f4.prototype.redIMul = function(N2) {\n                    return u4(this.red, "redMul works only with red numbers"), this.red._verify2(this, N2), this.red.imul(this, N2);\n                  }, f4.prototype.redSqr = function() {\n                    return u4(this.red, "redSqr works only with red numbers"), this.red._verify1(this), this.red.sqr(this);\n                  }, f4.prototype.redISqr = function() {\n                    return u4(this.red, "redISqr works only with red numbers"), this.red._verify1(this), this.red.isqr(this);\n                  }, f4.prototype.redSqrt = function() {\n                    return u4(this.red, "redSqrt works only with red numbers"), this.red._verify1(this), this.red.sqrt(this);\n                  }, f4.prototype.redInvm = function() {\n                    return u4(this.red, "redInvm works only with red numbers"), this.red._verify1(this), this.red.invm(this);\n                  }, f4.prototype.redNeg = function() {\n                    return u4(this.red, "redNeg works only with red numbers"), this.red._verify1(this), this.red.neg(this);\n                  }, f4.prototype.redPow = function(N2) {\n                    return u4(this.red && !N2.red, "redPow(normalNum)"), this.red._verify1(this), this.red.pow(this, N2);\n                  };\n                  var g3 = { k256: null, p224: null, p192: null, p25519: null };\n                  function P3(j3, N2) {\n                    this.name = j3, this.p = new f4(N2, 16), this.n = this.p.bitLength(), this.k = new f4(1).iushln(this.n).isub(this.p), this.tmp = this._tmp();\n                  }\n                  P3.prototype._tmp = function() {\n                    var N2 = new f4(null);\n                    return N2.words = new Array(Math.ceil(this.n / 13)), N2;\n                  }, P3.prototype.ireduce = function(N2) {\n                    var H = N2, te;\n                    do\n                      this.split(H, this.tmp), H = this.imulK(H), H = H.iadd(this.tmp), te = H.bitLength();\n                    while (te > this.n);\n                    var oe = te < this.n ? -1 : H.ucmp(this.p);\n                    return oe === 0 ? (H.words[0] = 0, H.length = 1) : oe > 0 ? H.isub(this.p) : H.strip !== void 0 ? H.strip() : H._strip(), H;\n                  }, P3.prototype.split = function(N2, H) {\n                    N2.iushrn(this.n, 0, H);\n                  }, P3.prototype.imulK = function(N2) {\n                    return N2.imul(this.k);\n                  };\n                  function T3() {\n                    P3.call(this, "k256", "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f");\n                  }\n                  c5(T3, P3), T3.prototype.split = function(N2, H) {\n                    for (var te = 4194303, oe = Math.min(N2.length, 9), _e = 0; _e < oe; _e++) H.words[_e] = N2.words[_e];\n                    if (H.length = oe, N2.length <= 9) {\n                      N2.words[0] = 0, N2.length = 1;\n                      return;\n                    }\n                    var Ee = N2.words[9];\n                    for (H.words[H.length++] = Ee & te, _e = 10; _e < N2.length; _e++) {\n                      var Ce = N2.words[_e] | 0;\n                      N2.words[_e - 10] = (Ce & te) << 4 | Ee >>> 22, Ee = Ce;\n                    }\n                    Ee >>>= 22, N2.words[_e - 10] = Ee, Ee === 0 && N2.length > 10 ? N2.length -= 10 : N2.length -= 9;\n                  }, T3.prototype.imulK = function(N2) {\n                    N2.words[N2.length] = 0, N2.words[N2.length + 1] = 0, N2.length += 2;\n                    for (var H = 0, te = 0; te < N2.length; te++) {\n                      var oe = N2.words[te] | 0;\n                      H += oe * 977, N2.words[te] = H & 67108863, H = oe * 64 + (H / 67108864 | 0);\n                    }\n                    return N2.words[N2.length - 1] === 0 && (N2.length--, N2.words[N2.length - 1] === 0 && N2.length--), N2;\n                  };\n                  function z3() {\n                    P3.call(this, "p224", "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001");\n                  }\n                  c5(z3, P3);\n                  function O3() {\n                    P3.call(this, "p192", "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff");\n                  }\n                  c5(O3, P3);\n                  function V2() {\n                    P3.call(this, "25519", "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed");\n                  }\n                  c5(V2, P3), V2.prototype.imulK = function(N2) {\n                    for (var H = 0, te = 0; te < N2.length; te++) {\n                      var oe = (N2.words[te] | 0) * 19 + H, _e = oe & 67108863;\n                      oe >>>= 26, N2.words[te] = _e, H = oe;\n                    }\n                    return H !== 0 && (N2.words[N2.length++] = H), N2;\n                  }, f4._prime = function(N2) {\n                    if (g3[N2]) return g3[N2];\n                    var H;\n                    if (N2 === "k256") H = new T3();\n                    else if (N2 === "p224") H = new z3();\n                    else if (N2 === "p192") H = new O3();\n                    else if (N2 === "p25519") H = new V2();\n                    else throw new Error("Unknown prime " + N2);\n                    return g3[N2] = H, H;\n                  };\n                  function G2(j3) {\n                    if (typeof j3 == "string") {\n                      var N2 = f4._prime(j3);\n                      this.m = N2.p, this.prime = N2;\n                    } else u4(j3.gtn(1), "modulus must be greater than 1"), this.m = j3, this.prime = null;\n                  }\n                  G2.prototype._verify1 = function(N2) {\n                    u4(N2.negative === 0, "red works only with positives"), u4(N2.red, "red works only with red numbers");\n                  }, G2.prototype._verify2 = function(N2, H) {\n                    u4((N2.negative | H.negative) === 0, "red works only with positives"), u4(N2.red && N2.red === H.red, "red works only with red numbers");\n                  }, G2.prototype.imod = function(N2) {\n                    return this.prime ? this.prime.ireduce(N2)._forceRed(this) : N2.umod(this.m)._forceRed(this);\n                  }, G2.prototype.neg = function(N2) {\n                    return N2.isZero() ? N2.clone() : this.m.sub(N2)._forceRed(this);\n                  }, G2.prototype.add = function(N2, H) {\n                    this._verify2(N2, H);\n                    var te = N2.add(H);\n                    return te.cmp(this.m) >= 0 && te.isub(this.m), te._forceRed(this);\n                  }, G2.prototype.iadd = function(N2, H) {\n                    this._verify2(N2, H);\n                    var te = N2.iadd(H);\n                    return te.cmp(this.m) >= 0 && te.isub(this.m), te;\n                  }, G2.prototype.sub = function(N2, H) {\n                    this._verify2(N2, H);\n                    var te = N2.sub(H);\n                    return te.cmpn(0) < 0 && te.iadd(this.m), te._forceRed(this);\n                  }, G2.prototype.isub = function(N2, H) {\n                    this._verify2(N2, H);\n                    var te = N2.isub(H);\n                    return te.cmpn(0) < 0 && te.iadd(this.m), te;\n                  }, G2.prototype.shl = function(N2, H) {\n                    return this._verify1(N2), this.imod(N2.ushln(H));\n                  }, G2.prototype.imul = function(N2, H) {\n                    return this._verify2(N2, H), this.imod(N2.imul(H));\n                  }, G2.prototype.mul = function(N2, H) {\n                    return this._verify2(N2, H), this.imod(N2.mul(H));\n                  }, G2.prototype.isqr = function(N2) {\n                    return this.imul(N2, N2.clone());\n                  }, G2.prototype.sqr = function(N2) {\n                    return this.mul(N2, N2);\n                  }, G2.prototype.sqrt = function(N2) {\n                    if (N2.isZero()) return N2.clone();\n                    var H = this.m.andln(3);\n                    if (u4(H % 2 === 1), H === 3) {\n                      var te = this.m.add(new f4(1)).iushrn(2);\n                      return this.pow(N2, te);\n                    }\n                    for (var oe = this.m.subn(1), _e = 0; !oe.isZero() && oe.andln(1) === 0; ) _e++, oe.iushrn(1);\n                    u4(!oe.isZero());\n                    var Ee = new f4(1).toRed(this), Ce = Ee.redNeg(), me = this.m.subn(1).iushrn(1), ie = this.m.bitLength();\n                    for (ie = new f4(2 * ie * ie).toRed(this); this.pow(ie, me).cmp(Ce) !== 0; ) ie.redIAdd(Ce);\n                    for (var Se = this.pow(ie, oe), Le = this.pow(N2, oe.addn(1).iushrn(1)), Ae = this.pow(N2, oe), Fe = _e; Ae.cmp(Ee) !== 0; ) {\n                      for (var Pe = Ae, ge = 0; Pe.cmp(Ee) !== 0; ge++) Pe = Pe.redSqr();\n                      u4(ge < Fe);\n                      var Re = this.pow(Se, new f4(1).iushln(Fe - ge - 1));\n                      Le = Le.redMul(Re), Se = Re.redSqr(), Ae = Ae.redMul(Se), Fe = ge;\n                    }\n                    return Le;\n                  }, G2.prototype.invm = function(N2) {\n                    var H = N2._invmp(this.m);\n                    return H.negative !== 0 ? (H.negative = 0, this.imod(H).redNeg()) : this.imod(H);\n                  }, G2.prototype.pow = function(N2, H) {\n                    if (H.isZero()) return new f4(1).toRed(this);\n                    if (H.cmpn(1) === 0) return N2.clone();\n                    var te = 4, oe = new Array(1 << te);\n                    oe[0] = new f4(1).toRed(this), oe[1] = N2;\n                    for (var _e = 2; _e < oe.length; _e++) oe[_e] = this.mul(oe[_e - 1], N2);\n                    var Ee = oe[0], Ce = 0, me = 0, ie = H.bitLength() % 26;\n                    for (ie === 0 && (ie = 26), _e = H.length - 1; _e >= 0; _e--) {\n                      for (var Se = H.words[_e], Le = ie - 1; Le >= 0; Le--) {\n                        var Ae = Se >> Le & 1;\n                        if (Ee !== oe[0] && (Ee = this.sqr(Ee)), Ae === 0 && Ce === 0) {\n                          me = 0;\n                          continue;\n                        }\n                        Ce <<= 1, Ce |= Ae, me++, !(me !== te && (_e !== 0 || Le !== 0)) && (Ee = this.mul(Ee, oe[Ce]), me = 0, Ce = 0);\n                      }\n                      ie = 26;\n                    }\n                    return Ee;\n                  }, G2.prototype.convertTo = function(N2) {\n                    var H = N2.umod(this.m);\n                    return H === N2 ? H.clone() : H;\n                  }, G2.prototype.convertFrom = function(N2) {\n                    var H = N2.clone();\n                    return H.red = null, H;\n                  }, f4.mont = function(N2) {\n                    return new Z(N2);\n                  };\n                  function Z(j3) {\n                    G2.call(this, j3), this.shift = this.m.bitLength(), this.shift % 26 !== 0 && (this.shift += 26 - this.shift % 26), this.r = new f4(1).iushln(this.shift), this.r2 = this.imod(this.r.sqr()), this.rinv = this.r._invmp(this.m), this.minv = this.rinv.mul(this.r).isubn(1).div(this.m), this.minv = this.minv.umod(this.r), this.minv = this.r.sub(this.minv);\n                  }\n                  c5(Z, G2), Z.prototype.convertTo = function(N2) {\n                    return this.imod(N2.ushln(this.shift));\n                  }, Z.prototype.convertFrom = function(N2) {\n                    var H = this.imod(N2.mul(this.rinv));\n                    return H.red = null, H;\n                  }, Z.prototype.imul = function(N2, H) {\n                    if (N2.isZero() || H.isZero()) return N2.words[0] = 0, N2.length = 1, N2;\n                    var te = N2.imul(H), oe = te.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), _e = te.isub(oe).iushrn(this.shift), Ee = _e;\n                    return _e.cmp(this.m) >= 0 ? Ee = _e.isub(this.m) : _e.cmpn(0) < 0 && (Ee = _e.iadd(this.m)), Ee._forceRed(this);\n                  }, Z.prototype.mul = function(N2, H) {\n                    if (N2.isZero() || H.isZero()) return new f4(0)._forceRed(this);\n                    var te = N2.mul(H), oe = te.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m), _e = te.isub(oe).iushrn(this.shift), Ee = _e;\n                    return _e.cmp(this.m) >= 0 ? Ee = _e.isub(this.m) : _e.cmpn(0) < 0 && (Ee = _e.iadd(this.m)), Ee._forceRed(this);\n                  }, Z.prototype.invm = function(N2) {\n                    var H = this.imod(N2._invmp(this.m).mul(this.r2));\n                    return H._forceRed(this);\n                  };\n                })(i3, this);\n              }, 6860: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] - l3[0], o4[1] = s3[1] - l3[1], o4[2] = s3[2] - l3[2], o4[3] = s3[3] - l3[3], o4;\n                }\n              }, 6864: function(i3) {\n                i3.exports = a4;\n                function a4() {\n                  var o4 = new Float32Array(16);\n                  return o4[0] = 1, o4[1] = 0, o4[2] = 0, o4[3] = 0, o4[4] = 0, o4[5] = 1, o4[6] = 0, o4[7] = 0, o4[8] = 0, o4[9] = 0, o4[10] = 1, o4[11] = 0, o4[12] = 0, o4[13] = 0, o4[14] = 0, o4[15] = 1, o4;\n                }\n              }, 6867: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = p3;\n                var s3 = o4(1888), l3 = o4(855), u4 = o4(7150);\n                function c5(k4, E3) {\n                  for (var S2 = 0; S2 < k4; ++S2) if (!(E3[S2] <= E3[S2 + k4])) return true;\n                  return false;\n                }\n                function f4(k4, E3, S2, L3) {\n                  for (var x2 = 0, C3 = 0, M4 = 0, g3 = k4.length; M4 < g3; ++M4) {\n                    var P3 = k4[M4];\n                    if (!c5(E3, P3)) {\n                      for (var T3 = 0; T3 < 2 * E3; ++T3) S2[x2++] = P3[T3];\n                      L3[C3++] = M4;\n                    }\n                  }\n                  return C3;\n                }\n                function h3(k4, E3, S2, L3) {\n                  var x2 = k4.length, C3 = E3.length;\n                  if (!(x2 <= 0 || C3 <= 0)) {\n                    var M4 = k4[0].length >>> 1;\n                    if (!(M4 <= 0)) {\n                      var g3, P3 = s3.mallocDouble(2 * M4 * x2), T3 = s3.mallocInt32(x2);\n                      if (x2 = f4(k4, M4, P3, T3), x2 > 0) {\n                        if (M4 === 1 && L3) l3.init(x2), g3 = l3.sweepComplete(M4, S2, 0, x2, P3, T3, 0, x2, P3, T3);\n                        else {\n                          var z3 = s3.mallocDouble(2 * M4 * C3), O3 = s3.mallocInt32(C3);\n                          C3 = f4(E3, M4, z3, O3), C3 > 0 && (l3.init(x2 + C3), M4 === 1 ? g3 = l3.sweepBipartite(M4, S2, 0, x2, P3, T3, 0, C3, z3, O3) : g3 = u4(M4, S2, L3, x2, P3, T3, C3, z3, O3), s3.free(z3), s3.free(O3));\n                        }\n                        s3.free(P3), s3.free(T3);\n                      }\n                      return g3;\n                    }\n                  }\n                }\n                var d3;\n                function v3(k4, E3) {\n                  d3.push([k4, E3]);\n                }\n                function _2(k4) {\n                  return d3 = [], h3(k4, k4, v3, true), d3;\n                }\n                function b(k4, E3) {\n                  return d3 = [], h3(k4, E3, v3, false), d3;\n                }\n                function p3(k4, E3, S2) {\n                  switch (arguments.length) {\n                    case 1:\n                      return _2(k4);\n                    case 2:\n                      return typeof E3 == "function" ? h3(k4, k4, E3, true) : b(k4, E3);\n                    case 3:\n                      return h3(k4, E3, S2, false);\n                    default:\n                      throw new Error("box-intersect: Invalid arguments");\n                  }\n                }\n              }, 6894: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = l3[1], f4 = l3[2], h3 = s3[1] - c5, d3 = s3[2] - f4, v3 = Math.sin(u4), _2 = Math.cos(u4);\n                  return o4[0] = s3[0], o4[1] = c5 + h3 * _2 - d3 * v3, o4[2] = f4 + h3 * v3 + d3 * _2, o4;\n                }\n              }, 7004: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4) {\n                  for (var s3 = o4.length, l3 = o4[o4.length - 1], u4 = s3, c5 = s3 - 2; c5 >= 0; --c5) {\n                    var f4 = l3, h3 = o4[c5];\n                    l3 = f4 + h3;\n                    var d3 = l3 - f4, v3 = h3 - d3;\n                    v3 && (o4[--u4] = l3, l3 = v3);\n                  }\n                  for (var _2 = 0, c5 = u4; c5 < s3; ++c5) {\n                    var f4 = o4[c5], h3 = l3;\n                    l3 = f4 + h3;\n                    var d3 = l3 - f4, v3 = h3 - d3;\n                    v3 && (o4[_2++] = v3);\n                  }\n                  return o4[_2++] = l3, o4.length = _2, o4;\n                }\n              }, 7056: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0] - o4[0], u4 = s3[1] - o4[1], c5 = s3[2] - o4[2];\n                  return Math.sqrt(l3 * l3 + u4 * u4 + c5 * c5);\n                }\n              }, 7089: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = Math.sin(l3), c5 = Math.cos(l3), f4 = s3[0], h3 = s3[1], d3 = s3[2], v3 = s3[3], _2 = s3[4], b = s3[5], p3 = s3[6], k4 = s3[7];\n                  return s3 !== o4 && (o4[8] = s3[8], o4[9] = s3[9], o4[10] = s3[10], o4[11] = s3[11], o4[12] = s3[12], o4[13] = s3[13], o4[14] = s3[14], o4[15] = s3[15]), o4[0] = f4 * c5 + _2 * u4, o4[1] = h3 * c5 + b * u4, o4[2] = d3 * c5 + p3 * u4, o4[3] = v3 * c5 + k4 * u4, o4[4] = _2 * c5 - f4 * u4, o4[5] = b * c5 - h3 * u4, o4[6] = p3 * c5 - d3 * u4, o4[7] = k4 * c5 - v3 * u4, o4;\n                }\n              }, 7150: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = j3;\n                var s3 = o4(1888), l3 = o4(8828), u4 = o4(2455), c5 = u4.partial, f4 = u4.full, h3 = o4(855), d3 = o4(3545), v3 = o4(8105), _2 = 128, b = 1 << 22, p3 = 1 << 22, k4 = v3("!(lo>=p0)&&!(p1>=hi)"), E3 = v3("lo===p0"), S2 = v3("lo<p0"), L3 = v3("hi<=p0"), x2 = v3("lo<=p0&&p0<=hi"), C3 = v3("lo<p0&&p0<=hi"), M4 = 6, g3 = 2, P3 = 1024, T3 = s3.mallocInt32(P3), z3 = s3.mallocDouble(P3);\n                function O3(N2, H) {\n                  var te = 8 * l3.log2(H + 1) * (N2 + 1) | 0, oe = l3.nextPow2(M4 * te);\n                  T3.length < oe && (s3.free(T3), T3 = s3.mallocInt32(oe));\n                  var _e = l3.nextPow2(g3 * te);\n                  z3.length < _e && (s3.free(z3), z3 = s3.mallocDouble(_e));\n                }\n                function V2(N2, H, te, oe, _e, Ee, Ce, me, ie) {\n                  var Se = M4 * N2;\n                  T3[Se] = H, T3[Se + 1] = te, T3[Se + 2] = oe, T3[Se + 3] = _e, T3[Se + 4] = Ee, T3[Se + 5] = Ce;\n                  var Le = g3 * N2;\n                  z3[Le] = me, z3[Le + 1] = ie;\n                }\n                function G2(N2, H, te, oe, _e, Ee, Ce, me, ie, Se, Le) {\n                  var Ae = 2 * N2, Fe = ie * Ae, Pe = Se[Fe + H];\n                  e: for (var ge = _e, Re = _e * Ae; ge < Ee; ++ge, Re += Ae) {\n                    var ce = Ce[Re + H], Ze = Ce[Re + H + N2];\n                    if (!(Pe < ce || Ze < Pe) && !(oe && Pe === ce)) {\n                      for (var ut = me[ge], pt = H + 1; pt < N2; ++pt) {\n                        var ce = Ce[Re + pt], Ze = Ce[Re + pt + N2], Zt = Se[Fe + pt], st = Se[Fe + pt + N2];\n                        if (Ze < Zt || st < ce) continue e;\n                      }\n                      var lt;\n                      if (oe ? lt = te(Le, ut) : lt = te(ut, Le), lt !== void 0) return lt;\n                    }\n                  }\n                }\n                function Z(N2, H, te, oe, _e, Ee, Ce, me, ie, Se) {\n                  var Le = 2 * N2, Ae = me * Le, Fe = ie[Ae + H];\n                  e: for (var Pe = oe, ge = oe * Le; Pe < _e; ++Pe, ge += Le) {\n                    var Re = Ce[Pe];\n                    if (Re !== Se) {\n                      var ce = Ee[ge + H], Ze = Ee[ge + H + N2];\n                      if (!(Fe < ce || Ze < Fe)) {\n                        for (var ut = H + 1; ut < N2; ++ut) {\n                          var ce = Ee[ge + ut], Ze = Ee[ge + ut + N2], pt = ie[Ae + ut], Zt = ie[Ae + ut + N2];\n                          if (Ze < pt || Zt < ce) continue e;\n                        }\n                        var st = te(Re, Se);\n                        if (st !== void 0) return st;\n                      }\n                    }\n                  }\n                }\n                function j3(N2, H, te, oe, _e, Ee, Ce, me, ie) {\n                  O3(N2, oe + Ce);\n                  var Se = 0, Le = 2 * N2, Ae;\n                  for (V2(Se++, 0, 0, oe, 0, Ce, te ? 16 : 0, -1 / 0, 1 / 0), te || V2(Se++, 0, 0, Ce, 0, oe, 1, -1 / 0, 1 / 0); Se > 0; ) {\n                    Se -= 1;\n                    var Fe = Se * M4, Pe = T3[Fe], ge = T3[Fe + 1], Re = T3[Fe + 2], ce = T3[Fe + 3], Ze = T3[Fe + 4], ut = T3[Fe + 5], pt = Se * g3, Zt = z3[pt], st = z3[pt + 1], lt = ut & 1, Gt = !!(ut & 16), Nt = _e, Jt = Ee, sr = me, wr = ie;\n                    if (lt && (Nt = me, Jt = ie, sr = _e, wr = Ee), !(ut & 2 && (Re = S2(N2, Pe, ge, Re, Nt, Jt, st), ge >= Re)) && !(ut & 4 && (ge = L3(N2, Pe, ge, Re, Nt, Jt, Zt), ge >= Re))) {\n                      var cr = Re - ge, $e = Ze - ce;\n                      if (Gt) {\n                        if (N2 * cr * (cr + $e) < p3) {\n                          if (Ae = h3.scanComplete(N2, Pe, H, ge, Re, Nt, Jt, ce, Ze, sr, wr), Ae !== void 0) return Ae;\n                          continue;\n                        }\n                      } else if (N2 * Math.min(cr, $e) < _2) {\n                        if (Ae = c5(N2, Pe, H, lt, ge, Re, Nt, Jt, ce, Ze, sr, wr), Ae !== void 0) return Ae;\n                        continue;\n                      } else if (N2 * cr * $e < b) {\n                        if (Ae = h3.scanBipartite(N2, Pe, H, lt, ge, Re, Nt, Jt, ce, Ze, sr, wr), Ae !== void 0) return Ae;\n                        continue;\n                      }\n                      var St = k4(N2, Pe, ge, Re, Nt, Jt, Zt, st);\n                      if (ge < St) if (N2 * (St - ge) < _2) {\n                        if (Ae = f4(N2, Pe + 1, H, ge, St, Nt, Jt, ce, Ze, sr, wr), Ae !== void 0) return Ae;\n                      } else if (Pe === N2 - 2) {\n                        if (lt ? Ae = h3.sweepBipartite(N2, H, ce, Ze, sr, wr, ge, St, Nt, Jt) : Ae = h3.sweepBipartite(N2, H, ge, St, Nt, Jt, ce, Ze, sr, wr), Ae !== void 0) return Ae;\n                      } else V2(Se++, Pe + 1, ge, St, ce, Ze, lt, -1 / 0, 1 / 0), V2(Se++, Pe + 1, ce, Ze, ge, St, lt ^ 1, -1 / 0, 1 / 0);\n                      if (St < Re) {\n                        var Qt = d3(N2, Pe, ce, Ze, sr, wr), Vt = sr[Le * Qt + Pe], _t = E3(N2, Pe, Qt, Ze, sr, wr, Vt);\n                        if (_t < Ze && V2(Se++, Pe, St, Re, _t, Ze, (lt | 4) + (Gt ? 16 : 0), Vt, st), ce < Qt && V2(Se++, Pe, St, Re, ce, Qt, (lt | 2) + (Gt ? 16 : 0), Zt, Vt), Qt + 1 === _t) {\n                          if (Gt ? Ae = Z(N2, Pe, H, St, Re, Nt, Jt, Qt, sr, wr[Qt]) : Ae = G2(N2, Pe, H, lt, St, Re, Nt, Jt, Qt, sr, wr[Qt]), Ae !== void 0) return Ae;\n                        } else if (Qt < _t) {\n                          var It;\n                          if (Gt) {\n                            if (It = x2(N2, Pe, St, Re, Nt, Jt, Vt), St < It) {\n                              var mt = E3(N2, Pe, St, It, Nt, Jt, Vt);\n                              if (Pe === N2 - 2) {\n                                if (St < mt && (Ae = h3.sweepComplete(N2, H, St, mt, Nt, Jt, Qt, _t, sr, wr), Ae !== void 0) || mt < It && (Ae = h3.sweepBipartite(N2, H, mt, It, Nt, Jt, Qt, _t, sr, wr), Ae !== void 0)) return Ae;\n                              } else St < mt && V2(Se++, Pe + 1, St, mt, Qt, _t, 16, -1 / 0, 1 / 0), mt < It && (V2(Se++, Pe + 1, mt, It, Qt, _t, 0, -1 / 0, 1 / 0), V2(Se++, Pe + 1, Qt, _t, mt, It, 1, -1 / 0, 1 / 0));\n                            }\n                          } else lt ? It = C3(N2, Pe, St, Re, Nt, Jt, Vt) : It = x2(N2, Pe, St, Re, Nt, Jt, Vt), St < It && (Pe === N2 - 2 ? lt ? Ae = h3.sweepBipartite(N2, H, Qt, _t, sr, wr, St, It, Nt, Jt) : Ae = h3.sweepBipartite(N2, H, St, It, Nt, Jt, Qt, _t, sr, wr) : (V2(Se++, Pe + 1, St, It, Qt, _t, lt, -1 / 0, 1 / 0), V2(Se++, Pe + 1, Qt, _t, St, It, lt ^ 1, -1 / 0, 1 / 0)));\n                        }\n                      }\n                    }\n                  }\n                }\n              }, 7163: function(i3) {\n                i3.exports = function(s3) {\n                  return s3 != null && (a4(s3) || o4(s3) || !!s3._isBuffer);\n                };\n                function a4(s3) {\n                  return !!s3.constructor && typeof s3.constructor.isBuffer == "function" && s3.constructor.isBuffer(s3);\n                }\n                function o4(s3) {\n                  return typeof s3.readFloatLE == "function" && typeof s3.slice == "function" && a4(s3.slice(0, 0));\n                }\n              }, 7169: function(i3, a4, o4) {\n                "use strict";\n                var s3 = typeof WeakMap == "undefined" ? o4(1538) : WeakMap, l3 = o4(2762), u4 = o4(8116), c5 = new s3();\n                function f4(h3) {\n                  var d3 = c5.get(h3), v3 = d3 && (d3._triangleBuffer.handle || d3._triangleBuffer.buffer);\n                  if (!v3 || !h3.isBuffer(v3)) {\n                    var _2 = l3(h3, new Float32Array([-1, -1, -1, 4, 4, -1]));\n                    d3 = u4(h3, [{ buffer: _2, type: h3.FLOAT, size: 2 }]), d3._triangleBuffer = _2, c5.set(h3, d3);\n                  }\n                  d3.bind(), h3.drawArrays(h3.TRIANGLES, 0, 3), d3.unbind();\n                }\n                i3.exports = f4;\n              }, 7182: function(i3, a4, o4) {\n                var s3 = { identity: o4(7894), translate: o4(7656), multiply: o4(6760), create: o4(6864), scale: o4(2504), fromRotationTranslation: o4(6743) }, l3 = s3.create(), u4 = s3.create();\n                i3.exports = function(f4, h3, d3, v3, _2, b) {\n                  return s3.identity(f4), s3.fromRotationTranslation(f4, b, h3), f4[3] = _2[0], f4[7] = _2[1], f4[11] = _2[2], f4[15] = _2[3], s3.identity(u4), v3[2] !== 0 && (u4[9] = v3[2], s3.multiply(f4, f4, u4)), v3[1] !== 0 && (u4[9] = 0, u4[8] = v3[1], s3.multiply(f4, f4, u4)), v3[0] !== 0 && (u4[8] = 0, u4[4] = v3[0], s3.multiply(f4, f4, u4)), s3.scale(f4, f4, d3), f4;\n                };\n              }, 7201: function(i3, a4, o4) {\n                "use strict";\n                var s3 = 1e-6, l3 = 1e-6, u4 = o4(9405), c5 = o4(2762), f4 = o4(8116), h3 = o4(7766), d3 = o4(8406), v3 = o4(6760), _2 = o4(7608), b = o4(9618), p3 = o4(6729), k4 = o4(7765), E3 = o4(1888), S2 = o4(840), L3 = o4(7626), x2 = S2.meshShader, C3 = S2.wireShader, M4 = S2.pointShader, g3 = S2.pickShader, P3 = S2.pointPickShader, T3 = S2.contourShader, z3 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                function O3(me, ie, Se, Le, Ae, Fe, Pe, ge, Re, ce, Ze, ut, pt, Zt, st, lt, Gt, Nt, Jt, sr, wr, cr, $e, St, Qt, Vt, _t) {\n                  this.gl = me, this.pixelRatio = 1, this.cells = [], this.positions = [], this.intensity = [], this.texture = ie, this.dirty = true, this.triShader = Se, this.lineShader = Le, this.pointShader = Ae, this.pickShader = Fe, this.pointPickShader = Pe, this.contourShader = ge, this.trianglePositions = Re, this.triangleColors = Ze, this.triangleNormals = pt, this.triangleUVs = ut, this.triangleIds = ce, this.triangleVAO = Zt, this.triangleCount = 0, this.lineWidth = 1, this.edgePositions = st, this.edgeColors = Gt, this.edgeUVs = Nt, this.edgeIds = lt, this.edgeVAO = Jt, this.edgeCount = 0, this.pointPositions = sr, this.pointColors = cr, this.pointUVs = $e, this.pointSizes = St, this.pointIds = wr, this.pointVAO = Qt, this.pointCount = 0, this.contourLineWidth = 1, this.contourPositions = Vt, this.contourVAO = _t, this.contourCount = 0, this.contourColor = [0, 0, 0], this.contourEnable = true, this.pickVertex = true, this.pickId = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lightPosition = [1e5, 1e5, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.opacity = 1, this.hasAlpha = false, this.opacityscale = false, this._model = z3, this._view = z3, this._projection = z3, this._resolution = [1, 1];\n                }\n                var V2 = O3.prototype;\n                V2.isOpaque = function() {\n                  return !this.hasAlpha;\n                }, V2.isTransparent = function() {\n                  return this.hasAlpha;\n                }, V2.pickSlots = 1, V2.setPickBase = function(me) {\n                  this.pickId = me;\n                };\n                function G2(me, ie) {\n                  if (!ie || !ie.length) return 1;\n                  for (var Se = 0; Se < ie.length; ++Se) {\n                    if (ie.length < 2) return 1;\n                    if (ie[Se][0] === me) return ie[Se][1];\n                    if (ie[Se][0] > me && Se > 0) {\n                      var Le = (ie[Se][0] - me) / (ie[Se][0] - ie[Se - 1][0]);\n                      return ie[Se][1] * (1 - Le) + Le * ie[Se - 1][1];\n                    }\n                  }\n                  return 1;\n                }\n                function Z(me, ie) {\n                  for (var Se = p3({ colormap: me, nshades: 256, format: "rgba" }), Le = new Uint8Array(256 * 4), Ae = 0; Ae < 256; ++Ae) {\n                    for (var Fe = Se[Ae], Pe = 0; Pe < 3; ++Pe) Le[4 * Ae + Pe] = Fe[Pe];\n                    ie ? Le[4 * Ae + 3] = 255 * G2(Ae / 255, ie) : Le[4 * Ae + 3] = 255 * Fe[3];\n                  }\n                  return b(Le, [256, 256, 4], [4, 0, 1]);\n                }\n                function j3(me) {\n                  for (var ie = me.length, Se = new Array(ie), Le = 0; Le < ie; ++Le) Se[Le] = me[Le][2];\n                  return Se;\n                }\n                V2.highlight = function(me) {\n                  if (!me || !this.contourEnable) {\n                    this.contourCount = 0;\n                    return;\n                  }\n                  for (var ie = k4(this.cells, this.intensity, me.intensity), Se = ie.cells, Le = ie.vertexIds, Ae = ie.vertexWeights, Fe = Se.length, Pe = E3.mallocFloat32(2 * 3 * Fe), ge = 0, Re = 0; Re < Fe; ++Re) for (var ce = Se[Re], Ze = 0; Ze < 2; ++Ze) {\n                    var ut = ce[0];\n                    ce.length === 2 && (ut = ce[Ze]);\n                    for (var pt = Le[ut][0], Zt = Le[ut][1], st = Ae[ut], lt = 1 - st, Gt = this.positions[pt], Nt = this.positions[Zt], Jt = 0; Jt < 3; ++Jt) Pe[ge++] = st * Gt[Jt] + lt * Nt[Jt];\n                  }\n                  this.contourCount = ge / 3 | 0, this.contourPositions.update(Pe.subarray(0, ge)), E3.free(Pe);\n                }, V2.update = function(me) {\n                  me = me || {};\n                  var ie = this.gl;\n                  this.dirty = true, "contourEnable" in me && (this.contourEnable = me.contourEnable), "contourColor" in me && (this.contourColor = me.contourColor), "lineWidth" in me && (this.lineWidth = me.lineWidth), "lightPosition" in me && (this.lightPosition = me.lightPosition), this.hasAlpha = false, "opacity" in me && (this.opacity = me.opacity, this.opacity < 1 && (this.hasAlpha = true)), "opacityscale" in me && (this.opacityscale = me.opacityscale, this.hasAlpha = true), "ambient" in me && (this.ambientLight = me.ambient), "diffuse" in me && (this.diffuseLight = me.diffuse), "specular" in me && (this.specularLight = me.specular), "roughness" in me && (this.roughness = me.roughness), "fresnel" in me && (this.fresnel = me.fresnel), me.texture ? (this.texture.dispose(), this.texture = h3(ie, me.texture)) : me.colormap && (this.texture.shape = [256, 256], this.texture.minFilter = ie.LINEAR_MIPMAP_LINEAR, this.texture.magFilter = ie.LINEAR, this.texture.setPixels(Z(me.colormap, this.opacityscale)), this.texture.generateMipmap());\n                  var Se = me.cells, Le = me.positions;\n                  if (!(!Le || !Se)) {\n                    var Ae = [], Fe = [], Pe = [], ge = [], Re = [], ce = [], Ze = [], ut = [], pt = [], Zt = [], st = [], lt = [], Gt = [], Nt = [];\n                    this.cells = Se, this.positions = Le;\n                    var Jt = me.vertexNormals, sr = me.cellNormals, wr = me.vertexNormalsEpsilon === void 0 ? s3 : me.vertexNormalsEpsilon, cr = me.faceNormalsEpsilon === void 0 ? l3 : me.faceNormalsEpsilon;\n                    me.useFacetNormals && !sr && (sr = d3.faceNormals(Se, Le, cr)), !sr && !Jt && (Jt = d3.vertexNormals(Se, Le, wr));\n                    var $e = me.vertexColors, St = me.cellColors, Qt = me.meshColor || [1, 1, 1, 1], Vt = me.vertexUVs, _t = me.vertexIntensity, It = me.cellUVs, mt = me.cellIntensity, er = 1 / 0, lr = -1 / 0;\n                    if (!Vt && !It) if (_t) if (me.vertexIntensityBounds) er = +me.vertexIntensityBounds[0], lr = +me.vertexIntensityBounds[1];\n                    else for (var Tr = 0; Tr < _t.length; ++Tr) {\n                      var Lr = _t[Tr];\n                      er = Math.min(er, Lr), lr = Math.max(lr, Lr);\n                    }\n                    else if (mt) if (me.cellIntensityBounds) er = +me.cellIntensityBounds[0], lr = +me.cellIntensityBounds[1];\n                    else for (var Tr = 0; Tr < mt.length; ++Tr) {\n                      var Lr = mt[Tr];\n                      er = Math.min(er, Lr), lr = Math.max(lr, Lr);\n                    }\n                    else for (var Tr = 0; Tr < Le.length; ++Tr) {\n                      var Lr = Le[Tr][2];\n                      er = Math.min(er, Lr), lr = Math.max(lr, Lr);\n                    }\n                    _t ? this.intensity = _t : mt ? this.intensity = mt : this.intensity = j3(Le), this.pickVertex = !(mt || St);\n                    var ti = me.pointSizes, Br = me.pointSize || 1;\n                    this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];\n                    for (var Tr = 0; Tr < Le.length; ++Tr) for (var Vr = Le[Tr], dt = 0; dt < 3; ++dt) isNaN(Vr[dt]) || !isFinite(Vr[dt]) || (this.bounds[0][dt] = Math.min(this.bounds[0][dt], Vr[dt]), this.bounds[1][dt] = Math.max(this.bounds[1][dt], Vr[dt]));\n                    var Ge = 0, Je = 0, je = 0;\n                    e: for (var Tr = 0; Tr < Se.length; ++Tr) {\n                      var tt = Se[Tr];\n                      switch (tt.length) {\n                        case 1:\n                          for (var xt = tt[0], Vr = Le[xt], dt = 0; dt < 3; ++dt) if (isNaN(Vr[dt]) || !isFinite(Vr[dt])) continue e;\n                          Zt.push(Vr[0], Vr[1], Vr[2]);\n                          var Ie;\n                          $e ? Ie = $e[xt] : St ? Ie = St[Tr] : Ie = Qt, this.opacityscale && _t ? Fe.push(Ie[0], Ie[1], Ie[2], this.opacity * G2((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? st.push(Ie[0], Ie[1], Ie[2], this.opacity) : (st.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true));\n                          var xe;\n                          Vt ? xe = Vt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[Tr] : mt ? xe = [(mt[Tr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], lt.push(xe[0], xe[1]), ti ? Gt.push(ti[xt]) : Gt.push(Br), Nt.push(Tr), je += 1;\n                          break;\n                        case 2:\n                          for (var dt = 0; dt < 2; ++dt) for (var xt = tt[dt], Vr = Le[xt], ke = 0; ke < 3; ++ke) if (isNaN(Vr[ke]) || !isFinite(Vr[ke])) continue e;\n                          for (var dt = 0; dt < 2; ++dt) {\n                            var xt = tt[dt], Vr = Le[xt];\n                            ce.push(Vr[0], Vr[1], Vr[2]);\n                            var Ie;\n                            $e ? Ie = $e[xt] : St ? Ie = St[Tr] : Ie = Qt, this.opacityscale && _t ? Fe.push(Ie[0], Ie[1], Ie[2], this.opacity * G2((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? Ze.push(Ie[0], Ie[1], Ie[2], this.opacity) : (Ze.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true));\n                            var xe;\n                            Vt ? xe = Vt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[Tr] : mt ? xe = [(mt[Tr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], ut.push(xe[0], xe[1]), pt.push(Tr);\n                          }\n                          Je += 1;\n                          break;\n                        case 3:\n                          for (var dt = 0; dt < 3; ++dt) for (var xt = tt[dt], Vr = Le[xt], ke = 0; ke < 3; ++ke) if (isNaN(Vr[ke]) || !isFinite(Vr[ke])) continue e;\n                          for (var dt = 0; dt < 3; ++dt) {\n                            var xt = tt[2 - dt], Vr = Le[xt];\n                            Ae.push(Vr[0], Vr[1], Vr[2]);\n                            var Ie;\n                            $e ? Ie = $e[xt] : St ? Ie = St[Tr] : Ie = Qt, Ie ? this.opacityscale && _t ? Fe.push(Ie[0], Ie[1], Ie[2], this.opacity * G2((_t[xt] - er) / (lr - er), this.opacityscale)) : Ie.length === 3 ? Fe.push(Ie[0], Ie[1], Ie[2], this.opacity) : (Fe.push(Ie[0], Ie[1], Ie[2], Ie[3] * this.opacity), Ie[3] < 1 && (this.hasAlpha = true)) : Fe.push(0.5, 0.5, 0.5, 1);\n                            var xe;\n                            Vt ? xe = Vt[xt] : _t ? xe = [(_t[xt] - er) / (lr - er), 0] : It ? xe = It[Tr] : mt ? xe = [(mt[Tr] - er) / (lr - er), 0] : xe = [(Vr[2] - er) / (lr - er), 0], ge.push(xe[0], xe[1]);\n                            var vt;\n                            Jt ? vt = Jt[xt] : vt = sr[Tr], Pe.push(vt[0], vt[1], vt[2]), Re.push(Tr);\n                          }\n                          Ge += 1;\n                          break;\n                        default:\n                          break;\n                      }\n                    }\n                    this.pointCount = je, this.edgeCount = Je, this.triangleCount = Ge, this.pointPositions.update(Zt), this.pointColors.update(st), this.pointUVs.update(lt), this.pointSizes.update(Gt), this.pointIds.update(new Uint32Array(Nt)), this.edgePositions.update(ce), this.edgeColors.update(Ze), this.edgeUVs.update(ut), this.edgeIds.update(new Uint32Array(pt)), this.trianglePositions.update(Ae), this.triangleColors.update(Fe), this.triangleUVs.update(ge), this.triangleNormals.update(Pe), this.triangleIds.update(new Uint32Array(Re));\n                  }\n                }, V2.drawTransparent = V2.draw = function(me) {\n                  me = me || {};\n                  for (var ie = this.gl, Se = me.model || z3, Le = me.view || z3, Ae = me.projection || z3, Fe = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], Pe = 0; Pe < 3; ++Pe) Fe[0][Pe] = Math.max(Fe[0][Pe], this.clipBounds[0][Pe]), Fe[1][Pe] = Math.min(Fe[1][Pe], this.clipBounds[1][Pe]);\n                  var ge = { model: Se, view: Le, projection: Ae, inverseModel: z3.slice(), clipBounds: Fe, kambient: this.ambientLight, kdiffuse: this.diffuseLight, kspecular: this.specularLight, roughness: this.roughness, fresnel: this.fresnel, eyePosition: [0, 0, 0], lightPosition: [0, 0, 0], contourColor: this.contourColor, texture: 0 };\n                  ge.inverseModel = _2(ge.inverseModel, ge.model), ie.disable(ie.CULL_FACE), this.texture.bind(0);\n                  var Re = new Array(16);\n                  v3(Re, ge.view, ge.model), v3(Re, ge.projection, Re), _2(Re, Re);\n                  for (var Pe = 0; Pe < 3; ++Pe) ge.eyePosition[Pe] = Re[12 + Pe] / Re[15];\n                  for (var ce = Re[15], Pe = 0; Pe < 3; ++Pe) ce += this.lightPosition[Pe] * Re[4 * Pe + 3];\n                  for (var Pe = 0; Pe < 3; ++Pe) {\n                    for (var Ze = Re[12 + Pe], ut = 0; ut < 3; ++ut) Ze += Re[4 * ut + Pe] * this.lightPosition[ut];\n                    ge.lightPosition[Pe] = Ze / ce;\n                  }\n                  if (this.triangleCount > 0) {\n                    var pt = this.triShader;\n                    pt.bind(), pt.uniforms = ge, this.triangleVAO.bind(), ie.drawArrays(ie.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind();\n                  }\n                  if (this.edgeCount > 0 && this.lineWidth > 0) {\n                    var pt = this.lineShader;\n                    pt.bind(), pt.uniforms = ge, this.edgeVAO.bind(), ie.lineWidth(this.lineWidth * this.pixelRatio), ie.drawArrays(ie.LINES, 0, this.edgeCount * 2), this.edgeVAO.unbind();\n                  }\n                  if (this.pointCount > 0) {\n                    var pt = this.pointShader;\n                    pt.bind(), pt.uniforms = ge, this.pointVAO.bind(), ie.drawArrays(ie.POINTS, 0, this.pointCount), this.pointVAO.unbind();\n                  }\n                  if (this.contourEnable && this.contourCount > 0 && this.contourLineWidth > 0) {\n                    var pt = this.contourShader;\n                    pt.bind(), pt.uniforms = ge, this.contourVAO.bind(), ie.drawArrays(ie.LINES, 0, this.contourCount), this.contourVAO.unbind();\n                  }\n                }, V2.drawPick = function(me) {\n                  me = me || {};\n                  for (var ie = this.gl, Se = me.model || z3, Le = me.view || z3, Ae = me.projection || z3, Fe = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], Pe = 0; Pe < 3; ++Pe) Fe[0][Pe] = Math.max(Fe[0][Pe], this.clipBounds[0][Pe]), Fe[1][Pe] = Math.min(Fe[1][Pe], this.clipBounds[1][Pe]);\n                  this._model = [].slice.call(Se), this._view = [].slice.call(Le), this._projection = [].slice.call(Ae), this._resolution = [ie.drawingBufferWidth, ie.drawingBufferHeight];\n                  var ge = { model: Se, view: Le, projection: Ae, clipBounds: Fe, pickId: this.pickId / 255 }, Re = this.pickShader;\n                  if (Re.bind(), Re.uniforms = ge, this.triangleCount > 0 && (this.triangleVAO.bind(), ie.drawArrays(ie.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind()), this.edgeCount > 0 && (this.edgeVAO.bind(), ie.lineWidth(this.lineWidth * this.pixelRatio), ie.drawArrays(ie.LINES, 0, this.edgeCount * 2), this.edgeVAO.unbind()), this.pointCount > 0) {\n                    var Re = this.pointPickShader;\n                    Re.bind(), Re.uniforms = ge, this.pointVAO.bind(), ie.drawArrays(ie.POINTS, 0, this.pointCount), this.pointVAO.unbind();\n                  }\n                }, V2.pick = function(me) {\n                  if (!me || me.id !== this.pickId) return null;\n                  for (var ie = me.value[0] + 256 * me.value[1] + 65536 * me.value[2], Se = this.cells[ie], Le = this.positions, Ae = new Array(Se.length), Fe = 0; Fe < Se.length; ++Fe) Ae[Fe] = Le[Se[Fe]];\n                  var Pe = me.coord[0], ge = me.coord[1];\n                  if (!this.pickVertex) {\n                    var Re = this.positions[Se[0]], ce = this.positions[Se[1]], Ze = this.positions[Se[2]], ut = [(Re[0] + ce[0] + Ze[0]) / 3, (Re[1] + ce[1] + Ze[1]) / 3, (Re[2] + ce[2] + Ze[2]) / 3];\n                    return { _cellCenter: true, position: [Pe, ge], index: ie, cell: Se, cellId: ie, intensity: this.intensity[ie], dataCoordinate: ut };\n                  }\n                  var pt = L3(Ae, [Pe * this.pixelRatio, this._resolution[1] - ge * this.pixelRatio], this._model, this._view, this._projection, this._resolution);\n                  if (!pt) return null;\n                  for (var Zt = pt[2], st = 0, Fe = 0; Fe < Se.length; ++Fe) st += Zt[Fe] * this.intensity[Se[Fe]];\n                  return { position: pt[1], index: Se[pt[0]], cell: Se, cellId: ie, intensity: st, dataCoordinate: this.positions[Se[pt[0]]] };\n                }, V2.dispose = function() {\n                  this.texture.dispose(), this.triShader.dispose(), this.lineShader.dispose(), this.pointShader.dispose(), this.pickShader.dispose(), this.pointPickShader.dispose(), this.triangleVAO.dispose(), this.trianglePositions.dispose(), this.triangleColors.dispose(), this.triangleUVs.dispose(), this.triangleNormals.dispose(), this.triangleIds.dispose(), this.edgeVAO.dispose(), this.edgePositions.dispose(), this.edgeColors.dispose(), this.edgeUVs.dispose(), this.edgeIds.dispose(), this.pointVAO.dispose(), this.pointPositions.dispose(), this.pointColors.dispose(), this.pointUVs.dispose(), this.pointSizes.dispose(), this.pointIds.dispose(), this.contourVAO.dispose(), this.contourPositions.dispose(), this.contourShader.dispose();\n                };\n                function N2(me) {\n                  var ie = u4(me, x2.vertex, x2.fragment);\n                  return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie.attributes.normal.location = 4, ie;\n                }\n                function H(me) {\n                  var ie = u4(me, C3.vertex, C3.fragment);\n                  return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie;\n                }\n                function te(me) {\n                  var ie = u4(me, M4.vertex, M4.fragment);\n                  return ie.attributes.position.location = 0, ie.attributes.color.location = 2, ie.attributes.uv.location = 3, ie.attributes.pointSize.location = 4, ie;\n                }\n                function oe(me) {\n                  var ie = u4(me, g3.vertex, g3.fragment);\n                  return ie.attributes.position.location = 0, ie.attributes.id.location = 1, ie;\n                }\n                function _e(me) {\n                  var ie = u4(me, P3.vertex, P3.fragment);\n                  return ie.attributes.position.location = 0, ie.attributes.id.location = 1, ie.attributes.pointSize.location = 4, ie;\n                }\n                function Ee(me) {\n                  var ie = u4(me, T3.vertex, T3.fragment);\n                  return ie.attributes.position.location = 0, ie;\n                }\n                function Ce(me, ie) {\n                  arguments.length === 1 && (ie = me, me = ie.gl);\n                  var Se = me.getExtension("OES_standard_derivatives") || me.getExtension("MOZ_OES_standard_derivatives") || me.getExtension("WEBKIT_OES_standard_derivatives");\n                  if (!Se) throw new Error("derivatives not supported");\n                  var Le = N2(me), Ae = H(me), Fe = te(me), Pe = oe(me), ge = _e(me), Re = Ee(me), ce = h3(me, b(new Uint8Array([255, 255, 255, 255]), [1, 1, 4]));\n                  ce.generateMipmap(), ce.minFilter = me.LINEAR_MIPMAP_LINEAR, ce.magFilter = me.LINEAR;\n                  var Ze = c5(me), ut = c5(me), pt = c5(me), Zt = c5(me), st = c5(me), lt = f4(me, [{ buffer: Ze, type: me.FLOAT, size: 3 }, { buffer: st, type: me.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: ut, type: me.FLOAT, size: 4 }, { buffer: pt, type: me.FLOAT, size: 2 }, { buffer: Zt, type: me.FLOAT, size: 3 }]), Gt = c5(me), Nt = c5(me), Jt = c5(me), sr = c5(me), wr = f4(me, [{ buffer: Gt, type: me.FLOAT, size: 3 }, { buffer: sr, type: me.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: Nt, type: me.FLOAT, size: 4 }, { buffer: Jt, type: me.FLOAT, size: 2 }]), cr = c5(me), $e = c5(me), St = c5(me), Qt = c5(me), Vt = c5(me), _t = f4(me, [{ buffer: cr, type: me.FLOAT, size: 3 }, { buffer: Vt, type: me.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: $e, type: me.FLOAT, size: 4 }, { buffer: St, type: me.FLOAT, size: 2 }, { buffer: Qt, type: me.FLOAT, size: 1 }]), It = c5(me), mt = f4(me, [{ buffer: It, type: me.FLOAT, size: 3 }]), er = new O3(me, ce, Le, Ae, Fe, Pe, ge, Re, Ze, st, ut, pt, Zt, lt, Gt, sr, Nt, Jt, wr, cr, Vt, $e, St, Qt, _t, It, mt);\n                  return er.update(ie), er;\n                }\n                i3.exports = Ce;\n              }, 7261: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = E3;\n                var s3 = o4(9215), l3 = o4(7608), u4 = o4(6079), c5 = o4(5911), f4 = o4(3536), h3 = o4(244);\n                function d3(S2, L3, x2) {\n                  return Math.sqrt(Math.pow(S2, 2) + Math.pow(L3, 2) + Math.pow(x2, 2));\n                }\n                function v3(S2) {\n                  return Math.min(1, Math.max(-1, S2));\n                }\n                function _2(S2) {\n                  var L3 = Math.abs(S2[0]), x2 = Math.abs(S2[1]), C3 = Math.abs(S2[2]), M4 = [0, 0, 0];\n                  L3 > Math.max(x2, C3) ? M4[2] = 1 : x2 > Math.max(L3, C3) ? M4[0] = 1 : M4[1] = 1;\n                  for (var g3 = 0, P3 = 0, T3 = 0; T3 < 3; ++T3) g3 += S2[T3] * S2[T3], P3 += M4[T3] * S2[T3];\n                  for (var T3 = 0; T3 < 3; ++T3) M4[T3] -= P3 / g3 * S2[T3];\n                  return f4(M4, M4), M4;\n                }\n                function b(S2, L3, x2, C3, M4, g3, P3, T3) {\n                  this.center = s3(x2), this.up = s3(C3), this.right = s3(M4), this.radius = s3([g3]), this.angle = s3([P3, T3]), this.angle.bounds = [[-1 / 0, -Math.PI / 2], [1 / 0, Math.PI / 2]], this.setDistanceLimits(S2, L3), this.computedCenter = this.center.curve(0), this.computedUp = this.up.curve(0), this.computedRight = this.right.curve(0), this.computedRadius = this.radius.curve(0), this.computedAngle = this.angle.curve(0), this.computedToward = [0, 0, 0], this.computedEye = [0, 0, 0], this.computedMatrix = new Array(16);\n                  for (var z3 = 0; z3 < 16; ++z3) this.computedMatrix[z3] = 0.5;\n                  this.recalcMatrix(0);\n                }\n                var p3 = b.prototype;\n                p3.setDistanceLimits = function(S2, L3) {\n                  S2 > 0 ? S2 = Math.log(S2) : S2 = -1 / 0, L3 > 0 ? L3 = Math.log(L3) : L3 = 1 / 0, L3 = Math.max(L3, S2), this.radius.bounds[0][0] = S2, this.radius.bounds[1][0] = L3;\n                }, p3.getDistanceLimits = function(S2) {\n                  var L3 = this.radius.bounds[0];\n                  return S2 ? (S2[0] = Math.exp(L3[0][0]), S2[1] = Math.exp(L3[1][0]), S2) : [Math.exp(L3[0][0]), Math.exp(L3[1][0])];\n                }, p3.recalcMatrix = function(S2) {\n                  this.center.curve(S2), this.up.curve(S2), this.right.curve(S2), this.radius.curve(S2), this.angle.curve(S2);\n                  for (var L3 = this.computedUp, x2 = this.computedRight, C3 = 0, M4 = 0, g3 = 0; g3 < 3; ++g3) M4 += L3[g3] * x2[g3], C3 += L3[g3] * L3[g3];\n                  for (var P3 = Math.sqrt(C3), T3 = 0, g3 = 0; g3 < 3; ++g3) x2[g3] -= L3[g3] * M4 / C3, T3 += x2[g3] * x2[g3], L3[g3] /= P3;\n                  for (var z3 = Math.sqrt(T3), g3 = 0; g3 < 3; ++g3) x2[g3] /= z3;\n                  var O3 = this.computedToward;\n                  c5(O3, L3, x2), f4(O3, O3);\n                  for (var V2 = Math.exp(this.computedRadius[0]), G2 = this.computedAngle[0], Z = this.computedAngle[1], j3 = Math.cos(G2), N2 = Math.sin(G2), H = Math.cos(Z), te = Math.sin(Z), oe = this.computedCenter, _e = j3 * H, Ee = N2 * H, Ce = te, me = -j3 * te, ie = -N2 * te, Se = H, Le = this.computedEye, Ae = this.computedMatrix, g3 = 0; g3 < 3; ++g3) {\n                    var Fe = _e * x2[g3] + Ee * O3[g3] + Ce * L3[g3];\n                    Ae[4 * g3 + 1] = me * x2[g3] + ie * O3[g3] + Se * L3[g3], Ae[4 * g3 + 2] = Fe, Ae[4 * g3 + 3] = 0;\n                  }\n                  var Pe = Ae[1], ge = Ae[5], Re = Ae[9], ce = Ae[2], Ze = Ae[6], ut = Ae[10], pt = ge * ut - Re * Ze, Zt = Re * ce - Pe * ut, st = Pe * Ze - ge * ce, lt = d3(pt, Zt, st);\n                  pt /= lt, Zt /= lt, st /= lt, Ae[0] = pt, Ae[4] = Zt, Ae[8] = st;\n                  for (var g3 = 0; g3 < 3; ++g3) Le[g3] = oe[g3] + Ae[2 + 4 * g3] * V2;\n                  for (var g3 = 0; g3 < 3; ++g3) {\n                    for (var T3 = 0, Gt = 0; Gt < 3; ++Gt) T3 += Ae[g3 + 4 * Gt] * Le[Gt];\n                    Ae[12 + g3] = -T3;\n                  }\n                  Ae[15] = 1;\n                }, p3.getMatrix = function(S2, L3) {\n                  this.recalcMatrix(S2);\n                  var x2 = this.computedMatrix;\n                  if (L3) {\n                    for (var C3 = 0; C3 < 16; ++C3) L3[C3] = x2[C3];\n                    return L3;\n                  }\n                  return x2;\n                };\n                var k4 = [0, 0, 0];\n                p3.rotate = function(S2, L3, x2, C3) {\n                  if (this.angle.move(S2, L3, x2), C3) {\n                    this.recalcMatrix(S2);\n                    var M4 = this.computedMatrix;\n                    k4[0] = M4[2], k4[1] = M4[6], k4[2] = M4[10];\n                    for (var g3 = this.computedUp, P3 = this.computedRight, T3 = this.computedToward, z3 = 0; z3 < 3; ++z3) M4[4 * z3] = g3[z3], M4[4 * z3 + 1] = P3[z3], M4[4 * z3 + 2] = T3[z3];\n                    u4(M4, M4, C3, k4);\n                    for (var z3 = 0; z3 < 3; ++z3) g3[z3] = M4[4 * z3], P3[z3] = M4[4 * z3 + 1];\n                    this.up.set(S2, g3[0], g3[1], g3[2]), this.right.set(S2, P3[0], P3[1], P3[2]);\n                  }\n                }, p3.pan = function(S2, L3, x2, C3) {\n                  L3 = L3 || 0, x2 = x2 || 0, C3 = C3 || 0, this.recalcMatrix(S2);\n                  var M4 = this.computedMatrix, g3 = Math.exp(this.computedRadius[0]), P3 = M4[1], T3 = M4[5], z3 = M4[9], O3 = d3(P3, T3, z3);\n                  P3 /= O3, T3 /= O3, z3 /= O3;\n                  var V2 = M4[0], G2 = M4[4], Z = M4[8], j3 = V2 * P3 + G2 * T3 + Z * z3;\n                  V2 -= P3 * j3, G2 -= T3 * j3, Z -= z3 * j3;\n                  var N2 = d3(V2, G2, Z);\n                  V2 /= N2, G2 /= N2, Z /= N2;\n                  var H = V2 * L3 + P3 * x2, te = G2 * L3 + T3 * x2, oe = Z * L3 + z3 * x2;\n                  this.center.move(S2, H, te, oe);\n                  var _e = Math.exp(this.computedRadius[0]);\n                  _e = Math.max(1e-4, _e + C3), this.radius.set(S2, Math.log(_e));\n                }, p3.translate = function(S2, L3, x2, C3) {\n                  this.center.move(S2, L3 || 0, x2 || 0, C3 || 0);\n                }, p3.setMatrix = function(S2, L3, x2, C3) {\n                  var M4 = 1;\n                  typeof x2 == "number" && (M4 = x2 | 0), (M4 < 0 || M4 > 3) && (M4 = 1);\n                  var g3 = (M4 + 2) % 3, P3 = (M4 + 1) % 3;\n                  L3 || (this.recalcMatrix(S2), L3 = this.computedMatrix);\n                  var T3 = L3[M4], z3 = L3[M4 + 4], O3 = L3[M4 + 8];\n                  if (C3) {\n                    var G2 = Math.abs(T3), Z = Math.abs(z3), j3 = Math.abs(O3), N2 = Math.max(G2, Z, j3);\n                    G2 === N2 ? (T3 = T3 < 0 ? -1 : 1, z3 = O3 = 0) : j3 === N2 ? (O3 = O3 < 0 ? -1 : 1, T3 = z3 = 0) : (z3 = z3 < 0 ? -1 : 1, T3 = O3 = 0);\n                  } else {\n                    var V2 = d3(T3, z3, O3);\n                    T3 /= V2, z3 /= V2, O3 /= V2;\n                  }\n                  var H = L3[g3], te = L3[g3 + 4], oe = L3[g3 + 8], _e = H * T3 + te * z3 + oe * O3;\n                  H -= T3 * _e, te -= z3 * _e, oe -= O3 * _e;\n                  var Ee = d3(H, te, oe);\n                  H /= Ee, te /= Ee, oe /= Ee;\n                  var Ce = z3 * oe - O3 * te, me = O3 * H - T3 * oe, ie = T3 * te - z3 * H, Se = d3(Ce, me, ie);\n                  Ce /= Se, me /= Se, ie /= Se, this.center.jump(S2, cr, $e, St), this.radius.idle(S2), this.up.jump(S2, T3, z3, O3), this.right.jump(S2, H, te, oe);\n                  var Le, Ae;\n                  if (M4 === 2) {\n                    var Fe = L3[1], Pe = L3[5], ge = L3[9], Re = Fe * H + Pe * te + ge * oe, ce = Fe * Ce + Pe * me + ge * ie;\n                    Zt < 0 ? Le = -Math.PI / 2 : Le = Math.PI / 2, Ae = Math.atan2(ce, Re);\n                  } else {\n                    var Ze = L3[2], ut = L3[6], pt = L3[10], Zt = Ze * T3 + ut * z3 + pt * O3, st = Ze * H + ut * te + pt * oe, lt = Ze * Ce + ut * me + pt * ie;\n                    Le = Math.asin(v3(Zt)), Ae = Math.atan2(lt, st);\n                  }\n                  this.angle.jump(S2, Ae, Le), this.recalcMatrix(S2);\n                  var Gt = L3[2], Nt = L3[6], Jt = L3[10], sr = this.computedMatrix;\n                  l3(sr, L3);\n                  var wr = sr[15], cr = sr[12] / wr, $e = sr[13] / wr, St = sr[14] / wr, Qt = Math.exp(this.computedRadius[0]);\n                  this.center.jump(S2, cr - Gt * Qt, $e - Nt * Qt, St - Jt * Qt);\n                }, p3.lastT = function() {\n                  return Math.max(this.center.lastT(), this.up.lastT(), this.right.lastT(), this.radius.lastT(), this.angle.lastT());\n                }, p3.idle = function(S2) {\n                  this.center.idle(S2), this.up.idle(S2), this.right.idle(S2), this.radius.idle(S2), this.angle.idle(S2);\n                }, p3.flush = function(S2) {\n                  this.center.flush(S2), this.up.flush(S2), this.right.flush(S2), this.radius.flush(S2), this.angle.flush(S2);\n                }, p3.setDistance = function(S2, L3) {\n                  L3 > 0 && this.radius.set(S2, Math.log(L3));\n                }, p3.lookAt = function(S2, L3, x2, C3) {\n                  this.recalcMatrix(S2), L3 = L3 || this.computedEye, x2 = x2 || this.computedCenter, C3 = C3 || this.computedUp;\n                  var M4 = C3[0], g3 = C3[1], P3 = C3[2], T3 = d3(M4, g3, P3);\n                  if (!(T3 < 1e-6)) {\n                    M4 /= T3, g3 /= T3, P3 /= T3;\n                    var z3 = L3[0] - x2[0], O3 = L3[1] - x2[1], V2 = L3[2] - x2[2], G2 = d3(z3, O3, V2);\n                    if (!(G2 < 1e-6)) {\n                      z3 /= G2, O3 /= G2, V2 /= G2;\n                      var Z = this.computedRight, j3 = Z[0], N2 = Z[1], H = Z[2], te = M4 * j3 + g3 * N2 + P3 * H;\n                      j3 -= te * M4, N2 -= te * g3, H -= te * P3;\n                      var oe = d3(j3, N2, H);\n                      if (!(oe < 0.01 && (j3 = g3 * V2 - P3 * O3, N2 = P3 * z3 - M4 * V2, H = M4 * O3 - g3 * z3, oe = d3(j3, N2, H), oe < 1e-6))) {\n                        j3 /= oe, N2 /= oe, H /= oe, this.up.set(S2, M4, g3, P3), this.right.set(S2, j3, N2, H), this.center.set(S2, x2[0], x2[1], x2[2]), this.radius.set(S2, Math.log(G2));\n                        var _e = g3 * H - P3 * N2, Ee = P3 * j3 - M4 * H, Ce = M4 * N2 - g3 * j3, me = d3(_e, Ee, Ce);\n                        _e /= me, Ee /= me, Ce /= me;\n                        var ie = M4 * z3 + g3 * O3 + P3 * V2, Se = j3 * z3 + N2 * O3 + H * V2, Le = _e * z3 + Ee * O3 + Ce * V2, Ae = Math.asin(v3(ie)), Fe = Math.atan2(Le, Se), Pe = this.angle._state, ge = Pe[Pe.length - 1], Re = Pe[Pe.length - 2];\n                        ge = ge % (2 * Math.PI);\n                        var ce = Math.abs(ge + 2 * Math.PI - Fe), Ze = Math.abs(ge - Fe), ut = Math.abs(ge - 2 * Math.PI - Fe);\n                        ce < Ze && (ge += 2 * Math.PI), ut < Ze && (ge -= 2 * Math.PI), this.angle.jump(this.angle.lastT(), ge, Re), this.angle.set(S2, Fe, Ae);\n                      }\n                    }\n                  }\n                };\n                function E3(S2) {\n                  S2 = S2 || {};\n                  var L3 = S2.center || [0, 0, 0], x2 = S2.up || [0, 1, 0], C3 = S2.right || _2(x2), M4 = S2.radius || 1, g3 = S2.theta || 0, P3 = S2.phi || 0;\n                  if (L3 = [].slice.call(L3, 0, 3), x2 = [].slice.call(x2, 0, 3), f4(x2, x2), C3 = [].slice.call(C3, 0, 3), f4(C3, C3), "eye" in S2) {\n                    var T3 = S2.eye, z3 = [T3[0] - L3[0], T3[1] - L3[1], T3[2] - L3[2]];\n                    c5(C3, z3, x2), d3(C3[0], C3[1], C3[2]) < 1e-6 ? C3 = _2(x2) : f4(C3, C3), M4 = d3(z3[0], z3[1], z3[2]);\n                    var O3 = h3(x2, z3) / M4, V2 = h3(C3, z3) / M4;\n                    P3 = Math.acos(O3), g3 = Math.acos(V2);\n                  }\n                  return M4 = Math.log(M4), new b(S2.zoomMin, S2.zoomMax, L3, x2, C3, M4, g3, P3);\n                }\n              }, 7319: function(i3, a4, o4) {\n                var s3 = o4(3236), l3 = o4(9405), u4 = s3([`precision highp float;\n#define GLSLIFY 1\n\nattribute vec3 position, nextPosition;\nattribute float arcLength, lineWidth;\nattribute vec4 color;\n\nuniform vec2 screenShape;\nuniform float pixelRatio;\nuniform mat4 model, view, projection;\n\nvarying vec4 fragColor;\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\n\nvec4 project(vec3 p) {\n  return projection * (view * (model * vec4(p, 1.0)));\n}\n\nvoid main() {\n  vec4 startPoint = project(position);\n  vec4 endPoint   = project(nextPosition);\n\n  vec2 A = startPoint.xy / startPoint.w;\n  vec2 B =   endPoint.xy /   endPoint.w;\n\n  float clipAngle = atan(\n    (B.y - A.y) * screenShape.y,\n    (B.x - A.x) * screenShape.x\n  );\n\n  vec2 offset = 0.5 * pixelRatio * lineWidth * vec2(\n    sin(clipAngle),\n    -cos(clipAngle)\n  ) / screenShape;\n\n  gl_Position = vec4(startPoint.xy + startPoint.w * offset, startPoint.zw);\n\n  worldPosition = position;\n  pixelArcLength = arcLength;\n  fragColor = color;\n}\n`]), c5 = s3([`precision highp float;\n#define GLSLIFY 1\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform vec3      clipBounds[2];\nuniform sampler2D dashTexture;\nuniform float     dashScale;\nuniform float     opacity;\n\nvarying vec3    worldPosition;\nvarying float   pixelArcLength;\nvarying vec4    fragColor;\n\nvoid main() {\n  if (\n    outOfRange(clipBounds[0], clipBounds[1], worldPosition) ||\n    fragColor.a * opacity == 0.\n  ) discard;\n\n  float dashWeight = texture2D(dashTexture, vec2(dashScale * pixelArcLength, 0)).r;\n  if(dashWeight < 0.5) {\n    discard;\n  }\n  gl_FragColor = fragColor * opacity;\n}\n`]), f4 = s3([`precision highp float;\n#define GLSLIFY 1\n\n#define FLOAT_MAX  1.70141184e38\n#define FLOAT_MIN  1.17549435e-38\n\n// https://github.com/mikolalysenko/glsl-read-float/blob/master/index.glsl\nvec4 packFloat(float v) {\n  float av = abs(v);\n\n  //Handle special cases\n  if(av < FLOAT_MIN) {\n    return vec4(0.0, 0.0, 0.0, 0.0);\n  } else if(v > FLOAT_MAX) {\n    return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;\n  } else if(v < -FLOAT_MAX) {\n    return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;\n  }\n\n  vec4 c = vec4(0,0,0,0);\n\n  //Compute exponent and mantissa\n  float e = floor(log2(av));\n  float m = av * pow(2.0, -e) - 1.0;\n\n  //Unpack mantissa\n  c[1] = floor(128.0 * m);\n  m -= c[1] / 128.0;\n  c[2] = floor(32768.0 * m);\n  m -= c[2] / 32768.0;\n  c[3] = floor(8388608.0 * m);\n\n  //Unpack exponent\n  float ebias = e + 127.0;\n  c[0] = floor(ebias / 2.0);\n  ebias -= c[0] * 2.0;\n  c[1] += floor(ebias) * 128.0;\n\n  //Unpack sign bit\n  c[0] += 128.0 * step(0.0, -v);\n\n  //Scale back to range\n  return c / 255.0;\n}\n\nbool outOfRange(float a, float b, float p) {\n  return ((p > max(a, b)) || \n          (p < min(a, b)));\n}\n\nbool outOfRange(vec2 a, vec2 b, vec2 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y));\n}\n\nbool outOfRange(vec3 a, vec3 b, vec3 p) {\n  return (outOfRange(a.x, b.x, p.x) ||\n          outOfRange(a.y, b.y, p.y) ||\n          outOfRange(a.z, b.z, p.z));\n}\n\nbool outOfRange(vec4 a, vec4 b, vec4 p) {\n  return outOfRange(a.xyz, b.xyz, p.xyz);\n}\n\nuniform float pickId;\nuniform vec3 clipBounds[2];\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n  if (outOfRange(clipBounds[0], clipBounds[1], worldPosition)) discard;\n\n  gl_FragColor = vec4(pickId/255.0, packFloat(pixelArcLength).xyz);\n}`]), h3 = [{ name: "position", type: "vec3" }, { name: "nextPosition", type: "vec3" }, { name: "arcLength", type: "float" }, { name: "lineWidth", type: "float" }, { name: "color", type: "vec4" }];\n                a4.createShader = function(d3) {\n                  return l3(d3, u4, c5, null, h3);\n                }, a4.createPickShader = function(d3) {\n                  return l3(d3, u4, f4, null, h3);\n                };\n              }, 7352: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5721), l3 = o4(4750), u4 = o4(2690);\n                i3.exports = c5;\n                function c5(f4) {\n                  var h3 = f4.length;\n                  if (h3 === 0) return [];\n                  if (h3 === 1) return [[0]];\n                  var d3 = f4[0].length;\n                  return d3 === 0 ? [] : d3 === 1 ? s3(f4) : d3 === 2 ? l3(f4) : u4(f4, d3);\n                }\n              }, 7399: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0], u4 = s3[1], c5 = s3[2], f4 = s3[3], h3 = l3 + l3, d3 = u4 + u4, v3 = c5 + c5, _2 = l3 * h3, b = u4 * h3, p3 = u4 * d3, k4 = c5 * h3, E3 = c5 * d3, S2 = c5 * v3, L3 = f4 * h3, x2 = f4 * d3, C3 = f4 * v3;\n                  return o4[0] = 1 - p3 - S2, o4[1] = b + C3, o4[2] = k4 - x2, o4[3] = 0, o4[4] = b - C3, o4[5] = 1 - _2 - S2, o4[6] = E3 + L3, o4[7] = 0, o4[8] = k4 + x2, o4[9] = E3 - L3, o4[10] = 1 - _2 - p3, o4[11] = 0, o4[12] = 0, o4[13] = 0, o4[14] = 0, o4[15] = 1, o4;\n                }\n              }, 7417: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = Math.max(s3[0], l3[0]), o4[1] = Math.max(s3[1], l3[1]), o4[2] = Math.max(s3[2], l3[2]), o4;\n                }\n              }, 7442: function(i3, a4, o4) {\n                var s3 = o4(6658), l3 = o4(7182), u4 = o4(2652), c5 = o4(9921), f4 = o4(8648), h3 = b(), d3 = b(), v3 = b();\n                i3.exports = _2;\n                function _2(E3, S2, L3, x2) {\n                  if (c5(S2) === 0 || c5(L3) === 0) return false;\n                  var C3 = u4(S2, h3.translate, h3.scale, h3.skew, h3.perspective, h3.quaternion), M4 = u4(L3, d3.translate, d3.scale, d3.skew, d3.perspective, d3.quaternion);\n                  return !C3 || !M4 ? false : (s3(v3.translate, h3.translate, d3.translate, x2), s3(v3.skew, h3.skew, d3.skew, x2), s3(v3.scale, h3.scale, d3.scale, x2), s3(v3.perspective, h3.perspective, d3.perspective, x2), f4(v3.quaternion, h3.quaternion, d3.quaternion, x2), l3(E3, v3.translate, v3.scale, v3.skew, v3.perspective, v3.quaternion), true);\n                }\n                function b() {\n                  return { translate: p3(), scale: p3(1), skew: p3(), perspective: k4(), quaternion: k4() };\n                }\n                function p3(E3) {\n                  return [E3 || 0, E3 || 0, E3 || 0];\n                }\n                function k4() {\n                  return [0, 0, 0, 1];\n                }\n              }, 7507: function(i3, a4) {\n                "use strict";\n                a4.byteLength = d3, a4.toByteArray = _2, a4.fromByteArray = k4;\n                for (var o4 = [], s3 = [], l3 = typeof Uint8Array != "undefined" ? Uint8Array : Array, u4 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", c5 = 0, f4 = u4.length; c5 < f4; ++c5) o4[c5] = u4[c5], s3[u4.charCodeAt(c5)] = c5;\n                s3[45] = 62, s3[95] = 63;\n                function h3(E3) {\n                  var S2 = E3.length;\n                  if (S2 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");\n                  var L3 = E3.indexOf("=");\n                  L3 === -1 && (L3 = S2);\n                  var x2 = L3 === S2 ? 0 : 4 - L3 % 4;\n                  return [L3, x2];\n                }\n                function d3(E3) {\n                  var S2 = h3(E3), L3 = S2[0], x2 = S2[1];\n                  return (L3 + x2) * 3 / 4 - x2;\n                }\n                function v3(E3, S2, L3) {\n                  return (S2 + L3) * 3 / 4 - L3;\n                }\n                function _2(E3) {\n                  var S2, L3 = h3(E3), x2 = L3[0], C3 = L3[1], M4 = new l3(v3(E3, x2, C3)), g3 = 0, P3 = C3 > 0 ? x2 - 4 : x2, T3;\n                  for (T3 = 0; T3 < P3; T3 += 4) S2 = s3[E3.charCodeAt(T3)] << 18 | s3[E3.charCodeAt(T3 + 1)] << 12 | s3[E3.charCodeAt(T3 + 2)] << 6 | s3[E3.charCodeAt(T3 + 3)], M4[g3++] = S2 >> 16 & 255, M4[g3++] = S2 >> 8 & 255, M4[g3++] = S2 & 255;\n                  return C3 === 2 && (S2 = s3[E3.charCodeAt(T3)] << 2 | s3[E3.charCodeAt(T3 + 1)] >> 4, M4[g3++] = S2 & 255), C3 === 1 && (S2 = s3[E3.charCodeAt(T3)] << 10 | s3[E3.charCodeAt(T3 + 1)] << 4 | s3[E3.charCodeAt(T3 + 2)] >> 2, M4[g3++] = S2 >> 8 & 255, M4[g3++] = S2 & 255), M4;\n                }\n                function b(E3) {\n                  return o4[E3 >> 18 & 63] + o4[E3 >> 12 & 63] + o4[E3 >> 6 & 63] + o4[E3 & 63];\n                }\n                function p3(E3, S2, L3) {\n                  for (var x2, C3 = [], M4 = S2; M4 < L3; M4 += 3) x2 = (E3[M4] << 16 & 16711680) + (E3[M4 + 1] << 8 & 65280) + (E3[M4 + 2] & 255), C3.push(b(x2));\n                  return C3.join("");\n                }\n                function k4(E3) {\n                  for (var S2, L3 = E3.length, x2 = L3 % 3, C3 = [], M4 = 16383, g3 = 0, P3 = L3 - x2; g3 < P3; g3 += M4) C3.push(p3(E3, g3, g3 + M4 > P3 ? P3 : g3 + M4));\n                  return x2 === 1 ? (S2 = E3[L3 - 1], C3.push(o4[S2 >> 2] + o4[S2 << 4 & 63] + "==")) : x2 === 2 && (S2 = (E3[L3 - 2] << 8) + E3[L3 - 1], C3.push(o4[S2 >> 10] + o4[S2 >> 4 & 63] + o4[S2 << 2 & 63] + "=")), C3.join("");\n                }\n              }, 7518: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1433);\n                function l3(f4, h3, d3, v3, _2, b) {\n                  this.location = f4, this.dimension = h3, this.a = d3, this.b = v3, this.c = _2, this.d = b;\n                }\n                l3.prototype.bind = function(f4) {\n                  switch (this.dimension) {\n                    case 1:\n                      f4.vertexAttrib1f(this.location, this.a);\n                      break;\n                    case 2:\n                      f4.vertexAttrib2f(this.location, this.a, this.b);\n                      break;\n                    case 3:\n                      f4.vertexAttrib3f(this.location, this.a, this.b, this.c);\n                      break;\n                    case 4:\n                      f4.vertexAttrib4f(this.location, this.a, this.b, this.c, this.d);\n                      break;\n                  }\n                };\n                function u4(f4, h3, d3) {\n                  this.gl = f4, this._ext = h3, this.handle = d3, this._attribs = [], this._useElements = false, this._elementsType = f4.UNSIGNED_SHORT;\n                }\n                u4.prototype.bind = function() {\n                  this._ext.bindVertexArrayOES(this.handle);\n                  for (var f4 = 0; f4 < this._attribs.length; ++f4) this._attribs[f4].bind(this.gl);\n                }, u4.prototype.unbind = function() {\n                  this._ext.bindVertexArrayOES(null);\n                }, u4.prototype.dispose = function() {\n                  this._ext.deleteVertexArrayOES(this.handle);\n                }, u4.prototype.update = function(f4, h3, d3) {\n                  if (this.bind(), s3(this.gl, h3, f4), this.unbind(), this._attribs.length = 0, f4) for (var v3 = 0; v3 < f4.length; ++v3) {\n                    var _2 = f4[v3];\n                    typeof _2 == "number" ? this._attribs.push(new l3(v3, 1, _2)) : Array.isArray(_2) && this._attribs.push(new l3(v3, _2.length, _2[0], _2[1], _2[2], _2[3]));\n                  }\n                  this._useElements = !!h3, this._elementsType = d3 || this.gl.UNSIGNED_SHORT;\n                }, u4.prototype.draw = function(f4, h3, d3) {\n                  d3 = d3 || 0;\n                  var v3 = this.gl;\n                  this._useElements ? v3.drawElements(f4, h3, this._elementsType, d3) : v3.drawArrays(f4, d3, h3);\n                };\n                function c5(f4, h3) {\n                  return new u4(f4, h3, h3.createVertexArrayOES());\n                }\n                i3.exports = c5;\n              }, 7520: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(9507);\n                function l3() {\n                  var u4 = false;\n                  try {\n                    var c5 = Object.defineProperty({}, "passive", { get: function() {\n                      u4 = true;\n                    } });\n                    window.addEventListener("test", null, c5), window.removeEventListener("test", null, c5);\n                  } catch (f4) {\n                    u4 = false;\n                  }\n                  return u4;\n                }\n                i3.exports = s3 && l3();\n              }, 7536: function(i3) {\n                i3.exports = a4;\n                function a4() {\n                  var o4 = new Float32Array(4);\n                  return o4[0] = 0, o4[1] = 0, o4[2] = 0, o4[3] = 0, o4;\n                }\n              }, 7608: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0], u4 = s3[1], c5 = s3[2], f4 = s3[3], h3 = s3[4], d3 = s3[5], v3 = s3[6], _2 = s3[7], b = s3[8], p3 = s3[9], k4 = s3[10], E3 = s3[11], S2 = s3[12], L3 = s3[13], x2 = s3[14], C3 = s3[15], M4 = l3 * d3 - u4 * h3, g3 = l3 * v3 - c5 * h3, P3 = l3 * _2 - f4 * h3, T3 = u4 * v3 - c5 * d3, z3 = u4 * _2 - f4 * d3, O3 = c5 * _2 - f4 * v3, V2 = b * L3 - p3 * S2, G2 = b * x2 - k4 * S2, Z = b * C3 - E3 * S2, j3 = p3 * x2 - k4 * L3, N2 = p3 * C3 - E3 * L3, H = k4 * C3 - E3 * x2, te = M4 * H - g3 * N2 + P3 * j3 + T3 * Z - z3 * G2 + O3 * V2;\n                  return te ? (te = 1 / te, o4[0] = (d3 * H - v3 * N2 + _2 * j3) * te, o4[1] = (c5 * N2 - u4 * H - f4 * j3) * te, o4[2] = (L3 * O3 - x2 * z3 + C3 * T3) * te, o4[3] = (k4 * z3 - p3 * O3 - E3 * T3) * te, o4[4] = (v3 * Z - h3 * H - _2 * G2) * te, o4[5] = (l3 * H - c5 * Z + f4 * G2) * te, o4[6] = (x2 * P3 - S2 * O3 - C3 * g3) * te, o4[7] = (b * O3 - k4 * P3 + E3 * g3) * te, o4[8] = (h3 * N2 - d3 * Z + _2 * V2) * te, o4[9] = (u4 * Z - l3 * N2 - f4 * V2) * te, o4[10] = (S2 * z3 - L3 * P3 + C3 * M4) * te, o4[11] = (p3 * P3 - b * z3 - E3 * M4) * te, o4[12] = (d3 * G2 - h3 * j3 - v3 * V2) * te, o4[13] = (l3 * j3 - u4 * G2 + c5 * V2) * te, o4[14] = (L3 * g3 - S2 * T3 - x2 * M4) * te, o4[15] = (b * T3 - p3 * g3 + k4 * M4) * te, o4) : null;\n                }\n              }, 7626: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2642), l3 = o4(9346);\n                i3.exports = d3;\n                function u4(v3, _2) {\n                  for (var b = [0, 0, 0, 0], p3 = 0; p3 < 4; ++p3) for (var k4 = 0; k4 < 4; ++k4) b[k4] += v3[4 * p3 + k4] * _2[p3];\n                  return b;\n                }\n                function c5(v3, _2, b, p3, k4) {\n                  for (var E3 = u4(p3, u4(b, u4(_2, [v3[0], v3[1], v3[2], 1]))), S2 = 0; S2 < 3; ++S2) E3[S2] /= E3[3];\n                  return [0.5 * k4[0] * (1 + E3[0]), 0.5 * k4[1] * (1 - E3[1])];\n                }\n                function f4(v3, _2) {\n                  if (v3.length === 2) {\n                    for (var b = 0, p3 = 0, k4 = 0; k4 < 2; ++k4) b += Math.pow(_2[k4] - v3[0][k4], 2), p3 += Math.pow(_2[k4] - v3[1][k4], 2);\n                    return b = Math.sqrt(b), p3 = Math.sqrt(p3), b + p3 < 1e-6 ? [1, 0] : [p3 / (b + p3), b / (p3 + b)];\n                  } else if (v3.length === 3) {\n                    var E3 = [0, 0];\n                    return l3(v3[0], v3[1], v3[2], _2, E3), s3(v3, E3);\n                  }\n                  return [];\n                }\n                function h3(v3, _2) {\n                  for (var b = [0, 0, 0], p3 = 0; p3 < v3.length; ++p3) for (var k4 = v3[p3], E3 = _2[p3], S2 = 0; S2 < 3; ++S2) b[S2] += E3 * k4[S2];\n                  return b;\n                }\n                function d3(v3, _2, b, p3, k4, E3) {\n                  if (v3.length === 1) return [0, v3[0].slice()];\n                  for (var S2 = new Array(v3.length), L3 = 0; L3 < v3.length; ++L3) S2[L3] = c5(v3[L3], b, p3, k4, E3);\n                  for (var x2 = 0, C3 = 1 / 0, L3 = 0; L3 < S2.length; ++L3) {\n                    for (var M4 = 0, g3 = 0; g3 < 2; ++g3) M4 += Math.pow(S2[L3][g3] - _2[g3], 2);\n                    M4 < C3 && (C3 = M4, x2 = L3);\n                  }\n                  for (var P3 = f4(S2, _2), T3 = 0, L3 = 0; L3 < 3; ++L3) {\n                    if (P3[L3] < -1e-3 || P3[L3] > 1.0001) return null;\n                    T3 += P3[L3];\n                  }\n                  return Math.abs(T3 - 1) > 1e-3 ? null : [x2, h3(v3, P3), P3];\n                }\n              }, 7636: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  s3 = s3 || 1;\n                  var l3 = Math.random() * 2 * Math.PI, u4 = Math.random() * 2 - 1, c5 = Math.sqrt(1 - u4 * u4) * s3;\n                  return o4[0] = Math.cos(l3) * c5, o4[1] = Math.sin(l3) * c5, o4[2] = u4 * s3, o4;\n                }\n              }, 7640: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(1888);\n                function l3(_2) {\n                  switch (_2) {\n                    case "uint32":\n                      return [s3.mallocUint32, s3.freeUint32];\n                    default:\n                      return null;\n                  }\n                }\n                var u4 = { "uint32,1,0": function(_2, b) {\n                  return function(k4, E3, S2, L3, x2, C3, M4, g3, P3, T3, z3) {\n                    var O3, V2, G2, Z = k4 * x2 + L3, j3, N2 = _2(g3), H, te, oe, _e;\n                    for (O3 = k4 + 1; O3 <= E3; ++O3) {\n                      for (V2 = O3, Z += x2, G2 = Z, H = 0, te = Z, j3 = 0; j3 < g3; ++j3) N2[H++] = S2[te], te += P3;\n                      e: for (; V2-- > k4; ) {\n                        H = 0, te = G2 - x2;\n                        t: for (j3 = 0; j3 < g3; ++j3) {\n                          if (oe = S2[te], _e = N2[H], oe < _e) break e;\n                          if (oe > _e) break t;\n                          te += T3, H += z3;\n                        }\n                        for (H = G2, te = G2 - x2, j3 = 0; j3 < g3; ++j3) S2[H] = S2[te], H += P3, te += P3;\n                        G2 -= x2;\n                      }\n                      for (H = G2, te = 0, j3 = 0; j3 < g3; ++j3) S2[H] = N2[te++], H += P3;\n                    }\n                    b(N2);\n                  };\n                } };\n                function c5(_2, b) {\n                  var p3 = l3(b), k4 = [b, _2].join(","), E3 = u4[k4];\n                  return p3 ? E3(p3[0], p3[1]) : E3();\n                }\n                var f4 = { "uint32,1,0": function(_2, b, p3) {\n                  return function k4(E3, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3) {\n                    var V2 = (S2 - E3 + 1) / 6 | 0, G2 = E3 + V2, Z = S2 - V2, j3 = E3 + S2 >> 1, N2 = j3 - V2, H = j3 + V2, te = G2, oe = N2, _e = j3, Ee = H, Ce = Z, me = E3 + 1, ie = S2 - 1, Se = true, Le, Ae, Fe, Pe, ge, Re, ce, Ze, ut, pt = 0, Zt = 0, st = 0, lt, Gt, Nt, Jt, sr, wr, cr, $e, St, Qt, Vt, _t, It, mt, er, lr, Tr = P3, Lr = b(Tr), ti = b(Tr);\n                    Gt = C3 * te, Nt = C3 * oe, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = te, te = oe, oe = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * Ee, Nt = C3 * Ce, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = Ee, Ee = Ce, Ce = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * te, Nt = C3 * _e, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = te, te = _e, _e = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * oe, Nt = C3 * _e, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = oe, oe = _e, _e = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * te, Nt = C3 * Ee, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = te, te = Ee, Ee = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * _e, Nt = C3 * Ee, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = _e, _e = Ee, Ee = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * oe, Nt = C3 * Ce, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = oe, oe = Ce, Ce = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * oe, Nt = C3 * _e, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = oe, oe = _e, _e = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    Gt = C3 * Ee, Nt = C3 * Ce, lr = x2;\n                    e: for (lt = 0; lt < P3; ++lt) {\n                      if (ce = Gt + lr, Ze = Nt + lr, st = L3[ce] - L3[Ze], st > 0) {\n                        Ae = Ee, Ee = Ce, Ce = Ae;\n                        break e;\n                      }\n                      if (st < 0) break e;\n                      lr += z3;\n                    }\n                    for (Gt = C3 * te, Nt = C3 * oe, Jt = C3 * _e, sr = C3 * Ee, wr = C3 * Ce, cr = C3 * G2, $e = C3 * j3, St = C3 * Z, er = 0, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, ut = Jt + lr, Qt = sr + lr, Vt = wr + lr, _t = cr + lr, It = $e + lr, mt = St + lr, Lr[er] = L3[Ze], ti[er] = L3[Qt], Se = Se && Lr[er] === ti[er], Fe = L3[ce], Pe = L3[ut], ge = L3[Vt], L3[_t] = Fe, L3[It] = Pe, L3[mt] = ge, ++er, lr += T3;\n                    for (Gt = C3 * N2, Nt = C3 * E3, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, L3[ce] = L3[Ze], lr += T3;\n                    for (Gt = C3 * H, Nt = C3 * S2, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, L3[ce] = L3[Ze], lr += T3;\n                    if (Se) for (Re = me; Re <= ie; ++Re) {\n                      ce = x2 + Re * C3, er = 0;\n                      e: for (lt = 0; lt < P3; ++lt) {\n                        if (st = L3[ce] - Lr[er], st !== 0) break e;\n                        er += O3, ce += z3;\n                      }\n                      if (st !== 0) if (st < 0) {\n                        if (Re !== me) for (Gt = C3 * Re, Nt = C3 * me, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                        ++me;\n                      } else for (; ; ) {\n                        ce = x2 + ie * C3, er = 0;\n                        e: for (lt = 0; lt < P3; ++lt) {\n                          if (st = L3[ce] - Lr[er], st !== 0) break e;\n                          er += O3, ce += z3;\n                        }\n                        if (st > 0) ie--;\n                        else if (st < 0) {\n                          for (Gt = C3 * Re, Nt = C3 * me, Jt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, ut = Jt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = L3[ut], L3[ut] = Le, lr += T3;\n                          ++me, --ie;\n                          break;\n                        } else {\n                          for (Gt = C3 * Re, Nt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                          --ie;\n                          break;\n                        }\n                      }\n                    }\n                    else for (Re = me; Re <= ie; ++Re) {\n                      ce = x2 + Re * C3, er = 0;\n                      e: for (lt = 0; lt < P3; ++lt) {\n                        if (pt = L3[ce] - Lr[er], pt !== 0) break e;\n                        er += O3, ce += z3;\n                      }\n                      if (pt < 0) {\n                        if (Re !== me) for (Gt = C3 * Re, Nt = C3 * me, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                        ++me;\n                      } else {\n                        ce = x2 + Re * C3, er = 0;\n                        e: for (lt = 0; lt < P3; ++lt) {\n                          if (Zt = L3[ce] - ti[er], Zt !== 0) break e;\n                          er += O3, ce += z3;\n                        }\n                        if (Zt > 0) for (; ; ) {\n                          ce = x2 + ie * C3, er = 0;\n                          e: for (lt = 0; lt < P3; ++lt) {\n                            if (st = L3[ce] - ti[er], st !== 0) break e;\n                            er += O3, ce += z3;\n                          }\n                          if (st > 0) {\n                            if (--ie < Re) break;\n                            continue;\n                          } else {\n                            ce = x2 + ie * C3, er = 0;\n                            e: for (lt = 0; lt < P3; ++lt) {\n                              if (st = L3[ce] - Lr[er], st !== 0) break e;\n                              er += O3, ce += z3;\n                            }\n                            if (st < 0) {\n                              for (Gt = C3 * Re, Nt = C3 * me, Jt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, ut = Jt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = L3[ut], L3[ut] = Le, lr += T3;\n                              ++me, --ie;\n                            } else {\n                              for (Gt = C3 * Re, Nt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                              --ie;\n                            }\n                            break;\n                          }\n                        }\n                      }\n                    }\n                    for (Gt = C3 * E3, Nt = C3 * (me - 1), er = 0, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, L3[ce] = L3[Ze], L3[Ze] = Lr[er], ++er, lr += T3;\n                    for (Gt = C3 * S2, Nt = C3 * (ie + 1), er = 0, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, L3[ce] = L3[Ze], L3[Ze] = ti[er], ++er, lr += T3;\n                    if (me - 2 - E3 <= 32 ? _2(E3, me - 2, L3, x2, C3, M4, g3, P3, T3, z3, O3) : k4(E3, me - 2, L3, x2, C3, M4, g3, P3, T3, z3, O3), S2 - (ie + 2) <= 32 ? _2(ie + 2, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3) : k4(ie + 2, S2, L3, x2, C3, M4, g3, P3, T3, z3, O3), Se) {\n                      p3(Lr), p3(ti);\n                      return;\n                    }\n                    if (me < G2 && ie > Z) {\n                      e: for (; ; ) {\n                        for (ce = x2 + me * C3, er = 0, lr = x2, lt = 0; lt < P3; ++lt) {\n                          if (L3[ce] !== Lr[er]) break e;\n                          ++er, ce += T3;\n                        }\n                        ++me;\n                      }\n                      e: for (; ; ) {\n                        for (ce = x2 + ie * C3, er = 0, lr = x2, lt = 0; lt < P3; ++lt) {\n                          if (L3[ce] !== ti[er]) break e;\n                          ++er, ce += T3;\n                        }\n                        --ie;\n                      }\n                      for (Re = me; Re <= ie; ++Re) {\n                        ce = x2 + Re * C3, er = 0;\n                        e: for (lt = 0; lt < P3; ++lt) {\n                          if (pt = L3[ce] - Lr[er], pt !== 0) break e;\n                          er += O3, ce += z3;\n                        }\n                        if (pt === 0) {\n                          if (Re !== me) for (Gt = C3 * Re, Nt = C3 * me, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                          ++me;\n                        } else {\n                          ce = x2 + Re * C3, er = 0;\n                          e: for (lt = 0; lt < P3; ++lt) {\n                            if (Zt = L3[ce] - ti[er], Zt !== 0) break e;\n                            er += O3, ce += z3;\n                          }\n                          if (Zt === 0) for (; ; ) {\n                            ce = x2 + ie * C3, er = 0;\n                            e: for (lt = 0; lt < P3; ++lt) {\n                              if (st = L3[ce] - ti[er], st !== 0) break e;\n                              er += O3, ce += z3;\n                            }\n                            if (st === 0) {\n                              if (--ie < Re) break;\n                              continue;\n                            } else {\n                              ce = x2 + ie * C3, er = 0;\n                              e: for (lt = 0; lt < P3; ++lt) {\n                                if (st = L3[ce] - Lr[er], st !== 0) break e;\n                                er += O3, ce += z3;\n                              }\n                              if (st < 0) {\n                                for (Gt = C3 * Re, Nt = C3 * me, Jt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, ut = Jt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = L3[ut], L3[ut] = Le, lr += T3;\n                                ++me, --ie;\n                              } else {\n                                for (Gt = C3 * Re, Nt = C3 * ie, lr = x2, lt = 0; lt < P3; ++lt) ce = Gt + lr, Ze = Nt + lr, Le = L3[ce], L3[ce] = L3[Ze], L3[Ze] = Le, lr += T3;\n                                --ie;\n                              }\n                              break;\n                            }\n                          }\n                        }\n                      }\n                    }\n                    p3(Lr), p3(ti), ie - me <= 32 ? _2(me, ie, L3, x2, C3, M4, g3, P3, T3, z3, O3) : k4(me, ie, L3, x2, C3, M4, g3, P3, T3, z3, O3);\n                  };\n                } };\n                function h3(_2, b, p3) {\n                  var k4 = l3(b), E3 = [b, _2].join(","), S2 = f4[E3];\n                  return _2.length > 1 && k4 ? S2(p3, k4[0], k4[1]) : S2(p3);\n                }\n                var d3 = { "uint32,1,0": function(_2, b) {\n                  return function(p3) {\n                    var k4 = p3.data, E3 = p3.offset | 0, S2 = p3.shape, L3 = p3.stride, x2 = L3[0] | 0, C3 = S2[0] | 0, M4 = L3[1] | 0, g3 = S2[1] | 0, P3 = M4, T3 = M4, z3 = 1;\n                    C3 <= 32 ? _2(0, C3 - 1, k4, E3, x2, M4, C3, g3, P3, T3, z3) : b(0, C3 - 1, k4, E3, x2, M4, C3, g3, P3, T3, z3);\n                  };\n                } };\n                function v3(_2, b) {\n                  var p3 = [b, _2].join(","), k4 = d3[p3], E3 = c5(_2, b), S2 = h3(_2, b, E3);\n                  return k4(E3, S2);\n                }\n                i3.exports = v3;\n              }, 7642: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(8954), l3 = o4(1682);\n                i3.exports = h3;\n                function u4(d3, v3) {\n                  this.point = d3, this.index = v3;\n                }\n                function c5(d3, v3) {\n                  for (var _2 = d3.point, b = v3.point, p3 = _2.length, k4 = 0; k4 < p3; ++k4) {\n                    var E3 = b[k4] - _2[k4];\n                    if (E3) return E3;\n                  }\n                  return 0;\n                }\n                function f4(d3, v3, _2) {\n                  if (d3 === 1) return _2 ? [[-1, 0]] : [];\n                  var b = v3.map(function(L3, x2) {\n                    return [L3[0], x2];\n                  });\n                  b.sort(function(L3, x2) {\n                    return L3[0] - x2[0];\n                  });\n                  for (var p3 = new Array(d3 - 1), k4 = 1; k4 < d3; ++k4) {\n                    var E3 = b[k4 - 1], S2 = b[k4];\n                    p3[k4 - 1] = [E3[1], S2[1]];\n                  }\n                  return _2 && p3.push([-1, p3[0][1]], [p3[d3 - 1][1], -1]), p3;\n                }\n                function h3(d3, v3) {\n                  var _2 = d3.length;\n                  if (_2 === 0) return [];\n                  var b = d3[0].length;\n                  if (b < 1) return [];\n                  if (b === 1) return f4(_2, d3, v3);\n                  for (var p3 = new Array(_2), k4 = 1, E3 = 0; E3 < _2; ++E3) {\n                    for (var S2 = d3[E3], L3 = new Array(b + 1), x2 = 0, C3 = 0; C3 < b; ++C3) {\n                      var M4 = S2[C3];\n                      L3[C3] = M4, x2 += M4 * M4;\n                    }\n                    L3[b] = x2, p3[E3] = new u4(L3, E3), k4 = Math.max(x2, k4);\n                  }\n                  l3(p3, c5), _2 = p3.length;\n                  for (var g3 = new Array(_2 + b + 1), P3 = new Array(_2 + b + 1), T3 = (b + 1) * (b + 1) * k4, z3 = new Array(b + 1), E3 = 0; E3 <= b; ++E3) z3[E3] = 0;\n                  z3[b] = T3, g3[0] = z3.slice(), P3[0] = -1;\n                  for (var E3 = 0; E3 <= b; ++E3) {\n                    var L3 = z3.slice();\n                    L3[E3] = 1, g3[E3 + 1] = L3, P3[E3 + 1] = -1;\n                  }\n                  for (var E3 = 0; E3 < _2; ++E3) {\n                    var O3 = p3[E3];\n                    g3[E3 + b + 1] = O3.point, P3[E3 + b + 1] = O3.index;\n                  }\n                  var V2 = s3(g3, false);\n                  if (v3 ? V2 = V2.filter(function(G2) {\n                    for (var Z = 0, j3 = 0; j3 <= b; ++j3) {\n                      var N2 = P3[G2[j3]];\n                      if (N2 < 0 && ++Z >= 2) return false;\n                      G2[j3] = N2;\n                    }\n                    return true;\n                  }) : V2 = V2.filter(function(G2) {\n                    for (var Z = 0; Z <= b; ++Z) {\n                      var j3 = P3[G2[Z]];\n                      if (j3 < 0) return false;\n                      G2[Z] = j3;\n                    }\n                    return true;\n                  }), b & 1) for (var E3 = 0; E3 < V2.length; ++E3) {\n                    var O3 = V2[E3], L3 = O3[0];\n                    O3[0] = O3[1], O3[1] = L3;\n                  }\n                  return V2;\n                }\n              }, 7656: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = l3[0], c5 = l3[1], f4 = l3[2], h3, d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3;\n                  return s3 === o4 ? (o4[12] = s3[0] * u4 + s3[4] * c5 + s3[8] * f4 + s3[12], o4[13] = s3[1] * u4 + s3[5] * c5 + s3[9] * f4 + s3[13], o4[14] = s3[2] * u4 + s3[6] * c5 + s3[10] * f4 + s3[14], o4[15] = s3[3] * u4 + s3[7] * c5 + s3[11] * f4 + s3[15]) : (h3 = s3[0], d3 = s3[1], v3 = s3[2], _2 = s3[3], b = s3[4], p3 = s3[5], k4 = s3[6], E3 = s3[7], S2 = s3[8], L3 = s3[9], x2 = s3[10], C3 = s3[11], o4[0] = h3, o4[1] = d3, o4[2] = v3, o4[3] = _2, o4[4] = b, o4[5] = p3, o4[6] = k4, o4[7] = E3, o4[8] = S2, o4[9] = L3, o4[10] = x2, o4[11] = C3, o4[12] = h3 * u4 + b * c5 + S2 * f4 + s3[12], o4[13] = d3 * u4 + p3 * c5 + L3 * f4 + s3[13], o4[14] = v3 * u4 + k4 * c5 + x2 * f4 + s3[14], o4[15] = _2 * u4 + E3 * c5 + C3 * f4 + s3[15]), o4;\n                }\n              }, 7718: function(i3, a4, o4) {\n                i3.exports = O3, i3.exports.processPixels = z3;\n                var s3 = o4(3711), l3 = o4(9618), u4 = o4(5878), c5 = o4(332), f4 = o4(2538), h3 = o4(2095), d3 = "b", v3 = "b|", _2 = "i", b = "i|", p3 = "sup", k4 = "+", E3 = "+1", S2 = "sub", L3 = "-", x2 = "-1";\n                function C3(V2, G2, Z, j3) {\n                  for (var N2 = "<" + V2 + ">", H = "</" + V2 + ">", te = N2.length, oe = H.length, _e = G2[0] === k4 || G2[0] === L3, Ee = 0, Ce = -oe; Ee > -1 && (Ee = Z.indexOf(N2, Ee), !(Ee === -1 || (Ce = Z.indexOf(H, Ee + te), Ce === -1) || Ce <= Ee)); ) {\n                    for (var me = Ee; me < Ce + oe; ++me) if (me < Ee + te || me >= Ce) j3[me] = null, Z = Z.substr(0, me) + " " + Z.substr(me + 1);\n                    else if (j3[me] !== null) {\n                      var ie = j3[me].indexOf(G2[0]);\n                      ie === -1 ? j3[me] += G2 : _e && (j3[me] = j3[me].substr(0, ie + 1) + (1 + parseInt(j3[me][ie + 1])) + j3[me].substr(ie + 2));\n                    }\n                    var Se = Ee + te, Le = Z.substr(Se, Ce - Se), Ae = Le.indexOf(N2);\n                    Ae !== -1 ? Ee = Ae : Ee = Ce + oe;\n                  }\n                  return j3;\n                }\n                function M4(V2, G2, Z) {\n                  for (var j3 = G2.textAlign || "start", N2 = G2.textBaseline || "alphabetic", H = [1 << 30, 1 << 30], te = [0, 0], oe = V2.length, _e = 0; _e < oe; ++_e) for (var Ee = V2[_e], Ce = 0; Ce < 2; ++Ce) H[Ce] = Math.min(H[Ce], Ee[Ce]) | 0, te[Ce] = Math.max(te[Ce], Ee[Ce]) | 0;\n                  var me = 0;\n                  switch (j3) {\n                    case "center":\n                      me = -0.5 * (H[0] + te[0]);\n                      break;\n                    case "right":\n                    case "end":\n                      me = -te[0];\n                      break;\n                    case "left":\n                    case "start":\n                      me = -H[0];\n                      break;\n                    default:\n                      throw new Error("vectorize-text: Unrecognized textAlign: \'" + j3 + "\'");\n                  }\n                  var ie = 0;\n                  switch (N2) {\n                    case "hanging":\n                    case "top":\n                      ie = -H[1];\n                      break;\n                    case "middle":\n                      ie = -0.5 * (H[1] + te[1]);\n                      break;\n                    case "alphabetic":\n                    case "ideographic":\n                      ie = -3 * Z;\n                      break;\n                    case "bottom":\n                      ie = -te[1];\n                      break;\n                    default:\n                      throw new Error("vectorize-text: Unrecoginized textBaseline: \'" + N2 + "\'");\n                  }\n                  var Se = 1 / Z;\n                  return "lineHeight" in G2 ? Se *= +G2.lineHeight : "width" in G2 ? Se = G2.width / (te[0] - H[0]) : "height" in G2 && (Se = G2.height / (te[1] - H[1])), V2.map(function(Le) {\n                    return [Se * (Le[0] + me), Se * (Le[1] + ie)];\n                  });\n                }\n                function g3(V2, G2, Z, j3, N2, H) {\n                  Z = Z.replace(/\\n/g, ""), H.breaklines === true ? Z = Z.replace(/\\<br\\>/g, `\n`) : Z = Z.replace(/\\<br\\>/g, " ");\n                  var te = "", oe = [];\n                  for (ge = 0; ge < Z.length; ++ge) oe[ge] = te;\n                  H.bolds === true && (oe = C3(d3, v3, Z, oe)), H.italics === true && (oe = C3(_2, b, Z, oe)), H.superscripts === true && (oe = C3(p3, E3, Z, oe)), H.subscripts === true && (oe = C3(S2, x2, Z, oe));\n                  var _e = [], Ee = "";\n                  for (ge = 0; ge < Z.length; ++ge) oe[ge] !== null && (Ee += Z[ge], _e.push(oe[ge]));\n                  var Ce = Ee.split(`\n`), me = Ce.length, ie = Math.round(N2 * j3), Se = j3, Le = j3 * 2, Ae = 0, Fe = me * ie + Le;\n                  V2.height < Fe && (V2.height = Fe), G2.fillStyle = "#000", G2.fillRect(0, 0, V2.width, V2.height), G2.fillStyle = "#fff";\n                  var Pe, ge, Re, ce, Ze, ut = 0, pt = "";\n                  function Zt() {\n                    if (pt !== "") {\n                      var $e = G2.measureText(pt).width;\n                      G2.fillText(pt, Se + Re, Le + ce), Re += $e;\n                    }\n                  }\n                  function st() {\n                    return "" + Math.round(Ze) + "px ";\n                  }\n                  function lt($e, St) {\n                    var Qt = "" + G2.font;\n                    if (H.subscripts === true) {\n                      var Vt = $e.indexOf(L3), _t = St.indexOf(L3), It = Vt > -1 ? parseInt($e[1 + Vt]) : 0, mt = _t > -1 ? parseInt(St[1 + _t]) : 0;\n                      It !== mt && (Qt = Qt.replace(st(), "?px "), Ze *= Math.pow(0.75, mt - It), Qt = Qt.replace("?px ", st())), ce += 0.25 * ie * (mt - It);\n                    }\n                    if (H.superscripts === true) {\n                      var er = $e.indexOf(k4), lr = St.indexOf(k4), Tr = er > -1 ? parseInt($e[1 + er]) : 0, Lr = lr > -1 ? parseInt(St[1 + lr]) : 0;\n                      Tr !== Lr && (Qt = Qt.replace(st(), "?px "), Ze *= Math.pow(0.75, Lr - Tr), Qt = Qt.replace("?px ", st())), ce -= 0.25 * ie * (Lr - Tr);\n                    }\n                    if (H.bolds === true) {\n                      var ti = $e.indexOf(v3) > -1, Br = St.indexOf(v3) > -1;\n                      !ti && Br && (Vr ? Qt = Qt.replace("italic ", "italic bold ") : Qt = "bold " + Qt), ti && !Br && (Qt = Qt.replace("bold ", ""));\n                    }\n                    if (H.italics === true) {\n                      var Vr = $e.indexOf(b) > -1, dt = St.indexOf(b) > -1;\n                      !Vr && dt && (Qt = "italic " + Qt), Vr && !dt && (Qt = Qt.replace("italic ", ""));\n                    }\n                    G2.font = Qt;\n                  }\n                  for (Pe = 0; Pe < me; ++Pe) {\n                    var Gt = Ce[Pe] + `\n`;\n                    for (Re = 0, ce = Pe * ie, Ze = j3, pt = "", ge = 0; ge < Gt.length; ++ge) {\n                      var Nt = ge + ut < _e.length ? _e[ge + ut] : _e[_e.length - 1];\n                      te === Nt ? pt += Gt[ge] : (Zt(), pt = Gt[ge], Nt !== void 0 && (lt(te, Nt), te = Nt));\n                    }\n                    Zt(), ut += Gt.length;\n                    var Jt = Math.round(Re + 2 * Se) | 0;\n                    Ae < Jt && (Ae = Jt);\n                  }\n                  var sr = Ae, wr = Le + ie * me, cr = l3(G2.getImageData(0, 0, sr, wr).data, [wr, sr, 4]);\n                  return cr.pick(-1, -1, 0).transpose(1, 0);\n                }\n                function P3(V2, G2) {\n                  var Z = s3(V2, 128);\n                  return G2 ? u4(Z.cells, Z.positions, 0.25) : { edges: Z.cells, positions: Z.positions };\n                }\n                function T3(V2, G2, Z, j3) {\n                  var N2 = P3(V2, j3), H = M4(N2.positions, G2, Z), te = N2.edges, oe = G2.orientation === "ccw";\n                  if (c5(H, te), G2.polygons || G2.polygon || G2.polyline) {\n                    for (var _e = h3(te, H), Ee = new Array(_e.length), Ce = 0; Ce < _e.length; ++Ce) {\n                      for (var me = _e[Ce], ie = new Array(me.length), Se = 0; Se < me.length; ++Se) {\n                        for (var Le = me[Se], Ae = new Array(Le.length), Fe = 0; Fe < Le.length; ++Fe) Ae[Fe] = H[Le[Fe]].slice();\n                        oe && Ae.reverse(), ie[Se] = Ae;\n                      }\n                      Ee[Ce] = ie;\n                    }\n                    return Ee;\n                  } else return G2.triangles || G2.triangulate || G2.triangle ? { cells: f4(H, te, { delaunay: false, exterior: false, interior: true }), positions: H } : { edges: te, positions: H };\n                }\n                function z3(V2, G2, Z) {\n                  try {\n                    return T3(V2, G2, Z, true);\n                  } catch (j3) {\n                  }\n                  try {\n                    return T3(V2, G2, Z, false);\n                  } catch (j3) {\n                  }\n                  return G2.polygons || G2.polyline || G2.polygon ? [] : G2.triangles || G2.triangulate || G2.triangle ? { cells: [], positions: [] } : { edges: [], positions: [] };\n                }\n                function O3(V2, G2, Z, j3) {\n                  var N2 = 64, H = 1.25, te = { breaklines: false, bolds: false, italics: false, subscripts: false, superscripts: false };\n                  j3 && (j3.size && j3.size > 0 && (N2 = j3.size), j3.lineSpacing && j3.lineSpacing > 0 && (H = j3.lineSpacing), j3.styletags && j3.styletags.breaklines && (te.breaklines = !!j3.styletags.breaklines), j3.styletags && j3.styletags.bolds && (te.bolds = !!j3.styletags.bolds), j3.styletags && j3.styletags.italics && (te.italics = !!j3.styletags.italics), j3.styletags && j3.styletags.subscripts && (te.subscripts = !!j3.styletags.subscripts), j3.styletags && j3.styletags.superscripts && (te.superscripts = !!j3.styletags.superscripts)), Z.font = [j3.fontStyle, j3.fontVariant, j3.fontWeight, N2 + "px", j3.font].filter(function(_e) {\n                    return _e;\n                  }).join(" "), Z.textAlign = "start", Z.textBaseline = "alphabetic", Z.direction = "ltr";\n                  var oe = g3(G2, Z, V2, N2, H, te);\n                  return z3(oe, j3, N2);\n                }\n              }, 7721: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5716);\n                i3.exports = l3;\n                function l3(u4) {\n                  return s3(u4[0]) * s3(u4[1]);\n                }\n              }, 7765: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = p3;\n                var s3 = o4(9618), l3 = o4(1888), u4 = o4(446), c5 = o4(1570);\n                function f4(k4) {\n                  for (var E3 = k4.length, S2 = 0, L3 = 0; L3 < E3; ++L3) S2 = Math.max(S2, k4[L3].length) | 0;\n                  return S2 - 1;\n                }\n                function h3(k4, E3) {\n                  for (var S2 = k4.length, L3 = l3.mallocUint8(S2), x2 = 0; x2 < S2; ++x2) L3[x2] = k4[x2] < E3 | 0;\n                  return L3;\n                }\n                function d3(k4, E3) {\n                  for (var S2 = k4.length, L3 = E3 * (E3 + 1) / 2 * S2 | 0, x2 = l3.mallocUint32(L3 * 2), C3 = 0, M4 = 0; M4 < S2; ++M4) for (var g3 = k4[M4], E3 = g3.length, P3 = 0; P3 < E3; ++P3) for (var T3 = 0; T3 < P3; ++T3) {\n                    var z3 = g3[T3], O3 = g3[P3];\n                    x2[C3++] = Math.min(z3, O3) | 0, x2[C3++] = Math.max(z3, O3) | 0;\n                  }\n                  var V2 = C3 / 2 | 0;\n                  u4(s3(x2, [V2, 2]));\n                  for (var G2 = 2, M4 = 2; M4 < C3; M4 += 2) x2[M4 - 2] === x2[M4] && x2[M4 - 1] === x2[M4 + 1] || (x2[G2++] = x2[M4], x2[G2++] = x2[M4 + 1]);\n                  return s3(x2, [G2 / 2 | 0, 2]);\n                }\n                function v3(k4, E3, S2, L3) {\n                  for (var x2 = k4.data, C3 = k4.shape[0], M4 = l3.mallocDouble(C3), g3 = 0, P3 = 0; P3 < C3; ++P3) {\n                    var T3 = x2[2 * P3], z3 = x2[2 * P3 + 1];\n                    if (S2[T3] !== S2[z3]) {\n                      var O3 = E3[T3], V2 = E3[z3];\n                      x2[2 * g3] = T3, x2[2 * g3 + 1] = z3, M4[g3++] = (V2 - L3) / (V2 - O3);\n                    }\n                  }\n                  return k4.shape[0] = g3, s3(M4, [g3]);\n                }\n                function _2(k4, E3) {\n                  var S2 = l3.mallocInt32(E3 * 2), L3 = k4.shape[0], x2 = k4.data;\n                  S2[0] = 0;\n                  for (var C3 = 0, M4 = 0; M4 < L3; ++M4) {\n                    var g3 = x2[2 * M4];\n                    if (g3 !== C3) {\n                      for (S2[2 * C3 + 1] = M4; ++C3 < g3; ) S2[2 * C3] = M4, S2[2 * C3 + 1] = M4;\n                      S2[2 * C3] = M4;\n                    }\n                  }\n                  for (S2[2 * C3 + 1] = L3; ++C3 < E3; ) S2[2 * C3] = S2[2 * C3 + 1] = L3;\n                  return S2;\n                }\n                function b(k4) {\n                  for (var E3 = k4.shape[0] | 0, S2 = k4.data, L3 = new Array(E3), x2 = 0; x2 < E3; ++x2) L3[x2] = [S2[2 * x2], S2[2 * x2 + 1]];\n                  return L3;\n                }\n                function p3(k4, E3, S2, L3) {\n                  S2 = S2 || 0, typeof L3 == "undefined" && (L3 = f4(k4));\n                  var x2 = k4.length;\n                  if (x2 === 0 || L3 < 1) return { cells: [], vertexIds: [], vertexWeights: [] };\n                  var C3 = h3(E3, +S2), M4 = d3(k4, L3), g3 = v3(M4, E3, C3, +S2), P3 = _2(M4, E3.length | 0), T3 = c5(L3)(k4, M4.data, P3, C3), z3 = b(M4), O3 = [].slice.call(g3.data, 0, g3.shape[0]);\n                  return l3.free(C3), l3.free(M4.data), l3.free(g3.data), l3.free(P3), { cells: T3, vertexIds: z3, vertexWeights: O3 };\n                }\n              }, 7766: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(9618), l3 = o4(5298), u4 = o4(1888);\n                i3.exports = g3;\n                var c5 = null, f4 = null, h3 = null;\n                function d3(P3) {\n                  c5 = [P3.LINEAR, P3.NEAREST_MIPMAP_LINEAR, P3.LINEAR_MIPMAP_NEAREST, P3.LINEAR_MIPMAP_NEAREST], f4 = [P3.NEAREST, P3.LINEAR, P3.NEAREST_MIPMAP_NEAREST, P3.NEAREST_MIPMAP_LINEAR, P3.LINEAR_MIPMAP_NEAREST, P3.LINEAR_MIPMAP_LINEAR], h3 = [P3.REPEAT, P3.CLAMP_TO_EDGE, P3.MIRRORED_REPEAT];\n                }\n                function v3(P3) {\n                  return typeof HTMLCanvasElement != "undefined" && P3 instanceof HTMLCanvasElement || typeof HTMLImageElement != "undefined" && P3 instanceof HTMLImageElement || typeof HTMLVideoElement != "undefined" && P3 instanceof HTMLVideoElement || typeof ImageData != "undefined" && P3 instanceof ImageData;\n                }\n                var _2 = function(P3, T3) {\n                  l3.muls(P3, T3, 255);\n                };\n                function b(P3, T3, z3) {\n                  var O3 = P3.gl, V2 = O3.getParameter(O3.MAX_TEXTURE_SIZE);\n                  if (T3 < 0 || T3 > V2 || z3 < 0 || z3 > V2) throw new Error("gl-texture2d: Invalid texture size");\n                  return P3._shape = [T3, z3], P3.bind(), O3.texImage2D(O3.TEXTURE_2D, 0, P3.format, T3, z3, 0, P3.format, P3.type, null), P3._mipLevels = [0], P3;\n                }\n                function p3(P3, T3, z3, O3, V2, G2) {\n                  this.gl = P3, this.handle = T3, this.format = V2, this.type = G2, this._shape = [z3, O3], this._mipLevels = [0], this._magFilter = P3.NEAREST, this._minFilter = P3.NEAREST, this._wrapS = P3.CLAMP_TO_EDGE, this._wrapT = P3.CLAMP_TO_EDGE, this._anisoSamples = 1;\n                  var Z = this, j3 = [this._wrapS, this._wrapT];\n                  Object.defineProperties(j3, [{ get: function() {\n                    return Z._wrapS;\n                  }, set: function(H) {\n                    return Z.wrapS = H;\n                  } }, { get: function() {\n                    return Z._wrapT;\n                  }, set: function(H) {\n                    return Z.wrapT = H;\n                  } }]), this._wrapVector = j3;\n                  var N2 = [this._shape[0], this._shape[1]];\n                  Object.defineProperties(N2, [{ get: function() {\n                    return Z._shape[0];\n                  }, set: function(H) {\n                    return Z.width = H;\n                  } }, { get: function() {\n                    return Z._shape[1];\n                  }, set: function(H) {\n                    return Z.height = H;\n                  } }]), this._shapeVector = N2;\n                }\n                var k4 = p3.prototype;\n                Object.defineProperties(k4, { minFilter: { get: function() {\n                  return this._minFilter;\n                }, set: function(P3) {\n                  this.bind();\n                  var T3 = this.gl;\n                  if (this.type === T3.FLOAT && c5.indexOf(P3) >= 0 && (T3.getExtension("OES_texture_float_linear") || (P3 = T3.NEAREST)), f4.indexOf(P3) < 0) throw new Error("gl-texture2d: Unknown filter mode " + P3);\n                  return T3.texParameteri(T3.TEXTURE_2D, T3.TEXTURE_MIN_FILTER, P3), this._minFilter = P3;\n                } }, magFilter: { get: function() {\n                  return this._magFilter;\n                }, set: function(P3) {\n                  this.bind();\n                  var T3 = this.gl;\n                  if (this.type === T3.FLOAT && c5.indexOf(P3) >= 0 && (T3.getExtension("OES_texture_float_linear") || (P3 = T3.NEAREST)), f4.indexOf(P3) < 0) throw new Error("gl-texture2d: Unknown filter mode " + P3);\n                  return T3.texParameteri(T3.TEXTURE_2D, T3.TEXTURE_MAG_FILTER, P3), this._magFilter = P3;\n                } }, mipSamples: { get: function() {\n                  return this._anisoSamples;\n                }, set: function(P3) {\n                  var T3 = this._anisoSamples;\n                  if (this._anisoSamples = Math.max(P3, 1) | 0, T3 !== this._anisoSamples) {\n                    var z3 = this.gl.getExtension("EXT_texture_filter_anisotropic");\n                    z3 && this.gl.texParameterf(this.gl.TEXTURE_2D, z3.TEXTURE_MAX_ANISOTROPY_EXT, this._anisoSamples);\n                  }\n                  return this._anisoSamples;\n                } }, wrapS: { get: function() {\n                  return this._wrapS;\n                }, set: function(P3) {\n                  if (this.bind(), h3.indexOf(P3) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P3);\n                  return this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, P3), this._wrapS = P3;\n                } }, wrapT: { get: function() {\n                  return this._wrapT;\n                }, set: function(P3) {\n                  if (this.bind(), h3.indexOf(P3) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P3);\n                  return this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, P3), this._wrapT = P3;\n                } }, wrap: { get: function() {\n                  return this._wrapVector;\n                }, set: function(P3) {\n                  if (Array.isArray(P3) || (P3 = [P3, P3]), P3.length !== 2) throw new Error("gl-texture2d: Must specify wrap mode for rows and columns");\n                  for (var T3 = 0; T3 < 2; ++T3) if (h3.indexOf(P3[T3]) < 0) throw new Error("gl-texture2d: Unknown wrap mode " + P3);\n                  this._wrapS = P3[0], this._wrapT = P3[1];\n                  var z3 = this.gl;\n                  return this.bind(), z3.texParameteri(z3.TEXTURE_2D, z3.TEXTURE_WRAP_S, this._wrapS), z3.texParameteri(z3.TEXTURE_2D, z3.TEXTURE_WRAP_T, this._wrapT), P3;\n                } }, shape: { get: function() {\n                  return this._shapeVector;\n                }, set: function(P3) {\n                  if (!Array.isArray(P3)) P3 = [P3 | 0, P3 | 0];\n                  else if (P3.length !== 2) throw new Error("gl-texture2d: Invalid texture shape");\n                  return b(this, P3[0] | 0, P3[1] | 0), [P3[0] | 0, P3[1] | 0];\n                } }, width: { get: function() {\n                  return this._shape[0];\n                }, set: function(P3) {\n                  return P3 = P3 | 0, b(this, P3, this._shape[1]), P3;\n                } }, height: { get: function() {\n                  return this._shape[1];\n                }, set: function(P3) {\n                  return P3 = P3 | 0, b(this, this._shape[0], P3), P3;\n                } } }), k4.bind = function(P3) {\n                  var T3 = this.gl;\n                  return P3 !== void 0 && T3.activeTexture(T3.TEXTURE0 + (P3 | 0)), T3.bindTexture(T3.TEXTURE_2D, this.handle), P3 !== void 0 ? P3 | 0 : T3.getParameter(T3.ACTIVE_TEXTURE) - T3.TEXTURE0;\n                }, k4.dispose = function() {\n                  this.gl.deleteTexture(this.handle);\n                }, k4.generateMipmap = function() {\n                  this.bind(), this.gl.generateMipmap(this.gl.TEXTURE_2D);\n                  for (var P3 = Math.min(this._shape[0], this._shape[1]), T3 = 0; P3 > 0; ++T3, P3 >>>= 1) this._mipLevels.indexOf(T3) < 0 && this._mipLevels.push(T3);\n                }, k4.setPixels = function(P3, T3, z3, O3) {\n                  var V2 = this.gl;\n                  this.bind(), Array.isArray(T3) ? (O3 = z3, z3 = T3[1] | 0, T3 = T3[0] | 0) : (T3 = T3 || 0, z3 = z3 || 0), O3 = O3 || 0;\n                  var G2 = v3(P3) ? P3 : P3.raw;\n                  if (G2) {\n                    var Z = this._mipLevels.indexOf(O3) < 0;\n                    Z ? (V2.texImage2D(V2.TEXTURE_2D, 0, this.format, this.format, this.type, G2), this._mipLevels.push(O3)) : V2.texSubImage2D(V2.TEXTURE_2D, O3, T3, z3, this.format, this.type, G2);\n                  } else if (P3.shape && P3.stride && P3.data) {\n                    if (P3.shape.length < 2 || T3 + P3.shape[1] > this._shape[1] >>> O3 || z3 + P3.shape[0] > this._shape[0] >>> O3 || T3 < 0 || z3 < 0) throw new Error("gl-texture2d: Texture dimensions are out of bounds");\n                    S2(V2, T3, z3, O3, this.format, this.type, this._mipLevels, P3);\n                  } else throw new Error("gl-texture2d: Unsupported data type");\n                };\n                function E3(P3, T3) {\n                  return P3.length === 3 ? T3[2] === 1 && T3[1] === P3[0] * P3[2] && T3[0] === P3[2] : T3[0] === 1 && T3[1] === P3[0];\n                }\n                function S2(P3, T3, z3, O3, V2, G2, Z, j3) {\n                  var N2 = j3.dtype, H = j3.shape.slice();\n                  if (H.length < 2 || H.length > 3) throw new Error("gl-texture2d: Invalid ndarray, must be 2d or 3d");\n                  var te = 0, oe = 0, _e = E3(H, j3.stride.slice());\n                  N2 === "float32" ? te = P3.FLOAT : N2 === "float64" ? (te = P3.FLOAT, _e = false, N2 = "float32") : N2 === "uint8" ? te = P3.UNSIGNED_BYTE : (te = P3.UNSIGNED_BYTE, _e = false, N2 = "uint8");\n                  var Ee = 1;\n                  if (H.length === 2) oe = P3.LUMINANCE, H = [H[0], H[1], 1], j3 = s3(j3.data, H, [j3.stride[0], j3.stride[1], 1], j3.offset);\n                  else if (H.length === 3) {\n                    if (H[2] === 1) oe = P3.ALPHA;\n                    else if (H[2] === 2) oe = P3.LUMINANCE_ALPHA;\n                    else if (H[2] === 3) oe = P3.RGB;\n                    else if (H[2] === 4) oe = P3.RGBA;\n                    else throw new Error("gl-texture2d: Invalid shape for pixel coords");\n                    Ee = H[2];\n                  } else throw new Error("gl-texture2d: Invalid shape for texture");\n                  if ((oe === P3.LUMINANCE || oe === P3.ALPHA) && (V2 === P3.LUMINANCE || V2 === P3.ALPHA) && (oe = V2), oe !== V2) throw new Error("gl-texture2d: Incompatible texture format for setPixels");\n                  var Ce = j3.size, me = Z.indexOf(O3) < 0;\n                  if (me && Z.push(O3), te === G2 && _e) j3.offset === 0 && j3.data.length === Ce ? me ? P3.texImage2D(P3.TEXTURE_2D, O3, V2, H[0], H[1], 0, V2, G2, j3.data) : P3.texSubImage2D(P3.TEXTURE_2D, O3, T3, z3, H[0], H[1], V2, G2, j3.data) : me ? P3.texImage2D(P3.TEXTURE_2D, O3, V2, H[0], H[1], 0, V2, G2, j3.data.subarray(j3.offset, j3.offset + Ce)) : P3.texSubImage2D(P3.TEXTURE_2D, O3, T3, z3, H[0], H[1], V2, G2, j3.data.subarray(j3.offset, j3.offset + Ce));\n                  else {\n                    var ie;\n                    G2 === P3.FLOAT ? ie = u4.mallocFloat32(Ce) : ie = u4.mallocUint8(Ce);\n                    var Se = s3(ie, H, [H[2], H[2] * H[0], 1]);\n                    te === P3.FLOAT && G2 === P3.UNSIGNED_BYTE ? _2(Se, j3) : l3.assign(Se, j3), me ? P3.texImage2D(P3.TEXTURE_2D, O3, V2, H[0], H[1], 0, V2, G2, ie.subarray(0, Ce)) : P3.texSubImage2D(P3.TEXTURE_2D, O3, T3, z3, H[0], H[1], V2, G2, ie.subarray(0, Ce)), G2 === P3.FLOAT ? u4.freeFloat32(ie) : u4.freeUint8(ie);\n                  }\n                }\n                function L3(P3) {\n                  var T3 = P3.createTexture();\n                  return P3.bindTexture(P3.TEXTURE_2D, T3), P3.texParameteri(P3.TEXTURE_2D, P3.TEXTURE_MIN_FILTER, P3.NEAREST), P3.texParameteri(P3.TEXTURE_2D, P3.TEXTURE_MAG_FILTER, P3.NEAREST), P3.texParameteri(P3.TEXTURE_2D, P3.TEXTURE_WRAP_S, P3.CLAMP_TO_EDGE), P3.texParameteri(P3.TEXTURE_2D, P3.TEXTURE_WRAP_T, P3.CLAMP_TO_EDGE), T3;\n                }\n                function x2(P3, T3, z3, O3, V2) {\n                  var G2 = P3.getParameter(P3.MAX_TEXTURE_SIZE);\n                  if (T3 < 0 || T3 > G2 || z3 < 0 || z3 > G2) throw new Error("gl-texture2d: Invalid texture shape");\n                  if (V2 === P3.FLOAT && !P3.getExtension("OES_texture_float")) throw new Error("gl-texture2d: Floating point textures not supported on this platform");\n                  var Z = L3(P3);\n                  return P3.texImage2D(P3.TEXTURE_2D, 0, O3, T3, z3, 0, O3, V2, null), new p3(P3, Z, T3, z3, O3, V2);\n                }\n                function C3(P3, T3, z3, O3, V2, G2) {\n                  var Z = L3(P3);\n                  return P3.texImage2D(P3.TEXTURE_2D, 0, V2, V2, G2, T3), new p3(P3, Z, z3, O3, V2, G2);\n                }\n                function M4(P3, T3) {\n                  var z3 = T3.dtype, O3 = T3.shape.slice(), V2 = P3.getParameter(P3.MAX_TEXTURE_SIZE);\n                  if (O3[0] < 0 || O3[0] > V2 || O3[1] < 0 || O3[1] > V2) throw new Error("gl-texture2d: Invalid texture size");\n                  var G2 = E3(O3, T3.stride.slice()), Z = 0;\n                  z3 === "float32" ? Z = P3.FLOAT : z3 === "float64" ? (Z = P3.FLOAT, G2 = false, z3 = "float32") : z3 === "uint8" ? Z = P3.UNSIGNED_BYTE : (Z = P3.UNSIGNED_BYTE, G2 = false, z3 = "uint8");\n                  var j3 = 0;\n                  if (O3.length === 2) j3 = P3.LUMINANCE, O3 = [O3[0], O3[1], 1], T3 = s3(T3.data, O3, [T3.stride[0], T3.stride[1], 1], T3.offset);\n                  else if (O3.length === 3) if (O3[2] === 1) j3 = P3.ALPHA;\n                  else if (O3[2] === 2) j3 = P3.LUMINANCE_ALPHA;\n                  else if (O3[2] === 3) j3 = P3.RGB;\n                  else if (O3[2] === 4) j3 = P3.RGBA;\n                  else throw new Error("gl-texture2d: Invalid shape for pixel coords");\n                  else throw new Error("gl-texture2d: Invalid shape for texture");\n                  Z === P3.FLOAT && !P3.getExtension("OES_texture_float") && (Z = P3.UNSIGNED_BYTE, G2 = false);\n                  var N2, H, te = T3.size;\n                  if (G2) T3.offset === 0 && T3.data.length === te ? N2 = T3.data : N2 = T3.data.subarray(T3.offset, T3.offset + te);\n                  else {\n                    var oe = [O3[2], O3[2] * O3[0], 1];\n                    H = u4.malloc(te, z3);\n                    var _e = s3(H, O3, oe, 0);\n                    (z3 === "float32" || z3 === "float64") && Z === P3.UNSIGNED_BYTE ? _2(_e, T3) : l3.assign(_e, T3), N2 = H.subarray(0, te);\n                  }\n                  var Ee = L3(P3);\n                  return P3.texImage2D(P3.TEXTURE_2D, 0, j3, O3[0], O3[1], 0, j3, Z, N2), G2 || u4.free(H), new p3(P3, Ee, O3[0], O3[1], j3, Z);\n                }\n                function g3(P3) {\n                  if (arguments.length <= 1) throw new Error("gl-texture2d: Missing arguments for texture2d constructor");\n                  if (c5 || d3(P3), typeof arguments[1] == "number") return x2(P3, arguments[1], arguments[2], arguments[3] || P3.RGBA, arguments[4] || P3.UNSIGNED_BYTE);\n                  if (Array.isArray(arguments[1])) return x2(P3, arguments[1][0] | 0, arguments[1][1] | 0, arguments[2] || P3.RGBA, arguments[3] || P3.UNSIGNED_BYTE);\n                  if (typeof arguments[1] == "object") {\n                    var T3 = arguments[1], z3 = v3(T3) ? T3 : T3.raw;\n                    if (z3) return C3(P3, z3, T3.width | 0, T3.height | 0, arguments[2] || P3.RGBA, arguments[3] || P3.UNSIGNED_BYTE);\n                    if (T3.shape && T3.data && T3.stride) return M4(P3, T3);\n                  }\n                  throw new Error("gl-texture2d: Invalid arguments for texture2d constructor");\n                }\n              }, 7790: function() {\n              }, 7815: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2931), l3 = o4(9970), u4 = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"], c5 = function(S2, L3, x2, C3) {\n                  for (var M4 = S2.points, g3 = S2.velocities, P3 = S2.divergences, T3 = [], z3 = [], O3 = [], V2 = [], G2 = [], Z = [], j3 = 0, N2 = 0, H = l3.create(), te = l3.create(), oe = 8, _e = 0; _e < M4.length; _e++) {\n                    var Ee = M4[_e], Ce = g3[_e], me = P3[_e];\n                    L3 === 0 && (me = x2 * 0.05), N2 = s3.length(Ce) / C3, H = l3.create(), s3.copy(H, Ce), H[3] = me;\n                    for (var ie = 0; ie < oe; ie++) G2[ie] = [Ee[0], Ee[1], Ee[2], ie];\n                    if (V2.length > 0) for (var ie = 0; ie < oe; ie++) {\n                      var Se = (ie + 1) % oe;\n                      T3.push(V2[ie], G2[ie], G2[Se], G2[Se], V2[Se], V2[ie]), O3.push(te, H, H, H, te, te), Z.push(j3, N2, N2, N2, j3, j3);\n                      var Le = T3.length;\n                      z3.push([Le - 6, Le - 5, Le - 4], [Le - 3, Le - 2, Le - 1]);\n                    }\n                    var Ae = V2;\n                    V2 = G2, G2 = Ae;\n                    var Fe = te;\n                    te = H, H = Fe;\n                    var Pe = j3;\n                    j3 = N2, N2 = Pe;\n                  }\n                  return { positions: T3, cells: z3, vectors: O3, vertexIntensity: Z };\n                }, f4 = function(S2, L3, x2, C3) {\n                  for (var M4 = 0, g3 = 0; g3 < S2.length; g3++) for (var P3 = S2[g3].velocities, T3 = 0; T3 < P3.length; T3++) M4 = Math.max(M4, s3.length(P3[T3]));\n                  for (var z3 = S2.map(function(_e) {\n                    return c5(_e, x2, C3, M4);\n                  }), O3 = [], V2 = [], G2 = [], Z = [], g3 = 0; g3 < z3.length; g3++) {\n                    var j3 = z3[g3], N2 = O3.length;\n                    O3 = O3.concat(j3.positions), G2 = G2.concat(j3.vectors), Z = Z.concat(j3.vertexIntensity);\n                    for (var T3 = 0; T3 < j3.cells.length; T3++) {\n                      var H = j3.cells[T3], te = [];\n                      V2.push(te);\n                      for (var oe = 0; oe < H.length; oe++) te.push(H[oe] + N2);\n                    }\n                  }\n                  return { positions: O3, cells: V2, vectors: G2, vertexIntensity: Z, colormap: L3 };\n                }, h3 = function(S2, L3) {\n                  var x2 = S2.length, C3;\n                  for (C3 = 0; C3 < x2; C3++) {\n                    var M4 = S2[C3];\n                    if (M4 === L3) return C3;\n                    if (M4 > L3) return C3 - 1;\n                  }\n                  return C3;\n                }, d3 = function(S2, L3, x2) {\n                  return S2 < L3 ? L3 : S2 > x2 ? x2 : S2;\n                }, v3 = function(S2, L3, x2) {\n                  var C3 = L3.vectors, M4 = L3.meshgrid, g3 = S2[0], P3 = S2[1], T3 = S2[2], z3 = M4[0].length, O3 = M4[1].length, V2 = M4[2].length, G2 = h3(M4[0], g3), Z = h3(M4[1], P3), j3 = h3(M4[2], T3), N2 = G2 + 1, H = Z + 1, te = j3 + 1;\n                  if (G2 = d3(G2, 0, z3 - 1), N2 = d3(N2, 0, z3 - 1), Z = d3(Z, 0, O3 - 1), H = d3(H, 0, O3 - 1), j3 = d3(j3, 0, V2 - 1), te = d3(te, 0, V2 - 1), G2 < 0 || Z < 0 || j3 < 0 || N2 > z3 - 1 || H > O3 - 1 || te > V2 - 1) return s3.create();\n                  var oe = M4[0][G2], _e = M4[0][N2], Ee = M4[1][Z], Ce = M4[1][H], me = M4[2][j3], ie = M4[2][te], Se = (g3 - oe) / (_e - oe), Le = (P3 - Ee) / (Ce - Ee), Ae = (T3 - me) / (ie - me);\n                  isFinite(Se) || (Se = 0.5), isFinite(Le) || (Le = 0.5), isFinite(Ae) || (Ae = 0.5);\n                  var Fe, Pe, ge, Re, ce, Ze;\n                  switch (x2.reversedX && (G2 = z3 - 1 - G2, N2 = z3 - 1 - N2), x2.reversedY && (Z = O3 - 1 - Z, H = O3 - 1 - H), x2.reversedZ && (j3 = V2 - 1 - j3, te = V2 - 1 - te), x2.filled) {\n                    case 5:\n                      ce = j3, Ze = te, ge = Z * V2, Re = H * V2, Fe = G2 * V2 * O3, Pe = N2 * V2 * O3;\n                      break;\n                    case 4:\n                      ce = j3, Ze = te, Fe = G2 * V2, Pe = N2 * V2, ge = Z * V2 * z3, Re = H * V2 * z3;\n                      break;\n                    case 3:\n                      ge = Z, Re = H, ce = j3 * O3, Ze = te * O3, Fe = G2 * O3 * V2, Pe = N2 * O3 * V2;\n                      break;\n                    case 2:\n                      ge = Z, Re = H, Fe = G2 * O3, Pe = N2 * O3, ce = j3 * O3 * z3, Ze = te * O3 * z3;\n                      break;\n                    case 1:\n                      Fe = G2, Pe = N2, ce = j3 * z3, Ze = te * z3, ge = Z * z3 * V2, Re = H * z3 * V2;\n                      break;\n                    default:\n                      Fe = G2, Pe = N2, ge = Z * z3, Re = H * z3, ce = j3 * z3 * O3, Ze = te * z3 * O3;\n                      break;\n                  }\n                  var ut = C3[Fe + ge + ce], pt = C3[Fe + ge + Ze], Zt = C3[Fe + Re + ce], st = C3[Fe + Re + Ze], lt = C3[Pe + ge + ce], Gt = C3[Pe + ge + Ze], Nt = C3[Pe + Re + ce], Jt = C3[Pe + Re + Ze], sr = s3.create(), wr = s3.create(), cr = s3.create(), $e = s3.create();\n                  s3.lerp(sr, ut, lt, Se), s3.lerp(wr, pt, Gt, Se), s3.lerp(cr, Zt, Nt, Se), s3.lerp($e, st, Jt, Se);\n                  var St = s3.create(), Qt = s3.create();\n                  s3.lerp(St, sr, cr, Le), s3.lerp(Qt, wr, $e, Le);\n                  var Vt = s3.create();\n                  return s3.lerp(Vt, St, Qt, Ae), Vt;\n                }, _2 = function(S2, L3) {\n                  var x2 = L3[0], C3 = L3[1], M4 = L3[2];\n                  return S2[0] = x2 < 0 ? -x2 : x2, S2[1] = C3 < 0 ? -C3 : C3, S2[2] = M4 < 0 ? -M4 : M4, S2;\n                }, b = function(S2) {\n                  var L3 = 1 / 0;\n                  S2.sort(function(g3, P3) {\n                    return g3 - P3;\n                  });\n                  for (var x2 = S2.length, C3 = 1; C3 < x2; C3++) {\n                    var M4 = Math.abs(S2[C3] - S2[C3 - 1]);\n                    M4 < L3 && (L3 = M4);\n                  }\n                  return L3;\n                }, p3 = function(S2) {\n                  for (var L3 = [], x2 = [], C3 = [], M4 = {}, g3 = {}, P3 = {}, T3 = S2.length, z3 = 0; z3 < T3; z3++) {\n                    var O3 = S2[z3], V2 = O3[0], G2 = O3[1], Z = O3[2];\n                    M4[V2] || (L3.push(V2), M4[V2] = true), g3[G2] || (x2.push(G2), g3[G2] = true), P3[Z] || (C3.push(Z), P3[Z] = true);\n                  }\n                  var j3 = b(L3), N2 = b(x2), H = b(C3), te = Math.min(j3, N2, H);\n                  return isFinite(te) ? te : 1;\n                };\n                i3.exports = function(S2, L3) {\n                  var x2 = S2.startingPositions, C3 = S2.maxLength || 1e3, M4 = S2.tubeSize || 1, g3 = S2.absoluteTubeSize, P3 = S2.gridFill || "+x+y+z", T3 = {};\n                  P3.indexOf("-x") !== -1 && (T3.reversedX = true), P3.indexOf("-y") !== -1 && (T3.reversedY = true), P3.indexOf("-z") !== -1 && (T3.reversedZ = true), T3.filled = u4.indexOf(P3.replace(/-/g, "").replace(/\\+/g, ""));\n                  var z3 = S2.getVelocity || function(Gt) {\n                    return v3(Gt, S2, T3);\n                  }, O3 = S2.getDivergence || function(Gt, Nt) {\n                    var Jt = s3.create(), sr = 1e-4;\n                    s3.add(Jt, Gt, [sr, 0, 0]);\n                    var wr = z3(Jt);\n                    s3.subtract(wr, wr, Nt), s3.scale(wr, wr, 1 / sr), s3.add(Jt, Gt, [0, sr, 0]);\n                    var cr = z3(Jt);\n                    s3.subtract(cr, cr, Nt), s3.scale(cr, cr, 1 / sr), s3.add(Jt, Gt, [0, 0, sr]);\n                    var $e = z3(Jt);\n                    return s3.subtract($e, $e, Nt), s3.scale($e, $e, 1 / sr), s3.add(Jt, wr, cr), s3.add(Jt, Jt, $e), Jt;\n                  }, V2 = [], G2 = L3[0][0], Z = L3[0][1], j3 = L3[0][2], N2 = L3[1][0], H = L3[1][1], te = L3[1][2], oe = function(Gt) {\n                    var Nt = Gt[0], Jt = Gt[1], sr = Gt[2];\n                    return !(Nt < G2 || Nt > N2 || Jt < Z || Jt > H || sr < j3 || sr > te);\n                  }, _e = s3.distance(L3[0], L3[1]), Ee = 10 * _e / C3, Ce = Ee * Ee, me = 1, ie = 0, Se = x2.length;\n                  Se > 1 && (me = p3(x2));\n                  for (var Le = 0; Le < Se; Le++) {\n                    var Ae = s3.create();\n                    s3.copy(Ae, x2[Le]);\n                    var Fe = [Ae], Pe = [], ge = z3(Ae), Re = Ae;\n                    Pe.push(ge);\n                    var ce = [], Ze = O3(Ae, ge), ut = s3.length(Ze);\n                    isFinite(ut) && ut > ie && (ie = ut), ce.push(ut), V2.push({ points: Fe, velocities: Pe, divergences: ce });\n                    for (var pt = 0; pt < C3 * 100 && Fe.length < C3 && oe(Ae); ) {\n                      pt++;\n                      var Zt = s3.clone(ge), st = s3.squaredLength(Zt);\n                      if (st === 0) break;\n                      if (st > Ce && s3.scale(Zt, Zt, Ee / Math.sqrt(st)), s3.add(Zt, Zt, Ae), ge = z3(Zt), s3.squaredDistance(Re, Zt) - Ce > -1e-4 * Ce) {\n                        Fe.push(Zt), Re = Zt, Pe.push(ge);\n                        var Ze = O3(Zt, ge), ut = s3.length(Ze);\n                        isFinite(ut) && ut > ie && (ie = ut), ce.push(ut);\n                      }\n                      Ae = Zt;\n                    }\n                  }\n                  var lt = f4(V2, S2.colormap, ie, me);\n                  return g3 ? lt.tubeScale = g3 : (ie === 0 && (ie = 1), lt.tubeScale = M4 * 0.5 * me / ie), lt;\n                };\n                var k4 = o4(6740), E3 = o4(6405).createMesh;\n                i3.exports.createTubeMesh = function(S2, L3) {\n                  return E3(S2, L3, { shaders: k4, traceType: "streamtube" });\n                };\n              }, 7827: function(i3) {\n                i3.exports = ["<<=", ">>=", "++", "--", "<<", ">>", "<=", ">=", "==", "!=", "&&", "||", "+=", "-=", "*=", "/=", "%=", "&=", "^^", "^=", "|=", "(", ")", "[", "]", ".", "!", "~", "*", "/", "%", "+", "-", "<", ">", "&", "^", "|", "?", ":", "=", ",", ";", "{", "}"];\n              }, 7842: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(6330), l3 = o4(1533), u4 = o4(2651), c5 = o4(6768), f4 = o4(869), h3 = o4(8697);\n                i3.exports = d3;\n                function d3(v3, _2) {\n                  if (s3(v3)) return _2 ? h3(v3, d3(_2)) : [v3[0].clone(), v3[1].clone()];\n                  var b = 0, p3, k4;\n                  if (l3(v3)) p3 = v3.clone();\n                  else if (typeof v3 == "string") p3 = c5(v3);\n                  else {\n                    if (v3 === 0) return [u4(0), u4(1)];\n                    if (v3 === Math.floor(v3)) p3 = u4(v3);\n                    else {\n                      for (; v3 !== Math.floor(v3); ) v3 = v3 * Math.pow(2, 256), b -= 256;\n                      p3 = u4(v3);\n                    }\n                  }\n                  if (s3(_2)) p3.mul(_2[1]), k4 = _2[0].clone();\n                  else if (l3(_2)) k4 = _2.clone();\n                  else if (typeof _2 == "string") k4 = c5(_2);\n                  else if (!_2) k4 = u4(1);\n                  else if (_2 === Math.floor(_2)) k4 = u4(_2);\n                  else {\n                    for (; _2 !== Math.floor(_2); ) _2 = _2 * Math.pow(2, 256), b += 256;\n                    k4 = u4(_2);\n                  }\n                  return b > 0 ? p3 = p3.ushln(b) : b < 0 && (k4 = k4.ushln(-b)), f4(p3, k4);\n                }\n              }, 7894: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  return o4[0] = 1, o4[1] = 0, o4[2] = 0, o4[3] = 0, o4[4] = 0, o4[5] = 1, o4[6] = 0, o4[7] = 0, o4[8] = 0, o4[9] = 0, o4[10] = 1, o4[11] = 0, o4[12] = 0, o4[13] = 0, o4[14] = 0, o4[15] = 1, o4;\n                }\n              }, 7932: function(i3, a4, o4) {\n                var s3 = o4(620);\n                i3.exports = s3.slice().concat(["layout", "centroid", "smooth", "case", "mat2x2", "mat2x3", "mat2x4", "mat3x2", "mat3x3", "mat3x4", "mat4x2", "mat4x3", "mat4x4", "uvec2", "uvec3", "uvec4", "samplerCubeShadow", "sampler2DArray", "sampler2DArrayShadow", "isampler2D", "isampler3D", "isamplerCube", "isampler2DArray", "usampler2D", "usampler3D", "usamplerCube", "usampler2DArray", "coherent", "restrict", "readonly", "writeonly", "resource", "atomic_uint", "noperspective", "patch", "sample", "subroutine", "common", "partition", "active", "filter", "image1D", "image2D", "image3D", "imageCube", "iimage1D", "iimage2D", "iimage3D", "iimageCube", "uimage1D", "uimage2D", "uimage3D", "uimageCube", "image1DArray", "image2DArray", "iimage1DArray", "iimage2DArray", "uimage1DArray", "uimage2DArray", "image1DShadow", "image2DShadow", "image1DArrayShadow", "image2DArrayShadow", "imageBuffer", "iimageBuffer", "uimageBuffer", "sampler1DArray", "sampler1DArrayShadow", "isampler1D", "isampler1DArray", "usampler1D", "usampler1DArray", "isampler2DRect", "usampler2DRect", "samplerBuffer", "isamplerBuffer", "usamplerBuffer", "sampler2DMS", "isampler2DMS", "usampler2DMS", "sampler2DMSArray", "isampler2DMSArray", "usampler2DMSArray"]);\n              }, 7960: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = s3[0] - o4[0], u4 = s3[1] - o4[1], c5 = s3[2] - o4[2], f4 = s3[3] - o4[3];\n                  return l3 * l3 + u4 * u4 + c5 * c5 + f4 * f4;\n                }\n              }, 8105: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                var a4 = { "lo===p0": s3, "lo<p0": l3, "lo<=p0": u4, "hi<=p0": c5, "lo<p0&&p0<=hi": h3, "lo<=p0&&p0<=hi": f4, "!(lo>=p0)&&!(p1>=hi)": d3 };\n                function o4(v3) {\n                  return a4[v3];\n                }\n                function s3(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + g3];\n                    if (z3 === S2) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var O3 = 0; L3 > O3; ++O3) {\n                        var V2 = k4[x2 + O3];\n                        k4[x2 + O3] = k4[C3], k4[C3++] = V2;\n                      }\n                      var G2 = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = G2;\n                    }\n                  }\n                  return M4;\n                }\n                function l3(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + g3];\n                    if (z3 < S2) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var O3 = 0; L3 > O3; ++O3) {\n                        var V2 = k4[x2 + O3];\n                        k4[x2 + O3] = k4[C3], k4[C3++] = V2;\n                      }\n                      var G2 = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = G2;\n                    }\n                  }\n                  return M4;\n                }\n                function u4(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + P3];\n                    if (z3 <= S2) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var O3 = 0; L3 > O3; ++O3) {\n                        var V2 = k4[x2 + O3];\n                        k4[x2 + O3] = k4[C3], k4[C3++] = V2;\n                      }\n                      var G2 = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = G2;\n                    }\n                  }\n                  return M4;\n                }\n                function c5(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + P3];\n                    if (z3 <= S2) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var O3 = 0; L3 > O3; ++O3) {\n                        var V2 = k4[x2 + O3];\n                        k4[x2 + O3] = k4[C3], k4[C3++] = V2;\n                      }\n                      var G2 = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = G2;\n                    }\n                  }\n                  return M4;\n                }\n                function f4(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + g3], O3 = k4[x2 + P3];\n                    if (z3 <= S2 && S2 <= O3) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var V2 = 0; L3 > V2; ++V2) {\n                        var G2 = k4[x2 + V2];\n                        k4[x2 + V2] = k4[C3], k4[C3++] = G2;\n                      }\n                      var Z = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = Z;\n                    }\n                  }\n                  return M4;\n                }\n                function h3(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = 2 * v3, x2 = L3 * b, C3 = x2, M4 = b, g3 = _2, P3 = v3 + _2, T3 = b; p3 > T3; ++T3, x2 += L3) {\n                    var z3 = k4[x2 + g3], O3 = k4[x2 + P3];\n                    if (z3 < S2 && S2 <= O3) if (M4 === T3) M4 += 1, C3 += L3;\n                    else {\n                      for (var V2 = 0; L3 > V2; ++V2) {\n                        var G2 = k4[x2 + V2];\n                        k4[x2 + V2] = k4[C3], k4[C3++] = G2;\n                      }\n                      var Z = E3[T3];\n                      E3[T3] = E3[M4], E3[M4++] = Z;\n                    }\n                  }\n                  return M4;\n                }\n                function d3(v3, _2, b, p3, k4, E3, S2, L3) {\n                  for (var x2 = 2 * v3, C3 = x2 * b, M4 = C3, g3 = b, P3 = _2, T3 = v3 + _2, z3 = b; p3 > z3; ++z3, C3 += x2) {\n                    var O3 = k4[C3 + P3], V2 = k4[C3 + T3];\n                    if (!(O3 >= S2) && !(L3 >= V2)) if (g3 === z3) g3 += 1, M4 += x2;\n                    else {\n                      for (var G2 = 0; x2 > G2; ++G2) {\n                        var Z = k4[C3 + G2];\n                        k4[C3 + G2] = k4[M4], k4[M4++] = Z;\n                      }\n                      var j3 = E3[z3];\n                      E3[z3] = E3[g3], E3[g3++] = j3;\n                    }\n                  }\n                  return g3;\n                }\n              }, 8107: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = Math.min(s3[0], l3[0]), o4[1] = Math.min(s3[1], l3[1]), o4[2] = Math.min(s3[2], l3[2]), o4;\n                }\n              }, 8116: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(7518), l3 = o4(870);\n                function u4(f4) {\n                  this.bindVertexArrayOES = f4.bindVertexArray.bind(f4), this.createVertexArrayOES = f4.createVertexArray.bind(f4), this.deleteVertexArrayOES = f4.deleteVertexArray.bind(f4);\n                }\n                function c5(f4, h3, d3, v3) {\n                  var _2 = f4.createVertexArray ? new u4(f4) : f4.getExtension("OES_vertex_array_object"), b;\n                  return _2 ? b = s3(f4, _2) : b = l3(f4), b.update(h3, d3, v3), b;\n                }\n                i3.exports = c5;\n              }, 8192: function(i3, a4, o4) {\n                i3.exports = c5;\n                var s3 = o4(2825), l3 = o4(3536), u4 = o4(244);\n                function c5(f4, h3) {\n                  var d3 = s3(f4[0], f4[1], f4[2]), v3 = s3(h3[0], h3[1], h3[2]);\n                  l3(d3, d3), l3(v3, v3);\n                  var _2 = u4(d3, v3);\n                  return _2 > 1 ? 0 : Math.acos(_2);\n                }\n              }, 8210: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                function a4(s3, l3) {\n                  var u4 = s3 + l3, c5 = u4 - s3, f4 = u4 - c5, h3 = l3 - c5, d3 = s3 - f4, v3 = d3 + h3;\n                  return v3 ? [v3, u4] : [u4];\n                }\n                function o4(s3, l3) {\n                  var u4 = s3.length | 0, c5 = l3.length | 0;\n                  if (u4 === 1 && c5 === 1) return a4(s3[0], l3[0]);\n                  var f4 = u4 + c5, h3 = new Array(f4), d3 = 0, v3 = 0, _2 = 0, b = Math.abs, p3 = s3[v3], k4 = b(p3), E3 = l3[_2], S2 = b(E3), L3, x2;\n                  k4 < S2 ? (x2 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (x2 = E3, _2 += 1, _2 < c5 && (E3 = l3[_2], S2 = b(E3))), v3 < u4 && k4 < S2 || _2 >= c5 ? (L3 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (L3 = E3, _2 += 1, _2 < c5 && (E3 = l3[_2], S2 = b(E3)));\n                  for (var C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, P3 = g3, T3 = C3, z3, O3, V2, G2, Z; v3 < u4 && _2 < c5; ) k4 < S2 ? (L3 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (L3 = E3, _2 += 1, _2 < c5 && (E3 = l3[_2], S2 = b(E3))), x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3;\n                  for (; v3 < u4; ) L3 = p3, x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3, v3 += 1, v3 < u4 && (p3 = s3[v3]);\n                  for (; _2 < c5; ) L3 = E3, x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3, _2 += 1, _2 < c5 && (E3 = l3[_2]);\n                  return P3 && (h3[d3++] = P3), T3 && (h3[d3++] = T3), d3 || (h3[d3++] = 0), h3.length = d3, h3;\n                }\n              }, 8277: function(i3) {\n                "use strict";\n                function a4() {\n                  return function(f4, h3, d3, v3, _2) {\n                    var b = f4[0], p3 = f4[1], k4 = f4[2], E3 = d3[0], S2 = d3[1], L3 = d3[2], x2 = [0, 0, 0];\n                    v3 |= 0;\n                    var C3 = 0, M4 = 0, g3 = 0, P3 = L3, T3 = S2 - k4 * L3, z3 = E3 - p3 * S2;\n                    for (g3 = 0; g3 < b; ++g3) {\n                      for (M4 = 0; M4 < p3; ++M4) {\n                        for (C3 = 0; C3 < k4; ++C3) {\n                          {\n                            var O3 = _2, V2;\n                            for (V2 = 0; V2 < x2.length - 1; ++V2) O3 = O3[x2[V2]];\n                            h3[v3] = O3[x2[x2.length - 1]];\n                          }\n                          v3 += P3, ++x2[2];\n                        }\n                        v3 += T3, x2[2] -= k4, ++x2[1];\n                      }\n                      v3 += z3, x2[1] -= p3, ++x2[0];\n                    }\n                  };\n                }\n                function o4() {\n                  return a4();\n                }\n                var s3 = o4;\n                function l3(f4) {\n                  var h3 = {};\n                  return function(v3, _2) {\n                    var b = v3.dtype, p3 = v3.order, k4 = [b, p3.join()].join(), E3 = h3[k4];\n                    return E3 || (h3[k4] = E3 = f4([b, p3])), E3(v3.shape.slice(0), v3.data, v3.stride, v3.offset | 0, _2);\n                  };\n                }\n                function u4(f4) {\n                  return l3(s3.bind(void 0, f4));\n                }\n                function c5(f4) {\n                  return u4({ funcName: f4.funcName });\n                }\n                i3.exports = c5({ funcName: "convert" });\n              }, 8284: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  var l3 = { identity: s3 }, u4 = o4.valueOf;\n                  return Object.defineProperty(o4, "valueOf", { value: function(c5) {\n                    return c5 !== s3 ? u4.apply(this, arguments) : l3;\n                  }, writable: true }), l3;\n                }\n              }, 8406: function(i3, a4) {\n                var o4 = 1e-6, s3 = 1e-6;\n                a4.vertexNormals = function(l3, u4, c5) {\n                  for (var f4 = u4.length, h3 = new Array(f4), d3 = c5 === void 0 ? o4 : c5, v3 = 0; v3 < f4; ++v3) h3[v3] = [0, 0, 0];\n                  for (var v3 = 0; v3 < l3.length; ++v3) for (var _2 = l3[v3], b = 0, p3 = _2[_2.length - 1], k4 = _2[0], E3 = 0; E3 < _2.length; ++E3) {\n                    b = p3, p3 = k4, k4 = _2[(E3 + 1) % _2.length];\n                    for (var S2 = u4[b], L3 = u4[p3], x2 = u4[k4], C3 = new Array(3), M4 = 0, g3 = new Array(3), P3 = 0, T3 = 0; T3 < 3; ++T3) C3[T3] = S2[T3] - L3[T3], M4 += C3[T3] * C3[T3], g3[T3] = x2[T3] - L3[T3], P3 += g3[T3] * g3[T3];\n                    if (M4 * P3 > d3) for (var z3 = h3[p3], O3 = 1 / Math.sqrt(M4 * P3), T3 = 0; T3 < 3; ++T3) {\n                      var V2 = (T3 + 1) % 3, G2 = (T3 + 2) % 3;\n                      z3[T3] += O3 * (g3[V2] * C3[G2] - g3[G2] * C3[V2]);\n                    }\n                  }\n                  for (var v3 = 0; v3 < f4; ++v3) {\n                    for (var z3 = h3[v3], Z = 0, T3 = 0; T3 < 3; ++T3) Z += z3[T3] * z3[T3];\n                    if (Z > d3) for (var O3 = 1 / Math.sqrt(Z), T3 = 0; T3 < 3; ++T3) z3[T3] *= O3;\n                    else for (var T3 = 0; T3 < 3; ++T3) z3[T3] = 0;\n                  }\n                  return h3;\n                }, a4.faceNormals = function(l3, u4, c5) {\n                  for (var f4 = l3.length, h3 = new Array(f4), d3 = c5 === void 0 ? s3 : c5, v3 = 0; v3 < f4; ++v3) {\n                    for (var _2 = l3[v3], b = new Array(3), p3 = 0; p3 < 3; ++p3) b[p3] = u4[_2[p3]];\n                    for (var k4 = new Array(3), E3 = new Array(3), p3 = 0; p3 < 3; ++p3) k4[p3] = b[1][p3] - b[0][p3], E3[p3] = b[2][p3] - b[0][p3];\n                    for (var S2 = new Array(3), L3 = 0, p3 = 0; p3 < 3; ++p3) {\n                      var x2 = (p3 + 1) % 3, C3 = (p3 + 2) % 3;\n                      S2[p3] = k4[x2] * E3[C3] - k4[C3] * E3[x2], L3 += S2[p3] * S2[p3];\n                    }\n                    L3 > d3 ? L3 = 1 / Math.sqrt(L3) : L3 = 0;\n                    for (var p3 = 0; p3 < 3; ++p3) S2[p3] *= L3;\n                    h3[v3] = S2;\n                  }\n                  return h3;\n                };\n              }, 8418: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(5219), l3 = o4(2762), u4 = o4(8116), c5 = o4(1888), f4 = o4(6760), h3 = o4(1283), d3 = o4(9366), v3 = o4(5964), _2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], b = ArrayBuffer, p3 = DataView;\n                function k4(Ae) {\n                  return b.isView(Ae) && !(Ae instanceof p3);\n                }\n                function E3(Ae) {\n                  return Array.isArray(Ae) || k4(Ae);\n                }\n                i3.exports = Le;\n                function S2(Ae, Fe) {\n                  var Pe = Ae[0], ge = Ae[1], Re = Ae[2], ce = Ae[3];\n                  return Ae[0] = Fe[0] * Pe + Fe[4] * ge + Fe[8] * Re + Fe[12] * ce, Ae[1] = Fe[1] * Pe + Fe[5] * ge + Fe[9] * Re + Fe[13] * ce, Ae[2] = Fe[2] * Pe + Fe[6] * ge + Fe[10] * Re + Fe[14] * ce, Ae[3] = Fe[3] * Pe + Fe[7] * ge + Fe[11] * Re + Fe[15] * ce, Ae;\n                }\n                function L3(Ae, Fe, Pe, ge) {\n                  return S2(ge, ge, Pe), S2(ge, ge, Fe), S2(ge, ge, Ae);\n                }\n                function x2(Ae, Fe) {\n                  this.index = Ae, this.dataCoordinate = this.position = Fe;\n                }\n                function C3(Ae) {\n                  return Ae === true || Ae > 1 ? 1 : Ae;\n                }\n                function M4(Ae, Fe, Pe, ge, Re, ce, Ze, ut, pt, Zt, st, lt) {\n                  this.gl = Ae, this.pixelRatio = 1, this.shader = Fe, this.orthoShader = Pe, this.projectShader = ge, this.pointBuffer = Re, this.colorBuffer = ce, this.glyphBuffer = Ze, this.idBuffer = ut, this.vao = pt, this.vertexCount = 0, this.lineVertexCount = 0, this.opacity = 1, this.hasAlpha = false, this.lineWidth = 0, this.projectScale = [0.6666666666666666, 0.6666666666666666, 0.6666666666666666], this.projectOpacity = [1, 1, 1], this.projectHasAlpha = false, this.pickId = 0, this.pickPerspectiveShader = Zt, this.pickOrthoShader = st, this.pickProjectShader = lt, this.points = [], this._selectResult = new x2(0, [0, 0, 0]), this.useOrtho = true, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.axesProject = [true, true, true], this.axesBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.highlightId = [1, 1, 1, 1], this.highlightScale = 2, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.dirty = true;\n                }\n                var g3 = M4.prototype;\n                g3.pickSlots = 1, g3.setPickBase = function(Ae) {\n                  this.pickId = Ae;\n                }, g3.isTransparent = function() {\n                  if (this.hasAlpha) return true;\n                  for (var Ae = 0; Ae < 3; ++Ae) if (this.axesProject[Ae] && this.projectHasAlpha) return true;\n                  return false;\n                }, g3.isOpaque = function() {\n                  if (!this.hasAlpha) return true;\n                  for (var Ae = 0; Ae < 3; ++Ae) if (this.axesProject[Ae] && !this.projectHasAlpha) return true;\n                  return false;\n                };\n                var P3 = [0, 0], T3 = [0, 0, 0], z3 = [0, 0, 0], O3 = [0, 0, 0, 1], V2 = [0, 0, 0, 1], G2 = _2.slice(), Z = [0, 0, 0], j3 = [[0, 0, 0], [0, 0, 0]];\n                function N2(Ae) {\n                  return Ae[0] = Ae[1] = Ae[2] = 0, Ae;\n                }\n                function H(Ae, Fe) {\n                  return Ae[0] = Fe[0], Ae[1] = Fe[1], Ae[2] = Fe[2], Ae[3] = 1, Ae;\n                }\n                function te(Ae, Fe, Pe, ge) {\n                  return Ae[0] = Fe[0], Ae[1] = Fe[1], Ae[2] = Fe[2], Ae[Pe] = ge, Ae;\n                }\n                function oe(Ae) {\n                  for (var Fe = j3, Pe = 0; Pe < 2; ++Pe) for (var ge = 0; ge < 3; ++ge) Fe[Pe][ge] = Math.max(Math.min(Ae[Pe][ge], 1e8), -1e8);\n                  return Fe;\n                }\n                function _e(Ae, Fe, Pe, ge) {\n                  var Re = Fe.axesProject, ce = Fe.gl, Ze = Ae.uniforms, ut = Pe.model || _2, pt = Pe.view || _2, Zt = Pe.projection || _2, st = Fe.axesBounds, lt = oe(Fe.clipBounds), Gt;\n                  Fe.axes && Fe.axes.lastCubeProps ? Gt = Fe.axes.lastCubeProps.axis : Gt = [1, 1, 1], P3[0] = 2 / ce.drawingBufferWidth, P3[1] = 2 / ce.drawingBufferHeight, Ae.bind(), Ze.view = pt, Ze.projection = Zt, Ze.screenSize = P3, Ze.highlightId = Fe.highlightId, Ze.highlightScale = Fe.highlightScale, Ze.clipBounds = lt, Ze.pickGroup = Fe.pickId / 255, Ze.pixelRatio = ge;\n                  for (var Nt = 0; Nt < 3; ++Nt) if (Re[Nt]) {\n                    Ze.scale = Fe.projectScale[Nt], Ze.opacity = Fe.projectOpacity[Nt];\n                    for (var Jt = G2, sr = 0; sr < 16; ++sr) Jt[sr] = 0;\n                    for (var sr = 0; sr < 4; ++sr) Jt[5 * sr] = 1;\n                    Jt[5 * Nt] = 0, Gt[Nt] < 0 ? Jt[12 + Nt] = st[0][Nt] : Jt[12 + Nt] = st[1][Nt], f4(Jt, ut, Jt), Ze.model = Jt;\n                    var wr = (Nt + 1) % 3, cr = (Nt + 2) % 3, $e = N2(T3), St = N2(z3);\n                    $e[wr] = 1, St[cr] = 1;\n                    var Qt = L3(Zt, pt, ut, H(O3, $e)), Vt = L3(Zt, pt, ut, H(V2, St));\n                    if (Math.abs(Qt[1]) > Math.abs(Vt[1])) {\n                      var _t = Qt;\n                      Qt = Vt, Vt = _t, _t = $e, $e = St, St = _t;\n                      var It = wr;\n                      wr = cr, cr = It;\n                    }\n                    Qt[0] < 0 && ($e[wr] = -1), Vt[1] > 0 && (St[cr] = -1);\n                    for (var mt = 0, er = 0, sr = 0; sr < 4; ++sr) mt += Math.pow(ut[4 * wr + sr], 2), er += Math.pow(ut[4 * cr + sr], 2);\n                    $e[wr] /= Math.sqrt(mt), St[cr] /= Math.sqrt(er), Ze.axes[0] = $e, Ze.axes[1] = St, Ze.fragClipBounds[0] = te(Z, lt[0], Nt, -1e8), Ze.fragClipBounds[1] = te(Z, lt[1], Nt, 1e8), Fe.vao.bind(), Fe.vao.draw(ce.TRIANGLES, Fe.vertexCount), Fe.lineWidth > 0 && (ce.lineWidth(Fe.lineWidth * ge), Fe.vao.draw(ce.LINES, Fe.lineVertexCount, Fe.vertexCount)), Fe.vao.unbind();\n                  }\n                }\n                var Ee = [-1e8, -1e8, -1e8], Ce = [1e8, 1e8, 1e8], me = [Ee, Ce];\n                function ie(Ae, Fe, Pe, ge, Re, ce, Ze) {\n                  var ut = Pe.gl;\n                  if ((ce === Pe.projectHasAlpha || Ze) && _e(Fe, Pe, ge, Re), ce === Pe.hasAlpha || Ze) {\n                    Ae.bind();\n                    var pt = Ae.uniforms;\n                    pt.model = ge.model || _2, pt.view = ge.view || _2, pt.projection = ge.projection || _2, P3[0] = 2 / ut.drawingBufferWidth, P3[1] = 2 / ut.drawingBufferHeight, pt.screenSize = P3, pt.highlightId = Pe.highlightId, pt.highlightScale = Pe.highlightScale, pt.fragClipBounds = me, pt.clipBounds = Pe.axes.bounds, pt.opacity = Pe.opacity, pt.pickGroup = Pe.pickId / 255, pt.pixelRatio = Re, Pe.vao.bind(), Pe.vao.draw(ut.TRIANGLES, Pe.vertexCount), Pe.lineWidth > 0 && (ut.lineWidth(Pe.lineWidth * Re), Pe.vao.draw(ut.LINES, Pe.lineVertexCount, Pe.vertexCount)), Pe.vao.unbind();\n                  }\n                }\n                g3.draw = function(Ae) {\n                  var Fe = this.useOrtho ? this.orthoShader : this.shader;\n                  ie(Fe, this.projectShader, this, Ae, this.pixelRatio, false, false);\n                }, g3.drawTransparent = function(Ae) {\n                  var Fe = this.useOrtho ? this.orthoShader : this.shader;\n                  ie(Fe, this.projectShader, this, Ae, this.pixelRatio, true, false);\n                }, g3.drawPick = function(Ae) {\n                  var Fe = this.useOrtho ? this.pickOrthoShader : this.pickPerspectiveShader;\n                  ie(Fe, this.pickProjectShader, this, Ae, 1, true, true);\n                }, g3.pick = function(Ae) {\n                  if (!Ae || Ae.id !== this.pickId) return null;\n                  var Fe = Ae.value[2] + (Ae.value[1] << 8) + (Ae.value[0] << 16);\n                  if (Fe >= this.pointCount || Fe < 0) return null;\n                  var Pe = this.points[Fe], ge = this._selectResult;\n                  ge.index = Fe;\n                  for (var Re = 0; Re < 3; ++Re) ge.position[Re] = ge.dataCoordinate[Re] = Pe[Re];\n                  return ge;\n                }, g3.highlight = function(Ae) {\n                  if (!Ae) this.highlightId = [1, 1, 1, 1];\n                  else {\n                    var Fe = Ae.index, Pe = Fe & 255, ge = Fe >> 8 & 255, Re = Fe >> 16 & 255;\n                    this.highlightId = [Pe / 255, ge / 255, Re / 255, 0];\n                  }\n                };\n                function Se(Ae, Fe, Pe, ge) {\n                  var Re;\n                  E3(Ae) ? Fe < Ae.length ? Re = Ae[Fe] : Re = void 0 : Re = Ae, Re = v3(Re);\n                  var ce = true;\n                  s3(Re) && (Re = "\\u25BC", ce = false), Pe || (Pe = {});\n                  var Ze = Pe.family;\n                  E3(Ze) && (Ze = Ze[Fe]), Ze || (Ze = "normal");\n                  var ut = Pe.weight;\n                  E3(ut) && (ut = ut[Fe]), ut || (ut = "normal");\n                  var pt = Pe.style;\n                  E3(pt) && (pt = pt[Fe]), pt || (pt = "normal");\n                  var Zt = Pe.variant;\n                  E3(Zt) && (Zt = Zt[Fe]), Zt || (Zt = "normal");\n                  var st = d3(Re, { family: Ze, weight: ut, style: pt, variant: Zt }, ge), st = d3(Re, Pe, ge);\n                  return { mesh: st[0], lines: st[1], bounds: st[2], visible: ce };\n                }\n                g3.update = function(Ae) {\n                  if (Ae = Ae || {}, "perspective" in Ae && (this.useOrtho = !Ae.perspective), "orthographic" in Ae && (this.useOrtho = !!Ae.orthographic), "lineWidth" in Ae && (this.lineWidth = Ae.lineWidth), "project" in Ae) if (E3(Ae.project)) this.axesProject = Ae.project;\n                  else {\n                    var Fe = !!Ae.project;\n                    this.axesProject = [Fe, Fe, Fe];\n                  }\n                  if ("projectScale" in Ae) if (E3(Ae.projectScale)) this.projectScale = Ae.projectScale.slice();\n                  else {\n                    var Pe = +Ae.projectScale;\n                    this.projectScale = [Pe, Pe, Pe];\n                  }\n                  if (this.projectHasAlpha = false, "projectOpacity" in Ae) {\n                    if (E3(Ae.projectOpacity)) this.projectOpacity = Ae.projectOpacity.slice();\n                    else {\n                      var Pe = +Ae.projectOpacity;\n                      this.projectOpacity = [Pe, Pe, Pe];\n                    }\n                    for (var ge = 0; ge < 3; ++ge) this.projectOpacity[ge] = C3(this.projectOpacity[ge]), this.projectOpacity[ge] < 1 && (this.projectHasAlpha = true);\n                  }\n                  this.hasAlpha = false, "opacity" in Ae && (this.opacity = C3(Ae.opacity), this.opacity < 1 && (this.hasAlpha = true)), this.dirty = true;\n                  var Re = Ae.position, ce = { family: Ae.font || "normal", style: Ae.fontStyle || "normal", weight: Ae.fontWeight || "normal", variant: Ae.fontVariant || "normal" }, Ze = Ae.alignment || [0, 0], ut, pt;\n                  if (Ze.length === 2) ut = Ze[0], pt = Ze[1];\n                  else {\n                    ut = [], pt = [];\n                    for (var ge = 0; ge < Ze.length; ++ge) ut[ge] = Ze[ge][0], pt[ge] = Ze[ge][1];\n                  }\n                  var Zt = [1 / 0, 1 / 0, 1 / 0], st = [-1 / 0, -1 / 0, -1 / 0], lt = Ae.glyph, Gt = Ae.color, Nt = Ae.size, Jt = Ae.angle, sr = Ae.lineColor, wr = -1, cr = 0, $e = 0, St = 0;\n                  if (Re.length) {\n                    St = Re.length;\n                    e: for (var ge = 0; ge < St; ++ge) {\n                      for (var Qt = Re[ge], Vt = 0; Vt < 3; ++Vt) if (isNaN(Qt[Vt]) || !isFinite(Qt[Vt])) continue e;\n                      var _t = Se(lt, ge, ce, this.pixelRatio), It = _t.mesh, mt = _t.lines, er = _t.bounds;\n                      cr += It.cells.length * 3, $e += mt.edges.length * 2;\n                    }\n                  }\n                  var lr = cr + $e, Tr = c5.mallocFloat(3 * lr), Lr = c5.mallocFloat(4 * lr), ti = c5.mallocFloat(2 * lr), Br = c5.mallocUint32(lr);\n                  if (lr > 0) {\n                    var Vr = 0, dt = cr, Ge = [0, 0, 0, 1], Je = [0, 0, 0, 1], je = E3(Gt) && E3(Gt[0]), tt = E3(sr) && E3(sr[0]);\n                    e: for (var ge = 0; ge < St; ++ge) {\n                      wr += 1;\n                      for (var Qt = Re[ge], Vt = 0; Vt < 3; ++Vt) {\n                        if (isNaN(Qt[Vt]) || !isFinite(Qt[Vt])) continue e;\n                        st[Vt] = Math.max(st[Vt], Qt[Vt]), Zt[Vt] = Math.min(Zt[Vt], Qt[Vt]);\n                      }\n                      var _t = Se(lt, ge, ce, this.pixelRatio), It = _t.mesh, mt = _t.lines, er = _t.bounds, xt = _t.visible;\n                      if (!xt) Ge = [1, 1, 1, 0];\n                      else if (E3(Gt)) {\n                        var Ie;\n                        if (je ? ge < Gt.length ? Ie = Gt[ge] : Ie = [0, 0, 0, 0] : Ie = Gt, Ie.length === 3) {\n                          for (var Vt = 0; Vt < 3; ++Vt) Ge[Vt] = Ie[Vt];\n                          Ge[3] = 1;\n                        } else if (Ie.length === 4) {\n                          for (var Vt = 0; Vt < 4; ++Vt) Ge[Vt] = Ie[Vt];\n                          !this.hasAlpha && Ie[3] < 1 && (this.hasAlpha = true);\n                        }\n                      } else Ge[0] = Ge[1] = Ge[2] = 0, Ge[3] = 1;\n                      if (!xt) Je = [1, 1, 1, 0];\n                      else if (E3(sr)) {\n                        var Ie;\n                        if (tt ? ge < sr.length ? Ie = sr[ge] : Ie = [0, 0, 0, 0] : Ie = sr, Ie.length === 3) {\n                          for (var Vt = 0; Vt < 3; ++Vt) Je[Vt] = Ie[Vt];\n                          Je[Vt] = 1;\n                        } else if (Ie.length === 4) {\n                          for (var Vt = 0; Vt < 4; ++Vt) Je[Vt] = Ie[Vt];\n                          !this.hasAlpha && Ie[3] < 1 && (this.hasAlpha = true);\n                        }\n                      } else Je[0] = Je[1] = Je[2] = 0, Je[3] = 1;\n                      var xe = 0.5;\n                      xt ? E3(Nt) ? ge < Nt.length ? xe = +Nt[ge] : xe = 12 : Nt ? xe = +Nt : this.useOrtho && (xe = 12) : xe = 0;\n                      var ke = 0;\n                      E3(Jt) ? ge < Jt.length ? ke = +Jt[ge] : ke = 0 : Jt && (ke = +Jt);\n                      for (var vt = Math.cos(ke), ir = Math.sin(ke), Qt = Re[ge], Vt = 0; Vt < 3; ++Vt) st[Vt] = Math.max(st[Vt], Qt[Vt]), Zt[Vt] = Math.min(Zt[Vt], Qt[Vt]);\n                      var ar = ut, vr = pt, ar = 0;\n                      E3(ut) ? ge < ut.length ? ar = ut[ge] : ar = 0 : ut && (ar = ut);\n                      var vr = 0;\n                      E3(pt) ? ge < pt.length ? vr = pt[ge] : vr = 0 : pt && (vr = pt), ar *= ar > 0 ? 1 - er[0][0] : ar < 0 ? 1 + er[1][0] : 1, vr *= vr > 0 ? 1 - er[0][1] : vr < 0 ? 1 + er[1][1] : 1;\n                      for (var ii = [ar, vr], In = It.cells || [], wi = It.positions || [], Vt = 0; Vt < In.length; ++Vt) for (var pi = In[Vt], $r = 0; $r < 3; ++$r) {\n                        for (var di = 0; di < 3; ++di) Tr[3 * Vr + di] = Qt[di];\n                        for (var di = 0; di < 4; ++di) Lr[4 * Vr + di] = Ge[di];\n                        Br[Vr] = wr;\n                        var ji = wi[pi[$r]];\n                        ti[2 * Vr] = xe * (vt * ji[0] - ir * ji[1] + ii[0]), ti[2 * Vr + 1] = xe * (ir * ji[0] + vt * ji[1] + ii[1]), Vr += 1;\n                      }\n                      for (var In = mt.edges, wi = mt.positions, Vt = 0; Vt < In.length; ++Vt) for (var pi = In[Vt], $r = 0; $r < 2; ++$r) {\n                        for (var di = 0; di < 3; ++di) Tr[3 * dt + di] = Qt[di];\n                        for (var di = 0; di < 4; ++di) Lr[4 * dt + di] = Je[di];\n                        Br[dt] = wr;\n                        var ji = wi[pi[$r]];\n                        ti[2 * dt] = xe * (vt * ji[0] - ir * ji[1] + ii[0]), ti[2 * dt + 1] = xe * (ir * ji[0] + vt * ji[1] + ii[1]), dt += 1;\n                      }\n                    }\n                  }\n                  this.bounds = [Zt, st], this.points = Re, this.pointCount = Re.length, this.vertexCount = cr, this.lineVertexCount = $e, this.pointBuffer.update(Tr), this.colorBuffer.update(Lr), this.glyphBuffer.update(ti), this.idBuffer.update(Br), c5.free(Tr), c5.free(Lr), c5.free(ti), c5.free(Br);\n                }, g3.dispose = function() {\n                  this.shader.dispose(), this.orthoShader.dispose(), this.pickPerspectiveShader.dispose(), this.pickOrthoShader.dispose(), this.vao.dispose(), this.pointBuffer.dispose(), this.colorBuffer.dispose(), this.glyphBuffer.dispose(), this.idBuffer.dispose();\n                };\n                function Le(Ae) {\n                  var Fe = Ae.gl, Pe = h3.createPerspective(Fe), ge = h3.createOrtho(Fe), Re = h3.createProject(Fe), ce = h3.createPickPerspective(Fe), Ze = h3.createPickOrtho(Fe), ut = h3.createPickProject(Fe), pt = l3(Fe), Zt = l3(Fe), st = l3(Fe), lt = l3(Fe), Gt = u4(Fe, [{ buffer: pt, size: 3, type: Fe.FLOAT }, { buffer: Zt, size: 4, type: Fe.FLOAT }, { buffer: st, size: 2, type: Fe.FLOAT }, { buffer: lt, size: 4, type: Fe.UNSIGNED_BYTE, normalized: true }]), Nt = new M4(Fe, Pe, ge, Re, pt, Zt, st, lt, Gt, ce, Ze, ut);\n                  return Nt.update(Ae), Nt;\n                }\n              }, 8489: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  return o4[0] = s3[0] + l3[0] * u4, o4[1] = s3[1] + l3[1] * u4, o4[2] = s3[2] + l3[2] * u4, o4;\n                }\n              }, 8507: function(i3) {\n                i3.exports = s3;\n                var a4 = Math.min;\n                function o4(l3, u4) {\n                  return l3 - u4;\n                }\n                function s3(l3, u4) {\n                  var c5 = l3.length, f4 = l3.length - u4.length;\n                  if (f4) return f4;\n                  switch (c5) {\n                    case 0:\n                      return 0;\n                    case 1:\n                      return l3[0] - u4[0];\n                    case 2:\n                      return l3[0] + l3[1] - u4[0] - u4[1] || a4(l3[0], l3[1]) - a4(u4[0], u4[1]);\n                    case 3:\n                      var h3 = l3[0] + l3[1], d3 = u4[0] + u4[1];\n                      if (f4 = h3 + l3[2] - (d3 + u4[2]), f4) return f4;\n                      var v3 = a4(l3[0], l3[1]), _2 = a4(u4[0], u4[1]);\n                      return a4(v3, l3[2]) - a4(_2, u4[2]) || a4(v3 + l3[2], h3) - a4(_2 + u4[2], d3);\n                    case 4:\n                      var b = l3[0], p3 = l3[1], k4 = l3[2], E3 = l3[3], S2 = u4[0], L3 = u4[1], x2 = u4[2], C3 = u4[3];\n                      return b + p3 + k4 + E3 - (S2 + L3 + x2 + C3) || a4(b, p3, k4, E3) - a4(S2, L3, x2, C3, S2) || a4(b + p3, b + k4, b + E3, p3 + k4, p3 + E3, k4 + E3) - a4(S2 + L3, S2 + x2, S2 + C3, L3 + x2, L3 + C3, x2 + C3) || a4(b + p3 + k4, b + p3 + E3, b + k4 + E3, p3 + k4 + E3) - a4(S2 + L3 + x2, S2 + L3 + C3, S2 + x2 + C3, L3 + x2 + C3);\n                    default:\n                      for (var M4 = l3.slice().sort(o4), g3 = u4.slice().sort(o4), P3 = 0; P3 < c5; ++P3) if (f4 = M4[P3] - g3[P3], f4) return f4;\n                      return 0;\n                  }\n                }\n              }, 8512: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(665);\n                i3.exports = l3;\n                function l3(u4, c5, f4) {\n                  typeof u4 == "function" && (f4 = !!c5, c5 = u4, u4 = window);\n                  var h3 = s3("ex", u4), d3 = function(v3) {\n                    f4 && v3.preventDefault();\n                    var _2 = v3.deltaX || 0, b = v3.deltaY || 0, p3 = v3.deltaZ || 0, k4 = v3.deltaMode, E3 = 1;\n                    switch (k4) {\n                      case 1:\n                        E3 = h3;\n                        break;\n                      case 2:\n                        E3 = window.innerHeight;\n                        break;\n                    }\n                    if (_2 *= E3, b *= E3, p3 *= E3, _2 || b || p3) return c5(_2, b, p3, v3);\n                  };\n                  return u4.addEventListener("wheel", d3), d3;\n                }\n              }, 8545: function(i3) {\n                "use strict";\n                i3.exports = o4;\n                function a4(s3, l3) {\n                  var u4 = s3 + l3, c5 = u4 - s3, f4 = u4 - c5, h3 = l3 - c5, d3 = s3 - f4, v3 = d3 + h3;\n                  return v3 ? [v3, u4] : [u4];\n                }\n                function o4(s3, l3) {\n                  var u4 = s3.length | 0, c5 = l3.length | 0;\n                  if (u4 === 1 && c5 === 1) return a4(s3[0], -l3[0]);\n                  var f4 = u4 + c5, h3 = new Array(f4), d3 = 0, v3 = 0, _2 = 0, b = Math.abs, p3 = s3[v3], k4 = b(p3), E3 = -l3[_2], S2 = b(E3), L3, x2;\n                  k4 < S2 ? (x2 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (x2 = E3, _2 += 1, _2 < c5 && (E3 = -l3[_2], S2 = b(E3))), v3 < u4 && k4 < S2 || _2 >= c5 ? (L3 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (L3 = E3, _2 += 1, _2 < c5 && (E3 = -l3[_2], S2 = b(E3)));\n                  for (var C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, P3 = g3, T3 = C3, z3, O3, V2, G2, Z; v3 < u4 && _2 < c5; ) k4 < S2 ? (L3 = p3, v3 += 1, v3 < u4 && (p3 = s3[v3], k4 = b(p3))) : (L3 = E3, _2 += 1, _2 < c5 && (E3 = -l3[_2], S2 = b(E3))), x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3;\n                  for (; v3 < u4; ) L3 = p3, x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3, v3 += 1, v3 < u4 && (p3 = s3[v3]);\n                  for (; _2 < c5; ) L3 = E3, x2 = P3, C3 = L3 + x2, M4 = C3 - L3, g3 = x2 - M4, g3 && (h3[d3++] = g3), z3 = T3 + C3, O3 = z3 - T3, V2 = z3 - O3, G2 = C3 - O3, Z = T3 - V2, P3 = Z + G2, T3 = z3, _2 += 1, _2 < c5 && (E3 = -l3[_2]);\n                  return P3 && (h3[d3++] = P3), T3 && (h3[d3++] = T3), d3 || (h3[d3++] = 0), h3.length = d3, h3;\n                }\n              }, 8572: function(i3) {\n                "use strict";\n                i3.exports = function(o4) {\n                  return o4 < 0 ? -1 : o4 > 0 ? 1 : 0;\n                };\n              }, 8648: function(i3, a4, o4) {\n                i3.exports = o4(783);\n              }, 8692: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3, u4) {\n                  var c5 = l3[0], f4 = l3[1], h3 = s3[0] - c5, d3 = s3[1] - f4, v3 = Math.sin(u4), _2 = Math.cos(u4);\n                  return o4[0] = c5 + h3 * _2 - d3 * v3, o4[1] = f4 + h3 * v3 + d3 * _2, o4[2] = s3[2], o4;\n                }\n              }, 8697: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(869);\n                i3.exports = l3;\n                function l3(u4, c5) {\n                  return s3(u4[0].mul(c5[1]), u4[1].mul(c5[0]));\n                }\n              }, 8731: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = d3;\n                var s3 = o4(8866);\n                function l3(v3, _2, b, p3, k4, E3) {\n                  this._gl = v3, this._wrapper = _2, this._index = b, this._locations = p3, this._dimension = k4, this._constFunc = E3;\n                }\n                var u4 = l3.prototype;\n                u4.pointer = function(_2, b, p3, k4) {\n                  var E3 = this, S2 = E3._gl, L3 = E3._locations[E3._index];\n                  S2.vertexAttribPointer(L3, E3._dimension, _2 || S2.FLOAT, !!b, p3 || 0, k4 || 0), S2.enableVertexAttribArray(L3);\n                }, u4.set = function(v3, _2, b, p3) {\n                  return this._constFunc(this._locations[this._index], v3, _2, b, p3);\n                }, Object.defineProperty(u4, "location", { get: function() {\n                  return this._locations[this._index];\n                }, set: function(v3) {\n                  return v3 !== this._locations[this._index] && (this._locations[this._index] = v3 | 0, this._wrapper.program = null), v3 | 0;\n                } });\n                var c5 = [function(v3, _2, b) {\n                  return b.length === void 0 ? v3.vertexAttrib1f(_2, b) : v3.vertexAttrib1fv(_2, b);\n                }, function(v3, _2, b, p3) {\n                  return b.length === void 0 ? v3.vertexAttrib2f(_2, b, p3) : v3.vertexAttrib2fv(_2, b);\n                }, function(v3, _2, b, p3, k4) {\n                  return b.length === void 0 ? v3.vertexAttrib3f(_2, b, p3, k4) : v3.vertexAttrib3fv(_2, b);\n                }, function(v3, _2, b, p3, k4, E3) {\n                  return b.length === void 0 ? v3.vertexAttrib4f(_2, b, p3, k4, E3) : v3.vertexAttrib4fv(_2, b);\n                }];\n                function f4(v3, _2, b, p3, k4, E3, S2) {\n                  var L3 = c5[k4], x2 = new l3(v3, _2, b, p3, k4, L3);\n                  Object.defineProperty(E3, S2, { set: function(C3) {\n                    return v3.disableVertexAttribArray(p3[b]), L3(v3, p3[b], C3), C3;\n                  }, get: function() {\n                    return x2;\n                  }, enumerable: true });\n                }\n                function h3(v3, _2, b, p3, k4, E3, S2) {\n                  for (var L3 = new Array(k4), x2 = new Array(k4), C3 = 0; C3 < k4; ++C3) f4(v3, _2, b[C3], p3, k4, L3, C3), x2[C3] = L3[C3];\n                  Object.defineProperty(L3, "location", { set: function(P3) {\n                    if (Array.isArray(P3)) for (var T3 = 0; T3 < k4; ++T3) x2[T3].location = P3[T3];\n                    else for (var T3 = 0; T3 < k4; ++T3) x2[T3].location = P3 + T3;\n                    return P3;\n                  }, get: function() {\n                    for (var P3 = new Array(k4), T3 = 0; T3 < k4; ++T3) P3[T3] = p3[b[T3]];\n                    return P3;\n                  }, enumerable: true }), L3.pointer = function(P3, T3, z3, O3) {\n                    P3 = P3 || v3.FLOAT, T3 = !!T3, z3 = z3 || k4 * k4, O3 = O3 || 0;\n                    for (var V2 = 0; V2 < k4; ++V2) {\n                      var G2 = p3[b[V2]];\n                      v3.vertexAttribPointer(G2, k4, P3, T3, z3, O3 + V2 * k4), v3.enableVertexAttribArray(G2);\n                    }\n                  };\n                  var M4 = new Array(k4), g3 = v3["vertexAttrib" + k4 + "fv"];\n                  Object.defineProperty(E3, S2, { set: function(P3) {\n                    for (var T3 = 0; T3 < k4; ++T3) {\n                      var z3 = p3[b[T3]];\n                      if (v3.disableVertexAttribArray(z3), Array.isArray(P3[0])) g3.call(v3, z3, P3[T3]);\n                      else {\n                        for (var O3 = 0; O3 < k4; ++O3) M4[O3] = P3[k4 * T3 + O3];\n                        g3.call(v3, z3, M4);\n                      }\n                    }\n                    return P3;\n                  }, get: function() {\n                    return L3;\n                  }, enumerable: true });\n                }\n                function d3(v3, _2, b, p3) {\n                  for (var k4 = {}, E3 = 0, S2 = b.length; E3 < S2; ++E3) {\n                    var L3 = b[E3], x2 = L3.name, C3 = L3.type, M4 = L3.locations;\n                    switch (C3) {\n                      case "bool":\n                      case "int":\n                      case "float":\n                        f4(v3, _2, M4[0], p3, 1, k4, x2);\n                        break;\n                      default:\n                        if (C3.indexOf("vec") >= 0) {\n                          var g3 = C3.charCodeAt(C3.length - 1) - 48;\n                          if (g3 < 2 || g3 > 4) throw new s3("", "Invalid data type for attribute " + x2 + ": " + C3);\n                          f4(v3, _2, M4[0], p3, g3, k4, x2);\n                        } else if (C3.indexOf("mat") >= 0) {\n                          var g3 = C3.charCodeAt(C3.length - 1) - 48;\n                          if (g3 < 2 || g3 > 4) throw new s3("", "Invalid data type for attribute " + x2 + ": " + C3);\n                          h3(v3, _2, M4, p3, g3, k4, x2);\n                        } else throw new s3("", "Unknown data type for attribute " + x2 + ": " + C3);\n                        break;\n                    }\n                  }\n                  return k4;\n                }\n              }, 8828: function(i3, a4) {\n                "use strict";\n                "use restrict";\n                var o4 = 32;\n                a4.INT_BITS = o4, a4.INT_MAX = 2147483647, a4.INT_MIN = -1 << o4 - 1, a4.sign = function(u4) {\n                  return (u4 > 0) - (u4 < 0);\n                }, a4.abs = function(u4) {\n                  var c5 = u4 >> o4 - 1;\n                  return (u4 ^ c5) - c5;\n                }, a4.min = function(u4, c5) {\n                  return c5 ^ (u4 ^ c5) & -(u4 < c5);\n                }, a4.max = function(u4, c5) {\n                  return u4 ^ (u4 ^ c5) & -(u4 < c5);\n                }, a4.isPow2 = function(u4) {\n                  return !(u4 & u4 - 1) && !!u4;\n                }, a4.log2 = function(u4) {\n                  var c5, f4;\n                  return c5 = (u4 > 65535) << 4, u4 >>>= c5, f4 = (u4 > 255) << 3, u4 >>>= f4, c5 |= f4, f4 = (u4 > 15) << 2, u4 >>>= f4, c5 |= f4, f4 = (u4 > 3) << 1, u4 >>>= f4, c5 |= f4, c5 | u4 >> 1;\n                }, a4.log10 = function(u4) {\n                  return u4 >= 1e9 ? 9 : u4 >= 1e8 ? 8 : u4 >= 1e7 ? 7 : u4 >= 1e6 ? 6 : u4 >= 1e5 ? 5 : u4 >= 1e4 ? 4 : u4 >= 1e3 ? 3 : u4 >= 100 ? 2 : u4 >= 10 ? 1 : 0;\n                }, a4.popCount = function(u4) {\n                  return u4 = u4 - (u4 >>> 1 & 1431655765), u4 = (u4 & 858993459) + (u4 >>> 2 & 858993459), (u4 + (u4 >>> 4) & 252645135) * 16843009 >>> 24;\n                };\n                function s3(u4) {\n                  var c5 = 32;\n                  return u4 &= -u4, u4 && c5--, u4 & 65535 && (c5 -= 16), u4 & 16711935 && (c5 -= 8), u4 & 252645135 && (c5 -= 4), u4 & 858993459 && (c5 -= 2), u4 & 1431655765 && (c5 -= 1), c5;\n                }\n                a4.countTrailingZeros = s3, a4.nextPow2 = function(u4) {\n                  return u4 += u4 === 0, --u4, u4 |= u4 >>> 1, u4 |= u4 >>> 2, u4 |= u4 >>> 4, u4 |= u4 >>> 8, u4 |= u4 >>> 16, u4 + 1;\n                }, a4.prevPow2 = function(u4) {\n                  return u4 |= u4 >>> 1, u4 |= u4 >>> 2, u4 |= u4 >>> 4, u4 |= u4 >>> 8, u4 |= u4 >>> 16, u4 - (u4 >>> 1);\n                }, a4.parity = function(u4) {\n                  return u4 ^= u4 >>> 16, u4 ^= u4 >>> 8, u4 ^= u4 >>> 4, u4 &= 15, 27030 >>> u4 & 1;\n                };\n                var l3 = new Array(256);\n                (function(u4) {\n                  for (var c5 = 0; c5 < 256; ++c5) {\n                    var f4 = c5, h3 = c5, d3 = 7;\n                    for (f4 >>>= 1; f4; f4 >>>= 1) h3 <<= 1, h3 |= f4 & 1, --d3;\n                    u4[c5] = h3 << d3 & 255;\n                  }\n                })(l3), a4.reverse = function(u4) {\n                  return l3[u4 & 255] << 24 | l3[u4 >>> 8 & 255] << 16 | l3[u4 >>> 16 & 255] << 8 | l3[u4 >>> 24 & 255];\n                }, a4.interleave2 = function(u4, c5) {\n                  return u4 &= 65535, u4 = (u4 | u4 << 8) & 16711935, u4 = (u4 | u4 << 4) & 252645135, u4 = (u4 | u4 << 2) & 858993459, u4 = (u4 | u4 << 1) & 1431655765, c5 &= 65535, c5 = (c5 | c5 << 8) & 16711935, c5 = (c5 | c5 << 4) & 252645135, c5 = (c5 | c5 << 2) & 858993459, c5 = (c5 | c5 << 1) & 1431655765, u4 | c5 << 1;\n                }, a4.deinterleave2 = function(u4, c5) {\n                  return u4 = u4 >>> c5 & 1431655765, u4 = (u4 | u4 >>> 1) & 858993459, u4 = (u4 | u4 >>> 2) & 252645135, u4 = (u4 | u4 >>> 4) & 16711935, u4 = (u4 | u4 >>> 16) & 65535, u4 << 16 >> 16;\n                }, a4.interleave3 = function(u4, c5, f4) {\n                  return u4 &= 1023, u4 = (u4 | u4 << 16) & 4278190335, u4 = (u4 | u4 << 8) & 251719695, u4 = (u4 | u4 << 4) & 3272356035, u4 = (u4 | u4 << 2) & 1227133513, c5 &= 1023, c5 = (c5 | c5 << 16) & 4278190335, c5 = (c5 | c5 << 8) & 251719695, c5 = (c5 | c5 << 4) & 3272356035, c5 = (c5 | c5 << 2) & 1227133513, u4 |= c5 << 1, f4 &= 1023, f4 = (f4 | f4 << 16) & 4278190335, f4 = (f4 | f4 << 8) & 251719695, f4 = (f4 | f4 << 4) & 3272356035, f4 = (f4 | f4 << 2) & 1227133513, u4 | f4 << 2;\n                }, a4.deinterleave3 = function(u4, c5) {\n                  return u4 = u4 >>> c5 & 1227133513, u4 = (u4 | u4 >>> 2) & 3272356035, u4 = (u4 | u4 >>> 4) & 251719695, u4 = (u4 | u4 >>> 8) & 4278190335, u4 = (u4 | u4 >>> 16) & 1023, u4 << 22 >> 22;\n                }, a4.nextCombination = function(u4) {\n                  var c5 = u4 | u4 - 1;\n                  return c5 + 1 | (~c5 & -~c5) - 1 >>> s3(u4) + 1;\n                };\n              }, 8866: function(i3) {\n                function a4(o4, s3, l3) {\n                  this.shortMessage = s3 || "", this.longMessage = l3 || "", this.rawError = o4 || "", this.message = "gl-shader: " + (s3 || o4 || "") + (l3 ? `\n` + l3 : ""), this.stack = new Error().stack;\n                }\n                a4.prototype = new Error(), a4.prototype.name = "GLError", a4.prototype.constructor = a4, i3.exports = a4;\n              }, 8902: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(2478), l3 = o4(3250)[3], u4 = 0, c5 = 1, f4 = 2;\n                i3.exports = S2;\n                function h3(L3, x2, C3, M4, g3) {\n                  this.a = L3, this.b = x2, this.idx = C3, this.lowerIds = M4, this.upperIds = g3;\n                }\n                function d3(L3, x2, C3, M4) {\n                  this.a = L3, this.b = x2, this.type = C3, this.idx = M4;\n                }\n                function v3(L3, x2) {\n                  var C3 = L3.a[0] - x2.a[0] || L3.a[1] - x2.a[1] || L3.type - x2.type;\n                  return C3 || L3.type !== u4 && (C3 = l3(L3.a, L3.b, x2.b), C3) ? C3 : L3.idx - x2.idx;\n                }\n                function _2(L3, x2) {\n                  return l3(L3.a, L3.b, x2);\n                }\n                function b(L3, x2, C3, M4, g3) {\n                  for (var P3 = s3.lt(x2, M4, _2), T3 = s3.gt(x2, M4, _2), z3 = P3; z3 < T3; ++z3) {\n                    for (var O3 = x2[z3], V2 = O3.lowerIds, Z = V2.length; Z > 1 && l3(C3[V2[Z - 2]], C3[V2[Z - 1]], M4) > 0; ) L3.push([V2[Z - 1], V2[Z - 2], g3]), Z -= 1;\n                    V2.length = Z, V2.push(g3);\n                    for (var G2 = O3.upperIds, Z = G2.length; Z > 1 && l3(C3[G2[Z - 2]], C3[G2[Z - 1]], M4) < 0; ) L3.push([G2[Z - 2], G2[Z - 1], g3]), Z -= 1;\n                    G2.length = Z, G2.push(g3);\n                  }\n                }\n                function p3(L3, x2) {\n                  var C3;\n                  return L3.a[0] < x2.a[0] ? C3 = l3(L3.a, L3.b, x2.a) : C3 = l3(x2.b, x2.a, L3.a), C3 || (x2.b[0] < L3.b[0] ? C3 = l3(L3.a, L3.b, x2.b) : C3 = l3(x2.b, x2.a, L3.b), C3 || L3.idx - x2.idx);\n                }\n                function k4(L3, x2, C3) {\n                  var M4 = s3.le(L3, C3, p3), g3 = L3[M4], P3 = g3.upperIds, T3 = P3[P3.length - 1];\n                  g3.upperIds = [T3], L3.splice(M4 + 1, 0, new h3(C3.a, C3.b, C3.idx, [T3], P3));\n                }\n                function E3(L3, x2, C3) {\n                  var M4 = C3.a;\n                  C3.a = C3.b, C3.b = M4;\n                  var g3 = s3.eq(L3, C3, p3), P3 = L3[g3], T3 = L3[g3 - 1];\n                  T3.upperIds = P3.upperIds, L3.splice(g3, 1);\n                }\n                function S2(L3, x2) {\n                  for (var C3 = L3.length, M4 = x2.length, g3 = [], P3 = 0; P3 < C3; ++P3) g3.push(new d3(L3[P3], null, u4, P3));\n                  for (var P3 = 0; P3 < M4; ++P3) {\n                    var T3 = x2[P3], z3 = L3[T3[0]], O3 = L3[T3[1]];\n                    z3[0] < O3[0] ? g3.push(new d3(z3, O3, f4, P3), new d3(O3, z3, c5, P3)) : z3[0] > O3[0] && g3.push(new d3(O3, z3, f4, P3), new d3(z3, O3, c5, P3));\n                  }\n                  g3.sort(v3);\n                  for (var V2 = g3[0].a[0] - (1 + Math.abs(g3[0].a[0])) * Math.pow(2, -52), G2 = [new h3([V2, 1], [V2, 0], -1, [], [], [], [])], Z = [], P3 = 0, j3 = g3.length; P3 < j3; ++P3) {\n                    var N2 = g3[P3], H = N2.type;\n                    H === u4 ? b(Z, G2, L3, N2.a, N2.idx) : H === f4 ? k4(G2, L3, N2) : E3(G2, L3, N2);\n                  }\n                  return Z;\n                }\n              }, 8954: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = p3;\n                var s3 = o4(3250), l3 = o4(6803).Fw;\n                function u4(k4, E3, S2) {\n                  this.vertices = k4, this.adjacent = E3, this.boundary = S2, this.lastVisited = -1;\n                }\n                u4.prototype.flip = function() {\n                  var k4 = this.vertices[0];\n                  this.vertices[0] = this.vertices[1], this.vertices[1] = k4;\n                  var E3 = this.adjacent[0];\n                  this.adjacent[0] = this.adjacent[1], this.adjacent[1] = E3;\n                };\n                function c5(k4, E3, S2) {\n                  this.vertices = k4, this.cell = E3, this.index = S2;\n                }\n                function f4(k4, E3) {\n                  return l3(k4.vertices, E3.vertices);\n                }\n                function h3(k4) {\n                  return function() {\n                    var E3 = this.tuple;\n                    return k4.apply(this, E3);\n                  };\n                }\n                function d3(k4) {\n                  var E3 = s3[k4 + 1];\n                  return E3 || (E3 = s3), h3(E3);\n                }\n                var v3 = [];\n                function _2(k4, E3, S2) {\n                  this.dimension = k4, this.vertices = E3, this.simplices = S2, this.interior = S2.filter(function(C3) {\n                    return !C3.boundary;\n                  }), this.tuple = new Array(k4 + 1);\n                  for (var L3 = 0; L3 <= k4; ++L3) this.tuple[L3] = this.vertices[L3];\n                  var x2 = v3[k4];\n                  x2 || (x2 = v3[k4] = d3(k4)), this.orient = x2;\n                }\n                var b = _2.prototype;\n                b.handleBoundaryDegeneracy = function(k4, E3) {\n                  var S2 = this.dimension, L3 = this.vertices.length - 1, x2 = this.tuple, C3 = this.vertices, M4 = [k4];\n                  for (k4.lastVisited = -L3; M4.length > 0; ) {\n                    k4 = M4.pop();\n                    for (var g3 = k4.adjacent, P3 = 0; P3 <= S2; ++P3) {\n                      var T3 = g3[P3];\n                      if (!(!T3.boundary || T3.lastVisited <= -L3)) {\n                        for (var z3 = T3.vertices, O3 = 0; O3 <= S2; ++O3) {\n                          var V2 = z3[O3];\n                          V2 < 0 ? x2[O3] = E3 : x2[O3] = C3[V2];\n                        }\n                        var G2 = this.orient();\n                        if (G2 > 0) return T3;\n                        T3.lastVisited = -L3, G2 === 0 && M4.push(T3);\n                      }\n                    }\n                  }\n                  return null;\n                }, b.walk = function(k4, E3) {\n                  var S2 = this.vertices.length - 1, L3 = this.dimension, x2 = this.vertices, C3 = this.tuple, M4 = E3 ? this.interior.length * Math.random() | 0 : this.interior.length - 1, g3 = this.interior[M4];\n                  e: for (; !g3.boundary; ) {\n                    for (var P3 = g3.vertices, T3 = g3.adjacent, z3 = 0; z3 <= L3; ++z3) C3[z3] = x2[P3[z3]];\n                    g3.lastVisited = S2;\n                    for (var z3 = 0; z3 <= L3; ++z3) {\n                      var O3 = T3[z3];\n                      if (!(O3.lastVisited >= S2)) {\n                        var V2 = C3[z3];\n                        C3[z3] = k4;\n                        var G2 = this.orient();\n                        if (C3[z3] = V2, G2 < 0) {\n                          g3 = O3;\n                          continue e;\n                        } else O3.boundary ? O3.lastVisited = -S2 : O3.lastVisited = S2;\n                      }\n                    }\n                    return;\n                  }\n                  return g3;\n                }, b.addPeaks = function(k4, E3) {\n                  var S2 = this.vertices.length - 1, L3 = this.dimension, x2 = this.vertices, C3 = this.tuple, M4 = this.interior, g3 = this.simplices, P3 = [E3];\n                  E3.lastVisited = S2, E3.vertices[E3.vertices.indexOf(-1)] = S2, E3.boundary = false, M4.push(E3);\n                  for (var T3 = []; P3.length > 0; ) {\n                    var E3 = P3.pop(), z3 = E3.vertices, O3 = E3.adjacent, V2 = z3.indexOf(S2);\n                    if (!(V2 < 0)) {\n                      for (var G2 = 0; G2 <= L3; ++G2) if (G2 !== V2) {\n                        var Z = O3[G2];\n                        if (!(!Z.boundary || Z.lastVisited >= S2)) {\n                          var j3 = Z.vertices;\n                          if (Z.lastVisited !== -S2) {\n                            for (var N2 = 0, H = 0; H <= L3; ++H) j3[H] < 0 ? (N2 = H, C3[H] = k4) : C3[H] = x2[j3[H]];\n                            var te = this.orient();\n                            if (te > 0) {\n                              j3[N2] = S2, Z.boundary = false, M4.push(Z), P3.push(Z), Z.lastVisited = S2;\n                              continue;\n                            } else Z.lastVisited = -S2;\n                          }\n                          var oe = Z.adjacent, _e = z3.slice(), Ee = O3.slice(), Ce = new u4(_e, Ee, true);\n                          g3.push(Ce);\n                          var me = oe.indexOf(E3);\n                          if (!(me < 0)) {\n                            oe[me] = Ce, Ee[V2] = Z, _e[G2] = -1, Ee[G2] = E3, O3[G2] = Ce, Ce.flip();\n                            for (var H = 0; H <= L3; ++H) {\n                              var ie = _e[H];\n                              if (!(ie < 0 || ie === S2)) {\n                                for (var Se = new Array(L3 - 1), Le = 0, Ae = 0; Ae <= L3; ++Ae) {\n                                  var Fe = _e[Ae];\n                                  Fe < 0 || Ae === H || (Se[Le++] = Fe);\n                                }\n                                T3.push(new c5(Se, Ce, H));\n                              }\n                            }\n                          }\n                        }\n                      }\n                    }\n                  }\n                  T3.sort(f4);\n                  for (var G2 = 0; G2 + 1 < T3.length; G2 += 2) {\n                    var Pe = T3[G2], ge = T3[G2 + 1], Re = Pe.index, ce = ge.index;\n                    Re < 0 || ce < 0 || (Pe.cell.adjacent[Pe.index] = ge.cell, ge.cell.adjacent[ge.index] = Pe.cell);\n                  }\n                }, b.insert = function(k4, E3) {\n                  var S2 = this.vertices;\n                  S2.push(k4);\n                  var L3 = this.walk(k4, E3);\n                  if (L3) {\n                    for (var x2 = this.dimension, C3 = this.tuple, M4 = 0; M4 <= x2; ++M4) {\n                      var g3 = L3.vertices[M4];\n                      g3 < 0 ? C3[M4] = k4 : C3[M4] = S2[g3];\n                    }\n                    var P3 = this.orient(C3);\n                    P3 < 0 || P3 === 0 && (L3 = this.handleBoundaryDegeneracy(L3, k4), !L3) || this.addPeaks(k4, L3);\n                  }\n                }, b.boundary = function() {\n                  for (var k4 = this.dimension, E3 = [], S2 = this.simplices, L3 = S2.length, x2 = 0; x2 < L3; ++x2) {\n                    var C3 = S2[x2];\n                    if (C3.boundary) {\n                      for (var M4 = new Array(k4), g3 = C3.vertices, P3 = 0, T3 = 0, z3 = 0; z3 <= k4; ++z3) g3[z3] >= 0 ? M4[P3++] = g3[z3] : T3 = z3 & 1;\n                      if (T3 === (k4 & 1)) {\n                        var O3 = M4[0];\n                        M4[0] = M4[1], M4[1] = O3;\n                      }\n                      E3.push(M4);\n                    }\n                  }\n                  return E3;\n                };\n                function p3(k4, E3) {\n                  var S2 = k4.length;\n                  if (S2 === 0) throw new Error("Must have at least d+1 points");\n                  var L3 = k4[0].length;\n                  if (S2 <= L3) throw new Error("Must input at least d+1 points");\n                  var x2 = k4.slice(0, L3 + 1), C3 = s3.apply(void 0, x2);\n                  if (C3 === 0) throw new Error("Input not in general position");\n                  for (var M4 = new Array(L3 + 1), g3 = 0; g3 <= L3; ++g3) M4[g3] = g3;\n                  C3 < 0 && (M4[0] = 1, M4[1] = 0);\n                  for (var P3 = new u4(M4, new Array(L3 + 1), false), T3 = P3.adjacent, z3 = new Array(L3 + 2), g3 = 0; g3 <= L3; ++g3) {\n                    for (var O3 = M4.slice(), V2 = 0; V2 <= L3; ++V2) V2 === g3 && (O3[V2] = -1);\n                    var G2 = O3[0];\n                    O3[0] = O3[1], O3[1] = G2;\n                    var Z = new u4(O3, new Array(L3 + 1), true);\n                    T3[g3] = Z, z3[g3] = Z;\n                  }\n                  z3[L3 + 1] = P3;\n                  for (var g3 = 0; g3 <= L3; ++g3) for (var O3 = T3[g3].vertices, j3 = T3[g3].adjacent, V2 = 0; V2 <= L3; ++V2) {\n                    var N2 = O3[V2];\n                    if (N2 < 0) {\n                      j3[V2] = P3;\n                      continue;\n                    }\n                    for (var H = 0; H <= L3; ++H) T3[H].vertices.indexOf(N2) < 0 && (j3[V2] = T3[H]);\n                  }\n                  for (var te = new _2(L3, x2, z3), oe = !!E3, g3 = L3 + 1; g3 < S2; ++g3) te.insert(k4[g3], oe);\n                  return te.boundary();\n                }\n              }, 8987: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(7842), l3 = o4(6504);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  for (var h3 = s3(f4), d3 = c5.length, v3 = new Array(d3), _2 = 0; _2 < d3; ++_2) v3[_2] = l3(c5[_2], h3);\n                  return v3;\n                }\n              }, 9060: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(9405), l3 = o4(2762), u4 = o4(8116), c5 = o4(7766), f4 = o4(6760), h3 = o4(7608), d3 = o4(9618), v3 = o4(6729), _2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                function b(C3, M4, g3, P3, T3, z3, O3, V2, G2, Z, j3) {\n                  this.gl = C3, this.pixelRatio = 1, this.cells = [], this.positions = [], this.intensity = [], this.texture = M4, this.dirty = true, this.triShader = g3, this.pickShader = P3, this.trianglePositions = T3, this.triangleVectors = z3, this.triangleColors = V2, this.triangleUVs = G2, this.triangleIds = O3, this.triangleVAO = Z, this.triangleCount = 0, this.pickId = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lightPosition = [1e5, 1e5, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.opacity = 1, this.traceType = j3, this.tubeScale = 1, this.coneScale = 2, this.vectorScale = 1, this.coneOffset = 0.25, this._model = _2, this._view = _2, this._projection = _2, this._resolution = [1, 1];\n                }\n                var p3 = b.prototype;\n                p3.isOpaque = function() {\n                  return this.opacity >= 1;\n                }, p3.isTransparent = function() {\n                  return this.opacity < 1;\n                }, p3.pickSlots = 1, p3.setPickBase = function(C3) {\n                  this.pickId = C3;\n                };\n                function k4(C3) {\n                  for (var M4 = v3({ colormap: C3, nshades: 256, format: "rgba" }), g3 = new Uint8Array(256 * 4), P3 = 0; P3 < 256; ++P3) {\n                    for (var T3 = M4[P3], z3 = 0; z3 < 3; ++z3) g3[4 * P3 + z3] = T3[z3];\n                    g3[4 * P3 + 3] = T3[3] * 255;\n                  }\n                  return d3(g3, [256, 256, 4], [4, 0, 1]);\n                }\n                function E3(C3) {\n                  for (var M4 = C3.length, g3 = new Array(M4), P3 = 0; P3 < M4; ++P3) g3[P3] = C3[P3][2];\n                  return g3;\n                }\n                p3.update = function(C3) {\n                  C3 = C3 || {};\n                  var M4 = this.gl;\n                  this.dirty = true, "lightPosition" in C3 && (this.lightPosition = C3.lightPosition), "opacity" in C3 && (this.opacity = C3.opacity), "ambient" in C3 && (this.ambientLight = C3.ambient), "diffuse" in C3 && (this.diffuseLight = C3.diffuse), "specular" in C3 && (this.specularLight = C3.specular), "roughness" in C3 && (this.roughness = C3.roughness), "fresnel" in C3 && (this.fresnel = C3.fresnel), C3.tubeScale !== void 0 && (this.tubeScale = C3.tubeScale), C3.vectorScale !== void 0 && (this.vectorScale = C3.vectorScale), C3.coneScale !== void 0 && (this.coneScale = C3.coneScale), C3.coneOffset !== void 0 && (this.coneOffset = C3.coneOffset), C3.colormap && (this.texture.shape = [256, 256], this.texture.minFilter = M4.LINEAR_MIPMAP_LINEAR, this.texture.magFilter = M4.LINEAR, this.texture.setPixels(k4(C3.colormap)), this.texture.generateMipmap());\n                  var g3 = C3.cells, P3 = C3.positions, T3 = C3.vectors;\n                  if (!(!P3 || !g3 || !T3)) {\n                    var z3 = [], O3 = [], V2 = [], G2 = [], Z = [];\n                    this.cells = g3, this.positions = P3, this.vectors = T3;\n                    var j3 = C3.meshColor || [1, 1, 1, 1], N2 = C3.vertexIntensity, H = 1 / 0, te = -1 / 0;\n                    if (N2) if (C3.vertexIntensityBounds) H = +C3.vertexIntensityBounds[0], te = +C3.vertexIntensityBounds[1];\n                    else for (var oe = 0; oe < N2.length; ++oe) {\n                      var _e = N2[oe];\n                      H = Math.min(H, _e), te = Math.max(te, _e);\n                    }\n                    else for (var oe = 0; oe < P3.length; ++oe) {\n                      var _e = P3[oe][2];\n                      H = Math.min(H, _e), te = Math.max(te, _e);\n                    }\n                    N2 ? this.intensity = N2 : this.intensity = E3(P3), this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];\n                    for (var oe = 0; oe < P3.length; ++oe) for (var Ee = P3[oe], Ce = 0; Ce < 3; ++Ce) isNaN(Ee[Ce]) || !isFinite(Ee[Ce]) || (this.bounds[0][Ce] = Math.min(this.bounds[0][Ce], Ee[Ce]), this.bounds[1][Ce] = Math.max(this.bounds[1][Ce], Ee[Ce]));\n                    var me = 0;\n                    e: for (var oe = 0; oe < g3.length; ++oe) {\n                      var ie = g3[oe];\n                      switch (ie.length) {\n                        case 3:\n                          for (var Ce = 0; Ce < 3; ++Ce) for (var Se = ie[Ce], Ee = P3[Se], Le = 0; Le < 3; ++Le) if (isNaN(Ee[Le]) || !isFinite(Ee[Le])) continue e;\n                          for (var Ce = 0; Ce < 3; ++Ce) {\n                            var Se = ie[2 - Ce], Ee = P3[Se];\n                            z3.push(Ee[0], Ee[1], Ee[2], Ee[3]);\n                            var Ae = T3[Se];\n                            O3.push(Ae[0], Ae[1], Ae[2], Ae[3] || 0);\n                            var Fe = j3;\n                            Fe.length === 3 ? V2.push(Fe[0], Fe[1], Fe[2], 1) : V2.push(Fe[0], Fe[1], Fe[2], Fe[3]);\n                            var Pe;\n                            N2 ? Pe = [(N2[Se] - H) / (te - H), 0] : Pe = [(Ee[2] - H) / (te - H), 0], G2.push(Pe[0], Pe[1]), Z.push(oe);\n                          }\n                          me += 1;\n                          break;\n                        default:\n                          break;\n                      }\n                    }\n                    this.triangleCount = me, this.trianglePositions.update(z3), this.triangleVectors.update(O3), this.triangleColors.update(V2), this.triangleUVs.update(G2), this.triangleIds.update(new Uint32Array(Z));\n                  }\n                }, p3.drawTransparent = p3.draw = function(C3) {\n                  C3 = C3 || {};\n                  for (var M4 = this.gl, g3 = C3.model || _2, P3 = C3.view || _2, T3 = C3.projection || _2, z3 = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], O3 = 0; O3 < 3; ++O3) z3[0][O3] = Math.max(z3[0][O3], this.clipBounds[0][O3]), z3[1][O3] = Math.min(z3[1][O3], this.clipBounds[1][O3]);\n                  var V2 = { model: g3, view: P3, projection: T3, inverseModel: _2.slice(), clipBounds: z3, kambient: this.ambientLight, kdiffuse: this.diffuseLight, kspecular: this.specularLight, roughness: this.roughness, fresnel: this.fresnel, eyePosition: [0, 0, 0], lightPosition: [0, 0, 0], opacity: this.opacity, tubeScale: this.tubeScale, vectorScale: this.vectorScale, coneScale: this.coneScale, coneOffset: this.coneOffset, texture: 0 };\n                  V2.inverseModel = h3(V2.inverseModel, V2.model), M4.disable(M4.CULL_FACE), this.texture.bind(0);\n                  var G2 = new Array(16);\n                  f4(G2, V2.view, V2.model), f4(G2, V2.projection, G2), h3(G2, G2);\n                  for (var O3 = 0; O3 < 3; ++O3) V2.eyePosition[O3] = G2[12 + O3] / G2[15];\n                  for (var Z = G2[15], O3 = 0; O3 < 3; ++O3) Z += this.lightPosition[O3] * G2[4 * O3 + 3];\n                  for (var O3 = 0; O3 < 3; ++O3) {\n                    for (var j3 = G2[12 + O3], N2 = 0; N2 < 3; ++N2) j3 += G2[4 * N2 + O3] * this.lightPosition[N2];\n                    V2.lightPosition[O3] = j3 / Z;\n                  }\n                  if (this.triangleCount > 0) {\n                    var H = this.triShader;\n                    H.bind(), H.uniforms = V2, this.triangleVAO.bind(), M4.drawArrays(M4.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind();\n                  }\n                }, p3.drawPick = function(C3) {\n                  C3 = C3 || {};\n                  for (var M4 = this.gl, g3 = C3.model || _2, P3 = C3.view || _2, T3 = C3.projection || _2, z3 = [[-1e6, -1e6, -1e6], [1e6, 1e6, 1e6]], O3 = 0; O3 < 3; ++O3) z3[0][O3] = Math.max(z3[0][O3], this.clipBounds[0][O3]), z3[1][O3] = Math.min(z3[1][O3], this.clipBounds[1][O3]);\n                  this._model = [].slice.call(g3), this._view = [].slice.call(P3), this._projection = [].slice.call(T3), this._resolution = [M4.drawingBufferWidth, M4.drawingBufferHeight];\n                  var V2 = { model: g3, view: P3, projection: T3, clipBounds: z3, tubeScale: this.tubeScale, vectorScale: this.vectorScale, coneScale: this.coneScale, coneOffset: this.coneOffset, pickId: this.pickId / 255 }, G2 = this.pickShader;\n                  G2.bind(), G2.uniforms = V2, this.triangleCount > 0 && (this.triangleVAO.bind(), M4.drawArrays(M4.TRIANGLES, 0, this.triangleCount * 3), this.triangleVAO.unbind());\n                }, p3.pick = function(C3) {\n                  if (!C3 || C3.id !== this.pickId) return null;\n                  var M4 = C3.value[0] + 256 * C3.value[1] + 65536 * C3.value[2], g3 = this.cells[M4], P3 = this.positions[g3[1]].slice(0, 3), T3 = { position: P3, dataCoordinate: P3, index: Math.floor(g3[1] / 48) };\n                  return this.traceType === "cone" ? T3.index = Math.floor(g3[1] / 48) : this.traceType === "streamtube" && (T3.intensity = this.intensity[g3[1]], T3.velocity = this.vectors[g3[1]].slice(0, 3), T3.divergence = this.vectors[g3[1]][3], T3.index = M4), T3;\n                }, p3.dispose = function() {\n                  this.texture.dispose(), this.triShader.dispose(), this.pickShader.dispose(), this.triangleVAO.dispose(), this.trianglePositions.dispose(), this.triangleVectors.dispose(), this.triangleColors.dispose(), this.triangleUVs.dispose(), this.triangleIds.dispose();\n                };\n                function S2(C3, M4) {\n                  var g3 = s3(C3, M4.meshShader.vertex, M4.meshShader.fragment, null, M4.meshShader.attributes);\n                  return g3.attributes.position.location = 0, g3.attributes.color.location = 2, g3.attributes.uv.location = 3, g3.attributes.vector.location = 4, g3;\n                }\n                function L3(C3, M4) {\n                  var g3 = s3(C3, M4.pickShader.vertex, M4.pickShader.fragment, null, M4.pickShader.attributes);\n                  return g3.attributes.position.location = 0, g3.attributes.id.location = 1, g3.attributes.vector.location = 4, g3;\n                }\n                function x2(C3, M4, g3) {\n                  var P3 = g3.shaders;\n                  arguments.length === 1 && (M4 = C3, C3 = M4.gl);\n                  var T3 = S2(C3, P3), z3 = L3(C3, P3), O3 = c5(C3, d3(new Uint8Array([255, 255, 255, 255]), [1, 1, 4]));\n                  O3.generateMipmap(), O3.minFilter = C3.LINEAR_MIPMAP_LINEAR, O3.magFilter = C3.LINEAR;\n                  var V2 = l3(C3), G2 = l3(C3), Z = l3(C3), j3 = l3(C3), N2 = l3(C3), H = u4(C3, [{ buffer: V2, type: C3.FLOAT, size: 4 }, { buffer: N2, type: C3.UNSIGNED_BYTE, size: 4, normalized: true }, { buffer: Z, type: C3.FLOAT, size: 4 }, { buffer: j3, type: C3.FLOAT, size: 2 }, { buffer: G2, type: C3.FLOAT, size: 4 }]), te = new b(C3, O3, T3, z3, V2, G2, N2, Z, j3, H, g3.traceType || "cone");\n                  return te.update(M4), te;\n                }\n                i3.exports = x2;\n              }, 9127: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = u4;\n                var s3 = o4(6204), l3 = o4(5771);\n                function u4(c5) {\n                  return l3(s3(c5));\n                }\n              }, 9131: function(i3, a4, o4) {\n                var s3 = o4(5177), l3 = o4(9288);\n                i3.exports = u4;\n                function u4(c5, f4) {\n                  return f4 = f4 || 1, c5[0] = Math.random(), c5[1] = Math.random(), c5[2] = Math.random(), c5[3] = Math.random(), s3(c5, c5), l3(c5, c5, f4), c5;\n                }\n              }, 9165: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = b;\n                var s3 = o4(2762), l3 = o4(8116), u4 = o4(3436), c5 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];\n                function f4(p3, k4, E3, S2) {\n                  this.gl = p3, this.shader = S2, this.buffer = k4, this.vao = E3, this.pixelRatio = 1, this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.lineWidth = [1, 1, 1], this.capSize = [10, 10, 10], this.lineCount = [0, 0, 0], this.lineOffset = [0, 0, 0], this.opacity = 1, this.hasAlpha = false;\n                }\n                var h3 = f4.prototype;\n                h3.isOpaque = function() {\n                  return !this.hasAlpha;\n                }, h3.isTransparent = function() {\n                  return this.hasAlpha;\n                }, h3.drawTransparent = h3.draw = function(p3) {\n                  var k4 = this.gl, E3 = this.shader.uniforms;\n                  this.shader.bind();\n                  var S2 = E3.view = p3.view || c5, L3 = E3.projection = p3.projection || c5;\n                  E3.model = p3.model || c5, E3.clipBounds = this.clipBounds, E3.opacity = this.opacity;\n                  var x2 = S2[12], C3 = S2[13], M4 = S2[14], g3 = S2[15], P3 = p3._ortho || false, T3 = P3 ? 2 : 1, z3 = T3 * this.pixelRatio * (L3[3] * x2 + L3[7] * C3 + L3[11] * M4 + L3[15] * g3) / k4.drawingBufferHeight;\n                  this.vao.bind();\n                  for (var O3 = 0; O3 < 3; ++O3) k4.lineWidth(this.lineWidth[O3] * this.pixelRatio), E3.capSize = this.capSize[O3] * z3, this.lineCount[O3] && k4.drawArrays(k4.LINES, this.lineOffset[O3], this.lineCount[O3]);\n                  this.vao.unbind();\n                };\n                function d3(p3, k4) {\n                  for (var E3 = 0; E3 < 3; ++E3) p3[0][E3] = Math.min(p3[0][E3], k4[E3]), p3[1][E3] = Math.max(p3[1][E3], k4[E3]);\n                }\n                var v3 = (function() {\n                  for (var p3 = new Array(3), k4 = 0; k4 < 3; ++k4) {\n                    for (var E3 = [], S2 = 1; S2 <= 2; ++S2) for (var L3 = -1; L3 <= 1; L3 += 2) {\n                      var x2 = (S2 + k4) % 3, C3 = [0, 0, 0];\n                      C3[x2] = L3, E3.push(C3);\n                    }\n                    p3[k4] = E3;\n                  }\n                  return p3;\n                })();\n                function _2(p3, k4, E3, S2) {\n                  for (var L3 = v3[S2], x2 = 0; x2 < L3.length; ++x2) {\n                    var C3 = L3[x2];\n                    p3.push(k4[0], k4[1], k4[2], E3[0], E3[1], E3[2], E3[3], C3[0], C3[1], C3[2]);\n                  }\n                  return L3.length;\n                }\n                h3.update = function(p3) {\n                  p3 = p3 || {}, "lineWidth" in p3 && (this.lineWidth = p3.lineWidth, Array.isArray(this.lineWidth) || (this.lineWidth = [this.lineWidth, this.lineWidth, this.lineWidth])), "capSize" in p3 && (this.capSize = p3.capSize, Array.isArray(this.capSize) || (this.capSize = [this.capSize, this.capSize, this.capSize])), this.hasAlpha = false, "opacity" in p3 && (this.opacity = +p3.opacity, this.opacity < 1 && (this.hasAlpha = true));\n                  var k4 = p3.color || [[0, 0, 0], [0, 0, 0], [0, 0, 0]], E3 = p3.position, S2 = p3.error;\n                  if (Array.isArray(k4[0]) || (k4 = [k4, k4, k4]), E3 && S2) {\n                    var L3 = [], x2 = E3.length, C3 = 0;\n                    this.bounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.lineCount = [0, 0, 0];\n                    for (var M4 = 0; M4 < 3; ++M4) {\n                      this.lineOffset[M4] = C3;\n                      e: for (var g3 = 0; g3 < x2; ++g3) {\n                        for (var P3 = E3[g3], T3 = 0; T3 < 3; ++T3) if (isNaN(P3[T3]) || !isFinite(P3[T3])) continue e;\n                        var z3 = S2[g3], O3 = k4[M4];\n                        if (Array.isArray(O3[0]) && (O3 = k4[g3]), O3.length === 3 ? O3 = [O3[0], O3[1], O3[2], 1] : O3.length === 4 && (O3 = [O3[0], O3[1], O3[2], O3[3]], !this.hasAlpha && O3[3] < 1 && (this.hasAlpha = true)), !(isNaN(z3[0][M4]) || isNaN(z3[1][M4]))) {\n                          if (z3[0][M4] < 0) {\n                            var V2 = P3.slice();\n                            V2[M4] += z3[0][M4], L3.push(P3[0], P3[1], P3[2], O3[0], O3[1], O3[2], O3[3], 0, 0, 0, V2[0], V2[1], V2[2], O3[0], O3[1], O3[2], O3[3], 0, 0, 0), d3(this.bounds, V2), C3 += 2 + _2(L3, V2, O3, M4);\n                          }\n                          if (z3[1][M4] > 0) {\n                            var V2 = P3.slice();\n                            V2[M4] += z3[1][M4], L3.push(P3[0], P3[1], P3[2], O3[0], O3[1], O3[2], O3[3], 0, 0, 0, V2[0], V2[1], V2[2], O3[0], O3[1], O3[2], O3[3], 0, 0, 0), d3(this.bounds, V2), C3 += 2 + _2(L3, V2, O3, M4);\n                          }\n                        }\n                      }\n                      this.lineCount[M4] = C3 - this.lineOffset[M4];\n                    }\n                    this.buffer.update(L3);\n                  }\n                }, h3.dispose = function() {\n                  this.shader.dispose(), this.buffer.dispose(), this.vao.dispose();\n                };\n                function b(p3) {\n                  var k4 = p3.gl, E3 = s3(k4), S2 = l3(k4, [{ buffer: E3, type: k4.FLOAT, size: 3, offset: 0, stride: 40 }, { buffer: E3, type: k4.FLOAT, size: 4, offset: 12, stride: 40 }, { buffer: E3, type: k4.FLOAT, size: 3, offset: 28, stride: 40 }]), L3 = u4(k4);\n                  L3.attributes.position.location = 0, L3.attributes.color.location = 1, L3.attributes.offset.location = 2;\n                  var x2 = new f4(k4, E3, S2, L3);\n                  return x2.update(p3), x2;\n                }\n              }, 9215: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = d3;\n                var s3 = o4(4769), l3 = o4(2478);\n                function u4(v3, _2, b) {\n                  return Math.min(_2, Math.max(v3, b));\n                }\n                function c5(v3, _2, b) {\n                  this.dimension = v3.length, this.bounds = [new Array(this.dimension), new Array(this.dimension)];\n                  for (var p3 = 0; p3 < this.dimension; ++p3) this.bounds[0][p3] = -1 / 0, this.bounds[1][p3] = 1 / 0;\n                  this._state = v3.slice().reverse(), this._velocity = _2.slice().reverse(), this._time = [b], this._scratch = [v3.slice(), v3.slice(), v3.slice(), v3.slice(), v3.slice()];\n                }\n                var f4 = c5.prototype;\n                f4.flush = function(v3) {\n                  var _2 = l3.gt(this._time, v3) - 1;\n                  _2 <= 0 || (this._time.splice(0, _2), this._state.splice(0, _2 * this.dimension), this._velocity.splice(0, _2 * this.dimension));\n                }, f4.curve = function(v3) {\n                  var _2 = this._time, b = _2.length, p3 = l3.le(_2, v3), k4 = this._scratch[0], E3 = this._state, S2 = this._velocity, L3 = this.dimension, x2 = this.bounds;\n                  if (p3 < 0) for (var C3 = L3 - 1, M4 = 0; M4 < L3; ++M4, --C3) k4[M4] = E3[C3];\n                  else if (p3 >= b - 1) for (var C3 = E3.length - 1, g3 = v3 - _2[b - 1], M4 = 0; M4 < L3; ++M4, --C3) k4[M4] = E3[C3] + g3 * S2[C3];\n                  else {\n                    for (var C3 = L3 * (p3 + 1) - 1, P3 = _2[p3], T3 = _2[p3 + 1], z3 = T3 - P3 || 1, O3 = this._scratch[1], V2 = this._scratch[2], G2 = this._scratch[3], Z = this._scratch[4], j3 = true, M4 = 0; M4 < L3; ++M4, --C3) O3[M4] = E3[C3], G2[M4] = S2[C3] * z3, V2[M4] = E3[C3 + L3], Z[M4] = S2[C3 + L3] * z3, j3 = j3 && O3[M4] === V2[M4] && G2[M4] === Z[M4] && G2[M4] === 0;\n                    if (j3) for (var M4 = 0; M4 < L3; ++M4) k4[M4] = O3[M4];\n                    else s3(O3, G2, V2, Z, (v3 - P3) / z3, k4);\n                  }\n                  for (var N2 = x2[0], H = x2[1], M4 = 0; M4 < L3; ++M4) k4[M4] = u4(N2[M4], H[M4], k4[M4]);\n                  return k4;\n                }, f4.dcurve = function(v3) {\n                  var _2 = this._time, b = _2.length, p3 = l3.le(_2, v3), k4 = this._scratch[0], E3 = this._state, S2 = this._velocity, L3 = this.dimension;\n                  if (p3 >= b - 1) for (var x2 = E3.length - 1, C3 = v3 - _2[b - 1], M4 = 0; M4 < L3; ++M4, --x2) k4[M4] = S2[x2];\n                  else {\n                    for (var x2 = L3 * (p3 + 1) - 1, g3 = _2[p3], P3 = _2[p3 + 1], T3 = P3 - g3 || 1, z3 = this._scratch[1], O3 = this._scratch[2], V2 = this._scratch[3], G2 = this._scratch[4], Z = true, M4 = 0; M4 < L3; ++M4, --x2) z3[M4] = E3[x2], V2[M4] = S2[x2] * T3, O3[M4] = E3[x2 + L3], G2[M4] = S2[x2 + L3] * T3, Z = Z && z3[M4] === O3[M4] && V2[M4] === G2[M4] && V2[M4] === 0;\n                    if (Z) for (var M4 = 0; M4 < L3; ++M4) k4[M4] = 0;\n                    else {\n                      s3.derivative(z3, V2, O3, G2, (v3 - g3) / T3, k4);\n                      for (var M4 = 0; M4 < L3; ++M4) k4[M4] /= T3;\n                    }\n                  }\n                  return k4;\n                }, f4.lastT = function() {\n                  var v3 = this._time;\n                  return v3[v3.length - 1];\n                }, f4.stable = function() {\n                  for (var v3 = this._velocity, _2 = v3.length, b = this.dimension - 1; b >= 0; --b) if (v3[--_2]) return false;\n                  return true;\n                }, f4.jump = function(v3) {\n                  var _2 = this.lastT(), b = this.dimension;\n                  if (!(v3 < _2 || arguments.length !== b + 1)) {\n                    var p3 = this._state, k4 = this._velocity, E3 = p3.length - this.dimension, S2 = this.bounds, L3 = S2[0], x2 = S2[1];\n                    this._time.push(_2, v3);\n                    for (var C3 = 0; C3 < 2; ++C3) for (var M4 = 0; M4 < b; ++M4) p3.push(p3[E3++]), k4.push(0);\n                    this._time.push(v3);\n                    for (var M4 = b; M4 > 0; --M4) p3.push(u4(L3[M4 - 1], x2[M4 - 1], arguments[M4])), k4.push(0);\n                  }\n                }, f4.push = function(v3) {\n                  var _2 = this.lastT(), b = this.dimension;\n                  if (!(v3 < _2 || arguments.length !== b + 1)) {\n                    var p3 = this._state, k4 = this._velocity, E3 = p3.length - this.dimension, S2 = v3 - _2, L3 = this.bounds, x2 = L3[0], C3 = L3[1], M4 = S2 > 1e-6 ? 1 / S2 : 0;\n                    this._time.push(v3);\n                    for (var g3 = b; g3 > 0; --g3) {\n                      var P3 = u4(x2[g3 - 1], C3[g3 - 1], arguments[g3]);\n                      p3.push(P3), k4.push((P3 - p3[E3++]) * M4);\n                    }\n                  }\n                }, f4.set = function(v3) {\n                  var _2 = this.dimension;\n                  if (!(v3 < this.lastT() || arguments.length !== _2 + 1)) {\n                    var b = this._state, p3 = this._velocity, k4 = this.bounds, E3 = k4[0], S2 = k4[1];\n                    this._time.push(v3);\n                    for (var L3 = _2; L3 > 0; --L3) b.push(u4(E3[L3 - 1], S2[L3 - 1], arguments[L3])), p3.push(0);\n                  }\n                }, f4.move = function(v3) {\n                  var _2 = this.lastT(), b = this.dimension;\n                  if (!(v3 <= _2 || arguments.length !== b + 1)) {\n                    var p3 = this._state, k4 = this._velocity, E3 = p3.length - this.dimension, S2 = this.bounds, L3 = S2[0], x2 = S2[1], C3 = v3 - _2, M4 = C3 > 1e-6 ? 1 / C3 : 0;\n                    this._time.push(v3);\n                    for (var g3 = b; g3 > 0; --g3) {\n                      var P3 = arguments[g3];\n                      p3.push(u4(L3[g3 - 1], x2[g3 - 1], p3[E3++] + P3)), k4.push(P3 * M4);\n                    }\n                  }\n                }, f4.idle = function(v3) {\n                  var _2 = this.lastT();\n                  if (!(v3 < _2)) {\n                    var b = this.dimension, p3 = this._state, k4 = this._velocity, E3 = p3.length - b, S2 = this.bounds, L3 = S2[0], x2 = S2[1], C3 = v3 - _2;\n                    this._time.push(v3);\n                    for (var M4 = b - 1; M4 >= 0; --M4) p3.push(u4(L3[M4], x2[M4], p3[E3] + C3 * k4[E3])), k4.push(0), E3 += 1;\n                  }\n                };\n                function h3(v3) {\n                  for (var _2 = new Array(v3), b = 0; b < v3; ++b) _2[b] = 0;\n                  return _2;\n                }\n                function d3(v3, _2, b) {\n                  switch (arguments.length) {\n                    case 0:\n                      return new c5([0], [0], 0);\n                    case 1:\n                      if (typeof v3 == "number") {\n                        var p3 = h3(v3);\n                        return new c5(p3, p3, 0);\n                      } else return new c5(v3, h3(v3.length), 0);\n                    case 2:\n                      if (typeof _2 == "number") {\n                        var p3 = h3(v3.length);\n                        return new c5(v3, p3, +_2);\n                      } else b = 0;\n                    case 3:\n                      if (v3.length !== _2.length) throw new Error("state and velocity lengths must match");\n                      return new c5(v3, _2, b);\n                  }\n                }\n              }, 9216: function(i3) {\n                "use strict";\n                i3.exports = l3, i3.exports.isMobile = l3, i3.exports.default = l3;\n                var a4 = /(android|bb\\d+|meego).+mobile|armv7l|avantgo|bada\\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\\/|plucker|pocket|psp|series[46]0|samsungbrowser.*mobile|symbian|treo|up\\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i, o4 = /CrOS/, s3 = /android|ipad|playbook|silk/i;\n                function l3(u4) {\n                  u4 || (u4 = {});\n                  var c5 = u4.ua;\n                  if (!c5 && typeof navigator != "undefined" && (c5 = navigator.userAgent), c5 && c5.headers && typeof c5.headers["user-agent"] == "string" && (c5 = c5.headers["user-agent"]), typeof c5 != "string") return false;\n                  var f4 = a4.test(c5) && !o4.test(c5) || !!u4.tablet && s3.test(c5);\n                  return !f4 && u4.tablet && u4.featureDetect && navigator && navigator.maxTouchPoints > 1 && c5.indexOf("Macintosh") !== -1 && c5.indexOf("Safari") !== -1 && (f4 = true), f4;\n                }\n              }, 9226: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] = Math.ceil(s3[0]), o4[1] = Math.ceil(s3[1]), o4[2] = Math.ceil(s3[2]), o4;\n                }\n              }, 9265: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3) {\n                  return o4[0] === s3[0] && o4[1] === s3[1] && o4[2] === s3[2];\n                }\n              }, 9288: function(i3) {\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  return o4[0] = s3[0] * l3, o4[1] = s3[1] * l3, o4[2] = s3[2] * l3, o4[3] = s3[3] * l3, o4;\n                }\n              }, 9346: function(i3) {\n                "use strict";\n                var a4 = new Float64Array(4), o4 = new Float64Array(4), s3 = new Float64Array(4);\n                function l3(u4, c5, f4, h3, d3) {\n                  a4.length < h3.length && (a4 = new Float64Array(h3.length), o4 = new Float64Array(h3.length), s3 = new Float64Array(h3.length));\n                  for (var v3 = 0; v3 < h3.length; ++v3) a4[v3] = u4[v3] - h3[v3], o4[v3] = c5[v3] - u4[v3], s3[v3] = f4[v3] - u4[v3];\n                  for (var _2 = 0, b = 0, p3 = 0, k4 = 0, E3 = 0, S2 = 0, v3 = 0; v3 < h3.length; ++v3) {\n                    var L3 = o4[v3], x2 = s3[v3], C3 = a4[v3];\n                    _2 += L3 * L3, b += L3 * x2, p3 += x2 * x2, k4 += C3 * L3, E3 += C3 * x2, S2 += C3 * C3;\n                  }\n                  var M4 = Math.abs(_2 * p3 - b * b), g3 = b * E3 - p3 * k4, P3 = b * k4 - _2 * E3, T3;\n                  if (g3 + P3 <= M4) if (g3 < 0) P3 < 0 && k4 < 0 ? (P3 = 0, -k4 >= _2 ? (g3 = 1, T3 = _2 + 2 * k4 + S2) : (g3 = -k4 / _2, T3 = k4 * g3 + S2)) : (g3 = 0, E3 >= 0 ? (P3 = 0, T3 = S2) : -E3 >= p3 ? (P3 = 1, T3 = p3 + 2 * E3 + S2) : (P3 = -E3 / p3, T3 = E3 * P3 + S2));\n                  else if (P3 < 0) P3 = 0, k4 >= 0 ? (g3 = 0, T3 = S2) : -k4 >= _2 ? (g3 = 1, T3 = _2 + 2 * k4 + S2) : (g3 = -k4 / _2, T3 = k4 * g3 + S2);\n                  else {\n                    var z3 = 1 / M4;\n                    g3 *= z3, P3 *= z3, T3 = g3 * (_2 * g3 + b * P3 + 2 * k4) + P3 * (b * g3 + p3 * P3 + 2 * E3) + S2;\n                  }\n                  else {\n                    var O3, V2, G2, Z;\n                    g3 < 0 ? (O3 = b + k4, V2 = p3 + E3, V2 > O3 ? (G2 = V2 - O3, Z = _2 - 2 * b + p3, G2 >= Z ? (g3 = 1, P3 = 0, T3 = _2 + 2 * k4 + S2) : (g3 = G2 / Z, P3 = 1 - g3, T3 = g3 * (_2 * g3 + b * P3 + 2 * k4) + P3 * (b * g3 + p3 * P3 + 2 * E3) + S2)) : (g3 = 0, V2 <= 0 ? (P3 = 1, T3 = p3 + 2 * E3 + S2) : E3 >= 0 ? (P3 = 0, T3 = S2) : (P3 = -E3 / p3, T3 = E3 * P3 + S2))) : P3 < 0 ? (O3 = b + E3, V2 = _2 + k4, V2 > O3 ? (G2 = V2 - O3, Z = _2 - 2 * b + p3, G2 >= Z ? (P3 = 1, g3 = 0, T3 = p3 + 2 * E3 + S2) : (P3 = G2 / Z, g3 = 1 - P3, T3 = g3 * (_2 * g3 + b * P3 + 2 * k4) + P3 * (b * g3 + p3 * P3 + 2 * E3) + S2)) : (P3 = 0, V2 <= 0 ? (g3 = 1, T3 = _2 + 2 * k4 + S2) : k4 >= 0 ? (g3 = 0, T3 = S2) : (g3 = -k4 / _2, T3 = k4 * g3 + S2))) : (G2 = p3 + E3 - b - k4, G2 <= 0 ? (g3 = 0, P3 = 1, T3 = p3 + 2 * E3 + S2) : (Z = _2 - 2 * b + p3, G2 >= Z ? (g3 = 1, P3 = 0, T3 = _2 + 2 * k4 + S2) : (g3 = G2 / Z, P3 = 1 - g3, T3 = g3 * (_2 * g3 + b * P3 + 2 * k4) + P3 * (b * g3 + p3 * P3 + 2 * E3) + S2)));\n                  }\n                  for (var j3 = 1 - g3 - P3, v3 = 0; v3 < h3.length; ++v3) d3[v3] = j3 * u4[v3] + g3 * c5[v3] + P3 * f4[v3];\n                  return T3 < 0 ? 0 : T3;\n                }\n                i3.exports = l3;\n              }, 9362: function(i3) {\n                "use strict";\n                i3.exports = a4;\n                function a4(o4, s3, l3) {\n                  var u4 = o4 + s3, c5 = u4 - o4, f4 = u4 - c5, h3 = s3 - c5, d3 = o4 - f4;\n                  return l3 ? (l3[0] = d3 + h3, l3[1] = u4, l3) : [d3 + h3, u4];\n                }\n              }, 9366: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(4359);\n                i3.exports = u4;\n                var l3 = {};\n                function u4(c5, f4, h3) {\n                  var d3 = [f4.style, f4.weight, f4.variant, f4.family].join("_"), v3 = l3[d3];\n                  if (v3 || (v3 = l3[d3] = {}), c5 in v3) return v3[c5];\n                  var _2 = { textAlign: "center", textBaseline: "middle", lineHeight: 1, font: f4.family, fontStyle: f4.style, fontWeight: f4.weight, fontVariant: f4.variant, lineSpacing: 1.25, styletags: { breaklines: true, bolds: true, italics: true, subscripts: true, superscripts: true } };\n                  _2.triangles = true;\n                  var b = s3(c5, _2);\n                  _2.triangles = false;\n                  var p3 = s3(c5, _2), k4, E3;\n                  if (h3 && h3 !== 1) {\n                    for (k4 = 0; k4 < b.positions.length; ++k4) for (E3 = 0; E3 < b.positions[k4].length; ++E3) b.positions[k4][E3] /= h3;\n                    for (k4 = 0; k4 < p3.positions.length; ++k4) for (E3 = 0; E3 < p3.positions[k4].length; ++E3) p3.positions[k4][E3] /= h3;\n                  }\n                  var S2 = [[1 / 0, 1 / 0], [-1 / 0, -1 / 0]], L3 = p3.positions.length;\n                  for (k4 = 0; k4 < L3; ++k4) {\n                    var x2 = p3.positions[k4];\n                    for (E3 = 0; E3 < 2; ++E3) S2[0][E3] = Math.min(S2[0][E3], x2[E3]), S2[1][E3] = Math.max(S2[1][E3], x2[E3]);\n                  }\n                  return v3[c5] = [b, p3, S2];\n                }\n              }, 9405: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(3327), l3 = o4(8731), u4 = o4(216), c5 = o4(5091), f4 = o4(2145), h3 = o4(8866);\n                function d3(p3) {\n                  this.gl = p3, this.gl.lastAttribCount = 0, this._vref = this._fref = this._relink = this.vertShader = this.fragShader = this.program = this.attributes = this.uniforms = this.types = null;\n                }\n                var v3 = d3.prototype;\n                v3.bind = function() {\n                  this.program || this._relink();\n                  var p3, k4 = this.gl.getProgramParameter(this.program, this.gl.ACTIVE_ATTRIBUTES), E3 = this.gl.lastAttribCount;\n                  if (k4 > E3) for (p3 = E3; p3 < k4; p3++) this.gl.enableVertexAttribArray(p3);\n                  else if (E3 > k4) for (p3 = k4; p3 < E3; p3++) this.gl.disableVertexAttribArray(p3);\n                  this.gl.lastAttribCount = k4, this.gl.useProgram(this.program);\n                }, v3.dispose = function() {\n                  for (var p3 = this.gl.lastAttribCount, k4 = 0; k4 < p3; k4++) this.gl.disableVertexAttribArray(k4);\n                  this.gl.lastAttribCount = 0, this._fref && this._fref.dispose(), this._vref && this._vref.dispose(), this.attributes = this.types = this.vertShader = this.fragShader = this.program = this._relink = this._fref = this._vref = null;\n                };\n                function _2(p3, k4) {\n                  return p3.name < k4.name ? -1 : 1;\n                }\n                v3.update = function(p3, k4, E3, S2) {\n                  if (!k4 || arguments.length === 1) {\n                    var L3 = p3;\n                    p3 = L3.vertex, k4 = L3.fragment, E3 = L3.uniforms, S2 = L3.attributes;\n                  }\n                  var x2 = this, C3 = x2.gl, M4 = x2._vref;\n                  x2._vref = c5.shader(C3, C3.VERTEX_SHADER, p3), M4 && M4.dispose(), x2.vertShader = x2._vref.shader;\n                  var g3 = this._fref;\n                  if (x2._fref = c5.shader(C3, C3.FRAGMENT_SHADER, k4), g3 && g3.dispose(), x2.fragShader = x2._fref.shader, !E3 || !S2) {\n                    var P3 = C3.createProgram();\n                    if (C3.attachShader(P3, x2.fragShader), C3.attachShader(P3, x2.vertShader), C3.linkProgram(P3), !C3.getProgramParameter(P3, C3.LINK_STATUS)) {\n                      var T3 = C3.getProgramInfoLog(P3);\n                      throw new h3(T3, "Error linking program:" + T3);\n                    }\n                    E3 = E3 || f4.uniforms(C3, P3), S2 = S2 || f4.attributes(C3, P3), C3.deleteProgram(P3);\n                  }\n                  S2 = S2.slice(), S2.sort(_2);\n                  var z3 = [], O3 = [], V2 = [], G2;\n                  for (G2 = 0; G2 < S2.length; ++G2) {\n                    var Z = S2[G2];\n                    if (Z.type.indexOf("mat") >= 0) {\n                      for (var j3 = Z.type.charAt(Z.type.length - 1) | 0, N2 = new Array(j3), H = 0; H < j3; ++H) N2[H] = V2.length, O3.push(Z.name + "[" + H + "]"), typeof Z.location == "number" ? V2.push(Z.location + H) : Array.isArray(Z.location) && Z.location.length === j3 && typeof Z.location[H] == "number" ? V2.push(Z.location[H] | 0) : V2.push(-1);\n                      z3.push({ name: Z.name, type: Z.type, locations: N2 });\n                    } else z3.push({ name: Z.name, type: Z.type, locations: [V2.length] }), O3.push(Z.name), typeof Z.location == "number" ? V2.push(Z.location | 0) : V2.push(-1);\n                  }\n                  var te = 0;\n                  for (G2 = 0; G2 < V2.length; ++G2) if (V2[G2] < 0) {\n                    for (; V2.indexOf(te) >= 0; ) te += 1;\n                    V2[G2] = te;\n                  }\n                  var oe = new Array(E3.length);\n                  function _e() {\n                    x2.program = c5.program(C3, x2._vref, x2._fref, O3, V2);\n                    for (var Ee = 0; Ee < E3.length; ++Ee) oe[Ee] = C3.getUniformLocation(x2.program, E3[Ee].name);\n                  }\n                  _e(), x2._relink = _e, x2.types = { uniforms: u4(E3), attributes: u4(S2) }, x2.attributes = l3(C3, x2, z3, V2), Object.defineProperty(x2, "uniforms", s3(C3, x2, E3, oe));\n                };\n                function b(p3, k4, E3, S2, L3) {\n                  var x2 = new d3(p3);\n                  return x2.update(k4, E3, S2, L3), x2;\n                }\n                i3.exports = b;\n              }, 9499: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = Fe;\n                var s3 = o4(8828), l3 = o4(2762), u4 = o4(8116), c5 = o4(7766), f4 = o4(1888), h3 = o4(6729), d3 = o4(5298), v3 = o4(9994), _2 = o4(9618), b = o4(3711), p3 = o4(6760), k4 = o4(7608), E3 = o4(2478), S2 = o4(6199), L3 = o4(990), x2 = L3.createShader, C3 = L3.createContourShader, M4 = L3.createPickShader, g3 = L3.createPickContourShader, P3 = 4 * 10, T3 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], z3 = [[0, 0], [0, 1], [1, 0], [1, 1], [1, 0], [0, 1]], O3 = [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]];\n                (function() {\n                  for (var Pe = 0; Pe < 3; ++Pe) {\n                    var ge = O3[Pe], Re = (Pe + 1) % 3, ce = (Pe + 2) % 3;\n                    ge[Re + 0] = 1, ge[ce + 3] = 1, ge[Pe + 6] = 1;\n                  }\n                })();\n                function V2(Pe, ge, Re, ce, Ze) {\n                  this.position = Pe, this.index = ge, this.uv = Re, this.level = ce, this.dataCoordinate = Ze;\n                }\n                var G2 = 256;\n                function Z(Pe, ge, Re, ce, Ze, ut, pt, Zt, st, lt, Gt, Nt, Jt, sr, wr) {\n                  this.gl = Pe, this.shape = ge, this.bounds = Re, this.objectOffset = wr, this.intensityBounds = [], this._shader = ce, this._pickShader = Ze, this._coordinateBuffer = ut, this._vao = pt, this._colorMap = Zt, this._contourShader = st, this._contourPickShader = lt, this._contourBuffer = Gt, this._contourVAO = Nt, this._contourOffsets = [[], [], []], this._contourCounts = [[], [], []], this._vertexCount = 0, this._pickResult = new V2([0, 0, 0], [0, 0], [0, 0], [0, 0, 0], [0, 0, 0]), this._dynamicBuffer = Jt, this._dynamicVAO = sr, this._dynamicOffsets = [0, 0, 0], this._dynamicCounts = [0, 0, 0], this.contourWidth = [1, 1, 1], this.contourLevels = [[1], [1], [1]], this.contourTint = [0, 0, 0], this.contourColor = [[0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1], [0.5, 0.5, 0.5, 1]], this.showContour = true, this.showSurface = true, this.enableHighlight = [true, true, true], this.highlightColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.highlightTint = [1, 1, 1], this.highlightLevel = [-1, -1, -1], this.enableDynamic = [true, true, true], this.dynamicLevel = [NaN, NaN, NaN], this.dynamicColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.dynamicTint = [1, 1, 1], this.dynamicWidth = [1, 1, 1], this.axesBounds = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]], this.surfaceProject = [false, false, false], this.contourProject = [[false, false, false], [false, false, false], [false, false, false]], this.colorBounds = [false, false], this._field = [_2(f4.mallocFloat(1024), [0, 0]), _2(f4.mallocFloat(1024), [0, 0]), _2(f4.mallocFloat(1024), [0, 0])], this.pickId = 1, this.clipBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.snapToData = false, this.pixelRatio = 1, this.opacity = 1, this.lightPosition = [10, 1e4, 0], this.ambientLight = 0.8, this.diffuseLight = 0.8, this.specularLight = 2, this.roughness = 0.5, this.fresnel = 1.5, this.vertexColor = 0, this.dirty = true;\n                }\n                var j3 = Z.prototype;\n                j3.genColormap = function(Pe, ge) {\n                  var Re = false, ce = v3([h3({ colormap: Pe, nshades: G2, format: "rgba" }).map(function(Ze, ut) {\n                    var pt = ge ? N2(ut / 255, ge) : Ze[3];\n                    return pt < 1 && (Re = true), [Ze[0], Ze[1], Ze[2], 255 * pt];\n                  })]);\n                  return d3.divseq(ce, 255), this.hasAlphaScale = Re, ce;\n                }, j3.isTransparent = function() {\n                  return this.opacity < 1 || this.hasAlphaScale;\n                }, j3.isOpaque = function() {\n                  return !this.isTransparent();\n                }, j3.pickSlots = 1, j3.setPickBase = function(Pe) {\n                  this.pickId = Pe;\n                };\n                function N2(Pe, ge) {\n                  if (!ge || !ge.length) return 1;\n                  for (var Re = 0; Re < ge.length; ++Re) {\n                    if (ge.length < 2) return 1;\n                    if (ge[Re][0] === Pe) return ge[Re][1];\n                    if (ge[Re][0] > Pe && Re > 0) {\n                      var ce = (ge[Re][0] - Pe) / (ge[Re][0] - ge[Re - 1][0]);\n                      return ge[Re][1] * (1 - ce) + ce * ge[Re - 1][1];\n                    }\n                  }\n                  return 1;\n                }\n                var H = [0, 0, 0], te = { showSurface: false, showContour: false, projections: [T3.slice(), T3.slice(), T3.slice()], clipBounds: [[[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]] };\n                function oe(Pe, ge) {\n                  var Re, ce, Ze, ut = ge.axes && ge.axes.lastCubeProps.axis || H, pt = ge.showSurface, Zt = ge.showContour;\n                  for (Re = 0; Re < 3; ++Re) for (pt = pt || ge.surfaceProject[Re], ce = 0; ce < 3; ++ce) Zt = Zt || ge.contourProject[Re][ce];\n                  for (Re = 0; Re < 3; ++Re) {\n                    var st = te.projections[Re];\n                    for (ce = 0; ce < 16; ++ce) st[ce] = 0;\n                    for (ce = 0; ce < 4; ++ce) st[5 * ce] = 1;\n                    st[5 * Re] = 0, st[12 + Re] = ge.axesBounds[+(ut[Re] > 0)][Re], p3(st, Pe.model, st);\n                    var lt = te.clipBounds[Re];\n                    for (Ze = 0; Ze < 2; ++Ze) for (ce = 0; ce < 3; ++ce) lt[Ze][ce] = Pe.clipBounds[Ze][ce];\n                    lt[0][Re] = -1e8, lt[1][Re] = 1e8;\n                  }\n                  return te.showSurface = pt, te.showContour = Zt, te;\n                }\n                var _e = { model: T3, view: T3, projection: T3, inverseModel: T3.slice(), lowerBound: [0, 0, 0], upperBound: [0, 0, 0], colorMap: 0, clipBounds: [[0, 0, 0], [0, 0, 0]], height: 0, contourTint: 0, contourColor: [0, 0, 0, 1], permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1], zOffset: -1e-4, objectOffset: [0, 0, 0], kambient: 1, kdiffuse: 1, kspecular: 1, lightPosition: [1e3, 1e3, 1e3], eyePosition: [0, 0, 0], roughness: 1, fresnel: 1, opacity: 1, vertexColor: 0 }, Ee = T3.slice(), Ce = [1, 0, 0, 0, 1, 0, 0, 0, 1];\n                function me(Pe, ge) {\n                  Pe = Pe || {};\n                  var Re = this.gl;\n                  Re.disable(Re.CULL_FACE), this._colorMap.bind(0);\n                  var ce = _e;\n                  ce.model = Pe.model || T3, ce.view = Pe.view || T3, ce.projection = Pe.projection || T3, ce.lowerBound = [this.bounds[0][0], this.bounds[0][1], this.colorBounds[0] || this.bounds[0][2]], ce.upperBound = [this.bounds[1][0], this.bounds[1][1], this.colorBounds[1] || this.bounds[1][2]], ce.objectOffset = this.objectOffset, ce.contourColor = this.contourColor[0], ce.inverseModel = k4(ce.inverseModel, ce.model);\n                  for (var Ze = 0; Ze < 2; ++Ze) for (var ut = ce.clipBounds[Ze], pt = 0; pt < 3; ++pt) ut[pt] = Math.min(Math.max(this.clipBounds[Ze][pt], -1e8), 1e8);\n                  ce.kambient = this.ambientLight, ce.kdiffuse = this.diffuseLight, ce.kspecular = this.specularLight, ce.roughness = this.roughness, ce.fresnel = this.fresnel, ce.opacity = this.opacity, ce.height = 0, ce.permutation = Ce, ce.vertexColor = this.vertexColor;\n                  var Zt = Ee;\n                  for (p3(Zt, ce.view, ce.model), p3(Zt, ce.projection, Zt), k4(Zt, Zt), Ze = 0; Ze < 3; ++Ze) ce.eyePosition[Ze] = Zt[12 + Ze] / Zt[15];\n                  var st = Zt[15];\n                  for (Ze = 0; Ze < 3; ++Ze) st += this.lightPosition[Ze] * Zt[4 * Ze + 3];\n                  for (Ze = 0; Ze < 3; ++Ze) {\n                    var lt = Zt[12 + Ze];\n                    for (pt = 0; pt < 3; ++pt) lt += Zt[4 * pt + Ze] * this.lightPosition[pt];\n                    ce.lightPosition[Ze] = lt / st;\n                  }\n                  var Gt = oe(ce, this);\n                  if (Gt.showSurface) {\n                    for (this._shader.bind(), this._shader.uniforms = ce, this._vao.bind(), this.showSurface && this._vertexCount && this._vao.draw(Re.TRIANGLES, this._vertexCount), Ze = 0; Ze < 3; ++Ze) !this.surfaceProject[Ze] || !this.vertexCount || (this._shader.uniforms.model = Gt.projections[Ze], this._shader.uniforms.clipBounds = Gt.clipBounds[Ze], this._vao.draw(Re.TRIANGLES, this._vertexCount));\n                    this._vao.unbind();\n                  }\n                  if (Gt.showContour) {\n                    var Nt = this._contourShader;\n                    ce.kambient = 1, ce.kdiffuse = 0, ce.kspecular = 0, ce.opacity = 1, Nt.bind(), Nt.uniforms = ce;\n                    var Jt = this._contourVAO;\n                    for (Jt.bind(), Ze = 0; Ze < 3; ++Ze) for (Nt.uniforms.permutation = O3[Ze], Re.lineWidth(this.contourWidth[Ze] * this.pixelRatio), pt = 0; pt < this.contourLevels[Ze].length; ++pt) pt === this.highlightLevel[Ze] ? (Nt.uniforms.contourColor = this.highlightColor[Ze], Nt.uniforms.contourTint = this.highlightTint[Ze]) : (pt === 0 || pt - 1 === this.highlightLevel[Ze]) && (Nt.uniforms.contourColor = this.contourColor[Ze], Nt.uniforms.contourTint = this.contourTint[Ze]), this._contourCounts[Ze][pt] && (Nt.uniforms.height = this.contourLevels[Ze][pt], Jt.draw(Re.LINES, this._contourCounts[Ze][pt], this._contourOffsets[Ze][pt]));\n                    for (Ze = 0; Ze < 3; ++Ze) for (Nt.uniforms.model = Gt.projections[Ze], Nt.uniforms.clipBounds = Gt.clipBounds[Ze], pt = 0; pt < 3; ++pt) if (this.contourProject[Ze][pt]) {\n                      Nt.uniforms.permutation = O3[pt], Re.lineWidth(this.contourWidth[pt] * this.pixelRatio);\n                      for (var sr = 0; sr < this.contourLevels[pt].length; ++sr) sr === this.highlightLevel[pt] ? (Nt.uniforms.contourColor = this.highlightColor[pt], Nt.uniforms.contourTint = this.highlightTint[pt]) : (sr === 0 || sr - 1 === this.highlightLevel[pt]) && (Nt.uniforms.contourColor = this.contourColor[pt], Nt.uniforms.contourTint = this.contourTint[pt]), this._contourCounts[pt][sr] && (Nt.uniforms.height = this.contourLevels[pt][sr], Jt.draw(Re.LINES, this._contourCounts[pt][sr], this._contourOffsets[pt][sr]));\n                    }\n                    for (Jt.unbind(), Jt = this._dynamicVAO, Jt.bind(), Ze = 0; Ze < 3; ++Ze) if (this._dynamicCounts[Ze] !== 0) for (Nt.uniforms.model = ce.model, Nt.uniforms.clipBounds = ce.clipBounds, Nt.uniforms.permutation = O3[Ze], Re.lineWidth(this.dynamicWidth[Ze] * this.pixelRatio), Nt.uniforms.contourColor = this.dynamicColor[Ze], Nt.uniforms.contourTint = this.dynamicTint[Ze], Nt.uniforms.height = this.dynamicLevel[Ze], Jt.draw(Re.LINES, this._dynamicCounts[Ze], this._dynamicOffsets[Ze]), pt = 0; pt < 3; ++pt) this.contourProject[pt][Ze] && (Nt.uniforms.model = Gt.projections[pt], Nt.uniforms.clipBounds = Gt.clipBounds[pt], Jt.draw(Re.LINES, this._dynamicCounts[Ze], this._dynamicOffsets[Ze]));\n                    Jt.unbind();\n                  }\n                }\n                j3.draw = function(Pe) {\n                  return me.call(this, Pe, false);\n                }, j3.drawTransparent = function(Pe) {\n                  return me.call(this, Pe, true);\n                };\n                var ie = { model: T3, view: T3, projection: T3, inverseModel: T3, clipBounds: [[0, 0, 0], [0, 0, 0]], height: 0, shape: [0, 0], pickId: 0, lowerBound: [0, 0, 0], upperBound: [0, 0, 0], zOffset: 0, objectOffset: [0, 0, 0], permutation: [1, 0, 0, 0, 1, 0, 0, 0, 1], lightPosition: [0, 0, 0], eyePosition: [0, 0, 0] };\n                j3.drawPick = function(Pe) {\n                  Pe = Pe || {};\n                  var ge = this.gl;\n                  ge.disable(ge.CULL_FACE);\n                  var Re = ie;\n                  Re.model = Pe.model || T3, Re.view = Pe.view || T3, Re.projection = Pe.projection || T3, Re.shape = this._field[2].shape, Re.pickId = this.pickId / 255, Re.lowerBound = this.bounds[0], Re.upperBound = this.bounds[1], Re.objectOffset = this.objectOffset, Re.permutation = Ce;\n                  for (var ce = 0; ce < 2; ++ce) for (var Ze = Re.clipBounds[ce], ut = 0; ut < 3; ++ut) Ze[ut] = Math.min(Math.max(this.clipBounds[ce][ut], -1e8), 1e8);\n                  var pt = oe(Re, this);\n                  if (pt.showSurface) {\n                    for (this._pickShader.bind(), this._pickShader.uniforms = Re, this._vao.bind(), this._vao.draw(ge.TRIANGLES, this._vertexCount), ce = 0; ce < 3; ++ce) this.surfaceProject[ce] && (this._pickShader.uniforms.model = pt.projections[ce], this._pickShader.uniforms.clipBounds = pt.clipBounds[ce], this._vao.draw(ge.TRIANGLES, this._vertexCount));\n                    this._vao.unbind();\n                  }\n                  if (pt.showContour) {\n                    var Zt = this._contourPickShader;\n                    Zt.bind(), Zt.uniforms = Re;\n                    var st = this._contourVAO;\n                    for (st.bind(), ut = 0; ut < 3; ++ut) for (ge.lineWidth(this.contourWidth[ut] * this.pixelRatio), Zt.uniforms.permutation = O3[ut], ce = 0; ce < this.contourLevels[ut].length; ++ce) this._contourCounts[ut][ce] && (Zt.uniforms.height = this.contourLevels[ut][ce], st.draw(ge.LINES, this._contourCounts[ut][ce], this._contourOffsets[ut][ce]));\n                    for (ce = 0; ce < 3; ++ce) for (Zt.uniforms.model = pt.projections[ce], Zt.uniforms.clipBounds = pt.clipBounds[ce], ut = 0; ut < 3; ++ut) if (this.contourProject[ce][ut]) {\n                      Zt.uniforms.permutation = O3[ut], ge.lineWidth(this.contourWidth[ut] * this.pixelRatio);\n                      for (var lt = 0; lt < this.contourLevels[ut].length; ++lt) this._contourCounts[ut][lt] && (Zt.uniforms.height = this.contourLevels[ut][lt], st.draw(ge.LINES, this._contourCounts[ut][lt], this._contourOffsets[ut][lt]));\n                    }\n                    st.unbind();\n                  }\n                }, j3.pick = function(Pe) {\n                  if (!Pe || Pe.id !== this.pickId) return null;\n                  var ge = this._field[2].shape, Re = this._pickResult, ce = ge[0] * (Pe.value[0] + (Pe.value[2] >> 4) / 16) / 255, Ze = Math.floor(ce), ut = ce - Ze, pt = ge[1] * (Pe.value[1] + (Pe.value[2] & 15) / 16) / 255, Zt = Math.floor(pt), st = pt - Zt;\n                  Ze += 1, Zt += 1;\n                  var lt = Re.position;\n                  lt[0] = lt[1] = lt[2] = 0;\n                  for (var Gt = 0; Gt < 2; ++Gt) for (var Nt = Gt ? ut : 1 - ut, Jt = 0; Jt < 2; ++Jt) for (var sr = Jt ? st : 1 - st, wr = Ze + Gt, cr = Zt + Jt, $e = Nt * sr, St = 0; St < 3; ++St) lt[St] += this._field[St].get(wr, cr) * $e;\n                  for (var Qt = this._pickResult.level, Vt = 0; Vt < 3; ++Vt) if (Qt[Vt] = E3.le(this.contourLevels[Vt], lt[Vt]), Qt[Vt] < 0) this.contourLevels[Vt].length > 0 && (Qt[Vt] = 0);\n                  else if (Qt[Vt] < this.contourLevels[Vt].length - 1) {\n                    var _t = this.contourLevels[Vt][Qt[Vt]], It = this.contourLevels[Vt][Qt[Vt] + 1];\n                    Math.abs(_t - lt[Vt]) > Math.abs(It - lt[Vt]) && (Qt[Vt] += 1);\n                  }\n                  for (Re.index[0] = ut < 0.5 ? Ze : Ze + 1, Re.index[1] = st < 0.5 ? Zt : Zt + 1, Re.uv[0] = ce / ge[0], Re.uv[1] = pt / ge[1], St = 0; St < 3; ++St) Re.dataCoordinate[St] = this._field[St].get(Re.index[0], Re.index[1]);\n                  return Re;\n                }, j3.padField = function(Pe, ge) {\n                  var Re = ge.shape.slice(), ce = Pe.shape.slice();\n                  d3.assign(Pe.lo(1, 1).hi(Re[0], Re[1]), ge), d3.assign(Pe.lo(1).hi(Re[0], 1), ge.hi(Re[0], 1)), d3.assign(Pe.lo(1, ce[1] - 1).hi(Re[0], 1), ge.lo(0, Re[1] - 1).hi(Re[0], 1)), d3.assign(Pe.lo(0, 1).hi(1, Re[1]), ge.hi(1)), d3.assign(Pe.lo(ce[0] - 1, 1).hi(1, Re[1]), ge.lo(Re[0] - 1)), Pe.set(0, 0, ge.get(0, 0)), Pe.set(0, ce[1] - 1, ge.get(0, Re[1] - 1)), Pe.set(ce[0] - 1, 0, ge.get(Re[0] - 1, 0)), Pe.set(ce[0] - 1, ce[1] - 1, ge.get(Re[0] - 1, Re[1] - 1));\n                };\n                function Se(Pe, ge) {\n                  return Array.isArray(Pe) ? [ge(Pe[0]), ge(Pe[1]), ge(Pe[2])] : [ge(Pe), ge(Pe), ge(Pe)];\n                }\n                function Le(Pe) {\n                  return Array.isArray(Pe) ? Pe.length === 3 ? [Pe[0], Pe[1], Pe[2], 1] : [Pe[0], Pe[1], Pe[2], Pe[3]] : [0, 0, 0, 1];\n                }\n                function Ae(Pe) {\n                  if (Array.isArray(Pe)) {\n                    if (Array.isArray(Pe)) return [Le(Pe[0]), Le(Pe[1]), Le(Pe[2])];\n                    var ge = Le(Pe);\n                    return [ge.slice(), ge.slice(), ge.slice()];\n                  }\n                }\n                j3.update = function(Pe) {\n                  Pe = Pe || {}, this.objectOffset = Pe.objectOffset || this.objectOffset, this.dirty = true, "contourWidth" in Pe && (this.contourWidth = Se(Pe.contourWidth, Number)), "showContour" in Pe && (this.showContour = Se(Pe.showContour, Boolean)), "showSurface" in Pe && (this.showSurface = !!Pe.showSurface), "contourTint" in Pe && (this.contourTint = Se(Pe.contourTint, Boolean)), "contourColor" in Pe && (this.contourColor = Ae(Pe.contourColor)), "contourProject" in Pe && (this.contourProject = Se(Pe.contourProject, function(yn) {\n                    return Se(yn, Boolean);\n                  })), "surfaceProject" in Pe && (this.surfaceProject = Pe.surfaceProject), "dynamicColor" in Pe && (this.dynamicColor = Ae(Pe.dynamicColor)), "dynamicTint" in Pe && (this.dynamicTint = Se(Pe.dynamicTint, Number)), "dynamicWidth" in Pe && (this.dynamicWidth = Se(Pe.dynamicWidth, Number)), "opacity" in Pe && (this.opacity = Pe.opacity), "opacityscale" in Pe && (this.opacityscale = Pe.opacityscale), "colorBounds" in Pe && (this.colorBounds = Pe.colorBounds), "vertexColor" in Pe && (this.vertexColor = Pe.vertexColor ? 1 : 0), "colormap" in Pe && this._colorMap.setPixels(this.genColormap(Pe.colormap, this.opacityscale));\n                  var ge = Pe.field || Pe.coords && Pe.coords[2] || null, Re = false;\n                  if (ge || (this._field[2].shape[0] || this._field[2].shape[2] ? ge = this._field[2].lo(1, 1).hi(this._field[2].shape[0] - 2, this._field[2].shape[1] - 2) : ge = this._field[2].hi(0, 0)), "field" in Pe || "coords" in Pe) {\n                    var ce = (ge.shape[0] + 2) * (ge.shape[1] + 2);\n                    ce > this._field[2].data.length && (f4.freeFloat(this._field[2].data), this._field[2].data = f4.mallocFloat(s3.nextPow2(ce))), this._field[2] = _2(this._field[2].data, [ge.shape[0] + 2, ge.shape[1] + 2]), this.padField(this._field[2], ge), this.shape = ge.shape.slice();\n                    for (var Ze = this.shape, ut = 0; ut < 2; ++ut) this._field[2].size > this._field[ut].data.length && (f4.freeFloat(this._field[ut].data), this._field[ut].data = f4.mallocFloat(this._field[2].size)), this._field[ut] = _2(this._field[ut].data, [Ze[0] + 2, Ze[1] + 2]);\n                    if (Pe.coords) {\n                      var pt = Pe.coords;\n                      if (!Array.isArray(pt) || pt.length !== 3) throw new Error("gl-surface: invalid coordinates for x/y");\n                      for (ut = 0; ut < 2; ++ut) {\n                        var Zt = pt[ut];\n                        for (Jt = 0; Jt < 2; ++Jt) if (Zt.shape[Jt] !== Ze[Jt]) throw new Error("gl-surface: coords have incorrect shape");\n                        this.padField(this._field[ut], Zt);\n                      }\n                    } else if (Pe.ticks) {\n                      var st = Pe.ticks;\n                      if (!Array.isArray(st) || st.length !== 2) throw new Error("gl-surface: invalid ticks");\n                      for (ut = 0; ut < 2; ++ut) {\n                        var lt = st[ut];\n                        if ((Array.isArray(lt) || lt.length) && (lt = _2(lt)), lt.shape[0] !== Ze[ut]) throw new Error("gl-surface: invalid tick length");\n                        var Gt = _2(lt.data, Ze);\n                        Gt.stride[ut] = lt.stride[0], Gt.stride[ut ^ 1] = 0, this.padField(this._field[ut], Gt);\n                      }\n                    } else {\n                      for (ut = 0; ut < 2; ++ut) {\n                        var Nt = [0, 0];\n                        Nt[ut] = 1, this._field[ut] = _2(this._field[ut].data, [Ze[0] + 2, Ze[1] + 2], Nt, 0);\n                      }\n                      this._field[0].set(0, 0, 0);\n                      for (var Jt = 0; Jt < Ze[0]; ++Jt) this._field[0].set(Jt + 1, 0, Jt);\n                      for (this._field[0].set(Ze[0] + 1, 0, Ze[0] - 1), this._field[1].set(0, 0, 0), Jt = 0; Jt < Ze[1]; ++Jt) this._field[1].set(0, Jt + 1, Jt);\n                      this._field[1].set(0, Ze[1] + 1, Ze[1] - 1);\n                    }\n                    var sr = this._field, wr = _2(f4.mallocFloat(sr[2].size * 3 * 2), [3, Ze[0] + 2, Ze[1] + 2, 2]);\n                    for (ut = 0; ut < 3; ++ut) S2(wr.pick(ut), sr[ut], "mirror");\n                    var cr = _2(f4.mallocFloat(sr[2].size * 3), [Ze[0] + 2, Ze[1] + 2, 3]);\n                    for (ut = 0; ut < Ze[0] + 2; ++ut) for (Jt = 0; Jt < Ze[1] + 2; ++Jt) {\n                      var $e = wr.get(0, ut, Jt, 0), St = wr.get(0, ut, Jt, 1), Qt = wr.get(1, ut, Jt, 0), Vt = wr.get(1, ut, Jt, 1), _t = wr.get(2, ut, Jt, 0), It = wr.get(2, ut, Jt, 1), mt = Qt * It - Vt * _t, er = _t * St - It * $e, lr = $e * Vt - St * Qt, Tr = Math.sqrt(mt * mt + er * er + lr * lr);\n                      Tr < 1e-8 ? (Tr = Math.max(Math.abs(mt), Math.abs(er), Math.abs(lr)), Tr < 1e-8 ? (lr = 1, er = mt = 0, Tr = 1) : Tr = 1 / Tr) : Tr = 1 / Math.sqrt(Tr), cr.set(ut, Jt, 0, mt * Tr), cr.set(ut, Jt, 1, er * Tr), cr.set(ut, Jt, 2, lr * Tr);\n                    }\n                    f4.free(wr.data);\n                    var Lr = [1 / 0, 1 / 0, 1 / 0], ti = [-1 / 0, -1 / 0, -1 / 0], Br = 1 / 0, Vr = -1 / 0, dt = (Ze[0] - 1) * (Ze[1] - 1) * 6, Ge = f4.mallocFloat(s3.nextPow2(10 * dt)), Je = 0, je = 0;\n                    for (ut = 0; ut < Ze[0] - 1; ++ut) e: for (Jt = 0; Jt < Ze[1] - 1; ++Jt) {\n                      for (var tt = 0; tt < 2; ++tt) for (var xt = 0; xt < 2; ++xt) for (var Ie = 0; Ie < 3; ++Ie) {\n                        var xe = this._field[Ie].get(1 + ut + tt, 1 + Jt + xt);\n                        if (isNaN(xe) || !isFinite(xe)) continue e;\n                      }\n                      for (Ie = 0; Ie < 6; ++Ie) {\n                        var ke = ut + z3[Ie][0], vt = Jt + z3[Ie][1], ir = this._field[0].get(ke + 1, vt + 1), ar = this._field[1].get(ke + 1, vt + 1);\n                        xe = this._field[2].get(ke + 1, vt + 1), mt = cr.get(ke + 1, vt + 1, 0), er = cr.get(ke + 1, vt + 1, 1), lr = cr.get(ke + 1, vt + 1, 2), Pe.intensity && (vr = Pe.intensity.get(ke, vt));\n                        var vr = Pe.intensity ? Pe.intensity.get(ke, vt) : xe + this.objectOffset[2];\n                        Ge[Je++] = ke, Ge[Je++] = vt, Ge[Je++] = ir, Ge[Je++] = ar, Ge[Je++] = xe, Ge[Je++] = 0, Ge[Je++] = vr, Ge[Je++] = mt, Ge[Je++] = er, Ge[Je++] = lr, Lr[0] = Math.min(Lr[0], ir + this.objectOffset[0]), Lr[1] = Math.min(Lr[1], ar + this.objectOffset[1]), Lr[2] = Math.min(Lr[2], xe + this.objectOffset[2]), Br = Math.min(Br, vr), ti[0] = Math.max(ti[0], ir + this.objectOffset[0]), ti[1] = Math.max(ti[1], ar + this.objectOffset[1]), ti[2] = Math.max(ti[2], xe + this.objectOffset[2]), Vr = Math.max(Vr, vr), je += 1;\n                      }\n                    }\n                    for (Pe.intensityBounds && (Br = +Pe.intensityBounds[0], Vr = +Pe.intensityBounds[1]), ut = 6; ut < Je; ut += 10) Ge[ut] = (Ge[ut] - Br) / (Vr - Br);\n                    this._vertexCount = je, this._coordinateBuffer.update(Ge.subarray(0, Je)), f4.freeFloat(Ge), f4.free(cr.data), this.bounds = [Lr, ti], this.intensity = Pe.intensity || this._field[2], (this.intensityBounds[0] !== Br || this.intensityBounds[1] !== Vr) && (Re = true), this.intensityBounds = [Br, Vr];\n                  }\n                  if ("levels" in Pe) {\n                    var ii = Pe.levels;\n                    for (Array.isArray(ii[0]) ? ii = ii.slice() : ii = [[], [], ii], ut = 0; ut < 3; ++ut) ii[ut] = ii[ut].slice(), ii[ut].sort(function(yn, Sn) {\n                      return yn - Sn;\n                    });\n                    for (ut = 0; ut < 3; ++ut) for (Jt = 0; Jt < ii[ut].length; ++Jt) ii[ut][Jt] -= this.objectOffset[ut];\n                    e: for (ut = 0; ut < 3; ++ut) {\n                      if (ii[ut].length !== this.contourLevels[ut].length) {\n                        Re = true;\n                        break;\n                      }\n                      for (Jt = 0; Jt < ii[ut].length; ++Jt) if (ii[ut][Jt] !== this.contourLevels[ut][Jt]) {\n                        Re = true;\n                        break e;\n                      }\n                    }\n                    this.contourLevels = ii;\n                  }\n                  if (Re) {\n                    sr = this._field, Ze = this.shape;\n                    for (var pi = [], $r = 0; $r < 3; ++$r) {\n                      var di = this.contourLevels[$r], ji = [], In = [], wi = [0, 0, 0];\n                      for (ut = 0; ut < di.length; ++ut) {\n                        var On = b(this._field[$r], di[ut]);\n                        ji.push(pi.length / 5 | 0), je = 0;\n                        e: for (Jt = 0; Jt < On.cells.length; ++Jt) {\n                          var qn = On.cells[Jt];\n                          for (Ie = 0; Ie < 2; ++Ie) {\n                            var Fn = On.positions[qn[Ie]], ra = Fn[0], la = Math.floor(ra) | 0, Ut = ra - la, wt = Fn[1], rr = Math.floor(wt) | 0, nr = wt - rr, Er = false;\n                            t: for (var Xr = 0; Xr < 3; ++Xr) {\n                              wi[Xr] = 0;\n                              var ri = ($r + Xr + 1) % 3;\n                              for (tt = 0; tt < 2; ++tt) {\n                                var Qr = tt ? Ut : 1 - Ut;\n                                for (ke = Math.min(Math.max(la + tt, 0), Ze[0]) | 0, xt = 0; xt < 2; ++xt) {\n                                  var Oi = xt ? nr : 1 - nr;\n                                  if (vt = Math.min(Math.max(rr + xt, 0), Ze[1]) | 0, Xr < 2 ? xe = this._field[ri].get(ke, vt) : xe = (this.intensity.get(ke, vt) - this.intensityBounds[0]) / (this.intensityBounds[1] - this.intensityBounds[0]), !isFinite(xe) || isNaN(xe)) {\n                                    Er = true;\n                                    break t;\n                                  }\n                                  var $i = Qr * Oi;\n                                  wi[Xr] += $i * xe;\n                                }\n                              }\n                            }\n                            if (!Er) pi.push(wi[0], wi[1], Fn[0], Fn[1], wi[2]), je += 1;\n                            else {\n                              if (Ie > 0) {\n                                for (var tn = 0; tn < 5; ++tn) pi.pop();\n                                je -= 1;\n                              }\n                              continue e;\n                            }\n                          }\n                        }\n                        In.push(je);\n                      }\n                      this._contourOffsets[$r] = ji, this._contourCounts[$r] = In;\n                    }\n                    var fn = f4.mallocFloat(pi.length);\n                    for (ut = 0; ut < pi.length; ++ut) fn[ut] = pi[ut];\n                    this._contourBuffer.update(fn), f4.freeFloat(fn);\n                  }\n                }, j3.dispose = function() {\n                  this._shader.dispose(), this._vao.dispose(), this._coordinateBuffer.dispose(), this._colorMap.dispose(), this._contourBuffer.dispose(), this._contourVAO.dispose(), this._contourShader.dispose(), this._contourPickShader.dispose(), this._dynamicBuffer.dispose(), this._dynamicVAO.dispose();\n                  for (var Pe = 0; Pe < 3; ++Pe) f4.freeFloat(this._field[Pe].data);\n                }, j3.highlight = function(Pe) {\n                  var ge;\n                  if (!Pe) {\n                    this._dynamicCounts = [0, 0, 0], this.dyanamicLevel = [NaN, NaN, NaN], this.highlightLevel = [-1, -1, -1];\n                    return;\n                  }\n                  for (ge = 0; ge < 3; ++ge) this.enableHighlight[ge] ? this.highlightLevel[ge] = Pe.level[ge] : this.highlightLevel[ge] = -1;\n                  var Re;\n                  for (this.snapToData ? Re = Pe.dataCoordinate : Re = Pe.position, ge = 0; ge < 3; ++ge) Re[ge] -= this.objectOffset[ge];\n                  if (!((!this.enableDynamic[0] || Re[0] === this.dynamicLevel[0]) && (!this.enableDynamic[1] || Re[1] === this.dynamicLevel[1]) && (!this.enableDynamic[2] || Re[2] === this.dynamicLevel[2]))) {\n                    for (var ce = 0, Ze = this.shape, ut = f4.mallocFloat(12 * Ze[0] * Ze[1]), pt = 0; pt < 3; ++pt) {\n                      if (!this.enableDynamic[pt]) {\n                        this.dynamicLevel[pt] = NaN, this._dynamicCounts[pt] = 0;\n                        continue;\n                      }\n                      this.dynamicLevel[pt] = Re[pt];\n                      var Zt = (pt + 1) % 3, st = (pt + 2) % 3, lt = this._field[pt], Gt = this._field[Zt], Nt = this._field[st], Jt = b(lt, Re[pt]), sr = Jt.cells, wr = Jt.positions;\n                      for (this._dynamicOffsets[pt] = ce, ge = 0; ge < sr.length; ++ge) for (var cr = sr[ge], $e = 0; $e < 2; ++$e) {\n                        var St = wr[cr[$e]], Qt = +St[0], Vt = Qt | 0, _t = Math.min(Vt + 1, Ze[0]) | 0, It = Qt - Vt, mt = 1 - It, er = +St[1], lr = er | 0, Tr = Math.min(lr + 1, Ze[1]) | 0, Lr = er - lr, ti = 1 - Lr, Br = mt * ti, Vr = mt * Lr, dt = It * ti, Ge = It * Lr, Je = Br * Gt.get(Vt, lr) + Vr * Gt.get(Vt, Tr) + dt * Gt.get(_t, lr) + Ge * Gt.get(_t, Tr), je = Br * Nt.get(Vt, lr) + Vr * Nt.get(Vt, Tr) + dt * Nt.get(_t, lr) + Ge * Nt.get(_t, Tr);\n                        if (isNaN(Je) || isNaN(je)) {\n                          $e && (ce -= 1);\n                          break;\n                        }\n                        ut[2 * ce + 0] = Je, ut[2 * ce + 1] = je, ce += 1;\n                      }\n                      this._dynamicCounts[pt] = ce - this._dynamicOffsets[pt];\n                    }\n                    this._dynamicBuffer.update(ut.subarray(0, 2 * ce)), f4.freeFloat(ut);\n                  }\n                };\n                function Fe(Pe) {\n                  var ge = Pe.gl, Re = x2(ge), ce = M4(ge), Ze = C3(ge), ut = g3(ge), pt = l3(ge), Zt = u4(ge, [{ buffer: pt, size: 4, stride: P3, offset: 0 }, { buffer: pt, size: 3, stride: P3, offset: 16 }, { buffer: pt, size: 3, stride: P3, offset: 28 }]), st = l3(ge), lt = u4(ge, [{ buffer: st, size: 4, stride: 20, offset: 0 }, { buffer: st, size: 1, stride: 20, offset: 16 }]), Gt = l3(ge), Nt = u4(ge, [{ buffer: Gt, size: 2, type: ge.FLOAT }]), Jt = c5(ge, 1, G2, ge.RGBA, ge.UNSIGNED_BYTE);\n                  Jt.minFilter = ge.LINEAR, Jt.magFilter = ge.LINEAR;\n                  var sr = new Z(ge, [0, 0], [[0, 0, 0], [0, 0, 0]], Re, ce, pt, Zt, Jt, Ze, ut, st, lt, Gt, Nt, [0, 0, 0]), wr = { levels: [[], [], []] };\n                  for (var cr in Pe) wr[cr] = Pe[cr];\n                  return wr.colormap = wr.colormap || "jet", sr.update(wr), sr;\n                }\n              }, 9507: function(i3) {\n                i3.exports = true;\n              }, 9618: function(i3, a4, o4) {\n                var s3 = o4(7163), l3 = typeof Float64Array != "undefined";\n                function u4(b, p3) {\n                  return b[0] - p3[0];\n                }\n                function c5() {\n                  var b = this.stride, p3 = new Array(b.length), k4;\n                  for (k4 = 0; k4 < p3.length; ++k4) p3[k4] = [Math.abs(b[k4]), k4];\n                  p3.sort(u4);\n                  var E3 = new Array(p3.length);\n                  for (k4 = 0; k4 < E3.length; ++k4) E3[k4] = p3[k4][1];\n                  return E3;\n                }\n                var f4 = { T: function(b) {\n                  function p3(E3) {\n                    this.data = E3;\n                  }\n                  var k4 = p3.prototype;\n                  return k4.dtype = b, k4.index = function() {\n                    return -1;\n                  }, k4.size = 0, k4.dimension = -1, k4.shape = k4.stride = k4.order = [], k4.lo = k4.hi = k4.transpose = k4.step = function() {\n                    return new p3(this.data);\n                  }, k4.get = k4.set = function() {\n                  }, k4.pick = function() {\n                    return null;\n                  }, function(S2) {\n                    return new p3(S2);\n                  };\n                }, 0: function(b, p3) {\n                  function k4(S2, L3) {\n                    this.data = S2, this.offset = L3;\n                  }\n                  var E3 = k4.prototype;\n                  return E3.dtype = b, E3.index = function() {\n                    return this.offset;\n                  }, E3.dimension = 0, E3.size = 1, E3.shape = E3.stride = E3.order = [], E3.lo = E3.hi = E3.transpose = E3.step = function() {\n                    return new k4(this.data, this.offset);\n                  }, E3.pick = function() {\n                    return p3(this.data);\n                  }, E3.valueOf = E3.get = function() {\n                    return b === "generic" ? this.data.get(this.offset) : this.data[this.offset];\n                  }, E3.set = function(L3) {\n                    return b === "generic" ? this.data.set(this.offset, L3) : this.data[this.offset] = L3;\n                  }, function(L3, x2, C3, M4) {\n                    return new k4(L3, M4);\n                  };\n                }, 1: function(b, p3, k4) {\n                  function E3(L3, x2, C3, M4) {\n                    this.data = L3, this.shape = [x2], this.stride = [C3], this.offset = M4 | 0;\n                  }\n                  var S2 = E3.prototype;\n                  return S2.dtype = b, S2.dimension = 1, Object.defineProperty(S2, "size", { get: function() {\n                    return this.shape[0];\n                  } }), S2.order = [0], S2.set = function(x2, C3) {\n                    return b === "generic" ? this.data.set(this.offset + this.stride[0] * x2, C3) : this.data[this.offset + this.stride[0] * x2] = C3;\n                  }, S2.get = function(x2) {\n                    return b === "generic" ? this.data.get(this.offset + this.stride[0] * x2) : this.data[this.offset + this.stride[0] * x2];\n                  }, S2.index = function(x2) {\n                    return this.offset + this.stride[0] * x2;\n                  }, S2.hi = function(x2) {\n                    return new E3(this.data, typeof x2 != "number" || x2 < 0 ? this.shape[0] : x2 | 0, this.stride[0], this.offset);\n                  }, S2.lo = function(x2) {\n                    var C3 = this.offset, M4 = 0, g3 = this.shape[0], P3 = this.stride[0];\n                    return typeof x2 == "number" && x2 >= 0 && (M4 = x2 | 0, C3 += P3 * M4, g3 -= M4), new E3(this.data, g3, P3, C3);\n                  }, S2.step = function(x2) {\n                    var C3 = this.shape[0], M4 = this.stride[0], g3 = this.offset, P3 = 0, T3 = Math.ceil;\n                    return typeof x2 == "number" && (P3 = x2 | 0, P3 < 0 ? (g3 += M4 * (C3 - 1), C3 = T3(-C3 / P3)) : C3 = T3(C3 / P3), M4 *= P3), new E3(this.data, C3, M4, g3);\n                  }, S2.transpose = function(x2) {\n                    x2 = x2 === void 0 ? 0 : x2 | 0;\n                    var C3 = this.shape, M4 = this.stride;\n                    return new E3(this.data, C3[x2], M4[x2], this.offset);\n                  }, S2.pick = function(x2) {\n                    var C3 = [], M4 = [], g3 = this.offset;\n                    typeof x2 == "number" && x2 >= 0 ? g3 = g3 + this.stride[0] * x2 | 0 : (C3.push(this.shape[0]), M4.push(this.stride[0]));\n                    var P3 = p3[C3.length + 1];\n                    return P3(this.data, C3, M4, g3);\n                  }, function(x2, C3, M4, g3) {\n                    return new E3(x2, C3[0], M4[0], g3);\n                  };\n                }, 2: function(b, p3, k4) {\n                  function E3(L3, x2, C3, M4, g3, P3) {\n                    this.data = L3, this.shape = [x2, C3], this.stride = [M4, g3], this.offset = P3 | 0;\n                  }\n                  var S2 = E3.prototype;\n                  return S2.dtype = b, S2.dimension = 2, Object.defineProperty(S2, "size", { get: function() {\n                    return this.shape[0] * this.shape[1];\n                  } }), Object.defineProperty(S2, "order", { get: function() {\n                    return Math.abs(this.stride[0]) > Math.abs(this.stride[1]) ? [1, 0] : [0, 1];\n                  } }), S2.set = function(x2, C3, M4) {\n                    return b === "generic" ? this.data.set(this.offset + this.stride[0] * x2 + this.stride[1] * C3, M4) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3] = M4;\n                  }, S2.get = function(x2, C3) {\n                    return b === "generic" ? this.data.get(this.offset + this.stride[0] * x2 + this.stride[1] * C3) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3];\n                  }, S2.index = function(x2, C3) {\n                    return this.offset + this.stride[0] * x2 + this.stride[1] * C3;\n                  }, S2.hi = function(x2, C3) {\n                    return new E3(this.data, typeof x2 != "number" || x2 < 0 ? this.shape[0] : x2 | 0, typeof C3 != "number" || C3 < 0 ? this.shape[1] : C3 | 0, this.stride[0], this.stride[1], this.offset);\n                  }, S2.lo = function(x2, C3) {\n                    var M4 = this.offset, g3 = 0, P3 = this.shape[0], T3 = this.shape[1], z3 = this.stride[0], O3 = this.stride[1];\n                    return typeof x2 == "number" && x2 >= 0 && (g3 = x2 | 0, M4 += z3 * g3, P3 -= g3), typeof C3 == "number" && C3 >= 0 && (g3 = C3 | 0, M4 += O3 * g3, T3 -= g3), new E3(this.data, P3, T3, z3, O3, M4);\n                  }, S2.step = function(x2, C3) {\n                    var M4 = this.shape[0], g3 = this.shape[1], P3 = this.stride[0], T3 = this.stride[1], z3 = this.offset, O3 = 0, V2 = Math.ceil;\n                    return typeof x2 == "number" && (O3 = x2 | 0, O3 < 0 ? (z3 += P3 * (M4 - 1), M4 = V2(-M4 / O3)) : M4 = V2(M4 / O3), P3 *= O3), typeof C3 == "number" && (O3 = C3 | 0, O3 < 0 ? (z3 += T3 * (g3 - 1), g3 = V2(-g3 / O3)) : g3 = V2(g3 / O3), T3 *= O3), new E3(this.data, M4, g3, P3, T3, z3);\n                  }, S2.transpose = function(x2, C3) {\n                    x2 = x2 === void 0 ? 0 : x2 | 0, C3 = C3 === void 0 ? 1 : C3 | 0;\n                    var M4 = this.shape, g3 = this.stride;\n                    return new E3(this.data, M4[x2], M4[C3], g3[x2], g3[C3], this.offset);\n                  }, S2.pick = function(x2, C3) {\n                    var M4 = [], g3 = [], P3 = this.offset;\n                    typeof x2 == "number" && x2 >= 0 ? P3 = P3 + this.stride[0] * x2 | 0 : (M4.push(this.shape[0]), g3.push(this.stride[0])), typeof C3 == "number" && C3 >= 0 ? P3 = P3 + this.stride[1] * C3 | 0 : (M4.push(this.shape[1]), g3.push(this.stride[1]));\n                    var T3 = p3[M4.length + 1];\n                    return T3(this.data, M4, g3, P3);\n                  }, function(x2, C3, M4, g3) {\n                    return new E3(x2, C3[0], C3[1], M4[0], M4[1], g3);\n                  };\n                }, 3: function(b, p3, k4) {\n                  function E3(L3, x2, C3, M4, g3, P3, T3, z3) {\n                    this.data = L3, this.shape = [x2, C3, M4], this.stride = [g3, P3, T3], this.offset = z3 | 0;\n                  }\n                  var S2 = E3.prototype;\n                  return S2.dtype = b, S2.dimension = 3, Object.defineProperty(S2, "size", { get: function() {\n                    return this.shape[0] * this.shape[1] * this.shape[2];\n                  } }), Object.defineProperty(S2, "order", { get: function() {\n                    var x2 = Math.abs(this.stride[0]), C3 = Math.abs(this.stride[1]), M4 = Math.abs(this.stride[2]);\n                    return x2 > C3 ? C3 > M4 ? [2, 1, 0] : x2 > M4 ? [1, 2, 0] : [1, 0, 2] : x2 > M4 ? [2, 0, 1] : M4 > C3 ? [0, 1, 2] : [0, 2, 1];\n                  } }), S2.set = function(x2, C3, M4, g3) {\n                    return b === "generic" ? this.data.set(this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4, g3) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4] = g3;\n                  }, S2.get = function(x2, C3, M4) {\n                    return b === "generic" ? this.data.get(this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4];\n                  }, S2.index = function(x2, C3, M4) {\n                    return this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4;\n                  }, S2.hi = function(x2, C3, M4) {\n                    return new E3(this.data, typeof x2 != "number" || x2 < 0 ? this.shape[0] : x2 | 0, typeof C3 != "number" || C3 < 0 ? this.shape[1] : C3 | 0, typeof M4 != "number" || M4 < 0 ? this.shape[2] : M4 | 0, this.stride[0], this.stride[1], this.stride[2], this.offset);\n                  }, S2.lo = function(x2, C3, M4) {\n                    var g3 = this.offset, P3 = 0, T3 = this.shape[0], z3 = this.shape[1], O3 = this.shape[2], V2 = this.stride[0], G2 = this.stride[1], Z = this.stride[2];\n                    return typeof x2 == "number" && x2 >= 0 && (P3 = x2 | 0, g3 += V2 * P3, T3 -= P3), typeof C3 == "number" && C3 >= 0 && (P3 = C3 | 0, g3 += G2 * P3, z3 -= P3), typeof M4 == "number" && M4 >= 0 && (P3 = M4 | 0, g3 += Z * P3, O3 -= P3), new E3(this.data, T3, z3, O3, V2, G2, Z, g3);\n                  }, S2.step = function(x2, C3, M4) {\n                    var g3 = this.shape[0], P3 = this.shape[1], T3 = this.shape[2], z3 = this.stride[0], O3 = this.stride[1], V2 = this.stride[2], G2 = this.offset, Z = 0, j3 = Math.ceil;\n                    return typeof x2 == "number" && (Z = x2 | 0, Z < 0 ? (G2 += z3 * (g3 - 1), g3 = j3(-g3 / Z)) : g3 = j3(g3 / Z), z3 *= Z), typeof C3 == "number" && (Z = C3 | 0, Z < 0 ? (G2 += O3 * (P3 - 1), P3 = j3(-P3 / Z)) : P3 = j3(P3 / Z), O3 *= Z), typeof M4 == "number" && (Z = M4 | 0, Z < 0 ? (G2 += V2 * (T3 - 1), T3 = j3(-T3 / Z)) : T3 = j3(T3 / Z), V2 *= Z), new E3(this.data, g3, P3, T3, z3, O3, V2, G2);\n                  }, S2.transpose = function(x2, C3, M4) {\n                    x2 = x2 === void 0 ? 0 : x2 | 0, C3 = C3 === void 0 ? 1 : C3 | 0, M4 = M4 === void 0 ? 2 : M4 | 0;\n                    var g3 = this.shape, P3 = this.stride;\n                    return new E3(this.data, g3[x2], g3[C3], g3[M4], P3[x2], P3[C3], P3[M4], this.offset);\n                  }, S2.pick = function(x2, C3, M4) {\n                    var g3 = [], P3 = [], T3 = this.offset;\n                    typeof x2 == "number" && x2 >= 0 ? T3 = T3 + this.stride[0] * x2 | 0 : (g3.push(this.shape[0]), P3.push(this.stride[0])), typeof C3 == "number" && C3 >= 0 ? T3 = T3 + this.stride[1] * C3 | 0 : (g3.push(this.shape[1]), P3.push(this.stride[1])), typeof M4 == "number" && M4 >= 0 ? T3 = T3 + this.stride[2] * M4 | 0 : (g3.push(this.shape[2]), P3.push(this.stride[2]));\n                    var z3 = p3[g3.length + 1];\n                    return z3(this.data, g3, P3, T3);\n                  }, function(x2, C3, M4, g3) {\n                    return new E3(x2, C3[0], C3[1], C3[2], M4[0], M4[1], M4[2], g3);\n                  };\n                }, 4: function(b, p3, k4) {\n                  function E3(L3, x2, C3, M4, g3, P3, T3, z3, O3, V2) {\n                    this.data = L3, this.shape = [x2, C3, M4, g3], this.stride = [P3, T3, z3, O3], this.offset = V2 | 0;\n                  }\n                  var S2 = E3.prototype;\n                  return S2.dtype = b, S2.dimension = 4, Object.defineProperty(S2, "size", { get: function() {\n                    return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3];\n                  } }), Object.defineProperty(S2, "order", { get: k4 }), S2.set = function(x2, C3, M4, g3, P3) {\n                    return b === "generic" ? this.data.set(this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4 + this.stride[3] * g3, P3) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4 + this.stride[3] * g3] = P3;\n                  }, S2.get = function(x2, C3, M4, g3) {\n                    return b === "generic" ? this.data.get(this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4 + this.stride[3] * g3) : this.data[this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4 + this.stride[3] * g3];\n                  }, S2.index = function(x2, C3, M4, g3) {\n                    return this.offset + this.stride[0] * x2 + this.stride[1] * C3 + this.stride[2] * M4 + this.stride[3] * g3;\n                  }, S2.hi = function(x2, C3, M4, g3) {\n                    return new E3(this.data, typeof x2 != "number" || x2 < 0 ? this.shape[0] : x2 | 0, typeof C3 != "number" || C3 < 0 ? this.shape[1] : C3 | 0, typeof M4 != "number" || M4 < 0 ? this.shape[2] : M4 | 0, typeof g3 != "number" || g3 < 0 ? this.shape[3] : g3 | 0, this.stride[0], this.stride[1], this.stride[2], this.stride[3], this.offset);\n                  }, S2.lo = function(x2, C3, M4, g3) {\n                    var P3 = this.offset, T3 = 0, z3 = this.shape[0], O3 = this.shape[1], V2 = this.shape[2], G2 = this.shape[3], Z = this.stride[0], j3 = this.stride[1], N2 = this.stride[2], H = this.stride[3];\n                    return typeof x2 == "number" && x2 >= 0 && (T3 = x2 | 0, P3 += Z * T3, z3 -= T3), typeof C3 == "number" && C3 >= 0 && (T3 = C3 | 0, P3 += j3 * T3, O3 -= T3), typeof M4 == "number" && M4 >= 0 && (T3 = M4 | 0, P3 += N2 * T3, V2 -= T3), typeof g3 == "number" && g3 >= 0 && (T3 = g3 | 0, P3 += H * T3, G2 -= T3), new E3(this.data, z3, O3, V2, G2, Z, j3, N2, H, P3);\n                  }, S2.step = function(x2, C3, M4, g3) {\n                    var P3 = this.shape[0], T3 = this.shape[1], z3 = this.shape[2], O3 = this.shape[3], V2 = this.stride[0], G2 = this.stride[1], Z = this.stride[2], j3 = this.stride[3], N2 = this.offset, H = 0, te = Math.ceil;\n                    return typeof x2 == "number" && (H = x2 | 0, H < 0 ? (N2 += V2 * (P3 - 1), P3 = te(-P3 / H)) : P3 = te(P3 / H), V2 *= H), typeof C3 == "number" && (H = C3 | 0, H < 0 ? (N2 += G2 * (T3 - 1), T3 = te(-T3 / H)) : T3 = te(T3 / H), G2 *= H), typeof M4 == "number" && (H = M4 | 0, H < 0 ? (N2 += Z * (z3 - 1), z3 = te(-z3 / H)) : z3 = te(z3 / H), Z *= H), typeof g3 == "number" && (H = g3 | 0, H < 0 ? (N2 += j3 * (O3 - 1), O3 = te(-O3 / H)) : O3 = te(O3 / H), j3 *= H), new E3(this.data, P3, T3, z3, O3, V2, G2, Z, j3, N2);\n                  }, S2.transpose = function(x2, C3, M4, g3) {\n                    x2 = x2 === void 0 ? 0 : x2 | 0, C3 = C3 === void 0 ? 1 : C3 | 0, M4 = M4 === void 0 ? 2 : M4 | 0, g3 = g3 === void 0 ? 3 : g3 | 0;\n                    var P3 = this.shape, T3 = this.stride;\n                    return new E3(this.data, P3[x2], P3[C3], P3[M4], P3[g3], T3[x2], T3[C3], T3[M4], T3[g3], this.offset);\n                  }, S2.pick = function(x2, C3, M4, g3) {\n                    var P3 = [], T3 = [], z3 = this.offset;\n                    typeof x2 == "number" && x2 >= 0 ? z3 = z3 + this.stride[0] * x2 | 0 : (P3.push(this.shape[0]), T3.push(this.stride[0])), typeof C3 == "number" && C3 >= 0 ? z3 = z3 + this.stride[1] * C3 | 0 : (P3.push(this.shape[1]), T3.push(this.stride[1])), typeof M4 == "number" && M4 >= 0 ? z3 = z3 + this.stride[2] * M4 | 0 : (P3.push(this.shape[2]), T3.push(this.stride[2])), typeof g3 == "number" && g3 >= 0 ? z3 = z3 + this.stride[3] * g3 | 0 : (P3.push(this.shape[3]), T3.push(this.stride[3]));\n                    var O3 = p3[P3.length + 1];\n                    return O3(this.data, P3, T3, z3);\n                  }, function(x2, C3, M4, g3) {\n                    return new E3(x2, C3[0], C3[1], C3[2], C3[3], M4[0], M4[1], M4[2], M4[3], g3);\n                  };\n                }, 5: function(p3, k4, E3) {\n                  function S2(x2, C3, M4, g3, P3, T3, z3, O3, V2, G2, Z, j3) {\n                    this.data = x2, this.shape = [C3, M4, g3, P3, T3], this.stride = [z3, O3, V2, G2, Z], this.offset = j3 | 0;\n                  }\n                  var L3 = S2.prototype;\n                  return L3.dtype = p3, L3.dimension = 5, Object.defineProperty(L3, "size", { get: function() {\n                    return this.shape[0] * this.shape[1] * this.shape[2] * this.shape[3] * this.shape[4];\n                  } }), Object.defineProperty(L3, "order", { get: E3 }), L3.set = function(C3, M4, g3, P3, T3, z3) {\n                    return p3 === "generic" ? this.data.set(this.offset + this.stride[0] * C3 + this.stride[1] * M4 + this.stride[2] * g3 + this.stride[3] * P3 + this.stride[4] * T3, z3) : this.data[this.offset + this.stride[0] * C3 + this.stride[1] * M4 + this.stride[2] * g3 + this.stride[3] * P3 + this.stride[4] * T3] = z3;\n                  }, L3.get = function(C3, M4, g3, P3, T3) {\n                    return p3 === "generic" ? this.data.get(this.offset + this.stride[0] * C3 + this.stride[1] * M4 + this.stride[2] * g3 + this.stride[3] * P3 + this.stride[4] * T3) : this.data[this.offset + this.stride[0] * C3 + this.stride[1] * M4 + this.stride[2] * g3 + this.stride[3] * P3 + this.stride[4] * T3];\n                  }, L3.index = function(C3, M4, g3, P3, T3) {\n                    return this.offset + this.stride[0] * C3 + this.stride[1] * M4 + this.stride[2] * g3 + this.stride[3] * P3 + this.stride[4] * T3;\n                  }, L3.hi = function(C3, M4, g3, P3, T3) {\n                    return new S2(this.data, typeof C3 != "number" || C3 < 0 ? this.shape[0] : C3 | 0, typeof M4 != "number" || M4 < 0 ? this.shape[1] : M4 | 0, typeof g3 != "number" || g3 < 0 ? this.shape[2] : g3 | 0, typeof P3 != "number" || P3 < 0 ? this.shape[3] : P3 | 0, typeof T3 != "number" || T3 < 0 ? this.shape[4] : T3 | 0, this.stride[0], this.stride[1], this.stride[2], this.stride[3], this.stride[4], this.offset);\n                  }, L3.lo = function(C3, M4, g3, P3, T3) {\n                    var z3 = this.offset, O3 = 0, V2 = this.shape[0], G2 = this.shape[1], Z = this.shape[2], j3 = this.shape[3], N2 = this.shape[4], H = this.stride[0], te = this.stride[1], oe = this.stride[2], _e = this.stride[3], Ee = this.stride[4];\n                    return typeof C3 == "number" && C3 >= 0 && (O3 = C3 | 0, z3 += H * O3, V2 -= O3), typeof M4 == "number" && M4 >= 0 && (O3 = M4 | 0, z3 += te * O3, G2 -= O3), typeof g3 == "number" && g3 >= 0 && (O3 = g3 | 0, z3 += oe * O3, Z -= O3), typeof P3 == "number" && P3 >= 0 && (O3 = P3 | 0, z3 += _e * O3, j3 -= O3), typeof T3 == "number" && T3 >= 0 && (O3 = T3 | 0, z3 += Ee * O3, N2 -= O3), new S2(this.data, V2, G2, Z, j3, N2, H, te, oe, _e, Ee, z3);\n                  }, L3.step = function(C3, M4, g3, P3, T3) {\n                    var z3 = this.shape[0], O3 = this.shape[1], V2 = this.shape[2], G2 = this.shape[3], Z = this.shape[4], j3 = this.stride[0], N2 = this.stride[1], H = this.stride[2], te = this.stride[3], oe = this.stride[4], _e = this.offset, Ee = 0, Ce = Math.ceil;\n                    return typeof C3 == "number" && (Ee = C3 | 0, Ee < 0 ? (_e += j3 * (z3 - 1), z3 = Ce(-z3 / Ee)) : z3 = Ce(z3 / Ee), j3 *= Ee), typeof M4 == "number" && (Ee = M4 | 0, Ee < 0 ? (_e += N2 * (O3 - 1), O3 = Ce(-O3 / Ee)) : O3 = Ce(O3 / Ee), N2 *= Ee), typeof g3 == "number" && (Ee = g3 | 0, Ee < 0 ? (_e += H * (V2 - 1), V2 = Ce(-V2 / Ee)) : V2 = Ce(V2 / Ee), H *= Ee), typeof P3 == "number" && (Ee = P3 | 0, Ee < 0 ? (_e += te * (G2 - 1), G2 = Ce(-G2 / Ee)) : G2 = Ce(G2 / Ee), te *= Ee), typeof T3 == "number" && (Ee = T3 | 0, Ee < 0 ? (_e += oe * (Z - 1), Z = Ce(-Z / Ee)) : Z = Ce(Z / Ee), oe *= Ee), new S2(this.data, z3, O3, V2, G2, Z, j3, N2, H, te, oe, _e);\n                  }, L3.transpose = function(C3, M4, g3, P3, T3) {\n                    C3 = C3 === void 0 ? 0 : C3 | 0, M4 = M4 === void 0 ? 1 : M4 | 0, g3 = g3 === void 0 ? 2 : g3 | 0, P3 = P3 === void 0 ? 3 : P3 | 0, T3 = T3 === void 0 ? 4 : T3 | 0;\n                    var z3 = this.shape, O3 = this.stride;\n                    return new S2(this.data, z3[C3], z3[M4], z3[g3], z3[P3], z3[T3], O3[C3], O3[M4], O3[g3], O3[P3], O3[T3], this.offset);\n                  }, L3.pick = function(C3, M4, g3, P3, T3) {\n                    var z3 = [], O3 = [], V2 = this.offset;\n                    typeof C3 == "number" && C3 >= 0 ? V2 = V2 + this.stride[0] * C3 | 0 : (z3.push(this.shape[0]), O3.push(this.stride[0])), typeof M4 == "number" && M4 >= 0 ? V2 = V2 + this.stride[1] * M4 | 0 : (z3.push(this.shape[1]), O3.push(this.stride[1])), typeof g3 == "number" && g3 >= 0 ? V2 = V2 + this.stride[2] * g3 | 0 : (z3.push(this.shape[2]), O3.push(this.stride[2])), typeof P3 == "number" && P3 >= 0 ? V2 = V2 + this.stride[3] * P3 | 0 : (z3.push(this.shape[3]), O3.push(this.stride[3])), typeof T3 == "number" && T3 >= 0 ? V2 = V2 + this.stride[4] * T3 | 0 : (z3.push(this.shape[4]), O3.push(this.stride[4]));\n                    var G2 = k4[z3.length + 1];\n                    return G2(this.data, z3, O3, V2);\n                  }, function(C3, M4, g3, P3) {\n                    return new S2(C3, M4[0], M4[1], M4[2], M4[3], M4[4], g3[0], g3[1], g3[2], g3[3], g3[4], P3);\n                  };\n                } };\n                function h3(b, p3) {\n                  var k4 = p3 === -1 ? "T" : String(p3), E3 = f4[k4];\n                  return p3 === -1 ? E3(b) : p3 === 0 ? E3(b, v3[b][0]) : E3(b, v3[b], c5);\n                }\n                function d3(b) {\n                  if (s3(b)) return "buffer";\n                  if (l3) switch (Object.prototype.toString.call(b)) {\n                    case "[object Float64Array]":\n                      return "float64";\n                    case "[object Float32Array]":\n                      return "float32";\n                    case "[object Int8Array]":\n                      return "int8";\n                    case "[object Int16Array]":\n                      return "int16";\n                    case "[object Int32Array]":\n                      return "int32";\n                    case "[object Uint8ClampedArray]":\n                      return "uint8_clamped";\n                    case "[object Uint8Array]":\n                      return "uint8";\n                    case "[object Uint16Array]":\n                      return "uint16";\n                    case "[object Uint32Array]":\n                      return "uint32";\n                    case "[object BigInt64Array]":\n                      return "bigint64";\n                    case "[object BigUint64Array]":\n                      return "biguint64";\n                  }\n                  return Array.isArray(b) ? "array" : "generic";\n                }\n                var v3 = { generic: [], buffer: [], array: [], float32: [], float64: [], int8: [], int16: [], int32: [], uint8_clamped: [], uint8: [], uint16: [], uint32: [], bigint64: [], biguint64: [] };\n                function _2(b, p3, k4, E3) {\n                  if (b === void 0) {\n                    var g3 = v3.array[0];\n                    return g3([]);\n                  } else typeof b == "number" && (b = [b]);\n                  p3 === void 0 && (p3 = [b.length]);\n                  var S2 = p3.length;\n                  if (k4 === void 0) {\n                    k4 = new Array(S2);\n                    for (var L3 = S2 - 1, x2 = 1; L3 >= 0; --L3) k4[L3] = x2, x2 *= p3[L3];\n                  }\n                  if (E3 === void 0) {\n                    E3 = 0;\n                    for (var L3 = 0; L3 < S2; ++L3) k4[L3] < 0 && (E3 -= (p3[L3] - 1) * k4[L3]);\n                  }\n                  for (var C3 = d3(b), M4 = v3[C3]; M4.length <= S2 + 1; ) M4.push(h3(C3, M4.length - 1));\n                  var g3 = M4[S2 + 1];\n                  return g3(b, p3, k4, E3);\n                }\n                i3.exports = _2;\n              }, 9921: function(i3) {\n                i3.exports = a4;\n                function a4(o4) {\n                  var s3 = o4[0], l3 = o4[1], u4 = o4[2], c5 = o4[3], f4 = o4[4], h3 = o4[5], d3 = o4[6], v3 = o4[7], _2 = o4[8], b = o4[9], p3 = o4[10], k4 = o4[11], E3 = o4[12], S2 = o4[13], L3 = o4[14], x2 = o4[15], C3 = s3 * h3 - l3 * f4, M4 = s3 * d3 - u4 * f4, g3 = s3 * v3 - c5 * f4, P3 = l3 * d3 - u4 * h3, T3 = l3 * v3 - c5 * h3, z3 = u4 * v3 - c5 * d3, O3 = _2 * S2 - b * E3, V2 = _2 * L3 - p3 * E3, G2 = _2 * x2 - k4 * E3, Z = b * L3 - p3 * S2, j3 = b * x2 - k4 * S2, N2 = p3 * x2 - k4 * L3;\n                  return C3 * N2 - M4 * j3 + g3 * Z + P3 * G2 - T3 * V2 + z3 * O3;\n                }\n              }, 9922: function(i3, a4, o4) {\n                i3.exports = l3;\n                var s3 = o4(2613);\n                function l3(u4, c5) {\n                  var f4 = u4[0], h3 = u4[1], d3 = u4[2], v3 = c5[0], _2 = c5[1], b = c5[2];\n                  return Math.abs(f4 - v3) <= s3 * Math.max(1, Math.abs(f4), Math.abs(v3)) && Math.abs(h3 - _2) <= s3 * Math.max(1, Math.abs(h3), Math.abs(_2)) && Math.abs(d3 - b) <= s3 * Math.max(1, Math.abs(d3), Math.abs(b));\n                }\n              }, 9970: function(i3, a4, o4) {\n                i3.exports = { create: o4(7536), clone: o4(2335), fromValues: o4(3390), copy: o4(2933), set: o4(4578), add: o4(4361), subtract: o4(6860), multiply: o4(3576), divide: o4(1373), min: o4(2334), max: o4(160), scale: o4(9288), scaleAndAdd: o4(4844), distance: o4(4691), squaredDistance: o4(7960), length: o4(6808), squaredLength: o4(483), negate: o4(1498), inverse: o4(4494), normalize: o4(5177), dot: o4(3750), lerp: o4(2573), random: o4(9131), transformMat4: o4(5352), transformQuat: o4(4041) };\n              }, 9977: function(i3, a4, o4) {\n                "use strict";\n                i3.exports = p3;\n                var s3 = o4(9215), l3 = o4(6582), u4 = o4(7399), c5 = o4(7608), f4 = o4(4081);\n                function h3(k4, E3, S2) {\n                  return Math.sqrt(Math.pow(k4, 2) + Math.pow(E3, 2) + Math.pow(S2, 2));\n                }\n                function d3(k4, E3, S2, L3) {\n                  return Math.sqrt(Math.pow(k4, 2) + Math.pow(E3, 2) + Math.pow(S2, 2) + Math.pow(L3, 2));\n                }\n                function v3(k4, E3) {\n                  var S2 = E3[0], L3 = E3[1], x2 = E3[2], C3 = E3[3], M4 = d3(S2, L3, x2, C3);\n                  M4 > 1e-6 ? (k4[0] = S2 / M4, k4[1] = L3 / M4, k4[2] = x2 / M4, k4[3] = C3 / M4) : (k4[0] = k4[1] = k4[2] = 0, k4[3] = 1);\n                }\n                function _2(k4, E3, S2) {\n                  this.radius = s3([S2]), this.center = s3(E3), this.rotation = s3(k4), this.computedRadius = this.radius.curve(0), this.computedCenter = this.center.curve(0), this.computedRotation = this.rotation.curve(0), this.computedUp = [0.1, 0, 0], this.computedEye = [0.1, 0, 0], this.computedMatrix = [0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], this.recalcMatrix(0);\n                }\n                var b = _2.prototype;\n                b.lastT = function() {\n                  return Math.max(this.radius.lastT(), this.center.lastT(), this.rotation.lastT());\n                }, b.recalcMatrix = function(k4) {\n                  this.radius.curve(k4), this.center.curve(k4), this.rotation.curve(k4);\n                  var E3 = this.computedRotation;\n                  v3(E3, E3);\n                  var S2 = this.computedMatrix;\n                  u4(S2, E3);\n                  var L3 = this.computedCenter, x2 = this.computedEye, C3 = this.computedUp, M4 = Math.exp(this.computedRadius[0]);\n                  x2[0] = L3[0] + M4 * S2[2], x2[1] = L3[1] + M4 * S2[6], x2[2] = L3[2] + M4 * S2[10], C3[0] = S2[1], C3[1] = S2[5], C3[2] = S2[9];\n                  for (var g3 = 0; g3 < 3; ++g3) {\n                    for (var P3 = 0, T3 = 0; T3 < 3; ++T3) P3 += S2[g3 + 4 * T3] * x2[T3];\n                    S2[12 + g3] = -P3;\n                  }\n                }, b.getMatrix = function(k4, E3) {\n                  this.recalcMatrix(k4);\n                  var S2 = this.computedMatrix;\n                  if (E3) {\n                    for (var L3 = 0; L3 < 16; ++L3) E3[L3] = S2[L3];\n                    return E3;\n                  }\n                  return S2;\n                }, b.idle = function(k4) {\n                  this.center.idle(k4), this.radius.idle(k4), this.rotation.idle(k4);\n                }, b.flush = function(k4) {\n                  this.center.flush(k4), this.radius.flush(k4), this.rotation.flush(k4);\n                }, b.pan = function(k4, E3, S2, L3) {\n                  E3 = E3 || 0, S2 = S2 || 0, L3 = L3 || 0, this.recalcMatrix(k4);\n                  var x2 = this.computedMatrix, C3 = x2[1], M4 = x2[5], g3 = x2[9], P3 = h3(C3, M4, g3);\n                  C3 /= P3, M4 /= P3, g3 /= P3;\n                  var T3 = x2[0], z3 = x2[4], O3 = x2[8], V2 = T3 * C3 + z3 * M4 + O3 * g3;\n                  T3 -= C3 * V2, z3 -= M4 * V2, O3 -= g3 * V2;\n                  var G2 = h3(T3, z3, O3);\n                  T3 /= G2, z3 /= G2, O3 /= G2;\n                  var Z = x2[2], j3 = x2[6], N2 = x2[10], H = Z * C3 + j3 * M4 + N2 * g3, te = Z * T3 + j3 * z3 + N2 * O3;\n                  Z -= H * C3 + te * T3, j3 -= H * M4 + te * z3, N2 -= H * g3 + te * O3;\n                  var oe = h3(Z, j3, N2);\n                  Z /= oe, j3 /= oe, N2 /= oe;\n                  var _e = T3 * E3 + C3 * S2, Ee = z3 * E3 + M4 * S2, Ce = O3 * E3 + g3 * S2;\n                  this.center.move(k4, _e, Ee, Ce);\n                  var me = Math.exp(this.computedRadius[0]);\n                  me = Math.max(1e-4, me + L3), this.radius.set(k4, Math.log(me));\n                }, b.rotate = function(k4, E3, S2, L3) {\n                  this.recalcMatrix(k4), E3 = E3 || 0, S2 = S2 || 0;\n                  var x2 = this.computedMatrix, C3 = x2[0], M4 = x2[4], g3 = x2[8], P3 = x2[1], T3 = x2[5], z3 = x2[9], O3 = x2[2], V2 = x2[6], G2 = x2[10], Z = E3 * C3 + S2 * P3, j3 = E3 * M4 + S2 * T3, N2 = E3 * g3 + S2 * z3, H = -(V2 * N2 - G2 * j3), te = -(G2 * Z - O3 * N2), oe = -(O3 * j3 - V2 * Z), _e = Math.sqrt(Math.max(0, 1 - Math.pow(H, 2) - Math.pow(te, 2) - Math.pow(oe, 2))), Ee = d3(H, te, oe, _e);\n                  Ee > 1e-6 ? (H /= Ee, te /= Ee, oe /= Ee, _e /= Ee) : (H = te = oe = 0, _e = 1);\n                  var Ce = this.computedRotation, me = Ce[0], ie = Ce[1], Se = Ce[2], Le = Ce[3], Ae = me * _e + Le * H + ie * oe - Se * te, Fe = ie * _e + Le * te + Se * H - me * oe, Pe = Se * _e + Le * oe + me * te - ie * H, ge = Le * _e - me * H - ie * te - Se * oe;\n                  if (L3) {\n                    H = O3, te = V2, oe = G2;\n                    var Re = Math.sin(L3) / h3(H, te, oe);\n                    H *= Re, te *= Re, oe *= Re, _e = Math.cos(E3), Ae = Ae * _e + ge * H + Fe * oe - Pe * te, Fe = Fe * _e + ge * te + Pe * H - Ae * oe, Pe = Pe * _e + ge * oe + Ae * te - Fe * H, ge = ge * _e - Ae * H - Fe * te - Pe * oe;\n                  }\n                  var ce = d3(Ae, Fe, Pe, ge);\n                  ce > 1e-6 ? (Ae /= ce, Fe /= ce, Pe /= ce, ge /= ce) : (Ae = Fe = Pe = 0, ge = 1), this.rotation.set(k4, Ae, Fe, Pe, ge);\n                }, b.lookAt = function(k4, E3, S2, L3) {\n                  this.recalcMatrix(k4), S2 = S2 || this.computedCenter, E3 = E3 || this.computedEye, L3 = L3 || this.computedUp;\n                  var x2 = this.computedMatrix;\n                  l3(x2, E3, S2, L3);\n                  var C3 = this.computedRotation;\n                  f4(C3, x2[0], x2[1], x2[2], x2[4], x2[5], x2[6], x2[8], x2[9], x2[10]), v3(C3, C3), this.rotation.set(k4, C3[0], C3[1], C3[2], C3[3]);\n                  for (var M4 = 0, g3 = 0; g3 < 3; ++g3) M4 += Math.pow(S2[g3] - E3[g3], 2);\n                  this.radius.set(k4, 0.5 * Math.log(Math.max(M4, 1e-6))), this.center.set(k4, S2[0], S2[1], S2[2]);\n                }, b.translate = function(k4, E3, S2, L3) {\n                  this.center.move(k4, E3 || 0, S2 || 0, L3 || 0);\n                }, b.setMatrix = function(k4, E3) {\n                  var S2 = this.computedRotation;\n                  f4(S2, E3[0], E3[1], E3[2], E3[4], E3[5], E3[6], E3[8], E3[9], E3[10]), v3(S2, S2), this.rotation.set(k4, S2[0], S2[1], S2[2], S2[3]);\n                  var L3 = this.computedMatrix;\n                  c5(L3, E3);\n                  var x2 = L3[15];\n                  if (Math.abs(x2) > 1e-6) {\n                    var C3 = L3[12] / x2, M4 = L3[13] / x2, g3 = L3[14] / x2;\n                    this.recalcMatrix(k4);\n                    var P3 = Math.exp(this.computedRadius[0]);\n                    this.center.set(k4, C3 - L3[2] * P3, M4 - L3[6] * P3, g3 - L3[10] * P3), this.radius.idle(k4);\n                  } else this.center.idle(k4), this.radius.idle(k4);\n                }, b.setDistance = function(k4, E3) {\n                  E3 > 0 && this.radius.set(k4, Math.log(E3));\n                }, b.setDistanceLimits = function(k4, E3) {\n                  k4 > 0 ? k4 = Math.log(k4) : k4 = -1 / 0, E3 > 0 ? E3 = Math.log(E3) : E3 = 1 / 0, E3 = Math.max(E3, k4), this.radius.bounds[0][0] = k4, this.radius.bounds[1][0] = E3;\n                }, b.getDistanceLimits = function(k4) {\n                  var E3 = this.radius.bounds;\n                  return k4 ? (k4[0] = Math.exp(E3[0][0]), k4[1] = Math.exp(E3[1][0]), k4) : [Math.exp(E3[0][0]), Math.exp(E3[1][0])];\n                }, b.toJSON = function() {\n                  return this.recalcMatrix(this.lastT()), { center: this.computedCenter.slice(), rotation: this.computedRotation.slice(), distance: Math.log(this.computedRadius[0]), zoomMin: this.radius.bounds[0][0], zoomMax: this.radius.bounds[1][0] };\n                }, b.fromJSON = function(k4) {\n                  var E3 = this.lastT(), S2 = k4.center;\n                  S2 && this.center.set(E3, S2[0], S2[1], S2[2]);\n                  var L3 = k4.rotation;\n                  L3 && this.rotation.set(E3, L3[0], L3[1], L3[2], L3[3]);\n                  var x2 = k4.distance;\n                  x2 && x2 > 0 && this.radius.set(E3, Math.log(x2)), this.setDistanceLimits(k4.zoomMin, k4.zoomMax);\n                };\n                function p3(k4) {\n                  k4 = k4 || {};\n                  var E3 = k4.center || [0, 0, 0], S2 = k4.rotation || [0, 0, 0, 1], L3 = k4.radius || 1;\n                  E3 = [].slice.call(E3, 0, 3), S2 = [].slice.call(S2, 0, 4), v3(S2, S2);\n                  var x2 = new _2(S2, E3, Math.log(L3));\n                  return x2.setDistanceLimits(k4.zoomMin, k4.zoomMax), ("eye" in k4 || "up" in k4) && x2.lookAt(0, k4.eye, k4.center, k4.up), x2;\n                }\n              }, 9994: function(i3, a4, o4) {\n                "use strict";\n                var s3 = o4(9618), l3 = o4(8277);\n                i3.exports = function(c5, f4) {\n                  for (var h3 = [], d3 = c5, v3 = 1; Array.isArray(d3); ) h3.push(d3.length), v3 *= d3.length, d3 = d3[0];\n                  return h3.length === 0 ? s3() : (f4 || (f4 = s3(new Float64Array(v3), h3)), l3(f4, c5), f4);\n                };\n              } }, t3 = {};\n              function r4(i3) {\n                var a4 = t3[i3];\n                if (a4 !== void 0) return a4.exports;\n                var o4 = t3[i3] = { id: i3, loaded: false, exports: {} };\n                return e3[i3].call(o4.exports, o4, o4.exports, r4), o4.loaded = true, o4.exports;\n              }\n              (function() {\n                r4.g = (function() {\n                  if (typeof globalThis == "object") return globalThis;\n                  try {\n                    return this || new Function("return this")();\n                  } catch (i3) {\n                    if (typeof window == "object") return window;\n                  }\n                })();\n              })(), (function() {\n                r4.nmd = function(i3) {\n                  return i3.paths = [], i3.children || (i3.children = []), i3;\n                };\n              })();\n              var n4 = r4(1964);\n              yPe.exports = n4;\n            })();\n          });\n          var gX = ye((V0r, _Pe) => {\n            "use strict";\n            _Pe.exports = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };\n          });\n          var TPe = ye((G0r, wPe) => {\n            "use strict";\n            var xPe = gX();\n            wPe.exports = QPt;\n            var bPe = { red: 0, orange: 60, yellow: 120, green: 180, blue: 240, purple: 300 };\n            function QPt(e3) {\n              var t3, r4 = [], n4 = 1, i3;\n              if (typeof e3 == "string") if (e3 = e3.toLowerCase(), xPe[e3]) r4 = xPe[e3].slice(), i3 = "rgb";\n              else if (e3 === "transparent") n4 = 0, i3 = "rgb", r4 = [0, 0, 0];\n              else if (/^#[A-Fa-f0-9]+$/.test(e3)) {\n                var a4 = e3.slice(1), o4 = a4.length, s3 = o4 <= 4;\n                n4 = 1, s3 ? (r4 = [parseInt(a4[0] + a4[0], 16), parseInt(a4[1] + a4[1], 16), parseInt(a4[2] + a4[2], 16)], o4 === 4 && (n4 = parseInt(a4[3] + a4[3], 16) / 255)) : (r4 = [parseInt(a4[0] + a4[1], 16), parseInt(a4[2] + a4[3], 16), parseInt(a4[4] + a4[5], 16)], o4 === 8 && (n4 = parseInt(a4[6] + a4[7], 16) / 255)), r4[0] || (r4[0] = 0), r4[1] || (r4[1] = 0), r4[2] || (r4[2] = 0), i3 = "rgb";\n              } else if (t3 = /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\\s*\\(([^\\)]*)\\)/.exec(e3)) {\n                var l3 = t3[1], u4 = l3 === "rgb", a4 = l3.replace(/a$/, "");\n                i3 = a4;\n                var o4 = a4 === "cmyk" ? 4 : a4 === "gray" ? 1 : 3;\n                r4 = t3[2].trim().split(/\\s*[,\\/]\\s*|\\s+/).map(function(h3, d3) {\n                  if (/%$/.test(h3)) return d3 === o4 ? parseFloat(h3) / 100 : a4 === "rgb" ? parseFloat(h3) * 255 / 100 : parseFloat(h3);\n                  if (a4[d3] === "h") {\n                    if (/deg$/.test(h3)) return parseFloat(h3);\n                    if (bPe[h3] !== void 0) return bPe[h3];\n                  }\n                  return parseFloat(h3);\n                }), l3 === a4 && r4.push(1), n4 = u4 || r4[o4] === void 0 ? 1 : r4[o4], r4 = r4.slice(0, o4);\n              } else e3.length > 10 && /[0-9](?:\\s|\\/)/.test(e3) && (r4 = e3.match(/([0-9]+)/g).map(function(c5) {\n                return parseFloat(c5);\n              }), i3 = e3.match(/([a-z])/ig).join("").toLowerCase());\n              else isNaN(e3) ? Array.isArray(e3) || e3.length ? (r4 = [e3[0], e3[1], e3[2]], i3 = "rgb", n4 = e3.length === 4 ? e3[3] : 1) : e3 instanceof Object && (e3.r != null || e3.red != null || e3.R != null ? (i3 = "rgb", r4 = [e3.r || e3.red || e3.R || 0, e3.g || e3.green || e3.G || 0, e3.b || e3.blue || e3.B || 0]) : (i3 = "hsl", r4 = [e3.h || e3.hue || e3.H || 0, e3.s || e3.saturation || e3.S || 0, e3.l || e3.lightness || e3.L || e3.b || e3.brightness]), n4 = e3.a || e3.alpha || e3.opacity || 1, e3.opacity != null && (n4 /= 100)) : (i3 = "rgb", r4 = [e3 >>> 16, (e3 & 65280) >>> 8, e3 & 255]);\n              return { space: i3, values: r4, alpha: n4 };\n            }\n          });\n          var SPe = ye((H0r, APe) => {\n            "use strict";\n            var eIt = TPe();\n            APe.exports = function(t3) {\n              Array.isArray(t3) && t3.raw && (t3 = String.raw.apply(null, arguments));\n              var r4, n4, i3, a4 = eIt(t3);\n              if (!a4.space) return [];\n              var o4 = [0, 0, 0], s3 = a4.space[0] === "h" ? [360, 100, 100] : [255, 255, 255];\n              return r4 = Array(3), r4[0] = Math.min(Math.max(a4.values[0], o4[0]), s3[0]), r4[1] = Math.min(Math.max(a4.values[1], o4[1]), s3[1]), r4[2] = Math.min(Math.max(a4.values[2], o4[2]), s3[2]), a4.space[0] === "h" && (r4 = tIt(r4)), r4.push(Math.min(Math.max(a4.alpha, 0), 1)), r4;\n            };\n            function tIt(e3) {\n              var t3 = e3[0] / 360, r4 = e3[1] / 100, n4 = e3[2] / 100, i3, a4, o4, s3, l3, u4 = 0;\n              if (r4 === 0) return l3 = n4 * 255, [l3, l3, l3];\n              for (a4 = n4 < 0.5 ? n4 * (1 + r4) : n4 + r4 - n4 * r4, i3 = 2 * n4 - a4, s3 = [0, 0, 0]; u4 < 3; ) o4 = t3 + 1 / 3 * -(u4 - 1), o4 < 0 ? o4++ : o4 > 1 && o4--, l3 = 6 * o4 < 1 ? i3 + (a4 - i3) * 6 * o4 : 2 * o4 < 1 ? a4 : 3 * o4 < 2 ? i3 + (a4 - i3) * (2 / 3 - o4) * 6 : i3, s3[u4++] = l3 * 255;\n              return s3;\n            }\n          });\n          var ZE = ye((j0r, MPe) => {\n            MPe.exports = rIt;\n            function rIt(e3, t3, r4) {\n              return t3 < r4 ? e3 < t3 ? t3 : e3 > r4 ? r4 : e3 : e3 < r4 ? r4 : e3 > t3 ? t3 : e3;\n            }\n          });\n          var YD = ye((W0r, EPe) => {\n            EPe.exports = function(e3) {\n              switch (e3) {\n                case "int8":\n                  return Int8Array;\n                case "int16":\n                  return Int16Array;\n                case "int32":\n                  return Int32Array;\n                case "uint8":\n                  return Uint8Array;\n                case "uint16":\n                  return Uint16Array;\n                case "uint32":\n                  return Uint32Array;\n                case "float32":\n                  return Float32Array;\n                case "float64":\n                  return Float64Array;\n                case "array":\n                  return Array;\n                case "uint8_clamped":\n                  return Uint8ClampedArray;\n              }\n            };\n          });\n          var J_ = ye((X0r, kPe) => {\n            "use strict";\n            var iIt = SPe(), KD = ZE(), nIt = YD();\n            kPe.exports = function(t3, r4) {\n              (r4 === "float" || !r4) && (r4 = "array"), r4 === "uint" && (r4 = "uint8"), r4 === "uint_clamped" && (r4 = "uint8_clamped");\n              var n4 = nIt(r4), i3 = new n4(4), a4 = r4 !== "uint8" && r4 !== "uint8_clamped";\n              return (!t3.length || typeof t3 == "string") && (t3 = iIt(t3), t3[0] /= 255, t3[1] /= 255, t3[2] /= 255), aIt(t3) ? (i3[0] = t3[0], i3[1] = t3[1], i3[2] = t3[2], i3[3] = t3[3] != null ? t3[3] : 255, a4 && (i3[0] /= 255, i3[1] /= 255, i3[2] /= 255, i3[3] /= 255), i3) : (a4 ? (i3[0] = t3[0], i3[1] = t3[1], i3[2] = t3[2], i3[3] = t3[3] != null ? t3[3] : 1) : (i3[0] = KD(Math.floor(t3[0] * 255), 0, 255), i3[1] = KD(Math.floor(t3[1] * 255), 0, 255), i3[2] = KD(Math.floor(t3[2] * 255), 0, 255), i3[3] = t3[3] == null ? 255 : KD(Math.floor(t3[3] * 255), 0, 255)), i3);\n            };\n            function aIt(e3) {\n              return !!(e3 instanceof Uint8Array || e3 instanceof Uint8ClampedArray || Array.isArray(e3) && (e3[0] > 1 || e3[0] === 0) && (e3[1] > 1 || e3[1] === 0) && (e3[2] > 1 || e3[2] === 0) && (!e3[3] || e3[3] > 1));\n            }\n          });\n          var Jy = ye((Z0r, CPe) => {\n            "use strict";\n            var oIt = J_();\n            function sIt(e3) {\n              return e3 ? oIt(e3) : [0, 0, 0, 1];\n            }\n            CPe.exports = sIt;\n          });\n          var $y = ye((Y0r, zPe) => {\n            "use strict";\n            var DPe = Eo(), lIt = cd(), JD = J_(), $D = tc(), uIt = Lh().defaultLine, LPe = vv().isArrayOrTypedArray, mX = JD(uIt), FPe = 1;\n            function PPe(e3, t3) {\n              var r4 = e3;\n              return r4[3] *= t3, r4;\n            }\n            function IPe(e3) {\n              if (DPe(e3)) return mX;\n              var t3 = JD(e3);\n              return t3.length ? t3 : mX;\n            }\n            function RPe(e3) {\n              return DPe(e3) ? e3 : FPe;\n            }\n            function cIt(e3, t3, r4) {\n              var n4 = e3.color;\n              n4 && n4._inputArray && (n4 = n4._inputArray);\n              var i3 = LPe(n4), a4 = LPe(t3), o4 = $D.extractOpts(e3), s3 = [], l3, u4, c5, f4, h3;\n              if (o4.colorscale !== void 0 ? l3 = $D.makeColorScaleFuncFromTrace(e3) : l3 = IPe, i3 ? u4 = function(v3, _2) {\n                return v3[_2] === void 0 ? mX : JD(l3(v3[_2]));\n              } : u4 = IPe, a4 ? c5 = function(v3, _2) {\n                return v3[_2] === void 0 ? FPe : RPe(v3[_2]);\n              } : c5 = RPe, i3 || a4) for (var d3 = 0; d3 < r4; d3++) f4 = u4(n4, d3), h3 = c5(t3, d3), s3[d3] = PPe(f4, h3);\n              else s3 = PPe(JD(n4), t3);\n              return s3;\n            }\n            function fIt(e3) {\n              var t3 = $D.extractOpts(e3), r4 = t3.colorscale;\n              return t3.reversescale && (r4 = $D.flipScale(t3.colorscale)), r4.map(function(n4) {\n                var i3 = n4[0], a4 = lIt(n4[1]), o4 = a4.toRgb();\n                return { index: i3, rgb: [o4.r, o4.g, o4.b, o4.a] };\n              });\n            }\n            zPe.exports = { formatColor: cIt, parseColorScale: fIt };\n          });\n          var yX = ye((K0r, OPe) => {\n            "use strict";\n            OPe.exports = { solid: [[], 0], dot: [[0.5, 1], 200], dash: [[0.5, 1], 50], longdash: [[0.5, 1], 10], dashdot: [[0.5, 0.625, 0.875, 1], 50], longdashdot: [[0.5, 0.7, 0.8, 1], 10] };\n          });\n          var QD = ye((J0r, qPe) => {\n            "use strict";\n            qPe.exports = { circle: "\\u25CF", "circle-open": "\\u25CB", square: "\\u25A0", "square-open": "\\u25A1", diamond: "\\u25C6", "diamond-open": "\\u25C7", cross: "+", x: "\\u274C" };\n          });\n          var NPe = ye(($0r, BPe) => {\n            "use strict";\n            var hIt = qa();\n            function _X(e3, t3, r4, n4) {\n              if (!t3 || !t3.visible) return null;\n              for (var i3 = hIt.getComponentMethod("errorbars", "makeComputeError")(t3), a4 = new Array(e3.length), o4 = 0; o4 < e3.length; o4++) {\n                var s3 = i3(+e3[o4], o4);\n                if (n4.type === "log") {\n                  var l3 = n4.c2l(e3[o4]), u4 = e3[o4] - s3[0], c5 = e3[o4] + s3[1];\n                  if (a4[o4] = [(n4.c2l(u4, true) - l3) * r4, (n4.c2l(c5, true) - l3) * r4], u4 > 0) {\n                    var f4 = n4.c2l(u4);\n                    n4._lowerLogErrorBound || (n4._lowerLogErrorBound = f4), n4._lowerErrorBound = Math.min(n4._lowerLogErrorBound, f4);\n                  }\n                } else a4[o4] = [-s3[0] * r4, s3[1] * r4];\n              }\n              return a4;\n            }\n            function dIt(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) if (e3[t3]) return e3[t3].length;\n              return 0;\n            }\n            function vIt(e3, t3, r4) {\n              var n4 = [_X(e3.x, e3.error_x, t3[0], r4.xaxis), _X(e3.y, e3.error_y, t3[1], r4.yaxis), _X(e3.z, e3.error_z, t3[2], r4.zaxis)], i3 = dIt(n4);\n              if (i3 === 0) return null;\n              for (var a4 = new Array(i3), o4 = 0; o4 < i3; o4++) {\n                for (var s3 = [[0, 0, 0], [0, 0, 0]], l3 = 0; l3 < 3; l3++) if (n4[l3]) for (var u4 = 0; u4 < 2; u4++) s3[u4][l3] = n4[l3][o4][u4];\n                a4[o4] = s3;\n              }\n              return a4;\n            }\n            BPe.exports = vIt;\n          });\n          var YPe = ye((Q0r, ZPe) => {\n            "use strict";\n            var pIt = Od().gl_line3d, UPe = Od().gl_scatter3d, gIt = Od().gl_error3d, mIt = Od().gl_mesh3d, yIt = Od().delaunay_triangulate, Qy = Dr(), WPe = Jy(), eF = $y().formatColor, _It = k3(), xX = yX(), xIt = QD(), bIt = ho(), wIt = ip().appendArrayPointValue, TIt = NPe();\n            function XPe(e3, t3) {\n              this.scene = e3, this.uid = t3, this.linePlot = null, this.scatterPlot = null, this.errorBars = null, this.textMarkers = null, this.delaunayMesh = null, this.color = null, this.mode = "", this.dataPoints = [], this.axesBounds = [[-1 / 0, -1 / 0, -1 / 0], [1 / 0, 1 / 0, 1 / 0]], this.textLabels = null, this.data = null;\n            }\n            var wX = XPe.prototype;\n            wX.handlePick = function(e3) {\n              if (e3.object && (e3.object === this.linePlot || e3.object === this.delaunayMesh || e3.object === this.textMarkers || e3.object === this.scatterPlot)) {\n                var t3 = e3.index = e3.data.index;\n                return e3.object.highlight && e3.object.highlight(null), this.scatterPlot && (e3.object = this.scatterPlot, this.scatterPlot.highlight(e3.data)), e3.textLabel = "", this.textLabels && (Qy.isArrayOrTypedArray(this.textLabels) ? (this.textLabels[t3] || this.textLabels[t3] === 0) && (e3.textLabel = this.textLabels[t3]) : e3.textLabel = this.textLabels), e3.traceCoordinate = [this.data.x[t3], this.data.y[t3], this.data.z[t3]], true;\n              }\n            };\n            function AIt(e3, t3, r4) {\n              var n4 = (r4 + 1) % 3, i3 = (r4 + 2) % 3, a4 = [], o4 = [], s3;\n              for (s3 = 0; s3 < e3.length; ++s3) {\n                var l3 = e3[s3];\n                isNaN(l3[n4]) || !isFinite(l3[n4]) || isNaN(l3[i3]) || !isFinite(l3[i3]) || (a4.push([l3[n4], l3[i3]]), o4.push(s3));\n              }\n              var u4 = yIt(a4);\n              for (s3 = 0; s3 < u4.length; ++s3) for (var c5 = u4[s3], f4 = 0; f4 < c5.length; ++f4) c5[f4] = o4[c5[f4]];\n              return { positions: e3, cells: u4, meshColor: t3 };\n            }\n            function SIt(e3) {\n              for (var t3 = [0, 0, 0], r4 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]], n4 = [1, 1, 1], i3 = 0; i3 < 3; i3++) {\n                var a4 = e3[i3];\n                a4 && a4.copy_zstyle !== false && e3[2].visible !== false && (a4 = e3[2]), !(!a4 || !a4.visible) && (t3[i3] = a4.width / 2, r4[i3] = WPe(a4.color), n4[i3] = a4.thickness);\n              }\n              return { capSize: t3, color: r4, lineWidth: n4 };\n            }\n            function VPe(e3) {\n              return e3 == null ? 0 : e3.indexOf("left") > -1 ? -1 : e3.indexOf("right") > -1 ? 1 : 0;\n            }\n            function GPe(e3) {\n              return e3 == null ? 0 : e3.indexOf("top") > -1 ? -1 : e3.indexOf("bottom") > -1 ? 1 : 0;\n            }\n            function MIt(e3) {\n              var t3 = 0, r4 = 0, n4 = [t3, r4];\n              if (Array.isArray(e3)) for (var i3 = 0; i3 < e3.length; i3++) n4[i3] = [t3, r4], e3[i3] && (n4[i3][0] = VPe(e3[i3]), n4[i3][1] = GPe(e3[i3]));\n              else n4[0] = VPe(e3), n4[1] = GPe(e3);\n              return n4;\n            }\n            function EIt(e3, t3) {\n              return t3(e3 * 4);\n            }\n            function kIt(e3) {\n              return xIt[e3];\n            }\n            function bX(e3, t3, r4, n4, i3) {\n              var a4 = null;\n              if (Qy.isArrayOrTypedArray(e3)) {\n                a4 = [];\n                for (var o4 = 0; o4 < t3; o4++) e3[o4] === void 0 ? a4[o4] = n4 : a4[o4] = r4(e3[o4], i3);\n              } else a4 = r4(e3, Qy.identity);\n              return a4;\n            }\n            function CIt(e3, t3) {\n              var r4 = [], n4 = e3.fullSceneLayout, i3 = e3.dataScale, a4 = n4.xaxis, o4 = n4.yaxis, s3 = n4.zaxis, l3 = t3.marker, u4 = t3.line, c5 = t3.x || [], f4 = t3.y || [], h3 = t3.z || [], d3 = c5.length, v3 = t3.xcalendar, _2 = t3.ycalendar, b = t3.zcalendar, p3, k4, E3, S2, L3, x2;\n              for (L3 = 0; L3 < d3; L3++) p3 = a4.d2l(c5[L3], 0, v3) * i3[0], k4 = o4.d2l(f4[L3], 0, _2) * i3[1], E3 = s3.d2l(h3[L3], 0, b) * i3[2], r4[L3] = [p3, k4, E3];\n              if (Array.isArray(t3.text)) x2 = t3.text;\n              else if (Qy.isTypedArray(t3.text)) x2 = Array.from(t3.text);\n              else if (t3.text !== void 0) for (x2 = new Array(d3), L3 = 0; L3 < d3; L3++) x2[L3] = t3.text;\n              function C3(oe, _e) {\n                var Ee = n4[oe];\n                return bIt.tickText(Ee, Ee.d2l(_e), true).text;\n              }\n              var M4 = t3.texttemplate;\n              if (M4) {\n                var g3 = e3.fullLayout, P3 = g3._d3locale, T3 = Array.isArray(M4), z3 = T3 ? Math.min(M4.length, d3) : d3, O3 = T3 ? function(oe) {\n                  return M4[oe];\n                } : function() {\n                  return M4;\n                };\n                for (x2 = new Array(z3), L3 = 0; L3 < z3; L3++) {\n                  var V2 = { x: c5[L3], y: f4[L3], z: h3[L3] }, G2 = { xLabel: C3("xaxis", c5[L3]), yLabel: C3("yaxis", f4[L3]), zLabel: C3("zaxis", h3[L3]) }, Z = {};\n                  wIt(Z, t3, L3), x2[L3] = Qy.texttemplateString({ data: [Z, V2, t3._meta], fallback: t3.texttemplatefallback, labels: G2, locale: P3, template: O3(L3) });\n                }\n              }\n              if (S2 = { position: r4, mode: t3.mode, text: x2 }, "line" in t3 && (S2.lineColor = eF(u4, 1, d3), S2.lineWidth = u4.width, S2.lineDashes = u4.dash), "marker" in t3) {\n                var j3 = _It(t3);\n                S2.scatterColor = eF(l3, 1, d3), S2.scatterSize = bX(l3.size, d3, EIt, 20, j3), S2.scatterMarker = bX(l3.symbol, d3, kIt, "\\u25CF"), S2.scatterLineWidth = l3.line.width, S2.scatterLineColor = eF(l3.line, 1, d3), S2.scatterAngle = 0;\n              }\n              "textposition" in t3 && (S2.textOffset = MIt(t3.textposition), S2.textColor = eF(t3.textfont, 1, d3), S2.textSize = bX(t3.textfont.size, d3, Qy.identity, 12), S2.textFontFamily = t3.textfont.family, S2.textFontWeight = t3.textfont.weight, S2.textFontStyle = t3.textfont.style, S2.textFontVariant = t3.textfont.variant, S2.textAngle = 0);\n              var N2 = ["x", "y", "z"];\n              for (S2.project = [false, false, false], S2.projectScale = [1, 1, 1], S2.projectOpacity = [1, 1, 1], L3 = 0; L3 < 3; ++L3) {\n                var H = t3.projection[N2[L3]];\n                (S2.project[L3] = H.show) && (S2.projectOpacity[L3] = H.opacity, S2.projectScale[L3] = H.scale);\n              }\n              S2.errorBounds = TIt(t3, i3, n4);\n              var te = SIt([t3.error_x, t3.error_y, t3.error_z]);\n              return S2.errorColor = te.color, S2.errorLineWidth = te.lineWidth, S2.errorCapSize = te.capSize, S2.delaunayAxis = t3.surfaceaxis, S2.delaunayColor = WPe(t3.surfacecolor), S2;\n            }\n            function HPe(e3) {\n              if (Qy.isArrayOrTypedArray(e3)) {\n                var t3 = e3[0];\n                return Qy.isArrayOrTypedArray(t3) && (e3 = t3), "rgb(" + e3.slice(0, 3).map(function(r4) {\n                  return Math.round(r4 * 255);\n                }) + ")";\n              }\n              return null;\n            }\n            function jPe(e3) {\n              return Qy.isArrayOrTypedArray(e3) ? e3.length === 4 && typeof e3[0] == "number" ? HPe(e3) : e3.map(HPe) : null;\n            }\n            wX.update = function(e3) {\n              var t3 = this.scene.glplot.gl, r4, n4, i3, a4, o4 = xX.solid;\n              this.data = e3;\n              var s3 = CIt(this.scene, e3);\n              "mode" in s3 && (this.mode = s3.mode), "lineDashes" in s3 && s3.lineDashes in xX && (o4 = xX[s3.lineDashes]), this.color = jPe(s3.scatterColor) || jPe(s3.lineColor), this.dataPoints = s3.position, r4 = { gl: this.scene.glplot.gl, position: s3.position, color: s3.lineColor, lineWidth: s3.lineWidth || 1, dashes: o4[0], dashScale: o4[1], opacity: e3.opacity, connectGaps: e3.connectgaps }, this.mode.indexOf("lines") !== -1 ? this.linePlot ? this.linePlot.update(r4) : (this.linePlot = pIt(r4), this.linePlot._trace = this, this.scene.glplot.add(this.linePlot)) : this.linePlot && (this.scene.glplot.remove(this.linePlot), this.linePlot.dispose(), this.linePlot = null);\n              var l3 = e3.opacity;\n              if (e3.marker && e3.marker.opacity !== void 0 && (l3 *= e3.marker.opacity), n4 = { gl: this.scene.glplot.gl, position: s3.position, color: s3.scatterColor, size: s3.scatterSize, glyph: s3.scatterMarker, opacity: l3, orthographic: true, lineWidth: s3.scatterLineWidth, lineColor: s3.scatterLineColor, project: s3.project, projectScale: s3.projectScale, projectOpacity: s3.projectOpacity }, this.mode.indexOf("markers") !== -1 ? this.scatterPlot ? this.scatterPlot.update(n4) : (this.scatterPlot = UPe(n4), this.scatterPlot._trace = this, this.scatterPlot.highlightScale = 1, this.scene.glplot.add(this.scatterPlot)) : this.scatterPlot && (this.scene.glplot.remove(this.scatterPlot), this.scatterPlot.dispose(), this.scatterPlot = null), a4 = { gl: this.scene.glplot.gl, position: s3.position, glyph: s3.text, color: s3.textColor, size: s3.textSize, angle: s3.textAngle, alignment: s3.textOffset, font: s3.textFontFamily, fontWeight: s3.textFontWeight, fontStyle: s3.textFontStyle, fontVariant: s3.textFontVariant, orthographic: true, lineWidth: 0, project: false, opacity: e3.opacity }, this.textLabels = e3.hovertext || e3.text, this.mode.indexOf("text") !== -1 ? this.textMarkers ? this.textMarkers.update(a4) : (this.textMarkers = UPe(a4), this.textMarkers._trace = this, this.textMarkers.highlightScale = 1, this.scene.glplot.add(this.textMarkers)) : this.textMarkers && (this.scene.glplot.remove(this.textMarkers), this.textMarkers.dispose(), this.textMarkers = null), i3 = { gl: this.scene.glplot.gl, position: s3.position, color: s3.errorColor, error: s3.errorBounds, lineWidth: s3.errorLineWidth, capSize: s3.errorCapSize, opacity: e3.opacity }, this.errorBars ? s3.errorBounds ? this.errorBars.update(i3) : (this.scene.glplot.remove(this.errorBars), this.errorBars.dispose(), this.errorBars = null) : s3.errorBounds && (this.errorBars = gIt(i3), this.errorBars._trace = this, this.scene.glplot.add(this.errorBars)), s3.delaunayAxis >= 0) {\n                var u4 = AIt(s3.position, s3.delaunayColor, s3.delaunayAxis);\n                u4.opacity = e3.opacity, this.delaunayMesh ? this.delaunayMesh.update(u4) : (u4.gl = t3, this.delaunayMesh = mIt(u4), this.delaunayMesh._trace = this, this.scene.glplot.add(this.delaunayMesh));\n              } else this.delaunayMesh && (this.scene.glplot.remove(this.delaunayMesh), this.delaunayMesh.dispose(), this.delaunayMesh = null);\n            };\n            wX.dispose = function() {\n              this.linePlot && (this.scene.glplot.remove(this.linePlot), this.linePlot.dispose()), this.scatterPlot && (this.scene.glplot.remove(this.scatterPlot), this.scatterPlot.dispose()), this.errorBars && (this.scene.glplot.remove(this.errorBars), this.errorBars.dispose()), this.textMarkers && (this.scene.glplot.remove(this.textMarkers), this.textMarkers.dispose()), this.delaunayMesh && (this.scene.glplot.remove(this.delaunayMesh), this.delaunayMesh.dispose());\n            };\n            function LIt(e3, t3) {\n              var r4 = new XPe(e3, t3.uid);\n              return r4.update(t3), r4;\n            }\n            ZPe.exports = LIt;\n          });\n          var EX = ye((egr, QPe) => {\n            "use strict";\n            var e1 = pf(), PIt = ec(), MX = Tu(), TX = df().axisHoverFormat, { hovertemplateAttrs: IIt, texttemplateAttrs: RIt, templatefallbackAttrs: KPe } = Ll(), JPe = Gl(), DIt = yX(), FIt = QD(), Kg = Ao().extendFlat, zIt = mc().overrideAll, $Pe = Z1(), OIt = e1.line, V2 = e1.marker, qIt = V2.line, BIt = Kg({ width: OIt.width, dash: { valType: "enumerated", values: $Pe(DIt), dflt: "solid" } }, MX("line"));\n            function AX(e3) {\n              return { show: { valType: "boolean", dflt: false }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, scale: { valType: "number", min: 0, max: 10, dflt: 2 / 3 } };\n            }\n            var SX = QPe.exports = zIt({ x: e1.x, y: e1.y, z: { valType: "data_array" }, text: Kg({}, e1.text, {}), texttemplate: RIt(), texttemplatefallback: KPe({ editType: "calc" }), hovertext: Kg({}, e1.hovertext, {}), hovertemplate: IIt(), hovertemplatefallback: KPe(), xhoverformat: TX("x"), yhoverformat: TX("y"), zhoverformat: TX("z"), mode: Kg({}, e1.mode, { dflt: "lines+markers" }), surfaceaxis: { valType: "enumerated", values: [-1, 0, 1, 2], dflt: -1 }, surfacecolor: { valType: "color" }, projection: { x: AX("x"), y: AX("y"), z: AX("z") }, connectgaps: e1.connectgaps, line: BIt, marker: Kg({ symbol: { valType: "enumerated", values: $Pe(FIt), dflt: "circle", arrayOk: true }, size: Kg({}, V2.size, { dflt: 8 }), sizeref: V2.sizeref, sizemin: V2.sizemin, sizemode: V2.sizemode, opacity: Kg({}, V2.opacity, { arrayOk: false }), colorbar: V2.colorbar, line: Kg({ width: Kg({}, qIt.width, { arrayOk: false }) }, MX("marker.line")) }, MX("marker")), textposition: Kg({}, e1.textposition, { dflt: "top center" }), textfont: PIt({ noFontShadow: true, noFontLineposition: true, noFontTextcase: true, editType: "calc", colorEditType: "style", arrayOk: true, variantValues: ["normal", "small-caps"] }), opacity: JPe.opacity, hoverinfo: Kg({}, JPe.hoverinfo) }, "calc", "nested");\n            SX.x.editType = SX.y.editType = SX.z.editType = "calc+clearAxisTypes";\n          });\n          var rIe = ye((tgr, tIe) => {\n            "use strict";\n            var eIe = qa(), NIt = Dr(), kX = Ru(), UIt = $p(), VIt = R0(), GIt = D0(), HIt = EX();\n            tIe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return NIt.coerce(t3, r4, HIt, d3, v3);\n              }\n              var o4 = jIt(t3, r4, a4, i3);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("xhoverformat"), a4("yhoverformat"), a4("zhoverformat"), a4("mode"), kX.hasMarkers(r4) && UIt(t3, r4, n4, i3, a4, { noSelect: true, noAngle: true }), kX.hasLines(r4) && (a4("connectgaps"), VIt(t3, r4, n4, i3, a4)), kX.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), GIt(t3, r4, i3, a4, { noSelect: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }));\n              var s3 = (r4.line || {}).color, l3 = (r4.marker || {}).color;\n              a4("surfaceaxis") >= 0 && a4("surfacecolor", s3 || l3);\n              for (var u4 = ["x", "y", "z"], c5 = 0; c5 < 3; ++c5) {\n                var f4 = "projection." + u4[c5];\n                a4(f4 + ".show") && (a4(f4 + ".opacity"), a4(f4 + ".scale"));\n              }\n              var h3 = eIe.getComponentMethod("errorbars", "supplyDefaults");\n              h3(t3, r4, s3 || l3 || n4, { axis: "z" }), h3(t3, r4, s3 || l3 || n4, { axis: "y", inherit: "z" }), h3(t3, r4, s3 || l3 || n4, { axis: "x", inherit: "z" });\n            };\n            function jIt(e3, t3, r4, n4) {\n              var i3 = 0, a4 = r4("x"), o4 = r4("y"), s3 = r4("z"), l3 = eIe.getComponentMethod("calendars", "handleTraceDefaults");\n              return l3(e3, t3, ["x", "y", "z"], n4), a4 && o4 && s3 && (i3 = Math.min(a4.length, o4.length, s3.length), t3._length = t3._xlength = t3._ylength = t3._zlength = i3), i3;\n            }\n          });\n          var nIe = ye((rgr, iIe) => {\n            "use strict";\n            var WIt = km(), XIt = F0();\n            iIe.exports = function(t3, r4) {\n              var n4 = [{ x: false, y: false, trace: r4, t: {} }];\n              return WIt(n4, r4), XIt(t3, r4), n4;\n            };\n          });\n          var oIe = ye((igr, aIe) => {\n            aIe.exports = ZIt;\n            function ZIt(e3, t3) {\n              if (typeof e3 != "string") throw new TypeError("must specify type string");\n              if (t3 = t3 || {}, typeof document == "undefined" && !t3.canvas) return null;\n              var r4 = t3.canvas || document.createElement("canvas");\n              typeof t3.width == "number" && (r4.width = t3.width), typeof t3.height == "number" && (r4.height = t3.height);\n              var n4 = t3, i3;\n              try {\n                var a4 = [e3];\n                e3.indexOf("webgl") === 0 && a4.push("experimental-" + e3);\n                for (var o4 = 0; o4 < a4.length; o4++) if (i3 = r4.getContext(a4[o4], n4), i3) return i3;\n              } catch (s3) {\n                i3 = null;\n              }\n              return i3 || null;\n            }\n          });\n          var lIe = ye((ngr, sIe) => {\n            var YIt = oIe();\n            sIe.exports = function(t3) {\n              return YIt("webgl", t3);\n            };\n          });\n          var CX = ye((agr, cIe) => {\n            "use strict";\n            var uIe = ka(), KIt = function() {\n            };\n            cIe.exports = function(t3) {\n              for (var r4 in t3) typeof t3[r4] == "function" && (t3[r4] = KIt);\n              t3.destroy = function() {\n                t3.container.parentNode.removeChild(t3.container);\n              };\n              var n4 = document.createElement("div");\n              n4.className = "no-webgl", n4.style.cursor = "pointer", n4.style.fontSize = "24px", n4.style.color = uIe.defaults[0], n4.style.position = "absolute", n4.style.left = n4.style.top = "0px", n4.style.width = n4.style.height = "100%", n4.style["background-color"] = uIe.lightLine, n4.style["z-index"] = 30;\n              var i3 = document.createElement("p");\n              return i3.textContent = "WebGL is not supported by your browser - visit https://get.webgl.org for more info", i3.style.position = "relative", i3.style.top = "50%", i3.style.left = "50%", i3.style.height = "30%", i3.style.width = "50%", i3.style.margin = "-15% 0 0 -25%", n4.appendChild(i3), t3.container.appendChild(n4), t3.container.style.background = "#FFFFFF", t3.container.onclick = function() {\n                window.open("https://get.webgl.org");\n              }, false;\n            };\n          });\n          var dIe = ye((ogr, hIe) => {\n            "use strict";\n            var G2 = Jy(), JIt = Dr(), $It = ["xaxis", "yaxis", "zaxis"];\n            function fIe() {\n              this.bounds = [[-10, -10, -10], [10, 10, 10]], this.ticks = [[], [], []], this.tickEnable = [true, true, true], this.tickFont = ["sans-serif", "sans-serif", "sans-serif"], this.tickSize = [12, 12, 12], this.tickFontWeight = ["normal", "normal", "normal", "normal"], this.tickFontStyle = ["normal", "normal", "normal", "normal"], this.tickFontVariant = ["normal", "normal", "normal", "normal"], this.tickAngle = [0, 0, 0], this.tickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.tickPad = [18, 18, 18], this.labels = ["x", "y", "z"], this.labelEnable = [true, true, true], this.labelFont = ["Open Sans", "Open Sans", "Open Sans"], this.labelSize = [20, 20, 20], this.labelFontWeight = ["normal", "normal", "normal", "normal"], this.labelFontStyle = ["normal", "normal", "normal", "normal"], this.labelFontVariant = ["normal", "normal", "normal", "normal"], this.labelColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.labelPad = [30, 30, 30], this.lineEnable = [true, true, true], this.lineMirror = [false, false, false], this.lineWidth = [1, 1, 1], this.lineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.lineTickEnable = [true, true, true], this.lineTickMirror = [false, false, false], this.lineTickLength = [10, 10, 10], this.lineTickWidth = [1, 1, 1], this.lineTickColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.gridEnable = [true, true, true], this.gridWidth = [1, 1, 1], this.gridColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroEnable = [true, true, true], this.zeroLineColor = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.zeroLineWidth = [2, 2, 2], this.backgroundEnable = [true, true, true], this.backgroundColor = [[0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5], [0.8, 0.8, 0.8, 0.5]], this._defaultTickPad = this.tickPad.slice(), this._defaultLabelPad = this.labelPad.slice(), this._defaultLineTickLength = this.lineTickLength.slice();\n            }\n            var QIt = fIe.prototype;\n            QIt.merge = function(e3, t3) {\n              for (var r4 = this, n4 = 0; n4 < 3; ++n4) {\n                var i3 = t3[$It[n4]];\n                if (!i3.visible) {\n                  r4.tickEnable[n4] = false, r4.labelEnable[n4] = false, r4.lineEnable[n4] = false, r4.lineTickEnable[n4] = false, r4.gridEnable[n4] = false, r4.zeroEnable[n4] = false, r4.backgroundEnable[n4] = false;\n                  continue;\n                }\n                r4.labels[n4] = e3._meta ? JIt.templateString(i3.title.text, e3._meta) : i3.title.text, "font" in i3.title && (i3.title.font.color && (r4.labelColor[n4] = G2(i3.title.font.color)), i3.title.font.family && (r4.labelFont[n4] = i3.title.font.family), i3.title.font.size && (r4.labelSize[n4] = i3.title.font.size), i3.title.font.weight && (r4.labelFontWeight[n4] = i3.title.font.weight), i3.title.font.style && (r4.labelFontStyle[n4] = i3.title.font.style), i3.title.font.variant && (r4.labelFontVariant[n4] = i3.title.font.variant)), "showline" in i3 && (r4.lineEnable[n4] = i3.showline), "linecolor" in i3 && (r4.lineColor[n4] = G2(i3.linecolor)), "linewidth" in i3 && (r4.lineWidth[n4] = i3.linewidth), "showgrid" in i3 && (r4.gridEnable[n4] = i3.showgrid), "gridcolor" in i3 && (r4.gridColor[n4] = G2(i3.gridcolor)), "gridwidth" in i3 && (r4.gridWidth[n4] = i3.gridwidth), i3.type === "log" ? r4.zeroEnable[n4] = false : "zeroline" in i3 && (r4.zeroEnable[n4] = i3.zeroline), "zerolinecolor" in i3 && (r4.zeroLineColor[n4] = G2(i3.zerolinecolor)), "zerolinewidth" in i3 && (r4.zeroLineWidth[n4] = i3.zerolinewidth), "ticks" in i3 && i3.ticks ? r4.lineTickEnable[n4] = true : r4.lineTickEnable[n4] = false, "ticklen" in i3 && (r4.lineTickLength[n4] = r4._defaultLineTickLength[n4] = i3.ticklen), "tickcolor" in i3 && (r4.lineTickColor[n4] = G2(i3.tickcolor)), "tickwidth" in i3 && (r4.lineTickWidth[n4] = i3.tickwidth), "tickangle" in i3 && (r4.tickAngle[n4] = i3.tickangle === "auto" ? -3600 : Math.PI * -i3.tickangle / 180), "showticklabels" in i3 && (r4.tickEnable[n4] = i3.showticklabels), "tickfont" in i3 && (i3.tickfont.color && (r4.tickColor[n4] = G2(i3.tickfont.color)), i3.tickfont.family && (r4.tickFont[n4] = i3.tickfont.family), i3.tickfont.size && (r4.tickSize[n4] = i3.tickfont.size), i3.tickfont.weight && (r4.tickFontWeight[n4] = i3.tickfont.weight), i3.tickfont.style && (r4.tickFontStyle[n4] = i3.tickfont.style), i3.tickfont.variant && (r4.tickFontVariant[n4] = i3.tickfont.variant)), "mirror" in i3 ? ["ticks", "all", "allticks"].indexOf(i3.mirror) !== -1 ? (r4.lineTickMirror[n4] = true, r4.lineMirror[n4] = true) : i3.mirror === true ? (r4.lineTickMirror[n4] = false, r4.lineMirror[n4] = true) : (r4.lineTickMirror[n4] = false, r4.lineMirror[n4] = false) : r4.lineMirror[n4] = false, "showbackground" in i3 && i3.showbackground !== false ? (r4.backgroundEnable[n4] = true, r4.backgroundColor[n4] = G2(i3.backgroundcolor)) : r4.backgroundEnable[n4] = false;\n              }\n            };\n            function e8t(e3, t3) {\n              var r4 = new fIe();\n              return r4.merge(e3, t3), r4;\n            }\n            hIe.exports = e8t;\n          });\n          var gIe = ye((sgr, pIe) => {\n            "use strict";\n            var t8t = Jy(), r8t = ["xaxis", "yaxis", "zaxis"];\n            function vIe() {\n              this.enabled = [true, true, true], this.colors = [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1]], this.drawSides = [true, true, true], this.lineWidth = [1, 1, 1];\n            }\n            var i8t = vIe.prototype;\n            i8t.merge = function(e3) {\n              for (var t3 = 0; t3 < 3; ++t3) {\n                var r4 = e3[r8t[t3]];\n                if (!r4.visible) {\n                  this.enabled[t3] = false, this.drawSides[t3] = false;\n                  continue;\n                }\n                this.enabled[t3] = r4.showspikes, this.colors[t3] = t8t(r4.spikecolor), this.drawSides[t3] = r4.spikesides, this.lineWidth[t3] = r4.spikethickness;\n              }\n            };\n            function n8t(e3) {\n              var t3 = new vIe();\n              return t3.merge(e3), t3;\n            }\n            pIe.exports = n8t;\n          });\n          var _Ie = ye((lgr, yIe) => {\n            "use strict";\n            yIe.exports = u8t;\n            var mIe = ho(), a8t = Dr(), o8t = ["xaxis", "yaxis", "zaxis"], s8t = [0, 0, 0];\n            function l8t(e3) {\n              for (var t3 = new Array(3), r4 = 0; r4 < 3; ++r4) {\n                for (var n4 = e3[r4], i3 = new Array(n4.length), a4 = 0; a4 < n4.length; ++a4) i3[a4] = n4[a4].x;\n                t3[r4] = i3;\n              }\n              return t3;\n            }\n            function u8t(e3) {\n              for (var t3 = e3.axesOptions, r4 = e3.glplot.axesPixels, n4 = e3.fullSceneLayout, i3 = [[], [], []], a4 = 0; a4 < 3; ++a4) {\n                var o4 = n4[o8t[a4]];\n                if (o4._length = (r4[a4].hi - r4[a4].lo) * r4[a4].pixelsPerDataUnit / e3.dataScale[a4], Math.abs(o4._length) === 1 / 0 || isNaN(o4._length)) i3[a4] = [];\n                else {\n                  o4._input_range = o4.range.slice(), o4.range[0] = r4[a4].lo / e3.dataScale[a4], o4.range[1] = r4[a4].hi / e3.dataScale[a4], o4._m = 1 / (e3.dataScale[a4] * r4[a4].pixelsPerDataUnit), o4.range[0] === o4.range[1] && (o4.range[0] -= 1, o4.range[1] += 1);\n                  var s3 = o4.tickmode;\n                  if (o4.tickmode === "auto") {\n                    o4.tickmode = "linear";\n                    var l3 = o4.nticks || a8t.constrain(o4._length / 40, 4, 9);\n                    mIe.autoTicks(o4, Math.abs(o4.range[1] - o4.range[0]) / l3);\n                  }\n                  for (var u4 = mIe.calcTicks(o4, { msUTC: true }), c5 = 0; c5 < u4.length; ++c5) u4[c5].x = u4[c5].x * e3.dataScale[a4], o4.type === "date" && (u4[c5].text = u4[c5].text.replace(/\\<br\\>/g, " "));\n                  i3[a4] = u4, o4.tickmode = s3;\n                }\n              }\n              t3.ticks = i3;\n              for (var a4 = 0; a4 < 3; ++a4) {\n                s8t[a4] = 0.5 * (e3.glplot.bounds[0][a4] + e3.glplot.bounds[1][a4]);\n                for (var c5 = 0; c5 < 2; ++c5) t3.bounds[c5][a4] = e3.glplot.bounds[c5][a4];\n              }\n              e3.contourLevels = l8t(i3);\n            }\n          });\n          var MIe = ye((ugr, SIe) => {\n            "use strict";\n            var wIe = Od().gl_plot3d, c8t = wIe.createCamera, xIe = wIe.createScene, f8t = lIe(), h8t = RL(), iF = qa(), up = Dr(), rF = up.preserveDrawingBuffer(), nF = ho(), Jg = vf(), d8t = Jy(), v8t = CX(), p8t = UU(), g8t = dIe(), m8t = gIe(), y8t = _Ie(), _8t = Ag().applyAutorangeOptions, YE, tF, TIe = false;\n            function AIe(e3, t3) {\n              var r4 = document.createElement("div"), n4 = e3.container;\n              this.graphDiv = e3.graphDiv;\n              var i3 = document.createElementNS("http://www.w3.org/2000/svg", "svg");\n              i3.style.position = "absolute", i3.style.top = i3.style.left = "0px", i3.style.width = i3.style.height = "100%", i3.style["z-index"] = 20, i3.style["pointer-events"] = "none", r4.appendChild(i3), this.svgContainer = i3, r4.id = e3.id, r4.style.position = "absolute", r4.style.top = r4.style.left = "0px", r4.style.width = r4.style.height = "100%", n4.appendChild(r4), this.fullLayout = t3, this.id = e3.id || "scene", this.fullSceneLayout = t3[this.id], this.plotArgs = [[], {}, {}], this.axesOptions = g8t(t3, t3[this.id]), this.spikeOptions = m8t(t3[this.id]), this.container = r4, this.staticMode = !!e3.staticPlot, this.pixelRatio = this.pixelRatio || e3.plotGlPixelRatio || 2, this.dataScale = [1, 1, 1], this.contourLevels = [[], [], []], this.convertAnnotations = iF.getComponentMethod("annotations3d", "convert"), this.drawAnnotations = iF.getComponentMethod("annotations3d", "draw"), this.initializeGLPlot();\n            }\n            var Sv = AIe.prototype;\n            Sv.prepareOptions = function() {\n              var e3 = this, t3 = { canvas: e3.canvas, gl: e3.gl, glOptions: { preserveDrawingBuffer: rF, premultipliedAlpha: true, antialias: true }, container: e3.container, axes: e3.axesOptions, spikes: e3.spikeOptions, pickRadius: 10, snapToData: true, autoScale: true, autoBounds: false, cameraObject: e3.camera, pixelRatio: e3.pixelRatio };\n              if (e3.staticMode) {\n                if (!tF && (YE = document.createElement("canvas"), tF = f8t({ canvas: YE, preserveDrawingBuffer: true, premultipliedAlpha: true, antialias: true }), !tF)) throw new Error("error creating static canvas/context for image server");\n                t3.gl = tF, t3.canvas = YE;\n              }\n              return t3;\n            };\n            var bIe = true;\n            Sv.tryCreatePlot = function() {\n              var e3 = this, t3 = e3.prepareOptions(), r4 = true;\n              try {\n                e3.glplot = xIe(t3);\n              } catch (n4) {\n                if (e3.staticMode || !bIe || rF) r4 = false;\n                else {\n                  up.warn(["webgl setup failed possibly due to", "false preserveDrawingBuffer config.", "The mobile/tablet device may not be detected by is-mobile module.", "Enabling preserveDrawingBuffer in second attempt to create webgl scene..."].join(" "));\n                  try {\n                    rF = t3.glOptions.preserveDrawingBuffer = true, e3.glplot = xIe(t3);\n                  } catch (i3) {\n                    rF = t3.glOptions.preserveDrawingBuffer = false, r4 = false;\n                  }\n                }\n              }\n              return bIe = false, r4;\n            };\n            Sv.initializeGLCamera = function() {\n              var e3 = this, t3 = e3.fullSceneLayout.camera, r4 = t3.projection.type === "orthographic";\n              e3.camera = c8t(e3.container, { center: [t3.center.x, t3.center.y, t3.center.z], eye: [t3.eye.x, t3.eye.y, t3.eye.z], up: [t3.up.x, t3.up.y, t3.up.z], _ortho: r4, zoomMin: 0.01, zoomMax: 100, mode: "orbit" });\n            };\n            Sv.initializeGLPlot = function() {\n              var e3 = this;\n              e3.initializeGLCamera();\n              var t3 = e3.tryCreatePlot();\n              if (!t3) return v8t(e3);\n              e3.traces = {}, e3.make4thDimension();\n              var r4 = e3.graphDiv, n4 = r4.layout, i3 = function() {\n                var o4 = {};\n                return e3.isCameraChanged(n4) && (o4[e3.id + ".camera"] = e3.getCamera()), e3.isAspectChanged(n4) && (o4[e3.id + ".aspectratio"] = e3.glplot.getAspectratio(), n4[e3.id].aspectmode !== "manual" && (e3.fullSceneLayout.aspectmode = n4[e3.id].aspectmode = o4[e3.id + ".aspectmode"] = "manual")), o4;\n              }, a4 = function(o4) {\n                if (o4.fullSceneLayout.dragmode !== false) {\n                  var s3 = i3();\n                  o4.saveLayout(n4), o4.graphDiv.emit("plotly_relayout", s3);\n                }\n              };\n              return e3.glplot.canvas && (e3.glplot.canvas.addEventListener("mouseup", function() {\n                a4(e3);\n              }), e3.glplot.canvas.addEventListener("touchstart", function() {\n                TIe = true;\n              }), e3.glplot.canvas.addEventListener("wheel", function(o4) {\n                if (r4._context._scrollZoom.gl3d) {\n                  if (e3.camera._ortho) {\n                    var s3 = o4.deltaX > o4.deltaY ? 1.1 : 0.9090909090909091, l3 = e3.glplot.getAspectratio();\n                    e3.glplot.setAspectratio({ x: s3 * l3.x, y: s3 * l3.y, z: s3 * l3.z });\n                  }\n                  a4(e3);\n                }\n              }, h8t ? { passive: false } : false), e3.glplot.canvas.addEventListener("mousemove", function() {\n                if (e3.fullSceneLayout.dragmode !== false && e3.camera.mouseListener.buttons !== 0) {\n                  var o4 = i3();\n                  e3.graphDiv.emit("plotly_relayouting", o4);\n                }\n              }), e3.staticMode || e3.glplot.canvas.addEventListener("webglcontextlost", function(o4) {\n                r4 && r4.emit && r4.emit("plotly_webglcontextlost", { event: o4, layer: e3.id });\n              }, false)), e3.glplot.oncontextloss = function() {\n                e3.recoverContext();\n              }, e3.glplot.onrender = function() {\n                e3.render();\n              }, true;\n            };\n            Sv.render = function() {\n              var e3 = this, t3 = e3.graphDiv, r4, n4 = e3.svgContainer, i3 = e3.container.getBoundingClientRect();\n              t3._fullLayout._calcInverseTransform(t3);\n              var a4 = t3._fullLayout._invScaleX, o4 = t3._fullLayout._invScaleY, s3 = i3.width * a4, l3 = i3.height * o4;\n              n4.setAttributeNS(null, "viewBox", "0 0 " + s3 + " " + l3), n4.setAttributeNS(null, "width", s3), n4.setAttributeNS(null, "height", l3), y8t(e3), e3.glplot.axes.update(e3.axesOptions);\n              for (var u4 = Object.keys(e3.traces), c5 = null, f4 = e3.glplot.selection, h3 = 0; h3 < u4.length; ++h3) r4 = e3.traces[u4[h3]], r4.data.hoverinfo !== "skip" && r4.handlePick(f4) && (c5 = r4), r4.setContourLevels && r4.setContourLevels();\n              function d3(P3, T3, z3) {\n                var O3 = e3.fullSceneLayout[P3 + "axis"];\n                return O3.type !== "log" && (T3 = O3.d2l(T3)), nF.hoverLabelText(O3, T3, z3);\n              }\n              if (c5 !== null) {\n                var v3 = p8t(e3.glplot.cameraParams, f4.dataCoordinate);\n                r4 = c5.data;\n                var _2 = t3._fullData[r4.index], b = f4.index, p3 = { xLabel: d3("x", f4.traceCoordinate[0], r4.xhoverformat), yLabel: d3("y", f4.traceCoordinate[1], r4.yhoverformat), zLabel: d3("z", f4.traceCoordinate[2], r4.zhoverformat) }, k4 = Jg.castHoverinfo(_2, e3.fullLayout, b), E3 = (k4 || "").split("+"), S2 = k4 && k4 === "all";\n                !_2.hovertemplate && !S2 && (E3.indexOf("x") === -1 && (p3.xLabel = void 0), E3.indexOf("y") === -1 && (p3.yLabel = void 0), E3.indexOf("z") === -1 && (p3.zLabel = void 0), E3.indexOf("text") === -1 && (f4.textLabel = void 0), E3.indexOf("name") === -1 && (c5.name = void 0));\n                var L3, x2 = [];\n                r4.type === "cone" || r4.type === "streamtube" ? (p3.uLabel = d3("x", f4.traceCoordinate[3], r4.uhoverformat), (S2 || E3.indexOf("u") !== -1) && x2.push("u: " + p3.uLabel), p3.vLabel = d3("y", f4.traceCoordinate[4], r4.vhoverformat), (S2 || E3.indexOf("v") !== -1) && x2.push("v: " + p3.vLabel), p3.wLabel = d3("z", f4.traceCoordinate[5], r4.whoverformat), (S2 || E3.indexOf("w") !== -1) && x2.push("w: " + p3.wLabel), p3.normLabel = f4.traceCoordinate[6].toPrecision(3), (S2 || E3.indexOf("norm") !== -1) && x2.push("norm: " + p3.normLabel), r4.type === "streamtube" && (p3.divergenceLabel = f4.traceCoordinate[7].toPrecision(3), (S2 || E3.indexOf("divergence") !== -1) && x2.push("divergence: " + p3.divergenceLabel)), f4.textLabel && x2.push(f4.textLabel), L3 = x2.join("<br>")) : r4.type === "isosurface" || r4.type === "volume" ? (p3.valueLabel = nF.hoverLabelText(e3._mockAxis, e3._mockAxis.d2l(f4.traceCoordinate[3]), r4.valuehoverformat), x2.push("value: " + p3.valueLabel), f4.textLabel && x2.push(f4.textLabel), L3 = x2.join("<br>")) : L3 = f4.textLabel;\n                var C3 = { x: f4.traceCoordinate[0], y: f4.traceCoordinate[1], z: f4.traceCoordinate[2], data: _2._input, fullData: _2, curveNumber: _2.index, pointNumber: b };\n                Jg.appendArrayPointValue(C3, _2, b), r4._module.eventData && (C3 = _2._module.eventData(C3, f4, _2, {}, b));\n                var M4 = { points: [C3] };\n                if (e3.fullSceneLayout.hovermode) {\n                  var g3 = [];\n                  Jg.loneHover({ trace: _2, x: (0.5 + 0.5 * v3[0] / v3[3]) * s3, y: (0.5 - 0.5 * v3[1] / v3[3]) * l3, xLabel: p3.xLabel, yLabel: p3.yLabel, zLabel: p3.zLabel, text: L3, name: c5.name, color: Jg.castHoverOption(_2, b, "bgcolor") || c5.color, borderColor: Jg.castHoverOption(_2, b, "bordercolor"), fontFamily: Jg.castHoverOption(_2, b, "font.family"), fontSize: Jg.castHoverOption(_2, b, "font.size"), fontColor: Jg.castHoverOption(_2, b, "font.color"), nameLength: Jg.castHoverOption(_2, b, "namelength"), textAlign: Jg.castHoverOption(_2, b, "align"), hovertemplate: up.castOption(_2, b, "hovertemplate"), hovertemplateLabels: up.extendFlat({}, C3, p3), eventData: [C3] }, { container: n4, gd: t3, inOut_bbox: g3 }), C3.bbox = g3[0];\n                }\n                f4.distance < 5 && (f4.buttons || TIe) ? t3.emit("plotly_click", M4) : t3.emit("plotly_hover", M4), this.oldEventData = M4;\n              } else Jg.loneUnhover(n4), this.oldEventData && t3.emit("plotly_unhover", this.oldEventData), this.oldEventData = void 0;\n              e3.drawAnnotations(e3);\n            };\n            Sv.recoverContext = function() {\n              var e3 = this;\n              e3.glplot.dispose();\n              var t3 = function() {\n                if (e3.glplot.gl.isContextLost()) {\n                  requestAnimationFrame(t3);\n                  return;\n                }\n                if (!e3.initializeGLPlot()) {\n                  up.error("Catastrophic and unrecoverable WebGL error. Context lost.");\n                  return;\n                }\n                e3.plot.apply(e3, e3.plotArgs);\n              };\n              requestAnimationFrame(t3);\n            };\n            var KE = ["xaxis", "yaxis", "zaxis"];\n            function x8t(e3, t3, r4) {\n              for (var n4 = e3.fullSceneLayout, i3 = 0; i3 < 3; i3++) {\n                var a4 = KE[i3], o4 = a4.charAt(0), s3 = n4[a4], l3 = t3[o4], u4 = t3[o4 + "calendar"], c5 = t3["_" + o4 + "length"];\n                if (!up.isArrayOrTypedArray(l3)) r4[0][i3] = Math.min(r4[0][i3], 0), r4[1][i3] = Math.max(r4[1][i3], c5 - 1);\n                else for (var f4, h3 = 0; h3 < (c5 || l3.length); h3++) if (up.isArrayOrTypedArray(l3[h3])) for (var d3 = 0; d3 < l3[h3].length; ++d3) f4 = s3.d2l(l3[h3][d3], 0, u4), !isNaN(f4) && isFinite(f4) && (r4[0][i3] = Math.min(r4[0][i3], f4), r4[1][i3] = Math.max(r4[1][i3], f4));\n                else f4 = s3.d2l(l3[h3], 0, u4), !isNaN(f4) && isFinite(f4) && (r4[0][i3] = Math.min(r4[0][i3], f4), r4[1][i3] = Math.max(r4[1][i3], f4));\n              }\n            }\n            function b8t(e3, t3) {\n              for (var r4 = e3.fullSceneLayout, n4 = r4.annotations || [], i3 = 0; i3 < 3; i3++) for (var a4 = KE[i3], o4 = a4.charAt(0), s3 = r4[a4], l3 = 0; l3 < n4.length; l3++) {\n                var u4 = n4[l3];\n                if (u4.visible) {\n                  var c5 = s3.r2l(u4[o4]);\n                  !isNaN(c5) && isFinite(c5) && (t3[0][i3] = Math.min(t3[0][i3], c5), t3[1][i3] = Math.max(t3[1][i3], c5));\n                }\n              }\n            }\n            Sv.plot = function(e3, t3, r4) {\n              var n4 = this;\n              if (n4.plotArgs = [e3, t3, r4], !n4.glplot.contextLost) {\n                var i3, a4, o4, s3, l3, u4, c5 = t3[n4.id], f4 = r4[n4.id];\n                n4.fullLayout = t3, n4.fullSceneLayout = c5, n4.axesOptions.merge(t3, c5), n4.spikeOptions.merge(c5), n4.setViewport(c5), n4.updateFx(c5.dragmode, c5.hovermode), n4.camera.enableWheel = n4.graphDiv._context._scrollZoom.gl3d, n4.glplot.setClearColor(d8t(c5.bgcolor)), n4.setConvert(l3), e3 ? Array.isArray(e3) || (e3 = [e3]) : e3 = [];\n                var h3 = [[1 / 0, 1 / 0, 1 / 0], [-1 / 0, -1 / 0, -1 / 0]];\n                for (o4 = 0; o4 < e3.length; ++o4) i3 = e3[o4], !(i3.visible !== true || i3._length === 0) && x8t(this, i3, h3);\n                b8t(this, h3);\n                var d3 = [1, 1, 1];\n                for (s3 = 0; s3 < 3; ++s3) h3[1][s3] === h3[0][s3] ? d3[s3] = 1 : d3[s3] = 1 / (h3[1][s3] - h3[0][s3]);\n                for (n4.dataScale = d3, n4.convertAnnotations(this), o4 = 0; o4 < e3.length; ++o4) i3 = e3[o4], !(i3.visible !== true || i3._length === 0) && (a4 = n4.traces[i3.uid], a4 ? a4.data.type === i3.type ? a4.update(i3) : (a4.dispose(), a4 = i3._module.plot(this, i3), n4.traces[i3.uid] = a4) : (a4 = i3._module.plot(this, i3), n4.traces[i3.uid] = a4), a4.name = i3.name);\n                var v3 = Object.keys(n4.traces);\n                e: for (o4 = 0; o4 < v3.length; ++o4) {\n                  for (s3 = 0; s3 < e3.length; ++s3) if (e3[s3].uid === v3[o4] && e3[s3].visible === true && e3[s3]._length !== 0) continue e;\n                  a4 = n4.traces[v3[o4]], a4.dispose(), delete n4.traces[v3[o4]];\n                }\n                n4.glplot.objects.sort(function(oe, _e) {\n                  return oe._trace.data.index - _e._trace.data.index;\n                });\n                var _2 = [[0, 0, 0], [0, 0, 0]], b = [], p3 = {};\n                for (o4 = 0; o4 < 3; ++o4) {\n                  l3 = c5[KE[o4]], u4 = l3.type, u4 in p3 ? (p3[u4].acc *= d3[o4], p3[u4].count += 1) : p3[u4] = { acc: d3[o4], count: 1 };\n                  var k4;\n                  if (l3.autorange) {\n                    _2[0][o4] = 1 / 0, _2[1][o4] = -1 / 0;\n                    var E3 = n4.glplot.objects, S2 = n4.fullSceneLayout.annotations || [], L3 = l3._name.charAt(0);\n                    for (s3 = 0; s3 < E3.length; s3++) {\n                      var x2 = E3[s3], C3 = x2.bounds, M4 = x2._trace.data._pad || 0;\n                      x2.constructor.name === "ErrorBars" && l3._lowerLogErrorBound ? _2[0][o4] = Math.min(_2[0][o4], l3._lowerLogErrorBound) : _2[0][o4] = Math.min(_2[0][o4], C3[0][o4] / d3[o4] - M4), _2[1][o4] = Math.max(_2[1][o4], C3[1][o4] / d3[o4] + M4);\n                    }\n                    for (s3 = 0; s3 < S2.length; s3++) {\n                      var g3 = S2[s3];\n                      if (g3.visible) {\n                        var P3 = l3.r2l(g3[L3]);\n                        _2[0][o4] = Math.min(_2[0][o4], P3), _2[1][o4] = Math.max(_2[1][o4], P3);\n                      }\n                    }\n                    if ("rangemode" in l3 && l3.rangemode === "tozero" && (_2[0][o4] = Math.min(_2[0][o4], 0), _2[1][o4] = Math.max(_2[1][o4], 0)), _2[0][o4] > _2[1][o4]) _2[0][o4] = -1, _2[1][o4] = 1;\n                    else {\n                      var T3 = _2[1][o4] - _2[0][o4];\n                      _2[0][o4] -= T3 / 32, _2[1][o4] += T3 / 32;\n                    }\n                    if (k4 = [_2[0][o4], _2[1][o4]], k4 = _8t(k4, l3), _2[0][o4] = k4[0], _2[1][o4] = k4[1], l3.isReversed()) {\n                      var z3 = _2[0][o4];\n                      _2[0][o4] = _2[1][o4], _2[1][o4] = z3;\n                    }\n                  } else k4 = l3.range, _2[0][o4] = l3.r2l(k4[0]), _2[1][o4] = l3.r2l(k4[1]);\n                  _2[0][o4] === _2[1][o4] && (_2[0][o4] -= 1, _2[1][o4] += 1), b[o4] = _2[1][o4] - _2[0][o4], l3.range = [_2[0][o4], _2[1][o4]], l3.limitRange(), n4.glplot.setBounds(o4, { min: l3.range[0] * d3[o4], max: l3.range[1] * d3[o4] });\n                }\n                var O3, V2 = c5.aspectmode;\n                if (V2 === "cube") O3 = [1, 1, 1];\n                else if (V2 === "manual") {\n                  var G2 = c5.aspectratio;\n                  O3 = [G2.x, G2.y, G2.z];\n                } else if (V2 === "auto" || V2 === "data") {\n                  var Z = [1, 1, 1];\n                  for (o4 = 0; o4 < 3; ++o4) {\n                    l3 = c5[KE[o4]], u4 = l3.type;\n                    var j3 = p3[u4];\n                    Z[o4] = Math.pow(j3.acc, 1 / j3.count) / d3[o4];\n                  }\n                  V2 === "data" || Math.max.apply(null, Z) / Math.min.apply(null, Z) <= 4 ? O3 = Z : O3 = [1, 1, 1];\n                } else throw new Error("scene.js aspectRatio was not one of the enumerated types");\n                c5.aspectratio.x = f4.aspectratio.x = O3[0], c5.aspectratio.y = f4.aspectratio.y = O3[1], c5.aspectratio.z = f4.aspectratio.z = O3[2], n4.glplot.setAspectratio(c5.aspectratio), n4.viewInitial.aspectratio || (n4.viewInitial.aspectratio = { x: c5.aspectratio.x, y: c5.aspectratio.y, z: c5.aspectratio.z }), n4.viewInitial.aspectmode || (n4.viewInitial.aspectmode = c5.aspectmode);\n                var N2 = c5.domain || null, H = t3._size || null;\n                if (N2 && H) {\n                  var te = n4.container.style;\n                  te.position = "absolute", te.left = H.l + N2.x[0] * H.w + "px", te.top = H.t + (1 - N2.y[1]) * H.h + "px", te.width = H.w * (N2.x[1] - N2.x[0]) + "px", te.height = H.h * (N2.y[1] - N2.y[0]) + "px";\n                }\n                n4.glplot.redraw();\n              }\n            };\n            Sv.destroy = function() {\n              var e3 = this;\n              e3.glplot && (e3.camera.mouseListener.enabled = false, e3.container.removeEventListener("wheel", e3.camera.wheelListener), e3.camera = null, e3.glplot.dispose(), e3.container.parentNode.removeChild(e3.container), e3.glplot = null);\n            };\n            function w8t(e3) {\n              return [[e3.eye.x, e3.eye.y, e3.eye.z], [e3.center.x, e3.center.y, e3.center.z], [e3.up.x, e3.up.y, e3.up.z]];\n            }\n            function T8t(e3) {\n              return { up: { x: e3.up[0], y: e3.up[1], z: e3.up[2] }, center: { x: e3.center[0], y: e3.center[1], z: e3.center[2] }, eye: { x: e3.eye[0], y: e3.eye[1], z: e3.eye[2] }, projection: { type: e3._ortho === true ? "orthographic" : "perspective" } };\n            }\n            Sv.getCamera = function() {\n              var e3 = this;\n              return e3.camera.view.recalcMatrix(e3.camera.view.lastT()), T8t(e3.camera);\n            };\n            Sv.setViewport = function(e3) {\n              var t3 = this, r4 = e3.camera;\n              t3.camera.lookAt.apply(this, w8t(r4)), t3.glplot.setAspectratio(e3.aspectratio);\n              var n4 = r4.projection.type === "orthographic", i3 = t3.camera._ortho;\n              n4 !== i3 && (t3.glplot.redraw(), t3.glplot.clearRGBA(), t3.glplot.dispose(), t3.initializeGLPlot());\n            };\n            Sv.isCameraChanged = function(e3) {\n              var t3 = this, r4 = t3.getCamera(), n4 = up.nestedProperty(e3, t3.id + ".camera"), i3 = n4.get();\n              function a4(u4, c5, f4, h3) {\n                var d3 = ["up", "center", "eye"], v3 = ["x", "y", "z"];\n                return c5[d3[f4]] && u4[d3[f4]][v3[h3]] === c5[d3[f4]][v3[h3]];\n              }\n              var o4 = false;\n              if (i3 === void 0) o4 = true;\n              else {\n                for (var s3 = 0; s3 < 3; s3++) for (var l3 = 0; l3 < 3; l3++) if (!a4(r4, i3, s3, l3)) {\n                  o4 = true;\n                  break;\n                }\n                (!i3.projection || r4.projection && r4.projection.type !== i3.projection.type) && (o4 = true);\n              }\n              return o4;\n            };\n            Sv.isAspectChanged = function(e3) {\n              var t3 = this, r4 = t3.glplot.getAspectratio(), n4 = up.nestedProperty(e3, t3.id + ".aspectratio"), i3 = n4.get();\n              return i3 === void 0 || i3.x !== r4.x || i3.y !== r4.y || i3.z !== r4.z;\n            };\n            Sv.saveLayout = function(e3) {\n              var t3 = this, r4 = t3.fullLayout, n4, i3, a4, o4, s3, l3, u4 = t3.isCameraChanged(e3), c5 = t3.isAspectChanged(e3), f4 = u4 || c5;\n              if (f4) {\n                var h3 = {};\n                if (u4 && (n4 = t3.getCamera(), i3 = up.nestedProperty(e3, t3.id + ".camera"), a4 = i3.get(), h3[t3.id + ".camera"] = a4), c5 && (o4 = t3.glplot.getAspectratio(), s3 = up.nestedProperty(e3, t3.id + ".aspectratio"), l3 = s3.get(), h3[t3.id + ".aspectratio"] = l3), iF.call("_storeDirectGUIEdit", e3, r4._preGUI, h3), u4) {\n                  i3.set(n4);\n                  var d3 = up.nestedProperty(r4, t3.id + ".camera");\n                  d3.set(n4);\n                }\n                if (c5) {\n                  s3.set(o4);\n                  var v3 = up.nestedProperty(r4, t3.id + ".aspectratio");\n                  v3.set(o4), t3.glplot.redraw();\n                }\n              }\n              return f4;\n            };\n            Sv.updateFx = function(e3, t3) {\n              var r4 = this, n4 = r4.camera;\n              if (n4) if (e3 === "orbit") n4.mode = "orbit", n4.keyBindingMode = "rotate";\n              else if (e3 === "turntable") {\n                n4.up = [0, 0, 1], n4.mode = "turntable", n4.keyBindingMode = "rotate";\n                var i3 = r4.graphDiv, a4 = i3._fullLayout, o4 = r4.fullSceneLayout.camera, s3 = o4.up.x, l3 = o4.up.y, u4 = o4.up.z;\n                if (u4 / Math.sqrt(s3 * s3 + l3 * l3 + u4 * u4) < 0.999) {\n                  var c5 = r4.id + ".camera.up", f4 = { x: 0, y: 0, z: 1 }, h3 = {};\n                  h3[c5] = f4;\n                  var d3 = i3.layout;\n                  iF.call("_storeDirectGUIEdit", d3, a4._preGUI, h3), o4.up = f4, up.nestedProperty(d3, c5).set(f4);\n                }\n              } else n4.keyBindingMode = e3;\n              r4.fullSceneLayout.hovermode = t3;\n            };\n            function A8t(e3, t3, r4) {\n              for (var n4 = 0, i3 = r4 - 1; n4 < i3; ++n4, --i3) for (var a4 = 0; a4 < t3; ++a4) for (var o4 = 0; o4 < 4; ++o4) {\n                var s3 = 4 * (t3 * n4 + a4) + o4, l3 = 4 * (t3 * i3 + a4) + o4, u4 = e3[s3];\n                e3[s3] = e3[l3], e3[l3] = u4;\n              }\n            }\n            function S8t(e3, t3, r4) {\n              for (var n4 = 0; n4 < r4; ++n4) for (var i3 = 0; i3 < t3; ++i3) {\n                var a4 = 4 * (t3 * n4 + i3), o4 = e3[a4 + 3];\n                if (o4 > 0) for (var s3 = 255 / o4, l3 = 0; l3 < 3; ++l3) e3[a4 + l3] = Math.min(s3 * e3[a4 + l3], 255);\n              }\n            }\n            Sv.toImage = function(e3) {\n              var t3 = this;\n              e3 || (e3 = "png"), t3.staticMode && t3.container.appendChild(YE), t3.glplot.redraw();\n              var r4 = t3.glplot.gl, n4 = r4.drawingBufferWidth, i3 = r4.drawingBufferHeight;\n              r4.bindFramebuffer(r4.FRAMEBUFFER, null);\n              var a4 = new Uint8Array(n4 * i3 * 4);\n              r4.readPixels(0, 0, n4, i3, r4.RGBA, r4.UNSIGNED_BYTE, a4), A8t(a4, n4, i3), S8t(a4, n4, i3);\n              var o4 = document.createElement("canvas");\n              o4.width = n4, o4.height = i3;\n              var s3 = o4.getContext("2d", { willReadFrequently: true }), l3 = s3.createImageData(n4, i3);\n              l3.data.set(a4), s3.putImageData(l3, 0, 0);\n              var u4;\n              switch (e3) {\n                case "jpeg":\n                  u4 = o4.toDataURL("image/jpeg");\n                  break;\n                case "webp":\n                  u4 = o4.toDataURL("image/webp");\n                  break;\n                default:\n                  u4 = o4.toDataURL("image/png");\n              }\n              return t3.staticMode && t3.container.removeChild(YE), u4;\n            };\n            Sv.setConvert = function() {\n              for (var e3 = this, t3 = 0; t3 < 3; t3++) {\n                var r4 = e3.fullSceneLayout[KE[t3]];\n                nF.setConvert(r4, e3.fullLayout), r4.setScale = up.noop;\n              }\n            };\n            Sv.make4thDimension = function() {\n              var e3 = this, t3 = e3.graphDiv, r4 = t3._fullLayout;\n              e3._mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, nF.setConvert(e3._mockAxis, r4);\n            };\n            SIe.exports = AIe;\n          });\n          var kIe = ye((cgr, EIe) => {\n            "use strict";\n            EIe.exports = { scene: { valType: "subplotid", dflt: "scene", editType: "calc+clearAxisTypes" } };\n          });\n          var PX = ye((fgr, CIe) => {\n            "use strict";\n            var M8t = ka(), xs = Rd(), LX = Ao().extendFlat, E8t = mc().overrideAll;\n            CIe.exports = E8t({ visible: xs.visible, showspikes: { valType: "boolean", dflt: true }, spikesides: { valType: "boolean", dflt: true }, spikethickness: { valType: "number", min: 0, dflt: 2 }, spikecolor: { valType: "color", dflt: M8t.defaultLine }, showbackground: { valType: "boolean", dflt: false }, backgroundcolor: { valType: "color", dflt: "rgba(204, 204, 204, 0.5)" }, showaxeslabels: { valType: "boolean", dflt: true }, color: xs.color, categoryorder: xs.categoryorder, categoryarray: xs.categoryarray, title: { text: xs.title.text, font: xs.title.font }, type: LX({}, xs.type, { values: ["-", "linear", "log", "date", "category"] }), autotypenumbers: xs.autotypenumbers, autorange: xs.autorange, autorangeoptions: { minallowed: xs.autorangeoptions.minallowed, maxallowed: xs.autorangeoptions.maxallowed, clipmin: xs.autorangeoptions.clipmin, clipmax: xs.autorangeoptions.clipmax, include: xs.autorangeoptions.include, editType: "plot" }, rangemode: xs.rangemode, minallowed: xs.minallowed, maxallowed: xs.maxallowed, range: LX({}, xs.range, { items: [{ valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }], anim: false }), tickmode: xs.minor.tickmode, nticks: xs.nticks, tick0: xs.tick0, dtick: xs.dtick, tickvals: xs.tickvals, ticktext: xs.ticktext, ticks: xs.ticks, mirror: xs.mirror, ticklen: xs.ticklen, tickwidth: xs.tickwidth, tickcolor: xs.tickcolor, showticklabels: xs.showticklabels, labelalias: xs.labelalias, tickfont: xs.tickfont, tickangle: xs.tickangle, tickprefix: xs.tickprefix, showtickprefix: xs.showtickprefix, ticksuffix: xs.ticksuffix, showticksuffix: xs.showticksuffix, showexponent: xs.showexponent, exponentformat: xs.exponentformat, minexponent: xs.minexponent, separatethousands: xs.separatethousands, tickformat: xs.tickformat, tickformatstops: xs.tickformatstops, hoverformat: xs.hoverformat, showline: xs.showline, linecolor: xs.linecolor, linewidth: xs.linewidth, showgrid: xs.showgrid, gridcolor: LX({}, xs.gridcolor, { dflt: "rgb(204, 204, 204)" }), gridwidth: xs.gridwidth, zeroline: xs.zeroline, zerolinecolor: xs.zerolinecolor, zerolinewidth: xs.zerolinewidth }, "plot", "from-root");\n          });\n          var FX = ye((hgr, LIe) => {\n            "use strict";\n            var IX = PX(), k8t = Cc().attributes, RX = Ao().extendFlat, C8t = Dr().counterRegex;\n            function DX(e3, t3, r4) {\n              return { x: { valType: "number", dflt: e3, editType: "camera" }, y: { valType: "number", dflt: t3, editType: "camera" }, z: { valType: "number", dflt: r4, editType: "camera" }, editType: "camera" };\n            }\n            LIe.exports = { _arrayAttrRegexps: [C8t("scene", ".annotations", true)], bgcolor: { valType: "color", dflt: "rgba(0,0,0,0)", editType: "plot" }, camera: { up: RX(DX(0, 0, 1), {}), center: RX(DX(0, 0, 0), {}), eye: RX(DX(1.25, 1.25, 1.25), {}), projection: { type: { valType: "enumerated", values: ["perspective", "orthographic"], dflt: "perspective", editType: "calc" }, editType: "calc" }, editType: "camera" }, domain: k8t({ name: "scene", editType: "plot" }), aspectmode: { valType: "enumerated", values: ["auto", "cube", "data", "manual"], dflt: "auto", editType: "plot", impliedEdits: { "aspectratio.x": void 0, "aspectratio.y": void 0, "aspectratio.z": void 0 } }, aspectratio: { x: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, y: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, z: { valType: "number", min: 0, editType: "plot", impliedEdits: { "^aspectmode": "manual" } }, editType: "plot", impliedEdits: { aspectmode: "manual" } }, xaxis: IX, yaxis: IX, zaxis: IX, dragmode: { valType: "enumerated", values: ["orbit", "turntable", "zoom", "pan", false], editType: "plot" }, hovermode: { valType: "enumerated", values: ["closest", false], dflt: "closest", editType: "modebar" }, uirevision: { valType: "any", editType: "none" }, editType: "plot" };\n          });\n          var DIe = ye((dgr, RIe) => {\n            "use strict";\n            var L8t = cd().mix, PIe = Dr(), P8t = vl(), I8t = PX(), R8t = SU(), D8t = i4(), IIe = ["xaxis", "yaxis", "zaxis"], F8t = 100 * 136 / 187;\n            RIe.exports = function(t3, r4, n4) {\n              var i3, a4;\n              function o4(u4, c5) {\n                return PIe.coerce(i3, a4, I8t, u4, c5);\n              }\n              for (var s3 = 0; s3 < IIe.length; s3++) {\n                var l3 = IIe[s3];\n                i3 = t3[l3] || {}, a4 = P8t.newContainer(r4, l3), a4._id = l3[0] + n4.scene, a4._name = l3, R8t(i3, a4, o4, n4), D8t(i3, a4, o4, { font: n4.font, letter: l3[0], data: n4.data, showGrid: true, noAutotickangles: true, noMinorloglabels: true, noTicklabelindex: true, noTickson: true, noTicklabelmode: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, noTicklabelposition: true, noTicklabeloverflow: true, noInsiderange: true, noUnifiedhovertitle: true, bgColor: n4.bgColor, calendar: n4.calendar }, n4.fullLayout), o4("gridcolor", L8t(a4.color, n4.bgColor, F8t).toRgbString()), o4("title.text", l3[0]), a4.setScale = PIe.noop, o4("showspikes") && (o4("spikesides"), o4("spikethickness"), o4("spikecolor", a4.color)), o4("showaxeslabels"), o4("showbackground") && o4("backgroundcolor");\n              }\n            };\n          });\n          var qIe = ye((vgr, OIe) => {\n            "use strict";\n            var z8t = Dr(), O8t = ka(), q8t = qa(), B8t = k_(), N8t = DIe(), FIe = FX(), U8t = Id().getSubplotData, zIe = "gl3d";\n            OIe.exports = function(t3, r4, n4) {\n              var i3 = r4._basePlotModules.length > 1;\n              function a4(o4) {\n                if (!i3) {\n                  var s3 = z8t.validate(t3[o4], FIe[o4]);\n                  if (s3) return t3[o4];\n                }\n              }\n              B8t(t3, r4, n4, { type: zIe, attributes: FIe, handleDefaults: V8t, fullLayout: r4, font: r4.font, fullData: n4, getDfltFromLayout: a4, autotypenumbersDflt: r4.autotypenumbers, paper_bgcolor: r4.paper_bgcolor, calendar: r4.calendar });\n            };\n            function V8t(e3, t3, r4, n4) {\n              for (var i3 = r4("bgcolor"), a4 = O8t.combine(i3, n4.paper_bgcolor), o4 = ["up", "center", "eye"], s3 = 0; s3 < o4.length; s3++) r4("camera." + o4[s3] + ".x"), r4("camera." + o4[s3] + ".y"), r4("camera." + o4[s3] + ".z");\n              r4("camera.projection.type");\n              var l3 = !!r4("aspectratio.x") && !!r4("aspectratio.y") && !!r4("aspectratio.z"), u4 = l3 ? "manual" : "auto", c5 = r4("aspectmode", u4);\n              l3 || (e3.aspectratio = t3.aspectratio = { x: 1, y: 1, z: 1 }, c5 === "manual" && (t3.aspectmode = "auto"), e3.aspectmode = t3.aspectmode);\n              var f4 = U8t(n4.fullData, zIe, n4.id);\n              N8t(e3, t3, { font: n4.font, scene: n4.id, data: f4, bgColor: a4, calendar: n4.calendar, autotypenumbersDflt: n4.autotypenumbersDflt, fullLayout: n4.fullLayout }), q8t.getComponentMethod("annotations3d", "handleDefaults")(e3, t3, n4);\n              var h3 = n4.getDfltFromLayout("dragmode");\n              if (h3 !== false && !h3) if (h3 = "orbit", e3.camera && e3.camera.up) {\n                var d3 = e3.camera.up.x, v3 = e3.camera.up.y, _2 = e3.camera.up.z;\n                _2 !== 0 && (!d3 || !v3 || !_2 || _2 / Math.sqrt(d3 * d3 + v3 * v3 + _2 * _2) > 0.999) && (h3 = "turntable");\n              } else h3 = "turntable";\n              r4("dragmode", h3), r4("hovermode", n4.getDfltFromLayout("hovermode"));\n            }\n          });\n          var $_ = ye((cp) => {\n            "use strict";\n            var G8t = mc().overrideAll, H8t = B1(), j8t = MIe(), W8t = Id().getSubplotData, X8t = Dr(), Z8t = Wp(), GA = "gl3d", zX = "scene";\n            cp.name = GA;\n            cp.attr = zX;\n            cp.idRoot = zX;\n            cp.idRegex = cp.attrRegex = X8t.counterRegex("scene");\n            cp.attributes = kIe();\n            cp.layoutAttributes = FX();\n            cp.baseLayoutAttrOverrides = G8t({ hoverlabel: H8t.hoverlabel }, "plot", "nested");\n            cp.supplyLayoutDefaults = qIe();\n            cp.plot = function(t3) {\n              for (var r4 = t3._fullLayout, n4 = t3._fullData, i3 = r4._subplots[GA], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = W8t(n4, GA, o4), l3 = r4[o4], u4 = l3.camera, c5 = l3._scene;\n                c5 || (c5 = new j8t({ id: o4, graphDiv: t3, container: t3.querySelector(".gl-container"), staticPlot: t3._context.staticPlot, plotGlPixelRatio: t3._context.plotGlPixelRatio, camera: u4 }, r4), l3._scene = c5), c5.viewInitial || (c5.viewInitial = { up: { x: u4.up.x, y: u4.up.y, z: u4.up.z }, eye: { x: u4.eye.x, y: u4.eye.y, z: u4.eye.z }, center: { x: u4.center.x, y: u4.center.y, z: u4.center.z } }), c5.plot(s3, r4, t3.layout);\n              }\n            };\n            cp.clean = function(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[GA] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                !t3[o4] && n4[o4]._scene && (n4[o4]._scene.destroy(), n4._infolayer && n4._infolayer.selectAll(".annotation-" + o4).remove());\n              }\n            };\n            cp.toSVG = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[GA], n4 = t3._size, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = t3[r4[i3]], o4 = a4.domain, s3 = a4._scene, l3 = s3.toImage("png"), u4 = t3._glimages.append("svg:image");\n                u4.attr({ xmlns: Z8t.svg, "xlink:href": l3, x: n4.l + n4.w * o4.x[0], y: n4.t + n4.h * (1 - o4.y[1]), width: n4.w * (o4.x[1] - o4.x[0]), height: n4.h * (o4.y[1] - o4.y[0]), preserveAspectRatio: "none" }), s3.destroy();\n              }\n            };\n            cp.cleanId = function(t3) {\n              if (t3.match(/^scene[0-9]*$/)) {\n                var r4 = t3.slice(5);\n                return r4 === "1" && (r4 = ""), zX + r4;\n              }\n            };\n            cp.updateFx = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[GA], n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]]._scene;\n                i3.updateFx(t3.dragmode, t3.hovermode);\n              }\n            };\n          });\n          var NIe = ye((ggr, BIe) => {\n            "use strict";\n            BIe.exports = { plot: YPe(), attributes: EX(), markerSymbols: QD(), supplyDefaults: rIe(), colorbar: [{ container: "marker", min: "cmin", max: "cmax" }, { container: "line", min: "cmin", max: "cmax" }], calc: nIe(), moduleType: "trace", name: "scatter3d", basePlotModule: $_(), categories: ["gl3d", "symbols", "showLegend", "scatter-like"], meta: {} };\n          });\n          var VIe = ye((mgr, UIe) => {\n            "use strict";\n            UIe.exports = NIe();\n          });\n          var JE = ye((ygr, jIe) => {\n            "use strict";\n            var GIe = ka(), Y8t = Tu(), OX = df().axisHoverFormat, { hovertemplateAttrs: K8t, templatefallbackAttrs: J8t } = Ll(), HIe = Gl(), qX = Ao().extendFlat, $8t = mc().overrideAll;\n            function BX(e3) {\n              return { valType: "boolean", dflt: false };\n            }\n            function NX(e3) {\n              return { show: { valType: "boolean", dflt: false }, start: { valType: "number", dflt: null, editType: "plot" }, end: { valType: "number", dflt: null, editType: "plot" }, size: { valType: "number", dflt: null, min: 0, editType: "plot" }, project: { x: BX("x"), y: BX("y"), z: BX("z") }, color: { valType: "color", dflt: GIe.defaultLine }, usecolormap: { valType: "boolean", dflt: false }, width: { valType: "number", min: 1, max: 16, dflt: 2 }, highlight: { valType: "boolean", dflt: true }, highlightcolor: { valType: "color", dflt: GIe.defaultLine }, highlightwidth: { valType: "number", min: 1, max: 16, dflt: 2 } };\n            }\n            var UX = jIe.exports = $8t(qX({ z: { valType: "data_array" }, x: { valType: "data_array" }, y: { valType: "data_array" }, text: { valType: "string", dflt: "", arrayOk: true }, hovertext: { valType: "string", dflt: "", arrayOk: true }, hovertemplate: K8t(), hovertemplatefallback: J8t(), xhoverformat: OX("x"), yhoverformat: OX("y"), zhoverformat: OX("z"), connectgaps: { valType: "boolean", dflt: false, editType: "calc" }, surfacecolor: { valType: "data_array" } }, Y8t("", { colorAttr: "z or surfacecolor", showScaleDflt: true, autoColorDflt: false, editTypeOverride: "calc" }), { contours: { x: NX("x"), y: NX("y"), z: NX("z") }, hidesurface: { valType: "boolean", dflt: false }, lightposition: { x: { valType: "number", min: -1e5, max: 1e5, dflt: 10 }, y: { valType: "number", min: -1e5, max: 1e5, dflt: 1e4 }, z: { valType: "number", min: -1e5, max: 1e5, dflt: 0 } }, lighting: { ambient: { valType: "number", min: 0, max: 1, dflt: 0.8 }, diffuse: { valType: "number", min: 0, max: 1, dflt: 0.8 }, specular: { valType: "number", min: 0, max: 2, dflt: 0.05, description: "Represents the level that incident rays are reflected in a single direction, causing shine." }, roughness: { valType: "number", min: 0, max: 1, dflt: 0.5, description: "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine." }, fresnel: { valType: "number", min: 0, max: 5, dflt: 0.2 } }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, opacityscale: { valType: "any", editType: "calc" }, hoverinfo: qX({}, HIe.hoverinfo), showlegend: qX({}, HIe.showlegend, { dflt: false }) }), "calc", "nested");\n            UX.x.editType = UX.y.editType = UX.z.editType = "calc+clearAxisTypes";\n          });\n          var GX = ye((_gr, ZIe) => {\n            "use strict";\n            var Q8t = qa(), WIe = Dr(), eRt = Qh(), tRt = JE(), VX = 0.1;\n            function rRt(e3, t3) {\n              for (var r4 = [], n4 = 32, i3 = 0; i3 < n4; i3++) {\n                var a4 = i3 / (n4 - 1), o4 = t3 + (1 - t3) * (1 - Math.pow(Math.sin(e3 * a4 * Math.PI), 2));\n                r4.push([a4, Math.max(0, Math.min(1, o4))]);\n              }\n              return r4;\n            }\n            function iRt(e3) {\n              var t3 = 0;\n              if (!Array.isArray(e3) || e3.length < 2 || !e3[0] || !e3[e3.length - 1] || +e3[0][0] != 0 || +e3[e3.length - 1][0] != 1) return false;\n              for (var r4 = 0; r4 < e3.length; r4++) {\n                var n4 = e3[r4];\n                if (n4.length !== 2 || +n4[0] < t3) return false;\n                t3 = +n4[0];\n              }\n              return true;\n            }\n            function nRt(e3, t3, r4, n4) {\n              var i3, a4;\n              function o4(b, p3) {\n                return WIe.coerce(e3, t3, tRt, b, p3);\n              }\n              var s3 = o4("x"), l3 = o4("y"), u4 = o4("z");\n              if (!u4 || !u4.length || s3 && s3.length < 1 || l3 && l3.length < 1) {\n                t3.visible = false;\n                return;\n              }\n              t3._xlength = Array.isArray(s3) && WIe.isArrayOrTypedArray(s3[0]) ? u4.length : u4[0].length, t3._ylength = u4.length;\n              var c5 = Q8t.getComponentMethod("calendars", "handleTraceDefaults");\n              c5(e3, t3, ["x", "y", "z"], n4), o4("text"), o4("hovertext"), o4("hovertemplate"), o4("hovertemplatefallback"), o4("xhoverformat"), o4("yhoverformat"), o4("zhoverformat"), ["lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lightposition.x", "lightposition.y", "lightposition.z", "hidesurface", "connectgaps", "opacity"].forEach(function(b) {\n                o4(b);\n              });\n              var f4 = o4("surfacecolor"), h3 = ["x", "y", "z"];\n              for (i3 = 0; i3 < 3; ++i3) {\n                var d3 = "contours." + h3[i3], v3 = o4(d3 + ".show"), _2 = o4(d3 + ".highlight");\n                if (v3 || _2) for (a4 = 0; a4 < 3; ++a4) o4(d3 + ".project." + h3[a4]);\n                v3 && (o4(d3 + ".color"), o4(d3 + ".width"), o4(d3 + ".usecolormap")), _2 && (o4(d3 + ".highlightcolor"), o4(d3 + ".highlightwidth")), o4(d3 + ".start"), o4(d3 + ".end"), o4(d3 + ".size");\n              }\n              eRt(e3, t3, n4, o4, { prefix: "", cLetter: "c" }), XIe(e3, t3, n4, o4), t3._length = null;\n            }\n            function XIe(e3, t3, r4, n4) {\n              var i3 = n4("opacityscale");\n              i3 === "max" ? t3.opacityscale = [[0, VX], [1, 1]] : i3 === "min" ? t3.opacityscale = [[0, 1], [1, VX]] : i3 === "extremes" ? t3.opacityscale = rRt(1, VX) : iRt(i3) || (t3.opacityscale = void 0);\n            }\n            ZIe.exports = { supplyDefaults: nRt, opacityscaleDefaults: XIe };\n          });\n          var JIe = ye((xgr, KIe) => {\n            "use strict";\n            var YIe = gv();\n            KIe.exports = function(t3, r4) {\n              r4.surfacecolor ? YIe(t3, r4, { vals: r4.surfacecolor, containerStr: "", cLetter: "c" }) : YIe(t3, r4, { vals: r4.z, containerStr: "", cLetter: "c" });\n            };\n          });\n          var i8e = ye((bgr, r8e) => {\n            "use strict";\n            var aRt = Od().gl_surface3d, HA = Od().ndarray, oRt = Od().ndarray_linear_interpolate.d2, sRt = o8(), lRt = s8(), $E = Dr().isArrayOrTypedArray, uRt = $y().parseColorScale, $Ie = Jy(), cRt = tc().extractOpts;\n            function e8e(e3, t3, r4) {\n              this.scene = e3, this.uid = r4, this.surface = t3, this.data = null, this.showContour = [false, false, false], this.contourStart = [null, null, null], this.contourEnd = [null, null, null], this.contourSize = [0, 0, 0], this.minValues = [1 / 0, 1 / 0, 1 / 0], this.maxValues = [-1 / 0, -1 / 0, -1 / 0], this.dataScaleX = 1, this.dataScaleY = 1, this.refineData = true, this.objectOffset = [0, 0, 0];\n            }\n            var $g = e8e.prototype;\n            $g.getXat = function(e3, t3, r4, n4) {\n              var i3 = $E(this.data.x) ? $E(this.data.x[0]) ? this.data.x[t3][e3] : this.data.x[e3] : e3;\n              return r4 === void 0 ? i3 : n4.d2l(i3, 0, r4);\n            };\n            $g.getYat = function(e3, t3, r4, n4) {\n              var i3 = $E(this.data.y) ? $E(this.data.y[0]) ? this.data.y[t3][e3] : this.data.y[t3] : t3;\n              return r4 === void 0 ? i3 : n4.d2l(i3, 0, r4);\n            };\n            $g.getZat = function(e3, t3, r4, n4) {\n              var i3 = this.data.z[t3][e3];\n              return i3 === null && this.data.connectgaps && this.data._interpolatedZ && (i3 = this.data._interpolatedZ[t3][e3]), r4 === void 0 ? i3 : n4.d2l(i3, 0, r4);\n            };\n            $g.handlePick = function(e3) {\n              if (e3.object === this.surface) {\n                var t3 = (e3.data.index[0] - 1) / this.dataScaleX - 1, r4 = (e3.data.index[1] - 1) / this.dataScaleY - 1, n4 = Math.max(Math.min(Math.round(t3), this.data.z[0].length - 1), 0), i3 = Math.max(Math.min(Math.round(r4), this.data._ylength - 1), 0);\n                e3.index = [n4, i3], e3.traceCoordinate = [this.getXat(n4, i3), this.getYat(n4, i3), this.getZat(n4, i3)], e3.dataCoordinate = [this.getXat(n4, i3, this.data.xcalendar, this.scene.fullSceneLayout.xaxis), this.getYat(n4, i3, this.data.ycalendar, this.scene.fullSceneLayout.yaxis), this.getZat(n4, i3, this.data.zcalendar, this.scene.fullSceneLayout.zaxis)];\n                for (var a4 = 0; a4 < 3; a4++) {\n                  var o4 = e3.dataCoordinate[a4];\n                  o4 != null && (e3.dataCoordinate[a4] *= this.scene.dataScale[a4]);\n                }\n                var s3 = this.data.hovertext || this.data.text;\n                return $E(s3) && s3[i3] && s3[i3][n4] !== void 0 ? e3.textLabel = s3[i3][n4] : s3 ? e3.textLabel = s3 : e3.textLabel = "", e3.data.dataCoordinate = e3.dataCoordinate.slice(), this.surface.highlight(e3.data), this.scene.glplot.spikes.position = e3.dataCoordinate, true;\n              }\n            };\n            function fRt(e3) {\n              var t3 = e3[0].rgb, r4 = e3[e3.length - 1].rgb;\n              return t3[0] === r4[0] && t3[1] === r4[1] && t3[2] === r4[2] && t3[3] === r4[3];\n            }\n            var jA = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999];\n            function hRt(e3, t3) {\n              if (e3 < t3) return 0;\n              for (var r4 = 0; Math.floor(e3 % t3) === 0; ) e3 /= t3, r4++;\n              return r4;\n            }\n            function HX(e3) {\n              for (var t3 = [], r4 = 0; r4 < jA.length; r4++) {\n                var n4 = jA[r4];\n                t3.push(hRt(e3, n4));\n              }\n              return t3;\n            }\n            function dRt(e3) {\n              for (var t3 = HX(e3), r4 = e3, n4 = 0; n4 < jA.length; n4++) if (t3[n4] > 0) {\n                r4 = jA[n4];\n                break;\n              }\n              return r4;\n            }\n            function vRt(e3, t3) {\n              if (!(e3 < 1 || t3 < 1)) {\n                for (var r4 = HX(e3), n4 = HX(t3), i3 = 1, a4 = 0; a4 < jA.length; a4++) i3 *= Math.pow(jA[a4], Math.max(r4[a4], n4[a4]));\n                return i3;\n              }\n            }\n            function pRt(e3) {\n              if (e3.length !== 0) {\n                for (var t3 = 1, r4 = 0; r4 < e3.length; r4++) t3 = vRt(t3, e3[r4]);\n                return t3;\n              }\n            }\n            $g.calcXnums = function(e3) {\n              var t3, r4 = [];\n              for (t3 = 1; t3 < e3; t3++) {\n                var n4 = this.getXat(t3 - 1, 0), i3 = this.getXat(t3, 0);\n                i3 !== n4 && n4 !== void 0 && n4 !== null && i3 !== void 0 && i3 !== null ? r4[t3 - 1] = Math.abs(i3 - n4) : r4[t3 - 1] = 0;\n              }\n              var a4 = 0;\n              for (t3 = 1; t3 < e3; t3++) a4 += r4[t3 - 1];\n              for (t3 = 1; t3 < e3; t3++) r4[t3 - 1] === 0 ? r4[t3 - 1] = 1 : r4[t3 - 1] = Math.round(a4 / r4[t3 - 1]);\n              return r4;\n            };\n            $g.calcYnums = function(e3) {\n              var t3, r4 = [];\n              for (t3 = 1; t3 < e3; t3++) {\n                var n4 = this.getYat(0, t3 - 1), i3 = this.getYat(0, t3);\n                i3 !== n4 && n4 !== void 0 && n4 !== null && i3 !== void 0 && i3 !== null ? r4[t3 - 1] = Math.abs(i3 - n4) : r4[t3 - 1] = 0;\n              }\n              var a4 = 0;\n              for (t3 = 1; t3 < e3; t3++) a4 += r4[t3 - 1];\n              for (t3 = 1; t3 < e3; t3++) r4[t3 - 1] === 0 ? r4[t3 - 1] = 1 : r4[t3 - 1] = Math.round(a4 / r4[t3 - 1]);\n              return r4;\n            };\n            var t8e = [1, 2, 4, 6, 12, 24, 36, 48, 60, 120, 180, 240, 360, 720, 840, 1260], QIe = t8e[9], aF = t8e[13];\n            $g.estimateScale = function(e3, t3) {\n              for (var r4 = t3 === 0 ? this.calcXnums(e3) : this.calcYnums(e3), n4 = 1 + pRt(r4); n4 < QIe; ) n4 *= 2;\n              for (; n4 > aF; ) n4--, n4 /= dRt(n4), n4++, n4 < QIe && (n4 = aF);\n              var i3 = Math.round(n4 / e3);\n              return i3 > 1 ? i3 : 1;\n            };\n            function gRt(e3, t3, r4) {\n              var n4 = r4[8] + r4[2] * t3[0] + r4[5] * t3[1];\n              return e3[0] = (r4[6] + r4[0] * t3[0] + r4[3] * t3[1]) / n4, e3[1] = (r4[7] + r4[1] * t3[0] + r4[4] * t3[1]) / n4, e3;\n            }\n            function mRt(e3, t3, r4) {\n              return yRt(e3, t3, gRt, r4), e3;\n            }\n            function yRt(e3, t3, r4, n4) {\n              for (var i3 = [0, 0], a4 = e3.shape[0], o4 = e3.shape[1], s3 = 0; s3 < a4; s3++) for (var l3 = 0; l3 < o4; l3++) r4(i3, [s3, l3], n4), e3.set(s3, l3, oRt(t3, i3[0], i3[1]));\n              return e3;\n            }\n            $g.refineCoords = function(e3) {\n              for (var t3 = this.dataScaleX, r4 = this.dataScaleY, n4 = e3[0].shape[0], i3 = e3[0].shape[1], a4 = Math.floor(e3[0].shape[0] * t3 + 1) | 0, o4 = Math.floor(e3[0].shape[1] * r4 + 1) | 0, s3 = 1 + n4 + 1, l3 = 1 + i3 + 1, u4 = HA(new Float32Array(s3 * l3), [s3, l3]), c5 = [1 / t3, 0, 0, 0, 1 / r4, 0, 0, 0, 1], f4 = 0; f4 < e3.length; ++f4) {\n                this.surface.padField(u4, e3[f4]);\n                var h3 = HA(new Float32Array(a4 * o4), [a4, o4]);\n                mRt(h3, u4, c5), e3[f4] = h3;\n              }\n            };\n            function _Rt(e3, t3) {\n              for (var r4 = false, n4 = 0; n4 < e3.length; n4++) if (t3 === e3[n4]) {\n                r4 = true;\n                break;\n              }\n              r4 === false && e3.push(t3);\n            }\n            $g.setContourLevels = function() {\n              var e3 = [[], [], []], t3 = [false, false, false], r4 = false, n4, i3, a4;\n              for (n4 = 0; n4 < 3; ++n4) if (this.showContour[n4] && (r4 = true, this.contourSize[n4] > 0 && this.contourStart[n4] !== null && this.contourEnd[n4] !== null && this.contourEnd[n4] > this.contourStart[n4])) for (t3[n4] = true, i3 = this.contourStart[n4]; i3 < this.contourEnd[n4]; i3 += this.contourSize[n4]) a4 = i3 * this.scene.dataScale[n4], _Rt(e3[n4], a4);\n              if (r4) {\n                var o4 = [[], [], []];\n                for (n4 = 0; n4 < 3; ++n4) this.showContour[n4] && (o4[n4] = t3[n4] ? e3[n4] : this.scene.contourLevels[n4]);\n                this.surface.update({ levels: o4 });\n              }\n            };\n            $g.update = function(e3) {\n              var t3 = this.scene, r4 = t3.fullSceneLayout, n4 = this.surface, i3 = uRt(e3), a4 = t3.dataScale, o4 = e3.z[0].length, s3 = e3._ylength, l3 = t3.contourLevels;\n              this.data = e3;\n              var u4, c5, f4, h3, d3 = [];\n              for (u4 = 0; u4 < 3; u4++) for (d3[u4] = [], c5 = 0; c5 < o4; c5++) d3[u4][c5] = [];\n              for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) d3[0][c5][f4] = this.getXat(c5, f4, e3.xcalendar, r4.xaxis), d3[1][c5][f4] = this.getYat(c5, f4, e3.ycalendar, r4.yaxis), d3[2][c5][f4] = this.getZat(c5, f4, e3.zcalendar, r4.zaxis);\n              if (e3.connectgaps) for (e3._emptypoints = lRt(d3[2]), sRt(d3[2], e3._emptypoints), e3._interpolatedZ = [], c5 = 0; c5 < o4; c5++) for (e3._interpolatedZ[c5] = [], f4 = 0; f4 < s3; f4++) e3._interpolatedZ[c5][f4] = d3[2][c5][f4];\n              for (u4 = 0; u4 < 3; u4++) for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) h3 = d3[u4][c5][f4], h3 == null ? d3[u4][c5][f4] = NaN : h3 = d3[u4][c5][f4] *= a4[u4];\n              for (u4 = 0; u4 < 3; u4++) for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) h3 = d3[u4][c5][f4], h3 != null && (this.minValues[u4] > h3 && (this.minValues[u4] = h3), this.maxValues[u4] < h3 && (this.maxValues[u4] = h3));\n              for (u4 = 0; u4 < 3; u4++) this.objectOffset[u4] = 0.5 * (this.minValues[u4] + this.maxValues[u4]);\n              for (u4 = 0; u4 < 3; u4++) for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) h3 = d3[u4][c5][f4], h3 != null && (d3[u4][c5][f4] -= this.objectOffset[u4]);\n              var v3 = [HA(new Float32Array(o4 * s3), [o4, s3]), HA(new Float32Array(o4 * s3), [o4, s3]), HA(new Float32Array(o4 * s3), [o4, s3])];\n              for (u4 = 0; u4 < 3; u4++) for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) v3[u4].set(c5, f4, d3[u4][c5][f4]);\n              d3 = [];\n              var _2 = { colormap: i3, levels: [[], [], []], showContour: [true, true, true], showSurface: !e3.hidesurface, contourProject: [[false, false, false], [false, false, false], [false, false, false]], contourWidth: [1, 1, 1], contourColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], contourTint: [1, 1, 1], dynamicColor: [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], dynamicWidth: [1, 1, 1], dynamicTint: [1, 1, 1], opacityscale: e3.opacityscale, opacity: e3.opacity }, b = cRt(e3);\n              if (_2.intensityBounds = [b.min, b.max], e3.surfacecolor) {\n                var p3 = HA(new Float32Array(o4 * s3), [o4, s3]);\n                for (c5 = 0; c5 < o4; c5++) for (f4 = 0; f4 < s3; f4++) p3.set(c5, f4, e3.surfacecolor[f4][c5]);\n                v3.push(p3);\n              } else _2.intensityBounds[0] *= a4[2], _2.intensityBounds[1] *= a4[2];\n              (aF < v3[0].shape[0] || aF < v3[0].shape[1]) && (this.refineData = false), this.refineData === true && (this.dataScaleX = this.estimateScale(v3[0].shape[0], 0), this.dataScaleY = this.estimateScale(v3[0].shape[1], 1), (this.dataScaleX !== 1 || this.dataScaleY !== 1) && this.refineCoords(v3)), e3.surfacecolor && (_2.intensity = v3.pop());\n              var k4 = [true, true, true], E3 = ["x", "y", "z"];\n              for (u4 = 0; u4 < 3; ++u4) {\n                var S2 = e3.contours[E3[u4]];\n                k4[u4] = S2.highlight, _2.showContour[u4] = S2.show || S2.highlight, _2.showContour[u4] && (_2.contourProject[u4] = [S2.project.x, S2.project.y, S2.project.z], S2.show ? (this.showContour[u4] = true, _2.levels[u4] = l3[u4], n4.highlightColor[u4] = _2.contourColor[u4] = $Ie(S2.color), S2.usecolormap ? n4.highlightTint[u4] = _2.contourTint[u4] = 0 : n4.highlightTint[u4] = _2.contourTint[u4] = 1, _2.contourWidth[u4] = S2.width, this.contourStart[u4] = S2.start, this.contourEnd[u4] = S2.end, this.contourSize[u4] = S2.size) : (this.showContour[u4] = false, this.contourStart[u4] = null, this.contourEnd[u4] = null, this.contourSize[u4] = 0), S2.highlight && (_2.dynamicColor[u4] = $Ie(S2.highlightcolor), _2.dynamicWidth[u4] = S2.highlightwidth));\n              }\n              fRt(i3) && (_2.vertexColor = true), _2.objectOffset = this.objectOffset, _2.coords = v3, n4.update(_2), n4.visible = e3.visible, n4.enableDynamic = k4, n4.enableHighlight = k4, n4.snapToData = true, "lighting" in e3 && (n4.ambientLight = e3.lighting.ambient, n4.diffuseLight = e3.lighting.diffuse, n4.specularLight = e3.lighting.specular, n4.roughness = e3.lighting.roughness, n4.fresnel = e3.lighting.fresnel), "lightposition" in e3 && (n4.lightPosition = [e3.lightposition.x, e3.lightposition.y, e3.lightposition.z]);\n            };\n            $g.dispose = function() {\n              this.scene.glplot.remove(this.surface), this.surface.dispose();\n            };\n            function xRt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = aRt({ gl: r4 }), i3 = new e8e(e3, n4, t3.uid);\n              return n4._trace = i3, i3.update(t3), e3.glplot.add(n4), i3;\n            }\n            r8e.exports = xRt;\n          });\n          var a8e = ye((wgr, n8e) => {\n            "use strict";\n            n8e.exports = { attributes: JE(), supplyDefaults: GX().supplyDefaults, colorbar: { min: "cmin", max: "cmax" }, calc: JIe(), plot: i8e(), moduleType: "trace", name: "surface", basePlotModule: $_(), categories: ["gl3d", "2dMap", "showLegend"], meta: {} };\n          });\n          var s8e = ye((Tgr, o8e) => {\n            "use strict";\n            o8e.exports = a8e();\n          });\n          var WA = ye((Agr, u8e) => {\n            "use strict";\n            var bRt = Tu(), jX = df().axisHoverFormat, { hovertemplateAttrs: wRt, templatefallbackAttrs: TRt } = Ll(), Q_ = JE(), l8e = Gl(), ex = Ao().extendFlat;\n            u8e.exports = ex({ x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, i: { valType: "data_array", editType: "calc" }, j: { valType: "data_array", editType: "calc" }, k: { valType: "data_array", editType: "calc" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: wRt({ editType: "calc" }), hovertemplatefallback: TRt({ editType: "calc" }), xhoverformat: jX("x"), yhoverformat: jX("y"), zhoverformat: jX("z"), delaunayaxis: { valType: "enumerated", values: ["x", "y", "z"], dflt: "z", editType: "calc" }, alphahull: { valType: "number", dflt: -1, editType: "calc" }, intensity: { valType: "data_array", editType: "calc" }, intensitymode: { valType: "enumerated", values: ["vertex", "cell"], dflt: "vertex", editType: "calc" }, color: { valType: "color", editType: "calc" }, vertexcolor: { valType: "data_array", editType: "calc" }, facecolor: { valType: "data_array", editType: "calc" } }, bRt("", { colorAttr: "`intensity`", showScaleDflt: true, editTypeOverride: "calc" }), { opacity: Q_.opacity, flatshading: { valType: "boolean", dflt: false, editType: "calc" }, contour: { show: ex({}, Q_.contours.x.show, {}), color: Q_.contours.x.color, width: Q_.contours.x.width, editType: "calc" }, lightposition: { x: ex({}, Q_.lightposition.x, { dflt: 1e5 }), y: ex({}, Q_.lightposition.y, { dflt: 1e5 }), z: ex({}, Q_.lightposition.z, { dflt: 0 }), editType: "calc" }, lighting: ex({ vertexnormalsepsilon: { valType: "number", min: 0, max: 1, dflt: 1e-12, editType: "calc", description: "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry." }, facenormalsepsilon: { valType: "number", min: 0, max: 1, dflt: 1e-6, editType: "calc", description: "Epsilon for face normals calculation avoids math issues arising from degenerate geometry." }, editType: "calc" }, Q_.lighting), hoverinfo: ex({}, l8e.hoverinfo, { editType: "calc" }), showlegend: ex({}, l8e.showlegend, { dflt: false }) });\n          });\n          var sF = ye((Sgr, f8e) => {\n            "use strict";\n            var ARt = Tu(), oF = df().axisHoverFormat, { hovertemplateAttrs: SRt, templatefallbackAttrs: MRt } = Ll(), QE = WA(), c8e = Gl(), WX = Ao().extendFlat, ERt = mc().overrideAll;\n            function XX(e3) {\n              return { show: { valType: "boolean", dflt: false }, locations: { valType: "data_array", dflt: [] }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } };\n            }\n            function ZX(e3) {\n              return { show: { valType: "boolean", dflt: true }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } };\n            }\n            var XA = f8e.exports = ERt(WX({ x: { valType: "data_array" }, y: { valType: "data_array" }, z: { valType: "data_array" }, value: { valType: "data_array" }, isomin: { valType: "number" }, isomax: { valType: "number" }, surface: { show: { valType: "boolean", dflt: true }, count: { valType: "integer", dflt: 2, min: 1 }, fill: { valType: "number", min: 0, max: 1, dflt: 1 }, pattern: { valType: "flaglist", flags: ["A", "B", "C", "D", "E"], extras: ["all", "odd", "even"], dflt: "all" } }, spaceframe: { show: { valType: "boolean", dflt: false }, fill: { valType: "number", min: 0, max: 1, dflt: 0.15 } }, slices: { x: XX("x"), y: XX("y"), z: XX("z") }, caps: { x: ZX("x"), y: ZX("y"), z: ZX("z") }, text: { valType: "string", dflt: "", arrayOk: true }, hovertext: { valType: "string", dflt: "", arrayOk: true }, hovertemplate: SRt(), hovertemplatefallback: MRt(), xhoverformat: oF("x"), yhoverformat: oF("y"), zhoverformat: oF("z"), valuehoverformat: oF("value", 1), showlegend: WX({}, c8e.showlegend, { dflt: false }) }, ARt("", { colorAttr: "`value`", showScaleDflt: true, editTypeOverride: "calc" }), { opacity: QE.opacity, lightposition: QE.lightposition, lighting: QE.lighting, flatshading: QE.flatshading, contour: QE.contour, hoverinfo: WX({}, c8e.hoverinfo) }), "calc", "nested");\n            XA.flatshading.dflt = true;\n            XA.lighting.facenormalsepsilon.dflt = 0;\n            XA.x.editType = XA.y.editType = XA.z.editType = XA.value.editType = "calc+clearAxisTypes";\n          });\n          var YX = ye((Mgr, d8e) => {\n            "use strict";\n            var kRt = Dr(), CRt = qa(), LRt = sF(), PRt = Qh();\n            function IRt(e3, t3, r4, n4) {\n              function i3(a4, o4) {\n                return kRt.coerce(e3, t3, LRt, a4, o4);\n              }\n              h8e(e3, t3, r4, n4, i3);\n            }\n            function h8e(e3, t3, r4, n4, i3) {\n              var a4 = i3("isomin"), o4 = i3("isomax");\n              o4 != null && a4 !== void 0 && a4 !== null && a4 > o4 && (t3.isomin = null, t3.isomax = null);\n              var s3 = i3("x"), l3 = i3("y"), u4 = i3("z"), c5 = i3("value");\n              if (!s3 || !s3.length || !l3 || !l3.length || !u4 || !u4.length || !c5 || !c5.length) {\n                t3.visible = false;\n                return;\n              }\n              var f4 = CRt.getComponentMethod("calendars", "handleTraceDefaults");\n              f4(e3, t3, ["x", "y", "z"], n4), i3("valuehoverformat"), ["x", "y", "z"].forEach(function(_2) {\n                i3(_2 + "hoverformat");\n                var b = "caps." + _2, p3 = i3(b + ".show");\n                p3 && i3(b + ".fill");\n                var k4 = "slices." + _2, E3 = i3(k4 + ".show");\n                E3 && (i3(k4 + ".fill"), i3(k4 + ".locations"));\n              });\n              var h3 = i3("spaceframe.show");\n              h3 && i3("spaceframe.fill");\n              var d3 = i3("surface.show");\n              d3 && (i3("surface.count"), i3("surface.fill"), i3("surface.pattern"));\n              var v3 = i3("contour.show");\n              v3 && (i3("contour.color"), i3("contour.width")), ["text", "hovertext", "hovertemplate", "lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lighting.vertexnormalsepsilon", "lighting.facenormalsepsilon", "lightposition.x", "lightposition.y", "lightposition.z", "flatshading", "opacity"].forEach(function(_2) {\n                i3(_2);\n              }), PRt(e3, t3, n4, i3, { prefix: "", cLetter: "c" }), t3._length = null;\n            }\n            d8e.exports = { supplyDefaults: IRt, supplyIsoDefaults: h8e };\n          });\n          var lF = ye((Egr, p8e) => {\n            "use strict";\n            var JX = Dr(), RRt = gv();\n            function DRt(e3, t3) {\n              t3._len = Math.min(t3.u.length, t3.v.length, t3.w.length, t3.x.length, t3.y.length, t3.z.length), t3._u = jm(t3.u, t3._len), t3._v = jm(t3.v, t3._len), t3._w = jm(t3.w, t3._len), t3._x = jm(t3.x, t3._len), t3._y = jm(t3.y, t3._len), t3._z = jm(t3.z, t3._len);\n              var r4 = v8e(t3);\n              t3._gridFill = r4.fill, t3._Xs = r4.Xs, t3._Ys = r4.Ys, t3._Zs = r4.Zs, t3._len = r4.len;\n              var n4 = 0, i3, a4, o4;\n              t3.starts && (i3 = jm(t3.starts.x || []), a4 = jm(t3.starts.y || []), o4 = jm(t3.starts.z || []), n4 = Math.min(i3.length, a4.length, o4.length)), t3._startsX = i3 || [], t3._startsY = a4 || [], t3._startsZ = o4 || [];\n              var s3 = 0, l3 = 1 / 0, u4;\n              for (u4 = 0; u4 < t3._len; u4++) {\n                var c5 = t3._u[u4], f4 = t3._v[u4], h3 = t3._w[u4], d3 = Math.sqrt(c5 * c5 + f4 * f4 + h3 * h3);\n                s3 = Math.max(s3, d3), l3 = Math.min(l3, d3);\n              }\n              for (RRt(e3, t3, { vals: [l3, s3], containerStr: "", cLetter: "c" }), u4 = 0; u4 < n4; u4++) {\n                var v3 = i3[u4];\n                r4.xMax = Math.max(r4.xMax, v3), r4.xMin = Math.min(r4.xMin, v3);\n                var _2 = a4[u4];\n                r4.yMax = Math.max(r4.yMax, _2), r4.yMin = Math.min(r4.yMin, _2);\n                var b = o4[u4];\n                r4.zMax = Math.max(r4.zMax, b), r4.zMin = Math.min(r4.zMin, b);\n              }\n              t3._slen = n4, t3._normMax = s3, t3._xbnds = [r4.xMin, r4.xMax], t3._ybnds = [r4.yMin, r4.yMax], t3._zbnds = [r4.zMin, r4.zMax];\n            }\n            function v8e(e3) {\n              var t3 = e3._x, r4 = e3._y, n4 = e3._z, i3 = e3._len, a4, o4, s3, l3 = -1 / 0, u4 = 1 / 0, c5 = -1 / 0, f4 = 1 / 0, h3 = -1 / 0, d3 = 1 / 0, v3 = "", _2, b, p3, k4, E3, S2, L3, x2, C3;\n              for (i3 && (k4 = t3[0], S2 = r4[0], x2 = n4[0]), i3 > 1 && (E3 = t3[i3 - 1], L3 = r4[i3 - 1], C3 = n4[i3 - 1]), a4 = 0; a4 < i3; a4++) l3 = Math.max(l3, t3[a4]), u4 = Math.min(u4, t3[a4]), c5 = Math.max(c5, r4[a4]), f4 = Math.min(f4, r4[a4]), h3 = Math.max(h3, n4[a4]), d3 = Math.min(d3, n4[a4]), !_2 && t3[a4] !== k4 && (_2 = true, v3 += "x"), !b && r4[a4] !== S2 && (b = true, v3 += "y"), !p3 && n4[a4] !== x2 && (p3 = true, v3 += "z");\n              _2 || (v3 += "x"), b || (v3 += "y"), p3 || (v3 += "z");\n              var M4 = KX(e3._x), g3 = KX(e3._y), P3 = KX(e3._z);\n              v3 = v3.replace("x", (k4 > E3 ? "-" : "+") + "x"), v3 = v3.replace("y", (S2 > L3 ? "-" : "+") + "y"), v3 = v3.replace("z", (x2 > C3 ? "-" : "+") + "z");\n              var T3 = function() {\n                i3 = 0, M4 = [], g3 = [], P3 = [];\n              };\n              (!i3 || i3 < M4.length * g3.length * P3.length) && T3();\n              var z3 = function(Fe) {\n                return Fe === "x" ? t3 : Fe === "y" ? r4 : n4;\n              }, O3 = function(Fe) {\n                return Fe === "x" ? M4 : Fe === "y" ? g3 : P3;\n              }, V2 = function(Fe) {\n                return Fe[i3 - 1] < Fe[0] ? -1 : 1;\n              }, G2 = z3(v3[1]), Z = z3(v3[3]), j3 = z3(v3[5]), N2 = O3(v3[1]).length, H = O3(v3[3]).length, te = O3(v3[5]).length, oe = false, _e = function(Fe, Pe, ge) {\n                return N2 * (H * Fe + Pe) + ge;\n              }, Ee = V2(z3(v3[1])), Ce = V2(z3(v3[3])), me = V2(z3(v3[5]));\n              for (a4 = 0; a4 < te - 1; a4++) {\n                for (o4 = 0; o4 < H - 1; o4++) {\n                  for (s3 = 0; s3 < N2 - 1; s3++) {\n                    var ie = _e(a4, o4, s3), Se = _e(a4, o4, s3 + 1), Le = _e(a4, o4 + 1, s3), Ae = _e(a4 + 1, o4, s3);\n                    if ((!(G2[ie] * Ee < G2[Se] * Ee) || !(Z[ie] * Ce < Z[Le] * Ce) || !(j3[ie] * me < j3[Ae] * me)) && (oe = true), oe) break;\n                  }\n                  if (oe) break;\n                }\n                if (oe) break;\n              }\n              return oe && (JX.warn("Encountered arbitrary coordinates! Unable to input data grid."), T3()), { xMin: u4, yMin: f4, zMin: d3, xMax: l3, yMax: c5, zMax: h3, Xs: M4, Ys: g3, Zs: P3, len: i3, fill: v3 };\n            }\n            function KX(e3) {\n              return JX.distinctVals(e3).vals;\n            }\n            function jm(e3, t3) {\n              if (t3 === void 0 && (t3 = e3.length), JX.isTypedArray(e3)) return e3.subarray(0, t3);\n              for (var r4 = [], n4 = 0; n4 < t3; n4++) r4[n4] = +e3[n4];\n              return r4;\n            }\n            p8e.exports = { calc: DRt, filter: jm, processGrid: v8e };\n          });\n          var $X = ye((kgr, g8e) => {\n            "use strict";\n            var FRt = gv(), zRt = lF().processGrid, uF = lF().filter;\n            g8e.exports = function(t3, r4) {\n              r4._len = Math.min(r4.x.length, r4.y.length, r4.z.length, r4.value.length), r4._x = uF(r4.x, r4._len), r4._y = uF(r4.y, r4._len), r4._z = uF(r4.z, r4._len), r4._value = uF(r4.value, r4._len);\n              var n4 = zRt(r4);\n              r4._gridFill = n4.fill, r4._Xs = n4.Xs, r4._Ys = n4.Ys, r4._Zs = n4.Zs, r4._len = n4.len;\n              for (var i3 = 1 / 0, a4 = -1 / 0, o4 = 0; o4 < r4._len; o4++) {\n                var s3 = r4._value[o4];\n                i3 = Math.min(i3, s3), a4 = Math.max(a4, s3);\n              }\n              r4._minValues = i3, r4._maxValues = a4, r4._vMin = r4.isomin === void 0 || r4.isomin === null ? i3 : r4.isomin, r4._vMax = r4.isomax === void 0 || r4.isomax === null ? a4 : r4.isomax, FRt(t3, r4, { vals: [r4._vMin, r4._vMax], containerStr: "", cLetter: "c" });\n            };\n          });\n          var ZA = ye((Cgr, m8e) => {\n            "use strict";\n            m8e.exports = function(t3, r4, n4, i3) {\n              i3 = i3 || t3.length;\n              for (var a4 = new Array(i3), o4 = 0; o4 < i3; o4++) a4[o4] = [t3[o4], r4[o4], n4[o4]];\n              return a4;\n            };\n          });\n          var cF = ye((Lgr, b8e) => {\n            "use strict";\n            var ORt = Od().gl_mesh3d, qRt = $y().parseColorScale, BRt = Dr().isArrayOrTypedArray, NRt = Jy(), URt = tc().extractOpts, y8e = ZA(), ek = function(e3, t3) {\n              for (var r4 = t3.length - 1; r4 > 0; r4--) {\n                var n4 = Math.min(t3[r4], t3[r4 - 1]), i3 = Math.max(t3[r4], t3[r4 - 1]);\n                if (i3 > n4 && n4 < e3 && e3 <= i3) return { id: r4, distRatio: (i3 - e3) / (i3 - n4) };\n              }\n              return { id: 0, distRatio: 0 };\n            };\n            function _8e(e3, t3, r4) {\n              this.scene = e3, this.uid = r4, this.mesh = t3, this.name = "", this.data = null, this.showContour = false;\n            }\n            var QX = _8e.prototype;\n            QX.handlePick = function(e3) {\n              if (e3.object === this.mesh) {\n                var t3 = e3.data.index, r4 = this.data._meshX[t3], n4 = this.data._meshY[t3], i3 = this.data._meshZ[t3], a4 = this.data._Ys.length, o4 = this.data._Zs.length, s3 = ek(r4, this.data._Xs).id, l3 = ek(n4, this.data._Ys).id, u4 = ek(i3, this.data._Zs).id, c5 = e3.index = u4 + o4 * l3 + o4 * a4 * s3;\n                e3.traceCoordinate = [this.data._meshX[c5], this.data._meshY[c5], this.data._meshZ[c5], this.data._value[c5]];\n                var f4 = this.data.hovertext || this.data.text;\n                return BRt(f4) && f4[c5] !== void 0 ? e3.textLabel = f4[c5] : f4 && (e3.textLabel = f4), true;\n              }\n            };\n            QX.update = function(e3) {\n              var t3 = this.scene, r4 = t3.fullSceneLayout;\n              this.data = x8e(e3);\n              function n4(l3, u4, c5, f4) {\n                return u4.map(function(h3) {\n                  return l3.d2l(h3, 0, f4) * c5;\n                });\n              }\n              var i3 = y8e(n4(r4.xaxis, e3._meshX, t3.dataScale[0], e3.xcalendar), n4(r4.yaxis, e3._meshY, t3.dataScale[1], e3.ycalendar), n4(r4.zaxis, e3._meshZ, t3.dataScale[2], e3.zcalendar)), a4 = y8e(e3._meshI, e3._meshJ, e3._meshK), o4 = { positions: i3, cells: a4, lightPosition: [e3.lightposition.x, e3.lightposition.y, e3.lightposition.z], ambient: e3.lighting.ambient, diffuse: e3.lighting.diffuse, specular: e3.lighting.specular, roughness: e3.lighting.roughness, fresnel: e3.lighting.fresnel, vertexNormalsEpsilon: e3.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e3.lighting.facenormalsepsilon, opacity: e3.opacity, contourEnable: e3.contour.show, contourColor: NRt(e3.contour.color).slice(0, 3), contourWidth: e3.contour.width, useFacetNormals: e3.flatshading }, s3 = URt(e3);\n              o4.vertexIntensity = e3._meshIntensity, o4.vertexIntensityBounds = [s3.min, s3.max], o4.colormap = qRt(e3), this.mesh.update(o4);\n            };\n            QX.dispose = function() {\n              this.scene.glplot.remove(this.mesh), this.mesh.dispose();\n            };\n            var VRt = ["xyz", "xzy", "yxz", "yzx", "zxy", "zyx"];\n            function x8e(e3) {\n              e3._meshI = [], e3._meshJ = [], e3._meshK = [];\n              var t3 = e3.surface.show, r4 = e3.spaceframe.show, n4 = e3.surface.fill, i3 = e3.spaceframe.fill, a4 = false, o4 = false, s3 = 0, l3, u4, c5 = e3._Xs, f4 = e3._Ys, h3 = e3._Zs, d3 = c5.length, v3 = f4.length, _2 = h3.length, b = VRt.indexOf(e3._gridFill.replace(/-/g, "").replace(/\\+/g, "")), p3 = function(Qt, Vt, _t) {\n                switch (b) {\n                  case 5:\n                    return _t + _2 * Vt + _2 * v3 * Qt;\n                  case 4:\n                    return _t + _2 * Qt + _2 * d3 * Vt;\n                  case 3:\n                    return Vt + v3 * _t + v3 * _2 * Qt;\n                  case 2:\n                    return Vt + v3 * Qt + v3 * d3 * _t;\n                  case 1:\n                    return Qt + d3 * _t + d3 * _2 * Vt;\n                  default:\n                    return Qt + d3 * Vt + d3 * v3 * _t;\n                }\n              }, k4 = e3._minValues, E3 = e3._maxValues, S2 = e3._vMin, L3 = e3._vMax, x2, C3, M4, g3;\n              function P3(Qt, Vt, _t) {\n                for (var It = g3.length, mt = u4; mt < It; mt++) if (Qt === x2[mt] && Vt === C3[mt] && _t === M4[mt]) return mt;\n                return -1;\n              }\n              function T3() {\n                u4 = l3;\n              }\n              function z3() {\n                x2 = [], C3 = [], M4 = [], g3 = [], l3 = 0, T3();\n              }\n              function O3(Qt, Vt, _t, It) {\n                return x2.push(Qt), C3.push(Vt), M4.push(_t), g3.push(It), l3++, l3 - 1;\n              }\n              function V2(Qt, Vt, _t) {\n                return e3._meshI.push(Qt), e3._meshJ.push(Vt), e3._meshK.push(_t), s3++, s3 - 1;\n              }\n              function G2(Qt, Vt, _t) {\n                for (var It = [], mt = 0; mt < Qt.length; mt++) It[mt] = (Qt[mt] + Vt[mt] + _t[mt]) / 3;\n                return It;\n              }\n              function Z(Qt, Vt, _t) {\n                for (var It = [], mt = 0; mt < Qt.length; mt++) It[mt] = Qt[mt] * (1 - _t) + _t * Vt[mt];\n                return It;\n              }\n              var j3;\n              function N2(Qt) {\n                j3 = Qt;\n              }\n              function H(Qt, Vt) {\n                var _t = Qt[0], It = Qt[1], mt = Qt[2], er = G2(_t, It, mt), lr = Math.sqrt(1 - j3), Tr = Z(er, _t, lr), Lr = Z(er, It, lr), ti = Z(er, mt, lr), Br = Vt[0], Vr = Vt[1], dt = Vt[2];\n                return { xyzv: [[_t, It, Lr], [Lr, Tr, _t], [It, mt, ti], [ti, Lr, It], [mt, _t, Tr], [Tr, ti, mt]], abc: [[Br, Vr, -1], [-1, -1, Br], [Vr, dt, -1], [-1, -1, Vr], [dt, Br, -1], [-1, -1, dt]] };\n              }\n              function te(Qt, Vt) {\n                return Qt === "all" || Qt === null ? true : Qt.indexOf(Vt) > -1;\n              }\n              function oe(Qt, Vt) {\n                return Qt === null ? Vt : Qt;\n              }\n              function _e(Qt, Vt, _t) {\n                T3();\n                var It = [Vt], mt = [_t];\n                if (j3 >= 1) It = [Vt], mt = [_t];\n                else if (j3 > 0) {\n                  var er = H(Vt, _t);\n                  It = er.xyzv, mt = er.abc;\n                }\n                for (var lr = 0; lr < It.length; lr++) {\n                  Vt = It[lr], _t = mt[lr];\n                  for (var Tr = [], Lr = 0; Lr < 3; Lr++) {\n                    var ti = Vt[Lr][0], Br = Vt[Lr][1], Vr = Vt[Lr][2], dt = Vt[Lr][3], Ge = _t[Lr] > -1 ? _t[Lr] : P3(ti, Br, Vr);\n                    Ge > -1 ? Tr[Lr] = Ge : Tr[Lr] = O3(ti, Br, Vr, oe(Qt, dt));\n                  }\n                  V2(Tr[0], Tr[1], Tr[2]);\n                }\n              }\n              function Ee(Qt, Vt, _t) {\n                var It = function(mt, er, lr) {\n                  _e(Qt, [Vt[mt], Vt[er], Vt[lr]], [_t[mt], _t[er], _t[lr]]);\n                };\n                It(0, 1, 2), It(2, 3, 0);\n              }\n              function Ce(Qt, Vt, _t) {\n                var It = function(mt, er, lr) {\n                  _e(Qt, [Vt[mt], Vt[er], Vt[lr]], [_t[mt], _t[er], _t[lr]]);\n                };\n                It(0, 1, 2), It(3, 0, 1), It(2, 3, 0), It(1, 2, 3);\n              }\n              function me(Qt, Vt, _t, It) {\n                var mt = Qt[3];\n                mt < _t && (mt = _t), mt > It && (mt = It);\n                for (var er = (Qt[3] - mt) / (Qt[3] - Vt[3] + 1e-9), lr = [], Tr = 0; Tr < 4; Tr++) lr[Tr] = (1 - er) * Qt[Tr] + er * Vt[Tr];\n                return lr;\n              }\n              function ie(Qt, Vt, _t) {\n                return Qt >= Vt && Qt <= _t;\n              }\n              function Se(Qt) {\n                var Vt = 1e-3 * (L3 - S2);\n                return Qt >= S2 - Vt && Qt <= L3 + Vt;\n              }\n              function Le(Qt) {\n                for (var Vt = [], _t = 0; _t < 4; _t++) {\n                  var It = Qt[_t];\n                  Vt.push([e3._x[It], e3._y[It], e3._z[It], e3._value[It]]);\n                }\n                return Vt;\n              }\n              var Ae = 3;\n              function Fe(Qt, Vt, _t, It, mt, er) {\n                er || (er = 1), _t = [-1, -1, -1];\n                var lr = false, Tr = [ie(Vt[0][3], It, mt), ie(Vt[1][3], It, mt), ie(Vt[2][3], It, mt)];\n                if (!Tr[0] && !Tr[1] && !Tr[2]) return false;\n                var Lr = function(Br, Vr, dt) {\n                  return Se(Vr[0][3]) && Se(Vr[1][3]) && Se(Vr[2][3]) ? (_e(Br, Vr, dt), true) : er < Ae ? Fe(Br, Vr, dt, S2, L3, ++er) : false;\n                };\n                if (Tr[0] && Tr[1] && Tr[2]) return Lr(Qt, Vt, _t) || lr;\n                var ti = false;\n                return [[0, 1, 2], [2, 0, 1], [1, 2, 0]].forEach(function(Br) {\n                  if (Tr[Br[0]] && Tr[Br[1]] && !Tr[Br[2]]) {\n                    var Vr = Vt[Br[0]], dt = Vt[Br[1]], Ge = Vt[Br[2]], Je = me(Ge, Vr, It, mt), je = me(Ge, dt, It, mt);\n                    lr = Lr(Qt, [je, Je, Vr], [-1, -1, _t[Br[0]]]) || lr, lr = Lr(Qt, [Vr, dt, je], [_t[Br[0]], _t[Br[1]], -1]) || lr, ti = true;\n                  }\n                }), ti || [[0, 1, 2], [1, 2, 0], [2, 0, 1]].forEach(function(Br) {\n                  if (Tr[Br[0]] && !Tr[Br[1]] && !Tr[Br[2]]) {\n                    var Vr = Vt[Br[0]], dt = Vt[Br[1]], Ge = Vt[Br[2]], Je = me(dt, Vr, It, mt), je = me(Ge, Vr, It, mt);\n                    lr = Lr(Qt, [je, Je, Vr], [-1, -1, _t[Br[0]]]) || lr, ti = true;\n                  }\n                }), lr;\n              }\n              function Pe(Qt, Vt, _t, It) {\n                var mt = false, er = Le(Vt), lr = [ie(er[0][3], _t, It), ie(er[1][3], _t, It), ie(er[2][3], _t, It), ie(er[3][3], _t, It)];\n                if (!lr[0] && !lr[1] && !lr[2] && !lr[3]) return mt;\n                if (lr[0] && lr[1] && lr[2] && lr[3]) return o4 && (mt = Ce(Qt, er, Vt) || mt), mt;\n                var Tr = false;\n                return [[0, 1, 2, 3], [3, 0, 1, 2], [2, 3, 0, 1], [1, 2, 3, 0]].forEach(function(Lr) {\n                  if (lr[Lr[0]] && lr[Lr[1]] && lr[Lr[2]] && !lr[Lr[3]]) {\n                    var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]];\n                    if (o4) mt = _e(Qt, [ti, Br, Vr], [Vt[Lr[0]], Vt[Lr[1]], Vt[Lr[2]]]) || mt;\n                    else {\n                      var Ge = me(dt, ti, _t, It), Je = me(dt, Br, _t, It), je = me(dt, Vr, _t, It);\n                      mt = _e(null, [Ge, Je, je], [-1, -1, -1]) || mt;\n                    }\n                    Tr = true;\n                  }\n                }), Tr || ([[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 0, 1, 2], [0, 2, 3, 1], [1, 3, 2, 0]].forEach(function(Lr) {\n                  if (lr[Lr[0]] && lr[Lr[1]] && !lr[Lr[2]] && !lr[Lr[3]]) {\n                    var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]], Ge = me(Vr, ti, _t, It), Je = me(Vr, Br, _t, It), je = me(dt, Br, _t, It), tt = me(dt, ti, _t, It);\n                    o4 ? (mt = _e(Qt, [ti, tt, Ge], [Vt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [Br, Je, je], [Vt[Lr[1]], -1, -1]) || mt) : mt = Ee(null, [Ge, Je, je, tt], [-1, -1, -1, -1]) || mt, Tr = true;\n                  }\n                }), Tr) || [[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 0, 1, 2]].forEach(function(Lr) {\n                  if (lr[Lr[0]] && !lr[Lr[1]] && !lr[Lr[2]] && !lr[Lr[3]]) {\n                    var ti = er[Lr[0]], Br = er[Lr[1]], Vr = er[Lr[2]], dt = er[Lr[3]], Ge = me(Br, ti, _t, It), Je = me(Vr, ti, _t, It), je = me(dt, ti, _t, It);\n                    o4 ? (mt = _e(Qt, [ti, Ge, Je], [Vt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [ti, Je, je], [Vt[Lr[0]], -1, -1]) || mt, mt = _e(Qt, [ti, je, Ge], [Vt[Lr[0]], -1, -1]) || mt) : mt = _e(null, [Ge, Je, je], [-1, -1, -1]) || mt, Tr = true;\n                  }\n                }), mt;\n              }\n              function ge(Qt, Vt, _t, It, mt, er, lr, Tr, Lr, ti, Br) {\n                var Vr = false;\n                return a4 && (te(Qt, "A") && (Vr = Pe(null, [Vt, _t, It, er], ti, Br) || Vr), te(Qt, "B") && (Vr = Pe(null, [_t, It, mt, Lr], ti, Br) || Vr), te(Qt, "C") && (Vr = Pe(null, [_t, er, lr, Lr], ti, Br) || Vr), te(Qt, "D") && (Vr = Pe(null, [It, er, Tr, Lr], ti, Br) || Vr), te(Qt, "E") && (Vr = Pe(null, [_t, It, er, Lr], ti, Br) || Vr)), o4 && (Vr = Pe(Qt, [_t, It, er, Lr], ti, Br) || Vr), Vr;\n              }\n              function Re(Qt, Vt, _t, It, mt, er, lr, Tr) {\n                return [Tr[0] === true ? true : Fe(Qt, Le([Vt, _t, It]), [Vt, _t, It], er, lr), Tr[1] === true ? true : Fe(Qt, Le([It, mt, Vt]), [It, mt, Vt], er, lr)];\n              }\n              function ce(Qt, Vt, _t, It, mt, er, lr, Tr, Lr) {\n                return Tr ? Re(Qt, Vt, _t, mt, It, er, lr, Lr) : Re(Qt, _t, mt, It, Vt, er, lr, Lr);\n              }\n              function Ze(Qt, Vt, _t, It, mt, er, lr) {\n                var Tr = false, Lr, ti, Br, Vr, dt = function() {\n                  Tr = Fe(Qt, [Lr, ti, Br], [-1, -1, -1], mt, er) || Tr, Tr = Fe(Qt, [Br, Vr, Lr], [-1, -1, -1], mt, er) || Tr;\n                }, Ge = lr[0], Je = lr[1], je = lr[2];\n                return Ge && (Lr = Z(Le([p3(Vt, _t - 0, It - 0)])[0], Le([p3(Vt - 1, _t - 0, It - 0)])[0], Ge), ti = Z(Le([p3(Vt, _t - 0, It - 1)])[0], Le([p3(Vt - 1, _t - 0, It - 1)])[0], Ge), Br = Z(Le([p3(Vt, _t - 1, It - 1)])[0], Le([p3(Vt - 1, _t - 1, It - 1)])[0], Ge), Vr = Z(Le([p3(Vt, _t - 1, It - 0)])[0], Le([p3(Vt - 1, _t - 1, It - 0)])[0], Ge), dt()), Je && (Lr = Z(Le([p3(Vt - 0, _t, It - 0)])[0], Le([p3(Vt - 0, _t - 1, It - 0)])[0], Je), ti = Z(Le([p3(Vt - 0, _t, It - 1)])[0], Le([p3(Vt - 0, _t - 1, It - 1)])[0], Je), Br = Z(Le([p3(Vt - 1, _t, It - 1)])[0], Le([p3(Vt - 1, _t - 1, It - 1)])[0], Je), Vr = Z(Le([p3(Vt - 1, _t, It - 0)])[0], Le([p3(Vt - 1, _t - 1, It - 0)])[0], Je), dt()), je && (Lr = Z(Le([p3(Vt - 0, _t - 0, It)])[0], Le([p3(Vt - 0, _t - 0, It - 1)])[0], je), ti = Z(Le([p3(Vt - 0, _t - 1, It)])[0], Le([p3(Vt - 0, _t - 1, It - 1)])[0], je), Br = Z(Le([p3(Vt - 1, _t - 1, It)])[0], Le([p3(Vt - 1, _t - 1, It - 1)])[0], je), Vr = Z(Le([p3(Vt - 1, _t - 0, It)])[0], Le([p3(Vt - 1, _t - 0, It - 1)])[0], je), dt()), Tr;\n              }\n              function ut(Qt, Vt, _t, It, mt, er, lr, Tr, Lr, ti, Br, Vr) {\n                var dt = Qt;\n                return Vr ? (a4 && Qt === "even" && (dt = null), ge(dt, Vt, _t, It, mt, er, lr, Tr, Lr, ti, Br)) : (a4 && Qt === "odd" && (dt = null), ge(dt, Lr, Tr, lr, er, mt, It, _t, Vt, ti, Br));\n              }\n              function pt(Qt, Vt, _t, It, mt) {\n                for (var er = [], lr = 0, Tr = 0; Tr < Vt.length; Tr++) for (var Lr = Vt[Tr], ti = 1; ti < _2; ti++) for (var Br = 1; Br < v3; Br++) er.push(ce(Qt, p3(Lr, Br - 1, ti - 1), p3(Lr, Br - 1, ti), p3(Lr, Br, ti - 1), p3(Lr, Br, ti), _t, It, (Lr + Br + ti) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;\n                return er;\n              }\n              function Zt(Qt, Vt, _t, It, mt) {\n                for (var er = [], lr = 0, Tr = 0; Tr < Vt.length; Tr++) for (var Lr = Vt[Tr], ti = 1; ti < d3; ti++) for (var Br = 1; Br < _2; Br++) er.push(ce(Qt, p3(ti - 1, Lr, Br - 1), p3(ti, Lr, Br - 1), p3(ti - 1, Lr, Br), p3(ti, Lr, Br), _t, It, (ti + Lr + Br) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;\n                return er;\n              }\n              function st(Qt, Vt, _t, It, mt) {\n                for (var er = [], lr = 0, Tr = 0; Tr < Vt.length; Tr++) for (var Lr = Vt[Tr], ti = 1; ti < v3; ti++) for (var Br = 1; Br < d3; Br++) er.push(ce(Qt, p3(Br - 1, ti - 1, Lr), p3(Br - 1, ti, Lr), p3(Br, ti - 1, Lr), p3(Br, ti, Lr), _t, It, (Br + ti + Lr) % 2, mt && mt[lr] ? mt[lr] : [])), lr++;\n                return er;\n              }\n              function lt(Qt, Vt, _t) {\n                for (var It = 1; It < _2; It++) for (var mt = 1; mt < v3; mt++) for (var er = 1; er < d3; er++) ut(Qt, p3(er - 1, mt - 1, It - 1), p3(er - 1, mt - 1, It), p3(er - 1, mt, It - 1), p3(er - 1, mt, It), p3(er, mt - 1, It - 1), p3(er, mt - 1, It), p3(er, mt, It - 1), p3(er, mt, It), Vt, _t, (er + mt + It) % 2);\n              }\n              function Gt(Qt, Vt, _t) {\n                o4 = true, lt(Qt, Vt, _t), o4 = false;\n              }\n              function Nt(Qt, Vt, _t) {\n                a4 = true, lt(Qt, Vt, _t), a4 = false;\n              }\n              function Jt(Qt, Vt, _t, It, mt, er) {\n                for (var lr = [], Tr = 0, Lr = 0; Lr < Vt.length; Lr++) for (var ti = Vt[Lr], Br = 1; Br < _2; Br++) for (var Vr = 1; Vr < v3; Vr++) lr.push(Ze(Qt, ti, Vr, Br, _t, It, mt[Lr], er && er[Tr] ? er[Tr] : [])), Tr++;\n                return lr;\n              }\n              function sr(Qt, Vt, _t, It, mt, er) {\n                for (var lr = [], Tr = 0, Lr = 0; Lr < Vt.length; Lr++) for (var ti = Vt[Lr], Br = 1; Br < d3; Br++) for (var Vr = 1; Vr < _2; Vr++) lr.push(Ze(Qt, Br, ti, Vr, _t, It, mt[Lr], er && er[Tr] ? er[Tr] : [])), Tr++;\n                return lr;\n              }\n              function wr(Qt, Vt, _t, It, mt, er) {\n                for (var lr = [], Tr = 0, Lr = 0; Lr < Vt.length; Lr++) for (var ti = Vt[Lr], Br = 1; Br < v3; Br++) for (var Vr = 1; Vr < d3; Vr++) lr.push(Ze(Qt, Vr, Br, ti, _t, It, mt[Lr], er && er[Tr] ? er[Tr] : [])), Tr++;\n                return lr;\n              }\n              function cr(Qt, Vt) {\n                for (var _t = [], It = Qt; It < Vt; It++) _t.push(It);\n                return _t;\n              }\n              function $e() {\n                for (var Qt = 0; Qt < d3; Qt++) for (var Vt = 0; Vt < v3; Vt++) for (var _t = 0; _t < _2; _t++) {\n                  var It = p3(Qt, Vt, _t);\n                  O3(e3._x[It], e3._y[It], e3._z[It], e3._value[It]);\n                }\n              }\n              function St() {\n                z3(), $e();\n                var Qt = null;\n                if (r4 && i3 && (N2(i3), Gt(Qt, S2, L3)), t3 && n4) {\n                  N2(n4);\n                  for (var Vt = e3.surface.pattern, _t = e3.surface.count, It = 0; It < _t; It++) {\n                    var mt = _t === 1 ? 0.5 : It / (_t - 1), er = (1 - mt) * S2 + mt * L3, lr = Math.abs(er - k4), Tr = Math.abs(er - E3), Lr = lr > Tr ? [k4, er] : [er, E3];\n                    Nt(Vt, Lr[0], Lr[1]);\n                  }\n                }\n                var ti = [[Math.min(S2, E3), Math.max(S2, E3)], [Math.min(k4, L3), Math.max(k4, L3)]];\n                ["x", "y", "z"].forEach(function(Br) {\n                  for (var Vr = [], dt = 0; dt < ti.length; dt++) {\n                    var Ge = 0, Je = ti[dt][0], je = ti[dt][1], tt = e3.slices[Br];\n                    if (tt.show && tt.fill) {\n                      N2(tt.fill);\n                      var xt = [], Ie = [], xe = [];\n                      if (tt.locations.length) for (var ke = 0; ke < tt.locations.length; ke++) {\n                        var vt = ek(tt.locations[ke], Br === "x" ? c5 : Br === "y" ? f4 : h3);\n                        vt.distRatio === 0 ? xt.push(vt.id) : vt.id > 0 && (Ie.push(vt.id), Br === "x" ? xe.push([vt.distRatio, 0, 0]) : Br === "y" ? xe.push([0, vt.distRatio, 0]) : xe.push([0, 0, vt.distRatio]));\n                      }\n                      else Br === "x" ? xt = cr(1, d3 - 1) : Br === "y" ? xt = cr(1, v3 - 1) : xt = cr(1, _2 - 1);\n                      Ie.length > 0 && (Br === "x" ? Vr[Ge] = Jt(Qt, Ie, Je, je, xe, Vr[Ge]) : Br === "y" ? Vr[Ge] = sr(Qt, Ie, Je, je, xe, Vr[Ge]) : Vr[Ge] = wr(Qt, Ie, Je, je, xe, Vr[Ge]), Ge++), xt.length > 0 && (Br === "x" ? Vr[Ge] = pt(Qt, xt, Je, je, Vr[Ge]) : Br === "y" ? Vr[Ge] = Zt(Qt, xt, Je, je, Vr[Ge]) : Vr[Ge] = st(Qt, xt, Je, je, Vr[Ge]), Ge++);\n                    }\n                    var ir = e3.caps[Br];\n                    ir.show && ir.fill && (N2(ir.fill), Br === "x" ? Vr[Ge] = pt(Qt, [0, d3 - 1], Je, je, Vr[Ge]) : Br === "y" ? Vr[Ge] = Zt(Qt, [0, v3 - 1], Je, je, Vr[Ge]) : Vr[Ge] = st(Qt, [0, _2 - 1], Je, je, Vr[Ge]), Ge++);\n                  }\n                }), s3 === 0 && z3(), e3._meshX = x2, e3._meshY = C3, e3._meshZ = M4, e3._meshIntensity = g3, e3._Xs = c5, e3._Ys = f4, e3._Zs = h3;\n              }\n              return St(), e3;\n            }\n            function GRt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = ORt({ gl: r4 }), i3 = new _8e(e3, n4, t3.uid);\n              return n4._trace = i3, i3.update(t3), e3.glplot.add(n4), i3;\n            }\n            b8e.exports = { findNearestOnAxis: ek, generateIsoMeshes: x8e, createIsosurfaceTrace: GRt };\n          });\n          var T8e = ye((Pgr, w8e) => {\n            "use strict";\n            w8e.exports = { attributes: sF(), supplyDefaults: YX().supplyDefaults, calc: $X(), colorbar: { min: "cmin", max: "cmax" }, plot: cF().createIsosurfaceTrace, moduleType: "trace", name: "isosurface", basePlotModule: $_(), categories: ["gl3d", "showLegend"], meta: {} };\n          });\n          var S8e = ye((Igr, A8e) => {\n            "use strict";\n            A8e.exports = T8e();\n          });\n          var tZ = ye((Rgr, E8e) => {\n            "use strict";\n            var HRt = Tu(), yh = sF(), jRt = JE(), M8e = Gl(), eZ = Ao().extendFlat, WRt = mc().overrideAll, fF = E8e.exports = WRt(eZ({ x: yh.x, y: yh.y, z: yh.z, value: yh.value, isomin: yh.isomin, isomax: yh.isomax, surface: yh.surface, spaceframe: { show: { valType: "boolean", dflt: false }, fill: { valType: "number", min: 0, max: 1, dflt: 1 } }, slices: yh.slices, caps: yh.caps, text: yh.text, hovertext: yh.hovertext, xhoverformat: yh.xhoverformat, yhoverformat: yh.yhoverformat, zhoverformat: yh.zhoverformat, valuehoverformat: yh.valuehoverformat, hovertemplate: yh.hovertemplate, hovertemplatefallback: yh.hovertemplatefallback }, HRt("", { colorAttr: "`value`", showScaleDflt: true, editTypeOverride: "calc" }), { colorbar: yh.colorbar, opacity: yh.opacity, opacityscale: jRt.opacityscale, lightposition: yh.lightposition, lighting: yh.lighting, flatshading: yh.flatshading, contour: yh.contour, hoverinfo: eZ({}, M8e.hoverinfo), showlegend: eZ({}, M8e.showlegend, { dflt: false }) }), "calc", "nested");\n            fF.x.editType = fF.y.editType = fF.z.editType = fF.value.editType = "calc+clearAxisTypes";\n          });\n          var C8e = ye((Dgr, k8e) => {\n            "use strict";\n            var XRt = Dr(), ZRt = tZ(), YRt = YX().supplyIsoDefaults, KRt = GX().opacityscaleDefaults;\n            k8e.exports = function(t3, r4, n4, i3) {\n              function a4(o4, s3) {\n                return XRt.coerce(t3, r4, ZRt, o4, s3);\n              }\n              YRt(t3, r4, n4, i3, a4), KRt(t3, r4, i3, a4);\n            };\n          });\n          var R8e = ye((Fgr, I8e) => {\n            "use strict";\n            var JRt = Od().gl_mesh3d, $Rt = $y().parseColorScale, QRt = Dr().isArrayOrTypedArray, eDt = Jy(), tDt = tc().extractOpts, L8e = ZA(), rZ = cF().findNearestOnAxis, rDt = cF().generateIsoMeshes;\n            function P8e(e3, t3, r4) {\n              this.scene = e3, this.uid = r4, this.mesh = t3, this.name = "", this.data = null, this.showContour = false;\n            }\n            var iZ = P8e.prototype;\n            iZ.handlePick = function(e3) {\n              if (e3.object === this.mesh) {\n                var t3 = e3.data.index, r4 = this.data._meshX[t3], n4 = this.data._meshY[t3], i3 = this.data._meshZ[t3], a4 = this.data._Ys.length, o4 = this.data._Zs.length, s3 = rZ(r4, this.data._Xs).id, l3 = rZ(n4, this.data._Ys).id, u4 = rZ(i3, this.data._Zs).id, c5 = e3.index = u4 + o4 * l3 + o4 * a4 * s3;\n                e3.traceCoordinate = [this.data._meshX[c5], this.data._meshY[c5], this.data._meshZ[c5], this.data._value[c5]];\n                var f4 = this.data.hovertext || this.data.text;\n                return QRt(f4) && f4[c5] !== void 0 ? e3.textLabel = f4[c5] : f4 && (e3.textLabel = f4), true;\n              }\n            };\n            iZ.update = function(e3) {\n              var t3 = this.scene, r4 = t3.fullSceneLayout;\n              this.data = rDt(e3);\n              function n4(l3, u4, c5, f4) {\n                return u4.map(function(h3) {\n                  return l3.d2l(h3, 0, f4) * c5;\n                });\n              }\n              var i3 = L8e(n4(r4.xaxis, e3._meshX, t3.dataScale[0], e3.xcalendar), n4(r4.yaxis, e3._meshY, t3.dataScale[1], e3.ycalendar), n4(r4.zaxis, e3._meshZ, t3.dataScale[2], e3.zcalendar)), a4 = L8e(e3._meshI, e3._meshJ, e3._meshK), o4 = { positions: i3, cells: a4, lightPosition: [e3.lightposition.x, e3.lightposition.y, e3.lightposition.z], ambient: e3.lighting.ambient, diffuse: e3.lighting.diffuse, specular: e3.lighting.specular, roughness: e3.lighting.roughness, fresnel: e3.lighting.fresnel, vertexNormalsEpsilon: e3.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e3.lighting.facenormalsepsilon, opacity: e3.opacity, opacityscale: e3.opacityscale, contourEnable: e3.contour.show, contourColor: eDt(e3.contour.color).slice(0, 3), contourWidth: e3.contour.width, useFacetNormals: e3.flatshading }, s3 = tDt(e3);\n              o4.vertexIntensity = e3._meshIntensity, o4.vertexIntensityBounds = [s3.min, s3.max], o4.colormap = $Rt(e3), this.mesh.update(o4);\n            };\n            iZ.dispose = function() {\n              this.scene.glplot.remove(this.mesh), this.mesh.dispose();\n            };\n            function iDt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = JRt({ gl: r4 }), i3 = new P8e(e3, n4, t3.uid);\n              return n4._trace = i3, i3.update(t3), e3.glplot.add(n4), i3;\n            }\n            I8e.exports = iDt;\n          });\n          var F8e = ye((zgr, D8e) => {\n            "use strict";\n            D8e.exports = { attributes: tZ(), supplyDefaults: C8e(), calc: $X(), colorbar: { min: "cmin", max: "cmax" }, plot: R8e(), moduleType: "trace", name: "volume", basePlotModule: $_(), categories: ["gl3d", "showLegend"], meta: {} };\n          });\n          var O8e = ye((Ogr, z8e) => {\n            "use strict";\n            z8e.exports = F8e();\n          });\n          var N8e = ye((qgr, B8e) => {\n            "use strict";\n            var nDt = qa(), q8e = Dr(), aDt = Qh(), oDt = WA();\n            B8e.exports = function(t3, r4, n4, i3) {\n              function a4(c5, f4) {\n                return q8e.coerce(t3, r4, oDt, c5, f4);\n              }\n              function o4(c5) {\n                var f4 = c5.map(function(h3) {\n                  var d3 = a4(h3);\n                  return d3 && q8e.isArrayOrTypedArray(d3) ? d3 : null;\n                });\n                return f4.every(function(h3) {\n                  return h3 && h3.length === f4[0].length;\n                }) && f4;\n              }\n              var s3 = o4(["x", "y", "z"]);\n              if (!s3) {\n                r4.visible = false;\n                return;\n              }\n              if (o4(["i", "j", "k"]), r4.i && (!r4.j || !r4.k) || r4.j && (!r4.k || !r4.i) || r4.k && (!r4.i || !r4.j)) {\n                r4.visible = false;\n                return;\n              }\n              var l3 = nDt.getComponentMethod("calendars", "handleTraceDefaults");\n              l3(t3, r4, ["x", "y", "z"], i3), ["lighting.ambient", "lighting.diffuse", "lighting.specular", "lighting.roughness", "lighting.fresnel", "lighting.vertexnormalsepsilon", "lighting.facenormalsepsilon", "lightposition.x", "lightposition.y", "lightposition.z", "flatshading", "alphahull", "delaunayaxis", "opacity"].forEach(function(c5) {\n                a4(c5);\n              });\n              var u4 = a4("contour.show");\n              u4 && (a4("contour.color"), a4("contour.width")), "intensity" in t3 ? (a4("intensity"), a4("intensitymode"), aDt(t3, r4, i3, a4, { prefix: "", cLetter: "c" })) : (r4.showscale = false, "facecolor" in t3 ? a4("facecolor") : "vertexcolor" in t3 ? a4("vertexcolor") : a4("color", n4)), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("xhoverformat"), a4("yhoverformat"), a4("zhoverformat"), r4._length = null;\n            };\n          });\n          var V8e = ye((Bgr, U8e) => {\n            "use strict";\n            var sDt = gv();\n            U8e.exports = function(t3, r4) {\n              r4.intensity && sDt(t3, r4, { vals: r4.intensity, containerStr: "", cLetter: "c" });\n            };\n          });\n          var X8e = ye((Ngr, W8e) => {\n            "use strict";\n            var lDt = Od().gl_mesh3d, uDt = Od().delaunay_triangulate, cDt = Od().alpha_shape, fDt = Od().convex_hull, hDt = $y().parseColorScale, dDt = Dr().isArrayOrTypedArray, sZ = Jy(), vDt = tc().extractOpts, G8e = ZA();\n            function j8e(e3, t3, r4) {\n              this.scene = e3, this.uid = r4, this.mesh = t3, this.name = "", this.color = "#fff", this.data = null, this.showContour = false;\n            }\n            var lZ = j8e.prototype;\n            lZ.handlePick = function(e3) {\n              if (e3.object === this.mesh) {\n                var t3 = e3.index = e3.data.index;\n                e3.data._cellCenter ? e3.traceCoordinate = e3.data.dataCoordinate : e3.traceCoordinate = [this.data.x[t3], this.data.y[t3], this.data.z[t3]];\n                var r4 = this.data.hovertext || this.data.text;\n                return dDt(r4) && r4[t3] !== void 0 ? e3.textLabel = r4[t3] : r4 && (e3.textLabel = r4), true;\n              }\n            };\n            function H8e(e3) {\n              for (var t3 = [], r4 = e3.length, n4 = 0; n4 < r4; n4++) t3[n4] = sZ(e3[n4]);\n              return t3;\n            }\n            function nZ(e3, t3, r4, n4) {\n              for (var i3 = [], a4 = t3.length, o4 = 0; o4 < a4; o4++) i3[o4] = e3.d2l(t3[o4], 0, n4) * r4;\n              return i3;\n            }\n            function aZ(e3) {\n              for (var t3 = [], r4 = e3.length, n4 = 0; n4 < r4; n4++) t3[n4] = Math.round(e3[n4]);\n              return t3;\n            }\n            function pDt(e3, t3) {\n              for (var r4 = ["x", "y", "z"].indexOf(e3), n4 = [], i3 = t3.length, a4 = 0; a4 < i3; a4++) n4[a4] = [t3[a4][(r4 + 1) % 3], t3[a4][(r4 + 2) % 3]];\n              return uDt(n4);\n            }\n            function oZ(e3, t3) {\n              for (var r4 = e3.length, n4 = 0; n4 < r4; n4++) if (e3[n4] <= -0.5 || e3[n4] >= t3 - 0.5) return false;\n              return true;\n            }\n            lZ.update = function(e3) {\n              var t3 = this.scene, r4 = t3.fullSceneLayout;\n              this.data = e3;\n              var n4 = e3.x.length, i3 = G8e(nZ(r4.xaxis, e3.x, t3.dataScale[0], e3.xcalendar), nZ(r4.yaxis, e3.y, t3.dataScale[1], e3.ycalendar), nZ(r4.zaxis, e3.z, t3.dataScale[2], e3.zcalendar)), a4;\n              if (e3.i && e3.j && e3.k) {\n                if (e3.i.length !== e3.j.length || e3.j.length !== e3.k.length || !oZ(e3.i, n4) || !oZ(e3.j, n4) || !oZ(e3.k, n4)) return;\n                a4 = G8e(aZ(e3.i), aZ(e3.j), aZ(e3.k));\n              } else e3.alphahull === 0 ? a4 = fDt(i3) : e3.alphahull > 0 ? a4 = cDt(e3.alphahull, i3) : a4 = pDt(e3.delaunayaxis, i3);\n              var o4 = { positions: i3, cells: a4, lightPosition: [e3.lightposition.x, e3.lightposition.y, e3.lightposition.z], ambient: e3.lighting.ambient, diffuse: e3.lighting.diffuse, specular: e3.lighting.specular, roughness: e3.lighting.roughness, fresnel: e3.lighting.fresnel, vertexNormalsEpsilon: e3.lighting.vertexnormalsepsilon, faceNormalsEpsilon: e3.lighting.facenormalsepsilon, opacity: e3.opacity, contourEnable: e3.contour.show, contourColor: sZ(e3.contour.color).slice(0, 3), contourWidth: e3.contour.width, useFacetNormals: e3.flatshading };\n              if (e3.intensity) {\n                var s3 = vDt(e3);\n                this.color = "#fff";\n                var l3 = e3.intensitymode;\n                o4[l3 + "Intensity"] = e3.intensity, o4[l3 + "IntensityBounds"] = [s3.min, s3.max], o4.colormap = hDt(e3);\n              } else e3.vertexcolor ? (this.color = e3.vertexcolor[0], o4.vertexColors = H8e(e3.vertexcolor)) : e3.facecolor ? (this.color = e3.facecolor[0], o4.cellColors = H8e(e3.facecolor)) : (this.color = e3.color, o4.meshColor = sZ(e3.color));\n              this.mesh.update(o4);\n            };\n            lZ.dispose = function() {\n              this.scene.glplot.remove(this.mesh), this.mesh.dispose();\n            };\n            function gDt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = lDt({ gl: r4 }), i3 = new j8e(e3, n4, t3.uid);\n              return n4._trace = i3, i3.update(t3), e3.glplot.add(n4), i3;\n            }\n            W8e.exports = gDt;\n          });\n          var Y8e = ye((Ugr, Z8e) => {\n            "use strict";\n            Z8e.exports = { attributes: WA(), supplyDefaults: N8e(), calc: V8e(), colorbar: { min: "cmin", max: "cmax" }, plot: X8e(), moduleType: "trace", name: "mesh3d", basePlotModule: $_(), categories: ["gl3d", "showLegend"], meta: {} };\n          });\n          var J8e = ye((Vgr, K8e) => {\n            "use strict";\n            K8e.exports = Y8e();\n          });\n          var cZ = ye((Ggr, Q8e) => {\n            "use strict";\n            var mDt = Tu(), YA = df().axisHoverFormat, { hovertemplateAttrs: yDt, templatefallbackAttrs: _Dt } = Ll(), xDt = WA(), $8e = Gl(), uZ = Ao().extendFlat, hF = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, u: { valType: "data_array", editType: "calc" }, v: { valType: "data_array", editType: "calc" }, w: { valType: "data_array", editType: "calc" }, sizemode: { valType: "enumerated", values: ["scaled", "absolute", "raw"], editType: "calc", dflt: "scaled" }, sizeref: { valType: "number", editType: "calc", min: 0 }, anchor: { valType: "enumerated", editType: "calc", values: ["tip", "tail", "cm", "center"], dflt: "cm" }, text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: yDt({ editType: "calc" }, { keys: ["norm"] }), hovertemplatefallback: _Dt({ editType: "calc" }), uhoverformat: YA("u", 1), vhoverformat: YA("v", 1), whoverformat: YA("w", 1), xhoverformat: YA("x"), yhoverformat: YA("y"), zhoverformat: YA("z"), showlegend: uZ({}, $8e.showlegend, { dflt: false }) };\n            uZ(hF, mDt("", { colorAttr: "u/v/w norm", showScaleDflt: true, editTypeOverride: "calc" }));\n            var bDt = ["opacity", "lightposition", "lighting"];\n            bDt.forEach(function(e3) {\n              hF[e3] = xDt[e3];\n            });\n            hF.hoverinfo = uZ({}, $8e.hoverinfo, { editType: "calc", flags: ["x", "y", "z", "u", "v", "w", "norm", "text", "name"], dflt: "x+y+z+norm+text+name" });\n            Q8e.exports = hF;\n          });\n          var tRe = ye((Hgr, eRe) => {\n            "use strict";\n            var wDt = Dr(), TDt = Qh(), ADt = cZ();\n            eRe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return wDt.coerce(t3, r4, ADt, d3, v3);\n              }\n              var o4 = a4("u"), s3 = a4("v"), l3 = a4("w"), u4 = a4("x"), c5 = a4("y"), f4 = a4("z");\n              if (!o4 || !o4.length || !s3 || !s3.length || !l3 || !l3.length || !u4 || !u4.length || !c5 || !c5.length || !f4 || !f4.length) {\n                r4.visible = false;\n                return;\n              }\n              var h3 = a4("sizemode");\n              a4("sizeref", h3 === "raw" ? 1 : 0.5), a4("anchor"), a4("lighting.ambient"), a4("lighting.diffuse"), a4("lighting.specular"), a4("lighting.roughness"), a4("lighting.fresnel"), a4("lightposition.x"), a4("lightposition.y"), a4("lightposition.z"), TDt(t3, r4, i3, a4, { prefix: "", cLetter: "c" }), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("uhoverformat"), a4("vhoverformat"), a4("whoverformat"), a4("xhoverformat"), a4("yhoverformat"), a4("zhoverformat"), r4._length = null;\n            };\n          });\n          var iRe = ye((jgr, rRe) => {\n            "use strict";\n            var SDt = gv();\n            rRe.exports = function(t3, r4) {\n              for (var n4 = r4.u, i3 = r4.v, a4 = r4.w, o4 = Math.min(r4.x.length, r4.y.length, r4.z.length, n4.length, i3.length, a4.length), s3 = -1 / 0, l3 = 1 / 0, u4 = 0; u4 < o4; u4++) {\n                var c5 = n4[u4], f4 = i3[u4], h3 = a4[u4], d3 = Math.sqrt(c5 * c5 + f4 * f4 + h3 * h3);\n                s3 = Math.max(s3, d3), l3 = Math.min(l3, d3);\n              }\n              r4._len = o4, r4._normMax = s3, SDt(t3, r4, { vals: [l3, s3], containerStr: "", cLetter: "c" });\n            };\n          });\n          var lRe = ye((Wgr, sRe) => {\n            "use strict";\n            var MDt = Od().gl_cone3d, EDt = Od().gl_cone3d.createConeMesh, kDt = Dr().simpleMap, CDt = $y().parseColorScale, LDt = tc().extractOpts, PDt = Dr().isArrayOrTypedArray, nRe = ZA();\n            function aRe(e3, t3) {\n              this.scene = e3, this.uid = t3, this.mesh = null, this.data = null;\n            }\n            var fZ = aRe.prototype;\n            fZ.handlePick = function(e3) {\n              if (e3.object === this.mesh) {\n                var t3 = e3.index = e3.data.index, r4 = this.data.x[t3], n4 = this.data.y[t3], i3 = this.data.z[t3], a4 = this.data.u[t3], o4 = this.data.v[t3], s3 = this.data.w[t3];\n                e3.traceCoordinate = [r4, n4, i3, a4, o4, s3, Math.sqrt(a4 * a4 + o4 * o4 + s3 * s3)];\n                var l3 = this.data.hovertext || this.data.text;\n                return PDt(l3) && l3[t3] !== void 0 ? e3.textLabel = l3[t3] : l3 && (e3.textLabel = l3), true;\n              }\n            };\n            var IDt = { xaxis: 0, yaxis: 1, zaxis: 2 }, RDt = { tip: 1, tail: 0, cm: 0.25, center: 0.5 }, DDt = { tip: 1, tail: 1, cm: 0.75, center: 0.5 };\n            function oRe(e3, t3) {\n              var r4 = e3.fullSceneLayout, n4 = e3.dataScale, i3 = {};\n              function a4(c5, f4) {\n                var h3 = r4[f4], d3 = n4[IDt[f4]];\n                return kDt(c5, function(v3) {\n                  return h3.d2l(v3) * d3;\n                });\n              }\n              i3.vectors = nRe(a4(t3.u, "xaxis"), a4(t3.v, "yaxis"), a4(t3.w, "zaxis"), t3._len), i3.positions = nRe(a4(t3.x, "xaxis"), a4(t3.y, "yaxis"), a4(t3.z, "zaxis"), t3._len);\n              var o4 = LDt(t3);\n              i3.colormap = CDt(t3), i3.vertexIntensityBounds = [o4.min / t3._normMax, o4.max / t3._normMax], i3.coneOffset = RDt[t3.anchor];\n              var s3 = t3.sizemode;\n              s3 === "scaled" ? i3.coneSize = t3.sizeref || 0.5 : s3 === "absolute" ? i3.coneSize = t3.sizeref && t3._normMax ? t3.sizeref / t3._normMax : 0.5 : s3 === "raw" && (i3.coneSize = t3.sizeref), i3.coneSizemode = s3;\n              var l3 = MDt(i3), u4 = t3.lightposition;\n              return l3.lightPosition = [u4.x, u4.y, u4.z], l3.ambient = t3.lighting.ambient, l3.diffuse = t3.lighting.diffuse, l3.specular = t3.lighting.specular, l3.roughness = t3.lighting.roughness, l3.fresnel = t3.lighting.fresnel, l3.opacity = t3.opacity, t3._pad = DDt[t3.anchor] * l3.vectorScale * l3.coneScale * t3._normMax, l3;\n            }\n            fZ.update = function(e3) {\n              this.data = e3;\n              var t3 = oRe(this.scene, e3);\n              this.mesh.update(t3);\n            };\n            fZ.dispose = function() {\n              this.scene.glplot.remove(this.mesh), this.mesh.dispose();\n            };\n            function FDt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = oRe(e3, t3), i3 = EDt(r4, n4), a4 = new aRe(e3, t3.uid);\n              return a4.mesh = i3, a4.data = t3, i3._trace = a4, e3.glplot.add(i3), a4;\n            }\n            sRe.exports = FDt;\n          });\n          var cRe = ye((Xgr, uRe) => {\n            "use strict";\n            uRe.exports = { moduleType: "trace", name: "cone", basePlotModule: $_(), categories: ["gl3d", "showLegend"], attributes: cZ(), supplyDefaults: tRe(), colorbar: { min: "cmin", max: "cmax" }, calc: iRe(), plot: lRe(), eventData: function(e3, t3) {\n              return e3.norm = t3.traceCoordinate[6], e3;\n            }, meta: {} };\n          });\n          var hRe = ye((Zgr, fRe) => {\n            "use strict";\n            fRe.exports = cRe();\n          });\n          var dZ = ye((Ygr, vRe) => {\n            "use strict";\n            var zDt = Tu(), KA = df().axisHoverFormat, { hovertemplateAttrs: ODt, templatefallbackAttrs: qDt } = Ll(), BDt = WA(), dRe = Gl(), hZ = Ao().extendFlat, dF = { x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, z: { valType: "data_array", editType: "calc+clearAxisTypes" }, u: { valType: "data_array", editType: "calc" }, v: { valType: "data_array", editType: "calc" }, w: { valType: "data_array", editType: "calc" }, starts: { x: { valType: "data_array", editType: "calc" }, y: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, editType: "calc" }, maxdisplayed: { valType: "integer", min: 0, dflt: 1e3, editType: "calc" }, sizeref: { valType: "number", editType: "calc", min: 0, dflt: 1 }, text: { valType: "string", dflt: "", editType: "calc" }, hovertext: { valType: "string", dflt: "", editType: "calc" }, hovertemplate: ODt({ editType: "calc" }, { keys: ["tubex", "tubey", "tubez", "tubeu", "tubev", "tubew", "norm", "divergence"] }), hovertemplatefallback: qDt({ editType: "calc" }), uhoverformat: KA("u", 1), vhoverformat: KA("v", 1), whoverformat: KA("w", 1), xhoverformat: KA("x"), yhoverformat: KA("y"), zhoverformat: KA("z"), showlegend: hZ({}, dRe.showlegend, { dflt: false }) };\n            hZ(dF, zDt("", { colorAttr: "u/v/w norm", showScaleDflt: true, editTypeOverride: "calc" }));\n            var NDt = ["opacity", "lightposition", "lighting"];\n            NDt.forEach(function(e3) {\n              dF[e3] = BDt[e3];\n            });\n            dF.hoverinfo = hZ({}, dRe.hoverinfo, { editType: "calc", flags: ["x", "y", "z", "u", "v", "w", "norm", "divergence", "text", "name"], dflt: "x+y+z+norm+text+name" });\n            vRe.exports = dF;\n          });\n          var gRe = ye((Kgr, pRe) => {\n            "use strict";\n            var UDt = Dr(), VDt = Qh(), GDt = dZ();\n            pRe.exports = function(t3, r4, n4, i3) {\n              function a4(h3, d3) {\n                return UDt.coerce(t3, r4, GDt, h3, d3);\n              }\n              var o4 = a4("u"), s3 = a4("v"), l3 = a4("w"), u4 = a4("x"), c5 = a4("y"), f4 = a4("z");\n              if (!o4 || !o4.length || !s3 || !s3.length || !l3 || !l3.length || !u4 || !u4.length || !c5 || !c5.length || !f4 || !f4.length) {\n                r4.visible = false;\n                return;\n              }\n              a4("starts.x"), a4("starts.y"), a4("starts.z"), a4("maxdisplayed"), a4("sizeref"), a4("lighting.ambient"), a4("lighting.diffuse"), a4("lighting.specular"), a4("lighting.roughness"), a4("lighting.fresnel"), a4("lightposition.x"), a4("lightposition.y"), a4("lightposition.z"), VDt(t3, r4, i3, a4, { prefix: "", cLetter: "c" }), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("uhoverformat"), a4("vhoverformat"), a4("whoverformat"), a4("xhoverformat"), a4("yhoverformat"), a4("zhoverformat"), r4._length = null;\n            };\n          });\n          var ARe = ye((Jgr, TRe) => {\n            "use strict";\n            var _Re = Od().gl_streamtube3d, HDt = _Re.createTubeMesh, jDt = Dr(), WDt = $y().parseColorScale, XDt = tc().extractOpts, mRe = ZA(), xRe = { xaxis: 0, yaxis: 1, zaxis: 2 };\n            function bRe(e3, t3) {\n              this.scene = e3, this.uid = t3, this.mesh = null, this.data = null;\n            }\n            var pZ = bRe.prototype;\n            pZ.handlePick = function(e3) {\n              var t3 = this.scene.fullSceneLayout, r4 = this.scene.dataScale;\n              function n4(o4, s3) {\n                var l3 = t3[s3], u4 = r4[xRe[s3]];\n                return l3.l2c(o4) / u4;\n              }\n              if (e3.object === this.mesh) {\n                var i3 = e3.data.position, a4 = e3.data.velocity;\n                return e3.traceCoordinate = [n4(i3[0], "xaxis"), n4(i3[1], "yaxis"), n4(i3[2], "zaxis"), n4(a4[0], "xaxis"), n4(a4[1], "yaxis"), n4(a4[2], "zaxis"), e3.data.intensity * this.data._normMax, e3.data.divergence], e3.textLabel = this.data.hovertext || this.data.text, true;\n              }\n            };\n            function yRe(e3) {\n              var t3 = e3.length, r4;\n              return t3 > 2 ? r4 = e3.slice(1, t3 - 1) : t3 === 2 ? r4 = [(e3[0] + e3[1]) / 2] : r4 = e3, r4;\n            }\n            function vZ(e3) {\n              var t3 = e3.length;\n              return t3 === 1 ? [0.5, 0.5] : [e3[1] - e3[0], e3[t3 - 1] - e3[t3 - 2]];\n            }\n            function wRe(e3, t3) {\n              var r4 = e3.fullSceneLayout, n4 = e3.dataScale, i3 = t3._len, a4 = {};\n              function o4(z3, O3) {\n                var V2 = r4[O3], G2 = n4[xRe[O3]];\n                return jDt.simpleMap(z3, function(Z) {\n                  return V2.d2l(Z) * G2;\n                });\n              }\n              if (a4.vectors = mRe(o4(t3._u, "xaxis"), o4(t3._v, "yaxis"), o4(t3._w, "zaxis"), i3), !i3) return { positions: [], cells: [] };\n              var s3 = o4(t3._Xs, "xaxis"), l3 = o4(t3._Ys, "yaxis"), u4 = o4(t3._Zs, "zaxis");\n              a4.meshgrid = [s3, l3, u4], a4.gridFill = t3._gridFill;\n              var c5 = t3._slen;\n              if (c5) a4.startingPositions = mRe(o4(t3._startsX, "xaxis"), o4(t3._startsY, "yaxis"), o4(t3._startsZ, "zaxis"));\n              else {\n                for (var f4 = l3[0], h3 = yRe(s3), d3 = yRe(u4), v3 = new Array(h3.length * d3.length), _2 = 0, b = 0; b < h3.length; b++) for (var p3 = 0; p3 < d3.length; p3++) v3[_2++] = [h3[b], f4, d3[p3]];\n                a4.startingPositions = v3;\n              }\n              a4.colormap = WDt(t3), a4.tubeSize = t3.sizeref, a4.maxLength = t3.maxdisplayed;\n              var k4 = o4(t3._xbnds, "xaxis"), E3 = o4(t3._ybnds, "yaxis"), S2 = o4(t3._zbnds, "zaxis"), L3 = vZ(s3), x2 = vZ(l3), C3 = vZ(u4), M4 = [[k4[0] - L3[0], E3[0] - x2[0], S2[0] - C3[0]], [k4[1] + L3[1], E3[1] + x2[1], S2[1] + C3[1]]], g3 = _Re(a4, M4), P3 = XDt(t3);\n              g3.vertexIntensityBounds = [P3.min / t3._normMax, P3.max / t3._normMax];\n              var T3 = t3.lightposition;\n              return g3.lightPosition = [T3.x, T3.y, T3.z], g3.ambient = t3.lighting.ambient, g3.diffuse = t3.lighting.diffuse, g3.specular = t3.lighting.specular, g3.roughness = t3.lighting.roughness, g3.fresnel = t3.lighting.fresnel, g3.opacity = t3.opacity, t3._pad = g3.tubeScale * t3.sizeref * 2, g3;\n            }\n            pZ.update = function(e3) {\n              this.data = e3;\n              var t3 = wRe(this.scene, e3);\n              this.mesh.update(t3);\n            };\n            pZ.dispose = function() {\n              this.scene.glplot.remove(this.mesh), this.mesh.dispose();\n            };\n            function ZDt(e3, t3) {\n              var r4 = e3.glplot.gl, n4 = wRe(e3, t3), i3 = HDt(r4, n4), a4 = new bRe(e3, t3.uid);\n              return a4.mesh = i3, a4.data = t3, i3._trace = a4, e3.glplot.add(i3), a4;\n            }\n            TRe.exports = ZDt;\n          });\n          var MRe = ye(($gr, SRe) => {\n            "use strict";\n            SRe.exports = { moduleType: "trace", name: "streamtube", basePlotModule: $_(), categories: ["gl3d", "showLegend"], attributes: dZ(), supplyDefaults: gRe(), colorbar: { min: "cmin", max: "cmax" }, calc: lF().calc, plot: ARe(), eventData: function(e3, t3) {\n              return e3.tubex = e3.x, e3.tubey = e3.y, e3.tubez = e3.z, e3.tubeu = t3.traceCoordinate[3], e3.tubev = t3.traceCoordinate[4], e3.tubew = t3.traceCoordinate[5], e3.norm = t3.traceCoordinate[6], e3.divergence = t3.traceCoordinate[7], delete e3.x, delete e3.y, delete e3.z, e3;\n            }, meta: {} };\n          });\n          var kRe = ye((Qgr, ERe) => {\n            "use strict";\n            ERe.exports = MRe();\n          });\n          var j22 = ye((tmr, IRe) => {\n            "use strict";\n            var { hovertemplateAttrs: YDt, texttemplateAttrs: KDt, templatefallbackAttrs: CRe } = Ll(), JDt = Cg(), Wm = pf(), $Dt = Gl(), LRe = Tu(), QDt = Pd().dash, H2 = Ao().extendFlat, eFt = mc().overrideAll, eg = Wm.marker, PRe = Wm.line, tFt = eg.line, emr = ["The library used by the *country names* `locationmode` option is changing in an upcoming version.", "Country names in existing plots may not work in the new version."].join(" ");\n            IRe.exports = eFt({ lon: { valType: "data_array" }, lat: { valType: "data_array" }, locations: { valType: "data_array" }, locationmode: { valType: "enumerated", values: ["ISO-3", "USA-states", "country names", "geojson-id"], dflt: "ISO-3" }, geojson: { valType: "any", editType: "calc" }, featureidkey: { valType: "string", editType: "calc", dflt: "id" }, mode: H2({}, Wm.mode, { dflt: "markers" }), text: H2({}, Wm.text, {}), texttemplate: KDt({ editType: "plot" }, { keys: ["lat", "lon", "location", "text"] }), texttemplatefallback: CRe({ editType: "plot" }), hovertext: H2({}, Wm.hovertext, {}), textfont: Wm.textfont, textposition: Wm.textposition, line: { color: PRe.color, width: PRe.width, dash: QDt }, connectgaps: Wm.connectgaps, marker: H2({ symbol: eg.symbol, opacity: eg.opacity, angle: eg.angle, angleref: H2({}, eg.angleref, { values: ["previous", "up", "north"] }), standoff: eg.standoff, size: eg.size, sizeref: eg.sizeref, sizemin: eg.sizemin, sizemode: eg.sizemode, colorbar: eg.colorbar, line: H2({ width: tFt.width }, LRe("marker.line")), gradient: eg.gradient }, LRe("marker")), fill: { valType: "enumerated", values: ["none", "toself"], dflt: "none" }, fillcolor: JDt(), selected: Wm.selected, unselected: Wm.unselected, hoverinfo: H2({}, $Dt.hoverinfo, { flags: ["lon", "lat", "location", "text", "name"] }), hovertemplate: YDt(), hovertemplatefallback: CRe() }, "calc", "nested");\n          });\n          var DRe = ye((rmr, RRe) => {\n            "use strict";\n            var vF = Dr(), gZ = Ru(), rFt = $p(), iFt = R0(), nFt = D0(), aFt = Rg(), oFt = j22(), sFt = ["The library used by the *country names* `locationmode` option is changing in the next major version.", "Some country names in existing plots may not work in the new version.", "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."].join(" ");\n            RRe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return vF.coerce(t3, r4, oFt, d3, v3);\n              }\n              var o4 = a4("locations"), s3;\n              if (o4 && o4.length) {\n                var l3 = a4("geojson"), u4;\n                (typeof l3 == "string" && l3 !== "" || vF.isPlainObject(l3)) && (u4 = "geojson-id");\n                var c5 = a4("locationmode", u4);\n                c5 === "country names" && vF.warn(sFt), c5 === "geojson-id" && a4("featureidkey"), s3 = o4.length;\n              } else {\n                var f4 = a4("lon") || [], h3 = a4("lat") || [];\n                s3 = Math.min(f4.length, h3.length);\n              }\n              if (!s3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = s3, a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("mode"), gZ.hasMarkers(r4) && rFt(t3, r4, n4, i3, a4, { gradient: true }), gZ.hasLines(r4) && (iFt(t3, r4, n4, i3, a4), a4("connectgaps")), gZ.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), nFt(t3, r4, i3, a4)), a4("fill"), r4.fill !== "none" && aFt(t3, r4, n4, a4), vF.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var ORe = ye((imr, zRe) => {\n            "use strict";\n            var FRe = ho();\n            zRe.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.geo]._subplot, o4 = a4.mockAxis, s3 = t3.lonlat;\n              return i3.lonLabel = FRe.tickText(o4, o4.c2l(s3[0]), true).text, i3.latLabel = FRe.tickText(o4, o4.c2l(s3[1]), true).text, i3;\n            };\n          });\n          var pF = ye((nmr, URe) => {\n            "use strict";\n            var mZ = Eo(), qRe = fs().BADNUM, lFt = F0(), uFt = km(), cFt = z0(), fFt = Dr().isArrayOrTypedArray, BRe = Dr()._;\n            function NRe(e3) {\n              return e3 && typeof e3 == "string";\n            }\n            URe.exports = function(t3, r4) {\n              var n4 = fFt(r4.locations), i3 = n4 ? r4.locations.length : r4._length, a4 = new Array(i3), o4;\n              r4.geojson ? o4 = function(h3) {\n                return NRe(h3) || mZ(h3);\n              } : o4 = NRe;\n              for (var s3 = 0; s3 < i3; s3++) {\n                var l3 = a4[s3] = {};\n                if (n4) {\n                  var u4 = r4.locations[s3];\n                  l3.loc = o4(u4) ? u4 : null;\n                } else {\n                  var c5 = r4.lon[s3], f4 = r4.lat[s3];\n                  mZ(c5) && mZ(f4) ? l3.lonlat = [+c5, +f4] : l3.lonlat = [qRe, qRe];\n                }\n              }\n              return uFt(a4, r4), lFt(t3, r4), cFt(a4, r4), i3 && (a4[0].t = { labels: { lat: BRe(t3, "lat:") + " ", lon: BRe(t3, "lon:") + " " } }), a4;\n            };\n          });\n          var tk = ye((Mv) => {\n            "use strict";\n            Mv.projNames = { airy: "airy", aitoff: "aitoff", "albers usa": "albersUsa", albers: "albers", august: "august", "azimuthal equal area": "azimuthalEqualArea", "azimuthal equidistant": "azimuthalEquidistant", baker: "baker", bertin1953: "bertin1953", boggs: "boggs", bonne: "bonne", bottomley: "bottomley", bromley: "bromley", collignon: "collignon", "conic conformal": "conicConformal", "conic equal area": "conicEqualArea", "conic equidistant": "conicEquidistant", craig: "craig", craster: "craster", "cylindrical equal area": "cylindricalEqualArea", "cylindrical stereographic": "cylindricalStereographic", eckert1: "eckert1", eckert2: "eckert2", eckert3: "eckert3", eckert4: "eckert4", eckert5: "eckert5", eckert6: "eckert6", eisenlohr: "eisenlohr", "equal earth": "equalEarth", equirectangular: "equirectangular", fahey: "fahey", "foucaut sinusoidal": "foucautSinusoidal", foucaut: "foucaut", ginzburg4: "ginzburg4", ginzburg5: "ginzburg5", ginzburg6: "ginzburg6", ginzburg8: "ginzburg8", ginzburg9: "ginzburg9", gnomonic: "gnomonic", "gringorten quincuncial": "gringortenQuincuncial", gringorten: "gringorten", guyou: "guyou", hammer: "hammer", hill: "hill", homolosine: "homolosine", hufnagel: "hufnagel", hyperelliptical: "hyperelliptical", kavrayskiy7: "kavrayskiy7", lagrange: "lagrange", larrivee: "larrivee", laskowski: "laskowski", loximuthal: "loximuthal", mercator: "mercator", miller: "miller", mollweide: "mollweide", "mt flat polar parabolic": "mtFlatPolarParabolic", "mt flat polar quartic": "mtFlatPolarQuartic", "mt flat polar sinusoidal": "mtFlatPolarSinusoidal", "natural earth": "naturalEarth", "natural earth1": "naturalEarth1", "natural earth2": "naturalEarth2", "nell hammer": "nellHammer", nicolosi: "nicolosi", orthographic: "orthographic", patterson: "patterson", "peirce quincuncial": "peirceQuincuncial", polyconic: "polyconic", "rectangular polyconic": "rectangularPolyconic", robinson: "robinson", satellite: "satellite", "sinu mollweide": "sinuMollweide", sinusoidal: "sinusoidal", stereographic: "stereographic", times: "times", "transverse mercator": "transverseMercator", "van der grinten": "vanDerGrinten", "van der grinten2": "vanDerGrinten2", "van der grinten3": "vanDerGrinten3", "van der grinten4": "vanDerGrinten4", wagner4: "wagner4", wagner6: "wagner6", wiechel: "wiechel", "winkel tripel": "winkel3", winkel3: "winkel3" };\n            Mv.axesNames = ["lonaxis", "lataxis"];\n            Mv.lonaxisSpan = { orthographic: 180, "azimuthal equal area": 360, "azimuthal equidistant": 360, "conic conformal": 180, gnomonic: 160, stereographic: 180, "transverse mercator": 180, "*": 360 };\n            Mv.lataxisSpan = { "conic conformal": 150, stereographic: 179.5, "*": 180 };\n            Mv.scopeDefaults = { world: { lonaxisRange: [-180, 180], lataxisRange: [-90, 90], projType: "equirectangular", projRotate: [0, 0, 0] }, usa: { lonaxisRange: [-180, -50], lataxisRange: [15, 80], projType: "albers usa" }, europe: { lonaxisRange: [-30, 60], lataxisRange: [30, 85], projType: "conic conformal", projRotate: [15, 0, 0], projParallels: [0, 60] }, asia: { lonaxisRange: [22, 160], lataxisRange: [-15, 55], projType: "mercator", projRotate: [0, 0, 0] }, africa: { lonaxisRange: [-30, 60], lataxisRange: [-40, 40], projType: "mercator", projRotate: [0, 0, 0] }, "north america": { lonaxisRange: [-180, -45], lataxisRange: [5, 85], projType: "conic conformal", projRotate: [-100, 0, 0], projParallels: [29.5, 45.5] }, "south america": { lonaxisRange: [-100, -30], lataxisRange: [-60, 15], projType: "mercator", projRotate: [0, 0, 0] }, antarctica: { lonaxisRange: [-180, 180], lataxisRange: [-90, -60], projType: "equirectangular", projRotate: [0, 0, 0] }, oceania: { lonaxisRange: [-180, 180], lataxisRange: [-50, 25], projType: "equirectangular", projRotate: [0, 0, 0] } };\n            Mv.clipPad = 1e-3;\n            Mv.precision = 0.1;\n            Mv.landColor = "#F0DC82";\n            Mv.waterColor = "#3399FF";\n            Mv.locationmodeToLayer = { "ISO-3": "countries", "USA-states": "subunits", "country names": "countries" };\n            Mv.sphereSVG = { type: "Sphere" };\n            Mv.fillLayers = { ocean: 1, land: 1, lakes: 1 };\n            Mv.lineLayers = { subunits: 1, countries: 1, coastlines: 1, rivers: 1, frame: 1 };\n            Mv.layers = ["bg", "ocean", "land", "lakes", "subunits", "countries", "coastlines", "rivers", "lataxis", "lonaxis", "frame", "backplot", "frontplot"];\n            Mv.layersForChoropleth = ["bg", "ocean", "land", "subunits", "countries", "coastlines", "lataxis", "lonaxis", "frame", "backplot", "rivers", "lakes", "frontplot"];\n            Mv.layerNameToAdjective = { ocean: "ocean", land: "land", lakes: "lake", subunits: "subunit", countries: "country", coastlines: "coastline", rivers: "river", frame: "frame" };\n          });\n          var yZ = ye((gF, VRe) => {\n            (function(e3, t3) {\n              typeof gF == "object" && typeof VRe != "undefined" ? t3(gF) : (e3 = e3 || self, t3(e3.topojson = e3.topojson || {}));\n            })(gF, function(e3) {\n              "use strict";\n              function t3(E3) {\n                return E3;\n              }\n              function r4(E3) {\n                if (E3 == null) return t3;\n                var S2, L3, x2 = E3.scale[0], C3 = E3.scale[1], M4 = E3.translate[0], g3 = E3.translate[1];\n                return function(P3, T3) {\n                  T3 || (S2 = L3 = 0);\n                  var z3 = 2, O3 = P3.length, V2 = new Array(O3);\n                  for (V2[0] = (S2 += P3[0]) * x2 + M4, V2[1] = (L3 += P3[1]) * C3 + g3; z3 < O3; ) V2[z3] = P3[z3], ++z3;\n                  return V2;\n                };\n              }\n              function n4(E3) {\n                var S2 = r4(E3.transform), L3, x2 = 1 / 0, C3 = x2, M4 = -x2, g3 = -x2;\n                function P3(z3) {\n                  z3 = S2(z3), z3[0] < x2 && (x2 = z3[0]), z3[0] > M4 && (M4 = z3[0]), z3[1] < C3 && (C3 = z3[1]), z3[1] > g3 && (g3 = z3[1]);\n                }\n                function T3(z3) {\n                  switch (z3.type) {\n                    case "GeometryCollection":\n                      z3.geometries.forEach(T3);\n                      break;\n                    case "Point":\n                      P3(z3.coordinates);\n                      break;\n                    case "MultiPoint":\n                      z3.coordinates.forEach(P3);\n                      break;\n                  }\n                }\n                E3.arcs.forEach(function(z3) {\n                  for (var O3 = -1, V2 = z3.length, G2; ++O3 < V2; ) G2 = S2(z3[O3], O3), G2[0] < x2 && (x2 = G2[0]), G2[0] > M4 && (M4 = G2[0]), G2[1] < C3 && (C3 = G2[1]), G2[1] > g3 && (g3 = G2[1]);\n                });\n                for (L3 in E3.objects) T3(E3.objects[L3]);\n                return [x2, C3, M4, g3];\n              }\n              function i3(E3, S2) {\n                for (var L3, x2 = E3.length, C3 = x2 - S2; C3 < --x2; ) L3 = E3[C3], E3[C3++] = E3[x2], E3[x2] = L3;\n              }\n              function a4(E3, S2) {\n                return typeof S2 == "string" && (S2 = E3.objects[S2]), S2.type === "GeometryCollection" ? { type: "FeatureCollection", features: S2.geometries.map(function(L3) {\n                  return o4(E3, L3);\n                }) } : o4(E3, S2);\n              }\n              function o4(E3, S2) {\n                var L3 = S2.id, x2 = S2.bbox, C3 = S2.properties == null ? {} : S2.properties, M4 = s3(E3, S2);\n                return L3 == null && x2 == null ? { type: "Feature", properties: C3, geometry: M4 } : x2 == null ? { type: "Feature", id: L3, properties: C3, geometry: M4 } : { type: "Feature", id: L3, bbox: x2, properties: C3, geometry: M4 };\n              }\n              function s3(E3, S2) {\n                var L3 = r4(E3.transform), x2 = E3.arcs;\n                function C3(O3, V2) {\n                  V2.length && V2.pop();\n                  for (var G2 = x2[O3 < 0 ? ~O3 : O3], Z = 0, j3 = G2.length; Z < j3; ++Z) V2.push(L3(G2[Z], Z));\n                  O3 < 0 && i3(V2, j3);\n                }\n                function M4(O3) {\n                  return L3(O3);\n                }\n                function g3(O3) {\n                  for (var V2 = [], G2 = 0, Z = O3.length; G2 < Z; ++G2) C3(O3[G2], V2);\n                  return V2.length < 2 && V2.push(V2[0]), V2;\n                }\n                function P3(O3) {\n                  for (var V2 = g3(O3); V2.length < 4; ) V2.push(V2[0]);\n                  return V2;\n                }\n                function T3(O3) {\n                  return O3.map(P3);\n                }\n                function z3(O3) {\n                  var V2 = O3.type, G2;\n                  switch (V2) {\n                    case "GeometryCollection":\n                      return { type: V2, geometries: O3.geometries.map(z3) };\n                    case "Point":\n                      G2 = M4(O3.coordinates);\n                      break;\n                    case "MultiPoint":\n                      G2 = O3.coordinates.map(M4);\n                      break;\n                    case "LineString":\n                      G2 = g3(O3.arcs);\n                      break;\n                    case "MultiLineString":\n                      G2 = O3.arcs.map(g3);\n                      break;\n                    case "Polygon":\n                      G2 = T3(O3.arcs);\n                      break;\n                    case "MultiPolygon":\n                      G2 = O3.arcs.map(T3);\n                      break;\n                    default:\n                      return null;\n                  }\n                  return { type: V2, coordinates: G2 };\n                }\n                return z3(S2);\n              }\n              function l3(E3, S2) {\n                var L3 = {}, x2 = {}, C3 = {}, M4 = [], g3 = -1;\n                S2.forEach(function(z3, O3) {\n                  var V2 = E3.arcs[z3 < 0 ? ~z3 : z3], G2;\n                  V2.length < 3 && !V2[1][0] && !V2[1][1] && (G2 = S2[++g3], S2[g3] = z3, S2[O3] = G2);\n                }), S2.forEach(function(z3) {\n                  var O3 = P3(z3), V2 = O3[0], G2 = O3[1], Z, j3;\n                  if (Z = C3[V2]) if (delete C3[Z.end], Z.push(z3), Z.end = G2, j3 = x2[G2]) {\n                    delete x2[j3.start];\n                    var N2 = j3 === Z ? Z : Z.concat(j3);\n                    x2[N2.start = Z.start] = C3[N2.end = j3.end] = N2;\n                  } else x2[Z.start] = C3[Z.end] = Z;\n                  else if (Z = x2[G2]) if (delete x2[Z.start], Z.unshift(z3), Z.start = V2, j3 = C3[V2]) {\n                    delete C3[j3.end];\n                    var H = j3 === Z ? Z : j3.concat(Z);\n                    x2[H.start = j3.start] = C3[H.end = Z.end] = H;\n                  } else x2[Z.start] = C3[Z.end] = Z;\n                  else Z = [z3], x2[Z.start = V2] = C3[Z.end = G2] = Z;\n                });\n                function P3(z3) {\n                  var O3 = E3.arcs[z3 < 0 ? ~z3 : z3], V2 = O3[0], G2;\n                  return E3.transform ? (G2 = [0, 0], O3.forEach(function(Z) {\n                    G2[0] += Z[0], G2[1] += Z[1];\n                  })) : G2 = O3[O3.length - 1], z3 < 0 ? [G2, V2] : [V2, G2];\n                }\n                function T3(z3, O3) {\n                  for (var V2 in z3) {\n                    var G2 = z3[V2];\n                    delete O3[G2.start], delete G2.start, delete G2.end, G2.forEach(function(Z) {\n                      L3[Z < 0 ? ~Z : Z] = 1;\n                    }), M4.push(G2);\n                  }\n                }\n                return T3(C3, x2), T3(x2, C3), S2.forEach(function(z3) {\n                  L3[z3 < 0 ? ~z3 : z3] || M4.push([z3]);\n                }), M4;\n              }\n              function u4(E3) {\n                return s3(E3, c5.apply(this, arguments));\n              }\n              function c5(E3, S2, L3) {\n                var x2, C3, M4;\n                if (arguments.length > 1) x2 = f4(E3, S2, L3);\n                else for (C3 = 0, x2 = new Array(M4 = E3.arcs.length); C3 < M4; ++C3) x2[C3] = C3;\n                return { type: "MultiLineString", arcs: l3(E3, x2) };\n              }\n              function f4(E3, S2, L3) {\n                var x2 = [], C3 = [], M4;\n                function g3(V2) {\n                  var G2 = V2 < 0 ? ~V2 : V2;\n                  (C3[G2] || (C3[G2] = [])).push({ i: V2, g: M4 });\n                }\n                function P3(V2) {\n                  V2.forEach(g3);\n                }\n                function T3(V2) {\n                  V2.forEach(P3);\n                }\n                function z3(V2) {\n                  V2.forEach(T3);\n                }\n                function O3(V2) {\n                  switch (M4 = V2, V2.type) {\n                    case "GeometryCollection":\n                      V2.geometries.forEach(O3);\n                      break;\n                    case "LineString":\n                      P3(V2.arcs);\n                      break;\n                    case "MultiLineString":\n                    case "Polygon":\n                      T3(V2.arcs);\n                      break;\n                    case "MultiPolygon":\n                      z3(V2.arcs);\n                      break;\n                  }\n                }\n                return O3(S2), C3.forEach(L3 == null ? function(V2) {\n                  x2.push(V2[0].i);\n                } : function(V2) {\n                  L3(V2[0].g, V2[V2.length - 1].g) && x2.push(V2[0].i);\n                }), x2;\n              }\n              function h3(E3) {\n                for (var S2 = -1, L3 = E3.length, x2, C3 = E3[L3 - 1], M4 = 0; ++S2 < L3; ) x2 = C3, C3 = E3[S2], M4 += x2[0] * C3[1] - x2[1] * C3[0];\n                return Math.abs(M4);\n              }\n              function d3(E3) {\n                return s3(E3, v3.apply(this, arguments));\n              }\n              function v3(E3, S2) {\n                var L3 = {}, x2 = [], C3 = [];\n                S2.forEach(M4);\n                function M4(T3) {\n                  switch (T3.type) {\n                    case "GeometryCollection":\n                      T3.geometries.forEach(M4);\n                      break;\n                    case "Polygon":\n                      g3(T3.arcs);\n                      break;\n                    case "MultiPolygon":\n                      T3.arcs.forEach(g3);\n                      break;\n                  }\n                }\n                function g3(T3) {\n                  T3.forEach(function(z3) {\n                    z3.forEach(function(O3) {\n                      (L3[O3 = O3 < 0 ? ~O3 : O3] || (L3[O3] = [])).push(T3);\n                    });\n                  }), x2.push(T3);\n                }\n                function P3(T3) {\n                  return h3(s3(E3, { type: "Polygon", arcs: [T3] }).coordinates[0]);\n                }\n                return x2.forEach(function(T3) {\n                  if (!T3._) {\n                    var z3 = [], O3 = [T3];\n                    for (T3._ = 1, C3.push(z3); T3 = O3.pop(); ) z3.push(T3), T3.forEach(function(V2) {\n                      V2.forEach(function(G2) {\n                        L3[G2 < 0 ? ~G2 : G2].forEach(function(Z) {\n                          Z._ || (Z._ = 1, O3.push(Z));\n                        });\n                      });\n                    });\n                  }\n                }), x2.forEach(function(T3) {\n                  delete T3._;\n                }), { type: "MultiPolygon", arcs: C3.map(function(T3) {\n                  var z3 = [], O3;\n                  if (T3.forEach(function(N2) {\n                    N2.forEach(function(H) {\n                      H.forEach(function(te) {\n                        L3[te < 0 ? ~te : te].length < 2 && z3.push(te);\n                      });\n                    });\n                  }), z3 = l3(E3, z3), (O3 = z3.length) > 1) for (var V2 = 1, G2 = P3(z3[0]), Z, j3; V2 < O3; ++V2) (Z = P3(z3[V2])) > G2 && (j3 = z3[0], z3[0] = z3[V2], z3[V2] = j3, G2 = Z);\n                  return z3;\n                }).filter(function(T3) {\n                  return T3.length > 0;\n                }) };\n              }\n              function _2(E3, S2) {\n                for (var L3 = 0, x2 = E3.length; L3 < x2; ) {\n                  var C3 = L3 + x2 >>> 1;\n                  E3[C3] < S2 ? L3 = C3 + 1 : x2 = C3;\n                }\n                return L3;\n              }\n              function b(E3) {\n                var S2 = {}, L3 = E3.map(function() {\n                  return [];\n                });\n                function x2(N2, H) {\n                  N2.forEach(function(te) {\n                    te < 0 && (te = ~te);\n                    var oe = S2[te];\n                    oe ? oe.push(H) : S2[te] = [H];\n                  });\n                }\n                function C3(N2, H) {\n                  N2.forEach(function(te) {\n                    x2(te, H);\n                  });\n                }\n                function M4(N2, H) {\n                  N2.type === "GeometryCollection" ? N2.geometries.forEach(function(te) {\n                    M4(te, H);\n                  }) : N2.type in g3 && g3[N2.type](N2.arcs, H);\n                }\n                var g3 = { LineString: x2, MultiLineString: C3, Polygon: C3, MultiPolygon: function(N2, H) {\n                  N2.forEach(function(te) {\n                    C3(te, H);\n                  });\n                } };\n                E3.forEach(M4);\n                for (var P3 in S2) for (var T3 = S2[P3], z3 = T3.length, O3 = 0; O3 < z3; ++O3) for (var V2 = O3 + 1; V2 < z3; ++V2) {\n                  var G2 = T3[O3], Z = T3[V2], j3;\n                  (j3 = L3[G2])[P3 = _2(j3, Z)] !== Z && j3.splice(P3, 0, Z), (j3 = L3[Z])[P3 = _2(j3, G2)] !== G2 && j3.splice(P3, 0, G2);\n                }\n                return L3;\n              }\n              function p3(E3) {\n                if (E3 == null) return t3;\n                var S2, L3, x2 = E3.scale[0], C3 = E3.scale[1], M4 = E3.translate[0], g3 = E3.translate[1];\n                return function(P3, T3) {\n                  T3 || (S2 = L3 = 0);\n                  var z3 = 2, O3 = P3.length, V2 = new Array(O3), G2 = Math.round((P3[0] - M4) / x2), Z = Math.round((P3[1] - g3) / C3);\n                  for (V2[0] = G2 - S2, S2 = G2, V2[1] = Z - L3, L3 = Z; z3 < O3; ) V2[z3] = P3[z3], ++z3;\n                  return V2;\n                };\n              }\n              function k4(E3, S2) {\n                if (E3.transform) throw new Error("already quantized");\n                if (!S2 || !S2.scale) {\n                  if (!((g3 = Math.floor(S2)) >= 2)) throw new Error("n must be \\u22652");\n                  T3 = E3.bbox || n4(E3);\n                  var L3 = T3[0], x2 = T3[1], C3 = T3[2], M4 = T3[3], g3;\n                  S2 = { scale: [C3 - L3 ? (C3 - L3) / (g3 - 1) : 1, M4 - x2 ? (M4 - x2) / (g3 - 1) : 1], translate: [L3, x2] };\n                } else T3 = E3.bbox;\n                var P3 = p3(S2), T3, z3, O3 = E3.objects, V2 = {};\n                function G2(N2) {\n                  return P3(N2);\n                }\n                function Z(N2) {\n                  var H;\n                  switch (N2.type) {\n                    case "GeometryCollection":\n                      H = { type: "GeometryCollection", geometries: N2.geometries.map(Z) };\n                      break;\n                    case "Point":\n                      H = { type: "Point", coordinates: G2(N2.coordinates) };\n                      break;\n                    case "MultiPoint":\n                      H = { type: "MultiPoint", coordinates: N2.coordinates.map(G2) };\n                      break;\n                    default:\n                      return N2;\n                  }\n                  return N2.id != null && (H.id = N2.id), N2.bbox != null && (H.bbox = N2.bbox), N2.properties != null && (H.properties = N2.properties), H;\n                }\n                function j3(N2) {\n                  var H = 0, te = 1, oe = N2.length, _e, Ee = new Array(oe);\n                  for (Ee[0] = P3(N2[0], 0); ++H < oe; ) ((_e = P3(N2[H], H))[0] || _e[1]) && (Ee[te++] = _e);\n                  return te === 1 && (Ee[te++] = [0, 0]), Ee.length = te, Ee;\n                }\n                for (z3 in O3) V2[z3] = Z(O3[z3]);\n                return { type: "Topology", bbox: T3, transform: S2, objects: V2, arcs: E3.arcs.map(j3) };\n              }\n              e3.bbox = n4, e3.feature = a4, e3.merge = d3, e3.mergeArcs = v3, e3.mesh = u4, e3.meshArcs = c5, e3.neighbors = b, e3.quantize = k4, e3.transform = r4, e3.untransform = p3, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var mF = ye((omr, GRe) => {\n            "use strict";\n            var _Z = GRe.exports = {}, hFt = tk().locationmodeToLayer, dFt = yZ().feature;\n            _Z.getTopojsonName = function(e3) {\n              return [e3.scope.replace(/ /g, "-"), "_", e3.resolution.toString(), "m"].join("");\n            };\n            _Z.getTopojsonPath = function(e3, t3) {\n              return e3 += e3.endsWith("/") ? "" : "/", `${e3}${t3}.json`;\n            };\n            _Z.getTopojsonFeatures = function(e3, t3) {\n              var r4 = hFt[e3.locationmode], n4 = t3.objects[r4];\n              return dFt(t3, n4).features;\n            };\n          });\n          var tx = ye((rk) => {\n            "use strict";\n            var vFt = fs().BADNUM;\n            rk.calcTraceToLineCoords = function(e3) {\n              for (var t3 = e3[0].trace, r4 = t3.connectgaps, n4 = [], i3 = [], a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4], s3 = o4.lonlat;\n                s3[0] !== vFt ? i3.push(s3) : !r4 && i3.length > 0 && (n4.push(i3), i3 = []);\n              }\n              return i3.length > 0 && n4.push(i3), n4;\n            };\n            rk.makeLine = function(e3) {\n              return e3.length === 1 ? { type: "LineString", coordinates: e3[0] } : { type: "MultiLineString", coordinates: e3 };\n            };\n            rk.makePolygon = function(e3) {\n              if (e3.length === 1) return { type: "Polygon", coordinates: e3 };\n              for (var t3 = new Array(e3.length), r4 = 0; r4 < e3.length; r4++) t3[r4] = [e3[r4]];\n              return { type: "MultiPolygon", coordinates: t3 };\n            };\n            rk.makeBlank = function() {\n              return { type: "Point", coordinates: [] };\n            };\n          });\n          var jRe = ye((lmr, HRe) => {\n            HRe.exports = { AFG: "afghan", ALA: "\\\\b\\\\wland", ALB: "albania", DZA: "algeria", ASM: "^(?=.*americ).*samoa", AND: "andorra", AGO: "angola", AIA: "anguill?a", ATA: "antarctica", ATG: "antigua", ARG: "argentin", ARM: "armenia", ABW: "^(?!.*bonaire).*\\\\baruba", AUS: "australia", AUT: "^(?!.*hungary).*austria|\\\\baustri.*\\\\bemp", AZE: "azerbaijan", BHS: "bahamas", BHR: "bahrain", BGD: "bangladesh|^(?=.*east).*paki?stan", BRB: "barbados", BLR: "belarus|byelo", BEL: "^(?!.*luxem).*belgium", BLZ: "belize|^(?=.*british).*honduras", BEN: "benin|dahome", BMU: "bermuda", BTN: "bhutan", BOL: "bolivia", BES: "^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\\\bbes.?islands", BIH: "herzegovina|bosnia", BWA: "botswana|bechuana", BVT: "bouvet", BRA: "brazil", IOT: "british.?indian.?ocean", BRN: "brunei", BGR: "bulgaria", BFA: "burkina|\\\\bfaso|upper.?volta", BDI: "burundi", CPV: "verde", KHM: "cambodia|kampuchea|khmer", CMR: "cameroon", CAN: "canada", CYM: "cayman", CAF: "\\\\bcentral.african.republic", TCD: "\\\\bchad", CHL: "\\\\bchile", CHN: "^(?!.*\\\\bmac)(?!.*\\\\bhong)(?!.*\\\\btai)(?!.*\\\\brep).*china|^(?=.*peo)(?=.*rep).*china", CXR: "christmas", CCK: "\\\\bcocos|keeling", COL: "colombia", COM: "comoro", COG: "^(?!.*\\\\bdem)(?!.*\\\\bd[\\\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\\\bcongo", COK: "\\\\bcook", CRI: "costa.?rica", CIV: "ivoire|ivory", HRV: "croatia", CUB: "\\\\bcuba", CUW: "^(?!.*bonaire).*\\\\bcura(c|\\xE7)ao", CYP: "cyprus", CSK: "czechoslovakia", CZE: "^(?=.*rep).*czech|czechia|bohemia", COD: "\\\\bdem.*congo|congo.*\\\\bdem|congo.*\\\\bd[\\\\.]?r|\\\\bd[\\\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc", DNK: "denmark", DJI: "djibouti", DMA: "dominica(?!n)", DOM: "dominican.rep", ECU: "ecuador", EGY: "egypt", SLV: "el.?salvador", GNQ: "guine.*eq|eq.*guine|^(?=.*span).*guinea", ERI: "eritrea", EST: "estonia", ETH: "ethiopia|abyssinia", FLK: "falkland|malvinas", FRO: "faroe|faeroe", FJI: "fiji", FIN: "finland", FRA: "^(?!.*\\\\bdep)(?!.*martinique).*france|french.?republic|\\\\bgaul", GUF: "^(?=.*french).*guiana", PYF: "french.?polynesia|tahiti", ATF: "french.?southern", GAB: "gabon", GMB: "gambia", GEO: "^(?!.*south).*georgia", DDR: "german.?democratic.?republic|democratic.?republic.*germany|east.germany", DEU: "^(?!.*east).*germany|^(?=.*\\\\bfed.*\\\\brep).*german", GHA: "ghana|gold.?coast", GIB: "gibraltar", GRC: "greece|hellenic|hellas", GRL: "greenland", GRD: "grenada", GLP: "guadeloupe", GUM: "\\\\bguam", GTM: "guatemala", GGY: "guernsey", GIN: "^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea", GNB: "bissau|^(?=.*portu).*guinea", GUY: "guyana|british.?guiana", HTI: "haiti", HMD: "heard.*mcdonald", VAT: "holy.?see|vatican|papal.?st", HND: "^(?!.*brit).*honduras", HKG: "hong.?kong", HUN: "^(?!.*austr).*hungary", ISL: "iceland", IND: "india(?!.*ocea)", IDN: "indonesia", IRN: "\\\\biran|persia", IRQ: "\\\\biraq|mesopotamia", IRL: "(^ireland)|(^republic.*ireland)", IMN: "^(?=.*isle).*\\\\bman", ISR: "israel", ITA: "italy", JAM: "jamaica", JPN: "japan", JEY: "jersey", JOR: "jordan", KAZ: "kazak", KEN: "kenya|british.?east.?africa|east.?africa.?prot", KIR: "kiribati", PRK: "^(?=.*democrat|people|north|d.*p.*.r).*\\\\bkorea|dprk|korea.*(d.*p.*r)", KWT: "kuwait", KGZ: "kyrgyz|kirghiz", LAO: "\\\\blaos?\\\\b", LVA: "latvia", LBN: "lebanon", LSO: "lesotho|basuto", LBR: "liberia", LBY: "libya", LIE: "liechtenstein", LTU: "lithuania", LUX: "^(?!.*belg).*luxem", MAC: "maca(o|u)", MDG: "madagascar|malagasy", MWI: "malawi|nyasa", MYS: "malaysia", MDV: "maldive", MLI: "\\\\bmali\\\\b", MLT: "\\\\bmalta", MHL: "marshall", MTQ: "martinique", MRT: "mauritania", MUS: "mauritius", MYT: "\\\\bmayotte", MEX: "\\\\bmexic", FSM: "fed.*micronesia|micronesia.*fed", MCO: "monaco", MNG: "mongolia", MNE: "^(?!.*serbia).*montenegro", MSR: "montserrat", MAR: "morocco|\\\\bmaroc", MOZ: "mozambique", MMR: "myanmar|burma", NAM: "namibia", NRU: "nauru", NPL: "nepal", NLD: "^(?!.*\\\\bant)(?!.*\\\\bcarib).*netherlands", ANT: "^(?=.*\\\\bant).*(nether|dutch)", NCL: "new.?caledonia", NZL: "new.?zealand", NIC: "nicaragua", NER: "\\\\bniger(?!ia)", NGA: "nigeria", NIU: "niue", NFK: "norfolk", MNP: "mariana", NOR: "norway", OMN: "\\\\boman|trucial", PAK: "^(?!.*east).*paki?stan", PLW: "palau", PSE: "palestin|\\\\bgaza|west.?bank", PAN: "panama", PNG: "papua|new.?guinea", PRY: "paraguay", PER: "peru", PHL: "philippines", PCN: "pitcairn", POL: "poland", PRT: "portugal", PRI: "puerto.?rico", QAT: "qatar", KOR: "^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\\\bkorea(?!.*d.*p.*r)", MDA: "moldov|b(a|e)ssarabia", REU: "r(e|\\xE9)union", ROU: "r(o|u|ou)mania", RUS: "\\\\brussia|soviet.?union|u\\\\.?s\\\\.?s\\\\.?r|socialist.?republics", RWA: "rwanda", BLM: "barth(e|\\xE9)lemy", SHN: "helena", KNA: "kitts|\\\\bnevis", LCA: "\\\\blucia", MAF: "^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)", SPM: "miquelon", VCT: "vincent", WSM: "^(?!.*amer).*samoa", SMR: "san.?marino", STP: "\\\\bs(a|\\xE3)o.?tom(e|\\xE9)", SAU: "\\\\bsa\\\\w*.?arabia", SEN: "senegal", SRB: "^(?!.*monte).*serbia", SYC: "seychell", SLE: "sierra", SGP: "singapore", SXM: "^(?!.*martin)(?!.*saba).*maarten", SVK: "^(?!.*cze).*slovak", SVN: "slovenia", SLB: "solomon", SOM: "somali", ZAF: "south.africa|s\\\\\\\\..?africa", SGS: "south.?georgia|sandwich", SSD: "\\\\bs\\\\w*.?sudan", ESP: "spain", LKA: "sri.?lanka|ceylon", SDN: "^(?!.*\\\\bs(?!u)).*sudan", SUR: "surinam|dutch.?guiana", SJM: "svalbard", SWZ: "swaziland", SWE: "sweden", CHE: "switz|swiss", SYR: "syria", TWN: "taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china", TJK: "tajik", THA: "thailand|\\\\bsiam", MKD: "macedonia|fyrom", TLS: "^(?=.*leste).*timor|^(?=.*east).*timor", TGO: "togo", TKL: "tokelau", TON: "tonga", TTO: "trinidad|tobago", TUN: "tunisia", TUR: "turkey", TKM: "turkmen", TCA: "turks", TUV: "tuvalu", UGA: "uganda", UKR: "ukrain", ARE: "emirates|^u\\\\.?a\\\\.?e\\\\.?$|united.?arab.?em", GBR: "united.?kingdom|britain|^u\\\\.?k\\\\.?$", TZA: "tanzania", USA: "united.?states\\\\b(?!.*islands)|\\\\bu\\\\.?s\\\\.?a\\\\.?\\\\b|^\\\\s*u\\\\.?s\\\\.?\\\\b(?!.*islands)", UMI: "minor.?outlying.?is", URY: "uruguay", UZB: "uzbek", VUT: "vanuatu|new.?hebrides", VEN: "venezuela", VNM: "^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam", VGB: "^(?=.*\\\\bu\\\\.?\\\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin", VIR: "^(?=.*\\\\bu\\\\.?\\\\s?s).*virgin|^(?=.*states).*virgin", WLF: "futuna|wallis", ESH: "western.sahara", YEM: "^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\\\bp\\\\.?d\\\\.?r).*yemen", YMD: "^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\\\bp\\\\.?d\\\\.?r).*yemen", YUG: "yugoslavia", ZMB: "zambia|northern.?rhodesia", EAZ: "zanzibar", ZWE: "zimbabwe|^(?!.*northern).*rhodesia" };\n          });\n          var xF = ye((ic) => {\n            "use strict";\n            Object.defineProperty(ic, "__esModule", { value: true });\n            var Op = 63710088e-1, bZ = { centimeters: Op * 100, centimetres: Op * 100, degrees: 360 / (2 * Math.PI), feet: Op * 3.28084, inches: Op * 39.37, kilometers: Op / 1e3, kilometres: Op / 1e3, meters: Op, metres: Op, miles: Op / 1609.344, millimeters: Op * 1e3, millimetres: Op * 1e3, nauticalmiles: Op / 1852, radians: 1, yards: Op * 1.0936 }, xZ = { acres: 247105e-9, centimeters: 1e4, centimetres: 1e4, feet: 10.763910417, hectares: 1e-4, inches: 1550.003100006, kilometers: 1e-6, kilometres: 1e-6, meters: 1, metres: 1, miles: 386e-9, nauticalmiles: 29155334959812285e-23, millimeters: 1e6, millimetres: 1e6, yards: 1.195990046 };\n            function rx(e3, t3, r4 = {}) {\n              let n4 = { type: "Feature" };\n              return (r4.id === 0 || r4.id) && (n4.id = r4.id), r4.bbox && (n4.bbox = r4.bbox), n4.properties = t3 || {}, n4.geometry = e3, n4;\n            }\n            function pFt(e3, t3, r4 = {}) {\n              switch (e3) {\n                case "Point":\n                  return wZ(t3).geometry;\n                case "LineString":\n                  return AZ(t3).geometry;\n                case "Polygon":\n                  return TZ(t3).geometry;\n                case "MultiPoint":\n                  return XRe(t3).geometry;\n                case "MultiLineString":\n                  return WRe(t3).geometry;\n                case "MultiPolygon":\n                  return ZRe(t3).geometry;\n                default:\n                  throw new Error(e3 + " is invalid");\n              }\n            }\n            function wZ(e3, t3, r4 = {}) {\n              if (!e3) throw new Error("coordinates is required");\n              if (!Array.isArray(e3)) throw new Error("coordinates must be an Array");\n              if (e3.length < 2) throw new Error("coordinates must be at least 2 numbers long");\n              if (!yF(e3[0]) || !yF(e3[1])) throw new Error("coordinates must contain numbers");\n              return rx({ type: "Point", coordinates: e3 }, t3, r4);\n            }\n            function gFt(e3, t3, r4 = {}) {\n              return _F(e3.map((n4) => wZ(n4, t3)), r4);\n            }\n            function TZ(e3, t3, r4 = {}) {\n              for (let i3 of e3) {\n                if (i3.length < 4) throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");\n                if (i3[i3.length - 1].length !== i3[0].length) throw new Error("First and last Position are not equivalent.");\n                for (let a4 = 0; a4 < i3[i3.length - 1].length; a4++) if (i3[i3.length - 1][a4] !== i3[0][a4]) throw new Error("First and last Position are not equivalent.");\n              }\n              return rx({ type: "Polygon", coordinates: e3 }, t3, r4);\n            }\n            function mFt(e3, t3, r4 = {}) {\n              return _F(e3.map((n4) => TZ(n4, t3)), r4);\n            }\n            function AZ(e3, t3, r4 = {}) {\n              if (e3.length < 2) throw new Error("coordinates must be an array of two or more positions");\n              return rx({ type: "LineString", coordinates: e3 }, t3, r4);\n            }\n            function yFt(e3, t3, r4 = {}) {\n              return _F(e3.map((n4) => AZ(n4, t3)), r4);\n            }\n            function _F(e3, t3 = {}) {\n              let r4 = { type: "FeatureCollection" };\n              return t3.id && (r4.id = t3.id), t3.bbox && (r4.bbox = t3.bbox), r4.features = e3, r4;\n            }\n            function WRe(e3, t3, r4 = {}) {\n              return rx({ type: "MultiLineString", coordinates: e3 }, t3, r4);\n            }\n            function XRe(e3, t3, r4 = {}) {\n              return rx({ type: "MultiPoint", coordinates: e3 }, t3, r4);\n            }\n            function ZRe(e3, t3, r4 = {}) {\n              return rx({ type: "MultiPolygon", coordinates: e3 }, t3, r4);\n            }\n            function _Ft(e3, t3, r4 = {}) {\n              return rx({ type: "GeometryCollection", geometries: e3 }, t3, r4);\n            }\n            function xFt(e3, t3 = 0) {\n              if (t3 && !(t3 >= 0)) throw new Error("precision must be a positive number");\n              let r4 = Math.pow(10, t3 || 0);\n              return Math.round(e3 * r4) / r4;\n            }\n            function YRe(e3, t3 = "kilometers") {\n              let r4 = bZ[t3];\n              if (!r4) throw new Error(t3 + " units is invalid");\n              return e3 * r4;\n            }\n            function SZ(e3, t3 = "kilometers") {\n              let r4 = bZ[t3];\n              if (!r4) throw new Error(t3 + " units is invalid");\n              return e3 / r4;\n            }\n            function bFt(e3, t3) {\n              return KRe(SZ(e3, t3));\n            }\n            function wFt(e3) {\n              let t3 = e3 % 360;\n              return t3 < 0 && (t3 += 360), t3;\n            }\n            function TFt(e3) {\n              return e3 = e3 % 360, e3 > 180 ? e3 - 360 : e3 < -180 ? e3 + 360 : e3;\n            }\n            function KRe(e3) {\n              return e3 % (2 * Math.PI) * 180 / Math.PI;\n            }\n            function AFt(e3) {\n              return e3 % 360 * Math.PI / 180;\n            }\n            function SFt(e3, t3 = "kilometers", r4 = "kilometers") {\n              if (!(e3 >= 0)) throw new Error("length must be a positive number");\n              return YRe(SZ(e3, t3), r4);\n            }\n            function MFt(e3, t3 = "meters", r4 = "kilometers") {\n              if (!(e3 >= 0)) throw new Error("area must be a positive number");\n              let n4 = xZ[t3];\n              if (!n4) throw new Error("invalid original units");\n              let i3 = xZ[r4];\n              if (!i3) throw new Error("invalid final units");\n              return e3 / n4 * i3;\n            }\n            function yF(e3) {\n              return !isNaN(e3) && e3 !== null && !Array.isArray(e3);\n            }\n            function EFt(e3) {\n              return e3 !== null && typeof e3 == "object" && !Array.isArray(e3);\n            }\n            function kFt(e3) {\n              if (!e3) throw new Error("bbox is required");\n              if (!Array.isArray(e3)) throw new Error("bbox must be an Array");\n              if (e3.length !== 4 && e3.length !== 6) throw new Error("bbox must be an Array of 4 or 6 numbers");\n              e3.forEach((t3) => {\n                if (!yF(t3)) throw new Error("bbox must only contain numbers");\n              });\n            }\n            function CFt(e3) {\n              if (!e3) throw new Error("id is required");\n              if (["string", "number"].indexOf(typeof e3) === -1) throw new Error("id must be a number or a string");\n            }\n            ic.areaFactors = xZ;\n            ic.azimuthToBearing = TFt;\n            ic.bearingToAzimuth = wFt;\n            ic.convertArea = MFt;\n            ic.convertLength = SFt;\n            ic.degreesToRadians = AFt;\n            ic.earthRadius = Op;\n            ic.factors = bZ;\n            ic.feature = rx;\n            ic.featureCollection = _F;\n            ic.geometry = pFt;\n            ic.geometryCollection = _Ft;\n            ic.isNumber = yF;\n            ic.isObject = EFt;\n            ic.lengthToDegrees = bFt;\n            ic.lengthToRadians = SZ;\n            ic.lineString = AZ;\n            ic.lineStrings = yFt;\n            ic.multiLineString = WRe;\n            ic.multiPoint = XRe;\n            ic.multiPolygon = ZRe;\n            ic.point = wZ;\n            ic.points = gFt;\n            ic.polygon = TZ;\n            ic.polygons = mFt;\n            ic.radiansToDegrees = KRe;\n            ic.radiansToLength = YRe;\n            ic.round = xFt;\n            ic.validateBBox = kFt;\n            ic.validateId = CFt;\n          });\n          var wF = ye((qd) => {\n            "use strict";\n            Object.defineProperty(qd, "__esModule", { value: true });\n            var Wv = xF();\n            function ik(e3, t3, r4) {\n              if (e3 !== null) for (var n4, i3, a4, o4, s3, l3, u4, c5 = 0, f4 = 0, h3, d3 = e3.type, v3 = d3 === "FeatureCollection", _2 = d3 === "Feature", b = v3 ? e3.features.length : 1, p3 = 0; p3 < b; p3++) {\n                u4 = v3 ? e3.features[p3].geometry : _2 ? e3.geometry : e3, h3 = u4 ? u4.type === "GeometryCollection" : false, s3 = h3 ? u4.geometries.length : 1;\n                for (var k4 = 0; k4 < s3; k4++) {\n                  var E3 = 0, S2 = 0;\n                  if (o4 = h3 ? u4.geometries[k4] : u4, o4 !== null) {\n                    l3 = o4.coordinates;\n                    var L3 = o4.type;\n                    switch (c5 = r4 && (L3 === "Polygon" || L3 === "MultiPolygon") ? 1 : 0, L3) {\n                      case null:\n                        break;\n                      case "Point":\n                        if (t3(l3, f4, p3, E3, S2) === false) return false;\n                        f4++, E3++;\n                        break;\n                      case "LineString":\n                      case "MultiPoint":\n                        for (n4 = 0; n4 < l3.length; n4++) {\n                          if (t3(l3[n4], f4, p3, E3, S2) === false) return false;\n                          f4++, L3 === "MultiPoint" && E3++;\n                        }\n                        L3 === "LineString" && E3++;\n                        break;\n                      case "Polygon":\n                      case "MultiLineString":\n                        for (n4 = 0; n4 < l3.length; n4++) {\n                          for (i3 = 0; i3 < l3[n4].length - c5; i3++) {\n                            if (t3(l3[n4][i3], f4, p3, E3, S2) === false) return false;\n                            f4++;\n                          }\n                          L3 === "MultiLineString" && E3++, L3 === "Polygon" && S2++;\n                        }\n                        L3 === "Polygon" && E3++;\n                        break;\n                      case "MultiPolygon":\n                        for (n4 = 0; n4 < l3.length; n4++) {\n                          for (S2 = 0, i3 = 0; i3 < l3[n4].length; i3++) {\n                            for (a4 = 0; a4 < l3[n4][i3].length - c5; a4++) {\n                              if (t3(l3[n4][i3][a4], f4, p3, E3, S2) === false) return false;\n                              f4++;\n                            }\n                            S2++;\n                          }\n                          E3++;\n                        }\n                        break;\n                      case "GeometryCollection":\n                        for (n4 = 0; n4 < o4.geometries.length; n4++) if (ik(o4.geometries[n4], t3, r4) === false) return false;\n                        break;\n                      default:\n                        throw new Error("Unknown Geometry Type");\n                    }\n                  }\n                }\n              }\n            }\n            function LFt(e3, t3, r4, n4) {\n              var i3 = r4;\n              return ik(e3, function(a4, o4, s3, l3, u4) {\n                o4 === 0 && r4 === void 0 ? i3 = a4 : i3 = t3(i3, a4, o4, s3, l3, u4);\n              }, n4), i3;\n            }\n            function JRe(e3, t3) {\n              var r4;\n              switch (e3.type) {\n                case "FeatureCollection":\n                  for (r4 = 0; r4 < e3.features.length && t3(e3.features[r4].properties, r4) !== false; r4++) ;\n                  break;\n                case "Feature":\n                  t3(e3.properties, 0);\n                  break;\n              }\n            }\n            function PFt(e3, t3, r4) {\n              var n4 = r4;\n              return JRe(e3, function(i3, a4) {\n                a4 === 0 && r4 === void 0 ? n4 = i3 : n4 = t3(n4, i3, a4);\n              }), n4;\n            }\n            function $Re(e3, t3) {\n              if (e3.type === "Feature") t3(e3, 0);\n              else if (e3.type === "FeatureCollection") for (var r4 = 0; r4 < e3.features.length && t3(e3.features[r4], r4) !== false; r4++) ;\n            }\n            function IFt(e3, t3, r4) {\n              var n4 = r4;\n              return $Re(e3, function(i3, a4) {\n                a4 === 0 && r4 === void 0 ? n4 = i3 : n4 = t3(n4, i3, a4);\n              }), n4;\n            }\n            function RFt(e3) {\n              var t3 = [];\n              return ik(e3, function(r4) {\n                t3.push(r4);\n              }), t3;\n            }\n            function MZ(e3, t3) {\n              var r4, n4, i3, a4, o4, s3, l3, u4, c5, f4, h3 = 0, d3 = e3.type === "FeatureCollection", v3 = e3.type === "Feature", _2 = d3 ? e3.features.length : 1;\n              for (r4 = 0; r4 < _2; r4++) {\n                for (s3 = d3 ? e3.features[r4].geometry : v3 ? e3.geometry : e3, u4 = d3 ? e3.features[r4].properties : v3 ? e3.properties : {}, c5 = d3 ? e3.features[r4].bbox : v3 ? e3.bbox : void 0, f4 = d3 ? e3.features[r4].id : v3 ? e3.id : void 0, l3 = s3 ? s3.type === "GeometryCollection" : false, o4 = l3 ? s3.geometries.length : 1, i3 = 0; i3 < o4; i3++) {\n                  if (a4 = l3 ? s3.geometries[i3] : s3, a4 === null) {\n                    if (t3(null, h3, u4, c5, f4) === false) return false;\n                    continue;\n                  }\n                  switch (a4.type) {\n                    case "Point":\n                    case "LineString":\n                    case "MultiPoint":\n                    case "Polygon":\n                    case "MultiLineString":\n                    case "MultiPolygon": {\n                      if (t3(a4, h3, u4, c5, f4) === false) return false;\n                      break;\n                    }\n                    case "GeometryCollection": {\n                      for (n4 = 0; n4 < a4.geometries.length; n4++) if (t3(a4.geometries[n4], h3, u4, c5, f4) === false) return false;\n                      break;\n                    }\n                    default:\n                      throw new Error("Unknown Geometry Type");\n                  }\n                }\n                h3++;\n              }\n            }\n            function DFt(e3, t3, r4) {\n              var n4 = r4;\n              return MZ(e3, function(i3, a4, o4, s3, l3) {\n                a4 === 0 && r4 === void 0 ? n4 = i3 : n4 = t3(n4, i3, a4, o4, s3, l3);\n              }), n4;\n            }\n            function bF(e3, t3) {\n              MZ(e3, function(r4, n4, i3, a4, o4) {\n                var s3 = r4 === null ? null : r4.type;\n                switch (s3) {\n                  case null:\n                  case "Point":\n                  case "LineString":\n                  case "Polygon":\n                    return t3(Wv.feature.call(void 0, r4, i3, { bbox: a4, id: o4 }), n4, 0) === false ? false : void 0;\n                }\n                var l3;\n                switch (s3) {\n                  case "MultiPoint":\n                    l3 = "Point";\n                    break;\n                  case "MultiLineString":\n                    l3 = "LineString";\n                    break;\n                  case "MultiPolygon":\n                    l3 = "Polygon";\n                    break;\n                }\n                for (var u4 = 0; u4 < r4.coordinates.length; u4++) {\n                  var c5 = r4.coordinates[u4], f4 = { type: l3, coordinates: c5 };\n                  if (t3(Wv.feature.call(void 0, f4, i3), n4, u4) === false) return false;\n                }\n              });\n            }\n            function FFt(e3, t3, r4) {\n              var n4 = r4;\n              return bF(e3, function(i3, a4, o4) {\n                a4 === 0 && o4 === 0 && r4 === void 0 ? n4 = i3 : n4 = t3(n4, i3, a4, o4);\n              }), n4;\n            }\n            function QRe(e3, t3) {\n              bF(e3, function(r4, n4, i3) {\n                var a4 = 0;\n                if (r4.geometry) {\n                  var o4 = r4.geometry.type;\n                  if (!(o4 === "Point" || o4 === "MultiPoint")) {\n                    var s3, l3 = 0, u4 = 0, c5 = 0;\n                    if (ik(r4, function(f4, h3, d3, v3, _2) {\n                      if (s3 === void 0 || n4 > l3 || v3 > u4 || _2 > c5) {\n                        s3 = f4, l3 = n4, u4 = v3, c5 = _2, a4 = 0;\n                        return;\n                      }\n                      var b = Wv.lineString.call(void 0, [s3, f4], r4.properties);\n                      if (t3(b, n4, i3, _2, a4) === false) return false;\n                      a4++, s3 = f4;\n                    }) === false) return false;\n                  }\n                }\n              });\n            }\n            function zFt(e3, t3, r4) {\n              var n4 = r4, i3 = false;\n              return QRe(e3, function(a4, o4, s3, l3, u4) {\n                i3 === false && r4 === void 0 ? n4 = a4 : n4 = t3(n4, a4, o4, s3, l3, u4), i3 = true;\n              }), n4;\n            }\n            function eDe(e3, t3) {\n              if (!e3) throw new Error("geojson is required");\n              bF(e3, function(r4, n4, i3) {\n                if (r4.geometry !== null) {\n                  var a4 = r4.geometry.type, o4 = r4.geometry.coordinates;\n                  switch (a4) {\n                    case "LineString":\n                      if (t3(r4, n4, i3, 0, 0) === false) return false;\n                      break;\n                    case "Polygon":\n                      for (var s3 = 0; s3 < o4.length; s3++) if (t3(Wv.lineString.call(void 0, o4[s3], r4.properties), n4, i3, s3) === false) return false;\n                      break;\n                  }\n                }\n              });\n            }\n            function OFt(e3, t3, r4) {\n              var n4 = r4;\n              return eDe(e3, function(i3, a4, o4, s3) {\n                a4 === 0 && r4 === void 0 ? n4 = i3 : n4 = t3(n4, i3, a4, o4, s3);\n              }), n4;\n            }\n            function qFt(e3, t3) {\n              if (t3 = t3 || {}, !Wv.isObject.call(void 0, t3)) throw new Error("options is invalid");\n              var r4 = t3.featureIndex || 0, n4 = t3.multiFeatureIndex || 0, i3 = t3.geometryIndex || 0, a4 = t3.segmentIndex || 0, o4 = t3.properties, s3;\n              switch (e3.type) {\n                case "FeatureCollection":\n                  r4 < 0 && (r4 = e3.features.length + r4), o4 = o4 || e3.features[r4].properties, s3 = e3.features[r4].geometry;\n                  break;\n                case "Feature":\n                  o4 = o4 || e3.properties, s3 = e3.geometry;\n                  break;\n                case "Point":\n                case "MultiPoint":\n                  return null;\n                case "LineString":\n                case "Polygon":\n                case "MultiLineString":\n                case "MultiPolygon":\n                  s3 = e3;\n                  break;\n                default:\n                  throw new Error("geojson is invalid");\n              }\n              if (s3 === null) return null;\n              var l3 = s3.coordinates;\n              switch (s3.type) {\n                case "Point":\n                case "MultiPoint":\n                  return null;\n                case "LineString":\n                  return a4 < 0 && (a4 = l3.length + a4 - 1), Wv.lineString.call(void 0, [l3[a4], l3[a4 + 1]], o4, t3);\n                case "Polygon":\n                  return i3 < 0 && (i3 = l3.length + i3), a4 < 0 && (a4 = l3[i3].length + a4 - 1), Wv.lineString.call(void 0, [l3[i3][a4], l3[i3][a4 + 1]], o4, t3);\n                case "MultiLineString":\n                  return n4 < 0 && (n4 = l3.length + n4), a4 < 0 && (a4 = l3[n4].length + a4 - 1), Wv.lineString.call(void 0, [l3[n4][a4], l3[n4][a4 + 1]], o4, t3);\n                case "MultiPolygon":\n                  return n4 < 0 && (n4 = l3.length + n4), i3 < 0 && (i3 = l3[n4].length + i3), a4 < 0 && (a4 = l3[n4][i3].length - a4 - 1), Wv.lineString.call(void 0, [l3[n4][i3][a4], l3[n4][i3][a4 + 1]], o4, t3);\n              }\n              throw new Error("geojson is invalid");\n            }\n            function BFt(e3, t3) {\n              if (t3 = t3 || {}, !Wv.isObject.call(void 0, t3)) throw new Error("options is invalid");\n              var r4 = t3.featureIndex || 0, n4 = t3.multiFeatureIndex || 0, i3 = t3.geometryIndex || 0, a4 = t3.coordIndex || 0, o4 = t3.properties, s3;\n              switch (e3.type) {\n                case "FeatureCollection":\n                  r4 < 0 && (r4 = e3.features.length + r4), o4 = o4 || e3.features[r4].properties, s3 = e3.features[r4].geometry;\n                  break;\n                case "Feature":\n                  o4 = o4 || e3.properties, s3 = e3.geometry;\n                  break;\n                case "Point":\n                case "MultiPoint":\n                  return null;\n                case "LineString":\n                case "Polygon":\n                case "MultiLineString":\n                case "MultiPolygon":\n                  s3 = e3;\n                  break;\n                default:\n                  throw new Error("geojson is invalid");\n              }\n              if (s3 === null) return null;\n              var l3 = s3.coordinates;\n              switch (s3.type) {\n                case "Point":\n                  return Wv.point.call(void 0, l3, o4, t3);\n                case "MultiPoint":\n                  return n4 < 0 && (n4 = l3.length + n4), Wv.point.call(void 0, l3[n4], o4, t3);\n                case "LineString":\n                  return a4 < 0 && (a4 = l3.length + a4), Wv.point.call(void 0, l3[a4], o4, t3);\n                case "Polygon":\n                  return i3 < 0 && (i3 = l3.length + i3), a4 < 0 && (a4 = l3[i3].length + a4), Wv.point.call(void 0, l3[i3][a4], o4, t3);\n                case "MultiLineString":\n                  return n4 < 0 && (n4 = l3.length + n4), a4 < 0 && (a4 = l3[n4].length + a4), Wv.point.call(void 0, l3[n4][a4], o4, t3);\n                case "MultiPolygon":\n                  return n4 < 0 && (n4 = l3.length + n4), i3 < 0 && (i3 = l3[n4].length + i3), a4 < 0 && (a4 = l3[n4][i3].length - a4), Wv.point.call(void 0, l3[n4][i3][a4], o4, t3);\n              }\n              throw new Error("geojson is invalid");\n            }\n            qd.coordAll = RFt;\n            qd.coordEach = ik;\n            qd.coordReduce = LFt;\n            qd.featureEach = $Re;\n            qd.featureReduce = IFt;\n            qd.findPoint = BFt;\n            qd.findSegment = qFt;\n            qd.flattenEach = bF;\n            qd.flattenReduce = FFt;\n            qd.geomEach = MZ;\n            qd.geomReduce = DFt;\n            qd.lineEach = eDe;\n            qd.lineReduce = OFt;\n            qd.propEach = JRe;\n            qd.propReduce = PFt;\n            qd.segmentEach = QRe;\n            qd.segmentReduce = zFt;\n          });\n          var aDe = ye((TF) => {\n            "use strict";\n            Object.defineProperty(TF, "__esModule", { value: true });\n            var tDe = xF(), NFt = wF();\n            function nDe(e3) {\n              return NFt.geomReduce.call(void 0, e3, (t3, r4) => t3 + UFt(r4), 0);\n            }\n            function UFt(e3) {\n              let t3 = 0, r4;\n              switch (e3.type) {\n                case "Polygon":\n                  return rDe(e3.coordinates);\n                case "MultiPolygon":\n                  for (r4 = 0; r4 < e3.coordinates.length; r4++) t3 += rDe(e3.coordinates[r4]);\n                  return t3;\n                case "Point":\n                case "MultiPoint":\n                case "LineString":\n                case "MultiLineString":\n                  return 0;\n              }\n              return 0;\n            }\n            function rDe(e3) {\n              let t3 = 0;\n              if (e3 && e3.length > 0) {\n                t3 += Math.abs(iDe(e3[0]));\n                for (let r4 = 1; r4 < e3.length; r4++) t3 -= Math.abs(iDe(e3[r4]));\n              }\n              return t3;\n            }\n            var VFt = tDe.earthRadius * tDe.earthRadius / 2, EZ = Math.PI / 180;\n            function iDe(e3) {\n              let t3 = e3.length - 1;\n              if (t3 <= 2) return 0;\n              let r4 = 0, n4 = 0;\n              for (; n4 < t3; ) {\n                let i3 = e3[n4], a4 = e3[n4 + 1 === t3 ? 0 : n4 + 1], o4 = e3[n4 + 2 >= t3 ? (n4 + 2) % t3 : n4 + 2], s3 = i3[0] * EZ, l3 = a4[1] * EZ, u4 = o4[0] * EZ;\n                r4 += (u4 - s3) * Math.sin(l3), n4++;\n              }\n              return r4 * VFt;\n            }\n            var GFt = nDe;\n            TF.area = nDe;\n            TF.default = GFt;\n          });\n          var sDe = ye((AF) => {\n            "use strict";\n            Object.defineProperty(AF, "__esModule", { value: true });\n            var HFt = xF(), jFt = wF();\n            function oDe(e3, t3 = {}) {\n              let r4 = 0, n4 = 0, i3 = 0;\n              return jFt.coordEach.call(void 0, e3, function(a4) {\n                r4 += a4[0], n4 += a4[1], i3++;\n              }, true), HFt.point.call(void 0, [r4 / i3, n4 / i3], t3.properties);\n            }\n            var WFt = oDe;\n            AF.centroid = oDe;\n            AF.default = WFt;\n          });\n          var uDe = ye((SF) => {\n            "use strict";\n            Object.defineProperty(SF, "__esModule", { value: true });\n            var XFt = wF();\n            function lDe(e3, t3 = {}) {\n              if (e3.bbox != null && t3.recompute !== true) return e3.bbox;\n              let r4 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];\n              return XFt.coordEach.call(void 0, e3, (n4) => {\n                r4[0] > n4[0] && (r4[0] = n4[0]), r4[1] > n4[1] && (r4[1] = n4[1]), r4[2] < n4[0] && (r4[2] = n4[0]), r4[3] < n4[1] && (r4[3] = n4[1]);\n              }), r4;\n            }\n            var ZFt = lDe;\n            SF.bbox = lDe;\n            SF.default = ZFt;\n          });\n          var ix = ye((vmr, vDe) => {\n            "use strict";\n            var YFt = Oa(), hDe = jRe(), { area: KFt } = aDe(), { centroid: JFt } = sDe(), { bbox: $Ft } = uDe(), cDe = HS(), JA = G1(), QFt = my(), ezt = PS(), MF = kM(), fDe = Object.keys(hDe), tzt = { "ISO-3": cDe, "USA-states": cDe, "country names": rzt };\n            function rzt(e3) {\n              for (var t3 = 0; t3 < fDe.length; t3++) {\n                var r4 = fDe[t3], n4 = new RegExp(hDe[r4]);\n                if (n4.test(e3.trim().toLowerCase())) return r4;\n              }\n              return JA.log("Unrecognized country name: " + e3 + "."), false;\n            }\n            function izt(e3, t3, r4) {\n              if (!t3 || typeof t3 != "string") return false;\n              var n4 = tzt[e3](t3), i3, a4, o4;\n              if (n4) {\n                if (e3 === "USA-states") for (i3 = [], o4 = 0; o4 < r4.length; o4++) a4 = r4[o4], a4.properties && a4.properties.gu && a4.properties.gu === "USA" && i3.push(a4);\n                else i3 = r4;\n                for (o4 = 0; o4 < i3.length; o4++) if (a4 = i3[o4], a4.id === n4) return a4;\n                JA.log(["Location with id", n4, "does not have a matching topojson feature at this resolution."].join(" "));\n              }\n              return false;\n            }\n            function nzt(e3) {\n              var t3 = e3.geometry, r4 = t3.coordinates, n4 = e3.id, i3 = [], a4, o4, s3, l3;\n              function u4(c5) {\n                for (var f4 = 0; f4 < c5.length - 1; f4++) if (c5[f4][0] > 0 && c5[f4 + 1][0] < 0) return f4;\n                return null;\n              }\n              switch (n4 === "RUS" || n4 === "FJI" ? a4 = function(c5) {\n                var f4;\n                if (u4(c5) === null) f4 = c5;\n                else for (f4 = new Array(c5.length), l3 = 0; l3 < c5.length; l3++) f4[l3] = [c5[l3][0] < 0 ? c5[l3][0] + 360 : c5[l3][0], c5[l3][1]];\n                i3.push(MF.tester(f4));\n              } : n4 === "ATA" ? a4 = function(c5) {\n                var f4 = u4(c5);\n                if (f4 === null) return i3.push(MF.tester(c5));\n                var h3 = new Array(c5.length + 1), d3 = 0;\n                for (l3 = 0; l3 < c5.length; l3++) l3 > f4 ? h3[d3++] = [c5[l3][0] + 360, c5[l3][1]] : l3 === f4 ? (h3[d3++] = c5[l3], h3[d3++] = [c5[l3][0], -90]) : h3[d3++] = c5[l3];\n                var v3 = MF.tester(h3);\n                v3.pts.pop(), i3.push(v3);\n              } : a4 = function(c5) {\n                i3.push(MF.tester(c5));\n              }, t3.type) {\n                case "MultiPolygon":\n                  for (o4 = 0; o4 < r4.length; o4++) for (s3 = 0; s3 < r4[o4].length; s3++) a4(r4[o4][s3]);\n                  break;\n                case "Polygon":\n                  for (o4 = 0; o4 < r4.length; o4++) a4(r4[o4]);\n                  break;\n              }\n              return i3;\n            }\n            function dDe(e3) {\n              var t3 = e3.geojson, r4 = window.PlotlyGeoAssets || {}, n4 = typeof t3 == "string" ? r4[t3] : t3;\n              return QFt(n4) ? n4 : (JA.error("Oops ... something went wrong when fetching " + t3), false);\n            }\n            function azt(e3) {\n              var t3 = e3[0].trace, r4 = dDe(t3);\n              if (!r4) return false;\n              var n4 = {}, i3 = [], a4;\n              for (a4 = 0; a4 < t3._length; a4++) {\n                var o4 = e3[a4];\n                (o4.loc || o4.loc === 0) && (n4[o4.loc] = o4);\n              }\n              function s3(c5) {\n                var f4 = ezt(c5, t3.featureidkey || "id").get(), h3 = n4[f4];\n                if (h3) {\n                  var d3 = c5.geometry;\n                  if (d3.type === "Polygon" || d3.type === "MultiPolygon") {\n                    var v3 = { type: "Feature", id: f4, geometry: d3, properties: {} };\n                    v3.geometry.coordinates.length > 0 ? v3.properties.ct = ozt(v3) : v3.properties.ct = [NaN, NaN], h3.fIn = c5, h3.fOut = v3, i3.push(v3);\n                  } else JA.log(["Location", h3.loc, "does not have a valid GeoJSON geometry.", "Traces with locationmode *geojson-id* only support", "*Polygon* and *MultiPolygon* geometries."].join(" "));\n                }\n                delete n4[f4];\n              }\n              switch (r4.type) {\n                case "FeatureCollection":\n                  var l3 = r4.features;\n                  for (a4 = 0; a4 < l3.length; a4++) s3(l3[a4]);\n                  break;\n                case "Feature":\n                  s3(r4);\n                  break;\n                default:\n                  return JA.warn(["Invalid GeoJSON type", (r4.type || "none") + ".", "Traces with locationmode *geojson-id* only support", "*FeatureCollection* and *Feature* types."].join(" ")), false;\n              }\n              for (var u4 in n4) JA.log(["Location *" + u4 + "*", "does not have a matching feature with id-key", "*" + t3.featureidkey + "*."].join(" "));\n              return i3;\n            }\n            function ozt(e3) {\n              var t3 = e3.geometry, r4;\n              if (t3.type === "MultiPolygon") for (var n4 = t3.coordinates, i3 = 0, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = { type: "Polygon", coordinates: n4[a4] }, s3 = KFt(o4);\n                s3 > i3 && (i3 = s3, r4 = o4);\n              }\n              else r4 = t3;\n              return JFt(r4).geometry.coordinates;\n            }\n            function szt(e3) {\n              var t3 = window.PlotlyGeoAssets || {}, r4 = [];\n              function n4(l3) {\n                return new Promise(function(u4, c5) {\n                  YFt.json(l3, function(f4, h3) {\n                    if (f4) {\n                      delete t3[l3];\n                      var d3 = f4.status === 404 ? \'GeoJSON at URL "\' + l3 + \'" does not exist.\' : "Unexpected error while fetching from " + l3;\n                      return c5(new Error(d3));\n                    }\n                    return t3[l3] = h3, u4(h3);\n                  });\n                });\n              }\n              function i3(l3) {\n                return new Promise(function(u4, c5) {\n                  var f4 = 0, h3 = setInterval(function() {\n                    if (t3[l3] && t3[l3] !== "pending") return clearInterval(h3), u4(t3[l3]);\n                    if (f4 > 100) return clearInterval(h3), c5("Unexpected error while fetching from " + l3);\n                    f4++;\n                  }, 50);\n                });\n              }\n              for (var a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4][0].trace, s3 = o4.geojson;\n                typeof s3 == "string" && (t3[s3] ? t3[s3] === "pending" && r4.push(i3(s3)) : (t3[s3] = "pending", r4.push(n4(s3))));\n              }\n              return r4;\n            }\n            function lzt(e3) {\n              return $Ft(e3);\n            }\n            vDe.exports = { locationToFeature: izt, feature2polygons: nzt, getTraceGeojson: dDe, extractTraceFeature: azt, fetchTraceGeoData: szt, computeBbox: lzt };\n          });\n          var kZ = ye((pmr, mDe) => {\n            "use strict";\n            var uzt = Oa(), czt = So(), pDe = ka(), gDe = op(), fzt = gDe.stylePoints, hzt = gDe.styleText;\n            mDe.exports = function(t3, r4) {\n              r4 && dzt(t3, r4);\n            };\n            function dzt(e3, t3) {\n              var r4 = t3[0].trace, n4 = t3[0].node3;\n              n4.style("opacity", t3[0].trace.opacity), fzt(n4, r4, e3), hzt(n4, r4, e3), n4.selectAll("path.js-line").style("fill", "none").each(function(i3) {\n                var a4 = uzt.select(this), o4 = i3.trace, s3 = o4.line || {};\n                a4.call(pDe.stroke, s3.color).call(czt.dashLine, s3.dash || "", s3.width || 0), o4.fill !== "none" && a4.call(pDe.fill, o4.fillcolor);\n              });\n            }\n          });\n          var IZ = ye((gmr, xDe) => {\n            "use strict";\n            var yDe = Oa(), kF = Dr(), vzt = mF().getTopojsonFeatures, CZ = tx(), EF = ix(), _De = Ag().findExtremes, PZ = fs().BADNUM, pzt = O0().calcMarkerSize, LZ = Ru(), gzt = kZ();\n            function mzt(e3, t3, r4) {\n              var n4 = t3.layers.frontplot.select(".scatterlayer"), i3 = kF.makeTraceGroups(n4, r4, "trace scattergeo");\n              function a4(o4, s3) {\n                o4.lonlat[0] === PZ && yDe.select(s3).remove();\n              }\n              i3.selectAll("*").remove(), i3.each(function(o4) {\n                var s3 = yDe.select(this), l3 = o4[0].trace;\n                if (LZ.hasLines(l3) || l3.fill !== "none") {\n                  var u4 = CZ.calcTraceToLineCoords(o4), c5 = l3.fill !== "none" ? CZ.makePolygon(u4) : CZ.makeLine(u4);\n                  s3.selectAll("path.js-line").data([{ geojson: c5, trace: l3 }]).enter().append("path").classed("js-line", true).style("stroke-miterlimit", 2);\n                }\n                LZ.hasMarkers(l3) && s3.selectAll("path.point").data(kF.identity).enter().append("path").classed("point", true).each(function(f4) {\n                  a4(f4, this);\n                }), LZ.hasText(l3) && s3.selectAll("g").data(kF.identity).enter().append("g").append("text").each(function(f4) {\n                  a4(f4, this);\n                }), gzt(e3, o4);\n              });\n            }\n            function yzt(e3, t3) {\n              var r4 = e3[0].trace, n4 = t3[r4.geo], i3 = n4._subplot, a4 = r4._length, o4, s3;\n              if (kF.isArrayOrTypedArray(r4.locations)) {\n                var l3 = r4.locationmode, u4 = l3 === "geojson-id" ? EF.extractTraceFeature(e3) : vzt(r4, i3.topojson);\n                for (o4 = 0; o4 < a4; o4++) {\n                  s3 = e3[o4];\n                  var c5 = l3 === "geojson-id" ? s3.fOut : EF.locationToFeature(l3, s3.loc, u4);\n                  s3.lonlat = c5 ? c5.properties.ct : [PZ, PZ];\n                }\n              }\n              var f4 = { padded: true }, h3, d3;\n              if (n4.fitbounds === "geojson" && r4.locationmode === "geojson-id") {\n                var v3 = EF.computeBbox(EF.getTraceGeojson(r4));\n                h3 = [v3[0], v3[2]], d3 = [v3[1], v3[3]];\n              } else {\n                for (h3 = new Array(a4), d3 = new Array(a4), o4 = 0; o4 < a4; o4++) s3 = e3[o4], h3[o4] = s3.lonlat[0], d3[o4] = s3.lonlat[1];\n                f4.ppad = pzt(r4, a4);\n              }\n              r4._extremes.lon = _De(n4.lonaxis._ax, h3, f4), r4._extremes.lat = _De(n4.lataxis._ax, d3, f4);\n            }\n            xDe.exports = { calcGeoJSON: yzt, plot: mzt };\n          });\n          var wDe = ye((mmr, bDe) => {\n            "use strict";\n            var _zt = vf(), xzt = fs().BADNUM, bzt = cT(), wzt = Dr().fillText, Tzt = j22();\n            bDe.exports = function(t3, r4, n4) {\n              var i3 = t3.cd, a4 = i3[0].trace, o4 = t3.xa, s3 = t3.ya, l3 = t3.subplot, u4 = l3.projection.isLonLatOverEdges, c5 = l3.project;\n              function f4(k4) {\n                var E3 = k4.lonlat;\n                if (E3[0] === xzt || u4(E3)) return 1 / 0;\n                var S2 = c5(E3), L3 = c5([r4, n4]), x2 = Math.abs(S2[0] - L3[0]), C3 = Math.abs(S2[1] - L3[1]), M4 = Math.max(3, k4.mrc || 0);\n                return Math.max(Math.sqrt(x2 * x2 + C3 * C3) - M4, 1 - 3 / M4);\n              }\n              if (_zt.getClosest(i3, f4, t3), t3.index !== false) {\n                var h3 = i3[t3.index], d3 = h3.lonlat, v3 = [o4.c2p(d3), s3.c2p(d3)], _2 = h3.mrc || 1;\n                t3.x0 = v3[0] - _2, t3.x1 = v3[0] + _2, t3.y0 = v3[1] - _2, t3.y1 = v3[1] + _2, t3.loc = h3.loc, t3.lon = d3[0], t3.lat = d3[1];\n                var b = {};\n                b[a4.geo] = { _subplot: l3 };\n                var p3 = a4._module.formatLabels(h3, a4, b);\n                return t3.lonLabel = p3.lonLabel, t3.latLabel = p3.latLabel, t3.color = bzt(a4, h3), t3.extraText = Azt(a4, h3, t3, i3[0].t.labels), t3.hovertemplate = a4.hovertemplate, [t3];\n              }\n            };\n            function Azt(e3, t3, r4, n4) {\n              if (e3.hovertemplate) return;\n              var i3 = t3.hi || e3.hoverinfo, a4 = i3 === "all" ? Tzt.hoverinfo.flags : i3.split("+"), o4 = a4.indexOf("location") !== -1 && Array.isArray(e3.locations), s3 = a4.indexOf("lon") !== -1, l3 = a4.indexOf("lat") !== -1, u4 = a4.indexOf("text") !== -1, c5 = [];\n              function f4(h3) {\n                return h3 + "\\xB0";\n              }\n              return o4 ? c5.push(t3.loc) : s3 && l3 ? c5.push("(" + f4(r4.latLabel) + ", " + f4(r4.lonLabel) + ")") : s3 ? c5.push(n4.lon + f4(r4.lonLabel)) : l3 && c5.push(n4.lat + f4(r4.latLabel)), u4 && wzt(t3, e3, c5), c5.join("<br>");\n            }\n          });\n          var ADe = ye((ymr, TDe) => {\n            "use strict";\n            TDe.exports = function(t3, r4, n4, i3, a4) {\n              t3.lon = r4.lon, t3.lat = r4.lat, t3.location = r4.loc ? r4.loc : null;\n              var o4 = i3[a4];\n              return o4.fIn && o4.fIn.properties && (t3.properties = o4.fIn.properties), t3;\n            };\n          });\n          var EDe = ye((_mr, MDe) => {\n            "use strict";\n            var SDe = Ru(), Szt = fs().BADNUM;\n            MDe.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3 = n4[0].trace, l3, u4, c5, f4, h3, d3 = !SDe.hasMarkers(s3) && !SDe.hasText(s3);\n              if (d3) return [];\n              if (r4 === false) for (h3 = 0; h3 < n4.length; h3++) n4[h3].selected = 0;\n              else for (h3 = 0; h3 < n4.length; h3++) l3 = n4[h3], u4 = l3.lonlat, u4[0] !== Szt && (c5 = i3.c2p(u4), f4 = a4.c2p(u4), r4.contains([c5, f4], null, h3, t3) ? (o4.push({ pointNumber: h3, lon: u4[0], lat: u4[1] }), l3.selected = 1) : l3.selected = 0);\n              return o4;\n            };\n          });\n          var nk = ye((CF, kDe) => {\n            (function(e3, t3) {\n              t3(typeof CF == "object" && typeof kDe != "undefined" ? CF : e3.d3 = e3.d3 || {});\n            })(CF, function(e3) {\n              "use strict";\n              function t3(Le, Ae) {\n                return Le < Ae ? -1 : Le > Ae ? 1 : Le >= Ae ? 0 : NaN;\n              }\n              function r4(Le) {\n                return Le.length === 1 && (Le = n4(Le)), { left: function(Ae, Fe, Pe, ge) {\n                  for (Pe == null && (Pe = 0), ge == null && (ge = Ae.length); Pe < ge; ) {\n                    var Re = Pe + ge >>> 1;\n                    Le(Ae[Re], Fe) < 0 ? Pe = Re + 1 : ge = Re;\n                  }\n                  return Pe;\n                }, right: function(Ae, Fe, Pe, ge) {\n                  for (Pe == null && (Pe = 0), ge == null && (ge = Ae.length); Pe < ge; ) {\n                    var Re = Pe + ge >>> 1;\n                    Le(Ae[Re], Fe) > 0 ? ge = Re : Pe = Re + 1;\n                  }\n                  return Pe;\n                } };\n              }\n              function n4(Le) {\n                return function(Ae, Fe) {\n                  return t3(Le(Ae), Fe);\n                };\n              }\n              var i3 = r4(t3), a4 = i3.right, o4 = i3.left;\n              function s3(Le, Ae) {\n                Ae == null && (Ae = l3);\n                for (var Fe = 0, Pe = Le.length - 1, ge = Le[0], Re = new Array(Pe < 0 ? 0 : Pe); Fe < Pe; ) Re[Fe] = Ae(ge, ge = Le[++Fe]);\n                return Re;\n              }\n              function l3(Le, Ae) {\n                return [Le, Ae];\n              }\n              function u4(Le, Ae, Fe) {\n                var Pe = Le.length, ge = Ae.length, Re = new Array(Pe * ge), ce, Ze, ut, pt;\n                for (Fe == null && (Fe = l3), ce = ut = 0; ce < Pe; ++ce) for (pt = Le[ce], Ze = 0; Ze < ge; ++Ze, ++ut) Re[ut] = Fe(pt, Ae[Ze]);\n                return Re;\n              }\n              function c5(Le, Ae) {\n                return Ae < Le ? -1 : Ae > Le ? 1 : Ae >= Le ? 0 : NaN;\n              }\n              function f4(Le) {\n                return Le === null ? NaN : +Le;\n              }\n              function h3(Le, Ae) {\n                var Fe = Le.length, Pe = 0, ge = -1, Re = 0, ce, Ze, ut = 0;\n                if (Ae == null) for (; ++ge < Fe; ) isNaN(ce = f4(Le[ge])) || (Ze = ce - Re, Re += Ze / ++Pe, ut += Ze * (ce - Re));\n                else for (; ++ge < Fe; ) isNaN(ce = f4(Ae(Le[ge], ge, Le))) || (Ze = ce - Re, Re += Ze / ++Pe, ut += Ze * (ce - Re));\n                if (Pe > 1) return ut / (Pe - 1);\n              }\n              function d3(Le, Ae) {\n                var Fe = h3(Le, Ae);\n                return Fe && Math.sqrt(Fe);\n              }\n              function v3(Le, Ae) {\n                var Fe = Le.length, Pe = -1, ge, Re, ce;\n                if (Ae == null) {\n                  for (; ++Pe < Fe; ) if ((ge = Le[Pe]) != null && ge >= ge) for (Re = ce = ge; ++Pe < Fe; ) (ge = Le[Pe]) != null && (Re > ge && (Re = ge), ce < ge && (ce = ge));\n                } else for (; ++Pe < Fe; ) if ((ge = Ae(Le[Pe], Pe, Le)) != null && ge >= ge) for (Re = ce = ge; ++Pe < Fe; ) (ge = Ae(Le[Pe], Pe, Le)) != null && (Re > ge && (Re = ge), ce < ge && (ce = ge));\n                return [Re, ce];\n              }\n              var _2 = Array.prototype, b = _2.slice, p3 = _2.map;\n              function k4(Le) {\n                return function() {\n                  return Le;\n                };\n              }\n              function E3(Le) {\n                return Le;\n              }\n              function S2(Le, Ae, Fe) {\n                Le = +Le, Ae = +Ae, Fe = (ge = arguments.length) < 2 ? (Ae = Le, Le = 0, 1) : ge < 3 ? 1 : +Fe;\n                for (var Pe = -1, ge = Math.max(0, Math.ceil((Ae - Le) / Fe)) | 0, Re = new Array(ge); ++Pe < ge; ) Re[Pe] = Le + Pe * Fe;\n                return Re;\n              }\n              var L3 = Math.sqrt(50), x2 = Math.sqrt(10), C3 = Math.sqrt(2);\n              function M4(Le, Ae, Fe) {\n                var Pe, ge = -1, Re, ce, Ze;\n                if (Ae = +Ae, Le = +Le, Fe = +Fe, Le === Ae && Fe > 0) return [Le];\n                if ((Pe = Ae < Le) && (Re = Le, Le = Ae, Ae = Re), (Ze = g3(Le, Ae, Fe)) === 0 || !isFinite(Ze)) return [];\n                if (Ze > 0) for (Le = Math.ceil(Le / Ze), Ae = Math.floor(Ae / Ze), ce = new Array(Re = Math.ceil(Ae - Le + 1)); ++ge < Re; ) ce[ge] = (Le + ge) * Ze;\n                else for (Le = Math.floor(Le * Ze), Ae = Math.ceil(Ae * Ze), ce = new Array(Re = Math.ceil(Le - Ae + 1)); ++ge < Re; ) ce[ge] = (Le - ge) / Ze;\n                return Pe && ce.reverse(), ce;\n              }\n              function g3(Le, Ae, Fe) {\n                var Pe = (Ae - Le) / Math.max(0, Fe), ge = Math.floor(Math.log(Pe) / Math.LN10), Re = Pe / Math.pow(10, ge);\n                return ge >= 0 ? (Re >= L3 ? 10 : Re >= x2 ? 5 : Re >= C3 ? 2 : 1) * Math.pow(10, ge) : -Math.pow(10, -ge) / (Re >= L3 ? 10 : Re >= x2 ? 5 : Re >= C3 ? 2 : 1);\n              }\n              function P3(Le, Ae, Fe) {\n                var Pe = Math.abs(Ae - Le) / Math.max(0, Fe), ge = Math.pow(10, Math.floor(Math.log(Pe) / Math.LN10)), Re = Pe / ge;\n                return Re >= L3 ? ge *= 10 : Re >= x2 ? ge *= 5 : Re >= C3 && (ge *= 2), Ae < Le ? -ge : ge;\n              }\n              function T3(Le) {\n                return Math.ceil(Math.log(Le.length) / Math.LN2) + 1;\n              }\n              function z3() {\n                var Le = E3, Ae = v3, Fe = T3;\n                function Pe(ge) {\n                  var Re, ce = ge.length, Ze, ut = new Array(ce);\n                  for (Re = 0; Re < ce; ++Re) ut[Re] = Le(ge[Re], Re, ge);\n                  var pt = Ae(ut), Zt = pt[0], st = pt[1], lt = Fe(ut, Zt, st);\n                  Array.isArray(lt) || (lt = P3(Zt, st, lt), lt = S2(Math.ceil(Zt / lt) * lt, st, lt));\n                  for (var Gt = lt.length; lt[0] <= Zt; ) lt.shift(), --Gt;\n                  for (; lt[Gt - 1] > st; ) lt.pop(), --Gt;\n                  var Nt = new Array(Gt + 1), Jt;\n                  for (Re = 0; Re <= Gt; ++Re) Jt = Nt[Re] = [], Jt.x0 = Re > 0 ? lt[Re - 1] : Zt, Jt.x1 = Re < Gt ? lt[Re] : st;\n                  for (Re = 0; Re < ce; ++Re) Ze = ut[Re], Zt <= Ze && Ze <= st && Nt[a4(lt, Ze, 0, Gt)].push(ge[Re]);\n                  return Nt;\n                }\n                return Pe.value = function(ge) {\n                  return arguments.length ? (Le = typeof ge == "function" ? ge : k4(ge), Pe) : Le;\n                }, Pe.domain = function(ge) {\n                  return arguments.length ? (Ae = typeof ge == "function" ? ge : k4([ge[0], ge[1]]), Pe) : Ae;\n                }, Pe.thresholds = function(ge) {\n                  return arguments.length ? (Fe = typeof ge == "function" ? ge : Array.isArray(ge) ? k4(b.call(ge)) : k4(ge), Pe) : Fe;\n                }, Pe;\n              }\n              function O3(Le, Ae, Fe) {\n                if (Fe == null && (Fe = f4), !!(Pe = Le.length)) {\n                  if ((Ae = +Ae) <= 0 || Pe < 2) return +Fe(Le[0], 0, Le);\n                  if (Ae >= 1) return +Fe(Le[Pe - 1], Pe - 1, Le);\n                  var Pe, ge = (Pe - 1) * Ae, Re = Math.floor(ge), ce = +Fe(Le[Re], Re, Le), Ze = +Fe(Le[Re + 1], Re + 1, Le);\n                  return ce + (Ze - ce) * (ge - Re);\n                }\n              }\n              function V2(Le, Ae, Fe) {\n                return Le = p3.call(Le, f4).sort(t3), Math.ceil((Fe - Ae) / (2 * (O3(Le, 0.75) - O3(Le, 0.25)) * Math.pow(Le.length, -1 / 3)));\n              }\n              function G2(Le, Ae, Fe) {\n                return Math.ceil((Fe - Ae) / (3.5 * d3(Le) * Math.pow(Le.length, -1 / 3)));\n              }\n              function Z(Le, Ae) {\n                var Fe = Le.length, Pe = -1, ge, Re;\n                if (Ae == null) {\n                  for (; ++Pe < Fe; ) if ((ge = Le[Pe]) != null && ge >= ge) for (Re = ge; ++Pe < Fe; ) (ge = Le[Pe]) != null && ge > Re && (Re = ge);\n                } else for (; ++Pe < Fe; ) if ((ge = Ae(Le[Pe], Pe, Le)) != null && ge >= ge) for (Re = ge; ++Pe < Fe; ) (ge = Ae(Le[Pe], Pe, Le)) != null && ge > Re && (Re = ge);\n                return Re;\n              }\n              function j3(Le, Ae) {\n                var Fe = Le.length, Pe = Fe, ge = -1, Re, ce = 0;\n                if (Ae == null) for (; ++ge < Fe; ) isNaN(Re = f4(Le[ge])) ? --Pe : ce += Re;\n                else for (; ++ge < Fe; ) isNaN(Re = f4(Ae(Le[ge], ge, Le))) ? --Pe : ce += Re;\n                if (Pe) return ce / Pe;\n              }\n              function N2(Le, Ae) {\n                var Fe = Le.length, Pe = -1, ge, Re = [];\n                if (Ae == null) for (; ++Pe < Fe; ) isNaN(ge = f4(Le[Pe])) || Re.push(ge);\n                else for (; ++Pe < Fe; ) isNaN(ge = f4(Ae(Le[Pe], Pe, Le))) || Re.push(ge);\n                return O3(Re.sort(t3), 0.5);\n              }\n              function H(Le) {\n                for (var Ae = Le.length, Fe, Pe = -1, ge = 0, Re, ce; ++Pe < Ae; ) ge += Le[Pe].length;\n                for (Re = new Array(ge); --Ae >= 0; ) for (ce = Le[Ae], Fe = ce.length; --Fe >= 0; ) Re[--ge] = ce[Fe];\n                return Re;\n              }\n              function te(Le, Ae) {\n                var Fe = Le.length, Pe = -1, ge, Re;\n                if (Ae == null) {\n                  for (; ++Pe < Fe; ) if ((ge = Le[Pe]) != null && ge >= ge) for (Re = ge; ++Pe < Fe; ) (ge = Le[Pe]) != null && Re > ge && (Re = ge);\n                } else for (; ++Pe < Fe; ) if ((ge = Ae(Le[Pe], Pe, Le)) != null && ge >= ge) for (Re = ge; ++Pe < Fe; ) (ge = Ae(Le[Pe], Pe, Le)) != null && Re > ge && (Re = ge);\n                return Re;\n              }\n              function oe(Le, Ae) {\n                for (var Fe = Ae.length, Pe = new Array(Fe); Fe--; ) Pe[Fe] = Le[Ae[Fe]];\n                return Pe;\n              }\n              function _e(Le, Ae) {\n                if (Fe = Le.length) {\n                  var Fe, Pe = 0, ge = 0, Re, ce = Le[ge];\n                  for (Ae == null && (Ae = t3); ++Pe < Fe; ) (Ae(Re = Le[Pe], ce) < 0 || Ae(ce, ce) !== 0) && (ce = Re, ge = Pe);\n                  if (Ae(ce, ce) === 0) return ge;\n                }\n              }\n              function Ee(Le, Ae, Fe) {\n                for (var Pe = (Fe == null ? Le.length : Fe) - (Ae = Ae == null ? 0 : +Ae), ge, Re; Pe; ) Re = Math.random() * Pe-- | 0, ge = Le[Pe + Ae], Le[Pe + Ae] = Le[Re + Ae], Le[Re + Ae] = ge;\n                return Le;\n              }\n              function Ce(Le, Ae) {\n                var Fe = Le.length, Pe = -1, ge, Re = 0;\n                if (Ae == null) for (; ++Pe < Fe; ) (ge = +Le[Pe]) && (Re += ge);\n                else for (; ++Pe < Fe; ) (ge = +Ae(Le[Pe], Pe, Le)) && (Re += ge);\n                return Re;\n              }\n              function me(Le) {\n                if (!(Re = Le.length)) return [];\n                for (var Ae = -1, Fe = te(Le, ie), Pe = new Array(Fe); ++Ae < Fe; ) for (var ge = -1, Re, ce = Pe[Ae] = new Array(Re); ++ge < Re; ) ce[ge] = Le[ge][Ae];\n                return Pe;\n              }\n              function ie(Le) {\n                return Le.length;\n              }\n              function Se() {\n                return me(arguments);\n              }\n              e3.bisect = a4, e3.bisectRight = a4, e3.bisectLeft = o4, e3.ascending = t3, e3.bisector = r4, e3.cross = u4, e3.descending = c5, e3.deviation = d3, e3.extent = v3, e3.histogram = z3, e3.thresholdFreedmanDiaconis = V2, e3.thresholdScott = G2, e3.thresholdSturges = T3, e3.max = Z, e3.mean = j3, e3.median = N2, e3.merge = H, e3.min = te, e3.pairs = s3, e3.permute = oe, e3.quantile = O3, e3.range = S2, e3.scan = _e, e3.shuffle = Ee, e3.sum = Ce, e3.ticks = M4, e3.tickIncrement = g3, e3.tickStep = P3, e3.transpose = me, e3.variance = h3, e3.zip = Se, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var RZ = ye((LF, CDe) => {\n            (function(e3, t3) {\n              typeof LF == "object" && typeof CDe != "undefined" ? t3(LF, nk()) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}, e3.d3));\n            })(LF, function(e3, t3) {\n              "use strict";\n              function r4() {\n                return new n4();\n              }\n              function n4() {\n                this.reset();\n              }\n              n4.prototype = { constructor: n4, reset: function() {\n                this.s = this.t = 0;\n              }, add: function(At) {\n                a4(i3, At, this.t), a4(this, i3.s, this.s), this.s ? this.t += i3.t : this.s = i3.t;\n              }, valueOf: function() {\n                return this.s;\n              } };\n              var i3 = new n4();\n              function a4(At, Wt, Cr) {\n                var Ar = At.s = Wt + Cr, Kr = Ar - Wt, ki = Ar - Kr;\n                At.t = Wt - ki + (Cr - Kr);\n              }\n              var o4 = 1e-6, s3 = 1e-12, l3 = Math.PI, u4 = l3 / 2, c5 = l3 / 4, f4 = l3 * 2, h3 = 180 / l3, d3 = l3 / 180, v3 = Math.abs, _2 = Math.atan, b = Math.atan2, p3 = Math.cos, k4 = Math.ceil, E3 = Math.exp, S2 = Math.log, L3 = Math.pow, x2 = Math.sin, C3 = Math.sign || function(At) {\n                return At > 0 ? 1 : At < 0 ? -1 : 0;\n              }, M4 = Math.sqrt, g3 = Math.tan;\n              function P3(At) {\n                return At > 1 ? 0 : At < -1 ? l3 : Math.acos(At);\n              }\n              function T3(At) {\n                return At > 1 ? u4 : At < -1 ? -u4 : Math.asin(At);\n              }\n              function z3(At) {\n                return (At = x2(At / 2)) * At;\n              }\n              function O3() {\n              }\n              function V2(At, Wt) {\n                At && Z.hasOwnProperty(At.type) && Z[At.type](At, Wt);\n              }\n              var G2 = { Feature: function(At, Wt) {\n                V2(At.geometry, Wt);\n              }, FeatureCollection: function(At, Wt) {\n                for (var Cr = At.features, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) V2(Cr[Ar].geometry, Wt);\n              } }, Z = { Sphere: function(At, Wt) {\n                Wt.sphere();\n              }, Point: function(At, Wt) {\n                At = At.coordinates, Wt.point(At[0], At[1], At[2]);\n              }, MultiPoint: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) At = Cr[Ar], Wt.point(At[0], At[1], At[2]);\n              }, LineString: function(At, Wt) {\n                j3(At.coordinates, Wt, 0);\n              }, MultiLineString: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) j3(Cr[Ar], Wt, 0);\n              }, Polygon: function(At, Wt) {\n                N2(At.coordinates, Wt);\n              }, MultiPolygon: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) N2(Cr[Ar], Wt);\n              }, GeometryCollection: function(At, Wt) {\n                for (var Cr = At.geometries, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) V2(Cr[Ar], Wt);\n              } };\n              function j3(At, Wt, Cr) {\n                var Ar = -1, Kr = At.length - Cr, ki;\n                for (Wt.lineStart(); ++Ar < Kr; ) ki = At[Ar], Wt.point(ki[0], ki[1], ki[2]);\n                Wt.lineEnd();\n              }\n              function N2(At, Wt) {\n                var Cr = -1, Ar = At.length;\n                for (Wt.polygonStart(); ++Cr < Ar; ) j3(At[Cr], Wt, 1);\n                Wt.polygonEnd();\n              }\n              function H(At, Wt) {\n                At && G2.hasOwnProperty(At.type) ? G2[At.type](At, Wt) : V2(At, Wt);\n              }\n              var te = r4(), oe = r4(), _e, Ee, Ce, me, ie, Se = { point: O3, lineStart: O3, lineEnd: O3, polygonStart: function() {\n                te.reset(), Se.lineStart = Le, Se.lineEnd = Ae;\n              }, polygonEnd: function() {\n                var At = +te;\n                oe.add(At < 0 ? f4 + At : At), this.lineStart = this.lineEnd = this.point = O3;\n              }, sphere: function() {\n                oe.add(f4);\n              } };\n              function Le() {\n                Se.point = Fe;\n              }\n              function Ae() {\n                Pe(_e, Ee);\n              }\n              function Fe(At, Wt) {\n                Se.point = Pe, _e = At, Ee = Wt, At *= d3, Wt *= d3, Ce = At, me = p3(Wt = Wt / 2 + c5), ie = x2(Wt);\n              }\n              function Pe(At, Wt) {\n                At *= d3, Wt *= d3, Wt = Wt / 2 + c5;\n                var Cr = At - Ce, Ar = Cr >= 0 ? 1 : -1, Kr = Ar * Cr, ki = p3(Wt), Xi = x2(Wt), dn = ie * Xi, wn = me * ki + dn * p3(Kr), Nn = dn * Ar * x2(Kr);\n                te.add(b(Nn, wn)), Ce = At, me = ki, ie = Xi;\n              }\n              function ge(At) {\n                return oe.reset(), H(At, Se), oe * 2;\n              }\n              function Re(At) {\n                return [b(At[1], At[0]), T3(At[2])];\n              }\n              function ce(At) {\n                var Wt = At[0], Cr = At[1], Ar = p3(Cr);\n                return [Ar * p3(Wt), Ar * x2(Wt), x2(Cr)];\n              }\n              function Ze(At, Wt) {\n                return At[0] * Wt[0] + At[1] * Wt[1] + At[2] * Wt[2];\n              }\n              function ut(At, Wt) {\n                return [At[1] * Wt[2] - At[2] * Wt[1], At[2] * Wt[0] - At[0] * Wt[2], At[0] * Wt[1] - At[1] * Wt[0]];\n              }\n              function pt(At, Wt) {\n                At[0] += Wt[0], At[1] += Wt[1], At[2] += Wt[2];\n              }\n              function Zt(At, Wt) {\n                return [At[0] * Wt, At[1] * Wt, At[2] * Wt];\n              }\n              function st(At) {\n                var Wt = M4(At[0] * At[0] + At[1] * At[1] + At[2] * At[2]);\n                At[0] /= Wt, At[1] /= Wt, At[2] /= Wt;\n              }\n              var lt, Gt, Nt, Jt, sr, wr, cr, $e, St = r4(), Qt, Vt, _t = { point: It, lineStart: er, lineEnd: lr, polygonStart: function() {\n                _t.point = Tr, _t.lineStart = Lr, _t.lineEnd = ti, St.reset(), Se.polygonStart();\n              }, polygonEnd: function() {\n                Se.polygonEnd(), _t.point = It, _t.lineStart = er, _t.lineEnd = lr, te < 0 ? (lt = -(Nt = 180), Gt = -(Jt = 90)) : St > o4 ? Jt = 90 : St < -o4 && (Gt = -90), Vt[0] = lt, Vt[1] = Nt;\n              }, sphere: function() {\n                lt = -(Nt = 180), Gt = -(Jt = 90);\n              } };\n              function It(At, Wt) {\n                Qt.push(Vt = [lt = At, Nt = At]), Wt < Gt && (Gt = Wt), Wt > Jt && (Jt = Wt);\n              }\n              function mt(At, Wt) {\n                var Cr = ce([At * d3, Wt * d3]);\n                if ($e) {\n                  var Ar = ut($e, Cr), Kr = [Ar[1], -Ar[0], 0], ki = ut(Kr, Ar);\n                  st(ki), ki = Re(ki);\n                  var Xi = At - sr, dn = Xi > 0 ? 1 : -1, wn = ki[0] * h3 * dn, Nn, Yi = v3(Xi) > 180;\n                  Yi ^ (dn * sr < wn && wn < dn * At) ? (Nn = ki[1] * h3, Nn > Jt && (Jt = Nn)) : (wn = (wn + 360) % 360 - 180, Yi ^ (dn * sr < wn && wn < dn * At) ? (Nn = -ki[1] * h3, Nn < Gt && (Gt = Nn)) : (Wt < Gt && (Gt = Wt), Wt > Jt && (Jt = Wt))), Yi ? At < sr ? Br(lt, At) > Br(lt, Nt) && (Nt = At) : Br(At, Nt) > Br(lt, Nt) && (lt = At) : Nt >= lt ? (At < lt && (lt = At), At > Nt && (Nt = At)) : At > sr ? Br(lt, At) > Br(lt, Nt) && (Nt = At) : Br(At, Nt) > Br(lt, Nt) && (lt = At);\n                } else Qt.push(Vt = [lt = At, Nt = At]);\n                Wt < Gt && (Gt = Wt), Wt > Jt && (Jt = Wt), $e = Cr, sr = At;\n              }\n              function er() {\n                _t.point = mt;\n              }\n              function lr() {\n                Vt[0] = lt, Vt[1] = Nt, _t.point = It, $e = null;\n              }\n              function Tr(At, Wt) {\n                if ($e) {\n                  var Cr = At - sr;\n                  St.add(v3(Cr) > 180 ? Cr + (Cr > 0 ? 360 : -360) : Cr);\n                } else wr = At, cr = Wt;\n                Se.point(At, Wt), mt(At, Wt);\n              }\n              function Lr() {\n                Se.lineStart();\n              }\n              function ti() {\n                Tr(wr, cr), Se.lineEnd(), v3(St) > o4 && (lt = -(Nt = 180)), Vt[0] = lt, Vt[1] = Nt, $e = null;\n              }\n              function Br(At, Wt) {\n                return (Wt -= At) < 0 ? Wt + 360 : Wt;\n              }\n              function Vr(At, Wt) {\n                return At[0] - Wt[0];\n              }\n              function dt(At, Wt) {\n                return At[0] <= At[1] ? At[0] <= Wt && Wt <= At[1] : Wt < At[0] || At[1] < Wt;\n              }\n              function Ge(At) {\n                var Wt, Cr, Ar, Kr, ki, Xi, dn;\n                if (Jt = Nt = -(lt = Gt = 1 / 0), Qt = [], H(At, _t), Cr = Qt.length) {\n                  for (Qt.sort(Vr), Wt = 1, Ar = Qt[0], ki = [Ar]; Wt < Cr; ++Wt) Kr = Qt[Wt], dt(Ar, Kr[0]) || dt(Ar, Kr[1]) ? (Br(Ar[0], Kr[1]) > Br(Ar[0], Ar[1]) && (Ar[1] = Kr[1]), Br(Kr[0], Ar[1]) > Br(Ar[0], Ar[1]) && (Ar[0] = Kr[0])) : ki.push(Ar = Kr);\n                  for (Xi = -1 / 0, Cr = ki.length - 1, Wt = 0, Ar = ki[Cr]; Wt <= Cr; Ar = Kr, ++Wt) Kr = ki[Wt], (dn = Br(Ar[1], Kr[0])) > Xi && (Xi = dn, lt = Kr[0], Nt = Ar[1]);\n                }\n                return Qt = Vt = null, lt === 1 / 0 || Gt === 1 / 0 ? [[NaN, NaN], [NaN, NaN]] : [[lt, Gt], [Nt, Jt]];\n              }\n              var Je, je, tt, xt, Ie, xe, ke, vt, ir, ar, vr, ii, pi, $r, di, ji, In = { sphere: O3, point: wi, lineStart: qn, lineEnd: la, polygonStart: function() {\n                In.lineStart = Ut, In.lineEnd = wt;\n              }, polygonEnd: function() {\n                In.lineStart = qn, In.lineEnd = la;\n              } };\n              function wi(At, Wt) {\n                At *= d3, Wt *= d3;\n                var Cr = p3(Wt);\n                On(Cr * p3(At), Cr * x2(At), x2(Wt));\n              }\n              function On(At, Wt, Cr) {\n                ++Je, tt += (At - tt) / Je, xt += (Wt - xt) / Je, Ie += (Cr - Ie) / Je;\n              }\n              function qn() {\n                In.point = Fn;\n              }\n              function Fn(At, Wt) {\n                At *= d3, Wt *= d3;\n                var Cr = p3(Wt);\n                $r = Cr * p3(At), di = Cr * x2(At), ji = x2(Wt), In.point = ra, On($r, di, ji);\n              }\n              function ra(At, Wt) {\n                At *= d3, Wt *= d3;\n                var Cr = p3(Wt), Ar = Cr * p3(At), Kr = Cr * x2(At), ki = x2(Wt), Xi = b(M4((Xi = di * ki - ji * Kr) * Xi + (Xi = ji * Ar - $r * ki) * Xi + (Xi = $r * Kr - di * Ar) * Xi), $r * Ar + di * Kr + ji * ki);\n                je += Xi, xe += Xi * ($r + ($r = Ar)), ke += Xi * (di + (di = Kr)), vt += Xi * (ji + (ji = ki)), On($r, di, ji);\n              }\n              function la() {\n                In.point = wi;\n              }\n              function Ut() {\n                In.point = rr;\n              }\n              function wt() {\n                nr(ii, pi), In.point = wi;\n              }\n              function rr(At, Wt) {\n                ii = At, pi = Wt, At *= d3, Wt *= d3, In.point = nr;\n                var Cr = p3(Wt);\n                $r = Cr * p3(At), di = Cr * x2(At), ji = x2(Wt), On($r, di, ji);\n              }\n              function nr(At, Wt) {\n                At *= d3, Wt *= d3;\n                var Cr = p3(Wt), Ar = Cr * p3(At), Kr = Cr * x2(At), ki = x2(Wt), Xi = di * ki - ji * Kr, dn = ji * Ar - $r * ki, wn = $r * Kr - di * Ar, Nn = M4(Xi * Xi + dn * dn + wn * wn), Yi = T3(Nn), Qi = Nn && -Yi / Nn;\n                ir += Qi * Xi, ar += Qi * dn, vr += Qi * wn, je += Yi, xe += Yi * ($r + ($r = Ar)), ke += Yi * (di + (di = Kr)), vt += Yi * (ji + (ji = ki)), On($r, di, ji);\n              }\n              function Er(At) {\n                Je = je = tt = xt = Ie = xe = ke = vt = ir = ar = vr = 0, H(At, In);\n                var Wt = ir, Cr = ar, Ar = vr, Kr = Wt * Wt + Cr * Cr + Ar * Ar;\n                return Kr < s3 && (Wt = xe, Cr = ke, Ar = vt, je < o4 && (Wt = tt, Cr = xt, Ar = Ie), Kr = Wt * Wt + Cr * Cr + Ar * Ar, Kr < s3) ? [NaN, NaN] : [b(Cr, Wt) * h3, T3(Ar / M4(Kr)) * h3];\n              }\n              function Xr(At) {\n                return function() {\n                  return At;\n                };\n              }\n              function ri(At, Wt) {\n                function Cr(Ar, Kr) {\n                  return Ar = At(Ar, Kr), Wt(Ar[0], Ar[1]);\n                }\n                return At.invert && Wt.invert && (Cr.invert = function(Ar, Kr) {\n                  return Ar = Wt.invert(Ar, Kr), Ar && At.invert(Ar[0], Ar[1]);\n                }), Cr;\n              }\n              function Qr(At, Wt) {\n                return [v3(At) > l3 ? At + Math.round(-At / f4) * f4 : At, Wt];\n              }\n              Qr.invert = Qr;\n              function Oi(At, Wt, Cr) {\n                return (At %= f4) ? Wt || Cr ? ri(tn(At), fn(Wt, Cr)) : tn(At) : Wt || Cr ? fn(Wt, Cr) : Qr;\n              }\n              function $i(At) {\n                return function(Wt, Cr) {\n                  return Wt += At, [Wt > l3 ? Wt - f4 : Wt < -l3 ? Wt + f4 : Wt, Cr];\n                };\n              }\n              function tn(At) {\n                var Wt = $i(At);\n                return Wt.invert = $i(-At), Wt;\n              }\n              function fn(At, Wt) {\n                var Cr = p3(At), Ar = x2(At), Kr = p3(Wt), ki = x2(Wt);\n                function Xi(dn, wn) {\n                  var Nn = p3(wn), Yi = p3(dn) * Nn, Qi = x2(dn) * Nn, on = x2(wn), Fi = on * Cr + Yi * Ar;\n                  return [b(Qi * Kr - Fi * ki, Yi * Cr - on * Ar), T3(Fi * Kr + Qi * ki)];\n                }\n                return Xi.invert = function(dn, wn) {\n                  var Nn = p3(wn), Yi = p3(dn) * Nn, Qi = x2(dn) * Nn, on = x2(wn), Fi = on * Kr - Qi * ki;\n                  return [b(Qi * Kr + on * ki, Yi * Cr + Fi * Ar), T3(Fi * Cr - Yi * Ar)];\n                }, Xi;\n              }\n              function yn(At) {\n                At = Oi(At[0] * d3, At[1] * d3, At.length > 2 ? At[2] * d3 : 0);\n                function Wt(Cr) {\n                  return Cr = At(Cr[0] * d3, Cr[1] * d3), Cr[0] *= h3, Cr[1] *= h3, Cr;\n                }\n                return Wt.invert = function(Cr) {\n                  return Cr = At.invert(Cr[0] * d3, Cr[1] * d3), Cr[0] *= h3, Cr[1] *= h3, Cr;\n                }, Wt;\n              }\n              function Sn(At, Wt, Cr, Ar, Kr, ki) {\n                if (Cr) {\n                  var Xi = p3(Wt), dn = x2(Wt), wn = Ar * Cr;\n                  Kr == null ? (Kr = Wt + Ar * f4, ki = Wt - wn / 2) : (Kr = Ba(Xi, Kr), ki = Ba(Xi, ki), (Ar > 0 ? Kr < ki : Kr > ki) && (Kr += Ar * f4));\n                  for (var Nn, Yi = Kr; Ar > 0 ? Yi > ki : Yi < ki; Yi -= wn) Nn = Re([Xi, -dn * p3(Yi), -dn * x2(Yi)]), At.point(Nn[0], Nn[1]);\n                }\n              }\n              function Ba(At, Wt) {\n                Wt = ce(Wt), Wt[0] -= At, st(Wt);\n                var Cr = P3(-Wt[1]);\n                return ((-Wt[2] < 0 ? -Cr : Cr) + f4 - o4) % f4;\n              }\n              function ua() {\n                var At = Xr([0, 0]), Wt = Xr(90), Cr = Xr(6), Ar, Kr, ki = { point: Xi };\n                function Xi(wn, Nn) {\n                  Ar.push(wn = Kr(wn, Nn)), wn[0] *= h3, wn[1] *= h3;\n                }\n                function dn() {\n                  var wn = At.apply(this, arguments), Nn = Wt.apply(this, arguments) * d3, Yi = Cr.apply(this, arguments) * d3;\n                  return Ar = [], Kr = Oi(-wn[0] * d3, -wn[1] * d3, 0).invert, Sn(ki, Nn, Yi, 1), wn = { type: "Polygon", coordinates: [Ar] }, Ar = Kr = null, wn;\n                }\n                return dn.center = function(wn) {\n                  return arguments.length ? (At = typeof wn == "function" ? wn : Xr([+wn[0], +wn[1]]), dn) : At;\n                }, dn.radius = function(wn) {\n                  return arguments.length ? (Wt = typeof wn == "function" ? wn : Xr(+wn), dn) : Wt;\n                }, dn.precision = function(wn) {\n                  return arguments.length ? (Cr = typeof wn == "function" ? wn : Xr(+wn), dn) : Cr;\n                }, dn;\n              }\n              function ma() {\n                var At = [], Wt;\n                return { point: function(Cr, Ar, Kr) {\n                  Wt.push([Cr, Ar, Kr]);\n                }, lineStart: function() {\n                  At.push(Wt = []);\n                }, lineEnd: O3, rejoin: function() {\n                  At.length > 1 && At.push(At.pop().concat(At.shift()));\n                }, result: function() {\n                  var Cr = At;\n                  return At = [], Wt = null, Cr;\n                } };\n              }\n              function Wa(At, Wt) {\n                return v3(At[0] - Wt[0]) < o4 && v3(At[1] - Wt[1]) < o4;\n              }\n              function Fa(At, Wt, Cr, Ar) {\n                this.x = At, this.z = Wt, this.o = Cr, this.e = Ar, this.v = false, this.n = this.p = null;\n              }\n              function Wo(At, Wt, Cr, Ar, Kr) {\n                var ki = [], Xi = [], dn, wn;\n                if (At.forEach(function($n) {\n                  if (!((Ca = $n.length - 1) <= 0)) {\n                    var Ca, Ra = $n[0], La = $n[Ca], Na;\n                    if (Wa(Ra, La)) {\n                      if (!Ra[2] && !La[2]) {\n                        for (Kr.lineStart(), dn = 0; dn < Ca; ++dn) Kr.point((Ra = $n[dn])[0], Ra[1]);\n                        Kr.lineEnd();\n                        return;\n                      }\n                      La[0] += 2 * o4;\n                    }\n                    ki.push(Na = new Fa(Ra, $n, null, true)), Xi.push(Na.o = new Fa(Ra, null, Na, false)), ki.push(Na = new Fa(La, $n, null, false)), Xi.push(Na.o = new Fa(La, null, Na, true));\n                  }\n                }), !!ki.length) {\n                  for (Xi.sort(Wt), da(ki), da(Xi), dn = 0, wn = Xi.length; dn < wn; ++dn) Xi[dn].e = Cr = !Cr;\n                  for (var Nn = ki[0], Yi, Qi; ; ) {\n                    for (var on = Nn, Fi = true; on.v; ) if ((on = on.n) === Nn) return;\n                    Yi = on.z, Kr.lineStart();\n                    do {\n                      if (on.v = on.o.v = true, on.e) {\n                        if (Fi) for (dn = 0, wn = Yi.length; dn < wn; ++dn) Kr.point((Qi = Yi[dn])[0], Qi[1]);\n                        else Ar(on.x, on.n.x, 1, Kr);\n                        on = on.n;\n                      } else {\n                        if (Fi) for (Yi = on.p.z, dn = Yi.length - 1; dn >= 0; --dn) Kr.point((Qi = Yi[dn])[0], Qi[1]);\n                        else Ar(on.x, on.p.x, -1, Kr);\n                        on = on.p;\n                      }\n                      on = on.o, Yi = on.z, Fi = !Fi;\n                    } while (!on.v);\n                    Kr.lineEnd();\n                  }\n                }\n              }\n              function da(At) {\n                if (Wt = At.length) {\n                  for (var Wt, Cr = 0, Ar = At[0], Kr; ++Cr < Wt; ) Ar.n = Kr = At[Cr], Kr.p = Ar, Ar = Kr;\n                  Ar.n = Kr = At[0], Kr.p = Ar;\n                }\n              }\n              var Wn = r4();\n              function Ha(At) {\n                return v3(At[0]) <= l3 ? At[0] : C3(At[0]) * ((v3(At[0]) + l3) % f4 - l3);\n              }\n              function vo(At, Wt) {\n                var Cr = Ha(Wt), Ar = Wt[1], Kr = x2(Ar), ki = [x2(Cr), -p3(Cr), 0], Xi = 0, dn = 0;\n                Wn.reset(), Kr === 1 ? Ar = u4 + o4 : Kr === -1 && (Ar = -u4 - o4);\n                for (var wn = 0, Nn = At.length; wn < Nn; ++wn) if (Qi = (Yi = At[wn]).length) for (var Yi, Qi, on = Yi[Qi - 1], Fi = Ha(on), $n = on[1] / 2 + c5, Ca = x2($n), Ra = p3($n), La = 0; La < Qi; ++La, Fi = Yn, Ca = Ka, Ra = bo, on = Na) {\n                  var Na = Yi[La], Yn = Ha(Na), Dn = Na[1] / 2 + c5, Ka = x2(Dn), bo = p3(Dn), Xo = Yn - Fi, Ss = Xo >= 0 ? 1 : -1, as = Ss * Xo, ws = as > l3, Ho = Ca * Ka;\n                  if (Wn.add(b(Ho * Ss * x2(as), Ra * bo + Ho * p3(as))), Xi += ws ? Xo + Ss * f4 : Xo, ws ^ Fi >= Cr ^ Yn >= Cr) {\n                    var ml = ut(ce(on), ce(Na));\n                    st(ml);\n                    var Ws = ut(ki, ml);\n                    st(Ws);\n                    var Ls = (ws ^ Xo >= 0 ? -1 : 1) * T3(Ws[2]);\n                    (Ar > Ls || Ar === Ls && (ml[0] || ml[1])) && (dn += ws ^ Xo >= 0 ? 1 : -1);\n                  }\n                }\n                return (Xi < -o4 || Xi < o4 && Wn < -o4) ^ dn & 1;\n              }\n              function jn(At, Wt, Cr, Ar) {\n                return function(Kr) {\n                  var ki = Wt(Kr), Xi = ma(), dn = Wt(Xi), wn = false, Nn, Yi, Qi, on = { point: Fi, lineStart: Ca, lineEnd: Ra, polygonStart: function() {\n                    on.point = La, on.lineStart = Na, on.lineEnd = Yn, Yi = [], Nn = [];\n                  }, polygonEnd: function() {\n                    on.point = Fi, on.lineStart = Ca, on.lineEnd = Ra, Yi = t3.merge(Yi);\n                    var Dn = vo(Nn, Ar);\n                    Yi.length ? (wn || (Kr.polygonStart(), wn = true), Wo(Yi, kr, Dn, Cr, Kr)) : Dn && (wn || (Kr.polygonStart(), wn = true), Kr.lineStart(), Cr(null, null, 1, Kr), Kr.lineEnd()), wn && (Kr.polygonEnd(), wn = false), Yi = Nn = null;\n                  }, sphere: function() {\n                    Kr.polygonStart(), Kr.lineStart(), Cr(null, null, 1, Kr), Kr.lineEnd(), Kr.polygonEnd();\n                  } };\n                  function Fi(Dn, Ka) {\n                    At(Dn, Ka) && Kr.point(Dn, Ka);\n                  }\n                  function $n(Dn, Ka) {\n                    ki.point(Dn, Ka);\n                  }\n                  function Ca() {\n                    on.point = $n, ki.lineStart();\n                  }\n                  function Ra() {\n                    on.point = Fi, ki.lineEnd();\n                  }\n                  function La(Dn, Ka) {\n                    Qi.push([Dn, Ka]), dn.point(Dn, Ka);\n                  }\n                  function Na() {\n                    dn.lineStart(), Qi = [];\n                  }\n                  function Yn() {\n                    La(Qi[0][0], Qi[0][1]), dn.lineEnd();\n                    var Dn = dn.clean(), Ka = Xi.result(), bo, Xo = Ka.length, Ss, as, ws;\n                    if (Qi.pop(), Nn.push(Qi), Qi = null, !!Xo) {\n                      if (Dn & 1) {\n                        if (as = Ka[0], (Ss = as.length - 1) > 0) {\n                          for (wn || (Kr.polygonStart(), wn = true), Kr.lineStart(), bo = 0; bo < Ss; ++bo) Kr.point((ws = as[bo])[0], ws[1]);\n                          Kr.lineEnd();\n                        }\n                        return;\n                      }\n                      Xo > 1 && Dn & 2 && Ka.push(Ka.pop().concat(Ka.shift())), Yi.push(Ka.filter(Mt));\n                    }\n                  }\n                  return on;\n                };\n              }\n              function Mt(At) {\n                return At.length > 1;\n              }\n              function kr(At, Wt) {\n                return ((At = At.x)[0] < 0 ? At[1] - u4 - o4 : u4 - At[1]) - ((Wt = Wt.x)[0] < 0 ? Wt[1] - u4 - o4 : u4 - Wt[1]);\n              }\n              var Jr = jn(function() {\n                return true;\n              }, vi, An, [-l3, -u4]);\n              function vi(At) {\n                var Wt = NaN, Cr = NaN, Ar = NaN, Kr;\n                return { lineStart: function() {\n                  At.lineStart(), Kr = 1;\n                }, point: function(ki, Xi) {\n                  var dn = ki > 0 ? l3 : -l3, wn = v3(ki - Wt);\n                  v3(wn - l3) < o4 ? (At.point(Wt, Cr = (Cr + Xi) / 2 > 0 ? u4 : -u4), At.point(Ar, Cr), At.lineEnd(), At.lineStart(), At.point(dn, Cr), At.point(ki, Cr), Kr = 0) : Ar !== dn && wn >= l3 && (v3(Wt - Ar) < o4 && (Wt -= Ar * o4), v3(ki - dn) < o4 && (ki -= dn * o4), Cr = hn(Wt, Cr, ki, Xi), At.point(Ar, Cr), At.lineEnd(), At.lineStart(), At.point(dn, Cr), Kr = 0), At.point(Wt = ki, Cr = Xi), Ar = dn;\n                }, lineEnd: function() {\n                  At.lineEnd(), Wt = Cr = NaN;\n                }, clean: function() {\n                  return 2 - Kr;\n                } };\n              }\n              function hn(At, Wt, Cr, Ar) {\n                var Kr, ki, Xi = x2(At - Cr);\n                return v3(Xi) > o4 ? _2((x2(Wt) * (ki = p3(Ar)) * x2(Cr) - x2(Ar) * (Kr = p3(Wt)) * x2(At)) / (Kr * ki * Xi)) : (Wt + Ar) / 2;\n              }\n              function An(At, Wt, Cr, Ar) {\n                var Kr;\n                if (At == null) Kr = Cr * u4, Ar.point(-l3, Kr), Ar.point(0, Kr), Ar.point(l3, Kr), Ar.point(l3, 0), Ar.point(l3, -Kr), Ar.point(0, -Kr), Ar.point(-l3, -Kr), Ar.point(-l3, 0), Ar.point(-l3, Kr);\n                else if (v3(At[0] - Wt[0]) > o4) {\n                  var ki = At[0] < Wt[0] ? l3 : -l3;\n                  Kr = Cr * ki / 2, Ar.point(-ki, Kr), Ar.point(0, Kr), Ar.point(ki, Kr);\n                } else Ar.point(Wt[0], Wt[1]);\n              }\n              function Mn(At) {\n                var Wt = p3(At), Cr = 6 * d3, Ar = Wt > 0, Kr = v3(Wt) > o4;\n                function ki(Yi, Qi, on, Fi) {\n                  Sn(Fi, At, Cr, on, Yi, Qi);\n                }\n                function Xi(Yi, Qi) {\n                  return p3(Yi) * p3(Qi) > Wt;\n                }\n                function dn(Yi) {\n                  var Qi, on, Fi, $n, Ca;\n                  return { lineStart: function() {\n                    $n = Fi = false, Ca = 1;\n                  }, point: function(Ra, La) {\n                    var Na = [Ra, La], Yn, Dn = Xi(Ra, La), Ka = Ar ? Dn ? 0 : Nn(Ra, La) : Dn ? Nn(Ra + (Ra < 0 ? l3 : -l3), La) : 0;\n                    if (!Qi && ($n = Fi = Dn) && Yi.lineStart(), Dn !== Fi && (Yn = wn(Qi, Na), (!Yn || Wa(Qi, Yn) || Wa(Na, Yn)) && (Na[2] = 1)), Dn !== Fi) Ca = 0, Dn ? (Yi.lineStart(), Yn = wn(Na, Qi), Yi.point(Yn[0], Yn[1])) : (Yn = wn(Qi, Na), Yi.point(Yn[0], Yn[1], 2), Yi.lineEnd()), Qi = Yn;\n                    else if (Kr && Qi && Ar ^ Dn) {\n                      var bo;\n                      !(Ka & on) && (bo = wn(Na, Qi, true)) && (Ca = 0, Ar ? (Yi.lineStart(), Yi.point(bo[0][0], bo[0][1]), Yi.point(bo[1][0], bo[1][1]), Yi.lineEnd()) : (Yi.point(bo[1][0], bo[1][1]), Yi.lineEnd(), Yi.lineStart(), Yi.point(bo[0][0], bo[0][1], 3)));\n                    }\n                    Dn && (!Qi || !Wa(Qi, Na)) && Yi.point(Na[0], Na[1]), Qi = Na, Fi = Dn, on = Ka;\n                  }, lineEnd: function() {\n                    Fi && Yi.lineEnd(), Qi = null;\n                  }, clean: function() {\n                    return Ca | ($n && Fi) << 1;\n                  } };\n                }\n                function wn(Yi, Qi, on) {\n                  var Fi = ce(Yi), $n = ce(Qi), Ca = [1, 0, 0], Ra = ut(Fi, $n), La = Ze(Ra, Ra), Na = Ra[0], Yn = La - Na * Na;\n                  if (!Yn) return !on && Yi;\n                  var Dn = Wt * La / Yn, Ka = -Wt * Na / Yn, bo = ut(Ca, Ra), Xo = Zt(Ca, Dn), Ss = Zt(Ra, Ka);\n                  pt(Xo, Ss);\n                  var as = bo, ws = Ze(Xo, as), Ho = Ze(as, as), ml = ws * ws - Ho * (Ze(Xo, Xo) - 1);\n                  if (!(ml < 0)) {\n                    var Ws = M4(ml), Ls = Zt(as, (-ws - Ws) / Ho);\n                    if (pt(Ls, Xo), Ls = Re(Ls), !on) return Ls;\n                    var va = Yi[0], no = Qi[0], ys = Yi[1], rs = Qi[1], $l;\n                    no < va && ($l = va, va = no, no = $l);\n                    var Cu = no - va, Yu = v3(Cu - l3) < o4, Nc = Yu || Cu < o4;\n                    if (!Yu && rs < ys && ($l = ys, ys = rs, rs = $l), Nc ? Yu ? ys + rs > 0 ^ Ls[1] < (v3(Ls[0] - va) < o4 ? ys : rs) : ys <= Ls[1] && Ls[1] <= rs : Cu > l3 ^ (va <= Ls[0] && Ls[0] <= no)) {\n                      var pu = Zt(as, (-ws + Ws) / Ho);\n                      return pt(pu, Xo), [Ls, Re(pu)];\n                    }\n                  }\n                }\n                function Nn(Yi, Qi) {\n                  var on = Ar ? At : l3 - At, Fi = 0;\n                  return Yi < -on ? Fi |= 1 : Yi > on && (Fi |= 2), Qi < -on ? Fi |= 4 : Qi > on && (Fi |= 8), Fi;\n                }\n                return jn(Xi, dn, ki, Ar ? [0, -At] : [-l3, At - l3]);\n              }\n              function Li(At, Wt, Cr, Ar, Kr, ki) {\n                var Xi = At[0], dn = At[1], wn = Wt[0], Nn = Wt[1], Yi = 0, Qi = 1, on = wn - Xi, Fi = Nn - dn, $n;\n                if ($n = Cr - Xi, !(!on && $n > 0)) {\n                  if ($n /= on, on < 0) {\n                    if ($n < Yi) return;\n                    $n < Qi && (Qi = $n);\n                  } else if (on > 0) {\n                    if ($n > Qi) return;\n                    $n > Yi && (Yi = $n);\n                  }\n                  if ($n = Kr - Xi, !(!on && $n < 0)) {\n                    if ($n /= on, on < 0) {\n                      if ($n > Qi) return;\n                      $n > Yi && (Yi = $n);\n                    } else if (on > 0) {\n                      if ($n < Yi) return;\n                      $n < Qi && (Qi = $n);\n                    }\n                    if ($n = Ar - dn, !(!Fi && $n > 0)) {\n                      if ($n /= Fi, Fi < 0) {\n                        if ($n < Yi) return;\n                        $n < Qi && (Qi = $n);\n                      } else if (Fi > 0) {\n                        if ($n > Qi) return;\n                        $n > Yi && (Yi = $n);\n                      }\n                      if ($n = ki - dn, !(!Fi && $n < 0)) {\n                        if ($n /= Fi, Fi < 0) {\n                          if ($n > Qi) return;\n                          $n > Yi && (Yi = $n);\n                        } else if (Fi > 0) {\n                          if ($n < Yi) return;\n                          $n < Qi && (Qi = $n);\n                        }\n                        return Yi > 0 && (At[0] = Xi + Yi * on, At[1] = dn + Yi * Fi), Qi < 1 && (Wt[0] = Xi + Qi * on, Wt[1] = dn + Qi * Fi), true;\n                      }\n                    }\n                  }\n                }\n              }\n              var _n = 1e9, ya = -_n;\n              function Jn(At, Wt, Cr, Ar) {\n                function Kr(Nn, Yi) {\n                  return At <= Nn && Nn <= Cr && Wt <= Yi && Yi <= Ar;\n                }\n                function ki(Nn, Yi, Qi, on) {\n                  var Fi = 0, $n = 0;\n                  if (Nn == null || (Fi = Xi(Nn, Qi)) !== ($n = Xi(Yi, Qi)) || wn(Nn, Yi) < 0 ^ Qi > 0) do\n                    on.point(Fi === 0 || Fi === 3 ? At : Cr, Fi > 1 ? Ar : Wt);\n                  while ((Fi = (Fi + Qi + 4) % 4) !== $n);\n                  else on.point(Yi[0], Yi[1]);\n                }\n                function Xi(Nn, Yi) {\n                  return v3(Nn[0] - At) < o4 ? Yi > 0 ? 0 : 3 : v3(Nn[0] - Cr) < o4 ? Yi > 0 ? 2 : 1 : v3(Nn[1] - Wt) < o4 ? Yi > 0 ? 1 : 0 : Yi > 0 ? 3 : 2;\n                }\n                function dn(Nn, Yi) {\n                  return wn(Nn.x, Yi.x);\n                }\n                function wn(Nn, Yi) {\n                  var Qi = Xi(Nn, 1), on = Xi(Yi, 1);\n                  return Qi !== on ? Qi - on : Qi === 0 ? Yi[1] - Nn[1] : Qi === 1 ? Nn[0] - Yi[0] : Qi === 2 ? Nn[1] - Yi[1] : Yi[0] - Nn[0];\n                }\n                return function(Nn) {\n                  var Yi = Nn, Qi = ma(), on, Fi, $n, Ca, Ra, La, Na, Yn, Dn, Ka, bo, Xo = { point: Ss, lineStart: ml, lineEnd: Ws, polygonStart: ws, polygonEnd: Ho };\n                  function Ss(va, no) {\n                    Kr(va, no) && Yi.point(va, no);\n                  }\n                  function as() {\n                    for (var va = 0, no = 0, ys = Fi.length; no < ys; ++no) for (var rs = Fi[no], $l = 1, Cu = rs.length, Yu = rs[0], Nc, pu, Uc = Yu[0], xu = Yu[1]; $l < Cu; ++$l) Nc = Uc, pu = xu, Yu = rs[$l], Uc = Yu[0], xu = Yu[1], pu <= Ar ? xu > Ar && (Uc - Nc) * (Ar - pu) > (xu - pu) * (At - Nc) && ++va : xu <= Ar && (Uc - Nc) * (Ar - pu) < (xu - pu) * (At - Nc) && --va;\n                    return va;\n                  }\n                  function ws() {\n                    Yi = Qi, on = [], Fi = [], bo = true;\n                  }\n                  function Ho() {\n                    var va = as(), no = bo && va, ys = (on = t3.merge(on)).length;\n                    (no || ys) && (Nn.polygonStart(), no && (Nn.lineStart(), ki(null, null, 1, Nn), Nn.lineEnd()), ys && Wo(on, dn, va, ki, Nn), Nn.polygonEnd()), Yi = Nn, on = Fi = $n = null;\n                  }\n                  function ml() {\n                    Xo.point = Ls, Fi && Fi.push($n = []), Ka = true, Dn = false, Na = Yn = NaN;\n                  }\n                  function Ws() {\n                    on && (Ls(Ca, Ra), La && Dn && Qi.rejoin(), on.push(Qi.result())), Xo.point = Ss, Dn && Yi.lineEnd();\n                  }\n                  function Ls(va, no) {\n                    var ys = Kr(va, no);\n                    if (Fi && $n.push([va, no]), Ka) Ca = va, Ra = no, La = ys, Ka = false, ys && (Yi.lineStart(), Yi.point(va, no));\n                    else if (ys && Dn) Yi.point(va, no);\n                    else {\n                      var rs = [Na = Math.max(ya, Math.min(_n, Na)), Yn = Math.max(ya, Math.min(_n, Yn))], $l = [va = Math.max(ya, Math.min(_n, va)), no = Math.max(ya, Math.min(_n, no))];\n                      Li(rs, $l, At, Wt, Cr, Ar) ? (Dn || (Yi.lineStart(), Yi.point(rs[0], rs[1])), Yi.point($l[0], $l[1]), ys || Yi.lineEnd(), bo = false) : ys && (Yi.lineStart(), Yi.point(va, no), bo = false);\n                    }\n                    Na = va, Yn = no, Dn = ys;\n                  }\n                  return Xo;\n                };\n              }\n              function Ma() {\n                var At = 0, Wt = 0, Cr = 960, Ar = 500, Kr, ki, Xi;\n                return Xi = { stream: function(dn) {\n                  return Kr && ki === dn ? Kr : Kr = Jn(At, Wt, Cr, Ar)(ki = dn);\n                }, extent: function(dn) {\n                  return arguments.length ? (At = +dn[0][0], Wt = +dn[0][1], Cr = +dn[1][0], Ar = +dn[1][1], Kr = ki = null, Xi) : [[At, Wt], [Cr, Ar]];\n                } };\n              }\n              var _o = r4(), No, po, Lo, ko = { sphere: O3, point: O3, lineStart: Ds, lineEnd: O3, polygonStart: O3, polygonEnd: O3 };\n              function Ds() {\n                ko.point = ll, ko.lineEnd = Fs;\n              }\n              function Fs() {\n                ko.point = ko.lineEnd = O3;\n              }\n              function ll(At, Wt) {\n                At *= d3, Wt *= d3, No = At, po = x2(Wt), Lo = p3(Wt), ko.point = ul;\n              }\n              function ul(At, Wt) {\n                At *= d3, Wt *= d3;\n                var Cr = x2(Wt), Ar = p3(Wt), Kr = v3(At - No), ki = p3(Kr), Xi = x2(Kr), dn = Ar * Xi, wn = Lo * Cr - po * Ar * ki, Nn = po * Cr + Lo * Ar * ki;\n                _o.add(b(M4(dn * dn + wn * wn), Nn)), No = At, po = Cr, Lo = Ar;\n              }\n              function zl(At) {\n                return _o.reset(), H(At, ko), +_o;\n              }\n              var us = [null, null], il = { type: "LineString", coordinates: us };\n              function As(At, Wt) {\n                return us[0] = At, us[1] = Wt, zl(il);\n              }\n              var cl = { Feature: function(At, Wt) {\n                return zs(At.geometry, Wt);\n              }, FeatureCollection: function(At, Wt) {\n                for (var Cr = At.features, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (zs(Cr[Ar].geometry, Wt)) return true;\n                return false;\n              } }, Ks = { Sphere: function() {\n                return true;\n              }, Point: function(At, Wt) {\n                return Io(At.coordinates, Wt);\n              }, MultiPoint: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (Io(Cr[Ar], Wt)) return true;\n                return false;\n              }, LineString: function(At, Wt) {\n                return ls(At.coordinates, Wt);\n              }, MultiLineString: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (ls(Cr[Ar], Wt)) return true;\n                return false;\n              }, Polygon: function(At, Wt) {\n                return Zl(At.coordinates, Wt);\n              }, MultiPolygon: function(At, Wt) {\n                for (var Cr = At.coordinates, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (Zl(Cr[Ar], Wt)) return true;\n                return false;\n              }, GeometryCollection: function(At, Wt) {\n                for (var Cr = At.geometries, Ar = -1, Kr = Cr.length; ++Ar < Kr; ) if (zs(Cr[Ar], Wt)) return true;\n                return false;\n              } };\n              function zs(At, Wt) {\n                return At && Ks.hasOwnProperty(At.type) ? Ks[At.type](At, Wt) : false;\n              }\n              function Io(At, Wt) {\n                return As(At, Wt) === 0;\n              }\n              function ls(At, Wt) {\n                for (var Cr, Ar, Kr, ki = 0, Xi = At.length; ki < Xi; ki++) {\n                  if (Ar = As(At[ki], Wt), Ar === 0 || ki > 0 && (Kr = As(At[ki], At[ki - 1]), Kr > 0 && Cr <= Kr && Ar <= Kr && (Cr + Ar - Kr) * (1 - Math.pow((Cr - Ar) / Kr, 2)) < s3 * Kr)) return true;\n                  Cr = Ar;\n                }\n                return false;\n              }\n              function Zl(At, Wt) {\n                return !!vo(At.map(Su), nc(Wt));\n              }\n              function Su(At) {\n                return At = At.map(nc), At.pop(), At;\n              }\n              function nc(At) {\n                return [At[0] * d3, At[1] * d3];\n              }\n              function bs(At, Wt) {\n                return (At && cl.hasOwnProperty(At.type) ? cl[At.type] : zs)(At, Wt);\n              }\n              function Rn(At, Wt, Cr) {\n                var Ar = t3.range(At, Wt - o4, Cr).concat(Wt);\n                return function(Kr) {\n                  return Ar.map(function(ki) {\n                    return [Kr, ki];\n                  });\n                };\n              }\n              function _a(At, Wt, Cr) {\n                var Ar = t3.range(At, Wt - o4, Cr).concat(Wt);\n                return function(Kr) {\n                  return Ar.map(function(ki) {\n                    return [ki, Kr];\n                  });\n                };\n              }\n              function Vu() {\n                var At, Wt, Cr, Ar, Kr, ki, Xi, dn, wn = 10, Nn = wn, Yi = 90, Qi = 360, on, Fi, $n, Ca, Ra = 2.5;\n                function La() {\n                  return { type: "MultiLineString", coordinates: Na() };\n                }\n                function Na() {\n                  return t3.range(k4(Ar / Yi) * Yi, Cr, Yi).map($n).concat(t3.range(k4(dn / Qi) * Qi, Xi, Qi).map(Ca)).concat(t3.range(k4(Wt / wn) * wn, At, wn).filter(function(Yn) {\n                    return v3(Yn % Yi) > o4;\n                  }).map(on)).concat(t3.range(k4(ki / Nn) * Nn, Kr, Nn).filter(function(Yn) {\n                    return v3(Yn % Qi) > o4;\n                  }).map(Fi));\n                }\n                return La.lines = function() {\n                  return Na().map(function(Yn) {\n                    return { type: "LineString", coordinates: Yn };\n                  });\n                }, La.outline = function() {\n                  return { type: "Polygon", coordinates: [$n(Ar).concat(Ca(Xi).slice(1), $n(Cr).reverse().slice(1), Ca(dn).reverse().slice(1))] };\n                }, La.extent = function(Yn) {\n                  return arguments.length ? La.extentMajor(Yn).extentMinor(Yn) : La.extentMinor();\n                }, La.extentMajor = function(Yn) {\n                  return arguments.length ? (Ar = +Yn[0][0], Cr = +Yn[1][0], dn = +Yn[0][1], Xi = +Yn[1][1], Ar > Cr && (Yn = Ar, Ar = Cr, Cr = Yn), dn > Xi && (Yn = dn, dn = Xi, Xi = Yn), La.precision(Ra)) : [[Ar, dn], [Cr, Xi]];\n                }, La.extentMinor = function(Yn) {\n                  return arguments.length ? (Wt = +Yn[0][0], At = +Yn[1][0], ki = +Yn[0][1], Kr = +Yn[1][1], Wt > At && (Yn = Wt, Wt = At, At = Yn), ki > Kr && (Yn = ki, ki = Kr, Kr = Yn), La.precision(Ra)) : [[Wt, ki], [At, Kr]];\n                }, La.step = function(Yn) {\n                  return arguments.length ? La.stepMajor(Yn).stepMinor(Yn) : La.stepMinor();\n                }, La.stepMajor = function(Yn) {\n                  return arguments.length ? (Yi = +Yn[0], Qi = +Yn[1], La) : [Yi, Qi];\n                }, La.stepMinor = function(Yn) {\n                  return arguments.length ? (wn = +Yn[0], Nn = +Yn[1], La) : [wn, Nn];\n                }, La.precision = function(Yn) {\n                  return arguments.length ? (Ra = +Yn, on = Rn(ki, Kr, 90), Fi = _a(Wt, At, Ra), $n = Rn(dn, Xi, 90), Ca = _a(Ar, Cr, Ra), La) : Ra;\n                }, La.extentMajor([[-180, -90 + o4], [180, 90 - o4]]).extentMinor([[-180, -80 - o4], [180, 80 + o4]]);\n              }\n              function Ol() {\n                return Vu()();\n              }\n              function xo(At, Wt) {\n                var Cr = At[0] * d3, Ar = At[1] * d3, Kr = Wt[0] * d3, ki = Wt[1] * d3, Xi = p3(Ar), dn = x2(Ar), wn = p3(ki), Nn = x2(ki), Yi = Xi * p3(Cr), Qi = Xi * x2(Cr), on = wn * p3(Kr), Fi = wn * x2(Kr), $n = 2 * T3(M4(z3(ki - Ar) + Xi * wn * z3(Kr - Cr))), Ca = x2($n), Ra = $n ? function(La) {\n                  var Na = x2(La *= $n) / Ca, Yn = x2($n - La) / Ca, Dn = Yn * Yi + Na * on, Ka = Yn * Qi + Na * Fi, bo = Yn * dn + Na * Nn;\n                  return [b(Ka, Dn) * h3, b(bo, M4(Dn * Dn + Ka * Ka)) * h3];\n                } : function() {\n                  return [Cr * h3, Ar * h3];\n                };\n                return Ra.distance = $n, Ra;\n              }\n              function Yl(At) {\n                return At;\n              }\n              var Ns = r4(), Hl = r4(), ac, aa, Oo, qo, ql = { point: O3, lineStart: O3, lineEnd: O3, polygonStart: function() {\n                ql.lineStart = Pc, ql.lineEnd = Uf;\n              }, polygonEnd: function() {\n                ql.lineStart = ql.lineEnd = ql.point = O3, Ns.add(v3(Hl)), Hl.reset();\n              }, result: function() {\n                var At = Ns / 2;\n                return Ns.reset(), At;\n              } };\n              function Pc() {\n                ql.point = Do;\n              }\n              function Do(At, Wt) {\n                ql.point = rf, ac = Oo = At, aa = qo = Wt;\n              }\n              function rf(At, Wt) {\n                Hl.add(qo * At - Oo * Wt), Oo = At, qo = Wt;\n              }\n              function Uf() {\n                rf(ac, aa);\n              }\n              var pl = 1 / 0, Zc = pl, Kl = -pl, Os = Kl, yu = { point: oc, lineStart: O3, lineEnd: O3, polygonStart: O3, polygonEnd: O3, result: function() {\n                var At = [[pl, Zc], [Kl, Os]];\n                return Kl = Os = -(Zc = pl = 1 / 0), At;\n              } };\n              function oc(At, Wt) {\n                At < pl && (pl = At), At > Kl && (Kl = At), Wt < Zc && (Zc = Wt), Wt > Os && (Os = Wt);\n              }\n              var Cf = 0, sc = 0, Vh = 0, Lf = 0, cs = 0, nf = 0, Vf = 0, Jl = 0, fl = 0, lc, Fu, Es, Hs, Go = { point: ps, lineStart: uc, lineEnd: qs, polygonStart: function() {\n                Go.lineStart = ad, Go.lineEnd = Po;\n              }, polygonEnd: function() {\n                Go.point = ps, Go.lineStart = uc, Go.lineEnd = qs;\n              }, result: function() {\n                var At = fl ? [Vf / fl, Jl / fl] : nf ? [Lf / nf, cs / nf] : Vh ? [Cf / Vh, sc / Vh] : [NaN, NaN];\n                return Cf = sc = Vh = Lf = cs = nf = Vf = Jl = fl = 0, At;\n              } };\n              function ps(At, Wt) {\n                Cf += At, sc += Wt, ++Vh;\n              }\n              function uc() {\n                Go.point = xl;\n              }\n              function xl(At, Wt) {\n                Go.point = Gu, ps(Es = At, Hs = Wt);\n              }\n              function Gu(At, Wt) {\n                var Cr = At - Es, Ar = Wt - Hs, Kr = M4(Cr * Cr + Ar * Ar);\n                Lf += Kr * (Es + At) / 2, cs += Kr * (Hs + Wt) / 2, nf += Kr, ps(Es = At, Hs = Wt);\n              }\n              function qs() {\n                Go.point = ps;\n              }\n              function ad() {\n                Go.point = od;\n              }\n              function Po() {\n                Yo(lc, Fu);\n              }\n              function od(At, Wt) {\n                Go.point = Yo, ps(lc = Es = At, Fu = Hs = Wt);\n              }\n              function Yo(At, Wt) {\n                var Cr = At - Es, Ar = Wt - Hs, Kr = M4(Cr * Cr + Ar * Ar);\n                Lf += Kr * (Es + At) / 2, cs += Kr * (Hs + Wt) / 2, nf += Kr, Kr = Hs * At - Es * Wt, Vf += Kr * (Es + At), Jl += Kr * (Hs + Wt), fl += Kr * 3, ps(Es = At, Hs = Wt);\n              }\n              function Pa(At) {\n                this._context = At;\n              }\n              Pa.prototype = { _radius: 4.5, pointRadius: function(At) {\n                return this._radius = At, this;\n              }, polygonStart: function() {\n                this._line = 0;\n              }, polygonEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._point = 0;\n              }, lineEnd: function() {\n                this._line === 0 && this._context.closePath(), this._point = NaN;\n              }, point: function(At, Wt) {\n                switch (this._point) {\n                  case 0: {\n                    this._context.moveTo(At, Wt), this._point = 1;\n                    break;\n                  }\n                  case 1: {\n                    this._context.lineTo(At, Wt);\n                    break;\n                  }\n                  default: {\n                    this._context.moveTo(At + this._radius, Wt), this._context.arc(At, Wt, this._radius, 0, f4);\n                    break;\n                  }\n                }\n              }, result: O3 };\n              var af = r4(), Hu, bl, Gf, Ic, yf, Bl = { point: O3, lineStart: function() {\n                Bl.point = wh;\n              }, lineEnd: function() {\n                Hu && Qf(bl, Gf), Bl.point = O3;\n              }, polygonStart: function() {\n                Hu = true;\n              }, polygonEnd: function() {\n                Hu = null;\n              }, result: function() {\n                var At = +af;\n                return af.reset(), At;\n              } };\n              function wh(At, Wt) {\n                Bl.point = Qf, bl = Ic = At, Gf = yf = Wt;\n              }\n              function Qf(At, Wt) {\n                Ic -= At, yf -= Wt, af.add(M4(Ic * Ic + yf * yf)), Ic = At, yf = Wt;\n              }\n              function _f() {\n                this._string = [];\n              }\n              _f.prototype = { _radius: 4.5, _circle: Yc(4.5), pointRadius: function(At) {\n                return (At = +At) !== this._radius && (this._radius = At, this._circle = null), this;\n              }, polygonStart: function() {\n                this._line = 0;\n              }, polygonEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._point = 0;\n              }, lineEnd: function() {\n                this._line === 0 && this._string.push("Z"), this._point = NaN;\n              }, point: function(At, Wt) {\n                switch (this._point) {\n                  case 0: {\n                    this._string.push("M", At, ",", Wt), this._point = 1;\n                    break;\n                  }\n                  case 1: {\n                    this._string.push("L", At, ",", Wt);\n                    break;\n                  }\n                  default: {\n                    this._circle == null && (this._circle = Yc(this._radius)), this._string.push("M", At, ",", Wt, this._circle);\n                    break;\n                  }\n                }\n              }, result: function() {\n                if (this._string.length) {\n                  var At = this._string.join("");\n                  return this._string = [], At;\n                } else return null;\n              } };\n              function Yc(At) {\n                return "m0," + At + "a" + At + "," + At + " 0 1,1 0," + -2 * At + "a" + At + "," + At + " 0 1,1 0," + 2 * At + "z";\n              }\n              function eh(At, Wt) {\n                var Cr = 4.5, Ar, Kr;\n                function ki(Xi) {\n                  return Xi && (typeof Cr == "function" && Kr.pointRadius(+Cr.apply(this, arguments)), H(Xi, Ar(Kr))), Kr.result();\n                }\n                return ki.area = function(Xi) {\n                  return H(Xi, Ar(ql)), ql.result();\n                }, ki.measure = function(Xi) {\n                  return H(Xi, Ar(Bl)), Bl.result();\n                }, ki.bounds = function(Xi) {\n                  return H(Xi, Ar(yu)), yu.result();\n                }, ki.centroid = function(Xi) {\n                  return H(Xi, Ar(Go)), Go.result();\n                }, ki.projection = function(Xi) {\n                  return arguments.length ? (Ar = Xi == null ? (At = null, Yl) : (At = Xi).stream, ki) : At;\n                }, ki.context = function(Xi) {\n                  return arguments.length ? (Kr = Xi == null ? (Wt = null, new _f()) : new Pa(Wt = Xi), typeof Cr != "function" && Kr.pointRadius(Cr), ki) : Wt;\n                }, ki.pointRadius = function(Xi) {\n                  return arguments.length ? (Cr = typeof Xi == "function" ? Xi : (Kr.pointRadius(+Xi), +Xi), ki) : Cr;\n                }, ki.projection(At).context(Wt);\n              }\n              function th(At) {\n                return { stream: ju(At) };\n              }\n              function ju(At) {\n                return function(Wt) {\n                  var Cr = new Hf();\n                  for (var Ar in At) Cr[Ar] = At[Ar];\n                  return Cr.stream = Wt, Cr;\n                };\n              }\n              function Hf() {\n              }\n              Hf.prototype = { constructor: Hf, point: function(At, Wt) {\n                this.stream.point(At, Wt);\n              }, sphere: function() {\n                this.stream.sphere();\n              }, lineStart: function() {\n                this.stream.lineStart();\n              }, lineEnd: function() {\n                this.stream.lineEnd();\n              }, polygonStart: function() {\n                this.stream.polygonStart();\n              }, polygonEnd: function() {\n                this.stream.polygonEnd();\n              } };\n              function cc(At, Wt, Cr) {\n                var Ar = At.clipExtent && At.clipExtent();\n                return At.scale(150).translate([0, 0]), Ar != null && At.clipExtent(null), H(Cr, At.stream(yu)), Wt(yu.result()), Ar != null && At.clipExtent(Ar), At;\n              }\n              function of(At, Wt, Cr) {\n                return cc(At, function(Ar) {\n                  var Kr = Wt[1][0] - Wt[0][0], ki = Wt[1][1] - Wt[0][1], Xi = Math.min(Kr / (Ar[1][0] - Ar[0][0]), ki / (Ar[1][1] - Ar[0][1])), dn = +Wt[0][0] + (Kr - Xi * (Ar[1][0] + Ar[0][0])) / 2, wn = +Wt[0][1] + (ki - Xi * (Ar[1][1] + Ar[0][1])) / 2;\n                  At.scale(150 * Xi).translate([dn, wn]);\n                }, Cr);\n              }\n              function Nl(At, Wt, Cr) {\n                return of(At, [[0, 0], Wt], Cr);\n              }\n              function Kc(At, Wt, Cr) {\n                return cc(At, function(Ar) {\n                  var Kr = +Wt, ki = Kr / (Ar[1][0] - Ar[0][0]), Xi = (Kr - ki * (Ar[1][0] + Ar[0][0])) / 2, dn = -ki * Ar[0][1];\n                  At.scale(150 * ki).translate([Xi, dn]);\n                }, Cr);\n              }\n              function Rc(At, Wt, Cr) {\n                return cc(At, function(Ar) {\n                  var Kr = +Wt, ki = Kr / (Ar[1][1] - Ar[0][1]), Xi = -ki * Ar[0][0], dn = (Kr - ki * (Ar[1][1] + Ar[0][1])) / 2;\n                  At.scale(150 * ki).translate([Xi, dn]);\n                }, Cr);\n              }\n              var gs = 16, jf = p3(30 * d3);\n              function Gh(At, Wt) {\n                return +Wt ? sf(At, Wt) : rh(At);\n              }\n              function rh(At) {\n                return ju({ point: function(Wt, Cr) {\n                  Wt = At(Wt, Cr), this.stream.point(Wt[0], Wt[1]);\n                } });\n              }\n              function sf(At, Wt) {\n                function Cr(Ar, Kr, ki, Xi, dn, wn, Nn, Yi, Qi, on, Fi, $n, Ca, Ra) {\n                  var La = Nn - Ar, Na = Yi - Kr, Yn = La * La + Na * Na;\n                  if (Yn > 4 * Wt && Ca--) {\n                    var Dn = Xi + on, Ka = dn + Fi, bo = wn + $n, Xo = M4(Dn * Dn + Ka * Ka + bo * bo), Ss = T3(bo /= Xo), as = v3(v3(bo) - 1) < o4 || v3(ki - Qi) < o4 ? (ki + Qi) / 2 : b(Ka, Dn), ws = At(as, Ss), Ho = ws[0], ml = ws[1], Ws = Ho - Ar, Ls = ml - Kr, va = Na * Ws - La * Ls;\n                    (va * va / Yn > Wt || v3((La * Ws + Na * Ls) / Yn - 0.5) > 0.3 || Xi * on + dn * Fi + wn * $n < jf) && (Cr(Ar, Kr, ki, Xi, dn, wn, Ho, ml, as, Dn /= Xo, Ka /= Xo, bo, Ca, Ra), Ra.point(Ho, ml), Cr(Ho, ml, as, Dn, Ka, bo, Nn, Yi, Qi, on, Fi, $n, Ca, Ra));\n                  }\n                }\n                return function(Ar) {\n                  var Kr, ki, Xi, dn, wn, Nn, Yi, Qi, on, Fi, $n, Ca, Ra = { point: La, lineStart: Na, lineEnd: Dn, polygonStart: function() {\n                    Ar.polygonStart(), Ra.lineStart = Ka;\n                  }, polygonEnd: function() {\n                    Ar.polygonEnd(), Ra.lineStart = Na;\n                  } };\n                  function La(Ss, as) {\n                    Ss = At(Ss, as), Ar.point(Ss[0], Ss[1]);\n                  }\n                  function Na() {\n                    Qi = NaN, Ra.point = Yn, Ar.lineStart();\n                  }\n                  function Yn(Ss, as) {\n                    var ws = ce([Ss, as]), Ho = At(Ss, as);\n                    Cr(Qi, on, Yi, Fi, $n, Ca, Qi = Ho[0], on = Ho[1], Yi = Ss, Fi = ws[0], $n = ws[1], Ca = ws[2], gs, Ar), Ar.point(Qi, on);\n                  }\n                  function Dn() {\n                    Ra.point = La, Ar.lineEnd();\n                  }\n                  function Ka() {\n                    Na(), Ra.point = bo, Ra.lineEnd = Xo;\n                  }\n                  function bo(Ss, as) {\n                    Yn(Kr = Ss, as), ki = Qi, Xi = on, dn = Fi, wn = $n, Nn = Ca, Ra.point = Yn;\n                  }\n                  function Xo() {\n                    Cr(Qi, on, Yi, Fi, $n, Ca, ki, Xi, Kr, dn, wn, Nn, gs, Ar), Ra.lineEnd = Dn, Dn();\n                  }\n                  return Ra;\n                };\n              }\n              var Th = ju({ point: function(At, Wt) {\n                this.stream.point(At * d3, Wt * d3);\n              } });\n              function Mu(At) {\n                return ju({ point: function(Wt, Cr) {\n                  var Ar = At(Wt, Cr);\n                  return this.stream.point(Ar[0], Ar[1]);\n                } });\n              }\n              function ih(At, Wt, Cr, Ar, Kr) {\n                function ki(Xi, dn) {\n                  return Xi *= Ar, dn *= Kr, [Wt + At * Xi, Cr - At * dn];\n                }\n                return ki.invert = function(Xi, dn) {\n                  return [(Xi - Wt) / At * Ar, (Cr - dn) / At * Kr];\n                }, ki;\n              }\n              function js(At, Wt, Cr, Ar, Kr, ki) {\n                var Xi = p3(ki), dn = x2(ki), wn = Xi * At, Nn = dn * At, Yi = Xi / At, Qi = dn / At, on = (dn * Cr - Xi * Wt) / At, Fi = (dn * Wt + Xi * Cr) / At;\n                function $n(Ca, Ra) {\n                  return Ca *= Ar, Ra *= Kr, [wn * Ca - Nn * Ra + Wt, Cr - Nn * Ca - wn * Ra];\n                }\n                return $n.invert = function(Ca, Ra) {\n                  return [Ar * (Yi * Ca - Qi * Ra + on), Kr * (Fi - Qi * Ca - Yi * Ra)];\n                }, $n;\n              }\n              function Eu(At) {\n                return Dc(function() {\n                  return At;\n                })();\n              }\n              function Dc(At) {\n                var Wt, Cr = 150, Ar = 480, Kr = 250, ki = 0, Xi = 0, dn = 0, wn = 0, Nn = 0, Yi, Qi = 0, on = 1, Fi = 1, $n = null, Ca = Jr, Ra = null, La, Na, Yn, Dn = Yl, Ka = 0.5, bo, Xo, Ss, as, ws;\n                function Ho(va) {\n                  return Ss(va[0] * d3, va[1] * d3);\n                }\n                function ml(va) {\n                  return va = Ss.invert(va[0], va[1]), va && [va[0] * h3, va[1] * h3];\n                }\n                Ho.stream = function(va) {\n                  return as && ws === va ? as : as = Th(Mu(Yi)(Ca(bo(Dn(ws = va)))));\n                }, Ho.preclip = function(va) {\n                  return arguments.length ? (Ca = va, $n = void 0, Ls()) : Ca;\n                }, Ho.postclip = function(va) {\n                  return arguments.length ? (Dn = va, Ra = La = Na = Yn = null, Ls()) : Dn;\n                }, Ho.clipAngle = function(va) {\n                  return arguments.length ? (Ca = +va ? Mn($n = va * d3) : ($n = null, Jr), Ls()) : $n * h3;\n                }, Ho.clipExtent = function(va) {\n                  return arguments.length ? (Dn = va == null ? (Ra = La = Na = Yn = null, Yl) : Jn(Ra = +va[0][0], La = +va[0][1], Na = +va[1][0], Yn = +va[1][1]), Ls()) : Ra == null ? null : [[Ra, La], [Na, Yn]];\n                }, Ho.scale = function(va) {\n                  return arguments.length ? (Cr = +va, Ws()) : Cr;\n                }, Ho.translate = function(va) {\n                  return arguments.length ? (Ar = +va[0], Kr = +va[1], Ws()) : [Ar, Kr];\n                }, Ho.center = function(va) {\n                  return arguments.length ? (ki = va[0] % 360 * d3, Xi = va[1] % 360 * d3, Ws()) : [ki * h3, Xi * h3];\n                }, Ho.rotate = function(va) {\n                  return arguments.length ? (dn = va[0] % 360 * d3, wn = va[1] % 360 * d3, Nn = va.length > 2 ? va[2] % 360 * d3 : 0, Ws()) : [dn * h3, wn * h3, Nn * h3];\n                }, Ho.angle = function(va) {\n                  return arguments.length ? (Qi = va % 360 * d3, Ws()) : Qi * h3;\n                }, Ho.reflectX = function(va) {\n                  return arguments.length ? (on = va ? -1 : 1, Ws()) : on < 0;\n                }, Ho.reflectY = function(va) {\n                  return arguments.length ? (Fi = va ? -1 : 1, Ws()) : Fi < 0;\n                }, Ho.precision = function(va) {\n                  return arguments.length ? (bo = Gh(Xo, Ka = va * va), Ls()) : M4(Ka);\n                }, Ho.fitExtent = function(va, no) {\n                  return of(Ho, va, no);\n                }, Ho.fitSize = function(va, no) {\n                  return Nl(Ho, va, no);\n                }, Ho.fitWidth = function(va, no) {\n                  return Kc(Ho, va, no);\n                }, Ho.fitHeight = function(va, no) {\n                  return Rc(Ho, va, no);\n                };\n                function Ws() {\n                  var va = js(Cr, 0, 0, on, Fi, Qi).apply(null, Wt(ki, Xi)), no = (Qi ? js : ih)(Cr, Ar - va[0], Kr - va[1], on, Fi, Qi);\n                  return Yi = Oi(dn, wn, Nn), Xo = ri(Wt, no), Ss = ri(Yi, Xo), bo = Gh(Xo, Ka), Ls();\n                }\n                function Ls() {\n                  return as = ws = null, Ho;\n                }\n                return function() {\n                  return Wt = At.apply(this, arguments), Ho.invert = Wt.invert && ml, Ws();\n                };\n              }\n              function ks(At) {\n                var Wt = 0, Cr = l3 / 3, Ar = Dc(At), Kr = Ar(Wt, Cr);\n                return Kr.parallels = function(ki) {\n                  return arguments.length ? Ar(Wt = ki[0] * d3, Cr = ki[1] * d3) : [Wt * h3, Cr * h3];\n                }, Kr;\n              }\n              function bc(At) {\n                var Wt = p3(At);\n                function Cr(Ar, Kr) {\n                  return [Ar * Wt, x2(Kr) / Wt];\n                }\n                return Cr.invert = function(Ar, Kr) {\n                  return [Ar / Wt, T3(Kr * Wt)];\n                }, Cr;\n              }\n              function hu(At, Wt) {\n                var Cr = x2(At), Ar = (Cr + x2(Wt)) / 2;\n                if (v3(Ar) < o4) return bc(At);\n                var Kr = 1 + Cr * (2 * Ar - Cr), ki = M4(Kr) / Ar;\n                function Xi(dn, wn) {\n                  var Nn = M4(Kr - 2 * Ar * x2(wn)) / Ar;\n                  return [Nn * x2(dn *= Ar), ki - Nn * p3(dn)];\n                }\n                return Xi.invert = function(dn, wn) {\n                  var Nn = ki - wn, Yi = b(dn, v3(Nn)) * C3(Nn);\n                  return Nn * Ar < 0 && (Yi -= l3 * C3(dn) * C3(Nn)), [Yi / Ar, T3((Kr - (dn * dn + Nn * Nn) * Ar * Ar) / (2 * Ar))];\n                }, Xi;\n              }\n              function _u() {\n                return ks(hu).scale(155.424).center([0, 33.6442]);\n              }\n              function nl() {\n                return _u().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-0.6, 38.7]);\n              }\n              function nh(At) {\n                var Wt = At.length;\n                return { point: function(Cr, Ar) {\n                  for (var Kr = -1; ++Kr < Wt; ) At[Kr].point(Cr, Ar);\n                }, sphere: function() {\n                  for (var Cr = -1; ++Cr < Wt; ) At[Cr].sphere();\n                }, lineStart: function() {\n                  for (var Cr = -1; ++Cr < Wt; ) At[Cr].lineStart();\n                }, lineEnd: function() {\n                  for (var Cr = -1; ++Cr < Wt; ) At[Cr].lineEnd();\n                }, polygonStart: function() {\n                  for (var Cr = -1; ++Cr < Wt; ) At[Cr].polygonStart();\n                }, polygonEnd: function() {\n                  for (var Cr = -1; ++Cr < Wt; ) At[Cr].polygonEnd();\n                } };\n              }\n              function Ah() {\n                var At, Wt, Cr = nl(), Ar, Kr = _u().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), ki, Xi = _u().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), dn, wn, Nn = { point: function(on, Fi) {\n                  wn = [on, Fi];\n                } };\n                function Yi(on) {\n                  var Fi = on[0], $n = on[1];\n                  return wn = null, Ar.point(Fi, $n), wn || (ki.point(Fi, $n), wn) || (dn.point(Fi, $n), wn);\n                }\n                Yi.invert = function(on) {\n                  var Fi = Cr.scale(), $n = Cr.translate(), Ca = (on[0] - $n[0]) / Fi, Ra = (on[1] - $n[1]) / Fi;\n                  return (Ra >= 0.12 && Ra < 0.234 && Ca >= -0.425 && Ca < -0.214 ? Kr : Ra >= 0.166 && Ra < 0.234 && Ca >= -0.214 && Ca < -0.115 ? Xi : Cr).invert(on);\n                }, Yi.stream = function(on) {\n                  return At && Wt === on ? At : At = nh([Cr.stream(Wt = on), Kr.stream(on), Xi.stream(on)]);\n                }, Yi.precision = function(on) {\n                  return arguments.length ? (Cr.precision(on), Kr.precision(on), Xi.precision(on), Qi()) : Cr.precision();\n                }, Yi.scale = function(on) {\n                  return arguments.length ? (Cr.scale(on), Kr.scale(on * 0.35), Xi.scale(on), Yi.translate(Cr.translate())) : Cr.scale();\n                }, Yi.translate = function(on) {\n                  if (!arguments.length) return Cr.translate();\n                  var Fi = Cr.scale(), $n = +on[0], Ca = +on[1];\n                  return Ar = Cr.translate(on).clipExtent([[$n - 0.455 * Fi, Ca - 0.238 * Fi], [$n + 0.455 * Fi, Ca + 0.238 * Fi]]).stream(Nn), ki = Kr.translate([$n - 0.307 * Fi, Ca + 0.201 * Fi]).clipExtent([[$n - 0.425 * Fi + o4, Ca + 0.12 * Fi + o4], [$n - 0.214 * Fi - o4, Ca + 0.234 * Fi - o4]]).stream(Nn), dn = Xi.translate([$n - 0.205 * Fi, Ca + 0.212 * Fi]).clipExtent([[$n - 0.214 * Fi + o4, Ca + 0.166 * Fi + o4], [$n - 0.115 * Fi - o4, Ca + 0.234 * Fi - o4]]).stream(Nn), Qi();\n                }, Yi.fitExtent = function(on, Fi) {\n                  return of(Yi, on, Fi);\n                }, Yi.fitSize = function(on, Fi) {\n                  return Nl(Yi, on, Fi);\n                }, Yi.fitWidth = function(on, Fi) {\n                  return Kc(Yi, on, Fi);\n                }, Yi.fitHeight = function(on, Fi) {\n                  return Rc(Yi, on, Fi);\n                };\n                function Qi() {\n                  return At = Wt = null, Yi;\n                }\n                return Yi.scale(1070);\n              }\n              function zu(At) {\n                return function(Wt, Cr) {\n                  var Ar = p3(Wt), Kr = p3(Cr), ki = At(Ar * Kr);\n                  return [ki * Kr * x2(Wt), ki * x2(Cr)];\n                };\n              }\n              function Fc(At) {\n                return function(Wt, Cr) {\n                  var Ar = M4(Wt * Wt + Cr * Cr), Kr = At(Ar), ki = x2(Kr), Xi = p3(Kr);\n                  return [b(Wt * ki, Ar * Xi), T3(Ar && Cr * ki / Ar)];\n                };\n              }\n              var wc = zu(function(At) {\n                return M4(2 / (1 + At));\n              });\n              wc.invert = Fc(function(At) {\n                return 2 * T3(At / 2);\n              });\n              function bd() {\n                return Eu(wc).scale(124.75).clipAngle(180 - 1e-3);\n              }\n              var xf = zu(function(At) {\n                return (At = P3(At)) && At / x2(At);\n              });\n              xf.invert = Fc(function(At) {\n                return At;\n              });\n              function Pf() {\n                return Eu(xf).scale(79.4188).clipAngle(180 - 1e-3);\n              }\n              function Ou(At, Wt) {\n                return [At, S2(g3((u4 + Wt) / 2))];\n              }\n              Ou.invert = function(At, Wt) {\n                return [At, 2 * _2(E3(Wt)) - u4];\n              };\n              function bf() {\n                return jl(Ou).scale(961 / f4);\n              }\n              function jl(At) {\n                var Wt = Eu(At), Cr = Wt.center, Ar = Wt.scale, Kr = Wt.translate, ki = Wt.clipExtent, Xi = null, dn, wn, Nn;\n                Wt.scale = function(Qi) {\n                  return arguments.length ? (Ar(Qi), Yi()) : Ar();\n                }, Wt.translate = function(Qi) {\n                  return arguments.length ? (Kr(Qi), Yi()) : Kr();\n                }, Wt.center = function(Qi) {\n                  return arguments.length ? (Cr(Qi), Yi()) : Cr();\n                }, Wt.clipExtent = function(Qi) {\n                  return arguments.length ? (Qi == null ? Xi = dn = wn = Nn = null : (Xi = +Qi[0][0], dn = +Qi[0][1], wn = +Qi[1][0], Nn = +Qi[1][1]), Yi()) : Xi == null ? null : [[Xi, dn], [wn, Nn]];\n                };\n                function Yi() {\n                  var Qi = l3 * Ar(), on = Wt(yn(Wt.rotate()).invert([0, 0]));\n                  return ki(Xi == null ? [[on[0] - Qi, on[1] - Qi], [on[0] + Qi, on[1] + Qi]] : At === Ou ? [[Math.max(on[0] - Qi, Xi), dn], [Math.min(on[0] + Qi, wn), Nn]] : [[Xi, Math.max(on[1] - Qi, dn)], [wn, Math.min(on[1] + Qi, Nn)]]);\n                }\n                return Yi();\n              }\n              function lf(At) {\n                return g3((u4 + At) / 2);\n              }\n              function Hh(At, Wt) {\n                var Cr = p3(At), Ar = At === Wt ? x2(At) : S2(Cr / p3(Wt)) / S2(lf(Wt) / lf(At)), Kr = Cr * L3(lf(At), Ar) / Ar;\n                if (!Ar) return Ou;\n                function ki(Xi, dn) {\n                  Kr > 0 ? dn < -u4 + o4 && (dn = -u4 + o4) : dn > u4 - o4 && (dn = u4 - o4);\n                  var wn = Kr / L3(lf(dn), Ar);\n                  return [wn * x2(Ar * Xi), Kr - wn * p3(Ar * Xi)];\n                }\n                return ki.invert = function(Xi, dn) {\n                  var wn = Kr - dn, Nn = C3(Ar) * M4(Xi * Xi + wn * wn), Yi = b(Xi, v3(wn)) * C3(wn);\n                  return wn * Ar < 0 && (Yi -= l3 * C3(Xi) * C3(wn)), [Yi / Ar, 2 * _2(L3(Kr / Nn, 1 / Ar)) - u4];\n                }, ki;\n              }\n              function If() {\n                return ks(Hh).scale(109.5).parallels([30, 30]);\n              }\n              function Cs(At, Wt) {\n                return [At, Wt];\n              }\n              Cs.invert = Cs;\n              function du() {\n                return Eu(Cs).scale(152.63);\n              }\n              function ku(At, Wt) {\n                var Cr = p3(At), Ar = At === Wt ? x2(At) : (Cr - p3(Wt)) / (Wt - At), Kr = Cr / Ar + At;\n                if (v3(Ar) < o4) return Cs;\n                function ki(Xi, dn) {\n                  var wn = Kr - dn, Nn = Ar * Xi;\n                  return [wn * x2(Nn), Kr - wn * p3(Nn)];\n                }\n                return ki.invert = function(Xi, dn) {\n                  var wn = Kr - dn, Nn = b(Xi, v3(wn)) * C3(wn);\n                  return wn * Ar < 0 && (Nn -= l3 * C3(Xi) * C3(wn)), [Nn / Ar, Kr - C3(Ar) * M4(Xi * Xi + wn * wn)];\n                }, ki;\n              }\n              function Wf() {\n                return ks(ku).scale(131.154).center([0, 13.9389]);\n              }\n              var Us = 1.340264, wf = -0.081106, zc = 893e-6, Wu = 3796e-6, Rf = M4(3) / 2, Xu = 12;\n              function uf(At, Wt) {\n                var Cr = T3(Rf * x2(Wt)), Ar = Cr * Cr, Kr = Ar * Ar * Ar;\n                return [At * p3(Cr) / (Rf * (Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar))), Cr * (Us + wf * Ar + Kr * (zc + Wu * Ar))];\n              }\n              uf.invert = function(At, Wt) {\n                for (var Cr = Wt, Ar = Cr * Cr, Kr = Ar * Ar * Ar, ki = 0, Xi, dn, wn; ki < Xu && (dn = Cr * (Us + wf * Ar + Kr * (zc + Wu * Ar)) - Wt, wn = Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar), Cr -= Xi = dn / wn, Ar = Cr * Cr, Kr = Ar * Ar * Ar, !(v3(Xi) < s3)); ++ki) ;\n                return [Rf * At * (Us + 3 * wf * Ar + Kr * (7 * zc + 9 * Wu * Ar)) / p3(Cr), T3(x2(Cr) / Rf)];\n              };\n              function Xf() {\n                return Eu(uf).scale(177.158);\n              }\n              function Wl(At, Wt) {\n                var Cr = p3(Wt), Ar = p3(At) * Cr;\n                return [Cr * x2(At) / Ar, x2(Wt) / Ar];\n              }\n              Wl.invert = Fc(_2);\n              function ah() {\n                return Eu(Wl).scale(144.049).clipAngle(60);\n              }\n              function Zu() {\n                var At = 1, Wt = 0, Cr = 0, Ar = 1, Kr = 1, ki = 0, Xi, dn, wn = null, Nn, Yi, Qi, on = 1, Fi = 1, $n = ju({ point: function(Dn, Ka) {\n                  var bo = Yn([Dn, Ka]);\n                  this.stream.point(bo[0], bo[1]);\n                } }), Ca = Yl, Ra, La;\n                function Na() {\n                  return on = At * Ar, Fi = At * Kr, Ra = La = null, Yn;\n                }\n                function Yn(Dn) {\n                  var Ka = Dn[0] * on, bo = Dn[1] * Fi;\n                  if (ki) {\n                    var Xo = bo * Xi - Ka * dn;\n                    Ka = Ka * Xi + bo * dn, bo = Xo;\n                  }\n                  return [Ka + Wt, bo + Cr];\n                }\n                return Yn.invert = function(Dn) {\n                  var Ka = Dn[0] - Wt, bo = Dn[1] - Cr;\n                  if (ki) {\n                    var Xo = bo * Xi + Ka * dn;\n                    Ka = Ka * Xi - bo * dn, bo = Xo;\n                  }\n                  return [Ka / on, bo / Fi];\n                }, Yn.stream = function(Dn) {\n                  return Ra && La === Dn ? Ra : Ra = $n(Ca(La = Dn));\n                }, Yn.postclip = function(Dn) {\n                  return arguments.length ? (Ca = Dn, wn = Nn = Yi = Qi = null, Na()) : Ca;\n                }, Yn.clipExtent = function(Dn) {\n                  return arguments.length ? (Ca = Dn == null ? (wn = Nn = Yi = Qi = null, Yl) : Jn(wn = +Dn[0][0], Nn = +Dn[0][1], Yi = +Dn[1][0], Qi = +Dn[1][1]), Na()) : wn == null ? null : [[wn, Nn], [Yi, Qi]];\n                }, Yn.scale = function(Dn) {\n                  return arguments.length ? (At = +Dn, Na()) : At;\n                }, Yn.translate = function(Dn) {\n                  return arguments.length ? (Wt = +Dn[0], Cr = +Dn[1], Na()) : [Wt, Cr];\n                }, Yn.angle = function(Dn) {\n                  return arguments.length ? (ki = Dn % 360 * d3, dn = x2(ki), Xi = p3(ki), Na()) : ki * h3;\n                }, Yn.reflectX = function(Dn) {\n                  return arguments.length ? (Ar = Dn ? -1 : 1, Na()) : Ar < 0;\n                }, Yn.reflectY = function(Dn) {\n                  return arguments.length ? (Kr = Dn ? -1 : 1, Na()) : Kr < 0;\n                }, Yn.fitExtent = function(Dn, Ka) {\n                  return of(Yn, Dn, Ka);\n                }, Yn.fitSize = function(Dn, Ka) {\n                  return Nl(Yn, Dn, Ka);\n                }, Yn.fitWidth = function(Dn, Ka) {\n                  return Kc(Yn, Dn, Ka);\n                }, Yn.fitHeight = function(Dn, Ka) {\n                  return Rc(Yn, Dn, Ka);\n                }, Yn;\n              }\n              function Oc(At, Wt) {\n                var Cr = Wt * Wt, Ar = Cr * Cr;\n                return [At * (0.8707 - 0.131979 * Cr + Ar * (-0.013791 + Ar * (3971e-6 * Cr - 1529e-6 * Ar))), Wt * (1.007226 + Cr * (0.015085 + Ar * (-0.044475 + 0.028874 * Cr - 5916e-6 * Ar)))];\n              }\n              Oc.invert = function(At, Wt) {\n                var Cr = Wt, Ar = 25, Kr;\n                do {\n                  var ki = Cr * Cr, Xi = ki * ki;\n                  Cr -= Kr = (Cr * (1.007226 + ki * (0.015085 + Xi * (-0.044475 + 0.028874 * ki - 5916e-6 * Xi))) - Wt) / (1.007226 + ki * (0.015085 * 3 + Xi * (-0.044475 * 7 + 0.028874 * 9 * ki - 5916e-6 * 11 * Xi)));\n                } while (v3(Kr) > o4 && --Ar > 0);\n                return [At / (0.8707 + (ki = Cr * Cr) * (-0.131979 + ki * (-0.013791 + ki * ki * ki * (3971e-6 - 1529e-6 * ki)))), Cr];\n              };\n              function Tc() {\n                return Eu(Oc).scale(175.295);\n              }\n              function wl(At, Wt) {\n                return [p3(Wt) * x2(At), x2(Wt)];\n              }\n              wl.invert = Fc(T3);\n              function vu() {\n                return Eu(wl).scale(249.5).clipAngle(90 + o4);\n              }\n              function qc(At, Wt) {\n                var Cr = p3(Wt), Ar = 1 + p3(At) * Cr;\n                return [Cr * x2(At) / Ar, x2(Wt) / Ar];\n              }\n              qc.invert = Fc(function(At) {\n                return 2 * _2(At);\n              });\n              function cf() {\n                return Eu(qc).scale(250).clipAngle(142);\n              }\n              function fc(At, Wt) {\n                return [S2(g3((u4 + Wt) / 2)), -At];\n              }\n              fc.invert = function(At, Wt) {\n                return [-Wt, 2 * _2(E3(At)) - u4];\n              };\n              function Bc() {\n                var At = jl(fc), Wt = At.center, Cr = At.rotate;\n                return At.center = function(Ar) {\n                  return arguments.length ? Wt([-Ar[1], Ar[0]]) : (Ar = Wt(), [Ar[1], -Ar[0]]);\n                }, At.rotate = function(Ar) {\n                  return arguments.length ? Cr([Ar[0], Ar[1], Ar.length > 2 ? Ar[2] + 90 : 90]) : (Ar = Cr(), [Ar[0], Ar[1], Ar[2] - 90]);\n                }, Cr([0, 0, 90]).scale(159.155);\n              }\n              e3.geoAlbers = nl, e3.geoAlbersUsa = Ah, e3.geoArea = ge, e3.geoAzimuthalEqualArea = bd, e3.geoAzimuthalEqualAreaRaw = wc, e3.geoAzimuthalEquidistant = Pf, e3.geoAzimuthalEquidistantRaw = xf, e3.geoBounds = Ge, e3.geoCentroid = Er, e3.geoCircle = ua, e3.geoClipAntimeridian = Jr, e3.geoClipCircle = Mn, e3.geoClipExtent = Ma, e3.geoClipRectangle = Jn, e3.geoConicConformal = If, e3.geoConicConformalRaw = Hh, e3.geoConicEqualArea = _u, e3.geoConicEqualAreaRaw = hu, e3.geoConicEquidistant = Wf, e3.geoConicEquidistantRaw = ku, e3.geoContains = bs, e3.geoDistance = As, e3.geoEqualEarth = Xf, e3.geoEqualEarthRaw = uf, e3.geoEquirectangular = du, e3.geoEquirectangularRaw = Cs, e3.geoGnomonic = ah, e3.geoGnomonicRaw = Wl, e3.geoGraticule = Vu, e3.geoGraticule10 = Ol, e3.geoIdentity = Zu, e3.geoInterpolate = xo, e3.geoLength = zl, e3.geoMercator = bf, e3.geoMercatorRaw = Ou, e3.geoNaturalEarth1 = Tc, e3.geoNaturalEarth1Raw = Oc, e3.geoOrthographic = vu, e3.geoOrthographicRaw = wl, e3.geoPath = eh, e3.geoProjection = Eu, e3.geoProjectionMutator = Dc, e3.geoRotation = yn, e3.geoStereographic = cf, e3.geoStereographicRaw = qc, e3.geoStream = H, e3.geoTransform = th, e3.geoTransverseMercator = Bc, e3.geoTransverseMercatorRaw = fc, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var PDe = ye((PF, LDe) => {\n            (function(e3, t3) {\n              typeof PF == "object" && typeof LDe != "undefined" ? t3(PF, RZ(), nk()) : t3(e3.d3 = e3.d3 || {}, e3.d3, e3.d3);\n            })(PF, function(e3, t3, r4) {\n              "use strict";\n              var n4 = Math.abs, i3 = Math.atan, a4 = Math.atan2, o4 = Math.cos, s3 = Math.exp, l3 = Math.floor, u4 = Math.log, c5 = Math.max, f4 = Math.min, h3 = Math.pow, d3 = Math.round, v3 = Math.sign || function(ve) {\n                return ve > 0 ? 1 : ve < 0 ? -1 : 0;\n              }, _2 = Math.sin, b = Math.tan, p3 = 1e-6, k4 = 1e-12, E3 = Math.PI, S2 = E3 / 2, L3 = E3 / 4, x2 = Math.SQRT1_2, C3 = G2(2), M4 = G2(E3), g3 = E3 * 2, P3 = 180 / E3, T3 = E3 / 180;\n              function z3(ve) {\n                return ve ? ve / Math.sin(ve) : 1;\n              }\n              function O3(ve) {\n                return ve > 1 ? S2 : ve < -1 ? -S2 : Math.asin(ve);\n              }\n              function V2(ve) {\n                return ve > 1 ? 0 : ve < -1 ? E3 : Math.acos(ve);\n              }\n              function G2(ve) {\n                return ve > 0 ? Math.sqrt(ve) : 0;\n              }\n              function Z(ve) {\n                return ve = s3(2 * ve), (ve - 1) / (ve + 1);\n              }\n              function j3(ve) {\n                return (s3(ve) - s3(-ve)) / 2;\n              }\n              function N2(ve) {\n                return (s3(ve) + s3(-ve)) / 2;\n              }\n              function H(ve) {\n                return u4(ve + G2(ve * ve + 1));\n              }\n              function te(ve) {\n                return u4(ve + G2(ve * ve - 1));\n              }\n              function oe(ve) {\n                var be = b(ve / 2), De = 2 * u4(o4(ve / 2)) / (be * be);\n                function Be(et, We) {\n                  var it = o4(et), Ft = o4(We), Ht = _2(We), tr = Ft * it, dr = -((1 - tr ? u4((1 + tr) / 2) / (1 - tr) : -0.5) + De / (1 + tr));\n                  return [dr * Ft * _2(et), dr * Ht];\n                }\n                return Be.invert = function(et, We) {\n                  var it = G2(et * et + We * We), Ft = -ve / 2, Ht = 50, tr;\n                  if (!it) return [0, 0];\n                  do {\n                    var dr = Ft / 2, Sr = o4(dr), Or = _2(dr), Wr = Or / Sr, ni = -u4(n4(Sr));\n                    Ft -= tr = (2 / Wr * ni - De * Wr - it) / (-ni / (Or * Or) + 1 - De / (2 * Sr * Sr)) * (Sr < 0 ? 0.7 : 1);\n                  } while (n4(tr) > p3 && --Ht > 0);\n                  var Pi = _2(Ft);\n                  return [a4(et * Pi, it * o4(Ft)), O3(We * Pi / it)];\n                }, Be;\n              }\n              function _e() {\n                var ve = S2, be = t3.geoProjectionMutator(oe), De = be(ve);\n                return De.radius = function(Be) {\n                  return arguments.length ? be(ve = Be * T3) : ve * P3;\n                }, De.scale(179.976).clipAngle(147);\n              }\n              function Ee(ve, be) {\n                var De = o4(be), Be = z3(V2(De * o4(ve /= 2)));\n                return [2 * De * _2(ve) * Be, _2(be) * Be];\n              }\n              Ee.invert = function(ve, be) {\n                if (!(ve * ve + 4 * be * be > E3 * E3 + p3)) {\n                  var De = ve, Be = be, et = 25;\n                  do {\n                    var We = _2(De), it = _2(De / 2), Ft = o4(De / 2), Ht = _2(Be), tr = o4(Be), dr = _2(2 * Be), Sr = Ht * Ht, Or = tr * tr, Wr = it * it, ni = 1 - Or * Ft * Ft, Pi = ni ? V2(tr * Ft) * G2(cn = 1 / ni) : cn = 0, cn, ln = 2 * Pi * tr * it - ve, Cn = Pi * Ht - be, Kn = cn * (Or * Wr + Pi * tr * Ft * Sr), Ta = cn * (0.5 * We * dr - Pi * 2 * Ht * it), fa = cn * 0.25 * (dr * it - Pi * Ht * Or * We), $a = cn * (Sr * Ft + Pi * Wr * tr), Co = Ta * fa - $a * Kn;\n                    if (!Co) break;\n                    var Qa = (Cn * Ta - ln * $a) / Co, mo = (ln * fa - Cn * Kn) / Co;\n                    De -= Qa, Be -= mo;\n                  } while ((n4(Qa) > p3 || n4(mo) > p3) && --et > 0);\n                  return [De, Be];\n                }\n              };\n              function Ce() {\n                return t3.geoProjection(Ee).scale(152.63);\n              }\n              function me(ve) {\n                var be = _2(ve), De = o4(ve), Be = ve >= 0 ? 1 : -1, et = b(Be * ve), We = (1 + be - De) / 2;\n                function it(Ft, Ht) {\n                  var tr = o4(Ht), dr = o4(Ft /= 2);\n                  return [(1 + tr) * _2(Ft), (Be * Ht > -a4(dr, et) - 1e-3 ? 0 : -Be * 10) + We + _2(Ht) * De - (1 + tr) * be * dr];\n                }\n                return it.invert = function(Ft, Ht) {\n                  var tr = 0, dr = 0, Sr = 50;\n                  do {\n                    var Or = o4(tr), Wr = _2(tr), ni = o4(dr), Pi = _2(dr), cn = 1 + ni, ln = cn * Wr - Ft, Cn = We + Pi * De - cn * be * Or - Ht, Kn = cn * Or / 2, Ta = -Wr * Pi, fa = be * cn * Wr / 2, $a = De * ni + be * Or * Pi, Co = Ta * fa - $a * Kn, Qa = (Cn * Ta - ln * $a) / Co / 2, mo = (ln * fa - Cn * Kn) / Co;\n                    n4(mo) > 2 && (mo /= 2), tr -= Qa, dr -= mo;\n                  } while ((n4(Qa) > p3 || n4(mo) > p3) && --Sr > 0);\n                  return Be * dr > -a4(o4(tr), et) - 1e-3 ? [tr * 2, dr] : null;\n                }, it;\n              }\n              function ie() {\n                var ve = 20 * T3, be = ve >= 0 ? 1 : -1, De = b(be * ve), Be = t3.geoProjectionMutator(me), et = Be(ve), We = et.stream;\n                return et.parallel = function(it) {\n                  return arguments.length ? (De = b((be = (ve = it * T3) >= 0 ? 1 : -1) * ve), Be(ve)) : ve * P3;\n                }, et.stream = function(it) {\n                  var Ft = et.rotate(), Ht = We(it), tr = (et.rotate([0, 0]), We(it)), dr = et.precision();\n                  return et.rotate(Ft), Ht.sphere = function() {\n                    tr.polygonStart(), tr.lineStart();\n                    for (var Sr = be * -180; be * Sr < 180; Sr += be * 90) tr.point(Sr, be * 90);\n                    if (ve) for (; be * (Sr -= 3 * be * dr) >= -180; ) tr.point(Sr, be * -a4(o4(Sr * T3 / 2), De) * P3);\n                    tr.lineEnd(), tr.polygonEnd();\n                  }, Ht;\n                }, et.scale(218.695).center([0, 28.0974]);\n              }\n              function Se(ve, be) {\n                var De = b(be / 2), Be = G2(1 - De * De), et = 1 + Be * o4(ve /= 2), We = _2(ve) * Be / et, it = De / et, Ft = We * We, Ht = it * it;\n                return [4 / 3 * We * (3 + Ft - 3 * Ht), 4 / 3 * it * (3 + 3 * Ft - Ht)];\n              }\n              Se.invert = function(ve, be) {\n                if (ve *= 3 / 8, be *= 3 / 8, !ve && n4(be) > 1) return null;\n                var De = ve * ve, Be = be * be, et = 1 + De + Be, We = G2((et - G2(et * et - 4 * be * be)) / 2), it = O3(We) / 3, Ft = We ? te(n4(be / We)) / 3 : H(n4(ve)) / 3, Ht = o4(it), tr = N2(Ft), dr = tr * tr - Ht * Ht;\n                return [v3(ve) * 2 * a4(j3(Ft) * Ht, 0.25 - dr), v3(be) * 2 * a4(tr * _2(it), 0.25 + dr)];\n              };\n              function Le() {\n                return t3.geoProjection(Se).scale(66.1603);\n              }\n              var Ae = G2(8), Fe = u4(1 + C3);\n              function Pe(ve, be) {\n                var De = n4(be);\n                return De < L3 ? [ve, u4(b(L3 + be / 2))] : [ve * o4(De) * (2 * C3 - 1 / _2(De)), v3(be) * (2 * C3 * (De - L3) - u4(b(De / 2)))];\n              }\n              Pe.invert = function(ve, be) {\n                if ((We = n4(be)) < Fe) return [ve, 2 * i3(s3(be)) - S2];\n                var De = L3, Be = 25, et, We;\n                do {\n                  var it = o4(De / 2), Ft = b(De / 2);\n                  De -= et = (Ae * (De - L3) - u4(Ft) - We) / (Ae - it * it / (2 * Ft));\n                } while (n4(et) > k4 && --Be > 0);\n                return [ve / (o4(De) * (Ae - 1 / _2(De))), v3(be) * De];\n              };\n              function ge() {\n                return t3.geoProjection(Pe).scale(112.314);\n              }\n              function Re(ve) {\n                var be = 2 * E3 / ve;\n                function De(Be, et) {\n                  var We = t3.geoAzimuthalEquidistantRaw(Be, et);\n                  if (n4(Be) > S2) {\n                    var it = a4(We[1], We[0]), Ft = G2(We[0] * We[0] + We[1] * We[1]), Ht = be * d3((it - S2) / be) + S2, tr = a4(_2(it -= Ht), 2 - o4(it));\n                    it = Ht + O3(E3 / Ft * _2(tr)) - tr, We[0] = Ft * o4(it), We[1] = Ft * _2(it);\n                  }\n                  return We;\n                }\n                return De.invert = function(Be, et) {\n                  var We = G2(Be * Be + et * et);\n                  if (We > S2) {\n                    var it = a4(et, Be), Ft = be * d3((it - S2) / be) + S2, Ht = it > Ft ? -1 : 1, tr = We * o4(Ft - it), dr = 1 / b(Ht * V2((tr - E3) / G2(E3 * (E3 - 2 * tr) + We * We)));\n                    it = Ft + 2 * i3((dr + Ht * G2(dr * dr - 3)) / 3), Be = We * o4(it), et = We * _2(it);\n                  }\n                  return t3.geoAzimuthalEquidistantRaw.invert(Be, et);\n                }, De;\n              }\n              function ce() {\n                var ve = 5, be = t3.geoProjectionMutator(Re), De = be(ve), Be = De.stream, et = 0.01, We = -o4(et * T3), it = _2(et * T3);\n                return De.lobes = function(Ft) {\n                  return arguments.length ? be(ve = +Ft) : ve;\n                }, De.stream = function(Ft) {\n                  var Ht = De.rotate(), tr = Be(Ft), dr = (De.rotate([0, 0]), Be(Ft));\n                  return De.rotate(Ht), tr.sphere = function() {\n                    dr.polygonStart(), dr.lineStart();\n                    for (var Sr = 0, Or = 360 / ve, Wr = 2 * E3 / ve, ni = 90 - 180 / ve, Pi = S2; Sr < ve; ++Sr, ni -= Or, Pi -= Wr) dr.point(a4(it * o4(Pi), We) * P3, O3(it * _2(Pi)) * P3), ni < -90 ? (dr.point(-90, -180 - ni - et), dr.point(-90, -180 - ni + et)) : (dr.point(90, ni + et), dr.point(90, ni - et));\n                    dr.lineEnd(), dr.polygonEnd();\n                  }, tr;\n                }, De.scale(87.8076).center([0, 17.1875]).clipAngle(180 - 1e-3);\n              }\n              function Ze(ve, be) {\n                if (arguments.length < 2 && (be = ve), be === 1) return t3.geoAzimuthalEqualAreaRaw;\n                if (be === 1 / 0) return ut;\n                function De(Be, et) {\n                  var We = t3.geoAzimuthalEqualAreaRaw(Be / be, et);\n                  return We[0] *= ve, We;\n                }\n                return De.invert = function(Be, et) {\n                  var We = t3.geoAzimuthalEqualAreaRaw.invert(Be / ve, et);\n                  return We[0] *= be, We;\n                }, De;\n              }\n              function ut(ve, be) {\n                return [ve * o4(be) / o4(be /= 2), 2 * _2(be)];\n              }\n              ut.invert = function(ve, be) {\n                var De = 2 * O3(be / 2);\n                return [ve * o4(De / 2) / o4(De), De];\n              };\n              function pt() {\n                var ve = 2, be = t3.geoProjectionMutator(Ze), De = be(ve);\n                return De.coefficient = function(Be) {\n                  return arguments.length ? be(ve = +Be) : ve;\n                }, De.scale(169.529);\n              }\n              function Zt(ve, be, De) {\n                var Be = 100, et, We, it;\n                De = De === void 0 ? 0 : +De, be = +be;\n                do\n                  We = ve(De), it = ve(De + p3), We === it && (it = We + p3), De -= et = -1 * p3 * (We - be) / (We - it);\n                while (Be-- > 0 && n4(et) > p3);\n                return Be < 0 ? NaN : De;\n              }\n              function st(ve, be, De) {\n                return be === void 0 && (be = 40), De === void 0 && (De = k4), function(Be, et, We, it) {\n                  var Ft, Ht, tr;\n                  We = We === void 0 ? 0 : +We, it = it === void 0 ? 0 : +it;\n                  for (var dr = 0; dr < be; dr++) {\n                    var Sr = ve(We, it), Or = Sr[0] - Be, Wr = Sr[1] - et;\n                    if (n4(Or) < De && n4(Wr) < De) break;\n                    var ni = Or * Or + Wr * Wr;\n                    if (ni > Ft) {\n                      We -= Ht /= 2, it -= tr /= 2;\n                      continue;\n                    }\n                    Ft = ni;\n                    var Pi = (We > 0 ? -1 : 1) * De, cn = (it > 0 ? -1 : 1) * De, ln = ve(We + Pi, it), Cn = ve(We, it + cn), Kn = (ln[0] - Sr[0]) / Pi, Ta = (ln[1] - Sr[1]) / Pi, fa = (Cn[0] - Sr[0]) / cn, $a = (Cn[1] - Sr[1]) / cn, Co = $a * Kn - Ta * fa, Qa = (n4(Co) < 0.5 ? 0.5 : 1) / Co;\n                    if (Ht = (Wr * fa - Or * $a) * Qa, tr = (Or * Ta - Wr * Kn) * Qa, We += Ht, it += tr, n4(Ht) < De && n4(tr) < De) break;\n                  }\n                  return [We, it];\n                };\n              }\n              function lt() {\n                var ve = Ze(1.68, 2), be = 1.4, De = 12;\n                function Be(et, We) {\n                  if (et + We < -be) {\n                    var it = (et - We + 1.6) * (et + We + be) / 8;\n                    et += it, We -= 0.8 * it * _2(We + E3 / 2);\n                  }\n                  var Ft = ve(et, We), Ht = (1 - o4(et * We)) / De;\n                  return Ft[1] < 0 && (Ft[0] *= 1 + Ht), Ft[1] > 0 && (Ft[1] *= 1 + Ht / 1.5 * Ft[0] * Ft[0]), Ft;\n                }\n                return Be.invert = st(Be), Be;\n              }\n              function Gt() {\n                return t3.geoProjection(lt()).rotate([-16.5, -42]).scale(176.57).center([7.93, 0.09]);\n              }\n              function Nt(ve, be) {\n                var De = ve * _2(be), Be = 30, et;\n                do\n                  be -= et = (be + _2(be) - De) / (1 + o4(be));\n                while (n4(et) > p3 && --Be > 0);\n                return be / 2;\n              }\n              function Jt(ve, be, De) {\n                function Be(et, We) {\n                  return [ve * et * o4(We = Nt(De, We)), be * _2(We)];\n                }\n                return Be.invert = function(et, We) {\n                  return We = O3(We / be), [et / (ve * o4(We)), O3((2 * We + _2(2 * We)) / De)];\n                }, Be;\n              }\n              var sr = Jt(C3 / S2, C3, E3);\n              function wr() {\n                return t3.geoProjection(sr).scale(169.529);\n              }\n              var cr = 2.00276, $e = 1.11072;\n              function St(ve, be) {\n                var De = Nt(E3, be);\n                return [cr * ve / (1 / o4(be) + $e / o4(De)), (be + C3 * _2(De)) / cr];\n              }\n              St.invert = function(ve, be) {\n                var De = cr * be, Be = be < 0 ? -L3 : L3, et = 25, We, it;\n                do\n                  it = De - C3 * _2(Be), Be -= We = (_2(2 * Be) + 2 * Be - E3 * _2(it)) / (2 * o4(2 * Be) + 2 + E3 * o4(it) * C3 * o4(Be));\n                while (n4(We) > p3 && --et > 0);\n                return it = De - C3 * _2(Be), [ve * (1 / o4(it) + $e / o4(Be)) / cr, it];\n              };\n              function Qt() {\n                return t3.geoProjection(St).scale(160.857);\n              }\n              function Vt(ve) {\n                var be = 0, De = t3.geoProjectionMutator(ve), Be = De(be);\n                return Be.parallel = function(et) {\n                  return arguments.length ? De(be = et * T3) : be * P3;\n                }, Be;\n              }\n              function _t(ve, be) {\n                return [ve * o4(be), be];\n              }\n              _t.invert = function(ve, be) {\n                return [ve / o4(be), be];\n              };\n              function It() {\n                return t3.geoProjection(_t).scale(152.63);\n              }\n              function mt(ve) {\n                if (!ve) return _t;\n                var be = 1 / b(ve);\n                function De(Be, et) {\n                  var We = be + ve - et, it = We && Be * o4(et) / We;\n                  return [We * _2(it), be - We * o4(it)];\n                }\n                return De.invert = function(Be, et) {\n                  var We = G2(Be * Be + (et = be - et) * et), it = be + ve - We;\n                  return [We / o4(it) * a4(Be, et), it];\n                }, De;\n              }\n              function er() {\n                return Vt(mt).scale(123.082).center([0, 26.1441]).parallel(45);\n              }\n              function lr(ve) {\n                function be(De, Be) {\n                  var et = S2 - Be, We = et && De * ve * _2(et) / et;\n                  return [et * _2(We) / ve, S2 - et * o4(We)];\n                }\n                return be.invert = function(De, Be) {\n                  var et = De * ve, We = S2 - Be, it = G2(et * et + We * We), Ft = a4(et, We);\n                  return [(it ? it / _2(it) : 1) * Ft / ve, S2 - it];\n                }, be;\n              }\n              function Tr() {\n                var ve = 0.5, be = t3.geoProjectionMutator(lr), De = be(ve);\n                return De.fraction = function(Be) {\n                  return arguments.length ? be(ve = +Be) : ve;\n                }, De.scale(158.837);\n              }\n              var Lr = Jt(1, 4 / E3, E3);\n              function ti() {\n                return t3.geoProjection(Lr).scale(152.63);\n              }\n              function Br(ve, be, De, Be, et, We) {\n                var it = o4(We), Ft;\n                if (n4(ve) > 1 || n4(We) > 1) Ft = V2(De * et + be * Be * it);\n                else {\n                  var Ht = _2(ve / 2), tr = _2(We / 2);\n                  Ft = 2 * O3(G2(Ht * Ht + be * Be * tr * tr));\n                }\n                return n4(Ft) > p3 ? [Ft, a4(Be * _2(We), be * et - De * Be * it)] : [0, 0];\n              }\n              function Vr(ve, be, De) {\n                return V2((ve * ve + be * be - De * De) / (2 * ve * be));\n              }\n              function dt(ve) {\n                return ve - 2 * E3 * l3((ve + E3) / (2 * E3));\n              }\n              function Ge(ve, be, De) {\n                for (var Be = [[ve[0], ve[1], _2(ve[1]), o4(ve[1])], [be[0], be[1], _2(be[1]), o4(be[1])], [De[0], De[1], _2(De[1]), o4(De[1])]], et = Be[2], We, it = 0; it < 3; ++it, et = We) We = Be[it], et.v = Br(We[1] - et[1], et[3], et[2], We[3], We[2], We[0] - et[0]), et.point = [0, 0];\n                var Ft = Vr(Be[0].v[0], Be[2].v[0], Be[1].v[0]), Ht = Vr(Be[0].v[0], Be[1].v[0], Be[2].v[0]), tr = E3 - Ft;\n                Be[2].point[1] = 0, Be[0].point[0] = -(Be[1].point[0] = Be[0].v[0] / 2);\n                var dr = [Be[2].point[0] = Be[0].point[0] + Be[2].v[0] * o4(Ft), 2 * (Be[0].point[1] = Be[1].point[1] = Be[2].v[0] * _2(Ft))];\n                function Sr(Or, Wr) {\n                  var ni = _2(Wr), Pi = o4(Wr), cn = new Array(3), ln;\n                  for (ln = 0; ln < 3; ++ln) {\n                    var Cn = Be[ln];\n                    if (cn[ln] = Br(Wr - Cn[1], Cn[3], Cn[2], Pi, ni, Or - Cn[0]), !cn[ln][0]) return Cn.point;\n                    cn[ln][1] = dt(cn[ln][1] - Cn.v[1]);\n                  }\n                  var Kn = dr.slice();\n                  for (ln = 0; ln < 3; ++ln) {\n                    var Ta = ln == 2 ? 0 : ln + 1, fa = Vr(Be[ln].v[0], cn[ln][0], cn[Ta][0]);\n                    cn[ln][1] < 0 && (fa = -fa), ln ? ln == 1 ? (fa = Ht - fa, Kn[0] -= cn[ln][0] * o4(fa), Kn[1] -= cn[ln][0] * _2(fa)) : (fa = tr - fa, Kn[0] += cn[ln][0] * o4(fa), Kn[1] += cn[ln][0] * _2(fa)) : (Kn[0] += cn[ln][0] * o4(fa), Kn[1] -= cn[ln][0] * _2(fa));\n                  }\n                  return Kn[0] /= 3, Kn[1] /= 3, Kn;\n                }\n                return Sr;\n              }\n              function Je(ve) {\n                return ve[0] *= T3, ve[1] *= T3, ve;\n              }\n              function je() {\n                return tt([0, 22], [45, 22], [22.5, -22]).scale(380).center([22.5, 2]);\n              }\n              function tt(ve, be, De) {\n                var Be = t3.geoCentroid({ type: "MultiPoint", coordinates: [ve, be, De] }), et = [-Be[0], -Be[1]], We = t3.geoRotation(et), it = Ge(Je(We(ve)), Je(We(be)), Je(We(De)));\n                it.invert = st(it);\n                var Ft = t3.geoProjection(it).rotate(et), Ht = Ft.center;\n                return delete Ft.rotate, Ft.center = function(tr) {\n                  return arguments.length ? Ht(We(tr)) : We.invert(Ht());\n                }, Ft.clipAngle(90);\n              }\n              function xt(ve, be) {\n                var De = G2(1 - _2(be));\n                return [2 / M4 * ve * De, M4 * (1 - De)];\n              }\n              xt.invert = function(ve, be) {\n                var De = (De = be / M4 - 1) * De;\n                return [De > 0 ? ve * G2(E3 / De) / 2 : 0, O3(1 - De)];\n              };\n              function Ie() {\n                return t3.geoProjection(xt).scale(95.6464).center([0, 30]);\n              }\n              function xe(ve) {\n                var be = b(ve);\n                function De(Be, et) {\n                  return [Be, (Be ? Be / _2(Be) : 1) * (_2(et) * o4(Be) - be * o4(et))];\n                }\n                return De.invert = be ? function(Be, et) {\n                  Be && (et *= _2(Be) / Be);\n                  var We = o4(Be);\n                  return [Be, 2 * a4(G2(We * We + be * be - et * et) - We, be - et)];\n                } : function(Be, et) {\n                  return [Be, O3(Be ? et * b(Be) / Be : et)];\n                }, De;\n              }\n              function ke() {\n                return Vt(xe).scale(249.828).clipAngle(90);\n              }\n              var vt = G2(3);\n              function ir(ve, be) {\n                return [vt * ve * (2 * o4(2 * be / 3) - 1) / M4, vt * M4 * _2(be / 3)];\n              }\n              ir.invert = function(ve, be) {\n                var De = 3 * O3(be / (vt * M4));\n                return [M4 * ve / (vt * (2 * o4(2 * De / 3) - 1)), De];\n              };\n              function ar() {\n                return t3.geoProjection(ir).scale(156.19);\n              }\n              function vr(ve) {\n                var be = o4(ve);\n                function De(Be, et) {\n                  return [Be * be, _2(et) / be];\n                }\n                return De.invert = function(Be, et) {\n                  return [Be / be, O3(et * be)];\n                }, De;\n              }\n              function ii() {\n                return Vt(vr).parallel(38.58).scale(195.044);\n              }\n              function pi(ve) {\n                var be = o4(ve);\n                function De(Be, et) {\n                  return [Be * be, (1 + be) * b(et / 2)];\n                }\n                return De.invert = function(Be, et) {\n                  return [Be / be, i3(et / (1 + be)) * 2];\n                }, De;\n              }\n              function $r() {\n                return Vt(pi).scale(124.75);\n              }\n              function di(ve, be) {\n                var De = G2(8 / (3 * E3));\n                return [De * ve * (1 - n4(be) / E3), De * be];\n              }\n              di.invert = function(ve, be) {\n                var De = G2(8 / (3 * E3)), Be = be / De;\n                return [ve / (De * (1 - n4(Be) / E3)), Be];\n              };\n              function ji() {\n                return t3.geoProjection(di).scale(165.664);\n              }\n              function In(ve, be) {\n                var De = G2(4 - 3 * _2(n4(be)));\n                return [2 / G2(6 * E3) * ve * De, v3(be) * G2(2 * E3 / 3) * (2 - De)];\n              }\n              In.invert = function(ve, be) {\n                var De = 2 - n4(be) / G2(2 * E3 / 3);\n                return [ve * G2(6 * E3) / (2 * De), v3(be) * O3((4 - De * De) / 3)];\n              };\n              function wi() {\n                return t3.geoProjection(In).scale(165.664);\n              }\n              function On(ve, be) {\n                var De = G2(E3 * (4 + E3));\n                return [2 / De * ve * (1 + G2(1 - 4 * be * be / (E3 * E3))), 4 / De * be];\n              }\n              On.invert = function(ve, be) {\n                var De = G2(E3 * (4 + E3)) / 2;\n                return [ve * De / (1 + G2(1 - be * be * (4 + E3) / (4 * E3))), be * De / 2];\n              };\n              function qn() {\n                return t3.geoProjection(On).scale(180.739);\n              }\n              function Fn(ve, be) {\n                var De = (2 + S2) * _2(be);\n                be /= 2;\n                for (var Be = 0, et = 1 / 0; Be < 10 && n4(et) > p3; Be++) {\n                  var We = o4(be);\n                  be -= et = (be + _2(be) * (We + 2) - De) / (2 * We * (1 + We));\n                }\n                return [2 / G2(E3 * (4 + E3)) * ve * (1 + o4(be)), 2 * G2(E3 / (4 + E3)) * _2(be)];\n              }\n              Fn.invert = function(ve, be) {\n                var De = be * G2((4 + E3) / E3) / 2, Be = O3(De), et = o4(Be);\n                return [ve / (2 / G2(E3 * (4 + E3)) * (1 + et)), O3((Be + De * (et + 2)) / (2 + S2))];\n              };\n              function ra() {\n                return t3.geoProjection(Fn).scale(180.739);\n              }\n              function la(ve, be) {\n                return [ve * (1 + o4(be)) / G2(2 + E3), 2 * be / G2(2 + E3)];\n              }\n              la.invert = function(ve, be) {\n                var De = G2(2 + E3), Be = be * De / 2;\n                return [De * ve / (1 + o4(Be)), Be];\n              };\n              function Ut() {\n                return t3.geoProjection(la).scale(173.044);\n              }\n              function wt(ve, be) {\n                for (var De = (1 + S2) * _2(be), Be = 0, et = 1 / 0; Be < 10 && n4(et) > p3; Be++) be -= et = (be + _2(be) - De) / (1 + o4(be));\n                return De = G2(2 + E3), [ve * (1 + o4(be)) / De, 2 * be / De];\n              }\n              wt.invert = function(ve, be) {\n                var De = 1 + S2, Be = G2(De / 2);\n                return [ve * 2 * Be / (1 + o4(be *= Be)), O3((be + _2(be)) / De)];\n              };\n              function rr() {\n                return t3.geoProjection(wt).scale(173.044);\n              }\n              var nr = 3 + 2 * C3;\n              function Er(ve, be) {\n                var De = _2(ve /= 2), Be = o4(ve), et = G2(o4(be)), We = o4(be /= 2), it = _2(be) / (We + C3 * Be * et), Ft = G2(2 / (1 + it * it)), Ht = G2((C3 * We + (Be + De) * et) / (C3 * We + (Be - De) * et));\n                return [nr * (Ft * (Ht - 1 / Ht) - 2 * u4(Ht)), nr * (Ft * it * (Ht + 1 / Ht) - 2 * i3(it))];\n              }\n              Er.invert = function(ve, be) {\n                if (!(We = Se.invert(ve / 1.2, be * 1.065))) return null;\n                var De = We[0], Be = We[1], et = 20, We;\n                ve /= nr, be /= nr;\n                do {\n                  var it = De / 2, Ft = Be / 2, Ht = _2(it), tr = o4(it), dr = _2(Ft), Sr = o4(Ft), Or = o4(Be), Wr = G2(Or), ni = dr / (Sr + C3 * tr * Wr), Pi = ni * ni, cn = G2(2 / (1 + Pi)), ln = C3 * Sr + (tr + Ht) * Wr, Cn = C3 * Sr + (tr - Ht) * Wr, Kn = ln / Cn, Ta = G2(Kn), fa = Ta - 1 / Ta, $a = Ta + 1 / Ta, Co = cn * fa - 2 * u4(Ta) - ve, Qa = cn * ni * $a - 2 * i3(ni) - be, mo = dr && x2 * Wr * Ht * Pi / dr, Bo = (C3 * tr * Sr + Wr) / (2 * (Sr + C3 * tr * Wr) * (Sr + C3 * tr * Wr) * Wr), Ps = -0.5 * ni * cn * cn * cn, Ts = Ps * mo, wo = Ps * Bo, To = (To = 2 * Sr + C3 * Wr * (tr - Ht)) * To * Ta, hl = (C3 * tr * Sr * Wr + Or) / To, Ul = -(C3 * Ht * dr) / (Wr * To), Lu = fa * Ts - 2 * hl / Ta + cn * (hl + hl / Kn), au = fa * wo - 2 * Ul / Ta + cn * (Ul + Ul / Kn), Js = ni * $a * Ts - 2 * mo / (1 + Pi) + cn * $a * mo + cn * ni * (hl - hl / Kn), Ql = ni * $a * wo - 2 * Bo / (1 + Pi) + cn * $a * Bo + cn * ni * (Ul - Ul / Kn), dc = au * Js - Ql * Lu;\n                  if (!dc) break;\n                  var Tl = (Qa * au - Co * Ql) / dc, Al = (Co * Js - Qa * Lu) / dc;\n                  De -= Tl, Be = c5(-S2, f4(S2, Be - Al));\n                } while ((n4(Tl) > p3 || n4(Al) > p3) && --et > 0);\n                return n4(n4(Be) - S2) < p3 ? [0, Be] : et && [De, Be];\n              };\n              function Xr() {\n                return t3.geoProjection(Er).scale(62.5271);\n              }\n              var ri = o4(35 * T3);\n              function Qr(ve, be) {\n                var De = b(be / 2);\n                return [ve * ri * G2(1 - De * De), (1 + ri) * De];\n              }\n              Qr.invert = function(ve, be) {\n                var De = be / (1 + ri);\n                return [ve && ve / (ri * G2(1 - De * De)), 2 * i3(De)];\n              };\n              function Oi() {\n                return t3.geoProjection(Qr).scale(137.152);\n              }\n              function $i(ve, be) {\n                var De = be / 2, Be = o4(De);\n                return [2 * ve / M4 * o4(be) * Be * Be, M4 * b(De)];\n              }\n              $i.invert = function(ve, be) {\n                var De = i3(be / M4), Be = o4(De), et = 2 * De;\n                return [ve * M4 / 2 / (o4(et) * Be * Be), et];\n              };\n              function tn() {\n                return t3.geoProjection($i).scale(135.264);\n              }\n              function fn(ve) {\n                var be = 1 - ve, De = We(E3, 0)[0] - We(-E3, 0)[0], Be = We(0, S2)[1] - We(0, -S2)[1], et = G2(2 * Be / De);\n                function We(Ht, tr) {\n                  var dr = o4(tr), Sr = _2(tr);\n                  return [dr / (be + ve * dr) * Ht, be * tr + ve * Sr];\n                }\n                function it(Ht, tr) {\n                  var dr = We(Ht, tr);\n                  return [dr[0] * et, dr[1] / et];\n                }\n                function Ft(Ht) {\n                  return it(0, Ht)[1];\n                }\n                return it.invert = function(Ht, tr) {\n                  var dr = Zt(Ft, tr), Sr = Ht / et * (ve + be / o4(dr));\n                  return [Sr, dr];\n                }, it;\n              }\n              function yn() {\n                var ve = 0.5, be = t3.geoProjectionMutator(fn), De = be(ve);\n                return De.alpha = function(Be) {\n                  return arguments.length ? be(ve = +Be) : ve;\n                }, De.scale(168.725);\n              }\n              function Sn(ve) {\n                return [ve[0] / 2, O3(b(ve[1] / 2 * T3)) * P3];\n              }\n              function Ba(ve) {\n                return [ve[0] * 2, 2 * i3(_2(ve[1] * T3)) * P3];\n              }\n              function ua(ve) {\n                ve == null && (ve = t3.geoOrthographic);\n                var be = ve(), De = t3.geoEquirectangular().scale(P3).precision(0).clipAngle(null).translate([0, 0]);\n                function Be(We) {\n                  return be(Sn(We));\n                }\n                be.invert && (Be.invert = function(We) {\n                  return Ba(be.invert(We));\n                }), Be.stream = function(We) {\n                  var it = be.stream(We), Ft = De.stream({ point: function(Ht, tr) {\n                    it.point(Ht / 2, O3(b(-tr / 2 * T3)) * P3);\n                  }, lineStart: function() {\n                    it.lineStart();\n                  }, lineEnd: function() {\n                    it.lineEnd();\n                  }, polygonStart: function() {\n                    it.polygonStart();\n                  }, polygonEnd: function() {\n                    it.polygonEnd();\n                  } });\n                  return Ft.sphere = it.sphere, Ft;\n                };\n                function et(We) {\n                  Be[We] = function() {\n                    return arguments.length ? (be[We].apply(be, arguments), Be) : be[We]();\n                  };\n                }\n                return Be.rotate = function(We) {\n                  return arguments.length ? (De.rotate(We), Be) : De.rotate();\n                }, Be.center = function(We) {\n                  return arguments.length ? (be.center(Sn(We)), Be) : Ba(be.center());\n                }, et("angle"), et("clipAngle"), et("clipExtent"), et("fitExtent"), et("fitHeight"), et("fitSize"), et("fitWidth"), et("scale"), et("translate"), et("precision"), Be.scale(249.5);\n              }\n              function ma(ve, be) {\n                var De = 2 * E3 / be, Be = ve * ve;\n                function et(We, it) {\n                  var Ft = t3.geoAzimuthalEquidistantRaw(We, it), Ht = Ft[0], tr = Ft[1], dr = Ht * Ht + tr * tr;\n                  if (dr > Be) {\n                    var Sr = G2(dr), Or = a4(tr, Ht), Wr = De * d3(Or / De), ni = Or - Wr, Pi = ve * o4(ni), cn = (ve * _2(ni) - ni * _2(Pi)) / (S2 - Pi), ln = Wa(ni, cn), Cn = (E3 - ve) / Fa(ln, Pi, E3);\n                    Ht = Sr;\n                    var Kn = 50, Ta;\n                    do\n                      Ht -= Ta = (ve + Fa(ln, Pi, Ht) * Cn - Sr) / (ln(Ht) * Cn);\n                    while (n4(Ta) > p3 && --Kn > 0);\n                    tr = ni * _2(Ht), Ht < S2 && (tr -= cn * (Ht - S2));\n                    var fa = _2(Wr), $a = o4(Wr);\n                    Ft[0] = Ht * $a - tr * fa, Ft[1] = Ht * fa + tr * $a;\n                  }\n                  return Ft;\n                }\n                return et.invert = function(We, it) {\n                  var Ft = We * We + it * it;\n                  if (Ft > Be) {\n                    var Ht = G2(Ft), tr = a4(it, We), dr = De * d3(tr / De), Sr = tr - dr;\n                    We = Ht * o4(Sr), it = Ht * _2(Sr);\n                    for (var Or = We - S2, Wr = _2(We), ni = it / Wr, Pi = We < S2 ? 1 / 0 : 0, cn = 10; ; ) {\n                      var ln = ve * _2(ni), Cn = ve * o4(ni), Kn = _2(Cn), Ta = S2 - Cn, fa = (ln - ni * Kn) / Ta, $a = Wa(ni, fa);\n                      if (n4(Pi) < k4 || !--cn) break;\n                      ni -= Pi = (ni * Wr - fa * Or - it) / (Wr - Or * 2 * (Ta * (Cn + ni * ln * o4(Cn) - Kn) - ln * (ln - ni * Kn)) / (Ta * Ta));\n                    }\n                    Ht = ve + Fa($a, Cn, We) * (E3 - ve) / Fa($a, Cn, E3), tr = dr + ni, We = Ht * o4(tr), it = Ht * _2(tr);\n                  }\n                  return t3.geoAzimuthalEquidistantRaw.invert(We, it);\n                }, et;\n              }\n              function Wa(ve, be) {\n                return function(De) {\n                  var Be = ve * o4(De);\n                  return De < S2 && (Be -= be), G2(1 + Be * Be);\n                };\n              }\n              function Fa(ve, be, De) {\n                for (var Be = 50, et = (De - be) / Be, We = ve(be) + ve(De), it = 1, Ft = be; it < Be; ++it) We += 2 * ve(Ft += et);\n                return We * 0.5 * et;\n              }\n              function Wo() {\n                var ve = 6, be = 30 * T3, De = o4(be), Be = _2(be), et = t3.geoProjectionMutator(ma), We = et(be, ve), it = We.stream, Ft = 0.01, Ht = -o4(Ft * T3), tr = _2(Ft * T3);\n                return We.radius = function(dr) {\n                  return arguments.length ? (De = o4(be = dr * T3), Be = _2(be), et(be, ve)) : be * P3;\n                }, We.lobes = function(dr) {\n                  return arguments.length ? et(be, ve = +dr) : ve;\n                }, We.stream = function(dr) {\n                  var Sr = We.rotate(), Or = it(dr), Wr = (We.rotate([0, 0]), it(dr));\n                  return We.rotate(Sr), Or.sphere = function() {\n                    Wr.polygonStart(), Wr.lineStart();\n                    for (var ni = 0, Pi = 2 * E3 / ve, cn = 0; ni < ve; ++ni, cn -= Pi) Wr.point(a4(tr * o4(cn), Ht) * P3, O3(tr * _2(cn)) * P3), Wr.point(a4(Be * o4(cn - Pi / 2), De) * P3, O3(Be * _2(cn - Pi / 2)) * P3);\n                    Wr.lineEnd(), Wr.polygonEnd();\n                  }, Or;\n                }, We.rotate([90, -40]).scale(91.7095).clipAngle(180 - 1e-3);\n              }\n              function da(ve, be, De, Be, et, We, it, Ft) {\n                arguments.length < 8 && (Ft = 0);\n                function Ht(tr, dr) {\n                  if (!dr) return [ve * tr / E3, 0];\n                  var Sr = dr * dr, Or = ve + Sr * (be + Sr * (De + Sr * Be)), Wr = dr * (et - 1 + Sr * (We - Ft + Sr * it)), ni = (Or * Or + Wr * Wr) / (2 * Wr), Pi = tr * O3(Or / ni) / E3;\n                  return [ni * _2(Pi), dr * (1 + Sr * Ft) + ni * (1 - o4(Pi))];\n                }\n                return Ht.invert = function(tr, dr) {\n                  var Sr = E3 * tr / ve, Or = dr, Wr, ni, Pi = 50;\n                  do {\n                    var cn = Or * Or, ln = ve + cn * (be + cn * (De + cn * Be)), Cn = Or * (et - 1 + cn * (We - Ft + cn * it)), Kn = ln * ln + Cn * Cn, Ta = 2 * Cn, fa = Kn / Ta, $a = fa * fa, Co = O3(ln / fa) / E3, Qa = Sr * Co, mo = ln * ln, Bo = (2 * be + cn * (4 * De + cn * 6 * Be)) * Or, Ps = et + cn * (3 * We + cn * 5 * it), Ts = 2 * (ln * Bo + Cn * (Ps - 1)), wo = 2 * (Ps - 1), To = (Ts * Ta - Kn * wo) / (Ta * Ta), hl = o4(Qa), Ul = _2(Qa), Lu = fa * hl, au = fa * Ul, Js = Sr / E3 * (1 / G2(1 - mo / $a)) * (Bo * fa - ln * To) / $a, Ql = au - tr, dc = Or * (1 + cn * Ft) + fa - Lu - dr, Tl = To * Ul + Lu * Js, Al = Lu * Co, X = 1 + To - (To * hl - au * Js), se = au * Co, Te = Tl * se - X * Al;\n                    if (!Te) break;\n                    Sr -= Wr = (dc * Tl - Ql * X) / Te, Or -= ni = (Ql * se - dc * Al) / Te;\n                  } while ((n4(Wr) > p3 || n4(ni) > p3) && --Pi > 0);\n                  return [Sr, Or];\n                }, Ht;\n              }\n              var Wn = da(2.8284, -1.6988, 0.75432, -0.18071, 1.76003, -0.38914, 0.042555);\n              function Ha() {\n                return t3.geoProjection(Wn).scale(149.995);\n              }\n              var vo = da(2.583819, -0.835827, 0.170354, -0.038094, 1.543313, -0.411435, 0.082742);\n              function jn() {\n                return t3.geoProjection(vo).scale(153.93);\n              }\n              var Mt = da(5 / 6 * E3, -0.62636, -0.0344, 0, 1.3493, -0.05524, 0, 0.045);\n              function kr() {\n                return t3.geoProjection(Mt).scale(130.945);\n              }\n              function Jr(ve, be) {\n                var De = ve * ve, Be = be * be;\n                return [ve * (1 - 0.162388 * Be) * (0.87 - 952426e-9 * De * De), be * (1 + Be / 12)];\n              }\n              Jr.invert = function(ve, be) {\n                var De = ve, Be = be, et = 50, We;\n                do {\n                  var it = Be * Be;\n                  Be -= We = (Be * (1 + it / 12) - be) / (1 + it / 4);\n                } while (n4(We) > p3 && --et > 0);\n                et = 50, ve /= 1 - 0.162388 * it;\n                do {\n                  var Ft = (Ft = De * De) * Ft;\n                  De -= We = (De * (0.87 - 952426e-9 * Ft) - ve) / (0.87 - 476213e-8 * Ft);\n                } while (n4(We) > p3 && --et > 0);\n                return [De, Be];\n              };\n              function vi() {\n                return t3.geoProjection(Jr).scale(131.747);\n              }\n              var hn = da(2.6516, -0.76534, 0.19123, -0.047094, 1.36289, -0.13965, 0.031762);\n              function An() {\n                return t3.geoProjection(hn).scale(131.087);\n              }\n              function Mn(ve) {\n                var be = ve(S2, 0)[0] - ve(-S2, 0)[0];\n                function De(Be, et) {\n                  var We = Be > 0 ? -0.5 : 0.5, it = ve(Be + We * E3, et);\n                  return it[0] -= We * be, it;\n                }\n                return ve.invert && (De.invert = function(Be, et) {\n                  var We = Be > 0 ? -0.5 : 0.5, it = ve.invert(Be + We * be, et), Ft = it[0] - We * E3;\n                  return Ft < -E3 ? Ft += 2 * E3 : Ft > E3 && (Ft -= 2 * E3), it[0] = Ft, it;\n                }), De;\n              }\n              function Li(ve, be) {\n                var De = v3(ve), Be = v3(be), et = o4(be), We = o4(ve) * et, it = _2(ve) * et, Ft = _2(Be * be);\n                ve = n4(a4(it, Ft)), be = O3(We), n4(ve - S2) > p3 && (ve %= S2);\n                var Ht = _n(ve > E3 / 4 ? S2 - ve : ve, be);\n                return ve > E3 / 4 && (Ft = Ht[0], Ht[0] = -Ht[1], Ht[1] = -Ft), Ht[0] *= De, Ht[1] *= -Be, Ht;\n              }\n              Li.invert = function(ve, be) {\n                n4(ve) > 1 && (ve = v3(ve) * 2 - ve), n4(be) > 1 && (be = v3(be) * 2 - be);\n                var De = v3(ve), Be = v3(be), et = -De * ve, We = -Be * be, it = We / et < 1, Ft = ya(it ? We : et, it ? et : We), Ht = Ft[0], tr = Ft[1], dr = o4(tr);\n                return it && (Ht = -S2 - Ht), [De * (a4(_2(Ht) * dr, -_2(tr)) + E3), Be * O3(o4(Ht) * dr)];\n              };\n              function _n(ve, be) {\n                if (be === S2) return [0, 0];\n                var De = _2(be), Be = De * De, et = Be * Be, We = 1 + et, it = 1 + 3 * et, Ft = 1 - et, Ht = O3(1 / G2(We)), tr = Ft + Be * We * Ht, dr = (1 - De) / tr, Sr = G2(dr), Or = dr * We, Wr = G2(Or), ni = Sr * Ft, Pi, cn;\n                if (ve === 0) return [0, -(ni + Be * Wr)];\n                var ln = o4(be), Cn = 1 / ln, Kn = 2 * De * ln, Ta = (-3 * Be + Ht * it) * Kn, fa = (-tr * ln - (1 - De) * Ta) / (tr * tr), $a = 0.5 * fa / Sr, Co = Ft * $a - 2 * Be * Sr * Kn, Qa = Be * We * fa + dr * it * Kn, mo = -Cn * Kn, Bo = -Cn * Qa, Ps = -2 * Cn * Co, Ts = 4 * ve / E3, wo;\n                if (ve > 0.222 * E3 || be < E3 / 4 && ve > 0.175 * E3) {\n                  if (Pi = (ni + Be * G2(Or * (1 + et) - ni * ni)) / (1 + et), ve > E3 / 4) return [Pi, Pi];\n                  var To = Pi, hl = 0.5 * Pi;\n                  Pi = 0.5 * (hl + To), cn = 50;\n                  do {\n                    var Ul = G2(Or - Pi * Pi), Lu = Pi * (Ps + mo * Ul) + Bo * O3(Pi / Wr) - Ts;\n                    if (!Lu) break;\n                    Lu < 0 ? hl = Pi : To = Pi, Pi = 0.5 * (hl + To);\n                  } while (n4(To - hl) > p3 && --cn > 0);\n                } else {\n                  Pi = p3, cn = 25;\n                  do {\n                    var au = Pi * Pi, Js = G2(Or - au), Ql = Ps + mo * Js, dc = Pi * Ql + Bo * O3(Pi / Wr) - Ts, Tl = Ql + (Bo - mo * au) / Js;\n                    Pi -= wo = Js ? dc / Tl : 0;\n                  } while (n4(wo) > p3 && --cn > 0);\n                }\n                return [Pi, -ni - Be * G2(Or - Pi * Pi)];\n              }\n              function ya(ve, be) {\n                for (var De = 0, Be = 1, et = 0.5, We = 50; ; ) {\n                  var it = et * et, Ft = G2(et), Ht = O3(1 / G2(1 + it)), tr = 1 - it + et * (1 + it) * Ht, dr = (1 - Ft) / tr, Sr = G2(dr), Or = dr * (1 + it), Wr = Sr * (1 - it), ni = Or - ve * ve, Pi = G2(ni), cn = be + Wr + et * Pi;\n                  if (n4(Be - De) < k4 || --We === 0 || cn === 0) break;\n                  cn > 0 ? De = et : Be = et, et = 0.5 * (De + Be);\n                }\n                if (!We) return null;\n                var ln = O3(Ft), Cn = o4(ln), Kn = 1 / Cn, Ta = 2 * Ft * Cn, fa = (-3 * et + Ht * (1 + 3 * it)) * Ta, $a = (-tr * Cn - (1 - Ft) * fa) / (tr * tr), Co = 0.5 * $a / Sr, Qa = (1 - it) * Co - 2 * et * Sr * Ta, mo = -2 * Kn * Qa, Bo = -Kn * Ta, Ps = -Kn * (et * (1 + it) * $a + dr * (1 + 3 * it) * Ta);\n                return [E3 / 4 * (ve * (mo + Bo * Pi) + Ps * O3(ve / G2(Or))), ln];\n              }\n              function Jn() {\n                return t3.geoProjection(Mn(Li)).scale(239.75);\n              }\n              function Ma(ve, be, De) {\n                var Be, et, We;\n                return ve ? (Be = _o(ve, De), be ? (et = _o(be, 1 - De), We = et[1] * et[1] + De * Be[0] * Be[0] * et[0] * et[0], [[Be[0] * et[2] / We, Be[1] * Be[2] * et[0] * et[1] / We], [Be[1] * et[1] / We, -Be[0] * Be[2] * et[0] * et[2] / We], [Be[2] * et[1] * et[2] / We, -De * Be[0] * Be[1] * et[0] / We]]) : [[Be[0], 0], [Be[1], 0], [Be[2], 0]]) : (et = _o(be, 1 - De), [[0, et[0] / et[1]], [1 / et[1], 0], [et[2] / et[1], 0]]);\n              }\n              function _o(ve, be) {\n                var De, Be, et, We, it;\n                if (be < p3) return We = _2(ve), Be = o4(ve), De = be * (ve - We * Be) / 4, [We - De * Be, Be + De * We, 1 - be * We * We / 2, ve - De];\n                if (be >= 1 - p3) return De = (1 - be) / 4, Be = N2(ve), We = Z(ve), et = 1 / Be, it = Be * j3(ve), [We + De * (it - ve) / (Be * Be), et - De * We * et * (it - ve), et + De * We * et * (it + ve), 2 * i3(s3(ve)) - S2 + De * (it - ve) / Be];\n                var Ft = [1, 0, 0, 0, 0, 0, 0, 0, 0], Ht = [G2(be), 0, 0, 0, 0, 0, 0, 0, 0], tr = 0;\n                for (Be = G2(1 - be), it = 1; n4(Ht[tr] / Ft[tr]) > p3 && tr < 8; ) De = Ft[tr++], Ht[tr] = (De - Be) / 2, Ft[tr] = (De + Be) / 2, Be = G2(De * Be), it *= 2;\n                et = it * Ft[tr] * ve;\n                do\n                  We = Ht[tr] * _2(Be = et) / Ft[tr], et = (O3(We) + et) / 2;\n                while (--tr);\n                return [_2(et), We = o4(et), We / o4(et - Be), et];\n              }\n              function No(ve, be, De) {\n                var Be = n4(ve), et = n4(be), We = j3(et);\n                if (Be) {\n                  var it = 1 / _2(Be), Ft = 1 / (b(Be) * b(Be)), Ht = -(Ft + De * (We * We * it * it) - 1 + De), tr = (De - 1) * Ft, dr = (-Ht + G2(Ht * Ht - 4 * tr)) / 2;\n                  return [po(i3(1 / G2(dr)), De) * v3(ve), po(i3(G2((dr / Ft - 1) / De)), 1 - De) * v3(be)];\n                }\n                return [0, po(i3(We), 1 - De) * v3(be)];\n              }\n              function po(ve, be) {\n                if (!be) return ve;\n                if (be === 1) return u4(b(ve / 2 + L3));\n                for (var De = 1, Be = G2(1 - be), et = G2(be), We = 0; n4(et) > p3; We++) {\n                  if (ve % E3) {\n                    var it = i3(Be * b(ve) / De);\n                    it < 0 && (it += E3), ve += it + ~~(ve / E3) * E3;\n                  } else ve += ve;\n                  et = (De + Be) / 2, Be = G2(De * Be), et = ((De = et) - Be) / 2;\n                }\n                return ve / (h3(2, We) * De);\n              }\n              function Lo(ve, be) {\n                var De = (C3 - 1) / (C3 + 1), Be = G2(1 - De * De), et = po(S2, Be * Be), We = -1, it = u4(b(E3 / 4 + n4(be) / 2)), Ft = s3(We * it) / G2(De), Ht = ko(Ft * o4(We * ve), Ft * _2(We * ve)), tr = No(Ht[0], Ht[1], Be * Be);\n                return [-tr[1], (be >= 0 ? 1 : -1) * (0.5 * et - tr[0])];\n              }\n              function ko(ve, be) {\n                var De = ve * ve, Be = be + 1, et = 1 - De - be * be;\n                return [0.5 * ((ve >= 0 ? S2 : -S2) - a4(et, 2 * ve)), -0.25 * u4(et * et + 4 * De) + 0.5 * u4(Be * Be + De)];\n              }\n              function Ds(ve, be) {\n                var De = be[0] * be[0] + be[1] * be[1];\n                return [(ve[0] * be[0] + ve[1] * be[1]) / De, (ve[1] * be[0] - ve[0] * be[1]) / De];\n              }\n              Lo.invert = function(ve, be) {\n                var De = (C3 - 1) / (C3 + 1), Be = G2(1 - De * De), et = po(S2, Be * Be), We = -1, it = Ma(0.5 * et - be, -ve, Be * Be), Ft = Ds(it[0], it[1]), Ht = a4(Ft[1], Ft[0]) / We;\n                return [Ht, 2 * i3(s3(0.5 / We * u4(De * Ft[0] * Ft[0] + De * Ft[1] * Ft[1]))) - S2];\n              };\n              function Fs() {\n                return t3.geoProjection(Mn(Lo)).scale(151.496);\n              }\n              function ll(ve) {\n                var be = _2(ve), De = o4(ve), Be = ul(ve);\n                Be.invert = ul(-ve);\n                function et(We, it) {\n                  var Ft = Be(We, it);\n                  We = Ft[0], it = Ft[1];\n                  var Ht = _2(it), tr = o4(it), dr = o4(We), Sr = V2(be * Ht + De * tr * dr), Or = _2(Sr), Wr = n4(Or) > p3 ? Sr / Or : 1;\n                  return [Wr * De * _2(We), (n4(We) > S2 ? Wr : -Wr) * (be * tr - De * Ht * dr)];\n                }\n                return et.invert = function(We, it) {\n                  var Ft = G2(We * We + it * it), Ht = -_2(Ft), tr = o4(Ft), dr = Ft * tr, Sr = -it * Ht, Or = Ft * be, Wr = G2(dr * dr + Sr * Sr - Or * Or), ni = a4(dr * Or + Sr * Wr, Sr * Or - dr * Wr), Pi = (Ft > S2 ? -1 : 1) * a4(We * Ht, Ft * o4(ni) * tr + it * _2(ni) * Ht);\n                  return Be.invert(Pi, ni);\n                }, et;\n              }\n              function ul(ve) {\n                var be = _2(ve), De = o4(ve);\n                return function(Be, et) {\n                  var We = o4(et), it = o4(Be) * We, Ft = _2(Be) * We, Ht = _2(et);\n                  return [a4(Ft, it * De - Ht * be), O3(Ht * De + it * be)];\n                };\n              }\n              function zl() {\n                var ve = 0, be = t3.geoProjectionMutator(ll), De = be(ve), Be = De.rotate, et = De.stream, We = t3.geoCircle();\n                return De.parallel = function(it) {\n                  if (!arguments.length) return ve * P3;\n                  var Ft = De.rotate();\n                  return be(ve = it * T3).rotate(Ft);\n                }, De.rotate = function(it) {\n                  return arguments.length ? (Be.call(De, [it[0], it[1] - ve * P3]), We.center([-it[0], -it[1]]), De) : (it = Be.call(De), it[1] += ve * P3, it);\n                }, De.stream = function(it) {\n                  return it = et(it), it.sphere = function() {\n                    it.polygonStart();\n                    var Ft = 0.01, Ht = We.radius(90 - Ft)().coordinates[0], tr = Ht.length - 1, dr = -1, Sr;\n                    for (it.lineStart(); ++dr < tr; ) it.point((Sr = Ht[dr])[0], Sr[1]);\n                    for (it.lineEnd(), Ht = We.radius(90 + Ft)().coordinates[0], tr = Ht.length - 1, it.lineStart(); --dr >= 0; ) it.point((Sr = Ht[dr])[0], Sr[1]);\n                    it.lineEnd(), it.polygonEnd();\n                  }, it;\n                }, De.scale(79.4187).parallel(45).clipAngle(180 - 1e-3);\n              }\n              var us = 3, il = O3(1 - 1 / us) * P3, As = vr(0);\n              function cl(ve) {\n                var be = il * T3, De = xt(E3, be)[0] - xt(-E3, be)[0], Be = As(0, be)[1], et = xt(0, be)[1], We = M4 - et, it = g3 / ve, Ft = 4 / g3, Ht = Be + We * We * 4 / g3;\n                function tr(dr, Sr) {\n                  var Or, Wr = n4(Sr);\n                  if (Wr > be) {\n                    var ni = f4(ve - 1, c5(0, l3((dr + E3) / it)));\n                    dr += E3 * (ve - 1) / ve - ni * it, Or = xt(dr, Wr), Or[0] = Or[0] * g3 / De - g3 * (ve - 1) / (2 * ve) + ni * g3 / ve, Or[1] = Be + (Or[1] - et) * 4 * We / g3, Sr < 0 && (Or[1] = -Or[1]);\n                  } else Or = As(dr, Sr);\n                  return Or[0] *= Ft, Or[1] /= Ht, Or;\n                }\n                return tr.invert = function(dr, Sr) {\n                  dr /= Ft, Sr *= Ht;\n                  var Or = n4(Sr);\n                  if (Or > Be) {\n                    var Wr = f4(ve - 1, c5(0, l3((dr + E3) / it)));\n                    dr = (dr + E3 * (ve - 1) / ve - Wr * it) * De / g3;\n                    var ni = xt.invert(dr, 0.25 * (Or - Be) * g3 / We + et);\n                    return ni[0] -= E3 * (ve - 1) / ve - Wr * it, Sr < 0 && (ni[1] = -ni[1]), ni;\n                  }\n                  return As.invert(dr, Sr);\n                }, tr;\n              }\n              function Ks(ve, be) {\n                return [ve, be & 1 ? 90 - p3 : il];\n              }\n              function zs(ve, be) {\n                return [ve, be & 1 ? -90 + p3 : -il];\n              }\n              function Io(ve) {\n                return [ve[0] * (1 - p3), ve[1]];\n              }\n              function ls(ve) {\n                var be = [].concat(r4.range(-180, 180 + ve / 2, ve).map(Ks), r4.range(180, -180 - ve / 2, -ve).map(zs));\n                return { type: "Polygon", coordinates: [ve === 180 ? be.map(Io) : be] };\n              }\n              function Zl() {\n                var ve = 4, be = t3.geoProjectionMutator(cl), De = be(ve), Be = De.stream;\n                return De.lobes = function(et) {\n                  return arguments.length ? be(ve = +et) : ve;\n                }, De.stream = function(et) {\n                  var We = De.rotate(), it = Be(et), Ft = (De.rotate([0, 0]), Be(et));\n                  return De.rotate(We), it.sphere = function() {\n                    t3.geoStream(ls(180 / ve), Ft);\n                  }, it;\n                }, De.scale(239.75);\n              }\n              function Su(ve) {\n                var be = 1 + ve, De = _2(1 / be), Be = O3(De), et = 2 * G2(E3 / (We = E3 + 4 * Be * be)), We, it = 0.5 * et * (be + G2(ve * (2 + ve))), Ft = ve * ve, Ht = be * be;\n                function tr(dr, Sr) {\n                  var Or = 1 - _2(Sr), Wr, ni;\n                  if (Or && Or < 2) {\n                    var Pi = S2 - Sr, cn = 25, ln;\n                    do {\n                      var Cn = _2(Pi), Kn = o4(Pi), Ta = Be + a4(Cn, be - Kn), fa = 1 + Ht - 2 * be * Kn;\n                      Pi -= ln = (Pi - Ft * Be - be * Cn + fa * Ta - 0.5 * Or * We) / (2 * be * Cn * Ta);\n                    } while (n4(ln) > k4 && --cn > 0);\n                    Wr = et * G2(fa), ni = dr * Ta / E3;\n                  } else Wr = et * (ve + Or), ni = dr * Be / E3;\n                  return [Wr * _2(ni), it - Wr * o4(ni)];\n                }\n                return tr.invert = function(dr, Sr) {\n                  var Or = dr * dr + (Sr -= it) * Sr, Wr = (1 + Ht - Or / (et * et)) / (2 * be), ni = V2(Wr), Pi = _2(ni), cn = Be + a4(Pi, be - Wr);\n                  return [O3(dr / G2(Or)) * E3 / cn, O3(1 - 2 * (ni - Ft * Be - be * Pi + (1 + Ht - 2 * be * Wr) * cn) / We)];\n                }, tr;\n              }\n              function nc() {\n                var ve = 1, be = t3.geoProjectionMutator(Su), De = be(ve);\n                return De.ratio = function(Be) {\n                  return arguments.length ? be(ve = +Be) : ve;\n                }, De.scale(167.774).center([0, 18.67]);\n              }\n              var bs = 0.7109889596207567, Rn = 0.0528035274542;\n              function _a(ve, be) {\n                return be > -bs ? (ve = sr(ve, be), ve[1] += Rn, ve) : _t(ve, be);\n              }\n              _a.invert = function(ve, be) {\n                return be > -bs ? sr.invert(ve, be - Rn) : _t.invert(ve, be);\n              };\n              function Vu() {\n                return t3.geoProjection(_a).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);\n              }\n              function Ol(ve, be) {\n                return n4(be) > bs ? (ve = sr(ve, be), ve[1] -= be > 0 ? Rn : -Rn, ve) : _t(ve, be);\n              }\n              Ol.invert = function(ve, be) {\n                return n4(be) > bs ? sr.invert(ve, be + (be > 0 ? Rn : -Rn)) : _t.invert(ve, be);\n              };\n              function xo() {\n                return t3.geoProjection(Ol).scale(152.63);\n              }\n              function Yl(ve, be, De, Be) {\n                var et = G2(4 * E3 / (2 * De + (1 + ve - be / 2) * _2(2 * De) + (ve + be) / 2 * _2(4 * De) + be / 2 * _2(6 * De))), We = G2(Be * _2(De) * G2((1 + ve * o4(2 * De) + be * o4(4 * De)) / (1 + ve + be))), it = De * Ht(1);\n                function Ft(Sr) {\n                  return G2(1 + ve * o4(2 * Sr) + be * o4(4 * Sr));\n                }\n                function Ht(Sr) {\n                  var Or = Sr * De;\n                  return (2 * Or + (1 + ve - be / 2) * _2(2 * Or) + (ve + be) / 2 * _2(4 * Or) + be / 2 * _2(6 * Or)) / De;\n                }\n                function tr(Sr) {\n                  return Ft(Sr) * _2(Sr);\n                }\n                var dr = function(Sr, Or) {\n                  var Wr = De * Zt(Ht, it * _2(Or) / De, Or / E3);\n                  isNaN(Wr) && (Wr = De * v3(Or));\n                  var ni = et * Ft(Wr);\n                  return [ni * We * Sr / E3 * o4(Wr), ni / We * _2(Wr)];\n                };\n                return dr.invert = function(Sr, Or) {\n                  var Wr = Zt(tr, Or * We / et);\n                  return [Sr * E3 / (o4(Wr) * et * We * Ft(Wr)), O3(De * Ht(Wr / De) / it)];\n                }, De === 0 && (et = G2(Be / E3), dr = function(Sr, Or) {\n                  return [Sr * et, _2(Or) / et];\n                }, dr.invert = function(Sr, Or) {\n                  return [Sr / et, O3(Or * et)];\n                }), dr;\n              }\n              function Ns() {\n                var ve = 1, be = 0, De = 45 * T3, Be = 2, et = t3.geoProjectionMutator(Yl), We = et(ve, be, De, Be);\n                return We.a = function(it) {\n                  return arguments.length ? et(ve = +it, be, De, Be) : ve;\n                }, We.b = function(it) {\n                  return arguments.length ? et(ve, be = +it, De, Be) : be;\n                }, We.psiMax = function(it) {\n                  return arguments.length ? et(ve, be, De = +it * T3, Be) : De * P3;\n                }, We.ratio = function(it) {\n                  return arguments.length ? et(ve, be, De, Be = +it) : Be;\n                }, We.scale(180.739);\n              }\n              function Hl(ve, be, De, Be, et, We, it, Ft, Ht, tr, dr) {\n                if (dr.nanEncountered) return NaN;\n                var Sr, Or, Wr, ni, Pi, cn, ln, Cn, Kn, Ta;\n                if (Sr = De - be, Or = ve(be + Sr * 0.25), Wr = ve(De - Sr * 0.25), isNaN(Or)) {\n                  dr.nanEncountered = true;\n                  return;\n                }\n                if (isNaN(Wr)) {\n                  dr.nanEncountered = true;\n                  return;\n                }\n                return ni = Sr * (Be + 4 * Or + et) / 12, Pi = Sr * (et + 4 * Wr + We) / 12, cn = ni + Pi, Ta = (cn - it) / 15, tr > Ht ? (dr.maxDepthCount++, cn + Ta) : Math.abs(Ta) < Ft ? cn + Ta : (ln = be + Sr * 0.5, Cn = Hl(ve, be, ln, Be, Or, et, ni, Ft * 0.5, Ht, tr + 1, dr), isNaN(Cn) ? (dr.nanEncountered = true, NaN) : (Kn = Hl(ve, ln, De, et, Wr, We, Pi, Ft * 0.5, Ht, tr + 1, dr), isNaN(Kn) ? (dr.nanEncountered = true, NaN) : Cn + Kn));\n              }\n              function ac(ve, be, De, Be, et) {\n                var We = { maxDepthCount: 0, nanEncountered: false };\n                Be === void 0 && (Be = 1e-8), et === void 0 && (et = 20);\n                var it = ve(be), Ft = ve(0.5 * (be + De)), Ht = ve(De), tr = (it + 4 * Ft + Ht) * (De - be) / 6, dr = Hl(ve, be, De, it, Ft, Ht, tr, Be, et, 1, We);\n                return dr;\n              }\n              function aa(ve, be, De) {\n                function Be(Wr) {\n                  return ve + (1 - ve) * h3(1 - h3(Wr, be), 1 / be);\n                }\n                function et(Wr) {\n                  return ac(Be, 0, Wr, 1e-4);\n                }\n                for (var We = 1 / et(1), it = 1e3, Ft = (1 + 1e-8) * We, Ht = [], tr = 0; tr <= it; tr++) Ht.push(et(tr / it) * Ft);\n                function dr(Wr) {\n                  var ni = 0, Pi = it, cn = it >> 1;\n                  do\n                    Ht[cn] > Wr ? Pi = cn : ni = cn, cn = ni + Pi >> 1;\n                  while (cn > ni);\n                  var ln = Ht[cn + 1] - Ht[cn];\n                  return ln && (ln = (Wr - Ht[cn + 1]) / ln), (cn + 1 + ln) / it;\n                }\n                var Sr = 2 * dr(1) / E3 * We / De, Or = function(Wr, ni) {\n                  var Pi = dr(n4(_2(ni))), cn = Be(Pi) * Wr;\n                  return Pi /= Sr, [cn, ni >= 0 ? Pi : -Pi];\n                };\n                return Or.invert = function(Wr, ni) {\n                  var Pi;\n                  return ni *= Sr, n4(ni) < 1 && (Pi = v3(ni) * O3(et(n4(ni)) * We)), [Wr / Be(n4(ni)), Pi];\n                }, Or;\n              }\n              function Oo() {\n                var ve = 0, be = 2.5, De = 1.183136, Be = t3.geoProjectionMutator(aa), et = Be(ve, be, De);\n                return et.alpha = function(We) {\n                  return arguments.length ? Be(ve = +We, be, De) : ve;\n                }, et.k = function(We) {\n                  return arguments.length ? Be(ve, be = +We, De) : be;\n                }, et.gamma = function(We) {\n                  return arguments.length ? Be(ve, be, De = +We) : De;\n                }, et.scale(152.63);\n              }\n              function qo(ve, be) {\n                return n4(ve[0] - be[0]) < p3 && n4(ve[1] - be[1]) < p3;\n              }\n              function ql(ve, be) {\n                for (var De = -1, Be = ve.length, et = ve[0], We, it, Ft, Ht = []; ++De < Be; ) {\n                  We = ve[De], it = (We[0] - et[0]) / be, Ft = (We[1] - et[1]) / be;\n                  for (var tr = 0; tr < be; ++tr) Ht.push([et[0] + tr * it, et[1] + tr * Ft]);\n                  et = We;\n                }\n                return Ht.push(We), Ht;\n              }\n              function Pc(ve) {\n                var be = [], De, Be, et, We, it, Ft, Ht, tr = ve[0].length;\n                for (Ht = 0; Ht < tr; ++Ht) De = ve[0][Ht], Be = De[0][0], et = De[0][1], We = De[1][1], it = De[2][0], Ft = De[2][1], be.push(ql([[Be + p3, et + p3], [Be + p3, We - p3], [it - p3, We - p3], [it - p3, Ft + p3]], 30));\n                for (Ht = ve[1].length - 1; Ht >= 0; --Ht) De = ve[1][Ht], Be = De[0][0], et = De[0][1], We = De[1][1], it = De[2][0], Ft = De[2][1], be.push(ql([[it - p3, Ft - p3], [it - p3, We + p3], [Be + p3, We + p3], [Be + p3, et - p3]], 30));\n                return { type: "Polygon", coordinates: [r4.merge(be)] };\n              }\n              function Do(ve, be, De) {\n                var Be, et;\n                function We(Ht, tr) {\n                  for (var dr = tr < 0 ? -1 : 1, Sr = be[+(tr < 0)], Or = 0, Wr = Sr.length - 1; Or < Wr && Ht > Sr[Or][2][0]; ++Or) ;\n                  var ni = ve(Ht - Sr[Or][1][0], tr);\n                  return ni[0] += ve(Sr[Or][1][0], dr * tr > dr * Sr[Or][0][1] ? Sr[Or][0][1] : tr)[0], ni;\n                }\n                De ? We.invert = De(We) : ve.invert && (We.invert = function(Ht, tr) {\n                  for (var dr = et[+(tr < 0)], Sr = be[+(tr < 0)], Or = 0, Wr = dr.length; Or < Wr; ++Or) {\n                    var ni = dr[Or];\n                    if (ni[0][0] <= Ht && Ht < ni[1][0] && ni[0][1] <= tr && tr < ni[1][1]) {\n                      var Pi = ve.invert(Ht - ve(Sr[Or][1][0], 0)[0], tr);\n                      return Pi[0] += Sr[Or][1][0], qo(We(Pi[0], Pi[1]), [Ht, tr]) ? Pi : null;\n                    }\n                  }\n                });\n                var it = t3.geoProjection(We), Ft = it.stream;\n                return it.stream = function(Ht) {\n                  var tr = it.rotate(), dr = Ft(Ht), Sr = (it.rotate([0, 0]), Ft(Ht));\n                  return it.rotate(tr), dr.sphere = function() {\n                    t3.geoStream(Be, Sr);\n                  }, dr;\n                }, it.lobes = function(Ht) {\n                  return arguments.length ? (Be = Pc(Ht), be = Ht.map(function(tr) {\n                    return tr.map(function(dr) {\n                      return [[dr[0][0] * T3, dr[0][1] * T3], [dr[1][0] * T3, dr[1][1] * T3], [dr[2][0] * T3, dr[2][1] * T3]];\n                    });\n                  }), et = be.map(function(tr) {\n                    return tr.map(function(dr) {\n                      var Sr = ve(dr[0][0], dr[0][1])[0], Or = ve(dr[2][0], dr[2][1])[0], Wr = ve(dr[1][0], dr[0][1])[1], ni = ve(dr[1][0], dr[1][1])[1], Pi;\n                      return Wr > ni && (Pi = Wr, Wr = ni, ni = Pi), [[Sr, Wr], [Or, ni]];\n                    });\n                  }), it) : be.map(function(tr) {\n                    return tr.map(function(dr) {\n                      return [[dr[0][0] * P3, dr[0][1] * P3], [dr[1][0] * P3, dr[1][1] * P3], [dr[2][0] * P3, dr[2][1] * P3]];\n                    });\n                  });\n                }, be != null && it.lobes(be), it;\n              }\n              var rf = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];\n              function Uf() {\n                return Do(St, rf).scale(160.857);\n              }\n              var pl = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];\n              function Zc() {\n                return Do(Ol, pl).scale(152.63);\n              }\n              var Kl = [[[[-180, 0], [-100, 90], [-40, 0]], [[-40, 0], [30, 90], [180, 0]]], [[[-180, 0], [-160, -90], [-100, 0]], [[-100, 0], [-60, -90], [-20, 0]], [[-20, 0], [20, -90], [80, 0]], [[80, 0], [140, -90], [180, 0]]]];\n              function Os() {\n                return Do(sr, Kl).scale(169.529);\n              }\n              var yu = [[[[-180, 0], [-90, 90], [0, 0]], [[0, 0], [90, 90], [180, 0]]], [[[-180, 0], [-90, -90], [0, 0]], [[0, 0], [90, -90], [180, 0]]]];\n              function oc() {\n                return Do(sr, yu).scale(169.529).rotate([20, 0]);\n              }\n              var Cf = [[[[-180, 35], [-30, 90], [0, 35]], [[0, 35], [30, 90], [180, 35]]], [[[-180, -10], [-102, -90], [-65, -10]], [[-65, -10], [5, -90], [77, -10]], [[77, -10], [103, -90], [180, -10]]]];\n              function sc() {\n                return Do(_a, Cf, st).rotate([-20, -55]).scale(164.263).center([0, -5.4036]);\n              }\n              var Vh = [[[[-180, 0], [-110, 90], [-40, 0]], [[-40, 0], [0, 90], [40, 0]], [[40, 0], [110, 90], [180, 0]]], [[[-180, 0], [-110, -90], [-40, 0]], [[-40, 0], [0, -90], [40, 0]], [[40, 0], [110, -90], [180, 0]]]];\n              function Lf() {\n                return Do(_t, Vh).scale(152.63).rotate([-20, 0]);\n              }\n              function cs(ve, be) {\n                return [3 / g3 * ve * G2(E3 * E3 / 3 - be * be), be];\n              }\n              cs.invert = function(ve, be) {\n                return [g3 / 3 * ve / G2(E3 * E3 / 3 - be * be), be];\n              };\n              function nf() {\n                return t3.geoProjection(cs).scale(158.837);\n              }\n              function Vf(ve) {\n                function be(De, Be) {\n                  if (n4(n4(Be) - S2) < p3) return [0, Be < 0 ? -2 : 2];\n                  var et = _2(Be), We = h3((1 + et) / (1 - et), ve / 2), it = 0.5 * (We + 1 / We) + o4(De *= ve);\n                  return [2 * _2(De) / it, (We - 1 / We) / it];\n                }\n                return be.invert = function(De, Be) {\n                  var et = n4(Be);\n                  if (n4(et - 2) < p3) return De ? null : [0, v3(Be) * S2];\n                  if (et > 2) return null;\n                  De /= 2, Be /= 2;\n                  var We = De * De, it = Be * Be, Ft = 2 * Be / (1 + We + it);\n                  return Ft = h3((1 + Ft) / (1 - Ft), 1 / ve), [a4(2 * De, 1 - We - it) / ve, O3((Ft - 1) / (Ft + 1))];\n                }, be;\n              }\n              function Jl() {\n                var ve = 0.5, be = t3.geoProjectionMutator(Vf), De = be(ve);\n                return De.spacing = function(Be) {\n                  return arguments.length ? be(ve = +Be) : ve;\n                }, De.scale(124.75);\n              }\n              var fl = E3 / C3;\n              function lc(ve, be) {\n                return [ve * (1 + G2(o4(be))) / 2, be / (o4(be / 2) * o4(ve / 6))];\n              }\n              lc.invert = function(ve, be) {\n                var De = n4(ve), Be = n4(be), et = p3, We = S2;\n                Be < fl ? We *= Be / fl : et += 6 * V2(fl / Be);\n                for (var it = 0; it < 25; it++) {\n                  var Ft = _2(We), Ht = G2(o4(We)), tr = _2(We / 2), dr = o4(We / 2), Sr = _2(et / 6), Or = o4(et / 6), Wr = 0.5 * et * (1 + Ht) - De, ni = We / (dr * Or) - Be, Pi = Ht ? -0.25 * et * Ft / Ht : 0, cn = 0.5 * (1 + Ht), ln = (1 + 0.5 * We * tr / dr) / (dr * Or), Cn = We / dr * (Sr / 6) / (Or * Or), Kn = Pi * Cn - ln * cn, Ta = (Wr * Cn - ni * cn) / Kn, fa = (ni * Pi - Wr * ln) / Kn;\n                  if (We -= Ta, et -= fa, n4(Ta) < p3 && n4(fa) < p3) break;\n                }\n                return [ve < 0 ? -et : et, be < 0 ? -We : We];\n              };\n              function Fu() {\n                return t3.geoProjection(lc).scale(97.2672);\n              }\n              function Es(ve, be) {\n                var De = ve * ve, Be = be * be;\n                return [ve * (0.975534 + Be * (-0.119161 + De * -0.0143059 + Be * -0.0547009)), be * (1.00384 + De * (0.0802894 + Be * -0.02855 + De * 199025e-9) + Be * (0.0998909 + Be * -0.0491032))];\n              }\n              Es.invert = function(ve, be) {\n                var De = v3(ve) * E3, Be = be / 2, et = 50;\n                do {\n                  var We = De * De, it = Be * Be, Ft = De * Be, Ht = De * (0.975534 + it * (-0.119161 + We * -0.0143059 + it * -0.0547009)) - ve, tr = Be * (1.00384 + We * (0.0802894 + it * -0.02855 + We * 199025e-9) + it * (0.0998909 + it * -0.0491032)) - be, dr = 0.975534 - it * (0.119161 + 3 * We * 0.0143059 + it * 0.0547009), Sr = -Ft * (2 * 0.119161 + 4 * 0.0547009 * it + 2 * 0.0143059 * We), Or = Ft * (2 * 0.0802894 + 4 * 199025e-9 * We + 2 * -0.02855 * it), Wr = 1.00384 + We * (0.0802894 + 199025e-9 * We) + it * (3 * (0.0998909 - 0.02855 * We) - 5 * 0.0491032 * it), ni = Sr * Or - Wr * dr, Pi = (tr * Sr - Ht * Wr) / ni, cn = (Ht * Or - tr * dr) / ni;\n                  De -= Pi, Be -= cn;\n                } while ((n4(Pi) > p3 || n4(cn) > p3) && --et > 0);\n                return et && [De, Be];\n              };\n              function Hs() {\n                return t3.geoProjection(Es).scale(139.98);\n              }\n              function Go(ve, be) {\n                return [_2(ve) / o4(be), b(be) * o4(ve)];\n              }\n              Go.invert = function(ve, be) {\n                var De = ve * ve, Be = be * be, et = Be + 1, We = De + et, it = ve ? x2 * G2((We - G2(We * We - 4 * De)) / De) : 1 / G2(et);\n                return [O3(ve * it), v3(be) * V2(it)];\n              };\n              function ps() {\n                return t3.geoProjection(Go).scale(144.049).clipAngle(90 - 1e-3);\n              }\n              function uc(ve) {\n                var be = o4(ve), De = b(L3 + ve / 2);\n                function Be(et, We) {\n                  var it = We - ve, Ft = n4(it) < p3 ? et * be : n4(Ft = L3 + We / 2) < p3 || n4(n4(Ft) - S2) < p3 ? 0 : et * it / u4(b(Ft) / De);\n                  return [Ft, it];\n                }\n                return Be.invert = function(et, We) {\n                  var it, Ft = We + ve;\n                  return [n4(We) < p3 ? et / be : n4(it = L3 + Ft / 2) < p3 || n4(n4(it) - S2) < p3 ? 0 : et * u4(b(it) / De) / We, Ft];\n                }, Be;\n              }\n              function xl() {\n                return Vt(uc).parallel(40).scale(158.837);\n              }\n              function Gu(ve, be) {\n                return [ve, 1.25 * u4(b(L3 + 0.4 * be))];\n              }\n              Gu.invert = function(ve, be) {\n                return [ve, 2.5 * i3(s3(0.8 * be)) - 0.625 * E3];\n              };\n              function qs() {\n                return t3.geoProjection(Gu).scale(108.318);\n              }\n              function ad(ve) {\n                var be = ve.length - 1;\n                function De(Be, et) {\n                  for (var We = o4(et), it = 2 / (1 + We * o4(Be)), Ft = it * We * _2(Be), Ht = it * _2(et), tr = be, dr = ve[tr], Sr = dr[0], Or = dr[1], Wr; --tr >= 0; ) dr = ve[tr], Sr = dr[0] + Ft * (Wr = Sr) - Ht * Or, Or = dr[1] + Ft * Or + Ht * Wr;\n                  return Sr = Ft * (Wr = Sr) - Ht * Or, Or = Ft * Or + Ht * Wr, [Sr, Or];\n                }\n                return De.invert = function(Be, et) {\n                  var We = 20, it = Be, Ft = et;\n                  do {\n                    for (var Ht = be, tr = ve[Ht], dr = tr[0], Sr = tr[1], Or = 0, Wr = 0, ni; --Ht >= 0; ) tr = ve[Ht], Or = dr + it * (ni = Or) - Ft * Wr, Wr = Sr + it * Wr + Ft * ni, dr = tr[0] + it * (ni = dr) - Ft * Sr, Sr = tr[1] + it * Sr + Ft * ni;\n                    Or = dr + it * (ni = Or) - Ft * Wr, Wr = Sr + it * Wr + Ft * ni, dr = it * (ni = dr) - Ft * Sr - Be, Sr = it * Sr + Ft * ni - et;\n                    var Pi = Or * Or + Wr * Wr, cn, ln;\n                    it -= cn = (dr * Or + Sr * Wr) / Pi, Ft -= ln = (Sr * Or - dr * Wr) / Pi;\n                  } while (n4(cn) + n4(ln) > p3 * p3 && --We > 0);\n                  if (We) {\n                    var Cn = G2(it * it + Ft * Ft), Kn = 2 * i3(Cn * 0.5), Ta = _2(Kn);\n                    return [a4(it * Ta, Cn * o4(Kn)), Cn ? O3(Ft * Ta / Cn) : 0];\n                  }\n                }, De;\n              }\n              var Po = [[0.9972523, 0], [52513e-7, -41175e-7], [74606e-7, 48125e-7], [-0.0153783, -0.1968253], [0.0636871, -0.1408027], [0.3660976, -0.2937382]], od = [[0.98879, 0], [0, 0], [-0.050909, 0], [0, 0], [0.075528, 0]], Yo = [[0.984299, 0], [0.0211642, 37608e-7], [-0.1036018, -0.0575102], [-0.0329095, -0.0320119], [0.0499471, 0.1223335], [0.026046, 0.0899805], [7388e-7, -0.1435792], [75848e-7, -0.1334108], [-0.0216473, 0.0776645], [-0.0225161, 0.0853673]], Pa = [[0.9245, 0], [0, 0], [0.01943, 0]], af = [[0.721316, 0], [0, 0], [-881625e-8, -617325e-8]];\n              function Hu() {\n                return Bl(Po, [152, -64]).scale(1400).center([-160.908, 62.4864]).clipAngle(30).angle(7.8);\n              }\n              function bl() {\n                return Bl(od, [95, -38]).scale(1e3).clipAngle(55).center([-96.5563, 38.8675]);\n              }\n              function Gf() {\n                return Bl(Yo, [120, -45]).scale(359.513).clipAngle(55).center([-117.474, 53.0628]);\n              }\n              function Ic() {\n                return Bl(Pa, [-20, -18]).scale(209.091).center([20, 16.7214]).clipAngle(82);\n              }\n              function yf() {\n                return Bl(af, [165, 10]).scale(250).clipAngle(130).center([-165, -10]);\n              }\n              function Bl(ve, be) {\n                var De = t3.geoProjection(ad(ve)).rotate(be).clipAngle(90), Be = t3.geoRotation(be), et = De.center;\n                return delete De.rotate, De.center = function(We) {\n                  return arguments.length ? et(Be(We)) : Be.invert(et());\n                }, De;\n              }\n              var wh = G2(6), Qf = G2(7);\n              function _f(ve, be) {\n                var De = O3(7 * _2(be) / (3 * wh));\n                return [wh * ve * (2 * o4(2 * De / 3) - 1) / Qf, 9 * _2(De / 3) / Qf];\n              }\n              _f.invert = function(ve, be) {\n                var De = 3 * O3(be * Qf / 9);\n                return [ve * Qf / (wh * (2 * o4(2 * De / 3) - 1)), O3(_2(De) * 3 * wh / 7)];\n              };\n              function Yc() {\n                return t3.geoProjection(_f).scale(164.859);\n              }\n              function eh(ve, be) {\n                for (var De = (1 + x2) * _2(be), Be = be, et = 0, We; et < 25 && (Be -= We = (_2(Be / 2) + _2(Be) - De) / (0.5 * o4(Be / 2) + o4(Be)), !(n4(We) < p3)); et++) ;\n                return [ve * (1 + 2 * o4(Be) / o4(Be / 2)) / (3 * C3), 2 * G2(3) * _2(Be / 2) / G2(2 + C3)];\n              }\n              eh.invert = function(ve, be) {\n                var De = be * G2(2 + C3) / (2 * G2(3)), Be = 2 * O3(De);\n                return [3 * C3 * ve / (1 + 2 * o4(Be) / o4(Be / 2)), O3((De + _2(Be)) / (1 + x2))];\n              };\n              function th() {\n                return t3.geoProjection(eh).scale(188.209);\n              }\n              function ju(ve, be) {\n                for (var De = G2(6 / (4 + E3)), Be = (1 + E3 / 4) * _2(be), et = be / 2, We = 0, it; We < 25 && (et -= it = (et / 2 + _2(et) - Be) / (0.5 + o4(et)), !(n4(it) < p3)); We++) ;\n                return [De * (0.5 + o4(et)) * ve / 1.5, De * et];\n              }\n              ju.invert = function(ve, be) {\n                var De = G2(6 / (4 + E3)), Be = be / De;\n                return n4(n4(Be) - S2) < p3 && (Be = Be < 0 ? -S2 : S2), [1.5 * ve / (De * (0.5 + o4(Be))), O3((Be / 2 + _2(Be)) / (1 + E3 / 4))];\n              };\n              function Hf() {\n                return t3.geoProjection(ju).scale(166.518);\n              }\n              function cc(ve, be) {\n                var De = be * be, Be = De * De, et = De * Be;\n                return [ve * (0.84719 - 0.13063 * De + et * et * (-0.04515 + 0.05494 * De - 0.02326 * Be + 331e-5 * et)), be * (1.01183 + Be * Be * (-0.02625 + 0.01926 * De - 396e-5 * Be))];\n              }\n              cc.invert = function(ve, be) {\n                var De = be, Be = 25, et, We, it, Ft;\n                do\n                  We = De * De, it = We * We, De -= et = (De * (1.01183 + it * it * (-0.02625 + 0.01926 * We - 396e-5 * it)) - be) / (1.01183 + it * it * (9 * -0.02625 + 11 * 0.01926 * We + 13 * -396e-5 * it));\n                while (n4(et) > k4 && --Be > 0);\n                return We = De * De, it = We * We, Ft = We * it, [ve / (0.84719 - 0.13063 * We + Ft * Ft * (-0.04515 + 0.05494 * We - 0.02326 * it + 331e-5 * Ft)), De];\n              };\n              function of() {\n                return t3.geoProjection(cc).scale(175.295);\n              }\n              function Nl(ve, be) {\n                return [ve * (1 + o4(be)) / 2, 2 * (be - b(be / 2))];\n              }\n              Nl.invert = function(ve, be) {\n                for (var De = be / 2, Be = 0, et = 1 / 0; Be < 10 && n4(et) > p3; ++Be) {\n                  var We = o4(be / 2);\n                  be -= et = (be - b(be / 2) - De) / (1 - 0.5 / (We * We));\n                }\n                return [2 * ve / (1 + o4(be)), be];\n              };\n              function Kc() {\n                return t3.geoProjection(Nl).scale(152.63);\n              }\n              var Rc = [[[[-180, 0], [-90, 90], [0, 0]], [[0, 0], [90, 90], [180, 0]]], [[[-180, 0], [-90, -90], [0, 0]], [[0, 0], [90, -90], [180, 0]]]];\n              function gs() {\n                return Do(Ze(1 / 0), Rc).rotate([20, 0]).scale(152.63);\n              }\n              function jf(ve, be) {\n                var De = _2(be), Be = o4(be), et = v3(ve);\n                if (ve === 0 || n4(be) === S2) return [0, be];\n                if (be === 0) return [ve, 0];\n                if (n4(ve) === S2) return [ve * Be, S2 * De];\n                var We = E3 / (2 * ve) - 2 * ve / E3, it = 2 * be / E3, Ft = (1 - it * it) / (De - it), Ht = We * We, tr = Ft * Ft, dr = 1 + Ht / tr, Sr = 1 + tr / Ht, Or = (We * De / Ft - We / 2) / dr, Wr = (tr * De / Ht + Ft / 2) / Sr, ni = Or * Or + Be * Be / dr, Pi = Wr * Wr - (tr * De * De / Ht + Ft * De - 1) / Sr;\n                return [S2 * (Or + G2(ni) * et), S2 * (Wr + G2(Pi < 0 ? 0 : Pi) * v3(-be * We) * et)];\n              }\n              jf.invert = function(ve, be) {\n                ve /= S2, be /= S2;\n                var De = ve * ve, Be = be * be, et = De + Be, We = E3 * E3;\n                return [ve ? (et - 1 + G2((1 - et) * (1 - et) + 4 * De)) / (2 * ve) * S2 : 0, Zt(function(it) {\n                  return et * (E3 * _2(it) - 2 * it) * E3 + 4 * it * it * (be - _2(it)) + 2 * E3 * it - We * be;\n                }, 0)];\n              };\n              function Gh() {\n                return t3.geoProjection(jf).scale(127.267);\n              }\n              var rh = 1.0148, sf = 0.23185, Th = -0.14499, Mu = 0.02406, ih = rh, js = 5 * sf, Eu = 7 * Th, Dc = 9 * Mu, ks = 1.790857183;\n              function bc(ve, be) {\n                var De = be * be;\n                return [ve, be * (rh + De * De * (sf + De * (Th + Mu * De)))];\n              }\n              bc.invert = function(ve, be) {\n                be > ks ? be = ks : be < -ks && (be = -ks);\n                var De = be, Be;\n                do {\n                  var et = De * De;\n                  De -= Be = (De * (rh + et * et * (sf + et * (Th + Mu * et))) - be) / (ih + et * et * (js + et * (Eu + Dc * et)));\n                } while (n4(Be) > p3);\n                return [ve, De];\n              };\n              function hu() {\n                return t3.geoProjection(bc).scale(139.319);\n              }\n              function _u(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                var De = b(be), Be = ve * _2(be);\n                return [_2(Be) / De, be + (1 - o4(Be)) / De];\n              }\n              _u.invert = function(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                var De = ve * ve + be * be, Be = be * 0.5, et = 10, We;\n                do {\n                  var it = b(Be), Ft = 1 / o4(Be), Ht = De - 2 * be * Be + Be * Be;\n                  Be -= We = (it * Ht + 2 * (Be - be)) / (2 + Ht * Ft * Ft + 2 * (Be - be) * it);\n                } while (n4(We) > p3 && --et > 0);\n                return it = b(Be), [(n4(be) < n4(Be + 1 / it) ? O3(ve * it) : v3(be) * v3(ve) * (V2(n4(ve * it)) + S2)) / _2(Be), Be];\n              };\n              function nl() {\n                return t3.geoProjection(_u).scale(103.74);\n              }\n              function nh(ve, be) {\n                var De = Fc(ve[1], ve[0]), Be = Fc(be[1], be[0]), et = bd(De, Be), We = wc(De) / wc(Be);\n                return zu([1, 0, ve[0][0], 0, 1, ve[0][1]], zu([We, 0, 0, 0, We, 0], zu([o4(et), _2(et), 0, -_2(et), o4(et), 0], [1, 0, -be[0][0], 0, 1, -be[0][1]])));\n              }\n              function Ah(ve) {\n                var be = 1 / (ve[0] * ve[4] - ve[1] * ve[3]);\n                return [be * ve[4], -be * ve[1], be * (ve[1] * ve[5] - ve[2] * ve[4]), -be * ve[3], be * ve[0], be * (ve[2] * ve[3] - ve[0] * ve[5])];\n              }\n              function zu(ve, be) {\n                return [ve[0] * be[0] + ve[1] * be[3], ve[0] * be[1] + ve[1] * be[4], ve[0] * be[2] + ve[1] * be[5] + ve[2], ve[3] * be[0] + ve[4] * be[3], ve[3] * be[1] + ve[4] * be[4], ve[3] * be[2] + ve[4] * be[5] + ve[5]];\n              }\n              function Fc(ve, be) {\n                return [ve[0] - be[0], ve[1] - be[1]];\n              }\n              function wc(ve) {\n                return G2(ve[0] * ve[0] + ve[1] * ve[1]);\n              }\n              function bd(ve, be) {\n                return a4(ve[0] * be[1] - ve[1] * be[0], ve[0] * be[0] + ve[1] * be[1]);\n              }\n              function xf(ve, be, De) {\n                Be(ve, { transform: null });\n                function Be(tr, dr) {\n                  if (tr.edges = jl(tr.face), dr.face) {\n                    var Sr = tr.shared = bf(tr.face, dr.face), Or = nh(Sr.map(dr.project), Sr.map(tr.project));\n                    tr.transform = dr.transform ? zu(dr.transform, Or) : Or;\n                    for (var Wr = dr.edges, ni = 0, Pi = Wr.length; ni < Pi; ++ni) Ou(Sr[0], Wr[ni][1]) && Ou(Sr[1], Wr[ni][0]) && (Wr[ni] = tr), Ou(Sr[0], Wr[ni][0]) && Ou(Sr[1], Wr[ni][1]) && (Wr[ni] = tr);\n                    for (Wr = tr.edges, ni = 0, Pi = Wr.length; ni < Pi; ++ni) Ou(Sr[0], Wr[ni][0]) && Ou(Sr[1], Wr[ni][1]) && (Wr[ni] = dr), Ou(Sr[0], Wr[ni][1]) && Ou(Sr[1], Wr[ni][0]) && (Wr[ni] = dr);\n                  } else tr.transform = dr.transform;\n                  return tr.children && tr.children.forEach(function(cn) {\n                    Be(cn, tr);\n                  }), tr;\n                }\n                function et(tr, dr) {\n                  var Sr = be(tr, dr), Or = Sr.project([tr * P3, dr * P3]), Wr;\n                  return (Wr = Sr.transform) ? [Wr[0] * Or[0] + Wr[1] * Or[1] + Wr[2], -(Wr[3] * Or[0] + Wr[4] * Or[1] + Wr[5])] : (Or[1] = -Or[1], Or);\n                }\n                lf(ve) && (et.invert = function(tr, dr) {\n                  var Sr = We(ve, [tr, -dr]);\n                  return Sr && (Sr[0] *= T3, Sr[1] *= T3, Sr);\n                });\n                function We(tr, dr) {\n                  var Sr = tr.project.invert, Or = tr.transform, Wr = dr;\n                  if (Or && (Or = Ah(Or), Wr = [Or[0] * Wr[0] + Or[1] * Wr[1] + Or[2], Or[3] * Wr[0] + Or[4] * Wr[1] + Or[5]]), Sr && tr === it(ni = Sr(Wr))) return ni;\n                  for (var ni, Pi = tr.children, cn = 0, ln = Pi && Pi.length; cn < ln; ++cn) if (ni = We(Pi[cn], dr)) return ni;\n                }\n                function it(tr) {\n                  return be(tr[0] * T3, tr[1] * T3);\n                }\n                var Ft = t3.geoProjection(et), Ht = Ft.stream;\n                return Ft.stream = function(tr) {\n                  var dr = Ft.rotate(), Sr = Ht(tr), Or = (Ft.rotate([0, 0]), Ht(tr));\n                  return Ft.rotate(dr), Sr.sphere = function() {\n                    Or.polygonStart(), Or.lineStart(), Pf(Or, ve), Or.lineEnd(), Or.polygonEnd();\n                  }, Sr;\n                }, Ft.angle(De == null ? -30 : De * P3);\n              }\n              function Pf(ve, be, De) {\n                var Be, et = be.edges, We = et.length, it, Ft = { type: "MultiPoint", coordinates: be.face }, Ht = be.face.filter(function(Pi) {\n                  return n4(Pi[1]) !== 90;\n                }), tr = t3.geoBounds({ type: "MultiPoint", coordinates: Ht }), dr = false, Sr = -1, Or = tr[1][0] - tr[0][0], Wr = Or === 180 || Or === 360 ? [(tr[0][0] + tr[1][0]) / 2, (tr[0][1] + tr[1][1]) / 2] : t3.geoCentroid(Ft);\n                if (De) for (; ++Sr < We && et[Sr] !== De; ) ;\n                ++Sr;\n                for (var ni = 0; ni < We; ++ni) it = et[(ni + Sr) % We], Array.isArray(it) ? (dr || (ve.point((Be = t3.geoInterpolate(it[0], Wr)(p3))[0], Be[1]), dr = true), ve.point((Be = t3.geoInterpolate(it[1], Wr)(p3))[0], Be[1])) : (dr = false, it !== De && Pf(ve, it, be));\n              }\n              function Ou(ve, be) {\n                return ve && be && ve[0] === be[0] && ve[1] === be[1];\n              }\n              function bf(ve, be) {\n                for (var De, Be, et = ve.length, We = null, it = 0; it < et; ++it) {\n                  De = ve[it];\n                  for (var Ft = be.length; --Ft >= 0; ) if (Be = be[Ft], De[0] === Be[0] && De[1] === Be[1]) {\n                    if (We) return [We, De];\n                    We = De;\n                  }\n                }\n              }\n              function jl(ve) {\n                for (var be = ve.length, De = [], Be = ve[be - 1], et = 0; et < be; ++et) De.push([Be, Be = ve[et]]);\n                return De;\n              }\n              function lf(ve) {\n                return ve.project.invert || ve.children && ve.children.some(lf);\n              }\n              var Hh = [[0, 90], [-90, 0], [0, 0], [90, 0], [180, 0], [0, -90]], If = [[0, 2, 1], [0, 3, 2], [5, 1, 2], [5, 2, 3], [0, 1, 4], [0, 4, 3], [5, 4, 1], [5, 3, 4]].map(function(ve) {\n                return ve.map(function(be) {\n                  return Hh[be];\n                });\n              });\n              function Cs(ve) {\n                ve = ve || function(De) {\n                  var Be = t3.geoCentroid({ type: "MultiPoint", coordinates: De });\n                  return t3.geoGnomonic().scale(1).translate([0, 0]).rotate([-Be[0], -Be[1]]);\n                };\n                var be = If.map(function(De) {\n                  return { face: De, project: ve(De) };\n                });\n                return [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(De, Be) {\n                  var et = be[De];\n                  et && (et.children || (et.children = [])).push(be[Be]);\n                }), xf(be[0], function(De, Be) {\n                  return be[De < -E3 / 2 ? Be < 0 ? 6 : 4 : De < 0 ? Be < 0 ? 2 : 0 : De < E3 / 2 ? Be < 0 ? 3 : 1 : Be < 0 ? 7 : 5];\n                }).angle(-30).scale(101.858).center([0, 45]);\n              }\n              var du = 2 / G2(3);\n              function ku(ve, be) {\n                var De = xt(ve, be);\n                return [De[0] * du, De[1]];\n              }\n              ku.invert = function(ve, be) {\n                return xt.invert(ve / du, be);\n              };\n              function Wf(ve) {\n                ve = ve || function(De) {\n                  var Be = t3.geoCentroid({ type: "MultiPoint", coordinates: De });\n                  return t3.geoProjection(ku).translate([0, 0]).scale(1).rotate(Be[1] > 0 ? [-Be[0], 0] : [180 - Be[0], 180]);\n                };\n                var be = If.map(function(De) {\n                  return { face: De, project: ve(De) };\n                });\n                return [-1, 0, 0, 1, 0, 1, 4, 5].forEach(function(De, Be) {\n                  var et = be[De];\n                  et && (et.children || (et.children = [])).push(be[Be]);\n                }), xf(be[0], function(De, Be) {\n                  return be[De < -E3 / 2 ? Be < 0 ? 6 : 4 : De < 0 ? Be < 0 ? 2 : 0 : De < E3 / 2 ? Be < 0 ? 3 : 1 : Be < 0 ? 7 : 5];\n                }).angle(-30).scale(121.906).center([0, 48.5904]);\n              }\n              function Us(ve) {\n                ve = ve || function(it) {\n                  var Ft = it.length === 6 ? t3.geoCentroid({ type: "MultiPoint", coordinates: it }) : it[0];\n                  return t3.geoGnomonic().scale(1).translate([0, 0]).rotate([-Ft[0], -Ft[1]]);\n                };\n                var be = If.map(function(it) {\n                  for (var Ft = it.map(Rf), Ht = Ft.length, tr = Ft[Ht - 1], dr, Sr = [], Or = 0; Or < Ht; ++Or) dr = Ft[Or], Sr.push(Wu([tr[0] * 0.9486832980505138 + dr[0] * 0.31622776601683794, tr[1] * 0.9486832980505138 + dr[1] * 0.31622776601683794, tr[2] * 0.9486832980505138 + dr[2] * 0.31622776601683794]), Wu([dr[0] * 0.9486832980505138 + tr[0] * 0.31622776601683794, dr[1] * 0.9486832980505138 + tr[1] * 0.31622776601683794, dr[2] * 0.9486832980505138 + tr[2] * 0.31622776601683794])), tr = dr;\n                  return Sr;\n                }), De = [], Be = [-1, 0, 0, 1, 0, 1, 4, 5];\n                be.forEach(function(it, Ft) {\n                  for (var Ht = If[Ft], tr = Ht.length, dr = De[Ft] = [], Sr = 0; Sr < tr; ++Sr) be.push([Ht[Sr], it[(Sr * 2 + 2) % (2 * tr)], it[(Sr * 2 + 1) % (2 * tr)]]), Be.push(Ft), dr.push(zc(Rf(it[(Sr * 2 + 2) % (2 * tr)]), Rf(it[(Sr * 2 + 1) % (2 * tr)])));\n                });\n                var et = be.map(function(it) {\n                  return { project: ve(it), face: it };\n                });\n                Be.forEach(function(it, Ft) {\n                  var Ht = et[it];\n                  Ht && (Ht.children || (Ht.children = [])).push(et[Ft]);\n                });\n                function We(it, Ft) {\n                  var Ht = o4(Ft), tr = [Ht * o4(it), Ht * _2(it), _2(Ft)], dr = it < -E3 / 2 ? Ft < 0 ? 6 : 4 : it < 0 ? Ft < 0 ? 2 : 0 : it < E3 / 2 ? Ft < 0 ? 3 : 1 : Ft < 0 ? 7 : 5, Sr = De[dr];\n                  return et[wf(Sr[0], tr) < 0 ? 8 + 3 * dr : wf(Sr[1], tr) < 0 ? 8 + 3 * dr + 1 : wf(Sr[2], tr) < 0 ? 8 + 3 * dr + 2 : dr];\n                }\n                return xf(et[0], We).angle(-30).scale(110.625).center([0, 45]);\n              }\n              function wf(ve, be) {\n                for (var De = 0, Be = ve.length, et = 0; De < Be; ++De) et += ve[De] * be[De];\n                return et;\n              }\n              function zc(ve, be) {\n                return [ve[1] * be[2] - ve[2] * be[1], ve[2] * be[0] - ve[0] * be[2], ve[0] * be[1] - ve[1] * be[0]];\n              }\n              function Wu(ve) {\n                return [a4(ve[1], ve[0]) * P3, O3(c5(-1, f4(1, ve[2]))) * P3];\n              }\n              function Rf(ve) {\n                var be = ve[0] * T3, De = ve[1] * T3, Be = o4(De);\n                return [Be * o4(be), Be * _2(be), _2(De)];\n              }\n              function Xu() {\n              }\n              function uf(ve) {\n                if ((De = ve.length) < 4) return false;\n                for (var be = 0, De, Be = ve[De - 1][1] * ve[0][0] - ve[De - 1][0] * ve[0][1]; ++be < De; ) Be += ve[be - 1][1] * ve[be][0] - ve[be - 1][0] * ve[be][1];\n                return Be <= 0;\n              }\n              function Xf(ve, be) {\n                for (var De = be[0], Be = be[1], et = false, We = 0, it = ve.length, Ft = it - 1; We < it; Ft = We++) {\n                  var Ht = ve[We], tr = Ht[0], dr = Ht[1], Sr = ve[Ft], Or = Sr[0], Wr = Sr[1];\n                  dr > Be ^ Wr > Be && De < (Or - tr) * (Be - dr) / (Wr - dr) + tr && (et = !et);\n                }\n                return et;\n              }\n              function Wl(ve, be) {\n                var De = be.stream, Be;\n                if (!De) throw new Error("invalid projection");\n                switch (ve && ve.type) {\n                  case "Feature":\n                    Be = Zu;\n                    break;\n                  case "FeatureCollection":\n                    Be = ah;\n                    break;\n                  default:\n                    Be = Tc;\n                    break;\n                }\n                return Be(ve, De);\n              }\n              function ah(ve, be) {\n                return { type: "FeatureCollection", features: ve.features.map(function(De) {\n                  return Zu(De, be);\n                }) };\n              }\n              function Zu(ve, be) {\n                return { type: "Feature", id: ve.id, properties: ve.properties, geometry: Tc(ve.geometry, be) };\n              }\n              function Oc(ve, be) {\n                return { type: "GeometryCollection", geometries: ve.geometries.map(function(De) {\n                  return Tc(De, be);\n                }) };\n              }\n              function Tc(ve, be) {\n                if (!ve) return null;\n                if (ve.type === "GeometryCollection") return Oc(ve, be);\n                var De;\n                switch (ve.type) {\n                  case "Point":\n                    De = qc;\n                    break;\n                  case "MultiPoint":\n                    De = qc;\n                    break;\n                  case "LineString":\n                    De = cf;\n                    break;\n                  case "MultiLineString":\n                    De = cf;\n                    break;\n                  case "Polygon":\n                    De = fc;\n                    break;\n                  case "MultiPolygon":\n                    De = fc;\n                    break;\n                  case "Sphere":\n                    De = fc;\n                    break;\n                  default:\n                    return null;\n                }\n                return t3.geoStream(ve, be(De)), De.result();\n              }\n              var wl = [], vu = [], qc = { point: function(ve, be) {\n                wl.push([ve, be]);\n              }, result: function() {\n                var ve = wl.length ? wl.length < 2 ? { type: "Point", coordinates: wl[0] } : { type: "MultiPoint", coordinates: wl } : null;\n                return wl = [], ve;\n              } }, cf = { lineStart: Xu, point: function(ve, be) {\n                wl.push([ve, be]);\n              }, lineEnd: function() {\n                wl.length && (vu.push(wl), wl = []);\n              }, result: function() {\n                var ve = vu.length ? vu.length < 2 ? { type: "LineString", coordinates: vu[0] } : { type: "MultiLineString", coordinates: vu } : null;\n                return vu = [], ve;\n              } }, fc = { polygonStart: Xu, lineStart: Xu, point: function(ve, be) {\n                wl.push([ve, be]);\n              }, lineEnd: function() {\n                var ve = wl.length;\n                if (ve) {\n                  do\n                    wl.push(wl[0].slice());\n                  while (++ve < 4);\n                  vu.push(wl), wl = [];\n                }\n              }, polygonEnd: Xu, result: function() {\n                if (!vu.length) return null;\n                var ve = [], be = [];\n                return vu.forEach(function(De) {\n                  uf(De) ? ve.push([De]) : be.push(De);\n                }), be.forEach(function(De) {\n                  var Be = De[0];\n                  ve.some(function(et) {\n                    if (Xf(et[0], Be)) return et.push(De), true;\n                  }) || ve.push([De]);\n                }), vu = [], ve.length ? ve.length > 1 ? { type: "MultiPolygon", coordinates: ve } : { type: "Polygon", coordinates: ve[0] } : null;\n              } };\n              function Bc(ve) {\n                var be = ve(S2, 0)[0] - ve(-S2, 0)[0];\n                function De(Be, et) {\n                  var We = n4(Be) < S2, it = ve(We ? Be : Be > 0 ? Be - E3 : Be + E3, et), Ft = (it[0] - it[1]) * x2, Ht = (it[0] + it[1]) * x2;\n                  if (We) return [Ft, Ht];\n                  var tr = be * x2, dr = Ft > 0 ^ Ht > 0 ? -1 : 1;\n                  return [dr * Ft - v3(Ht) * tr, dr * Ht - v3(Ft) * tr];\n                }\n                return ve.invert && (De.invert = function(Be, et) {\n                  var We = (Be + et) * x2, it = (et - Be) * x2, Ft = n4(We) < 0.5 * be && n4(it) < 0.5 * be;\n                  if (!Ft) {\n                    var Ht = be * x2, tr = We > 0 ^ it > 0 ? -1 : 1, dr = -tr * Be + (it > 0 ? 1 : -1) * Ht, Sr = -tr * et + (We > 0 ? 1 : -1) * Ht;\n                    We = (-dr - Sr) * x2, it = (dr - Sr) * x2;\n                  }\n                  var Or = ve.invert(We, it);\n                  return Ft || (Or[0] += We > 0 ? E3 : -E3), Or;\n                }), t3.geoProjection(De).rotate([-90, -90, 45]).clipAngle(180 - 1e-3);\n              }\n              function At() {\n                return Bc(Li).scale(176.423);\n              }\n              function Wt() {\n                return Bc(Lo).scale(111.48);\n              }\n              function Cr(ve, be) {\n                if (!(0 <= (be = +be) && be <= 20)) throw new Error("invalid digits");\n                function De(tr) {\n                  var dr = tr.length, Sr = 2, Or = new Array(dr);\n                  for (Or[0] = +tr[0].toFixed(be), Or[1] = +tr[1].toFixed(be); Sr < dr; ) Or[Sr] = tr[Sr], ++Sr;\n                  return Or;\n                }\n                function Be(tr) {\n                  return tr.map(De);\n                }\n                function et(tr) {\n                  for (var dr = De(tr[0]), Sr = [dr], Or = 1; Or < tr.length; Or++) {\n                    var Wr = De(tr[Or]);\n                    (Wr.length > 2 || Wr[0] != dr[0] || Wr[1] != dr[1]) && (Sr.push(Wr), dr = Wr);\n                  }\n                  return Sr.length === 1 && tr.length > 1 && Sr.push(De(tr[tr.length - 1])), Sr;\n                }\n                function We(tr) {\n                  return tr.map(et);\n                }\n                function it(tr) {\n                  if (tr == null) return tr;\n                  var dr;\n                  switch (tr.type) {\n                    case "GeometryCollection":\n                      dr = { type: "GeometryCollection", geometries: tr.geometries.map(it) };\n                      break;\n                    case "Point":\n                      dr = { type: "Point", coordinates: De(tr.coordinates) };\n                      break;\n                    case "MultiPoint":\n                      dr = { type: tr.type, coordinates: Be(tr.coordinates) };\n                      break;\n                    case "LineString":\n                      dr = { type: tr.type, coordinates: et(tr.coordinates) };\n                      break;\n                    case "MultiLineString":\n                    case "Polygon":\n                      dr = { type: tr.type, coordinates: We(tr.coordinates) };\n                      break;\n                    case "MultiPolygon":\n                      dr = { type: "MultiPolygon", coordinates: tr.coordinates.map(We) };\n                      break;\n                    default:\n                      return tr;\n                  }\n                  return tr.bbox != null && (dr.bbox = tr.bbox), dr;\n                }\n                function Ft(tr) {\n                  var dr = { type: "Feature", properties: tr.properties, geometry: it(tr.geometry) };\n                  return tr.id != null && (dr.id = tr.id), tr.bbox != null && (dr.bbox = tr.bbox), dr;\n                }\n                if (ve != null) switch (ve.type) {\n                  case "Feature":\n                    return Ft(ve);\n                  case "FeatureCollection": {\n                    var Ht = { type: "FeatureCollection", features: ve.features.map(Ft) };\n                    return ve.bbox != null && (Ht.bbox = ve.bbox), Ht;\n                  }\n                  default:\n                    return it(ve);\n                }\n                return ve;\n              }\n              function Ar(ve) {\n                var be = _2(ve);\n                function De(Be, et) {\n                  var We = be ? b(Be * be / 2) / be : Be / 2;\n                  if (!et) return [2 * We, -ve];\n                  var it = 2 * i3(We * _2(et)), Ft = 1 / b(et);\n                  return [_2(it) * Ft, et + (1 - o4(it)) * Ft - ve];\n                }\n                return De.invert = function(Be, et) {\n                  if (n4(et += ve) < p3) return [be ? 2 * i3(be * Be / 2) / be : Be, 0];\n                  var We = Be * Be + et * et, it = 0, Ft = 10, Ht;\n                  do {\n                    var tr = b(it), dr = 1 / o4(it), Sr = We - 2 * et * it + it * it;\n                    it -= Ht = (tr * Sr + 2 * (it - et)) / (2 + Sr * dr * dr + 2 * (it - et) * tr);\n                  } while (n4(Ht) > p3 && --Ft > 0);\n                  var Or = Be * (tr = b(it)), Wr = b(n4(et) < n4(it + 1 / tr) ? O3(Or) * 0.5 : V2(Or) * 0.5 + E3 / 4) / _2(it);\n                  return [be ? 2 * i3(be * Wr) / be : 2 * Wr, it];\n                }, De;\n              }\n              function Kr() {\n                return Vt(Ar).scale(131.215);\n              }\n              var ki = [[0.9986, -0.062], [1, 0], [0.9986, 0.062], [0.9954, 0.124], [0.99, 0.186], [0.9822, 0.248], [0.973, 0.31], [0.96, 0.372], [0.9427, 0.434], [0.9216, 0.4958], [0.8962, 0.5571], [0.8679, 0.6176], [0.835, 0.6769], [0.7986, 0.7346], [0.7597, 0.7903], [0.7186, 0.8435], [0.6732, 0.8936], [0.6213, 0.9394], [0.5722, 0.9761], [0.5322, 1]];\n              ki.forEach(function(ve) {\n                ve[1] *= 1.0144;\n              });\n              function Xi(ve, be) {\n                var De = f4(18, n4(be) * 36 / E3), Be = l3(De), et = De - Be, We = (Sr = ki[Be])[0], it = Sr[1], Ft = (Sr = ki[++Be])[0], Ht = Sr[1], tr = (Sr = ki[f4(19, ++Be)])[0], dr = Sr[1], Sr;\n                return [ve * (Ft + et * (tr - We) / 2 + et * et * (tr - 2 * Ft + We) / 2), (be > 0 ? S2 : -S2) * (Ht + et * (dr - it) / 2 + et * et * (dr - 2 * Ht + it) / 2)];\n              }\n              Xi.invert = function(ve, be) {\n                var De = be / S2, Be = De * 90, et = f4(18, n4(Be / 5)), We = c5(0, l3(et));\n                do {\n                  var it = ki[We][1], Ft = ki[We + 1][1], Ht = ki[f4(19, We + 2)][1], tr = Ht - it, dr = Ht - 2 * Ft + it, Sr = 2 * (n4(De) - Ft) / tr, Or = dr / tr, Wr = Sr * (1 - Or * Sr * (1 - 2 * Or * Sr));\n                  if (Wr >= 0 || We === 1) {\n                    Be = (be >= 0 ? 5 : -5) * (Wr + et);\n                    var ni = 50, Pi;\n                    do\n                      et = f4(18, n4(Be) / 5), We = l3(et), Wr = et - We, it = ki[We][1], Ft = ki[We + 1][1], Ht = ki[f4(19, We + 2)][1], Be -= (Pi = (be >= 0 ? S2 : -S2) * (Ft + Wr * (Ht - it) / 2 + Wr * Wr * (Ht - 2 * Ft + it) / 2) - be) * P3;\n                    while (n4(Pi) > k4 && --ni > 0);\n                    break;\n                  }\n                } while (--We >= 0);\n                var cn = ki[We][0], ln = ki[We + 1][0], Cn = ki[f4(19, We + 2)][0];\n                return [ve / (ln + Wr * (Cn - cn) / 2 + Wr * Wr * (Cn - 2 * ln + cn) / 2), Be * T3];\n              };\n              function dn() {\n                return t3.geoProjection(Xi).scale(152.63);\n              }\n              function wn(ve) {\n                function be(De, Be) {\n                  var et = o4(Be), We = (ve - 1) / (ve - et * o4(De));\n                  return [We * et * _2(De), We * _2(Be)];\n                }\n                return be.invert = function(De, Be) {\n                  var et = De * De + Be * Be, We = G2(et), it = (ve - G2(1 - et * (ve + 1) / (ve - 1))) / ((ve - 1) / We + We / (ve - 1));\n                  return [a4(De * it, We * G2(1 - it * it)), We ? O3(Be * it / We) : 0];\n                }, be;\n              }\n              function Nn(ve, be) {\n                var De = wn(ve);\n                if (!be) return De;\n                var Be = o4(be), et = _2(be);\n                function We(it, Ft) {\n                  var Ht = De(it, Ft), tr = Ht[1], dr = tr * et / (ve - 1) + Be;\n                  return [Ht[0] * Be / dr, tr / dr];\n                }\n                return We.invert = function(it, Ft) {\n                  var Ht = (ve - 1) / (ve - 1 - Ft * et);\n                  return De.invert(Ht * it, Ht * Ft * Be);\n                }, We;\n              }\n              function Yi() {\n                var ve = 2, be = 0, De = t3.geoProjectionMutator(Nn), Be = De(ve, be);\n                return Be.distance = function(et) {\n                  return arguments.length ? De(ve = +et, be) : ve;\n                }, Be.tilt = function(et) {\n                  return arguments.length ? De(ve, be = et * T3) : be * P3;\n                }, Be.scale(432.147).clipAngle(V2(1 / ve) * P3 - 1e-6);\n              }\n              var Qi = 1e-4, on = 1e4, Fi = -180, $n = Fi + Qi, Ca = 180, Ra = Ca - Qi, La = -90, Na = La + Qi, Yn = 90, Dn = Yn - Qi;\n              function Ka(ve) {\n                return ve.length > 0;\n              }\n              function bo(ve) {\n                return Math.floor(ve * on) / on;\n              }\n              function Xo(ve) {\n                return ve === La || ve === Yn ? [0, ve] : [Fi, bo(ve)];\n              }\n              function Ss(ve) {\n                var be = ve[0], De = ve[1], Be = false;\n                return be <= $n ? (be = Fi, Be = true) : be >= Ra && (be = Ca, Be = true), De <= Na ? (De = La, Be = true) : De >= Dn && (De = Yn, Be = true), Be ? [be, De] : ve;\n              }\n              function as(ve) {\n                return ve.map(Ss);\n              }\n              function ws(ve, be, De) {\n                for (var Be = 0, et = ve.length; Be < et; ++Be) {\n                  var We = ve[Be].slice();\n                  De.push({ index: -1, polygon: be, ring: We });\n                  for (var it = 0, Ft = We.length; it < Ft; ++it) {\n                    var Ht = We[it], tr = Ht[0], dr = Ht[1];\n                    if (tr <= $n || tr >= Ra || dr <= Na || dr >= Dn) {\n                      We[it] = Ss(Ht);\n                      for (var Sr = it + 1; Sr < Ft; ++Sr) {\n                        var Or = We[Sr], Wr = Or[0], ni = Or[1];\n                        if (Wr > $n && Wr < Ra && ni > Na && ni < Dn) break;\n                      }\n                      if (Sr === it + 1) continue;\n                      if (it) {\n                        var Pi = { index: -1, polygon: be, ring: We.slice(0, it + 1) };\n                        Pi.ring[Pi.ring.length - 1] = Xo(dr), De[De.length - 1] = Pi;\n                      } else De.pop();\n                      if (Sr >= Ft) break;\n                      De.push({ index: -1, polygon: be, ring: We = We.slice(Sr - 1) }), We[0] = Xo(We[0][1]), it = -1, Ft = We.length;\n                    }\n                  }\n                }\n              }\n              function Ho(ve) {\n                var be, De = ve.length, Be = {}, et = {}, We, it, Ft, Ht, tr;\n                for (be = 0; be < De; ++be) {\n                  if (We = ve[be], it = We.ring[0], Ht = We.ring[We.ring.length - 1], it[0] === Ht[0] && it[1] === Ht[1]) {\n                    We.polygon.push(We.ring), ve[be] = null;\n                    continue;\n                  }\n                  We.index = be, Be[it] = et[Ht] = We;\n                }\n                for (be = 0; be < De; ++be) if (We = ve[be], We) {\n                  if (it = We.ring[0], Ht = We.ring[We.ring.length - 1], Ft = et[it], tr = Be[Ht], delete Be[it], delete et[Ht], it[0] === Ht[0] && it[1] === Ht[1]) {\n                    We.polygon.push(We.ring);\n                    continue;\n                  }\n                  Ft ? (delete et[it], delete Be[Ft.ring[0]], Ft.ring.pop(), ve[Ft.index] = null, We = { index: -1, polygon: Ft.polygon, ring: Ft.ring.concat(We.ring) }, Ft === tr ? We.polygon.push(We.ring) : (We.index = De++, ve.push(Be[We.ring[0]] = et[We.ring[We.ring.length - 1]] = We))) : tr ? (delete Be[Ht], delete et[tr.ring[tr.ring.length - 1]], We.ring.pop(), We = { index: De++, polygon: tr.polygon, ring: We.ring.concat(tr.ring) }, ve[tr.index] = null, ve.push(Be[We.ring[0]] = et[We.ring[We.ring.length - 1]] = We)) : (We.ring.push(We.ring[0]), We.polygon.push(We.ring));\n                }\n              }\n              function ml(ve) {\n                var be = { type: "Feature", geometry: Ws(ve.geometry) };\n                return ve.id != null && (be.id = ve.id), ve.bbox != null && (be.bbox = ve.bbox), ve.properties != null && (be.properties = ve.properties), be;\n              }\n              function Ws(ve) {\n                if (ve == null) return ve;\n                var be, De, Be, et;\n                switch (ve.type) {\n                  case "GeometryCollection":\n                    be = { type: "GeometryCollection", geometries: ve.geometries.map(Ws) };\n                    break;\n                  case "Point":\n                    be = { type: "Point", coordinates: Ss(ve.coordinates) };\n                    break;\n                  case "MultiPoint":\n                  case "LineString":\n                    be = { type: ve.type, coordinates: as(ve.coordinates) };\n                    break;\n                  case "MultiLineString":\n                    be = { type: "MultiLineString", coordinates: ve.coordinates.map(as) };\n                    break;\n                  case "Polygon": {\n                    var We = [];\n                    ws(ve.coordinates, We, De = []), Ho(De), be = { type: "Polygon", coordinates: We };\n                    break;\n                  }\n                  case "MultiPolygon": {\n                    De = [], Be = -1, et = ve.coordinates.length;\n                    for (var it = new Array(et); ++Be < et; ) ws(ve.coordinates[Be], it[Be] = [], De);\n                    Ho(De), be = { type: "MultiPolygon", coordinates: it.filter(Ka) };\n                    break;\n                  }\n                  default:\n                    return ve;\n                }\n                return ve.bbox != null && (be.bbox = ve.bbox), be;\n              }\n              function Ls(ve) {\n                if (ve == null) return ve;\n                switch (ve.type) {\n                  case "Feature":\n                    return ml(ve);\n                  case "FeatureCollection": {\n                    var be = { type: "FeatureCollection", features: ve.features.map(ml) };\n                    return ve.bbox != null && (be.bbox = ve.bbox), be;\n                  }\n                  default:\n                    return Ws(ve);\n                }\n              }\n              function va(ve, be) {\n                var De = b(be / 2), Be = _2(L3 * De);\n                return [ve * (0.74482 - 0.34588 * Be * Be), 1.70711 * De];\n              }\n              va.invert = function(ve, be) {\n                var De = be / 1.70711, Be = _2(L3 * De);\n                return [ve / (0.74482 - 0.34588 * Be * Be), 2 * i3(De)];\n              };\n              function no() {\n                return t3.geoProjection(va).scale(146.153);\n              }\n              function ys(ve, be, De) {\n                var Be = t3.geoInterpolate(be, De), et = Be(0.5), We = t3.geoRotation([-et[0], -et[1]])(be), it = Be.distance / 2, Ft = -O3(_2(We[1] * T3) / _2(it)), Ht = [-et[0], -et[1], -(We[0] > 0 ? E3 - Ft : Ft) * P3], tr = t3.geoProjection(ve(it)).rotate(Ht), dr = t3.geoRotation(Ht), Sr = tr.center;\n                return delete tr.rotate, tr.center = function(Or) {\n                  return arguments.length ? Sr(dr(Or)) : dr.invert(Sr());\n                }, tr.clipAngle(90);\n              }\n              function rs(ve) {\n                var be = o4(ve);\n                function De(Be, et) {\n                  var We = t3.geoGnomonicRaw(Be, et);\n                  return We[0] *= be, We;\n                }\n                return De.invert = function(Be, et) {\n                  return t3.geoGnomonicRaw.invert(Be / be, et);\n                }, De;\n              }\n              function $l() {\n                return Cu([-158, 21.5], [-77, 39]).clipAngle(60).scale(400);\n              }\n              function Cu(ve, be) {\n                return ys(rs, ve, be);\n              }\n              function Yu(ve) {\n                if (!(ve *= 2)) return t3.geoAzimuthalEquidistantRaw;\n                var be = -ve / 2, De = -be, Be = ve * ve, et = b(De), We = 0.5 / _2(De);\n                function it(Ft, Ht) {\n                  var tr = V2(o4(Ht) * o4(Ft - be)), dr = V2(o4(Ht) * o4(Ft - De)), Sr = Ht < 0 ? -1 : 1;\n                  return tr *= tr, dr *= dr, [(tr - dr) / (2 * ve), Sr * G2(4 * Be * dr - (Be - tr + dr) * (Be - tr + dr)) / (2 * ve)];\n                }\n                return it.invert = function(Ft, Ht) {\n                  var tr = Ht * Ht, dr = o4(G2(tr + (Or = Ft + be) * Or)), Sr = o4(G2(tr + (Or = Ft + De) * Or)), Or, Wr;\n                  return [a4(Wr = dr - Sr, Or = (dr + Sr) * et), (Ht < 0 ? -1 : 1) * V2(G2(Or * Or + Wr * Wr) * We)];\n                }, it;\n              }\n              function Nc() {\n                return pu([-158, 21.5], [-77, 39]).clipAngle(130).scale(122.571);\n              }\n              function pu(ve, be) {\n                return ys(Yu, ve, be);\n              }\n              function Uc(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                var De = n4(be / S2), Be = O3(De);\n                if (n4(ve) < p3 || n4(n4(be) - S2) < p3) return [0, v3(be) * E3 * b(Be / 2)];\n                var et = o4(Be), We = n4(E3 / ve - ve / E3) / 2, it = We * We, Ft = et / (De + et - 1), Ht = Ft * (2 / De - 1), tr = Ht * Ht, dr = tr + it, Sr = Ft - tr, Or = it + Ft;\n                return [v3(ve) * E3 * (We * Sr + G2(it * Sr * Sr - dr * (Ft * Ft - tr))) / dr, v3(be) * E3 * (Ht * Or - We * G2((it + 1) * dr - Or * Or)) / dr];\n              }\n              Uc.invert = function(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                if (n4(ve) < p3) return [0, S2 * _2(2 * i3(be / E3))];\n                var De = (ve /= E3) * ve, Be = (be /= E3) * be, et = De + Be, We = et * et, it = -n4(be) * (1 + et), Ft = it - 2 * Be + De, Ht = -2 * it + 1 + 2 * Be + We, tr = Be / Ht + (2 * Ft * Ft * Ft / (Ht * Ht * Ht) - 9 * it * Ft / (Ht * Ht)) / 27, dr = (it - Ft * Ft / (3 * Ht)) / Ht, Sr = 2 * G2(-dr / 3), Or = V2(3 * tr / (dr * Sr)) / 3;\n                return [E3 * (et - 1 + G2(1 + 2 * (De - Be) + We)) / (2 * ve), v3(be) * E3 * (-Sr * o4(Or + E3 / 3) - Ft / (3 * Ht))];\n              };\n              function xu() {\n                return t3.geoProjection(Uc).scale(79.4183);\n              }\n              function Ac(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                var De = n4(be / S2), Be = O3(De);\n                if (n4(ve) < p3 || n4(n4(be) - S2) < p3) return [0, v3(be) * E3 * b(Be / 2)];\n                var et = o4(Be), We = n4(E3 / ve - ve / E3) / 2, it = We * We, Ft = et * (G2(1 + it) - We * et) / (1 + it * De * De);\n                return [v3(ve) * E3 * Ft, v3(be) * E3 * G2(1 - Ft * (2 * We + Ft))];\n              }\n              Ac.invert = function(ve, be) {\n                if (!ve) return [0, S2 * _2(2 * i3(be / E3))];\n                var De = n4(ve / E3), Be = (1 - De * De - (be /= E3) * be) / (2 * De), et = Be * Be, We = G2(et + 1);\n                return [v3(ve) * E3 * (We - Be), v3(be) * S2 * _2(2 * a4(G2((1 - 2 * Be * De) * (Be + We) - De), G2(We + Be + De)))];\n              };\n              function Ua() {\n                return t3.geoProjection(Ac).scale(79.4183);\n              }\n              function oo(ve, be) {\n                if (n4(be) < p3) return [ve, 0];\n                var De = be / S2, Be = O3(De);\n                if (n4(ve) < p3 || n4(n4(be) - S2) < p3) return [0, E3 * b(Be / 2)];\n                var et = (E3 / ve - ve / E3) / 2, We = De / (1 + o4(Be));\n                return [E3 * (v3(ve) * G2(et * et + 1 - We * We) - et), E3 * We];\n              }\n              oo.invert = function(ve, be) {\n                if (!be) return [ve, 0];\n                var De = be / E3, Be = (E3 * E3 * (1 - De * De) - ve * ve) / (2 * E3 * ve);\n                return [ve ? E3 * (v3(ve) * G2(Be * Be + 1) - Be) : 0, S2 * _2(2 * i3(De))];\n              };\n              function Vc() {\n                return t3.geoProjection(oo).scale(79.4183);\n              }\n              function hc(ve, be) {\n                if (!be) return [ve, 0];\n                var De = n4(be);\n                if (!ve || De === S2) return [0, be];\n                var Be = De / S2, et = Be * Be, We = (8 * Be - et * (et + 2) - 5) / (2 * et * (Be - 1)), it = We * We, Ft = Be * We, Ht = et + it + 2 * Ft, tr = Be + 3 * We, dr = ve / S2, Sr = dr + 1 / dr, Or = v3(n4(ve) - S2) * G2(Sr * Sr - 4), Wr = Or * Or, ni = Ht * (et + it * Wr - 1) + (1 - et) * (et * (tr * tr + 4 * it) + 12 * Ft * it + 4 * it * it), Pi = (Or * (Ht + it - 1) + 2 * G2(ni)) / (4 * Ht + Wr);\n                return [v3(ve) * S2 * Pi, v3(be) * S2 * G2(1 + Or * n4(Pi) - Pi * Pi)];\n              }\n              hc.invert = function(ve, be) {\n                var De;\n                if (!ve || !be) return [ve, be];\n                be /= E3;\n                var Be = v3(ve) * ve / S2, et = (Be * Be - 1 + 4 * be * be) / n4(Be), We = et * et, it = 2 * be, Ft = 50;\n                do {\n                  var Ht = it * it, tr = (8 * it - Ht * (Ht + 2) - 5) / (2 * Ht * (it - 1)), dr = (3 * it - Ht * it - 10) / (2 * Ht * it), Sr = tr * tr, Or = it * tr, Wr = it + tr, ni = Wr * Wr, Pi = it + 3 * tr, cn = ni * (Ht + Sr * We - 1) + (1 - Ht) * (Ht * (Pi * Pi + 4 * Sr) + Sr * (12 * Or + 4 * Sr)), ln = -2 * Wr * (4 * Or * Sr + (1 - 4 * Ht + 3 * Ht * Ht) * (1 + dr) + Sr * (-6 + 14 * Ht - We + (-8 + 8 * Ht - 2 * We) * dr) + Or * (-8 + 12 * Ht + (-10 + 10 * Ht - We) * dr)), Cn = G2(cn), Kn = et * (ni + Sr - 1) + 2 * Cn - Be * (4 * ni + We), Ta = et * (2 * tr * dr + 2 * Wr * (1 + dr)) + ln / Cn - 8 * Wr * (et * (-1 + Sr + ni) + 2 * Cn) * (1 + dr) / (We + 4 * ni);\n                  it -= De = Kn / Ta;\n                } while (De > p3 && --Ft > 0);\n                return [v3(ve) * (G2(et * et + 4) + et) * E3 / 4, S2 * it];\n              };\n              function Ku() {\n                return t3.geoProjection(hc).scale(127.16);\n              }\n              function ue(ve, be, De, Be, et) {\n                function We(it, Ft) {\n                  var Ht = De * _2(Be * Ft), tr = G2(1 - Ht * Ht), dr = G2(2 / (1 + tr * o4(it *= et)));\n                  return [ve * tr * dr * _2(it), be * Ht * dr];\n                }\n                return We.invert = function(it, Ft) {\n                  var Ht = it / ve, tr = Ft / be, dr = G2(Ht * Ht + tr * tr), Sr = 2 * O3(dr / 2);\n                  return [a4(it * b(Sr), ve * dr) / et, dr && O3(Ft * _2(Sr) / (be * De * dr)) / Be];\n                }, We;\n              }\n              function w4(ve, be, De, Be) {\n                var et = E3 / 3;\n                ve = c5(ve, p3), be = c5(be, p3), ve = f4(ve, S2), be = f4(be, E3 - p3), De = c5(De, 0), De = f4(De, 100 - p3), Be = c5(Be, p3);\n                var We = De / 100 + 1, it = Be / 100, Ft = V2(We * o4(et)) / et, Ht = _2(ve) / _2(Ft * S2), tr = be / E3, dr = G2(it * _2(ve / 2) / _2(be / 2)), Sr = dr / G2(tr * Ht * Ft), Or = 1 / (dr * G2(tr * Ht * Ft));\n                return ue(Sr, Or, Ht, Ft, tr);\n              }\n              function B4() {\n                var ve = 65 * T3, be = 60 * T3, De = 20, Be = 200, et = t3.geoProjectionMutator(w4), We = et(ve, be, De, Be);\n                return We.poleline = function(it) {\n                  return arguments.length ? et(ve = +it * T3, be, De, Be) : ve * P3;\n                }, We.parallels = function(it) {\n                  return arguments.length ? et(ve, be = +it * T3, De, Be) : be * P3;\n                }, We.inflation = function(it) {\n                  return arguments.length ? et(ve, be, De = +it, Be) : De;\n                }, We.ratio = function(it) {\n                  return arguments.length ? et(ve, be, De, Be = +it) : Be;\n                }, We.scale(163.775);\n              }\n              function Q() {\n                return B4().poleline(65).parallels(60).inflation(0).ratio(200).scale(172.633);\n              }\n              var ee = 4 * E3 + 3 * G2(3), le = 2 * G2(2 * E3 * G2(3) / ee), qe = Jt(le * G2(3) / E3, le, ee / 6);\n              function Xe() {\n                return t3.geoProjection(qe).scale(176.84);\n              }\n              function ot(ve, be) {\n                return [ve * G2(1 - 3 * be * be / (E3 * E3)), be];\n              }\n              ot.invert = function(ve, be) {\n                return [ve / G2(1 - 3 * be * be / (E3 * E3)), be];\n              };\n              function Tt() {\n                return t3.geoProjection(ot).scale(152.63);\n              }\n              function Yt(ve, be) {\n                var De = o4(be), Be = o4(ve) * De, et = 1 - Be, We = o4(ve = a4(_2(ve) * De, -_2(be))), it = _2(ve);\n                return De = G2(1 - Be * Be), [it * De - We * et, -We * De - it * et];\n              }\n              Yt.invert = function(ve, be) {\n                var De = (ve * ve + be * be) / -2, Be = G2(-De * (2 + De)), et = be * De + ve * Be, We = ve * De - be * Be, it = G2(We * We + et * et);\n                return [a4(Be * et, it * (1 + De)), it ? -O3(Be * We / it) : 0];\n              };\n              function Kt() {\n                return t3.geoProjection(Yt).rotate([0, -90, 45]).scale(124.75).clipAngle(180 - 1e-3);\n              }\n              function xr(ve, be) {\n                var De = Ee(ve, be);\n                return [(De[0] + ve / S2) / 2, (De[1] + be) / 2];\n              }\n              xr.invert = function(ve, be) {\n                var De = ve, Be = be, et = 25;\n                do {\n                  var We = o4(Be), it = _2(Be), Ft = _2(2 * Be), Ht = it * it, tr = We * We, dr = _2(De), Sr = o4(De / 2), Or = _2(De / 2), Wr = Or * Or, ni = 1 - tr * Sr * Sr, Pi = ni ? V2(We * Sr) * G2(cn = 1 / ni) : cn = 0, cn, ln = 0.5 * (2 * Pi * We * Or + De / S2) - ve, Cn = 0.5 * (Pi * it + Be) - be, Kn = 0.5 * cn * (tr * Wr + Pi * We * Sr * Ht) + 0.5 / S2, Ta = cn * (dr * Ft / 4 - Pi * it * Or), fa = 0.125 * cn * (Ft * Or - Pi * it * tr * dr), $a = 0.5 * cn * (Ht * Sr + Pi * Wr * We) + 0.5, Co = Ta * fa - $a * Kn, Qa = (Cn * Ta - ln * $a) / Co, mo = (ln * fa - Cn * Kn) / Co;\n                  De -= Qa, Be -= mo;\n                } while ((n4(Qa) > p3 || n4(mo) > p3) && --et > 0);\n                return [De, Be];\n              };\n              function Ir() {\n                return t3.geoProjection(xr).scale(158.837);\n              }\n              e3.geoNaturalEarth = t3.geoNaturalEarth1, e3.geoNaturalEarthRaw = t3.geoNaturalEarth1Raw, e3.geoAiry = _e, e3.geoAiryRaw = oe, e3.geoAitoff = Ce, e3.geoAitoffRaw = Ee, e3.geoArmadillo = ie, e3.geoArmadilloRaw = me, e3.geoAugust = Le, e3.geoAugustRaw = Se, e3.geoBaker = ge, e3.geoBakerRaw = Pe, e3.geoBerghaus = ce, e3.geoBerghausRaw = Re, e3.geoBertin1953 = Gt, e3.geoBertin1953Raw = lt, e3.geoBoggs = Qt, e3.geoBoggsRaw = St, e3.geoBonne = er, e3.geoBonneRaw = mt, e3.geoBottomley = Tr, e3.geoBottomleyRaw = lr, e3.geoBromley = ti, e3.geoBromleyRaw = Lr, e3.geoChamberlin = tt, e3.geoChamberlinRaw = Ge, e3.geoChamberlinAfrica = je, e3.geoCollignon = Ie, e3.geoCollignonRaw = xt, e3.geoCraig = ke, e3.geoCraigRaw = xe, e3.geoCraster = ar, e3.geoCrasterRaw = ir, e3.geoCylindricalEqualArea = ii, e3.geoCylindricalEqualAreaRaw = vr, e3.geoCylindricalStereographic = $r, e3.geoCylindricalStereographicRaw = pi, e3.geoEckert1 = ji, e3.geoEckert1Raw = di, e3.geoEckert2 = wi, e3.geoEckert2Raw = In, e3.geoEckert3 = qn, e3.geoEckert3Raw = On, e3.geoEckert4 = ra, e3.geoEckert4Raw = Fn, e3.geoEckert5 = Ut, e3.geoEckert5Raw = la, e3.geoEckert6 = rr, e3.geoEckert6Raw = wt, e3.geoEisenlohr = Xr, e3.geoEisenlohrRaw = Er, e3.geoFahey = Oi, e3.geoFaheyRaw = Qr, e3.geoFoucaut = tn, e3.geoFoucautRaw = $i, e3.geoFoucautSinusoidal = yn, e3.geoFoucautSinusoidalRaw = fn, e3.geoGilbert = ua, e3.geoGingery = Wo, e3.geoGingeryRaw = ma, e3.geoGinzburg4 = Ha, e3.geoGinzburg4Raw = Wn, e3.geoGinzburg5 = jn, e3.geoGinzburg5Raw = vo, e3.geoGinzburg6 = kr, e3.geoGinzburg6Raw = Mt, e3.geoGinzburg8 = vi, e3.geoGinzburg8Raw = Jr, e3.geoGinzburg9 = An, e3.geoGinzburg9Raw = hn, e3.geoGringorten = Jn, e3.geoGringortenRaw = Li, e3.geoGuyou = Fs, e3.geoGuyouRaw = Lo, e3.geoHammer = pt, e3.geoHammerRaw = Ze, e3.geoHammerRetroazimuthal = zl, e3.geoHammerRetroazimuthalRaw = ll, e3.geoHealpix = Zl, e3.geoHealpixRaw = cl, e3.geoHill = nc, e3.geoHillRaw = Su, e3.geoHomolosine = xo, e3.geoHomolosineRaw = Ol, e3.geoHufnagel = Ns, e3.geoHufnagelRaw = Yl, e3.geoHyperelliptical = Oo, e3.geoHyperellipticalRaw = aa, e3.geoInterrupt = Do, e3.geoInterruptedBoggs = Uf, e3.geoInterruptedHomolosine = Zc, e3.geoInterruptedMollweide = Os, e3.geoInterruptedMollweideHemispheres = oc, e3.geoInterruptedSinuMollweide = sc, e3.geoInterruptedSinusoidal = Lf, e3.geoKavrayskiy7 = nf, e3.geoKavrayskiy7Raw = cs, e3.geoLagrange = Jl, e3.geoLagrangeRaw = Vf, e3.geoLarrivee = Fu, e3.geoLarriveeRaw = lc, e3.geoLaskowski = Hs, e3.geoLaskowskiRaw = Es, e3.geoLittrow = ps, e3.geoLittrowRaw = Go, e3.geoLoximuthal = xl, e3.geoLoximuthalRaw = uc, e3.geoMiller = qs, e3.geoMillerRaw = Gu, e3.geoModifiedStereographic = Bl, e3.geoModifiedStereographicRaw = ad, e3.geoModifiedStereographicAlaska = Hu, e3.geoModifiedStereographicGs48 = bl, e3.geoModifiedStereographicGs50 = Gf, e3.geoModifiedStereographicMiller = Ic, e3.geoModifiedStereographicLee = yf, e3.geoMollweide = wr, e3.geoMollweideRaw = sr, e3.geoMtFlatPolarParabolic = Yc, e3.geoMtFlatPolarParabolicRaw = _f, e3.geoMtFlatPolarQuartic = th, e3.geoMtFlatPolarQuarticRaw = eh, e3.geoMtFlatPolarSinusoidal = Hf, e3.geoMtFlatPolarSinusoidalRaw = ju, e3.geoNaturalEarth2 = of, e3.geoNaturalEarth2Raw = cc, e3.geoNellHammer = Kc, e3.geoNellHammerRaw = Nl, e3.geoInterruptedQuarticAuthalic = gs, e3.geoNicolosi = Gh, e3.geoNicolosiRaw = jf, e3.geoPatterson = hu, e3.geoPattersonRaw = bc, e3.geoPolyconic = nl, e3.geoPolyconicRaw = _u, e3.geoPolyhedral = xf, e3.geoPolyhedralButterfly = Cs, e3.geoPolyhedralCollignon = Wf, e3.geoPolyhedralWaterman = Us, e3.geoProject = Wl, e3.geoGringortenQuincuncial = At, e3.geoPeirceQuincuncial = Wt, e3.geoPierceQuincuncial = Wt, e3.geoQuantize = Cr, e3.geoQuincuncial = Bc, e3.geoRectangularPolyconic = Kr, e3.geoRectangularPolyconicRaw = Ar, e3.geoRobinson = dn, e3.geoRobinsonRaw = Xi, e3.geoSatellite = Yi, e3.geoSatelliteRaw = Nn, e3.geoSinuMollweide = Vu, e3.geoSinuMollweideRaw = _a, e3.geoSinusoidal = It, e3.geoSinusoidalRaw = _t, e3.geoStitch = Ls, e3.geoTimes = no, e3.geoTimesRaw = va, e3.geoTwoPointAzimuthal = Cu, e3.geoTwoPointAzimuthalRaw = rs, e3.geoTwoPointAzimuthalUsa = $l, e3.geoTwoPointEquidistant = pu, e3.geoTwoPointEquidistantRaw = Yu, e3.geoTwoPointEquidistantUsa = Nc, e3.geoVanDerGrinten = xu, e3.geoVanDerGrintenRaw = Uc, e3.geoVanDerGrinten2 = Ua, e3.geoVanDerGrinten2Raw = Ac, e3.geoVanDerGrinten3 = Vc, e3.geoVanDerGrinten3Raw = oo, e3.geoVanDerGrinten4 = Ku, e3.geoVanDerGrinten4Raw = hc, e3.geoWagner = B4, e3.geoWagner7 = Q, e3.geoWagnerRaw = w4, e3.geoWagner4 = Xe, e3.geoWagner4Raw = qe, e3.geoWagner6 = Tt, e3.geoWagner6Raw = ot, e3.geoWiechel = Kt, e3.geoWiechelRaw = Yt, e3.geoWinkel3 = Ir, e3.geoWinkel3Raw = xr, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var zDe = ye((xmr, FDe) => {\n            "use strict";\n            var id = Oa(), DZ = Dr(), Mzt = qa(), $A = Math.PI / 180, W2 = 180 / Math.PI, zZ = { cursor: "pointer" }, OZ = { cursor: "auto" };\n            function Ezt(e3, t3) {\n              var r4 = e3.projection, n4;\n              return t3._isScoped ? n4 = kzt : t3._isClipped ? n4 = Lzt : n4 = Czt, n4(e3, r4);\n            }\n            FDe.exports = Ezt;\n            function qZ(e3, t3) {\n              return id.behavior.zoom().translate(t3.translate()).scale(t3.scale());\n            }\n            function BZ(e3, t3, r4) {\n              var n4 = e3.id, i3 = e3.graphDiv, a4 = i3.layout, o4 = a4[n4], s3 = i3._fullLayout, l3 = s3[n4], u4 = {}, c5 = {};\n              function f4(h3, d3) {\n                u4[n4 + "." + h3] = DZ.nestedProperty(o4, h3).get(), Mzt.call("_storeDirectGUIEdit", a4, s3._preGUI, u4);\n                var v3 = DZ.nestedProperty(l3, h3);\n                v3.get() !== d3 && (v3.set(d3), DZ.nestedProperty(o4, h3).set(d3), c5[n4 + "." + h3] = d3);\n              }\n              r4(f4), f4("projection.scale", t3.scale() / e3.fitScale), f4("fitbounds", false), i3.emit("plotly_relayout", c5);\n            }\n            function kzt(e3, t3) {\n              var r4 = qZ(e3, t3);\n              function n4() {\n                id.select(this).style(zZ);\n              }\n              function i3() {\n                t3.scale(id.event.scale).translate(id.event.translate), e3.render(true);\n                var s3 = t3.invert(e3.midPt);\n                e3.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t3.scale() / e3.fitScale, "geo.center.lon": s3[0], "geo.center.lat": s3[1] });\n              }\n              function a4(s3) {\n                var l3 = t3.invert(e3.midPt);\n                s3("center.lon", l3[0]), s3("center.lat", l3[1]);\n              }\n              function o4() {\n                id.select(this).style(OZ), BZ(e3, t3, a4);\n              }\n              return r4.on("zoomstart", n4).on("zoom", i3).on("zoomend", o4), r4;\n            }\n            function Czt(e3, t3) {\n              var r4 = qZ(e3, t3), n4 = 2, i3, a4, o4, s3, l3, u4, c5, f4, h3;\n              function d3(E3) {\n                return t3.invert(E3);\n              }\n              function v3(E3) {\n                var S2 = d3(E3);\n                if (!S2) return true;\n                var L3 = t3(S2);\n                return Math.abs(L3[0] - E3[0]) > n4 || Math.abs(L3[1] - E3[1]) > n4;\n              }\n              function _2() {\n                id.select(this).style(zZ), i3 = id.mouse(this), a4 = t3.rotate(), o4 = t3.translate(), s3 = a4, l3 = d3(i3);\n              }\n              function b() {\n                if (u4 = id.mouse(this), v3(i3)) {\n                  r4.scale(t3.scale()), r4.translate(t3.translate());\n                  return;\n                }\n                t3.scale(id.event.scale), t3.translate([o4[0], id.event.translate[1]]), l3 ? d3(u4) && (f4 = d3(u4), c5 = [s3[0] + (f4[0] - l3[0]), a4[1], a4[2]], t3.rotate(c5), s3 = c5) : (i3 = u4, l3 = d3(i3)), h3 = true, e3.render(true);\n                var E3 = t3.rotate(), S2 = t3.invert(e3.midPt);\n                e3.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t3.scale() / e3.fitScale, "geo.center.lon": S2[0], "geo.center.lat": S2[1], "geo.projection.rotation.lon": -E3[0] });\n              }\n              function p3() {\n                id.select(this).style(OZ), h3 && BZ(e3, t3, k4);\n              }\n              function k4(E3) {\n                var S2 = t3.rotate(), L3 = t3.invert(e3.midPt);\n                E3("projection.rotation.lon", -S2[0]), E3("center.lon", L3[0]), E3("center.lat", L3[1]);\n              }\n              return r4.on("zoomstart", _2).on("zoom", b).on("zoomend", p3), r4;\n            }\n            function Lzt(e3, t3) {\n              var r4 = { r: t3.rotate(), k: t3.scale() }, n4 = qZ(e3, t3), i3 = qzt(n4, "zoomstart", "zoom", "zoomend"), a4 = 0, o4 = n4.on, s3;\n              n4.on("zoomstart", function() {\n                id.select(this).style(zZ);\n                var h3 = id.mouse(this), d3 = t3.rotate(), v3 = d3, _2 = t3.translate(), b = Pzt(d3);\n                s3 = IF(t3, h3), o4.call(n4, "zoom", function() {\n                  var p3 = id.mouse(this);\n                  if (t3.scale(r4.k = id.event.scale), !s3) h3 = p3, s3 = IF(t3, h3);\n                  else if (IF(t3, p3)) {\n                    t3.rotate(d3).translate(_2);\n                    var k4 = IF(t3, p3), E3 = Rzt(s3, k4), S2 = Fzt(Izt(b, E3)), L3 = r4.r = Dzt(S2, s3, v3);\n                    (!isFinite(L3[0]) || !isFinite(L3[1]) || !isFinite(L3[2])) && (L3 = v3), t3.rotate(L3), v3 = L3;\n                  }\n                  u4(i3.of(this, arguments));\n                }), l3(i3.of(this, arguments));\n              }).on("zoomend", function() {\n                id.select(this).style(OZ), o4.call(n4, "zoom", null), c5(i3.of(this, arguments)), BZ(e3, t3, f4);\n              }).on("zoom.redraw", function() {\n                e3.render(true);\n                var h3 = t3.rotate();\n                e3.graphDiv.emit("plotly_relayouting", { "geo.projection.scale": t3.scale() / e3.fitScale, "geo.projection.rotation.lon": -h3[0], "geo.projection.rotation.lat": -h3[1] });\n              });\n              function l3(h3) {\n                a4++ || h3({ type: "zoomstart" });\n              }\n              function u4(h3) {\n                h3({ type: "zoom" });\n              }\n              function c5(h3) {\n                --a4 || h3({ type: "zoomend" });\n              }\n              function f4(h3) {\n                var d3 = t3.rotate();\n                h3("projection.rotation.lon", -d3[0]), h3("projection.rotation.lat", -d3[1]);\n              }\n              return id.rebind(n4, i3, "on");\n            }\n            function IF(e3, t3) {\n              var r4 = e3.invert(t3);\n              return r4 && isFinite(r4[0]) && isFinite(r4[1]) && zzt(r4);\n            }\n            function Pzt(e3) {\n              var t3 = 0.5 * e3[0] * $A, r4 = 0.5 * e3[1] * $A, n4 = 0.5 * e3[2] * $A, i3 = Math.sin(t3), a4 = Math.cos(t3), o4 = Math.sin(r4), s3 = Math.cos(r4), l3 = Math.sin(n4), u4 = Math.cos(n4);\n              return [a4 * s3 * u4 + i3 * o4 * l3, i3 * s3 * u4 - a4 * o4 * l3, a4 * o4 * u4 + i3 * s3 * l3, a4 * s3 * l3 - i3 * o4 * u4];\n            }\n            function Izt(e3, t3) {\n              var r4 = e3[0], n4 = e3[1], i3 = e3[2], a4 = e3[3], o4 = t3[0], s3 = t3[1], l3 = t3[2], u4 = t3[3];\n              return [r4 * o4 - n4 * s3 - i3 * l3 - a4 * u4, r4 * s3 + n4 * o4 + i3 * u4 - a4 * l3, r4 * l3 - n4 * u4 + i3 * o4 + a4 * s3, r4 * u4 + n4 * l3 - i3 * s3 + a4 * o4];\n            }\n            function Rzt(e3, t3) {\n              if (!(!e3 || !t3)) {\n                var r4 = Ozt(e3, t3), n4 = Math.sqrt(DDe(r4, r4)), i3 = 0.5 * Math.acos(Math.max(-1, Math.min(1, DDe(e3, t3)))), a4 = Math.sin(i3) / n4;\n                return n4 && [Math.cos(i3), r4[2] * a4, -r4[1] * a4, r4[0] * a4];\n              }\n            }\n            function Dzt(e3, t3, r4) {\n              var n4 = FZ(t3, 2, e3[0]);\n              n4 = FZ(n4, 1, e3[1]), n4 = FZ(n4, 0, e3[2] - r4[2]);\n              var i3 = t3[0], a4 = t3[1], o4 = t3[2], s3 = n4[0], l3 = n4[1], u4 = n4[2], c5 = Math.atan2(a4, i3) * W2, f4 = Math.sqrt(i3 * i3 + a4 * a4), h3, d3;\n              Math.abs(l3) > f4 ? (d3 = (l3 > 0 ? 90 : -90) - c5, h3 = 0) : (d3 = Math.asin(l3 / f4) * W2 - c5, h3 = Math.sqrt(f4 * f4 - l3 * l3));\n              var v3 = 180 - d3 - 2 * c5, _2 = (Math.atan2(u4, s3) - Math.atan2(o4, h3)) * W2, b = (Math.atan2(u4, s3) - Math.atan2(o4, -h3)) * W2, p3 = IDe(r4[0], r4[1], d3, _2), k4 = IDe(r4[0], r4[1], v3, b);\n              return p3 <= k4 ? [d3, _2, r4[2]] : [v3, b, r4[2]];\n            }\n            function IDe(e3, t3, r4, n4) {\n              var i3 = RDe(r4 - e3), a4 = RDe(n4 - t3);\n              return Math.sqrt(i3 * i3 + a4 * a4);\n            }\n            function RDe(e3) {\n              return (e3 % 360 + 540) % 360 - 180;\n            }\n            function FZ(e3, t3, r4) {\n              var n4 = r4 * $A, i3 = e3.slice(), a4 = t3 === 0 ? 1 : 0, o4 = t3 === 2 ? 1 : 2, s3 = Math.cos(n4), l3 = Math.sin(n4);\n              return i3[a4] = e3[a4] * s3 - e3[o4] * l3, i3[o4] = e3[o4] * s3 + e3[a4] * l3, i3;\n            }\n            function Fzt(e3) {\n              return [Math.atan2(2 * (e3[0] * e3[1] + e3[2] * e3[3]), 1 - 2 * (e3[1] * e3[1] + e3[2] * e3[2])) * W2, Math.asin(Math.max(-1, Math.min(1, 2 * (e3[0] * e3[2] - e3[3] * e3[1])))) * W2, Math.atan2(2 * (e3[0] * e3[3] + e3[1] * e3[2]), 1 - 2 * (e3[2] * e3[2] + e3[3] * e3[3])) * W2];\n            }\n            function zzt(e3) {\n              var t3 = e3[0] * $A, r4 = e3[1] * $A, n4 = Math.cos(r4);\n              return [n4 * Math.cos(t3), n4 * Math.sin(t3), Math.sin(r4)];\n            }\n            function DDe(e3, t3) {\n              for (var r4 = 0, n4 = 0, i3 = e3.length; n4 < i3; ++n4) r4 += e3[n4] * t3[n4];\n              return r4;\n            }\n            function Ozt(e3, t3) {\n              return [e3[1] * t3[2] - e3[2] * t3[1], e3[2] * t3[0] - e3[0] * t3[2], e3[0] * t3[1] - e3[1] * t3[0]];\n            }\n            function qzt(e3) {\n              for (var t3 = 0, r4 = arguments.length, n4 = []; ++t3 < r4; ) n4.push(arguments[t3]);\n              var i3 = id.dispatch.apply(null, n4);\n              return i3.of = function(a4, o4) {\n                return function(s3) {\n                  var l3;\n                  try {\n                    l3 = s3.sourceEvent = id.event, s3.target = e3, id.event = s3, i3[s3.type].apply(a4, o4);\n                  } finally {\n                    id.event = l3;\n                  }\n                };\n              }, i3;\n            }\n          });\n          var GDe = ye((bmr, VDe) => {\n            "use strict";\n            var t1 = Oa(), VZ = RZ(), Bzt = VZ.geoPath, Nzt = VZ.geoDistance, Uzt = PDe(), Vzt = qa(), ok = Dr(), Gzt = ok.strTranslate, RF = ka(), ak = So(), ODe = vf(), Hzt = Mc(), UZ = ho(), qDe = Ag().getAutoRange, NZ = yv(), jzt = Of().prepSelect, Wzt = Of().clearOutline, Xzt = Of().selectOnClick, Zzt = zDe(), fp = tk(), Yzt = ix(), NDe = mF(), Kzt = yZ().feature;\n            function UDe(e3) {\n              this.id = e3.id, this.graphDiv = e3.graphDiv, this.container = e3.container, this.topojsonURL = e3.topojsonURL, this.isStatic = e3.staticPlot, this.topojsonName = null, this.topojson = null, this.projection = null, this.scope = null, this.viewInitial = null, this.fitScale = null, this.bounds = null, this.midPt = null, this.hasChoropleth = false, this.traceHash = {}, this.layers = {}, this.basePaths = {}, this.dataPaths = {}, this.dataPoints = {}, this.clipDef = null, this.clipRect = null, this.bgRect = null, this.makeFramework();\n            }\n            var Qg = UDe.prototype;\n            VDe.exports = function(t3) {\n              return new UDe(t3);\n            };\n            Qg.plot = function(e3, t3, r4, n4) {\n              var i3 = this;\n              if (n4) return i3.update(e3, t3, true);\n              i3._geoCalcData = e3, i3._fullLayout = t3;\n              var a4 = t3[this.id], o4 = [], s3 = false;\n              for (var l3 in fp.layerNameToAdjective) if (l3 !== "frame" && a4["show" + l3]) {\n                s3 = true;\n                break;\n              }\n              for (var u4 = false, c5 = 0; c5 < e3.length; c5++) {\n                var f4 = e3[0][0].trace;\n                f4._geo = i3, f4.locationmode && (s3 = true);\n                var h3 = f4.marker;\n                if (h3) {\n                  var d3 = h3.angle, v3 = h3.angleref;\n                  (d3 || v3 === "north" || v3 === "previous") && (u4 = true);\n                }\n              }\n              if (this._hasMarkerAngles = u4, s3) {\n                var _2 = NDe.getTopojsonName(a4);\n                (i3.topojson === null || _2 !== i3.topojsonName) && (i3.topojsonName = _2, PlotlyGeoAssets.topojson[i3.topojsonName] === void 0 && o4.push(i3.fetchTopojson()));\n              }\n              o4 = o4.concat(Yzt.fetchTraceGeoData(e3)), r4.push(new Promise(function(b, p3) {\n                Promise.all(o4).then(function() {\n                  i3.topojson = PlotlyGeoAssets.topojson[i3.topojsonName], i3.update(e3, t3), b();\n                }).catch(p3);\n              }));\n            };\n            Qg.fetchTopojson = function() {\n              var e3 = this, t3 = NDe.getTopojsonPath(e3.topojsonURL, e3.topojsonName);\n              return new Promise(function(r4, n4) {\n                t1.json(t3, function(i3, a4) {\n                  if (i3) return i3.status === 404 ? n4(new Error(["plotly.js could not find topojson file at", t3 + ".", "Make sure the *topojsonURL* plot config option", "is set properly."].join(" "))) : n4(new Error(["unexpected error while fetching topojson file at", t3].join(" ")));\n                  PlotlyGeoAssets.topojson[e3.topojsonName] = a4, r4();\n                });\n              });\n            };\n            Qg.update = function(e3, t3, r4) {\n              var n4 = t3[this.id];\n              this.hasChoropleth = false;\n              for (var i3 = 0; i3 < e3.length; i3++) {\n                var a4 = e3[i3], o4 = a4[0].trace;\n                o4.type === "choropleth" && (this.hasChoropleth = true), o4.visible === true && o4._length > 0 && o4._module.calcGeoJSON(a4, t3);\n              }\n              if (!r4) {\n                var s3 = this.updateProjection(e3, t3);\n                if (s3) return;\n                (!this.viewInitial || this.scope !== n4.scope) && this.saveViewInitial(n4);\n              }\n              this.scope = n4.scope, this.updateBaseLayers(t3, n4), this.updateDims(t3, n4), this.updateFx(t3, n4), Hzt.generalUpdatePerTraceModule(this.graphDiv, this, e3, n4);\n              var l3 = this.layers.frontplot.select(".scatterlayer");\n              this.dataPoints.point = l3.selectAll(".point"), this.dataPoints.text = l3.selectAll("text"), this.dataPaths.line = l3.selectAll(".js-line");\n              var u4 = this.layers.backplot.select(".choroplethlayer");\n              this.dataPaths.choropleth = u4.selectAll("path"), this._render();\n            };\n            Qg.updateProjection = function(e3, t3) {\n              var r4 = this.graphDiv, n4 = t3[this.id], i3 = t3._size, a4 = n4.domain, o4 = n4.projection, s3 = n4.lonaxis, l3 = n4.lataxis, u4 = s3._ax, c5 = l3._ax, f4 = this.projection = Jzt(n4), h3 = [[i3.l + i3.w * a4.x[0], i3.t + i3.h * (1 - a4.y[1])], [i3.l + i3.w * a4.x[1], i3.t + i3.h * (1 - a4.y[0])]], d3 = n4.center || {}, v3 = o4.rotation || {}, _2 = s3.range || [], b = l3.range || [];\n              if (n4.fitbounds) {\n                u4._length = h3[1][0] - h3[0][0], c5._length = h3[1][1] - h3[0][1], u4.range = qDe(r4, u4), c5.range = qDe(r4, c5);\n                var p3 = (u4.range[0] + u4.range[1]) / 2, k4 = (c5.range[0] + c5.range[1]) / 2;\n                if (n4._isScoped) d3 = { lon: p3, lat: k4 };\n                else if (n4._isClipped) {\n                  d3 = { lon: p3, lat: k4 }, v3 = { lon: p3, lat: k4, roll: v3.roll };\n                  var E3 = o4.type, S2 = fp.lonaxisSpan[E3] / 2 || 180, L3 = fp.lataxisSpan[E3] / 2 || 90;\n                  _2 = [p3 - S2, p3 + S2], b = [k4 - L3, k4 + L3];\n                } else d3 = { lon: p3, lat: k4 }, v3 = { lon: p3, lat: v3.lat, roll: v3.roll };\n              }\n              f4.center([d3.lon - v3.lon, d3.lat - v3.lat]).rotate([-v3.lon, -v3.lat, v3.roll]).parallels(o4.parallels);\n              var x2 = BDe(_2, b);\n              f4.fitExtent(h3, x2);\n              var C3 = this.bounds = f4.getBounds(x2), M4 = this.fitScale = f4.scale(), g3 = f4.translate();\n              if (n4.fitbounds) {\n                var P3 = f4.getBounds(BDe(u4.range, c5.range)), T3 = Math.min((C3[1][0] - C3[0][0]) / (P3[1][0] - P3[0][0]), (C3[1][1] - C3[0][1]) / (P3[1][1] - P3[0][1]));\n                isFinite(T3) ? f4.scale(T3 * M4) : ok.warn("Something went wrong during" + this.id + "fitbounds computations.");\n              } else f4.scale(o4.scale * M4);\n              var z3 = this.midPt = [(C3[0][0] + C3[1][0]) / 2, (C3[0][1] + C3[1][1]) / 2];\n              if (f4.translate([g3[0] + (z3[0] - g3[0]), g3[1] + (z3[1] - g3[1])]).clipExtent(C3), n4._isAlbersUsa) {\n                var O3 = f4([d3.lon, d3.lat]), V2 = f4.translate();\n                f4.translate([V2[0] - (O3[0] - V2[0]), V2[1] - (O3[1] - V2[1])]);\n              }\n            };\n            Qg.updateBaseLayers = function(e3, t3) {\n              var r4 = this, n4 = r4.topojson, i3 = r4.layers, a4 = r4.basePaths;\n              function o4(h3) {\n                return h3 === "lonaxis" || h3 === "lataxis";\n              }\n              function s3(h3) {\n                return !!fp.lineLayers[h3];\n              }\n              function l3(h3) {\n                return !!fp.fillLayers[h3];\n              }\n              var u4 = this.hasChoropleth ? fp.layersForChoropleth : fp.layers, c5 = u4.filter(function(h3) {\n                return s3(h3) || l3(h3) ? t3["show" + h3] : o4(h3) ? t3[h3].showgrid : true;\n              }), f4 = r4.framework.selectAll(".layer").data(c5, String);\n              f4.exit().each(function(h3) {\n                delete i3[h3], delete a4[h3], t1.select(this).remove();\n              }), f4.enter().append("g").attr("class", function(h3) {\n                return "layer " + h3;\n              }).each(function(h3) {\n                var d3 = i3[h3] = t1.select(this);\n                h3 === "bg" ? r4.bgRect = d3.append("rect").style("pointer-events", "all") : o4(h3) ? a4[h3] = d3.append("path").style("fill", "none") : h3 === "backplot" ? d3.append("g").classed("choroplethlayer", true) : h3 === "frontplot" ? d3.append("g").classed("scatterlayer", true) : s3(h3) ? a4[h3] = d3.append("path").style("fill", "none").style("stroke-miterlimit", 2) : l3(h3) && (a4[h3] = d3.append("path").style("stroke", "none"));\n              }), f4.order(), f4.each(function(h3) {\n                var d3 = a4[h3], v3 = fp.layerNameToAdjective[h3];\n                h3 === "frame" ? d3.datum(fp.sphereSVG) : s3(h3) || l3(h3) ? d3.datum(Kzt(n4, n4.objects[h3])) : o4(h3) && d3.datum($zt(h3, t3, e3)).call(RF.stroke, t3[h3].gridcolor).call(ak.dashLine, t3[h3].griddash, t3[h3].gridwidth), s3(h3) ? d3.call(RF.stroke, t3[v3 + "color"]).call(ak.dashLine, "", t3[v3 + "width"]) : l3(h3) && d3.call(RF.fill, t3[v3 + "color"]);\n              });\n            };\n            Qg.updateDims = function(e3, t3) {\n              var r4 = this.bounds, n4 = (t3.framewidth || 0) / 2, i3 = r4[0][0] - n4, a4 = r4[0][1] - n4, o4 = r4[1][0] - i3 + n4, s3 = r4[1][1] - a4 + n4;\n              ak.setRect(this.clipRect, i3, a4, o4, s3), this.bgRect.call(ak.setRect, i3, a4, o4, s3).call(RF.fill, t3.bgcolor), this.xaxis._offset = i3, this.xaxis._length = o4, this.yaxis._offset = a4, this.yaxis._length = s3;\n            };\n            Qg.updateFx = function(e3, t3) {\n              var r4 = this, n4 = r4.graphDiv, i3 = r4.bgRect, a4 = e3.dragmode, o4 = e3.clickmode;\n              if (r4.isStatic) return;\n              function s3() {\n                var f4 = r4.viewInitial, h3 = {};\n                for (var d3 in f4) h3[r4.id + "." + d3] = f4[d3];\n                Vzt.call("_guiRelayout", n4, h3), n4.emit("plotly_doubleclick", null);\n              }\n              function l3(f4) {\n                return r4.projection.invert([f4[0] + r4.xaxis._offset, f4[1] + r4.yaxis._offset]);\n              }\n              var u4 = function(f4, h3) {\n                if (h3.isRect) {\n                  var d3 = f4.range = {};\n                  d3[r4.id] = [l3([h3.xmin, h3.ymin]), l3([h3.xmax, h3.ymax])];\n                } else {\n                  var v3 = f4.lassoPoints = {};\n                  v3[r4.id] = h3.map(l3);\n                }\n              }, c5 = { element: r4.bgRect.node(), gd: n4, plotinfo: { id: r4.id, xaxis: r4.xaxis, yaxis: r4.yaxis, fillRangeItems: u4 }, xaxes: [r4.xaxis], yaxes: [r4.yaxis], subplot: r4.id, clickFn: function(f4) {\n                f4 === 2 && Wzt(n4);\n              } };\n              a4 === "pan" ? (i3.node().onmousedown = null, i3.call(Zzt(r4, t3)), i3.on("dblclick.zoom", s3), n4._context._scrollZoom.geo || i3.on("wheel.zoom", null)) : (a4 === "select" || a4 === "lasso") && (i3.on(".zoom", null), c5.prepFn = function(f4, h3, d3) {\n                jzt(f4, h3, d3, c5, a4);\n              }, NZ.init(c5)), i3.on("mousemove", function() {\n                var f4 = r4.projection.invert(ok.getPositionFromD3Event());\n                if (!f4) return NZ.unhover(n4, t1.event);\n                r4.xaxis.p2c = function() {\n                  return f4[0];\n                }, r4.yaxis.p2c = function() {\n                  return f4[1];\n                }, ODe.hover(n4, t1.event, r4.id);\n              }), i3.on("mouseout", function() {\n                n4._dragging || NZ.unhover(n4, t1.event);\n              }), i3.on("click", function() {\n                a4 !== "select" && a4 !== "lasso" && (o4.indexOf("select") > -1 && Xzt(t1.event, n4, [r4.xaxis], [r4.yaxis], r4.id, c5), o4.indexOf("event") > -1 && ODe.click(n4, t1.event));\n              });\n            };\n            Qg.makeFramework = function() {\n              var e3 = this, t3 = e3.graphDiv, r4 = t3._fullLayout, n4 = "clip" + r4._uid + e3.id;\n              e3.clipDef = r4._clips.append("clipPath").attr("id", n4), e3.clipRect = e3.clipDef.append("rect"), e3.framework = t1.select(e3.container).append("g").attr("class", "geo " + e3.id).call(ak.setClipUrl, n4, t3), e3.project = function(i3) {\n                var a4 = e3.projection(i3);\n                return a4 ? [a4[0] - e3.xaxis._offset, a4[1] - e3.yaxis._offset] : [null, null];\n              }, e3.xaxis = { _id: "x", c2p: function(i3) {\n                return e3.project(i3)[0];\n              } }, e3.yaxis = { _id: "y", c2p: function(i3) {\n                return e3.project(i3)[1];\n              } }, e3.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, UZ.setConvert(e3.mockAxis, r4);\n            };\n            Qg.saveViewInitial = function(e3) {\n              var t3 = e3.center || {}, r4 = e3.projection, n4 = r4.rotation || {};\n              this.viewInitial = { fitbounds: e3.fitbounds, "projection.scale": r4.scale };\n              var i3;\n              e3._isScoped ? i3 = { "center.lon": t3.lon, "center.lat": t3.lat } : e3._isClipped ? i3 = { "projection.rotation.lon": n4.lon, "projection.rotation.lat": n4.lat } : i3 = { "center.lon": t3.lon, "center.lat": t3.lat, "projection.rotation.lon": n4.lon }, ok.extendFlat(this.viewInitial, i3);\n            };\n            Qg.render = function(e3) {\n              this._hasMarkerAngles && e3 ? this.plot(this._geoCalcData, this._fullLayout, [], true) : this._render();\n            };\n            Qg._render = function() {\n              var e3 = this.projection, t3 = e3.getPath(), r4;\n              function n4(a4) {\n                var o4 = e3(a4.lonlat);\n                return o4 ? Gzt(o4[0], o4[1]) : null;\n              }\n              function i3(a4) {\n                return e3.isLonLatOverEdges(a4.lonlat) ? "none" : null;\n              }\n              for (r4 in this.basePaths) this.basePaths[r4].attr("d", t3);\n              for (r4 in this.dataPaths) this.dataPaths[r4].attr("d", function(a4) {\n                return t3(a4.geojson);\n              });\n              for (r4 in this.dataPoints) this.dataPoints[r4].attr("display", i3).attr("transform", n4);\n            };\n            function Jzt(e3) {\n              var t3 = e3.projection, r4 = t3.type, n4 = fp.projNames[r4];\n              n4 = "geo" + ok.titleCase(n4);\n              for (var i3 = VZ[n4] || Uzt[n4], a4 = i3(), o4 = e3._isSatellite ? Math.acos(1 / t3.distance) * 180 / Math.PI : e3._isClipped ? fp.lonaxisSpan[r4] / 2 : null, s3 = ["center", "rotate", "parallels", "clipExtent"], l3 = function(f4) {\n                return f4 ? a4 : [];\n              }, u4 = 0; u4 < s3.length; u4++) {\n                var c5 = s3[u4];\n                typeof a4[c5] != "function" && (a4[c5] = l3);\n              }\n              return a4.isLonLatOverEdges = function(f4) {\n                if (a4(f4) === null) return true;\n                if (o4) {\n                  var h3 = a4.rotate(), d3 = Nzt(f4, [-h3[0], -h3[1]]), v3 = o4 * Math.PI / 180;\n                  return d3 > v3;\n                } else return false;\n              }, a4.getPath = function() {\n                return Bzt().projection(a4);\n              }, a4.getBounds = function(f4) {\n                return a4.getPath().bounds(f4);\n              }, a4.precision(fp.precision), e3._isSatellite && a4.tilt(t3.tilt).distance(t3.distance), o4 && a4.clipAngle(o4 - fp.clipPad), a4;\n            }\n            function $zt(e3, t3, r4) {\n              var n4 = 1e-6, i3 = 2.5, a4 = t3[e3], o4 = fp.scopeDefaults[t3.scope], s3, l3, u4;\n              e3 === "lonaxis" ? (s3 = o4.lonaxisRange, l3 = o4.lataxisRange, u4 = function(k4, E3) {\n                return [k4, E3];\n              }) : e3 === "lataxis" && (s3 = o4.lataxisRange, l3 = o4.lonaxisRange, u4 = function(k4, E3) {\n                return [E3, k4];\n              });\n              var c5 = { type: "linear", range: [s3[0], s3[1] - n4], tick0: a4.tick0, dtick: a4.dtick };\n              UZ.setConvert(c5, r4);\n              var f4 = UZ.calcTicks(c5);\n              !t3.isScoped && e3 === "lonaxis" && f4.pop();\n              for (var h3 = f4.length, d3 = new Array(h3), v3 = 0; v3 < h3; v3++) for (var _2 = f4[v3].x, b = d3[v3] = [], p3 = l3[0]; p3 < l3[1] + i3; p3 += i3) b.push(u4(_2, p3));\n              return { type: "MultiLineString", coordinates: d3 };\n            }\n            function BDe(e3, t3) {\n              var r4 = fp.clipPad, n4 = e3[0] + r4, i3 = e3[1] - r4, a4 = t3[0] + r4, o4 = t3[1] - r4;\n              n4 > 0 && i3 < 0 && (i3 += 360);\n              var s3 = (i3 - n4) / 4;\n              return { type: "Polygon", coordinates: [[[n4, a4], [n4, o4], [n4 + s3, o4], [n4 + 2 * s3, o4], [n4 + 3 * s3, o4], [i3, o4], [i3, a4], [i3 - s3, a4], [i3 - 2 * s3, a4], [i3 - 3 * s3, a4], [n4, a4]]] };\n            }\n          });\n          var GZ = ye((wmr, WDe) => {\n            "use strict";\n            var e5 = Lh(), Qzt = Cc().attributes, e7t = Pd().dash, QA = tk(), t7t = mc().overrideAll, HDe = Z1(), jDe = { range: { valType: "info_array", items: [{ valType: "number" }, { valType: "number" }] }, showgrid: { valType: "boolean", dflt: false }, tick0: { valType: "number", dflt: 0 }, dtick: { valType: "number" }, gridcolor: { valType: "color", dflt: e5.lightLine }, gridwidth: { valType: "number", min: 0, dflt: 1 }, griddash: e7t }, r7t = WDe.exports = t7t({ domain: Qzt({ name: "geo" }, {}), fitbounds: { valType: "enumerated", values: [false, "locations", "geojson"], dflt: false, editType: "plot" }, resolution: { valType: "enumerated", values: [110, 50], dflt: 110, coerceNumber: true }, scope: { valType: "enumerated", values: HDe(QA.scopeDefaults), dflt: "world" }, projection: { type: { valType: "enumerated", values: HDe(QA.projNames) }, rotation: { lon: { valType: "number" }, lat: { valType: "number" }, roll: { valType: "number" } }, tilt: { valType: "number", dflt: 0 }, distance: { valType: "number", min: 1.001, dflt: 2 }, parallels: { valType: "info_array", items: [{ valType: "number" }, { valType: "number" }] }, scale: { valType: "number", min: 0, dflt: 1 } }, center: { lon: { valType: "number" }, lat: { valType: "number" } }, visible: { valType: "boolean", dflt: true }, showcoastlines: { valType: "boolean" }, coastlinecolor: { valType: "color", dflt: e5.defaultLine }, coastlinewidth: { valType: "number", min: 0, dflt: 1 }, showland: { valType: "boolean", dflt: false }, landcolor: { valType: "color", dflt: QA.landColor }, showocean: { valType: "boolean", dflt: false }, oceancolor: { valType: "color", dflt: QA.waterColor }, showlakes: { valType: "boolean", dflt: false }, lakecolor: { valType: "color", dflt: QA.waterColor }, showrivers: { valType: "boolean", dflt: false }, rivercolor: { valType: "color", dflt: QA.waterColor }, riverwidth: { valType: "number", min: 0, dflt: 1 }, showcountries: { valType: "boolean" }, countrycolor: { valType: "color", dflt: e5.defaultLine }, countrywidth: { valType: "number", min: 0, dflt: 1 }, showsubunits: { valType: "boolean" }, subunitcolor: { valType: "color", dflt: e5.defaultLine }, subunitwidth: { valType: "number", min: 0, dflt: 1 }, showframe: { valType: "boolean" }, framecolor: { valType: "color", dflt: e5.defaultLine }, framewidth: { valType: "number", min: 0, dflt: 1 }, bgcolor: { valType: "color", dflt: e5.background }, lonaxis: jDe, lataxis: jDe }, "plot", "from-root");\n            r7t.uirevision = { valType: "any", editType: "none" };\n          });\n          var YDe = ye((Tmr, ZDe) => {\n            "use strict";\n            var DF = Dr(), i7t = k_(), n7t = Id().getSubplotData, FF = tk(), a7t = GZ(), XDe = FF.axesNames;\n            ZDe.exports = function(t3, r4, n4) {\n              i7t(t3, r4, n4, { type: "geo", attributes: a7t, handleDefaults: o7t, fullData: n4, partition: "y" });\n            };\n            function o7t(e3, t3, r4, n4) {\n              var i3 = n7t(n4.fullData, "geo", n4.id), a4 = i3.map(function(oe) {\n                return oe.index;\n              }), o4 = r4("resolution"), s3 = r4("scope"), l3 = FF.scopeDefaults[s3], u4 = r4("projection.type", l3.projType), c5 = t3._isAlbersUsa = u4 === "albers usa";\n              c5 && (s3 = t3.scope = "usa");\n              var f4 = t3._isScoped = s3 !== "world", h3 = t3._isSatellite = u4 === "satellite", d3 = t3._isConic = u4.indexOf("conic") !== -1 || u4 === "albers", v3 = t3._isClipped = !!FF.lonaxisSpan[u4];\n              if (e3.visible === false) {\n                var _2 = DF.extendDeep({}, t3._template);\n                _2.showcoastlines = false, _2.showcountries = false, _2.showframe = false, _2.showlakes = false, _2.showland = false, _2.showocean = false, _2.showrivers = false, _2.showsubunits = false, _2.lonaxis && (_2.lonaxis.showgrid = false), _2.lataxis && (_2.lataxis.showgrid = false), t3._template = _2;\n              }\n              for (var b = r4("visible"), p3, k4 = 0; k4 < XDe.length; k4++) {\n                var E3 = XDe[k4], S2 = [30, 10][k4], L3;\n                if (f4) L3 = l3[E3 + "Range"];\n                else {\n                  var x2 = FF[E3 + "Span"], C3 = (x2[u4] || x2["*"]) / 2, M4 = r4("projection.rotation." + E3.slice(0, 3), l3.projRotate[k4]);\n                  L3 = [M4 - C3, M4 + C3];\n                }\n                var g3 = r4(E3 + ".range", L3);\n                r4(E3 + ".tick0"), r4(E3 + ".dtick", S2), p3 = r4(E3 + ".showgrid", b ? void 0 : false), p3 && (r4(E3 + ".gridcolor"), r4(E3 + ".gridwidth"), r4(E3 + ".griddash")), t3[E3]._ax = { type: "linear", _id: E3.slice(0, 3), _traceIndices: a4, setScale: DF.identity, c2l: DF.identity, r2l: DF.identity, autorange: true, range: g3.slice(), _m: 1, _input: {} };\n              }\n              var P3 = t3.lonaxis.range, T3 = t3.lataxis.range, z3 = P3[0], O3 = P3[1];\n              z3 > 0 && O3 < 0 && (O3 += 360);\n              var V2 = (z3 + O3) / 2, G2;\n              if (!c5) {\n                var Z = f4 ? l3.projRotate : [V2, 0, 0];\n                G2 = r4("projection.rotation.lon", Z[0]), r4("projection.rotation.lat", Z[1]), r4("projection.rotation.roll", Z[2]), p3 = r4("showcoastlines", !f4 && b), p3 && (r4("coastlinecolor"), r4("coastlinewidth")), p3 = r4("showocean", b ? void 0 : false), p3 && r4("oceancolor");\n              }\n              var j3, N2;\n              if (c5 ? (j3 = -96.6, N2 = 38.7) : (j3 = f4 ? V2 : G2, N2 = (T3[0] + T3[1]) / 2), r4("center.lon", j3), r4("center.lat", N2), h3 && (r4("projection.tilt"), r4("projection.distance")), d3) {\n                var H = l3.projParallels || [0, 60];\n                r4("projection.parallels", H);\n              }\n              r4("projection.scale"), p3 = r4("showland", b ? void 0 : false), p3 && r4("landcolor"), p3 = r4("showlakes", b ? void 0 : false), p3 && r4("lakecolor"), p3 = r4("showrivers", b ? void 0 : false), p3 && (r4("rivercolor"), r4("riverwidth")), p3 = r4("showcountries", f4 && s3 !== "usa" && b), p3 && (r4("countrycolor"), r4("countrywidth")), (s3 === "usa" || s3 === "north america" && o4 === 50) && (r4("showsubunits", b), r4("subunitcolor"), r4("subunitwidth")), f4 || (p3 = r4("showframe", b), p3 && (r4("framecolor"), r4("framewidth"))), r4("bgcolor");\n              var te = r4("fitbounds");\n              te && (delete t3.projection.scale, f4 ? (delete t3.center.lon, delete t3.center.lat) : v3 ? (delete t3.center.lon, delete t3.center.lat, delete t3.projection.rotation.lon, delete t3.projection.rotation.lat, delete t3.lonaxis.range, delete t3.lataxis.range) : (delete t3.center.lon, delete t3.center.lat, delete t3.projection.rotation.lon));\n            }\n          });\n          var HZ = ye((Amr, $De) => {\n            "use strict";\n            var s7t = Id().getSubplotCalcData, l7t = Dr().counterRegex, u7t = GDe(), Xm = "geo", KDe = l7t(Xm), JDe = {};\n            JDe[Xm] = { valType: "subplotid", dflt: Xm, editType: "calc" };\n            function c7t(e3) {\n              for (var t3 = e3._fullLayout, r4 = e3.calcdata, n4 = t3._subplots[Xm], i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3], o4 = s7t(r4, Xm, a4), s3 = t3[a4], l3 = s3._subplot;\n                l3 || (l3 = u7t({ id: a4, graphDiv: e3, container: t3._geolayer.node(), topojsonURL: e3._context.topojsonURL, staticPlot: e3._context.staticPlot }), t3[a4]._subplot = l3), l3.plot(o4, t3, e3._promises);\n              }\n            }\n            function f7t(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[Xm] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = n4[o4]._subplot;\n                !t3[o4] && s3 && (s3.framework.remove(), s3.clipDef.remove());\n              }\n            }\n            function h7t(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[Xm], n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]], a4 = i3._subplot;\n                a4.updateFx(t3, i3);\n              }\n            }\n            $De.exports = { attr: Xm, name: Xm, idRoot: Xm, idRegex: KDe, attrRegex: KDe, attributes: JDe, layoutAttributes: GZ(), supplyLayoutDefaults: YDe(), plot: c7t, updateFx: h7t, clean: f7t };\n          });\n          var eFe = ye((Smr, QDe) => {\n            "use strict";\n            QDe.exports = { attributes: j22(), supplyDefaults: DRe(), colorbar: $d(), formatLabels: ORe(), calc: pF(), calcGeoJSON: IZ().calcGeoJSON, plot: IZ().plot, style: kZ(), styleOnSelect: op().styleOnSelect, hoverPoints: wDe(), eventData: ADe(), selectPoints: EDe(), moduleType: "trace", name: "scattergeo", basePlotModule: HZ(), categories: ["geo", "symbols", "showLegend", "scatter-like"], meta: {} };\n          });\n          var rFe = ye((Mmr, tFe) => {\n            "use strict";\n            tFe.exports = eFe();\n          });\n          var t5 = ye((Emr, aFe) => {\n            "use strict";\n            var { hovertemplateAttrs: d7t, templatefallbackAttrs: v7t } = Ll(), ax = j22(), p7t = Tu(), iFe = Gl(), g7t = Lh().defaultLine, nx = Ao().extendFlat, nFe = ax.marker.line;\n            aFe.exports = nx({ locations: { valType: "data_array", editType: "calc" }, locationmode: ax.locationmode, z: { valType: "data_array", editType: "calc" }, geojson: nx({}, ax.geojson, {}), featureidkey: ax.featureidkey, text: nx({}, ax.text, {}), hovertext: nx({}, ax.hovertext, {}), marker: { line: { color: nx({}, nFe.color, { dflt: g7t }), width: nx({}, nFe.width, { dflt: 1 }), editType: "calc" }, opacity: { valType: "number", arrayOk: true, min: 0, max: 1, dflt: 1, editType: "style" }, editType: "calc" }, selected: { marker: { opacity: ax.selected.marker.opacity, editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: ax.unselected.marker.opacity, editType: "plot" }, editType: "plot" }, hoverinfo: nx({}, iFe.hoverinfo, { editType: "calc", flags: ["location", "z", "text", "name"] }), hovertemplate: d7t(), hovertemplatefallback: v7t(), showlegend: nx({}, iFe.showlegend, { dflt: false }) }, p7t("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var sFe = ye((kmr, oFe) => {\n            "use strict";\n            var sk = Dr(), m7t = Qh(), y7t = t5(), _7t = ["The library used by the *country names* `locationmode` option is changing in the next major version.", "Some country names in existing plots may not work in the new version.", "To ensure consistent behavior, consider setting `locationmode` to *ISO-3*."].join(" ");\n            oFe.exports = function(t3, r4, n4, i3) {\n              function a4(h3, d3) {\n                return sk.coerce(t3, r4, y7t, h3, d3);\n              }\n              var o4 = a4("locations"), s3 = a4("z");\n              if (!(o4 && o4.length && sk.isArrayOrTypedArray(s3) && s3.length)) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = Math.min(o4.length, s3.length);\n              var l3 = a4("geojson"), u4;\n              (typeof l3 == "string" && l3 !== "" || sk.isPlainObject(l3)) && (u4 = "geojson-id");\n              var c5 = a4("locationmode", u4);\n              c5 === "country names" && sk.warn(_7t), c5 === "geojson-id" && a4("featureidkey"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var f4 = a4("marker.line.width");\n              f4 && a4("marker.line.color"), a4("marker.opacity"), m7t(t3, r4, i3, a4, { prefix: "", cLetter: "z" }), sk.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var zF = ye((Cmr, cFe) => {\n            "use strict";\n            var lFe = Eo(), x7t = fs().BADNUM, b7t = gv(), w7t = km(), T7t = z0();\n            function uFe(e3) {\n              return e3 && typeof e3 == "string";\n            }\n            cFe.exports = function(t3, r4) {\n              var n4 = r4._length, i3 = new Array(n4), a4;\n              r4.geojson ? a4 = function(c5) {\n                return uFe(c5) || lFe(c5);\n              } : a4 = uFe;\n              for (var o4 = 0; o4 < n4; o4++) {\n                var s3 = i3[o4] = {}, l3 = r4.locations[o4], u4 = r4.z[o4];\n                a4(l3) && lFe(u4) ? (s3.loc = l3, s3.z = u4) : (s3.loc = null, s3.z = x7t), s3.index = o4;\n              }\n              return w7t(i3, r4), b7t(t3, r4, { vals: r4.z, containerStr: "", cLetter: "z" }), T7t(i3, r4), i3;\n            };\n          });\n          var OF = ye((Lmr, hFe) => {\n            "use strict";\n            var A7t = Oa(), S7t = ka(), jZ = So(), M7t = tc();\n            function E7t(e3, t3) {\n              t3 && fFe(e3, t3);\n            }\n            function fFe(e3, t3) {\n              var r4 = t3[0].trace, n4 = t3[0].node3, i3 = n4.selectAll(".choroplethlocation"), a4 = r4.marker || {}, o4 = a4.line || {}, s3 = M7t.makeColorScaleFuncFromTrace(r4);\n              i3.each(function(l3) {\n                A7t.select(this).attr("fill", s3(l3.z)).call(S7t.stroke, l3.mlc || o4.color).call(jZ.dashLine, "", l3.mlw || o4.width || 0).style("opacity", a4.opacity);\n              }), jZ.selectedPointStyle(i3, r4);\n            }\n            function k7t(e3, t3) {\n              var r4 = t3[0].node3, n4 = t3[0].trace;\n              n4.selectedpoints ? jZ.selectedPointStyle(r4.selectAll(".choroplethlocation"), n4) : fFe(e3, t3);\n            }\n            hFe.exports = { style: E7t, styleOnSelect: k7t };\n          });\n          var WZ = ye((Pmr, pFe) => {\n            "use strict";\n            var C7t = Oa(), dFe = Dr(), r5 = ix(), L7t = mF().getTopojsonFeatures, vFe = Ag().findExtremes, P7t = OF().style;\n            function I7t(e3, t3, r4) {\n              var n4 = t3.layers.backplot.select(".choroplethlayer");\n              dFe.makeTraceGroups(n4, r4, "trace choropleth").each(function(i3) {\n                var a4 = C7t.select(this), o4 = a4.selectAll("path.choroplethlocation").data(dFe.identity);\n                o4.enter().append("path").classed("choroplethlocation", true), o4.exit().remove(), P7t(e3, i3);\n              });\n            }\n            function R7t(e3, t3) {\n              for (var r4 = e3[0].trace, n4 = t3[r4.geo], i3 = n4._subplot, a4 = r4.locationmode, o4 = r4._length, s3 = a4 === "geojson-id" ? r5.extractTraceFeature(e3) : L7t(r4, i3.topojson), l3 = [], u4 = [], c5 = 0; c5 < o4; c5++) {\n                var f4 = e3[c5], h3 = a4 === "geojson-id" ? f4.fOut : r5.locationToFeature(a4, f4.loc, s3);\n                if (h3) {\n                  f4.geojson = h3, f4.ct = h3.properties.ct, f4._polygons = r5.feature2polygons(h3);\n                  var d3 = r5.computeBbox(h3);\n                  l3.push(d3[0], d3[2]), u4.push(d3[1], d3[3]);\n                } else f4.geojson = null;\n              }\n              if (n4.fitbounds === "geojson" && a4 === "geojson-id") {\n                var v3 = r5.computeBbox(r5.getTraceGeojson(r4));\n                l3 = [v3[0], v3[2]], u4 = [v3[1], v3[3]];\n              }\n              var _2 = { padded: true };\n              r4._extremes.lon = vFe(n4.lonaxis._ax, l3, _2), r4._extremes.lat = vFe(n4.lataxis._ax, u4, _2);\n            }\n            pFe.exports = { calcGeoJSON: R7t, plot: I7t };\n          });\n          var qF = ye((Imr, gFe) => {\n            "use strict";\n            var D7t = ho(), F7t = t5(), z7t = Dr().fillText;\n            gFe.exports = function(t3, r4, n4) {\n              var i3 = t3.cd, a4 = i3[0].trace, o4 = t3.subplot, s3, l3, u4, c5, f4 = [r4, n4], h3 = [r4 + 360, n4];\n              for (l3 = 0; l3 < i3.length; l3++) if (s3 = i3[l3], c5 = false, s3._polygons) {\n                for (u4 = 0; u4 < s3._polygons.length; u4++) s3._polygons[u4].contains(f4) && (c5 = !c5), s3._polygons[u4].contains(h3) && (c5 = !c5);\n                if (c5) break;\n              }\n              if (!(!c5 || !s3)) return t3.x0 = t3.x1 = t3.xa.c2p(s3.ct), t3.y0 = t3.y1 = t3.ya.c2p(s3.ct), t3.index = s3.index, t3.location = s3.loc, t3.z = s3.z, t3.zLabel = D7t.tickText(o4.mockAxis, o4.mockAxis.c2l(s3.z), "hover").text, t3.hovertemplate = s3.hovertemplate, O7t(t3, a4, s3), [t3];\n            };\n            function O7t(e3, t3, r4) {\n              if (!t3.hovertemplate) {\n                var n4 = r4.hi || t3.hoverinfo, i3 = String(r4.loc), a4 = n4 === "all" ? F7t.hoverinfo.flags : n4.split("+"), o4 = a4.indexOf("name") !== -1, s3 = a4.indexOf("location") !== -1, l3 = a4.indexOf("z") !== -1, u4 = a4.indexOf("text") !== -1, c5 = !o4 && s3, f4 = [];\n                c5 ? e3.nameOverride = i3 : (o4 && (e3.nameOverride = t3.name), s3 && f4.push(i3)), l3 && f4.push(e3.zLabel), u4 && z7t(r4, t3, f4), e3.extraText = f4.join("<br>");\n              }\n            }\n          });\n          var BF = ye((Rmr, mFe) => {\n            "use strict";\n            mFe.exports = function(t3, r4, n4, i3, a4) {\n              t3.location = r4.location, t3.z = r4.z;\n              var o4 = i3[a4];\n              return o4.fIn && o4.fIn.properties && (t3.properties = o4.fIn.properties), t3.ct = o4.ct, t3;\n            };\n          });\n          var NF = ye((Dmr, yFe) => {\n            "use strict";\n            yFe.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3, l3, u4, c5, f4;\n              if (r4 === false) for (s3 = 0; s3 < n4.length; s3++) n4[s3].selected = 0;\n              else for (s3 = 0; s3 < n4.length; s3++) l3 = n4[s3], u4 = l3.ct, u4 && (c5 = i3.c2p(u4), f4 = a4.c2p(u4), r4.contains([c5, f4], null, s3, t3) ? (o4.push({ pointNumber: s3, lon: u4[0], lat: u4[1] }), l3.selected = 1) : l3.selected = 0);\n              return o4;\n            };\n          });\n          var xFe = ye((Fmr, _Fe) => {\n            "use strict";\n            _Fe.exports = { attributes: t5(), supplyDefaults: sFe(), colorbar: S_(), calc: zF(), calcGeoJSON: WZ().calcGeoJSON, plot: WZ().plot, style: OF().style, styleOnSelect: OF().styleOnSelect, hoverPoints: qF(), eventData: BF(), selectPoints: NF(), moduleType: "trace", name: "choropleth", basePlotModule: HZ(), categories: ["geo", "noOpacity", "showLegend"], meta: {} };\n          });\n          var wFe = ye((zmr, bFe) => {\n            "use strict";\n            bFe.exports = xFe();\n          });\n          var UF = ye((Omr, AFe) => {\n            "use strict";\n            var q7t = qa(), s0 = Dr(), B7t = cT();\n            function N7t(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = i3[0].t, o4 = i3[0].trace, s3 = e3.xa, l3 = e3.ya, u4 = a4.x, c5 = a4.y, f4 = s3.c2p(t3), h3 = l3.c2p(r4), d3 = e3.distance, v3;\n              if (a4.tree) {\n                var _2 = s3.p2c(f4 - d3), b = s3.p2c(f4 + d3), p3 = l3.p2c(h3 - d3), k4 = l3.p2c(h3 + d3);\n                n4 === "x" ? v3 = a4.tree.range(Math.min(_2, b), Math.min(l3._rl[0], l3._rl[1]), Math.max(_2, b), Math.max(l3._rl[0], l3._rl[1])) : v3 = a4.tree.range(Math.min(_2, b), Math.min(p3, k4), Math.max(_2, b), Math.max(p3, k4));\n              } else v3 = a4.ids;\n              var E3, S2, L3, x2, C3, M4, g3, P3, T3, z3 = d3;\n              if (n4 === "x") {\n                var O3 = !!o4.xperiodalignment, V2 = !!o4.yperiodalignment;\n                for (C3 = 0; C3 < v3.length; C3++) {\n                  if (E3 = v3[C3], L3 = u4[E3], M4 = Math.abs(s3.c2p(L3) - f4), O3) {\n                    var G2 = s3.c2p(o4._xStarts[E3]), Z = s3.c2p(o4._xEnds[E3]);\n                    M4 = f4 >= Math.min(G2, Z) && f4 <= Math.max(G2, Z) ? 0 : 1 / 0;\n                  }\n                  if (M4 < z3) {\n                    if (z3 = M4, x2 = c5[E3], g3 = l3.c2p(x2) - h3, V2) {\n                      var j3 = l3.c2p(o4._yStarts[E3]), N2 = l3.c2p(o4._yEnds[E3]);\n                      g3 = h3 >= Math.min(j3, N2) && h3 <= Math.max(j3, N2) ? 0 : 1 / 0;\n                    }\n                    T3 = Math.sqrt(M4 * M4 + g3 * g3), S2 = v3[C3];\n                  }\n                }\n              } else for (C3 = v3.length - 1; C3 > -1; C3--) E3 = v3[C3], L3 = u4[E3], x2 = c5[E3], M4 = s3.c2p(L3) - f4, g3 = l3.c2p(x2) - h3, P3 = Math.sqrt(M4 * M4 + g3 * g3), P3 < z3 && (z3 = T3 = P3, S2 = E3);\n              return e3.index = S2, e3.distance = z3, e3.dxy = T3, S2 === void 0 ? [e3] : [TFe(e3, u4, c5, o4)];\n            }\n            function TFe(e3, t3, r4, n4) {\n              var i3 = e3.xa, a4 = e3.ya, o4 = e3.distance, s3 = e3.dxy, l3 = e3.index, u4 = { pointNumber: l3, x: t3[l3], y: r4[l3] };\n              u4.tx = s0.isArrayOrTypedArray(n4.text) ? n4.text[l3] : n4.text, u4.htx = Array.isArray(n4.hovertext) ? n4.hovertext[l3] : n4.hovertext, u4.data = Array.isArray(n4.customdata) ? n4.customdata[l3] : n4.customdata, u4.tp = Array.isArray(n4.textposition) ? n4.textposition[l3] : n4.textposition;\n              var c5 = n4.textfont;\n              c5 && (u4.ts = s0.isArrayOrTypedArray(c5.size) ? c5.size[l3] : c5.size, u4.tc = s0.isArrayOrTypedArray(c5.color) ? c5.color[l3] : c5.color, u4.tf = Array.isArray(c5.family) ? c5.family[l3] : c5.family, u4.tw = Array.isArray(c5.weight) ? c5.weight[l3] : c5.weight, u4.ty = Array.isArray(c5.style) ? c5.style[l3] : c5.style, u4.tv = Array.isArray(c5.variant) ? c5.variant[l3] : c5.variant);\n              var f4 = n4.marker;\n              f4 && (u4.ms = s0.isArrayOrTypedArray(f4.size) ? f4.size[l3] : f4.size, u4.mo = s0.isArrayOrTypedArray(f4.opacity) ? f4.opacity[l3] : f4.opacity, u4.mx = s0.isArrayOrTypedArray(f4.symbol) ? f4.symbol[l3] : f4.symbol, u4.ma = s0.isArrayOrTypedArray(f4.angle) ? f4.angle[l3] : f4.angle, u4.mc = s0.isArrayOrTypedArray(f4.color) ? f4.color[l3] : f4.color);\n              var h3 = f4 && f4.line;\n              h3 && (u4.mlc = Array.isArray(h3.color) ? h3.color[l3] : h3.color, u4.mlw = s0.isArrayOrTypedArray(h3.width) ? h3.width[l3] : h3.width);\n              var d3 = f4 && f4.gradient;\n              d3 && d3.type !== "none" && (u4.mgt = Array.isArray(d3.type) ? d3.type[l3] : d3.type, u4.mgc = Array.isArray(d3.color) ? d3.color[l3] : d3.color);\n              var v3 = i3.c2p(u4.x, true), _2 = a4.c2p(u4.y, true), b = u4.mrc || 1, p3 = n4.hoverlabel;\n              p3 && (u4.hbg = Array.isArray(p3.bgcolor) ? p3.bgcolor[l3] : p3.bgcolor, u4.hbc = Array.isArray(p3.bordercolor) ? p3.bordercolor[l3] : p3.bordercolor, u4.hts = s0.isArrayOrTypedArray(p3.font.size) ? p3.font.size[l3] : p3.font.size, u4.htc = Array.isArray(p3.font.color) ? p3.font.color[l3] : p3.font.color, u4.htf = Array.isArray(p3.font.family) ? p3.font.family[l3] : p3.font.family, u4.hnl = s0.isArrayOrTypedArray(p3.namelength) ? p3.namelength[l3] : p3.namelength);\n              var k4 = n4.hoverinfo;\n              k4 && (u4.hi = Array.isArray(k4) ? k4[l3] : k4);\n              var E3 = n4.hovertemplate;\n              E3 && (u4.ht = Array.isArray(E3) ? E3[l3] : E3);\n              var S2 = {};\n              S2[e3.index] = u4;\n              var L3 = n4._origX, x2 = n4._origY, C3 = s0.extendFlat({}, e3, { color: B7t(n4, u4), x0: v3 - b, x1: v3 + b, xLabelVal: L3 ? L3[l3] : u4.x, y0: _2 - b, y1: _2 + b, yLabelVal: x2 ? x2[l3] : u4.y, cd: S2, distance: o4, spikeDistance: s3, hovertemplate: u4.ht });\n              return u4.htx ? C3.text = u4.htx : u4.tx ? C3.text = u4.tx : n4.text && (C3.text = n4.text), s0.fillText(u4, n4, C3), q7t.getComponentMethod("errorbars", "hoverInfo")(u4, n4, C3), C3;\n            }\n            AFe.exports = { hoverPoints: N7t, calcHover: TFe };\n          });\n          var ox = ye((qmr, MFe) => {\n            "use strict";\n            var SFe = 20;\n            MFe.exports = { TOO_MANY_POINTS: 1e5, SYMBOL_SDF_SIZE: 200, SYMBOL_SIZE: SFe, SYMBOL_STROKE: SFe / 20, DOT_RE: /-dot/, OPEN_RE: /-open/, DASHES: { solid: [1], dot: [1, 1], dash: [4, 1], longdash: [8, 1], dashdot: [4, 1, 1, 1], longdashdot: [8, 1, 1, 1] } };\n          });\n          var lk = ye((Bmr, LFe) => {\n            "use strict";\n            var U7t = Gl(), V7t = ec(), G7t = Cg(), mf = pf(), EFe = df().axisHoverFormat, kFe = Tu(), H7t = Z1(), XZ = Ao().extendFlat, j7t = mc().overrideAll, W7t = ox().DASHES, CFe = mf.line, r1 = mf.marker, X7t = r1.line, sx = LFe.exports = j7t({ x: mf.x, x0: mf.x0, dx: mf.dx, y: mf.y, y0: mf.y0, dy: mf.dy, xperiod: mf.xperiod, yperiod: mf.yperiod, xperiod0: mf.xperiod0, yperiod0: mf.yperiod0, xperiodalignment: mf.xperiodalignment, yperiodalignment: mf.yperiodalignment, xhoverformat: EFe("x"), yhoverformat: EFe("y"), text: mf.text, hovertext: mf.hovertext, textposition: mf.textposition, textfont: V7t({ noFontShadow: true, noFontLineposition: true, noFontTextcase: true, editType: "calc", colorEditType: "style", arrayOk: true, noNumericWeightValues: true, variantValues: ["normal", "small-caps"] }), mode: { valType: "flaglist", flags: ["lines", "markers", "text"], extras: ["none"] }, line: { color: CFe.color, width: CFe.width, shape: { valType: "enumerated", values: ["linear", "hv", "vh", "hvh", "vhv"], dflt: "linear", editType: "plot" }, dash: { valType: "enumerated", values: H7t(W7t), dflt: "solid" } }, marker: XZ({}, kFe("marker"), { symbol: r1.symbol, angle: r1.angle, size: r1.size, sizeref: r1.sizeref, sizemin: r1.sizemin, sizemode: r1.sizemode, opacity: r1.opacity, colorbar: r1.colorbar, line: XZ({}, kFe("marker.line"), { width: X7t.width }) }), connectgaps: mf.connectgaps, fill: XZ({}, mf.fill, { dflt: "none" }), fillcolor: G7t(), selected: { marker: mf.selected.marker, textfont: mf.selected.textfont }, unselected: { marker: mf.unselected.marker, textfont: mf.unselected.textfont }, opacity: U7t.opacity }, "calc", "nested");\n            sx.x.editType = sx.y.editType = sx.x0.editType = sx.y0.editType = "calc+clearAxisTypes";\n            sx.hovertemplate = mf.hovertemplate;\n            sx.hovertemplatefallback = mf.hovertemplatefallback;\n            sx.texttemplate = mf.texttemplate;\n            sx.texttemplatefallback = mf.texttemplatefallback;\n          });\n          var VF = ye((ZZ) => {\n            "use strict";\n            var PFe = ox();\n            ZZ.isOpenSymbol = function(e3) {\n              return typeof e3 == "string" ? PFe.OPEN_RE.test(e3) : e3 % 200 > 100;\n            };\n            ZZ.isDotSymbol = function(e3) {\n              return typeof e3 == "string" ? PFe.DOT_RE.test(e3) : e3 > 200;\n            };\n          });\n          var DFe = ye((Umr, RFe) => {\n            "use strict";\n            var IFe = Dr(), Z7t = qa(), Y7t = VF(), K7t = lk(), J7t = Sm(), GF = Ru(), $7t = eT(), Q7t = Ig(), e9t = $p(), t9t = R0(), r9t = Rg(), i9t = D0();\n            RFe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return IFe.coerce(t3, r4, K7t, d3, v3);\n              }\n              var o4 = t3.marker ? Y7t.isOpenSymbol(t3.marker.symbol) : false, s3 = GF.isBubble(t3), l3 = $7t(t3, r4, i3, a4);\n              if (!l3) {\n                r4.visible = false;\n                return;\n              }\n              Q7t(t3, r4, i3, a4), a4("xhoverformat"), a4("yhoverformat");\n              var u4 = l3 < J7t.PTS_LINESONLY ? "lines+markers" : "lines";\n              a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("mode", u4), GF.hasMarkers(r4) && (e9t(t3, r4, n4, i3, a4, { noAngleRef: true, noStandOff: true }), a4("marker.line.width", o4 || s3 ? 1 : 0)), GF.hasLines(r4) && (a4("connectgaps"), t9t(t3, r4, n4, i3, a4), a4("line.shape")), GF.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), i9t(t3, r4, i3, a4, { noFontShadow: true, noFontLineposition: true, noFontTextcase: true }));\n              var c5 = (r4.line || {}).color, f4 = (r4.marker || {}).color;\n              a4("fill"), r4.fill !== "none" && r9t(t3, r4, n4, a4);\n              var h3 = Z7t.getComponentMethod("errorbars", "supplyDefaults");\n              h3(t3, r4, c5 || f4 || n4, { axis: "y" }), h3(t3, r4, c5 || f4 || n4, { axis: "x", inherit: "y" }), IFe.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var zFe = ye((Vmr, FFe) => {\n            "use strict";\n            var n9t = nI();\n            FFe.exports = function(t3, r4, n4) {\n              var i3 = t3.i;\n              return "x" in t3 || (t3.x = r4._x[i3]), "y" in t3 || (t3.y = r4._y[i3]), n9t(t3, r4, n4);\n            };\n          });\n          var qFe = ye((Gmr, OFe) => {\n            "use strict";\n            function a9t(e3, t3, r4, n4, i3) {\n              for (var a4 = i3 + 1; n4 <= i3; ) {\n                var o4 = n4 + i3 >>> 1, s3 = e3[o4], l3 = r4 !== void 0 ? r4(s3, t3) : s3 - t3;\n                l3 >= 0 ? (a4 = o4, i3 = o4 - 1) : n4 = o4 + 1;\n              }\n              return a4;\n            }\n            function o9t(e3, t3, r4, n4, i3) {\n              for (var a4 = i3 + 1; n4 <= i3; ) {\n                var o4 = n4 + i3 >>> 1, s3 = e3[o4], l3 = r4 !== void 0 ? r4(s3, t3) : s3 - t3;\n                l3 > 0 ? (a4 = o4, i3 = o4 - 1) : n4 = o4 + 1;\n              }\n              return a4;\n            }\n            function s9t(e3, t3, r4, n4, i3) {\n              for (var a4 = n4 - 1; n4 <= i3; ) {\n                var o4 = n4 + i3 >>> 1, s3 = e3[o4], l3 = r4 !== void 0 ? r4(s3, t3) : s3 - t3;\n                l3 < 0 ? (a4 = o4, n4 = o4 + 1) : i3 = o4 - 1;\n              }\n              return a4;\n            }\n            function l9t(e3, t3, r4, n4, i3) {\n              for (var a4 = n4 - 1; n4 <= i3; ) {\n                var o4 = n4 + i3 >>> 1, s3 = e3[o4], l3 = r4 !== void 0 ? r4(s3, t3) : s3 - t3;\n                l3 <= 0 ? (a4 = o4, n4 = o4 + 1) : i3 = o4 - 1;\n              }\n              return a4;\n            }\n            function u9t(e3, t3, r4, n4, i3) {\n              for (; n4 <= i3; ) {\n                var a4 = n4 + i3 >>> 1, o4 = e3[a4], s3 = r4 !== void 0 ? r4(o4, t3) : o4 - t3;\n                if (s3 === 0) return a4;\n                s3 <= 0 ? n4 = a4 + 1 : i3 = a4 - 1;\n              }\n              return -1;\n            }\n            function uk(e3, t3, r4, n4, i3, a4) {\n              return typeof r4 == "function" ? a4(e3, t3, r4, n4 === void 0 ? 0 : n4 | 0, i3 === void 0 ? e3.length - 1 : i3 | 0) : a4(e3, t3, void 0, r4 === void 0 ? 0 : r4 | 0, n4 === void 0 ? e3.length - 1 : n4 | 0);\n            }\n            OFe.exports = { ge: function(e3, t3, r4, n4, i3) {\n              return uk(e3, t3, r4, n4, i3, a9t);\n            }, gt: function(e3, t3, r4, n4, i3) {\n              return uk(e3, t3, r4, n4, i3, o9t);\n            }, lt: function(e3, t3, r4, n4, i3) {\n              return uk(e3, t3, r4, n4, i3, s9t);\n            }, le: function(e3, t3, r4, n4, i3) {\n              return uk(e3, t3, r4, n4, i3, l9t);\n            }, eq: function(e3, t3, r4, n4, i3) {\n              return uk(e3, t3, r4, n4, i3, u9t);\n            } };\n          });\n          var Zm = ye((Hmr, NFe) => {\n            "use strict";\n            NFe.exports = function(t3, r4, n4) {\n              var i3 = {}, a4, o4;\n              if (typeof r4 == "string" && (r4 = BFe(r4)), Array.isArray(r4)) {\n                var s3 = {};\n                for (o4 = 0; o4 < r4.length; o4++) s3[r4[o4]] = true;\n                r4 = s3;\n              }\n              for (a4 in r4) r4[a4] = BFe(r4[a4]);\n              var l3 = {};\n              for (a4 in r4) {\n                var u4 = r4[a4];\n                if (Array.isArray(u4)) for (o4 = 0; o4 < u4.length; o4++) {\n                  var c5 = u4[o4];\n                  if (n4 && (l3[c5] = true), c5 in t3) {\n                    if (i3[a4] = t3[c5], n4) for (var f4 = o4; f4 < u4.length; f4++) l3[u4[f4]] = true;\n                    break;\n                  }\n                }\n                else a4 in t3 && (r4[a4] && (i3[a4] = t3[a4]), n4 && (l3[a4] = true));\n              }\n              if (n4) for (a4 in t3) l3[a4] || (i3[a4] = t3[a4]);\n              return i3;\n            };\n            var YZ = {};\n            function BFe(e3) {\n              return YZ[e3] ? YZ[e3] : (typeof e3 == "string" && (e3 = YZ[e3] = e3.split(/\\s*,\\s*|\\s+/)), e3);\n            }\n          });\n          var i5 = ye((jmr, UFe) => {\n            "use strict";\n            var c9t = Zm();\n            UFe.exports = f9t;\n            function f9t(e3) {\n              var t3;\n              return arguments.length > 1 && (e3 = arguments), typeof e3 == "string" ? e3 = e3.split(/\\s/).map(parseFloat) : typeof e3 == "number" && (e3 = [e3]), e3.length && typeof e3[0] == "number" ? e3.length === 1 ? t3 = { width: e3[0], height: e3[0], x: 0, y: 0 } : e3.length === 2 ? t3 = { width: e3[0], height: e3[1], x: 0, y: 0 } : t3 = { x: e3[0], y: e3[1], width: e3[2] - e3[0] || 0, height: e3[3] - e3[1] || 0 } : e3 && (e3 = c9t(e3, { left: "x l left Left", top: "y t top Top", width: "w width W Width", height: "h height W Width", bottom: "b bottom Bottom", right: "r right Right" }), t3 = { x: e3.left || 0, y: e3.top || 0 }, e3.width == null ? e3.right ? t3.width = e3.right - t3.x : t3.width = 0 : t3.width = e3.width, e3.height == null ? e3.bottom ? t3.height = e3.bottom - t3.y : t3.height = 0 : t3.height = e3.height), t3;\n            }\n          });\n          var X2 = ye((Wmr, VFe) => {\n            "use strict";\n            VFe.exports = h9t;\n            function h9t(e3, t3) {\n              if (!e3 || e3.length == null) throw Error("Argument should be an array");\n              t3 == null ? t3 = 1 : t3 = Math.floor(t3);\n              for (var r4 = Array(t3 * 2), n4 = 0; n4 < t3; n4++) {\n                for (var i3 = -1 / 0, a4 = 1 / 0, o4 = n4, s3 = e3.length; o4 < s3; o4 += t3) e3[o4] > i3 && (i3 = e3[o4]), e3[o4] < a4 && (a4 = e3[o4]);\n                r4[n4] = a4, r4[t3 + n4] = i3;\n              }\n              return r4;\n            }\n          });\n          var HFe = ye((Xmr, GFe) => {\n            GFe.exports = function() {\n              for (var e3 = 0; e3 < arguments.length; e3++) if (arguments[e3] !== void 0) return arguments[e3];\n            };\n          });\n          var Z2 = ye((Zmr, WFe) => {\n            var jFe = YD();\n            WFe.exports = d9t;\n            function d9t(e3, t3, r4) {\n              if (!e3) throw new TypeError("must specify data as first parameter");\n              if (r4 = +(r4 || 0) | 0, Array.isArray(e3) && e3[0] && typeof e3[0][0] == "number") {\n                var n4 = e3[0].length, i3 = e3.length * n4, a4, o4, s3, l3;\n                (!t3 || typeof t3 == "string") && (t3 = new (jFe(t3 || "float32"))(i3 + r4));\n                var u4 = t3.length - r4;\n                if (i3 !== u4) throw new Error("source length " + i3 + " (" + n4 + "x" + e3.length + ") does not match destination length " + u4);\n                for (a4 = 0, s3 = r4; a4 < e3.length; a4++) for (o4 = 0; o4 < n4; o4++) t3[s3++] = e3[a4][o4] === null ? NaN : e3[a4][o4];\n              } else if (!t3 || typeof t3 == "string") {\n                var c5 = jFe(t3 || "float32");\n                if (Array.isArray(e3) || t3 === "array") for (t3 = new c5(e3.length + r4), a4 = 0, s3 = r4, l3 = t3.length; s3 < l3; s3++, a4++) t3[s3] = e3[a4] === null ? NaN : e3[a4];\n                else r4 === 0 ? t3 = new c5(e3) : (t3 = new c5(e3.length + r4), t3.set(e3, r4));\n              } else t3.set(e3, r4);\n              return t3;\n            }\n          });\n          var ZFe = ye((Ymr, XFe) => {\n            "use strict";\n            XFe.exports = function(e3) {\n              var t3 = typeof e3;\n              return e3 !== null && (t3 === "object" || t3 === "function");\n            };\n          });\n          var KFe = ye((Kmr, YFe) => {\n            "use strict";\n            YFe.exports = Math.log2 || function(e3) {\n              return Math.log(e3) * Math.LOG2E;\n            };\n          });\n          var ize = ye((Jmr, rze) => {\n            "use strict";\n            var JFe = qFe(), $Fe = ZE(), v9t = i5(), p9t = X2(), QFe = Zm(), KZ = HFe(), g9t = Z2(), m9t = ZFe(), y9t = YD(), eze = KFe(), _9t = 1073741824;\n            rze.exports = function(t3, r4) {\n              r4 || (r4 = {}), t3 = g9t(t3, "float64"), r4 = QFe(r4, { bounds: "range bounds dataBox databox", maxDepth: "depth maxDepth maxdepth level maxLevel maxlevel levels", dtype: "type dtype format out dst output destination" });\n              let n4 = KZ(r4.maxDepth, 255), i3 = KZ(r4.bounds, p9t(t3, 2));\n              i3[0] === i3[2] && i3[2]++, i3[1] === i3[3] && i3[3]++;\n              let a4 = tze(t3, i3), o4 = t3.length >>> 1, s3;\n              r4.dtype || (r4.dtype = "array"), typeof r4.dtype == "string" ? s3 = new (y9t(r4.dtype))(o4) : r4.dtype && (s3 = r4.dtype, Array.isArray(s3) && (s3.length = o4));\n              for (let p3 = 0; p3 < o4; ++p3) s3[p3] = p3;\n              let l3 = [], u4 = [], c5 = [], f4 = [];\n              d3(0, 0, 1, s3, 0, 1);\n              let h3 = 0;\n              for (let p3 = 0; p3 < l3.length; p3++) {\n                let k4 = l3[p3];\n                if (s3.set) s3.set(k4, h3);\n                else for (let S2 = 0, L3 = k4.length; S2 < L3; S2++) s3[S2 + h3] = k4[S2];\n                let E3 = h3 + l3[p3].length;\n                f4[p3] = [h3, E3], h3 = E3;\n              }\n              return s3.range = v3, s3;\n              function d3(p3, k4, E3, S2, L3, x2) {\n                if (!S2.length) return null;\n                let C3 = l3[L3] || (l3[L3] = []), M4 = c5[L3] || (c5[L3] = []), g3 = u4[L3] || (u4[L3] = []), P3 = C3.length;\n                if (L3++, L3 > n4 || x2 > _9t) {\n                  for (let N2 = 0; N2 < S2.length; N2++) C3.push(S2[N2]), M4.push(x2), g3.push(null, null, null, null);\n                  return P3;\n                }\n                if (C3.push(S2[0]), M4.push(x2), S2.length <= 1) return g3.push(null, null, null, null), P3;\n                let T3 = E3 * 0.5, z3 = p3 + T3, O3 = k4 + T3, V2 = [], G2 = [], Z = [], j3 = [];\n                for (let N2 = 1, H = S2.length; N2 < H; N2++) {\n                  let te = S2[N2], oe = a4[te * 2], _e = a4[te * 2 + 1];\n                  oe < z3 ? _e < O3 ? V2.push(te) : G2.push(te) : _e < O3 ? Z.push(te) : j3.push(te);\n                }\n                return x2 <<= 2, g3.push(d3(p3, k4, T3, V2, L3, x2), d3(p3, O3, T3, G2, L3, x2 + 1), d3(z3, k4, T3, Z, L3, x2 + 2), d3(z3, O3, T3, j3, L3, x2 + 3)), P3;\n              }\n              function v3(...p3) {\n                let k4;\n                if (m9t(p3[p3.length - 1])) {\n                  let Z = p3.pop();\n                  !p3.length && (Z.x != null || Z.l != null || Z.left != null) && (p3 = [Z], k4 = {}), k4 = QFe(Z, { level: "level maxLevel", d: "d diam diameter r radius px pxSize pixel pixelSize maxD size minSize", lod: "lod details ranges offsets" });\n                } else k4 = {};\n                p3.length || (p3 = i3);\n                let E3 = v9t(...p3), [S2, L3, x2, C3] = [Math.min(E3.x, E3.x + E3.width), Math.min(E3.y, E3.y + E3.height), Math.max(E3.x, E3.x + E3.width), Math.max(E3.y, E3.y + E3.height)], [M4, g3, P3, T3] = tze([S2, L3, x2, C3], i3), z3 = KZ(k4.level, l3.length);\n                if (k4.d != null) {\n                  let Z;\n                  typeof k4.d == "number" ? Z = [k4.d, k4.d] : k4.d.length && (Z = k4.d), z3 = Math.min(Math.max(Math.ceil(-eze(Math.abs(Z[0]) / (i3[2] - i3[0]))), Math.ceil(-eze(Math.abs(Z[1]) / (i3[3] - i3[1])))), z3);\n                }\n                if (z3 = Math.min(z3, l3.length), k4.lod) return _2(M4, g3, P3, T3, z3);\n                let O3 = [];\n                V2(0, 0, 1, 0, 0, 1);\n                function V2(Z, j3, N2, H, te, oe) {\n                  if (te === null || oe === null) return;\n                  let _e = Z + N2, Ee = j3 + N2;\n                  if (M4 > _e || g3 > Ee || P3 < Z || T3 < j3 || H >= z3 || te === oe) return;\n                  let Ce = l3[H];\n                  oe === void 0 && (oe = Ce.length);\n                  for (let Re = te; Re < oe; Re++) {\n                    let ce = Ce[Re], Ze = t3[ce * 2], ut = t3[ce * 2 + 1];\n                    Ze >= S2 && Ze <= x2 && ut >= L3 && ut <= C3 && O3.push(ce);\n                  }\n                  let me = u4[H], ie = me[te * 4 + 0], Se = me[te * 4 + 1], Le = me[te * 4 + 2], Ae = me[te * 4 + 3], Fe = G2(me, te + 1), Pe = N2 * 0.5, ge = H + 1;\n                  V2(Z, j3, Pe, ge, ie, Se || Le || Ae || Fe), V2(Z, j3 + Pe, Pe, ge, Se, Le || Ae || Fe), V2(Z + Pe, j3, Pe, ge, Le, Ae || Fe), V2(Z + Pe, j3 + Pe, Pe, ge, Ae, Fe);\n                }\n                function G2(Z, j3) {\n                  let N2 = null, H = 0;\n                  for (; N2 === null; ) if (N2 = Z[j3 * 4 + H], H++, H > Z.length) return null;\n                  return N2;\n                }\n                return O3;\n              }\n              function _2(p3, k4, E3, S2, L3) {\n                let x2 = [];\n                for (let C3 = 0; C3 < L3; C3++) {\n                  let M4 = c5[C3], g3 = f4[C3][0], P3 = b(p3, k4, C3), T3 = b(E3, S2, C3), z3 = JFe.ge(M4, P3), O3 = JFe.gt(M4, T3, z3, M4.length - 1);\n                  x2[C3] = [z3 + g3, O3 + g3];\n                }\n                return x2;\n              }\n              function b(p3, k4, E3) {\n                let S2 = 1, L3 = 0.5, x2 = 0.5, C3 = 0.5;\n                for (let M4 = 0; M4 < E3; M4++) S2 <<= 2, S2 += p3 < L3 ? k4 < x2 ? 0 : 1 : k4 < x2 ? 2 : 3, C3 *= 0.5, L3 += p3 < L3 ? -C3 : C3, x2 += k4 < x2 ? -C3 : C3;\n                return S2;\n              }\n            };\n            function tze(e3, t3) {\n              let [r4, n4, i3, a4] = t3, o4 = 1 / (i3 - r4), s3 = 1 / (a4 - n4), l3 = new Array(e3.length);\n              for (let u4 = 0, c5 = e3.length / 2; u4 < c5; u4++) l3[2 * u4] = $Fe((e3[2 * u4] - r4) * o4, 0, 1), l3[2 * u4 + 1] = $Fe((e3[2 * u4 + 1] - n4) * s3, 0, 1);\n              return l3;\n            }\n          });\n          var HF = ye(($mr, nze) => {\n            "use strict";\n            nze.exports = ize();\n          });\n          var JZ = ye((Qmr, aze) => {\n            aze.exports = x9t;\n            function x9t(e3) {\n              var t3 = 0, r4 = 0, n4 = 0, i3 = 0;\n              return e3.map(function(a4) {\n                a4 = a4.slice();\n                var o4 = a4[0], s3 = o4.toUpperCase();\n                if (o4 != s3) switch (a4[0] = s3, o4) {\n                  case "a":\n                    a4[6] += n4, a4[7] += i3;\n                    break;\n                  case "v":\n                    a4[1] += i3;\n                    break;\n                  case "h":\n                    a4[1] += n4;\n                    break;\n                  default:\n                    for (var l3 = 1; l3 < a4.length; ) a4[l3++] += n4, a4[l3++] += i3;\n                }\n                switch (s3) {\n                  case "Z":\n                    n4 = t3, i3 = r4;\n                    break;\n                  case "H":\n                    n4 = a4[1];\n                    break;\n                  case "V":\n                    i3 = a4[1];\n                    break;\n                  case "M":\n                    n4 = t3 = a4[1], i3 = r4 = a4[2];\n                    break;\n                  default:\n                    n4 = a4[a4.length - 2], i3 = a4[a4.length - 1];\n                }\n                return a4;\n              });\n            }\n          });\n          var lze = ye((jF, sze) => {\n            "use strict";\n            Object.defineProperty(jF, "__esModule", { value: true });\n            var b9t = /* @__PURE__ */ (function() {\n              function e3(t3, r4) {\n                var n4 = [], i3 = true, a4 = false, o4 = void 0;\n                try {\n                  for (var s3 = t3[Symbol.iterator](), l3; !(i3 = (l3 = s3.next()).done) && (n4.push(l3.value), !(r4 && n4.length === r4)); i3 = true) ;\n                } catch (u4) {\n                  a4 = true, o4 = u4;\n                } finally {\n                  try {\n                    !i3 && s3.return && s3.return();\n                  } finally {\n                    if (a4) throw o4;\n                  }\n                }\n                return n4;\n              }\n              return function(t3, r4) {\n                if (Array.isArray(t3)) return t3;\n                if (Symbol.iterator in Object(t3)) return e3(t3, r4);\n                throw new TypeError("Invalid attempt to destructure non-iterable instance");\n              };\n            })(), ck = Math.PI * 2, $Z = function(t3, r4, n4, i3, a4, o4, s3) {\n              var l3 = t3.x, u4 = t3.y;\n              l3 *= r4, u4 *= n4;\n              var c5 = i3 * l3 - a4 * u4, f4 = a4 * l3 + i3 * u4;\n              return { x: c5 + o4, y: f4 + s3 };\n            }, w9t = function(t3, r4) {\n              var n4 = r4 === 1.5707963267948966 ? 0.551915024494 : r4 === -1.5707963267948966 ? -0.551915024494 : 1.3333333333333333 * Math.tan(r4 / 4), i3 = Math.cos(t3), a4 = Math.sin(t3), o4 = Math.cos(t3 + r4), s3 = Math.sin(t3 + r4);\n              return [{ x: i3 - a4 * n4, y: a4 + i3 * n4 }, { x: o4 + s3 * n4, y: s3 - o4 * n4 }, { x: o4, y: s3 }];\n            }, oze = function(t3, r4, n4, i3) {\n              var a4 = t3 * i3 - r4 * n4 < 0 ? -1 : 1, o4 = t3 * n4 + r4 * i3;\n              return o4 > 1 && (o4 = 1), o4 < -1 && (o4 = -1), a4 * Math.acos(o4);\n            }, T9t = function(t3, r4, n4, i3, a4, o4, s3, l3, u4, c5, f4, h3) {\n              var d3 = Math.pow(a4, 2), v3 = Math.pow(o4, 2), _2 = Math.pow(f4, 2), b = Math.pow(h3, 2), p3 = d3 * v3 - d3 * b - v3 * _2;\n              p3 < 0 && (p3 = 0), p3 /= d3 * b + v3 * _2, p3 = Math.sqrt(p3) * (s3 === l3 ? -1 : 1);\n              var k4 = p3 * a4 / o4 * h3, E3 = p3 * -o4 / a4 * f4, S2 = c5 * k4 - u4 * E3 + (t3 + n4) / 2, L3 = u4 * k4 + c5 * E3 + (r4 + i3) / 2, x2 = (f4 - k4) / a4, C3 = (h3 - E3) / o4, M4 = (-f4 - k4) / a4, g3 = (-h3 - E3) / o4, P3 = oze(1, 0, x2, C3), T3 = oze(x2, C3, M4, g3);\n              return l3 === 0 && T3 > 0 && (T3 -= ck), l3 === 1 && T3 < 0 && (T3 += ck), [S2, L3, P3, T3];\n            }, A9t = function(t3) {\n              var r4 = t3.px, n4 = t3.py, i3 = t3.cx, a4 = t3.cy, o4 = t3.rx, s3 = t3.ry, l3 = t3.xAxisRotation, u4 = l3 === void 0 ? 0 : l3, c5 = t3.largeArcFlag, f4 = c5 === void 0 ? 0 : c5, h3 = t3.sweepFlag, d3 = h3 === void 0 ? 0 : h3, v3 = [];\n              if (o4 === 0 || s3 === 0) return [];\n              var _2 = Math.sin(u4 * ck / 360), b = Math.cos(u4 * ck / 360), p3 = b * (r4 - i3) / 2 + _2 * (n4 - a4) / 2, k4 = -_2 * (r4 - i3) / 2 + b * (n4 - a4) / 2;\n              if (p3 === 0 && k4 === 0) return [];\n              o4 = Math.abs(o4), s3 = Math.abs(s3);\n              var E3 = Math.pow(p3, 2) / Math.pow(o4, 2) + Math.pow(k4, 2) / Math.pow(s3, 2);\n              E3 > 1 && (o4 *= Math.sqrt(E3), s3 *= Math.sqrt(E3));\n              var S2 = T9t(r4, n4, i3, a4, o4, s3, f4, d3, _2, b, p3, k4), L3 = b9t(S2, 4), x2 = L3[0], C3 = L3[1], M4 = L3[2], g3 = L3[3], P3 = Math.abs(g3) / (ck / 4);\n              Math.abs(1 - P3) < 1e-7 && (P3 = 1);\n              var T3 = Math.max(Math.ceil(P3), 1);\n              g3 /= T3;\n              for (var z3 = 0; z3 < T3; z3++) v3.push(w9t(M4, g3)), M4 += g3;\n              return v3.map(function(O3) {\n                var V2 = $Z(O3[0], o4, s3, b, _2, x2, C3), G2 = V2.x, Z = V2.y, j3 = $Z(O3[1], o4, s3, b, _2, x2, C3), N2 = j3.x, H = j3.y, te = $Z(O3[2], o4, s3, b, _2, x2, C3), oe = te.x, _e = te.y;\n                return { x1: G2, y1: Z, x2: N2, y2: H, x: oe, y: _e };\n              });\n            };\n            jF.default = A9t;\n            sze.exports = jF.default;\n          });\n          var fze = ye((eyr, cze) => {\n            "use strict";\n            cze.exports = M9t;\n            var S9t = lze();\n            function M9t(e3) {\n              for (var t3, r4 = [], n4 = 0, i3 = 0, a4 = 0, o4 = 0, s3 = null, l3 = null, u4 = 0, c5 = 0, f4 = 0, h3 = e3.length; f4 < h3; f4++) {\n                var d3 = e3[f4], v3 = d3[0];\n                switch (v3) {\n                  case "M":\n                    a4 = d3[1], o4 = d3[2];\n                    break;\n                  case "A":\n                    var _2 = S9t({ px: u4, py: c5, cx: d3[6], cy: d3[7], rx: d3[1], ry: d3[2], xAxisRotation: d3[3], largeArcFlag: d3[4], sweepFlag: d3[5] });\n                    if (!_2.length) continue;\n                    for (var b = 0, p3; b < _2.length; b++) p3 = _2[b], d3 = ["C", p3.x1, p3.y1, p3.x2, p3.y2, p3.x, p3.y], b < _2.length - 1 && r4.push(d3);\n                    break;\n                  case "S":\n                    var k4 = u4, E3 = c5;\n                    (t3 == "C" || t3 == "S") && (k4 += k4 - n4, E3 += E3 - i3), d3 = ["C", k4, E3, d3[1], d3[2], d3[3], d3[4]];\n                    break;\n                  case "T":\n                    t3 == "Q" || t3 == "T" ? (s3 = u4 * 2 - s3, l3 = c5 * 2 - l3) : (s3 = u4, l3 = c5), d3 = uze(u4, c5, s3, l3, d3[1], d3[2]);\n                    break;\n                  case "Q":\n                    s3 = d3[1], l3 = d3[2], d3 = uze(u4, c5, d3[1], d3[2], d3[3], d3[4]);\n                    break;\n                  case "L":\n                    d3 = WF(u4, c5, d3[1], d3[2]);\n                    break;\n                  case "H":\n                    d3 = WF(u4, c5, d3[1], c5);\n                    break;\n                  case "V":\n                    d3 = WF(u4, c5, u4, d3[1]);\n                    break;\n                  case "Z":\n                    d3 = WF(u4, c5, a4, o4);\n                    break;\n                }\n                t3 = v3, u4 = d3[d3.length - 2], c5 = d3[d3.length - 1], d3.length > 4 ? (n4 = d3[d3.length - 4], i3 = d3[d3.length - 3]) : (n4 = u4, i3 = c5), r4.push(d3);\n              }\n              return r4;\n            }\n            function WF(e3, t3, r4, n4) {\n              return ["C", e3, t3, r4, n4, r4, n4];\n            }\n            function uze(e3, t3, r4, n4, i3, a4) {\n              return ["C", e3 / 3 + 2 / 3 * r4, t3 / 3 + 2 / 3 * n4, i3 / 3 + 2 / 3 * r4, a4 / 3 + 2 / 3 * n4, i3, a4];\n            }\n          });\n          var QZ = ye((tyr, hze) => {\n            "use strict";\n            hze.exports = function(t3) {\n              return typeof t3 != "string" ? false : (t3 = t3.trim(), !!(/^[mzlhvcsqta]\\s*[-+.0-9][^mlhvzcsqta]+/i.test(t3) && /[\\dz]$/i.test(t3) && t3.length > 4));\n            };\n          });\n          var pze = ye((ryr, vze) => {\n            "use strict";\n            var E9t = eM(), k9t = JZ(), C9t = fze(), L9t = QZ(), dze = lE();\n            vze.exports = P9t;\n            function P9t(e3) {\n              if (Array.isArray(e3) && e3.length === 1 && typeof e3[0] == "string" && (e3 = e3[0]), typeof e3 == "string" && (dze(L9t(e3), "String is not an SVG path."), e3 = E9t(e3)), dze(Array.isArray(e3), "Argument should be a string or an array of path segments."), e3 = k9t(e3), e3 = C9t(e3), !e3.length) return [0, 0, 0, 0];\n              for (var t3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], r4 = 0, n4 = e3.length; r4 < n4; r4++) for (var i3 = e3[r4].slice(1), a4 = 0; a4 < i3.length; a4 += 2) i3[a4 + 0] < t3[0] && (t3[0] = i3[a4 + 0]), i3[a4 + 1] < t3[1] && (t3[1] = i3[a4 + 1]), i3[a4 + 0] > t3[2] && (t3[2] = i3[a4 + 0]), i3[a4 + 1] > t3[3] && (t3[3] = i3[a4 + 1]);\n              return t3;\n            }\n          });\n          var bze = ye((iyr, xze) => {\n            var Y2 = Math.PI, gze = _ze(120);\n            xze.exports = I9t;\n            function I9t(e3) {\n              for (var t3, r4 = [], n4 = 0, i3 = 0, a4 = 0, o4 = 0, s3 = null, l3 = null, u4 = 0, c5 = 0, f4 = 0, h3 = e3.length; f4 < h3; f4++) {\n                var d3 = e3[f4], v3 = d3[0];\n                switch (v3) {\n                  case "M":\n                    a4 = d3[1], o4 = d3[2];\n                    break;\n                  case "A":\n                    d3 = yze(u4, c5, d3[1], d3[2], _ze(d3[3]), d3[4], d3[5], d3[6], d3[7]), d3.unshift("C"), d3.length > 7 && (r4.push(d3.splice(0, 7)), d3.unshift("C"));\n                    break;\n                  case "S":\n                    var _2 = u4, b = c5;\n                    (t3 == "C" || t3 == "S") && (_2 += _2 - n4, b += b - i3), d3 = ["C", _2, b, d3[1], d3[2], d3[3], d3[4]];\n                    break;\n                  case "T":\n                    t3 == "Q" || t3 == "T" ? (s3 = u4 * 2 - s3, l3 = c5 * 2 - l3) : (s3 = u4, l3 = c5), d3 = mze(u4, c5, s3, l3, d3[1], d3[2]);\n                    break;\n                  case "Q":\n                    s3 = d3[1], l3 = d3[2], d3 = mze(u4, c5, d3[1], d3[2], d3[3], d3[4]);\n                    break;\n                  case "L":\n                    d3 = XF(u4, c5, d3[1], d3[2]);\n                    break;\n                  case "H":\n                    d3 = XF(u4, c5, d3[1], c5);\n                    break;\n                  case "V":\n                    d3 = XF(u4, c5, u4, d3[1]);\n                    break;\n                  case "Z":\n                    d3 = XF(u4, c5, a4, o4);\n                    break;\n                }\n                t3 = v3, u4 = d3[d3.length - 2], c5 = d3[d3.length - 1], d3.length > 4 ? (n4 = d3[d3.length - 4], i3 = d3[d3.length - 3]) : (n4 = u4, i3 = c5), r4.push(d3);\n              }\n              return r4;\n            }\n            function XF(e3, t3, r4, n4) {\n              return ["C", e3, t3, r4, n4, r4, n4];\n            }\n            function mze(e3, t3, r4, n4, i3, a4) {\n              return ["C", e3 / 3 + 2 / 3 * r4, t3 / 3 + 2 / 3 * n4, i3 / 3 + 2 / 3 * r4, a4 / 3 + 2 / 3 * n4, i3, a4];\n            }\n            function yze(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4) {\n              if (u4) E3 = u4[0], S2 = u4[1], p3 = u4[2], k4 = u4[3];\n              else {\n                var c5 = eY(e3, t3, -i3);\n                e3 = c5.x, t3 = c5.y, c5 = eY(s3, l3, -i3), s3 = c5.x, l3 = c5.y;\n                var f4 = (e3 - s3) / 2, h3 = (t3 - l3) / 2, d3 = f4 * f4 / (r4 * r4) + h3 * h3 / (n4 * n4);\n                d3 > 1 && (d3 = Math.sqrt(d3), r4 = d3 * r4, n4 = d3 * n4);\n                var v3 = r4 * r4, _2 = n4 * n4, b = (a4 == o4 ? -1 : 1) * Math.sqrt(Math.abs((v3 * _2 - v3 * h3 * h3 - _2 * f4 * f4) / (v3 * h3 * h3 + _2 * f4 * f4)));\n                b == 1 / 0 && (b = 1);\n                var p3 = b * r4 * h3 / n4 + (e3 + s3) / 2, k4 = b * -n4 * f4 / r4 + (t3 + l3) / 2, E3 = Math.asin(((t3 - k4) / n4).toFixed(9)), S2 = Math.asin(((l3 - k4) / n4).toFixed(9));\n                E3 = e3 < p3 ? Y2 - E3 : E3, S2 = s3 < p3 ? Y2 - S2 : S2, E3 < 0 && (E3 = Y2 * 2 + E3), S2 < 0 && (S2 = Y2 * 2 + S2), o4 && E3 > S2 && (E3 = E3 - Y2 * 2), !o4 && S2 > E3 && (S2 = S2 - Y2 * 2);\n              }\n              if (Math.abs(S2 - E3) > gze) {\n                var L3 = S2, x2 = s3, C3 = l3;\n                S2 = E3 + gze * (o4 && S2 > E3 ? 1 : -1), s3 = p3 + r4 * Math.cos(S2), l3 = k4 + n4 * Math.sin(S2);\n                var M4 = yze(s3, l3, r4, n4, i3, 0, o4, x2, C3, [S2, L3, p3, k4]);\n              }\n              var g3 = Math.tan((S2 - E3) / 4), P3 = 4 / 3 * r4 * g3, T3 = 4 / 3 * n4 * g3, z3 = [2 * e3 - (e3 + P3 * Math.sin(E3)), 2 * t3 - (t3 - T3 * Math.cos(E3)), s3 + P3 * Math.sin(S2), l3 - T3 * Math.cos(S2), s3, l3];\n              if (u4) return z3;\n              M4 && (z3 = z3.concat(M4));\n              for (var O3 = 0; O3 < z3.length; ) {\n                var V2 = eY(z3[O3], z3[O3 + 1], i3);\n                z3[O3++] = V2.x, z3[O3++] = V2.y;\n              }\n              return z3;\n            }\n            function eY(e3, t3, r4) {\n              return { x: e3 * Math.cos(r4) - t3 * Math.sin(r4), y: e3 * Math.sin(r4) + t3 * Math.cos(r4) };\n            }\n            function _ze(e3) {\n              return e3 * (Y2 / 180);\n            }\n          });\n          var Tze = ye((nyr, wze) => {\n            var R9t = JZ(), D9t = bze(), F9t = { M: "moveTo", C: "bezierCurveTo" };\n            wze.exports = function(e3, t3) {\n              e3.beginPath(), D9t(R9t(t3)).forEach(function(r4) {\n                var n4 = r4[0], i3 = r4.slice(1);\n                e3[F9t[n4]].apply(e3, i3);\n              }), e3.closePath();\n            };\n          });\n          var Eze = ye((ayr, Mze) => {\n            "use strict";\n            var z9t = ZE();\n            Mze.exports = O9t;\n            var fk = 1e20;\n            function O9t(e3, t3) {\n              t3 || (t3 = {});\n              var r4 = t3.cutoff == null ? 0.25 : t3.cutoff, n4 = t3.radius == null ? 8 : t3.radius, i3 = t3.channel || 0, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3, _2;\n              if (ArrayBuffer.isView(e3) || Array.isArray(e3)) {\n                if (!t3.width || !t3.height) throw Error("For raw data width and height should be provided by options");\n                a4 = t3.width, o4 = t3.height, l3 = e3, t3.stride ? c5 = t3.stride : c5 = Math.floor(e3.length / a4 / o4);\n              } else window.HTMLCanvasElement && e3 instanceof window.HTMLCanvasElement ? (h3 = e3, f4 = h3.getContext("2d"), a4 = h3.width, o4 = h3.height, d3 = f4.getImageData(0, 0, a4, o4), l3 = d3.data, c5 = 4) : window.CanvasRenderingContext2D && e3 instanceof window.CanvasRenderingContext2D ? (h3 = e3.canvas, f4 = e3, a4 = h3.width, o4 = h3.height, d3 = f4.getImageData(0, 0, a4, o4), l3 = d3.data, c5 = 4) : window.ImageData && e3 instanceof window.ImageData && (d3 = e3, a4 = e3.width, o4 = e3.height, l3 = d3.data, c5 = 4);\n              if (s3 = Math.max(a4, o4), window.Uint8ClampedArray && l3 instanceof window.Uint8ClampedArray || window.Uint8Array && l3 instanceof window.Uint8Array) for (u4 = l3, l3 = Array(a4 * o4), v3 = 0, _2 = u4.length; v3 < _2; v3++) l3[v3] = u4[v3 * c5 + i3] / 255;\n              else if (c5 !== 1) throw Error("Raw data can have only 1 value per pixel");\n              var b = Array(a4 * o4), p3 = Array(a4 * o4), k4 = Array(s3), E3 = Array(s3), S2 = Array(s3 + 1), L3 = Array(s3);\n              for (v3 = 0, _2 = a4 * o4; v3 < _2; v3++) {\n                var x2 = l3[v3];\n                b[v3] = x2 === 1 ? 0 : x2 === 0 ? fk : Math.pow(Math.max(0, 0.5 - x2), 2), p3[v3] = x2 === 1 ? fk : x2 === 0 ? 0 : Math.pow(Math.max(0, x2 - 0.5), 2);\n              }\n              Aze(b, a4, o4, k4, E3, L3, S2), Aze(p3, a4, o4, k4, E3, L3, S2);\n              var C3 = window.Float32Array ? new Float32Array(a4 * o4) : new Array(a4 * o4);\n              for (v3 = 0, _2 = a4 * o4; v3 < _2; v3++) C3[v3] = z9t(1 - ((b[v3] - p3[v3]) / n4 + r4), 0, 1);\n              return C3;\n            }\n            function Aze(e3, t3, r4, n4, i3, a4, o4) {\n              for (var s3 = 0; s3 < t3; s3++) {\n                for (var l3 = 0; l3 < r4; l3++) n4[l3] = e3[l3 * t3 + s3];\n                for (Sze(n4, i3, a4, o4, r4), l3 = 0; l3 < r4; l3++) e3[l3 * t3 + s3] = i3[l3];\n              }\n              for (l3 = 0; l3 < r4; l3++) {\n                for (s3 = 0; s3 < t3; s3++) n4[s3] = e3[l3 * t3 + s3];\n                for (Sze(n4, i3, a4, o4, t3), s3 = 0; s3 < t3; s3++) e3[l3 * t3 + s3] = Math.sqrt(i3[s3]);\n              }\n            }\n            function Sze(e3, t3, r4, n4, i3) {\n              r4[0] = 0, n4[0] = -fk, n4[1] = +fk;\n              for (var a4 = 1, o4 = 0; a4 < i3; a4++) {\n                for (var s3 = (e3[a4] + a4 * a4 - (e3[r4[o4]] + r4[o4] * r4[o4])) / (2 * a4 - 2 * r4[o4]); s3 <= n4[o4]; ) o4--, s3 = (e3[a4] + a4 * a4 - (e3[r4[o4]] + r4[o4] * r4[o4])) / (2 * a4 - 2 * r4[o4]);\n                o4++, r4[o4] = a4, n4[o4] = s3, n4[o4 + 1] = +fk;\n              }\n              for (a4 = 0, o4 = 0; a4 < i3; a4++) {\n                for (; n4[o4 + 1] < a4; ) o4++;\n                t3[a4] = (a4 - r4[o4]) * (a4 - r4[o4]) + e3[r4[o4]];\n              }\n            }\n          });\n          var Cze = ye((oyr, kze) => {\n            "use strict";\n            var q9t = pze(), B9t = eM(), N9t = Tze(), U9t = QZ(), V9t = Eze(), tY = document.createElement("canvas"), hp = tY.getContext("2d");\n            kze.exports = G9t;\n            function G9t(e3, t3) {\n              if (!U9t(e3)) throw Error("Argument should be valid svg path string");\n              t3 || (t3 = {});\n              var r4, n4;\n              t3.shape ? (r4 = t3.shape[0], n4 = t3.shape[1]) : (r4 = tY.width = t3.w || t3.width || 200, n4 = tY.height = t3.h || t3.height || 200);\n              var i3 = Math.min(r4, n4), a4 = t3.stroke || 0, o4 = t3.viewbox || t3.viewBox || q9t(e3), s3 = [r4 / (o4[2] - o4[0]), n4 / (o4[3] - o4[1])], l3 = Math.min(s3[0] || 0, s3[1] || 0) / 2;\n              if (hp.fillStyle = "black", hp.fillRect(0, 0, r4, n4), hp.fillStyle = "white", a4 && (typeof a4 != "number" && (a4 = 1), a4 > 0 ? hp.strokeStyle = "white" : hp.strokeStyle = "black", hp.lineWidth = Math.abs(a4)), hp.translate(r4 * 0.5, n4 * 0.5), hp.scale(l3, l3), H9t()) {\n                var u4 = new Path2D(e3);\n                hp.fill(u4), a4 && hp.stroke(u4);\n              } else {\n                var c5 = B9t(e3);\n                N9t(hp, c5), hp.fill(), a4 && hp.stroke();\n              }\n              hp.setTransform(1, 0, 0, 1, 0, 0);\n              var f4 = V9t(hp, { cutoff: t3.cutoff != null ? t3.cutoff : 0.5, radius: t3.radius != null ? t3.radius : i3 * 0.5 });\n              return f4;\n            }\n            var ZF;\n            function H9t() {\n              if (ZF != null) return ZF;\n              var e3 = document.createElement("canvas").getContext("2d");\n              if (e3.canvas.width = e3.canvas.height = 1, !window.Path2D) return ZF = false;\n              var t3 = new Path2D("M0,0h1v1h-1v-1Z");\n              e3.fillStyle = "black", e3.fill(t3);\n              var r4 = e3.getImageData(0, 0, 1, 1);\n              return ZF = r4 && r4.data && r4.data[3] === 255;\n            }\n          });\n          var J2 = ye((syr, Nze) => {\n            "use strict";\n            var KF = Eo(), j9t = Cze(), YF = J_(), W9t = qa(), o5 = Dr(), _h = o5.isArrayOrTypedArray, n5 = So(), Lze = hf(), Pze = $y().formatColor, a5 = Ru(), X9t = k3(), iY = VF(), hk = ox(), Z9t = N1().DESELECTDIM, Ize = { start: 1, left: 1, end: -1, right: -1, middle: 0, center: 0, bottom: 1, top: -1 }, Y9t = ip().appendArrayPointValue;\n            function K9t(e3, t3) {\n              var r4, n4 = { marker: void 0, markerSel: void 0, markerUnsel: void 0, line: void 0, fill: void 0, errorX: void 0, errorY: void 0, text: void 0, textSel: void 0, textUnsel: void 0 }, i3 = e3._context.plotGlPixelRatio;\n              if (t3.visible !== true) return n4;\n              if (a5.hasText(t3) && (n4.text = Bze(e3, t3), n4.textSel = Dze(e3, t3, t3.selected), n4.textUnsel = Dze(e3, t3, t3.unselected)), a5.hasMarkers(t3) && (n4.marker = aY(e3, t3), n4.markerSel = nY(e3, t3, t3.selected), n4.markerUnsel = nY(e3, t3, t3.unselected), !t3.unselected && _h(t3.marker.opacity))) {\n                var a4 = t3.marker.opacity;\n                for (n4.markerUnsel.opacity = new Array(a4.length), r4 = 0; r4 < a4.length; r4++) n4.markerUnsel.opacity[r4] = Z9t * a4[r4];\n              }\n              if (a5.hasLines(t3)) {\n                n4.line = { overlay: true, thickness: t3.line.width * i3, color: t3.line.color, opacity: t3.opacity };\n                var o4 = (hk.DASHES[t3.line.dash] || [1]).slice();\n                for (r4 = 0; r4 < o4.length; ++r4) o4[r4] *= t3.line.width * i3;\n                n4.line.dashes = o4;\n              }\n              return t3.error_x && t3.error_x.visible && (n4.errorX = Fze(t3, t3.error_x, i3)), t3.error_y && t3.error_y.visible && (n4.errorY = Fze(t3, t3.error_y, i3)), t3.fill && t3.fill !== "none" && (n4.fill = { closed: true, fill: t3.fillcolor, thickness: 0 }), n4;\n            }\n            function Bze(e3, t3) {\n              var r4 = e3._fullLayout, n4 = t3._length, i3 = t3.textfont, a4 = t3.textposition, o4 = _h(a4) ? a4 : [a4], s3 = i3.color, l3 = i3.size, u4 = i3.family, c5 = i3.weight, f4 = i3.style, h3 = i3.variant, d3 = {}, v3, _2 = e3._context.plotGlPixelRatio, b = t3.texttemplate;\n              if (b) {\n                d3.text = [];\n                var p3 = r4._d3locale, k4 = Array.isArray(b), E3 = k4 ? Math.min(b.length, n4) : n4, S2 = k4 ? function(P3) {\n                  return b[P3];\n                } : function() {\n                  return b;\n                };\n                for (v3 = 0; v3 < E3; v3++) {\n                  var L3 = { i: v3 }, x2 = t3._module.formatLabels(L3, t3, r4), C3 = {};\n                  Y9t(C3, t3, v3), d3.text.push(o5.texttemplateString({ data: [C3, L3, t3._meta], fallback: t3.texttemplatefallback, labels: x2, locale: p3, template: S2(v3) }));\n                }\n              } else _h(t3.text) && t3.text.length < n4 ? d3.text = t3.text.slice() : d3.text = t3.text;\n              if (_h(d3.text)) for (v3 = d3.text.length; v3 < n4; v3++) d3.text[v3] = "";\n              for (d3.opacity = t3.opacity, d3.font = {}, d3.align = [], d3.baseline = [], v3 = 0; v3 < o4.length; v3++) {\n                var M4 = o4[v3].split(/\\s+/);\n                switch (M4[1]) {\n                  case "left":\n                    d3.align.push("right");\n                    break;\n                  case "right":\n                    d3.align.push("left");\n                    break;\n                  default:\n                    d3.align.push(M4[1]);\n                }\n                switch (M4[0]) {\n                  case "top":\n                    d3.baseline.push("bottom");\n                    break;\n                  case "bottom":\n                    d3.baseline.push("top");\n                    break;\n                  default:\n                    d3.baseline.push(M4[0]);\n                }\n              }\n              if (_h(s3)) for (d3.color = new Array(n4), v3 = 0; v3 < n4; v3++) d3.color[v3] = s3[v3];\n              else d3.color = s3;\n              if (_h(l3) || Array.isArray(u4) || _h(c5) || Array.isArray(f4) || Array.isArray(h3)) for (d3.font = new Array(n4), v3 = 0; v3 < n4; v3++) {\n                var g3 = d3.font[v3] = {};\n                g3.size = (o5.isTypedArray(l3) ? l3[v3] : _h(l3) ? KF(l3[v3]) ? l3[v3] : 0 : l3) * _2, g3.family = Array.isArray(u4) ? u4[v3] : u4, g3.weight = Rze(_h(c5) ? c5[v3] : c5), g3.style = Array.isArray(f4) ? f4[v3] : f4, g3.variant = Array.isArray(h3) ? h3[v3] : h3;\n              }\n              else d3.font = { size: l3 * _2, family: u4, weight: Rze(c5), style: f4, variant: h3 };\n              return d3;\n            }\n            function Rze(e3) {\n              return e3 <= 1e3 ? e3 > 500 ? "bold" : "normal" : e3;\n            }\n            function aY(e3, t3) {\n              var r4 = t3._length, n4 = t3.marker, i3 = {}, a4, o4 = _h(n4.symbol), s3 = _h(n4.angle), l3 = _h(n4.color), u4 = _h(n4.line.color), c5 = _h(n4.opacity), f4 = _h(n4.size), h3 = _h(n4.line.width), d3;\n              if (o4 || (d3 = iY.isOpenSymbol(n4.symbol)), o4 || l3 || u4 || c5 || s3) {\n                i3.symbols = new Array(r4), i3.angles = new Array(r4), i3.colors = new Array(r4), i3.borderColors = new Array(r4);\n                var v3 = n4.symbol, _2 = n4.angle, b = Pze(n4, n4.opacity, r4), p3 = Pze(n4.line, n4.opacity, r4);\n                if (!_h(p3[0])) {\n                  var k4 = p3;\n                  for (p3 = Array(r4), a4 = 0; a4 < r4; a4++) p3[a4] = k4;\n                }\n                if (!_h(b[0])) {\n                  var E3 = b;\n                  for (b = Array(r4), a4 = 0; a4 < r4; a4++) b[a4] = E3;\n                }\n                if (!_h(v3)) {\n                  var S2 = v3;\n                  for (v3 = Array(r4), a4 = 0; a4 < r4; a4++) v3[a4] = S2;\n                }\n                if (!_h(_2)) {\n                  var L3 = _2;\n                  for (_2 = Array(r4), a4 = 0; a4 < r4; a4++) _2[a4] = L3;\n                }\n                for (i3.symbols = v3, i3.angles = _2, i3.colors = b, i3.borderColors = p3, a4 = 0; a4 < r4; a4++) o4 && (d3 = iY.isOpenSymbol(n4.symbol[a4])), d3 && (p3[a4] = b[a4].slice(), b[a4] = b[a4].slice(), b[a4][3] = 0);\n                for (i3.opacity = t3.opacity, i3.markers = new Array(r4), a4 = 0; a4 < r4; a4++) i3.markers[a4] = qze({ mx: i3.symbols[a4], ma: i3.angles[a4] }, t3);\n              } else d3 ? (i3.color = YF(n4.color, "uint8"), i3.color[3] = 0, i3.borderColor = YF(n4.color, "uint8")) : (i3.color = YF(n4.color, "uint8"), i3.borderColor = YF(n4.line.color, "uint8")), i3.opacity = t3.opacity * n4.opacity, i3.marker = qze({ mx: n4.symbol, ma: n4.angle }, t3);\n              var x2 = 1, C3 = X9t(t3, x2), M4;\n              if (f4 || h3) {\n                var g3 = i3.sizes = new Array(r4), P3 = i3.borderSizes = new Array(r4), T3 = 0, z3;\n                if (f4) {\n                  for (a4 = 0; a4 < r4; a4++) g3[a4] = C3(n4.size[a4]), T3 += g3[a4];\n                  z3 = T3 / r4;\n                } else for (M4 = C3(n4.size), a4 = 0; a4 < r4; a4++) g3[a4] = M4;\n                if (h3) for (a4 = 0; a4 < r4; a4++) P3[a4] = n4.line.width[a4];\n                else for (M4 = n4.line.width, a4 = 0; a4 < r4; a4++) P3[a4] = M4;\n                i3.sizeAvg = z3;\n              } else i3.size = C3(n4 && n4.size || 10), i3.borderSizes = C3(n4.line.width);\n              return i3;\n            }\n            function nY(e3, t3, r4) {\n              var n4 = t3.marker, i3 = {};\n              return r4 && (r4.marker && r4.marker.symbol ? i3 = aY(e3, o5.extendFlat({}, n4, r4.marker)) : r4.marker && (r4.marker.size && (i3.size = r4.marker.size), r4.marker.color && (i3.colors = r4.marker.color), r4.marker.opacity !== void 0 && (i3.opacity = r4.marker.opacity))), i3;\n            }\n            function Dze(e3, t3, r4) {\n              var n4 = {};\n              if (!r4) return n4;\n              if (r4.textfont) {\n                var i3 = { opacity: 1, text: t3.text, texttemplate: t3.texttemplate, textposition: t3.textposition, textfont: o5.extendFlat({}, t3.textfont) };\n                r4.textfont && o5.extendFlat(i3.textfont, r4.textfont), n4 = Bze(e3, i3);\n              }\n              return n4;\n            }\n            function Fze(e3, t3, r4) {\n              var n4 = { capSize: t3.width * 2 * r4, lineWidth: t3.thickness * r4, color: t3.color };\n              return t3.copy_ystyle && (n4 = e3.error_y), n4;\n            }\n            var zze = hk.SYMBOL_SDF_SIZE, K2 = hk.SYMBOL_SIZE, Oze = hk.SYMBOL_STROKE, rY = {}, J9t = n5.symbolFuncs[0](K2 * 0.05);\n            function qze(e3, t3) {\n              var r4 = e3.mx;\n              if (r4 === "circle") return null;\n              var n4, i3, a4 = n5.symbolNumber(r4), o4 = n5.symbolFuncs[a4 % 100], s3 = !!n5.symbolNoDot[a4 % 100], l3 = !!n5.symbolNoFill[a4 % 100], u4 = iY.isDotSymbol(r4);\n              if (e3.ma && (r4 += "_" + e3.ma), rY[r4]) return rY[r4];\n              var c5 = n5.getMarkerAngle(e3, t3);\n              return u4 && !s3 ? n4 = o4(K2 * 1.1, c5) + J9t : n4 = o4(K2, c5), i3 = j9t(n4, { w: zze, h: zze, viewBox: [-K2, -K2, K2, K2], stroke: l3 ? Oze : -Oze }), rY[r4] = i3, i3 || null;\n            }\n            function $9t(e3, t3, r4) {\n              var n4 = r4.length, i3 = n4 / 2, a4, o4;\n              if (a5.hasLines(t3) && i3) if (t3.line.shape === "hv") {\n                for (a4 = [], o4 = 0; o4 < i3 - 1; o4++) isNaN(r4[o4 * 2]) || isNaN(r4[o4 * 2 + 1]) ? a4.push(NaN, NaN, NaN, NaN) : (a4.push(r4[o4 * 2], r4[o4 * 2 + 1]), !isNaN(r4[o4 * 2 + 2]) && !isNaN(r4[o4 * 2 + 3]) ? a4.push(r4[o4 * 2 + 2], r4[o4 * 2 + 1]) : a4.push(NaN, NaN));\n                a4.push(r4[n4 - 2], r4[n4 - 1]);\n              } else if (t3.line.shape === "hvh") {\n                for (a4 = [], o4 = 0; o4 < i3 - 1; o4++) if (isNaN(r4[o4 * 2]) || isNaN(r4[o4 * 2 + 1]) || isNaN(r4[o4 * 2 + 2]) || isNaN(r4[o4 * 2 + 3])) !isNaN(r4[o4 * 2]) && !isNaN(r4[o4 * 2 + 1]) ? a4.push(r4[o4 * 2], r4[o4 * 2 + 1]) : a4.push(NaN, NaN), a4.push(NaN, NaN);\n                else {\n                  var s3 = (r4[o4 * 2] + r4[o4 * 2 + 2]) / 2;\n                  a4.push(r4[o4 * 2], r4[o4 * 2 + 1], s3, r4[o4 * 2 + 1], s3, r4[o4 * 2 + 3]);\n                }\n                a4.push(r4[n4 - 2], r4[n4 - 1]);\n              } else if (t3.line.shape === "vhv") {\n                for (a4 = [], o4 = 0; o4 < i3 - 1; o4++) if (isNaN(r4[o4 * 2]) || isNaN(r4[o4 * 2 + 1]) || isNaN(r4[o4 * 2 + 2]) || isNaN(r4[o4 * 2 + 3])) !isNaN(r4[o4 * 2]) && !isNaN(r4[o4 * 2 + 1]) ? a4.push(r4[o4 * 2], r4[o4 * 2 + 1]) : a4.push(NaN, NaN), a4.push(NaN, NaN);\n                else {\n                  var l3 = (r4[o4 * 2 + 1] + r4[o4 * 2 + 3]) / 2;\n                  a4.push(r4[o4 * 2], r4[o4 * 2 + 1], r4[o4 * 2], l3, r4[o4 * 2 + 2], l3);\n                }\n                a4.push(r4[n4 - 2], r4[n4 - 1]);\n              } else if (t3.line.shape === "vh") {\n                for (a4 = [], o4 = 0; o4 < i3 - 1; o4++) isNaN(r4[o4 * 2]) || isNaN(r4[o4 * 2 + 1]) ? a4.push(NaN, NaN, NaN, NaN) : (a4.push(r4[o4 * 2], r4[o4 * 2 + 1]), !isNaN(r4[o4 * 2 + 2]) && !isNaN(r4[o4 * 2 + 3]) ? a4.push(r4[o4 * 2], r4[o4 * 2 + 3]) : a4.push(NaN, NaN));\n                a4.push(r4[n4 - 2], r4[n4 - 1]);\n              } else a4 = r4;\n              var u4 = false;\n              for (o4 = 0; o4 < a4.length; o4++) if (isNaN(a4[o4])) {\n                u4 = true;\n                break;\n              }\n              var c5 = u4 || a4.length > hk.TOO_MANY_POINTS || a5.hasMarkers(t3) ? "rect" : "round";\n              if (u4 && t3.connectgaps) {\n                var f4 = a4[0], h3 = a4[1];\n                for (o4 = 0; o4 < a4.length; o4 += 2) isNaN(a4[o4]) || isNaN(a4[o4 + 1]) ? (a4[o4] = f4, a4[o4 + 1] = h3) : (f4 = a4[o4], h3 = a4[o4 + 1]);\n              }\n              return { join: c5, positions: a4 };\n            }\n            function Q9t(e3, t3, r4, n4, i3) {\n              var a4 = W9t.getComponentMethod("errorbars", "makeComputeError"), o4 = Lze.getFromId(e3, t3.xaxis, "x"), s3 = Lze.getFromId(e3, t3.yaxis, "y"), l3 = r4.length / 2, u4 = {};\n              function c5(f4, h3) {\n                var d3 = h3._id.charAt(0), v3 = t3["error_" + d3];\n                if (v3 && v3.visible && (h3.type === "linear" || h3.type === "log")) {\n                  for (var _2 = a4(v3), b = { x: 0, y: 1 }[d3], p3 = { x: [0, 1, 2, 3], y: [2, 3, 0, 1] }[d3], k4 = new Float64Array(4 * l3), E3 = 1 / 0, S2 = -1 / 0, L3 = 0, x2 = 0; L3 < l3; L3++, x2 += 4) {\n                    var C3 = f4[L3];\n                    if (KF(C3)) {\n                      var M4 = r4[L3 * 2 + b], g3 = _2(C3, L3), P3 = g3[0], T3 = g3[1];\n                      if (KF(P3) && KF(T3)) {\n                        var z3 = C3 - P3, O3 = C3 + T3;\n                        k4[x2 + p3[0]] = M4 - h3.c2l(z3), k4[x2 + p3[1]] = h3.c2l(O3) - M4, k4[x2 + p3[2]] = 0, k4[x2 + p3[3]] = 0, E3 = Math.min(E3, C3 - P3), S2 = Math.max(S2, C3 + T3);\n                      }\n                    }\n                  }\n                  u4[d3] = { positions: r4, errors: k4, _bnds: [E3, S2] };\n                }\n              }\n              return c5(n4, o4), c5(i3, s3), u4;\n            }\n            function eOt(e3, t3, r4, n4) {\n              var i3 = t3._length, a4 = {}, o4;\n              if (a5.hasMarkers(t3)) {\n                var s3 = r4.font, l3 = r4.align, u4 = r4.baseline;\n                for (a4.offset = new Array(i3), o4 = 0; o4 < i3; o4++) {\n                  var c5 = n4.sizes ? n4.sizes[o4] : n4.size, f4 = _h(s3) ? s3[o4].size : s3.size, h3 = _h(l3) ? l3.length > 1 ? l3[o4] : l3[0] : l3, d3 = _h(u4) ? u4.length > 1 ? u4[o4] : u4[0] : u4, v3 = Ize[h3], _2 = Ize[d3], b = c5 ? c5 / 0.8 + 1 : 0, p3 = -_2 * b - _2 * 0.5;\n                  a4.offset[o4] = [v3 * b / f4, p3 / f4];\n                }\n              }\n              return a4;\n            }\n            Nze.exports = { style: K9t, markerStyle: aY, markerSelection: nY, linePositions: $9t, errorBarPositions: Q9t, textPosition: eOt };\n          });\n          var oY = ye((lyr, Uze) => {\n            "use strict";\n            var JF = Dr();\n            Uze.exports = function(t3, r4) {\n              var n4 = r4._scene, i3 = { count: 0, dirty: true, lineOptions: [], fillOptions: [], markerOptions: [], markerSelectedOptions: [], markerUnselectedOptions: [], errorXOptions: [], errorYOptions: [], textOptions: [], textSelectedOptions: [], textUnselectedOptions: [], selectBatch: [], unselectBatch: [] }, a4 = { fill2d: false, scatter2d: false, error2d: false, line2d: false, glText: false, select2d: false };\n              return r4._scene || (n4 = r4._scene = {}, n4.init = function() {\n                JF.extendFlat(n4, a4, i3);\n              }, n4.init(), n4.update = function(s3) {\n                var l3 = JF.repeat(s3, n4.count);\n                if (n4.fill2d && n4.fill2d.update(l3), n4.scatter2d && n4.scatter2d.update(l3), n4.line2d && n4.line2d.update(l3), n4.error2d && n4.error2d.update(l3.concat(l3)), n4.select2d && n4.select2d.update(l3), n4.glText) for (var u4 = 0; u4 < n4.count; u4++) n4.glText[u4].update(s3);\n              }, n4.draw = function() {\n                for (var s3 = n4.count, l3 = n4.fill2d, u4 = n4.error2d, c5 = n4.line2d, f4 = n4.scatter2d, h3 = n4.glText, d3 = n4.select2d, v3 = n4.selectBatch, _2 = n4.unselectBatch, b = 0; b < s3; b++) {\n                  if (l3 && n4.fillOrder[b] && l3.draw(n4.fillOrder[b]), c5 && n4.lineOptions[b] && c5.draw(b), u4 && (n4.errorXOptions[b] && u4.draw(b), n4.errorYOptions[b] && u4.draw(b + s3)), f4 && n4.markerOptions[b]) if (_2[b].length) {\n                    var p3 = JF.repeat([], n4.count);\n                    p3[b] = _2[b], f4.draw(p3);\n                  } else v3[b].length || f4.draw(b);\n                  h3[b] && n4.textOptions[b] && h3[b].render();\n                }\n                d3 && d3.draw(v3), n4.dirty = false;\n              }, n4.destroy = function() {\n                n4.fill2d && n4.fill2d.destroy && n4.fill2d.destroy(), n4.scatter2d && n4.scatter2d.destroy && n4.scatter2d.destroy(), n4.error2d && n4.error2d.destroy && n4.error2d.destroy(), n4.line2d && n4.line2d.destroy && n4.line2d.destroy(), n4.select2d && n4.select2d.destroy && n4.select2d.destroy(), n4.glText && n4.glText.forEach(function(s3) {\n                  s3.destroy && s3.destroy();\n                }), n4.lineOptions = null, n4.fillOptions = null, n4.markerOptions = null, n4.markerSelectedOptions = null, n4.markerUnselectedOptions = null, n4.errorXOptions = null, n4.errorYOptions = null, n4.textOptions = null, n4.textSelectedOptions = null, n4.textUnselectedOptions = null, n4.selectBatch = null, n4.unselectBatch = null, r4._scene = null;\n              }), n4.dirty || JF.extendFlat(n4, i3), n4;\n            };\n          });\n          var Xze = ye((uyr, Wze) => {\n            "use strict";\n            var tOt = HF(), s5 = Dr(), Vze = hf(), rOt = Ag().findExtremes, Gze = Dg(), sY = O0(), iOt = sY.calcMarkerSize, nOt = sY.calcAxisExpansion, aOt = sY.setFirstScatter, oOt = F0(), l5 = J2(), sOt = oY(), Hze = fs().BADNUM, lOt = ox().TOO_MANY_POINTS;\n            Wze.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = r4._xA = Vze.getFromId(t3, r4.xaxis, "x"), a4 = r4._yA = Vze.getFromId(t3, r4.yaxis, "y"), o4 = n4._plots[r4.xaxis + r4.yaxis], s3 = r4._length, l3 = s3 >= lOt, u4 = s3 * 2, c5 = {}, f4, h3 = i3.makeCalcdata(r4, "x"), d3 = a4.makeCalcdata(r4, "y"), v3 = Gze(r4, i3, "x", h3), _2 = Gze(r4, a4, "y", d3), b = v3.vals, p3 = _2.vals;\n              r4._x = b, r4._y = p3, r4.xperiodalignment && (r4._origX = h3, r4._xStarts = v3.starts, r4._xEnds = v3.ends), r4.yperiodalignment && (r4._origY = d3, r4._yStarts = _2.starts, r4._yEnds = _2.ends);\n              var k4 = new Array(u4), E3 = new Array(s3);\n              for (f4 = 0; f4 < s3; f4++) k4[f4 * 2] = b[f4] === Hze ? NaN : b[f4], k4[f4 * 2 + 1] = p3[f4] === Hze ? NaN : p3[f4], E3[f4] = f4;\n              if (i3.type === "log") for (f4 = 0; f4 < u4; f4 += 2) k4[f4] = i3.c2l(k4[f4]);\n              if (a4.type === "log") for (f4 = 1; f4 < u4; f4 += 2) k4[f4] = a4.c2l(k4[f4]);\n              l3 && i3.type !== "log" && a4.type !== "log" ? c5.tree = tOt(k4) : c5.ids = E3, oOt(t3, r4);\n              var S2 = uOt(t3, o4, r4, k4, b, p3), L3 = sOt(t3, o4);\n              aOt(n4, r4);\n              var x2;\n              return l3 ? S2.marker && (x2 = S2.marker.sizeAvg || Math.max(S2.marker.size, 3)) : x2 = iOt(r4, s3), nOt(t3, r4, i3, a4, b, p3, x2), S2.errorX && jze(r4, i3, S2.errorX), S2.errorY && jze(r4, a4, S2.errorY), S2.fill && !L3.fill2d && (L3.fill2d = true), S2.marker && !L3.scatter2d && (L3.scatter2d = true), S2.line && !L3.line2d && (L3.line2d = true), (S2.errorX || S2.errorY) && !L3.error2d && (L3.error2d = true), S2.text && !L3.glText && (L3.glText = true), S2.marker && (S2.marker.snap = s3), L3.lineOptions.push(S2.line), L3.errorXOptions.push(S2.errorX), L3.errorYOptions.push(S2.errorY), L3.fillOptions.push(S2.fill), L3.markerOptions.push(S2.marker), L3.markerSelectedOptions.push(S2.markerSel), L3.markerUnselectedOptions.push(S2.markerUnsel), L3.textOptions.push(S2.text), L3.textSelectedOptions.push(S2.textSel), L3.textUnselectedOptions.push(S2.textUnsel), L3.selectBatch.push([]), L3.unselectBatch.push([]), c5._scene = L3, c5.index = L3.count, c5.x = b, c5.y = p3, c5.positions = k4, L3.count++, [{ x: false, y: false, t: c5, trace: r4 }];\n            };\n            function jze(e3, t3, r4) {\n              var n4 = e3._extremes[t3._id], i3 = rOt(t3, r4._bnds, { padded: true });\n              n4.min = n4.min.concat(i3.min), n4.max = n4.max.concat(i3.max);\n            }\n            function uOt(e3, t3, r4, n4, i3, a4) {\n              var o4 = l5.style(e3, r4);\n              if (o4.marker && (o4.marker.positions = n4), o4.line && n4.length > 1 && s5.extendFlat(o4.line, l5.linePositions(e3, r4, n4)), o4.errorX || o4.errorY) {\n                var s3 = l5.errorBarPositions(e3, r4, n4, i3, a4);\n                o4.errorX && s5.extendFlat(o4.errorX, s3.x), o4.errorY && s5.extendFlat(o4.errorY, s3.y);\n              }\n              return o4.text && (s5.extendFlat(o4.text, { positions: n4 }, l5.textPosition(e3, r4, o4.text, o4.marker)), s5.extendFlat(o4.textSel, { positions: n4 }, l5.textPosition(e3, r4, o4.text, o4.markerSel)), s5.extendFlat(o4.textUnsel, { positions: n4 }, l5.textPosition(e3, r4, o4.text, o4.markerUnsel))), o4;\n            }\n          });\n          var lY = ye((cyr, Yze) => {\n            "use strict";\n            var Zze = Dr(), cOt = ka(), fOt = N1().DESELECTDIM;\n            function hOt(e3) {\n              var t3 = e3[0], r4 = t3.trace, n4 = t3.t, i3 = n4._scene, a4 = n4.index, o4 = i3.selectBatch[a4], s3 = i3.unselectBatch[a4], l3 = i3.textOptions[a4], u4 = i3.textSelectedOptions[a4] || {}, c5 = i3.textUnselectedOptions[a4] || {}, f4 = Zze.extendFlat({}, l3), h3, d3;\n              if (o4.length || s3.length) {\n                var v3 = u4.color, _2 = c5.color, b = l3.color, p3 = Zze.isArrayOrTypedArray(b);\n                for (f4.color = new Array(r4._length), h3 = 0; h3 < o4.length; h3++) d3 = o4[h3], f4.color[d3] = v3 || (p3 ? b[d3] : b);\n                for (h3 = 0; h3 < s3.length; h3++) {\n                  d3 = s3[h3];\n                  var k4 = p3 ? b[d3] : b;\n                  f4.color[d3] = _2 || (v3 ? k4 : cOt.addOpacity(k4, fOt));\n                }\n              }\n              i3.glText[a4].update(f4);\n            }\n            Yze.exports = { styleTextSelection: hOt };\n          });\n          var uY = ye((fyr, Jze) => {\n            "use strict";\n            var Kze = Ru(), dOt = lY().styleTextSelection;\n            Jze.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3 = n4[0].trace, l3 = n4[0].t, u4 = s3._length, c5 = l3.x, f4 = l3.y, h3 = l3._scene, d3 = l3.index;\n              if (!h3) return o4;\n              var v3 = Kze.hasText(s3), _2 = Kze.hasMarkers(s3), b = !_2 && !v3;\n              if (s3.visible !== true || b) return o4;\n              var p3 = [], k4 = [];\n              if (r4 !== false && !r4.degenerate) for (var E3 = 0; E3 < u4; E3++) r4.contains([l3.xpx[E3], l3.ypx[E3]], false, E3, t3) ? (p3.push(E3), o4.push({ pointNumber: E3, x: i3.c2d(c5[E3]), y: a4.c2d(f4[E3]) })) : k4.push(E3);\n              if (_2) {\n                var S2 = h3.scatter2d;\n                if (!p3.length && !k4.length) {\n                  var L3 = new Array(h3.count);\n                  L3[d3] = h3.markerOptions[d3], S2.update.apply(S2, L3);\n                } else if (!h3.selectBatch[d3].length && !h3.unselectBatch[d3].length) {\n                  var x2 = new Array(h3.count);\n                  x2[d3] = h3.markerUnselectedOptions[d3], S2.update.apply(S2, x2);\n                }\n              }\n              return h3.selectBatch[d3] = p3, h3.unselectBatch[d3] = k4, v3 && dOt(n4), o4;\n            };\n          });\n          var Qze = ye((hyr, $ze) => {\n            "use strict";\n            var vOt = UF();\n            $ze.exports = { moduleType: "trace", name: "scattergl", basePlotModule: ph(), categories: ["gl", "regl", "cartesian", "symbols", "errorBarsOK", "showLegend", "scatter-like"], attributes: lk(), supplyDefaults: DFe(), crossTraceDefaults: aU(), colorbar: $d(), formatLabels: zFe(), calc: Xze(), hoverPoints: vOt.hoverPoints, selectPoints: uY(), meta: {} };\n          });\n          var t7e = ye((dyr, QF) => {\n            "use strict";\n            var $F = ZE();\n            QF.exports = e7e;\n            QF.exports.to = e7e;\n            QF.exports.from = pOt;\n            function e7e(e3, t3) {\n              t3 == null && (t3 = true);\n              var r4 = e3[0], n4 = e3[1], i3 = e3[2], a4 = e3[3];\n              a4 == null && (a4 = t3 ? 1 : 255), t3 && (r4 *= 255, n4 *= 255, i3 *= 255, a4 *= 255), r4 = $F(r4, 0, 255) & 255, n4 = $F(n4, 0, 255) & 255, i3 = $F(i3, 0, 255) & 255, a4 = $F(a4, 0, 255) & 255;\n              var o4 = r4 * 16777216 + (n4 << 16) + (i3 << 8) + a4;\n              return o4;\n            }\n            function pOt(e3, t3) {\n              e3 = +e3;\n              var r4 = e3 >>> 24, n4 = (e3 & 16711680) >>> 16, i3 = (e3 & 65280) >>> 8, a4 = e3 & 255;\n              return t3 === false ? [r4, n4, i3, a4] : [r4 / 255, n4 / 255, i3 / 255, a4 / 255];\n            }\n          });\n          var Oh = ye((vyr, i7e) => {\n            "use strict";\n            var r7e = Object.getOwnPropertySymbols, gOt = Object.prototype.hasOwnProperty, mOt = Object.prototype.propertyIsEnumerable;\n            function yOt(e3) {\n              if (e3 == null) throw new TypeError("Object.assign cannot be called with null or undefined");\n              return Object(e3);\n            }\n            function _Ot() {\n              try {\n                if (!Object.assign) return false;\n                var e3 = new String("abc");\n                if (e3[5] = "de", Object.getOwnPropertyNames(e3)[0] === "5") return false;\n                for (var t3 = {}, r4 = 0; r4 < 10; r4++) t3["_" + String.fromCharCode(r4)] = r4;\n                var n4 = Object.getOwnPropertyNames(t3).map(function(a4) {\n                  return t3[a4];\n                });\n                if (n4.join("") !== "0123456789") return false;\n                var i3 = {};\n                return "abcdefghijklmnopqrst".split("").forEach(function(a4) {\n                  i3[a4] = a4;\n                }), Object.keys(Object.assign({}, i3)).join("") === "abcdefghijklmnopqrst";\n              } catch (a4) {\n                return false;\n              }\n            }\n            i7e.exports = _Ot() ? Object.assign : function(e3, t3) {\n              for (var r4, n4 = yOt(e3), i3, a4 = 1; a4 < arguments.length; a4++) {\n                r4 = Object(arguments[a4]);\n                for (var o4 in r4) gOt.call(r4, o4) && (n4[o4] = r4[o4]);\n                if (r7e) {\n                  i3 = r7e(r4);\n                  for (var s3 = 0; s3 < i3.length; s3++) mOt.call(r4, i3[s3]) && (n4[i3[s3]] = r4[i3[s3]]);\n                }\n              }\n              return n4;\n            };\n          });\n          var a7e = ye((pyr, n7e) => {\n            n7e.exports = function(e3) {\n              typeof e3 == "string" && (e3 = [e3]);\n              for (var t3 = [].slice.call(arguments, 1), r4 = [], n4 = 0; n4 < e3.length - 1; n4++) r4.push(e3[n4], t3[n4] || "");\n              return r4.push(e3[n4]), r4.join("");\n            };\n          });\n          var cY = ye((gyr, o7e) => {\n            "use strict";\n            o7e.exports = function(t3, r4, n4) {\n              Array.isArray(n4) || (n4 = [].slice.call(arguments, 2));\n              for (var i3 = 0, a4 = n4.length; i3 < a4; i3++) {\n                var o4 = n4[i3];\n                for (var s3 in o4) if (!(r4[s3] !== void 0 && !Array.isArray(r4[s3]) && t3[s3] === r4[s3]) && s3 in r4) {\n                  var l3;\n                  if (o4[s3] === true) l3 = r4[s3];\n                  else {\n                    if (o4[s3] === false) continue;\n                    if (typeof o4[s3] == "function" && (l3 = o4[s3](r4[s3], t3, r4), l3 === void 0)) continue;\n                  }\n                  t3[s3] = l3;\n                }\n              }\n              return t3;\n            };\n          });\n          var l7e = ye((myr, s7e) => {\n            "use strict";\n            s7e.exports = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\\//.test(navigator.appVersion));\n          });\n          var ez = ye((yyr, u5) => {\n            "use strict";\n            u5.exports = dk;\n            u5.exports.float32 = u5.exports.float = dk;\n            u5.exports.fract32 = u5.exports.fract = xOt;\n            var u7e = new Float32Array(1);\n            function xOt(e3, t3) {\n              if (e3.length) {\n                if (e3 instanceof Float32Array) return new Float32Array(e3.length);\n                t3 instanceof Float32Array || (t3 = dk(e3));\n                for (var r4 = 0, n4 = t3.length; r4 < n4; r4++) t3[r4] = e3[r4] - t3[r4];\n                return t3;\n              }\n              return dk(e3 - dk(e3));\n            }\n            function dk(e3) {\n              return e3.length ? e3 instanceof Float32Array ? e3 : new Float32Array(e3) : (u7e[0] = e3, u7e[0]);\n            }\n          });\n          var hY = ye((_yr, h7e) => {\n            "use strict";\n            function bOt(e3, t3) {\n              var r4 = e3 == null ? null : typeof Symbol != "undefined" && e3[Symbol.iterator] || e3["@@iterator"];\n              if (r4 != null) {\n                var n4, i3, a4, o4, s3 = [], l3 = true, u4 = false;\n                try {\n                  if (a4 = (r4 = r4.call(e3)).next, t3 === 0) {\n                    if (Object(r4) !== r4) return;\n                    l3 = false;\n                  } else for (; !(l3 = (n4 = a4.call(r4)).done) && (s3.push(n4.value), s3.length !== t3); l3 = true) ;\n                } catch (c5) {\n                  u4 = true, i3 = c5;\n                } finally {\n                  try {\n                    if (!l3 && r4.return != null && (o4 = r4.return(), Object(o4) !== o4)) return;\n                  } finally {\n                    if (u4) throw i3;\n                  }\n                }\n                return s3;\n              }\n            }\n            function wOt(e3, t3) {\n              return SOt(e3) || bOt(e3, t3) || f7e(e3, t3) || kOt();\n            }\n            function TOt(e3) {\n              return AOt(e3) || MOt(e3) || f7e(e3) || EOt();\n            }\n            function AOt(e3) {\n              if (Array.isArray(e3)) return fY(e3);\n            }\n            function SOt(e3) {\n              if (Array.isArray(e3)) return e3;\n            }\n            function MOt(e3) {\n              if (typeof Symbol != "undefined" && e3[Symbol.iterator] != null || e3["@@iterator"] != null) return Array.from(e3);\n            }\n            function f7e(e3, t3) {\n              if (e3) {\n                if (typeof e3 == "string") return fY(e3, t3);\n                var r4 = Object.prototype.toString.call(e3).slice(8, -1);\n                if (r4 === "Object" && e3.constructor && (r4 = e3.constructor.name), r4 === "Map" || r4 === "Set") return Array.from(e3);\n                if (r4 === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r4)) return fY(e3, t3);\n              }\n            }\n            function fY(e3, t3) {\n              (t3 == null || t3 > e3.length) && (t3 = e3.length);\n              for (var r4 = 0, n4 = new Array(t3); r4 < t3; r4++) n4[r4] = e3[r4];\n              return n4;\n            }\n            function EOt() {\n              throw new TypeError(`Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);\n            }\n            function kOt() {\n              throw new TypeError(`Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);\n            }\n            var COt = J_(), LOt = X2(), POt = t7e(), IOt = HF(), $2 = Oh(), tz = a7e(), ROt = Zm(), DOt = cY(), FOt = Z2(), c7e = l7e(), rz = ez(), zOt = i5(), OOt = nv;\n            function nv(e3, t3) {\n              var r4 = this;\n              if (!(this instanceof nv)) return new nv(e3, t3);\n              typeof e3 == "function" ? (t3 || (t3 = {}), t3.regl = e3) : (t3 = e3, e3 = null), t3 && t3.length && (t3.positions = t3), e3 = t3.regl;\n              var n4 = e3._gl, i3, a4 = [], o4 = {}, s3 = [], l3 = [null], u4 = [null], c5 = 255, f4 = 100;\n              this.tooManyColors = c7e, i3 = e3.texture({ data: new Uint8Array(c5 * 4), width: c5, height: 1, type: "uint8", format: "rgba", wrapS: "clamp", wrapT: "clamp", mag: "nearest", min: "nearest" }), $2(this, { regl: e3, gl: n4, groups: s3, markerCache: u4, markerTextures: l3, palette: a4, paletteIds: o4, paletteTexture: i3, maxColors: c5, maxSize: f4, canvas: n4.canvas }), this.update(t3);\n              var h3 = { uniforms: { constPointSize: !!t3.constPointSize, opacity: e3.prop("opacity"), paletteSize: function(b, p3) {\n                return [r4.tooManyColors ? 0 : c5, i3.height];\n              }, pixelRatio: e3.context("pixelRatio"), scale: e3.prop("scale"), scaleFract: e3.prop("scaleFract"), translate: e3.prop("translate"), translateFract: e3.prop("translateFract"), markerTexture: e3.prop("markerTexture"), paletteTexture: i3 }, attributes: { x: function(b, p3) {\n                return p3.xAttr || { buffer: p3.positionBuffer, stride: 8, offset: 0 };\n              }, y: function(b, p3) {\n                return p3.yAttr || { buffer: p3.positionBuffer, stride: 8, offset: 4 };\n              }, xFract: function(b, p3) {\n                return p3.xAttr ? { constant: [0, 0] } : { buffer: p3.positionFractBuffer, stride: 8, offset: 0 };\n              }, yFract: function(b, p3) {\n                return p3.yAttr ? { constant: [0, 0] } : { buffer: p3.positionFractBuffer, stride: 8, offset: 4 };\n              }, size: function(b, p3) {\n                return p3.size.length ? { buffer: p3.sizeBuffer, stride: 2, offset: 0 } : { constant: [Math.round(p3.size * 255 / r4.maxSize)] };\n              }, borderSize: function(b, p3) {\n                return p3.borderSize.length ? { buffer: p3.sizeBuffer, stride: 2, offset: 1 } : { constant: [Math.round(p3.borderSize * 255 / r4.maxSize)] };\n              }, colorId: function(b, p3) {\n                return p3.color.length ? { buffer: p3.colorBuffer, stride: r4.tooManyColors ? 8 : 4, offset: 0 } : { constant: r4.tooManyColors ? a4.slice(p3.color * 4, p3.color * 4 + 4) : [p3.color] };\n              }, borderColorId: function(b, p3) {\n                return p3.borderColor.length ? { buffer: p3.colorBuffer, stride: r4.tooManyColors ? 8 : 4, offset: r4.tooManyColors ? 4 : 2 } : { constant: r4.tooManyColors ? a4.slice(p3.borderColor * 4, p3.borderColor * 4 + 4) : [p3.borderColor] };\n              }, isActive: function(b, p3) {\n                return p3.activation === true ? { constant: [1] } : p3.activation ? p3.activation : { constant: [0] };\n              } }, blend: { enable: true, color: [0, 0, 0, 1], func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, scissor: { enable: true, box: e3.prop("viewport") }, viewport: e3.prop("viewport"), stencil: { enable: false }, depth: { enable: false }, elements: e3.prop("elements"), count: e3.prop("count"), offset: e3.prop("offset"), primitive: "points" }, d3 = $2({}, h3);\n              d3.frag = tz([`precision highp float;\n#define GLSLIFY 1\n\nuniform float opacity;\nuniform sampler2D markerTexture;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragWidth, fragBorderColorLevel, fragColorLevel;\n\nfloat smoothStep(float x, float y) {\n  return 1.0 / (1.0 + exp(50.0*(x - y)));\n}\n\nvoid main() {\n  float dist = texture2D(markerTexture, gl_PointCoord).r, delta = fragWidth;\n\n  // max-distance alpha\n  if (dist < 0.003) discard;\n\n  // null-border case\n  if (fragBorderColorLevel == fragColorLevel || fragBorderColor.a == 0.) {\n    float colorAmt = smoothstep(.5 - delta, .5 + delta, dist);\n    gl_FragColor = vec4(fragColor.rgb, colorAmt * fragColor.a * opacity);\n  }\n  else {\n    float borderColorAmt = smoothstep(fragBorderColorLevel - delta, fragBorderColorLevel + delta, dist);\n    float colorAmt = smoothstep(fragColorLevel - delta, fragColorLevel + delta, dist);\n\n    vec4 color = fragBorderColor;\n    color.a *= borderColorAmt;\n    color = mix(color, fragColor, colorAmt);\n    color.a *= opacity;\n\n    gl_FragColor = color;\n  }\n\n}\n`]), d3.vert = tz([`precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\n// \\`invariant\\` effectively turns off optimizations for the position.\n// We need this because -fast-math on M1 Macs is re-ordering\n// floating point operations in a way that causes floating point\n// precision limits to put points in the wrong locations.\ninvariant gl_Position;\n\nuniform bool constPointSize;\nuniform float pixelRatio;\nuniform vec2 scale, scaleFract, translate, translateFract, paletteSize;\nuniform sampler2D paletteTexture;\n\nconst float maxSize = 100.;\nconst float borderLevel = .5;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragPointSize, fragBorderRadius, fragWidth, fragBorderColorLevel, fragColorLevel;\n\nfloat pointSizeScale = (constPointSize) ? 2. : pixelRatio;\n\nbool isDirect = (paletteSize.x < 1.);\n\nvec4 getColor(vec4 id) {\n  return isDirect ? id / 255. : texture2D(paletteTexture,\n    vec2(\n      (id.x + .5) / paletteSize.x,\n      (id.y + .5) / paletteSize.y\n    )\n  );\n}\n\nvoid main() {\n  // ignore inactive points\n  if (isActive == 0.) return;\n\n  vec2 position = vec2(x, y);\n  vec2 positionFract = vec2(xFract, yFract);\n\n  vec4 color = getColor(colorId);\n  vec4 borderColor = getColor(borderColorId);\n\n  float size = size * maxSize / 255.;\n  float borderSize = borderSize * maxSize / 255.;\n\n  gl_PointSize = 2. * size * pointSizeScale;\n  fragPointSize = size * pixelRatio;\n\n  vec2 pos = (position + translate) * scale\n      + (positionFract + translateFract) * scale\n      + (position + translate) * scaleFract\n      + (positionFract + translateFract) * scaleFract;\n\n  gl_Position = vec4(pos * 2. - 1., 0., 1.);\n\n  fragColor = color;\n  fragBorderColor = borderColor;\n  fragWidth = 1. / gl_PointSize;\n\n  fragBorderColorLevel = clamp(borderLevel - borderLevel * borderSize / size, 0., 1.);\n  fragColorLevel = clamp(borderLevel + (1. - borderLevel) * borderSize / size, 0., 1.);\n}\n`]), this.drawMarker = e3(d3);\n              var v3 = $2({}, h3);\n              v3.frag = tz([`precision highp float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nuniform float opacity;\n\nfloat smoothStep(float edge0, float edge1, float x) {\n	float t;\n	t = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n	return t * t * (3.0 - 2.0 * t);\n}\n\nvoid main() {\n	float radius, alpha = 1.0, delta = fragWidth;\n\n	radius = length(2.0 * gl_PointCoord.xy - 1.0);\n\n	if (radius > 1.0 + delta) {\n		discard;\n	}\n\n	alpha -= smoothstep(1.0 - delta, 1.0 + delta, radius);\n\n	float borderRadius = fragBorderRadius;\n	float ratio = smoothstep(borderRadius - delta, borderRadius + delta, radius);\n	vec4 color = mix(fragColor, fragBorderColor, ratio);\n	color.a *= alpha * opacity;\n	gl_FragColor = color;\n}\n`]), v3.vert = tz([`precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\n// \\`invariant\\` effectively turns off optimizations for the position.\n// We need this because -fast-math on M1 Macs is re-ordering\n// floating point operations in a way that causes floating point\n// precision limits to put points in the wrong locations.\ninvariant gl_Position;\n\nuniform bool constPointSize;\nuniform float pixelRatio;\nuniform vec2 paletteSize, scale, scaleFract, translate, translateFract;\nuniform sampler2D paletteTexture;\n\nconst float maxSize = 100.;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nfloat pointSizeScale = (constPointSize) ? 2. : pixelRatio;\n\nbool isDirect = (paletteSize.x < 1.);\n\nvec4 getColor(vec4 id) {\n  return isDirect ? id / 255. : texture2D(paletteTexture,\n    vec2(\n      (id.x + .5) / paletteSize.x,\n      (id.y + .5) / paletteSize.y\n    )\n  );\n}\n\nvoid main() {\n  // ignore inactive points\n  if (isActive == 0.) return;\n\n  vec2 position = vec2(x, y);\n  vec2 positionFract = vec2(xFract, yFract);\n\n  vec4 color = getColor(colorId);\n  vec4 borderColor = getColor(borderColorId);\n\n  float size = size * maxSize / 255.;\n  float borderSize = borderSize * maxSize / 255.;\n\n  gl_PointSize = (size + borderSize) * pointSizeScale;\n\n  vec2 pos = (position + translate) * scale\n      + (positionFract + translateFract) * scale\n      + (position + translate) * scaleFract\n      + (positionFract + translateFract) * scaleFract;\n\n  gl_Position = vec4(pos * 2. - 1., 0., 1.);\n\n  fragBorderRadius = 1. - 2. * borderSize / (size + borderSize);\n  fragColor = color;\n  fragBorderColor = borderColor.a == 0. || borderSize == 0. ? vec4(color.rgb, 0.) : borderColor;\n  fragWidth = 1. / gl_PointSize;\n}\n`]), c7e && (v3.frag = v3.frag.replace("smoothstep", "smoothStep"), d3.frag = d3.frag.replace("smoothstep", "smoothStep")), this.drawCircle = e3(v3);\n            }\n            nv.defaults = { color: "black", borderColor: "transparent", borderSize: 0, size: 12, opacity: 1, marker: void 0, viewport: null, range: null, pixelSize: null, count: 0, offset: 0, bounds: null, positions: [], snap: 1e4 };\n            nv.prototype.render = function() {\n              return arguments.length && this.update.apply(this, arguments), this.draw(), this;\n            };\n            nv.prototype.draw = function() {\n              for (var e3 = this, t3 = arguments.length, r4 = new Array(t3), n4 = 0; n4 < t3; n4++) r4[n4] = arguments[n4];\n              var i3 = this.groups;\n              if (r4.length === 1 && Array.isArray(r4[0]) && (r4[0][0] === null || Array.isArray(r4[0][0])) && (r4 = r4[0]), this.regl._refresh(), r4.length) for (var a4 = 0; a4 < r4.length; a4++) this.drawItem(a4, r4[a4]);\n              else i3.forEach(function(o4, s3) {\n                e3.drawItem(s3);\n              });\n              return this;\n            };\n            nv.prototype.drawItem = function(e3, t3) {\n              var r4 = this.groups, n4 = r4[e3];\n              if (typeof t3 == "number" && (e3 = t3, n4 = r4[t3], t3 = null), !!(n4 && n4.count && n4.opacity)) {\n                n4.activation[0] && this.drawCircle(this.getMarkerDrawOptions(0, n4, t3));\n                for (var i3 = [], a4 = 1; a4 < n4.activation.length; a4++) !n4.activation[a4] || n4.activation[a4] !== true && !n4.activation[a4].data.length || i3.push.apply(i3, TOt(this.getMarkerDrawOptions(a4, n4, t3)));\n                i3.length && this.drawMarker(i3);\n              }\n            };\n            nv.prototype.getMarkerDrawOptions = function(e3, t3, r4) {\n              var n4 = t3.range, i3 = t3.tree, a4 = t3.viewport, o4 = t3.activation, s3 = t3.selectionBuffer, l3 = t3.count, u4 = this.regl;\n              if (!i3) return r4 ? [$2({}, t3, { markerTexture: this.markerTextures[e3], activation: o4[e3], count: r4.length, elements: r4, offset: 0 })] : [$2({}, t3, { markerTexture: this.markerTextures[e3], activation: o4[e3], offset: 0 })];\n              var c5 = [], f4 = i3.range(n4, { lod: true, px: [(n4[2] - n4[0]) / a4.width, (n4[3] - n4[1]) / a4.height] });\n              if (r4) {\n                for (var h3 = o4[e3], d3 = h3.data, v3 = new Uint8Array(l3), _2 = 0; _2 < r4.length; _2++) {\n                  var b = r4[_2];\n                  v3[b] = d3 ? d3[b] : 1;\n                }\n                s3.subdata(v3);\n              }\n              for (var p3 = f4.length; p3--; ) {\n                var k4 = wOt(f4[p3], 2), E3 = k4[0], S2 = k4[1];\n                c5.push($2({}, t3, { markerTexture: this.markerTextures[e3], activation: r4 ? s3 : o4[e3], offset: E3, count: S2 - E3 }));\n              }\n              return c5;\n            };\n            nv.prototype.update = function() {\n              for (var e3 = this, t3 = arguments.length, r4 = new Array(t3), n4 = 0; n4 < t3; n4++) r4[n4] = arguments[n4];\n              if (r4.length) {\n                r4.length === 1 && Array.isArray(r4[0]) && (r4 = r4[0]);\n                var i3 = this.groups, a4 = this.gl, o4 = this.regl, s3 = this.maxSize, l3 = this.maxColors, u4 = this.palette;\n                this.groups = i3 = r4.map(function(c5, f4) {\n                  var h3 = i3[f4];\n                  if (c5 === void 0) return h3;\n                  c5 === null ? c5 = { positions: null } : typeof c5 == "function" ? c5 = { ondraw: c5 } : typeof c5[0] == "number" && (c5 = { positions: c5 }), c5 = ROt(c5, { positions: "positions data points", snap: "snap cluster lod tree", size: "sizes size radius", borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline", color: "colors color fill fill-color fillColor", borderColor: "borderColors borderColor stroke stroke-color strokeColor", marker: "markers marker shape", range: "range dataBox databox", viewport: "viewport viewPort viewBox viewbox", opacity: "opacity alpha transparency", bounds: "bound bounds boundaries limits", tooManyColors: "tooManyColors palette paletteMode optimizePalette enablePalette" }), c5.positions === null && (c5.positions = []), c5.tooManyColors != null && (e3.tooManyColors = c5.tooManyColors), h3 || (i3[f4] = h3 = { id: f4, scale: null, translate: null, scaleFract: null, translateFract: null, activation: [], selectionBuffer: o4.buffer({ data: new Uint8Array(0), usage: "stream", type: "uint8" }), sizeBuffer: o4.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "uint8" }), colorBuffer: o4.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "uint8" }), positionBuffer: o4.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "float" }), positionFractBuffer: o4.buffer({ data: new Uint8Array(0), usage: "dynamic", type: "float" }) }, c5 = $2({}, nv.defaults, c5)), c5.positions && !("marker" in c5) && (c5.marker = h3.marker, delete h3.marker), c5.marker && !("positions" in c5) && (c5.positions = h3.positions, delete h3.positions);\n                  var d3 = 0, v3 = 0;\n                  if (DOt(h3, c5, [{ snap: true, size: function(j3, N2) {\n                    return j3 == null && (j3 = nv.defaults.size), d3 += j3 && j3.length ? 1 : 0, j3;\n                  }, borderSize: function(j3, N2) {\n                    return j3 == null && (j3 = nv.defaults.borderSize), d3 += j3 && j3.length ? 1 : 0, j3;\n                  }, opacity: parseFloat, color: function(j3, N2) {\n                    return j3 == null && (j3 = nv.defaults.color), j3 = e3.updateColor(j3), v3++, j3;\n                  }, borderColor: function(j3, N2) {\n                    return j3 == null && (j3 = nv.defaults.borderColor), j3 = e3.updateColor(j3), v3++, j3;\n                  }, bounds: function(j3, N2, H) {\n                    return "range" in H || (H.range = null), j3;\n                  }, positions: function(j3, N2, H) {\n                    var te = N2.snap, oe = N2.positionBuffer, _e = N2.positionFractBuffer, Ee = N2.selectionBuffer;\n                    if (j3.x || j3.y) return j3.x.length ? N2.xAttr = { buffer: o4.buffer(j3.x), offset: 0, stride: 4, count: j3.x.length } : N2.xAttr = { buffer: j3.x.buffer, offset: j3.x.offset * 4 || 0, stride: (j3.x.stride || 1) * 4, count: j3.x.count }, j3.y.length ? N2.yAttr = { buffer: o4.buffer(j3.y), offset: 0, stride: 4, count: j3.y.length } : N2.yAttr = { buffer: j3.y.buffer, offset: j3.y.offset * 4 || 0, stride: (j3.y.stride || 1) * 4, count: j3.y.count }, N2.count = Math.max(N2.xAttr.count, N2.yAttr.count), j3;\n                    j3 = FOt(j3, "float64");\n                    var Ce = N2.count = Math.floor(j3.length / 2), me = N2.bounds = Ce ? LOt(j3, 2) : null;\n                    if (!H.range && !N2.range && (delete N2.range, H.range = me), !H.marker && !N2.marker && (delete N2.marker, H.marker = null), te && (te === true || Ce > te) ? N2.tree = IOt(j3, { bounds: me }) : te && te.length && (N2.tree = te), N2.tree) {\n                      var ie = { primitive: "points", usage: "static", data: N2.tree, type: "uint32" };\n                      N2.elements ? N2.elements(ie) : N2.elements = o4.elements(ie);\n                    }\n                    var Se = rz.float32(j3);\n                    oe({ data: Se, usage: "dynamic" });\n                    var Le = rz.fract32(j3, Se);\n                    return _e({ data: Le, usage: "dynamic" }), Ee({ data: new Uint8Array(Ce), type: "uint8", usage: "stream" }), j3;\n                  } }, { marker: function(j3, N2, H) {\n                    var te = N2.activation;\n                    if (te.forEach(function(Le) {\n                      return Le && Le.destroy && Le.destroy();\n                    }), te.length = 0, !j3 || typeof j3[0] == "number") {\n                      var oe = e3.addMarker(j3);\n                      te[oe] = true;\n                    } else {\n                      for (var _e = [], Ee = 0, Ce = Math.min(j3.length, N2.count); Ee < Ce; Ee++) {\n                        var me = e3.addMarker(j3[Ee]);\n                        _e[me] || (_e[me] = new Uint8Array(N2.count)), _e[me][Ee] = 1;\n                      }\n                      for (var ie = 0; ie < _e.length; ie++) if (_e[ie]) {\n                        var Se = { data: _e[ie], type: "uint8", usage: "static" };\n                        te[ie] ? te[ie](Se) : te[ie] = o4.buffer(Se), te[ie].data = _e[ie];\n                      }\n                    }\n                    return j3;\n                  }, range: function(j3, N2, H) {\n                    var te = N2.bounds;\n                    if (te) return j3 || (j3 = te), N2.scale = [1 / (j3[2] - j3[0]), 1 / (j3[3] - j3[1])], N2.translate = [-j3[0], -j3[1]], N2.scaleFract = rz.fract(N2.scale), N2.translateFract = rz.fract(N2.translate), j3;\n                  }, viewport: function(j3) {\n                    var N2 = zOt(j3 || [a4.drawingBufferWidth, a4.drawingBufferHeight]);\n                    return N2;\n                  } }]), d3) {\n                    var _2 = h3, b = _2.count, p3 = _2.size, k4 = _2.borderSize, E3 = _2.sizeBuffer, S2 = new Uint8Array(b * 2);\n                    if (p3.length || k4.length) for (var L3 = 0; L3 < b; L3++) S2[L3 * 2] = Math.round((p3[L3] == null ? p3 : p3[L3]) * 255 / s3), S2[L3 * 2 + 1] = Math.round((k4[L3] == null ? k4 : k4[L3]) * 255 / s3);\n                    E3({ data: S2, usage: "dynamic" });\n                  }\n                  if (v3) {\n                    var x2 = h3, C3 = x2.count, M4 = x2.color, g3 = x2.borderColor, P3 = x2.colorBuffer, T3;\n                    if (e3.tooManyColors) {\n                      if (M4.length || g3.length) {\n                        T3 = new Uint8Array(C3 * 8);\n                        for (var z3 = 0; z3 < C3; z3++) {\n                          var O3 = M4[z3];\n                          T3[z3 * 8] = u4[O3 * 4], T3[z3 * 8 + 1] = u4[O3 * 4 + 1], T3[z3 * 8 + 2] = u4[O3 * 4 + 2], T3[z3 * 8 + 3] = u4[O3 * 4 + 3];\n                          var V2 = g3[z3];\n                          T3[z3 * 8 + 4] = u4[V2 * 4], T3[z3 * 8 + 5] = u4[V2 * 4 + 1], T3[z3 * 8 + 6] = u4[V2 * 4 + 2], T3[z3 * 8 + 7] = u4[V2 * 4 + 3];\n                        }\n                      }\n                    } else if (M4.length || g3.length) {\n                      T3 = new Uint8Array(C3 * 4 + 2);\n                      for (var G2 = 0; G2 < C3; G2++) M4[G2] != null && (T3[G2 * 4] = M4[G2] % l3, T3[G2 * 4 + 1] = Math.floor(M4[G2] / l3)), g3[G2] != null && (T3[G2 * 4 + 2] = g3[G2] % l3, T3[G2 * 4 + 3] = Math.floor(g3[G2] / l3));\n                    }\n                    P3({ data: T3 || new Uint8Array(0), type: "uint8", usage: "dynamic" });\n                  }\n                  return h3;\n                });\n              }\n            };\n            nv.prototype.addMarker = function(e3) {\n              var t3 = this.markerTextures, r4 = this.regl, n4 = this.markerCache, i3 = e3 == null ? 0 : n4.indexOf(e3);\n              if (i3 >= 0) return i3;\n              var a4;\n              if (e3 instanceof Uint8Array || e3 instanceof Uint8ClampedArray) a4 = e3;\n              else {\n                a4 = new Uint8Array(e3.length);\n                for (var o4 = 0, s3 = e3.length; o4 < s3; o4++) a4[o4] = e3[o4] * 255;\n              }\n              var l3 = Math.floor(Math.sqrt(a4.length));\n              return i3 = t3.length, n4.push(e3), t3.push(r4.texture({ channels: 1, data: a4, radius: l3, mag: "linear", min: "linear" })), i3;\n            };\n            nv.prototype.updateColor = function(e3) {\n              var t3 = this.paletteIds, r4 = this.palette, n4 = this.maxColors;\n              Array.isArray(e3) || (e3 = [e3]);\n              var i3 = [];\n              if (typeof e3[0] == "number") {\n                var a4 = [];\n                if (Array.isArray(e3)) for (var o4 = 0; o4 < e3.length; o4 += 4) a4.push(e3.slice(o4, o4 + 4));\n                else for (var s3 = 0; s3 < e3.length; s3 += 4) a4.push(e3.subarray(s3, s3 + 4));\n                e3 = a4;\n              }\n              for (var l3 = 0; l3 < e3.length; l3++) {\n                var u4 = e3[l3];\n                u4 = COt(u4, "uint8");\n                var c5 = POt(u4, false);\n                if (t3[c5] == null) {\n                  var f4 = r4.length;\n                  t3[c5] = Math.floor(f4 / 4), r4[f4] = u4[0], r4[f4 + 1] = u4[1], r4[f4 + 2] = u4[2], r4[f4 + 3] = u4[3];\n                }\n                i3[l3] = t3[c5];\n              }\n              return !this.tooManyColors && r4.length > n4 * 4 && (this.tooManyColors = true), this.updatePalette(r4), i3.length === 1 ? i3[0] : i3;\n            };\n            nv.prototype.updatePalette = function(e3) {\n              if (!this.tooManyColors) {\n                var t3 = this.maxColors, r4 = this.paletteTexture, n4 = Math.ceil(e3.length * 0.25 / t3);\n                if (n4 > 1) {\n                  e3 = e3.slice();\n                  for (var i3 = e3.length * 0.25 % t3; i3 < n4 * t3; i3++) e3.push(0, 0, 0, 0);\n                }\n                r4.height < n4 && r4.resize(t3, n4), r4.subimage({ width: Math.min(e3.length * 0.25, t3), height: n4, data: e3 }, 0, 0);\n              }\n            };\n            nv.prototype.destroy = function() {\n              return this.groups.forEach(function(e3) {\n                e3.sizeBuffer.destroy(), e3.positionBuffer.destroy(), e3.positionFractBuffer.destroy(), e3.colorBuffer.destroy(), e3.activation.forEach(function(t3) {\n                  return t3 && t3.destroy && t3.destroy();\n                }), e3.selectionBuffer.destroy(), e3.elements && e3.elements.destroy();\n              }), this.groups.length = 0, this.paletteTexture.destroy(), this.markerTextures.forEach(function(e3) {\n                return e3 && e3.destroy && e3.destroy();\n              }), this;\n            };\n            var qOt = Oh(), BOt = function(t3, r4) {\n              var n4 = new OOt(t3, r4), i3 = n4.render.bind(n4);\n              return qOt(i3, { render: i3, update: n4.update.bind(n4), draw: n4.draw.bind(n4), destroy: n4.destroy.bind(n4), regl: n4.regl, gl: n4.gl, canvas: n4.gl.canvas, groups: n4.groups, markers: n4.markerCache, palette: n4.palette }), i3;\n            };\n            h7e.exports = BOt;\n          });\n          var m7e = ye((xyr, gY) => {\n            "use strict";\n            gY.exports = az;\n            gY.exports.default = az;\n            function az(e3, t3, r4) {\n              r4 = r4 || 2;\n              var n4 = t3 && t3.length, i3 = n4 ? t3[0] * r4 : e3.length, a4 = v7e(e3, 0, i3, r4, true), o4 = [];\n              if (!a4 || a4.next === a4.prev) return o4;\n              var s3, l3, u4, c6, f4, h3, d3;\n              if (n4 && (a4 = HOt(e3, t3, a4, r4)), e3.length > 80 * r4) {\n                s3 = u4 = e3[0], l3 = c6 = e3[1];\n                for (var v3 = r4; v3 < i3; v3 += r4) f4 = e3[v3], h3 = e3[v3 + 1], f4 < s3 && (s3 = f4), h3 < l3 && (l3 = h3), f4 > u4 && (u4 = f4), h3 > c6 && (c6 = h3);\n                d3 = Math.max(u4 - s3, c6 - l3), d3 = d3 !== 0 ? 32767 / d3 : 0;\n              }\n              return vk(a4, o4, r4, s3, l3, d3, 0), o4;\n            }\n            function v7e(e3, t3, r4, n4, i3) {\n              var a4, o4;\n              if (i3 === pY(e3, t3, r4, n4) > 0) for (a4 = t3; a4 < r4; a4 += n4) o4 = d7e(a4, e3[a4], e3[a4 + 1], o4);\n              else for (a4 = r4 - n4; a4 >= t3; a4 -= n4) o4 = d7e(a4, e3[a4], e3[a4 + 1], o4);\n              return o4 && oz(o4, o4.next) && (gk(o4), o4 = o4.next), o4;\n            }\n            function Q2(e3, t3) {\n              if (!e3) return e3;\n              t3 || (t3 = e3);\n              var r4 = e3, n4;\n              do\n                if (n4 = false, !r4.steiner && (oz(r4, r4.next) || xh(r4.prev, r4, r4.next) === 0)) {\n                  if (gk(r4), r4 = t3 = r4.prev, r4 === r4.next) break;\n                  n4 = true;\n                } else r4 = r4.next;\n              while (n4 || r4 !== t3);\n              return t3;\n            }\n            function vk(e3, t3, r4, n4, i3, a4, o4) {\n              if (e3) {\n                !o4 && a4 && YOt(e3, n4, i3, a4);\n                for (var s3 = e3, l3, u4; e3.prev !== e3.next; ) {\n                  if (l3 = e3.prev, u4 = e3.next, a4 ? UOt(e3, n4, i3, a4) : NOt(e3)) {\n                    t3.push(l3.i / r4 | 0), t3.push(e3.i / r4 | 0), t3.push(u4.i / r4 | 0), gk(e3), e3 = u4.next, s3 = u4.next;\n                    continue;\n                  }\n                  if (e3 = u4, e3 === s3) {\n                    o4 ? o4 === 1 ? (e3 = VOt(Q2(e3), t3, r4), vk(e3, t3, r4, n4, i3, a4, 2)) : o4 === 2 && GOt(e3, t3, r4, n4, i3, a4) : vk(Q2(e3), t3, r4, n4, i3, a4, 1);\n                    break;\n                  }\n                }\n              }\n            }\n            function NOt(e3) {\n              var t3 = e3.prev, r4 = e3, n4 = e3.next;\n              if (xh(t3, r4, n4) >= 0) return false;\n              for (var i3 = t3.x, a4 = r4.x, o4 = n4.x, s3 = t3.y, l3 = r4.y, u4 = n4.y, c6 = i3 < a4 ? i3 < o4 ? i3 : o4 : a4 < o4 ? a4 : o4, f4 = s3 < l3 ? s3 < u4 ? s3 : u4 : l3 < u4 ? l3 : u4, h3 = i3 > a4 ? i3 > o4 ? i3 : o4 : a4 > o4 ? a4 : o4, d3 = s3 > l3 ? s3 > u4 ? s3 : u4 : l3 > u4 ? l3 : u4, v3 = n4.next; v3 !== t3; ) {\n                if (v3.x >= c6 && v3.x <= h3 && v3.y >= f4 && v3.y <= d3 && c5(i3, s3, a4, l3, o4, u4, v3.x, v3.y) && xh(v3.prev, v3, v3.next) >= 0) return false;\n                v3 = v3.next;\n              }\n              return true;\n            }\n            function UOt(e3, t3, r4, n4) {\n              var i3 = e3.prev, a4 = e3, o4 = e3.next;\n              if (xh(i3, a4, o4) >= 0) return false;\n              for (var s3 = i3.x, l3 = a4.x, u4 = o4.x, c6 = i3.y, f4 = a4.y, h3 = o4.y, d3 = s3 < l3 ? s3 < u4 ? s3 : u4 : l3 < u4 ? l3 : u4, v3 = c6 < f4 ? c6 < h3 ? c6 : h3 : f4 < h3 ? f4 : h3, _2 = s3 > l3 ? s3 > u4 ? s3 : u4 : l3 > u4 ? l3 : u4, b = c6 > f4 ? c6 > h3 ? c6 : h3 : f4 > h3 ? f4 : h3, p3 = dY(d3, v3, t3, r4, n4), k4 = dY(_2, b, t3, r4, n4), E3 = e3.prevZ, S2 = e3.nextZ; E3 && E3.z >= p3 && S2 && S2.z <= k4; ) {\n                if (E3.x >= d3 && E3.x <= _2 && E3.y >= v3 && E3.y <= b && E3 !== i3 && E3 !== o4 && c5(s3, c6, l3, f4, u4, h3, E3.x, E3.y) && xh(E3.prev, E3, E3.next) >= 0 || (E3 = E3.prevZ, S2.x >= d3 && S2.x <= _2 && S2.y >= v3 && S2.y <= b && S2 !== i3 && S2 !== o4 && c5(s3, c6, l3, f4, u4, h3, S2.x, S2.y) && xh(S2.prev, S2, S2.next) >= 0)) return false;\n                S2 = S2.nextZ;\n              }\n              for (; E3 && E3.z >= p3; ) {\n                if (E3.x >= d3 && E3.x <= _2 && E3.y >= v3 && E3.y <= b && E3 !== i3 && E3 !== o4 && c5(s3, c6, l3, f4, u4, h3, E3.x, E3.y) && xh(E3.prev, E3, E3.next) >= 0) return false;\n                E3 = E3.prevZ;\n              }\n              for (; S2 && S2.z <= k4; ) {\n                if (S2.x >= d3 && S2.x <= _2 && S2.y >= v3 && S2.y <= b && S2 !== i3 && S2 !== o4 && c5(s3, c6, l3, f4, u4, h3, S2.x, S2.y) && xh(S2.prev, S2, S2.next) >= 0) return false;\n                S2 = S2.nextZ;\n              }\n              return true;\n            }\n            function VOt(e3, t3, r4) {\n              var n4 = e3;\n              do {\n                var i3 = n4.prev, a4 = n4.next.next;\n                !oz(i3, a4) && p7e(i3, n4, n4.next, a4) && pk(i3, a4) && pk(a4, i3) && (t3.push(i3.i / r4 | 0), t3.push(n4.i / r4 | 0), t3.push(a4.i / r4 | 0), gk(n4), gk(n4.next), n4 = e3 = a4), n4 = n4.next;\n              } while (n4 !== e3);\n              return Q2(n4);\n            }\n            function GOt(e3, t3, r4, n4, i3, a4) {\n              var o4 = e3;\n              do {\n                for (var s3 = o4.next.next; s3 !== o4.prev; ) {\n                  if (o4.i !== s3.i && $Ot(o4, s3)) {\n                    var l3 = g7e(o4, s3);\n                    o4 = Q2(o4, o4.next), l3 = Q2(l3, l3.next), vk(o4, t3, r4, n4, i3, a4, 0), vk(l3, t3, r4, n4, i3, a4, 0);\n                    return;\n                  }\n                  s3 = s3.next;\n                }\n                o4 = o4.next;\n              } while (o4 !== e3);\n            }\n            function HOt(e3, t3, r4, n4) {\n              var i3 = [], a4, o4, s3, l3, u4;\n              for (a4 = 0, o4 = t3.length; a4 < o4; a4++) s3 = t3[a4] * n4, l3 = a4 < o4 - 1 ? t3[a4 + 1] * n4 : e3.length, u4 = v7e(e3, s3, l3, n4, false), u4 === u4.next && (u4.steiner = true), i3.push(JOt(u4));\n              for (i3.sort(jOt), a4 = 0; a4 < i3.length; a4++) r4 = WOt(i3[a4], r4);\n              return r4;\n            }\n            function jOt(e3, t3) {\n              return e3.x - t3.x;\n            }\n            function WOt(e3, t3) {\n              var r4 = XOt(e3, t3);\n              if (!r4) return t3;\n              var n4 = g7e(r4, e3);\n              return Q2(n4, n4.next), Q2(r4, r4.next);\n            }\n            function XOt(e3, t3) {\n              var r4 = t3, n4 = e3.x, i3 = e3.y, a4 = -1 / 0, o4;\n              do {\n                if (i3 <= r4.y && i3 >= r4.next.y && r4.next.y !== r4.y) {\n                  var s3 = r4.x + (i3 - r4.y) * (r4.next.x - r4.x) / (r4.next.y - r4.y);\n                  if (s3 <= n4 && s3 > a4 && (a4 = s3, o4 = r4.x < r4.next.x ? r4 : r4.next, s3 === n4)) return o4;\n                }\n                r4 = r4.next;\n              } while (r4 !== t3);\n              if (!o4) return null;\n              var l3 = o4, u4 = o4.x, c6 = o4.y, f4 = 1 / 0, h3;\n              r4 = o4;\n              do\n                n4 >= r4.x && r4.x >= u4 && n4 !== r4.x && c5(i3 < c6 ? n4 : a4, i3, u4, c6, i3 < c6 ? a4 : n4, i3, r4.x, r4.y) && (h3 = Math.abs(i3 - r4.y) / (n4 - r4.x), pk(r4, e3) && (h3 < f4 || h3 === f4 && (r4.x > o4.x || r4.x === o4.x && ZOt(o4, r4))) && (o4 = r4, f4 = h3)), r4 = r4.next;\n              while (r4 !== l3);\n              return o4;\n            }\n            function ZOt(e3, t3) {\n              return xh(e3.prev, e3, t3.prev) < 0 && xh(t3.next, e3, e3.next) < 0;\n            }\n            function YOt(e3, t3, r4, n4) {\n              var i3 = e3;\n              do\n                i3.z === 0 && (i3.z = dY(i3.x, i3.y, t3, r4, n4)), i3.prevZ = i3.prev, i3.nextZ = i3.next, i3 = i3.next;\n              while (i3 !== e3);\n              i3.prevZ.nextZ = null, i3.prevZ = null, KOt(i3);\n            }\n            function KOt(e3) {\n              var t3, r4, n4, i3, a4, o4, s3, l3, u4 = 1;\n              do {\n                for (r4 = e3, e3 = null, a4 = null, o4 = 0; r4; ) {\n                  for (o4++, n4 = r4, s3 = 0, t3 = 0; t3 < u4 && (s3++, n4 = n4.nextZ, !!n4); t3++) ;\n                  for (l3 = u4; s3 > 0 || l3 > 0 && n4; ) s3 !== 0 && (l3 === 0 || !n4 || r4.z <= n4.z) ? (i3 = r4, r4 = r4.nextZ, s3--) : (i3 = n4, n4 = n4.nextZ, l3--), a4 ? a4.nextZ = i3 : e3 = i3, i3.prevZ = a4, a4 = i3;\n                  r4 = n4;\n                }\n                a4.nextZ = null, u4 *= 2;\n              } while (o4 > 1);\n              return e3;\n            }\n            function dY(e3, t3, r4, n4, i3) {\n              return e3 = (e3 - r4) * i3 | 0, t3 = (t3 - n4) * i3 | 0, e3 = (e3 | e3 << 8) & 16711935, e3 = (e3 | e3 << 4) & 252645135, e3 = (e3 | e3 << 2) & 858993459, e3 = (e3 | e3 << 1) & 1431655765, t3 = (t3 | t3 << 8) & 16711935, t3 = (t3 | t3 << 4) & 252645135, t3 = (t3 | t3 << 2) & 858993459, t3 = (t3 | t3 << 1) & 1431655765, e3 | t3 << 1;\n            }\n            function JOt(e3) {\n              var t3 = e3, r4 = e3;\n              do\n                (t3.x < r4.x || t3.x === r4.x && t3.y < r4.y) && (r4 = t3), t3 = t3.next;\n              while (t3 !== e3);\n              return r4;\n            }\n            function c5(e3, t3, r4, n4, i3, a4, o4, s3) {\n              return (i3 - o4) * (t3 - s3) >= (e3 - o4) * (a4 - s3) && (e3 - o4) * (n4 - s3) >= (r4 - o4) * (t3 - s3) && (r4 - o4) * (a4 - s3) >= (i3 - o4) * (n4 - s3);\n            }\n            function $Ot(e3, t3) {\n              return e3.next.i !== t3.i && e3.prev.i !== t3.i && !QOt(e3, t3) && (pk(e3, t3) && pk(t3, e3) && eqt(e3, t3) && (xh(e3.prev, e3, t3.prev) || xh(e3, t3.prev, t3)) || oz(e3, t3) && xh(e3.prev, e3, e3.next) > 0 && xh(t3.prev, t3, t3.next) > 0);\n            }\n            function xh(e3, t3, r4) {\n              return (t3.y - e3.y) * (r4.x - t3.x) - (t3.x - e3.x) * (r4.y - t3.y);\n            }\n            function oz(e3, t3) {\n              return e3.x === t3.x && e3.y === t3.y;\n            }\n            function p7e(e3, t3, r4, n4) {\n              var i3 = nz(xh(e3, t3, r4)), a4 = nz(xh(e3, t3, n4)), o4 = nz(xh(r4, n4, e3)), s3 = nz(xh(r4, n4, t3));\n              return !!(i3 !== a4 && o4 !== s3 || i3 === 0 && iz(e3, r4, t3) || a4 === 0 && iz(e3, n4, t3) || o4 === 0 && iz(r4, e3, n4) || s3 === 0 && iz(r4, t3, n4));\n            }\n            function iz(e3, t3, r4) {\n              return t3.x <= Math.max(e3.x, r4.x) && t3.x >= Math.min(e3.x, r4.x) && t3.y <= Math.max(e3.y, r4.y) && t3.y >= Math.min(e3.y, r4.y);\n            }\n            function nz(e3) {\n              return e3 > 0 ? 1 : e3 < 0 ? -1 : 0;\n            }\n            function QOt(e3, t3) {\n              var r4 = e3;\n              do {\n                if (r4.i !== e3.i && r4.next.i !== e3.i && r4.i !== t3.i && r4.next.i !== t3.i && p7e(r4, r4.next, e3, t3)) return true;\n                r4 = r4.next;\n              } while (r4 !== e3);\n              return false;\n            }\n            function pk(e3, t3) {\n              return xh(e3.prev, e3, e3.next) < 0 ? xh(e3, t3, e3.next) >= 0 && xh(e3, e3.prev, t3) >= 0 : xh(e3, t3, e3.prev) < 0 || xh(e3, e3.next, t3) < 0;\n            }\n            function eqt(e3, t3) {\n              var r4 = e3, n4 = false, i3 = (e3.x + t3.x) / 2, a4 = (e3.y + t3.y) / 2;\n              do\n                r4.y > a4 != r4.next.y > a4 && r4.next.y !== r4.y && i3 < (r4.next.x - r4.x) * (a4 - r4.y) / (r4.next.y - r4.y) + r4.x && (n4 = !n4), r4 = r4.next;\n              while (r4 !== e3);\n              return n4;\n            }\n            function g7e(e3, t3) {\n              var r4 = new vY(e3.i, e3.x, e3.y), n4 = new vY(t3.i, t3.x, t3.y), i3 = e3.next, a4 = t3.prev;\n              return e3.next = t3, t3.prev = e3, r4.next = i3, i3.prev = r4, n4.next = r4, r4.prev = n4, a4.next = n4, n4.prev = a4, n4;\n            }\n            function d7e(e3, t3, r4, n4) {\n              var i3 = new vY(e3, t3, r4);\n              return n4 ? (i3.next = n4.next, i3.prev = n4, n4.next.prev = i3, n4.next = i3) : (i3.prev = i3, i3.next = i3), i3;\n            }\n            function gk(e3) {\n              e3.next.prev = e3.prev, e3.prev.next = e3.next, e3.prevZ && (e3.prevZ.nextZ = e3.nextZ), e3.nextZ && (e3.nextZ.prevZ = e3.prevZ);\n            }\n            function vY(e3, t3, r4) {\n              this.i = e3, this.x = t3, this.y = r4, this.prev = null, this.next = null, this.z = 0, this.prevZ = null, this.nextZ = null, this.steiner = false;\n            }\n            az.deviation = function(e3, t3, r4, n4) {\n              var i3 = t3 && t3.length, a4 = i3 ? t3[0] * r4 : e3.length, o4 = Math.abs(pY(e3, 0, a4, r4));\n              if (i3) for (var s3 = 0, l3 = t3.length; s3 < l3; s3++) {\n                var u4 = t3[s3] * r4, c6 = s3 < l3 - 1 ? t3[s3 + 1] * r4 : e3.length;\n                o4 -= Math.abs(pY(e3, u4, c6, r4));\n              }\n              var f4 = 0;\n              for (s3 = 0; s3 < n4.length; s3 += 3) {\n                var h3 = n4[s3] * r4, d3 = n4[s3 + 1] * r4, v3 = n4[s3 + 2] * r4;\n                f4 += Math.abs((e3[h3] - e3[v3]) * (e3[d3 + 1] - e3[h3 + 1]) - (e3[h3] - e3[d3]) * (e3[v3 + 1] - e3[h3 + 1]));\n              }\n              return o4 === 0 && f4 === 0 ? 0 : Math.abs((f4 - o4) / o4);\n            };\n            function pY(e3, t3, r4, n4) {\n              for (var i3 = 0, a4 = t3, o4 = r4 - n4; a4 < r4; a4 += n4) i3 += (e3[o4] - e3[a4]) * (e3[a4 + 1] + e3[o4 + 1]), o4 = a4;\n              return i3;\n            }\n            az.flatten = function(e3) {\n              for (var t3 = e3[0][0].length, r4 = { vertices: [], holes: [], dimensions: t3 }, n4 = 0, i3 = 0; i3 < e3.length; i3++) {\n                for (var a4 = 0; a4 < e3[i3].length; a4++) for (var o4 = 0; o4 < t3; o4++) r4.vertices.push(e3[i3][a4][o4]);\n                i3 > 0 && (n4 += e3[i3 - 1].length, r4.holes.push(n4));\n              }\n              return r4;\n            };\n          });\n          var _7e = ye((byr, y7e) => {\n            "use strict";\n            var tqt = X2();\n            y7e.exports = rqt;\n            function rqt(e3, t3, r4) {\n              if (!e3 || e3.length == null) throw Error("Argument should be an array");\n              t3 == null && (t3 = 1), r4 == null && (r4 = tqt(e3, t3));\n              for (var n4 = 0; n4 < t3; n4++) {\n                var i3 = r4[t3 + n4], a4 = r4[n4], o4 = n4, s3 = e3.length;\n                if (i3 === 1 / 0 && a4 === -1 / 0) for (o4 = n4; o4 < s3; o4 += t3) e3[o4] = e3[o4] === i3 ? 1 : e3[o4] === a4 ? 0 : 0.5;\n                else if (i3 === 1 / 0) for (o4 = n4; o4 < s3; o4 += t3) e3[o4] = e3[o4] === i3 ? 1 : 0;\n                else if (a4 === -1 / 0) for (o4 = n4; o4 < s3; o4 += t3) e3[o4] = e3[o4] === a4 ? 0 : 1;\n                else {\n                  var l3 = i3 - a4;\n                  for (o4 = n4; o4 < s3; o4 += t3) isNaN(e3[o4]) || (e3[o4] = l3 === 0 ? 0.5 : (e3[o4] - a4) / l3);\n                }\n              }\n              return e3;\n            }\n          });\n          var b7e = ye((wyr, x7e) => {\n            "use strict";\n            x7e.exports = function() {\n              var e3, t3;\n              if (typeof WeakMap != "function") return false;\n              try {\n                e3 = new WeakMap([[t3 = {}, "one"], [{}, "two"], [{}, "three"]]);\n              } catch (r4) {\n                return false;\n              }\n              return !(String(e3) !== "[object WeakMap]" || typeof e3.set != "function" || e3.set({}, 1) !== e3 || typeof e3.delete != "function" || typeof e3.has != "function" || e3.get(t3) !== "one");\n            };\n          });\n          var T7e = ye((Tyr, w7e) => {\n            "use strict";\n            w7e.exports = function() {\n            };\n          });\n          var lx = ye((Ayr, A7e) => {\n            "use strict";\n            var iqt = T7e()();\n            A7e.exports = function(e3) {\n              return e3 !== iqt && e3 !== null;\n            };\n          });\n          var mY = ye((Syr, M7e) => {\n            "use strict";\n            var nqt = Object.create, aqt = Object.getPrototypeOf, S7e = {};\n            M7e.exports = function() {\n              var e3 = Object.setPrototypeOf, t3 = arguments[0] || nqt;\n              return typeof e3 != "function" ? false : aqt(e3(t3(null), S7e)) === S7e;\n            };\n          });\n          var yY = ye((Myr, E7e) => {\n            "use strict";\n            var oqt = lx(), sqt = { function: true, object: true };\n            E7e.exports = function(e3) {\n              return oqt(e3) && sqt[typeof e3] || false;\n            };\n          });\n          var i1 = ye((Eyr, k7e) => {\n            "use strict";\n            var lqt = lx();\n            k7e.exports = function(e3) {\n              if (!lqt(e3)) throw new TypeError("Cannot use null or undefined");\n              return e3;\n            };\n          });\n          var L7e = ye((kyr, C7e) => {\n            "use strict";\n            var _Y = Object.create, sz;\n            mY()() || (sz = xY());\n            C7e.exports = (function() {\n              var e3, t3, r4;\n              return !sz || sz.level !== 1 ? _Y : (e3 = {}, t3 = {}, r4 = { configurable: false, enumerable: false, writable: true, value: void 0 }, Object.getOwnPropertyNames(Object.prototype).forEach(function(n4) {\n                if (n4 === "__proto__") {\n                  t3[n4] = { configurable: true, enumerable: false, writable: true, value: void 0 };\n                  return;\n                }\n                t3[n4] = r4;\n              }), Object.defineProperties(e3, t3), Object.defineProperty(sz, "nullPolyfill", { configurable: false, enumerable: false, writable: false, value: e3 }), function(n4, i3) {\n                return _Y(n4 === null ? e3 : n4, i3);\n              });\n            })();\n          });\n          var xY = ye((Cyr, P7e) => {\n            "use strict";\n            var uqt = yY(), cqt = i1(), fqt = Object.prototype.isPrototypeOf, hqt = Object.defineProperty, dqt = { configurable: true, enumerable: false, writable: true, value: void 0 }, lz;\n            lz = function(e3, t3) {\n              if (cqt(e3), t3 === null || uqt(t3)) return e3;\n              throw new TypeError("Prototype must be null or an object");\n            };\n            P7e.exports = (function(e3) {\n              var t3, r4;\n              return e3 ? (e3.level === 2 ? e3.set ? (r4 = e3.set, t3 = function(n4, i3) {\n                return r4.call(lz(n4, i3), i3), n4;\n              }) : t3 = function(n4, i3) {\n                return lz(n4, i3).__proto__ = i3, n4;\n              } : t3 = function n4(i3, a4) {\n                var o4;\n                return lz(i3, a4), o4 = fqt.call(n4.nullPolyfill, i3), o4 && delete n4.nullPolyfill.__proto__, a4 === null && (a4 = n4.nullPolyfill), i3.__proto__ = a4, o4 && hqt(n4.nullPolyfill, "__proto__", dqt), i3;\n              }, Object.defineProperty(t3, "level", { configurable: false, enumerable: false, writable: false, value: e3.level })) : null;\n            })((function() {\n              var e3 = /* @__PURE__ */ Object.create(null), t3 = {}, r4, n4 = Object.getOwnPropertyDescriptor(Object.prototype, "__proto__");\n              if (n4) {\n                try {\n                  r4 = n4.set, r4.call(e3, t3);\n                } catch (i3) {\n                }\n                if (Object.getPrototypeOf(e3) === t3) return { set: r4, level: 2 };\n              }\n              return e3.__proto__ = t3, Object.getPrototypeOf(e3) === t3 ? { level: 2 } : (e3 = {}, e3.__proto__ = t3, Object.getPrototypeOf(e3) === t3 ? { level: 1 } : false);\n            })());\n            L7e();\n          });\n          var uz = ye((Lyr, I7e) => {\n            "use strict";\n            I7e.exports = mY()() ? Object.setPrototypeOf : xY();\n          });\n          var D7e = ye((Pyr, R7e) => {\n            "use strict";\n            var vqt = yY();\n            R7e.exports = function(e3) {\n              if (!vqt(e3)) throw new TypeError(e3 + " is not an Object");\n              return e3;\n            };\n          });\n          var z7e = ye((Iyr, F7e) => {\n            "use strict";\n            var pqt = /* @__PURE__ */ Object.create(null), gqt = Math.random;\n            F7e.exports = function() {\n              var e3;\n              do\n                e3 = gqt().toString(36).slice(2);\n              while (pqt[e3]);\n              return e3;\n            };\n          });\n          var ew = ye((Ryr, O7e) => {\n            "use strict";\n            var mqt = void 0;\n            O7e.exports = function(e3) {\n              return e3 !== mqt && e3 !== null;\n            };\n          });\n          var cz = ye((Dyr, q7e) => {\n            "use strict";\n            var yqt = ew(), _qt = { object: true, function: true, undefined: true };\n            q7e.exports = function(e3) {\n              return yqt(e3) ? hasOwnProperty.call(_qt, typeof e3) : false;\n            };\n          });\n          var N7e = ye((Fyr, B7e) => {\n            "use strict";\n            var xqt = cz();\n            B7e.exports = function(e3) {\n              if (!xqt(e3)) return false;\n              try {\n                return e3.constructor ? e3.constructor.prototype === e3 : false;\n              } catch (t3) {\n                return false;\n              }\n            };\n          });\n          var V7e = ye((zyr, U7e) => {\n            "use strict";\n            var bqt = N7e();\n            U7e.exports = function(e3) {\n              if (typeof e3 != "function" || !hasOwnProperty.call(e3, "length")) return false;\n              try {\n                if (typeof e3.length != "number" || typeof e3.call != "function" || typeof e3.apply != "function") return false;\n              } catch (t3) {\n                return false;\n              }\n              return !bqt(e3);\n            };\n          });\n          var bY = ye((Oyr, G7e) => {\n            "use strict";\n            var wqt = V7e(), Tqt = /^\\s*class[\\s{/}]/, Aqt = Function.prototype.toString;\n            G7e.exports = function(e3) {\n              return !(!wqt(e3) || Tqt.test(Aqt.call(e3)));\n            };\n          });\n          var j7e = ye((qyr, H7e) => {\n            "use strict";\n            H7e.exports = function() {\n              var e3 = Object.assign, t3;\n              return typeof e3 != "function" ? false : (t3 = { foo: "raz" }, e3(t3, { bar: "dwa" }, { trzy: "trzy" }), t3.foo + t3.bar + t3.trzy === "razdwatrzy");\n            };\n          });\n          var X7e = ye((Byr, W7e) => {\n            "use strict";\n            W7e.exports = function() {\n              try {\n                return Object.keys("primitive"), true;\n              } catch (e3) {\n                return false;\n              }\n            };\n          });\n          var Y7e = ye((Nyr, Z7e) => {\n            "use strict";\n            var Sqt = lx(), Mqt = Object.keys;\n            Z7e.exports = function(e3) {\n              return Mqt(Sqt(e3) ? Object(e3) : e3);\n            };\n          });\n          var J7e = ye((Uyr, K7e) => {\n            "use strict";\n            K7e.exports = X7e()() ? Object.keys : Y7e();\n          });\n          var Q7e = ye((Vyr, $7e) => {\n            "use strict";\n            var Eqt = J7e(), kqt = i1(), Cqt = Math.max;\n            $7e.exports = function(e3, t3) {\n              var r4, n4, i3 = Cqt(arguments.length, 2), a4;\n              for (e3 = Object(kqt(e3)), a4 = function(o4) {\n                try {\n                  e3[o4] = t3[o4];\n                } catch (s3) {\n                  r4 || (r4 = s3);\n                }\n              }, n4 = 1; n4 < i3; ++n4) t3 = arguments[n4], Eqt(t3).forEach(a4);\n              if (r4 !== void 0) throw r4;\n              return e3;\n            };\n          });\n          var fz = ye((Gyr, e9e) => {\n            "use strict";\n            e9e.exports = j7e()() ? Object.assign : Q7e();\n          });\n          var wY = ye((Hyr, t9e) => {\n            "use strict";\n            var Lqt = lx(), Pqt = Array.prototype.forEach, Iqt = Object.create, Rqt = function(e3, t3) {\n              var r4;\n              for (r4 in e3) t3[r4] = e3[r4];\n            };\n            t9e.exports = function(e3) {\n              var t3 = Iqt(null);\n              return Pqt.call(arguments, function(r4) {\n                Lqt(r4) && Rqt(Object(r4), t3);\n              }), t3;\n            };\n          });\n          var i9e = ye((jyr, r9e) => {\n            "use strict";\n            var TY = "razdwatrzy";\n            r9e.exports = function() {\n              return typeof TY.contains != "function" ? false : TY.contains("dwa") === true && TY.contains("foo") === false;\n            };\n          });\n          var a9e = ye((Wyr, n9e) => {\n            "use strict";\n            var Dqt = String.prototype.indexOf;\n            n9e.exports = function(e3) {\n              return Dqt.call(this, e3, arguments[1]) > -1;\n            };\n          });\n          var AY = ye((Xyr, o9e) => {\n            "use strict";\n            o9e.exports = i9e()() ? String.prototype.contains : a9e();\n          });\n          var n1 = ye((Zyr, c9e) => {\n            "use strict";\n            var hz = ew(), s9e = bY(), l9e = fz(), u9e = wY(), mk = AY(), Fqt = c9e.exports = function(e3, t3) {\n              var r4, n4, i3, a4, o4;\n              return arguments.length < 2 || typeof e3 != "string" ? (a4 = t3, t3 = e3, e3 = null) : a4 = arguments[2], hz(e3) ? (r4 = mk.call(e3, "c"), n4 = mk.call(e3, "e"), i3 = mk.call(e3, "w")) : (r4 = i3 = true, n4 = false), o4 = { value: t3, configurable: r4, enumerable: n4, writable: i3 }, a4 ? l9e(u9e(a4), o4) : o4;\n            };\n            Fqt.gs = function(e3, t3, r4) {\n              var n4, i3, a4, o4;\n              return typeof e3 != "string" ? (a4 = r4, r4 = t3, t3 = e3, e3 = null) : a4 = arguments[3], hz(t3) ? s9e(t3) ? hz(r4) ? s9e(r4) || (a4 = r4, r4 = void 0) : r4 = void 0 : (a4 = t3, t3 = r4 = void 0) : t3 = void 0, hz(e3) ? (n4 = mk.call(e3, "c"), i3 = mk.call(e3, "e")) : (n4 = true, i3 = false), o4 = { get: t3, set: r4, configurable: n4, enumerable: i3 }, a4 ? l9e(u9e(a4), o4) : o4;\n            };\n          });\n          var yk = ye((Yyr, h9e) => {\n            "use strict";\n            var f9e = Object.prototype.toString, zqt = f9e.call(/* @__PURE__ */ (function() {\n              return arguments;\n            })());\n            h9e.exports = function(e3) {\n              return f9e.call(e3) === zqt;\n            };\n          });\n          var _k = ye((Kyr, v9e) => {\n            "use strict";\n            var d9e = Object.prototype.toString, Oqt = d9e.call("");\n            v9e.exports = function(e3) {\n              return typeof e3 == "string" || e3 && typeof e3 == "object" && (e3 instanceof String || d9e.call(e3) === Oqt) || false;\n            };\n          });\n          var g9e = ye((Jyr, p9e) => {\n            "use strict";\n            p9e.exports = function() {\n              return typeof globalThis != "object" || !globalThis ? false : globalThis.Array === Array;\n            };\n          });\n          var _9e = ye(($yr, y9e) => {\n            var m9e = function() {\n              if (typeof self == "object" && self) return self;\n              if (typeof window == "object" && window) return window;\n              throw new Error("Unable to resolve global `this`");\n            };\n            y9e.exports = (function() {\n              if (this) return this;\n              try {\n                Object.defineProperty(Object.prototype, "__global__", { get: function() {\n                  return this;\n                }, configurable: true });\n              } catch (e3) {\n                return m9e();\n              }\n              try {\n                return __global__ || m9e();\n              } finally {\n                delete Object.prototype.__global__;\n              }\n            })();\n          });\n          var xk = ye((Qyr, x9e) => {\n            "use strict";\n            x9e.exports = g9e()() ? globalThis : _9e();\n          });\n          var w9e = ye((e1r, b9e) => {\n            "use strict";\n            var qqt = xk(), SY = { object: true, symbol: true };\n            b9e.exports = function() {\n              var e3 = qqt.Symbol, t3;\n              if (typeof e3 != "function") return false;\n              t3 = e3("test symbol");\n              try {\n                String(t3);\n              } catch (r4) {\n                return false;\n              }\n              return !(!SY[typeof e3.iterator] || !SY[typeof e3.toPrimitive] || !SY[typeof e3.toStringTag]);\n            };\n          });\n          var A9e = ye((t1r, T9e) => {\n            "use strict";\n            T9e.exports = function(e3) {\n              return e3 ? typeof e3 == "symbol" ? true : !e3.constructor || e3.constructor.name !== "Symbol" ? false : e3[e3.constructor.toStringTag] === "Symbol" : false;\n            };\n          });\n          var MY = ye((r1r, S9e) => {\n            "use strict";\n            var Bqt = A9e();\n            S9e.exports = function(e3) {\n              if (!Bqt(e3)) throw new TypeError(e3 + " is not a symbol");\n              return e3;\n            };\n          });\n          var L9e = ye((i1r, C9e) => {\n            "use strict";\n            var M9e = n1(), Nqt = Object.create, E9e = Object.defineProperty, Uqt = Object.prototype, k9e = Nqt(null);\n            C9e.exports = function(e3) {\n              for (var t3 = 0, r4, n4; k9e[e3 + (t3 || "")]; ) ++t3;\n              return e3 += t3 || "", k9e[e3] = true, r4 = "@@" + e3, E9e(Uqt, r4, M9e.gs(null, function(i3) {\n                n4 || (n4 = true, E9e(this, r4, M9e(i3)), n4 = false);\n              })), r4;\n            };\n          });\n          var I9e = ye((n1r, P9e) => {\n            "use strict";\n            var em = n1(), qh = xk().Symbol;\n            P9e.exports = function(e3) {\n              return Object.defineProperties(e3, { hasInstance: em("", qh && qh.hasInstance || e3("hasInstance")), isConcatSpreadable: em("", qh && qh.isConcatSpreadable || e3("isConcatSpreadable")), iterator: em("", qh && qh.iterator || e3("iterator")), match: em("", qh && qh.match || e3("match")), replace: em("", qh && qh.replace || e3("replace")), search: em("", qh && qh.search || e3("search")), species: em("", qh && qh.species || e3("species")), split: em("", qh && qh.split || e3("split")), toPrimitive: em("", qh && qh.toPrimitive || e3("toPrimitive")), toStringTag: em("", qh && qh.toStringTag || e3("toStringTag")), unscopables: em("", qh && qh.unscopables || e3("unscopables")) });\n            };\n          });\n          var F9e = ye((a1r, D9e) => {\n            "use strict";\n            var R9e = n1(), Vqt = MY(), bk = /* @__PURE__ */ Object.create(null);\n            D9e.exports = function(e3) {\n              return Object.defineProperties(e3, { for: R9e(function(t3) {\n                return bk[t3] ? bk[t3] : bk[t3] = e3(String(t3));\n              }), keyFor: R9e(function(t3) {\n                var r4;\n                Vqt(t3);\n                for (r4 in bk) if (bk[r4] === t3) return r4;\n              }) });\n            };\n          });\n          var q9e = ye((o1r, O9e) => {\n            "use strict";\n            var Ym = n1(), EY = MY(), dz = xk().Symbol, Gqt = L9e(), Hqt = I9e(), jqt = F9e(), Wqt = Object.create, kY = Object.defineProperties, vz = Object.defineProperty, Xv, f5, z9e;\n            if (typeof dz == "function") try {\n              String(dz()), z9e = true;\n            } catch (e3) {\n            }\n            else dz = null;\n            f5 = function(t3) {\n              if (this instanceof f5) throw new TypeError("Symbol is not a constructor");\n              return Xv(t3);\n            };\n            O9e.exports = Xv = function e3(t3) {\n              var r4;\n              if (this instanceof e3) throw new TypeError("Symbol is not a constructor");\n              return z9e ? dz(t3) : (r4 = Wqt(f5.prototype), t3 = t3 === void 0 ? "" : String(t3), kY(r4, { __description__: Ym("", t3), __name__: Ym("", Gqt(t3)) }));\n            };\n            Hqt(Xv);\n            jqt(Xv);\n            kY(f5.prototype, { constructor: Ym(Xv), toString: Ym("", function() {\n              return this.__name__;\n            }) });\n            kY(Xv.prototype, { toString: Ym(function() {\n              return "Symbol (" + EY(this).__description__ + ")";\n            }), valueOf: Ym(function() {\n              return EY(this);\n            }) });\n            vz(Xv.prototype, Xv.toPrimitive, Ym("", function() {\n              var e3 = EY(this);\n              return typeof e3 == "symbol" ? e3 : e3.toString();\n            }));\n            vz(Xv.prototype, Xv.toStringTag, Ym("c", "Symbol"));\n            vz(f5.prototype, Xv.toStringTag, Ym("c", Xv.prototype[Xv.toStringTag]));\n            vz(f5.prototype, Xv.toPrimitive, Ym("c", Xv.prototype[Xv.toPrimitive]));\n          });\n          var ux = ye((s1r, B9e) => {\n            "use strict";\n            B9e.exports = w9e()() ? xk().Symbol : q9e();\n          });\n          var U9e = ye((l1r, N9e) => {\n            "use strict";\n            var Xqt = i1();\n            N9e.exports = function() {\n              return Xqt(this).length = 0, this;\n            };\n          });\n          var h5 = ye((u1r, V9e) => {\n            "use strict";\n            V9e.exports = function(e3) {\n              if (typeof e3 != "function") throw new TypeError(e3 + " is not a function");\n              return e3;\n            };\n          });\n          var H9e = ye((c1r, G9e) => {\n            "use strict";\n            var Zqt = ew(), Yqt = cz(), Kqt = Object.prototype.toString;\n            G9e.exports = function(e3) {\n              if (!Zqt(e3)) return null;\n              if (Yqt(e3)) {\n                var t3 = e3.toString;\n                if (typeof t3 != "function" || t3 === Kqt) return null;\n              }\n              try {\n                return "" + e3;\n              } catch (r4) {\n                return null;\n              }\n            };\n          });\n          var W9e = ye((f1r, j9e) => {\n            "use strict";\n            j9e.exports = function(e3) {\n              try {\n                return e3.toString();\n              } catch (t3) {\n                try {\n                  return String(e3);\n                } catch (r4) {\n                  return null;\n                }\n              }\n            };\n          });\n          var Z9e = ye((h1r, X9e) => {\n            "use strict";\n            var Jqt = W9e(), $qt = /[\\n\\r\\u2028\\u2029]/g;\n            X9e.exports = function(e3) {\n              var t3 = Jqt(e3);\n              return t3 === null ? "<Non-coercible to string value>" : (t3.length > 100 && (t3 = t3.slice(0, 99) + "\\u2026"), t3 = t3.replace($qt, function(r4) {\n                switch (r4) {\n                  case `\n`:\n                    return "\\\\n";\n                  case "\\r":\n                    return "\\\\r";\n                  case "\\u2028":\n                    return "\\\\u2028";\n                  case "\\u2029":\n                    return "\\\\u2029";\n                  default:\n                    throw new Error("Unexpected character");\n                }\n              }), t3);\n            };\n          });\n          var CY = ye((d1r, J9e) => {\n            "use strict";\n            var Y9e = ew(), Qqt = cz(), eBt = H9e(), tBt = Z9e(), K9e = function(e3, t3) {\n              return e3.replace("%v", tBt(t3));\n            };\n            J9e.exports = function(e3, t3, r4) {\n              if (!Qqt(r4)) throw new TypeError(K9e(t3, e3));\n              if (!Y9e(e3)) {\n                if ("default" in r4) return r4.default;\n                if (r4.isOptional) return null;\n              }\n              var n4 = eBt(r4.errorMessage);\n              throw Y9e(n4) || (n4 = t3), new TypeError(K9e(n4, e3));\n            };\n          });\n          var Q9e = ye((v1r, $9e) => {\n            "use strict";\n            var rBt = CY(), iBt = ew();\n            $9e.exports = function(e3) {\n              return iBt(e3) ? e3 : rBt(e3, "Cannot use %v", arguments[1]);\n            };\n          });\n          var tOe = ye((p1r, eOe) => {\n            "use strict";\n            var nBt = CY(), aBt = bY();\n            eOe.exports = function(e3) {\n              return aBt(e3) ? e3 : nBt(e3, "%v is not a plain function", arguments[1]);\n            };\n          });\n          var iOe = ye((g1r, rOe) => {\n            "use strict";\n            rOe.exports = function() {\n              var e3 = Array.from, t3, r4;\n              return typeof e3 != "function" ? false : (t3 = ["raz", "dwa"], r4 = e3(t3), !!(r4 && r4 !== t3 && r4[1] === "dwa"));\n            };\n          });\n          var aOe = ye((m1r, nOe) => {\n            "use strict";\n            var oBt = Object.prototype.toString, sBt = RegExp.prototype.test.bind(/^[object [A-Za-z0-9]*Function]$/);\n            nOe.exports = function(e3) {\n              return typeof e3 == "function" && sBt(oBt.call(e3));\n            };\n          });\n          var sOe = ye((y1r, oOe) => {\n            "use strict";\n            oOe.exports = function() {\n              var e3 = Math.sign;\n              return typeof e3 != "function" ? false : e3(10) === 1 && e3(-20) === -1;\n            };\n          });\n          var uOe = ye((_1r, lOe) => {\n            "use strict";\n            lOe.exports = function(e3) {\n              return e3 = Number(e3), isNaN(e3) || e3 === 0 ? e3 : e3 > 0 ? 1 : -1;\n            };\n          });\n          var fOe = ye((x1r, cOe) => {\n            "use strict";\n            cOe.exports = sOe()() ? Math.sign : uOe();\n          });\n          var dOe = ye((b1r, hOe) => {\n            "use strict";\n            var lBt = fOe(), uBt = Math.abs, cBt = Math.floor;\n            hOe.exports = function(e3) {\n              return isNaN(e3) ? 0 : (e3 = Number(e3), e3 === 0 || !isFinite(e3) ? e3 : lBt(e3) * cBt(uBt(e3)));\n            };\n          });\n          var pOe = ye((w1r, vOe) => {\n            "use strict";\n            var fBt = dOe(), hBt = Math.max;\n            vOe.exports = function(e3) {\n              return hBt(0, fBt(e3));\n            };\n          });\n          var _Oe = ye((T1r, yOe) => {\n            "use strict";\n            var dBt = ux().iterator, vBt = yk(), pBt = aOe(), gBt = pOe(), gOe = h5(), mBt = i1(), yBt = lx(), _Bt = _k(), mOe = Array.isArray, LY = Function.prototype.call, tw = { configurable: true, enumerable: true, writable: true, value: null }, PY = Object.defineProperty;\n            yOe.exports = function(e3) {\n              var t3 = arguments[1], r4 = arguments[2], n4, i3, a4, o4, s3, l3, u4, c5, f4, h3;\n              if (e3 = Object(mBt(e3)), yBt(t3) && gOe(t3), !this || this === Array || !pBt(this)) {\n                if (!t3) {\n                  if (vBt(e3)) return s3 = e3.length, s3 !== 1 ? Array.apply(null, e3) : (o4 = new Array(1), o4[0] = e3[0], o4);\n                  if (mOe(e3)) {\n                    for (o4 = new Array(s3 = e3.length), i3 = 0; i3 < s3; ++i3) o4[i3] = e3[i3];\n                    return o4;\n                  }\n                }\n                o4 = [];\n              } else n4 = this;\n              if (!mOe(e3)) {\n                if ((f4 = e3[dBt]) !== void 0) {\n                  for (u4 = gOe(f4).call(e3), n4 && (o4 = new n4()), c5 = u4.next(), i3 = 0; !c5.done; ) h3 = t3 ? LY.call(t3, r4, c5.value, i3) : c5.value, n4 ? (tw.value = h3, PY(o4, i3, tw)) : o4[i3] = h3, c5 = u4.next(), ++i3;\n                  s3 = i3;\n                } else if (_Bt(e3)) {\n                  for (s3 = e3.length, n4 && (o4 = new n4()), i3 = 0, a4 = 0; i3 < s3; ++i3) h3 = e3[i3], i3 + 1 < s3 && (l3 = h3.charCodeAt(0), l3 >= 55296 && l3 <= 56319 && (h3 += e3[++i3])), h3 = t3 ? LY.call(t3, r4, h3, a4) : h3, n4 ? (tw.value = h3, PY(o4, a4, tw)) : o4[a4] = h3, ++a4;\n                  s3 = a4;\n                }\n              }\n              if (s3 === void 0) for (s3 = gBt(e3.length), n4 && (o4 = new n4(s3)), i3 = 0; i3 < s3; ++i3) h3 = t3 ? LY.call(t3, r4, e3[i3], i3) : e3[i3], n4 ? (tw.value = h3, PY(o4, i3, tw)) : o4[i3] = h3;\n              return n4 && (tw.value = null, o4.length = s3), o4;\n            };\n          });\n          var bOe = ye((A1r, xOe) => {\n            "use strict";\n            xOe.exports = iOe()() ? Array.from : _Oe();\n          });\n          var TOe = ye((S1r, wOe) => {\n            "use strict";\n            var xBt = bOe(), bBt = fz(), wBt = i1();\n            wOe.exports = function(e3) {\n              var t3 = Object(wBt(e3)), r4 = arguments[1], n4 = Object(arguments[2]);\n              if (t3 !== e3 && !r4) return t3;\n              var i3 = {};\n              return r4 ? xBt(r4, function(a4) {\n                (n4.ensure || a4 in e3) && (i3[a4] = e3[a4]);\n              }) : bBt(i3, e3), i3;\n            };\n          });\n          var MOe = ye((M1r, SOe) => {\n            "use strict";\n            var TBt = h5(), ABt = i1(), SBt = Function.prototype.bind, AOe = Function.prototype.call, MBt = Object.keys, EBt = Object.prototype.propertyIsEnumerable;\n            SOe.exports = function(e3, t3) {\n              return function(r4, n4) {\n                var i3, a4 = arguments[2], o4 = arguments[3];\n                return r4 = Object(ABt(r4)), TBt(n4), i3 = MBt(r4), o4 && i3.sort(typeof o4 == "function" ? SBt.call(o4, r4) : void 0), typeof e3 != "function" && (e3 = i3[e3]), AOe.call(e3, i3, function(s3, l3) {\n                  return EBt.call(r4, s3) ? AOe.call(n4, a4, r4[s3], s3, r4, l3) : t3;\n                });\n              };\n            };\n          });\n          var kOe = ye((E1r, EOe) => {\n            "use strict";\n            EOe.exports = MOe()("forEach");\n          });\n          var LOe = ye((k1r, COe) => {\n            "use strict";\n            var kBt = h5(), CBt = kOe(), LBt = Function.prototype.call;\n            COe.exports = function(e3, t3) {\n              var r4 = {}, n4 = arguments[2];\n              return kBt(t3), CBt(e3, function(i3, a4, o4, s3) {\n                r4[a4] = LBt.call(t3, n4, i3, a4, o4, s3);\n              }), r4;\n            };\n          });\n          var DOe = ye((C1r, ROe) => {\n            "use strict";\n            var PBt = ew(), IBt = Q9e(), POe = tOe(), RBt = TOe(), DBt = wY(), FBt = LOe(), zBt = Function.prototype.bind, OBt = Object.defineProperty, qBt = Object.prototype.hasOwnProperty, IOe;\n            IOe = function(e3, t3, r4) {\n              var n4 = IBt(t3) && POe(t3.value), i3;\n              return i3 = RBt(t3), delete i3.writable, delete i3.value, i3.get = function() {\n                return !r4.overwriteDefinition && qBt.call(this, e3) ? n4 : (t3.value = zBt.call(n4, r4.resolveContext ? r4.resolveContext(this) : this), OBt(this, e3, t3), this[e3]);\n              }, i3;\n            };\n            ROe.exports = function(e3) {\n              var t3 = DBt(arguments[1]);\n              return PBt(t3.resolveContext) && POe(t3.resolveContext), FBt(e3, function(r4, n4) {\n                return IOe(n4, r4, t3);\n              });\n            };\n          });\n          var IY = ye((L1r, qOe) => {\n            "use strict";\n            var BBt = U9e(), NBt = fz(), UBt = h5(), VBt = i1(), qp = n1(), GBt = DOe(), FOe = ux(), zOe = Object.defineProperty, OOe = Object.defineProperties, wk;\n            qOe.exports = wk = function(e3, t3) {\n              if (!(this instanceof wk)) throw new TypeError("Constructor requires \'new\'");\n              OOe(this, { __list__: qp("w", VBt(e3)), __context__: qp("w", t3), __nextIndex__: qp("w", 0) }), t3 && (UBt(t3.on), t3.on("_add", this._onAdd), t3.on("_delete", this._onDelete), t3.on("_clear", this._onClear));\n            };\n            delete wk.prototype.constructor;\n            OOe(wk.prototype, NBt({ _next: qp(function() {\n              var e3;\n              if (this.__list__) {\n                if (this.__redo__ && (e3 = this.__redo__.shift(), e3 !== void 0)) return e3;\n                if (this.__nextIndex__ < this.__list__.length) return this.__nextIndex__++;\n                this._unBind();\n              }\n            }), next: qp(function() {\n              return this._createResult(this._next());\n            }), _createResult: qp(function(e3) {\n              return e3 === void 0 ? { done: true, value: void 0 } : { done: false, value: this._resolve(e3) };\n            }), _resolve: qp(function(e3) {\n              return this.__list__[e3];\n            }), _unBind: qp(function() {\n              this.__list__ = null, delete this.__redo__, this.__context__ && (this.__context__.off("_add", this._onAdd), this.__context__.off("_delete", this._onDelete), this.__context__.off("_clear", this._onClear), this.__context__ = null);\n            }), toString: qp(function() {\n              return "[object " + (this[FOe.toStringTag] || "Object") + "]";\n            }) }, GBt({ _onAdd: qp(function(e3) {\n              if (!(e3 >= this.__nextIndex__)) {\n                if (++this.__nextIndex__, !this.__redo__) {\n                  zOe(this, "__redo__", qp("c", [e3]));\n                  return;\n                }\n                this.__redo__.forEach(function(t3, r4) {\n                  t3 >= e3 && (this.__redo__[r4] = ++t3);\n                }, this), this.__redo__.push(e3);\n              }\n            }), _onDelete: qp(function(e3) {\n              var t3;\n              e3 >= this.__nextIndex__ || (--this.__nextIndex__, this.__redo__ && (t3 = this.__redo__.indexOf(e3), t3 !== -1 && this.__redo__.splice(t3, 1), this.__redo__.forEach(function(r4, n4) {\n                r4 > e3 && (this.__redo__[n4] = --r4);\n              }, this)));\n            }), _onClear: qp(function() {\n              this.__redo__ && BBt.call(this.__redo__), this.__nextIndex__ = 0;\n            }) })));\n            zOe(wk.prototype, FOe.iterator, qp(function() {\n              return this;\n            }));\n          });\n          var GOe = ye((P1r, VOe) => {\n            "use strict";\n            var BOe = uz(), NOe = AY(), RY = n1(), HBt = ux(), DY = IY(), UOe = Object.defineProperty, d5;\n            d5 = VOe.exports = function(e3, t3) {\n              if (!(this instanceof d5)) throw new TypeError("Constructor requires \'new\'");\n              DY.call(this, e3), t3 ? NOe.call(t3, "key+value") ? t3 = "key+value" : NOe.call(t3, "key") ? t3 = "key" : t3 = "value" : t3 = "value", UOe(this, "__kind__", RY("", t3));\n            };\n            BOe && BOe(d5, DY);\n            delete d5.prototype.constructor;\n            d5.prototype = Object.create(DY.prototype, { _resolve: RY(function(e3) {\n              return this.__kind__ === "value" ? this.__list__[e3] : this.__kind__ === "key+value" ? [e3, this.__list__[e3]] : e3;\n            }) });\n            UOe(d5.prototype, HBt.toStringTag, RY("c", "Array Iterator"));\n          });\n          var XOe = ye((I1r, WOe) => {\n            "use strict";\n            var HOe = uz(), pz = n1(), jBt = ux(), FY = IY(), jOe = Object.defineProperty, v5;\n            v5 = WOe.exports = function(e3) {\n              if (!(this instanceof v5)) throw new TypeError("Constructor requires \'new\'");\n              e3 = String(e3), FY.call(this, e3), jOe(this, "__length__", pz("", e3.length));\n            };\n            HOe && HOe(v5, FY);\n            delete v5.prototype.constructor;\n            v5.prototype = Object.create(FY.prototype, { _next: pz(function() {\n              if (this.__list__) {\n                if (this.__nextIndex__ < this.__length__) return this.__nextIndex__++;\n                this._unBind();\n              }\n            }), _resolve: pz(function(e3) {\n              var t3 = this.__list__[e3], r4;\n              return this.__nextIndex__ === this.__length__ ? t3 : (r4 = t3.charCodeAt(0), r4 >= 55296 && r4 <= 56319 ? t3 + this.__list__[this.__nextIndex__++] : t3);\n            }) });\n            jOe(v5.prototype, jBt.toStringTag, pz("c", "String Iterator"));\n          });\n          var YOe = ye((R1r, ZOe) => {\n            "use strict";\n            var WBt = yk(), XBt = lx(), ZBt = _k(), YBt = ux().iterator, KBt = Array.isArray;\n            ZOe.exports = function(e3) {\n              return XBt(e3) ? KBt(e3) || ZBt(e3) || WBt(e3) ? true : typeof e3[YBt] == "function" : false;\n            };\n          });\n          var JOe = ye((D1r, KOe) => {\n            "use strict";\n            var JBt = YOe();\n            KOe.exports = function(e3) {\n              if (!JBt(e3)) throw new TypeError(e3 + " is not iterable");\n              return e3;\n            };\n          });\n          var zY = ye((F1r, eqe) => {\n            "use strict";\n            var $Bt = yk(), QBt = _k(), $Oe = GOe(), eNt = XOe(), tNt = JOe(), QOe = ux().iterator;\n            eqe.exports = function(e3) {\n              return typeof tNt(e3)[QOe] == "function" ? e3[QOe]() : $Bt(e3) ? new $Oe(e3) : QBt(e3) ? new eNt(e3) : new $Oe(e3);\n            };\n          });\n          var rqe = ye((z1r, tqe) => {\n            "use strict";\n            var rNt = yk(), iNt = h5(), nNt = _k(), aNt = zY(), oNt = Array.isArray, OY = Function.prototype.call, sNt = Array.prototype.some;\n            tqe.exports = function(e3, t3) {\n              var r4, n4 = arguments[2], i3, a4, o4, s3, l3, u4, c5;\n              if (oNt(e3) || rNt(e3) ? r4 = "array" : nNt(e3) ? r4 = "string" : e3 = aNt(e3), iNt(t3), a4 = function() {\n                o4 = true;\n              }, r4 === "array") {\n                sNt.call(e3, function(f4) {\n                  return OY.call(t3, n4, f4, a4), o4;\n                });\n                return;\n              }\n              if (r4 === "string") {\n                for (l3 = e3.length, s3 = 0; s3 < l3 && (u4 = e3[s3], s3 + 1 < l3 && (c5 = u4.charCodeAt(0), c5 >= 55296 && c5 <= 56319 && (u4 += e3[++s3])), OY.call(t3, n4, u4, a4), !o4); ++s3) ;\n                return;\n              }\n              for (i3 = e3.next(); !i3.done; ) {\n                if (OY.call(t3, n4, i3.value, a4), o4) return;\n                i3 = e3.next();\n              }\n            };\n          });\n          var nqe = ye((O1r, iqe) => {\n            "use strict";\n            iqe.exports = (function() {\n              return typeof WeakMap != "function" ? false : Object.prototype.toString.call(/* @__PURE__ */ new WeakMap()) === "[object WeakMap]";\n            })();\n          });\n          var sqe = ye((q1r, oqe) => {\n            "use strict";\n            var lNt = lx(), mz = uz(), gz = D7e(), uNt = i1(), cNt = z7e(), a1 = n1(), fNt = zY(), hNt = rqe(), dNt = ux().toStringTag, aqe = nqe(), vNt = Array.isArray, BY = Object.defineProperty, qY = Object.prototype.hasOwnProperty, pNt = Object.getPrototypeOf, cx;\n            oqe.exports = cx = function() {\n              var e3 = arguments[0], t3;\n              if (!(this instanceof cx)) throw new TypeError("Constructor requires \'new\'");\n              return t3 = aqe && mz && WeakMap !== cx ? mz(/* @__PURE__ */ new WeakMap(), pNt(this)) : this, lNt(e3) && (vNt(e3) || (e3 = fNt(e3))), BY(t3, "__weakMapData__", a1("c", "$weakMap$" + cNt())), e3 && hNt(e3, function(r4) {\n                uNt(r4), t3.set(r4[0], r4[1]);\n              }), t3;\n            };\n            aqe && (mz && mz(cx, WeakMap), cx.prototype = Object.create(WeakMap.prototype, { constructor: a1(cx) }));\n            Object.defineProperties(cx.prototype, { delete: a1(function(e3) {\n              return qY.call(gz(e3), this.__weakMapData__) ? (delete e3[this.__weakMapData__], true) : false;\n            }), get: a1(function(e3) {\n              if (qY.call(gz(e3), this.__weakMapData__)) return e3[this.__weakMapData__];\n            }), has: a1(function(e3) {\n              return qY.call(gz(e3), this.__weakMapData__);\n            }), set: a1(function(e3, t3) {\n              return BY(gz(e3), this.__weakMapData__, a1("c", t3)), this;\n            }), toString: a1(function() {\n              return "[object WeakMap]";\n            }) });\n            BY(cx.prototype, dNt, a1("c", "WeakMap"));\n          });\n          var NY = ye((B1r, lqe) => {\n            "use strict";\n            lqe.exports = b7e()() ? WeakMap : sqe();\n          });\n          var cqe = ye((N1r, uqe) => {\n            "use strict";\n            uqe.exports = function(e3, t3, r4) {\n              if (typeof Array.prototype.findIndex == "function") return e3.findIndex(t3, r4);\n              if (typeof t3 != "function") throw new TypeError("predicate must be a function");\n              var n4 = Object(e3), i3 = n4.length;\n              if (i3 === 0) return -1;\n              for (var a4 = 0; a4 < i3; a4++) if (t3.call(r4, n4[a4], a4, n4)) return a4;\n              return -1;\n            };\n          });\n          var GY = ye((U1r, dqe) => {\n            "use strict";\n            var yz = J_(), gNt = X2(), VY = Oh(), mNt = Zm(), yNt = Z2(), fqe = m7e(), _Nt = _7e(), { float32: xNt, fract32: UY } = ez(), bNt = NY(), hqe = i5(), wNt = cqe(), TNt = `\nprecision highp float;\n\nattribute vec2 aCoord, bCoord, aCoordFract, bCoordFract;\nattribute vec4 color;\nattribute float lineEnd, lineTop;\n\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float thickness, pixelRatio, id, depth;\nuniform vec4 viewport;\n\nvarying vec4 fragColor;\nvarying vec2 tangent;\n\nvec2 project(vec2 position, vec2 positionFract, vec2 scale, vec2 scaleFract, vec2 translate, vec2 translateFract) {\n	// the order is important\n	return position * scale + translate\n       + positionFract * scale + translateFract\n       + position * scaleFract\n       + positionFract * scaleFract;\n}\n\nvoid main() {\n	float lineStart = 1. - lineEnd;\n	float lineOffset = lineTop * 2. - 1.;\n\n	vec2 diff = (bCoord + bCoordFract - aCoord - aCoordFract);\n	tangent = normalize(diff * scale * viewport.zw);\n	vec2 normal = vec2(-tangent.y, tangent.x);\n\n	vec2 position = project(aCoord, aCoordFract, scale, scaleFract, translate, translateFract) * lineStart\n		+ project(bCoord, bCoordFract, scale, scaleFract, translate, translateFract) * lineEnd\n\n		+ thickness * normal * .5 * lineOffset / viewport.zw;\n\n	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n	fragColor = color / 255.;\n}\n`, ANt = `\nprecision highp float;\n\nuniform float dashLength, pixelRatio, thickness, opacity, id;\nuniform sampler2D dashTexture;\n\nvarying vec4 fragColor;\nvarying vec2 tangent;\n\nvoid main() {\n	float alpha = 1.;\n\n	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;\n	float dash = texture2D(dashTexture, vec2(t, .5)).r;\n\n	gl_FragColor = fragColor;\n	gl_FragColor.a *= alpha * opacity * dash;\n}\n`, SNt = `\nprecision highp float;\n\nattribute vec2 position, positionFract;\n\nuniform vec4 color;\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float pixelRatio, id;\nuniform vec4 viewport;\nuniform float opacity;\n\nvarying vec4 fragColor;\n\nconst float MAX_LINES = 256.;\n\nvoid main() {\n	float depth = (MAX_LINES - 4. - id) / (MAX_LINES);\n\n	vec2 position = position * scale + translate\n       + positionFract * scale + translateFract\n       + position * scaleFract\n       + positionFract * scaleFract;\n\n	gl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n	fragColor = color / 255.;\n	fragColor.a *= opacity;\n}\n`, MNt = `\nprecision highp float;\nvarying vec4 fragColor;\n\nvoid main() {\n	gl_FragColor = fragColor;\n}\n`, ENt = `\nprecision highp float;\n\nattribute vec2 aCoord, bCoord, nextCoord, prevCoord;\nattribute vec4 aColor, bColor;\nattribute float lineEnd, lineTop;\n\nuniform vec2 scale, translate;\nuniform float thickness, pixelRatio, id, depth;\nuniform vec4 viewport;\nuniform float miterLimit, miterMode;\n\nvarying vec4 fragColor;\nvarying vec4 startCutoff, endCutoff;\nvarying vec2 tangent;\nvarying vec2 startCoord, endCoord;\nvarying float enableStartMiter, enableEndMiter;\n\nconst float REVERSE_THRESHOLD = -.875;\nconst float MIN_DIFF = 1e-6;\n\n// TODO: possible optimizations: avoid overcalculating all for vertices and calc just one instead\n// TODO: precalculate dot products, normalize things beforehead etc.\n// TODO: refactor to rectangular algorithm\n\nfloat distToLine(vec2 p, vec2 a, vec2 b) {\n	vec2 diff = b - a;\n	vec2 perp = normalize(vec2(-diff.y, diff.x));\n	return dot(p - a, perp);\n}\n\nbool isNaN( float val ){\n  return ( val < 0.0 || 0.0 < val || val == 0.0 ) ? false : true;\n}\n\nvoid main() {\n	vec2 aCoord = aCoord, bCoord = bCoord, prevCoord = prevCoord, nextCoord = nextCoord;\n\n  vec2 adjustedScale;\n  adjustedScale.x = (abs(scale.x) < MIN_DIFF) ? MIN_DIFF : scale.x;\n  adjustedScale.y = (abs(scale.y) < MIN_DIFF) ? MIN_DIFF : scale.y;\n\n  vec2 scaleRatio = adjustedScale * viewport.zw;\n	vec2 normalWidth = thickness / scaleRatio;\n\n	float lineStart = 1. - lineEnd;\n	float lineBot = 1. - lineTop;\n\n	fragColor = (lineStart * aColor + lineEnd * bColor) / 255.;\n\n	if (isNaN(aCoord.x) || isNaN(aCoord.y) || isNaN(bCoord.x) || isNaN(bCoord.y)) return;\n\n	if (aCoord == prevCoord) prevCoord = aCoord + normalize(bCoord - aCoord);\n	if (bCoord == nextCoord) nextCoord = bCoord - normalize(bCoord - aCoord);\n\n\n	vec2 prevDiff = aCoord - prevCoord;\n	vec2 currDiff = bCoord - aCoord;\n	vec2 nextDiff = nextCoord - bCoord;\n\n	vec2 prevTangent = normalize(prevDiff * scaleRatio);\n	vec2 currTangent = normalize(currDiff * scaleRatio);\n	vec2 nextTangent = normalize(nextDiff * scaleRatio);\n\n	vec2 prevNormal = vec2(-prevTangent.y, prevTangent.x);\n	vec2 currNormal = vec2(-currTangent.y, currTangent.x);\n	vec2 nextNormal = vec2(-nextTangent.y, nextTangent.x);\n\n	vec2 startJoinDirection = normalize(prevTangent - currTangent);\n	vec2 endJoinDirection = normalize(currTangent - nextTangent);\n\n	// collapsed/unidirectional segment cases\n	// FIXME: there should be more elegant solution\n	vec2 prevTanDiff = abs(prevTangent - currTangent);\n	vec2 nextTanDiff = abs(nextTangent - currTangent);\n	if (max(prevTanDiff.x, prevTanDiff.y) < MIN_DIFF) {\n		startJoinDirection = currNormal;\n	}\n	if (max(nextTanDiff.x, nextTanDiff.y) < MIN_DIFF) {\n		endJoinDirection = currNormal;\n	}\n	if (aCoord == bCoord) {\n		endJoinDirection = startJoinDirection;\n		currNormal = prevNormal;\n		currTangent = prevTangent;\n	}\n\n	tangent = currTangent;\n\n	//calculate join shifts relative to normals\n	float startJoinShift = dot(currNormal, startJoinDirection);\n	float endJoinShift = dot(currNormal, endJoinDirection);\n\n	float startMiterRatio = abs(1. / startJoinShift);\n	float endMiterRatio = abs(1. / endJoinShift);\n\n	vec2 startJoin = startJoinDirection * startMiterRatio;\n	vec2 endJoin = endJoinDirection * endMiterRatio;\n\n	vec2 startTopJoin, startBotJoin, endTopJoin, endBotJoin;\n	startTopJoin = sign(startJoinShift) * startJoin * .5;\n	startBotJoin = -startTopJoin;\n\n	endTopJoin = sign(endJoinShift) * endJoin * .5;\n	endBotJoin = -endTopJoin;\n\n	vec2 aTopCoord = aCoord + normalWidth * startTopJoin;\n	vec2 bTopCoord = bCoord + normalWidth * endTopJoin;\n	vec2 aBotCoord = aCoord + normalWidth * startBotJoin;\n	vec2 bBotCoord = bCoord + normalWidth * endBotJoin;\n\n	//miter anti-clipping\n	float baClipping = distToLine(bCoord, aCoord, aBotCoord) / dot(normalize(normalWidth * endBotJoin), normalize(normalWidth.yx * vec2(-startBotJoin.y, startBotJoin.x)));\n	float abClipping = distToLine(aCoord, bCoord, bTopCoord) / dot(normalize(normalWidth * startBotJoin), normalize(normalWidth.yx * vec2(-endBotJoin.y, endBotJoin.x)));\n\n	//prevent close to reverse direction switch\n	bool prevReverse = dot(currTangent, prevTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, prevNormal)) * min(length(prevDiff), length(currDiff)) <  length(normalWidth * currNormal);\n	bool nextReverse = dot(currTangent, nextTangent) <= REVERSE_THRESHOLD && abs(dot(currTangent, nextNormal)) * min(length(nextDiff), length(currDiff)) <  length(normalWidth * currNormal);\n\n	if (prevReverse) {\n		//make join rectangular\n		vec2 miterShift = normalWidth * startJoinDirection * miterLimit * .5;\n		float normalAdjust = 1. - min(miterLimit / startMiterRatio, 1.);\n		aBotCoord = aCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;\n		aTopCoord = aCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;\n	}\n	else if (!nextReverse && baClipping > 0. && baClipping < length(normalWidth * endBotJoin)) {\n		//handle miter clipping\n		bTopCoord -= normalWidth * endTopJoin;\n		bTopCoord += normalize(endTopJoin * normalWidth) * baClipping;\n	}\n\n	if (nextReverse) {\n		//make join rectangular\n		vec2 miterShift = normalWidth * endJoinDirection * miterLimit * .5;\n		float normalAdjust = 1. - min(miterLimit / endMiterRatio, 1.);\n		bBotCoord = bCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;\n		bTopCoord = bCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;\n	}\n	else if (!prevReverse && abClipping > 0. && abClipping < length(normalWidth * startBotJoin)) {\n		//handle miter clipping\n		aBotCoord -= normalWidth * startBotJoin;\n		aBotCoord += normalize(startBotJoin * normalWidth) * abClipping;\n	}\n\n	vec2 aTopPosition = (aTopCoord) * adjustedScale + translate;\n	vec2 aBotPosition = (aBotCoord) * adjustedScale + translate;\n\n	vec2 bTopPosition = (bTopCoord) * adjustedScale + translate;\n	vec2 bBotPosition = (bBotCoord) * adjustedScale + translate;\n\n	//position is normalized 0..1 coord on the screen\n	vec2 position = (aTopPosition * lineTop + aBotPosition * lineBot) * lineStart + (bTopPosition * lineTop + bBotPosition * lineBot) * lineEnd;\n\n	startCoord = aCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n	endCoord = bCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n\n	gl_Position = vec4(position  * 2.0 - 1.0, depth, 1);\n\n	enableStartMiter = step(dot(currTangent, prevTangent), .5);\n	enableEndMiter = step(dot(currTangent, nextTangent), .5);\n\n	//bevel miter cutoffs\n	if (miterMode == 1.) {\n		if (enableStartMiter == 1.) {\n			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * miterLimit * .5;\n			startCutoff = vec4(aCoord, aCoord);\n			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n			startCutoff += viewport.xyxy;\n			startCutoff += startMiterWidth.xyxy;\n		}\n\n		if (enableEndMiter == 1.) {\n			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * miterLimit * .5;\n			endCutoff = vec4(bCoord, bCoord);\n			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;\n			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n			endCutoff += viewport.xyxy;\n			endCutoff += endMiterWidth.xyxy;\n		}\n	}\n\n	//round miter cutoffs\n	else if (miterMode == 2.) {\n		if (enableStartMiter == 1.) {\n			vec2 startMiterWidth = vec2(startJoinDirection) * thickness * abs(dot(startJoinDirection, currNormal)) * .5;\n			startCutoff = vec4(aCoord, aCoord);\n			startCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n			startCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n			startCutoff += viewport.xyxy;\n			startCutoff += startMiterWidth.xyxy;\n		}\n\n		if (enableEndMiter == 1.) {\n			vec2 endMiterWidth = vec2(endJoinDirection) * thickness * abs(dot(endJoinDirection, currNormal)) * .5;\n			endCutoff = vec4(bCoord, bCoord);\n			endCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x)  / scaleRatio;\n			endCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n			endCutoff += viewport.xyxy;\n			endCutoff += endMiterWidth.xyxy;\n		}\n	}\n}\n`, kNt = `\nprecision highp float;\n\nuniform float dashLength, pixelRatio, thickness, opacity, id, miterMode;\nuniform sampler2D dashTexture;\n\nvarying vec4 fragColor;\nvarying vec2 tangent;\nvarying vec4 startCutoff, endCutoff;\nvarying vec2 startCoord, endCoord;\nvarying float enableStartMiter, enableEndMiter;\n\nfloat distToLine(vec2 p, vec2 a, vec2 b) {\n	vec2 diff = b - a;\n	vec2 perp = normalize(vec2(-diff.y, diff.x));\n	return dot(p - a, perp);\n}\n\nvoid main() {\n	float alpha = 1., distToStart, distToEnd;\n	float cutoff = thickness * .5;\n\n	//bevel miter\n	if (miterMode == 1.) {\n		if (enableStartMiter == 1.) {\n			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n			if (distToStart < -1.) {\n				discard;\n				return;\n			}\n			alpha *= min(max(distToStart + 1., 0.), 1.);\n		}\n\n		if (enableEndMiter == 1.) {\n			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n			if (distToEnd < -1.) {\n				discard;\n				return;\n			}\n			alpha *= min(max(distToEnd + 1., 0.), 1.);\n		}\n	}\n\n	// round miter\n	else if (miterMode == 2.) {\n		if (enableStartMiter == 1.) {\n			distToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n			if (distToStart < 0.) {\n				float radius = length(gl_FragCoord.xy - startCoord);\n\n				if(radius > cutoff + .5) {\n					discard;\n					return;\n				}\n\n				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n			}\n		}\n\n		if (enableEndMiter == 1.) {\n			distToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n			if (distToEnd < 0.) {\n				float radius = length(gl_FragCoord.xy - endCoord);\n\n				if(radius > cutoff + .5) {\n					discard;\n					return;\n				}\n\n				alpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n			}\n		}\n	}\n\n	float t = fract(dot(tangent, gl_FragCoord.xy) / dashLength) * .5 + .25;\n	float dash = texture2D(dashTexture, vec2(t, .5)).r;\n\n	gl_FragColor = fragColor;\n	gl_FragColor.a *= alpha * opacity * dash;\n}\n`;\n            dqe.exports = Wc;\n            function Wc(e3, t3) {\n              if (!(this instanceof Wc)) return new Wc(e3, t3);\n              if (typeof e3 == "function" ? (t3 || (t3 = {}), t3.regl = e3) : t3 = e3, t3.length && (t3.positions = t3), e3 = t3.regl, !e3.hasExtension("ANGLE_instanced_arrays")) throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");\n              this.gl = e3._gl, this.regl = e3, this.passes = [], this.shaders = Wc.shaders.has(e3) ? Wc.shaders.get(e3) : Wc.shaders.set(e3, Wc.createShaders(e3)).get(e3), this.update(t3);\n            }\n            Wc.dashMult = 2;\n            Wc.maxPatternLength = 256;\n            Wc.precisionThreshold = 3e6;\n            Wc.maxPoints = 1e4;\n            Wc.maxLines = 2048;\n            Wc.shaders = new bNt();\n            Wc.createShaders = function(e3) {\n              let t3 = e3.buffer({ usage: "static", type: "float", data: [0, 1, 0, 0, 1, 1, 1, 0] }), r4 = { primitive: "triangle strip", instances: e3.prop("count"), count: 4, offset: 0, uniforms: { miterMode: (o4, s3) => s3.join === "round" ? 2 : 1, miterLimit: e3.prop("miterLimit"), scale: e3.prop("scale"), scaleFract: e3.prop("scaleFract"), translateFract: e3.prop("translateFract"), translate: e3.prop("translate"), thickness: e3.prop("thickness"), dashTexture: e3.prop("dashTexture"), opacity: e3.prop("opacity"), pixelRatio: e3.context("pixelRatio"), id: e3.prop("id"), dashLength: e3.prop("dashLength"), viewport: (o4, s3) => [s3.viewport.x, s3.viewport.y, o4.viewportWidth, o4.viewportHeight], depth: e3.prop("depth") }, blend: { enable: true, color: [0, 0, 0, 0], equation: { rgb: "add", alpha: "add" }, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, depth: { enable: (o4, s3) => !s3.overlay }, stencil: { enable: false }, scissor: { enable: true, box: e3.prop("viewport") }, viewport: e3.prop("viewport") }, n4 = e3(VY({ vert: TNt, frag: ANt, attributes: { lineEnd: { buffer: t3, divisor: 0, stride: 8, offset: 0 }, lineTop: { buffer: t3, divisor: 0, stride: 8, offset: 4 }, aCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 16, divisor: 1 }, aCoordFract: { buffer: e3.prop("positionFractBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoordFract: { buffer: e3.prop("positionFractBuffer"), stride: 8, offset: 16, divisor: 1 }, color: { buffer: e3.prop("colorBuffer"), stride: 4, offset: 0, divisor: 1 } } }, r4)), i3;\n              try {\n                i3 = e3(VY({ cull: { enable: true, face: "back" }, vert: ENt, frag: kNt, attributes: { lineEnd: { buffer: t3, divisor: 0, stride: 8, offset: 0 }, lineTop: { buffer: t3, divisor: 0, stride: 8, offset: 4 }, aColor: { buffer: e3.prop("colorBuffer"), stride: 4, offset: 0, divisor: 1 }, bColor: { buffer: e3.prop("colorBuffer"), stride: 4, offset: 4, divisor: 1 }, prevCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 0, divisor: 1 }, aCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 8, divisor: 1 }, bCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 16, divisor: 1 }, nextCoord: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 24, divisor: 1 } } }, r4));\n              } catch (o4) {\n                i3 = n4;\n              }\n              return { fill: e3({ primitive: "triangle", elements: (o4, s3) => s3.triangles, offset: 0, vert: SNt, frag: MNt, uniforms: { scale: e3.prop("scale"), color: e3.prop("fill"), scaleFract: e3.prop("scaleFract"), translateFract: e3.prop("translateFract"), translate: e3.prop("translate"), opacity: e3.prop("opacity"), pixelRatio: e3.context("pixelRatio"), id: e3.prop("id"), viewport: (o4, s3) => [s3.viewport.x, s3.viewport.y, o4.viewportWidth, o4.viewportHeight] }, attributes: { position: { buffer: e3.prop("positionBuffer"), stride: 8, offset: 8 }, positionFract: { buffer: e3.prop("positionFractBuffer"), stride: 8, offset: 8 } }, blend: r4.blend, depth: { enable: false }, scissor: r4.scissor, stencil: r4.stencil, viewport: r4.viewport }), rect: n4, miter: i3 };\n            };\n            Wc.defaults = { dashes: null, join: "miter", miterLimit: 1, thickness: 10, cap: "square", color: "black", opacity: 1, overlay: false, viewport: null, range: null, close: false, fill: null };\n            Wc.prototype.render = function(...e3) {\n              e3.length && this.update(...e3), this.draw();\n            };\n            Wc.prototype.draw = function(...e3) {\n              return (e3.length ? e3 : this.passes).forEach((t3, r4) => {\n                if (t3 && Array.isArray(t3)) return this.draw(...t3);\n                typeof t3 == "number" && (t3 = this.passes[t3]), t3 && t3.count > 1 && t3.opacity && (this.regl._refresh(), t3.fill && t3.triangles && t3.triangles.length > 2 && this.shaders.fill(t3), t3.thickness && (t3.scale[0] * t3.viewport.width > Wc.precisionThreshold || t3.scale[1] * t3.viewport.height > Wc.precisionThreshold ? this.shaders.rect(t3) : t3.join === "rect" || !t3.join && (t3.thickness <= 2 || t3.count >= Wc.maxPoints) ? this.shaders.rect(t3) : this.shaders.miter(t3)));\n              }), this;\n            };\n            Wc.prototype.update = function(e3) {\n              if (!e3) return;\n              e3.length != null ? typeof e3[0] == "number" && (e3 = [{ positions: e3 }]) : Array.isArray(e3) || (e3 = [e3]);\n              let { regl: t3, gl: r4 } = this;\n              if (e3.forEach((i3, a4) => {\n                let o4 = this.passes[a4];\n                if (i3 !== void 0) {\n                  if (i3 === null) {\n                    this.passes[a4] = null;\n                    return;\n                  }\n                  if (typeof i3[0] == "number" && (i3 = { positions: i3 }), i3 = mNt(i3, { positions: "positions points data coords", thickness: "thickness lineWidth lineWidths line-width linewidth width stroke-width strokewidth strokeWidth", join: "lineJoin linejoin join type mode", miterLimit: "miterlimit miterLimit", dashes: "dash dashes dasharray dash-array dashArray", color: "color colour stroke colors colours stroke-color strokeColor", fill: "fill fill-color fillColor", opacity: "alpha opacity", overlay: "overlay crease overlap intersect", close: "closed close closed-path closePath", range: "range dataBox", viewport: "viewport viewBox", hole: "holes hole hollow", splitNull: "splitNull" }), o4 || (this.passes[a4] = o4 = { id: a4, scale: null, scaleFract: null, translate: null, translateFract: null, count: 0, hole: [], depth: 0, dashLength: 1, dashTexture: t3.texture({ channels: 1, data: new Uint8Array([255]), width: 1, height: 1, mag: "linear", min: "linear" }), colorBuffer: t3.buffer({ usage: "dynamic", type: "uint8", data: new Uint8Array() }), positionBuffer: t3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }), positionFractBuffer: t3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }) }, i3 = VY({}, Wc.defaults, i3)), i3.thickness != null && (o4.thickness = parseFloat(i3.thickness)), i3.opacity != null && (o4.opacity = parseFloat(i3.opacity)), i3.miterLimit != null && (o4.miterLimit = parseFloat(i3.miterLimit)), i3.overlay != null && (o4.overlay = !!i3.overlay, a4 < Wc.maxLines && (o4.depth = 2 * (Wc.maxLines - 1 - a4 % Wc.maxLines) / Wc.maxLines - 1)), i3.join != null && (o4.join = i3.join), i3.hole != null && (o4.hole = i3.hole), i3.fill != null && (o4.fill = i3.fill ? yz(i3.fill, "uint8") : null), i3.viewport != null && (o4.viewport = hqe(i3.viewport)), o4.viewport || (o4.viewport = hqe([r4.drawingBufferWidth, r4.drawingBufferHeight])), i3.close != null && (o4.close = i3.close), i3.positions === null && (i3.positions = []), i3.positions) {\n                    let u4, c5;\n                    if (i3.positions.x && i3.positions.y) {\n                      let v3 = i3.positions.x, _2 = i3.positions.y;\n                      c5 = o4.count = Math.max(v3.length, _2.length), u4 = new Float64Array(c5 * 2);\n                      for (let b = 0; b < c5; b++) u4[b * 2] = v3[b], u4[b * 2 + 1] = _2[b];\n                    } else u4 = yNt(i3.positions, "float64"), c5 = o4.count = Math.floor(u4.length / 2);\n                    let f4 = o4.bounds = gNt(u4, 2);\n                    if (o4.fill) {\n                      let v3 = [], _2 = {}, b = 0;\n                      for (let p3 = 0, k4 = 0, E3 = o4.count; p3 < E3; p3++) {\n                        let S2 = u4[p3 * 2], L3 = u4[p3 * 2 + 1];\n                        isNaN(S2) || isNaN(L3) || S2 == null || L3 == null ? (S2 = u4[b * 2], L3 = u4[b * 2 + 1], _2[p3] = b) : b = p3, v3[k4++] = S2, v3[k4++] = L3;\n                      }\n                      if (i3.splitNull) {\n                        o4.count - 1 in _2 || (_2[o4.count] = o4.count - 1);\n                        let p3 = Object.keys(_2).map(Number).sort((L3, x2) => L3 - x2), k4 = [], E3 = 0, S2 = o4.hole != null ? o4.hole[0] : null;\n                        if (S2 != null) {\n                          let L3 = wNt(p3, (x2) => x2 >= S2);\n                          p3 = p3.slice(0, L3), p3.push(S2);\n                        }\n                        for (let L3 = 0; L3 < p3.length; L3++) {\n                          let x2 = v3.slice(E3 * 2, p3[L3] * 2).concat(S2 ? v3.slice(S2 * 2) : []), C3 = (o4.hole || []).map((g3) => g3 - S2 + (p3[L3] - E3)), M4 = fqe(x2, C3);\n                          M4 = M4.map((g3) => g3 + E3 + (g3 + E3 < p3[L3] ? 0 : S2 - p3[L3])), k4.push(...M4), E3 = p3[L3] + 1;\n                        }\n                        for (let L3 = 0, x2 = k4.length; L3 < x2; L3++) _2[k4[L3]] != null && (k4[L3] = _2[k4[L3]]);\n                        o4.triangles = k4;\n                      } else {\n                        let p3 = fqe(v3, o4.hole || []);\n                        for (let k4 = 0, E3 = p3.length; k4 < E3; k4++) _2[p3[k4]] != null && (p3[k4] = _2[p3[k4]]);\n                        o4.triangles = p3;\n                      }\n                    }\n                    let h3 = new Float64Array(u4);\n                    _Nt(h3, 2, f4);\n                    let d3 = new Float64Array(c5 * 2 + 6);\n                    o4.close ? u4[0] === u4[c5 * 2 - 2] && u4[1] === u4[c5 * 2 - 1] ? (d3[0] = h3[c5 * 2 - 4], d3[1] = h3[c5 * 2 - 3]) : (d3[0] = h3[c5 * 2 - 2], d3[1] = h3[c5 * 2 - 1]) : (d3[0] = h3[0], d3[1] = h3[1]), d3.set(h3, 2), o4.close ? u4[0] === u4[c5 * 2 - 2] && u4[1] === u4[c5 * 2 - 1] ? (d3[c5 * 2 + 2] = h3[2], d3[c5 * 2 + 3] = h3[3], o4.count -= 1) : (d3[c5 * 2 + 2] = h3[0], d3[c5 * 2 + 3] = h3[1], d3[c5 * 2 + 4] = h3[2], d3[c5 * 2 + 5] = h3[3]) : (d3[c5 * 2 + 2] = h3[c5 * 2 - 2], d3[c5 * 2 + 3] = h3[c5 * 2 - 1], d3[c5 * 2 + 4] = h3[c5 * 2 - 2], d3[c5 * 2 + 5] = h3[c5 * 2 - 1]);\n                    var s3 = xNt(d3);\n                    o4.positionBuffer(s3);\n                    var l3 = UY(d3, s3);\n                    o4.positionFractBuffer(l3);\n                  }\n                  if (i3.range ? o4.range = i3.range : o4.range || (o4.range = o4.bounds), (i3.range || i3.positions) && o4.count) {\n                    let u4 = o4.bounds, c5 = u4[2] - u4[0], f4 = u4[3] - u4[1], h3 = o4.range[2] - o4.range[0], d3 = o4.range[3] - o4.range[1];\n                    o4.scale = [c5 / h3, f4 / d3], o4.translate = [-o4.range[0] / h3 + u4[0] / h3 || 0, -o4.range[1] / d3 + u4[1] / d3 || 0], o4.scaleFract = UY(o4.scale), o4.translateFract = UY(o4.translate);\n                  }\n                  if (i3.dashes) {\n                    let u4 = 0, c5;\n                    if (!i3.dashes || i3.dashes.length < 2) u4 = 1, c5 = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255]);\n                    else {\n                      u4 = 0;\n                      for (let d3 = 0; d3 < i3.dashes.length; ++d3) u4 += i3.dashes[d3];\n                      c5 = new Uint8Array(u4 * Wc.dashMult);\n                      let f4 = 0, h3 = 255;\n                      for (let d3 = 0; d3 < 2; d3++) for (let v3 = 0; v3 < i3.dashes.length; ++v3) {\n                        for (let _2 = 0, b = i3.dashes[v3] * Wc.dashMult * 0.5; _2 < b; ++_2) c5[f4++] = h3;\n                        h3 ^= 255;\n                      }\n                    }\n                    o4.dashLength = u4, o4.dashTexture({ channels: 1, data: c5, width: c5.length, height: 1, mag: "linear", min: "linear" }, 0, 0);\n                  }\n                  if (i3.color) {\n                    let u4 = o4.count, c5 = i3.color;\n                    c5 || (c5 = "transparent");\n                    let f4 = new Uint8Array(u4 * 4 + 4);\n                    if (!Array.isArray(c5) || typeof c5[0] == "number") {\n                      let h3 = yz(c5, "uint8");\n                      for (let d3 = 0; d3 < u4 + 1; d3++) f4.set(h3, d3 * 4);\n                    } else {\n                      for (let h3 = 0; h3 < u4; h3++) {\n                        let d3 = yz(c5[h3], "uint8");\n                        f4.set(d3, h3 * 4);\n                      }\n                      f4.set(yz(c5[0], "uint8"), u4 * 4);\n                    }\n                    o4.colorBuffer({ usage: "dynamic", type: "uint8", data: f4 });\n                  }\n                }\n              }), e3.length < this.passes.length) {\n                for (let i3 = e3.length; i3 < this.passes.length; i3++) {\n                  let a4 = this.passes[i3];\n                  a4 && (a4.colorBuffer.destroy(), a4.positionBuffer.destroy(), a4.dashTexture.destroy());\n                }\n                this.passes.length = e3.length;\n              }\n              let n4 = [];\n              for (let i3 = 0; i3 < this.passes.length; i3++) this.passes[i3] !== null && n4.push(this.passes[i3]);\n              return this.passes = n4, this;\n            };\n            Wc.prototype.destroy = function() {\n              return this.passes.forEach((e3) => {\n                e3.colorBuffer.destroy(), e3.positionBuffer.destroy(), e3.dashTexture.destroy();\n              }), this.passes.length = 0, this;\n            };\n          });\n          var yqe = ye((V1r, mqe) => {\n            "use strict";\n            var CNt = X2(), LNt = J_(), PNt = cY(), INt = Zm(), vqe = Oh(), pqe = Z2(), { float32: RNt, fract32: HY } = ez();\n            mqe.exports = DNt;\n            var gqe = [[1, 0, 0, 1, 0, 0], [1, 0, 0, -1, 0, 0], [-1, 0, 0, -1, 0, 0], [-1, 0, 0, -1, 0, 0], [-1, 0, 0, 1, 0, 0], [1, 0, 0, 1, 0, 0], [1, 0, -1, 0, 0, 1], [1, 0, -1, 0, 0, -1], [1, 0, 1, 0, 0, -1], [1, 0, 1, 0, 0, -1], [1, 0, 1, 0, 0, 1], [1, 0, -1, 0, 0, 1], [-1, 0, -1, 0, 0, 1], [-1, 0, -1, 0, 0, -1], [-1, 0, 1, 0, 0, -1], [-1, 0, 1, 0, 0, -1], [-1, 0, 1, 0, 0, 1], [-1, 0, -1, 0, 0, 1], [0, 1, 1, 0, 0, 0], [0, 1, -1, 0, 0, 0], [0, -1, -1, 0, 0, 0], [0, -1, -1, 0, 0, 0], [0, 1, 1, 0, 0, 0], [0, -1, 1, 0, 0, 0], [0, 1, 0, -1, 1, 0], [0, 1, 0, -1, -1, 0], [0, 1, 0, 1, -1, 0], [0, 1, 0, 1, 1, 0], [0, 1, 0, -1, 1, 0], [0, 1, 0, 1, -1, 0], [0, -1, 0, -1, 1, 0], [0, -1, 0, -1, -1, 0], [0, -1, 0, 1, -1, 0], [0, -1, 0, 1, 1, 0], [0, -1, 0, -1, 1, 0], [0, -1, 0, 1, -1, 0]];\n            function DNt(e3, t3) {\n              if (typeof e3 == "function" ? (t3 || (t3 = {}), t3.regl = e3) : t3 = e3, t3.length && (t3.positions = t3), e3 = t3.regl, !e3.hasExtension("ANGLE_instanced_arrays")) throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");\n              let r4 = e3._gl, n4, i3, a4, o4, s3, l3, u4 = { color: "black", capSize: 5, lineWidth: 1, opacity: 1, viewport: null, range: null, offset: 0, count: 0, bounds: null, positions: [], errors: [] }, c5 = [];\n              return o4 = e3.buffer({ usage: "dynamic", type: "uint8", data: new Uint8Array(0) }), i3 = e3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), a4 = e3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), s3 = e3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) }), l3 = e3.buffer({ usage: "static", type: "float", data: gqe }), v3(t3), n4 = e3({ vert: `\n		precision highp float;\n\n		attribute vec2 position, positionFract;\n		attribute vec4 error;\n		attribute vec4 color;\n\n		attribute vec2 direction, lineOffset, capOffset;\n\n		uniform vec4 viewport;\n		uniform float lineWidth, capSize;\n		uniform vec2 scale, scaleFract, translate, translateFract;\n\n		varying vec4 fragColor;\n\n		void main() {\n			fragColor = color / 255.;\n\n			vec2 pixelOffset = lineWidth * lineOffset + (capSize + lineWidth) * capOffset;\n\n			vec2 dxy = -step(.5, direction.xy) * error.xz + step(direction.xy, vec2(-.5)) * error.yw;\n\n			vec2 position = position + dxy;\n\n			vec2 pos = (position + translate) * scale\n				+ (positionFract + translateFract) * scale\n				+ (position + translate) * scaleFract\n				+ (positionFract + translateFract) * scaleFract;\n\n			pos += pixelOffset / viewport.zw;\n\n			gl_Position = vec4(pos * 2. - 1., 0, 1);\n		}\n		`, frag: `\n		precision highp float;\n\n		varying vec4 fragColor;\n\n		uniform float opacity;\n\n		void main() {\n			gl_FragColor = fragColor;\n			gl_FragColor.a *= opacity;\n		}\n		`, uniforms: { range: e3.prop("range"), lineWidth: e3.prop("lineWidth"), capSize: e3.prop("capSize"), opacity: e3.prop("opacity"), scale: e3.prop("scale"), translate: e3.prop("translate"), scaleFract: e3.prop("scaleFract"), translateFract: e3.prop("translateFract"), viewport: (b, p3) => [p3.viewport.x, p3.viewport.y, b.viewportWidth, b.viewportHeight] }, attributes: { color: { buffer: o4, offset: (b, p3) => p3.offset * 4, divisor: 1 }, position: { buffer: i3, offset: (b, p3) => p3.offset * 8, divisor: 1 }, positionFract: { buffer: a4, offset: (b, p3) => p3.offset * 8, divisor: 1 }, error: { buffer: s3, offset: (b, p3) => p3.offset * 16, divisor: 1 }, direction: { buffer: l3, stride: 24, offset: 0 }, lineOffset: { buffer: l3, stride: 24, offset: 8 }, capOffset: { buffer: l3, stride: 24, offset: 16 } }, primitive: "triangles", blend: { enable: true, color: [0, 0, 0, 0], equation: { rgb: "add", alpha: "add" }, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, depth: { enable: false }, scissor: { enable: true, box: e3.prop("viewport") }, viewport: e3.prop("viewport"), stencil: false, instances: e3.prop("count"), count: gqe.length }), vqe(f4, { update: v3, draw: h3, destroy: _2, regl: e3, gl: r4, canvas: r4.canvas, groups: c5 }), f4;\n              function f4(b) {\n                b ? v3(b) : b === null && _2(), h3();\n              }\n              function h3(b) {\n                if (typeof b == "number") return d3(b);\n                b && !Array.isArray(b) && (b = [b]), e3._refresh(), c5.forEach((p3, k4) => {\n                  if (p3) {\n                    if (b && (b[k4] ? p3.draw = true : p3.draw = false), !p3.draw) {\n                      p3.draw = true;\n                      return;\n                    }\n                    d3(k4);\n                  }\n                });\n              }\n              function d3(b) {\n                typeof b == "number" && (b = c5[b]), b != null && b && b.count && b.color && b.opacity && b.positions && b.positions.length > 1 && (b.scaleRatio = [b.scale[0] * b.viewport.width, b.scale[1] * b.viewport.height], n4(b), b.after && b.after(b));\n              }\n              function v3(b) {\n                if (!b) return;\n                b.length != null ? typeof b[0] == "number" && (b = [{ positions: b }]) : Array.isArray(b) || (b = [b]);\n                let p3 = 0, k4 = 0;\n                if (f4.groups = c5 = b.map((L3, x2) => {\n                  let C3 = c5[x2];\n                  if (L3) typeof L3 == "function" ? L3 = { after: L3 } : typeof L3[0] == "number" && (L3 = { positions: L3 });\n                  else return C3;\n                  return L3 = INt(L3, { color: "color colors fill", capSize: "capSize cap capsize cap-size", lineWidth: "lineWidth line-width width line thickness", opacity: "opacity alpha", range: "range dataBox", viewport: "viewport viewBox", errors: "errors error", positions: "positions position data points" }), C3 || (c5[x2] = C3 = { id: x2, scale: null, translate: null, scaleFract: null, translateFract: null, draw: true }, L3 = vqe({}, u4, L3)), PNt(C3, L3, [{ lineWidth: (M4) => +M4 * 0.5, capSize: (M4) => +M4 * 0.5, opacity: parseFloat, errors: (M4) => (M4 = pqe(M4), k4 += M4.length, M4), positions: (M4, g3) => (M4 = pqe(M4, "float64"), g3.count = Math.floor(M4.length / 2), g3.bounds = CNt(M4, 2), g3.offset = p3, p3 += g3.count, M4) }, { color: (M4, g3) => {\n                    let P3 = g3.count;\n                    if (M4 || (M4 = "transparent"), !Array.isArray(M4) || typeof M4[0] == "number") {\n                      let z3 = M4;\n                      M4 = Array(P3);\n                      for (let O3 = 0; O3 < P3; O3++) M4[O3] = z3;\n                    }\n                    if (M4.length < P3) throw Error("Not enough colors");\n                    let T3 = new Uint8Array(P3 * 4);\n                    for (let z3 = 0; z3 < P3; z3++) {\n                      let O3 = LNt(M4[z3], "uint8");\n                      T3.set(O3, z3 * 4);\n                    }\n                    return T3;\n                  }, range: (M4, g3, P3) => {\n                    let T3 = g3.bounds;\n                    return M4 || (M4 = T3), g3.scale = [1 / (M4[2] - M4[0]), 1 / (M4[3] - M4[1])], g3.translate = [-M4[0], -M4[1]], g3.scaleFract = HY(g3.scale), g3.translateFract = HY(g3.translate), M4;\n                  }, viewport: (M4) => {\n                    let g3;\n                    return Array.isArray(M4) ? g3 = { x: M4[0], y: M4[1], width: M4[2] - M4[0], height: M4[3] - M4[1] } : M4 ? (g3 = { x: M4.x || M4.left || 0, y: M4.y || M4.top || 0 }, M4.right ? g3.width = M4.right - g3.x : g3.width = M4.w || M4.width || 0, M4.bottom ? g3.height = M4.bottom - g3.y : g3.height = M4.h || M4.height || 0) : g3 = { x: 0, y: 0, width: r4.drawingBufferWidth, height: r4.drawingBufferHeight }, g3;\n                  } }]), C3;\n                }), p3 || k4) {\n                  let L3 = c5.reduce((g3, P3, T3) => g3 + (P3 ? P3.count : 0), 0), x2 = new Float64Array(L3 * 2), C3 = new Uint8Array(L3 * 4), M4 = new Float32Array(L3 * 4);\n                  c5.forEach((g3, P3) => {\n                    if (!g3) return;\n                    let { positions: T3, count: z3, offset: O3, color: V2, errors: G2 } = g3;\n                    z3 && (C3.set(V2, O3 * 4), M4.set(G2, O3 * 4), x2.set(T3, O3 * 2));\n                  });\n                  var E3 = RNt(x2);\n                  i3(E3);\n                  var S2 = HY(x2, E3);\n                  a4(S2), o4(C3), s3(M4);\n                }\n              }\n              function _2() {\n                i3.destroy(), a4.destroy(), o4.destroy(), s3.destroy(), l3.destroy();\n              }\n            }\n          });\n          var bqe = ye((G1r, xqe) => {\n            var _qe = /[\\\'\\"]/;\n            xqe.exports = function(t3) {\n              return t3 ? (_qe.test(t3.charAt(0)) && (t3 = t3.substr(1)), _qe.test(t3.charAt(t3.length - 1)) && (t3 = t3.substr(0, t3.length - 1)), t3) : "";\n            };\n          });\n          var jY = ye((H1r, FNt) => {\n            FNt.exports = ["inherit", "initial", "unset"];\n          });\n          var WY = ye((j1r, zNt) => {\n            zNt.exports = ["caption", "icon", "menu", "message-box", "small-caption", "status-bar"];\n          });\n          var XY = ye((W1r, ONt) => {\n            ONt.exports = ["normal", "bold", "bolder", "lighter", "100", "200", "300", "400", "500", "600", "700", "800", "900"];\n          });\n          var ZY = ye((X1r, qNt) => {\n            qNt.exports = ["normal", "italic", "oblique"];\n          });\n          var YY = ye((Z1r, BNt) => {\n            BNt.exports = ["normal", "condensed", "semi-condensed", "extra-condensed", "ultra-condensed", "expanded", "semi-expanded", "extra-expanded", "ultra-expanded"];\n          });\n          var Sqe = ye((Y1r, Aqe) => {\n            "use strict";\n            function wqe(e3, t3) {\n              if (typeof e3 != "string") return [e3];\n              var r4 = [e3];\n              typeof t3 == "string" || Array.isArray(t3) ? t3 = { brackets: t3 } : t3 || (t3 = {});\n              var n4 = t3.brackets ? Array.isArray(t3.brackets) ? t3.brackets : [t3.brackets] : ["{}", "[]", "()"], i3 = t3.escape || "___", a4 = !!t3.flat;\n              n4.forEach(function(l3) {\n                var u4 = new RegExp(["\\\\", l3[0], "[^\\\\", l3[0], "\\\\", l3[1], "]*\\\\", l3[1]].join("")), c5 = [];\n                function f4(h3, d3, v3) {\n                  var _2 = r4.push(h3.slice(l3[0].length, -l3[1].length)) - 1;\n                  return c5.push(_2), i3 + _2 + i3;\n                }\n                r4.forEach(function(h3, d3) {\n                  for (var v3, _2 = 0; h3 != v3; ) if (v3 = h3, h3 = h3.replace(u4, f4), _2++ > 1e4) throw Error("References have circular dependency. Please, check them.");\n                  r4[d3] = h3;\n                }), c5 = c5.reverse(), r4 = r4.map(function(h3) {\n                  return c5.forEach(function(d3) {\n                    h3 = h3.replace(new RegExp("(\\\\" + i3 + d3 + "\\\\" + i3 + ")", "g"), l3[0] + "$1" + l3[1]);\n                  }), h3;\n                });\n              });\n              var o4 = new RegExp("\\\\" + i3 + "([0-9]+)\\\\" + i3);\n              function s3(l3, u4, c5) {\n                for (var f4 = [], h3, d3 = 0; h3 = o4.exec(l3); ) {\n                  if (d3++ > 1e4) throw Error("Circular references in parenthesis");\n                  f4.push(l3.slice(0, h3.index)), f4.push(s3(u4[h3[1]], u4)), l3 = l3.slice(h3.index + h3[0].length);\n                }\n                return f4.push(l3), f4;\n              }\n              return a4 ? r4 : s3(r4[0], r4);\n            }\n            function Tqe(e3, t3) {\n              if (t3 && t3.flat) {\n                var r4 = t3 && t3.escape || "___", n4 = e3[0], i3;\n                if (!n4) return "";\n                for (var a4 = new RegExp("\\\\" + r4 + "([0-9]+)\\\\" + r4), o4 = 0; n4 != i3; ) {\n                  if (o4++ > 1e4) throw Error("Circular references in " + e3);\n                  i3 = n4, n4 = n4.replace(a4, s3);\n                }\n                return n4;\n              }\n              return e3.reduce(function l3(u4, c5) {\n                return Array.isArray(c5) && (c5 = c5.reduce(l3, "")), u4 + c5;\n              }, "");\n              function s3(l3, u4) {\n                if (e3[u4] == null) throw Error("Reference " + u4 + "is undefined");\n                return e3[u4];\n              }\n            }\n            function KY(e3, t3) {\n              return Array.isArray(e3) ? Tqe(e3, t3) : wqe(e3, t3);\n            }\n            KY.parse = wqe;\n            KY.stringify = Tqe;\n            Aqe.exports = KY;\n          });\n          var kqe = ye((K1r, Eqe) => {\n            "use strict";\n            var Mqe = Sqe();\n            Eqe.exports = function(t3, r4, n4) {\n              if (t3 == null) throw Error("First argument should be a string");\n              if (r4 == null) throw Error("Separator should be a string or a RegExp");\n              n4 ? (typeof n4 == "string" || Array.isArray(n4)) && (n4 = { ignore: n4 }) : n4 = {}, n4.escape == null && (n4.escape = true), n4.ignore == null ? n4.ignore = ["[]", "()", "{}", "<>", \'""\', "\'\'", "``", "\\u201C\\u201D", "\\xAB\\xBB"] : (typeof n4.ignore == "string" && (n4.ignore = [n4.ignore]), n4.ignore = n4.ignore.map(function(f4) {\n                return f4.length === 1 && (f4 = f4 + f4), f4;\n              }));\n              var i3 = Mqe.parse(t3, { flat: true, brackets: n4.ignore }), a4 = i3[0], o4 = a4.split(r4);\n              if (n4.escape) {\n                for (var s3 = [], l3 = 0; l3 < o4.length; l3++) {\n                  var u4 = o4[l3], c5 = o4[l3 + 1];\n                  u4[u4.length - 1] === "\\\\" && u4[u4.length - 2] !== "\\\\" ? (s3.push(u4 + r4 + c5), l3++) : s3.push(u4);\n                }\n                o4 = s3;\n              }\n              for (var l3 = 0; l3 < o4.length; l3++) i3[0] = o4[l3], o4[l3] = Mqe.stringify(i3, { flat: true });\n              return o4;\n            };\n          });\n          var Cqe = ye((J1r, NNt) => {\n            NNt.exports = ["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "larger", "smaller"];\n          });\n          var JY = ye(($1r, Lqe) => {\n            "use strict";\n            var UNt = Cqe();\n            Lqe.exports = { isSize: function(t3) {\n              return /^[\\d\\.]/.test(t3) || t3.indexOf("/") !== -1 || UNt.indexOf(t3) !== -1;\n            } };\n          });\n          var Dqe = ye((Q1r, Rqe) => {\n            "use strict";\n            var VNt = bqe(), GNt = jY(), HNt = WY(), jNt = XY(), WNt = ZY(), XNt = YY(), $Y = kqe(), ZNt = JY().isSize;\n            Rqe.exports = Iqe;\n            var Tk = Iqe.cache = {};\n            function Iqe(e3) {\n              if (typeof e3 != "string") throw new Error("Font argument must be a string.");\n              if (Tk[e3]) return Tk[e3];\n              if (e3 === "") throw new Error("Cannot parse an empty string.");\n              if (HNt.indexOf(e3) !== -1) return Tk[e3] = { system: e3 };\n              for (var t3 = { style: "normal", variant: "normal", weight: "normal", stretch: "normal", lineHeight: "normal", size: "1rem", family: ["serif"] }, r4 = $Y(e3, /\\s+/), n4; n4 = r4.shift(); ) {\n                if (GNt.indexOf(n4) !== -1) return ["style", "variant", "weight", "stretch"].forEach(function(a4) {\n                  t3[a4] = n4;\n                }), Tk[e3] = t3;\n                if (WNt.indexOf(n4) !== -1) {\n                  t3.style = n4;\n                  continue;\n                }\n                if (n4 === "normal" || n4 === "small-caps") {\n                  t3.variant = n4;\n                  continue;\n                }\n                if (XNt.indexOf(n4) !== -1) {\n                  t3.stretch = n4;\n                  continue;\n                }\n                if (jNt.indexOf(n4) !== -1) {\n                  t3.weight = n4;\n                  continue;\n                }\n                if (ZNt(n4)) {\n                  var i3 = $Y(n4, "/");\n                  if (t3.size = i3[0], i3[1] != null ? t3.lineHeight = Pqe(i3[1]) : r4[0] === "/" && (r4.shift(), t3.lineHeight = Pqe(r4.shift())), !r4.length) throw new Error("Missing required font-family.");\n                  return t3.family = $Y(r4.join(" "), /\\s*,\\s*/).map(VNt), Tk[e3] = t3;\n                }\n                throw new Error("Unknown or unsupported font token: " + n4);\n              }\n              throw new Error("Missing required font-size.");\n            }\n            function Pqe(e3) {\n              var t3 = parseFloat(e3);\n              return t3.toString() === e3 ? t3 : e3;\n            }\n          });\n          var eK = ye((e_r, Fqe) => {\n            "use strict";\n            var YNt = Zm(), KNt = JY().isSize, JNt = Sk(jY()), $Nt = Sk(WY()), QNt = Sk(XY()), eUt = Sk(ZY()), tUt = Sk(YY()), rUt = { normal: 1, "small-caps": 1 }, iUt = { serif: 1, "sans-serif": 1, monospace: 1, cursive: 1, fantasy: 1, "system-ui": 1 }, QY = { style: "normal", variant: "normal", weight: "normal", stretch: "normal", size: "1rem", lineHeight: "normal", family: "serif" };\n            Fqe.exports = function(t3) {\n              if (t3 = YNt(t3, { style: "style fontstyle fontStyle font-style slope distinction", variant: "variant font-variant fontVariant fontvariant var capitalization", weight: "weight w font-weight fontWeight fontweight", stretch: "stretch font-stretch fontStretch fontstretch width", size: "size s font-size fontSize fontsize height em emSize", lineHeight: "lh line-height lineHeight lineheight leading", family: "font family fontFamily font-family fontfamily type typeface face", system: "system reserved default global" }), t3.system) return t3.system && Ak(t3.system, $Nt), t3.system;\n              if (Ak(t3.style, eUt), Ak(t3.variant, rUt), Ak(t3.weight, QNt), Ak(t3.stretch, tUt), t3.size == null && (t3.size = QY.size), typeof t3.size == "number" && (t3.size += "px"), !KNt) throw Error("Bad size value `" + t3.size + "`");\n              t3.family || (t3.family = QY.family), Array.isArray(t3.family) && (t3.family.length || (t3.family = [QY.family]), t3.family = t3.family.map(function(n4) {\n                return iUt[n4] ? n4 : \'"\' + n4 + \'"\';\n              }).join(", "));\n              var r4 = [];\n              return r4.push(t3.style), t3.variant !== t3.style && r4.push(t3.variant), t3.weight !== t3.variant && t3.weight !== t3.style && r4.push(t3.weight), t3.stretch !== t3.weight && t3.stretch !== t3.variant && t3.stretch !== t3.style && r4.push(t3.stretch), r4.push(t3.size + (t3.lineHeight == null || t3.lineHeight === "normal" || t3.lineHeight + "" == "1" ? "" : "/" + t3.lineHeight)), r4.push(t3.family), r4.filter(Boolean).join(" ");\n            };\n            function Ak(e3, t3) {\n              if (e3 && !t3[e3] && !JNt[e3]) throw Error("Unknown keyword `" + e3 + "`");\n              return e3;\n            }\n            function Sk(e3) {\n              for (var t3 = {}, r4 = 0; r4 < e3.length; r4++) t3[e3[r4]] = 1;\n              return t3;\n            }\n          });\n          var Oqe = ye((t_r, zqe) => {\n            "use strict";\n            zqe.exports = { parse: Dqe(), stringify: eK() };\n          });\n          var qqe = ye((tK, rK) => {\n            (function(e3, t3) {\n              typeof tK == "object" && typeof rK != "undefined" ? rK.exports = t3() : e3.createREGL = t3();\n            })(tK, function() {\n              "use strict";\n              var e3 = function(Me, bt) {\n                for (var zt = Object.keys(bt), Rr = 0; Rr < zt.length; ++Rr) Me[zt[Rr]] = bt[zt[Rr]];\n                return Me;\n              }, t3 = 0, r4 = 0, n4 = 5, i3 = 6;\n              function a4(Me, bt) {\n                this.id = t3++, this.type = Me, this.data = bt;\n              }\n              function o4(Me) {\n                return Me.replace(/\\\\/g, "\\\\\\\\").replace(/"/g, \'\\\\"\');\n              }\n              function s3(Me) {\n                if (Me.length === 0) return [];\n                var bt = Me.charAt(0), zt = Me.charAt(Me.length - 1);\n                if (Me.length > 1 && bt === zt && (bt === \'"\' || bt === "\'")) return [\'"\' + o4(Me.substr(1, Me.length - 2)) + \'"\'];\n                var Rr = /\\[(false|true|null|\\d+|\'[^\']*\'|"[^"]*")\\]/.exec(Me);\n                if (Rr) return s3(Me.substr(0, Rr.index)).concat(s3(Rr[1])).concat(s3(Me.substr(Rr.index + Rr[0].length)));\n                var jr = Me.split(".");\n                if (jr.length === 1) return [\'"\' + o4(Me) + \'"\'];\n                for (var Nr = [], Gr = 0; Gr < jr.length; ++Gr) Nr = Nr.concat(s3(jr[Gr]));\n                return Nr;\n              }\n              function l3(Me) {\n                return "[" + s3(Me).join("][") + "]";\n              }\n              function u4(Me, bt) {\n                return new a4(Me, l3(bt + ""));\n              }\n              function c5(Me) {\n                return typeof Me == "function" && !Me._reglType || Me instanceof a4;\n              }\n              function f4(Me, bt) {\n                if (typeof Me == "function") return new a4(r4, Me);\n                if (typeof Me == "number" || typeof Me == "boolean") return new a4(n4, Me);\n                if (Array.isArray(Me)) return new a4(i3, Me.map(function(zt, Rr) {\n                  return f4(zt, bt + "[" + Rr + "]");\n                }));\n                if (Me instanceof a4) return Me;\n              }\n              var h3 = { DynamicVariable: a4, define: u4, isDynamic: c5, unbox: f4, accessor: l3 }, d3 = { next: typeof requestAnimationFrame == "function" ? function(Me) {\n                return requestAnimationFrame(Me);\n              } : function(Me) {\n                return setTimeout(Me, 16);\n              }, cancel: typeof cancelAnimationFrame == "function" ? function(Me) {\n                return cancelAnimationFrame(Me);\n              } : clearTimeout }, v3 = typeof performance != "undefined" && performance.now ? function() {\n                return performance.now();\n              } : function() {\n                return +/* @__PURE__ */ new Date();\n              };\n              function _2() {\n                var Me = { "": 0 }, bt = [""];\n                return { id: function(zt) {\n                  var Rr = Me[zt];\n                  return Rr || (Rr = Me[zt] = bt.length, bt.push(zt), Rr);\n                }, str: function(zt) {\n                  return bt[zt];\n                } };\n              }\n              function b(Me, bt, zt) {\n                var Rr = document.createElement("canvas");\n                e3(Rr.style, { border: 0, margin: 0, padding: 0, top: 0, left: 0, width: "100%", height: "100%" }), Me.appendChild(Rr), Me === document.body && (Rr.style.position = "absolute", e3(Me.style, { margin: 0, padding: 0 }));\n                function jr() {\n                  var mi = window.innerWidth, Ui = window.innerHeight;\n                  if (Me !== document.body) {\n                    var qi = Rr.getBoundingClientRect();\n                    mi = qi.right - qi.left, Ui = qi.bottom - qi.top;\n                  }\n                  Rr.width = zt * mi, Rr.height = zt * Ui;\n                }\n                var Nr;\n                Me !== document.body && typeof ResizeObserver == "function" ? (Nr = new ResizeObserver(function() {\n                  setTimeout(jr);\n                }), Nr.observe(Me)) : window.addEventListener("resize", jr, false);\n                function Gr() {\n                  Nr ? Nr.disconnect() : window.removeEventListener("resize", jr), Me.removeChild(Rr);\n                }\n                return jr(), { canvas: Rr, onDestroy: Gr };\n              }\n              function p3(Me, bt) {\n                function zt(Rr) {\n                  try {\n                    return Me.getContext(Rr, bt);\n                  } catch (jr) {\n                    return null;\n                  }\n                }\n                return zt("webgl") || zt("experimental-webgl") || zt("webgl-experimental");\n              }\n              function k4(Me) {\n                return typeof Me.nodeName == "string" && typeof Me.appendChild == "function" && typeof Me.getBoundingClientRect == "function";\n              }\n              function E3(Me) {\n                return typeof Me.drawArrays == "function" || typeof Me.drawElements == "function";\n              }\n              function S2(Me) {\n                return typeof Me == "string" ? Me.split() : Me;\n              }\n              function L3(Me) {\n                return typeof Me == "string" ? document.querySelector(Me) : Me;\n              }\n              function x2(Me) {\n                var bt = Me || {}, zt, Rr, jr, Nr, Gr = {}, mi = [], Ui = [], qi = typeof window == "undefined" ? 1 : window.devicePixelRatio, Ei = false, Hn = {}, en = function(Mr) {\n                }, Wi = function() {\n                };\n                if (typeof bt == "string" ? zt = document.querySelector(bt) : typeof bt == "object" && (k4(bt) ? zt = bt : E3(bt) ? (Nr = bt, jr = Nr.canvas) : ("gl" in bt ? Nr = bt.gl : "canvas" in bt ? jr = L3(bt.canvas) : "container" in bt && (Rr = L3(bt.container)), "attributes" in bt && (Gr = bt.attributes), "extensions" in bt && (mi = S2(bt.extensions)), "optionalExtensions" in bt && (Ui = S2(bt.optionalExtensions)), "onDone" in bt && (en = bt.onDone), "profile" in bt && (Ei = !!bt.profile), "pixelRatio" in bt && (qi = +bt.pixelRatio), "cachedCode" in bt && (Hn = bt.cachedCode))), zt && (zt.nodeName.toLowerCase() === "canvas" ? jr = zt : Rr = zt), !Nr) {\n                  if (!jr) {\n                    var si = b(Rr || document.body, en, qi);\n                    if (!si) return null;\n                    jr = si.canvas, Wi = si.onDestroy;\n                  }\n                  Gr.premultipliedAlpha === void 0 && (Gr.premultipliedAlpha = true), Nr = p3(jr, Gr);\n                }\n                return Nr ? { gl: Nr, canvas: jr, container: Rr, extensions: mi, optionalExtensions: Ui, pixelRatio: qi, profile: Ei, cachedCode: Hn, onDone: en, onDestroy: Wi } : (Wi(), en("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org"), null);\n              }\n              function C3(Me, bt) {\n                var zt = {};\n                function Rr(Gr) {\n                  var mi = Gr.toLowerCase(), Ui;\n                  try {\n                    Ui = zt[mi] = Me.getExtension(mi);\n                  } catch (qi) {\n                  }\n                  return !!Ui;\n                }\n                for (var jr = 0; jr < bt.extensions.length; ++jr) {\n                  var Nr = bt.extensions[jr];\n                  if (!Rr(Nr)) return bt.onDestroy(), bt.onDone(\'"\' + Nr + \'" extension is not supported by the current WebGL context, try upgrading your system or a different browser\'), null;\n                }\n                return bt.optionalExtensions.forEach(Rr), { extensions: zt, restore: function() {\n                  Object.keys(zt).forEach(function(Gr) {\n                    if (zt[Gr] && !Rr(Gr)) throw new Error("(regl): error restoring extension " + Gr);\n                  });\n                } };\n              }\n              function M4(Me, bt) {\n                for (var zt = Array(Me), Rr = 0; Rr < Me; ++Rr) zt[Rr] = bt(Rr);\n                return zt;\n              }\n              var g3 = 5120, P3 = 5121, T3 = 5122, z3 = 5123, O3 = 5124, V2 = 5125, G2 = 5126;\n              function Z(Me) {\n                for (var bt = 16; bt <= 1 << 28; bt *= 16) if (Me <= bt) return bt;\n                return 0;\n              }\n              function j3(Me) {\n                var bt, zt;\n                return bt = (Me > 65535) << 4, Me >>>= bt, zt = (Me > 255) << 3, Me >>>= zt, bt |= zt, zt = (Me > 15) << 2, Me >>>= zt, bt |= zt, zt = (Me > 3) << 1, Me >>>= zt, bt |= zt, bt | Me >> 1;\n              }\n              function N2() {\n                var Me = M4(8, function() {\n                  return [];\n                });\n                function bt(Nr) {\n                  var Gr = Z(Nr), mi = Me[j3(Gr) >> 2];\n                  return mi.length > 0 ? mi.pop() : new ArrayBuffer(Gr);\n                }\n                function zt(Nr) {\n                  Me[j3(Nr.byteLength) >> 2].push(Nr);\n                }\n                function Rr(Nr, Gr) {\n                  var mi = null;\n                  switch (Nr) {\n                    case g3:\n                      mi = new Int8Array(bt(Gr), 0, Gr);\n                      break;\n                    case P3:\n                      mi = new Uint8Array(bt(Gr), 0, Gr);\n                      break;\n                    case T3:\n                      mi = new Int16Array(bt(2 * Gr), 0, Gr);\n                      break;\n                    case z3:\n                      mi = new Uint16Array(bt(2 * Gr), 0, Gr);\n                      break;\n                    case O3:\n                      mi = new Int32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    case V2:\n                      mi = new Uint32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    case G2:\n                      mi = new Float32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    default:\n                      return null;\n                  }\n                  return mi.length !== Gr ? mi.subarray(0, Gr) : mi;\n                }\n                function jr(Nr) {\n                  zt(Nr.buffer);\n                }\n                return { alloc: bt, free: zt, allocType: Rr, freeType: jr };\n              }\n              var H = N2();\n              H.zero = N2();\n              var te = 3408, oe = 3410, _e = 3411, Ee = 3412, Ce = 3413, me = 3414, ie = 3415, Se = 33901, Le = 33902, Ae = 3379, Fe = 3386, Pe = 34921, ge = 36347, Re = 36348, ce = 35661, Ze = 35660, ut = 34930, pt = 36349, Zt = 34076, st = 34024, lt = 7936, Gt = 7937, Nt = 7938, Jt = 35724, sr = 34047, wr = 36063, cr = 34852, $e = 3553, St = 34067, Qt = 34069, Vt = 33984, _t = 6408, It = 5126, mt = 5121, er = 36160, lr = 36053, Tr = 36064, Lr = 16384, ti = function(Me, bt) {\n                var zt = 1;\n                bt.ext_texture_filter_anisotropic && (zt = Me.getParameter(sr));\n                var Rr = 1, jr = 1;\n                bt.webgl_draw_buffers && (Rr = Me.getParameter(cr), jr = Me.getParameter(wr));\n                var Nr = !!bt.oes_texture_float;\n                if (Nr) {\n                  var Gr = Me.createTexture();\n                  Me.bindTexture($e, Gr), Me.texImage2D($e, 0, _t, 1, 1, 0, _t, It, null);\n                  var mi = Me.createFramebuffer();\n                  if (Me.bindFramebuffer(er, mi), Me.framebufferTexture2D(er, Tr, $e, Gr, 0), Me.bindTexture($e, null), Me.checkFramebufferStatus(er) !== lr) Nr = false;\n                  else {\n                    Me.viewport(0, 0, 1, 1), Me.clearColor(1, 0, 0, 1), Me.clear(Lr);\n                    var Ui = H.allocType(It, 4);\n                    Me.readPixels(0, 0, 1, 1, _t, It, Ui), Me.getError() ? Nr = false : (Me.deleteFramebuffer(mi), Me.deleteTexture(Gr), Nr = Ui[0] === 1), H.freeType(Ui);\n                  }\n                }\n                var qi = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent)), Ei = true;\n                if (!qi) {\n                  var Hn = Me.createTexture(), en = H.allocType(mt, 36);\n                  Me.activeTexture(Vt), Me.bindTexture(St, Hn), Me.texImage2D(Qt, 0, _t, 3, 3, 0, _t, mt, en), H.freeType(en), Me.bindTexture(St, null), Me.deleteTexture(Hn), Ei = !Me.getError();\n                }\n                return { colorBits: [Me.getParameter(oe), Me.getParameter(_e), Me.getParameter(Ee), Me.getParameter(Ce)], depthBits: Me.getParameter(me), stencilBits: Me.getParameter(ie), subpixelBits: Me.getParameter(te), extensions: Object.keys(bt).filter(function(Wi) {\n                  return !!bt[Wi];\n                }), maxAnisotropic: zt, maxDrawbuffers: Rr, maxColorAttachments: jr, pointSizeDims: Me.getParameter(Se), lineWidthDims: Me.getParameter(Le), maxViewportDims: Me.getParameter(Fe), maxCombinedTextureUnits: Me.getParameter(ce), maxCubeMapSize: Me.getParameter(Zt), maxRenderbufferSize: Me.getParameter(st), maxTextureUnits: Me.getParameter(ut), maxTextureSize: Me.getParameter(Ae), maxAttributes: Me.getParameter(Pe), maxVertexUniforms: Me.getParameter(ge), maxVertexTextureUnits: Me.getParameter(Ze), maxVaryingVectors: Me.getParameter(Re), maxFragmentUniforms: Me.getParameter(pt), glsl: Me.getParameter(Jt), renderer: Me.getParameter(Gt), vendor: Me.getParameter(lt), version: Me.getParameter(Nt), readFloat: Nr, npotTextureCube: Ei };\n              }, Br = function(Me) {\n                return Me instanceof Uint8Array || Me instanceof Uint16Array || Me instanceof Uint32Array || Me instanceof Int8Array || Me instanceof Int16Array || Me instanceof Int32Array || Me instanceof Float32Array || Me instanceof Float64Array || Me instanceof Uint8ClampedArray;\n              };\n              function Vr(Me) {\n                return !!Me && typeof Me == "object" && Array.isArray(Me.shape) && Array.isArray(Me.stride) && typeof Me.offset == "number" && Me.shape.length === Me.stride.length && (Array.isArray(Me.data) || Br(Me.data));\n              }\n              var dt = function(Me) {\n                return Object.keys(Me).map(function(bt) {\n                  return Me[bt];\n                });\n              }, Ge = { shape: xe, flatten: Ie };\n              function Je(Me, bt, zt) {\n                for (var Rr = 0; Rr < bt; ++Rr) zt[Rr] = Me[Rr];\n              }\n              function je(Me, bt, zt, Rr) {\n                for (var jr = 0, Nr = 0; Nr < bt; ++Nr) for (var Gr = Me[Nr], mi = 0; mi < zt; ++mi) Rr[jr++] = Gr[mi];\n              }\n              function tt(Me, bt, zt, Rr, jr, Nr) {\n                for (var Gr = Nr, mi = 0; mi < bt; ++mi) for (var Ui = Me[mi], qi = 0; qi < zt; ++qi) for (var Ei = Ui[qi], Hn = 0; Hn < Rr; ++Hn) jr[Gr++] = Ei[Hn];\n              }\n              function xt(Me, bt, zt, Rr, jr) {\n                for (var Nr = 1, Gr = zt + 1; Gr < bt.length; ++Gr) Nr *= bt[Gr];\n                var mi = bt[zt];\n                if (bt.length - zt === 4) {\n                  var Ui = bt[zt + 1], qi = bt[zt + 2], Ei = bt[zt + 3];\n                  for (Gr = 0; Gr < mi; ++Gr) tt(Me[Gr], Ui, qi, Ei, Rr, jr), jr += Nr;\n                } else for (Gr = 0; Gr < mi; ++Gr) xt(Me[Gr], bt, zt + 1, Rr, jr), jr += Nr;\n              }\n              function Ie(Me, bt, zt, Rr) {\n                var jr = 1;\n                if (bt.length) for (var Nr = 0; Nr < bt.length; ++Nr) jr *= bt[Nr];\n                else jr = 0;\n                var Gr = Rr || H.allocType(zt, jr);\n                switch (bt.length) {\n                  case 0:\n                    break;\n                  case 1:\n                    Je(Me, bt[0], Gr);\n                    break;\n                  case 2:\n                    je(Me, bt[0], bt[1], Gr);\n                    break;\n                  case 3:\n                    tt(Me, bt[0], bt[1], bt[2], Gr, 0);\n                    break;\n                  default:\n                    xt(Me, bt, 0, Gr, 0);\n                }\n                return Gr;\n              }\n              function xe(Me) {\n                for (var bt = [], zt = Me; zt.length; zt = zt[0]) bt.push(zt.length);\n                return bt;\n              }\n              var ke = { "[object Int8Array]": 5120, "[object Int16Array]": 5122, "[object Int32Array]": 5124, "[object Uint8Array]": 5121, "[object Uint8ClampedArray]": 5121, "[object Uint16Array]": 5123, "[object Uint32Array]": 5125, "[object Float32Array]": 5126, "[object Float64Array]": 5121, "[object ArrayBuffer]": 5121 }, vt = 5120, ir = 5122, ar = 5124, vr = 5121, ii = 5123, pi = 5125, $r = 5126, di = 5126, ji = { int8: vt, int16: ir, int32: ar, uint8: vr, uint16: ii, uint32: pi, float: $r, float32: di }, In = 35048, wi = 35040, On = { dynamic: In, stream: wi, static: 35044 }, qn = Ge.flatten, Fn = Ge.shape, ra = 35044, la = 35040, Ut = 5121, wt = 5126, rr = [];\n              rr[5120] = 1, rr[5122] = 2, rr[5124] = 4, rr[5121] = 1, rr[5123] = 2, rr[5125] = 4, rr[5126] = 4;\n              function nr(Me) {\n                return ke[Object.prototype.toString.call(Me)] | 0;\n              }\n              function Er(Me, bt) {\n                for (var zt = 0; zt < bt.length; ++zt) Me[zt] = bt[zt];\n              }\n              function Xr(Me, bt, zt, Rr, jr, Nr, Gr) {\n                for (var mi = 0, Ui = 0; Ui < zt; ++Ui) for (var qi = 0; qi < Rr; ++qi) Me[mi++] = bt[jr * Ui + Nr * qi + Gr];\n              }\n              function ri(Me, bt, zt, Rr) {\n                var jr = 0, Nr = {};\n                function Gr(Mr) {\n                  this.id = jr++, this.buffer = Me.createBuffer(), this.type = Mr, this.usage = ra, this.byteLength = 0, this.dimension = 1, this.dtype = Ut, this.persistentData = null, zt.profile && (this.stats = { size: 0 });\n                }\n                Gr.prototype.bind = function() {\n                  Me.bindBuffer(this.type, this.buffer);\n                }, Gr.prototype.destroy = function() {\n                  en(this);\n                };\n                var mi = [];\n                function Ui(Mr, Yr) {\n                  var xi = mi.pop();\n                  return xi || (xi = new Gr(Mr)), xi.bind(), Hn(xi, Yr, la, 0, 1, false), xi;\n                }\n                function qi(Mr) {\n                  mi.push(Mr);\n                }\n                function Ei(Mr, Yr, xi) {\n                  Mr.byteLength = Yr.byteLength, Me.bufferData(Mr.type, Yr, xi);\n                }\n                function Hn(Mr, Yr, xi, Ri, ci, an) {\n                  var Zi;\n                  if (Mr.usage = xi, Array.isArray(Yr)) {\n                    if (Mr.dtype = Ri || wt, Yr.length > 0) {\n                      var Bn;\n                      if (Array.isArray(Yr[0])) {\n                        Zi = Fn(Yr);\n                        for (var hi = 1, li = 1; li < Zi.length; ++li) hi *= Zi[li];\n                        Mr.dimension = hi, Bn = qn(Yr, Zi, Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn);\n                      } else if (typeof Yr[0] == "number") {\n                        Mr.dimension = ci;\n                        var mn = H.allocType(Mr.dtype, Yr.length);\n                        Er(mn, Yr), Ei(Mr, mn, xi), an ? Mr.persistentData = mn : H.freeType(mn);\n                      } else Br(Yr[0]) && (Mr.dimension = Yr[0].length, Mr.dtype = Ri || nr(Yr[0]) || wt, Bn = qn(Yr, [Yr.length, Yr[0].length], Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn));\n                    }\n                  } else if (Br(Yr)) Mr.dtype = Ri || nr(Yr), Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr.buffer)));\n                  else if (Vr(Yr)) {\n                    Zi = Yr.shape;\n                    var Ji = Yr.stride, Vi = Yr.offset, Ni = 0, pn = 0, Vn = 0, na = 0;\n                    Zi.length === 1 ? (Ni = Zi[0], pn = 1, Vn = Ji[0], na = 0) : Zi.length === 2 && (Ni = Zi[0], pn = Zi[1], Vn = Ji[0], na = Ji[1]), Mr.dtype = Ri || nr(Yr.data) || wt, Mr.dimension = pn;\n                    var Ki = H.allocType(Mr.dtype, Ni * pn);\n                    Xr(Ki, Yr.data, Ni, pn, Vn, na, Vi), Ei(Mr, Ki, xi), an ? Mr.persistentData = Ki : H.freeType(Ki);\n                  } else Yr instanceof ArrayBuffer && (Mr.dtype = Ut, Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr))));\n                }\n                function en(Mr) {\n                  bt.bufferCount--, Rr(Mr);\n                  var Yr = Mr.buffer;\n                  Me.deleteBuffer(Yr), Mr.buffer = null, delete Nr[Mr.id];\n                }\n                function Wi(Mr, Yr, xi, Ri) {\n                  bt.bufferCount++;\n                  var ci = new Gr(Yr);\n                  Nr[ci.id] = ci;\n                  function an(hi) {\n                    var li = ra, mn = null, Ji = 0, Vi = 0, Ni = 1;\n                    return Array.isArray(hi) || Br(hi) || Vr(hi) || hi instanceof ArrayBuffer ? mn = hi : typeof hi == "number" ? Ji = hi | 0 : hi && ("data" in hi && (mn = hi.data), "usage" in hi && (li = On[hi.usage]), "type" in hi && (Vi = ji[hi.type]), "dimension" in hi && (Ni = hi.dimension | 0), "length" in hi && (Ji = hi.length | 0)), ci.bind(), mn ? Hn(ci, mn, li, Vi, Ni, Ri) : (Ji && Me.bufferData(ci.type, Ji, li), ci.dtype = Vi || Ut, ci.usage = li, ci.dimension = Ni, ci.byteLength = Ji), zt.profile && (ci.stats.size = ci.byteLength * rr[ci.dtype]), an;\n                  }\n                  function Zi(hi, li) {\n                    Me.bufferSubData(ci.type, li, hi);\n                  }\n                  function Bn(hi, li) {\n                    var mn = (li || 0) | 0, Ji;\n                    if (ci.bind(), Br(hi) || hi instanceof ArrayBuffer) Zi(hi, mn);\n                    else if (Array.isArray(hi)) {\n                      if (hi.length > 0) {\n                        if (typeof hi[0] == "number") {\n                          var Vi = H.allocType(ci.dtype, hi.length);\n                          Er(Vi, hi), Zi(Vi, mn), H.freeType(Vi);\n                        } else if (Array.isArray(hi[0]) || Br(hi[0])) {\n                          Ji = Fn(hi);\n                          var Ni = qn(hi, Ji, ci.dtype);\n                          Zi(Ni, mn), H.freeType(Ni);\n                        }\n                      }\n                    } else if (Vr(hi)) {\n                      Ji = hi.shape;\n                      var pn = hi.stride, Vn = 0, na = 0, Ki = 0, kn = 0;\n                      Ji.length === 1 ? (Vn = Ji[0], na = 1, Ki = pn[0], kn = 0) : Ji.length === 2 && (Vn = Ji[0], na = Ji[1], Ki = pn[0], kn = pn[1]);\n                      var ta = Array.isArray(hi.data) ? ci.dtype : nr(hi.data), oa = H.allocType(ta, Vn * na);\n                      Xr(oa, hi.data, Vn, na, Ki, kn, hi.offset), Zi(oa, mn), H.freeType(oa);\n                    }\n                    return an;\n                  }\n                  return xi || an(Mr), an._reglType = "buffer", an._buffer = ci, an.subdata = Bn, zt.profile && (an.stats = ci.stats), an.destroy = function() {\n                    en(ci);\n                  }, an;\n                }\n                function si() {\n                  dt(Nr).forEach(function(Mr) {\n                    Mr.buffer = Me.createBuffer(), Me.bindBuffer(Mr.type, Mr.buffer), Me.bufferData(Mr.type, Mr.persistentData || Mr.byteLength, Mr.usage);\n                  });\n                }\n                return zt.profile && (bt.getTotalBufferSize = function() {\n                  var Mr = 0;\n                  return Object.keys(Nr).forEach(function(Yr) {\n                    Mr += Nr[Yr].stats.size;\n                  }), Mr;\n                }), { create: Wi, createStream: Ui, destroyStream: qi, clear: function() {\n                  dt(Nr).forEach(en), mi.forEach(en);\n                }, getBuffer: function(Mr) {\n                  return Mr && Mr._buffer instanceof Gr ? Mr._buffer : null;\n                }, restore: si, _initBuffer: Hn };\n              }\n              var Qr = 0, Oi = 0, $i = 1, tn = 1, fn = 4, yn = 4, Sn = { points: Qr, point: Oi, lines: $i, line: tn, triangles: fn, triangle: yn, "line loop": 2, "line strip": 3, "triangle strip": 5, "triangle fan": 6 }, Ba = 0, ua = 1, ma = 4, Wa = 5120, Fa = 5121, Wo = 5122, da = 5123, Wn = 5124, Ha = 5125, vo = 34963, jn = 35040, Mt = 35044;\n              function kr(Me, bt, zt, Rr) {\n                var jr = {}, Nr = 0, Gr = { uint8: Fa, uint16: da };\n                bt.oes_element_index_uint && (Gr.uint32 = Ha);\n                function mi(si) {\n                  this.id = Nr++, jr[this.id] = this, this.buffer = si, this.primType = ma, this.vertCount = 0, this.type = 0;\n                }\n                mi.prototype.bind = function() {\n                  this.buffer.bind();\n                };\n                var Ui = [];\n                function qi(si) {\n                  var Mr = Ui.pop();\n                  return Mr || (Mr = new mi(zt.create(null, vo, true, false)._buffer)), Hn(Mr, si, jn, -1, -1, 0, 0), Mr;\n                }\n                function Ei(si) {\n                  Ui.push(si);\n                }\n                function Hn(si, Mr, Yr, xi, Ri, ci, an) {\n                  si.buffer.bind();\n                  var Zi;\n                  if (Mr) {\n                    var Bn = an;\n                    !an && (!Br(Mr) || Vr(Mr) && !Br(Mr.data)) && (Bn = bt.oes_element_index_uint ? Ha : da), zt._initBuffer(si.buffer, Mr, Yr, Bn, 3);\n                  } else Me.bufferData(vo, ci, Yr), si.buffer.dtype = Zi || Fa, si.buffer.usage = Yr, si.buffer.dimension = 3, si.buffer.byteLength = ci;\n                  if (Zi = an, !an) {\n                    switch (si.buffer.dtype) {\n                      case Fa:\n                      case Wa:\n                        Zi = Fa;\n                        break;\n                      case da:\n                      case Wo:\n                        Zi = da;\n                        break;\n                      case Ha:\n                      case Wn:\n                        Zi = Ha;\n                        break;\n                      default:\n                    }\n                    si.buffer.dtype = Zi;\n                  }\n                  si.type = Zi;\n                  var hi = Ri;\n                  hi < 0 && (hi = si.buffer.byteLength, Zi === da ? hi >>= 1 : Zi === Ha && (hi >>= 2)), si.vertCount = hi;\n                  var li = xi;\n                  if (xi < 0) {\n                    li = ma;\n                    var mn = si.buffer.dimension;\n                    mn === 1 && (li = Ba), mn === 2 && (li = ua), mn === 3 && (li = ma);\n                  }\n                  si.primType = li;\n                }\n                function en(si) {\n                  Rr.elementsCount--, delete jr[si.id], si.buffer.destroy(), si.buffer = null;\n                }\n                function Wi(si, Mr) {\n                  var Yr = zt.create(null, vo, true), xi = new mi(Yr._buffer);\n                  Rr.elementsCount++;\n                  function Ri(ci) {\n                    if (!ci) Yr(), xi.primType = ma, xi.vertCount = 0, xi.type = Fa;\n                    else if (typeof ci == "number") Yr(ci), xi.primType = ma, xi.vertCount = ci | 0, xi.type = Fa;\n                    else {\n                      var an = null, Zi = Mt, Bn = -1, hi = -1, li = 0, mn = 0;\n                      Array.isArray(ci) || Br(ci) || Vr(ci) ? an = ci : ("data" in ci && (an = ci.data), "usage" in ci && (Zi = On[ci.usage]), "primitive" in ci && (Bn = Sn[ci.primitive]), "count" in ci && (hi = ci.count | 0), "type" in ci && (mn = Gr[ci.type]), "length" in ci ? li = ci.length | 0 : (li = hi, mn === da || mn === Wo ? li *= 2 : (mn === Ha || mn === Wn) && (li *= 4))), Hn(xi, an, Zi, Bn, hi, li, mn);\n                    }\n                    return Ri;\n                  }\n                  return Ri(si), Ri._reglType = "elements", Ri._elements = xi, Ri.subdata = function(ci, an) {\n                    return Yr.subdata(ci, an), Ri;\n                  }, Ri.destroy = function() {\n                    en(xi);\n                  }, Ri;\n                }\n                return { create: Wi, createStream: qi, destroyStream: Ei, getElements: function(si) {\n                  return typeof si == "function" && si._elements instanceof mi ? si._elements : null;\n                }, clear: function() {\n                  dt(jr).forEach(en);\n                } };\n              }\n              var Jr = new Float32Array(1), vi = new Uint32Array(Jr.buffer), hn = 5123;\n              function An(Me) {\n                for (var bt = H.allocType(hn, Me.length), zt = 0; zt < Me.length; ++zt) if (isNaN(Me[zt])) bt[zt] = 65535;\n                else if (Me[zt] === 1 / 0) bt[zt] = 31744;\n                else if (Me[zt] === -1 / 0) bt[zt] = 64512;\n                else {\n                  Jr[0] = Me[zt];\n                  var Rr = vi[0], jr = Rr >>> 31 << 15, Nr = (Rr << 1 >>> 24) - 127, Gr = Rr >> 13 & 1023;\n                  if (Nr < -24) bt[zt] = jr;\n                  else if (Nr < -14) {\n                    var mi = -14 - Nr;\n                    bt[zt] = jr + (Gr + 1024 >> mi);\n                  } else Nr > 15 ? bt[zt] = jr + 31744 : bt[zt] = jr + (Nr + 15 << 10) + Gr;\n                }\n                return bt;\n              }\n              function Mn(Me) {\n                return Array.isArray(Me) || Br(Me);\n              }\n              var Li = 34467, _n = 3553, ya = 34067, Jn = 34069, Ma = 6408, _o = 6406, No = 6407, po = 6409, Lo = 6410, ko = 32854, Ds = 32855, Fs = 36194, ll = 32819, ul = 32820, zl = 33635, us = 34042, il = 6402, As = 34041, cl = 35904, Ks = 35906, zs = 36193, Io = 33776, ls = 33777, Zl = 33778, Su = 33779, nc = 35986, bs = 35987, Rn = 34798, _a = 35840, Vu = 35841, Ol = 35842, xo = 35843, Yl = 36196, Ns = 5121, Hl = 5123, ac = 5125, aa = 5126, Oo = 10242, qo = 10243, ql = 10497, Pc = 33071, Do = 33648, rf = 10240, Uf = 10241, pl = 9728, Zc = 9729, Kl = 9984, Os = 9985, yu = 9986, oc = 9987, Cf = 33170, sc = 4352, Vh = 4353, Lf = 4354, cs = 34046, nf = 3317, Vf = 37440, Jl = 37441, fl = 37443, lc = 37444, Fu = 33984, Es = [Kl, yu, Os, oc], Hs = [0, po, Lo, No, Ma], Go = {};\n              Go[po] = Go[_o] = Go[il] = 1, Go[As] = Go[Lo] = 2, Go[No] = Go[cl] = 3, Go[Ma] = Go[Ks] = 4;\n              function ps(Me) {\n                return "[object " + Me + "]";\n              }\n              var uc = ps("HTMLCanvasElement"), xl = ps("OffscreenCanvas"), Gu = ps("CanvasRenderingContext2D"), qs = ps("ImageBitmap"), ad = ps("HTMLImageElement"), Po = ps("HTMLVideoElement"), od = Object.keys(ke).concat([uc, xl, Gu, qs, ad, Po]), Yo = [];\n              Yo[Ns] = 1, Yo[aa] = 4, Yo[zs] = 2, Yo[Hl] = 2, Yo[ac] = 4;\n              var Pa = [];\n              Pa[ko] = 2, Pa[Ds] = 2, Pa[Fs] = 2, Pa[As] = 4, Pa[Io] = 0.5, Pa[ls] = 0.5, Pa[Zl] = 1, Pa[Su] = 1, Pa[nc] = 0.5, Pa[bs] = 1, Pa[Rn] = 1, Pa[_a] = 0.5, Pa[Vu] = 0.25, Pa[Ol] = 0.5, Pa[xo] = 0.25, Pa[Yl] = 0.5;\n              function af(Me) {\n                return Array.isArray(Me) && (Me.length === 0 || typeof Me[0] == "number");\n              }\n              function Hu(Me) {\n                if (!Array.isArray(Me)) return false;\n                var bt = Me.length;\n                return !(bt === 0 || !Mn(Me[0]));\n              }\n              function bl(Me) {\n                return Object.prototype.toString.call(Me);\n              }\n              function Gf(Me) {\n                return bl(Me) === uc;\n              }\n              function Ic(Me) {\n                return bl(Me) === xl;\n              }\n              function yf(Me) {\n                return bl(Me) === Gu;\n              }\n              function Bl(Me) {\n                return bl(Me) === qs;\n              }\n              function wh(Me) {\n                return bl(Me) === ad;\n              }\n              function Qf(Me) {\n                return bl(Me) === Po;\n              }\n              function _f(Me) {\n                if (!Me) return false;\n                var bt = bl(Me);\n                return od.indexOf(bt) >= 0 ? true : af(Me) || Hu(Me) || Vr(Me);\n              }\n              function Yc(Me) {\n                return ke[Object.prototype.toString.call(Me)] | 0;\n              }\n              function eh(Me, bt) {\n                var zt = bt.length;\n                switch (Me.type) {\n                  case Ns:\n                  case Hl:\n                  case ac:\n                  case aa:\n                    var Rr = H.allocType(Me.type, zt);\n                    Rr.set(bt), Me.data = Rr;\n                    break;\n                  case zs:\n                    Me.data = An(bt);\n                    break;\n                  default:\n                }\n              }\n              function th(Me, bt) {\n                return H.allocType(Me.type === zs ? aa : Me.type, bt);\n              }\n              function ju(Me, bt) {\n                Me.type === zs ? (Me.data = An(bt), H.freeType(bt)) : Me.data = bt;\n              }\n              function Hf(Me, bt, zt, Rr, jr, Nr) {\n                for (var Gr = Me.width, mi = Me.height, Ui = Me.channels, qi = Gr * mi * Ui, Ei = th(Me, qi), Hn = 0, en = 0; en < mi; ++en) for (var Wi = 0; Wi < Gr; ++Wi) for (var si = 0; si < Ui; ++si) Ei[Hn++] = bt[zt * Wi + Rr * en + jr * si + Nr];\n                ju(Me, Ei);\n              }\n              function cc(Me, bt, zt, Rr, jr, Nr) {\n                var Gr;\n                if (typeof Pa[Me] != "undefined" ? Gr = Pa[Me] : Gr = Go[Me] * Yo[bt], Nr && (Gr *= 6), jr) {\n                  for (var mi = 0, Ui = zt; Ui >= 1; ) mi += Gr * Ui * Ui, Ui /= 2;\n                  return mi;\n                } else return Gr * zt * Rr;\n              }\n              function of(Me, bt, zt, Rr, jr, Nr, Gr) {\n                var mi = { "don\'t care": sc, "dont care": sc, nice: Lf, fast: Vh }, Ui = { repeat: ql, clamp: Pc, mirror: Do }, qi = { nearest: pl, linear: Zc }, Ei = e3({ mipmap: oc, "nearest mipmap nearest": Kl, "linear mipmap nearest": Os, "nearest mipmap linear": yu, "linear mipmap linear": oc }, qi), Hn = { none: 0, browser: lc }, en = { uint8: Ns, rgba4: ll, rgb565: zl, "rgb5 a1": ul }, Wi = { alpha: _o, luminance: po, "luminance alpha": Lo, rgb: No, rgba: Ma, rgba4: ko, "rgb5 a1": Ds, rgb565: Fs }, si = {};\n                bt.ext_srgb && (Wi.srgb = cl, Wi.srgba = Ks), bt.oes_texture_float && (en.float32 = en.float = aa), bt.oes_texture_half_float && (en.float16 = en["half float"] = zs), bt.webgl_depth_texture && (e3(Wi, { depth: il, "depth stencil": As }), e3(en, { uint16: Hl, uint32: ac, "depth stencil": us })), bt.webgl_compressed_texture_s3tc && e3(si, { "rgb s3tc dxt1": Io, "rgba s3tc dxt1": ls, "rgba s3tc dxt3": Zl, "rgba s3tc dxt5": Su }), bt.webgl_compressed_texture_atc && e3(si, { "rgb atc": nc, "rgba atc explicit alpha": bs, "rgba atc interpolated alpha": Rn }), bt.webgl_compressed_texture_pvrtc && e3(si, { "rgb pvrtc 4bppv1": _a, "rgb pvrtc 2bppv1": Vu, "rgba pvrtc 4bppv1": Ol, "rgba pvrtc 2bppv1": xo }), bt.webgl_compressed_texture_etc1 && (si["rgb etc1"] = Yl);\n                var Mr = Array.prototype.slice.call(Me.getParameter(Li));\n                Object.keys(si).forEach(function(ne) {\n                  var we = si[ne];\n                  Mr.indexOf(we) >= 0 && (Wi[ne] = we);\n                });\n                var Yr = Object.keys(Wi);\n                zt.textureFormats = Yr;\n                var xi = [];\n                Object.keys(Wi).forEach(function(ne) {\n                  var we = Wi[ne];\n                  xi[we] = ne;\n                });\n                var Ri = [];\n                Object.keys(en).forEach(function(ne) {\n                  var we = en[ne];\n                  Ri[we] = ne;\n                });\n                var ci = [];\n                Object.keys(qi).forEach(function(ne) {\n                  var we = qi[ne];\n                  ci[we] = ne;\n                });\n                var an = [];\n                Object.keys(Ei).forEach(function(ne) {\n                  var we = Ei[ne];\n                  an[we] = ne;\n                });\n                var Zi = [];\n                Object.keys(Ui).forEach(function(ne) {\n                  var we = Ui[ne];\n                  Zi[we] = ne;\n                });\n                var Bn = Yr.reduce(function(ne, we) {\n                  var Ue = Wi[we];\n                  return Ue === po || Ue === _o || Ue === po || Ue === Lo || Ue === il || Ue === As || bt.ext_srgb && (Ue === cl || Ue === Ks) ? ne[Ue] = Ue : Ue === Ds || we.indexOf("rgba") >= 0 ? ne[Ue] = Ma : ne[Ue] = No, ne;\n                }, {});\n                function hi() {\n                  this.internalformat = Ma, this.format = Ma, this.type = Ns, this.compressed = false, this.premultiplyAlpha = false, this.flipY = false, this.unpackAlignment = 1, this.colorSpace = lc, this.width = 0, this.height = 0, this.channels = 0;\n                }\n                function li(ne, we) {\n                  ne.internalformat = we.internalformat, ne.format = we.format, ne.type = we.type, ne.compressed = we.compressed, ne.premultiplyAlpha = we.premultiplyAlpha, ne.flipY = we.flipY, ne.unpackAlignment = we.unpackAlignment, ne.colorSpace = we.colorSpace, ne.width = we.width, ne.height = we.height, ne.channels = we.channels;\n                }\n                function mn(ne, we) {\n                  if (!(typeof we != "object" || !we)) {\n                    if ("premultiplyAlpha" in we && (ne.premultiplyAlpha = we.premultiplyAlpha), "flipY" in we && (ne.flipY = we.flipY), "alignment" in we && (ne.unpackAlignment = we.alignment), "colorSpace" in we && (ne.colorSpace = Hn[we.colorSpace]), "type" in we) {\n                      var Ue = we.type;\n                      ne.type = en[Ue];\n                    }\n                    var ft = ne.width, Xt = ne.height, hr = ne.channels, qt = false;\n                    "shape" in we ? (ft = we.shape[0], Xt = we.shape[1], we.shape.length === 3 && (hr = we.shape[2], qt = true)) : ("radius" in we && (ft = Xt = we.radius), "width" in we && (ft = we.width), "height" in we && (Xt = we.height), "channels" in we && (hr = we.channels, qt = true)), ne.width = ft | 0, ne.height = Xt | 0, ne.channels = hr | 0;\n                    var Ve = false;\n                    if ("format" in we) {\n                      var Qe = we.format, at = ne.internalformat = Wi[Qe];\n                      ne.format = Bn[at], Qe in en && ("type" in we || (ne.type = en[Qe])), Qe in si && (ne.compressed = true), Ve = true;\n                    }\n                    !qt && Ve ? ne.channels = Go[ne.format] : qt && !Ve && ne.channels !== Hs[ne.format] && (ne.format = ne.internalformat = Hs[ne.channels]);\n                  }\n                }\n                function Ji(ne) {\n                  Me.pixelStorei(Vf, ne.flipY), Me.pixelStorei(Jl, ne.premultiplyAlpha), Me.pixelStorei(fl, ne.colorSpace), Me.pixelStorei(nf, ne.unpackAlignment);\n                }\n                function Vi() {\n                  hi.call(this), this.xOffset = 0, this.yOffset = 0, this.data = null, this.needsFree = false, this.element = null, this.needsCopy = false;\n                }\n                function Ni(ne, we) {\n                  var Ue = null;\n                  if (_f(we) ? Ue = we : we && (mn(ne, we), "x" in we && (ne.xOffset = we.x | 0), "y" in we && (ne.yOffset = we.y | 0), _f(we.data) && (Ue = we.data)), we.copy) {\n                    var ft = jr.viewportWidth, Xt = jr.viewportHeight;\n                    ne.width = ne.width || ft - ne.xOffset, ne.height = ne.height || Xt - ne.yOffset, ne.needsCopy = true;\n                  } else if (!Ue) ne.width = ne.width || 1, ne.height = ne.height || 1, ne.channels = ne.channels || 4;\n                  else if (Br(Ue)) ne.channels = ne.channels || 4, ne.data = Ue, !("type" in we) && ne.type === Ns && (ne.type = Yc(Ue));\n                  else if (af(Ue)) ne.channels = ne.channels || 4, eh(ne, Ue), ne.alignment = 1, ne.needsFree = true;\n                  else if (Vr(Ue)) {\n                    var hr = Ue.data;\n                    !Array.isArray(hr) && ne.type === Ns && (ne.type = Yc(hr));\n                    var qt = Ue.shape, Ve = Ue.stride, Qe, at, Ct, Ot, Rt, Bt;\n                    qt.length === 3 ? (Ct = qt[2], Bt = Ve[2]) : (Ct = 1, Bt = 1), Qe = qt[0], at = qt[1], Ot = Ve[0], Rt = Ve[1], ne.alignment = 1, ne.width = Qe, ne.height = at, ne.channels = Ct, ne.format = ne.internalformat = Hs[Ct], ne.needsFree = true, Hf(ne, hr, Ot, Rt, Bt, Ue.offset);\n                  } else if (Gf(Ue) || Ic(Ue) || yf(Ue)) Gf(Ue) || Ic(Ue) ? ne.element = Ue : ne.element = Ue.canvas, ne.width = ne.element.width, ne.height = ne.element.height, ne.channels = 4;\n                  else if (Bl(Ue)) ne.element = Ue, ne.width = Ue.width, ne.height = Ue.height, ne.channels = 4;\n                  else if (wh(Ue)) ne.element = Ue, ne.width = Ue.naturalWidth, ne.height = Ue.naturalHeight, ne.channels = 4;\n                  else if (Qf(Ue)) ne.element = Ue, ne.width = Ue.videoWidth, ne.height = Ue.videoHeight, ne.channels = 4;\n                  else if (Hu(Ue)) {\n                    var Dt = ne.width || Ue[0].length, yt = ne.height || Ue.length, Pt = ne.channels;\n                    Mn(Ue[0][0]) ? Pt = Pt || Ue[0][0].length : Pt = Pt || 1;\n                    for (var ht = Ge.shape(Ue), ur = 1, br = 0; br < ht.length; ++br) ur *= ht[br];\n                    var Ur = th(ne, ur);\n                    Ge.flatten(Ue, ht, "", Ur), ju(ne, Ur), ne.alignment = 1, ne.width = Dt, ne.height = yt, ne.channels = Pt, ne.format = ne.internalformat = Hs[Pt], ne.needsFree = true;\n                  }\n                  ne.type === aa || ne.type;\n                }\n                function pn(ne, we, Ue) {\n                  var ft = ne.element, Xt = ne.data, hr = ne.internalformat, qt = ne.format, Ve = ne.type, Qe = ne.width, at = ne.height;\n                  Ji(ne), ft ? Me.texImage2D(we, Ue, qt, qt, Ve, ft) : ne.compressed ? Me.compressedTexImage2D(we, Ue, hr, Qe, at, 0, Xt) : ne.needsCopy ? (Rr(), Me.copyTexImage2D(we, Ue, qt, ne.xOffset, ne.yOffset, Qe, at, 0)) : Me.texImage2D(we, Ue, qt, Qe, at, 0, qt, Ve, Xt || null);\n                }\n                function Vn(ne, we, Ue, ft, Xt) {\n                  var hr = ne.element, qt = ne.data, Ve = ne.internalformat, Qe = ne.format, at = ne.type, Ct = ne.width, Ot = ne.height;\n                  Ji(ne), hr ? Me.texSubImage2D(we, Xt, Ue, ft, Qe, at, hr) : ne.compressed ? Me.compressedTexSubImage2D(we, Xt, Ue, ft, Ve, Ct, Ot, qt) : ne.needsCopy ? (Rr(), Me.copyTexSubImage2D(we, Xt, Ue, ft, ne.xOffset, ne.yOffset, Ct, Ot)) : Me.texSubImage2D(we, Xt, Ue, ft, Ct, Ot, Qe, at, qt);\n                }\n                var na = [];\n                function Ki() {\n                  return na.pop() || new Vi();\n                }\n                function kn(ne) {\n                  ne.needsFree && H.freeType(ne.data), Vi.call(ne), na.push(ne);\n                }\n                function ta() {\n                  hi.call(this), this.genMipmaps = false, this.mipmapHint = sc, this.mipmask = 0, this.images = Array(16);\n                }\n                function oa(ne, we, Ue) {\n                  var ft = ne.images[0] = Ki();\n                  ne.mipmask = 1, ft.width = ne.width = we, ft.height = ne.height = Ue, ft.channels = ne.channels = 4;\n                }\n                function ba(ne, we) {\n                  var Ue = null;\n                  if (_f(we)) Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;\n                  else if (mn(ne, we), Array.isArray(we.mipmap)) for (var ft = we.mipmap, Xt = 0; Xt < ft.length; ++Xt) Ue = ne.images[Xt] = Ki(), li(Ue, ne), Ue.width >>= Xt, Ue.height >>= Xt, Ni(Ue, ft[Xt]), ne.mipmask |= 1 << Xt;\n                  else Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;\n                  li(ne, ne.images[0]), ne.compressed && (ne.internalformat === Io || ne.internalformat === ls || ne.internalformat === Zl || ne.internalformat);\n                }\n                function is(ne, we) {\n                  for (var Ue = ne.images, ft = 0; ft < Ue.length; ++ft) {\n                    if (!Ue[ft]) return;\n                    pn(Ue[ft], we, ft);\n                  }\n                }\n                var Zs = [];\n                function Va() {\n                  var ne = Zs.pop() || new ta();\n                  hi.call(ne), ne.mipmask = 0;\n                  for (var we = 0; we < 16; ++we) ne.images[we] = null;\n                  return ne;\n                }\n                function Ml(ne) {\n                  for (var we = ne.images, Ue = 0; Ue < we.length; ++Ue) we[Ue] && kn(we[Ue]), we[Ue] = null;\n                  Zs.push(ne);\n                }\n                function zo() {\n                  this.minFilter = pl, this.magFilter = pl, this.wrapS = Pc, this.wrapT = Pc, this.anisotropic = 1, this.genMipmaps = false, this.mipmapHint = sc;\n                }\n                function Qs(ne, we) {\n                  if ("min" in we) {\n                    var Ue = we.min;\n                    ne.minFilter = Ei[Ue], Es.indexOf(ne.minFilter) >= 0 && !("faces" in we) && (ne.genMipmaps = true);\n                  }\n                  if ("mag" in we) {\n                    var ft = we.mag;\n                    ne.magFilter = qi[ft];\n                  }\n                  var Xt = ne.wrapS, hr = ne.wrapT;\n                  if ("wrap" in we) {\n                    var qt = we.wrap;\n                    typeof qt == "string" ? Xt = hr = Ui[qt] : Array.isArray(qt) && (Xt = Ui[qt[0]], hr = Ui[qt[1]]);\n                  } else {\n                    if ("wrapS" in we) {\n                      var Ve = we.wrapS;\n                      Xt = Ui[Ve];\n                    }\n                    if ("wrapT" in we) {\n                      var Qe = we.wrapT;\n                      hr = Ui[Qe];\n                    }\n                  }\n                  if (ne.wrapS = Xt, ne.wrapT = hr, "anisotropic" in we) {\n                    var at = we.anisotropic;\n                    ne.anisotropic = we.anisotropic;\n                  }\n                  if ("mipmap" in we) {\n                    var Ct = false;\n                    switch (typeof we.mipmap) {\n                      case "string":\n                        ne.mipmapHint = mi[we.mipmap], ne.genMipmaps = true, Ct = true;\n                        break;\n                      case "boolean":\n                        Ct = ne.genMipmaps = we.mipmap;\n                        break;\n                      case "object":\n                        ne.genMipmaps = false, Ct = true;\n                        break;\n                      default:\n                    }\n                    Ct && !("min" in we) && (ne.minFilter = Kl);\n                  }\n                }\n                function al(ne, we) {\n                  Me.texParameteri(we, Uf, ne.minFilter), Me.texParameteri(we, rf, ne.magFilter), Me.texParameteri(we, Oo, ne.wrapS), Me.texParameteri(we, qo, ne.wrapT), bt.ext_texture_filter_anisotropic && Me.texParameteri(we, cs, ne.anisotropic), ne.genMipmaps && (Me.hint(Cf, ne.mipmapHint), Me.generateMipmap(we));\n                }\n                var Vl = 0, ss = {}, Vs = zt.maxTextureUnits, Ys = Array(Vs).map(function() {\n                  return null;\n                });\n                function wa(ne) {\n                  hi.call(this), this.mipmask = 0, this.internalformat = Ma, this.id = Vl++, this.refCount = 1, this.target = ne, this.texture = Me.createTexture(), this.unit = -1, this.bindCount = 0, this.texInfo = new zo(), Gr.profile && (this.stats = { size: 0 });\n                }\n                function ol(ne) {\n                  Me.activeTexture(Fu), Me.bindTexture(ne.target, ne.texture);\n                }\n                function io() {\n                  var ne = Ys[0];\n                  ne ? Me.bindTexture(ne.target, ne.texture) : Me.bindTexture(_n, null);\n                }\n                function Y(ne) {\n                  var we = ne.texture, Ue = ne.unit, ft = ne.target;\n                  Ue >= 0 && (Me.activeTexture(Fu + Ue), Me.bindTexture(ft, null), Ys[Ue] = null), Me.deleteTexture(we), ne.texture = null, ne.params = null, ne.pixels = null, ne.refCount = 0, delete ss[ne.id], Nr.textureCount--;\n                }\n                e3(wa.prototype, { bind: function() {\n                  var ne = this;\n                  ne.bindCount += 1;\n                  var we = ne.unit;\n                  if (we < 0) {\n                    for (var Ue = 0; Ue < Vs; ++Ue) {\n                      var ft = Ys[Ue];\n                      if (ft) {\n                        if (ft.bindCount > 0) continue;\n                        ft.unit = -1;\n                      }\n                      Ys[Ue] = ne, we = Ue;\n                      break;\n                    }\n                    we >= Vs, Gr.profile && Nr.maxTextureUnits < we + 1 && (Nr.maxTextureUnits = we + 1), ne.unit = we, Me.activeTexture(Fu + we), Me.bindTexture(ne.target, ne.texture);\n                  }\n                  return we;\n                }, unbind: function() {\n                  this.bindCount -= 1;\n                }, decRef: function() {\n                  --this.refCount <= 0 && Y(this);\n                } });\n                function D3(ne, we) {\n                  var Ue = new wa(_n);\n                  ss[Ue.id] = Ue, Nr.textureCount++;\n                  function ft(qt, Ve) {\n                    var Qe = Ue.texInfo;\n                    zo.call(Qe);\n                    var at = Va();\n                    return typeof qt == "number" ? typeof Ve == "number" ? oa(at, qt | 0, Ve | 0) : oa(at, qt | 0, qt | 0) : qt ? (Qs(Qe, qt), ba(at, qt)) : oa(at, 1, 1), Qe.genMipmaps && (at.mipmask = (at.width << 1) - 1), Ue.mipmask = at.mipmask, li(Ue, at), Ue.internalformat = at.internalformat, ft.width = at.width, ft.height = at.height, ol(Ue), is(at, _n), al(Qe, _n), io(), Ml(at), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, at.width, at.height, Qe.genMipmaps, false)), ft.format = xi[Ue.internalformat], ft.type = Ri[Ue.type], ft.mag = ci[Qe.magFilter], ft.min = an[Qe.minFilter], ft.wrapS = Zi[Qe.wrapS], ft.wrapT = Zi[Qe.wrapT], ft;\n                  }\n                  function Xt(qt, Ve, Qe, at) {\n                    var Ct = Ve | 0, Ot = Qe | 0, Rt = at | 0, Bt = Ki();\n                    return li(Bt, Ue), Bt.width = 0, Bt.height = 0, Ni(Bt, qt), Bt.width = Bt.width || (Ue.width >> Rt) - Ct, Bt.height = Bt.height || (Ue.height >> Rt) - Ot, ol(Ue), Vn(Bt, _n, Ct, Ot, Rt), io(), kn(Bt), ft;\n                  }\n                  function hr(qt, Ve) {\n                    var Qe = qt | 0, at = Ve | 0 || Qe;\n                    if (Qe === Ue.width && at === Ue.height) return ft;\n                    ft.width = Ue.width = Qe, ft.height = Ue.height = at, ol(Ue);\n                    for (var Ct = 0; Ue.mipmask >> Ct; ++Ct) {\n                      var Ot = Qe >> Ct, Rt = at >> Ct;\n                      if (!Ot || !Rt) break;\n                      Me.texImage2D(_n, Ct, Ue.format, Ot, Rt, 0, Ue.format, Ue.type, null);\n                    }\n                    return io(), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, Qe, at, false, false)), ft;\n                  }\n                  return ft(ne, we), ft.subimage = Xt, ft.resize = hr, ft._reglType = "texture2d", ft._texture = Ue, Gr.profile && (ft.stats = Ue.stats), ft.destroy = function() {\n                    Ue.decRef();\n                  }, ft;\n                }\n                function J(ne, we, Ue, ft, Xt, hr) {\n                  var qt = new wa(ya);\n                  ss[qt.id] = qt, Nr.cubeCount++;\n                  var Ve = new Array(6);\n                  function Qe(Ot, Rt, Bt, Dt, yt, Pt) {\n                    var ht, ur = qt.texInfo;\n                    for (zo.call(ur), ht = 0; ht < 6; ++ht) Ve[ht] = Va();\n                    if (typeof Ot == "number" || !Ot) {\n                      var br = Ot | 0 || 1;\n                      for (ht = 0; ht < 6; ++ht) oa(Ve[ht], br, br);\n                    } else if (typeof Ot == "object") if (Rt) ba(Ve[0], Ot), ba(Ve[1], Rt), ba(Ve[2], Bt), ba(Ve[3], Dt), ba(Ve[4], yt), ba(Ve[5], Pt);\n                    else if (Qs(ur, Ot), mn(qt, Ot), "faces" in Ot) {\n                      var Ur = Ot.faces;\n                      for (ht = 0; ht < 6; ++ht) li(Ve[ht], qt), ba(Ve[ht], Ur[ht]);\n                    } else for (ht = 0; ht < 6; ++ht) ba(Ve[ht], Ot);\n                    for (li(qt, Ve[0]), ur.genMipmaps ? qt.mipmask = (Ve[0].width << 1) - 1 : qt.mipmask = Ve[0].mipmask, qt.internalformat = Ve[0].internalformat, Qe.width = Ve[0].width, Qe.height = Ve[0].height, ol(qt), ht = 0; ht < 6; ++ht) is(Ve[ht], Jn + ht);\n                    for (al(ur, ya), io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, ur.genMipmaps, true)), Qe.format = xi[qt.internalformat], Qe.type = Ri[qt.type], Qe.mag = ci[ur.magFilter], Qe.min = an[ur.minFilter], Qe.wrapS = Zi[ur.wrapS], Qe.wrapT = Zi[ur.wrapT], ht = 0; ht < 6; ++ht) Ml(Ve[ht]);\n                    return Qe;\n                  }\n                  function at(Ot, Rt, Bt, Dt, yt) {\n                    var Pt = Bt | 0, ht = Dt | 0, ur = yt | 0, br = Ki();\n                    return li(br, qt), br.width = 0, br.height = 0, Ni(br, Rt), br.width = br.width || (qt.width >> ur) - Pt, br.height = br.height || (qt.height >> ur) - ht, ol(qt), Vn(br, Jn + Ot, Pt, ht, ur), io(), kn(br), Qe;\n                  }\n                  function Ct(Ot) {\n                    var Rt = Ot | 0;\n                    if (Rt !== qt.width) {\n                      Qe.width = qt.width = Rt, Qe.height = qt.height = Rt, ol(qt);\n                      for (var Bt = 0; Bt < 6; ++Bt) for (var Dt = 0; qt.mipmask >> Dt; ++Dt) Me.texImage2D(Jn + Bt, Dt, qt.format, Rt >> Dt, Rt >> Dt, 0, qt.format, qt.type, null);\n                      return io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, false, true)), Qe;\n                    }\n                  }\n                  return Qe(ne, we, Ue, ft, Xt, hr), Qe.subimage = at, Qe.resize = Ct, Qe._reglType = "textureCube", Qe._texture = qt, Gr.profile && (Qe.stats = qt.stats), Qe.destroy = function() {\n                    qt.decRef();\n                  }, Qe;\n                }\n                function q2() {\n                  for (var ne = 0; ne < Vs; ++ne) Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Ys[ne] = null;\n                  dt(ss).forEach(Y), Nr.cubeCount = 0, Nr.textureCount = 0;\n                }\n                Gr.profile && (Nr.getTotalTextureSize = function() {\n                  var ne = 0;\n                  return Object.keys(ss).forEach(function(we) {\n                    ne += ss[we].stats.size;\n                  }), ne;\n                });\n                function K() {\n                  for (var ne = 0; ne < Vs; ++ne) {\n                    var we = Ys[ne];\n                    we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null);\n                  }\n                  dt(ss).forEach(function(Ue) {\n                    Ue.texture = Me.createTexture(), Me.bindTexture(Ue.target, Ue.texture);\n                    for (var ft = 0; ft < 32; ++ft) if ((Ue.mipmask & 1 << ft) !== 0) if (Ue.target === _n) Me.texImage2D(_n, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);\n                    else for (var Xt = 0; Xt < 6; ++Xt) Me.texImage2D(Jn + Xt, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);\n                    al(Ue.texInfo, Ue.target);\n                  });\n                }\n                function de() {\n                  for (var ne = 0; ne < Vs; ++ne) {\n                    var we = Ys[ne];\n                    we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null), Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Me.bindTexture(ya, null);\n                  }\n                }\n                return { create2D: D3, createCube: J, clear: q2, getTexture: function(ne) {\n                  return null;\n                }, restore: K, refresh: de };\n              }\n              var Nl = 36161, Kc = 32854, Rc = 32855, gs = 36194, jf = 33189, Gh = 36168, rh = 34041, sf = 35907, Th = 34836, Mu = 34842, ih = 34843, js = [];\n              js[Kc] = 2, js[Rc] = 2, js[gs] = 2, js[jf] = 2, js[Gh] = 1, js[rh] = 4, js[sf] = 4, js[Th] = 16, js[Mu] = 8, js[ih] = 6;\n              function Eu(Me, bt, zt) {\n                return js[Me] * bt * zt;\n              }\n              var Dc = function(Me, bt, zt, Rr, jr) {\n                var Nr = { rgba4: Kc, rgb565: gs, "rgb5 a1": Rc, depth: jf, stencil: Gh, "depth stencil": rh };\n                bt.ext_srgb && (Nr.srgba = sf), bt.ext_color_buffer_half_float && (Nr.rgba16f = Mu, Nr.rgb16f = ih), bt.webgl_color_buffer_float && (Nr.rgba32f = Th);\n                var Gr = [];\n                Object.keys(Nr).forEach(function(Wi) {\n                  var si = Nr[Wi];\n                  Gr[si] = Wi;\n                });\n                var mi = 0, Ui = {};\n                function qi(Wi) {\n                  this.id = mi++, this.refCount = 1, this.renderbuffer = Wi, this.format = Kc, this.width = 0, this.height = 0, jr.profile && (this.stats = { size: 0 });\n                }\n                qi.prototype.decRef = function() {\n                  --this.refCount <= 0 && Ei(this);\n                };\n                function Ei(Wi) {\n                  var si = Wi.renderbuffer;\n                  Me.bindRenderbuffer(Nl, null), Me.deleteRenderbuffer(si), Wi.renderbuffer = null, Wi.refCount = 0, delete Ui[Wi.id], Rr.renderbufferCount--;\n                }\n                function Hn(Wi, si) {\n                  var Mr = new qi(Me.createRenderbuffer());\n                  Ui[Mr.id] = Mr, Rr.renderbufferCount++;\n                  function Yr(Ri, ci) {\n                    var an = 0, Zi = 0, Bn = Kc;\n                    if (typeof Ri == "object" && Ri) {\n                      var hi = Ri;\n                      if ("shape" in hi) {\n                        var li = hi.shape;\n                        an = li[0] | 0, Zi = li[1] | 0;\n                      } else "radius" in hi && (an = Zi = hi.radius | 0), "width" in hi && (an = hi.width | 0), "height" in hi && (Zi = hi.height | 0);\n                      "format" in hi && (Bn = Nr[hi.format]);\n                    } else typeof Ri == "number" ? (an = Ri | 0, typeof ci == "number" ? Zi = ci | 0 : Zi = an) : Ri || (an = Zi = 1);\n                    if (!(an === Mr.width && Zi === Mr.height && Bn === Mr.format)) return Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Mr.format = Bn, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Bn, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height)), Yr.format = Gr[Mr.format], Yr;\n                  }\n                  function xi(Ri, ci) {\n                    var an = Ri | 0, Zi = ci | 0 || an;\n                    return an === Mr.width && Zi === Mr.height || (Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Mr.format, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height))), Yr;\n                  }\n                  return Yr(Wi, si), Yr.resize = xi, Yr._reglType = "renderbuffer", Yr._renderbuffer = Mr, jr.profile && (Yr.stats = Mr.stats), Yr.destroy = function() {\n                    Mr.decRef();\n                  }, Yr;\n                }\n                jr.profile && (Rr.getTotalRenderbufferSize = function() {\n                  var Wi = 0;\n                  return Object.keys(Ui).forEach(function(si) {\n                    Wi += Ui[si].stats.size;\n                  }), Wi;\n                });\n                function en() {\n                  dt(Ui).forEach(function(Wi) {\n                    Wi.renderbuffer = Me.createRenderbuffer(), Me.bindRenderbuffer(Nl, Wi.renderbuffer), Me.renderbufferStorage(Nl, Wi.format, Wi.width, Wi.height);\n                  }), Me.bindRenderbuffer(Nl, null);\n                }\n                return { create: Hn, clear: function() {\n                  dt(Ui).forEach(Ei);\n                }, restore: en };\n              }, ks = 36160, bc = 36161, hu = 3553, _u = 34069, nl = 36064, nh = 36096, Ah = 36128, zu = 33306, Fc = 36053, wc = 36193, bd = 5121, xf = 5126, Pf = 6407, Ou = 6408, bf = [];\n              bf[Ou] = 4, bf[Pf] = 3;\n              var jl = [];\n              jl[bd] = 1, jl[xf] = 4, jl[wc] = 2;\n              function lf(Me, bt, zt, Rr, jr, Nr) {\n                var Gr = { cur: null, next: null, dirty: false, setFBO: null }, mi = ["rgba"], Ui = ["rgba4", "rgb565", "rgb5 a1"];\n                bt.ext_srgb && Ui.push("srgba"), bt.ext_color_buffer_half_float && Ui.push("rgba16f", "rgb16f"), bt.webgl_color_buffer_float && Ui.push("rgba32f");\n                var qi = ["uint8"];\n                bt.oes_texture_half_float && qi.push("half float", "float16"), bt.oes_texture_float && qi.push("float", "float32");\n                function Ei(Vi, Ni, pn) {\n                  this.target = Vi, this.texture = Ni, this.renderbuffer = pn;\n                  var Vn = 0, na = 0;\n                  Ni ? (Vn = Ni.width, na = Ni.height) : pn && (Vn = pn.width, na = pn.height), this.width = Vn, this.height = na;\n                }\n                function Hn(Vi) {\n                  Vi && (Vi.texture && Vi.texture._texture.decRef(), Vi.renderbuffer && Vi.renderbuffer._renderbuffer.decRef());\n                }\n                function en(Vi, Ni, pn) {\n                  if (Vi) if (Vi.texture) {\n                    var Vn = Vi.texture._texture, na = Math.max(1, Vn.width), Ki = Math.max(1, Vn.height);\n                    Vn.refCount += 1;\n                  } else {\n                    var kn = Vi.renderbuffer._renderbuffer;\n                    kn.refCount += 1;\n                  }\n                }\n                function Wi(Vi, Ni) {\n                  Ni && (Ni.texture ? Me.framebufferTexture2D(ks, Vi, Ni.target, Ni.texture._texture.texture, 0) : Me.framebufferRenderbuffer(ks, Vi, bc, Ni.renderbuffer._renderbuffer.renderbuffer));\n                }\n                function si(Vi) {\n                  var Ni = hu, pn = null, Vn = null, na = Vi;\n                  typeof Vi == "object" && (na = Vi.data, "target" in Vi && (Ni = Vi.target | 0));\n                  var Ki = na._reglType;\n                  return Ki === "texture2d" || Ki === "textureCube" ? pn = na : Ki === "renderbuffer" && (Vn = na, Ni = bc), new Ei(Ni, pn, Vn);\n                }\n                function Mr(Vi, Ni, pn, Vn, na) {\n                  if (pn) {\n                    var Ki = Rr.create2D({ width: Vi, height: Ni, format: Vn, type: na });\n                    return Ki._texture.refCount = 0, new Ei(hu, Ki, null);\n                  } else {\n                    var kn = jr.create({ width: Vi, height: Ni, format: Vn });\n                    return kn._renderbuffer.refCount = 0, new Ei(bc, null, kn);\n                  }\n                }\n                function Yr(Vi) {\n                  return Vi && (Vi.texture || Vi.renderbuffer);\n                }\n                function xi(Vi, Ni, pn) {\n                  Vi && (Vi.texture ? Vi.texture.resize(Ni, pn) : Vi.renderbuffer && Vi.renderbuffer.resize(Ni, pn), Vi.width = Ni, Vi.height = pn);\n                }\n                var Ri = 0, ci = {};\n                function an() {\n                  this.id = Ri++, ci[this.id] = this, this.framebuffer = Me.createFramebuffer(), this.width = 0, this.height = 0, this.colorAttachments = [], this.depthAttachment = null, this.stencilAttachment = null, this.depthStencilAttachment = null;\n                }\n                function Zi(Vi) {\n                  Vi.colorAttachments.forEach(Hn), Hn(Vi.depthAttachment), Hn(Vi.stencilAttachment), Hn(Vi.depthStencilAttachment);\n                }\n                function Bn(Vi) {\n                  var Ni = Vi.framebuffer;\n                  Me.deleteFramebuffer(Ni), Vi.framebuffer = null, Nr.framebufferCount--, delete ci[Vi.id];\n                }\n                function hi(Vi) {\n                  var Ni;\n                  Me.bindFramebuffer(ks, Vi.framebuffer);\n                  var pn = Vi.colorAttachments;\n                  for (Ni = 0; Ni < pn.length; ++Ni) Wi(nl + Ni, pn[Ni]);\n                  for (Ni = pn.length; Ni < zt.maxColorAttachments; ++Ni) Me.framebufferTexture2D(ks, nl + Ni, hu, null, 0);\n                  Me.framebufferTexture2D(ks, zu, hu, null, 0), Me.framebufferTexture2D(ks, nh, hu, null, 0), Me.framebufferTexture2D(ks, Ah, hu, null, 0), Wi(nh, Vi.depthAttachment), Wi(Ah, Vi.stencilAttachment), Wi(zu, Vi.depthStencilAttachment);\n                  var Vn = Me.checkFramebufferStatus(ks);\n                  Me.isContextLost(), Me.bindFramebuffer(ks, Gr.next ? Gr.next.framebuffer : null), Gr.cur = Gr.next, Me.getError();\n                }\n                function li(Vi, Ni) {\n                  var pn = new an();\n                  Nr.framebufferCount++;\n                  function Vn(Ki, kn) {\n                    var ta, oa = 0, ba = 0, is = true, Zs = true, Va = null, Ml = true, zo = "rgba", Qs = "uint8", al = 1, Vl = null, ss = null, Vs = null, Ys = false;\n                    if (typeof Ki == "number") oa = Ki | 0, ba = kn | 0 || oa;\n                    else if (!Ki) oa = ba = 1;\n                    else {\n                      var wa = Ki;\n                      if ("shape" in wa) {\n                        var ol = wa.shape;\n                        oa = ol[0], ba = ol[1];\n                      } else "radius" in wa && (oa = ba = wa.radius), "width" in wa && (oa = wa.width), "height" in wa && (ba = wa.height);\n                      ("color" in wa || "colors" in wa) && (Va = wa.color || wa.colors, Array.isArray(Va)), Va || ("colorCount" in wa && (al = wa.colorCount | 0), "colorTexture" in wa && (Ml = !!wa.colorTexture, zo = "rgba4"), "colorType" in wa && (Qs = wa.colorType, Ml || (Qs === "half float" || Qs === "float16" ? zo = "rgba16f" : (Qs === "float" || Qs === "float32") && (zo = "rgba32f"))), "colorFormat" in wa && (zo = wa.colorFormat, mi.indexOf(zo) >= 0 ? Ml = true : Ui.indexOf(zo) >= 0 && (Ml = false))), ("depthTexture" in wa || "depthStencilTexture" in wa) && (Ys = !!(wa.depthTexture || wa.depthStencilTexture)), "depth" in wa && (typeof wa.depth == "boolean" ? is = wa.depth : (Vl = wa.depth, Zs = false)), "stencil" in wa && (typeof wa.stencil == "boolean" ? Zs = wa.stencil : (ss = wa.stencil, is = false)), "depthStencil" in wa && (typeof wa.depthStencil == "boolean" ? is = Zs = wa.depthStencil : (Vs = wa.depthStencil, is = false, Zs = false));\n                    }\n                    var io = null, Y = null, D3 = null, J = null;\n                    if (Array.isArray(Va)) io = Va.map(si);\n                    else if (Va) io = [si(Va)];\n                    else for (io = new Array(al), ta = 0; ta < al; ++ta) io[ta] = Mr(oa, ba, Ml, zo, Qs);\n                    oa = oa || io[0].width, ba = ba || io[0].height, Vl ? Y = si(Vl) : is && !Zs && (Y = Mr(oa, ba, Ys, "depth", "uint32")), ss ? D3 = si(ss) : Zs && !is && (D3 = Mr(oa, ba, false, "stencil", "uint8")), Vs ? J = si(Vs) : !Vl && !ss && Zs && is && (J = Mr(oa, ba, Ys, "depth stencil", "depth stencil"));\n                    var q2 = null;\n                    for (ta = 0; ta < io.length; ++ta) if (en(io[ta], oa, ba), io[ta] && io[ta].texture) {\n                      var K = bf[io[ta].texture._texture.format] * jl[io[ta].texture._texture.type];\n                      q2 === null && (q2 = K);\n                    }\n                    return en(Y, oa, ba), en(D3, oa, ba), en(J, oa, ba), Zi(pn), pn.width = oa, pn.height = ba, pn.colorAttachments = io, pn.depthAttachment = Y, pn.stencilAttachment = D3, pn.depthStencilAttachment = J, Vn.color = io.map(Yr), Vn.depth = Yr(Y), Vn.stencil = Yr(D3), Vn.depthStencil = Yr(J), Vn.width = pn.width, Vn.height = pn.height, hi(pn), Vn;\n                  }\n                  function na(Ki, kn) {\n                    var ta = Math.max(Ki | 0, 1), oa = Math.max(kn | 0 || ta, 1);\n                    if (ta === pn.width && oa === pn.height) return Vn;\n                    for (var ba = pn.colorAttachments, is = 0; is < ba.length; ++is) xi(ba[is], ta, oa);\n                    return xi(pn.depthAttachment, ta, oa), xi(pn.stencilAttachment, ta, oa), xi(pn.depthStencilAttachment, ta, oa), pn.width = Vn.width = ta, pn.height = Vn.height = oa, hi(pn), Vn;\n                  }\n                  return Vn(Vi, Ni), e3(Vn, { resize: na, _reglType: "framebuffer", _framebuffer: pn, destroy: function() {\n                    Bn(pn), Zi(pn);\n                  }, use: function(Ki) {\n                    Gr.setFBO({ framebuffer: Vn }, Ki);\n                  } });\n                }\n                function mn(Vi) {\n                  var Ni = Array(6);\n                  function pn(na) {\n                    var Ki, kn = { color: null }, ta = 0, oa = null, ba = "rgba", is = "uint8", Zs = 1;\n                    if (typeof na == "number") ta = na | 0;\n                    else if (!na) ta = 1;\n                    else {\n                      var Va = na;\n                      if ("shape" in Va) {\n                        var Ml = Va.shape;\n                        ta = Ml[0];\n                      } else "radius" in Va && (ta = Va.radius | 0), "width" in Va ? (ta = Va.width | 0, "height" in Va) : "height" in Va && (ta = Va.height | 0);\n                      ("color" in Va || "colors" in Va) && (oa = Va.color || Va.colors, Array.isArray(oa)), oa || ("colorCount" in Va && (Zs = Va.colorCount | 0), "colorType" in Va && (is = Va.colorType), "colorFormat" in Va && (ba = Va.colorFormat)), "depth" in Va && (kn.depth = Va.depth), "stencil" in Va && (kn.stencil = Va.stencil), "depthStencil" in Va && (kn.depthStencil = Va.depthStencil);\n                    }\n                    var zo;\n                    if (oa) if (Array.isArray(oa)) for (zo = [], Ki = 0; Ki < oa.length; ++Ki) zo[Ki] = oa[Ki];\n                    else zo = [oa];\n                    else {\n                      zo = Array(Zs);\n                      var Qs = { radius: ta, format: ba, type: is };\n                      for (Ki = 0; Ki < Zs; ++Ki) zo[Ki] = Rr.createCube(Qs);\n                    }\n                    for (kn.color = Array(zo.length), Ki = 0; Ki < zo.length; ++Ki) {\n                      var al = zo[Ki];\n                      ta = ta || al.width, kn.color[Ki] = { target: _u, data: zo[Ki] };\n                    }\n                    for (Ki = 0; Ki < 6; ++Ki) {\n                      for (var Vl = 0; Vl < zo.length; ++Vl) kn.color[Vl].target = _u + Ki;\n                      Ki > 0 && (kn.depth = Ni[0].depth, kn.stencil = Ni[0].stencil, kn.depthStencil = Ni[0].depthStencil), Ni[Ki] ? Ni[Ki](kn) : Ni[Ki] = li(kn);\n                    }\n                    return e3(pn, { width: ta, height: ta, color: zo });\n                  }\n                  function Vn(na) {\n                    var Ki, kn = na | 0;\n                    if (kn === pn.width) return pn;\n                    var ta = pn.color;\n                    for (Ki = 0; Ki < ta.length; ++Ki) ta[Ki].resize(kn);\n                    for (Ki = 0; Ki < 6; ++Ki) Ni[Ki].resize(kn);\n                    return pn.width = pn.height = kn, pn;\n                  }\n                  return pn(Vi), e3(pn, { faces: Ni, resize: Vn, _reglType: "framebufferCube", destroy: function() {\n                    Ni.forEach(function(na) {\n                      na.destroy();\n                    });\n                  } });\n                }\n                function Ji() {\n                  Gr.cur = null, Gr.next = null, Gr.dirty = true, dt(ci).forEach(function(Vi) {\n                    Vi.framebuffer = Me.createFramebuffer(), hi(Vi);\n                  });\n                }\n                return e3(Gr, { getFramebuffer: function(Vi) {\n                  if (typeof Vi == "function" && Vi._reglType === "framebuffer") {\n                    var Ni = Vi._framebuffer;\n                    if (Ni instanceof an) return Ni;\n                  }\n                  return null;\n                }, create: li, createCube: mn, clear: function() {\n                  dt(ci).forEach(Bn);\n                }, restore: Ji });\n              }\n              var Hh = 5126, If = 34962, Cs = 34963;\n              function du() {\n                this.state = 0, this.x = 0, this.y = 0, this.z = 0, this.w = 0, this.buffer = null, this.size = 0, this.normalized = false, this.type = Hh, this.offset = 0, this.stride = 0, this.divisor = 0;\n              }\n              function ku(Me, bt, zt, Rr, jr, Nr, Gr) {\n                for (var mi = zt.maxAttributes, Ui = new Array(mi), qi = 0; qi < mi; ++qi) Ui[qi] = new du();\n                var Ei = 0, Hn = {}, en = { Record: du, scope: {}, state: Ui, currentVAO: null, targetVAO: null, restore: si() ? Zi : function() {\n                }, createVAO: Bn, getVAO: Yr, destroyBuffer: Wi, setVAO: si() ? xi : Ri, clear: si() ? ci : function() {\n                } };\n                function Wi(hi) {\n                  for (var li = 0; li < Ui.length; ++li) {\n                    var mn = Ui[li];\n                    mn.buffer === hi && (Me.disableVertexAttribArray(li), mn.buffer = null);\n                  }\n                }\n                function si() {\n                  return bt.oes_vertex_array_object;\n                }\n                function Mr() {\n                  return bt.angle_instanced_arrays;\n                }\n                function Yr(hi) {\n                  return typeof hi == "function" && hi._vao ? hi._vao : null;\n                }\n                function xi(hi) {\n                  if (hi !== en.currentVAO) {\n                    var li = si();\n                    hi ? li.bindVertexArrayOES(hi.vao) : li.bindVertexArrayOES(null), en.currentVAO = hi;\n                  }\n                }\n                function Ri(hi) {\n                  if (hi !== en.currentVAO) {\n                    if (hi) hi.bindAttrs();\n                    else {\n                      for (var li = Mr(), mn = 0; mn < Ui.length; ++mn) {\n                        var Ji = Ui[mn];\n                        Ji.buffer ? (Me.enableVertexAttribArray(mn), Ji.buffer.bind(), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offfset), li && Ji.divisor && li.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));\n                      }\n                      Gr.elements ? Me.bindBuffer(Cs, Gr.elements.buffer.buffer) : Me.bindBuffer(Cs, null);\n                    }\n                    en.currentVAO = hi;\n                  }\n                }\n                function ci() {\n                  dt(Hn).forEach(function(hi) {\n                    hi.destroy();\n                  });\n                }\n                function an() {\n                  this.id = ++Ei, this.attributes = [], this.elements = null, this.ownsElements = false, this.count = 0, this.offset = 0, this.instances = -1, this.primitive = 4;\n                  var hi = si();\n                  hi ? this.vao = hi.createVertexArrayOES() : this.vao = null, Hn[this.id] = this, this.buffers = [];\n                }\n                an.prototype.bindAttrs = function() {\n                  for (var hi = Mr(), li = this.attributes, mn = 0; mn < li.length; ++mn) {\n                    var Ji = li[mn];\n                    Ji.buffer ? (Me.enableVertexAttribArray(mn), Me.bindBuffer(If, Ji.buffer.buffer), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offset), hi && Ji.divisor && hi.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));\n                  }\n                  for (var Vi = li.length; Vi < mi; ++Vi) Me.disableVertexAttribArray(Vi);\n                  var Ni = Nr.getElements(this.elements);\n                  Ni ? Me.bindBuffer(Cs, Ni.buffer.buffer) : Me.bindBuffer(Cs, null);\n                }, an.prototype.refresh = function() {\n                  var hi = si();\n                  hi && (hi.bindVertexArrayOES(this.vao), this.bindAttrs(), en.currentVAO = null, hi.bindVertexArrayOES(null));\n                }, an.prototype.destroy = function() {\n                  if (this.vao) {\n                    var hi = si();\n                    this === en.currentVAO && (en.currentVAO = null, hi.bindVertexArrayOES(null)), hi.deleteVertexArrayOES(this.vao), this.vao = null;\n                  }\n                  this.ownsElements && (this.elements.destroy(), this.elements = null, this.ownsElements = false), Hn[this.id] && (delete Hn[this.id], Rr.vaoCount -= 1);\n                };\n                function Zi() {\n                  var hi = si();\n                  hi && dt(Hn).forEach(function(li) {\n                    li.refresh();\n                  });\n                }\n                function Bn(hi) {\n                  var li = new an();\n                  Rr.vaoCount += 1;\n                  function mn(Ji) {\n                    var Vi;\n                    if (Array.isArray(Ji)) Vi = Ji, li.elements && li.ownsElements && li.elements.destroy(), li.elements = null, li.ownsElements = false, li.offset = 0, li.count = 0, li.instances = -1, li.primitive = 4;\n                    else {\n                      if (Ji.elements) {\n                        var Ni = Ji.elements;\n                        li.ownsElements ? typeof Ni == "function" && Ni._reglType === "elements" ? (li.elements.destroy(), li.ownsElements = false) : (li.elements(Ni), li.ownsElements = false) : Nr.getElements(Ji.elements) ? (li.elements = Ji.elements, li.ownsElements = false) : (li.elements = Nr.create(Ji.elements), li.ownsElements = true);\n                      } else li.elements = null, li.ownsElements = false;\n                      Vi = Ji.attributes, li.offset = 0, li.count = -1, li.instances = -1, li.primitive = 4, li.elements && (li.count = li.elements._elements.vertCount, li.primitive = li.elements._elements.primType), "offset" in Ji && (li.offset = Ji.offset | 0), "count" in Ji && (li.count = Ji.count | 0), "instances" in Ji && (li.instances = Ji.instances | 0), "primitive" in Ji && (li.primitive = Sn[Ji.primitive]);\n                    }\n                    var pn = {}, Vn = li.attributes;\n                    Vn.length = Vi.length;\n                    for (var na = 0; na < Vi.length; ++na) {\n                      var Ki = Vi[na], kn = Vn[na] = new du(), ta = Ki.data || Ki;\n                      if (Array.isArray(ta) || Br(ta) || Vr(ta)) {\n                        var oa;\n                        li.buffers[na] && (oa = li.buffers[na], Br(ta) && oa._buffer.byteLength >= ta.byteLength ? oa.subdata(ta) : (oa.destroy(), li.buffers[na] = null)), li.buffers[na] || (oa = li.buffers[na] = jr.create(Ki, If, false, true)), kn.buffer = jr.getBuffer(oa), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1, pn[na] = 1;\n                      } else jr.getBuffer(Ki) ? (kn.buffer = jr.getBuffer(Ki), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1) : jr.getBuffer(Ki.buffer) ? (kn.buffer = jr.getBuffer(Ki.buffer), kn.size = (+Ki.size || kn.buffer.dimension) | 0, kn.normalized = !!Ki.normalized || false, "type" in Ki ? kn.type = ji[Ki.type] : kn.type = kn.buffer.dtype, kn.offset = (Ki.offset || 0) | 0, kn.stride = (Ki.stride || 0) | 0, kn.divisor = (Ki.divisor || 0) | 0, kn.state = 1) : "x" in Ki && (kn.x = +Ki.x || 0, kn.y = +Ki.y || 0, kn.z = +Ki.z || 0, kn.w = +Ki.w || 0, kn.state = 2);\n                    }\n                    for (var ba = 0; ba < li.buffers.length; ++ba) !pn[ba] && li.buffers[ba] && (li.buffers[ba].destroy(), li.buffers[ba] = null);\n                    return li.refresh(), mn;\n                  }\n                  return mn.destroy = function() {\n                    for (var Ji = 0; Ji < li.buffers.length; ++Ji) li.buffers[Ji] && li.buffers[Ji].destroy();\n                    li.buffers.length = 0, li.ownsElements && (li.elements.destroy(), li.elements = null, li.ownsElements = false), li.destroy();\n                  }, mn._vao = li, mn._reglType = "vao", mn(hi);\n                }\n                return en;\n              }\n              var Wf = 35632, Us = 35633, wf = 35718, zc = 35721;\n              function Wu(Me, bt, zt, Rr) {\n                var jr = {}, Nr = {};\n                function Gr(Mr, Yr, xi, Ri) {\n                  this.name = Mr, this.id = Yr, this.location = xi, this.info = Ri;\n                }\n                function mi(Mr, Yr) {\n                  for (var xi = 0; xi < Mr.length; ++xi) if (Mr[xi].id === Yr.id) {\n                    Mr[xi].location = Yr.location;\n                    return;\n                  }\n                  Mr.push(Yr);\n                }\n                function Ui(Mr, Yr, xi) {\n                  var Ri = Mr === Wf ? jr : Nr, ci = Ri[Yr];\n                  if (!ci) {\n                    var an = bt.str(Yr);\n                    ci = Me.createShader(Mr), Me.shaderSource(ci, an), Me.compileShader(ci), Ri[Yr] = ci;\n                  }\n                  return ci;\n                }\n                var qi = {}, Ei = [], Hn = 0;\n                function en(Mr, Yr) {\n                  this.id = Hn++, this.fragId = Mr, this.vertId = Yr, this.program = null, this.uniforms = [], this.attributes = [], this.refCount = 1, Rr.profile && (this.stats = { uniformsCount: 0, attributesCount: 0 });\n                }\n                function Wi(Mr, Yr, xi) {\n                  var Ri, ci, an = Ui(Wf, Mr.fragId), Zi = Ui(Us, Mr.vertId), Bn = Mr.program = Me.createProgram();\n                  if (Me.attachShader(Bn, an), Me.attachShader(Bn, Zi), xi) for (Ri = 0; Ri < xi.length; ++Ri) {\n                    var hi = xi[Ri];\n                    Me.bindAttribLocation(Bn, hi[0], hi[1]);\n                  }\n                  Me.linkProgram(Bn);\n                  var li = Me.getProgramParameter(Bn, wf);\n                  Rr.profile && (Mr.stats.uniformsCount = li);\n                  var mn = Mr.uniforms;\n                  for (Ri = 0; Ri < li; ++Ri) if (ci = Me.getActiveUniform(Bn, Ri), ci) if (ci.size > 1) for (var Ji = 0; Ji < ci.size; ++Ji) {\n                    var Vi = ci.name.replace("[0]", "[" + Ji + "]");\n                    mi(mn, new Gr(Vi, bt.id(Vi), Me.getUniformLocation(Bn, Vi), ci));\n                  }\n                  else mi(mn, new Gr(ci.name, bt.id(ci.name), Me.getUniformLocation(Bn, ci.name), ci));\n                  var Ni = Me.getProgramParameter(Bn, zc);\n                  Rr.profile && (Mr.stats.attributesCount = Ni);\n                  var pn = Mr.attributes;\n                  for (Ri = 0; Ri < Ni; ++Ri) ci = Me.getActiveAttrib(Bn, Ri), ci && mi(pn, new Gr(ci.name, bt.id(ci.name), Me.getAttribLocation(Bn, ci.name), ci));\n                }\n                Rr.profile && (zt.getMaxUniformsCount = function() {\n                  var Mr = 0;\n                  return Ei.forEach(function(Yr) {\n                    Yr.stats.uniformsCount > Mr && (Mr = Yr.stats.uniformsCount);\n                  }), Mr;\n                }, zt.getMaxAttributesCount = function() {\n                  var Mr = 0;\n                  return Ei.forEach(function(Yr) {\n                    Yr.stats.attributesCount > Mr && (Mr = Yr.stats.attributesCount);\n                  }), Mr;\n                });\n                function si() {\n                  jr = {}, Nr = {};\n                  for (var Mr = 0; Mr < Ei.length; ++Mr) Wi(Ei[Mr], null, Ei[Mr].attributes.map(function(Yr) {\n                    return [Yr.location, Yr.name];\n                  }));\n                }\n                return { clear: function() {\n                  var Mr = Me.deleteShader.bind(Me);\n                  dt(jr).forEach(Mr), jr = {}, dt(Nr).forEach(Mr), Nr = {}, Ei.forEach(function(Yr) {\n                    Me.deleteProgram(Yr.program);\n                  }), Ei.length = 0, qi = {}, zt.shaderCount = 0;\n                }, program: function(Mr, Yr, xi, Ri) {\n                  var ci = qi[Yr];\n                  ci || (ci = qi[Yr] = {});\n                  var an = ci[Mr];\n                  if (an && (an.refCount++, !Ri)) return an;\n                  var Zi = new en(Yr, Mr);\n                  return zt.shaderCount++, Wi(Zi, xi, Ri), an || (ci[Mr] = Zi), Ei.push(Zi), e3(Zi, { destroy: function() {\n                    if (Zi.refCount--, Zi.refCount <= 0) {\n                      Me.deleteProgram(Zi.program);\n                      var Bn = Ei.indexOf(Zi);\n                      Ei.splice(Bn, 1), zt.shaderCount--;\n                    }\n                    ci[Zi.vertId].refCount <= 0 && (Me.deleteShader(Nr[Zi.vertId]), delete Nr[Zi.vertId], delete qi[Zi.fragId][Zi.vertId]), Object.keys(qi[Zi.fragId]).length || (Me.deleteShader(jr[Zi.fragId]), delete jr[Zi.fragId], delete qi[Zi.fragId]);\n                  } });\n                }, restore: si, shader: Ui, frag: -1, vert: -1 };\n              }\n              var Rf = 6408, Xu = 5121, uf = 3333, Xf = 5126;\n              function Wl(Me, bt, zt, Rr, jr, Nr, Gr) {\n                function mi(Ei) {\n                  var Hn;\n                  bt.next === null ? Hn = Xu : Hn = bt.next.colorAttachments[0].texture._texture.type;\n                  var en = 0, Wi = 0, si = Rr.framebufferWidth, Mr = Rr.framebufferHeight, Yr = null;\n                  Br(Ei) ? Yr = Ei : Ei && (en = Ei.x | 0, Wi = Ei.y | 0, si = (Ei.width || Rr.framebufferWidth - en) | 0, Mr = (Ei.height || Rr.framebufferHeight - Wi) | 0, Yr = Ei.data || null), zt();\n                  var xi = si * Mr * 4;\n                  return Yr || (Hn === Xu ? Yr = new Uint8Array(xi) : Hn === Xf && (Yr = Yr || new Float32Array(xi))), Me.pixelStorei(uf, 4), Me.readPixels(en, Wi, si, Mr, Rf, Hn, Yr), Yr;\n                }\n                function Ui(Ei) {\n                  var Hn;\n                  return bt.setFBO({ framebuffer: Ei.framebuffer }, function() {\n                    Hn = mi(Ei);\n                  }), Hn;\n                }\n                function qi(Ei) {\n                  return !Ei || !("framebuffer" in Ei) ? mi(Ei) : Ui(Ei);\n                }\n                return qi;\n              }\n              var ah = 0, Zu = "";\n              function Oc(Me) {\n                return vu(Tc(fc(Me)));\n              }\n              function Tc(Me) {\n                return At(Yi(Bc(Me), Me.length * 8));\n              }\n              function wl(Me, bt) {\n                var zt = Bc(Me);\n                zt.length > 16 && (zt = Yi(zt, Me.length * 8));\n                for (var Rr = Array(16), jr = Array(16), Nr = 0; Nr < 16; Nr++) Rr[Nr] = zt[Nr] ^ 909522486, jr[Nr] = zt[Nr] ^ 1549556828;\n                var Gr = Yi(Rr.concat(Bc(bt)), 512 + bt.length * 8);\n                return At(Yi(jr.concat(Gr), 768));\n              }\n              function vu(Me) {\n                for (var bt = ah ? "0123456789ABCDEF" : "0123456789abcdef", zt = "", Rr, jr = 0; jr < Me.length; jr++) Rr = Me.charCodeAt(jr), zt += bt.charAt(Rr >>> 4 & 15) + bt.charAt(Rr & 15);\n                return zt;\n              }\n              function qc(Me) {\n                for (var bt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", zt = "", Rr = Me.length, jr = 0; jr < Rr; jr += 3) for (var Nr = Me.charCodeAt(jr) << 16 | (jr + 1 < Rr ? Me.charCodeAt(jr + 1) << 8 : 0) | (jr + 2 < Rr ? Me.charCodeAt(jr + 2) : 0), Gr = 0; Gr < 4; Gr++) jr * 8 + Gr * 6 > Me.length * 8 ? zt += Zu : zt += bt.charAt(Nr >>> 6 * (3 - Gr) & 63);\n                return zt;\n              }\n              function cf(Me, bt) {\n                var zt = bt.length, Rr = Array(), jr, Nr, Gr, mi, Ui = Array(Math.ceil(Me.length / 2));\n                for (jr = 0; jr < Ui.length; jr++) Ui[jr] = Me.charCodeAt(jr * 2) << 8 | Me.charCodeAt(jr * 2 + 1);\n                for (; Ui.length > 0; ) {\n                  for (mi = Array(), Gr = 0, jr = 0; jr < Ui.length; jr++) Gr = (Gr << 16) + Ui[jr], Nr = Math.floor(Gr / zt), Gr -= Nr * zt, (mi.length > 0 || Nr > 0) && (mi[mi.length] = Nr);\n                  Rr[Rr.length] = Gr, Ui = mi;\n                }\n                var qi = "";\n                for (jr = Rr.length - 1; jr >= 0; jr--) qi += bt.charAt(Rr[jr]);\n                var Ei = Math.ceil(Me.length * 8 / (Math.log(bt.length) / Math.log(2)));\n                for (jr = qi.length; jr < Ei; jr++) qi = bt[0] + qi;\n                return qi;\n              }\n              function fc(Me) {\n                for (var bt = "", zt = -1, Rr, jr; ++zt < Me.length; ) Rr = Me.charCodeAt(zt), jr = zt + 1 < Me.length ? Me.charCodeAt(zt + 1) : 0, 55296 <= Rr && Rr <= 56319 && 56320 <= jr && jr <= 57343 && (Rr = 65536 + ((Rr & 1023) << 10) + (jr & 1023), zt++), Rr <= 127 ? bt += String.fromCharCode(Rr) : Rr <= 2047 ? bt += String.fromCharCode(192 | Rr >>> 6 & 31, 128 | Rr & 63) : Rr <= 65535 ? bt += String.fromCharCode(224 | Rr >>> 12 & 15, 128 | Rr >>> 6 & 63, 128 | Rr & 63) : Rr <= 2097151 && (bt += String.fromCharCode(240 | Rr >>> 18 & 7, 128 | Rr >>> 12 & 63, 128 | Rr >>> 6 & 63, 128 | Rr & 63));\n                return bt;\n              }\n              function Bc(Me) {\n                for (var bt = Array(Me.length >> 2), zt = 0; zt < bt.length; zt++) bt[zt] = 0;\n                for (var zt = 0; zt < Me.length * 8; zt += 8) bt[zt >> 5] |= (Me.charCodeAt(zt / 8) & 255) << 24 - zt % 32;\n                return bt;\n              }\n              function At(Me) {\n                for (var bt = "", zt = 0; zt < Me.length * 32; zt += 8) bt += String.fromCharCode(Me[zt >> 5] >>> 24 - zt % 32 & 255);\n                return bt;\n              }\n              function Wt(Me, bt) {\n                return Me >>> bt | Me << 32 - bt;\n              }\n              function Cr(Me, bt) {\n                return Me >>> bt;\n              }\n              function Ar(Me, bt, zt) {\n                return Me & bt ^ ~Me & zt;\n              }\n              function Kr(Me, bt, zt) {\n                return Me & bt ^ Me & zt ^ bt & zt;\n              }\n              function ki(Me) {\n                return Wt(Me, 2) ^ Wt(Me, 13) ^ Wt(Me, 22);\n              }\n              function Xi(Me) {\n                return Wt(Me, 6) ^ Wt(Me, 11) ^ Wt(Me, 25);\n              }\n              function dn(Me) {\n                return Wt(Me, 7) ^ Wt(Me, 18) ^ Cr(Me, 3);\n              }\n              function wn(Me) {\n                return Wt(Me, 17) ^ Wt(Me, 19) ^ Cr(Me, 10);\n              }\n              var Nn = new Array(1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998);\n              function Yi(Me, bt) {\n                var zt = new Array(1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225), Rr = new Array(64), jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr;\n                for (Me[bt >> 5] |= 128 << 24 - bt % 32, Me[(bt + 64 >> 9 << 4) + 15] = bt, en = 0; en < Me.length; en += 16) {\n                  for (jr = zt[0], Nr = zt[1], Gr = zt[2], mi = zt[3], Ui = zt[4], qi = zt[5], Ei = zt[6], Hn = zt[7], Wi = 0; Wi < 64; Wi++) Wi < 16 ? Rr[Wi] = Me[Wi + en] : Rr[Wi] = Qi(Qi(Qi(wn(Rr[Wi - 2]), Rr[Wi - 7]), dn(Rr[Wi - 15])), Rr[Wi - 16]), si = Qi(Qi(Qi(Qi(Hn, Xi(Ui)), Ar(Ui, qi, Ei)), Nn[Wi]), Rr[Wi]), Mr = Qi(ki(jr), Kr(jr, Nr, Gr)), Hn = Ei, Ei = qi, qi = Ui, Ui = Qi(mi, si), mi = Gr, Gr = Nr, Nr = jr, jr = Qi(si, Mr);\n                  zt[0] = Qi(jr, zt[0]), zt[1] = Qi(Nr, zt[1]), zt[2] = Qi(Gr, zt[2]), zt[3] = Qi(mi, zt[3]), zt[4] = Qi(Ui, zt[4]), zt[5] = Qi(qi, zt[5]), zt[6] = Qi(Ei, zt[6]), zt[7] = Qi(Hn, zt[7]);\n                }\n                return zt;\n              }\n              function Qi(Me, bt) {\n                var zt = (Me & 65535) + (bt & 65535), Rr = (Me >> 16) + (bt >> 16) + (zt >> 16);\n                return Rr << 16 | zt & 65535;\n              }\n              function on(Me) {\n                return Array.prototype.slice.call(Me);\n              }\n              function Fi(Me) {\n                return on(Me).join("");\n              }\n              function $n(Me) {\n                var bt = Me && Me.cache, zt = 0, Rr = [], jr = [], Nr = [];\n                function Gr(si, Mr) {\n                  var Yr = Mr && Mr.stable;\n                  if (!Yr) {\n                    for (var xi = 0; xi < jr.length; ++xi) if (jr[xi] === si && !Nr[xi]) return Rr[xi];\n                  }\n                  var Ri = "g" + zt++;\n                  return Rr.push(Ri), jr.push(si), Nr.push(Yr), Ri;\n                }\n                function mi() {\n                  var si = [];\n                  function Mr() {\n                    si.push.apply(si, on(arguments));\n                  }\n                  var Yr = [];\n                  function xi() {\n                    var Ri = "v" + zt++;\n                    return Yr.push(Ri), arguments.length > 0 && (si.push(Ri, "="), si.push.apply(si, on(arguments)), si.push(";")), Ri;\n                  }\n                  return e3(Mr, { def: xi, toString: function() {\n                    return Fi([Yr.length > 0 ? "var " + Yr.join(",") + ";" : "", Fi(si)]);\n                  } });\n                }\n                function Ui() {\n                  var si = mi(), Mr = mi(), Yr = si.toString, xi = Mr.toString;\n                  function Ri(ci, an) {\n                    Mr(ci, an, "=", si.def(ci, an), ";");\n                  }\n                  return e3(function() {\n                    si.apply(si, on(arguments));\n                  }, { def: si.def, entry: si, exit: Mr, save: Ri, set: function(ci, an, Zi) {\n                    Ri(ci, an), si(ci, an, "=", Zi, ";");\n                  }, toString: function() {\n                    return Yr() + xi();\n                  } });\n                }\n                function qi() {\n                  var si = Fi(arguments), Mr = Ui(), Yr = Ui(), xi = Mr.toString, Ri = Yr.toString;\n                  return e3(Mr, { then: function() {\n                    return Mr.apply(Mr, on(arguments)), this;\n                  }, else: function() {\n                    return Yr.apply(Yr, on(arguments)), this;\n                  }, toString: function() {\n                    var ci = Ri();\n                    return ci && (ci = "else{" + ci + "}"), Fi(["if(", si, "){", xi(), "}", ci]);\n                  } });\n                }\n                var Ei = mi(), Hn = {};\n                function en(si, Mr) {\n                  var Yr = [];\n                  function xi() {\n                    var Bn = "a" + Yr.length;\n                    return Yr.push(Bn), Bn;\n                  }\n                  Mr = Mr || 0;\n                  for (var Ri = 0; Ri < Mr; ++Ri) xi();\n                  var ci = Ui(), an = ci.toString, Zi = Hn[si] = e3(ci, { arg: xi, toString: function() {\n                    return Fi(["function(", Yr.join(), "){", an(), "}"]);\n                  } });\n                  return Zi;\n                }\n                function Wi() {\n                  var si = [\'"use strict";\', Ei, "return {"];\n                  Object.keys(Hn).forEach(function(Ri) {\n                    si.push(\'"\', Ri, \'":\', Hn[Ri].toString(), ",");\n                  }), si.push("}");\n                  var Mr = Fi(si).replace(/;/g, `;\n`).replace(/}/g, `}\n`).replace(/{/g, `{\n`), Yr;\n                  if (bt && (Yr = Oc(Mr), bt[Yr])) return bt[Yr].apply(null, jr);\n                  var xi = Function.apply(null, Rr.concat(Mr));\n                  return bt && (bt[Yr] = xi), xi.apply(null, jr);\n                }\n                return { global: Ei, link: Gr, block: mi, proc: en, scope: Ui, cond: qi, compile: Wi };\n              }\n              var Ca = "xyzw".split(""), Ra = 5121, La = 1, Na = 2, Yn = 0, Dn = 1, Ka = 2, bo = 3, Xo = 4, Ss = 5, as = 6, ws = "dither", Ho = "blend.enable", ml = "blend.color", Ws = "blend.equation", Ls = "blend.func", va = "depth.enable", no = "depth.func", ys = "depth.range", rs = "depth.mask", $l = "colorMask", Cu = "cull.enable", Yu = "cull.face", Nc = "frontFace", pu = "lineWidth", Uc = "polygonOffset.enable", xu = "polygonOffset.offset", Ac = "sample.alpha", Ua = "sample.enable", oo = "sample.coverage", Vc = "stencil.enable", hc = "stencil.mask", Ku = "stencil.func", ue = "stencil.opFront", w4 = "stencil.opBack", B4 = "scissor.enable", Q = "scissor.box", ee = "viewport", le = "profile", qe = "framebuffer", Xe = "vert", ot = "frag", Tt = "elements", Yt = "primitive", Kt = "count", xr = "offset", Ir = "instances", ve = "vao", be = "Width", De = "Height", Be = qe + be, et = qe + De, We = ee + be, it = ee + De, Ft = "drawingBuffer", Ht = Ft + be, tr = Ft + De, dr = [Ls, Ws, Ku, ue, w4, oo, ee, Q, xu], Sr = 34962, Or = 34963, Wr = 2884, ni = 3042, Pi = 3024, cn = 2960, ln = 2929, Cn = 3089, Kn = 32823, Ta = 32926, fa = 32928, $a = 5126, Co = 35664, Qa = 35665, mo = 35666, Bo = 5124, Ps = 35667, Ts = 35668, wo = 35669, To = 35670, hl = 35671, Ul = 35672, Lu = 35673, au = 35674, Js = 35675, Ql = 35676, dc = 35678, Tl = 35680, Al = 4, X = 1028, se = 1029, Te = 2304, Ne = 2305, He = 32775, Ye = 32776, kt = 519, nt = 7680, jt = 0, gr = 1, yr = 32774, Hr = 513, qr = 36160, _i = 36064, bi = { 0: 0, 1: 1, zero: 0, one: 1, "src color": 768, "one minus src color": 769, "src alpha": 770, "one minus src alpha": 771, "dst color": 774, "one minus dst color": 775, "dst alpha": 772, "one minus dst alpha": 773, "constant color": 32769, "one minus constant color": 32770, "constant alpha": 32771, "one minus constant alpha": 32772, "src alpha saturate": 776 }, Zr = { never: 512, less: 513, "<": 513, equal: 514, "=": 514, "==": 514, "===": 514, lequal: 515, "<=": 515, greater: 516, ">": 516, notequal: 517, "!=": 517, "!==": 517, gequal: 518, ">=": 518, always: 519 }, ai = { 0: 0, zero: 0, keep: 7680, replace: 7681, increment: 7682, decrement: 7683, "increment wrap": 34055, "decrement wrap": 34056, invert: 5386 }, gi = { cw: Te, ccw: Ne };\n              function Ii(Me) {\n                return Array.isArray(Me) || Br(Me) || Vr(Me);\n              }\n              function Si(Me) {\n                return Me.sort(function(bt, zt) {\n                  return bt === ee ? -1 : zt === ee ? 1 : bt < zt ? -1 : 1;\n                });\n              }\n              function ei(Me, bt, zt, Rr) {\n                this.thisDep = Me, this.contextDep = bt, this.propDep = zt, this.append = Rr;\n              }\n              function Ln(Me) {\n                return Me && !(Me.thisDep || Me.contextDep || Me.propDep);\n              }\n              function En(Me) {\n                return new ei(false, false, false, Me);\n              }\n              function Un(Me, bt) {\n                var zt = Me.type;\n                if (zt === Yn) {\n                  var Rr = Me.data.length;\n                  return new ei(true, Rr >= 1, Rr >= 2, bt);\n                } else if (zt === Xo) {\n                  var jr = Me.data;\n                  return new ei(jr.thisDep, jr.contextDep, jr.propDep, bt);\n                } else {\n                  if (zt === Ss) return new ei(false, false, false, bt);\n                  if (zt === as) {\n                    for (var Nr = false, Gr = false, mi = false, Ui = 0; Ui < Me.data.length; ++Ui) {\n                      var qi = Me.data[Ui];\n                      if (qi.type === Dn) mi = true;\n                      else if (qi.type === Ka) Gr = true;\n                      else if (qi.type === bo) Nr = true;\n                      else if (qi.type === Yn) {\n                        Nr = true;\n                        var Ei = qi.data;\n                        Ei >= 1 && (Gr = true), Ei >= 2 && (mi = true);\n                      } else qi.type === Xo && (Nr = Nr || qi.data.thisDep, Gr = Gr || qi.data.contextDep, mi = mi || qi.data.propDep);\n                    }\n                    return new ei(Nr, Gr, mi, bt);\n                  } else return new ei(zt === bo, zt === Ka, zt === Dn, bt);\n                }\n              }\n              var ia = new ei(false, false, false, function() {\n              });\n              function Ea(Me, bt, zt, Rr, jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr) {\n                var Yr = qi.Record, xi = { add: 32774, subtract: 32778, "reverse subtract": 32779 };\n                zt.ext_blend_minmax && (xi.min = He, xi.max = Ye);\n                var Ri = zt.angle_instanced_arrays, ci = zt.webgl_draw_buffers, an = zt.oes_vertex_array_object, Zi = { dirty: true, profile: Mr.profile }, Bn = {}, hi = [], li = {}, mn = {};\n                function Ji(Ve) {\n                  return Ve.replace(".", "_");\n                }\n                function Vi(Ve, Qe, at) {\n                  var Ct = Ji(Ve);\n                  hi.push(Ve), Bn[Ct] = Zi[Ct] = !!at, li[Ct] = Qe;\n                }\n                function Ni(Ve, Qe, at) {\n                  var Ct = Ji(Ve);\n                  hi.push(Ve), Array.isArray(at) ? (Zi[Ct] = at.slice(), Bn[Ct] = at.slice()) : Zi[Ct] = Bn[Ct] = at, mn[Ct] = Qe;\n                }\n                function pn(Ve) {\n                  return !!isNaN(Ve);\n                }\n                Vi(ws, Pi), Vi(Ho, ni), Ni(ml, "blendColor", [0, 0, 0, 0]), Ni(Ws, "blendEquationSeparate", [yr, yr]), Ni(Ls, "blendFuncSeparate", [gr, jt, gr, jt]), Vi(va, ln, true), Ni(no, "depthFunc", Hr), Ni(ys, "depthRange", [0, 1]), Ni(rs, "depthMask", true), Ni($l, $l, [true, true, true, true]), Vi(Cu, Wr), Ni(Yu, "cullFace", se), Ni(Nc, Nc, Ne), Ni(pu, pu, 1), Vi(Uc, Kn), Ni(xu, "polygonOffset", [0, 0]), Vi(Ac, Ta), Vi(Ua, fa), Ni(oo, "sampleCoverage", [1, false]), Vi(Vc, cn), Ni(hc, "stencilMask", -1), Ni(Ku, "stencilFunc", [kt, 0, -1]), Ni(ue, "stencilOpSeparate", [X, nt, nt, nt]), Ni(w4, "stencilOpSeparate", [se, nt, nt, nt]), Vi(B4, Cn), Ni(Q, "scissor", [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]), Ni(ee, ee, [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]);\n                var Vn = { gl: Me, context: en, strings: bt, next: Bn, current: Zi, draw: Hn, elements: Nr, buffer: jr, shader: Ei, attributes: qi.state, vao: qi, uniforms: Ui, framebuffer: mi, extensions: zt, timer: Wi, isBufferArgs: Ii }, na = { primTypes: Sn, compareFuncs: Zr, blendFuncs: bi, blendEquations: xi, stencilOps: ai, glTypes: ji, orientationType: gi };\n                ci && (na.backBuffer = [se], na.drawBuffer = M4(Rr.maxDrawbuffers, function(Ve) {\n                  return Ve === 0 ? [0] : M4(Ve, function(Qe) {\n                    return _i + Qe;\n                  });\n                }));\n                var Ki = 0;\n                function kn() {\n                  var Ve = $n({ cache: si }), Qe = Ve.link, at = Ve.global;\n                  Ve.id = Ki++, Ve.batchId = "0";\n                  var Ct = Qe(Vn), Ot = Ve.shared = { props: "a0" };\n                  Object.keys(Vn).forEach(function(Pt) {\n                    Ot[Pt] = at.def(Ct, ".", Pt);\n                  });\n                  var Rt = Ve.next = {}, Bt = Ve.current = {};\n                  Object.keys(mn).forEach(function(Pt) {\n                    Array.isArray(Zi[Pt]) && (Rt[Pt] = at.def(Ot.next, ".", Pt), Bt[Pt] = at.def(Ot.current, ".", Pt));\n                  });\n                  var Dt = Ve.constants = {};\n                  Object.keys(na).forEach(function(Pt) {\n                    Dt[Pt] = at.def(JSON.stringify(na[Pt]));\n                  }), Ve.invoke = function(Pt, ht) {\n                    switch (ht.type) {\n                      case Yn:\n                        var ur = ["this", Ot.context, Ot.props, Ve.batchId];\n                        return Pt.def(Qe(ht.data), ".call(", ur.slice(0, Math.max(ht.data.length + 1, 4)), ")");\n                      case Dn:\n                        return Pt.def(Ot.props, ht.data);\n                      case Ka:\n                        return Pt.def(Ot.context, ht.data);\n                      case bo:\n                        return Pt.def("this", ht.data);\n                      case Xo:\n                        return ht.data.append(Ve, Pt), ht.data.ref;\n                      case Ss:\n                        return ht.data.toString();\n                      case as:\n                        return ht.data.map(function(br) {\n                          return Ve.invoke(Pt, br);\n                        });\n                    }\n                  }, Ve.attribCache = {};\n                  var yt = {};\n                  return Ve.scopeAttrib = function(Pt) {\n                    var ht = bt.id(Pt);\n                    if (ht in yt) return yt[ht];\n                    var ur = qi.scope[ht];\n                    ur || (ur = qi.scope[ht] = new Yr());\n                    var br = yt[ht] = Qe(ur);\n                    return br;\n                  }, Ve;\n                }\n                function ta(Ve) {\n                  var Qe = Ve.static, at = Ve.dynamic, Ct;\n                  if (le in Qe) {\n                    var Ot = !!Qe[le];\n                    Ct = En(function(Bt, Dt) {\n                      return Ot;\n                    }), Ct.enable = Ot;\n                  } else if (le in at) {\n                    var Rt = at[le];\n                    Ct = Un(Rt, function(Bt, Dt) {\n                      return Bt.invoke(Dt, Rt);\n                    });\n                  }\n                  return Ct;\n                }\n                function oa(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic;\n                  if (qe in at) {\n                    var Ot = at[qe];\n                    return Ot ? (Ot = mi.getFramebuffer(Ot), En(function(Bt, Dt) {\n                      var yt = Bt.link(Ot), Pt = Bt.shared;\n                      Dt.set(Pt.framebuffer, ".next", yt);\n                      var ht = Pt.context;\n                      return Dt.set(ht, "." + Be, yt + ".width"), Dt.set(ht, "." + et, yt + ".height"), yt;\n                    })) : En(function(Bt, Dt) {\n                      var yt = Bt.shared;\n                      Dt.set(yt.framebuffer, ".next", "null");\n                      var Pt = yt.context;\n                      return Dt.set(Pt, "." + Be, Pt + "." + Ht), Dt.set(Pt, "." + et, Pt + "." + tr), "null";\n                    });\n                  } else if (qe in Ct) {\n                    var Rt = Ct[qe];\n                    return Un(Rt, function(Bt, Dt) {\n                      var yt = Bt.invoke(Dt, Rt), Pt = Bt.shared, ht = Pt.framebuffer, ur = Dt.def(ht, ".getFramebuffer(", yt, ")");\n                      Dt.set(ht, ".next", ur);\n                      var br = Pt.context;\n                      return Dt.set(br, "." + Be, ur + "?" + ur + ".width:" + br + "." + Ht), Dt.set(br, "." + et, ur + "?" + ur + ".height:" + br + "." + tr), ur;\n                    });\n                  } else return null;\n                }\n                function ba(Ve, Qe, at) {\n                  var Ct = Ve.static, Ot = Ve.dynamic;\n                  function Rt(yt) {\n                    if (yt in Ct) {\n                      var Pt = Ct[yt], ht = true, ur = Pt.x | 0, br = Pt.y | 0, Ur, Di;\n                      return "width" in Pt ? Ur = Pt.width | 0 : ht = false, "height" in Pt ? Di = Pt.height | 0 : ht = false, new ei(!ht && Qe && Qe.thisDep, !ht && Qe && Qe.contextDep, !ht && Qe && Qe.propDep, function(gn, rn) {\n                        var Ci = gn.shared.context, Bi = Ur;\n                        "width" in Pt || (Bi = rn.def(Ci, ".", Be, "-", ur));\n                        var Gi = Di;\n                        return "height" in Pt || (Gi = rn.def(Ci, ".", et, "-", br)), [ur, br, Bi, Gi];\n                      });\n                    } else if (yt in Ot) {\n                      var fi = Ot[yt], Ti = Un(fi, function(gn, rn) {\n                        var Ci = gn.invoke(rn, fi), Bi = gn.shared.context, Gi = rn.def(Ci, ".x|0"), sn = rn.def(Ci, ".y|0"), zn = rn.def(\'"width" in \', Ci, "?", Ci, ".width|0:", "(", Bi, ".", Be, "-", Gi, ")"), Ja = rn.def(\'"height" in \', Ci, "?", Ci, ".height|0:", "(", Bi, ".", et, "-", sn, ")");\n                        return [Gi, sn, zn, Ja];\n                      });\n                      return Qe && (Ti.thisDep = Ti.thisDep || Qe.thisDep, Ti.contextDep = Ti.contextDep || Qe.contextDep, Ti.propDep = Ti.propDep || Qe.propDep), Ti;\n                    } else return Qe ? new ei(Qe.thisDep, Qe.contextDep, Qe.propDep, function(gn, rn) {\n                      var Ci = gn.shared.context;\n                      return [0, 0, rn.def(Ci, ".", Be), rn.def(Ci, ".", et)];\n                    }) : null;\n                  }\n                  var Bt = Rt(ee);\n                  if (Bt) {\n                    var Dt = Bt;\n                    Bt = new ei(Bt.thisDep, Bt.contextDep, Bt.propDep, function(yt, Pt) {\n                      var ht = Dt.append(yt, Pt), ur = yt.shared.context;\n                      return Pt.set(ur, "." + We, ht[2]), Pt.set(ur, "." + it, ht[3]), ht;\n                    });\n                  }\n                  return { viewport: Bt, scissor_box: Rt(Q) };\n                }\n                function is(Ve, Qe) {\n                  var at = Ve.static, Ct = typeof at[ot] == "string" && typeof at[Xe] == "string";\n                  if (Ct) {\n                    if (Object.keys(Qe.dynamic).length > 0) return null;\n                    var Ot = Qe.static, Rt = Object.keys(Ot);\n                    if (Rt.length > 0 && typeof Ot[Rt[0]] == "number") {\n                      for (var Bt = [], Dt = 0; Dt < Rt.length; ++Dt) Bt.push([Ot[Rt[Dt]] | 0, Rt[Dt]]);\n                      return Bt;\n                    }\n                  }\n                  return null;\n                }\n                function Zs(Ve, Qe, at) {\n                  var Ct = Ve.static, Ot = Ve.dynamic;\n                  function Rt(ht) {\n                    if (ht in Ct) {\n                      var ur = bt.id(Ct[ht]), br = En(function() {\n                        return ur;\n                      });\n                      return br.id = ur, br;\n                    } else if (ht in Ot) {\n                      var Ur = Ot[ht];\n                      return Un(Ur, function(Di, fi) {\n                        var Ti = Di.invoke(fi, Ur), gn = fi.def(Di.shared.strings, ".id(", Ti, ")");\n                        return gn;\n                      });\n                    }\n                    return null;\n                  }\n                  var Bt = Rt(ot), Dt = Rt(Xe), yt = null, Pt;\n                  return Ln(Bt) && Ln(Dt) ? (yt = Ei.program(Dt.id, Bt.id, null, at), Pt = En(function(ht, ur) {\n                    return ht.link(yt);\n                  })) : Pt = new ei(Bt && Bt.thisDep || Dt && Dt.thisDep, Bt && Bt.contextDep || Dt && Dt.contextDep, Bt && Bt.propDep || Dt && Dt.propDep, function(ht, ur) {\n                    var br = ht.shared.shader, Ur;\n                    Bt ? Ur = Bt.append(ht, ur) : Ur = ur.def(br, ".", ot);\n                    var Di;\n                    Dt ? Di = Dt.append(ht, ur) : Di = ur.def(br, ".", Xe);\n                    var fi = br + ".program(" + Di + "," + Ur;\n                    return ur.def(fi + ")");\n                  }), { frag: Bt, vert: Dt, progVar: Pt, program: yt };\n                }\n                function Va(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {}, Rt = false;\n                  function Bt() {\n                    if (ve in at) {\n                      var rn = at[ve];\n                      return rn !== null && qi.getVAO(rn) === null && (rn = qi.createVAO(rn)), Rt = true, Ot.vao = rn, En(function(Bi) {\n                        var Gi = qi.getVAO(rn);\n                        return Gi ? Bi.link(Gi) : "null";\n                      });\n                    } else if (ve in Ct) {\n                      Rt = true;\n                      var Ci = Ct[ve];\n                      return Un(Ci, function(Bi, Gi) {\n                        var sn = Bi.invoke(Gi, Ci);\n                        return Gi.def(Bi.shared.vao + ".getVAO(" + sn + ")");\n                      });\n                    }\n                    return null;\n                  }\n                  var Dt = Bt(), yt = false;\n                  function Pt() {\n                    if (Tt in at) {\n                      var rn = at[Tt];\n                      if (Ot.elements = rn, Ii(rn)) {\n                        var Ci = Ot.elements = Nr.create(rn, true);\n                        rn = Nr.getElements(Ci), yt = true;\n                      } else rn && (rn = Nr.getElements(rn), yt = true);\n                      var Bi = En(function(sn, zn) {\n                        if (rn) {\n                          var Ja = sn.link(rn);\n                          return sn.ELEMENTS = Ja, Ja;\n                        }\n                        return sn.ELEMENTS = null, null;\n                      });\n                      return Bi.value = rn, Bi;\n                    } else if (Tt in Ct) {\n                      yt = true;\n                      var Gi = Ct[Tt];\n                      return Un(Gi, function(sn, zn) {\n                        var Ja = sn.shared, co = Ja.isBufferArgs, ts = Ja.elements, so = sn.invoke(zn, Gi), Zo = zn.def("null"), ms = zn.def(co, "(", so, ")"), ou = sn.cond(ms).then(Zo, "=", ts, ".createStream(", so, ");").else(Zo, "=", ts, ".getElements(", so, ");");\n                        return zn.entry(ou), zn.exit(sn.cond(ms).then(ts, ".destroyStream(", Zo, ");")), sn.ELEMENTS = Zo, Zo;\n                      });\n                    } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                      return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.elements + ".getElements(" + sn.shared.vao + ".currentVAO.elements):null");\n                    });\n                    return null;\n                  }\n                  var ht = Pt();\n                  function ur() {\n                    if (Yt in at) {\n                      var rn = at[Yt];\n                      return Ot.primitive = rn, En(function(Bi, Gi) {\n                        return Sn[rn];\n                      });\n                    } else if (Yt in Ct) {\n                      var Ci = Ct[Yt];\n                      return Un(Ci, function(Bi, Gi) {\n                        var sn = Bi.constants.primTypes, zn = Bi.invoke(Gi, Ci);\n                        return Gi.def(sn, "[", zn, "]");\n                      });\n                    } else {\n                      if (yt) return Ln(ht) ? ht.value ? En(function(Bi, Gi) {\n                        return Gi.def(Bi.ELEMENTS, ".primType");\n                      }) : En(function() {\n                        return Al;\n                      }) : new ei(ht.thisDep, ht.contextDep, ht.propDep, function(Bi, Gi) {\n                        var sn = Bi.ELEMENTS;\n                        return Gi.def(sn, "?", sn, ".primType:", Al);\n                      });\n                      if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(Bi, Gi) {\n                        return Gi.def(Bi.shared.vao + ".currentVAO?" + Bi.shared.vao + ".currentVAO.primitive:" + Al);\n                      });\n                    }\n                    return null;\n                  }\n                  function br(rn, Ci) {\n                    if (rn in at) {\n                      var Bi = at[rn] | 0;\n                      return Ci ? Ot.offset = Bi : Ot.instances = Bi, En(function(sn, zn) {\n                        return Ci && (sn.OFFSET = Bi), Bi;\n                      });\n                    } else if (rn in Ct) {\n                      var Gi = Ct[rn];\n                      return Un(Gi, function(sn, zn) {\n                        var Ja = sn.invoke(zn, Gi);\n                        return Ci && (sn.OFFSET = Ja), Ja;\n                      });\n                    } else if (Ci) {\n                      if (yt) return En(function(sn, zn) {\n                        return sn.OFFSET = 0, 0;\n                      });\n                      if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                        return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.offset:0");\n                      });\n                    } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                      return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.instances:-1");\n                    });\n                    return null;\n                  }\n                  var Ur = br(xr, true);\n                  function Di() {\n                    if (Kt in at) {\n                      var rn = at[Kt] | 0;\n                      return Ot.count = rn, En(function() {\n                        return rn;\n                      });\n                    } else if (Kt in Ct) {\n                      var Ci = Ct[Kt];\n                      return Un(Ci, function(zn, Ja) {\n                        var co = zn.invoke(Ja, Ci);\n                        return co;\n                      });\n                    } else if (yt) if (Ln(ht)) {\n                      if (ht) return Ur ? new ei(Ur.thisDep, Ur.contextDep, Ur.propDep, function(zn, Ja) {\n                        var co = Ja.def(zn.ELEMENTS, ".vertCount-", zn.OFFSET);\n                        return co;\n                      }) : En(function(zn, Ja) {\n                        return Ja.def(zn.ELEMENTS, ".vertCount");\n                      });\n                      var Bi = En(function() {\n                        return -1;\n                      });\n                      return Bi;\n                    } else {\n                      var Gi = new ei(ht.thisDep || Ur.thisDep, ht.contextDep || Ur.contextDep, ht.propDep || Ur.propDep, function(zn, Ja) {\n                        var co = zn.ELEMENTS;\n                        return zn.OFFSET ? Ja.def(co, "?", co, ".vertCount-", zn.OFFSET, ":-1") : Ja.def(co, "?", co, ".vertCount:-1");\n                      });\n                      return Gi;\n                    }\n                    else if (Rt) {\n                      var sn = new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(zn, Ja) {\n                        return Ja.def(zn.shared.vao, ".currentVAO?", zn.shared.vao, ".currentVAO.count:-1");\n                      });\n                      return sn;\n                    }\n                    return null;\n                  }\n                  var fi = ur(), Ti = Di(), gn = br(Ir, false);\n                  return { elements: ht, primitive: fi, count: Ti, instances: gn, offset: Ur, vao: Dt, vaoActive: Rt, elementsActive: yt, static: Ot };\n                }\n                function Ml(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return hi.forEach(function(Rt) {\n                    var Bt = Ji(Rt);\n                    function Dt(yt, Pt) {\n                      if (Rt in at) {\n                        var ht = yt(at[Rt]);\n                        Ot[Bt] = En(function() {\n                          return ht;\n                        });\n                      } else if (Rt in Ct) {\n                        var ur = Ct[Rt];\n                        Ot[Bt] = Un(ur, function(br, Ur) {\n                          return Pt(br, Ur, br.invoke(Ur, ur));\n                        });\n                      }\n                    }\n                    switch (Rt) {\n                      case Cu:\n                      case Ho:\n                      case ws:\n                      case Vc:\n                      case va:\n                      case B4:\n                      case Uc:\n                      case Ac:\n                      case Ua:\n                      case rs:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          return ht;\n                        });\n                      case no:\n                        return Dt(function(yt) {\n                          return Zr[yt];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.compareFuncs;\n                          return Pt.def(ur, "[", ht, "]");\n                        });\n                      case ys:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def("+", ht, "[0]"), br = Pt.def("+", ht, "[1]");\n                          return [ur, br];\n                        });\n                      case Ls:\n                        return Dt(function(yt) {\n                          var Pt = "srcRGB" in yt ? yt.srcRGB : yt.src, ht = "srcAlpha" in yt ? yt.srcAlpha : yt.src, ur = "dstRGB" in yt ? yt.dstRGB : yt.dst, br = "dstAlpha" in yt ? yt.dstAlpha : yt.dst;\n                          return [bi[Pt], bi[ur], bi[ht], bi[br]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.blendFuncs;\n                          function br(Ci, Bi) {\n                            var Gi = Pt.def(\'"\', Ci, Bi, \'" in \', ht, "?", ht, ".", Ci, Bi, ":", ht, ".", Ci);\n                            return Gi;\n                          }\n                          var Ur = br("src", "RGB"), Di = br("dst", "RGB"), fi = Pt.def(ur, "[", Ur, "]"), Ti = Pt.def(ur, "[", br("src", "Alpha"), "]"), gn = Pt.def(ur, "[", Di, "]"), rn = Pt.def(ur, "[", br("dst", "Alpha"), "]");\n                          return [fi, gn, Ti, rn];\n                        });\n                      case Ws:\n                        return Dt(function(yt) {\n                          if (typeof yt == "string") return [xi[yt], xi[yt]];\n                          if (typeof yt == "object") return [xi[yt.rgb], xi[yt.alpha]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.blendEquations, br = Pt.def(), Ur = Pt.def(), Di = yt.cond("typeof ", ht, \'==="string"\');\n                          return Di.then(br, "=", Ur, "=", ur, "[", ht, "];"), Di.else(br, "=", ur, "[", ht, ".rgb];", Ur, "=", ur, "[", ht, ".alpha];"), Pt(Di), [br, Ur];\n                        });\n                      case ml:\n                        return Dt(function(yt) {\n                          return M4(4, function(Pt) {\n                            return +yt[Pt];\n                          });\n                        }, function(yt, Pt, ht) {\n                          return M4(4, function(ur) {\n                            return Pt.def("+", ht, "[", ur, "]");\n                          });\n                        });\n                      case hc:\n                        return Dt(function(yt) {\n                          return yt | 0;\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht, "|0");\n                        });\n                      case Ku:\n                        return Dt(function(yt) {\n                          var Pt = yt.cmp || "keep", ht = yt.ref || 0, ur = "mask" in yt ? yt.mask : -1;\n                          return [Zr[Pt], ht, ur];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.compareFuncs, br = Pt.def(\'"cmp" in \', ht, "?", ur, "[", ht, ".cmp]", ":", nt), Ur = Pt.def(ht, ".ref|0"), Di = Pt.def(\'"mask" in \', ht, "?", ht, ".mask|0:-1");\n                          return [br, Ur, Di];\n                        });\n                      case ue:\n                      case w4:\n                        return Dt(function(yt) {\n                          var Pt = yt.fail || "keep", ht = yt.zfail || "keep", ur = yt.zpass || "keep";\n                          return [Rt === w4 ? se : X, ai[Pt], ai[ht], ai[ur]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.stencilOps;\n                          function br(Ur) {\n                            return Pt.def(\'"\', Ur, \'" in \', ht, "?", ur, "[", ht, ".", Ur, "]:", nt);\n                          }\n                          return [Rt === w4 ? se : X, br("fail"), br("zfail"), br("zpass")];\n                        });\n                      case xu:\n                        return Dt(function(yt) {\n                          var Pt = yt.factor | 0, ht = yt.units | 0;\n                          return [Pt, ht];\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def(ht, ".factor|0"), br = Pt.def(ht, ".units|0");\n                          return [ur, br];\n                        });\n                      case Yu:\n                        return Dt(function(yt) {\n                          var Pt = 0;\n                          return yt === "front" ? Pt = X : yt === "back" && (Pt = se), Pt;\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht, \'==="front"?\', X, ":", se);\n                        });\n                      case pu:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          return ht;\n                        });\n                      case Nc:\n                        return Dt(function(yt) {\n                          return gi[yt];\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht + \'==="cw"?\' + Te + ":" + Ne);\n                        });\n                      case $l:\n                        return Dt(function(yt) {\n                          return yt.map(function(Pt) {\n                            return !!Pt;\n                          });\n                        }, function(yt, Pt, ht) {\n                          return M4(4, function(ur) {\n                            return "!!" + ht + "[" + ur + "]";\n                          });\n                        });\n                      case oo:\n                        return Dt(function(yt) {\n                          var Pt = "value" in yt ? yt.value : 1, ht = !!yt.invert;\n                          return [Pt, ht];\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def(\'"value" in \', ht, "?+", ht, ".value:1"), br = Pt.def("!!", ht, ".invert");\n                          return [ur, br];\n                        });\n                    }\n                  }), Ot;\n                }\n                function zo(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return Object.keys(at).forEach(function(Rt) {\n                    var Bt = at[Rt], Dt;\n                    if (typeof Bt == "number" || typeof Bt == "boolean") Dt = En(function() {\n                      return Bt;\n                    });\n                    else if (typeof Bt == "function") {\n                      var yt = Bt._reglType;\n                      yt === "texture2d" || yt === "textureCube" ? Dt = En(function(Pt) {\n                        return Pt.link(Bt);\n                      }) : (yt === "framebuffer" || yt === "framebufferCube") && (Dt = En(function(Pt) {\n                        return Pt.link(Bt.color[0]);\n                      }));\n                    } else Mn(Bt) && (Dt = En(function(Pt) {\n                      var ht = Pt.global.def("[", M4(Bt.length, function(ur) {\n                        return Bt[ur];\n                      }), "]");\n                      return ht;\n                    }));\n                    Dt.value = Bt, Ot[Rt] = Dt;\n                  }), Object.keys(Ct).forEach(function(Rt) {\n                    var Bt = Ct[Rt];\n                    Ot[Rt] = Un(Bt, function(Dt, yt) {\n                      return Dt.invoke(yt, Bt);\n                    });\n                  }), Ot;\n                }\n                function Qs(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return Object.keys(at).forEach(function(Rt) {\n                    var Bt = at[Rt], Dt = bt.id(Rt), yt = new Yr();\n                    if (Ii(Bt)) yt.state = La, yt.buffer = jr.getBuffer(jr.create(Bt, Sr, false, true)), yt.type = 0;\n                    else {\n                      var Pt = jr.getBuffer(Bt);\n                      if (Pt) yt.state = La, yt.buffer = Pt, yt.type = 0;\n                      else if ("constant" in Bt) {\n                        var ht = Bt.constant;\n                        yt.buffer = "null", yt.state = Na, typeof ht == "number" ? yt.x = ht : Ca.forEach(function(gn, rn) {\n                          rn < ht.length && (yt[gn] = ht[rn]);\n                        });\n                      } else {\n                        Ii(Bt.buffer) ? Pt = jr.getBuffer(jr.create(Bt.buffer, Sr, false, true)) : Pt = jr.getBuffer(Bt.buffer);\n                        var ur = Bt.offset | 0, br = Bt.stride | 0, Ur = Bt.size | 0, Di = !!Bt.normalized, fi = 0;\n                        "type" in Bt && (fi = ji[Bt.type]);\n                        var Ti = Bt.divisor | 0;\n                        yt.buffer = Pt, yt.state = La, yt.size = Ur, yt.normalized = Di, yt.type = fi || Pt.dtype, yt.offset = ur, yt.stride = br, yt.divisor = Ti;\n                      }\n                    }\n                    Ot[Rt] = En(function(gn, rn) {\n                      var Ci = gn.attribCache;\n                      if (Dt in Ci) return Ci[Dt];\n                      var Bi = { isStream: false };\n                      return Object.keys(yt).forEach(function(Gi) {\n                        Bi[Gi] = yt[Gi];\n                      }), yt.buffer && (Bi.buffer = gn.link(yt.buffer), Bi.type = Bi.type || Bi.buffer + ".dtype"), Ci[Dt] = Bi, Bi;\n                    });\n                  }), Object.keys(Ct).forEach(function(Rt) {\n                    var Bt = Ct[Rt];\n                    function Dt(yt, Pt) {\n                      var ht = yt.invoke(Pt, Bt), ur = yt.shared, br = yt.constants, Ur = ur.isBufferArgs, Di = ur.buffer, fi = { isStream: Pt.def(false) }, Ti = new Yr();\n                      Ti.state = La, Object.keys(Ti).forEach(function(Bi) {\n                        fi[Bi] = Pt.def("" + Ti[Bi]);\n                      });\n                      var gn = fi.buffer, rn = fi.type;\n                      Pt("if(", Ur, "(", ht, ")){", fi.isStream, "=true;", gn, "=", Di, ".createStream(", Sr, ",", ht, ");", rn, "=", gn, ".dtype;", "}else{", gn, "=", Di, ".getBuffer(", ht, ");", "if(", gn, "){", rn, "=", gn, ".dtype;", \'}else if("constant" in \', ht, "){", fi.state, "=", Na, ";", "if(typeof " + ht + \'.constant === "number"){\', fi[Ca[0]], "=", ht, ".constant;", Ca.slice(1).map(function(Bi) {\n                        return fi[Bi];\n                      }).join("="), "=0;", "}else{", Ca.map(function(Bi, Gi) {\n                        return fi[Bi] + "=" + ht + ".constant.length>" + Gi + "?" + ht + ".constant[" + Gi + "]:0;";\n                      }).join(""), "}}else{", "if(", Ur, "(", ht, ".buffer)){", gn, "=", Di, ".createStream(", Sr, ",", ht, ".buffer);", "}else{", gn, "=", Di, ".getBuffer(", ht, ".buffer);", "}", rn, \'="type" in \', ht, "?", br.glTypes, "[", ht, ".type]:", gn, ".dtype;", fi.normalized, "=!!", ht, ".normalized;");\n                      function Ci(Bi) {\n                        Pt(fi[Bi], "=", ht, ".", Bi, "|0;");\n                      }\n                      return Ci("size"), Ci("offset"), Ci("stride"), Ci("divisor"), Pt("}}"), Pt.exit("if(", fi.isStream, "){", Di, ".destroyStream(", gn, ");", "}"), fi;\n                    }\n                    Ot[Rt] = Un(Bt, Dt);\n                  }), Ot;\n                }\n                function al(Ve) {\n                  var Qe = Ve.static, at = Ve.dynamic, Ct = {};\n                  return Object.keys(Qe).forEach(function(Ot) {\n                    var Rt = Qe[Ot];\n                    Ct[Ot] = En(function(Bt, Dt) {\n                      return typeof Rt == "number" || typeof Rt == "boolean" ? "" + Rt : Bt.link(Rt);\n                    });\n                  }), Object.keys(at).forEach(function(Ot) {\n                    var Rt = at[Ot];\n                    Ct[Ot] = Un(Rt, function(Bt, Dt) {\n                      return Bt.invoke(Dt, Rt);\n                    });\n                  }), Ct;\n                }\n                function Vl(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.static, Bt = Ve.dynamic, Dt = is(Ve, Qe), yt = oa(Ve, Ot), Pt = ba(Ve, yt, Ot), ht = Va(Ve, Ot), ur = Ml(Ve, Ot), br = Zs(Ve, Ot, Dt);\n                  function Ur(Ci) {\n                    var Bi = Pt[Ci];\n                    Bi && (ur[Ci] = Bi);\n                  }\n                  Ur(ee), Ur(Ji(Q));\n                  var Di = Object.keys(ur).length > 0, fi = { framebuffer: yt, draw: ht, shader: br, state: ur, dirty: Di, scopeVAO: null, drawVAO: null, useVAO: false, attributes: {} };\n                  if (fi.profile = ta(Ve, Ot), fi.uniforms = zo(at, Ot), fi.drawVAO = fi.scopeVAO = ht.vao, !fi.drawVAO && br.program && !Dt && zt.angle_instanced_arrays && ht.static.elements) {\n                    var Ti = true, gn = br.program.attributes.map(function(Ci) {\n                      var Bi = Qe.static[Ci];\n                      return Ti = Ti && !!Bi, Bi;\n                    });\n                    if (Ti && gn.length > 0) {\n                      var rn = qi.getVAO(qi.createVAO({ attributes: gn, elements: ht.static.elements }));\n                      fi.drawVAO = new ei(null, null, null, function(Ci, Bi) {\n                        return Ci.link(rn);\n                      }), fi.useVAO = true;\n                    }\n                  }\n                  return Dt ? fi.useVAO = true : fi.attributes = Qs(Qe, Ot), fi.context = al(Ct, Ot), fi;\n                }\n                function ss(Ve, Qe, at) {\n                  var Ct = Ve.shared, Ot = Ct.context, Rt = Ve.scope();\n                  Object.keys(at).forEach(function(Bt) {\n                    Qe.save(Ot, "." + Bt);\n                    var Dt = at[Bt], yt = Dt.append(Ve, Qe);\n                    Array.isArray(yt) ? Rt(Ot, ".", Bt, "=[", yt.join(), "];") : Rt(Ot, ".", Bt, "=", yt, ";");\n                  }), Qe(Rt);\n                }\n                function Vs(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.framebuffer, Dt;\n                  ci && (Dt = Qe.def(Ot.extensions, ".webgl_draw_buffers"));\n                  var yt = Ve.constants, Pt = yt.drawBuffer, ht = yt.backBuffer, ur;\n                  at ? ur = at.append(Ve, Qe) : ur = Qe.def(Bt, ".next"), Ct || Qe("if(", ur, "!==", Bt, ".cur){"), Qe("if(", ur, "){", Rt, ".bindFramebuffer(", qr, ",", ur, ".framebuffer);"), ci && Qe(Dt, ".drawBuffersWEBGL(", Pt, "[", ur, ".colorAttachments.length]);"), Qe("}else{", Rt, ".bindFramebuffer(", qr, ",null);"), ci && Qe(Dt, ".drawBuffersWEBGL(", ht, ");"), Qe("}", Bt, ".cur=", ur, ";"), Ct || Qe("}");\n                }\n                function Ys(Ve, Qe, at) {\n                  var Ct = Ve.shared, Ot = Ct.gl, Rt = Ve.current, Bt = Ve.next, Dt = Ct.current, yt = Ct.next, Pt = Ve.cond(Dt, ".dirty");\n                  hi.forEach(function(ht) {\n                    var ur = Ji(ht);\n                    if (!(ur in at.state)) {\n                      var br, Ur;\n                      if (ur in Bt) {\n                        br = Bt[ur], Ur = Rt[ur];\n                        var Di = M4(Zi[ur].length, function(Ti) {\n                          return Pt.def(br, "[", Ti, "]");\n                        });\n                        Pt(Ve.cond(Di.map(function(Ti, gn) {\n                          return Ti + "!==" + Ur + "[" + gn + "]";\n                        }).join("||")).then(Ot, ".", mn[ur], "(", Di, ");", Di.map(function(Ti, gn) {\n                          return Ur + "[" + gn + "]=" + Ti;\n                        }).join(";"), ";"));\n                      } else {\n                        br = Pt.def(yt, ".", ur);\n                        var fi = Ve.cond(br, "!==", Dt, ".", ur);\n                        Pt(fi), ur in li ? fi(Ve.cond(br).then(Ot, ".enable(", li[ur], ");").else(Ot, ".disable(", li[ur], ");"), Dt, ".", ur, "=", br, ";") : fi(Ot, ".", mn[ur], "(", br, ");", Dt, ".", ur, "=", br, ";");\n                      }\n                    }\n                  }), Object.keys(at.state).length === 0 && Pt(Dt, ".dirty=false;"), Qe(Pt);\n                }\n                function wa(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ve.current, Bt = Ot.current, Dt = Ot.gl, yt;\n                  Si(Object.keys(at)).forEach(function(Pt) {\n                    var ht = at[Pt];\n                    if (!(Ct && !Ct(ht))) {\n                      var ur = ht.append(Ve, Qe);\n                      if (li[Pt]) {\n                        var br = li[Pt];\n                        Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Ve.cond(yt).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", yt, ";")) : (Qe(Ve.cond(ur).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", ur, ";"));\n                      } else if (Mn(ur)) {\n                        var Ur = Rt[Pt];\n                        Qe(Dt, ".", mn[Pt], "(", ur, ");", ur.map(function(Di, fi) {\n                          return Ur + "[" + fi + "]=" + Di;\n                        }).join(";"), ";");\n                      } else Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Dt, ".", mn[Pt], "(", yt, ");", Bt, ".", Pt, "=", yt, ";")) : Qe(Dt, ".", mn[Pt], "(", ur, ");", Bt, ".", Pt, "=", ur, ";");\n                    }\n                  });\n                }\n                function ol(Ve, Qe) {\n                  Ri && (Ve.instancing = Qe.def(Ve.shared.extensions, ".angle_instanced_arrays"));\n                }\n                function io(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.shared, Bt = Ve.stats, Dt = Rt.current, yt = Rt.timer, Pt = at.profile;\n                  function ht() {\n                    return typeof performance == "undefined" ? "Date.now()" : "performance.now()";\n                  }\n                  var ur, br;\n                  function Ur(Ci) {\n                    ur = Qe.def(), Ci(ur, "=", ht(), ";"), typeof Ot == "string" ? Ci(Bt, ".count+=", Ot, ";") : Ci(Bt, ".count++;"), Wi && (Ct ? (br = Qe.def(), Ci(br, "=", yt, ".getNumPendingQueries();")) : Ci(yt, ".beginQuery(", Bt, ");"));\n                  }\n                  function Di(Ci) {\n                    Ci(Bt, ".cpuTime+=", ht(), "-", ur, ";"), Wi && (Ct ? Ci(yt, ".pushScopeStats(", br, ",", yt, ".getNumPendingQueries(),", Bt, ");") : Ci(yt, ".endQuery();"));\n                  }\n                  function fi(Ci) {\n                    var Bi = Qe.def(Dt, ".profile");\n                    Qe(Dt, ".profile=", Ci, ";"), Qe.exit(Dt, ".profile=", Bi, ";");\n                  }\n                  var Ti;\n                  if (Pt) {\n                    if (Ln(Pt)) {\n                      Pt.enable ? (Ur(Qe), Di(Qe.exit), fi("true")) : fi("false");\n                      return;\n                    }\n                    Ti = Pt.append(Ve, Qe), fi(Ti);\n                  } else Ti = Qe.def(Dt, ".profile");\n                  var gn = Ve.block();\n                  Ur(gn), Qe("if(", Ti, "){", gn, "}");\n                  var rn = Ve.block();\n                  Di(rn), Qe.exit("if(", Ti, "){", rn, "}");\n                }\n                function Y(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.shared;\n                  function Bt(yt) {\n                    switch (yt) {\n                      case Co:\n                      case Ps:\n                      case hl:\n                        return 2;\n                      case Qa:\n                      case Ts:\n                      case Ul:\n                        return 3;\n                      case mo:\n                      case wo:\n                      case Lu:\n                        return 4;\n                      default:\n                        return 1;\n                    }\n                  }\n                  function Dt(yt, Pt, ht) {\n                    var ur = Rt.gl, br = Qe.def(yt, ".location"), Ur = Qe.def(Rt.attributes, "[", br, "]"), Di = ht.state, fi = ht.buffer, Ti = [ht.x, ht.y, ht.z, ht.w], gn = ["buffer", "normalized", "offset", "stride"];\n                    function rn() {\n                      Qe("if(!", Ur, ".buffer){", ur, ".enableVertexAttribArray(", br, ");}");\n                      var Bi = ht.type, Gi;\n                      if (ht.size ? Gi = Qe.def(ht.size, "||", Pt) : Gi = Pt, Qe("if(", Ur, ".type!==", Bi, "||", Ur, ".size!==", Gi, "||", gn.map(function(zn) {\n                        return Ur + "." + zn + "!==" + ht[zn];\n                      }).join("||"), "){", ur, ".bindBuffer(", Sr, ",", fi, ".buffer);", ur, ".vertexAttribPointer(", [br, Gi, Bi, ht.normalized, ht.stride, ht.offset], ");", Ur, ".type=", Bi, ";", Ur, ".size=", Gi, ";", gn.map(function(zn) {\n                        return Ur + "." + zn + "=" + ht[zn] + ";";\n                      }).join(""), "}"), Ri) {\n                        var sn = ht.divisor;\n                        Qe("if(", Ur, ".divisor!==", sn, "){", Ve.instancing, ".vertexAttribDivisorANGLE(", [br, sn], ");", Ur, ".divisor=", sn, ";}");\n                      }\n                    }\n                    function Ci() {\n                      Qe("if(", Ur, ".buffer){", ur, ".disableVertexAttribArray(", br, ");", Ur, ".buffer=null;", "}if(", Ca.map(function(Bi, Gi) {\n                        return Ur + "." + Bi + "!==" + Ti[Gi];\n                      }).join("||"), "){", ur, ".vertexAttrib4f(", br, ",", Ti, ");", Ca.map(function(Bi, Gi) {\n                        return Ur + "." + Bi + "=" + Ti[Gi] + ";";\n                      }).join(""), "}");\n                    }\n                    Di === La ? rn() : Di === Na ? Ci() : (Qe("if(", Di, "===", La, "){"), rn(), Qe("}else{"), Ci(), Qe("}"));\n                  }\n                  Ct.forEach(function(yt) {\n                    var Pt = yt.name, ht = at.attributes[Pt], ur;\n                    if (ht) {\n                      if (!Ot(ht)) return;\n                      ur = ht.append(Ve, Qe);\n                    } else {\n                      if (!Ot(ia)) return;\n                      var br = Ve.scopeAttrib(Pt);\n                      ur = {}, Object.keys(new Yr()).forEach(function(Ur) {\n                        ur[Ur] = Qe.def(br, ".", Ur);\n                      });\n                    }\n                    Dt(Ve.link(yt), Bt(yt.info.type), ur);\n                  });\n                }\n                function D3(Ve, Qe, at, Ct, Ot, Rt) {\n                  for (var Bt = Ve.shared, Dt = Bt.gl, yt, Pt = 0; Pt < Ct.length; ++Pt) {\n                    var ht = Ct[Pt], ur = ht.name, br = ht.info.type, Ur = at.uniforms[ur], Di = Ve.link(ht), fi = Di + ".location", Ti;\n                    if (Ur) {\n                      if (!Ot(Ur)) continue;\n                      if (Ln(Ur)) {\n                        var gn = Ur.value;\n                        if (br === dc || br === Tl) {\n                          var rn = Ve.link(gn._texture || gn.color[0]._texture);\n                          Qe(Dt, ".uniform1i(", fi, ",", rn + ".bind());"), Qe.exit(rn, ".unbind();");\n                        } else if (br === au || br === Js || br === Ql) {\n                          var Ci = Ve.global.def("new Float32Array([" + Array.prototype.slice.call(gn) + "])"), Bi = 2;\n                          br === Js ? Bi = 3 : br === Ql && (Bi = 4), Qe(Dt, ".uniformMatrix", Bi, "fv(", fi, ",false,", Ci, ");");\n                        } else {\n                          switch (br) {\n                            case $a:\n                              yt = "1f";\n                              break;\n                            case Co:\n                              yt = "2f";\n                              break;\n                            case Qa:\n                              yt = "3f";\n                              break;\n                            case mo:\n                              yt = "4f";\n                              break;\n                            case To:\n                              yt = "1i";\n                              break;\n                            case Bo:\n                              yt = "1i";\n                              break;\n                            case hl:\n                              yt = "2i";\n                              break;\n                            case Ps:\n                              yt = "2i";\n                              break;\n                            case Ul:\n                              yt = "3i";\n                              break;\n                            case Ts:\n                              yt = "3i";\n                              break;\n                            case Lu:\n                              yt = "4i";\n                              break;\n                            case wo:\n                              yt = "4i";\n                              break;\n                          }\n                          Qe(Dt, ".uniform", yt, "(", fi, ",", Mn(gn) ? Array.prototype.slice.call(gn) : gn, ");");\n                        }\n                        continue;\n                      } else Ti = Ur.append(Ve, Qe);\n                    } else {\n                      if (!Ot(ia)) continue;\n                      Ti = Qe.def(Bt.uniforms, "[", bt.id(ur), "]");\n                    }\n                    br === dc ? Qe("if(", Ti, "&&", Ti, \'._reglType==="framebuffer"){\', Ti, "=", Ti, ".color[0];", "}") : br === Tl && Qe("if(", Ti, "&&", Ti, \'._reglType==="framebufferCube"){\', Ti, "=", Ti, ".color[0];", "}");\n                    var Gi = 1;\n                    switch (br) {\n                      case dc:\n                      case Tl:\n                        var sn = Qe.def(Ti, "._texture");\n                        Qe(Dt, ".uniform1i(", fi, ",", sn, ".bind());"), Qe.exit(sn, ".unbind();");\n                        continue;\n                      case Bo:\n                      case To:\n                        yt = "1i";\n                        break;\n                      case Ps:\n                      case hl:\n                        yt = "2i", Gi = 2;\n                        break;\n                      case Ts:\n                      case Ul:\n                        yt = "3i", Gi = 3;\n                        break;\n                      case wo:\n                      case Lu:\n                        yt = "4i", Gi = 4;\n                        break;\n                      case $a:\n                        yt = "1f";\n                        break;\n                      case Co:\n                        yt = "2f", Gi = 2;\n                        break;\n                      case Qa:\n                        yt = "3f", Gi = 3;\n                        break;\n                      case mo:\n                        yt = "4f", Gi = 4;\n                        break;\n                      case au:\n                        yt = "Matrix2fv";\n                        break;\n                      case Js:\n                        yt = "Matrix3fv";\n                        break;\n                      case Ql:\n                        yt = "Matrix4fv";\n                        break;\n                    }\n                    if (yt.charAt(0) === "M") {\n                      Qe(Dt, ".uniform", yt, "(", fi, ",");\n                      var zn = Math.pow(br - au + 2, 2), Ja = Ve.global.def("new Float32Array(", zn, ")");\n                      Array.isArray(Ti) ? Qe("false,(", M4(zn, function(ms) {\n                        return Ja + "[" + ms + "]=" + Ti[ms];\n                      }), ",", Ja, ")") : Qe("false,(Array.isArray(", Ti, ")||", Ti, " instanceof Float32Array)?", Ti, ":(", M4(zn, function(ms) {\n                        return Ja + "[" + ms + "]=" + Ti + "[" + ms + "]";\n                      }), ",", Ja, ")"), Qe(");");\n                    } else if (Gi > 1) {\n                      for (var co = [], ts = [], so = 0; so < Gi; ++so) Array.isArray(Ti) ? ts.push(Ti[so]) : ts.push(Qe.def(Ti + "[" + so + "]")), Rt && co.push(Qe.def());\n                      Rt && Qe("if(!", Ve.batchId, "||", co.map(function(ms, ou) {\n                        return ms + "!==" + ts[ou];\n                      }).join("||"), "){", co.map(function(ms, ou) {\n                        return ms + "=" + ts[ou] + ";";\n                      }).join("")), Qe(Dt, ".uniform", yt, "(", fi, ",", ts.join(","), ");"), Rt && Qe("}");\n                    } else {\n                      if (Rt) {\n                        var Zo = Qe.def();\n                        Qe("if(!", Ve.batchId, "||", Zo, "!==", Ti, "){", Zo, "=", Ti, ";");\n                      }\n                      Qe(Dt, ".uniform", yt, "(", fi, ",", Ti, ");"), Rt && Qe("}");\n                    }\n                  }\n                }\n                function J(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.draw, Dt = Ct.draw;\n                  function yt() {\n                    var Gi = Dt.elements, sn, zn = Qe;\n                    return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn), Dt.elementsActive && zn("if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);")) : (sn = zn.def(), zn(sn, "=", Bt, ".", Tt, ";", "if(", sn, "){", Rt, ".bindBuffer(", Or, ",", sn, ".buffer.buffer);}", "else if(", Ot.vao, ".currentVAO){", sn, "=", Ve.shared.elements + ".getElements(" + Ot.vao, ".currentVAO.elements);", an ? "" : "if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);", "}")), sn;\n                  }\n                  function Pt() {\n                    var Gi = Dt.count, sn, zn = Qe;\n                    return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn)) : sn = zn.def(Bt, ".", Kt), sn;\n                  }\n                  var ht = yt();\n                  function ur(Gi) {\n                    var sn = Dt[Gi];\n                    return sn ? sn.contextDep && Ct.contextDynamic || sn.propDep ? sn.append(Ve, at) : sn.append(Ve, Qe) : Qe.def(Bt, ".", Gi);\n                  }\n                  var br = ur(Yt), Ur = ur(xr), Di = Pt();\n                  if (typeof Di == "number") {\n                    if (Di === 0) return;\n                  } else at("if(", Di, "){"), at.exit("}");\n                  var fi, Ti;\n                  Ri && (fi = ur(Ir), Ti = Ve.instancing);\n                  var gn = ht + ".type", rn = Dt.elements && Ln(Dt.elements) && !Dt.vaoActive;\n                  function Ci() {\n                    function Gi() {\n                      at(Ti, ".drawElementsInstancedANGLE(", [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)", fi], ");");\n                    }\n                    function sn() {\n                      at(Ti, ".drawArraysInstancedANGLE(", [br, Ur, Di, fi], ");");\n                    }\n                    ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();\n                  }\n                  function Bi() {\n                    function Gi() {\n                      at(Rt + ".drawElements(" + [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)"] + ");");\n                    }\n                    function sn() {\n                      at(Rt + ".drawArrays(" + [br, Ur, Di] + ");");\n                    }\n                    ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();\n                  }\n                  Ri && (typeof fi != "number" || fi >= 0) ? typeof fi == "string" ? (at("if(", fi, ">0){"), Ci(), at("}else if(", fi, "<0){"), Bi(), at("}")) : Ci() : Bi();\n                }\n                function q2(Ve, Qe, at, Ct, Ot) {\n                  var Rt = kn(), Bt = Rt.proc("body", Ot);\n                  return Ri && (Rt.instancing = Bt.def(Rt.shared.extensions, ".angle_instanced_arrays")), Ve(Rt, Bt, at, Ct), Rt.compile().body;\n                }\n                function K(Ve, Qe, at, Ct) {\n                  ol(Ve, Qe), at.useVAO ? at.drawVAO ? Qe(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Qe), ");") : Qe(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Qe(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Qe, at, Ct.attributes, function() {\n                    return true;\n                  })), D3(Ve, Qe, at, Ct.uniforms, function() {\n                    return true;\n                  }, false), J(Ve, Qe, Qe, at);\n                }\n                function de(Ve, Qe) {\n                  var at = Ve.proc("draw", 1);\n                  ol(Ve, at), ss(Ve, at, Qe.context), Vs(Ve, at, Qe.framebuffer), Ys(Ve, at, Qe), wa(Ve, at, Qe.state), io(Ve, at, Qe, false, true);\n                  var Ct = Qe.shader.progVar.append(Ve, at);\n                  if (at(Ve.shared.gl, ".useProgram(", Ct, ".program);"), Qe.shader.program) K(Ve, at, Qe, Qe.shader.program);\n                  else {\n                    at(Ve.shared.vao, ".setVAO(null);");\n                    var Ot = Ve.global.def("{}"), Rt = at.def(Ct, ".id"), Bt = at.def(Ot, "[", Rt, "]");\n                    at(Ve.cond(Bt).then(Bt, ".call(this,a0);").else(Bt, "=", Ot, "[", Rt, "]=", Ve.link(function(Dt) {\n                      return q2(K, Ve, Qe, Dt, 1);\n                    }), "(", Ct, ");", Bt, ".call(this,a0);"));\n                  }\n                  Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");\n                }\n                function ne(Ve, Qe, at, Ct) {\n                  Ve.batchId = "a1", ol(Ve, Qe);\n                  function Ot() {\n                    return true;\n                  }\n                  Y(Ve, Qe, at, Ct.attributes, Ot), D3(Ve, Qe, at, Ct.uniforms, Ot, false), J(Ve, Qe, Qe, at);\n                }\n                function we(Ve, Qe, at, Ct) {\n                  ol(Ve, Qe);\n                  var Ot = at.contextDep, Rt = Qe.def(), Bt = "a0", Dt = "a1", yt = Qe.def();\n                  Ve.shared.props = yt, Ve.batchId = Rt;\n                  var Pt = Ve.scope(), ht = Ve.scope();\n                  Qe(Pt.entry, "for(", Rt, "=0;", Rt, "<", Dt, ";++", Rt, "){", yt, "=", Bt, "[", Rt, "];", ht, "}", Pt.exit);\n                  function ur(gn) {\n                    return gn.contextDep && Ot || gn.propDep;\n                  }\n                  function br(gn) {\n                    return !ur(gn);\n                  }\n                  if (at.needsContext && ss(Ve, ht, at.context), at.needsFramebuffer && Vs(Ve, ht, at.framebuffer), wa(Ve, ht, at.state, ur), at.profile && ur(at.profile) && io(Ve, ht, at, false, true), Ct) at.useVAO ? at.drawVAO ? ur(at.drawVAO) ? ht(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, ht), ");") : Pt(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Pt), ");") : Pt(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Pt(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Pt, at, Ct.attributes, br), Y(Ve, ht, at, Ct.attributes, ur)), D3(Ve, Pt, at, Ct.uniforms, br, false), D3(Ve, ht, at, Ct.uniforms, ur, true), J(Ve, Pt, ht, at);\n                  else {\n                    var Ur = Ve.global.def("{}"), Di = at.shader.progVar.append(Ve, ht), fi = ht.def(Di, ".id"), Ti = ht.def(Ur, "[", fi, "]");\n                    ht(Ve.shared.gl, ".useProgram(", Di, ".program);", "if(!", Ti, "){", Ti, "=", Ur, "[", fi, "]=", Ve.link(function(gn) {\n                      return q2(ne, Ve, at, gn, 2);\n                    }), "(", Di, ");}", Ti, ".call(this,a0[", Rt, "],", Rt, ");");\n                  }\n                }\n                function Ue(Ve, Qe) {\n                  var at = Ve.proc("batch", 2);\n                  Ve.batchId = "0", ol(Ve, at);\n                  var Ct = false, Ot = true;\n                  Object.keys(Qe.context).forEach(function(Ur) {\n                    Ct = Ct || Qe.context[Ur].propDep;\n                  }), Ct || (ss(Ve, at, Qe.context), Ot = false);\n                  var Rt = Qe.framebuffer, Bt = false;\n                  Rt ? (Rt.propDep ? Ct = Bt = true : Rt.contextDep && Ct && (Bt = true), Bt || Vs(Ve, at, Rt)) : Vs(Ve, at, null), Qe.state.viewport && Qe.state.viewport.propDep && (Ct = true);\n                  function Dt(Ur) {\n                    return Ur.contextDep && Ct || Ur.propDep;\n                  }\n                  Ys(Ve, at, Qe), wa(Ve, at, Qe.state, function(Ur) {\n                    return !Dt(Ur);\n                  }), (!Qe.profile || !Dt(Qe.profile)) && io(Ve, at, Qe, false, "a1"), Qe.contextDep = Ct, Qe.needsContext = Ot, Qe.needsFramebuffer = Bt;\n                  var yt = Qe.shader.progVar;\n                  if (yt.contextDep && Ct || yt.propDep) we(Ve, at, Qe, null);\n                  else {\n                    var Pt = yt.append(Ve, at);\n                    if (at(Ve.shared.gl, ".useProgram(", Pt, ".program);"), Qe.shader.program) we(Ve, at, Qe, Qe.shader.program);\n                    else {\n                      at(Ve.shared.vao, ".setVAO(null);");\n                      var ht = Ve.global.def("{}"), ur = at.def(Pt, ".id"), br = at.def(ht, "[", ur, "]");\n                      at(Ve.cond(br).then(br, ".call(this,a0,a1);").else(br, "=", ht, "[", ur, "]=", Ve.link(function(Ur) {\n                        return q2(we, Ve, Qe, Ur, 2);\n                      }), "(", Pt, ");", br, ".call(this,a0,a1);"));\n                    }\n                  }\n                  Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");\n                }\n                function ft(Ve, Qe) {\n                  var at = Ve.proc("scope", 3);\n                  Ve.batchId = "a2";\n                  var Ct = Ve.shared, Ot = Ct.current;\n                  if (ss(Ve, at, Qe.context), Qe.framebuffer && Qe.framebuffer.append(Ve, at), Si(Object.keys(Qe.state)).forEach(function(Dt) {\n                    var yt = Qe.state[Dt], Pt = yt.append(Ve, at);\n                    Mn(Pt) ? Pt.forEach(function(ht, ur) {\n                      pn(ht) ? at.set(Ve.next[Dt], "[" + ur + "]", ht) : at.set(Ve.next[Dt], "[" + ur + "]", Ve.link(ht, { stable: true }));\n                    }) : Ln(yt) ? at.set(Ct.next, "." + Dt, Ve.link(Pt, { stable: true })) : at.set(Ct.next, "." + Dt, Pt);\n                  }), io(Ve, at, Qe, true, true), [Tt, xr, Kt, Ir, Yt].forEach(function(Dt) {\n                    var yt = Qe.draw[Dt];\n                    if (yt) {\n                      var Pt = yt.append(Ve, at);\n                      pn(Pt) ? at.set(Ct.draw, "." + Dt, Pt) : at.set(Ct.draw, "." + Dt, Ve.link(Pt), { stable: true });\n                    }\n                  }), Object.keys(Qe.uniforms).forEach(function(Dt) {\n                    var yt = Qe.uniforms[Dt].append(Ve, at);\n                    Array.isArray(yt) && (yt = "[" + yt.map(function(Pt) {\n                      return pn(Pt) ? Pt : Ve.link(Pt, { stable: true });\n                    }) + "]"), at.set(Ct.uniforms, "[" + Ve.link(bt.id(Dt), { stable: true }) + "]", yt);\n                  }), Object.keys(Qe.attributes).forEach(function(Dt) {\n                    var yt = Qe.attributes[Dt].append(Ve, at), Pt = Ve.scopeAttrib(Dt);\n                    Object.keys(new Yr()).forEach(function(ht) {\n                      at.set(Pt, "." + ht, yt[ht]);\n                    });\n                  }), Qe.scopeVAO) {\n                    var Rt = Qe.scopeVAO.append(Ve, at);\n                    pn(Rt) ? at.set(Ct.vao, ".targetVAO", Rt) : at.set(Ct.vao, ".targetVAO", Ve.link(Rt, { stable: true }));\n                  }\n                  function Bt(Dt) {\n                    var yt = Qe.shader[Dt];\n                    if (yt) {\n                      var Pt = yt.append(Ve, at);\n                      pn(Pt) ? at.set(Ct.shader, "." + Dt, Pt) : at.set(Ct.shader, "." + Dt, Ve.link(Pt, { stable: true }));\n                    }\n                  }\n                  Bt(Xe), Bt(ot), Object.keys(Qe.state).length > 0 && (at(Ot, ".dirty=true;"), at.exit(Ot, ".dirty=true;")), at("a1(", Ve.shared.context, ",a0,", Ve.batchId, ");");\n                }\n                function Xt(Ve) {\n                  if (!(typeof Ve != "object" || Mn(Ve))) {\n                    for (var Qe = Object.keys(Ve), at = 0; at < Qe.length; ++at) if (h3.isDynamic(Ve[Qe[at]])) return true;\n                    return false;\n                  }\n                }\n                function hr(Ve, Qe, at) {\n                  var Ct = Qe.static[at];\n                  if (!Ct || !Xt(Ct)) return;\n                  var Ot = Ve.global, Rt = Object.keys(Ct), Bt = false, Dt = false, yt = false, Pt = Ve.global.def("{}");\n                  Rt.forEach(function(ur) {\n                    var br = Ct[ur];\n                    if (h3.isDynamic(br)) {\n                      typeof br == "function" && (br = Ct[ur] = h3.unbox(br));\n                      var Ur = Un(br, null);\n                      Bt = Bt || Ur.thisDep, yt = yt || Ur.propDep, Dt = Dt || Ur.contextDep;\n                    } else {\n                      switch (Ot(Pt, ".", ur, "="), typeof br) {\n                        case "number":\n                          Ot(br);\n                          break;\n                        case "string":\n                          Ot(\'"\', br, \'"\');\n                          break;\n                        case "object":\n                          Array.isArray(br) && Ot("[", br.join(), "]");\n                          break;\n                        default:\n                          Ot(Ve.link(br));\n                          break;\n                      }\n                      Ot(";");\n                    }\n                  });\n                  function ht(ur, br) {\n                    Rt.forEach(function(Ur) {\n                      var Di = Ct[Ur];\n                      if (h3.isDynamic(Di)) {\n                        var fi = ur.invoke(br, Di);\n                        br(Pt, ".", Ur, "=", fi, ";");\n                      }\n                    });\n                  }\n                  Qe.dynamic[at] = new h3.DynamicVariable(Xo, { thisDep: Bt, contextDep: Dt, propDep: yt, ref: Pt, append: ht }), delete Qe.static[at];\n                }\n                function qt(Ve, Qe, at, Ct, Ot) {\n                  var Rt = kn();\n                  Rt.stats = Rt.link(Ot), Object.keys(Qe.static).forEach(function(Dt) {\n                    hr(Rt, Qe, Dt);\n                  }), dr.forEach(function(Dt) {\n                    hr(Rt, Ve, Dt);\n                  });\n                  var Bt = Vl(Ve, Qe, at, Ct, Rt);\n                  return Bt.shader.program && (Bt.shader.program.attributes.sort(function(Dt, yt) {\n                    return Dt.name < yt.name ? -1 : 1;\n                  }), Bt.shader.program.uniforms.sort(function(Dt, yt) {\n                    return Dt.name < yt.name ? -1 : 1;\n                  })), de(Rt, Bt), ft(Rt, Bt), Ue(Rt, Bt), e3(Rt.compile(), { destroy: function() {\n                    Bt.shader.program.destroy();\n                  } });\n                }\n                return { next: Bn, current: Zi, procs: (function() {\n                  var Ve = kn(), Qe = Ve.proc("poll"), at = Ve.proc("refresh"), Ct = Ve.block();\n                  Qe(Ct), at(Ct);\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.next, Dt = Ot.current;\n                  Ct(Dt, ".dirty=false;"), Vs(Ve, Qe), Vs(Ve, at, null, true);\n                  var yt;\n                  Ri && (yt = Ve.link(Ri)), zt.oes_vertex_array_object && at(Ve.link(zt.oes_vertex_array_object), ".bindVertexArrayOES(null);");\n                  var Pt = at.def(Ot.attributes), ht = at.def(0), ur = Ve.cond(ht, ".buffer");\n                  ur.then(Rt, ".enableVertexAttribArray(i);", Rt, ".bindBuffer(", Sr, ",", ht, ".buffer.buffer);", Rt, ".vertexAttribPointer(i,", ht, ".size,", ht, ".type,", ht, ".normalized,", ht, ".stride,", ht, ".offset);").else(Rt, ".disableVertexAttribArray(i);", Rt, ".vertexAttrib4f(i,", ht, ".x,", ht, ".y,", ht, ".z,", ht, ".w);", ht, ".buffer=null;");\n                  var br = Ve.link(Rr.maxAttributes, { stable: true });\n                  return at("for(var i=0;i<", br, ";++i){", ht, "=", Pt, "[i];", ur, "}"), Ri && at("for(var i=0;i<", br, ";++i){", yt, ".vertexAttribDivisorANGLE(i,", Pt, "[i].divisor);", "}"), at(Ve.shared.vao, ".currentVAO=null;", Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);"), Object.keys(li).forEach(function(Ur) {\n                    var Di = li[Ur], fi = Ct.def(Bt, ".", Ur), Ti = Ve.block();\n                    Ti("if(", fi, "){", Rt, ".enable(", Di, ")}else{", Rt, ".disable(", Di, ")}", Dt, ".", Ur, "=", fi, ";"), at(Ti), Qe("if(", fi, "!==", Dt, ".", Ur, "){", Ti, "}");\n                  }), Object.keys(mn).forEach(function(Ur) {\n                    var Di = mn[Ur], fi = Zi[Ur], Ti, gn, rn = Ve.block();\n                    if (rn(Rt, ".", Di, "("), Mn(fi)) {\n                      var Ci = fi.length;\n                      Ti = Ve.global.def(Bt, ".", Ur), gn = Ve.global.def(Dt, ".", Ur), rn(M4(Ci, function(Bi) {\n                        return Ti + "[" + Bi + "]";\n                      }), ");", M4(Ci, function(Bi) {\n                        return gn + "[" + Bi + "]=" + Ti + "[" + Bi + "];";\n                      }).join("")), Qe("if(", M4(Ci, function(Bi) {\n                        return Ti + "[" + Bi + "]!==" + gn + "[" + Bi + "]";\n                      }).join("||"), "){", rn, "}");\n                    } else Ti = Ct.def(Bt, ".", Ur), gn = Ct.def(Dt, ".", Ur), rn(Ti, ");", Dt, ".", Ur, "=", Ti, ";"), Qe("if(", Ti, "!==", gn, "){", rn, "}");\n                    at(rn);\n                  }), Ve.compile();\n                })(), compile: qt };\n              }\n              function Ia() {\n                return { vaoCount: 0, bufferCount: 0, elementsCount: 0, framebufferCount: 0, shaderCount: 0, textureCount: 0, cubeCount: 0, renderbufferCount: 0, maxTextureUnits: 0 };\n              }\n              var yo = 34918, Da = 34919, go = 35007, Is = function(Me, bt) {\n                if (!bt.ext_disjoint_timer_query) return null;\n                var zt = [];\n                function Rr() {\n                  return zt.pop() || bt.ext_disjoint_timer_query.createQueryEXT();\n                }\n                function jr(xi) {\n                  zt.push(xi);\n                }\n                var Nr = [];\n                function Gr(xi) {\n                  var Ri = Rr();\n                  bt.ext_disjoint_timer_query.beginQueryEXT(go, Ri), Nr.push(Ri), Wi(Nr.length - 1, Nr.length, xi);\n                }\n                function mi() {\n                  bt.ext_disjoint_timer_query.endQueryEXT(go);\n                }\n                function Ui() {\n                  this.startQueryIndex = -1, this.endQueryIndex = -1, this.sum = 0, this.stats = null;\n                }\n                var qi = [];\n                function Ei() {\n                  return qi.pop() || new Ui();\n                }\n                function Hn(xi) {\n                  qi.push(xi);\n                }\n                var en = [];\n                function Wi(xi, Ri, ci) {\n                  var an = Ei();\n                  an.startQueryIndex = xi, an.endQueryIndex = Ri, an.sum = 0, an.stats = ci, en.push(an);\n                }\n                var si = [], Mr = [];\n                function Yr() {\n                  var xi, Ri, ci = Nr.length;\n                  if (ci !== 0) {\n                    Mr.length = Math.max(Mr.length, ci + 1), si.length = Math.max(si.length, ci + 1), si[0] = 0, Mr[0] = 0;\n                    var an = 0;\n                    for (xi = 0, Ri = 0; Ri < Nr.length; ++Ri) {\n                      var Zi = Nr[Ri];\n                      bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, Da) ? (an += bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, yo), jr(Zi)) : Nr[xi++] = Zi, si[Ri + 1] = an, Mr[Ri + 1] = xi;\n                    }\n                    for (Nr.length = xi, xi = 0, Ri = 0; Ri < en.length; ++Ri) {\n                      var Bn = en[Ri], hi = Bn.startQueryIndex, li = Bn.endQueryIndex;\n                      Bn.sum += si[li] - si[hi];\n                      var mn = Mr[hi], Ji = Mr[li];\n                      Ji === mn ? (Bn.stats.gpuTime += Bn.sum / 1e6, Hn(Bn)) : (Bn.startQueryIndex = mn, Bn.endQueryIndex = Ji, en[xi++] = Bn);\n                    }\n                    en.length = xi;\n                  }\n                }\n                return { beginQuery: Gr, endQuery: mi, pushScopeStats: Wi, update: Yr, getNumPendingQueries: function() {\n                  return Nr.length;\n                }, clear: function() {\n                  zt.push.apply(zt, Nr);\n                  for (var xi = 0; xi < zt.length; xi++) bt.ext_disjoint_timer_query.deleteQueryEXT(zt[xi]);\n                  Nr.length = 0, zt.length = 0;\n                }, restore: function() {\n                  Nr.length = 0, zt.length = 0;\n                } };\n              }, Ms = 16384, Xs = 256, Gn = 1024, ja = 34962, Fo = "webglcontextlost", Uo = "webglcontextrestored", $s = 1, Sl = 2, bu = 3;\n              function dl(Me, bt) {\n                for (var zt = 0; zt < Me.length; ++zt) if (Me[zt] === bt) return zt;\n                return -1;\n              }\n              function Sc(Me) {\n                var bt = x2(Me);\n                if (!bt) return null;\n                var zt = bt.gl, Rr = zt.getContextAttributes(), jr = zt.isContextLost(), Nr = C3(zt, bt);\n                if (!Nr) return null;\n                var Gr = _2(), mi = Ia(), Ui = bt.cachedCode || {}, qi = Nr.extensions, Ei = Is(zt, qi), Hn = v3(), en = zt.drawingBufferWidth, Wi = zt.drawingBufferHeight, si = { tick: 0, time: 0, viewportWidth: en, viewportHeight: Wi, framebufferWidth: en, framebufferHeight: Wi, drawingBufferWidth: en, drawingBufferHeight: Wi, pixelRatio: bt.pixelRatio }, Mr = {}, Yr = { elements: null, primitive: 4, count: -1, offset: 0, instances: -1 }, xi = ti(zt, qi), Ri = ri(zt, mi, bt, Zi), ci = kr(zt, qi, Ri, mi), an = ku(zt, qi, xi, mi, Ri, ci, Yr);\n                function Zi(q2) {\n                  return an.destroyBuffer(q2);\n                }\n                var Bn = Wu(zt, Gr, mi, bt), hi = of(zt, qi, xi, function() {\n                  Ji.procs.poll();\n                }, si, mi, bt), li = Dc(zt, qi, xi, mi, bt), mn = lf(zt, qi, xi, hi, li, mi), Ji = Ea(zt, Gr, qi, xi, Ri, ci, hi, mn, Mr, an, Bn, Yr, si, Ei, Ui, bt), Vi = Wl(zt, mn, Ji.procs.poll, si, Rr, qi, xi), Ni = Ji.next, pn = zt.canvas, Vn = [], na = [], Ki = [], kn = [bt.onDestroy], ta = null;\n                function oa() {\n                  if (Vn.length === 0) {\n                    Ei && Ei.update(), ta = null;\n                    return;\n                  }\n                  ta = d3.next(oa), Ys();\n                  for (var q2 = Vn.length - 1; q2 >= 0; --q2) {\n                    var K = Vn[q2];\n                    K && K(si, null, 0);\n                  }\n                  zt.flush(), Ei && Ei.update();\n                }\n                function ba() {\n                  !ta && Vn.length > 0 && (ta = d3.next(oa));\n                }\n                function is() {\n                  ta && (d3.cancel(oa), ta = null);\n                }\n                function Zs(q2) {\n                  q2.preventDefault(), jr = true, is(), na.forEach(function(K) {\n                    K();\n                  });\n                }\n                function Va(q2) {\n                  zt.getError(), jr = false, Nr.restore(), Bn.restore(), Ri.restore(), hi.restore(), li.restore(), mn.restore(), an.restore(), Ei && Ei.restore(), Ji.procs.refresh(), ba(), Ki.forEach(function(K) {\n                    K();\n                  });\n                }\n                pn && (pn.addEventListener(Fo, Zs, false), pn.addEventListener(Uo, Va, false));\n                function Ml() {\n                  Vn.length = 0, is(), pn && (pn.removeEventListener(Fo, Zs), pn.removeEventListener(Uo, Va)), Bn.clear(), mn.clear(), li.clear(), an.clear(), hi.clear(), ci.clear(), Ri.clear(), Ei && Ei.clear(), kn.forEach(function(q2) {\n                    q2();\n                  });\n                }\n                function zo(q2) {\n                  function K(Rt) {\n                    var Bt = e3({}, Rt);\n                    delete Bt.uniforms, delete Bt.attributes, delete Bt.context, delete Bt.vao, "stencil" in Bt && Bt.stencil.op && (Bt.stencil.opBack = Bt.stencil.opFront = Bt.stencil.op, delete Bt.stencil.op);\n                    function Dt(yt) {\n                      if (yt in Bt) {\n                        var Pt = Bt[yt];\n                        delete Bt[yt], Object.keys(Pt).forEach(function(ht) {\n                          Bt[yt + "." + ht] = Pt[ht];\n                        });\n                      }\n                    }\n                    return Dt("blend"), Dt("depth"), Dt("cull"), Dt("stencil"), Dt("polygonOffset"), Dt("scissor"), Dt("sample"), "vao" in Rt && (Bt.vao = Rt.vao), Bt;\n                  }\n                  function de(Rt, Bt) {\n                    var Dt = {}, yt = {};\n                    return Object.keys(Rt).forEach(function(Pt) {\n                      var ht = Rt[Pt];\n                      if (h3.isDynamic(ht)) {\n                        yt[Pt] = h3.unbox(ht, Pt);\n                        return;\n                      } else if (Bt && Array.isArray(ht)) {\n                        for (var ur = 0; ur < ht.length; ++ur) if (h3.isDynamic(ht[ur])) {\n                          yt[Pt] = h3.unbox(ht, Pt);\n                          return;\n                        }\n                      }\n                      Dt[Pt] = ht;\n                    }), { dynamic: yt, static: Dt };\n                  }\n                  var ne = de(q2.context || {}, true), we = de(q2.uniforms || {}, true), Ue = de(q2.attributes || {}, false), ft = de(K(q2), false), Xt = { gpuTime: 0, cpuTime: 0, count: 0 }, hr = Ji.compile(ft, Ue, we, ne, Xt), qt = hr.draw, Ve = hr.batch, Qe = hr.scope, at = [];\n                  function Ct(Rt) {\n                    for (; at.length < Rt; ) at.push(null);\n                    return at;\n                  }\n                  function Ot(Rt, Bt) {\n                    var Dt;\n                    if (typeof Rt == "function") return Qe.call(this, null, Rt, 0);\n                    if (typeof Bt == "function") if (typeof Rt == "number") for (Dt = 0; Dt < Rt; ++Dt) Qe.call(this, null, Bt, Dt);\n                    else if (Array.isArray(Rt)) for (Dt = 0; Dt < Rt.length; ++Dt) Qe.call(this, Rt[Dt], Bt, Dt);\n                    else return Qe.call(this, Rt, Bt, 0);\n                    else if (typeof Rt == "number") {\n                      if (Rt > 0) return Ve.call(this, Ct(Rt | 0), Rt | 0);\n                    } else if (Array.isArray(Rt)) {\n                      if (Rt.length) return Ve.call(this, Rt, Rt.length);\n                    } else return qt.call(this, Rt);\n                  }\n                  return e3(Ot, { stats: Xt, destroy: function() {\n                    hr.destroy();\n                  } });\n                }\n                var Qs = mn.setFBO = zo({ framebuffer: h3.define.call(null, $s, "framebuffer") });\n                function al(q2, K) {\n                  var de = 0;\n                  Ji.procs.poll();\n                  var ne = K.color;\n                  ne && (zt.clearColor(+ne[0] || 0, +ne[1] || 0, +ne[2] || 0, +ne[3] || 0), de |= Ms), "depth" in K && (zt.clearDepth(+K.depth), de |= Xs), "stencil" in K && (zt.clearStencil(K.stencil | 0), de |= Gn), zt.clear(de);\n                }\n                function Vl(q2) {\n                  if ("framebuffer" in q2) if (q2.framebuffer && q2.framebuffer_reglType === "framebufferCube") for (var K = 0; K < 6; ++K) Qs(e3({ framebuffer: q2.framebuffer.faces[K] }, q2), al);\n                  else Qs(q2, al);\n                  else al(null, q2);\n                }\n                function ss(q2) {\n                  Vn.push(q2);\n                  function K() {\n                    var de = dl(Vn, q2);\n                    function ne() {\n                      var we = dl(Vn, ne);\n                      Vn[we] = Vn[Vn.length - 1], Vn.length -= 1, Vn.length <= 0 && is();\n                    }\n                    Vn[de] = ne;\n                  }\n                  return ba(), { cancel: K };\n                }\n                function Vs() {\n                  var q2 = Ni.viewport, K = Ni.scissor_box;\n                  q2[0] = q2[1] = K[0] = K[1] = 0, si.viewportWidth = si.framebufferWidth = si.drawingBufferWidth = q2[2] = K[2] = zt.drawingBufferWidth, si.viewportHeight = si.framebufferHeight = si.drawingBufferHeight = q2[3] = K[3] = zt.drawingBufferHeight;\n                }\n                function Ys() {\n                  si.tick += 1, si.time = ol(), Vs(), Ji.procs.poll();\n                }\n                function wa() {\n                  hi.refresh(), Vs(), Ji.procs.refresh(), Ei && Ei.update();\n                }\n                function ol() {\n                  return (v3() - Hn) / 1e3;\n                }\n                wa();\n                function io(q2, K) {\n                  var de;\n                  switch (q2) {\n                    case "frame":\n                      return ss(K);\n                    case "lost":\n                      de = na;\n                      break;\n                    case "restore":\n                      de = Ki;\n                      break;\n                    case "destroy":\n                      de = kn;\n                      break;\n                    default:\n                  }\n                  return de.push(K), { cancel: function() {\n                    for (var ne = 0; ne < de.length; ++ne) if (de[ne] === K) {\n                      de[ne] = de[de.length - 1], de.pop();\n                      return;\n                    }\n                  } };\n                }\n                function Y() {\n                  return Ui;\n                }\n                function D3(q2) {\n                  Object.entries(q2).forEach(function(K) {\n                    Ui[K[0]] = K[1];\n                  });\n                }\n                var J = e3(zo, { clear: Vl, prop: h3.define.bind(null, $s), context: h3.define.bind(null, Sl), this: h3.define.bind(null, bu), draw: zo({}), buffer: function(q2) {\n                  return Ri.create(q2, ja, false, false);\n                }, elements: function(q2) {\n                  return ci.create(q2, false);\n                }, texture: hi.create2D, cube: hi.createCube, renderbuffer: li.create, framebuffer: mn.create, framebufferCube: mn.createCube, vao: an.createVAO, attributes: Rr, frame: ss, on: io, limits: xi, hasExtension: function(q2) {\n                  return xi.extensions.indexOf(q2.toLowerCase()) >= 0;\n                }, read: Vi, destroy: Ml, _gl: zt, _refresh: wa, poll: function() {\n                  Ys(), Ei && Ei.update();\n                }, now: ol, stats: mi, getCachedCode: Y, preloadCachedCode: D3 });\n                return bt.onDone(null, J), J;\n              }\n              return Sc;\n            });\n          });\n          var Gqe = ye((r_r, Vqe) => {\n            "use strict";\n            var nUt = Zm();\n            Vqe.exports = function(t3) {\n              if (t3 ? typeof t3 == "string" && (t3 = { container: t3 }) : t3 = {}, Nqe(t3) ? t3 = { container: t3 } : aUt(t3) ? t3 = { container: t3 } : oUt(t3) ? t3 = { gl: t3 } : t3 = nUt(t3, { container: "container target element el canvas holder parent parentNode wrapper use ref root node", gl: "gl context webgl glContext", attrs: "attributes attrs contextAttributes", pixelRatio: "pixelRatio pxRatio px ratio pxratio pixelratio", width: "w width", height: "h height" }, true), t3.pixelRatio || (t3.pixelRatio = window.pixelRatio || 1), t3.gl) return t3.gl;\n              if (t3.canvas && (t3.container = t3.canvas.parentNode), t3.container) {\n                if (typeof t3.container == "string") {\n                  var r4 = document.querySelector(t3.container);\n                  if (!r4) throw Error("Element " + t3.container + " is not found");\n                  t3.container = r4;\n                }\n                Nqe(t3.container) ? (t3.canvas = t3.container, t3.container = t3.canvas.parentNode) : t3.canvas || (t3.canvas = Uqe(), t3.container.appendChild(t3.canvas), Bqe(t3));\n              } else if (!t3.canvas) if (typeof document != "undefined") t3.container = document.body || document.documentElement, t3.canvas = Uqe(), t3.container.appendChild(t3.canvas), Bqe(t3);\n              else throw Error("Not DOM environment. Use headless-gl.");\n              return t3.gl || ["webgl", "experimental-webgl", "webgl-experimental"].some(function(n4) {\n                try {\n                  t3.gl = t3.canvas.getContext(n4, t3.attrs);\n                } catch (i3) {\n                }\n                return t3.gl;\n              }), t3.gl;\n            };\n            function Bqe(e3) {\n              if (e3.container) if (e3.container == document.body) document.body.style.width || (e3.canvas.width = e3.width || e3.pixelRatio * window.innerWidth), document.body.style.height || (e3.canvas.height = e3.height || e3.pixelRatio * window.innerHeight);\n              else {\n                var t3 = e3.container.getBoundingClientRect();\n                e3.canvas.width = e3.width || t3.right - t3.left, e3.canvas.height = e3.height || t3.bottom - t3.top;\n              }\n            }\n            function Nqe(e3) {\n              return typeof e3.getContext == "function" && "width" in e3 && "height" in e3;\n            }\n            function aUt(e3) {\n              return typeof e3.nodeName == "string" && typeof e3.appendChild == "function" && typeof e3.getBoundingClientRect == "function";\n            }\n            function oUt(e3) {\n              return typeof e3.drawArrays == "function" || typeof e3.drawElements == "function";\n            }\n            function Uqe() {\n              var e3 = document.createElement("canvas");\n              return e3.style.position = "absolute", e3.style.top = 0, e3.style.left = 0, e3;\n            }\n          });\n          var jqe = ye((i_r, Hqe) => {\n            "use strict";\n            var sUt = eK(), lUt = [32, 126];\n            Hqe.exports = uUt;\n            function uUt(e3) {\n              e3 = e3 || {};\n              var t3 = e3.shape ? e3.shape : e3.canvas ? [e3.canvas.width, e3.canvas.height] : [512, 512], r4 = e3.canvas || document.createElement("canvas"), n4 = e3.font, i3 = typeof e3.step == "number" ? [e3.step, e3.step] : e3.step || [32, 32], a4 = e3.chars || lUt;\n              if (n4 && typeof n4 != "string" && (n4 = sUt(n4)), !Array.isArray(a4)) a4 = String(a4).split("");\n              else if (a4.length === 2 && typeof a4[0] == "number" && typeof a4[1] == "number") {\n                for (var o4 = [], s3 = a4[0], l3 = 0; s3 <= a4[1]; s3++) o4[l3++] = String.fromCharCode(s3);\n                a4 = o4;\n              }\n              t3 = t3.slice(), r4.width = t3[0], r4.height = t3[1];\n              var u4 = r4.getContext("2d");\n              u4.fillStyle = "#000", u4.fillRect(0, 0, r4.width, r4.height), u4.font = n4, u4.textAlign = "center", u4.textBaseline = "middle", u4.fillStyle = "#fff";\n              for (var c5 = i3[0] / 2, f4 = i3[1] / 2, s3 = 0; s3 < a4.length; s3++) u4.fillText(a4[s3], c5, f4), (c5 += i3[0]) > t3[0] - i3[0] / 2 && (c5 = i3[0] / 2, f4 += i3[1]);\n              return r4;\n            }\n          });\n          var nK = ye((Bh) => {\n            "use strict";\n            "use restrict";\n            var iK = 32;\n            Bh.INT_BITS = iK;\n            Bh.INT_MAX = 2147483647;\n            Bh.INT_MIN = -1 << iK - 1;\n            Bh.sign = function(e3) {\n              return (e3 > 0) - (e3 < 0);\n            };\n            Bh.abs = function(e3) {\n              var t3 = e3 >> iK - 1;\n              return (e3 ^ t3) - t3;\n            };\n            Bh.min = function(e3, t3) {\n              return t3 ^ (e3 ^ t3) & -(e3 < t3);\n            };\n            Bh.max = function(e3, t3) {\n              return e3 ^ (e3 ^ t3) & -(e3 < t3);\n            };\n            Bh.isPow2 = function(e3) {\n              return !(e3 & e3 - 1) && !!e3;\n            };\n            Bh.log2 = function(e3) {\n              var t3, r4;\n              return t3 = (e3 > 65535) << 4, e3 >>>= t3, r4 = (e3 > 255) << 3, e3 >>>= r4, t3 |= r4, r4 = (e3 > 15) << 2, e3 >>>= r4, t3 |= r4, r4 = (e3 > 3) << 1, e3 >>>= r4, t3 |= r4, t3 | e3 >> 1;\n            };\n            Bh.log10 = function(e3) {\n              return e3 >= 1e9 ? 9 : e3 >= 1e8 ? 8 : e3 >= 1e7 ? 7 : e3 >= 1e6 ? 6 : e3 >= 1e5 ? 5 : e3 >= 1e4 ? 4 : e3 >= 1e3 ? 3 : e3 >= 100 ? 2 : e3 >= 10 ? 1 : 0;\n            };\n            Bh.popCount = function(e3) {\n              return e3 = e3 - (e3 >>> 1 & 1431655765), e3 = (e3 & 858993459) + (e3 >>> 2 & 858993459), (e3 + (e3 >>> 4) & 252645135) * 16843009 >>> 24;\n            };\n            function Wqe(e3) {\n              var t3 = 32;\n              return e3 &= -e3, e3 && t3--, e3 & 65535 && (t3 -= 16), e3 & 16711935 && (t3 -= 8), e3 & 252645135 && (t3 -= 4), e3 & 858993459 && (t3 -= 2), e3 & 1431655765 && (t3 -= 1), t3;\n            }\n            Bh.countTrailingZeros = Wqe;\n            Bh.nextPow2 = function(e3) {\n              return e3 += e3 === 0, --e3, e3 |= e3 >>> 1, e3 |= e3 >>> 2, e3 |= e3 >>> 4, e3 |= e3 >>> 8, e3 |= e3 >>> 16, e3 + 1;\n            };\n            Bh.prevPow2 = function(e3) {\n              return e3 |= e3 >>> 1, e3 |= e3 >>> 2, e3 |= e3 >>> 4, e3 |= e3 >>> 8, e3 |= e3 >>> 16, e3 - (e3 >>> 1);\n            };\n            Bh.parity = function(e3) {\n              return e3 ^= e3 >>> 16, e3 ^= e3 >>> 8, e3 ^= e3 >>> 4, e3 &= 15, 27030 >>> e3 & 1;\n            };\n            var Mk = new Array(256);\n            (function(e3) {\n              for (var t3 = 0; t3 < 256; ++t3) {\n                var r4 = t3, n4 = t3, i3 = 7;\n                for (r4 >>>= 1; r4; r4 >>>= 1) n4 <<= 1, n4 |= r4 & 1, --i3;\n                e3[t3] = n4 << i3 & 255;\n              }\n            })(Mk);\n            Bh.reverse = function(e3) {\n              return Mk[e3 & 255] << 24 | Mk[e3 >>> 8 & 255] << 16 | Mk[e3 >>> 16 & 255] << 8 | Mk[e3 >>> 24 & 255];\n            };\n            Bh.interleave2 = function(e3, t3) {\n              return e3 &= 65535, e3 = (e3 | e3 << 8) & 16711935, e3 = (e3 | e3 << 4) & 252645135, e3 = (e3 | e3 << 2) & 858993459, e3 = (e3 | e3 << 1) & 1431655765, t3 &= 65535, t3 = (t3 | t3 << 8) & 16711935, t3 = (t3 | t3 << 4) & 252645135, t3 = (t3 | t3 << 2) & 858993459, t3 = (t3 | t3 << 1) & 1431655765, e3 | t3 << 1;\n            };\n            Bh.deinterleave2 = function(e3, t3) {\n              return e3 = e3 >>> t3 & 1431655765, e3 = (e3 | e3 >>> 1) & 858993459, e3 = (e3 | e3 >>> 2) & 252645135, e3 = (e3 | e3 >>> 4) & 16711935, e3 = (e3 | e3 >>> 16) & 65535, e3 << 16 >> 16;\n            };\n            Bh.interleave3 = function(e3, t3, r4) {\n              return e3 &= 1023, e3 = (e3 | e3 << 16) & 4278190335, e3 = (e3 | e3 << 8) & 251719695, e3 = (e3 | e3 << 4) & 3272356035, e3 = (e3 | e3 << 2) & 1227133513, t3 &= 1023, t3 = (t3 | t3 << 16) & 4278190335, t3 = (t3 | t3 << 8) & 251719695, t3 = (t3 | t3 << 4) & 3272356035, t3 = (t3 | t3 << 2) & 1227133513, e3 |= t3 << 1, r4 &= 1023, r4 = (r4 | r4 << 16) & 4278190335, r4 = (r4 | r4 << 8) & 251719695, r4 = (r4 | r4 << 4) & 3272356035, r4 = (r4 | r4 << 2) & 1227133513, e3 | r4 << 2;\n            };\n            Bh.deinterleave3 = function(e3, t3) {\n              return e3 = e3 >>> t3 & 1227133513, e3 = (e3 | e3 >>> 2) & 3272356035, e3 = (e3 | e3 >>> 4) & 251719695, e3 = (e3 | e3 >>> 8) & 4278190335, e3 = (e3 | e3 >>> 16) & 1023, e3 << 22 >> 22;\n            };\n            Bh.nextCombination = function(e3) {\n              var t3 = e3 | e3 - 1;\n              return t3 + 1 | (~t3 & -~t3) - 1 >>> Wqe(e3) + 1;\n            };\n          });\n          var Yqe = ye((a_r, Zqe) => {\n            "use strict";\n            function Xqe(e3, t3, r4) {\n              var n4 = e3[r4] | 0;\n              if (n4 <= 0) return [];\n              var i3 = new Array(n4), a4;\n              if (r4 === e3.length - 1) for (a4 = 0; a4 < n4; ++a4) i3[a4] = t3;\n              else for (a4 = 0; a4 < n4; ++a4) i3[a4] = Xqe(e3, t3, r4 + 1);\n              return i3;\n            }\n            function cUt(e3, t3) {\n              var r4, n4;\n              for (r4 = new Array(e3), n4 = 0; n4 < e3; ++n4) r4[n4] = t3;\n              return r4;\n            }\n            function fUt(e3, t3) {\n              switch (typeof t3 == "undefined" && (t3 = 0), typeof e3) {\n                case "number":\n                  if (e3 > 0) return cUt(e3 | 0, t3);\n                  break;\n                case "object":\n                  if (typeof e3.length == "number") return Xqe(e3, t3, 0);\n                  break;\n              }\n              return [];\n            }\n            Zqe.exports = fUt;\n          });\n          var cBe = ye((mu) => {\n            "use strict";\n            var fx = nK(), Ev = Yqe(), Kqe = c22().Buffer;\n            window.__TYPEDARRAY_POOL || (window.__TYPEDARRAY_POOL = { UINT8: Ev([32, 0]), UINT16: Ev([32, 0]), UINT32: Ev([32, 0]), BIGUINT64: Ev([32, 0]), INT8: Ev([32, 0]), INT16: Ev([32, 0]), INT32: Ev([32, 0]), BIGINT64: Ev([32, 0]), FLOAT: Ev([32, 0]), DOUBLE: Ev([32, 0]), DATA: Ev([32, 0]), UINT8C: Ev([32, 0]), BUFFER: Ev([32, 0]) });\n            var hUt = typeof Uint8ClampedArray != "undefined", dUt = typeof BigUint64Array != "undefined", vUt = typeof BigInt64Array != "undefined", nd = window.__TYPEDARRAY_POOL;\n            nd.UINT8C || (nd.UINT8C = Ev([32, 0]));\n            nd.BIGUINT64 || (nd.BIGUINT64 = Ev([32, 0]));\n            nd.BIGINT64 || (nd.BIGINT64 = Ev([32, 0]));\n            nd.BUFFER || (nd.BUFFER = Ev([32, 0]));\n            var _z = nd.DATA, xz = nd.BUFFER;\n            mu.free = function(t3) {\n              if (Kqe.isBuffer(t3)) xz[fx.log2(t3.length)].push(t3);\n              else {\n                if (Object.prototype.toString.call(t3) !== "[object ArrayBuffer]" && (t3 = t3.buffer), !t3) return;\n                var r4 = t3.length || t3.byteLength, n4 = fx.log2(r4) | 0;\n                _z[n4].push(t3);\n              }\n            };\n            function Jqe(e3) {\n              if (e3) {\n                var t3 = e3.length || e3.byteLength, r4 = fx.log2(t3);\n                _z[r4].push(e3);\n              }\n            }\n            function pUt(e3) {\n              Jqe(e3.buffer);\n            }\n            mu.freeUint8 = mu.freeUint16 = mu.freeUint32 = mu.freeBigUint64 = mu.freeInt8 = mu.freeInt16 = mu.freeInt32 = mu.freeBigInt64 = mu.freeFloat32 = mu.freeFloat = mu.freeFloat64 = mu.freeDouble = mu.freeUint8Clamped = mu.freeDataView = pUt;\n            mu.freeArrayBuffer = Jqe;\n            mu.freeBuffer = function(t3) {\n              xz[fx.log2(t3.length)].push(t3);\n            };\n            mu.malloc = function(t3, r4) {\n              if (r4 === void 0 || r4 === "arraybuffer") return Bp(t3);\n              switch (r4) {\n                case "uint8":\n                  return aK(t3);\n                case "uint16":\n                  return $qe(t3);\n                case "uint32":\n                  return Qqe(t3);\n                case "int8":\n                  return eBe(t3);\n                case "int16":\n                  return tBe(t3);\n                case "int32":\n                  return rBe(t3);\n                case "float":\n                case "float32":\n                  return iBe(t3);\n                case "double":\n                case "float64":\n                  return nBe(t3);\n                case "uint8_clamped":\n                  return aBe(t3);\n                case "bigint64":\n                  return sBe(t3);\n                case "biguint64":\n                  return oBe(t3);\n                case "buffer":\n                  return uBe(t3);\n                case "data":\n                case "dataview":\n                  return lBe(t3);\n                default:\n                  return null;\n              }\n              return null;\n            };\n            function Bp(t3) {\n              var t3 = fx.nextPow2(t3), r4 = fx.log2(t3), n4 = _z[r4];\n              return n4.length > 0 ? n4.pop() : new ArrayBuffer(t3);\n            }\n            mu.mallocArrayBuffer = Bp;\n            function aK(e3) {\n              return new Uint8Array(Bp(e3), 0, e3);\n            }\n            mu.mallocUint8 = aK;\n            function $qe(e3) {\n              return new Uint16Array(Bp(2 * e3), 0, e3);\n            }\n            mu.mallocUint16 = $qe;\n            function Qqe(e3) {\n              return new Uint32Array(Bp(4 * e3), 0, e3);\n            }\n            mu.mallocUint32 = Qqe;\n            function eBe(e3) {\n              return new Int8Array(Bp(e3), 0, e3);\n            }\n            mu.mallocInt8 = eBe;\n            function tBe(e3) {\n              return new Int16Array(Bp(2 * e3), 0, e3);\n            }\n            mu.mallocInt16 = tBe;\n            function rBe(e3) {\n              return new Int32Array(Bp(4 * e3), 0, e3);\n            }\n            mu.mallocInt32 = rBe;\n            function iBe(e3) {\n              return new Float32Array(Bp(4 * e3), 0, e3);\n            }\n            mu.mallocFloat32 = mu.mallocFloat = iBe;\n            function nBe(e3) {\n              return new Float64Array(Bp(8 * e3), 0, e3);\n            }\n            mu.mallocFloat64 = mu.mallocDouble = nBe;\n            function aBe(e3) {\n              return hUt ? new Uint8ClampedArray(Bp(e3), 0, e3) : aK(e3);\n            }\n            mu.mallocUint8Clamped = aBe;\n            function oBe(e3) {\n              return dUt ? new BigUint64Array(Bp(8 * e3), 0, e3) : null;\n            }\n            mu.mallocBigUint64 = oBe;\n            function sBe(e3) {\n              return vUt ? new BigInt64Array(Bp(8 * e3), 0, e3) : null;\n            }\n            mu.mallocBigInt64 = sBe;\n            function lBe(e3) {\n              return new DataView(Bp(e3), 0, e3);\n            }\n            mu.mallocDataView = lBe;\n            function uBe(e3) {\n              e3 = fx.nextPow2(e3);\n              var t3 = fx.log2(e3), r4 = xz[t3];\n              return r4.length > 0 ? r4.pop() : new Kqe(e3);\n            }\n            mu.mallocBuffer = uBe;\n            mu.clearCache = function() {\n              for (var t3 = 0; t3 < 32; ++t3) nd.UINT8[t3].length = 0, nd.UINT16[t3].length = 0, nd.UINT32[t3].length = 0, nd.INT8[t3].length = 0, nd.INT16[t3].length = 0, nd.INT32[t3].length = 0, nd.FLOAT[t3].length = 0, nd.DOUBLE[t3].length = 0, nd.BIGUINT64[t3].length = 0, nd.BIGINT64[t3].length = 0, nd.UINT8C[t3].length = 0, _z[t3].length = 0, xz[t3].length = 0;\n            };\n          });\n          var hBe = ye((s_r, fBe) => {\n            "use strict";\n            var gUt = Object.prototype.toString;\n            fBe.exports = function(e3) {\n              var t3;\n              return gUt.call(e3) === "[object Object]" && (t3 = Object.getPrototypeOf(e3), t3 === null || t3 === Object.getPrototypeOf({}));\n            };\n          });\n          var oK = ye((l_r, dBe) => {\n            dBe.exports = function(t3, r4) {\n              r4 || (r4 = [0, ""]), t3 = String(t3);\n              var n4 = parseFloat(t3, 10);\n              return r4[0] = n4, r4[1] = t3.match(/[\\d.\\-\\+]*\\s*(.*)/)[1] || "", r4;\n            };\n          });\n          var gBe = ye((u_r, pBe) => {\n            "use strict";\n            var mUt = oK();\n            pBe.exports = vBe;\n            var Ek = 96;\n            function sK(e3, t3) {\n              var r4 = mUt(getComputedStyle(e3).getPropertyValue(t3));\n              return r4[0] * vBe(r4[1], e3);\n            }\n            function yUt(e3, t3) {\n              var r4 = document.createElement("div");\n              r4.style["font-size"] = "128" + e3, t3.appendChild(r4);\n              var n4 = sK(r4, "font-size") / 128;\n              return t3.removeChild(r4), n4;\n            }\n            function vBe(e3, t3) {\n              switch (t3 = t3 || document.body, e3 = (e3 || "px").trim().toLowerCase(), (t3 === window || t3 === document) && (t3 = document.body), e3) {\n                case "%":\n                  return t3.clientHeight / 100;\n                case "ch":\n                case "ex":\n                  return yUt(e3, t3);\n                case "em":\n                  return sK(t3, "font-size");\n                case "rem":\n                  return sK(document.body, "font-size");\n                case "vw":\n                  return window.innerWidth / 100;\n                case "vh":\n                  return window.innerHeight / 100;\n                case "vmin":\n                  return Math.min(window.innerWidth, window.innerHeight) / 100;\n                case "vmax":\n                  return Math.max(window.innerWidth, window.innerHeight) / 100;\n                case "in":\n                  return Ek;\n                case "cm":\n                  return Ek / 2.54;\n                case "mm":\n                  return Ek / 25.4;\n                case "pt":\n                  return Ek / 72;\n                case "pc":\n                  return Ek / 6;\n              }\n              return 1;\n            }\n          });\n          var _Be = ye((c_r, yBe) => {\n            "use strict";\n            yBe.exports = Tz;\n            var _Ut = Tz.canvas = document.createElement("canvas"), bz = _Ut.getContext("2d"), mBe = wz([32, 126]);\n            Tz.createPairs = wz;\n            Tz.ascii = mBe;\n            function Tz(e3, t3) {\n              Array.isArray(e3) && (e3 = e3.join(", "));\n              var r4 = {}, n4, i3 = 16, a4 = 0.05;\n              t3 && (t3.length === 2 && typeof t3[0] == "number" ? n4 = wz(t3) : Array.isArray(t3) ? n4 = t3 : (t3.o ? n4 = wz(t3.o) : t3.pairs && (n4 = t3.pairs), t3.fontSize && (i3 = t3.fontSize), t3.threshold != null && (a4 = t3.threshold))), n4 || (n4 = mBe), bz.font = i3 + "px " + e3;\n              for (var o4 = 0; o4 < n4.length; o4++) {\n                var s3 = n4[o4], l3 = bz.measureText(s3[0]).width + bz.measureText(s3[1]).width, u4 = bz.measureText(s3).width;\n                if (Math.abs(l3 - u4) > i3 * a4) {\n                  var c5 = (u4 - l3) / i3;\n                  r4[s3] = c5 * 1e3;\n                }\n              }\n              return r4;\n            }\n            function wz(e3) {\n              for (var t3 = [], r4 = e3[0]; r4 <= e3[1]; r4++) for (var n4 = String.fromCharCode(r4), i3 = e3[0]; i3 < e3[1]; i3++) {\n                var a4 = String.fromCharCode(i3), o4 = n4 + a4;\n                t3.push(o4);\n              }\n              return t3;\n            }\n          });\n          var TBe = ye((f_r, wBe) => {\n            "use strict";\n            wBe.exports = hx;\n            hx.canvas = document.createElement("canvas");\n            hx.cache = {};\n            function hx(o4, t3) {\n              t3 || (t3 = {}), (typeof o4 == "string" || Array.isArray(o4)) && (t3.family = o4);\n              var r4 = Array.isArray(t3.family) ? t3.family.join(", ") : t3.family;\n              if (!r4) throw Error("`family` must be defined");\n              var n4 = t3.size || t3.fontSize || t3.em || 48, i3 = t3.weight || t3.fontWeight || "", a4 = t3.style || t3.fontStyle || "", o4 = [a4, i3, n4].join(" ") + "px " + r4, s3 = t3.origin || "top";\n              if (hx.cache[r4] && n4 <= hx.cache[r4].em) return xBe(hx.cache[r4], s3);\n              var l3 = t3.canvas || hx.canvas, u4 = l3.getContext("2d"), c5 = { upper: t3.upper !== void 0 ? t3.upper : "H", lower: t3.lower !== void 0 ? t3.lower : "x", descent: t3.descent !== void 0 ? t3.descent : "p", ascent: t3.ascent !== void 0 ? t3.ascent : "h", tittle: t3.tittle !== void 0 ? t3.tittle : "i", overshoot: t3.overshoot !== void 0 ? t3.overshoot : "O" }, f4 = Math.ceil(n4 * 1.5);\n              l3.height = f4, l3.width = f4 * 0.5, u4.font = o4;\n              var h3 = "H", d3 = { top: 0 };\n              u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillStyle = "black", u4.fillText(h3, 0, 0);\n              var v3 = Km(u4.getImageData(0, 0, f4, f4));\n              u4.clearRect(0, 0, f4, f4), u4.textBaseline = "bottom", u4.fillText(h3, 0, f4);\n              var _2 = Km(u4.getImageData(0, 0, f4, f4));\n              d3.lineHeight = d3.bottom = f4 - _2 + v3, u4.clearRect(0, 0, f4, f4), u4.textBaseline = "alphabetic", u4.fillText(h3, 0, f4);\n              var b = Km(u4.getImageData(0, 0, f4, f4)), p3 = f4 - b - 1 + v3;\n              d3.baseline = d3.alphabetic = p3, u4.clearRect(0, 0, f4, f4), u4.textBaseline = "middle", u4.fillText(h3, 0, f4 * 0.5);\n              var k4 = Km(u4.getImageData(0, 0, f4, f4));\n              d3.median = d3.middle = f4 - k4 - 1 + v3 - f4 * 0.5, u4.clearRect(0, 0, f4, f4), u4.textBaseline = "hanging", u4.fillText(h3, 0, f4 * 0.5);\n              var E3 = Km(u4.getImageData(0, 0, f4, f4));\n              d3.hanging = f4 - E3 - 1 + v3 - f4 * 0.5, u4.clearRect(0, 0, f4, f4), u4.textBaseline = "ideographic", u4.fillText(h3, 0, f4);\n              var S2 = Km(u4.getImageData(0, 0, f4, f4));\n              if (d3.ideographic = f4 - S2 - 1 + v3, c5.upper && (u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.upper, 0, 0), d3.upper = Km(u4.getImageData(0, 0, f4, f4)), d3.capHeight = d3.baseline - d3.upper), c5.lower && (u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.lower, 0, 0), d3.lower = Km(u4.getImageData(0, 0, f4, f4)), d3.xHeight = d3.baseline - d3.lower), c5.tittle && (u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.tittle, 0, 0), d3.tittle = Km(u4.getImageData(0, 0, f4, f4))), c5.ascent && (u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.ascent, 0, 0), d3.ascent = Km(u4.getImageData(0, 0, f4, f4))), c5.descent && (u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.descent, 0, 0), d3.descent = bBe(u4.getImageData(0, 0, f4, f4))), c5.overshoot) {\n                u4.clearRect(0, 0, f4, f4), u4.textBaseline = "top", u4.fillText(c5.overshoot, 0, 0);\n                var L3 = bBe(u4.getImageData(0, 0, f4, f4));\n                d3.overshoot = L3 - p3;\n              }\n              for (var x2 in d3) d3[x2] /= n4;\n              return d3.em = n4, hx.cache[r4] = d3, xBe(d3, s3);\n            }\n            function xBe(e3, t3) {\n              var r4 = {};\n              typeof t3 == "string" && (t3 = e3[t3]);\n              for (var n4 in e3) n4 !== "em" && (r4[n4] = e3[n4] - t3);\n              return r4;\n            }\n            function Km(e3) {\n              for (var t3 = e3.height, r4 = e3.data, n4 = 3; n4 < r4.length; n4 += 4) if (r4[n4] !== 0) return Math.floor((n4 - 3) * 0.25 / t3);\n            }\n            function bBe(e3) {\n              for (var t3 = e3.height, r4 = e3.data, n4 = r4.length - 1; n4 > 0; n4 -= 4) if (r4[n4] !== 0) return Math.floor((n4 - 3) * 0.25 / t3);\n            }\n          });\n          var EBe = ye((h_r, MBe) => {\n            "use strict";\n            var p5 = Oqe(), xUt = Zm(), bUt = qqe(), wUt = Gqe(), TUt = NY(), lK = J_(), AUt = jqe(), dx = cBe(), SUt = i5(), MUt = hBe(), EUt = oK(), kUt = gBe(), CUt = _Be(), LUt = Oh(), PUt = TBe(), IUt = Z2(), RUt = nK(), ABe = RUt.nextPow2, SBe = new TUt(), Sz = false;\n            document.body && (Az = document.body.appendChild(document.createElement("div")), Az.style.font = "italic small-caps bold condensed 16px/2 cursive", getComputedStyle(Az).fontStretch && (Sz = true), document.body.removeChild(Az));\n            var Az, xc = function(t3) {\n              DUt(t3) ? (t3 = { regl: t3 }, this.gl = t3.regl._gl) : this.gl = wUt(t3), this.shader = SBe.get(this.gl), this.shader ? this.regl = this.shader.regl : this.regl = t3.regl || bUt({ gl: this.gl }), this.charBuffer = this.regl.buffer({ type: "uint8", usage: "stream" }), this.sizeBuffer = this.regl.buffer({ type: "float", usage: "stream" }), this.shader || (this.shader = this.createShader(), SBe.set(this.gl, this.shader)), this.batch = [], this.fontSize = [], this.font = [], this.fontAtlas = [], this.draw = this.shader.draw.bind(this), this.render = function() {\n                this.regl._refresh(), this.draw(this.batch);\n              }, this.canvas = this.gl.canvas, this.update(MUt(t3) ? t3 : {});\n            };\n            xc.prototype.createShader = function() {\n              var t3 = this.regl, r4 = t3({ blend: { enable: true, color: [0, 0, 0, 1], func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: "one minus dst alpha", dstAlpha: "one" } }, stencil: { enable: false }, depth: { enable: false }, count: t3.prop("count"), offset: t3.prop("offset"), attributes: { charOffset: { offset: 4, stride: 8, buffer: t3.this("sizeBuffer") }, width: { offset: 0, stride: 8, buffer: t3.this("sizeBuffer") }, char: t3.this("charBuffer"), position: t3.this("position") }, uniforms: { atlasSize: function(i3, a4) {\n                return [a4.atlas.width, a4.atlas.height];\n              }, atlasDim: function(i3, a4) {\n                return [a4.atlas.cols, a4.atlas.rows];\n              }, atlas: function(i3, a4) {\n                return a4.atlas.texture;\n              }, charStep: function(i3, a4) {\n                return a4.atlas.step;\n              }, em: function(i3, a4) {\n                return a4.atlas.em;\n              }, color: t3.prop("color"), opacity: t3.prop("opacity"), viewport: t3.this("viewportArray"), scale: t3.this("scale"), align: t3.prop("align"), baseline: t3.prop("baseline"), translate: t3.this("translate"), positionOffset: t3.prop("positionOffset") }, primitive: "points", viewport: t3.this("viewport"), vert: `\n			precision highp float;\n			attribute float width, charOffset, char;\n			attribute vec2 position;\n			uniform float fontSize, charStep, em, align, baseline;\n			uniform vec4 viewport;\n			uniform vec4 color;\n			uniform vec2 atlasSize, atlasDim, scale, translate, positionOffset;\n			varying vec2 charCoord, charId;\n			varying float charWidth;\n			varying vec4 fontColor;\n			void main () {\n				vec2 offset = floor(em * (vec2(align + charOffset, baseline)\n					+ vec2(positionOffset.x, -positionOffset.y)))\n					/ (viewport.zw * scale.xy);\n\n				vec2 position = (position + translate) * scale;\n				position += offset * scale;\n\n				charCoord = position * viewport.zw + viewport.xy;\n\n				gl_Position = vec4(position * 2. - 1., 0, 1);\n\n				gl_PointSize = charStep;\n\n				charId.x = mod(char, atlasDim.x);\n				charId.y = floor(char / atlasDim.x);\n\n				charWidth = width * em;\n\n				fontColor = color / 255.;\n			}`, frag: `\n			precision highp float;\n			uniform float fontSize, charStep, opacity;\n			uniform vec2 atlasSize;\n			uniform vec4 viewport;\n			uniform sampler2D atlas;\n			varying vec4 fontColor;\n			varying vec2 charCoord, charId;\n			varying float charWidth;\n\n			float lightness(vec4 color) {\n				return color.r * 0.299 + color.g * 0.587 + color.b * 0.114;\n			}\n\n			void main () {\n				vec2 uv = gl_FragCoord.xy - charCoord + charStep * .5;\n				float halfCharStep = floor(charStep * .5 + .5);\n\n				// invert y and shift by 1px (FF expecially needs that)\n				uv.y = charStep - uv.y;\n\n				// ignore points outside of character bounding box\n				float halfCharWidth = ceil(charWidth * .5);\n				if (floor(uv.x) > halfCharStep + halfCharWidth ||\n					floor(uv.x) < halfCharStep - halfCharWidth) return;\n\n				uv += charId * charStep;\n				uv = uv / atlasSize;\n\n				vec4 color = fontColor;\n				vec4 mask = texture2D(atlas, uv);\n\n				float maskY = lightness(mask);\n				// float colorY = lightness(color);\n				color.a *= maskY;\n				color.a *= opacity;\n\n				// color.a += .1;\n\n				// antialiasing, see yiq color space y-channel formula\n				// color.rgb += (1. - color.rgb) * (1. - mask.rgb);\n\n				gl_FragColor = color;\n			}` }), n4 = {};\n              return { regl: t3, draw: r4, atlas: n4 };\n            };\n            xc.prototype.update = function(t3) {\n              var r4 = this;\n              if (typeof t3 == "string") t3 = { text: t3 };\n              else if (!t3) return;\n              t3 = xUt(t3, { position: "position positions coord coords coordinates", font: "font fontFace fontface typeface cssFont css-font family fontFamily", fontSize: "fontSize fontsize size font-size", text: "text texts chars characters value values symbols", align: "align alignment textAlign textbaseline", baseline: "baseline textBaseline textbaseline", direction: "dir direction textDirection", color: "color colour fill fill-color fillColor textColor textcolor", kerning: "kerning kern", range: "range dataBox", viewport: "vp viewport viewBox viewbox viewPort", opacity: "opacity alpha transparency visible visibility opaque", offset: "offset positionOffset padding shift indent indentation" }, true), t3.opacity != null && (Array.isArray(t3.opacity) ? this.opacity = t3.opacity.map(function(Ce) {\n                return parseFloat(Ce);\n              }) : this.opacity = parseFloat(t3.opacity)), t3.viewport != null && (this.viewport = SUt(t3.viewport), this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]), this.viewport == null && (this.viewport = { x: 0, y: 0, width: this.gl.drawingBufferWidth, height: this.gl.drawingBufferHeight }, this.viewportArray = [this.viewport.x, this.viewport.y, this.viewport.width, this.viewport.height]), t3.kerning != null && (this.kerning = t3.kerning), t3.offset != null && (typeof t3.offset == "number" && (t3.offset = [t3.offset, 0]), this.positionOffset = IUt(t3.offset)), t3.direction && (this.direction = t3.direction), t3.range && (this.range = t3.range, this.scale = [1 / (t3.range[2] - t3.range[0]), 1 / (t3.range[3] - t3.range[1])], this.translate = [-t3.range[0], -t3.range[1]]), t3.scale && (this.scale = t3.scale), t3.translate && (this.translate = t3.translate), this.scale || (this.scale = [1 / this.viewport.width, 1 / this.viewport.height]), this.translate || (this.translate = [0, 0]), !this.font.length && !t3.font && (t3.font = xc.baseFontSize + "px sans-serif");\n              var n4 = false, i3 = false;\n              if (t3.font && (Array.isArray(t3.font) ? t3.font : [t3.font]).forEach(function(Ce, me) {\n                if (typeof Ce == "string") try {\n                  Ce = p5.parse(Ce);\n                } catch (Ze) {\n                  Ce = p5.parse(xc.baseFontSize + "px " + Ce);\n                }\n                else {\n                  var ie = Ce.style, Se = Ce.weight, Le = Ce.stretch, Ae = Ce.variant;\n                  Ce = p5.parse(p5.stringify(Ce)), ie && (Ce.style = ie), Se && (Ce.weight = Se), Le && (Ce.stretch = Le), Ae && (Ce.variant = Ae);\n                }\n                var Fe = p5.stringify({ size: xc.baseFontSize, family: Ce.family, stretch: Sz ? Ce.stretch : void 0, variant: Ce.variant, weight: Ce.weight, style: Ce.style }), Pe = EUt(Ce.size), ge = Math.round(Pe[0] * kUt(Pe[1]));\n                if (ge !== r4.fontSize[me] && (i3 = true, r4.fontSize[me] = ge), (!r4.font[me] || Fe != r4.font[me].baseString) && (n4 = true, r4.font[me] = xc.fonts[Fe], !r4.font[me])) {\n                  var Re = Ce.family.join(", "), ce = [Ce.style];\n                  Ce.style != Ce.variant && ce.push(Ce.variant), Ce.variant != Ce.weight && ce.push(Ce.weight), Sz && Ce.weight != Ce.stretch && ce.push(Ce.stretch), r4.font[me] = { baseString: Fe, family: Re, weight: Ce.weight, stretch: Ce.stretch, style: Ce.style, variant: Ce.variant, width: {}, kerning: {}, metrics: PUt(Re, { origin: "top", fontSize: xc.baseFontSize, fontStyle: ce.join(" ") }) }, xc.fonts[Fe] = r4.font[me];\n                }\n              }), (n4 || i3) && this.font.forEach(function(Ce, me) {\n                var ie = p5.stringify({ size: r4.fontSize[me], family: Ce.family, stretch: Sz ? Ce.stretch : void 0, variant: Ce.variant, weight: Ce.weight, style: Ce.style });\n                if (r4.fontAtlas[me] = r4.shader.atlas[ie], !r4.fontAtlas[me]) {\n                  var Se = Ce.metrics;\n                  r4.shader.atlas[ie] = r4.fontAtlas[me] = { fontString: ie, step: Math.ceil(r4.fontSize[me] * Se.bottom * 0.5) * 2, em: r4.fontSize[me], cols: 0, rows: 0, height: 0, width: 0, chars: [], ids: {}, texture: r4.regl.texture() };\n                }\n                t3.text == null && (t3.text = r4.text);\n              }), typeof t3.text == "string" && t3.position && t3.position.length > 2) {\n                for (var a4 = Array(t3.position.length * 0.5), o4 = 0; o4 < a4.length; o4++) a4[o4] = t3.text;\n                t3.text = a4;\n              }\n              var s3;\n              if (t3.text != null || n4) {\n                if (this.textOffsets = [0], Array.isArray(t3.text)) {\n                  this.count = t3.text[0].length, this.counts = [this.count];\n                  for (var l3 = 1; l3 < t3.text.length; l3++) this.textOffsets[l3] = this.textOffsets[l3 - 1] + t3.text[l3 - 1].length, this.count += t3.text[l3].length, this.counts.push(t3.text[l3].length);\n                  this.text = t3.text.join("");\n                } else this.text = t3.text, this.count = this.text.length, this.counts = [this.count];\n                s3 = [], this.font.forEach(function(Ce, me) {\n                  xc.atlasContext.font = Ce.baseString;\n                  for (var ie = r4.fontAtlas[me], Se = 0; Se < r4.text.length; Se++) {\n                    var Le = r4.text.charAt(Se);\n                    if (ie.ids[Le] == null && (ie.ids[Le] = ie.chars.length, ie.chars.push(Le), s3.push(Le)), Ce.width[Le] == null && (Ce.width[Le] = xc.atlasContext.measureText(Le).width / xc.baseFontSize, r4.kerning)) {\n                      var Ae = [];\n                      for (var Fe in Ce.width) Ae.push(Fe + Le, Le + Fe);\n                      LUt(Ce.kerning, CUt(Ce.family, { pairs: Ae }));\n                    }\n                  }\n                });\n              }\n              if (t3.position) if (t3.position.length > 2) {\n                for (var u4 = !t3.position[0].length, c5 = dx.mallocFloat(this.count * 2), f4 = 0, h3 = 0; f4 < this.counts.length; f4++) {\n                  var d3 = this.counts[f4];\n                  if (u4) for (var v3 = 0; v3 < d3; v3++) c5[h3++] = t3.position[f4 * 2], c5[h3++] = t3.position[f4 * 2 + 1];\n                  else for (var _2 = 0; _2 < d3; _2++) c5[h3++] = t3.position[f4][0], c5[h3++] = t3.position[f4][1];\n                }\n                this.position.call ? this.position({ type: "float", data: c5 }) : this.position = this.regl.buffer({ type: "float", data: c5 }), dx.freeFloat(c5);\n              } else this.position.destroy && this.position.destroy(), this.position = { constant: t3.position };\n              if (t3.text || n4) {\n                var b = dx.mallocUint8(this.count), p3 = dx.mallocFloat(this.count * 2);\n                this.textWidth = [];\n                for (var k4 = 0, E3 = 0; k4 < this.counts.length; k4++) {\n                  for (var S2 = this.counts[k4], L3 = this.font[k4] || this.font[0], x2 = this.fontAtlas[k4] || this.fontAtlas[0], C3 = 0; C3 < S2; C3++) {\n                    var M4 = this.text.charAt(E3), g3 = this.text.charAt(E3 - 1);\n                    if (b[E3] = x2.ids[M4], p3[E3 * 2] = L3.width[M4], C3) {\n                      var P3 = p3[E3 * 2 - 2], T3 = p3[E3 * 2], z3 = p3[E3 * 2 - 1], O3 = z3 + P3 * 0.5 + T3 * 0.5;\n                      if (this.kerning) {\n                        var V2 = L3.kerning[g3 + M4];\n                        V2 && (O3 += V2 * 1e-3);\n                      }\n                      p3[E3 * 2 + 1] = O3;\n                    } else p3[E3 * 2 + 1] = p3[E3 * 2] * 0.5;\n                    E3++;\n                  }\n                  this.textWidth.push(p3.length ? p3[E3 * 2 - 2] * 0.5 + p3[E3 * 2 - 1] : 0);\n                }\n                t3.align || (t3.align = this.align), this.charBuffer({ data: b, type: "uint8", usage: "stream" }), this.sizeBuffer({ data: p3, type: "float", usage: "stream" }), dx.freeUint8(b), dx.freeFloat(p3), s3.length && this.font.forEach(function(Ce, me) {\n                  var ie = r4.fontAtlas[me], Se = ie.step, Le = Math.floor(xc.maxAtlasSize / Se), Ae = Math.min(Le, ie.chars.length), Fe = Math.ceil(ie.chars.length / Ae), Pe = ABe(Ae * Se), ge = ABe(Fe * Se);\n                  ie.width = Pe, ie.height = ge, ie.rows = Fe, ie.cols = Ae, ie.em && ie.texture({ data: AUt({ canvas: xc.atlasCanvas, font: ie.fontString, chars: ie.chars, shape: [Pe, ge], step: [Se, Se] }) });\n                });\n              }\n              if (t3.align && (this.align = t3.align, this.alignOffset = this.textWidth.map(function(Ce, me) {\n                var ie = Array.isArray(r4.align) ? r4.align.length > 1 ? r4.align[me] : r4.align[0] : r4.align;\n                if (typeof ie == "number") return ie;\n                switch (ie) {\n                  case "right":\n                  case "end":\n                    return -Ce;\n                  case "center":\n                  case "centre":\n                  case "middle":\n                    return -Ce * 0.5;\n                }\n                return 0;\n              })), this.baseline == null && t3.baseline == null && (t3.baseline = 0), t3.baseline != null && (this.baseline = t3.baseline, Array.isArray(this.baseline) || (this.baseline = [this.baseline]), this.baselineOffset = this.baseline.map(function(Ce, me) {\n                var ie = (r4.font[me] || r4.font[0]).metrics, Se = 0;\n                return Se += ie.bottom * 0.5, typeof Ce == "number" ? Se += Ce - ie.baseline : Se += -ie[Ce], Se *= -1, Se;\n              })), t3.color != null) if (t3.color || (t3.color = "transparent"), typeof t3.color == "string" || !isNaN(t3.color)) this.color = lK(t3.color, "uint8");\n              else {\n                var G2;\n                if (typeof t3.color[0] == "number" && t3.color.length > this.counts.length) {\n                  var Z = t3.color.length;\n                  G2 = dx.mallocUint8(Z);\n                  for (var j3 = (t3.color.subarray || t3.color.slice).bind(t3.color), N2 = 0; N2 < Z; N2 += 4) G2.set(lK(j3(N2, N2 + 4), "uint8"), N2);\n                } else {\n                  var H = t3.color.length;\n                  G2 = dx.mallocUint8(H * 4);\n                  for (var te = 0; te < H; te++) G2.set(lK(t3.color[te] || 0, "uint8"), te * 4);\n                }\n                this.color = G2;\n              }\n              if (t3.position || t3.text || t3.color || t3.baseline || t3.align || t3.font || t3.offset || t3.opacity) {\n                var oe = this.color.length > 4 || this.baselineOffset.length > 1 || this.align && this.align.length > 1 || this.fontAtlas.length > 1 || this.positionOffset.length > 2;\n                if (oe) {\n                  var _e = Math.max(this.position.length * 0.5 || 0, this.color.length * 0.25 || 0, this.baselineOffset.length || 0, this.alignOffset.length || 0, this.font.length || 0, this.opacity.length || 0, this.positionOffset.length * 0.5 || 0);\n                  this.batch = Array(_e);\n                  for (var Ee = 0; Ee < this.batch.length; Ee++) this.batch[Ee] = { count: this.counts.length > 1 ? this.counts[Ee] : this.counts[0], offset: this.textOffsets.length > 1 ? this.textOffsets[Ee] : this.textOffsets[0], color: this.color ? this.color.length <= 4 ? this.color : this.color.subarray(Ee * 4, Ee * 4 + 4) : [0, 0, 0, 255], opacity: Array.isArray(this.opacity) ? this.opacity[Ee] : this.opacity, baseline: this.baselineOffset[Ee] != null ? this.baselineOffset[Ee] : this.baselineOffset[0], align: this.align ? this.alignOffset[Ee] != null ? this.alignOffset[Ee] : this.alignOffset[0] : 0, atlas: this.fontAtlas[Ee] || this.fontAtlas[0], positionOffset: this.positionOffset.length > 2 ? this.positionOffset.subarray(Ee * 2, Ee * 2 + 2) : this.positionOffset };\n                } else this.count ? this.batch = [{ count: this.count, offset: 0, color: this.color || [0, 0, 0, 255], opacity: Array.isArray(this.opacity) ? this.opacity[0] : this.opacity, baseline: this.baselineOffset[0], align: this.alignOffset ? this.alignOffset[0] : 0, atlas: this.fontAtlas[0], positionOffset: this.positionOffset }] : this.batch = [];\n              }\n            };\n            xc.prototype.destroy = function() {\n            };\n            xc.prototype.kerning = true;\n            xc.prototype.position = { constant: new Float32Array(2) };\n            xc.prototype.translate = null;\n            xc.prototype.scale = null;\n            xc.prototype.font = null;\n            xc.prototype.text = "";\n            xc.prototype.positionOffset = [0, 0];\n            xc.prototype.opacity = 1;\n            xc.prototype.color = new Uint8Array([0, 0, 0, 255]);\n            xc.prototype.alignOffset = [0, 0];\n            xc.maxAtlasSize = 1024;\n            xc.atlasCanvas = document.createElement("canvas");\n            xc.atlasContext = xc.atlasCanvas.getContext("2d", { alpha: false });\n            xc.baseFontSize = 64;\n            xc.fonts = {};\n            function DUt(e3) {\n              return typeof e3 == "function" && e3._gl && e3.prop && e3.texture && e3.buffer;\n            }\n            MBe.exports = xc;\n          });\n          var kBe = ye((uK, cK) => {\n            (function(e3, t3) {\n              typeof uK == "object" && typeof cK != "undefined" ? cK.exports = t3() : e3.createREGL = t3();\n            })(uK, function() {\n              "use strict";\n              var e3 = function(Me, bt) {\n                for (var zt = Object.keys(bt), Rr = 0; Rr < zt.length; ++Rr) Me[zt[Rr]] = bt[zt[Rr]];\n                return Me;\n              }, t3 = 0, r4 = 0, n4 = 5, i3 = 6;\n              function a4(Me, bt) {\n                this.id = t3++, this.type = Me, this.data = bt;\n              }\n              function o4(Me) {\n                return Me.replace(/\\\\/g, "\\\\\\\\").replace(/"/g, \'\\\\"\');\n              }\n              function s3(Me) {\n                if (Me.length === 0) return [];\n                var bt = Me.charAt(0), zt = Me.charAt(Me.length - 1);\n                if (Me.length > 1 && bt === zt && (bt === \'"\' || bt === "\'")) return [\'"\' + o4(Me.substr(1, Me.length - 2)) + \'"\'];\n                var Rr = /\\[(false|true|null|\\d+|\'[^\']*\'|"[^"]*")\\]/.exec(Me);\n                if (Rr) return s3(Me.substr(0, Rr.index)).concat(s3(Rr[1])).concat(s3(Me.substr(Rr.index + Rr[0].length)));\n                var jr = Me.split(".");\n                if (jr.length === 1) return [\'"\' + o4(Me) + \'"\'];\n                for (var Nr = [], Gr = 0; Gr < jr.length; ++Gr) Nr = Nr.concat(s3(jr[Gr]));\n                return Nr;\n              }\n              function l3(Me) {\n                return "[" + s3(Me).join("][") + "]";\n              }\n              function u4(Me, bt) {\n                return new a4(Me, l3(bt + ""));\n              }\n              function c5(Me) {\n                return typeof Me == "function" && !Me._reglType || Me instanceof a4;\n              }\n              function f4(Me, bt) {\n                if (typeof Me == "function") return new a4(r4, Me);\n                if (typeof Me == "number" || typeof Me == "boolean") return new a4(n4, Me);\n                if (Array.isArray(Me)) return new a4(i3, Me.map(function(zt, Rr) {\n                  return f4(zt, bt + "[" + Rr + "]");\n                }));\n                if (Me instanceof a4) return Me;\n              }\n              var h3 = { DynamicVariable: a4, define: u4, isDynamic: c5, unbox: f4, accessor: l3 }, d3 = { next: typeof requestAnimationFrame == "function" ? function(Me) {\n                return requestAnimationFrame(Me);\n              } : function(Me) {\n                return setTimeout(Me, 16);\n              }, cancel: typeof cancelAnimationFrame == "function" ? function(Me) {\n                return cancelAnimationFrame(Me);\n              } : clearTimeout }, v3 = typeof performance != "undefined" && performance.now ? function() {\n                return performance.now();\n              } : function() {\n                return +/* @__PURE__ */ new Date();\n              };\n              function _2() {\n                var Me = { "": 0 }, bt = [""];\n                return { id: function(zt) {\n                  var Rr = Me[zt];\n                  return Rr || (Rr = Me[zt] = bt.length, bt.push(zt), Rr);\n                }, str: function(zt) {\n                  return bt[zt];\n                } };\n              }\n              function b(Me, bt, zt) {\n                var Rr = document.createElement("canvas");\n                e3(Rr.style, { border: 0, margin: 0, padding: 0, top: 0, left: 0, width: "100%", height: "100%" }), Me.appendChild(Rr), Me === document.body && (Rr.style.position = "absolute", e3(Me.style, { margin: 0, padding: 0 }));\n                function jr() {\n                  var mi = window.innerWidth, Ui = window.innerHeight;\n                  if (Me !== document.body) {\n                    var qi = Rr.getBoundingClientRect();\n                    mi = qi.right - qi.left, Ui = qi.bottom - qi.top;\n                  }\n                  Rr.width = zt * mi, Rr.height = zt * Ui;\n                }\n                var Nr;\n                Me !== document.body && typeof ResizeObserver == "function" ? (Nr = new ResizeObserver(function() {\n                  setTimeout(jr);\n                }), Nr.observe(Me)) : window.addEventListener("resize", jr, false);\n                function Gr() {\n                  Nr ? Nr.disconnect() : window.removeEventListener("resize", jr), Me.removeChild(Rr);\n                }\n                return jr(), { canvas: Rr, onDestroy: Gr };\n              }\n              function p3(Me, bt) {\n                function zt(Rr) {\n                  try {\n                    return Me.getContext(Rr, bt);\n                  } catch (jr) {\n                    return null;\n                  }\n                }\n                return zt("webgl") || zt("experimental-webgl") || zt("webgl-experimental");\n              }\n              function k4(Me) {\n                return typeof Me.nodeName == "string" && typeof Me.appendChild == "function" && typeof Me.getBoundingClientRect == "function";\n              }\n              function E3(Me) {\n                return typeof Me.drawArrays == "function" || typeof Me.drawElements == "function";\n              }\n              function S2(Me) {\n                return typeof Me == "string" ? Me.split() : Me;\n              }\n              function L3(Me) {\n                return typeof Me == "string" ? document.querySelector(Me) : Me;\n              }\n              function x2(Me) {\n                var bt = Me || {}, zt, Rr, jr, Nr, Gr = {}, mi = [], Ui = [], qi = typeof window == "undefined" ? 1 : window.devicePixelRatio, Ei = false, Hn = {}, en = function(Mr) {\n                }, Wi = function() {\n                };\n                if (typeof bt == "string" ? zt = document.querySelector(bt) : typeof bt == "object" && (k4(bt) ? zt = bt : E3(bt) ? (Nr = bt, jr = Nr.canvas) : ("gl" in bt ? Nr = bt.gl : "canvas" in bt ? jr = L3(bt.canvas) : "container" in bt && (Rr = L3(bt.container)), "attributes" in bt && (Gr = bt.attributes), "extensions" in bt && (mi = S2(bt.extensions)), "optionalExtensions" in bt && (Ui = S2(bt.optionalExtensions)), "onDone" in bt && (en = bt.onDone), "profile" in bt && (Ei = !!bt.profile), "pixelRatio" in bt && (qi = +bt.pixelRatio), "cachedCode" in bt && (Hn = bt.cachedCode))), zt && (zt.nodeName.toLowerCase() === "canvas" ? jr = zt : Rr = zt), !Nr) {\n                  if (!jr) {\n                    var si = b(Rr || document.body, en, qi);\n                    if (!si) return null;\n                    jr = si.canvas, Wi = si.onDestroy;\n                  }\n                  Gr.premultipliedAlpha === void 0 && (Gr.premultipliedAlpha = true), Nr = p3(jr, Gr);\n                }\n                return Nr ? { gl: Nr, canvas: jr, container: Rr, extensions: mi, optionalExtensions: Ui, pixelRatio: qi, profile: Ei, cachedCode: Hn, onDone: en, onDestroy: Wi } : (Wi(), en("webgl not supported, try upgrading your browser or graphics drivers http://get.webgl.org"), null);\n              }\n              function C3(Me, bt) {\n                var zt = {};\n                function Rr(Gr) {\n                  var mi = Gr.toLowerCase(), Ui;\n                  try {\n                    Ui = zt[mi] = Me.getExtension(mi);\n                  } catch (qi) {\n                  }\n                  return !!Ui;\n                }\n                for (var jr = 0; jr < bt.extensions.length; ++jr) {\n                  var Nr = bt.extensions[jr];\n                  if (!Rr(Nr)) return bt.onDestroy(), bt.onDone(\'"\' + Nr + \'" extension is not supported by the current WebGL context, try upgrading your system or a different browser\'), null;\n                }\n                return bt.optionalExtensions.forEach(Rr), { extensions: zt, restore: function() {\n                  Object.keys(zt).forEach(function(Gr) {\n                    if (zt[Gr] && !Rr(Gr)) throw new Error("(regl): error restoring extension " + Gr);\n                  });\n                } };\n              }\n              function M4(Me, bt) {\n                for (var zt = Array(Me), Rr = 0; Rr < Me; ++Rr) zt[Rr] = bt(Rr);\n                return zt;\n              }\n              var g3 = 5120, P3 = 5121, T3 = 5122, z3 = 5123, O3 = 5124, V2 = 5125, G2 = 5126;\n              function Z(Me) {\n                for (var bt = 16; bt <= 1 << 28; bt *= 16) if (Me <= bt) return bt;\n                return 0;\n              }\n              function j3(Me) {\n                var bt, zt;\n                return bt = (Me > 65535) << 4, Me >>>= bt, zt = (Me > 255) << 3, Me >>>= zt, bt |= zt, zt = (Me > 15) << 2, Me >>>= zt, bt |= zt, zt = (Me > 3) << 1, Me >>>= zt, bt |= zt, bt | Me >> 1;\n              }\n              function N2() {\n                var Me = M4(8, function() {\n                  return [];\n                });\n                function bt(Nr) {\n                  var Gr = Z(Nr), mi = Me[j3(Gr) >> 2];\n                  return mi.length > 0 ? mi.pop() : new ArrayBuffer(Gr);\n                }\n                function zt(Nr) {\n                  Me[j3(Nr.byteLength) >> 2].push(Nr);\n                }\n                function Rr(Nr, Gr) {\n                  var mi = null;\n                  switch (Nr) {\n                    case g3:\n                      mi = new Int8Array(bt(Gr), 0, Gr);\n                      break;\n                    case P3:\n                      mi = new Uint8Array(bt(Gr), 0, Gr);\n                      break;\n                    case T3:\n                      mi = new Int16Array(bt(2 * Gr), 0, Gr);\n                      break;\n                    case z3:\n                      mi = new Uint16Array(bt(2 * Gr), 0, Gr);\n                      break;\n                    case O3:\n                      mi = new Int32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    case V2:\n                      mi = new Uint32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    case G2:\n                      mi = new Float32Array(bt(4 * Gr), 0, Gr);\n                      break;\n                    default:\n                      return null;\n                  }\n                  return mi.length !== Gr ? mi.subarray(0, Gr) : mi;\n                }\n                function jr(Nr) {\n                  zt(Nr.buffer);\n                }\n                return { alloc: bt, free: zt, allocType: Rr, freeType: jr };\n              }\n              var H = N2();\n              H.zero = N2();\n              var te = 3408, oe = 3410, _e = 3411, Ee = 3412, Ce = 3413, me = 3414, ie = 3415, Se = 33901, Le = 33902, Ae = 3379, Fe = 3386, Pe = 34921, ge = 36347, Re = 36348, ce = 35661, Ze = 35660, ut = 34930, pt = 36349, Zt = 34076, st = 34024, lt = 7936, Gt = 7937, Nt = 7938, Jt = 35724, sr = 34047, wr = 36063, cr = 34852, $e = 3553, St = 34067, Qt = 34069, Vt = 33984, _t = 6408, It = 5126, mt = 5121, er = 36160, lr = 36053, Tr = 36064, Lr = 16384, ti = function(Me, bt) {\n                var zt = 1;\n                bt.ext_texture_filter_anisotropic && (zt = Me.getParameter(sr));\n                var Rr = 1, jr = 1;\n                bt.webgl_draw_buffers && (Rr = Me.getParameter(cr), jr = Me.getParameter(wr));\n                var Nr = !!bt.oes_texture_float;\n                if (Nr) {\n                  var Gr = Me.createTexture();\n                  Me.bindTexture($e, Gr), Me.texImage2D($e, 0, _t, 1, 1, 0, _t, It, null);\n                  var mi = Me.createFramebuffer();\n                  if (Me.bindFramebuffer(er, mi), Me.framebufferTexture2D(er, Tr, $e, Gr, 0), Me.bindTexture($e, null), Me.checkFramebufferStatus(er) !== lr) Nr = false;\n                  else {\n                    Me.viewport(0, 0, 1, 1), Me.clearColor(1, 0, 0, 1), Me.clear(Lr);\n                    var Ui = H.allocType(It, 4);\n                    Me.readPixels(0, 0, 1, 1, _t, It, Ui), Me.getError() ? Nr = false : (Me.deleteFramebuffer(mi), Me.deleteTexture(Gr), Nr = Ui[0] === 1), H.freeType(Ui);\n                  }\n                }\n                var qi = typeof navigator != "undefined" && (/MSIE/.test(navigator.userAgent) || /Trident\\//.test(navigator.appVersion) || /Edge/.test(navigator.userAgent)), Ei = true;\n                if (!qi) {\n                  var Hn = Me.createTexture(), en = H.allocType(mt, 36);\n                  Me.activeTexture(Vt), Me.bindTexture(St, Hn), Me.texImage2D(Qt, 0, _t, 3, 3, 0, _t, mt, en), H.freeType(en), Me.bindTexture(St, null), Me.deleteTexture(Hn), Ei = !Me.getError();\n                }\n                return { colorBits: [Me.getParameter(oe), Me.getParameter(_e), Me.getParameter(Ee), Me.getParameter(Ce)], depthBits: Me.getParameter(me), stencilBits: Me.getParameter(ie), subpixelBits: Me.getParameter(te), extensions: Object.keys(bt).filter(function(Wi) {\n                  return !!bt[Wi];\n                }), maxAnisotropic: zt, maxDrawbuffers: Rr, maxColorAttachments: jr, pointSizeDims: Me.getParameter(Se), lineWidthDims: Me.getParameter(Le), maxViewportDims: Me.getParameter(Fe), maxCombinedTextureUnits: Me.getParameter(ce), maxCubeMapSize: Me.getParameter(Zt), maxRenderbufferSize: Me.getParameter(st), maxTextureUnits: Me.getParameter(ut), maxTextureSize: Me.getParameter(Ae), maxAttributes: Me.getParameter(Pe), maxVertexUniforms: Me.getParameter(ge), maxVertexTextureUnits: Me.getParameter(Ze), maxVaryingVectors: Me.getParameter(Re), maxFragmentUniforms: Me.getParameter(pt), glsl: Me.getParameter(Jt), renderer: Me.getParameter(Gt), vendor: Me.getParameter(lt), version: Me.getParameter(Nt), readFloat: Nr, npotTextureCube: Ei };\n              }, Br = function(Me) {\n                return Me instanceof Uint8Array || Me instanceof Uint16Array || Me instanceof Uint32Array || Me instanceof Int8Array || Me instanceof Int16Array || Me instanceof Int32Array || Me instanceof Float32Array || Me instanceof Float64Array || Me instanceof Uint8ClampedArray;\n              };\n              function Vr(Me) {\n                return !!Me && typeof Me == "object" && Array.isArray(Me.shape) && Array.isArray(Me.stride) && typeof Me.offset == "number" && Me.shape.length === Me.stride.length && (Array.isArray(Me.data) || Br(Me.data));\n              }\n              var dt = function(Me) {\n                return Object.keys(Me).map(function(bt) {\n                  return Me[bt];\n                });\n              }, Ge = { shape: xe, flatten: Ie };\n              function Je(Me, bt, zt) {\n                for (var Rr = 0; Rr < bt; ++Rr) zt[Rr] = Me[Rr];\n              }\n              function je(Me, bt, zt, Rr) {\n                for (var jr = 0, Nr = 0; Nr < bt; ++Nr) for (var Gr = Me[Nr], mi = 0; mi < zt; ++mi) Rr[jr++] = Gr[mi];\n              }\n              function tt(Me, bt, zt, Rr, jr, Nr) {\n                for (var Gr = Nr, mi = 0; mi < bt; ++mi) for (var Ui = Me[mi], qi = 0; qi < zt; ++qi) for (var Ei = Ui[qi], Hn = 0; Hn < Rr; ++Hn) jr[Gr++] = Ei[Hn];\n              }\n              function xt(Me, bt, zt, Rr, jr) {\n                for (var Nr = 1, Gr = zt + 1; Gr < bt.length; ++Gr) Nr *= bt[Gr];\n                var mi = bt[zt];\n                if (bt.length - zt === 4) {\n                  var Ui = bt[zt + 1], qi = bt[zt + 2], Ei = bt[zt + 3];\n                  for (Gr = 0; Gr < mi; ++Gr) tt(Me[Gr], Ui, qi, Ei, Rr, jr), jr += Nr;\n                } else for (Gr = 0; Gr < mi; ++Gr) xt(Me[Gr], bt, zt + 1, Rr, jr), jr += Nr;\n              }\n              function Ie(Me, bt, zt, Rr) {\n                var jr = 1;\n                if (bt.length) for (var Nr = 0; Nr < bt.length; ++Nr) jr *= bt[Nr];\n                else jr = 0;\n                var Gr = Rr || H.allocType(zt, jr);\n                switch (bt.length) {\n                  case 0:\n                    break;\n                  case 1:\n                    Je(Me, bt[0], Gr);\n                    break;\n                  case 2:\n                    je(Me, bt[0], bt[1], Gr);\n                    break;\n                  case 3:\n                    tt(Me, bt[0], bt[1], bt[2], Gr, 0);\n                    break;\n                  default:\n                    xt(Me, bt, 0, Gr, 0);\n                }\n                return Gr;\n              }\n              function xe(Me) {\n                for (var bt = [], zt = Me; zt.length; zt = zt[0]) bt.push(zt.length);\n                return bt;\n              }\n              var ke = { "[object Int8Array]": 5120, "[object Int16Array]": 5122, "[object Int32Array]": 5124, "[object Uint8Array]": 5121, "[object Uint8ClampedArray]": 5121, "[object Uint16Array]": 5123, "[object Uint32Array]": 5125, "[object Float32Array]": 5126, "[object Float64Array]": 5121, "[object ArrayBuffer]": 5121 }, vt = 5120, ir = 5122, ar = 5124, vr = 5121, ii = 5123, pi = 5125, $r = 5126, di = 5126, ji = { int8: vt, int16: ir, int32: ar, uint8: vr, uint16: ii, uint32: pi, float: $r, float32: di }, In = 35048, wi = 35040, On = { dynamic: In, stream: wi, static: 35044 }, qn = Ge.flatten, Fn = Ge.shape, ra = 35044, la = 35040, Ut = 5121, wt = 5126, rr = [];\n              rr[5120] = 1, rr[5122] = 2, rr[5124] = 4, rr[5121] = 1, rr[5123] = 2, rr[5125] = 4, rr[5126] = 4;\n              function nr(Me) {\n                return ke[Object.prototype.toString.call(Me)] | 0;\n              }\n              function Er(Me, bt) {\n                for (var zt = 0; zt < bt.length; ++zt) Me[zt] = bt[zt];\n              }\n              function Xr(Me, bt, zt, Rr, jr, Nr, Gr) {\n                for (var mi = 0, Ui = 0; Ui < zt; ++Ui) for (var qi = 0; qi < Rr; ++qi) Me[mi++] = bt[jr * Ui + Nr * qi + Gr];\n              }\n              function ri(Me, bt, zt, Rr) {\n                var jr = 0, Nr = {};\n                function Gr(Mr) {\n                  this.id = jr++, this.buffer = Me.createBuffer(), this.type = Mr, this.usage = ra, this.byteLength = 0, this.dimension = 1, this.dtype = Ut, this.persistentData = null, zt.profile && (this.stats = { size: 0 });\n                }\n                Gr.prototype.bind = function() {\n                  Me.bindBuffer(this.type, this.buffer);\n                }, Gr.prototype.destroy = function() {\n                  en(this);\n                };\n                var mi = [];\n                function Ui(Mr, Yr) {\n                  var xi = mi.pop();\n                  return xi || (xi = new Gr(Mr)), xi.bind(), Hn(xi, Yr, la, 0, 1, false), xi;\n                }\n                function qi(Mr) {\n                  mi.push(Mr);\n                }\n                function Ei(Mr, Yr, xi) {\n                  Mr.byteLength = Yr.byteLength, Me.bufferData(Mr.type, Yr, xi);\n                }\n                function Hn(Mr, Yr, xi, Ri, ci, an) {\n                  var Zi;\n                  if (Mr.usage = xi, Array.isArray(Yr)) {\n                    if (Mr.dtype = Ri || wt, Yr.length > 0) {\n                      var Bn;\n                      if (Array.isArray(Yr[0])) {\n                        Zi = Fn(Yr);\n                        for (var hi = 1, li = 1; li < Zi.length; ++li) hi *= Zi[li];\n                        Mr.dimension = hi, Bn = qn(Yr, Zi, Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn);\n                      } else if (typeof Yr[0] == "number") {\n                        Mr.dimension = ci;\n                        var mn = H.allocType(Mr.dtype, Yr.length);\n                        Er(mn, Yr), Ei(Mr, mn, xi), an ? Mr.persistentData = mn : H.freeType(mn);\n                      } else Br(Yr[0]) && (Mr.dimension = Yr[0].length, Mr.dtype = Ri || nr(Yr[0]) || wt, Bn = qn(Yr, [Yr.length, Yr[0].length], Mr.dtype), Ei(Mr, Bn, xi), an ? Mr.persistentData = Bn : H.freeType(Bn));\n                    }\n                  } else if (Br(Yr)) Mr.dtype = Ri || nr(Yr), Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr.buffer)));\n                  else if (Vr(Yr)) {\n                    Zi = Yr.shape;\n                    var Ji = Yr.stride, Vi = Yr.offset, Ni = 0, pn = 0, Vn = 0, na = 0;\n                    Zi.length === 1 ? (Ni = Zi[0], pn = 1, Vn = Ji[0], na = 0) : Zi.length === 2 && (Ni = Zi[0], pn = Zi[1], Vn = Ji[0], na = Ji[1]), Mr.dtype = Ri || nr(Yr.data) || wt, Mr.dimension = pn;\n                    var Ki = H.allocType(Mr.dtype, Ni * pn);\n                    Xr(Ki, Yr.data, Ni, pn, Vn, na, Vi), Ei(Mr, Ki, xi), an ? Mr.persistentData = Ki : H.freeType(Ki);\n                  } else Yr instanceof ArrayBuffer && (Mr.dtype = Ut, Mr.dimension = ci, Ei(Mr, Yr, xi), an && (Mr.persistentData = new Uint8Array(new Uint8Array(Yr))));\n                }\n                function en(Mr) {\n                  bt.bufferCount--, Rr(Mr);\n                  var Yr = Mr.buffer;\n                  Me.deleteBuffer(Yr), Mr.buffer = null, delete Nr[Mr.id];\n                }\n                function Wi(Mr, Yr, xi, Ri) {\n                  bt.bufferCount++;\n                  var ci = new Gr(Yr);\n                  Nr[ci.id] = ci;\n                  function an(hi) {\n                    var li = ra, mn = null, Ji = 0, Vi = 0, Ni = 1;\n                    return Array.isArray(hi) || Br(hi) || Vr(hi) || hi instanceof ArrayBuffer ? mn = hi : typeof hi == "number" ? Ji = hi | 0 : hi && ("data" in hi && (mn = hi.data), "usage" in hi && (li = On[hi.usage]), "type" in hi && (Vi = ji[hi.type]), "dimension" in hi && (Ni = hi.dimension | 0), "length" in hi && (Ji = hi.length | 0)), ci.bind(), mn ? Hn(ci, mn, li, Vi, Ni, Ri) : (Ji && Me.bufferData(ci.type, Ji, li), ci.dtype = Vi || Ut, ci.usage = li, ci.dimension = Ni, ci.byteLength = Ji), zt.profile && (ci.stats.size = ci.byteLength * rr[ci.dtype]), an;\n                  }\n                  function Zi(hi, li) {\n                    Me.bufferSubData(ci.type, li, hi);\n                  }\n                  function Bn(hi, li) {\n                    var mn = (li || 0) | 0, Ji;\n                    if (ci.bind(), Br(hi) || hi instanceof ArrayBuffer) Zi(hi, mn);\n                    else if (Array.isArray(hi)) {\n                      if (hi.length > 0) {\n                        if (typeof hi[0] == "number") {\n                          var Vi = H.allocType(ci.dtype, hi.length);\n                          Er(Vi, hi), Zi(Vi, mn), H.freeType(Vi);\n                        } else if (Array.isArray(hi[0]) || Br(hi[0])) {\n                          Ji = Fn(hi);\n                          var Ni = qn(hi, Ji, ci.dtype);\n                          Zi(Ni, mn), H.freeType(Ni);\n                        }\n                      }\n                    } else if (Vr(hi)) {\n                      Ji = hi.shape;\n                      var pn = hi.stride, Vn = 0, na = 0, Ki = 0, kn = 0;\n                      Ji.length === 1 ? (Vn = Ji[0], na = 1, Ki = pn[0], kn = 0) : Ji.length === 2 && (Vn = Ji[0], na = Ji[1], Ki = pn[0], kn = pn[1]);\n                      var ta = Array.isArray(hi.data) ? ci.dtype : nr(hi.data), oa = H.allocType(ta, Vn * na);\n                      Xr(oa, hi.data, Vn, na, Ki, kn, hi.offset), Zi(oa, mn), H.freeType(oa);\n                    }\n                    return an;\n                  }\n                  return xi || an(Mr), an._reglType = "buffer", an._buffer = ci, an.subdata = Bn, zt.profile && (an.stats = ci.stats), an.destroy = function() {\n                    en(ci);\n                  }, an;\n                }\n                function si() {\n                  dt(Nr).forEach(function(Mr) {\n                    Mr.buffer = Me.createBuffer(), Me.bindBuffer(Mr.type, Mr.buffer), Me.bufferData(Mr.type, Mr.persistentData || Mr.byteLength, Mr.usage);\n                  });\n                }\n                return zt.profile && (bt.getTotalBufferSize = function() {\n                  var Mr = 0;\n                  return Object.keys(Nr).forEach(function(Yr) {\n                    Mr += Nr[Yr].stats.size;\n                  }), Mr;\n                }), { create: Wi, createStream: Ui, destroyStream: qi, clear: function() {\n                  dt(Nr).forEach(en), mi.forEach(en);\n                }, getBuffer: function(Mr) {\n                  return Mr && Mr._buffer instanceof Gr ? Mr._buffer : null;\n                }, restore: si, _initBuffer: Hn };\n              }\n              var Qr = 0, Oi = 0, $i = 1, tn = 1, fn = 4, yn = 4, Sn = { points: Qr, point: Oi, lines: $i, line: tn, triangles: fn, triangle: yn, "line loop": 2, "line strip": 3, "triangle strip": 5, "triangle fan": 6 }, Ba = 0, ua = 1, ma = 4, Wa = 5120, Fa = 5121, Wo = 5122, da = 5123, Wn = 5124, Ha = 5125, vo = 34963, jn = 35040, Mt = 35044;\n              function kr(Me, bt, zt, Rr) {\n                var jr = {}, Nr = 0, Gr = { uint8: Fa, uint16: da };\n                bt.oes_element_index_uint && (Gr.uint32 = Ha);\n                function mi(si) {\n                  this.id = Nr++, jr[this.id] = this, this.buffer = si, this.primType = ma, this.vertCount = 0, this.type = 0;\n                }\n                mi.prototype.bind = function() {\n                  this.buffer.bind();\n                };\n                var Ui = [];\n                function qi(si) {\n                  var Mr = Ui.pop();\n                  return Mr || (Mr = new mi(zt.create(null, vo, true, false)._buffer)), Hn(Mr, si, jn, -1, -1, 0, 0), Mr;\n                }\n                function Ei(si) {\n                  Ui.push(si);\n                }\n                function Hn(si, Mr, Yr, xi, Ri, ci, an) {\n                  si.buffer.bind();\n                  var Zi;\n                  if (Mr) {\n                    var Bn = an;\n                    !an && (!Br(Mr) || Vr(Mr) && !Br(Mr.data)) && (Bn = bt.oes_element_index_uint ? Ha : da), zt._initBuffer(si.buffer, Mr, Yr, Bn, 3);\n                  } else Me.bufferData(vo, ci, Yr), si.buffer.dtype = Zi || Fa, si.buffer.usage = Yr, si.buffer.dimension = 3, si.buffer.byteLength = ci;\n                  if (Zi = an, !an) {\n                    switch (si.buffer.dtype) {\n                      case Fa:\n                      case Wa:\n                        Zi = Fa;\n                        break;\n                      case da:\n                      case Wo:\n                        Zi = da;\n                        break;\n                      case Ha:\n                      case Wn:\n                        Zi = Ha;\n                        break;\n                      default:\n                    }\n                    si.buffer.dtype = Zi;\n                  }\n                  si.type = Zi;\n                  var hi = Ri;\n                  hi < 0 && (hi = si.buffer.byteLength, Zi === da ? hi >>= 1 : Zi === Ha && (hi >>= 2)), si.vertCount = hi;\n                  var li = xi;\n                  if (xi < 0) {\n                    li = ma;\n                    var mn = si.buffer.dimension;\n                    mn === 1 && (li = Ba), mn === 2 && (li = ua), mn === 3 && (li = ma);\n                  }\n                  si.primType = li;\n                }\n                function en(si) {\n                  Rr.elementsCount--, delete jr[si.id], si.buffer.destroy(), si.buffer = null;\n                }\n                function Wi(si, Mr) {\n                  var Yr = zt.create(null, vo, true), xi = new mi(Yr._buffer);\n                  Rr.elementsCount++;\n                  function Ri(ci) {\n                    if (!ci) Yr(), xi.primType = ma, xi.vertCount = 0, xi.type = Fa;\n                    else if (typeof ci == "number") Yr(ci), xi.primType = ma, xi.vertCount = ci | 0, xi.type = Fa;\n                    else {\n                      var an = null, Zi = Mt, Bn = -1, hi = -1, li = 0, mn = 0;\n                      Array.isArray(ci) || Br(ci) || Vr(ci) ? an = ci : ("data" in ci && (an = ci.data), "usage" in ci && (Zi = On[ci.usage]), "primitive" in ci && (Bn = Sn[ci.primitive]), "count" in ci && (hi = ci.count | 0), "type" in ci && (mn = Gr[ci.type]), "length" in ci ? li = ci.length | 0 : (li = hi, mn === da || mn === Wo ? li *= 2 : (mn === Ha || mn === Wn) && (li *= 4))), Hn(xi, an, Zi, Bn, hi, li, mn);\n                    }\n                    return Ri;\n                  }\n                  return Ri(si), Ri._reglType = "elements", Ri._elements = xi, Ri.subdata = function(ci, an) {\n                    return Yr.subdata(ci, an), Ri;\n                  }, Ri.destroy = function() {\n                    en(xi);\n                  }, Ri;\n                }\n                return { create: Wi, createStream: qi, destroyStream: Ei, getElements: function(si) {\n                  return typeof si == "function" && si._elements instanceof mi ? si._elements : null;\n                }, clear: function() {\n                  dt(jr).forEach(en);\n                } };\n              }\n              var Jr = new Float32Array(1), vi = new Uint32Array(Jr.buffer), hn = 5123;\n              function An(Me) {\n                for (var bt = H.allocType(hn, Me.length), zt = 0; zt < Me.length; ++zt) if (isNaN(Me[zt])) bt[zt] = 65535;\n                else if (Me[zt] === 1 / 0) bt[zt] = 31744;\n                else if (Me[zt] === -1 / 0) bt[zt] = 64512;\n                else {\n                  Jr[0] = Me[zt];\n                  var Rr = vi[0], jr = Rr >>> 31 << 15, Nr = (Rr << 1 >>> 24) - 127, Gr = Rr >> 13 & 1023;\n                  if (Nr < -24) bt[zt] = jr;\n                  else if (Nr < -14) {\n                    var mi = -14 - Nr;\n                    bt[zt] = jr + (Gr + 1024 >> mi);\n                  } else Nr > 15 ? bt[zt] = jr + 31744 : bt[zt] = jr + (Nr + 15 << 10) + Gr;\n                }\n                return bt;\n              }\n              function Mn(Me) {\n                return Array.isArray(Me) || Br(Me);\n              }\n              var Li = 34467, _n = 3553, ya = 34067, Jn = 34069, Ma = 6408, _o = 6406, No = 6407, po = 6409, Lo = 6410, ko = 32854, Ds = 32855, Fs = 36194, ll = 32819, ul = 32820, zl = 33635, us = 34042, il = 6402, As = 34041, cl = 35904, Ks = 35906, zs = 36193, Io = 33776, ls = 33777, Zl = 33778, Su = 33779, nc = 35986, bs = 35987, Rn = 34798, _a = 35840, Vu = 35841, Ol = 35842, xo = 35843, Yl = 36196, Ns = 5121, Hl = 5123, ac = 5125, aa = 5126, Oo = 10242, qo = 10243, ql = 10497, Pc = 33071, Do = 33648, rf = 10240, Uf = 10241, pl = 9728, Zc = 9729, Kl = 9984, Os = 9985, yu = 9986, oc = 9987, Cf = 33170, sc = 4352, Vh = 4353, Lf = 4354, cs = 34046, nf = 3317, Vf = 37440, Jl = 37441, fl = 37443, lc = 37444, Fu = 33984, Es = [Kl, yu, Os, oc], Hs = [0, po, Lo, No, Ma], Go = {};\n              Go[po] = Go[_o] = Go[il] = 1, Go[As] = Go[Lo] = 2, Go[No] = Go[cl] = 3, Go[Ma] = Go[Ks] = 4;\n              function ps(Me) {\n                return "[object " + Me + "]";\n              }\n              var uc = ps("HTMLCanvasElement"), xl = ps("OffscreenCanvas"), Gu = ps("CanvasRenderingContext2D"), qs = ps("ImageBitmap"), ad = ps("HTMLImageElement"), Po = ps("HTMLVideoElement"), od = Object.keys(ke).concat([uc, xl, Gu, qs, ad, Po]), Yo = [];\n              Yo[Ns] = 1, Yo[aa] = 4, Yo[zs] = 2, Yo[Hl] = 2, Yo[ac] = 4;\n              var Pa = [];\n              Pa[ko] = 2, Pa[Ds] = 2, Pa[Fs] = 2, Pa[As] = 4, Pa[Io] = 0.5, Pa[ls] = 0.5, Pa[Zl] = 1, Pa[Su] = 1, Pa[nc] = 0.5, Pa[bs] = 1, Pa[Rn] = 1, Pa[_a] = 0.5, Pa[Vu] = 0.25, Pa[Ol] = 0.5, Pa[xo] = 0.25, Pa[Yl] = 0.5;\n              function af(Me) {\n                return Array.isArray(Me) && (Me.length === 0 || typeof Me[0] == "number");\n              }\n              function Hu(Me) {\n                if (!Array.isArray(Me)) return false;\n                var bt = Me.length;\n                return !(bt === 0 || !Mn(Me[0]));\n              }\n              function bl(Me) {\n                return Object.prototype.toString.call(Me);\n              }\n              function Gf(Me) {\n                return bl(Me) === uc;\n              }\n              function Ic(Me) {\n                return bl(Me) === xl;\n              }\n              function yf(Me) {\n                return bl(Me) === Gu;\n              }\n              function Bl(Me) {\n                return bl(Me) === qs;\n              }\n              function wh(Me) {\n                return bl(Me) === ad;\n              }\n              function Qf(Me) {\n                return bl(Me) === Po;\n              }\n              function _f(Me) {\n                if (!Me) return false;\n                var bt = bl(Me);\n                return od.indexOf(bt) >= 0 ? true : af(Me) || Hu(Me) || Vr(Me);\n              }\n              function Yc(Me) {\n                return ke[Object.prototype.toString.call(Me)] | 0;\n              }\n              function eh(Me, bt) {\n                var zt = bt.length;\n                switch (Me.type) {\n                  case Ns:\n                  case Hl:\n                  case ac:\n                  case aa:\n                    var Rr = H.allocType(Me.type, zt);\n                    Rr.set(bt), Me.data = Rr;\n                    break;\n                  case zs:\n                    Me.data = An(bt);\n                    break;\n                  default:\n                }\n              }\n              function th(Me, bt) {\n                return H.allocType(Me.type === zs ? aa : Me.type, bt);\n              }\n              function ju(Me, bt) {\n                Me.type === zs ? (Me.data = An(bt), H.freeType(bt)) : Me.data = bt;\n              }\n              function Hf(Me, bt, zt, Rr, jr, Nr) {\n                for (var Gr = Me.width, mi = Me.height, Ui = Me.channels, qi = Gr * mi * Ui, Ei = th(Me, qi), Hn = 0, en = 0; en < mi; ++en) for (var Wi = 0; Wi < Gr; ++Wi) for (var si = 0; si < Ui; ++si) Ei[Hn++] = bt[zt * Wi + Rr * en + jr * si + Nr];\n                ju(Me, Ei);\n              }\n              function cc(Me, bt, zt, Rr, jr, Nr) {\n                var Gr;\n                if (typeof Pa[Me] != "undefined" ? Gr = Pa[Me] : Gr = Go[Me] * Yo[bt], Nr && (Gr *= 6), jr) {\n                  for (var mi = 0, Ui = zt; Ui >= 1; ) mi += Gr * Ui * Ui, Ui /= 2;\n                  return mi;\n                } else return Gr * zt * Rr;\n              }\n              function of(Me, bt, zt, Rr, jr, Nr, Gr) {\n                var mi = { "don\'t care": sc, "dont care": sc, nice: Lf, fast: Vh }, Ui = { repeat: ql, clamp: Pc, mirror: Do }, qi = { nearest: pl, linear: Zc }, Ei = e3({ mipmap: oc, "nearest mipmap nearest": Kl, "linear mipmap nearest": Os, "nearest mipmap linear": yu, "linear mipmap linear": oc }, qi), Hn = { none: 0, browser: lc }, en = { uint8: Ns, rgba4: ll, rgb565: zl, "rgb5 a1": ul }, Wi = { alpha: _o, luminance: po, "luminance alpha": Lo, rgb: No, rgba: Ma, rgba4: ko, "rgb5 a1": Ds, rgb565: Fs }, si = {};\n                bt.ext_srgb && (Wi.srgb = cl, Wi.srgba = Ks), bt.oes_texture_float && (en.float32 = en.float = aa), bt.oes_texture_half_float && (en.float16 = en["half float"] = zs), bt.webgl_depth_texture && (e3(Wi, { depth: il, "depth stencil": As }), e3(en, { uint16: Hl, uint32: ac, "depth stencil": us })), bt.webgl_compressed_texture_s3tc && e3(si, { "rgb s3tc dxt1": Io, "rgba s3tc dxt1": ls, "rgba s3tc dxt3": Zl, "rgba s3tc dxt5": Su }), bt.webgl_compressed_texture_atc && e3(si, { "rgb atc": nc, "rgba atc explicit alpha": bs, "rgba atc interpolated alpha": Rn }), bt.webgl_compressed_texture_pvrtc && e3(si, { "rgb pvrtc 4bppv1": _a, "rgb pvrtc 2bppv1": Vu, "rgba pvrtc 4bppv1": Ol, "rgba pvrtc 2bppv1": xo }), bt.webgl_compressed_texture_etc1 && (si["rgb etc1"] = Yl);\n                var Mr = Array.prototype.slice.call(Me.getParameter(Li));\n                Object.keys(si).forEach(function(ne) {\n                  var we = si[ne];\n                  Mr.indexOf(we) >= 0 && (Wi[ne] = we);\n                });\n                var Yr = Object.keys(Wi);\n                zt.textureFormats = Yr;\n                var xi = [];\n                Object.keys(Wi).forEach(function(ne) {\n                  var we = Wi[ne];\n                  xi[we] = ne;\n                });\n                var Ri = [];\n                Object.keys(en).forEach(function(ne) {\n                  var we = en[ne];\n                  Ri[we] = ne;\n                });\n                var ci = [];\n                Object.keys(qi).forEach(function(ne) {\n                  var we = qi[ne];\n                  ci[we] = ne;\n                });\n                var an = [];\n                Object.keys(Ei).forEach(function(ne) {\n                  var we = Ei[ne];\n                  an[we] = ne;\n                });\n                var Zi = [];\n                Object.keys(Ui).forEach(function(ne) {\n                  var we = Ui[ne];\n                  Zi[we] = ne;\n                });\n                var Bn = Yr.reduce(function(ne, we) {\n                  var Ue = Wi[we];\n                  return Ue === po || Ue === _o || Ue === po || Ue === Lo || Ue === il || Ue === As || bt.ext_srgb && (Ue === cl || Ue === Ks) ? ne[Ue] = Ue : Ue === Ds || we.indexOf("rgba") >= 0 ? ne[Ue] = Ma : ne[Ue] = No, ne;\n                }, {});\n                function hi() {\n                  this.internalformat = Ma, this.format = Ma, this.type = Ns, this.compressed = false, this.premultiplyAlpha = false, this.flipY = false, this.unpackAlignment = 1, this.colorSpace = lc, this.width = 0, this.height = 0, this.channels = 0;\n                }\n                function li(ne, we) {\n                  ne.internalformat = we.internalformat, ne.format = we.format, ne.type = we.type, ne.compressed = we.compressed, ne.premultiplyAlpha = we.premultiplyAlpha, ne.flipY = we.flipY, ne.unpackAlignment = we.unpackAlignment, ne.colorSpace = we.colorSpace, ne.width = we.width, ne.height = we.height, ne.channels = we.channels;\n                }\n                function mn(ne, we) {\n                  if (!(typeof we != "object" || !we)) {\n                    if ("premultiplyAlpha" in we && (ne.premultiplyAlpha = we.premultiplyAlpha), "flipY" in we && (ne.flipY = we.flipY), "alignment" in we && (ne.unpackAlignment = we.alignment), "colorSpace" in we && (ne.colorSpace = Hn[we.colorSpace]), "type" in we) {\n                      var Ue = we.type;\n                      ne.type = en[Ue];\n                    }\n                    var ft = ne.width, Xt = ne.height, hr = ne.channels, qt = false;\n                    "shape" in we ? (ft = we.shape[0], Xt = we.shape[1], we.shape.length === 3 && (hr = we.shape[2], qt = true)) : ("radius" in we && (ft = Xt = we.radius), "width" in we && (ft = we.width), "height" in we && (Xt = we.height), "channels" in we && (hr = we.channels, qt = true)), ne.width = ft | 0, ne.height = Xt | 0, ne.channels = hr | 0;\n                    var Ve = false;\n                    if ("format" in we) {\n                      var Qe = we.format, at = ne.internalformat = Wi[Qe];\n                      ne.format = Bn[at], Qe in en && ("type" in we || (ne.type = en[Qe])), Qe in si && (ne.compressed = true), Ve = true;\n                    }\n                    !qt && Ve ? ne.channels = Go[ne.format] : qt && !Ve && ne.channels !== Hs[ne.format] && (ne.format = ne.internalformat = Hs[ne.channels]);\n                  }\n                }\n                function Ji(ne) {\n                  Me.pixelStorei(Vf, ne.flipY), Me.pixelStorei(Jl, ne.premultiplyAlpha), Me.pixelStorei(fl, ne.colorSpace), Me.pixelStorei(nf, ne.unpackAlignment);\n                }\n                function Vi() {\n                  hi.call(this), this.xOffset = 0, this.yOffset = 0, this.data = null, this.needsFree = false, this.element = null, this.needsCopy = false;\n                }\n                function Ni(ne, we) {\n                  var Ue = null;\n                  if (_f(we) ? Ue = we : we && (mn(ne, we), "x" in we && (ne.xOffset = we.x | 0), "y" in we && (ne.yOffset = we.y | 0), _f(we.data) && (Ue = we.data)), we.copy) {\n                    var ft = jr.viewportWidth, Xt = jr.viewportHeight;\n                    ne.width = ne.width || ft - ne.xOffset, ne.height = ne.height || Xt - ne.yOffset, ne.needsCopy = true;\n                  } else if (!Ue) ne.width = ne.width || 1, ne.height = ne.height || 1, ne.channels = ne.channels || 4;\n                  else if (Br(Ue)) ne.channels = ne.channels || 4, ne.data = Ue, !("type" in we) && ne.type === Ns && (ne.type = Yc(Ue));\n                  else if (af(Ue)) ne.channels = ne.channels || 4, eh(ne, Ue), ne.alignment = 1, ne.needsFree = true;\n                  else if (Vr(Ue)) {\n                    var hr = Ue.data;\n                    !Array.isArray(hr) && ne.type === Ns && (ne.type = Yc(hr));\n                    var qt = Ue.shape, Ve = Ue.stride, Qe, at, Ct, Ot, Rt, Bt;\n                    qt.length === 3 ? (Ct = qt[2], Bt = Ve[2]) : (Ct = 1, Bt = 1), Qe = qt[0], at = qt[1], Ot = Ve[0], Rt = Ve[1], ne.alignment = 1, ne.width = Qe, ne.height = at, ne.channels = Ct, ne.format = ne.internalformat = Hs[Ct], ne.needsFree = true, Hf(ne, hr, Ot, Rt, Bt, Ue.offset);\n                  } else if (Gf(Ue) || Ic(Ue) || yf(Ue)) Gf(Ue) || Ic(Ue) ? ne.element = Ue : ne.element = Ue.canvas, ne.width = ne.element.width, ne.height = ne.element.height, ne.channels = 4;\n                  else if (Bl(Ue)) ne.element = Ue, ne.width = Ue.width, ne.height = Ue.height, ne.channels = 4;\n                  else if (wh(Ue)) ne.element = Ue, ne.width = Ue.naturalWidth, ne.height = Ue.naturalHeight, ne.channels = 4;\n                  else if (Qf(Ue)) ne.element = Ue, ne.width = Ue.videoWidth, ne.height = Ue.videoHeight, ne.channels = 4;\n                  else if (Hu(Ue)) {\n                    var Dt = ne.width || Ue[0].length, yt = ne.height || Ue.length, Pt = ne.channels;\n                    Mn(Ue[0][0]) ? Pt = Pt || Ue[0][0].length : Pt = Pt || 1;\n                    for (var ht = Ge.shape(Ue), ur = 1, br = 0; br < ht.length; ++br) ur *= ht[br];\n                    var Ur = th(ne, ur);\n                    Ge.flatten(Ue, ht, "", Ur), ju(ne, Ur), ne.alignment = 1, ne.width = Dt, ne.height = yt, ne.channels = Pt, ne.format = ne.internalformat = Hs[Pt], ne.needsFree = true;\n                  }\n                  ne.type === aa || ne.type;\n                }\n                function pn(ne, we, Ue) {\n                  var ft = ne.element, Xt = ne.data, hr = ne.internalformat, qt = ne.format, Ve = ne.type, Qe = ne.width, at = ne.height;\n                  Ji(ne), ft ? Me.texImage2D(we, Ue, qt, qt, Ve, ft) : ne.compressed ? Me.compressedTexImage2D(we, Ue, hr, Qe, at, 0, Xt) : ne.needsCopy ? (Rr(), Me.copyTexImage2D(we, Ue, qt, ne.xOffset, ne.yOffset, Qe, at, 0)) : Me.texImage2D(we, Ue, qt, Qe, at, 0, qt, Ve, Xt || null);\n                }\n                function Vn(ne, we, Ue, ft, Xt) {\n                  var hr = ne.element, qt = ne.data, Ve = ne.internalformat, Qe = ne.format, at = ne.type, Ct = ne.width, Ot = ne.height;\n                  Ji(ne), hr ? Me.texSubImage2D(we, Xt, Ue, ft, Qe, at, hr) : ne.compressed ? Me.compressedTexSubImage2D(we, Xt, Ue, ft, Ve, Ct, Ot, qt) : ne.needsCopy ? (Rr(), Me.copyTexSubImage2D(we, Xt, Ue, ft, ne.xOffset, ne.yOffset, Ct, Ot)) : Me.texSubImage2D(we, Xt, Ue, ft, Ct, Ot, Qe, at, qt);\n                }\n                var na = [];\n                function Ki() {\n                  return na.pop() || new Vi();\n                }\n                function kn(ne) {\n                  ne.needsFree && H.freeType(ne.data), Vi.call(ne), na.push(ne);\n                }\n                function ta() {\n                  hi.call(this), this.genMipmaps = false, this.mipmapHint = sc, this.mipmask = 0, this.images = Array(16);\n                }\n                function oa(ne, we, Ue) {\n                  var ft = ne.images[0] = Ki();\n                  ne.mipmask = 1, ft.width = ne.width = we, ft.height = ne.height = Ue, ft.channels = ne.channels = 4;\n                }\n                function ba(ne, we) {\n                  var Ue = null;\n                  if (_f(we)) Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;\n                  else if (mn(ne, we), Array.isArray(we.mipmap)) for (var ft = we.mipmap, Xt = 0; Xt < ft.length; ++Xt) Ue = ne.images[Xt] = Ki(), li(Ue, ne), Ue.width >>= Xt, Ue.height >>= Xt, Ni(Ue, ft[Xt]), ne.mipmask |= 1 << Xt;\n                  else Ue = ne.images[0] = Ki(), li(Ue, ne), Ni(Ue, we), ne.mipmask = 1;\n                  li(ne, ne.images[0]), ne.compressed && (ne.internalformat === Io || ne.internalformat === ls || ne.internalformat === Zl || ne.internalformat);\n                }\n                function is(ne, we) {\n                  for (var Ue = ne.images, ft = 0; ft < Ue.length; ++ft) {\n                    if (!Ue[ft]) return;\n                    pn(Ue[ft], we, ft);\n                  }\n                }\n                var Zs = [];\n                function Va() {\n                  var ne = Zs.pop() || new ta();\n                  hi.call(ne), ne.mipmask = 0;\n                  for (var we = 0; we < 16; ++we) ne.images[we] = null;\n                  return ne;\n                }\n                function Ml(ne) {\n                  for (var we = ne.images, Ue = 0; Ue < we.length; ++Ue) we[Ue] && kn(we[Ue]), we[Ue] = null;\n                  Zs.push(ne);\n                }\n                function zo() {\n                  this.minFilter = pl, this.magFilter = pl, this.wrapS = Pc, this.wrapT = Pc, this.anisotropic = 1, this.genMipmaps = false, this.mipmapHint = sc;\n                }\n                function Qs(ne, we) {\n                  if ("min" in we) {\n                    var Ue = we.min;\n                    ne.minFilter = Ei[Ue], Es.indexOf(ne.minFilter) >= 0 && !("faces" in we) && (ne.genMipmaps = true);\n                  }\n                  if ("mag" in we) {\n                    var ft = we.mag;\n                    ne.magFilter = qi[ft];\n                  }\n                  var Xt = ne.wrapS, hr = ne.wrapT;\n                  if ("wrap" in we) {\n                    var qt = we.wrap;\n                    typeof qt == "string" ? Xt = hr = Ui[qt] : Array.isArray(qt) && (Xt = Ui[qt[0]], hr = Ui[qt[1]]);\n                  } else {\n                    if ("wrapS" in we) {\n                      var Ve = we.wrapS;\n                      Xt = Ui[Ve];\n                    }\n                    if ("wrapT" in we) {\n                      var Qe = we.wrapT;\n                      hr = Ui[Qe];\n                    }\n                  }\n                  if (ne.wrapS = Xt, ne.wrapT = hr, "anisotropic" in we) {\n                    var at = we.anisotropic;\n                    ne.anisotropic = we.anisotropic;\n                  }\n                  if ("mipmap" in we) {\n                    var Ct = false;\n                    switch (typeof we.mipmap) {\n                      case "string":\n                        ne.mipmapHint = mi[we.mipmap], ne.genMipmaps = true, Ct = true;\n                        break;\n                      case "boolean":\n                        Ct = ne.genMipmaps = we.mipmap;\n                        break;\n                      case "object":\n                        ne.genMipmaps = false, Ct = true;\n                        break;\n                      default:\n                    }\n                    Ct && !("min" in we) && (ne.minFilter = Kl);\n                  }\n                }\n                function al(ne, we) {\n                  Me.texParameteri(we, Uf, ne.minFilter), Me.texParameteri(we, rf, ne.magFilter), Me.texParameteri(we, Oo, ne.wrapS), Me.texParameteri(we, qo, ne.wrapT), bt.ext_texture_filter_anisotropic && Me.texParameteri(we, cs, ne.anisotropic), ne.genMipmaps && (Me.hint(Cf, ne.mipmapHint), Me.generateMipmap(we));\n                }\n                var Vl = 0, ss = {}, Vs = zt.maxTextureUnits, Ys = Array(Vs).map(function() {\n                  return null;\n                });\n                function wa(ne) {\n                  hi.call(this), this.mipmask = 0, this.internalformat = Ma, this.id = Vl++, this.refCount = 1, this.target = ne, this.texture = Me.createTexture(), this.unit = -1, this.bindCount = 0, this.texInfo = new zo(), Gr.profile && (this.stats = { size: 0 });\n                }\n                function ol(ne) {\n                  Me.activeTexture(Fu), Me.bindTexture(ne.target, ne.texture);\n                }\n                function io() {\n                  var ne = Ys[0];\n                  ne ? Me.bindTexture(ne.target, ne.texture) : Me.bindTexture(_n, null);\n                }\n                function Y(ne) {\n                  var we = ne.texture, Ue = ne.unit, ft = ne.target;\n                  Ue >= 0 && (Me.activeTexture(Fu + Ue), Me.bindTexture(ft, null), Ys[Ue] = null), Me.deleteTexture(we), ne.texture = null, ne.params = null, ne.pixels = null, ne.refCount = 0, delete ss[ne.id], Nr.textureCount--;\n                }\n                e3(wa.prototype, { bind: function() {\n                  var ne = this;\n                  ne.bindCount += 1;\n                  var we = ne.unit;\n                  if (we < 0) {\n                    for (var Ue = 0; Ue < Vs; ++Ue) {\n                      var ft = Ys[Ue];\n                      if (ft) {\n                        if (ft.bindCount > 0) continue;\n                        ft.unit = -1;\n                      }\n                      Ys[Ue] = ne, we = Ue;\n                      break;\n                    }\n                    we >= Vs, Gr.profile && Nr.maxTextureUnits < we + 1 && (Nr.maxTextureUnits = we + 1), ne.unit = we, Me.activeTexture(Fu + we), Me.bindTexture(ne.target, ne.texture);\n                  }\n                  return we;\n                }, unbind: function() {\n                  this.bindCount -= 1;\n                }, decRef: function() {\n                  --this.refCount <= 0 && Y(this);\n                } });\n                function D3(ne, we) {\n                  var Ue = new wa(_n);\n                  ss[Ue.id] = Ue, Nr.textureCount++;\n                  function ft(qt, Ve) {\n                    var Qe = Ue.texInfo;\n                    zo.call(Qe);\n                    var at = Va();\n                    return typeof qt == "number" ? typeof Ve == "number" ? oa(at, qt | 0, Ve | 0) : oa(at, qt | 0, qt | 0) : qt ? (Qs(Qe, qt), ba(at, qt)) : oa(at, 1, 1), Qe.genMipmaps && (at.mipmask = (at.width << 1) - 1), Ue.mipmask = at.mipmask, li(Ue, at), Ue.internalformat = at.internalformat, ft.width = at.width, ft.height = at.height, ol(Ue), is(at, _n), al(Qe, _n), io(), Ml(at), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, at.width, at.height, Qe.genMipmaps, false)), ft.format = xi[Ue.internalformat], ft.type = Ri[Ue.type], ft.mag = ci[Qe.magFilter], ft.min = an[Qe.minFilter], ft.wrapS = Zi[Qe.wrapS], ft.wrapT = Zi[Qe.wrapT], ft;\n                  }\n                  function Xt(qt, Ve, Qe, at) {\n                    var Ct = Ve | 0, Ot = Qe | 0, Rt = at | 0, Bt = Ki();\n                    return li(Bt, Ue), Bt.width = 0, Bt.height = 0, Ni(Bt, qt), Bt.width = Bt.width || (Ue.width >> Rt) - Ct, Bt.height = Bt.height || (Ue.height >> Rt) - Ot, ol(Ue), Vn(Bt, _n, Ct, Ot, Rt), io(), kn(Bt), ft;\n                  }\n                  function hr(qt, Ve) {\n                    var Qe = qt | 0, at = Ve | 0 || Qe;\n                    if (Qe === Ue.width && at === Ue.height) return ft;\n                    ft.width = Ue.width = Qe, ft.height = Ue.height = at, ol(Ue);\n                    for (var Ct = 0; Ue.mipmask >> Ct; ++Ct) {\n                      var Ot = Qe >> Ct, Rt = at >> Ct;\n                      if (!Ot || !Rt) break;\n                      Me.texImage2D(_n, Ct, Ue.format, Ot, Rt, 0, Ue.format, Ue.type, null);\n                    }\n                    return io(), Gr.profile && (Ue.stats.size = cc(Ue.internalformat, Ue.type, Qe, at, false, false)), ft;\n                  }\n                  return ft(ne, we), ft.subimage = Xt, ft.resize = hr, ft._reglType = "texture2d", ft._texture = Ue, Gr.profile && (ft.stats = Ue.stats), ft.destroy = function() {\n                    Ue.decRef();\n                  }, ft;\n                }\n                function J(ne, we, Ue, ft, Xt, hr) {\n                  var qt = new wa(ya);\n                  ss[qt.id] = qt, Nr.cubeCount++;\n                  var Ve = new Array(6);\n                  function Qe(Ot, Rt, Bt, Dt, yt, Pt) {\n                    var ht, ur = qt.texInfo;\n                    for (zo.call(ur), ht = 0; ht < 6; ++ht) Ve[ht] = Va();\n                    if (typeof Ot == "number" || !Ot) {\n                      var br = Ot | 0 || 1;\n                      for (ht = 0; ht < 6; ++ht) oa(Ve[ht], br, br);\n                    } else if (typeof Ot == "object") if (Rt) ba(Ve[0], Ot), ba(Ve[1], Rt), ba(Ve[2], Bt), ba(Ve[3], Dt), ba(Ve[4], yt), ba(Ve[5], Pt);\n                    else if (Qs(ur, Ot), mn(qt, Ot), "faces" in Ot) {\n                      var Ur = Ot.faces;\n                      for (ht = 0; ht < 6; ++ht) li(Ve[ht], qt), ba(Ve[ht], Ur[ht]);\n                    } else for (ht = 0; ht < 6; ++ht) ba(Ve[ht], Ot);\n                    for (li(qt, Ve[0]), ur.genMipmaps ? qt.mipmask = (Ve[0].width << 1) - 1 : qt.mipmask = Ve[0].mipmask, qt.internalformat = Ve[0].internalformat, Qe.width = Ve[0].width, Qe.height = Ve[0].height, ol(qt), ht = 0; ht < 6; ++ht) is(Ve[ht], Jn + ht);\n                    for (al(ur, ya), io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, ur.genMipmaps, true)), Qe.format = xi[qt.internalformat], Qe.type = Ri[qt.type], Qe.mag = ci[ur.magFilter], Qe.min = an[ur.minFilter], Qe.wrapS = Zi[ur.wrapS], Qe.wrapT = Zi[ur.wrapT], ht = 0; ht < 6; ++ht) Ml(Ve[ht]);\n                    return Qe;\n                  }\n                  function at(Ot, Rt, Bt, Dt, yt) {\n                    var Pt = Bt | 0, ht = Dt | 0, ur = yt | 0, br = Ki();\n                    return li(br, qt), br.width = 0, br.height = 0, Ni(br, Rt), br.width = br.width || (qt.width >> ur) - Pt, br.height = br.height || (qt.height >> ur) - ht, ol(qt), Vn(br, Jn + Ot, Pt, ht, ur), io(), kn(br), Qe;\n                  }\n                  function Ct(Ot) {\n                    var Rt = Ot | 0;\n                    if (Rt !== qt.width) {\n                      Qe.width = qt.width = Rt, Qe.height = qt.height = Rt, ol(qt);\n                      for (var Bt = 0; Bt < 6; ++Bt) for (var Dt = 0; qt.mipmask >> Dt; ++Dt) Me.texImage2D(Jn + Bt, Dt, qt.format, Rt >> Dt, Rt >> Dt, 0, qt.format, qt.type, null);\n                      return io(), Gr.profile && (qt.stats.size = cc(qt.internalformat, qt.type, Qe.width, Qe.height, false, true)), Qe;\n                    }\n                  }\n                  return Qe(ne, we, Ue, ft, Xt, hr), Qe.subimage = at, Qe.resize = Ct, Qe._reglType = "textureCube", Qe._texture = qt, Gr.profile && (Qe.stats = qt.stats), Qe.destroy = function() {\n                    qt.decRef();\n                  }, Qe;\n                }\n                function q2() {\n                  for (var ne = 0; ne < Vs; ++ne) Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Ys[ne] = null;\n                  dt(ss).forEach(Y), Nr.cubeCount = 0, Nr.textureCount = 0;\n                }\n                Gr.profile && (Nr.getTotalTextureSize = function() {\n                  var ne = 0;\n                  return Object.keys(ss).forEach(function(we) {\n                    ne += ss[we].stats.size;\n                  }), ne;\n                });\n                function K() {\n                  for (var ne = 0; ne < Vs; ++ne) {\n                    var we = Ys[ne];\n                    we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null);\n                  }\n                  dt(ss).forEach(function(Ue) {\n                    Ue.texture = Me.createTexture(), Me.bindTexture(Ue.target, Ue.texture);\n                    for (var ft = 0; ft < 32; ++ft) if ((Ue.mipmask & 1 << ft) !== 0) if (Ue.target === _n) Me.texImage2D(_n, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);\n                    else for (var Xt = 0; Xt < 6; ++Xt) Me.texImage2D(Jn + Xt, ft, Ue.internalformat, Ue.width >> ft, Ue.height >> ft, 0, Ue.internalformat, Ue.type, null);\n                    al(Ue.texInfo, Ue.target);\n                  });\n                }\n                function de() {\n                  for (var ne = 0; ne < Vs; ++ne) {\n                    var we = Ys[ne];\n                    we && (we.bindCount = 0, we.unit = -1, Ys[ne] = null), Me.activeTexture(Fu + ne), Me.bindTexture(_n, null), Me.bindTexture(ya, null);\n                  }\n                }\n                return { create2D: D3, createCube: J, clear: q2, getTexture: function(ne) {\n                  return null;\n                }, restore: K, refresh: de };\n              }\n              var Nl = 36161, Kc = 32854, Rc = 32855, gs = 36194, jf = 33189, Gh = 36168, rh = 34041, sf = 35907, Th = 34836, Mu = 34842, ih = 34843, js = [];\n              js[Kc] = 2, js[Rc] = 2, js[gs] = 2, js[jf] = 2, js[Gh] = 1, js[rh] = 4, js[sf] = 4, js[Th] = 16, js[Mu] = 8, js[ih] = 6;\n              function Eu(Me, bt, zt) {\n                return js[Me] * bt * zt;\n              }\n              var Dc = function(Me, bt, zt, Rr, jr) {\n                var Nr = { rgba4: Kc, rgb565: gs, "rgb5 a1": Rc, depth: jf, stencil: Gh, "depth stencil": rh };\n                bt.ext_srgb && (Nr.srgba = sf), bt.ext_color_buffer_half_float && (Nr.rgba16f = Mu, Nr.rgb16f = ih), bt.webgl_color_buffer_float && (Nr.rgba32f = Th);\n                var Gr = [];\n                Object.keys(Nr).forEach(function(Wi) {\n                  var si = Nr[Wi];\n                  Gr[si] = Wi;\n                });\n                var mi = 0, Ui = {};\n                function qi(Wi) {\n                  this.id = mi++, this.refCount = 1, this.renderbuffer = Wi, this.format = Kc, this.width = 0, this.height = 0, jr.profile && (this.stats = { size: 0 });\n                }\n                qi.prototype.decRef = function() {\n                  --this.refCount <= 0 && Ei(this);\n                };\n                function Ei(Wi) {\n                  var si = Wi.renderbuffer;\n                  Me.bindRenderbuffer(Nl, null), Me.deleteRenderbuffer(si), Wi.renderbuffer = null, Wi.refCount = 0, delete Ui[Wi.id], Rr.renderbufferCount--;\n                }\n                function Hn(Wi, si) {\n                  var Mr = new qi(Me.createRenderbuffer());\n                  Ui[Mr.id] = Mr, Rr.renderbufferCount++;\n                  function Yr(Ri, ci) {\n                    var an = 0, Zi = 0, Bn = Kc;\n                    if (typeof Ri == "object" && Ri) {\n                      var hi = Ri;\n                      if ("shape" in hi) {\n                        var li = hi.shape;\n                        an = li[0] | 0, Zi = li[1] | 0;\n                      } else "radius" in hi && (an = Zi = hi.radius | 0), "width" in hi && (an = hi.width | 0), "height" in hi && (Zi = hi.height | 0);\n                      "format" in hi && (Bn = Nr[hi.format]);\n                    } else typeof Ri == "number" ? (an = Ri | 0, typeof ci == "number" ? Zi = ci | 0 : Zi = an) : Ri || (an = Zi = 1);\n                    if (!(an === Mr.width && Zi === Mr.height && Bn === Mr.format)) return Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Mr.format = Bn, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Bn, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height)), Yr.format = Gr[Mr.format], Yr;\n                  }\n                  function xi(Ri, ci) {\n                    var an = Ri | 0, Zi = ci | 0 || an;\n                    return an === Mr.width && Zi === Mr.height || (Yr.width = Mr.width = an, Yr.height = Mr.height = Zi, Me.bindRenderbuffer(Nl, Mr.renderbuffer), Me.renderbufferStorage(Nl, Mr.format, an, Zi), jr.profile && (Mr.stats.size = Eu(Mr.format, Mr.width, Mr.height))), Yr;\n                  }\n                  return Yr(Wi, si), Yr.resize = xi, Yr._reglType = "renderbuffer", Yr._renderbuffer = Mr, jr.profile && (Yr.stats = Mr.stats), Yr.destroy = function() {\n                    Mr.decRef();\n                  }, Yr;\n                }\n                jr.profile && (Rr.getTotalRenderbufferSize = function() {\n                  var Wi = 0;\n                  return Object.keys(Ui).forEach(function(si) {\n                    Wi += Ui[si].stats.size;\n                  }), Wi;\n                });\n                function en() {\n                  dt(Ui).forEach(function(Wi) {\n                    Wi.renderbuffer = Me.createRenderbuffer(), Me.bindRenderbuffer(Nl, Wi.renderbuffer), Me.renderbufferStorage(Nl, Wi.format, Wi.width, Wi.height);\n                  }), Me.bindRenderbuffer(Nl, null);\n                }\n                return { create: Hn, clear: function() {\n                  dt(Ui).forEach(Ei);\n                }, restore: en };\n              }, ks = 36160, bc = 36161, hu = 3553, _u = 34069, nl = 36064, nh = 36096, Ah = 36128, zu = 33306, Fc = 36053, wc = 36193, bd = 5121, xf = 5126, Pf = 6407, Ou = 6408, bf = [];\n              bf[Ou] = 4, bf[Pf] = 3;\n              var jl = [];\n              jl[bd] = 1, jl[xf] = 4, jl[wc] = 2;\n              function lf(Me, bt, zt, Rr, jr, Nr) {\n                var Gr = { cur: null, next: null, dirty: false, setFBO: null }, mi = ["rgba"], Ui = ["rgba4", "rgb565", "rgb5 a1"];\n                bt.ext_srgb && Ui.push("srgba"), bt.ext_color_buffer_half_float && Ui.push("rgba16f", "rgb16f"), bt.webgl_color_buffer_float && Ui.push("rgba32f");\n                var qi = ["uint8"];\n                bt.oes_texture_half_float && qi.push("half float", "float16"), bt.oes_texture_float && qi.push("float", "float32");\n                function Ei(Vi, Ni, pn) {\n                  this.target = Vi, this.texture = Ni, this.renderbuffer = pn;\n                  var Vn = 0, na = 0;\n                  Ni ? (Vn = Ni.width, na = Ni.height) : pn && (Vn = pn.width, na = pn.height), this.width = Vn, this.height = na;\n                }\n                function Hn(Vi) {\n                  Vi && (Vi.texture && Vi.texture._texture.decRef(), Vi.renderbuffer && Vi.renderbuffer._renderbuffer.decRef());\n                }\n                function en(Vi, Ni, pn) {\n                  if (Vi) if (Vi.texture) {\n                    var Vn = Vi.texture._texture, na = Math.max(1, Vn.width), Ki = Math.max(1, Vn.height);\n                    Vn.refCount += 1;\n                  } else {\n                    var kn = Vi.renderbuffer._renderbuffer;\n                    kn.refCount += 1;\n                  }\n                }\n                function Wi(Vi, Ni) {\n                  Ni && (Ni.texture ? Me.framebufferTexture2D(ks, Vi, Ni.target, Ni.texture._texture.texture, 0) : Me.framebufferRenderbuffer(ks, Vi, bc, Ni.renderbuffer._renderbuffer.renderbuffer));\n                }\n                function si(Vi) {\n                  var Ni = hu, pn = null, Vn = null, na = Vi;\n                  typeof Vi == "object" && (na = Vi.data, "target" in Vi && (Ni = Vi.target | 0));\n                  var Ki = na._reglType;\n                  return Ki === "texture2d" || Ki === "textureCube" ? pn = na : Ki === "renderbuffer" && (Vn = na, Ni = bc), new Ei(Ni, pn, Vn);\n                }\n                function Mr(Vi, Ni, pn, Vn, na) {\n                  if (pn) {\n                    var Ki = Rr.create2D({ width: Vi, height: Ni, format: Vn, type: na });\n                    return Ki._texture.refCount = 0, new Ei(hu, Ki, null);\n                  } else {\n                    var kn = jr.create({ width: Vi, height: Ni, format: Vn });\n                    return kn._renderbuffer.refCount = 0, new Ei(bc, null, kn);\n                  }\n                }\n                function Yr(Vi) {\n                  return Vi && (Vi.texture || Vi.renderbuffer);\n                }\n                function xi(Vi, Ni, pn) {\n                  Vi && (Vi.texture ? Vi.texture.resize(Ni, pn) : Vi.renderbuffer && Vi.renderbuffer.resize(Ni, pn), Vi.width = Ni, Vi.height = pn);\n                }\n                var Ri = 0, ci = {};\n                function an() {\n                  this.id = Ri++, ci[this.id] = this, this.framebuffer = Me.createFramebuffer(), this.width = 0, this.height = 0, this.colorAttachments = [], this.depthAttachment = null, this.stencilAttachment = null, this.depthStencilAttachment = null;\n                }\n                function Zi(Vi) {\n                  Vi.colorAttachments.forEach(Hn), Hn(Vi.depthAttachment), Hn(Vi.stencilAttachment), Hn(Vi.depthStencilAttachment);\n                }\n                function Bn(Vi) {\n                  var Ni = Vi.framebuffer;\n                  Me.deleteFramebuffer(Ni), Vi.framebuffer = null, Nr.framebufferCount--, delete ci[Vi.id];\n                }\n                function hi(Vi) {\n                  var Ni;\n                  Me.bindFramebuffer(ks, Vi.framebuffer);\n                  var pn = Vi.colorAttachments;\n                  for (Ni = 0; Ni < pn.length; ++Ni) Wi(nl + Ni, pn[Ni]);\n                  for (Ni = pn.length; Ni < zt.maxColorAttachments; ++Ni) Me.framebufferTexture2D(ks, nl + Ni, hu, null, 0);\n                  Me.framebufferTexture2D(ks, zu, hu, null, 0), Me.framebufferTexture2D(ks, nh, hu, null, 0), Me.framebufferTexture2D(ks, Ah, hu, null, 0), Wi(nh, Vi.depthAttachment), Wi(Ah, Vi.stencilAttachment), Wi(zu, Vi.depthStencilAttachment);\n                  var Vn = Me.checkFramebufferStatus(ks);\n                  Me.isContextLost(), Me.bindFramebuffer(ks, Gr.next ? Gr.next.framebuffer : null), Gr.cur = Gr.next, Me.getError();\n                }\n                function li(Vi, Ni) {\n                  var pn = new an();\n                  Nr.framebufferCount++;\n                  function Vn(Ki, kn) {\n                    var ta, oa = 0, ba = 0, is = true, Zs = true, Va = null, Ml = true, zo = "rgba", Qs = "uint8", al = 1, Vl = null, ss = null, Vs = null, Ys = false;\n                    if (typeof Ki == "number") oa = Ki | 0, ba = kn | 0 || oa;\n                    else if (!Ki) oa = ba = 1;\n                    else {\n                      var wa = Ki;\n                      if ("shape" in wa) {\n                        var ol = wa.shape;\n                        oa = ol[0], ba = ol[1];\n                      } else "radius" in wa && (oa = ba = wa.radius), "width" in wa && (oa = wa.width), "height" in wa && (ba = wa.height);\n                      ("color" in wa || "colors" in wa) && (Va = wa.color || wa.colors, Array.isArray(Va)), Va || ("colorCount" in wa && (al = wa.colorCount | 0), "colorTexture" in wa && (Ml = !!wa.colorTexture, zo = "rgba4"), "colorType" in wa && (Qs = wa.colorType, Ml || (Qs === "half float" || Qs === "float16" ? zo = "rgba16f" : (Qs === "float" || Qs === "float32") && (zo = "rgba32f"))), "colorFormat" in wa && (zo = wa.colorFormat, mi.indexOf(zo) >= 0 ? Ml = true : Ui.indexOf(zo) >= 0 && (Ml = false))), ("depthTexture" in wa || "depthStencilTexture" in wa) && (Ys = !!(wa.depthTexture || wa.depthStencilTexture)), "depth" in wa && (typeof wa.depth == "boolean" ? is = wa.depth : (Vl = wa.depth, Zs = false)), "stencil" in wa && (typeof wa.stencil == "boolean" ? Zs = wa.stencil : (ss = wa.stencil, is = false)), "depthStencil" in wa && (typeof wa.depthStencil == "boolean" ? is = Zs = wa.depthStencil : (Vs = wa.depthStencil, is = false, Zs = false));\n                    }\n                    var io = null, Y = null, D3 = null, J = null;\n                    if (Array.isArray(Va)) io = Va.map(si);\n                    else if (Va) io = [si(Va)];\n                    else for (io = new Array(al), ta = 0; ta < al; ++ta) io[ta] = Mr(oa, ba, Ml, zo, Qs);\n                    oa = oa || io[0].width, ba = ba || io[0].height, Vl ? Y = si(Vl) : is && !Zs && (Y = Mr(oa, ba, Ys, "depth", "uint32")), ss ? D3 = si(ss) : Zs && !is && (D3 = Mr(oa, ba, false, "stencil", "uint8")), Vs ? J = si(Vs) : !Vl && !ss && Zs && is && (J = Mr(oa, ba, Ys, "depth stencil", "depth stencil"));\n                    var q2 = null;\n                    for (ta = 0; ta < io.length; ++ta) if (en(io[ta], oa, ba), io[ta] && io[ta].texture) {\n                      var K = bf[io[ta].texture._texture.format] * jl[io[ta].texture._texture.type];\n                      q2 === null && (q2 = K);\n                    }\n                    return en(Y, oa, ba), en(D3, oa, ba), en(J, oa, ba), Zi(pn), pn.width = oa, pn.height = ba, pn.colorAttachments = io, pn.depthAttachment = Y, pn.stencilAttachment = D3, pn.depthStencilAttachment = J, Vn.color = io.map(Yr), Vn.depth = Yr(Y), Vn.stencil = Yr(D3), Vn.depthStencil = Yr(J), Vn.width = pn.width, Vn.height = pn.height, hi(pn), Vn;\n                  }\n                  function na(Ki, kn) {\n                    var ta = Math.max(Ki | 0, 1), oa = Math.max(kn | 0 || ta, 1);\n                    if (ta === pn.width && oa === pn.height) return Vn;\n                    for (var ba = pn.colorAttachments, is = 0; is < ba.length; ++is) xi(ba[is], ta, oa);\n                    return xi(pn.depthAttachment, ta, oa), xi(pn.stencilAttachment, ta, oa), xi(pn.depthStencilAttachment, ta, oa), pn.width = Vn.width = ta, pn.height = Vn.height = oa, hi(pn), Vn;\n                  }\n                  return Vn(Vi, Ni), e3(Vn, { resize: na, _reglType: "framebuffer", _framebuffer: pn, destroy: function() {\n                    Bn(pn), Zi(pn);\n                  }, use: function(Ki) {\n                    Gr.setFBO({ framebuffer: Vn }, Ki);\n                  } });\n                }\n                function mn(Vi) {\n                  var Ni = Array(6);\n                  function pn(na) {\n                    var Ki, kn = { color: null }, ta = 0, oa = null, ba = "rgba", is = "uint8", Zs = 1;\n                    if (typeof na == "number") ta = na | 0;\n                    else if (!na) ta = 1;\n                    else {\n                      var Va = na;\n                      if ("shape" in Va) {\n                        var Ml = Va.shape;\n                        ta = Ml[0];\n                      } else "radius" in Va && (ta = Va.radius | 0), "width" in Va ? (ta = Va.width | 0, "height" in Va) : "height" in Va && (ta = Va.height | 0);\n                      ("color" in Va || "colors" in Va) && (oa = Va.color || Va.colors, Array.isArray(oa)), oa || ("colorCount" in Va && (Zs = Va.colorCount | 0), "colorType" in Va && (is = Va.colorType), "colorFormat" in Va && (ba = Va.colorFormat)), "depth" in Va && (kn.depth = Va.depth), "stencil" in Va && (kn.stencil = Va.stencil), "depthStencil" in Va && (kn.depthStencil = Va.depthStencil);\n                    }\n                    var zo;\n                    if (oa) if (Array.isArray(oa)) for (zo = [], Ki = 0; Ki < oa.length; ++Ki) zo[Ki] = oa[Ki];\n                    else zo = [oa];\n                    else {\n                      zo = Array(Zs);\n                      var Qs = { radius: ta, format: ba, type: is };\n                      for (Ki = 0; Ki < Zs; ++Ki) zo[Ki] = Rr.createCube(Qs);\n                    }\n                    for (kn.color = Array(zo.length), Ki = 0; Ki < zo.length; ++Ki) {\n                      var al = zo[Ki];\n                      ta = ta || al.width, kn.color[Ki] = { target: _u, data: zo[Ki] };\n                    }\n                    for (Ki = 0; Ki < 6; ++Ki) {\n                      for (var Vl = 0; Vl < zo.length; ++Vl) kn.color[Vl].target = _u + Ki;\n                      Ki > 0 && (kn.depth = Ni[0].depth, kn.stencil = Ni[0].stencil, kn.depthStencil = Ni[0].depthStencil), Ni[Ki] ? Ni[Ki](kn) : Ni[Ki] = li(kn);\n                    }\n                    return e3(pn, { width: ta, height: ta, color: zo });\n                  }\n                  function Vn(na) {\n                    var Ki, kn = na | 0;\n                    if (kn === pn.width) return pn;\n                    var ta = pn.color;\n                    for (Ki = 0; Ki < ta.length; ++Ki) ta[Ki].resize(kn);\n                    for (Ki = 0; Ki < 6; ++Ki) Ni[Ki].resize(kn);\n                    return pn.width = pn.height = kn, pn;\n                  }\n                  return pn(Vi), e3(pn, { faces: Ni, resize: Vn, _reglType: "framebufferCube", destroy: function() {\n                    Ni.forEach(function(na) {\n                      na.destroy();\n                    });\n                  } });\n                }\n                function Ji() {\n                  Gr.cur = null, Gr.next = null, Gr.dirty = true, dt(ci).forEach(function(Vi) {\n                    Vi.framebuffer = Me.createFramebuffer(), hi(Vi);\n                  });\n                }\n                return e3(Gr, { getFramebuffer: function(Vi) {\n                  if (typeof Vi == "function" && Vi._reglType === "framebuffer") {\n                    var Ni = Vi._framebuffer;\n                    if (Ni instanceof an) return Ni;\n                  }\n                  return null;\n                }, create: li, createCube: mn, clear: function() {\n                  dt(ci).forEach(Bn);\n                }, restore: Ji });\n              }\n              var Hh = 5126, If = 34962, Cs = 34963;\n              function du() {\n                this.state = 0, this.x = 0, this.y = 0, this.z = 0, this.w = 0, this.buffer = null, this.size = 0, this.normalized = false, this.type = Hh, this.offset = 0, this.stride = 0, this.divisor = 0;\n              }\n              function ku(Me, bt, zt, Rr, jr, Nr, Gr) {\n                for (var mi = zt.maxAttributes, Ui = new Array(mi), qi = 0; qi < mi; ++qi) Ui[qi] = new du();\n                var Ei = 0, Hn = {}, en = { Record: du, scope: {}, state: Ui, currentVAO: null, targetVAO: null, restore: si() ? Zi : function() {\n                }, createVAO: Bn, getVAO: Yr, destroyBuffer: Wi, setVAO: si() ? xi : Ri, clear: si() ? ci : function() {\n                } };\n                function Wi(hi) {\n                  for (var li = 0; li < Ui.length; ++li) {\n                    var mn = Ui[li];\n                    mn.buffer === hi && (Me.disableVertexAttribArray(li), mn.buffer = null);\n                  }\n                }\n                function si() {\n                  return bt.oes_vertex_array_object;\n                }\n                function Mr() {\n                  return bt.angle_instanced_arrays;\n                }\n                function Yr(hi) {\n                  return typeof hi == "function" && hi._vao ? hi._vao : null;\n                }\n                function xi(hi) {\n                  if (hi !== en.currentVAO) {\n                    var li = si();\n                    hi ? li.bindVertexArrayOES(hi.vao) : li.bindVertexArrayOES(null), en.currentVAO = hi;\n                  }\n                }\n                function Ri(hi) {\n                  if (hi !== en.currentVAO) {\n                    if (hi) hi.bindAttrs();\n                    else {\n                      for (var li = Mr(), mn = 0; mn < Ui.length; ++mn) {\n                        var Ji = Ui[mn];\n                        Ji.buffer ? (Me.enableVertexAttribArray(mn), Ji.buffer.bind(), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offfset), li && Ji.divisor && li.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));\n                      }\n                      Gr.elements ? Me.bindBuffer(Cs, Gr.elements.buffer.buffer) : Me.bindBuffer(Cs, null);\n                    }\n                    en.currentVAO = hi;\n                  }\n                }\n                function ci() {\n                  dt(Hn).forEach(function(hi) {\n                    hi.destroy();\n                  });\n                }\n                function an() {\n                  this.id = ++Ei, this.attributes = [], this.elements = null, this.ownsElements = false, this.count = 0, this.offset = 0, this.instances = -1, this.primitive = 4;\n                  var hi = si();\n                  hi ? this.vao = hi.createVertexArrayOES() : this.vao = null, Hn[this.id] = this, this.buffers = [];\n                }\n                an.prototype.bindAttrs = function() {\n                  for (var hi = Mr(), li = this.attributes, mn = 0; mn < li.length; ++mn) {\n                    var Ji = li[mn];\n                    Ji.buffer ? (Me.enableVertexAttribArray(mn), Me.bindBuffer(If, Ji.buffer.buffer), Me.vertexAttribPointer(mn, Ji.size, Ji.type, Ji.normalized, Ji.stride, Ji.offset), hi && Ji.divisor && hi.vertexAttribDivisorANGLE(mn, Ji.divisor)) : (Me.disableVertexAttribArray(mn), Me.vertexAttrib4f(mn, Ji.x, Ji.y, Ji.z, Ji.w));\n                  }\n                  for (var Vi = li.length; Vi < mi; ++Vi) Me.disableVertexAttribArray(Vi);\n                  var Ni = Nr.getElements(this.elements);\n                  Ni ? Me.bindBuffer(Cs, Ni.buffer.buffer) : Me.bindBuffer(Cs, null);\n                }, an.prototype.refresh = function() {\n                  var hi = si();\n                  hi && (hi.bindVertexArrayOES(this.vao), this.bindAttrs(), en.currentVAO = null, hi.bindVertexArrayOES(null));\n                }, an.prototype.destroy = function() {\n                  if (this.vao) {\n                    var hi = si();\n                    this === en.currentVAO && (en.currentVAO = null, hi.bindVertexArrayOES(null)), hi.deleteVertexArrayOES(this.vao), this.vao = null;\n                  }\n                  this.ownsElements && (this.elements.destroy(), this.elements = null, this.ownsElements = false), Hn[this.id] && (delete Hn[this.id], Rr.vaoCount -= 1);\n                };\n                function Zi() {\n                  var hi = si();\n                  hi && dt(Hn).forEach(function(li) {\n                    li.refresh();\n                  });\n                }\n                function Bn(hi) {\n                  var li = new an();\n                  Rr.vaoCount += 1;\n                  function mn(Ji) {\n                    var Vi;\n                    if (Array.isArray(Ji)) Vi = Ji, li.elements && li.ownsElements && li.elements.destroy(), li.elements = null, li.ownsElements = false, li.offset = 0, li.count = 0, li.instances = -1, li.primitive = 4;\n                    else {\n                      if (Ji.elements) {\n                        var Ni = Ji.elements;\n                        li.ownsElements ? typeof Ni == "function" && Ni._reglType === "elements" ? (li.elements.destroy(), li.ownsElements = false) : (li.elements(Ni), li.ownsElements = false) : Nr.getElements(Ji.elements) ? (li.elements = Ji.elements, li.ownsElements = false) : (li.elements = Nr.create(Ji.elements), li.ownsElements = true);\n                      } else li.elements = null, li.ownsElements = false;\n                      Vi = Ji.attributes, li.offset = 0, li.count = -1, li.instances = -1, li.primitive = 4, li.elements && (li.count = li.elements._elements.vertCount, li.primitive = li.elements._elements.primType), "offset" in Ji && (li.offset = Ji.offset | 0), "count" in Ji && (li.count = Ji.count | 0), "instances" in Ji && (li.instances = Ji.instances | 0), "primitive" in Ji && (li.primitive = Sn[Ji.primitive]);\n                    }\n                    var pn = {}, Vn = li.attributes;\n                    Vn.length = Vi.length;\n                    for (var na = 0; na < Vi.length; ++na) {\n                      var Ki = Vi[na], kn = Vn[na] = new du(), ta = Ki.data || Ki;\n                      if (Array.isArray(ta) || Br(ta) || Vr(ta)) {\n                        var oa;\n                        li.buffers[na] && (oa = li.buffers[na], Br(ta) && oa._buffer.byteLength >= ta.byteLength ? oa.subdata(ta) : (oa.destroy(), li.buffers[na] = null)), li.buffers[na] || (oa = li.buffers[na] = jr.create(Ki, If, false, true)), kn.buffer = jr.getBuffer(oa), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1, pn[na] = 1;\n                      } else jr.getBuffer(Ki) ? (kn.buffer = jr.getBuffer(Ki), kn.size = kn.buffer.dimension | 0, kn.normalized = false, kn.type = kn.buffer.dtype, kn.offset = 0, kn.stride = 0, kn.divisor = 0, kn.state = 1) : jr.getBuffer(Ki.buffer) ? (kn.buffer = jr.getBuffer(Ki.buffer), kn.size = (+Ki.size || kn.buffer.dimension) | 0, kn.normalized = !!Ki.normalized || false, "type" in Ki ? kn.type = ji[Ki.type] : kn.type = kn.buffer.dtype, kn.offset = (Ki.offset || 0) | 0, kn.stride = (Ki.stride || 0) | 0, kn.divisor = (Ki.divisor || 0) | 0, kn.state = 1) : "x" in Ki && (kn.x = +Ki.x || 0, kn.y = +Ki.y || 0, kn.z = +Ki.z || 0, kn.w = +Ki.w || 0, kn.state = 2);\n                    }\n                    for (var ba = 0; ba < li.buffers.length; ++ba) !pn[ba] && li.buffers[ba] && (li.buffers[ba].destroy(), li.buffers[ba] = null);\n                    return li.refresh(), mn;\n                  }\n                  return mn.destroy = function() {\n                    for (var Ji = 0; Ji < li.buffers.length; ++Ji) li.buffers[Ji] && li.buffers[Ji].destroy();\n                    li.buffers.length = 0, li.ownsElements && (li.elements.destroy(), li.elements = null, li.ownsElements = false), li.destroy();\n                  }, mn._vao = li, mn._reglType = "vao", mn(hi);\n                }\n                return en;\n              }\n              var Wf = 35632, Us = 35633, wf = 35718, zc = 35721;\n              function Wu(Me, bt, zt, Rr) {\n                var jr = {}, Nr = {};\n                function Gr(Mr, Yr, xi, Ri) {\n                  this.name = Mr, this.id = Yr, this.location = xi, this.info = Ri;\n                }\n                function mi(Mr, Yr) {\n                  for (var xi = 0; xi < Mr.length; ++xi) if (Mr[xi].id === Yr.id) {\n                    Mr[xi].location = Yr.location;\n                    return;\n                  }\n                  Mr.push(Yr);\n                }\n                function Ui(Mr, Yr, xi) {\n                  var Ri = Mr === Wf ? jr : Nr, ci = Ri[Yr];\n                  if (!ci) {\n                    var an = bt.str(Yr);\n                    ci = Me.createShader(Mr), Me.shaderSource(ci, an), Me.compileShader(ci), Ri[Yr] = ci;\n                  }\n                  return ci;\n                }\n                var qi = {}, Ei = [], Hn = 0;\n                function en(Mr, Yr) {\n                  this.id = Hn++, this.fragId = Mr, this.vertId = Yr, this.program = null, this.uniforms = [], this.attributes = [], this.refCount = 1, Rr.profile && (this.stats = { uniformsCount: 0, attributesCount: 0 });\n                }\n                function Wi(Mr, Yr, xi) {\n                  var Ri, ci, an = Ui(Wf, Mr.fragId), Zi = Ui(Us, Mr.vertId), Bn = Mr.program = Me.createProgram();\n                  if (Me.attachShader(Bn, an), Me.attachShader(Bn, Zi), xi) for (Ri = 0; Ri < xi.length; ++Ri) {\n                    var hi = xi[Ri];\n                    Me.bindAttribLocation(Bn, hi[0], hi[1]);\n                  }\n                  Me.linkProgram(Bn);\n                  var li = Me.getProgramParameter(Bn, wf);\n                  Rr.profile && (Mr.stats.uniformsCount = li);\n                  var mn = Mr.uniforms;\n                  for (Ri = 0; Ri < li; ++Ri) if (ci = Me.getActiveUniform(Bn, Ri), ci) if (ci.size > 1) for (var Ji = 0; Ji < ci.size; ++Ji) {\n                    var Vi = ci.name.replace("[0]", "[" + Ji + "]");\n                    mi(mn, new Gr(Vi, bt.id(Vi), Me.getUniformLocation(Bn, Vi), ci));\n                  }\n                  else mi(mn, new Gr(ci.name, bt.id(ci.name), Me.getUniformLocation(Bn, ci.name), ci));\n                  var Ni = Me.getProgramParameter(Bn, zc);\n                  Rr.profile && (Mr.stats.attributesCount = Ni);\n                  var pn = Mr.attributes;\n                  for (Ri = 0; Ri < Ni; ++Ri) ci = Me.getActiveAttrib(Bn, Ri), ci && mi(pn, new Gr(ci.name, bt.id(ci.name), Me.getAttribLocation(Bn, ci.name), ci));\n                }\n                Rr.profile && (zt.getMaxUniformsCount = function() {\n                  var Mr = 0;\n                  return Ei.forEach(function(Yr) {\n                    Yr.stats.uniformsCount > Mr && (Mr = Yr.stats.uniformsCount);\n                  }), Mr;\n                }, zt.getMaxAttributesCount = function() {\n                  var Mr = 0;\n                  return Ei.forEach(function(Yr) {\n                    Yr.stats.attributesCount > Mr && (Mr = Yr.stats.attributesCount);\n                  }), Mr;\n                });\n                function si() {\n                  jr = {}, Nr = {};\n                  for (var Mr = 0; Mr < Ei.length; ++Mr) Wi(Ei[Mr], null, Ei[Mr].attributes.map(function(Yr) {\n                    return [Yr.location, Yr.name];\n                  }));\n                }\n                return { clear: function() {\n                  var Mr = Me.deleteShader.bind(Me);\n                  dt(jr).forEach(Mr), jr = {}, dt(Nr).forEach(Mr), Nr = {}, Ei.forEach(function(Yr) {\n                    Me.deleteProgram(Yr.program);\n                  }), Ei.length = 0, qi = {}, zt.shaderCount = 0;\n                }, program: function(Mr, Yr, xi, Ri) {\n                  var ci = qi[Yr];\n                  ci || (ci = qi[Yr] = {});\n                  var an = ci[Mr];\n                  if (an && (an.refCount++, !Ri)) return an;\n                  var Zi = new en(Yr, Mr);\n                  return zt.shaderCount++, Wi(Zi, xi, Ri), an || (ci[Mr] = Zi), Ei.push(Zi), e3(Zi, { destroy: function() {\n                    if (Zi.refCount--, Zi.refCount <= 0) {\n                      Me.deleteProgram(Zi.program);\n                      var Bn = Ei.indexOf(Zi);\n                      Ei.splice(Bn, 1), zt.shaderCount--;\n                    }\n                    ci[Zi.vertId].refCount <= 0 && (Me.deleteShader(Nr[Zi.vertId]), delete Nr[Zi.vertId], delete qi[Zi.fragId][Zi.vertId]), Object.keys(qi[Zi.fragId]).length || (Me.deleteShader(jr[Zi.fragId]), delete jr[Zi.fragId], delete qi[Zi.fragId]);\n                  } });\n                }, restore: si, shader: Ui, frag: -1, vert: -1 };\n              }\n              var Rf = 6408, Xu = 5121, uf = 3333, Xf = 5126;\n              function Wl(Me, bt, zt, Rr, jr, Nr, Gr) {\n                function mi(Ei) {\n                  var Hn;\n                  bt.next === null ? Hn = Xu : Hn = bt.next.colorAttachments[0].texture._texture.type;\n                  var en = 0, Wi = 0, si = Rr.framebufferWidth, Mr = Rr.framebufferHeight, Yr = null;\n                  Br(Ei) ? Yr = Ei : Ei && (en = Ei.x | 0, Wi = Ei.y | 0, si = (Ei.width || Rr.framebufferWidth - en) | 0, Mr = (Ei.height || Rr.framebufferHeight - Wi) | 0, Yr = Ei.data || null), zt();\n                  var xi = si * Mr * 4;\n                  return Yr || (Hn === Xu ? Yr = new Uint8Array(xi) : Hn === Xf && (Yr = Yr || new Float32Array(xi))), Me.pixelStorei(uf, 4), Me.readPixels(en, Wi, si, Mr, Rf, Hn, Yr), Yr;\n                }\n                function Ui(Ei) {\n                  var Hn;\n                  return bt.setFBO({ framebuffer: Ei.framebuffer }, function() {\n                    Hn = mi(Ei);\n                  }), Hn;\n                }\n                function qi(Ei) {\n                  return !Ei || !("framebuffer" in Ei) ? mi(Ei) : Ui(Ei);\n                }\n                return qi;\n              }\n              var ah = 0, Zu = "";\n              function Oc(Me) {\n                return vu(Tc(fc(Me)));\n              }\n              function Tc(Me) {\n                return At(Yi(Bc(Me), Me.length * 8));\n              }\n              function wl(Me, bt) {\n                var zt = Bc(Me);\n                zt.length > 16 && (zt = Yi(zt, Me.length * 8));\n                for (var Rr = Array(16), jr = Array(16), Nr = 0; Nr < 16; Nr++) Rr[Nr] = zt[Nr] ^ 909522486, jr[Nr] = zt[Nr] ^ 1549556828;\n                var Gr = Yi(Rr.concat(Bc(bt)), 512 + bt.length * 8);\n                return At(Yi(jr.concat(Gr), 768));\n              }\n              function vu(Me) {\n                for (var bt = ah ? "0123456789ABCDEF" : "0123456789abcdef", zt = "", Rr, jr = 0; jr < Me.length; jr++) Rr = Me.charCodeAt(jr), zt += bt.charAt(Rr >>> 4 & 15) + bt.charAt(Rr & 15);\n                return zt;\n              }\n              function qc(Me) {\n                for (var bt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", zt = "", Rr = Me.length, jr = 0; jr < Rr; jr += 3) for (var Nr = Me.charCodeAt(jr) << 16 | (jr + 1 < Rr ? Me.charCodeAt(jr + 1) << 8 : 0) | (jr + 2 < Rr ? Me.charCodeAt(jr + 2) : 0), Gr = 0; Gr < 4; Gr++) jr * 8 + Gr * 6 > Me.length * 8 ? zt += Zu : zt += bt.charAt(Nr >>> 6 * (3 - Gr) & 63);\n                return zt;\n              }\n              function cf(Me, bt) {\n                var zt = bt.length, Rr = Array(), jr, Nr, Gr, mi, Ui = Array(Math.ceil(Me.length / 2));\n                for (jr = 0; jr < Ui.length; jr++) Ui[jr] = Me.charCodeAt(jr * 2) << 8 | Me.charCodeAt(jr * 2 + 1);\n                for (; Ui.length > 0; ) {\n                  for (mi = Array(), Gr = 0, jr = 0; jr < Ui.length; jr++) Gr = (Gr << 16) + Ui[jr], Nr = Math.floor(Gr / zt), Gr -= Nr * zt, (mi.length > 0 || Nr > 0) && (mi[mi.length] = Nr);\n                  Rr[Rr.length] = Gr, Ui = mi;\n                }\n                var qi = "";\n                for (jr = Rr.length - 1; jr >= 0; jr--) qi += bt.charAt(Rr[jr]);\n                var Ei = Math.ceil(Me.length * 8 / (Math.log(bt.length) / Math.log(2)));\n                for (jr = qi.length; jr < Ei; jr++) qi = bt[0] + qi;\n                return qi;\n              }\n              function fc(Me) {\n                for (var bt = "", zt = -1, Rr, jr; ++zt < Me.length; ) Rr = Me.charCodeAt(zt), jr = zt + 1 < Me.length ? Me.charCodeAt(zt + 1) : 0, 55296 <= Rr && Rr <= 56319 && 56320 <= jr && jr <= 57343 && (Rr = 65536 + ((Rr & 1023) << 10) + (jr & 1023), zt++), Rr <= 127 ? bt += String.fromCharCode(Rr) : Rr <= 2047 ? bt += String.fromCharCode(192 | Rr >>> 6 & 31, 128 | Rr & 63) : Rr <= 65535 ? bt += String.fromCharCode(224 | Rr >>> 12 & 15, 128 | Rr >>> 6 & 63, 128 | Rr & 63) : Rr <= 2097151 && (bt += String.fromCharCode(240 | Rr >>> 18 & 7, 128 | Rr >>> 12 & 63, 128 | Rr >>> 6 & 63, 128 | Rr & 63));\n                return bt;\n              }\n              function Bc(Me) {\n                for (var bt = Array(Me.length >> 2), zt = 0; zt < bt.length; zt++) bt[zt] = 0;\n                for (var zt = 0; zt < Me.length * 8; zt += 8) bt[zt >> 5] |= (Me.charCodeAt(zt / 8) & 255) << 24 - zt % 32;\n                return bt;\n              }\n              function At(Me) {\n                for (var bt = "", zt = 0; zt < Me.length * 32; zt += 8) bt += String.fromCharCode(Me[zt >> 5] >>> 24 - zt % 32 & 255);\n                return bt;\n              }\n              function Wt(Me, bt) {\n                return Me >>> bt | Me << 32 - bt;\n              }\n              function Cr(Me, bt) {\n                return Me >>> bt;\n              }\n              function Ar(Me, bt, zt) {\n                return Me & bt ^ ~Me & zt;\n              }\n              function Kr(Me, bt, zt) {\n                return Me & bt ^ Me & zt ^ bt & zt;\n              }\n              function ki(Me) {\n                return Wt(Me, 2) ^ Wt(Me, 13) ^ Wt(Me, 22);\n              }\n              function Xi(Me) {\n                return Wt(Me, 6) ^ Wt(Me, 11) ^ Wt(Me, 25);\n              }\n              function dn(Me) {\n                return Wt(Me, 7) ^ Wt(Me, 18) ^ Cr(Me, 3);\n              }\n              function wn(Me) {\n                return Wt(Me, 17) ^ Wt(Me, 19) ^ Cr(Me, 10);\n              }\n              var Nn = new Array(1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998);\n              function Yi(Me, bt) {\n                var zt = new Array(1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225), Rr = new Array(64), jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr;\n                for (Me[bt >> 5] |= 128 << 24 - bt % 32, Me[(bt + 64 >> 9 << 4) + 15] = bt, en = 0; en < Me.length; en += 16) {\n                  for (jr = zt[0], Nr = zt[1], Gr = zt[2], mi = zt[3], Ui = zt[4], qi = zt[5], Ei = zt[6], Hn = zt[7], Wi = 0; Wi < 64; Wi++) Wi < 16 ? Rr[Wi] = Me[Wi + en] : Rr[Wi] = Qi(Qi(Qi(wn(Rr[Wi - 2]), Rr[Wi - 7]), dn(Rr[Wi - 15])), Rr[Wi - 16]), si = Qi(Qi(Qi(Qi(Hn, Xi(Ui)), Ar(Ui, qi, Ei)), Nn[Wi]), Rr[Wi]), Mr = Qi(ki(jr), Kr(jr, Nr, Gr)), Hn = Ei, Ei = qi, qi = Ui, Ui = Qi(mi, si), mi = Gr, Gr = Nr, Nr = jr, jr = Qi(si, Mr);\n                  zt[0] = Qi(jr, zt[0]), zt[1] = Qi(Nr, zt[1]), zt[2] = Qi(Gr, zt[2]), zt[3] = Qi(mi, zt[3]), zt[4] = Qi(Ui, zt[4]), zt[5] = Qi(qi, zt[5]), zt[6] = Qi(Ei, zt[6]), zt[7] = Qi(Hn, zt[7]);\n                }\n                return zt;\n              }\n              function Qi(Me, bt) {\n                var zt = (Me & 65535) + (bt & 65535), Rr = (Me >> 16) + (bt >> 16) + (zt >> 16);\n                return Rr << 16 | zt & 65535;\n              }\n              function on(Me) {\n                return Array.prototype.slice.call(Me);\n              }\n              function Fi(Me) {\n                return on(Me).join("");\n              }\n              function $n(Me) {\n                var bt = Me && Me.cache, zt = 0, Rr = [], jr = [], Nr = [];\n                function Gr(si, Mr) {\n                  var Yr = Mr && Mr.stable;\n                  if (!Yr) {\n                    for (var xi = 0; xi < jr.length; ++xi) if (jr[xi] === si && !Nr[xi]) return Rr[xi];\n                  }\n                  var Ri = "g" + zt++;\n                  return Rr.push(Ri), jr.push(si), Nr.push(Yr), Ri;\n                }\n                function mi() {\n                  var si = [];\n                  function Mr() {\n                    si.push.apply(si, on(arguments));\n                  }\n                  var Yr = [];\n                  function xi() {\n                    var Ri = "v" + zt++;\n                    return Yr.push(Ri), arguments.length > 0 && (si.push(Ri, "="), si.push.apply(si, on(arguments)), si.push(";")), Ri;\n                  }\n                  return e3(Mr, { def: xi, toString: function() {\n                    return Fi([Yr.length > 0 ? "var " + Yr.join(",") + ";" : "", Fi(si)]);\n                  } });\n                }\n                function Ui() {\n                  var si = mi(), Mr = mi(), Yr = si.toString, xi = Mr.toString;\n                  function Ri(ci, an) {\n                    Mr(ci, an, "=", si.def(ci, an), ";");\n                  }\n                  return e3(function() {\n                    si.apply(si, on(arguments));\n                  }, { def: si.def, entry: si, exit: Mr, save: Ri, set: function(ci, an, Zi) {\n                    Ri(ci, an), si(ci, an, "=", Zi, ";");\n                  }, toString: function() {\n                    return Yr() + xi();\n                  } });\n                }\n                function qi() {\n                  var si = Fi(arguments), Mr = Ui(), Yr = Ui(), xi = Mr.toString, Ri = Yr.toString;\n                  return e3(Mr, { then: function() {\n                    return Mr.apply(Mr, on(arguments)), this;\n                  }, else: function() {\n                    return Yr.apply(Yr, on(arguments)), this;\n                  }, toString: function() {\n                    var ci = Ri();\n                    return ci && (ci = "else{" + ci + "}"), Fi(["if(", si, "){", xi(), "}", ci]);\n                  } });\n                }\n                var Ei = mi(), Hn = {};\n                function en(si, Mr) {\n                  var Yr = [];\n                  function xi() {\n                    var Bn = "a" + Yr.length;\n                    return Yr.push(Bn), Bn;\n                  }\n                  Mr = Mr || 0;\n                  for (var Ri = 0; Ri < Mr; ++Ri) xi();\n                  var ci = Ui(), an = ci.toString, Zi = Hn[si] = e3(ci, { arg: xi, toString: function() {\n                    return Fi(["function(", Yr.join(), "){", an(), "}"]);\n                  } });\n                  return Zi;\n                }\n                function Wi() {\n                  var si = [\'"use strict";\', Ei, "return {"];\n                  Object.keys(Hn).forEach(function(Ri) {\n                    si.push(\'"\', Ri, \'":\', Hn[Ri].toString(), ",");\n                  }), si.push("}");\n                  var Mr = Fi(si).replace(/;/g, `;\n`).replace(/}/g, `}\n`).replace(/{/g, `{\n`), Yr;\n                  if (bt && (Yr = Oc(Mr), bt[Yr])) return bt[Yr].apply(null, jr);\n                  var xi = Function.apply(null, Rr.concat(Mr));\n                  return bt && (bt[Yr] = xi), xi.apply(null, jr);\n                }\n                return { global: Ei, link: Gr, block: mi, proc: en, scope: Ui, cond: qi, compile: Wi };\n              }\n              var Ca = "xyzw".split(""), Ra = 5121, La = 1, Na = 2, Yn = 0, Dn = 1, Ka = 2, bo = 3, Xo = 4, Ss = 5, as = 6, ws = "dither", Ho = "blend.enable", ml = "blend.color", Ws = "blend.equation", Ls = "blend.func", va = "depth.enable", no = "depth.func", ys = "depth.range", rs = "depth.mask", $l = "colorMask", Cu = "cull.enable", Yu = "cull.face", Nc = "frontFace", pu = "lineWidth", Uc = "polygonOffset.enable", xu = "polygonOffset.offset", Ac = "sample.alpha", Ua = "sample.enable", oo = "sample.coverage", Vc = "stencil.enable", hc = "stencil.mask", Ku = "stencil.func", ue = "stencil.opFront", w4 = "stencil.opBack", B4 = "scissor.enable", Q = "scissor.box", ee = "viewport", le = "profile", qe = "framebuffer", Xe = "vert", ot = "frag", Tt = "elements", Yt = "primitive", Kt = "count", xr = "offset", Ir = "instances", ve = "vao", be = "Width", De = "Height", Be = qe + be, et = qe + De, We = ee + be, it = ee + De, Ft = "drawingBuffer", Ht = Ft + be, tr = Ft + De, dr = [Ls, Ws, Ku, ue, w4, oo, ee, Q, xu], Sr = 34962, Or = 34963, Wr = 2884, ni = 3042, Pi = 3024, cn = 2960, ln = 2929, Cn = 3089, Kn = 32823, Ta = 32926, fa = 32928, $a = 5126, Co = 35664, Qa = 35665, mo = 35666, Bo = 5124, Ps = 35667, Ts = 35668, wo = 35669, To = 35670, hl = 35671, Ul = 35672, Lu = 35673, au = 35674, Js = 35675, Ql = 35676, dc = 35678, Tl = 35680, Al = 4, X = 1028, se = 1029, Te = 2304, Ne = 2305, He = 32775, Ye = 32776, kt = 519, nt = 7680, jt = 0, gr = 1, yr = 32774, Hr = 513, qr = 36160, _i = 36064, bi = { 0: 0, 1: 1, zero: 0, one: 1, "src color": 768, "one minus src color": 769, "src alpha": 770, "one minus src alpha": 771, "dst color": 774, "one minus dst color": 775, "dst alpha": 772, "one minus dst alpha": 773, "constant color": 32769, "one minus constant color": 32770, "constant alpha": 32771, "one minus constant alpha": 32772, "src alpha saturate": 776 }, Zr = { never: 512, less: 513, "<": 513, equal: 514, "=": 514, "==": 514, "===": 514, lequal: 515, "<=": 515, greater: 516, ">": 516, notequal: 517, "!=": 517, "!==": 517, gequal: 518, ">=": 518, always: 519 }, ai = { 0: 0, zero: 0, keep: 7680, replace: 7681, increment: 7682, decrement: 7683, "increment wrap": 34055, "decrement wrap": 34056, invert: 5386 }, gi = { cw: Te, ccw: Ne };\n              function Ii(Me) {\n                return Array.isArray(Me) || Br(Me) || Vr(Me);\n              }\n              function Si(Me) {\n                return Me.sort(function(bt, zt) {\n                  return bt === ee ? -1 : zt === ee ? 1 : bt < zt ? -1 : 1;\n                });\n              }\n              function ei(Me, bt, zt, Rr) {\n                this.thisDep = Me, this.contextDep = bt, this.propDep = zt, this.append = Rr;\n              }\n              function Ln(Me) {\n                return Me && !(Me.thisDep || Me.contextDep || Me.propDep);\n              }\n              function En(Me) {\n                return new ei(false, false, false, Me);\n              }\n              function Un(Me, bt) {\n                var zt = Me.type;\n                if (zt === Yn) {\n                  var Rr = Me.data.length;\n                  return new ei(true, Rr >= 1, Rr >= 2, bt);\n                } else if (zt === Xo) {\n                  var jr = Me.data;\n                  return new ei(jr.thisDep, jr.contextDep, jr.propDep, bt);\n                } else {\n                  if (zt === Ss) return new ei(false, false, false, bt);\n                  if (zt === as) {\n                    for (var Nr = false, Gr = false, mi = false, Ui = 0; Ui < Me.data.length; ++Ui) {\n                      var qi = Me.data[Ui];\n                      if (qi.type === Dn) mi = true;\n                      else if (qi.type === Ka) Gr = true;\n                      else if (qi.type === bo) Nr = true;\n                      else if (qi.type === Yn) {\n                        Nr = true;\n                        var Ei = qi.data;\n                        Ei >= 1 && (Gr = true), Ei >= 2 && (mi = true);\n                      } else qi.type === Xo && (Nr = Nr || qi.data.thisDep, Gr = Gr || qi.data.contextDep, mi = mi || qi.data.propDep);\n                    }\n                    return new ei(Nr, Gr, mi, bt);\n                  } else return new ei(zt === bo, zt === Ka, zt === Dn, bt);\n                }\n              }\n              var ia = new ei(false, false, false, function() {\n              });\n              function Ea(Me, bt, zt, Rr, jr, Nr, Gr, mi, Ui, qi, Ei, Hn, en, Wi, si, Mr) {\n                var Yr = qi.Record, xi = { add: 32774, subtract: 32778, "reverse subtract": 32779 };\n                zt.ext_blend_minmax && (xi.min = He, xi.max = Ye);\n                var Ri = zt.angle_instanced_arrays, ci = zt.webgl_draw_buffers, an = zt.oes_vertex_array_object, Zi = { dirty: true, profile: Mr.profile }, Bn = {}, hi = [], li = {}, mn = {};\n                function Ji(Ve) {\n                  return Ve.replace(".", "_");\n                }\n                function Vi(Ve, Qe, at) {\n                  var Ct = Ji(Ve);\n                  hi.push(Ve), Bn[Ct] = Zi[Ct] = !!at, li[Ct] = Qe;\n                }\n                function Ni(Ve, Qe, at) {\n                  var Ct = Ji(Ve);\n                  hi.push(Ve), Array.isArray(at) ? (Zi[Ct] = at.slice(), Bn[Ct] = at.slice()) : Zi[Ct] = Bn[Ct] = at, mn[Ct] = Qe;\n                }\n                function pn(Ve) {\n                  return !!isNaN(Ve);\n                }\n                Vi(ws, Pi), Vi(Ho, ni), Ni(ml, "blendColor", [0, 0, 0, 0]), Ni(Ws, "blendEquationSeparate", [yr, yr]), Ni(Ls, "blendFuncSeparate", [gr, jt, gr, jt]), Vi(va, ln, true), Ni(no, "depthFunc", Hr), Ni(ys, "depthRange", [0, 1]), Ni(rs, "depthMask", true), Ni($l, $l, [true, true, true, true]), Vi(Cu, Wr), Ni(Yu, "cullFace", se), Ni(Nc, Nc, Ne), Ni(pu, pu, 1), Vi(Uc, Kn), Ni(xu, "polygonOffset", [0, 0]), Vi(Ac, Ta), Vi(Ua, fa), Ni(oo, "sampleCoverage", [1, false]), Vi(Vc, cn), Ni(hc, "stencilMask", -1), Ni(Ku, "stencilFunc", [kt, 0, -1]), Ni(ue, "stencilOpSeparate", [X, nt, nt, nt]), Ni(w4, "stencilOpSeparate", [se, nt, nt, nt]), Vi(B4, Cn), Ni(Q, "scissor", [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]), Ni(ee, ee, [0, 0, Me.drawingBufferWidth, Me.drawingBufferHeight]);\n                var Vn = { gl: Me, context: en, strings: bt, next: Bn, current: Zi, draw: Hn, elements: Nr, buffer: jr, shader: Ei, attributes: qi.state, vao: qi, uniforms: Ui, framebuffer: mi, extensions: zt, timer: Wi, isBufferArgs: Ii }, na = { primTypes: Sn, compareFuncs: Zr, blendFuncs: bi, blendEquations: xi, stencilOps: ai, glTypes: ji, orientationType: gi };\n                ci && (na.backBuffer = [se], na.drawBuffer = M4(Rr.maxDrawbuffers, function(Ve) {\n                  return Ve === 0 ? [0] : M4(Ve, function(Qe) {\n                    return _i + Qe;\n                  });\n                }));\n                var Ki = 0;\n                function kn() {\n                  var Ve = $n({ cache: si }), Qe = Ve.link, at = Ve.global;\n                  Ve.id = Ki++, Ve.batchId = "0";\n                  var Ct = Qe(Vn), Ot = Ve.shared = { props: "a0" };\n                  Object.keys(Vn).forEach(function(Pt) {\n                    Ot[Pt] = at.def(Ct, ".", Pt);\n                  });\n                  var Rt = Ve.next = {}, Bt = Ve.current = {};\n                  Object.keys(mn).forEach(function(Pt) {\n                    Array.isArray(Zi[Pt]) && (Rt[Pt] = at.def(Ot.next, ".", Pt), Bt[Pt] = at.def(Ot.current, ".", Pt));\n                  });\n                  var Dt = Ve.constants = {};\n                  Object.keys(na).forEach(function(Pt) {\n                    Dt[Pt] = at.def(JSON.stringify(na[Pt]));\n                  }), Ve.invoke = function(Pt, ht) {\n                    switch (ht.type) {\n                      case Yn:\n                        var ur = ["this", Ot.context, Ot.props, Ve.batchId];\n                        return Pt.def(Qe(ht.data), ".call(", ur.slice(0, Math.max(ht.data.length + 1, 4)), ")");\n                      case Dn:\n                        return Pt.def(Ot.props, ht.data);\n                      case Ka:\n                        return Pt.def(Ot.context, ht.data);\n                      case bo:\n                        return Pt.def("this", ht.data);\n                      case Xo:\n                        return ht.data.append(Ve, Pt), ht.data.ref;\n                      case Ss:\n                        return ht.data.toString();\n                      case as:\n                        return ht.data.map(function(br) {\n                          return Ve.invoke(Pt, br);\n                        });\n                    }\n                  }, Ve.attribCache = {};\n                  var yt = {};\n                  return Ve.scopeAttrib = function(Pt) {\n                    var ht = bt.id(Pt);\n                    if (ht in yt) return yt[ht];\n                    var ur = qi.scope[ht];\n                    ur || (ur = qi.scope[ht] = new Yr());\n                    var br = yt[ht] = Qe(ur);\n                    return br;\n                  }, Ve;\n                }\n                function ta(Ve) {\n                  var Qe = Ve.static, at = Ve.dynamic, Ct;\n                  if (le in Qe) {\n                    var Ot = !!Qe[le];\n                    Ct = En(function(Bt, Dt) {\n                      return Ot;\n                    }), Ct.enable = Ot;\n                  } else if (le in at) {\n                    var Rt = at[le];\n                    Ct = Un(Rt, function(Bt, Dt) {\n                      return Bt.invoke(Dt, Rt);\n                    });\n                  }\n                  return Ct;\n                }\n                function oa(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic;\n                  if (qe in at) {\n                    var Ot = at[qe];\n                    return Ot ? (Ot = mi.getFramebuffer(Ot), En(function(Bt, Dt) {\n                      var yt = Bt.link(Ot), Pt = Bt.shared;\n                      Dt.set(Pt.framebuffer, ".next", yt);\n                      var ht = Pt.context;\n                      return Dt.set(ht, "." + Be, yt + ".width"), Dt.set(ht, "." + et, yt + ".height"), yt;\n                    })) : En(function(Bt, Dt) {\n                      var yt = Bt.shared;\n                      Dt.set(yt.framebuffer, ".next", "null");\n                      var Pt = yt.context;\n                      return Dt.set(Pt, "." + Be, Pt + "." + Ht), Dt.set(Pt, "." + et, Pt + "." + tr), "null";\n                    });\n                  } else if (qe in Ct) {\n                    var Rt = Ct[qe];\n                    return Un(Rt, function(Bt, Dt) {\n                      var yt = Bt.invoke(Dt, Rt), Pt = Bt.shared, ht = Pt.framebuffer, ur = Dt.def(ht, ".getFramebuffer(", yt, ")");\n                      Dt.set(ht, ".next", ur);\n                      var br = Pt.context;\n                      return Dt.set(br, "." + Be, ur + "?" + ur + ".width:" + br + "." + Ht), Dt.set(br, "." + et, ur + "?" + ur + ".height:" + br + "." + tr), ur;\n                    });\n                  } else return null;\n                }\n                function ba(Ve, Qe, at) {\n                  var Ct = Ve.static, Ot = Ve.dynamic;\n                  function Rt(yt) {\n                    if (yt in Ct) {\n                      var Pt = Ct[yt], ht = true, ur = Pt.x | 0, br = Pt.y | 0, Ur, Di;\n                      return "width" in Pt ? Ur = Pt.width | 0 : ht = false, "height" in Pt ? Di = Pt.height | 0 : ht = false, new ei(!ht && Qe && Qe.thisDep, !ht && Qe && Qe.contextDep, !ht && Qe && Qe.propDep, function(gn, rn) {\n                        var Ci = gn.shared.context, Bi = Ur;\n                        "width" in Pt || (Bi = rn.def(Ci, ".", Be, "-", ur));\n                        var Gi = Di;\n                        return "height" in Pt || (Gi = rn.def(Ci, ".", et, "-", br)), [ur, br, Bi, Gi];\n                      });\n                    } else if (yt in Ot) {\n                      var fi = Ot[yt], Ti = Un(fi, function(gn, rn) {\n                        var Ci = gn.invoke(rn, fi), Bi = gn.shared.context, Gi = rn.def(Ci, ".x|0"), sn = rn.def(Ci, ".y|0"), zn = rn.def(\'"width" in \', Ci, "?", Ci, ".width|0:", "(", Bi, ".", Be, "-", Gi, ")"), Ja = rn.def(\'"height" in \', Ci, "?", Ci, ".height|0:", "(", Bi, ".", et, "-", sn, ")");\n                        return [Gi, sn, zn, Ja];\n                      });\n                      return Qe && (Ti.thisDep = Ti.thisDep || Qe.thisDep, Ti.contextDep = Ti.contextDep || Qe.contextDep, Ti.propDep = Ti.propDep || Qe.propDep), Ti;\n                    } else return Qe ? new ei(Qe.thisDep, Qe.contextDep, Qe.propDep, function(gn, rn) {\n                      var Ci = gn.shared.context;\n                      return [0, 0, rn.def(Ci, ".", Be), rn.def(Ci, ".", et)];\n                    }) : null;\n                  }\n                  var Bt = Rt(ee);\n                  if (Bt) {\n                    var Dt = Bt;\n                    Bt = new ei(Bt.thisDep, Bt.contextDep, Bt.propDep, function(yt, Pt) {\n                      var ht = Dt.append(yt, Pt), ur = yt.shared.context;\n                      return Pt.set(ur, "." + We, ht[2]), Pt.set(ur, "." + it, ht[3]), ht;\n                    });\n                  }\n                  return { viewport: Bt, scissor_box: Rt(Q) };\n                }\n                function is(Ve, Qe) {\n                  var at = Ve.static, Ct = typeof at[ot] == "string" && typeof at[Xe] == "string";\n                  if (Ct) {\n                    if (Object.keys(Qe.dynamic).length > 0) return null;\n                    var Ot = Qe.static, Rt = Object.keys(Ot);\n                    if (Rt.length > 0 && typeof Ot[Rt[0]] == "number") {\n                      for (var Bt = [], Dt = 0; Dt < Rt.length; ++Dt) Bt.push([Ot[Rt[Dt]] | 0, Rt[Dt]]);\n                      return Bt;\n                    }\n                  }\n                  return null;\n                }\n                function Zs(Ve, Qe, at) {\n                  var Ct = Ve.static, Ot = Ve.dynamic;\n                  function Rt(ht) {\n                    if (ht in Ct) {\n                      var ur = bt.id(Ct[ht]), br = En(function() {\n                        return ur;\n                      });\n                      return br.id = ur, br;\n                    } else if (ht in Ot) {\n                      var Ur = Ot[ht];\n                      return Un(Ur, function(Di, fi) {\n                        var Ti = Di.invoke(fi, Ur), gn = fi.def(Di.shared.strings, ".id(", Ti, ")");\n                        return gn;\n                      });\n                    }\n                    return null;\n                  }\n                  var Bt = Rt(ot), Dt = Rt(Xe), yt = null, Pt;\n                  return Ln(Bt) && Ln(Dt) ? (yt = Ei.program(Dt.id, Bt.id, null, at), Pt = En(function(ht, ur) {\n                    return ht.link(yt);\n                  })) : Pt = new ei(Bt && Bt.thisDep || Dt && Dt.thisDep, Bt && Bt.contextDep || Dt && Dt.contextDep, Bt && Bt.propDep || Dt && Dt.propDep, function(ht, ur) {\n                    var br = ht.shared.shader, Ur;\n                    Bt ? Ur = Bt.append(ht, ur) : Ur = ur.def(br, ".", ot);\n                    var Di;\n                    Dt ? Di = Dt.append(ht, ur) : Di = ur.def(br, ".", Xe);\n                    var fi = br + ".program(" + Di + "," + Ur;\n                    return ur.def(fi + ")");\n                  }), { frag: Bt, vert: Dt, progVar: Pt, program: yt };\n                }\n                function Va(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {}, Rt = false;\n                  function Bt() {\n                    if (ve in at) {\n                      var rn = at[ve];\n                      return rn !== null && qi.getVAO(rn) === null && (rn = qi.createVAO(rn)), Rt = true, Ot.vao = rn, En(function(Bi) {\n                        var Gi = qi.getVAO(rn);\n                        return Gi ? Bi.link(Gi) : "null";\n                      });\n                    } else if (ve in Ct) {\n                      Rt = true;\n                      var Ci = Ct[ve];\n                      return Un(Ci, function(Bi, Gi) {\n                        var sn = Bi.invoke(Gi, Ci);\n                        return Gi.def(Bi.shared.vao + ".getVAO(" + sn + ")");\n                      });\n                    }\n                    return null;\n                  }\n                  var Dt = Bt(), yt = false;\n                  function Pt() {\n                    if (Tt in at) {\n                      var rn = at[Tt];\n                      if (Ot.elements = rn, Ii(rn)) {\n                        var Ci = Ot.elements = Nr.create(rn, true);\n                        rn = Nr.getElements(Ci), yt = true;\n                      } else rn && (rn = Nr.getElements(rn), yt = true);\n                      var Bi = En(function(sn, zn) {\n                        if (rn) {\n                          var Ja = sn.link(rn);\n                          return sn.ELEMENTS = Ja, Ja;\n                        }\n                        return sn.ELEMENTS = null, null;\n                      });\n                      return Bi.value = rn, Bi;\n                    } else if (Tt in Ct) {\n                      yt = true;\n                      var Gi = Ct[Tt];\n                      return Un(Gi, function(sn, zn) {\n                        var Ja = sn.shared, co = Ja.isBufferArgs, ts = Ja.elements, so = sn.invoke(zn, Gi), Zo = zn.def("null"), ms = zn.def(co, "(", so, ")"), ou = sn.cond(ms).then(Zo, "=", ts, ".createStream(", so, ");").else(Zo, "=", ts, ".getElements(", so, ");");\n                        return zn.entry(ou), zn.exit(sn.cond(ms).then(ts, ".destroyStream(", Zo, ");")), sn.ELEMENTS = Zo, Zo;\n                      });\n                    } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                      return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.elements + ".getElements(" + sn.shared.vao + ".currentVAO.elements):null");\n                    });\n                    return null;\n                  }\n                  var ht = Pt();\n                  function ur() {\n                    if (Yt in at) {\n                      var rn = at[Yt];\n                      return Ot.primitive = rn, En(function(Bi, Gi) {\n                        return Sn[rn];\n                      });\n                    } else if (Yt in Ct) {\n                      var Ci = Ct[Yt];\n                      return Un(Ci, function(Bi, Gi) {\n                        var sn = Bi.constants.primTypes, zn = Bi.invoke(Gi, Ci);\n                        return Gi.def(sn, "[", zn, "]");\n                      });\n                    } else {\n                      if (yt) return Ln(ht) ? ht.value ? En(function(Bi, Gi) {\n                        return Gi.def(Bi.ELEMENTS, ".primType");\n                      }) : En(function() {\n                        return Al;\n                      }) : new ei(ht.thisDep, ht.contextDep, ht.propDep, function(Bi, Gi) {\n                        var sn = Bi.ELEMENTS;\n                        return Gi.def(sn, "?", sn, ".primType:", Al);\n                      });\n                      if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(Bi, Gi) {\n                        return Gi.def(Bi.shared.vao + ".currentVAO?" + Bi.shared.vao + ".currentVAO.primitive:" + Al);\n                      });\n                    }\n                    return null;\n                  }\n                  function br(rn, Ci) {\n                    if (rn in at) {\n                      var Bi = at[rn] | 0;\n                      return Ci ? Ot.offset = Bi : Ot.instances = Bi, En(function(sn, zn) {\n                        return Ci && (sn.OFFSET = Bi), Bi;\n                      });\n                    } else if (rn in Ct) {\n                      var Gi = Ct[rn];\n                      return Un(Gi, function(sn, zn) {\n                        var Ja = sn.invoke(zn, Gi);\n                        return Ci && (sn.OFFSET = Ja), Ja;\n                      });\n                    } else if (Ci) {\n                      if (yt) return En(function(sn, zn) {\n                        return sn.OFFSET = 0, 0;\n                      });\n                      if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                        return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.offset:0");\n                      });\n                    } else if (Rt) return new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(sn, zn) {\n                      return zn.def(sn.shared.vao + ".currentVAO?" + sn.shared.vao + ".currentVAO.instances:-1");\n                    });\n                    return null;\n                  }\n                  var Ur = br(xr, true);\n                  function Di() {\n                    if (Kt in at) {\n                      var rn = at[Kt] | 0;\n                      return Ot.count = rn, En(function() {\n                        return rn;\n                      });\n                    } else if (Kt in Ct) {\n                      var Ci = Ct[Kt];\n                      return Un(Ci, function(zn, Ja) {\n                        var co = zn.invoke(Ja, Ci);\n                        return co;\n                      });\n                    } else if (yt) if (Ln(ht)) {\n                      if (ht) return Ur ? new ei(Ur.thisDep, Ur.contextDep, Ur.propDep, function(zn, Ja) {\n                        var co = Ja.def(zn.ELEMENTS, ".vertCount-", zn.OFFSET);\n                        return co;\n                      }) : En(function(zn, Ja) {\n                        return Ja.def(zn.ELEMENTS, ".vertCount");\n                      });\n                      var Bi = En(function() {\n                        return -1;\n                      });\n                      return Bi;\n                    } else {\n                      var Gi = new ei(ht.thisDep || Ur.thisDep, ht.contextDep || Ur.contextDep, ht.propDep || Ur.propDep, function(zn, Ja) {\n                        var co = zn.ELEMENTS;\n                        return zn.OFFSET ? Ja.def(co, "?", co, ".vertCount-", zn.OFFSET, ":-1") : Ja.def(co, "?", co, ".vertCount:-1");\n                      });\n                      return Gi;\n                    }\n                    else if (Rt) {\n                      var sn = new ei(Dt.thisDep, Dt.contextDep, Dt.propDep, function(zn, Ja) {\n                        return Ja.def(zn.shared.vao, ".currentVAO?", zn.shared.vao, ".currentVAO.count:-1");\n                      });\n                      return sn;\n                    }\n                    return null;\n                  }\n                  var fi = ur(), Ti = Di(), gn = br(Ir, false);\n                  return { elements: ht, primitive: fi, count: Ti, instances: gn, offset: Ur, vao: Dt, vaoActive: Rt, elementsActive: yt, static: Ot };\n                }\n                function Ml(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return hi.forEach(function(Rt) {\n                    var Bt = Ji(Rt);\n                    function Dt(yt, Pt) {\n                      if (Rt in at) {\n                        var ht = yt(at[Rt]);\n                        Ot[Bt] = En(function() {\n                          return ht;\n                        });\n                      } else if (Rt in Ct) {\n                        var ur = Ct[Rt];\n                        Ot[Bt] = Un(ur, function(br, Ur) {\n                          return Pt(br, Ur, br.invoke(Ur, ur));\n                        });\n                      }\n                    }\n                    switch (Rt) {\n                      case Cu:\n                      case Ho:\n                      case ws:\n                      case Vc:\n                      case va:\n                      case B4:\n                      case Uc:\n                      case Ac:\n                      case Ua:\n                      case rs:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          return ht;\n                        });\n                      case no:\n                        return Dt(function(yt) {\n                          return Zr[yt];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.compareFuncs;\n                          return Pt.def(ur, "[", ht, "]");\n                        });\n                      case ys:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def("+", ht, "[0]"), br = Pt.def("+", ht, "[1]");\n                          return [ur, br];\n                        });\n                      case Ls:\n                        return Dt(function(yt) {\n                          var Pt = "srcRGB" in yt ? yt.srcRGB : yt.src, ht = "srcAlpha" in yt ? yt.srcAlpha : yt.src, ur = "dstRGB" in yt ? yt.dstRGB : yt.dst, br = "dstAlpha" in yt ? yt.dstAlpha : yt.dst;\n                          return [bi[Pt], bi[ur], bi[ht], bi[br]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.blendFuncs;\n                          function br(Ci, Bi) {\n                            var Gi = Pt.def(\'"\', Ci, Bi, \'" in \', ht, "?", ht, ".", Ci, Bi, ":", ht, ".", Ci);\n                            return Gi;\n                          }\n                          var Ur = br("src", "RGB"), Di = br("dst", "RGB"), fi = Pt.def(ur, "[", Ur, "]"), Ti = Pt.def(ur, "[", br("src", "Alpha"), "]"), gn = Pt.def(ur, "[", Di, "]"), rn = Pt.def(ur, "[", br("dst", "Alpha"), "]");\n                          return [fi, gn, Ti, rn];\n                        });\n                      case Ws:\n                        return Dt(function(yt) {\n                          if (typeof yt == "string") return [xi[yt], xi[yt]];\n                          if (typeof yt == "object") return [xi[yt.rgb], xi[yt.alpha]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.blendEquations, br = Pt.def(), Ur = Pt.def(), Di = yt.cond("typeof ", ht, \'==="string"\');\n                          return Di.then(br, "=", Ur, "=", ur, "[", ht, "];"), Di.else(br, "=", ur, "[", ht, ".rgb];", Ur, "=", ur, "[", ht, ".alpha];"), Pt(Di), [br, Ur];\n                        });\n                      case ml:\n                        return Dt(function(yt) {\n                          return M4(4, function(Pt) {\n                            return +yt[Pt];\n                          });\n                        }, function(yt, Pt, ht) {\n                          return M4(4, function(ur) {\n                            return Pt.def("+", ht, "[", ur, "]");\n                          });\n                        });\n                      case hc:\n                        return Dt(function(yt) {\n                          return yt | 0;\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht, "|0");\n                        });\n                      case Ku:\n                        return Dt(function(yt) {\n                          var Pt = yt.cmp || "keep", ht = yt.ref || 0, ur = "mask" in yt ? yt.mask : -1;\n                          return [Zr[Pt], ht, ur];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.compareFuncs, br = Pt.def(\'"cmp" in \', ht, "?", ur, "[", ht, ".cmp]", ":", nt), Ur = Pt.def(ht, ".ref|0"), Di = Pt.def(\'"mask" in \', ht, "?", ht, ".mask|0:-1");\n                          return [br, Ur, Di];\n                        });\n                      case ue:\n                      case w4:\n                        return Dt(function(yt) {\n                          var Pt = yt.fail || "keep", ht = yt.zfail || "keep", ur = yt.zpass || "keep";\n                          return [Rt === w4 ? se : X, ai[Pt], ai[ht], ai[ur]];\n                        }, function(yt, Pt, ht) {\n                          var ur = yt.constants.stencilOps;\n                          function br(Ur) {\n                            return Pt.def(\'"\', Ur, \'" in \', ht, "?", ur, "[", ht, ".", Ur, "]:", nt);\n                          }\n                          return [Rt === w4 ? se : X, br("fail"), br("zfail"), br("zpass")];\n                        });\n                      case xu:\n                        return Dt(function(yt) {\n                          var Pt = yt.factor | 0, ht = yt.units | 0;\n                          return [Pt, ht];\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def(ht, ".factor|0"), br = Pt.def(ht, ".units|0");\n                          return [ur, br];\n                        });\n                      case Yu:\n                        return Dt(function(yt) {\n                          var Pt = 0;\n                          return yt === "front" ? Pt = X : yt === "back" && (Pt = se), Pt;\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht, \'==="front"?\', X, ":", se);\n                        });\n                      case pu:\n                        return Dt(function(yt) {\n                          return yt;\n                        }, function(yt, Pt, ht) {\n                          return ht;\n                        });\n                      case Nc:\n                        return Dt(function(yt) {\n                          return gi[yt];\n                        }, function(yt, Pt, ht) {\n                          return Pt.def(ht + \'==="cw"?\' + Te + ":" + Ne);\n                        });\n                      case $l:\n                        return Dt(function(yt) {\n                          return yt.map(function(Pt) {\n                            return !!Pt;\n                          });\n                        }, function(yt, Pt, ht) {\n                          return M4(4, function(ur) {\n                            return "!!" + ht + "[" + ur + "]";\n                          });\n                        });\n                      case oo:\n                        return Dt(function(yt) {\n                          var Pt = "value" in yt ? yt.value : 1, ht = !!yt.invert;\n                          return [Pt, ht];\n                        }, function(yt, Pt, ht) {\n                          var ur = Pt.def(\'"value" in \', ht, "?+", ht, ".value:1"), br = Pt.def("!!", ht, ".invert");\n                          return [ur, br];\n                        });\n                    }\n                  }), Ot;\n                }\n                function zo(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return Object.keys(at).forEach(function(Rt) {\n                    var Bt = at[Rt], Dt;\n                    if (typeof Bt == "number" || typeof Bt == "boolean") Dt = En(function() {\n                      return Bt;\n                    });\n                    else if (typeof Bt == "function") {\n                      var yt = Bt._reglType;\n                      yt === "texture2d" || yt === "textureCube" ? Dt = En(function(Pt) {\n                        return Pt.link(Bt);\n                      }) : (yt === "framebuffer" || yt === "framebufferCube") && (Dt = En(function(Pt) {\n                        return Pt.link(Bt.color[0]);\n                      }));\n                    } else Mn(Bt) && (Dt = En(function(Pt) {\n                      var ht = Pt.global.def("[", M4(Bt.length, function(ur) {\n                        return Bt[ur];\n                      }), "]");\n                      return ht;\n                    }));\n                    Dt.value = Bt, Ot[Rt] = Dt;\n                  }), Object.keys(Ct).forEach(function(Rt) {\n                    var Bt = Ct[Rt];\n                    Ot[Rt] = Un(Bt, function(Dt, yt) {\n                      return Dt.invoke(yt, Bt);\n                    });\n                  }), Ot;\n                }\n                function Qs(Ve, Qe) {\n                  var at = Ve.static, Ct = Ve.dynamic, Ot = {};\n                  return Object.keys(at).forEach(function(Rt) {\n                    var Bt = at[Rt], Dt = bt.id(Rt), yt = new Yr();\n                    if (Ii(Bt)) yt.state = La, yt.buffer = jr.getBuffer(jr.create(Bt, Sr, false, true)), yt.type = 0;\n                    else {\n                      var Pt = jr.getBuffer(Bt);\n                      if (Pt) yt.state = La, yt.buffer = Pt, yt.type = 0;\n                      else if ("constant" in Bt) {\n                        var ht = Bt.constant;\n                        yt.buffer = "null", yt.state = Na, typeof ht == "number" ? yt.x = ht : Ca.forEach(function(gn, rn) {\n                          rn < ht.length && (yt[gn] = ht[rn]);\n                        });\n                      } else {\n                        Ii(Bt.buffer) ? Pt = jr.getBuffer(jr.create(Bt.buffer, Sr, false, true)) : Pt = jr.getBuffer(Bt.buffer);\n                        var ur = Bt.offset | 0, br = Bt.stride | 0, Ur = Bt.size | 0, Di = !!Bt.normalized, fi = 0;\n                        "type" in Bt && (fi = ji[Bt.type]);\n                        var Ti = Bt.divisor | 0;\n                        yt.buffer = Pt, yt.state = La, yt.size = Ur, yt.normalized = Di, yt.type = fi || Pt.dtype, yt.offset = ur, yt.stride = br, yt.divisor = Ti;\n                      }\n                    }\n                    Ot[Rt] = En(function(gn, rn) {\n                      var Ci = gn.attribCache;\n                      if (Dt in Ci) return Ci[Dt];\n                      var Bi = { isStream: false };\n                      return Object.keys(yt).forEach(function(Gi) {\n                        Bi[Gi] = yt[Gi];\n                      }), yt.buffer && (Bi.buffer = gn.link(yt.buffer), Bi.type = Bi.type || Bi.buffer + ".dtype"), Ci[Dt] = Bi, Bi;\n                    });\n                  }), Object.keys(Ct).forEach(function(Rt) {\n                    var Bt = Ct[Rt];\n                    function Dt(yt, Pt) {\n                      var ht = yt.invoke(Pt, Bt), ur = yt.shared, br = yt.constants, Ur = ur.isBufferArgs, Di = ur.buffer, fi = { isStream: Pt.def(false) }, Ti = new Yr();\n                      Ti.state = La, Object.keys(Ti).forEach(function(Bi) {\n                        fi[Bi] = Pt.def("" + Ti[Bi]);\n                      });\n                      var gn = fi.buffer, rn = fi.type;\n                      Pt("if(", Ur, "(", ht, ")){", fi.isStream, "=true;", gn, "=", Di, ".createStream(", Sr, ",", ht, ");", rn, "=", gn, ".dtype;", "}else{", gn, "=", Di, ".getBuffer(", ht, ");", "if(", gn, "){", rn, "=", gn, ".dtype;", \'}else if("constant" in \', ht, "){", fi.state, "=", Na, ";", "if(typeof " + ht + \'.constant === "number"){\', fi[Ca[0]], "=", ht, ".constant;", Ca.slice(1).map(function(Bi) {\n                        return fi[Bi];\n                      }).join("="), "=0;", "}else{", Ca.map(function(Bi, Gi) {\n                        return fi[Bi] + "=" + ht + ".constant.length>" + Gi + "?" + ht + ".constant[" + Gi + "]:0;";\n                      }).join(""), "}}else{", "if(", Ur, "(", ht, ".buffer)){", gn, "=", Di, ".createStream(", Sr, ",", ht, ".buffer);", "}else{", gn, "=", Di, ".getBuffer(", ht, ".buffer);", "}", rn, \'="type" in \', ht, "?", br.glTypes, "[", ht, ".type]:", gn, ".dtype;", fi.normalized, "=!!", ht, ".normalized;");\n                      function Ci(Bi) {\n                        Pt(fi[Bi], "=", ht, ".", Bi, "|0;");\n                      }\n                      return Ci("size"), Ci("offset"), Ci("stride"), Ci("divisor"), Pt("}}"), Pt.exit("if(", fi.isStream, "){", Di, ".destroyStream(", gn, ");", "}"), fi;\n                    }\n                    Ot[Rt] = Un(Bt, Dt);\n                  }), Ot;\n                }\n                function al(Ve) {\n                  var Qe = Ve.static, at = Ve.dynamic, Ct = {};\n                  return Object.keys(Qe).forEach(function(Ot) {\n                    var Rt = Qe[Ot];\n                    Ct[Ot] = En(function(Bt, Dt) {\n                      return typeof Rt == "number" || typeof Rt == "boolean" ? "" + Rt : Bt.link(Rt);\n                    });\n                  }), Object.keys(at).forEach(function(Ot) {\n                    var Rt = at[Ot];\n                    Ct[Ot] = Un(Rt, function(Bt, Dt) {\n                      return Bt.invoke(Dt, Rt);\n                    });\n                  }), Ct;\n                }\n                function Vl(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.static, Bt = Ve.dynamic, Dt = is(Ve, Qe), yt = oa(Ve, Ot), Pt = ba(Ve, yt, Ot), ht = Va(Ve, Ot), ur = Ml(Ve, Ot), br = Zs(Ve, Ot, Dt);\n                  function Ur(Ci) {\n                    var Bi = Pt[Ci];\n                    Bi && (ur[Ci] = Bi);\n                  }\n                  Ur(ee), Ur(Ji(Q));\n                  var Di = Object.keys(ur).length > 0, fi = { framebuffer: yt, draw: ht, shader: br, state: ur, dirty: Di, scopeVAO: null, drawVAO: null, useVAO: false, attributes: {} };\n                  if (fi.profile = ta(Ve, Ot), fi.uniforms = zo(at, Ot), fi.drawVAO = fi.scopeVAO = ht.vao, !fi.drawVAO && br.program && !Dt && zt.angle_instanced_arrays && ht.static.elements) {\n                    var Ti = true, gn = br.program.attributes.map(function(Ci) {\n                      var Bi = Qe.static[Ci];\n                      return Ti = Ti && !!Bi, Bi;\n                    });\n                    if (Ti && gn.length > 0) {\n                      var rn = qi.getVAO(qi.createVAO({ attributes: gn, elements: ht.static.elements }));\n                      fi.drawVAO = new ei(null, null, null, function(Ci, Bi) {\n                        return Ci.link(rn);\n                      }), fi.useVAO = true;\n                    }\n                  }\n                  return Dt ? fi.useVAO = true : fi.attributes = Qs(Qe, Ot), fi.context = al(Ct, Ot), fi;\n                }\n                function ss(Ve, Qe, at) {\n                  var Ct = Ve.shared, Ot = Ct.context, Rt = Ve.scope();\n                  Object.keys(at).forEach(function(Bt) {\n                    Qe.save(Ot, "." + Bt);\n                    var Dt = at[Bt], yt = Dt.append(Ve, Qe);\n                    Array.isArray(yt) ? Rt(Ot, ".", Bt, "=[", yt.join(), "];") : Rt(Ot, ".", Bt, "=", yt, ";");\n                  }), Qe(Rt);\n                }\n                function Vs(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.framebuffer, Dt;\n                  ci && (Dt = Qe.def(Ot.extensions, ".webgl_draw_buffers"));\n                  var yt = Ve.constants, Pt = yt.drawBuffer, ht = yt.backBuffer, ur;\n                  at ? ur = at.append(Ve, Qe) : ur = Qe.def(Bt, ".next"), Ct || Qe("if(", ur, "!==", Bt, ".cur){"), Qe("if(", ur, "){", Rt, ".bindFramebuffer(", qr, ",", ur, ".framebuffer);"), ci && Qe(Dt, ".drawBuffersWEBGL(", Pt, "[", ur, ".colorAttachments.length]);"), Qe("}else{", Rt, ".bindFramebuffer(", qr, ",null);"), ci && Qe(Dt, ".drawBuffersWEBGL(", ht, ");"), Qe("}", Bt, ".cur=", ur, ";"), Ct || Qe("}");\n                }\n                function Ys(Ve, Qe, at) {\n                  var Ct = Ve.shared, Ot = Ct.gl, Rt = Ve.current, Bt = Ve.next, Dt = Ct.current, yt = Ct.next, Pt = Ve.cond(Dt, ".dirty");\n                  hi.forEach(function(ht) {\n                    var ur = Ji(ht);\n                    if (!(ur in at.state)) {\n                      var br, Ur;\n                      if (ur in Bt) {\n                        br = Bt[ur], Ur = Rt[ur];\n                        var Di = M4(Zi[ur].length, function(Ti) {\n                          return Pt.def(br, "[", Ti, "]");\n                        });\n                        Pt(Ve.cond(Di.map(function(Ti, gn) {\n                          return Ti + "!==" + Ur + "[" + gn + "]";\n                        }).join("||")).then(Ot, ".", mn[ur], "(", Di, ");", Di.map(function(Ti, gn) {\n                          return Ur + "[" + gn + "]=" + Ti;\n                        }).join(";"), ";"));\n                      } else {\n                        br = Pt.def(yt, ".", ur);\n                        var fi = Ve.cond(br, "!==", Dt, ".", ur);\n                        Pt(fi), ur in li ? fi(Ve.cond(br).then(Ot, ".enable(", li[ur], ");").else(Ot, ".disable(", li[ur], ");"), Dt, ".", ur, "=", br, ";") : fi(Ot, ".", mn[ur], "(", br, ");", Dt, ".", ur, "=", br, ";");\n                      }\n                    }\n                  }), Object.keys(at.state).length === 0 && Pt(Dt, ".dirty=false;"), Qe(Pt);\n                }\n                function wa(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ve.current, Bt = Ot.current, Dt = Ot.gl, yt;\n                  Si(Object.keys(at)).forEach(function(Pt) {\n                    var ht = at[Pt];\n                    if (!(Ct && !Ct(ht))) {\n                      var ur = ht.append(Ve, Qe);\n                      if (li[Pt]) {\n                        var br = li[Pt];\n                        Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Ve.cond(yt).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", yt, ";")) : (Qe(Ve.cond(ur).then(Dt, ".enable(", br, ");").else(Dt, ".disable(", br, ");")), Qe(Bt, ".", Pt, "=", ur, ";"));\n                      } else if (Mn(ur)) {\n                        var Ur = Rt[Pt];\n                        Qe(Dt, ".", mn[Pt], "(", ur, ");", ur.map(function(Di, fi) {\n                          return Ur + "[" + fi + "]=" + Di;\n                        }).join(";"), ";");\n                      } else Ln(ht) ? (yt = Ve.link(ur, { stable: true }), Qe(Dt, ".", mn[Pt], "(", yt, ");", Bt, ".", Pt, "=", yt, ";")) : Qe(Dt, ".", mn[Pt], "(", ur, ");", Bt, ".", Pt, "=", ur, ";");\n                    }\n                  });\n                }\n                function ol(Ve, Qe) {\n                  Ri && (Ve.instancing = Qe.def(Ve.shared.extensions, ".angle_instanced_arrays"));\n                }\n                function io(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.shared, Bt = Ve.stats, Dt = Rt.current, yt = Rt.timer, Pt = at.profile;\n                  function ht() {\n                    return typeof performance == "undefined" ? "Date.now()" : "performance.now()";\n                  }\n                  var ur, br;\n                  function Ur(Ci) {\n                    ur = Qe.def(), Ci(ur, "=", ht(), ";"), typeof Ot == "string" ? Ci(Bt, ".count+=", Ot, ";") : Ci(Bt, ".count++;"), Wi && (Ct ? (br = Qe.def(), Ci(br, "=", yt, ".getNumPendingQueries();")) : Ci(yt, ".beginQuery(", Bt, ");"));\n                  }\n                  function Di(Ci) {\n                    Ci(Bt, ".cpuTime+=", ht(), "-", ur, ";"), Wi && (Ct ? Ci(yt, ".pushScopeStats(", br, ",", yt, ".getNumPendingQueries(),", Bt, ");") : Ci(yt, ".endQuery();"));\n                  }\n                  function fi(Ci) {\n                    var Bi = Qe.def(Dt, ".profile");\n                    Qe(Dt, ".profile=", Ci, ";"), Qe.exit(Dt, ".profile=", Bi, ";");\n                  }\n                  var Ti;\n                  if (Pt) {\n                    if (Ln(Pt)) {\n                      Pt.enable ? (Ur(Qe), Di(Qe.exit), fi("true")) : fi("false");\n                      return;\n                    }\n                    Ti = Pt.append(Ve, Qe), fi(Ti);\n                  } else Ti = Qe.def(Dt, ".profile");\n                  var gn = Ve.block();\n                  Ur(gn), Qe("if(", Ti, "){", gn, "}");\n                  var rn = Ve.block();\n                  Di(rn), Qe.exit("if(", Ti, "){", rn, "}");\n                }\n                function Y(Ve, Qe, at, Ct, Ot) {\n                  var Rt = Ve.shared;\n                  function Bt(yt) {\n                    switch (yt) {\n                      case Co:\n                      case Ps:\n                      case hl:\n                        return 2;\n                      case Qa:\n                      case Ts:\n                      case Ul:\n                        return 3;\n                      case mo:\n                      case wo:\n                      case Lu:\n                        return 4;\n                      default:\n                        return 1;\n                    }\n                  }\n                  function Dt(yt, Pt, ht) {\n                    var ur = Rt.gl, br = Qe.def(yt, ".location"), Ur = Qe.def(Rt.attributes, "[", br, "]"), Di = ht.state, fi = ht.buffer, Ti = [ht.x, ht.y, ht.z, ht.w], gn = ["buffer", "normalized", "offset", "stride"];\n                    function rn() {\n                      Qe("if(!", Ur, ".buffer){", ur, ".enableVertexAttribArray(", br, ");}");\n                      var Bi = ht.type, Gi;\n                      if (ht.size ? Gi = Qe.def(ht.size, "||", Pt) : Gi = Pt, Qe("if(", Ur, ".type!==", Bi, "||", Ur, ".size!==", Gi, "||", gn.map(function(zn) {\n                        return Ur + "." + zn + "!==" + ht[zn];\n                      }).join("||"), "){", ur, ".bindBuffer(", Sr, ",", fi, ".buffer);", ur, ".vertexAttribPointer(", [br, Gi, Bi, ht.normalized, ht.stride, ht.offset], ");", Ur, ".type=", Bi, ";", Ur, ".size=", Gi, ";", gn.map(function(zn) {\n                        return Ur + "." + zn + "=" + ht[zn] + ";";\n                      }).join(""), "}"), Ri) {\n                        var sn = ht.divisor;\n                        Qe("if(", Ur, ".divisor!==", sn, "){", Ve.instancing, ".vertexAttribDivisorANGLE(", [br, sn], ");", Ur, ".divisor=", sn, ";}");\n                      }\n                    }\n                    function Ci() {\n                      Qe("if(", Ur, ".buffer){", ur, ".disableVertexAttribArray(", br, ");", Ur, ".buffer=null;", "}if(", Ca.map(function(Bi, Gi) {\n                        return Ur + "." + Bi + "!==" + Ti[Gi];\n                      }).join("||"), "){", ur, ".vertexAttrib4f(", br, ",", Ti, ");", Ca.map(function(Bi, Gi) {\n                        return Ur + "." + Bi + "=" + Ti[Gi] + ";";\n                      }).join(""), "}");\n                    }\n                    Di === La ? rn() : Di === Na ? Ci() : (Qe("if(", Di, "===", La, "){"), rn(), Qe("}else{"), Ci(), Qe("}"));\n                  }\n                  Ct.forEach(function(yt) {\n                    var Pt = yt.name, ht = at.attributes[Pt], ur;\n                    if (ht) {\n                      if (!Ot(ht)) return;\n                      ur = ht.append(Ve, Qe);\n                    } else {\n                      if (!Ot(ia)) return;\n                      var br = Ve.scopeAttrib(Pt);\n                      ur = {}, Object.keys(new Yr()).forEach(function(Ur) {\n                        ur[Ur] = Qe.def(br, ".", Ur);\n                      });\n                    }\n                    Dt(Ve.link(yt), Bt(yt.info.type), ur);\n                  });\n                }\n                function D3(Ve, Qe, at, Ct, Ot, Rt) {\n                  for (var Bt = Ve.shared, Dt = Bt.gl, yt, Pt = 0; Pt < Ct.length; ++Pt) {\n                    var ht = Ct[Pt], ur = ht.name, br = ht.info.type, Ur = at.uniforms[ur], Di = Ve.link(ht), fi = Di + ".location", Ti;\n                    if (Ur) {\n                      if (!Ot(Ur)) continue;\n                      if (Ln(Ur)) {\n                        var gn = Ur.value;\n                        if (br === dc || br === Tl) {\n                          var rn = Ve.link(gn._texture || gn.color[0]._texture);\n                          Qe(Dt, ".uniform1i(", fi, ",", rn + ".bind());"), Qe.exit(rn, ".unbind();");\n                        } else if (br === au || br === Js || br === Ql) {\n                          var Ci = Ve.global.def("new Float32Array([" + Array.prototype.slice.call(gn) + "])"), Bi = 2;\n                          br === Js ? Bi = 3 : br === Ql && (Bi = 4), Qe(Dt, ".uniformMatrix", Bi, "fv(", fi, ",false,", Ci, ");");\n                        } else {\n                          switch (br) {\n                            case $a:\n                              yt = "1f";\n                              break;\n                            case Co:\n                              yt = "2f";\n                              break;\n                            case Qa:\n                              yt = "3f";\n                              break;\n                            case mo:\n                              yt = "4f";\n                              break;\n                            case To:\n                              yt = "1i";\n                              break;\n                            case Bo:\n                              yt = "1i";\n                              break;\n                            case hl:\n                              yt = "2i";\n                              break;\n                            case Ps:\n                              yt = "2i";\n                              break;\n                            case Ul:\n                              yt = "3i";\n                              break;\n                            case Ts:\n                              yt = "3i";\n                              break;\n                            case Lu:\n                              yt = "4i";\n                              break;\n                            case wo:\n                              yt = "4i";\n                              break;\n                          }\n                          Qe(Dt, ".uniform", yt, "(", fi, ",", Mn(gn) ? Array.prototype.slice.call(gn) : gn, ");");\n                        }\n                        continue;\n                      } else Ti = Ur.append(Ve, Qe);\n                    } else {\n                      if (!Ot(ia)) continue;\n                      Ti = Qe.def(Bt.uniforms, "[", bt.id(ur), "]");\n                    }\n                    br === dc ? Qe("if(", Ti, "&&", Ti, \'._reglType==="framebuffer"){\', Ti, "=", Ti, ".color[0];", "}") : br === Tl && Qe("if(", Ti, "&&", Ti, \'._reglType==="framebufferCube"){\', Ti, "=", Ti, ".color[0];", "}");\n                    var Gi = 1;\n                    switch (br) {\n                      case dc:\n                      case Tl:\n                        var sn = Qe.def(Ti, "._texture");\n                        Qe(Dt, ".uniform1i(", fi, ",", sn, ".bind());"), Qe.exit(sn, ".unbind();");\n                        continue;\n                      case Bo:\n                      case To:\n                        yt = "1i";\n                        break;\n                      case Ps:\n                      case hl:\n                        yt = "2i", Gi = 2;\n                        break;\n                      case Ts:\n                      case Ul:\n                        yt = "3i", Gi = 3;\n                        break;\n                      case wo:\n                      case Lu:\n                        yt = "4i", Gi = 4;\n                        break;\n                      case $a:\n                        yt = "1f";\n                        break;\n                      case Co:\n                        yt = "2f", Gi = 2;\n                        break;\n                      case Qa:\n                        yt = "3f", Gi = 3;\n                        break;\n                      case mo:\n                        yt = "4f", Gi = 4;\n                        break;\n                      case au:\n                        yt = "Matrix2fv";\n                        break;\n                      case Js:\n                        yt = "Matrix3fv";\n                        break;\n                      case Ql:\n                        yt = "Matrix4fv";\n                        break;\n                    }\n                    if (yt.charAt(0) === "M") {\n                      Qe(Dt, ".uniform", yt, "(", fi, ",");\n                      var zn = Math.pow(br - au + 2, 2), Ja = Ve.global.def("new Float32Array(", zn, ")");\n                      Array.isArray(Ti) ? Qe("false,(", M4(zn, function(ms) {\n                        return Ja + "[" + ms + "]=" + Ti[ms];\n                      }), ",", Ja, ")") : Qe("false,(Array.isArray(", Ti, ")||", Ti, " instanceof Float32Array)?", Ti, ":(", M4(zn, function(ms) {\n                        return Ja + "[" + ms + "]=" + Ti + "[" + ms + "]";\n                      }), ",", Ja, ")"), Qe(");");\n                    } else if (Gi > 1) {\n                      for (var co = [], ts = [], so = 0; so < Gi; ++so) Array.isArray(Ti) ? ts.push(Ti[so]) : ts.push(Qe.def(Ti + "[" + so + "]")), Rt && co.push(Qe.def());\n                      Rt && Qe("if(!", Ve.batchId, "||", co.map(function(ms, ou) {\n                        return ms + "!==" + ts[ou];\n                      }).join("||"), "){", co.map(function(ms, ou) {\n                        return ms + "=" + ts[ou] + ";";\n                      }).join("")), Qe(Dt, ".uniform", yt, "(", fi, ",", ts.join(","), ");"), Rt && Qe("}");\n                    } else {\n                      if (Rt) {\n                        var Zo = Qe.def();\n                        Qe("if(!", Ve.batchId, "||", Zo, "!==", Ti, "){", Zo, "=", Ti, ";");\n                      }\n                      Qe(Dt, ".uniform", yt, "(", fi, ",", Ti, ");"), Rt && Qe("}");\n                    }\n                  }\n                }\n                function J(Ve, Qe, at, Ct) {\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.draw, Dt = Ct.draw;\n                  function yt() {\n                    var Gi = Dt.elements, sn, zn = Qe;\n                    return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn), Dt.elementsActive && zn("if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);")) : (sn = zn.def(), zn(sn, "=", Bt, ".", Tt, ";", "if(", sn, "){", Rt, ".bindBuffer(", Or, ",", sn, ".buffer.buffer);}", "else if(", Ot.vao, ".currentVAO){", sn, "=", Ve.shared.elements + ".getElements(" + Ot.vao, ".currentVAO.elements);", an ? "" : "if(" + sn + ")" + Rt + ".bindBuffer(" + Or + "," + sn + ".buffer.buffer);", "}")), sn;\n                  }\n                  function Pt() {\n                    var Gi = Dt.count, sn, zn = Qe;\n                    return Gi ? ((Gi.contextDep && Ct.contextDynamic || Gi.propDep) && (zn = at), sn = Gi.append(Ve, zn)) : sn = zn.def(Bt, ".", Kt), sn;\n                  }\n                  var ht = yt();\n                  function ur(Gi) {\n                    var sn = Dt[Gi];\n                    return sn ? sn.contextDep && Ct.contextDynamic || sn.propDep ? sn.append(Ve, at) : sn.append(Ve, Qe) : Qe.def(Bt, ".", Gi);\n                  }\n                  var br = ur(Yt), Ur = ur(xr), Di = Pt();\n                  if (typeof Di == "number") {\n                    if (Di === 0) return;\n                  } else at("if(", Di, "){"), at.exit("}");\n                  var fi, Ti;\n                  Ri && (fi = ur(Ir), Ti = Ve.instancing);\n                  var gn = ht + ".type", rn = Dt.elements && Ln(Dt.elements) && !Dt.vaoActive;\n                  function Ci() {\n                    function Gi() {\n                      at(Ti, ".drawElementsInstancedANGLE(", [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)", fi], ");");\n                    }\n                    function sn() {\n                      at(Ti, ".drawArraysInstancedANGLE(", [br, Ur, Di, fi], ");");\n                    }\n                    ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();\n                  }\n                  function Bi() {\n                    function Gi() {\n                      at(Rt + ".drawElements(" + [br, Di, gn, Ur + "<<((" + gn + "-" + Ra + ")>>1)"] + ");");\n                    }\n                    function sn() {\n                      at(Rt + ".drawArrays(" + [br, Ur, Di] + ");");\n                    }\n                    ht && ht !== "null" ? rn ? Gi() : (at("if(", ht, "){"), Gi(), at("}else{"), sn(), at("}")) : sn();\n                  }\n                  Ri && (typeof fi != "number" || fi >= 0) ? typeof fi == "string" ? (at("if(", fi, ">0){"), Ci(), at("}else if(", fi, "<0){"), Bi(), at("}")) : Ci() : Bi();\n                }\n                function q2(Ve, Qe, at, Ct, Ot) {\n                  var Rt = kn(), Bt = Rt.proc("body", Ot);\n                  return Ri && (Rt.instancing = Bt.def(Rt.shared.extensions, ".angle_instanced_arrays")), Ve(Rt, Bt, at, Ct), Rt.compile().body;\n                }\n                function K(Ve, Qe, at, Ct) {\n                  ol(Ve, Qe), at.useVAO ? at.drawVAO ? Qe(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Qe), ");") : Qe(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Qe(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Qe, at, Ct.attributes, function() {\n                    return true;\n                  })), D3(Ve, Qe, at, Ct.uniforms, function() {\n                    return true;\n                  }, false), J(Ve, Qe, Qe, at);\n                }\n                function de(Ve, Qe) {\n                  var at = Ve.proc("draw", 1);\n                  ol(Ve, at), ss(Ve, at, Qe.context), Vs(Ve, at, Qe.framebuffer), Ys(Ve, at, Qe), wa(Ve, at, Qe.state), io(Ve, at, Qe, false, true);\n                  var Ct = Qe.shader.progVar.append(Ve, at);\n                  if (at(Ve.shared.gl, ".useProgram(", Ct, ".program);"), Qe.shader.program) K(Ve, at, Qe, Qe.shader.program);\n                  else {\n                    at(Ve.shared.vao, ".setVAO(null);");\n                    var Ot = Ve.global.def("{}"), Rt = at.def(Ct, ".id"), Bt = at.def(Ot, "[", Rt, "]");\n                    at(Ve.cond(Bt).then(Bt, ".call(this,a0);").else(Bt, "=", Ot, "[", Rt, "]=", Ve.link(function(Dt) {\n                      return q2(K, Ve, Qe, Dt, 1);\n                    }), "(", Ct, ");", Bt, ".call(this,a0);"));\n                  }\n                  Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");\n                }\n                function ne(Ve, Qe, at, Ct) {\n                  Ve.batchId = "a1", ol(Ve, Qe);\n                  function Ot() {\n                    return true;\n                  }\n                  Y(Ve, Qe, at, Ct.attributes, Ot), D3(Ve, Qe, at, Ct.uniforms, Ot, false), J(Ve, Qe, Qe, at);\n                }\n                function we(Ve, Qe, at, Ct) {\n                  ol(Ve, Qe);\n                  var Ot = at.contextDep, Rt = Qe.def(), Bt = "a0", Dt = "a1", yt = Qe.def();\n                  Ve.shared.props = yt, Ve.batchId = Rt;\n                  var Pt = Ve.scope(), ht = Ve.scope();\n                  Qe(Pt.entry, "for(", Rt, "=0;", Rt, "<", Dt, ";++", Rt, "){", yt, "=", Bt, "[", Rt, "];", ht, "}", Pt.exit);\n                  function ur(gn) {\n                    return gn.contextDep && Ot || gn.propDep;\n                  }\n                  function br(gn) {\n                    return !ur(gn);\n                  }\n                  if (at.needsContext && ss(Ve, ht, at.context), at.needsFramebuffer && Vs(Ve, ht, at.framebuffer), wa(Ve, ht, at.state, ur), at.profile && ur(at.profile) && io(Ve, ht, at, false, true), Ct) at.useVAO ? at.drawVAO ? ur(at.drawVAO) ? ht(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, ht), ");") : Pt(Ve.shared.vao, ".setVAO(", at.drawVAO.append(Ve, Pt), ");") : Pt(Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);") : (Pt(Ve.shared.vao, ".setVAO(null);"), Y(Ve, Pt, at, Ct.attributes, br), Y(Ve, ht, at, Ct.attributes, ur)), D3(Ve, Pt, at, Ct.uniforms, br, false), D3(Ve, ht, at, Ct.uniforms, ur, true), J(Ve, Pt, ht, at);\n                  else {\n                    var Ur = Ve.global.def("{}"), Di = at.shader.progVar.append(Ve, ht), fi = ht.def(Di, ".id"), Ti = ht.def(Ur, "[", fi, "]");\n                    ht(Ve.shared.gl, ".useProgram(", Di, ".program);", "if(!", Ti, "){", Ti, "=", Ur, "[", fi, "]=", Ve.link(function(gn) {\n                      return q2(ne, Ve, at, gn, 2);\n                    }), "(", Di, ");}", Ti, ".call(this,a0[", Rt, "],", Rt, ");");\n                  }\n                }\n                function Ue(Ve, Qe) {\n                  var at = Ve.proc("batch", 2);\n                  Ve.batchId = "0", ol(Ve, at);\n                  var Ct = false, Ot = true;\n                  Object.keys(Qe.context).forEach(function(Ur) {\n                    Ct = Ct || Qe.context[Ur].propDep;\n                  }), Ct || (ss(Ve, at, Qe.context), Ot = false);\n                  var Rt = Qe.framebuffer, Bt = false;\n                  Rt ? (Rt.propDep ? Ct = Bt = true : Rt.contextDep && Ct && (Bt = true), Bt || Vs(Ve, at, Rt)) : Vs(Ve, at, null), Qe.state.viewport && Qe.state.viewport.propDep && (Ct = true);\n                  function Dt(Ur) {\n                    return Ur.contextDep && Ct || Ur.propDep;\n                  }\n                  Ys(Ve, at, Qe), wa(Ve, at, Qe.state, function(Ur) {\n                    return !Dt(Ur);\n                  }), (!Qe.profile || !Dt(Qe.profile)) && io(Ve, at, Qe, false, "a1"), Qe.contextDep = Ct, Qe.needsContext = Ot, Qe.needsFramebuffer = Bt;\n                  var yt = Qe.shader.progVar;\n                  if (yt.contextDep && Ct || yt.propDep) we(Ve, at, Qe, null);\n                  else {\n                    var Pt = yt.append(Ve, at);\n                    if (at(Ve.shared.gl, ".useProgram(", Pt, ".program);"), Qe.shader.program) we(Ve, at, Qe, Qe.shader.program);\n                    else {\n                      at(Ve.shared.vao, ".setVAO(null);");\n                      var ht = Ve.global.def("{}"), ur = at.def(Pt, ".id"), br = at.def(ht, "[", ur, "]");\n                      at(Ve.cond(br).then(br, ".call(this,a0,a1);").else(br, "=", ht, "[", ur, "]=", Ve.link(function(Ur) {\n                        return q2(we, Ve, Qe, Ur, 2);\n                      }), "(", Pt, ");", br, ".call(this,a0,a1);"));\n                    }\n                  }\n                  Object.keys(Qe.state).length > 0 && at(Ve.shared.current, ".dirty=true;"), Ve.shared.vao && at(Ve.shared.vao, ".setVAO(null);");\n                }\n                function ft(Ve, Qe) {\n                  var at = Ve.proc("scope", 3);\n                  Ve.batchId = "a2";\n                  var Ct = Ve.shared, Ot = Ct.current;\n                  if (ss(Ve, at, Qe.context), Qe.framebuffer && Qe.framebuffer.append(Ve, at), Si(Object.keys(Qe.state)).forEach(function(Dt) {\n                    var yt = Qe.state[Dt], Pt = yt.append(Ve, at);\n                    Mn(Pt) ? Pt.forEach(function(ht, ur) {\n                      pn(ht) ? at.set(Ve.next[Dt], "[" + ur + "]", ht) : at.set(Ve.next[Dt], "[" + ur + "]", Ve.link(ht, { stable: true }));\n                    }) : Ln(yt) ? at.set(Ct.next, "." + Dt, Ve.link(Pt, { stable: true })) : at.set(Ct.next, "." + Dt, Pt);\n                  }), io(Ve, at, Qe, true, true), [Tt, xr, Kt, Ir, Yt].forEach(function(Dt) {\n                    var yt = Qe.draw[Dt];\n                    if (yt) {\n                      var Pt = yt.append(Ve, at);\n                      pn(Pt) ? at.set(Ct.draw, "." + Dt, Pt) : at.set(Ct.draw, "." + Dt, Ve.link(Pt), { stable: true });\n                    }\n                  }), Object.keys(Qe.uniforms).forEach(function(Dt) {\n                    var yt = Qe.uniforms[Dt].append(Ve, at);\n                    Array.isArray(yt) && (yt = "[" + yt.map(function(Pt) {\n                      return pn(Pt) ? Pt : Ve.link(Pt, { stable: true });\n                    }) + "]"), at.set(Ct.uniforms, "[" + Ve.link(bt.id(Dt), { stable: true }) + "]", yt);\n                  }), Object.keys(Qe.attributes).forEach(function(Dt) {\n                    var yt = Qe.attributes[Dt].append(Ve, at), Pt = Ve.scopeAttrib(Dt);\n                    Object.keys(new Yr()).forEach(function(ht) {\n                      at.set(Pt, "." + ht, yt[ht]);\n                    });\n                  }), Qe.scopeVAO) {\n                    var Rt = Qe.scopeVAO.append(Ve, at);\n                    pn(Rt) ? at.set(Ct.vao, ".targetVAO", Rt) : at.set(Ct.vao, ".targetVAO", Ve.link(Rt, { stable: true }));\n                  }\n                  function Bt(Dt) {\n                    var yt = Qe.shader[Dt];\n                    if (yt) {\n                      var Pt = yt.append(Ve, at);\n                      pn(Pt) ? at.set(Ct.shader, "." + Dt, Pt) : at.set(Ct.shader, "." + Dt, Ve.link(Pt, { stable: true }));\n                    }\n                  }\n                  Bt(Xe), Bt(ot), Object.keys(Qe.state).length > 0 && (at(Ot, ".dirty=true;"), at.exit(Ot, ".dirty=true;")), at("a1(", Ve.shared.context, ",a0,", Ve.batchId, ");");\n                }\n                function Xt(Ve) {\n                  if (!(typeof Ve != "object" || Mn(Ve))) {\n                    for (var Qe = Object.keys(Ve), at = 0; at < Qe.length; ++at) if (h3.isDynamic(Ve[Qe[at]])) return true;\n                    return false;\n                  }\n                }\n                function hr(Ve, Qe, at) {\n                  var Ct = Qe.static[at];\n                  if (!Ct || !Xt(Ct)) return;\n                  var Ot = Ve.global, Rt = Object.keys(Ct), Bt = false, Dt = false, yt = false, Pt = Ve.global.def("{}");\n                  Rt.forEach(function(ur) {\n                    var br = Ct[ur];\n                    if (h3.isDynamic(br)) {\n                      typeof br == "function" && (br = Ct[ur] = h3.unbox(br));\n                      var Ur = Un(br, null);\n                      Bt = Bt || Ur.thisDep, yt = yt || Ur.propDep, Dt = Dt || Ur.contextDep;\n                    } else {\n                      switch (Ot(Pt, ".", ur, "="), typeof br) {\n                        case "number":\n                          Ot(br);\n                          break;\n                        case "string":\n                          Ot(\'"\', br, \'"\');\n                          break;\n                        case "object":\n                          Array.isArray(br) && Ot("[", br.join(), "]");\n                          break;\n                        default:\n                          Ot(Ve.link(br));\n                          break;\n                      }\n                      Ot(";");\n                    }\n                  });\n                  function ht(ur, br) {\n                    Rt.forEach(function(Ur) {\n                      var Di = Ct[Ur];\n                      if (h3.isDynamic(Di)) {\n                        var fi = ur.invoke(br, Di);\n                        br(Pt, ".", Ur, "=", fi, ";");\n                      }\n                    });\n                  }\n                  Qe.dynamic[at] = new h3.DynamicVariable(Xo, { thisDep: Bt, contextDep: Dt, propDep: yt, ref: Pt, append: ht }), delete Qe.static[at];\n                }\n                function qt(Ve, Qe, at, Ct, Ot) {\n                  var Rt = kn();\n                  Rt.stats = Rt.link(Ot), Object.keys(Qe.static).forEach(function(Dt) {\n                    hr(Rt, Qe, Dt);\n                  }), dr.forEach(function(Dt) {\n                    hr(Rt, Ve, Dt);\n                  });\n                  var Bt = Vl(Ve, Qe, at, Ct, Rt);\n                  return Bt.shader.program && (Bt.shader.program.attributes.sort(function(Dt, yt) {\n                    return Dt.name < yt.name ? -1 : 1;\n                  }), Bt.shader.program.uniforms.sort(function(Dt, yt) {\n                    return Dt.name < yt.name ? -1 : 1;\n                  })), de(Rt, Bt), ft(Rt, Bt), Ue(Rt, Bt), e3(Rt.compile(), { destroy: function() {\n                    Bt.shader.program.destroy();\n                  } });\n                }\n                return { next: Bn, current: Zi, procs: (function() {\n                  var Ve = kn(), Qe = Ve.proc("poll"), at = Ve.proc("refresh"), Ct = Ve.block();\n                  Qe(Ct), at(Ct);\n                  var Ot = Ve.shared, Rt = Ot.gl, Bt = Ot.next, Dt = Ot.current;\n                  Ct(Dt, ".dirty=false;"), Vs(Ve, Qe), Vs(Ve, at, null, true);\n                  var yt;\n                  Ri && (yt = Ve.link(Ri)), zt.oes_vertex_array_object && at(Ve.link(zt.oes_vertex_array_object), ".bindVertexArrayOES(null);");\n                  var Pt = at.def(Ot.attributes), ht = at.def(0), ur = Ve.cond(ht, ".buffer");\n                  ur.then(Rt, ".enableVertexAttribArray(i);", Rt, ".bindBuffer(", Sr, ",", ht, ".buffer.buffer);", Rt, ".vertexAttribPointer(i,", ht, ".size,", ht, ".type,", ht, ".normalized,", ht, ".stride,", ht, ".offset);").else(Rt, ".disableVertexAttribArray(i);", Rt, ".vertexAttrib4f(i,", ht, ".x,", ht, ".y,", ht, ".z,", ht, ".w);", ht, ".buffer=null;");\n                  var br = Ve.link(Rr.maxAttributes, { stable: true });\n                  return at("for(var i=0;i<", br, ";++i){", ht, "=", Pt, "[i];", ur, "}"), Ri && at("for(var i=0;i<", br, ";++i){", yt, ".vertexAttribDivisorANGLE(i,", Pt, "[i].divisor);", "}"), at(Ve.shared.vao, ".currentVAO=null;", Ve.shared.vao, ".setVAO(", Ve.shared.vao, ".targetVAO);"), Object.keys(li).forEach(function(Ur) {\n                    var Di = li[Ur], fi = Ct.def(Bt, ".", Ur), Ti = Ve.block();\n                    Ti("if(", fi, "){", Rt, ".enable(", Di, ")}else{", Rt, ".disable(", Di, ")}", Dt, ".", Ur, "=", fi, ";"), at(Ti), Qe("if(", fi, "!==", Dt, ".", Ur, "){", Ti, "}");\n                  }), Object.keys(mn).forEach(function(Ur) {\n                    var Di = mn[Ur], fi = Zi[Ur], Ti, gn, rn = Ve.block();\n                    if (rn(Rt, ".", Di, "("), Mn(fi)) {\n                      var Ci = fi.length;\n                      Ti = Ve.global.def(Bt, ".", Ur), gn = Ve.global.def(Dt, ".", Ur), rn(M4(Ci, function(Bi) {\n                        return Ti + "[" + Bi + "]";\n                      }), ");", M4(Ci, function(Bi) {\n                        return gn + "[" + Bi + "]=" + Ti + "[" + Bi + "];";\n                      }).join("")), Qe("if(", M4(Ci, function(Bi) {\n                        return Ti + "[" + Bi + "]!==" + gn + "[" + Bi + "]";\n                      }).join("||"), "){", rn, "}");\n                    } else Ti = Ct.def(Bt, ".", Ur), gn = Ct.def(Dt, ".", Ur), rn(Ti, ");", Dt, ".", Ur, "=", Ti, ";"), Qe("if(", Ti, "!==", gn, "){", rn, "}");\n                    at(rn);\n                  }), Ve.compile();\n                })(), compile: qt };\n              }\n              function Ia() {\n                return { vaoCount: 0, bufferCount: 0, elementsCount: 0, framebufferCount: 0, shaderCount: 0, textureCount: 0, cubeCount: 0, renderbufferCount: 0, maxTextureUnits: 0 };\n              }\n              var yo = 34918, Da = 34919, go = 35007, Is = function(Me, bt) {\n                if (!bt.ext_disjoint_timer_query) return null;\n                var zt = [];\n                function Rr() {\n                  return zt.pop() || bt.ext_disjoint_timer_query.createQueryEXT();\n                }\n                function jr(xi) {\n                  zt.push(xi);\n                }\n                var Nr = [];\n                function Gr(xi) {\n                  var Ri = Rr();\n                  bt.ext_disjoint_timer_query.beginQueryEXT(go, Ri), Nr.push(Ri), Wi(Nr.length - 1, Nr.length, xi);\n                }\n                function mi() {\n                  bt.ext_disjoint_timer_query.endQueryEXT(go);\n                }\n                function Ui() {\n                  this.startQueryIndex = -1, this.endQueryIndex = -1, this.sum = 0, this.stats = null;\n                }\n                var qi = [];\n                function Ei() {\n                  return qi.pop() || new Ui();\n                }\n                function Hn(xi) {\n                  qi.push(xi);\n                }\n                var en = [];\n                function Wi(xi, Ri, ci) {\n                  var an = Ei();\n                  an.startQueryIndex = xi, an.endQueryIndex = Ri, an.sum = 0, an.stats = ci, en.push(an);\n                }\n                var si = [], Mr = [];\n                function Yr() {\n                  var xi, Ri, ci = Nr.length;\n                  if (ci !== 0) {\n                    Mr.length = Math.max(Mr.length, ci + 1), si.length = Math.max(si.length, ci + 1), si[0] = 0, Mr[0] = 0;\n                    var an = 0;\n                    for (xi = 0, Ri = 0; Ri < Nr.length; ++Ri) {\n                      var Zi = Nr[Ri];\n                      bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, Da) ? (an += bt.ext_disjoint_timer_query.getQueryObjectEXT(Zi, yo), jr(Zi)) : Nr[xi++] = Zi, si[Ri + 1] = an, Mr[Ri + 1] = xi;\n                    }\n                    for (Nr.length = xi, xi = 0, Ri = 0; Ri < en.length; ++Ri) {\n                      var Bn = en[Ri], hi = Bn.startQueryIndex, li = Bn.endQueryIndex;\n                      Bn.sum += si[li] - si[hi];\n                      var mn = Mr[hi], Ji = Mr[li];\n                      Ji === mn ? (Bn.stats.gpuTime += Bn.sum / 1e6, Hn(Bn)) : (Bn.startQueryIndex = mn, Bn.endQueryIndex = Ji, en[xi++] = Bn);\n                    }\n                    en.length = xi;\n                  }\n                }\n                return { beginQuery: Gr, endQuery: mi, pushScopeStats: Wi, update: Yr, getNumPendingQueries: function() {\n                  return Nr.length;\n                }, clear: function() {\n                  zt.push.apply(zt, Nr);\n                  for (var xi = 0; xi < zt.length; xi++) bt.ext_disjoint_timer_query.deleteQueryEXT(zt[xi]);\n                  Nr.length = 0, zt.length = 0;\n                }, restore: function() {\n                  Nr.length = 0, zt.length = 0;\n                } };\n              }, Ms = 16384, Xs = 256, Gn = 1024, ja = 34962, Fo = "webglcontextlost", Uo = "webglcontextrestored", $s = 1, Sl = 2, bu = 3;\n              function dl(Me, bt) {\n                for (var zt = 0; zt < Me.length; ++zt) if (Me[zt] === bt) return zt;\n                return -1;\n              }\n              function Sc(Me) {\n                var bt = x2(Me);\n                if (!bt) return null;\n                var zt = bt.gl, Rr = zt.getContextAttributes(), jr = zt.isContextLost(), Nr = C3(zt, bt);\n                if (!Nr) return null;\n                var Gr = _2(), mi = Ia(), Ui = bt.cachedCode || {}, qi = Nr.extensions, Ei = Is(zt, qi), Hn = v3(), en = zt.drawingBufferWidth, Wi = zt.drawingBufferHeight, si = { tick: 0, time: 0, viewportWidth: en, viewportHeight: Wi, framebufferWidth: en, framebufferHeight: Wi, drawingBufferWidth: en, drawingBufferHeight: Wi, pixelRatio: bt.pixelRatio }, Mr = {}, Yr = { elements: null, primitive: 4, count: -1, offset: 0, instances: -1 }, xi = ti(zt, qi), Ri = ri(zt, mi, bt, Zi), ci = kr(zt, qi, Ri, mi), an = ku(zt, qi, xi, mi, Ri, ci, Yr);\n                function Zi(q2) {\n                  return an.destroyBuffer(q2);\n                }\n                var Bn = Wu(zt, Gr, mi, bt), hi = of(zt, qi, xi, function() {\n                  Ji.procs.poll();\n                }, si, mi, bt), li = Dc(zt, qi, xi, mi, bt), mn = lf(zt, qi, xi, hi, li, mi), Ji = Ea(zt, Gr, qi, xi, Ri, ci, hi, mn, Mr, an, Bn, Yr, si, Ei, Ui, bt), Vi = Wl(zt, mn, Ji.procs.poll, si, Rr, qi, xi), Ni = Ji.next, pn = zt.canvas, Vn = [], na = [], Ki = [], kn = [bt.onDestroy], ta = null;\n                function oa() {\n                  if (Vn.length === 0) {\n                    Ei && Ei.update(), ta = null;\n                    return;\n                  }\n                  ta = d3.next(oa), Ys();\n                  for (var q2 = Vn.length - 1; q2 >= 0; --q2) {\n                    var K = Vn[q2];\n                    K && K(si, null, 0);\n                  }\n                  zt.flush(), Ei && Ei.update();\n                }\n                function ba() {\n                  !ta && Vn.length > 0 && (ta = d3.next(oa));\n                }\n                function is() {\n                  ta && (d3.cancel(oa), ta = null);\n                }\n                function Zs(q2) {\n                  q2.preventDefault(), jr = true, is(), na.forEach(function(K) {\n                    K();\n                  });\n                }\n                function Va(q2) {\n                  zt.getError(), jr = false, Nr.restore(), Bn.restore(), Ri.restore(), hi.restore(), li.restore(), mn.restore(), an.restore(), Ei && Ei.restore(), Ji.procs.refresh(), ba(), Ki.forEach(function(K) {\n                    K();\n                  });\n                }\n                pn && (pn.addEventListener(Fo, Zs, false), pn.addEventListener(Uo, Va, false));\n                function Ml() {\n                  Vn.length = 0, is(), pn && (pn.removeEventListener(Fo, Zs), pn.removeEventListener(Uo, Va)), Bn.clear(), mn.clear(), li.clear(), an.clear(), hi.clear(), ci.clear(), Ri.clear(), Ei && Ei.clear(), kn.forEach(function(q2) {\n                    q2();\n                  });\n                }\n                function zo(q2) {\n                  function K(Rt) {\n                    var Bt = e3({}, Rt);\n                    delete Bt.uniforms, delete Bt.attributes, delete Bt.context, delete Bt.vao, "stencil" in Bt && Bt.stencil.op && (Bt.stencil.opBack = Bt.stencil.opFront = Bt.stencil.op, delete Bt.stencil.op);\n                    function Dt(yt) {\n                      if (yt in Bt) {\n                        var Pt = Bt[yt];\n                        delete Bt[yt], Object.keys(Pt).forEach(function(ht) {\n                          Bt[yt + "." + ht] = Pt[ht];\n                        });\n                      }\n                    }\n                    return Dt("blend"), Dt("depth"), Dt("cull"), Dt("stencil"), Dt("polygonOffset"), Dt("scissor"), Dt("sample"), "vao" in Rt && (Bt.vao = Rt.vao), Bt;\n                  }\n                  function de(Rt, Bt) {\n                    var Dt = {}, yt = {};\n                    return Object.keys(Rt).forEach(function(Pt) {\n                      var ht = Rt[Pt];\n                      if (h3.isDynamic(ht)) {\n                        yt[Pt] = h3.unbox(ht, Pt);\n                        return;\n                      } else if (Bt && Array.isArray(ht)) {\n                        for (var ur = 0; ur < ht.length; ++ur) if (h3.isDynamic(ht[ur])) {\n                          yt[Pt] = h3.unbox(ht, Pt);\n                          return;\n                        }\n                      }\n                      Dt[Pt] = ht;\n                    }), { dynamic: yt, static: Dt };\n                  }\n                  var ne = de(q2.context || {}, true), we = de(q2.uniforms || {}, true), Ue = de(q2.attributes || {}, false), ft = de(K(q2), false), Xt = { gpuTime: 0, cpuTime: 0, count: 0 }, hr = Ji.compile(ft, Ue, we, ne, Xt), qt = hr.draw, Ve = hr.batch, Qe = hr.scope, at = [];\n                  function Ct(Rt) {\n                    for (; at.length < Rt; ) at.push(null);\n                    return at;\n                  }\n                  function Ot(Rt, Bt) {\n                    var Dt;\n                    if (typeof Rt == "function") return Qe.call(this, null, Rt, 0);\n                    if (typeof Bt == "function") if (typeof Rt == "number") for (Dt = 0; Dt < Rt; ++Dt) Qe.call(this, null, Bt, Dt);\n                    else if (Array.isArray(Rt)) for (Dt = 0; Dt < Rt.length; ++Dt) Qe.call(this, Rt[Dt], Bt, Dt);\n                    else return Qe.call(this, Rt, Bt, 0);\n                    else if (typeof Rt == "number") {\n                      if (Rt > 0) return Ve.call(this, Ct(Rt | 0), Rt | 0);\n                    } else if (Array.isArray(Rt)) {\n                      if (Rt.length) return Ve.call(this, Rt, Rt.length);\n                    } else return qt.call(this, Rt);\n                  }\n                  return e3(Ot, { stats: Xt, destroy: function() {\n                    hr.destroy();\n                  } });\n                }\n                var Qs = mn.setFBO = zo({ framebuffer: h3.define.call(null, $s, "framebuffer") });\n                function al(q2, K) {\n                  var de = 0;\n                  Ji.procs.poll();\n                  var ne = K.color;\n                  ne && (zt.clearColor(+ne[0] || 0, +ne[1] || 0, +ne[2] || 0, +ne[3] || 0), de |= Ms), "depth" in K && (zt.clearDepth(+K.depth), de |= Xs), "stencil" in K && (zt.clearStencil(K.stencil | 0), de |= Gn), zt.clear(de);\n                }\n                function Vl(q2) {\n                  if ("framebuffer" in q2) if (q2.framebuffer && q2.framebuffer_reglType === "framebufferCube") for (var K = 0; K < 6; ++K) Qs(e3({ framebuffer: q2.framebuffer.faces[K] }, q2), al);\n                  else Qs(q2, al);\n                  else al(null, q2);\n                }\n                function ss(q2) {\n                  Vn.push(q2);\n                  function K() {\n                    var de = dl(Vn, q2);\n                    function ne() {\n                      var we = dl(Vn, ne);\n                      Vn[we] = Vn[Vn.length - 1], Vn.length -= 1, Vn.length <= 0 && is();\n                    }\n                    Vn[de] = ne;\n                  }\n                  return ba(), { cancel: K };\n                }\n                function Vs() {\n                  var q2 = Ni.viewport, K = Ni.scissor_box;\n                  q2[0] = q2[1] = K[0] = K[1] = 0, si.viewportWidth = si.framebufferWidth = si.drawingBufferWidth = q2[2] = K[2] = zt.drawingBufferWidth, si.viewportHeight = si.framebufferHeight = si.drawingBufferHeight = q2[3] = K[3] = zt.drawingBufferHeight;\n                }\n                function Ys() {\n                  si.tick += 1, si.time = ol(), Vs(), Ji.procs.poll();\n                }\n                function wa() {\n                  hi.refresh(), Vs(), Ji.procs.refresh(), Ei && Ei.update();\n                }\n                function ol() {\n                  return (v3() - Hn) / 1e3;\n                }\n                wa();\n                function io(q2, K) {\n                  var de;\n                  switch (q2) {\n                    case "frame":\n                      return ss(K);\n                    case "lost":\n                      de = na;\n                      break;\n                    case "restore":\n                      de = Ki;\n                      break;\n                    case "destroy":\n                      de = kn;\n                      break;\n                    default:\n                  }\n                  return de.push(K), { cancel: function() {\n                    for (var ne = 0; ne < de.length; ++ne) if (de[ne] === K) {\n                      de[ne] = de[de.length - 1], de.pop();\n                      return;\n                    }\n                  } };\n                }\n                function Y() {\n                  return Ui;\n                }\n                function D3(q2) {\n                  Object.entries(q2).forEach(function(K) {\n                    Ui[K[0]] = K[1];\n                  });\n                }\n                var J = e3(zo, { clear: Vl, prop: h3.define.bind(null, $s), context: h3.define.bind(null, Sl), this: h3.define.bind(null, bu), draw: zo({}), buffer: function(q2) {\n                  return Ri.create(q2, ja, false, false);\n                }, elements: function(q2) {\n                  return ci.create(q2, false);\n                }, texture: hi.create2D, cube: hi.createCube, renderbuffer: li.create, framebuffer: mn.create, framebufferCube: mn.createCube, vao: an.createVAO, attributes: Rr, frame: ss, on: io, limits: xi, hasExtension: function(q2) {\n                  return xi.extensions.indexOf(q2.toLowerCase()) >= 0;\n                }, read: Vi, destroy: Ml, _gl: zt, _refresh: wa, poll: function() {\n                  Ys(), Ei && Ei.update();\n                }, now: ol, stats: mi, getCachedCode: Y, preloadCachedCode: D3 });\n                return bt.onDone(null, J), J;\n              }\n              return Sc;\n            });\n          });\n          var Mz = ye((d_r, CBe) => {\n            "use strict";\n            var FUt = CX(), zUt = kBe();\n            CBe.exports = function(t3, r4, n4) {\n              var i3 = t3._fullLayout, a4 = true;\n              return i3._glcanvas.each(function(o4) {\n                if (o4.regl) {\n                  o4.regl.preloadCachedCode(n4);\n                  return;\n                }\n                if (!(o4.pick && !i3._has("parcoords"))) {\n                  try {\n                    o4.regl = zUt({ canvas: this, attributes: { antialias: !o4.pick, preserveDrawingBuffer: true }, pixelRatio: t3._context.plotGlPixelRatio || window.devicePixelRatio, extensions: r4 || [], cachedCode: n4 || {} });\n                  } catch (s3) {\n                    a4 = false;\n                  }\n                  o4.regl || (a4 = false), a4 && this.addEventListener("webglcontextlost", function(s3) {\n                    t3 && t3.emit && t3.emit("plotly_webglcontextlost", { event: s3, layer: o4.key });\n                  }, false);\n                }\n              }), a4 || FUt({ container: i3._glcontainer.node() }), a4;\n            };\n          });\n          var dK = ye((hK, DBe) => {\n            "use strict";\n            var LBe = hY(), PBe = GY(), OUt = yqe(), IBe = EBe(), fK = Dr(), qUt = Eg().selectMode, BUt = Mz(), NUt = Ru(), UUt = _U(), VUt = lY().styleTextSelection, RBe = {};\n            function GUt(e3, t3, r4, n4) {\n              var i3 = e3._size, a4 = e3.width * n4, o4 = e3.height * n4, s3 = i3.l * n4, l3 = i3.b * n4, u4 = i3.r * n4, c5 = i3.t * n4, f4 = i3.w * n4, h3 = i3.h * n4;\n              return [s3 + t3.domain[0] * f4, l3 + r4.domain[0] * h3, a4 - u4 - (1 - t3.domain[1]) * f4, o4 - c5 - (1 - r4.domain[1]) * h3];\n            }\n            var hK = DBe.exports = function(t3, r4, n4) {\n              if (n4.length) {\n                var i3 = t3._fullLayout, a4 = r4._scene, o4 = r4.xaxis, s3 = r4.yaxis, l3, u4;\n                if (a4) {\n                  var c5 = BUt(t3, ["ANGLE_instanced_arrays", "OES_element_index_uint"], RBe);\n                  if (!c5) {\n                    a4.init();\n                    return;\n                  }\n                  var f4 = a4.count, h3 = i3._glcanvas.data()[0].regl;\n                  if (UUt(t3, r4, n4), a4.dirty) {\n                    if ((a4.line2d || a4.error2d) && !(a4.scatter2d || a4.fill2d || a4.glText) && h3.clear({ color: true, depth: true }), a4.error2d === true && (a4.error2d = OUt(h3)), a4.line2d === true && (a4.line2d = PBe(h3)), a4.scatter2d === true && (a4.scatter2d = LBe(h3)), a4.fill2d === true && (a4.fill2d = PBe(h3)), a4.glText === true) for (a4.glText = new Array(f4), l3 = 0; l3 < f4; l3++) a4.glText[l3] = new IBe(h3);\n                    if (a4.glText) {\n                      if (f4 > a4.glText.length) {\n                        var d3 = f4 - a4.glText.length;\n                        for (l3 = 0; l3 < d3; l3++) a4.glText.push(new IBe(h3));\n                      } else if (f4 < a4.glText.length) {\n                        var v3 = a4.glText.length - f4, _2 = a4.glText.splice(f4, v3);\n                        _2.forEach(function(H) {\n                          H.destroy();\n                        });\n                      }\n                      for (l3 = 0; l3 < f4; l3++) a4.glText[l3].update(a4.textOptions[l3]);\n                    }\n                    if (a4.line2d && (a4.line2d.update(a4.lineOptions), a4.lineOptions = a4.lineOptions.map(function(H) {\n                      if (H && H.positions) {\n                        for (var te = H.positions, oe = 0; oe < te.length && (isNaN(te[oe]) || isNaN(te[oe + 1])); ) oe += 2;\n                        for (var _e = te.length - 2; _e > oe && (isNaN(te[_e]) || isNaN(te[_e + 1])); ) _e -= 2;\n                        H.positions = te.slice(oe, _e + 2);\n                      }\n                      return H;\n                    }), a4.line2d.update(a4.lineOptions)), a4.error2d) {\n                      var b = (a4.errorXOptions || []).concat(a4.errorYOptions || []);\n                      a4.error2d.update(b);\n                    }\n                    a4.scatter2d && a4.scatter2d.update(a4.markerOptions), a4.fillOrder = fK.repeat(null, f4), a4.fill2d && (a4.fillOptions = a4.fillOptions.map(function(H, te) {\n                      var oe = n4[te];\n                      if (!(!H || !oe || !oe[0] || !oe[0].trace)) {\n                        var _e = oe[0], Ee = _e.trace, Ce = _e.t, me = a4.lineOptions[te], ie, Se, Le = [];\n                        Ee._ownfill && Le.push(te), Ee._nexttrace && Le.push(te + 1), Le.length && (a4.fillOrder[te] = Le);\n                        var Ae = [], Fe = me && me.positions || Ce.positions, Pe, ge;\n                        if (Ee.fill === "tozeroy") {\n                          for (Pe = 0; Pe < Fe.length && isNaN(Fe[Pe + 1]); ) Pe += 2;\n                          for (ge = Fe.length - 2; ge > Pe && isNaN(Fe[ge + 1]); ) ge -= 2;\n                          Fe[Pe + 1] !== 0 && (Ae = [Fe[Pe], 0]), Ae = Ae.concat(Fe.slice(Pe, ge + 2)), Fe[ge + 1] !== 0 && (Ae = Ae.concat([Fe[ge], 0]));\n                        } else if (Ee.fill === "tozerox") {\n                          for (Pe = 0; Pe < Fe.length && isNaN(Fe[Pe]); ) Pe += 2;\n                          for (ge = Fe.length - 2; ge > Pe && isNaN(Fe[ge]); ) ge -= 2;\n                          Fe[Pe] !== 0 && (Ae = [0, Fe[Pe + 1]]), Ae = Ae.concat(Fe.slice(Pe, ge + 2)), Fe[ge] !== 0 && (Ae = Ae.concat([0, Fe[ge + 1]]));\n                        } else if (Ee.fill === "toself" || Ee.fill === "tonext") {\n                          for (Ae = [], ie = 0, H.splitNull = true, Se = 0; Se < Fe.length; Se += 2) (isNaN(Fe[Se]) || isNaN(Fe[Se + 1])) && (Ae = Ae.concat(Fe.slice(ie, Se)), Ae.push(Fe[ie], Fe[ie + 1]), Ae.push(null, null), ie = Se + 2);\n                          Ae = Ae.concat(Fe.slice(ie)), ie && Ae.push(Fe[ie], Fe[ie + 1]);\n                        } else {\n                          var Re = Ee._nexttrace;\n                          if (Re) {\n                            var ce = a4.lineOptions[te + 1];\n                            if (ce) {\n                              var Ze = ce.positions;\n                              if (Ee.fill === "tonexty") {\n                                for (Ae = Fe.slice(), te = Math.floor(Ze.length / 2); te--; ) {\n                                  var ut = Ze[te * 2], pt = Ze[te * 2 + 1];\n                                  isNaN(ut) || isNaN(pt) || Ae.push(ut, pt);\n                                }\n                                H.fill = Re.fillcolor;\n                              }\n                            }\n                          }\n                        }\n                        if (Ee._prevtrace && Ee._prevtrace.fill === "tonext") {\n                          var Zt = a4.lineOptions[te - 1].positions, st = Ae.length / 2;\n                          ie = st;\n                          var lt = [ie];\n                          for (Se = 0; Se < Zt.length; Se += 2) (isNaN(Zt[Se]) || isNaN(Zt[Se + 1])) && (lt.push(Se / 2 + st + 1), ie = Se + 2);\n                          Ae = Ae.concat(Zt), H.hole = lt;\n                        }\n                        return H.fillmode = Ee.fill, H.opacity = Ee.opacity, H.positions = Ae, H;\n                      }\n                    }), a4.fill2d.update(a4.fillOptions));\n                  }\n                  var p3 = i3.dragmode, k4 = qUt(p3), E3 = i3.clickmode.indexOf("select") > -1;\n                  for (l3 = 0; l3 < f4; l3++) {\n                    var S2 = n4[l3][0], L3 = S2.trace, x2 = S2.t, C3 = x2.index, M4 = L3._length, g3 = x2.x, P3 = x2.y;\n                    if (L3.selectedpoints || k4 || E3) {\n                      if (k4 || (k4 = true), L3.selectedpoints) {\n                        var T3 = a4.selectBatch[C3] = fK.selIndices2selPoints(L3), z3 = {};\n                        for (u4 = 0; u4 < T3.length; u4++) z3[T3[u4]] = 1;\n                        var O3 = [];\n                        for (u4 = 0; u4 < M4; u4++) z3[u4] || O3.push(u4);\n                        a4.unselectBatch[C3] = O3;\n                      }\n                      var V2 = x2.xpx = new Array(M4), G2 = x2.ypx = new Array(M4);\n                      for (u4 = 0; u4 < M4; u4++) V2[u4] = o4.c2p(g3[u4]), G2[u4] = s3.c2p(P3[u4]);\n                    } else x2.xpx = x2.ypx = null;\n                  }\n                  if (k4) {\n                    if (a4.select2d || (a4.select2d = LBe(i3._glcanvas.data()[1].regl)), a4.scatter2d) {\n                      var Z = new Array(f4);\n                      for (l3 = 0; l3 < f4; l3++) Z[l3] = a4.selectBatch[l3].length || a4.unselectBatch[l3].length ? a4.markerUnselectedOptions[l3] : {};\n                      a4.scatter2d.update(Z);\n                    }\n                    a4.select2d && (a4.select2d.update(a4.markerOptions), a4.select2d.update(a4.markerSelectedOptions)), a4.glText && n4.forEach(function(H) {\n                      var te = ((H || [])[0] || {}).trace || {};\n                      NUt.hasText(te) && VUt(H);\n                    });\n                  } else a4.scatter2d && a4.scatter2d.update(a4.markerOptions);\n                  var j3 = { viewport: GUt(i3, o4, s3, t3._context.plotGlPixelRatio), range: [(o4._rl || o4.range)[0], (s3._rl || s3.range)[0], (o4._rl || o4.range)[1], (s3._rl || s3.range)[1]] }, N2 = fK.repeat(j3, a4.count);\n                  a4.fill2d && a4.fill2d.update(N2), a4.line2d && a4.line2d.update(N2), a4.error2d && a4.error2d.update(N2.concat(N2)), a4.scatter2d && a4.scatter2d.update(N2), a4.select2d && a4.select2d.update(N2), a4.glText && a4.glText.forEach(function(H) {\n                    H.update(j3);\n                  });\n                }\n              }\n            };\n            hK.reglPrecompiled = RBe;\n          });\n          var OBe = ye((v_r, zBe) => {\n            "use strict";\n            var FBe = Qze();\n            FBe.plot = dK();\n            zBe.exports = FBe;\n          });\n          var BBe = ye((p_r, qBe) => {\n            "use strict";\n            qBe.exports = OBe();\n          });\n          var vK = ye((g_r, GBe) => {\n            "use strict";\n            var HUt = pf(), VBe = Tu(), NBe = df().axisHoverFormat, { hovertemplateAttrs: jUt, templatefallbackAttrs: WUt } = Ll(), kk = lk(), XUt = hd().idRegex, ZUt = vl().templatedArray, g5 = Ao().extendFlat, o1 = HUt.marker, YUt = o1.line, KUt = g5(VBe("marker.line", { editTypeOverride: "calc" }), { width: g5({}, YUt.width, { editType: "calc" }), editType: "calc" }), Ez = g5(VBe("marker"), { symbol: o1.symbol, angle: o1.angle, size: g5({}, o1.size, { editType: "markerSize" }), sizeref: o1.sizeref, sizemin: o1.sizemin, sizemode: o1.sizemode, opacity: o1.opacity, colorbar: o1.colorbar, line: KUt, editType: "calc" });\n            Ez.color.editType = Ez.cmin.editType = Ez.cmax.editType = "style";\n            function UBe(e3) {\n              return { valType: "info_array", freeLength: true, editType: "calc", items: { valType: "subplotid", regex: XUt[e3], editType: "plot" } };\n            }\n            GBe.exports = { dimensions: ZUt("dimension", { visible: { valType: "boolean", dflt: true, editType: "calc" }, label: { valType: "string", editType: "calc" }, values: { valType: "data_array", editType: "calc+clearAxisTypes" }, axis: { type: { valType: "enumerated", values: ["linear", "log", "date", "category"], editType: "calc+clearAxisTypes" }, matches: { valType: "boolean", dflt: false, editType: "calc" }, editType: "calc+clearAxisTypes" }, editType: "calc+clearAxisTypes" }), text: g5({}, kk.text, {}), hovertext: g5({}, kk.hovertext, {}), hovertemplate: jUt(), hovertemplatefallback: WUt(), xhoverformat: NBe("x"), yhoverformat: NBe("y"), marker: Ez, xaxes: UBe("x"), yaxes: UBe("y"), diagonal: { visible: { valType: "boolean", dflt: true, editType: "calc" }, editType: "calc" }, showupperhalf: { valType: "boolean", dflt: true, editType: "calc" }, showlowerhalf: { valType: "boolean", dflt: true, editType: "calc" }, selected: { marker: kk.selected.marker, editType: "calc" }, unselected: { marker: kk.unselected.marker, editType: "calc" }, opacity: kk.opacity };\n          });\n          var kz = ye((m_r, HBe) => {\n            "use strict";\n            HBe.exports = function(e3, t3, r4, n4) {\n              n4 || (n4 = 1 / 0);\n              var i3, a4;\n              for (i3 = 0; i3 < t3.length; i3++) a4 = t3[i3], a4.visible && (n4 = Math.min(n4, a4[r4].length));\n              for (n4 === 1 / 0 && (n4 = 0), e3._length = n4, i3 = 0; i3 < t3.length; i3++) a4 = t3[i3], a4.visible && (a4._length = n4);\n              return n4;\n            };\n          });\n          var XBe = ye((y_r, WBe) => {\n            "use strict";\n            var pK = Dr(), JUt = Yd(), jBe = vK(), $Ut = Ru(), QUt = $p(), eVt = kz(), tVt = VF().isOpenSymbol;\n            WBe.exports = function(t3, r4, n4, i3) {\n              function a4(d3, v3) {\n                return pK.coerce(t3, r4, jBe, d3, v3);\n              }\n              var o4 = JUt(t3, r4, { name: "dimensions", handleItemDefaults: rVt }), s3 = a4("diagonal.visible"), l3 = a4("showupperhalf"), u4 = a4("showlowerhalf"), c5 = eVt(r4, o4, "values");\n              if (!c5 || !s3 && !l3 && !u4) {\n                r4.visible = false;\n                return;\n              }\n              a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("xhoverformat"), a4("yhoverformat"), QUt(t3, r4, n4, i3, a4, { noAngleRef: true, noStandOff: true });\n              var f4 = tVt(r4.marker.symbol), h3 = $Ut.isBubble(r4);\n              a4("marker.line.width", f4 || h3 ? 1 : 0), iVt(t3, r4, i3, a4), pK.coerceSelectionMarkerOpacity(r4, a4);\n            };\n            function rVt(e3, t3) {\n              function r4(i3, a4) {\n                return pK.coerce(e3, t3, jBe.dimensions, i3, a4);\n              }\n              r4("label");\n              var n4 = r4("values");\n              n4 && n4.length ? r4("visible") : t3.visible = false, r4("axis.type"), r4("axis.matches");\n            }\n            function iVt(e3, t3, r4, n4) {\n              var i3 = t3.dimensions, a4 = i3.length, o4 = t3.showupperhalf, s3 = t3.showlowerhalf, l3 = t3.diagonal.visible, u4, c5, f4 = new Array(a4), h3 = new Array(a4);\n              for (u4 = 0; u4 < a4; u4++) {\n                var d3 = u4 ? u4 + 1 : "";\n                f4[u4] = "x" + d3, h3[u4] = "y" + d3;\n              }\n              var v3 = n4("xaxes", f4), _2 = n4("yaxes", h3), b = t3._diag = new Array(a4);\n              t3._xaxes = {}, t3._yaxes = {};\n              var p3 = [], k4 = [];\n              function E3(z3, O3, V2, G2) {\n                if (z3) {\n                  var Z = z3.charAt(0), j3 = r4._splomAxes[Z];\n                  if (t3["_" + Z + "axes"][z3] = 1, G2.push(z3), !(z3 in j3)) {\n                    var N2 = j3[z3] = {};\n                    V2 && (N2.label = V2.label || "", V2.visible && V2.axis && (V2.axis.type && (N2.type = V2.axis.type), V2.axis.matches && (N2.matches = O3)));\n                  }\n                }\n              }\n              var S2 = !l3 && !s3, L3 = !l3 && !o4;\n              for (t3._axesDim = {}, u4 = 0; u4 < a4; u4++) {\n                var x2 = i3[u4], C3 = u4 === 0, M4 = u4 === a4 - 1, g3 = C3 && S2 || M4 && L3 ? void 0 : v3[u4], P3 = C3 && L3 || M4 && S2 ? void 0 : _2[u4];\n                E3(g3, P3, x2, p3), E3(P3, g3, x2, k4), b[u4] = [g3, P3], t3._axesDim[g3] = u4, t3._axesDim[P3] = u4;\n              }\n              for (u4 = 0; u4 < p3.length; u4++) for (c5 = 0; c5 < k4.length; c5++) {\n                var T3 = p3[u4] + k4[c5];\n                (u4 > c5 && o4 || u4 < c5 && s3 || u4 === c5 && (l3 || !s3 || !o4)) && (r4._splomSubplots[T3] = 1);\n              }\n              (!s3 || !l3 && o4 && s3) && (r4._splomGridDflt.xside = "bottom", r4._splomGridDflt.yside = "left");\n            }\n          });\n          var KBe = ye((__r, YBe) => {\n            "use strict";\n            var ZBe = Dr();\n            YBe.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = r4.uid, a4 = n4._splomScenes;\n              a4 || (a4 = n4._splomScenes = {});\n              var o4 = { dirty: true, selectBatch: [], unselectBatch: [] }, s3 = { matrix: false, selectBatch: [], unselectBatch: [] }, l3 = a4[r4.uid];\n              return l3 || (l3 = a4[i3] = ZBe.extendFlat({}, o4, s3), l3.draw = function() {\n                l3.matrix && l3.matrix.draw && (l3.selectBatch.length || l3.unselectBatch.length ? l3.matrix.draw(l3.unselectBatch, l3.selectBatch) : l3.matrix.draw()), l3.dirty = false;\n              }, l3.destroy = function() {\n                l3.matrix && l3.matrix.destroy && l3.matrix.destroy(), l3.matrixOptions = null, l3.selectBatch = null, l3.unselectBatch = null, l3 = null;\n              }), l3.dirty || ZBe.extendFlat(l3, o4), l3;\n            };\n          });\n          var QBe = ye((x_r, $Be) => {\n            "use strict";\n            var gK = Dr(), Cz = hf(), nVt = O0().calcMarkerSize, aVt = O0().calcAxisExpansion, oVt = F0(), JBe = J2().markerSelection, sVt = J2().markerStyle, lVt = KBe(), uVt = fs().BADNUM, cVt = ox().TOO_MANY_POINTS;\n            $Be.exports = function(t3, r4) {\n              var n4 = r4.dimensions, i3 = r4._length, a4 = {}, o4 = a4.cdata = [], s3 = a4.data = [], l3 = r4._visibleDims = [], u4, c5, f4, h3, d3;\n              function v3(E3, S2) {\n                for (var L3 = E3.makeCalcdata({ v: S2.values, vcalendar: r4.calendar }, "v"), x2 = 0; x2 < L3.length; x2++) L3[x2] = L3[x2] === uVt ? NaN : L3[x2];\n                o4.push(L3), s3.push(E3.type === "log" ? gK.simpleMap(L3, E3.c2l) : L3);\n              }\n              for (u4 = 0; u4 < n4.length; u4++) if (f4 = n4[u4], f4.visible) {\n                if (h3 = Cz.getFromId(t3, r4._diag[u4][0]), d3 = Cz.getFromId(t3, r4._diag[u4][1]), h3 && d3 && h3.type !== d3.type) {\n                  gK.log("Skipping splom dimension " + u4 + " with conflicting axis types");\n                  continue;\n                }\n                h3 ? (v3(h3, f4), d3 && d3.type === "category" && (d3._categories = h3._categories.slice())) : v3(d3, f4), l3.push(u4);\n              }\n              oVt(t3, r4), gK.extendFlat(a4, sVt(t3, r4));\n              var _2 = o4.length, b = _2 * i3 > cVt, p3;\n              for (b ? p3 = a4.sizeAvg || Math.max(a4.size, 3) : p3 = nVt(r4, i3), c5 = 0; c5 < l3.length; c5++) u4 = l3[c5], f4 = n4[u4], h3 = Cz.getFromId(t3, r4._diag[u4][0]) || {}, d3 = Cz.getFromId(t3, r4._diag[u4][1]) || {}, aVt(t3, r4, h3, d3, o4[c5], o4[c5], p3);\n              var k4 = lVt(t3, r4);\n              return k4.matrix || (k4.matrix = true), k4.matrixOptions = a4, k4.selectedOptions = JBe(t3, r4, r4.selected), k4.unselectedOptions = JBe(t3, r4, r4.unselected), [{ x: false, y: false, t: {}, trace: r4 }];\n            };\n          });\n          var tNe = ye((eNe, Ck) => {\n            (function() {\n              var e3, t3, r4, n4, i3, a4;\n              typeof performance != "undefined" && performance !== null && performance.now ? Ck.exports = function() {\n                return performance.now();\n              } : typeof process != "undefined" && process !== null && process.hrtime ? (Ck.exports = function() {\n                return (e3() - i3) / 1e6;\n              }, t3 = process.hrtime, e3 = function() {\n                var o4;\n                return o4 = t3(), o4[0] * 1e9 + o4[1];\n              }, n4 = e3(), a4 = process.uptime() * 1e9, i3 = n4 - a4) : Date.now ? (Ck.exports = function() {\n                return Date.now() - r4;\n              }, r4 = Date.now()) : (Ck.exports = function() {\n                return (/* @__PURE__ */ new Date()).getTime() - r4;\n              }, r4 = (/* @__PURE__ */ new Date()).getTime());\n            }).call(eNe);\n          });\n          var iNe = ye((b_r, Iz) => {\n            var fVt = tNe(), s1 = window, Lz = ["moz", "webkit"], y5 = "AnimationFrame", _5 = s1["request" + y5], Lk = s1["cancel" + y5] || s1["cancelRequest" + y5];\n            for (m5 = 0; !_5 && m5 < Lz.length; m5++) _5 = s1[Lz[m5] + "Request" + y5], Lk = s1[Lz[m5] + "Cancel" + y5] || s1[Lz[m5] + "CancelRequest" + y5];\n            var m5;\n            (!_5 || !Lk) && (Pz = 0, mK = 0, vx = [], rNe = 1e3 / 60, _5 = function(e3) {\n              if (vx.length === 0) {\n                var t3 = fVt(), r4 = Math.max(0, rNe - (t3 - Pz));\n                Pz = r4 + t3, setTimeout(function() {\n                  var n4 = vx.slice(0);\n                  vx.length = 0;\n                  for (var i3 = 0; i3 < n4.length; i3++) if (!n4[i3].cancelled) try {\n                    n4[i3].callback(Pz);\n                  } catch (a4) {\n                    setTimeout(function() {\n                      throw a4;\n                    }, 0);\n                  }\n                }, Math.round(r4));\n              }\n              return vx.push({ handle: ++mK, callback: e3, cancelled: false }), mK;\n            }, Lk = function(e3) {\n              for (var t3 = 0; t3 < vx.length; t3++) vx[t3].handle === e3 && (vx[t3].cancelled = true);\n            });\n            var Pz, mK, vx, rNe;\n            Iz.exports = function(e3) {\n              return _5.call(s1, e3);\n            };\n            Iz.exports.cancel = function() {\n              Lk.apply(s1, arguments);\n            };\n            Iz.exports.polyfill = function(e3) {\n              e3 || (e3 = s1), e3.requestAnimationFrame = _5, e3.cancelAnimationFrame = Lk;\n            };\n          });\n          var aNe = ye((w_r, nNe) => {\n            nNe.exports = function(t3, r4) {\n              var n4 = typeof t3 == "number", i3 = typeof r4 == "number";\n              n4 && !i3 ? (r4 = t3, t3 = 0) : !n4 && !i3 && (t3 = 0, r4 = 0), t3 = t3 | 0, r4 = r4 | 0;\n              var a4 = r4 - t3;\n              if (a4 < 0) throw new Error("array length must be positive");\n              for (var o4 = new Array(a4), s3 = 0, l3 = t3; s3 < a4; s3++, l3++) o4[s3] = l3;\n              return o4;\n            };\n          });\n          var uNe = ye((T_r, lNe) => {\n            "use strict";\n            var hVt = hY(), dVt = Zm(), vVt = X2(), oNe = iNe(), pVt = aNe(), yK = i5(), gVt = Z2();\n            lNe.exports = px;\n            function px(e3, t3) {\n              if (!(this instanceof px)) return new px(e3, t3);\n              this.traces = [], this.passes = {}, this.regl = e3, this.scatter = hVt(e3), this.canvas = this.scatter.canvas;\n            }\n            px.prototype.render = function(...e3) {\n              return e3.length && this.update(...e3), this.regl.attributes.preserveDrawingBuffer ? this.draw() : (this.dirty ? this.planned == null && (this.planned = oNe(() => {\n                this.draw(), this.dirty = true, this.planned = null;\n              })) : (this.draw(), this.dirty = true, oNe(() => {\n                this.dirty = false;\n              })), this);\n            };\n            px.prototype.update = function(...e3) {\n              if (!e3.length) return;\n              for (let n4 = 0; n4 < e3.length; n4++) this.updateItem(n4, e3[n4]);\n              this.traces = this.traces.filter(Boolean);\n              let t3 = [], r4 = 0;\n              for (let n4 = 0; n4 < this.traces.length; n4++) {\n                let i3 = this.traces[n4], a4 = this.traces[n4].passes;\n                for (let o4 = 0; o4 < a4.length; o4++) t3.push(this.passes[a4[o4]]);\n                i3.passOffset = r4, r4 += i3.passes.length;\n              }\n              return this.scatter.update(...t3), this;\n            };\n            px.prototype.updateItem = function(e3, t3) {\n              let { regl: r4 } = this;\n              if (t3 === null) return this.traces[e3] = null, this;\n              if (!t3) return this;\n              let n4 = dVt(t3, { data: "data items columns rows values dimensions samples x", snap: "snap cluster", size: "sizes size radius", color: "colors color fill fill-color fillColor", opacity: "opacity alpha transparency opaque", borderSize: "borderSizes borderSize border-size bordersize borderWidth borderWidths border-width borderwidth stroke-width strokeWidth strokewidth outline", borderColor: "borderColors borderColor bordercolor stroke stroke-color strokeColor", marker: "markers marker shape", range: "range ranges databox dataBox", viewport: "viewport viewBox viewbox", domain: "domain domains area areas", padding: "pad padding paddings pads margin margins", transpose: "transpose transposed", diagonal: "diagonal diag showDiagonal", upper: "upper up top upperhalf upperHalf showupperhalf showUpper showUpperHalf", lower: "lower low bottom lowerhalf lowerHalf showlowerhalf showLowerHalf showLower" }), i3 = this.traces[e3] || (this.traces[e3] = { id: e3, buffer: r4.buffer({ usage: "dynamic", type: "float", data: new Uint8Array() }), color: "black", marker: null, size: 12, borderColor: "transparent", borderSize: 1, viewport: yK([r4._gl.drawingBufferWidth, r4._gl.drawingBufferHeight]), padding: [0, 0, 0, 0], opacity: 1, diagonal: true, upper: true, lower: true });\n              if (n4.color != null && (i3.color = n4.color), n4.size != null && (i3.size = n4.size), n4.marker != null && (i3.marker = n4.marker), n4.borderColor != null && (i3.borderColor = n4.borderColor), n4.borderSize != null && (i3.borderSize = n4.borderSize), n4.opacity != null && (i3.opacity = n4.opacity), n4.viewport && (i3.viewport = yK(n4.viewport)), n4.diagonal != null && (i3.diagonal = n4.diagonal), n4.upper != null && (i3.upper = n4.upper), n4.lower != null && (i3.lower = n4.lower), n4.data) {\n                i3.buffer(gVt(n4.data)), i3.columns = n4.data.length, i3.count = n4.data[0].length, i3.bounds = [];\n                for (let _2 = 0; _2 < i3.columns; _2++) i3.bounds[_2] = vVt(n4.data[_2], 1);\n              }\n              let a4;\n              n4.range && (i3.range = n4.range, a4 = i3.range && typeof i3.range[0] != "number"), n4.domain && (i3.domain = n4.domain);\n              let o4 = false;\n              n4.padding != null && (Array.isArray(n4.padding) && n4.padding.length === i3.columns && typeof n4.padding[n4.padding.length - 1] == "number" ? (i3.padding = n4.padding.map(sNe), o4 = true) : i3.padding = sNe(n4.padding));\n              let s3 = i3.columns, l3 = i3.count, u4 = i3.viewport.width, c5 = i3.viewport.height, f4 = i3.viewport.x, h3 = i3.viewport.y, d3 = u4 / s3, v3 = c5 / s3;\n              i3.passes = [];\n              for (let _2 = 0; _2 < s3; _2++) for (let b = 0; b < s3; b++) {\n                if (!i3.diagonal && b === _2 || !i3.upper && _2 > b || !i3.lower && _2 < b) continue;\n                let p3 = mVt(i3.id, _2, b), k4 = this.passes[p3] || (this.passes[p3] = {});\n                if (n4.data && (n4.transpose ? k4.positions = { x: { buffer: i3.buffer, offset: b, count: l3, stride: s3 }, y: { buffer: i3.buffer, offset: _2, count: l3, stride: s3 } } : k4.positions = { x: { buffer: i3.buffer, offset: b * l3, count: l3 }, y: { buffer: i3.buffer, offset: _2 * l3, count: l3 } }, k4.bounds = Rz(i3.bounds, _2, b)), n4.domain || n4.viewport || n4.data) {\n                  let E3 = o4 ? Rz(i3.padding, _2, b) : i3.padding;\n                  if (i3.domain) {\n                    let [S2, L3, x2, C3] = Rz(i3.domain, _2, b);\n                    k4.viewport = [f4 + S2 * u4 + E3[0], h3 + L3 * c5 + E3[1], f4 + x2 * u4 - E3[2], h3 + C3 * c5 - E3[3]];\n                  } else k4.viewport = [f4 + b * d3 + d3 * E3[0], h3 + _2 * v3 + v3 * E3[1], f4 + (b + 1) * d3 - d3 * E3[2], h3 + (_2 + 1) * v3 - v3 * E3[3]];\n                }\n                n4.color && (k4.color = i3.color), n4.size && (k4.size = i3.size), n4.marker && (k4.marker = i3.marker), n4.borderSize && (k4.borderSize = i3.borderSize), n4.borderColor && (k4.borderColor = i3.borderColor), n4.opacity && (k4.opacity = i3.opacity), n4.range && (k4.range = a4 ? Rz(i3.range, _2, b) : i3.range || k4.bounds), i3.passes.push(p3);\n              }\n              return this;\n            };\n            px.prototype.draw = function(...e3) {\n              if (!e3.length) this.scatter.draw();\n              else {\n                let t3 = [];\n                for (let r4 = 0; r4 < e3.length; r4++) if (typeof e3[r4] == "number") {\n                  let { passes: n4, passOffset: i3 } = this.traces[e3[r4]];\n                  t3.push(...pVt(i3, i3 + n4.length));\n                } else if (e3[r4].length) {\n                  let n4 = e3[r4], { passes: i3, passOffset: a4 } = this.traces[r4];\n                  i3 = i3.map((o4, s3) => {\n                    t3[a4 + s3] = n4;\n                  });\n                }\n                this.scatter.draw(...t3);\n              }\n              return this;\n            };\n            px.prototype.destroy = function() {\n              return this.traces.forEach((e3) => {\n                e3.buffer && e3.buffer.destroy && e3.buffer.destroy();\n              }), this.traces = null, this.passes = null, this.scatter.destroy(), this;\n            };\n            function mVt(e3, t3, r4) {\n              let n4 = e3.id != null ? e3.id : e3, i3 = t3, a4 = r4;\n              return n4 << 16 | (i3 & 255) << 8 | a4 & 255;\n            }\n            function Rz(e3, t3, r4) {\n              let n4, i3, a4, o4, s3, l3, u4, c5, f4 = e3[t3], h3 = e3[r4];\n              return f4.length > 2 ? (n4 = f4[0], a4 = f4[2], i3 = f4[1], o4 = f4[3]) : f4.length ? (n4 = i3 = f4[0], a4 = o4 = f4[1]) : (n4 = f4.x, i3 = f4.y, a4 = f4.x + f4.width, o4 = f4.y + f4.height), h3.length > 2 ? (s3 = h3[0], u4 = h3[2], l3 = h3[1], c5 = h3[3]) : h3.length ? (s3 = l3 = h3[0], u4 = c5 = h3[1]) : (s3 = h3.x, l3 = h3.y, u4 = h3.x + h3.width, c5 = h3.y + h3.height), [s3, i3, u4, o4];\n            }\n            function sNe(e3) {\n              if (typeof e3 == "number") return [e3, e3, e3, e3];\n              if (e3.length === 2) return [e3[0], e3[1], e3[0], e3[1]];\n              {\n                let t3 = yK(e3);\n                return [t3.x, t3.y, t3.x + t3.width, t3.y + t3.height];\n              }\n            }\n          });\n          var fNe = ye((A_r, cNe) => {\n            "use strict";\n            var yVt = uNe(), _K = Dr(), Dz = hf(), _Vt = Eg().selectMode;\n            cNe.exports = function(t3, r4, n4) {\n              if (n4.length) for (var i3 = 0; i3 < n4.length; i3++) xVt(t3, n4[i3][0]);\n            };\n            function xVt(e3, t3) {\n              var r4 = e3._fullLayout, n4 = r4._size, i3 = t3.trace, a4 = t3.t, o4 = r4._splomScenes[i3.uid], s3 = o4.matrixOptions, l3 = s3.cdata, u4 = r4._glcanvas.data()[0].regl, c5 = r4.dragmode, f4, h3, d3, v3, _2;\n              if (l3.length !== 0) {\n                s3.lower = i3.showupperhalf, s3.upper = i3.showlowerhalf, s3.diagonal = i3.diagonal.visible;\n                var b = i3._visibleDims, p3 = l3.length, k4 = o4.viewOpts = {};\n                for (k4.ranges = new Array(p3), k4.domains = new Array(p3), _2 = 0; _2 < b.length; _2++) {\n                  d3 = b[_2];\n                  var E3 = k4.ranges[_2] = new Array(4), S2 = k4.domains[_2] = new Array(4);\n                  f4 = Dz.getFromId(e3, i3._diag[d3][0]), f4 && (E3[0] = f4._rl[0], E3[2] = f4._rl[1], S2[0] = f4.domain[0], S2[2] = f4.domain[1]), h3 = Dz.getFromId(e3, i3._diag[d3][1]), h3 && (E3[1] = h3._rl[0], E3[3] = h3._rl[1], S2[1] = h3.domain[0], S2[3] = h3.domain[1]);\n                }\n                var L3 = e3._context.plotGlPixelRatio, x2 = n4.l * L3, C3 = n4.b * L3, M4 = n4.w * L3, g3 = n4.h * L3;\n                k4.viewport = [x2, C3, M4 + x2, g3 + C3], o4.matrix === true && (o4.matrix = yVt(u4));\n                var P3 = r4.clickmode.indexOf("select") > -1, T3 = _Vt(c5) || !!i3.selectedpoints || P3, z3 = true;\n                if (T3) {\n                  var O3 = i3._length;\n                  if (i3.selectedpoints) {\n                    o4.selectBatch = i3.selectedpoints;\n                    var V2 = i3.selectedpoints, G2 = {};\n                    for (d3 = 0; d3 < V2.length; d3++) G2[V2[d3]] = true;\n                    var Z = [];\n                    for (d3 = 0; d3 < O3; d3++) G2[d3] || Z.push(d3);\n                    o4.unselectBatch = Z;\n                  }\n                  var j3 = a4.xpx = new Array(p3), N2 = a4.ypx = new Array(p3);\n                  for (_2 = 0; _2 < b.length; _2++) {\n                    if (d3 = b[_2], f4 = Dz.getFromId(e3, i3._diag[d3][0]), f4) for (j3[_2] = new Array(O3), v3 = 0; v3 < O3; v3++) j3[_2][v3] = f4.c2p(l3[_2][v3]);\n                    if (h3 = Dz.getFromId(e3, i3._diag[d3][1]), h3) for (N2[_2] = new Array(O3), v3 = 0; v3 < O3; v3++) N2[_2][v3] = h3.c2p(l3[_2][v3]);\n                  }\n                  if (o4.selectBatch.length || o4.unselectBatch.length) {\n                    var H = _K.extendFlat({}, s3, o4.unselectedOptions, k4), te = _K.extendFlat({}, s3, o4.selectedOptions, k4);\n                    o4.matrix.update(H, te), z3 = false;\n                  }\n                } else a4.xpx = a4.ypx = null;\n                if (z3) {\n                  var oe = _K.extendFlat({}, s3, k4);\n                  o4.matrix.update(oe, null);\n                }\n              }\n            }\n          });\n          var xK = ye((hNe) => {\n            "use strict";\n            hNe.getDimIndex = function(t3, r4) {\n              for (var n4 = r4._id, i3 = n4.charAt(0), a4 = { x: 0, y: 1 }[i3], o4 = t3._visibleDims, s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3];\n                if (t3._diag[l3][a4] === n4) return s3;\n              }\n              return false;\n            };\n          });\n          var mNe = ye((M_r, gNe) => {\n            "use strict";\n            var dNe = xK(), bVt = UF().calcHover, vNe = ho().getFromId, wVt = Ao().extendFlat;\n            function TVt(e3, t3, r4, n4, i3) {\n              i3 || (i3 = {});\n              var a4 = (n4 || "").charAt(0) === "x", o4 = (n4 || "").charAt(0) === "y", s3 = pNe(e3, t3, r4);\n              if ((a4 || o4) && i3.hoversubplots === "axis" && s3[0]) for (var l3 = (a4 ? e3.xa : e3.ya)._subplotsWith, u4 = i3.gd, c5 = wVt({}, e3), f4 = 0; f4 < l3.length; f4++) {\n                var h3 = l3[f4];\n                if (h3 !== e3.xa._id + e3.ya._id) {\n                  o4 ? c5.xa = vNe(u4, h3, "x") : c5.ya = vNe(u4, h3, "y");\n                  var d3 = a4 || o4, v3 = pNe(c5, t3, r4, d3);\n                  s3 = s3.concat(v3);\n                }\n              }\n              return s3;\n            }\n            function pNe(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = i3[0].trace, o4 = e3.scene, s3 = o4.matrixOptions.cdata, l3 = e3.xa, u4 = e3.ya, c5 = l3.c2p(t3), f4 = u4.c2p(r4), h3 = e3.distance, d3 = dNe.getDimIndex(a4, l3), v3 = dNe.getDimIndex(a4, u4);\n              if (d3 === false || v3 === false) return [e3];\n              for (var _2 = s3[d3], b = s3[v3], p3, k4, E3 = h3, S2 = 0; S2 < _2.length; S2++) if (!(n4 && S2 !== e3.index)) {\n                var L3 = _2[S2], x2 = b[S2], C3 = l3.c2p(L3) - c5, M4 = u4.c2p(x2) - f4, g3 = Math.sqrt(C3 * C3 + M4 * M4);\n                (n4 || g3 < E3) && (E3 = k4 = g3, p3 = S2);\n              }\n              return e3.index = p3, e3.distance = E3, e3.dxy = k4, p3 === void 0 ? [e3] : [bVt(e3, _2, b, a4)];\n            }\n            gNe.exports = { hoverPoints: TVt };\n          });\n          var TNe = ye((E_r, wNe) => {\n            "use strict";\n            var bNe = Dr(), yNe = bNe.pushUnique, _Ne = Ru(), xNe = xK();\n            wNe.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = n4[0].trace, a4 = n4[0].t, o4 = t3.scene, s3 = o4.matrixOptions.cdata, l3 = t3.xaxis, u4 = t3.yaxis, c5 = [];\n              if (!o4) return c5;\n              var f4 = !_Ne.hasMarkers(i3) && !_Ne.hasText(i3);\n              if (i3.visible !== true || f4) return c5;\n              var h3 = xNe.getDimIndex(i3, l3), d3 = xNe.getDimIndex(i3, u4);\n              if (h3 === false || d3 === false) return c5;\n              var v3 = a4.xpx[h3], _2 = a4.ypx[d3], b = s3[h3], p3 = s3[d3], k4 = (t3.scene.selectBatch || []).slice(), E3 = [];\n              if (r4 !== false && !r4.degenerate) for (var S2 = 0; S2 < b.length; S2++) r4.contains([v3[S2], _2[S2]], null, S2, t3) ? (c5.push({ pointNumber: S2, x: b[S2], y: p3[S2] }), yNe(k4, S2)) : k4.indexOf(S2) !== -1 ? yNe(k4, S2) : E3.push(S2);\n              var L3 = o4.matrixOptions;\n              return !k4.length && !E3.length ? o4.matrix.update(L3, null) : !o4.selectBatch.length && !o4.unselectBatch.length && o4.matrix.update(o4.unselectedOptions, bNe.extendFlat({}, L3, o4.selectedOptions, o4.viewOpts)), o4.selectBatch = k4, o4.unselectBatch = E3, c5;\n            };\n          });\n          var MNe = ye((k_r, SNe) => {\n            "use strict";\n            var ANe = Dr(), AVt = F0(), SVt = J2().markerStyle;\n            SNe.exports = function(t3, r4) {\n              var n4 = r4.trace, i3 = t3._fullLayout._splomScenes[n4.uid];\n              if (i3) {\n                AVt(t3, n4), ANe.extendFlat(i3.matrixOptions, SVt(t3, n4));\n                var a4 = ANe.extendFlat({}, i3.matrixOptions, i3.viewOpts);\n                i3.matrix.update(a4, null);\n              }\n            };\n          });\n          var kNe = ye((C_r, ENe) => {\n            "use strict";\n            var MVt = qa(), EVt = fV();\n            ENe.exports = { moduleType: "trace", name: "splom", categories: ["gl", "regl", "cartesian", "symbols", "showLegend", "scatter-like"], attributes: vK(), supplyDefaults: XBe(), colorbar: $d(), calc: QBe(), plot: fNe(), hoverPoints: mNe().hoverPoints, selectPoints: TNe(), editStyle: MNe(), meta: {} };\n            MVt.register(EVt);\n          });\n          var DNe = ye((L_r, RNe) => {\n            "use strict";\n            var kVt = GY(), CVt = qa(), LVt = Mz(), PVt = Id().getModuleCalcData, gx = ph(), CNe = hf().getFromId, LNe = ho().shouldShowZeroLine, PNe = "splom", INe = {};\n            function IVt(e3) {\n              var t3 = e3._fullLayout, r4 = CVt.getModule(PNe), n4 = PVt(e3.calcdata, r4)[0], i3 = LVt(e3, ["ANGLE_instanced_arrays", "OES_element_index_uint"], INe);\n              i3 && (t3._hasOnlyLargeSploms && bK(e3), r4.plot(e3, {}, n4));\n            }\n            function RVt(e3) {\n              var t3 = e3.calcdata, r4 = e3._fullLayout;\n              r4._hasOnlyLargeSploms && bK(e3);\n              for (var n4 = 0; n4 < t3.length; n4++) {\n                var i3 = t3[n4][0], a4 = i3.trace, o4 = r4._splomScenes[a4.uid];\n                a4.type === "splom" && o4 && o4.matrix && DVt(e3, a4, o4);\n              }\n            }\n            function DVt(e3, t3, r4) {\n              for (var n4 = r4.matrixOptions.data.length, i3 = t3._visibleDims, a4 = r4.viewOpts.ranges = new Array(n4), o4 = 0; o4 < i3.length; o4++) {\n                var s3 = i3[o4], l3 = a4[o4] = new Array(4), u4 = CNe(e3, t3._diag[s3][0]);\n                u4 && (l3[0] = u4.r2l(u4.range[0]), l3[2] = u4.r2l(u4.range[1]));\n                var c5 = CNe(e3, t3._diag[s3][1]);\n                c5 && (l3[1] = c5.r2l(c5.range[0]), l3[3] = c5.r2l(c5.range[1]));\n              }\n              r4.selectBatch.length || r4.unselectBatch.length ? r4.matrix.update({ ranges: a4 }, { ranges: a4 }) : r4.matrix.update({ ranges: a4 });\n            }\n            function bK(e3) {\n              var t3 = e3._fullLayout, r4 = t3._glcanvas.data()[0].regl, n4 = t3._splomGrid;\n              n4 || (n4 = t3._splomGrid = kVt(r4)), n4.update(FVt(e3));\n            }\n            function FVt(e3) {\n              var t3 = e3._context.plotGlPixelRatio, r4 = e3._fullLayout, n4 = r4._size, i3 = [0, 0, r4.width * t3, r4.height * t3], a4 = {}, o4;\n              function s3(x2, C3, M4, g3, P3, T3) {\n                M4 *= t3, g3 *= t3, P3 *= t3, T3 *= t3;\n                var z3 = C3[x2 + "color"], O3 = C3[x2 + "width"], V2 = String(z3 + O3);\n                V2 in a4 ? a4[V2].data.push(NaN, NaN, M4, g3, P3, T3) : a4[V2] = { data: [M4, g3, P3, T3], join: "rect", thickness: O3 * t3, color: z3, viewport: i3, range: i3, overlay: false };\n              }\n              for (o4 in r4._splomSubplots) {\n                var l3 = r4._plots[o4], u4 = l3.xaxis, c5 = l3.yaxis, f4 = u4._gridVals, h3 = c5._gridVals, d3 = u4._offset, v3 = u4._length, _2 = c5._length, b = n4.b + c5.domain[0] * n4.h, p3 = -c5._m, k4 = -p3 * c5.r2l(c5.range[0], c5.calendar), E3, S2;\n                if (u4.showgrid) for (o4 = 0; o4 < f4.length; o4++) E3 = d3 + u4.l2p(f4[o4].x), s3("grid", u4, E3, b, E3, b + _2);\n                if (c5.showgrid) for (o4 = 0; o4 < h3.length; o4++) S2 = b + k4 + p3 * h3[o4].x, s3("grid", c5, d3, S2, d3 + v3, S2);\n                LNe(e3, u4, c5) && (E3 = d3 + u4.l2p(0), s3("zeroline", u4, E3, b, E3, b + _2)), LNe(e3, c5, u4) && (S2 = b + k4 + 0, s3("zeroline", c5, d3, S2, d3 + v3, S2));\n              }\n              var L3 = [];\n              for (o4 in a4) L3.push(a4[o4]);\n              return L3;\n            }\n            function zVt(e3, t3, r4, n4) {\n              var i3 = {}, a4;\n              if (n4._splomScenes) {\n                for (a4 = 0; a4 < e3.length; a4++) {\n                  var o4 = e3[a4];\n                  o4.type === "splom" && (i3[o4.uid] = 1);\n                }\n                for (a4 = 0; a4 < r4.length; a4++) {\n                  var s3 = r4[a4];\n                  if (!i3[s3.uid]) {\n                    var l3 = n4._splomScenes[s3.uid];\n                    l3 && l3.destroy && l3.destroy(), n4._splomScenes[s3.uid] = null, delete n4._splomScenes[s3.uid];\n                  }\n                }\n              }\n              Object.keys(n4._splomScenes || {}).length === 0 && delete n4._splomScenes, n4._splomGrid && !t3._hasOnlyLargeSploms && n4._hasOnlyLargeSploms && (n4._splomGrid.destroy(), n4._splomGrid = null, delete n4._splomGrid), gx.clean(e3, t3, r4, n4);\n            }\n            RNe.exports = { name: PNe, attr: gx.attr, attrRegex: gx.attrRegex, layoutAttributes: gx.layoutAttributes, supplyLayoutDefaults: gx.supplyLayoutDefaults, drawFramework: gx.drawFramework, plot: IVt, drag: RVt, updateGrid: bK, clean: zVt, updateFx: gx.updateFx, toSVG: gx.toSVG, reglPrecompiled: INe };\n          });\n          var ONe = ye((P_r, zNe) => {\n            "use strict";\n            var FNe = kNe();\n            FNe.basePlotModule = DNe(), zNe.exports = FNe;\n          });\n          var BNe = ye((I_r, qNe) => {\n            "use strict";\n            qNe.exports = ONe();\n          });\n          var AK = ye((R_r, NNe) => {\n            "use strict";\n            var OVt = Tu(), wK = Rd(), TK = ec(), qVt = Cc().attributes, Fz = Ao().extendFlat, BVt = vl().templatedArray;\n            NNe.exports = { domain: qVt({ name: "parcoords", trace: true, editType: "plot" }), labelangle: { valType: "angle", dflt: 0, editType: "plot" }, labelside: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, labelfont: TK({ editType: "plot" }), tickfont: TK({ autoShadowDflt: true, editType: "plot" }), rangefont: TK({ editType: "plot" }), dimensions: BVt("dimension", { label: { valType: "string", editType: "plot" }, tickvals: Fz({}, wK.tickvals, { editType: "plot" }), ticktext: Fz({}, wK.ticktext, { editType: "plot" }), tickformat: Fz({}, wK.tickformat, { editType: "plot" }), visible: { valType: "boolean", dflt: true, editType: "plot" }, range: { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], editType: "plot" }, constraintrange: { valType: "info_array", freeLength: true, dimensions: "1-2", items: [{ valType: "any", editType: "plot" }, { valType: "any", editType: "plot" }], editType: "plot" }, multiselect: { valType: "boolean", dflt: true, editType: "plot" }, values: { valType: "data_array", editType: "calc" }, editType: "calc" }), line: Fz({ editType: "calc" }, OVt("line", { colorscaleDflt: "Viridis", autoColorDflt: false, editTypeOverride: "calc" })), unselected: { line: { color: { valType: "color", dflt: "#7f7f7f", editType: "plot" }, opacity: { valType: "number", min: 0, max: 1, dflt: "auto", editType: "plot" }, editType: "plot" }, editType: "plot" } };\n          });\n          var Pk = ye((D_r, UNe) => {\n            "use strict";\n            UNe.exports = { maxDimensionCount: 60, overdrag: 45, verticalPadding: 2, tickDistance: 50, canvasPixelRatio: 1, blockLineCount: 5e3, layers: ["contextLineLayer", "focusLineLayer", "pickLineLayer"], axisTitleOffset: 28, axisExtentOffset: 10, bar: { width: 4, captureWidth: 10, fillColor: "magenta", fillOpacity: 1, snapDuration: 150, snapRatio: 0.25, snapClose: 0.01, strokeOpacity: 1, strokeWidth: 1, handleHeight: 8, handleOpacity: 1, handleOverlap: 0 }, cn: { axisExtentText: "axis-extent-text", parcoordsLineLayers: "parcoords-line-layers", parcoordsLineLayer: "parcoords-lines", parcoords: "parcoords", parcoordsControlView: "parcoords-control-view", yAxis: "y-axis", axisOverlays: "axis-overlays", axis: "axis", axisHeading: "axis-heading", axisTitle: "axis-title", axisExtent: "axis-extent", axisExtentTop: "axis-extent-top", axisExtentTopText: "axis-extent-top-text", axisExtentBottom: "axis-extent-bottom", axisExtentBottomText: "axis-extent-bottom-text", axisBrush: "axis-brush" }, id: { filterBarPattern: "filter-bar-pattern" } };\n          });\n          var Jm = ye((F_r, GNe) => {\n            "use strict";\n            var NVt = HS();\n            function VNe(e3) {\n              return [e3];\n            }\n            GNe.exports = { keyFun: function(e3) {\n              return e3.key;\n            }, repeat: VNe, descend: NVt, wrap: VNe, unwrap: function(e3) {\n              return e3[0];\n            } };\n          });\n          var EK = ye((z_r, eUe) => {\n            "use strict";\n            var bh = Pk(), tm = Oa(), UVt = Jm().keyFun, zz = Jm().repeat, x5 = Dr().sorterAsc, VVt = Dr().strTranslate, HNe = bh.bar.snapRatio;\n            function jNe(e3, t3) {\n              return e3 * (1 - HNe) + t3 * HNe;\n            }\n            var WNe = bh.bar.snapClose;\n            function GVt(e3, t3) {\n              return e3 * (1 - WNe) + t3 * WNe;\n            }\n            function qz(e3, t3, r4, n4) {\n              if (HVt(r4, n4)) return r4;\n              var i3 = e3 ? -1 : 1, a4 = 0, o4 = t3.length - 1;\n              if (i3 < 0) {\n                var s3 = a4;\n                a4 = o4, o4 = s3;\n              }\n              for (var l3 = t3[a4], u4 = l3, c5 = a4; i3 * c5 < i3 * o4; c5 += i3) {\n                var f4 = c5 + i3, h3 = t3[f4];\n                if (i3 * r4 < i3 * GVt(l3, h3)) return jNe(l3, u4);\n                if (i3 * r4 < i3 * h3 || f4 === o4) return jNe(h3, l3);\n                u4 = l3, l3 = h3;\n              }\n            }\n            function HVt(e3, t3) {\n              for (var r4 = 0; r4 < t3.length; r4++) if (e3 >= t3[r4][0] && e3 <= t3[r4][1]) return true;\n              return false;\n            }\n            function jVt(e3) {\n              e3.attr("x", -bh.bar.captureWidth / 2).attr("width", bh.bar.captureWidth);\n            }\n            function WVt(e3) {\n              e3.attr("visibility", "visible").style("visibility", "visible").attr("fill", "yellow").attr("opacity", 0);\n            }\n            function XVt(e3) {\n              if (!e3.brush.filterSpecified) return "0," + e3.height;\n              for (var t3 = XNe(e3.brush.filter.getConsolidated(), e3.height), r4 = [0], n4, i3, a4, o4 = t3.length ? t3[0][0] : null, s3 = 0; s3 < t3.length; s3++) n4 = t3[s3], i3 = n4[1] - n4[0], r4.push(o4), r4.push(i3), a4 = s3 + 1, a4 < t3.length && (o4 = t3[a4][0] - n4[1]);\n              return r4.push(e3.height), r4;\n            }\n            function XNe(e3, t3) {\n              return e3.map(function(r4) {\n                return r4.map(function(n4) {\n                  return Math.max(0, n4 * t3);\n                }).sort(x5);\n              });\n            }\n            function ZVt(e3, t3) {\n              var r4 = bh.bar.handleHeight;\n              if (!(t3 > e3[1] + r4 || t3 < e3[0] - r4)) return t3 >= 0.9 * e3[1] + 0.1 * e3[0] ? "n" : t3 <= 0.9 * e3[0] + 0.1 * e3[1] ? "s" : "ns";\n            }\n            function ZNe() {\n              tm.select(document.body).style("cursor", null);\n            }\n            function MK(e3) {\n              e3.attr("stroke-dasharray", XVt);\n            }\n            function Oz(e3, t3) {\n              var r4 = tm.select(e3).selectAll(".highlight, .highlight-shadow"), n4 = t3 ? r4.transition().duration(bh.bar.snapDuration).each("end", t3) : r4;\n              MK(n4);\n            }\n            function YNe(e3, t3) {\n              var r4 = e3.brush, n4 = r4.filterSpecified, i3 = NaN, a4 = {}, o4;\n              if (n4) {\n                var s3 = e3.height, l3 = r4.filter.getConsolidated(), u4 = XNe(l3, s3), c5 = NaN, f4 = NaN, h3 = NaN;\n                for (o4 = 0; o4 <= u4.length; o4++) {\n                  var d3 = u4[o4];\n                  if (d3 && d3[0] <= t3 && t3 <= d3[1]) {\n                    c5 = o4;\n                    break;\n                  } else if (f4 = o4 ? o4 - 1 : NaN, d3 && d3[0] > t3) {\n                    h3 = o4;\n                    break;\n                  }\n                }\n                if (i3 = c5, isNaN(i3) && (isNaN(f4) || isNaN(h3) ? i3 = isNaN(f4) ? h3 : f4 : i3 = t3 - u4[f4][1] < u4[h3][0] - t3 ? f4 : h3), !isNaN(i3)) {\n                  var v3 = u4[i3], _2 = ZVt(v3, t3);\n                  _2 && (a4.interval = l3[i3], a4.intervalPix = v3, a4.region = _2);\n                }\n              }\n              if (e3.ordinal && !a4.region) {\n                var b = e3.unitTickvals, p3 = e3.unitToPaddedPx.invert(t3);\n                for (o4 = 0; o4 < b.length; o4++) {\n                  var k4 = [b[Math.max(o4 - 1, 0)] * 0.25 + b[o4] * 0.75, b[Math.min(o4 + 1, b.length - 1)] * 0.25 + b[o4] * 0.75];\n                  if (p3 >= k4[0] && p3 <= k4[1]) {\n                    a4.clickableOrdinalRange = k4;\n                    break;\n                  }\n                }\n              }\n              return a4;\n            }\n            function YVt(e3, t3) {\n              tm.event.sourceEvent.stopPropagation();\n              var r4 = t3.height - tm.mouse(e3)[1] - 2 * bh.verticalPadding, n4 = t3.unitToPaddedPx.invert(r4), i3 = t3.brush, a4 = YNe(t3, r4), o4 = a4.interval, s3 = i3.svgBrush;\n              if (s3.wasDragged = false, s3.grabbingBar = a4.region === "ns", s3.grabbingBar) {\n                var l3 = o4.map(t3.unitToPaddedPx);\n                s3.grabPoint = r4 - l3[0] - bh.verticalPadding, s3.barLength = l3[1] - l3[0];\n              }\n              s3.clickableOrdinalRange = a4.clickableOrdinalRange, s3.stayingIntervals = t3.multiselect && i3.filterSpecified ? i3.filter.getConsolidated() : [], o4 && (s3.stayingIntervals = s3.stayingIntervals.filter(function(u4) {\n                return u4[0] !== o4[0] && u4[1] !== o4[1];\n              })), s3.startExtent = a4.region ? o4[a4.region === "s" ? 1 : 0] : n4, t3.parent.inBrushDrag = true, s3.brushStartCallback();\n            }\n            function KNe(e3, t3) {\n              tm.event.sourceEvent.stopPropagation();\n              var r4 = t3.height - tm.mouse(e3)[1] - 2 * bh.verticalPadding, n4 = t3.brush.svgBrush;\n              n4.wasDragged = true, n4._dragging = true, n4.grabbingBar ? n4.newExtent = [r4 - n4.grabPoint, r4 + n4.barLength - n4.grabPoint].map(t3.unitToPaddedPx.invert) : n4.newExtent = [n4.startExtent, t3.unitToPaddedPx.invert(r4)].sort(x5), t3.brush.filterSpecified = true, n4.extent = n4.stayingIntervals.concat([n4.newExtent]), n4.brushCallback(t3), Oz(e3.parentNode);\n            }\n            function KVt(e3, t3) {\n              var r4 = t3.brush, n4 = r4.filter, i3 = r4.svgBrush;\n              i3._dragging || (JNe(e3, t3), KNe(e3, t3), t3.brush.svgBrush.wasDragged = false), i3._dragging = false;\n              var a4 = tm.event;\n              a4.sourceEvent.stopPropagation();\n              var o4 = i3.grabbingBar;\n              if (i3.grabbingBar = false, i3.grabLocation = void 0, t3.parent.inBrushDrag = false, ZNe(), !i3.wasDragged) {\n                i3.wasDragged = void 0, i3.clickableOrdinalRange ? r4.filterSpecified && t3.multiselect ? i3.extent.push(i3.clickableOrdinalRange) : (i3.extent = [i3.clickableOrdinalRange], r4.filterSpecified = true) : o4 ? (i3.extent = i3.stayingIntervals, i3.extent.length === 0 && SK(r4)) : SK(r4), i3.brushCallback(t3), Oz(e3.parentNode), i3.brushEndCallback(r4.filterSpecified ? n4.getConsolidated() : []);\n                return;\n              }\n              var s3 = function() {\n                n4.set(n4.getConsolidated());\n              };\n              if (t3.ordinal) {\n                var l3 = t3.unitTickvals;\n                l3[l3.length - 1] < l3[0] && l3.reverse(), i3.newExtent = [qz(0, l3, i3.newExtent[0], i3.stayingIntervals), qz(1, l3, i3.newExtent[1], i3.stayingIntervals)];\n                var u4 = i3.newExtent[1] > i3.newExtent[0];\n                i3.extent = i3.stayingIntervals.concat(u4 ? [i3.newExtent] : []), i3.extent.length || SK(r4), i3.brushCallback(t3), u4 ? Oz(e3.parentNode, s3) : (s3(), Oz(e3.parentNode));\n              } else s3();\n              i3.brushEndCallback(r4.filterSpecified ? n4.getConsolidated() : []);\n            }\n            function JNe(e3, t3) {\n              var r4 = t3.height - tm.mouse(e3)[1] - 2 * bh.verticalPadding, n4 = YNe(t3, r4), i3 = "crosshair";\n              n4.clickableOrdinalRange ? i3 = "pointer" : n4.region && (i3 = n4.region + "-resize"), tm.select(document.body).style("cursor", i3);\n            }\n            function JVt(e3) {\n              e3.on("mousemove", function(t3) {\n                tm.event.preventDefault(), t3.parent.inBrushDrag || JNe(this, t3);\n              }).on("mouseleave", function(t3) {\n                t3.parent.inBrushDrag || ZNe();\n              }).call(tm.behavior.drag().on("dragstart", function(t3) {\n                YVt(this, t3);\n              }).on("drag", function(t3) {\n                KNe(this, t3);\n              }).on("dragend", function(t3) {\n                KVt(this, t3);\n              }));\n            }\n            function $Ne(e3, t3) {\n              return e3[0] - t3[0];\n            }\n            function $Vt(e3, t3, r4) {\n              var n4 = r4._context.staticPlot, i3 = e3.selectAll(".background").data(zz);\n              i3.enter().append("rect").classed("background", true).call(jVt).call(WVt).style("pointer-events", n4 ? "none" : "auto").attr("transform", VVt(0, bh.verticalPadding)), i3.call(JVt).attr("height", function(s3) {\n                return s3.height - bh.verticalPadding;\n              });\n              var a4 = e3.selectAll(".highlight-shadow").data(zz);\n              a4.enter().append("line").classed("highlight-shadow", true).attr("x", -bh.bar.width / 2).attr("stroke-width", bh.bar.width + bh.bar.strokeWidth).attr("stroke", t3).attr("opacity", bh.bar.strokeOpacity).attr("stroke-linecap", "butt"), a4.attr("y1", function(s3) {\n                return s3.height;\n              }).call(MK);\n              var o4 = e3.selectAll(".highlight").data(zz);\n              o4.enter().append("line").classed("highlight", true).attr("x", -bh.bar.width / 2).attr("stroke-width", bh.bar.width - bh.bar.strokeWidth).attr("stroke", bh.bar.fillColor).attr("opacity", bh.bar.fillOpacity).attr("stroke-linecap", "butt"), o4.attr("y1", function(s3) {\n                return s3.height;\n              }).call(MK);\n            }\n            function QVt(e3, t3, r4) {\n              var n4 = e3.selectAll("." + bh.cn.axisBrush).data(zz, UVt);\n              n4.enter().append("g").classed(bh.cn.axisBrush, true), $Vt(n4, t3, r4);\n            }\n            function eGt(e3) {\n              return e3.svgBrush.extent.map(function(t3) {\n                return t3.slice();\n              });\n            }\n            function SK(e3) {\n              e3.filterSpecified = false, e3.svgBrush.extent = [[-1 / 0, 1 / 0]];\n            }\n            function tGt(e3) {\n              return function(r4) {\n                var n4 = r4.brush, i3 = eGt(n4), a4 = i3.slice();\n                n4.filter.set(a4), e3();\n              };\n            }\n            function QNe(e3) {\n              for (var t3 = e3.slice(), r4 = [], n4, i3 = t3.shift(); i3; ) {\n                for (n4 = i3.slice(); (i3 = t3.shift()) && i3[0] <= n4[1]; ) n4[1] = Math.max(n4[1], i3[1]);\n                r4.push(n4);\n              }\n              return r4.length === 1 && r4[0][0] > r4[0][1] && (r4 = []), r4;\n            }\n            function rGt() {\n              var e3 = [], t3, r4;\n              return { set: function(n4) {\n                e3 = n4.map(function(i3) {\n                  return i3.slice().sort(x5);\n                }).sort($Ne), e3.length === 1 && e3[0][0] === -1 / 0 && e3[0][1] === 1 / 0 && (e3 = [[0, -1]]), t3 = QNe(e3), r4 = e3.reduce(function(i3, a4) {\n                  return [Math.min(i3[0], a4[0]), Math.max(i3[1], a4[1])];\n                }, [1 / 0, -1 / 0]);\n              }, get: function() {\n                return e3.slice();\n              }, getConsolidated: function() {\n                return t3;\n              }, getBounds: function() {\n                return r4;\n              } };\n            }\n            function iGt(e3, t3, r4, n4, i3, a4) {\n              var o4 = rGt();\n              return o4.set(r4), { filter: o4, filterSpecified: t3, svgBrush: { extent: [], brushStartCallback: n4, brushCallback: tGt(i3), brushEndCallback: a4 } };\n            }\n            function nGt(e3, t3) {\n              if (Array.isArray(e3[0]) ? (e3 = e3.map(function(n4) {\n                return n4.sort(x5);\n              }), t3.multiselect ? e3 = QNe(e3.sort($Ne)) : e3 = [e3[0]]) : e3 = [e3.sort(x5)], t3.tickvals) {\n                var r4 = t3.tickvals.slice().sort(x5);\n                if (e3 = e3.map(function(n4) {\n                  var i3 = [qz(0, r4, n4[0], []), qz(1, r4, n4[1], [])];\n                  if (i3[1] > i3[0]) return i3;\n                }).filter(function(n4) {\n                  return n4;\n                }), !e3.length) return;\n              }\n              return e3.length > 1 ? e3 : e3[0];\n            }\n            eUe.exports = { makeBrush: iGt, ensureAxisBrush: QVt, cleanRanges: nGt };\n          });\n          var iUe = ye((O_r, rUe) => {\n            "use strict";\n            var mx = Dr(), aGt = pv().hasColorscale, oGt = Qh(), sGt = Cc().defaults, lGt = Yd(), uGt = ho(), tUe = AK(), cGt = EK(), kK = Pk().maxDimensionCount, fGt = kz();\n            function hGt(e3, t3, r4, n4, i3) {\n              var a4 = i3("line.color", r4);\n              if (aGt(e3, "line") && mx.isArrayOrTypedArray(a4)) {\n                if (a4.length) return i3("line.colorscale"), oGt(e3, t3, n4, i3, { prefix: "line.", cLetter: "c" }), a4.length;\n                t3.line.color = r4;\n              }\n              return 1 / 0;\n            }\n            function dGt(e3, t3, r4, n4) {\n              function i3(u4, c5) {\n                return mx.coerce(e3, t3, tUe.dimensions, u4, c5);\n              }\n              var a4 = i3("values"), o4 = i3("visible");\n              if (a4 && a4.length || (o4 = t3.visible = false), o4) {\n                i3("label"), i3("tickvals"), i3("ticktext"), i3("tickformat");\n                var s3 = i3("range");\n                t3._ax = { _id: "y", type: "linear", showexponent: "all", exponentformat: "B", range: s3 }, uGt.setConvert(t3._ax, n4.layout), i3("multiselect");\n                var l3 = i3("constraintrange");\n                l3 && (t3.constraintrange = cGt.cleanRanges(l3, t3));\n              }\n            }\n            rUe.exports = function(t3, r4, n4, i3) {\n              function a4(c5, f4) {\n                return mx.coerce(t3, r4, tUe, c5, f4);\n              }\n              var o4 = t3.dimensions;\n              Array.isArray(o4) && o4.length > kK && (mx.log("parcoords traces support up to " + kK + " dimensions at the moment"), o4.splice(kK));\n              var s3 = lGt(t3, r4, { name: "dimensions", layout: i3, handleItemDefaults: dGt }), l3 = hGt(t3, r4, n4, i3, a4);\n              sGt(r4, i3, a4), (!Array.isArray(s3) || !s3.length) && (r4.visible = false), fGt(r4, s3, "values", l3);\n              var u4 = mx.extendFlat({}, i3.font, { size: Math.round(i3.font.size / 1.2) });\n              mx.coerceFont(a4, "labelfont", u4), mx.coerceFont(a4, "tickfont", u4, { autoShadowDflt: true }), mx.coerceFont(a4, "rangefont", u4), a4("labelangle"), a4("labelside"), a4("unselected.line.color"), a4("unselected.line.opacity");\n            };\n          });\n          var aUe = ye((q_r, nUe) => {\n            "use strict";\n            var vGt = Dr().isArrayOrTypedArray, CK = tc(), pGt = Jm().wrap;\n            nUe.exports = function(t3, r4) {\n              var n4, i3;\n              return CK.hasColorscale(r4, "line") && vGt(r4.line.color) ? (n4 = r4.line.color, i3 = CK.extractOpts(r4.line).colorscale, CK.calc(t3, r4, { vals: n4, containerStr: "line", cLetter: "c" })) : (n4 = gGt(r4._length), i3 = [[0, r4.line.color], [1, r4.line.color]]), pGt({ lineColor: n4, cscale: i3 });\n            };\n            function gGt(e3) {\n              for (var t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = 0.5;\n              return t3;\n            }\n          });\n          function mGt(e3) {\n            var c5, f4;\n            var t3, r4 = [], n4 = 1, i3;\n            if (typeof e3 == "number") return { space: "rgb", values: [e3 >>> 16, (e3 & 65280) >>> 8, e3 & 255], alpha: 1 };\n            if (typeof e3 == "number") return { space: "rgb", values: [e3 >>> 16, (e3 & 65280) >>> 8, e3 & 255], alpha: 1 };\n            if (e3 = String(e3).toLowerCase(), LK.default[e3]) r4 = LK.default[e3].slice(), i3 = "rgb";\n            else if (e3 === "transparent") n4 = 0, i3 = "rgb", r4 = [0, 0, 0];\n            else if (e3[0] === "#") {\n              var a4 = e3.slice(1), o4 = a4.length, s3 = o4 <= 4;\n              n4 = 1, s3 ? (r4 = [parseInt(a4[0] + a4[0], 16), parseInt(a4[1] + a4[1], 16), parseInt(a4[2] + a4[2], 16)], o4 === 4 && (n4 = parseInt(a4[3] + a4[3], 16) / 255)) : (r4 = [parseInt(a4[0] + a4[1], 16), parseInt(a4[2] + a4[3], 16), parseInt(a4[4] + a4[5], 16)], o4 === 8 && (n4 = parseInt(a4[6] + a4[7], 16) / 255)), r4[0] || (r4[0] = 0), r4[1] || (r4[1] = 0), r4[2] || (r4[2] = 0), i3 = "rgb";\n            } else if (t3 = /^((?:rgba?|hs[lvb]a?|hwba?|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms|oklch|oklab|color))\\s*\\(([^\\)]*)\\)/.exec(e3)) {\n              var l3 = t3[1];\n              i3 = l3.replace(/a$/, "");\n              var u4 = i3 === "cmyk" ? 4 : i3 === "gray" ? 1 : 3;\n              r4 = t3[2].trim().split(/\\s*[,\\/]\\s*|\\s+/), i3 === "color" && (i3 = r4.shift()), r4 = r4.map(function(h3, d3) {\n                if (h3[h3.length - 1] === "%") return h3 = parseFloat(h3) / 100, d3 === 3 ? h3 : i3 === "rgb" ? h3 * 255 : i3[0] === "h" || i3[0] === "l" && !d3 ? h3 * 100 : i3 === "lab" ? h3 * 125 : i3 === "lch" ? d3 < 2 ? h3 * 150 : h3 * 360 : i3[0] === "o" && !d3 ? h3 : i3 === "oklab" ? h3 * 0.4 : i3 === "oklch" ? d3 < 2 ? h3 * 0.4 : h3 * 360 : h3;\n                if (i3[d3] === "h" || d3 === 2 && i3[i3.length - 1] === "h") {\n                  if (oUe[h3] !== void 0) return oUe[h3];\n                  if (h3.endsWith("deg")) return parseFloat(h3);\n                  if (h3.endsWith("turn")) return parseFloat(h3) * 360;\n                  if (h3.endsWith("grad")) return parseFloat(h3) * 360 / 400;\n                  if (h3.endsWith("rad")) return parseFloat(h3) * 180 / Math.PI;\n                }\n                return h3 === "none" ? 0 : parseFloat(h3);\n              }), n4 = r4.length > u4 ? r4.pop() : 1;\n            } else /[0-9](?:\\s|\\/|,)/.test(e3) && (r4 = e3.match(/([0-9]+)/g).map(function(h3) {\n              return parseFloat(h3);\n            }), i3 = ((f4 = (c5 = e3.match(/([a-z])/ig)) == null ? void 0 : c5.join("")) == null ? void 0 : f4.toLowerCase()) || "rgb");\n            return { space: i3, values: r4, alpha: n4 };\n          }\n          var LK, sUe, oUe, lUe = gu(() => {\n            LK = gtt(gX(), 1), sUe = mGt, oUe = { red: 0, orange: 60, yellow: 120, green: 180, blue: 240, purple: 300 };\n          });\n          var Ik, PK = gu(() => {\n            Ik = { name: "rgb", min: [0, 0, 0], max: [255, 255, 255], channel: ["red", "green", "blue"], alias: ["RGB"] };\n          });\n          var Bz, uUe = gu(() => {\n            PK();\n            Bz = { name: "hsl", min: [0, 0, 0], max: [360, 100, 100], channel: ["hue", "saturation", "lightness"], alias: ["HSL"], rgb: function(e3) {\n              var t3 = e3[0] / 360, r4 = e3[1] / 100, n4 = e3[2] / 100, i3, a4, o4, s3, l3, u4 = 0;\n              if (r4 === 0) return l3 = n4 * 255, [l3, l3, l3];\n              for (a4 = n4 < 0.5 ? n4 * (1 + r4) : n4 + r4 - n4 * r4, i3 = 2 * n4 - a4, s3 = [0, 0, 0]; u4 < 3; ) o4 = t3 + 1 / 3 * -(u4 - 1), o4 < 0 ? o4++ : o4 > 1 && o4--, l3 = 6 * o4 < 1 ? i3 + (a4 - i3) * 6 * o4 : 2 * o4 < 1 ? a4 : 3 * o4 < 2 ? i3 + (a4 - i3) * (2 / 3 - o4) * 6 : i3, s3[u4++] = l3 * 255;\n              return s3;\n            } };\n            Ik.hsl = function(e3) {\n              var t3 = e3[0] / 255, r4 = e3[1] / 255, n4 = e3[2] / 255, i3 = Math.min(t3, r4, n4), a4 = Math.max(t3, r4, n4), o4 = a4 - i3, s3, l3, u4;\n              return a4 === i3 ? s3 = 0 : t3 === a4 ? s3 = (r4 - n4) / o4 : r4 === a4 ? s3 = 2 + (n4 - t3) / o4 : n4 === a4 && (s3 = 4 + (t3 - r4) / o4), s3 = Math.min(s3 * 60, 360), s3 < 0 && (s3 += 360), u4 = (i3 + a4) / 2, a4 === i3 ? l3 = 0 : u4 <= 0.5 ? l3 = o4 / (a4 + i3) : l3 = o4 / (2 - a4 - i3), [s3, l3 * 100, u4 * 100];\n            };\n          });\n          var fUe = {};\n          cee(fUe, { default: () => cUe });\n          function cUe(e3) {\n            Array.isArray(e3) && e3.raw && (e3 = String.raw(...arguments)), e3 instanceof Number && (e3 = +e3);\n            var t3, r4, n4, i3 = sUe(e3);\n            if (!i3.space) return [];\n            let a4 = i3.space[0] === "h" ? Bz.min : Ik.min, o4 = i3.space[0] === "h" ? Bz.max : Ik.max;\n            return t3 = Array(3), t3[0] = Math.min(Math.max(i3.values[0], a4[0]), o4[0]), t3[1] = Math.min(Math.max(i3.values[1], a4[1]), o4[1]), t3[2] = Math.min(Math.max(i3.values[2], a4[2]), o4[2]), i3.space[0] === "h" && (t3 = Bz.rgb(t3)), t3.push(Math.min(Math.max(i3.alpha, 0), 1)), t3;\n          }\n          var hUe = gu(() => {\n            lUe();\n            PK();\n            uUe();\n          });\n          var IK = ye((Nz) => {\n            "use strict";\n            var yGt = Dr().isTypedArray;\n            Nz.convertTypedArray = function(e3) {\n              return yGt(e3) ? Array.prototype.slice.call(e3) : e3;\n            };\n            Nz.isOrdinal = function(e3) {\n              return !!e3.tickvals;\n            };\n            Nz.isVisible = function(e3) {\n              return e3.visible || !("visible" in e3);\n            };\n          });\n          var wUe = ye((X_r, bUe) => {\n            "use strict";\n            var _Gt = ["precision highp float;", "", "varying vec4 fragColor;", "", "attribute vec4 p01_04, p05_08, p09_12, p13_16,", "               p17_20, p21_24, p25_28, p29_32,", "               p33_36, p37_40, p41_44, p45_48,", "               p49_52, p53_56, p57_60, colors;", "", "uniform mat4 dim0A, dim1A, dim0B, dim1B, dim0C, dim1C, dim0D, dim1D,", "             loA, hiA, loB, hiB, loC, hiC, loD, hiD;", "", "uniform vec2 resolution, viewBoxPos, viewBoxSize;", "uniform float maskHeight;", "uniform float drwLayer; // 0: context, 1: focus, 2: pick", "uniform vec4 contextColor;", "uniform sampler2D maskTexture, palette;", "", "bool isPick    = (drwLayer > 1.5);", "bool isContext = (drwLayer < 0.5);", "", "const vec4 ZEROS = vec4(0.0, 0.0, 0.0, 0.0);", "const vec4 UNITS = vec4(1.0, 1.0, 1.0, 1.0);", "", "float val(mat4 p, mat4 v) {", "    return dot(matrixCompMult(p, v) * UNITS, UNITS);", "}", "", "float axisY(float ratio, mat4 A, mat4 B, mat4 C, mat4 D) {", "    float y1 = val(A, dim0A) + val(B, dim0B) + val(C, dim0C) + val(D, dim0D);", "    float y2 = val(A, dim1A) + val(B, dim1B) + val(C, dim1C) + val(D, dim1D);", "    return y1 * (1.0 - ratio) + y2 * ratio;", "}", "", "int iMod(int a, int b) {", "    return a - b * (a / b);", "}", "", "bool fOutside(float p, float lo, float hi) {", "    return (lo < hi) && (lo > p || p > hi);", "}", "", "bool vOutside(vec4 p, vec4 lo, vec4 hi) {", "    return (", "        fOutside(p[0], lo[0], hi[0]) ||", "        fOutside(p[1], lo[1], hi[1]) ||", "        fOutside(p[2], lo[2], hi[2]) ||", "        fOutside(p[3], lo[3], hi[3])", "    );", "}", "", "bool mOutside(mat4 p, mat4 lo, mat4 hi) {", "    return (", "        vOutside(p[0], lo[0], hi[0]) ||", "        vOutside(p[1], lo[1], hi[1]) ||", "        vOutside(p[2], lo[2], hi[2]) ||", "        vOutside(p[3], lo[3], hi[3])", "    );", "}", "", "bool outsideBoundingBox(mat4 A, mat4 B, mat4 C, mat4 D) {", "    return mOutside(A, loA, hiA) ||", "           mOutside(B, loB, hiB) ||", "           mOutside(C, loC, hiC) ||", "           mOutside(D, loD, hiD);", "}", "", "bool outsideRasterMask(mat4 A, mat4 B, mat4 C, mat4 D) {", "    mat4 pnts[4];", "    pnts[0] = A;", "    pnts[1] = B;", "    pnts[2] = C;", "    pnts[3] = D;", "", "    for(int i = 0; i < 4; ++i) {", "        for(int j = 0; j < 4; ++j) {", "            for(int k = 0; k < 4; ++k) {", "                if(0 == iMod(", "                    int(255.0 * texture2D(maskTexture,", "                        vec2(", "                            (float(i * 2 + j / 2) + 0.5) / 8.0,", "                            (pnts[i][j][k] * (maskHeight - 1.0) + 1.0) / maskHeight", "                        ))[3]", "                    ) / int(pow(2.0, float(iMod(j * 4 + k, 8)))),", "                    2", "                )) return true;", "            }", "        }", "    }", "    return false;", "}", "", "vec4 position(bool isContext, float v, mat4 A, mat4 B, mat4 C, mat4 D) {", "    float x = 0.5 * sign(v) + 0.5;", "    float y = axisY(x, A, B, C, D);", "    float z = 1.0 - abs(v);", "", "    z += isContext ? 0.0 : 2.0 * float(", "        outsideBoundingBox(A, B, C, D) ||", "        outsideRasterMask(A, B, C, D)", "    );", "", "    return vec4(", "        2.0 * (vec2(x, y) * viewBoxSize + viewBoxPos) / resolution - 1.0,", "        z,", "        1.0", "    );", "}", "", "void main() {", "    mat4 A = mat4(p01_04, p05_08, p09_12, p13_16);", "    mat4 B = mat4(p17_20, p21_24, p25_28, p29_32);", "    mat4 C = mat4(p33_36, p37_40, p41_44, p45_48);", "    mat4 D = mat4(p49_52, p53_56, p57_60, ZEROS);", "", "    float v = colors[3];", "", "    gl_Position = position(isContext, v, A, B, C, D);", "", "    fragColor =", "        isContext ? vec4(contextColor) :", "        isPick ? vec4(colors.rgb, 1.0) : texture2D(palette, vec2(abs(v), 0.5));", "}"].join(`\n`), xGt = ["precision highp float;", "", "varying vec4 fragColor;", "", "void main() {", "    gl_FragColor = fragColor;", "}"].join(`\n`), Rk = Pk().maxDimensionCount, yUe = Dr(), dUe = 1e-6, Uz = 2048, bGt = new Uint8Array(4), vUe = new Uint8Array(4), pUe = { shape: [256, 1], format: "rgba", type: "uint8", mag: "nearest", min: "nearest" };\n            function wGt(e3) {\n              e3.read({ x: 0, y: 0, width: 1, height: 1, data: bGt });\n            }\n            function _Ue(e3, t3, r4, n4, i3) {\n              var a4 = e3._gl;\n              a4.enable(a4.SCISSOR_TEST), a4.scissor(t3, r4, n4, i3), e3.clear({ color: [0, 0, 0, 0], depth: 1 });\n            }\n            function TGt(e3, t3, r4, n4, i3, a4) {\n              var o4 = a4.key;\n              function s3(l3) {\n                var u4 = Math.min(n4, i3 - l3 * n4);\n                l3 === 0 && (window.cancelAnimationFrame(r4.currentRafs[o4]), delete r4.currentRafs[o4], _Ue(e3, a4.scissorX, a4.scissorY, a4.scissorWidth, a4.viewBoxSize[1])), !r4.clearOnly && (a4.count = 2 * u4, a4.offset = 2 * l3 * n4, t3(a4), l3 * n4 + u4 < i3 && (r4.currentRafs[o4] = window.requestAnimationFrame(function() {\n                  s3(l3 + 1);\n                })), r4.drawCompleted = false);\n              }\n              r4.drawCompleted || (wGt(e3), r4.drawCompleted = true), s3(0);\n            }\n            function AGt(e3) {\n              return Math.max(dUe, Math.min(1 - dUe, e3));\n            }\n            function SGt(e3, t3) {\n              for (var r4 = new Array(256), n4 = 0; n4 < 256; n4++) r4[n4] = e3(n4 / 255).concat(t3);\n              return r4;\n            }\n            function RK(e3, t3) {\n              return (e3 >>> 8 * t3) % 256 / 255;\n            }\n            function MGt(e3, t3, r4) {\n              for (var n4 = new Array(e3 * (Rk + 4)), i3 = 0, a4 = 0; a4 < e3; a4++) {\n                for (var o4 = 0; o4 < Rk; o4++) n4[i3++] = o4 < t3.length ? t3[o4].paddedUnitValues[a4] : 0.5;\n                n4[i3++] = RK(a4, 2), n4[i3++] = RK(a4, 1), n4[i3++] = RK(a4, 0), n4[i3++] = AGt(r4[a4]);\n              }\n              return n4;\n            }\n            function EGt(e3, t3, r4) {\n              for (var n4 = new Array(t3 * 8), i3 = 0, a4 = 0; a4 < t3; a4++) for (var o4 = 0; o4 < 2; o4++) for (var s3 = 0; s3 < 4; s3++) {\n                var l3 = e3 * 4 + s3, u4 = r4[a4 * 64 + l3];\n                l3 === 63 && o4 === 0 && (u4 *= -1), n4[i3++] = u4;\n              }\n              return n4;\n            }\n            function gUe(e3) {\n              var t3 = "0" + e3;\n              return t3.slice(-2);\n            }\n            function xUe(e3) {\n              return e3 < Rk ? "p" + gUe(e3 + 1) + "_" + gUe(e3 + 4) : "colors";\n            }\n            function kGt(e3, t3, r4) {\n              for (var n4 = 0; n4 <= Rk; n4 += 4) e3[xUe(n4)](EGt(n4 / 4, t3, r4));\n            }\n            function CGt(e3) {\n              for (var t3 = {}, r4 = 0; r4 <= Rk; r4 += 4) t3[xUe(r4)] = e3.buffer({ usage: "dynamic", type: "float", data: new Uint8Array(0) });\n              return t3;\n            }\n            function LGt(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4, c5, f4, h3, d3) {\n              for (var v3 = [[], []], _2 = 0; _2 < 64; _2++) v3[0][_2] = _2 === i3 ? 1 : 0, v3[1][_2] = _2 === a4 ? 1 : 0;\n              o4 *= d3, s3 *= d3, l3 *= d3, u4 *= d3;\n              var b = e3.lines.canvasOverdrag * d3, p3 = e3.domain, k4 = e3.canvasWidth * d3, E3 = e3.canvasHeight * d3, S2 = e3.pad.l * d3, L3 = e3.pad.b * d3, x2 = e3.layoutHeight * d3, C3 = e3.layoutWidth * d3, M4 = e3.deselectedLines.color, g3 = e3.deselectedLines.opacity, P3 = yUe.extendFlat({ key: c5, resolution: [k4, E3], viewBoxPos: [o4 + b, s3], viewBoxSize: [l3, u4], i0: i3, i1: a4, dim0A: v3[0].slice(0, 16), dim0B: v3[0].slice(16, 32), dim0C: v3[0].slice(32, 48), dim0D: v3[0].slice(48, 64), dim1A: v3[1].slice(0, 16), dim1B: v3[1].slice(16, 32), dim1C: v3[1].slice(32, 48), dim1D: v3[1].slice(48, 64), drwLayer: f4, contextColor: [M4[0] / 255, M4[1] / 255, M4[2] / 255, g3 !== "auto" ? M4[3] * g3 : Math.max(1 / 255, Math.pow(1 / e3.lines.color.length, 1 / 3))], scissorX: (n4 === t3 ? 0 : o4 + b) + (S2 - b) + C3 * p3.x[0], scissorWidth: (n4 === r4 ? k4 - o4 + b : l3 + 0.5) + (n4 === t3 ? o4 + b : 0), scissorY: s3 + L3 + x2 * p3.y[0], scissorHeight: u4, viewportX: S2 - b + C3 * p3.x[0], viewportY: L3 + x2 * p3.y[0], viewportWidth: k4, viewportHeight: E3 }, h3);\n              return P3;\n            }\n            function mUe(e3) {\n              var t3 = Uz - 1, r4 = Math.max(0, Math.floor(e3[0] * t3), 0), n4 = Math.min(t3, Math.ceil(e3[1] * t3), t3);\n              return [Math.min(r4, n4), Math.max(r4, n4)];\n            }\n            bUe.exports = function(e3, t3) {\n              var r4 = t3.context, n4 = t3.pick, i3 = t3.regl, a4 = i3._gl, o4 = a4.getParameter(a4.ALIASED_LINE_WIDTH_RANGE), s3 = Math.max(o4[0], Math.min(o4[1], t3.viewModel.plotGlPixelRatio)), l3 = { currentRafs: {}, drawCompleted: true, clearOnly: false }, u4, c5, f4, h3, d3 = CGt(i3), v3, _2 = i3.texture(pUe), b = [];\n              k4(t3);\n              var p3 = i3({ profile: false, blend: { enable: r4, func: { srcRGB: "src alpha", dstRGB: "one minus src alpha", srcAlpha: 1, dstAlpha: 1 }, equation: { rgb: "add", alpha: "add" }, color: [0, 0, 0, 0] }, depth: { enable: !r4, mask: true, func: "less", range: [0, 1] }, cull: { enable: true, face: "back" }, scissor: { enable: true, box: { x: i3.prop("scissorX"), y: i3.prop("scissorY"), width: i3.prop("scissorWidth"), height: i3.prop("scissorHeight") } }, viewport: { x: i3.prop("viewportX"), y: i3.prop("viewportY"), width: i3.prop("viewportWidth"), height: i3.prop("viewportHeight") }, dither: false, vert: _Gt, frag: xGt, primitive: "lines", lineWidth: s3, attributes: d3, uniforms: { resolution: i3.prop("resolution"), viewBoxPos: i3.prop("viewBoxPos"), viewBoxSize: i3.prop("viewBoxSize"), dim0A: i3.prop("dim0A"), dim1A: i3.prop("dim1A"), dim0B: i3.prop("dim0B"), dim1B: i3.prop("dim1B"), dim0C: i3.prop("dim0C"), dim1C: i3.prop("dim1C"), dim0D: i3.prop("dim0D"), dim1D: i3.prop("dim1D"), loA: i3.prop("loA"), hiA: i3.prop("hiA"), loB: i3.prop("loB"), hiB: i3.prop("hiB"), loC: i3.prop("loC"), hiC: i3.prop("hiC"), loD: i3.prop("loD"), hiD: i3.prop("hiD"), palette: _2, contextColor: i3.prop("contextColor"), maskTexture: i3.prop("maskTexture"), drwLayer: i3.prop("drwLayer"), maskHeight: i3.prop("maskHeight") }, offset: i3.prop("offset"), count: i3.prop("count") });\n              function k4(M4) {\n                u4 = M4.model, c5 = M4.viewModel, f4 = c5.dimensions.slice(), h3 = f4[0] ? f4[0].values.length : 0;\n                var g3 = u4.lines, P3 = n4 ? g3.color.map(function(z3, O3) {\n                  return O3 / g3.color.length;\n                }) : g3.color, T3 = MGt(h3, f4, P3);\n                kGt(d3, h3, T3), !r4 && !n4 && (_2 = i3.texture(yUe.extendFlat({ data: SGt(u4.unitToColor, 255) }, pUe)));\n              }\n              function E3(M4) {\n                var g3, P3, T3, z3 = [[], []];\n                for (T3 = 0; T3 < 64; T3++) {\n                  var O3 = !M4 && T3 < f4.length ? f4[T3].brush.filter.getBounds() : [-1 / 0, 1 / 0];\n                  z3[0][T3] = O3[0], z3[1][T3] = O3[1];\n                }\n                var V2 = Uz * 8, G2 = new Array(V2);\n                for (g3 = 0; g3 < V2; g3++) G2[g3] = 255;\n                if (!M4) for (g3 = 0; g3 < f4.length; g3++) {\n                  var Z = g3 % 8, j3 = (g3 - Z) / 8, N2 = Math.pow(2, Z), H = f4[g3], te = H.brush.filter.get();\n                  if (!(te.length < 2)) {\n                    var oe = mUe(te[0])[1];\n                    for (P3 = 1; P3 < te.length; P3++) {\n                      var _e = mUe(te[P3]);\n                      for (T3 = oe + 1; T3 < _e[0]; T3++) G2[T3 * 8 + j3] &= ~N2;\n                      oe = Math.max(oe, _e[1]);\n                    }\n                  }\n                }\n                var Ee = { shape: [8, Uz], format: "alpha", type: "uint8", mag: "nearest", min: "nearest", data: G2 };\n                return v3 ? v3(Ee) : v3 = i3.texture(Ee), { maskTexture: v3, maskHeight: Uz, loA: z3[0].slice(0, 16), loB: z3[0].slice(16, 32), loC: z3[0].slice(32, 48), loD: z3[0].slice(48, 64), hiA: z3[1].slice(0, 16), hiB: z3[1].slice(16, 32), hiC: z3[1].slice(32, 48), hiD: z3[1].slice(48, 64) };\n              }\n              function S2(M4, g3, P3) {\n                var T3 = M4.length, z3, O3, V2, G2 = 1 / 0, Z = -1 / 0;\n                for (z3 = 0; z3 < T3; z3++) M4[z3].dim0.canvasX < G2 && (G2 = M4[z3].dim0.canvasX, O3 = z3), M4[z3].dim1.canvasX > Z && (Z = M4[z3].dim1.canvasX, V2 = z3);\n                T3 === 0 && _Ue(i3, 0, 0, u4.canvasWidth, u4.canvasHeight);\n                var j3 = E3(r4);\n                for (z3 = 0; z3 < T3; z3++) {\n                  var N2 = M4[z3], H = N2.dim0.crossfilterDimensionIndex, te = N2.dim1.crossfilterDimensionIndex, oe = N2.canvasX, _e = N2.canvasY, Ee = oe + N2.panelSizeX, Ce = N2.plotGlPixelRatio;\n                  if (g3 || !b[H] || b[H][0] !== oe || b[H][1] !== Ee) {\n                    b[H] = [oe, Ee];\n                    var me = LGt(u4, O3, V2, z3, H, te, oe, _e, N2.panelSizeX, N2.panelSizeY, N2.dim0.crossfilterDimensionIndex, r4 ? 0 : n4 ? 2 : 1, j3, Ce);\n                    l3.clearOnly = P3;\n                    var ie = g3 ? u4.lines.blockLineCount : h3;\n                    TGt(i3, p3, l3, ie, h3, me);\n                  }\n                }\n              }\n              function L3(M4, g3) {\n                return i3.read({ x: M4, y: g3, width: 1, height: 1, data: vUe }), vUe;\n              }\n              function x2(M4, g3, P3, T3) {\n                var z3 = new Uint8Array(4 * P3 * T3);\n                return i3.read({ x: M4, y: g3, width: P3, height: T3, data: z3 }), z3;\n              }\n              function C3() {\n                e3.style["pointer-events"] = "none", _2.destroy(), v3 && v3.destroy();\n                for (var M4 in d3) d3[M4].destroy();\n              }\n              return { render: S2, readPixel: L3, readPixels: x2, destroy: C3, update: k4 };\n            };\n          });\n          var zUe = ye((Z_r, FUe) => {\n            "use strict";\n            var Bd = Oa(), l1 = Dr(), DK = l1.isArrayOrTypedArray, kUe = l1.numberFormat, CUe = (hUe(), ob(fUe)).default, LUe = ho(), PGt = l1.strRotate, $m = l1.strTranslate, IGt = ru(), Vz = So(), TUe = tc(), OK = Jm(), tg = OK.keyFun, Qm = OK.repeat, PUe = OK.unwrap, b5 = IK(), Dl = Pk(), IUe = EK(), RGt = wUe();\n            function AUe(e3, t3, r4) {\n              return l1.aggNums(e3, null, t3, r4);\n            }\n            function RUe(e3, t3) {\n              return qK(AUe(Math.min, e3, t3), AUe(Math.max, e3, t3));\n            }\n            function Gz(e3) {\n              var t3 = e3.range;\n              return t3 ? qK(t3[0], t3[1]) : RUe(e3.values, e3._length);\n            }\n            function qK(e3, t3) {\n              return (isNaN(e3) || !isFinite(e3)) && (e3 = 0), (isNaN(t3) || !isFinite(t3)) && (t3 = 0), e3 === t3 && (e3 === 0 ? (e3 -= 1, t3 += 1) : (e3 *= 0.9, t3 *= 1.1)), [e3, t3];\n            }\n            function DGt(e3, t3) {\n              return t3 ? function(r4, n4) {\n                var i3 = t3[n4];\n                return i3 == null ? e3(r4) : i3;\n              } : e3;\n            }\n            function FGt(e3, t3, r4, n4, i3) {\n              var a4 = Gz(r4);\n              return n4 ? Bd.scale.ordinal().domain(n4.map(DGt(kUe(r4.tickformat), i3))).range(n4.map(function(o4) {\n                var s3 = (o4 - a4[0]) / (a4[1] - a4[0]);\n                return e3 - t3 + s3 * (2 * t3 - e3);\n              })) : Bd.scale.linear().domain(a4).range([e3 - t3, t3]);\n            }\n            function zGt(e3, t3) {\n              return Bd.scale.linear().range([t3, e3 - t3]);\n            }\n            function OGt(e3, t3) {\n              return Bd.scale.linear().domain(Gz(e3)).range([t3, 1 - t3]);\n            }\n            function qGt(e3) {\n              if (e3.tickvals) {\n                var t3 = Gz(e3);\n                return Bd.scale.ordinal().domain(e3.tickvals).range(e3.tickvals.map(function(r4) {\n                  return (r4 - t3[0]) / (t3[1] - t3[0]);\n                }));\n              }\n            }\n            function BGt(e3) {\n              var t3 = e3.map(function(a4) {\n                return a4[0];\n              }), r4 = e3.map(function(a4) {\n                var o4 = CUe(a4[1]);\n                return Bd.rgb("rgb(" + o4[0] + "," + o4[1] + "," + o4[2] + ")");\n              }), n4 = function(a4) {\n                return function(o4) {\n                  return o4[a4];\n                };\n              }, i3 = "rgb".split("").map(function(a4) {\n                return Bd.scale.linear().clamp(true).domain(t3).range(r4.map(n4(a4)));\n              });\n              return function(a4) {\n                return i3.map(function(o4) {\n                  return o4(a4);\n                });\n              };\n            }\n            function zK(e3) {\n              return e3.dimensions.some(function(t3) {\n                return t3.brush.filterSpecified;\n              });\n            }\n            function NGt(e3, t3, r4) {\n              var n4 = PUe(t3), i3 = n4.trace, a4 = b5.convertTypedArray(n4.lineColor), o4 = i3.line, s3 = { color: CUe(i3.unselected.line.color), opacity: i3.unselected.line.opacity }, l3 = TUe.extractOpts(o4), u4 = l3.reversescale ? TUe.flipScale(n4.cscale) : n4.cscale, c5 = i3.domain, f4 = i3.dimensions, h3 = e3.width, d3 = i3.labelangle, v3 = i3.labelside, _2 = i3.labelfont, b = i3.tickfont, p3 = i3.rangefont, k4 = l1.extendDeepNoArrays({}, o4, { color: a4.map(Bd.scale.linear().domain(Gz({ values: a4, range: [l3.min, l3.max], _length: i3._length }))), blockLineCount: Dl.blockLineCount, canvasOverdrag: Dl.overdrag * Dl.canvasPixelRatio }), E3 = Math.floor(h3 * (c5.x[1] - c5.x[0])), S2 = Math.floor(e3.height * (c5.y[1] - c5.y[0])), L3 = e3.margin || { l: 80, r: 80, t: 100, b: 80 }, x2 = E3, C3 = S2;\n              return { key: r4, colCount: f4.filter(b5.isVisible).length, dimensions: f4, tickDistance: Dl.tickDistance, unitToColor: BGt(u4), lines: k4, deselectedLines: s3, labelAngle: d3, labelSide: v3, labelFont: _2, tickFont: b, rangeFont: p3, layoutWidth: h3, layoutHeight: e3.height, domain: c5, translateX: c5.x[0] * h3, translateY: e3.height - c5.y[1] * e3.height, pad: L3, canvasWidth: x2 * Dl.canvasPixelRatio + 2 * k4.canvasOverdrag, canvasHeight: C3 * Dl.canvasPixelRatio, width: x2, height: C3, canvasPixelRatio: Dl.canvasPixelRatio };\n            }\n            function UGt(e3, t3, r4) {\n              var n4 = r4.width, i3 = r4.height, a4 = r4.dimensions, o4 = r4.canvasPixelRatio, s3 = function(h3) {\n                return n4 * h3 / Math.max(1, r4.colCount - 1);\n              }, l3 = Dl.verticalPadding / i3, u4 = zGt(i3, Dl.verticalPadding), c5 = { key: r4.key, xScale: s3, model: r4, inBrushDrag: false }, f4 = {};\n              return c5.dimensions = a4.filter(b5.isVisible).map(function(h3, d3) {\n                var v3 = OGt(h3, l3), _2 = f4[h3.label];\n                f4[h3.label] = (_2 || 0) + 1;\n                var b = h3.label + (_2 ? "__" + _2 : ""), p3 = h3.constraintrange, k4 = p3 && p3.length;\n                k4 && !DK(p3[0]) && (p3 = [p3]);\n                var E3 = k4 ? p3.map(function(O3) {\n                  return O3.map(v3);\n                }) : [[-1 / 0, 1 / 0]], S2 = function() {\n                  var O3 = c5;\n                  O3.focusLayer && O3.focusLayer.render(O3.panels, true);\n                  var V2 = zK(O3);\n                  !e3.contextShown() && V2 ? (O3.contextLayer && O3.contextLayer.render(O3.panels, true), e3.contextShown(true)) : e3.contextShown() && !V2 && (O3.contextLayer && O3.contextLayer.render(O3.panels, true, true), e3.contextShown(false));\n                }, L3 = h3.values;\n                L3.length > h3._length && (L3 = L3.slice(0, h3._length));\n                var x2 = h3.tickvals, C3;\n                function M4(O3, V2) {\n                  return { val: O3, text: C3[V2] };\n                }\n                function g3(O3, V2) {\n                  return O3.val - V2.val;\n                }\n                if (DK(x2) && x2.length) {\n                  l1.isTypedArray(x2) && (x2 = Array.from(x2)), C3 = h3.ticktext, !DK(C3) || !C3.length ? C3 = x2.map(kUe(h3.tickformat)) : C3.length > x2.length ? C3 = C3.slice(0, x2.length) : x2.length > C3.length && (x2 = x2.slice(0, C3.length));\n                  for (var P3 = 1; P3 < x2.length; P3++) if (x2[P3] < x2[P3 - 1]) {\n                    for (var T3 = x2.map(M4).sort(g3), z3 = 0; z3 < x2.length; z3++) x2[z3] = T3[z3].val, C3[z3] = T3[z3].text;\n                    break;\n                  }\n                } else x2 = void 0;\n                return L3 = b5.convertTypedArray(L3), { key: b, label: h3.label, tickFormat: h3.tickformat, tickvals: x2, ticktext: C3, ordinal: b5.isOrdinal(h3), multiselect: h3.multiselect, xIndex: d3, crossfilterDimensionIndex: d3, visibleIndex: h3._index, height: i3, values: L3, paddedUnitValues: L3.map(v3), unitTickvals: x2 && x2.map(v3), xScale: s3, x: s3(d3), canvasX: s3(d3) * o4, unitToPaddedPx: u4, domainScale: FGt(i3, Dl.verticalPadding, h3, x2, C3), ordinalScale: qGt(h3), parent: c5, model: r4, brush: IUe.makeBrush(e3, k4, E3, function() {\n                  e3.linePickActive(false);\n                }, S2, function(O3) {\n                  if (c5.focusLayer.render(c5.panels, true), c5.pickLayer && c5.pickLayer.render(c5.panels, true), e3.linePickActive(true), t3 && t3.filterChanged) {\n                    var V2 = v3.invert, G2 = O3.map(function(Z) {\n                      return Z.map(V2).sort(l1.sorterAsc);\n                    }).sort(function(Z, j3) {\n                      return Z[0] - j3[0];\n                    });\n                    t3.filterChanged(c5.key, h3._index, G2);\n                  }\n                }) };\n              }), c5;\n            }\n            function SUe(e3) {\n              e3.classed(Dl.cn.axisExtentText, true).attr("text-anchor", "middle").style("cursor", "default");\n            }\n            function VGt() {\n              var e3 = true, t3 = false;\n              return { linePickActive: function(r4) {\n                return arguments.length ? e3 = !!r4 : e3;\n              }, contextShown: function(r4) {\n                return arguments.length ? t3 = !!r4 : t3;\n              } };\n            }\n            function MUe(e3, t3) {\n              var r4 = t3 === "top" ? 1 : -1, n4 = e3 * Math.PI / 180, i3 = Math.sin(n4), a4 = Math.cos(n4);\n              return { dir: r4, dx: i3, dy: a4, degrees: e3 };\n            }\n            function FK(e3, t3, r4) {\n              for (var n4 = t3.panels || (t3.panels = []), i3 = e3.data(), a4 = 0; a4 < i3.length - 1; a4++) {\n                var o4 = n4[a4] || (n4[a4] = {}), s3 = i3[a4], l3 = i3[a4 + 1];\n                o4.dim0 = s3, o4.dim1 = l3, o4.canvasX = s3.canvasX, o4.panelSizeX = l3.canvasX - s3.canvasX, o4.panelSizeY = t3.model.canvasHeight, o4.y = 0, o4.canvasY = 0, o4.plotGlPixelRatio = r4;\n              }\n            }\n            function GGt(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) for (var r4 = 0; r4 < e3[t3].length; r4++) for (var n4 = e3[t3][r4].trace, i3 = n4.dimensions, a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4].values, s3 = i3[a4]._ax;\n                s3 && (s3.range ? s3.range = qK(s3.range[0], s3.range[1]) : s3.range = RUe(o4, n4._length), s3.dtick || (s3.dtick = 0.01 * (Math.abs(s3.range[1] - s3.range[0]) || 1)), s3.tickformat = i3[a4].tickformat, LUe.calcTicks(s3), s3.cleanRange());\n              }\n            }\n            function DUe(e3, t3) {\n              return LUe.tickText(e3._ax, t3, false).text;\n            }\n            function EUe(e3, t3) {\n              if (e3.ordinal) return "";\n              var r4 = e3.domainScale.domain(), n4 = r4[t3 ? r4.length - 1 : 0];\n              return DUe(e3.model.dimensions[e3.visibleIndex], n4);\n            }\n            FUe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._context.staticPlot, o4 = t3._fullLayout, s3 = o4._toppaper, l3 = o4._glcontainer, u4 = t3._context.plotGlPixelRatio, c5 = t3._fullLayout.paper_bgcolor;\n              GGt(r4);\n              var f4 = VGt(), h3 = r4.filter(function(z3) {\n                return PUe(z3).trace.visible;\n              }).map(NGt.bind(0, n4)).map(UGt.bind(0, f4, i3));\n              l3.each(function(z3, O3) {\n                return l1.extendFlat(z3, h3[O3]);\n              });\n              var d3 = l3.selectAll(".gl-canvas").each(function(z3) {\n                z3.viewModel = h3[0], z3.viewModel.plotGlPixelRatio = u4, z3.viewModel.paperColor = c5, z3.model = z3.viewModel ? z3.viewModel.model : null;\n              }), v3 = null, _2 = d3.filter(function(z3) {\n                return z3.pick;\n              });\n              _2.style("pointer-events", a4 ? "none" : "auto").on("mousemove", function(z3) {\n                if (f4.linePickActive() && z3.lineLayer && i3 && i3.hover) {\n                  var O3 = Bd.event, V2 = this.width, G2 = this.height, Z = Bd.mouse(this), j3 = Z[0], N2 = Z[1];\n                  if (j3 < 0 || N2 < 0 || j3 >= V2 || N2 >= G2) return;\n                  var H = z3.lineLayer.readPixel(j3, G2 - 1 - N2), te = H[3] !== 0, oe = te ? H[2] + 256 * (H[1] + 256 * H[0]) : null, _e = { x: j3, y: N2, clientX: O3.clientX, clientY: O3.clientY, dataIndex: z3.model.key, curveNumber: oe };\n                  oe !== v3 && (te ? i3.hover(_e) : i3.unhover && i3.unhover(_e), v3 = oe);\n                }\n              }), d3.style("opacity", function(z3) {\n                return z3.pick ? 0 : 1;\n              }), s3.style("background", "rgba(255, 255, 255, 0)");\n              var b = s3.selectAll("." + Dl.cn.parcoords).data(h3, tg);\n              b.exit().remove(), b.enter().append("g").classed(Dl.cn.parcoords, true).style("shape-rendering", "crispEdges").style("pointer-events", "none"), b.attr("transform", function(z3) {\n                return $m(z3.model.translateX, z3.model.translateY);\n              });\n              var p3 = b.selectAll("." + Dl.cn.parcoordsControlView).data(Qm, tg);\n              p3.enter().append("g").classed(Dl.cn.parcoordsControlView, true), p3.attr("transform", function(z3) {\n                return $m(z3.model.pad.l, z3.model.pad.t);\n              });\n              var k4 = p3.selectAll("." + Dl.cn.yAxis).data(function(z3) {\n                return z3.dimensions;\n              }, tg);\n              k4.enter().append("g").classed(Dl.cn.yAxis, true), p3.each(function(z3) {\n                FK(k4, z3, u4);\n              }), d3.each(function(z3) {\n                if (z3.viewModel) {\n                  !z3.lineLayer || i3 ? z3.lineLayer = RGt(this, z3) : z3.lineLayer.update(z3), (z3.key || z3.key === 0) && (z3.viewModel[z3.key] = z3.lineLayer);\n                  var O3 = !z3.context || i3;\n                  z3.lineLayer.render(z3.viewModel.panels, O3);\n                }\n              }), k4.attr("transform", function(z3) {\n                return $m(z3.xScale(z3.xIndex), 0);\n              }), k4.call(Bd.behavior.drag().origin(function(z3) {\n                return z3;\n              }).on("drag", function(z3) {\n                var O3 = z3.parent;\n                f4.linePickActive(false), z3.x = Math.max(-Dl.overdrag, Math.min(z3.model.width + Dl.overdrag, Bd.event.x)), z3.canvasX = z3.x * z3.model.canvasPixelRatio, k4.sort(function(V2, G2) {\n                  return V2.x - G2.x;\n                }).each(function(V2, G2) {\n                  V2.xIndex = G2, V2.x = z3 === V2 ? V2.x : V2.xScale(V2.xIndex), V2.canvasX = V2.x * V2.model.canvasPixelRatio;\n                }), FK(k4, O3, u4), k4.filter(function(V2) {\n                  return Math.abs(z3.xIndex - V2.xIndex) !== 0;\n                }).attr("transform", function(V2) {\n                  return $m(V2.xScale(V2.xIndex), 0);\n                }), Bd.select(this).attr("transform", $m(z3.x, 0)), k4.each(function(V2, G2, Z) {\n                  Z === z3.parent.key && (O3.dimensions[G2] = V2);\n                }), O3.contextLayer && O3.contextLayer.render(O3.panels, false, !zK(O3)), O3.focusLayer.render && O3.focusLayer.render(O3.panels);\n              }).on("dragend", function(z3) {\n                var O3 = z3.parent;\n                z3.x = z3.xScale(z3.xIndex), z3.canvasX = z3.x * z3.model.canvasPixelRatio, FK(k4, O3, u4), Bd.select(this).attr("transform", function(V2) {\n                  return $m(V2.x, 0);\n                }), O3.contextLayer && O3.contextLayer.render(O3.panels, false, !zK(O3)), O3.focusLayer && O3.focusLayer.render(O3.panels), O3.pickLayer && O3.pickLayer.render(O3.panels, true), f4.linePickActive(true), i3 && i3.axesMoved && i3.axesMoved(O3.key, O3.dimensions.map(function(V2) {\n                  return V2.crossfilterDimensionIndex;\n                }));\n              })), k4.exit().remove();\n              var E3 = k4.selectAll("." + Dl.cn.axisOverlays).data(Qm, tg);\n              E3.enter().append("g").classed(Dl.cn.axisOverlays, true), E3.selectAll("." + Dl.cn.axis).remove();\n              var S2 = E3.selectAll("." + Dl.cn.axis).data(Qm, tg);\n              S2.enter().append("g").classed(Dl.cn.axis, true), S2.each(function(z3) {\n                var O3 = z3.model.height / z3.model.tickDistance, V2 = z3.domainScale, G2 = V2.domain();\n                Bd.select(this).call(Bd.svg.axis().orient("left").tickSize(4).outerTickSize(2).ticks(O3, z3.tickFormat).tickValues(z3.ordinal ? G2 : null).tickFormat(function(Z) {\n                  return b5.isOrdinal(z3) ? Z : DUe(z3.model.dimensions[z3.visibleIndex], Z);\n                }).scale(V2)), Vz.font(S2.selectAll("text"), z3.model.tickFont);\n              }), S2.selectAll(".domain, .tick>line").attr("fill", "none").attr("stroke", "black").attr("stroke-opacity", 0.25).attr("stroke-width", "1px"), S2.selectAll("text").style("cursor", "default");\n              var L3 = E3.selectAll("." + Dl.cn.axisHeading).data(Qm, tg);\n              L3.enter().append("g").classed(Dl.cn.axisHeading, true);\n              var x2 = L3.selectAll("." + Dl.cn.axisTitle).data(Qm, tg);\n              x2.enter().append("text").classed(Dl.cn.axisTitle, true).attr("text-anchor", "middle").style("cursor", "ew-resize").style("pointer-events", a4 ? "none" : "auto"), x2.text(function(z3) {\n                return z3.label;\n              }).each(function(z3) {\n                var O3 = Bd.select(this);\n                Vz.font(O3, z3.model.labelFont), IGt.convertToTspans(O3, t3);\n              }).attr("transform", function(z3) {\n                var O3 = MUe(z3.model.labelAngle, z3.model.labelSide), V2 = Dl.axisTitleOffset;\n                return (O3.dir > 0 ? "" : $m(0, 2 * V2 + z3.model.height)) + PGt(O3.degrees) + $m(-V2 * O3.dx, -V2 * O3.dy);\n              }).attr("text-anchor", function(z3) {\n                var O3 = MUe(z3.model.labelAngle, z3.model.labelSide), V2 = Math.abs(O3.dx), G2 = Math.abs(O3.dy);\n                return 2 * V2 > G2 ? O3.dir * O3.dx < 0 ? "start" : "end" : "middle";\n              });\n              var C3 = E3.selectAll("." + Dl.cn.axisExtent).data(Qm, tg);\n              C3.enter().append("g").classed(Dl.cn.axisExtent, true);\n              var M4 = C3.selectAll("." + Dl.cn.axisExtentTop).data(Qm, tg);\n              M4.enter().append("g").classed(Dl.cn.axisExtentTop, true), M4.attr("transform", $m(0, -Dl.axisExtentOffset));\n              var g3 = M4.selectAll("." + Dl.cn.axisExtentTopText).data(Qm, tg);\n              g3.enter().append("text").classed(Dl.cn.axisExtentTopText, true).call(SUe), g3.text(function(z3) {\n                return EUe(z3, true);\n              }).each(function(z3) {\n                Vz.font(Bd.select(this), z3.model.rangeFont);\n              });\n              var P3 = C3.selectAll("." + Dl.cn.axisExtentBottom).data(Qm, tg);\n              P3.enter().append("g").classed(Dl.cn.axisExtentBottom, true), P3.attr("transform", function(z3) {\n                return $m(0, z3.model.height + Dl.axisExtentOffset);\n              });\n              var T3 = P3.selectAll("." + Dl.cn.axisExtentBottomText).data(Qm, tg);\n              T3.enter().append("text").classed(Dl.cn.axisExtentBottomText, true).attr("dy", "0.75em").call(SUe), T3.text(function(z3) {\n                return EUe(z3, false);\n              }).each(function(z3) {\n                Vz.font(Bd.select(this), z3.model.rangeFont);\n              }), IUe.ensureAxisBrush(E3, c5, t3);\n            };\n          });\n          var NK = ye((BK, NUe) => {\n            "use strict";\n            var HGt = zUe(), jGt = Mz(), OUe = IK().isVisible, BUe = {};\n            function qUe(e3, t3, r4) {\n              var n4 = t3.indexOf(r4), i3 = e3.indexOf(n4);\n              return i3 === -1 && (i3 += t3.length), i3;\n            }\n            function WGt(e3, t3) {\n              return function(n4, i3) {\n                return qUe(e3, t3, n4) - qUe(e3, t3, i3);\n              };\n            }\n            var BK = NUe.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = jGt(t3, [], BUe);\n              if (i3) {\n                var a4 = {}, o4 = {}, s3 = {}, l3 = {}, u4 = n4._size;\n                r4.forEach(function(v3, _2) {\n                  var b = v3[0].trace;\n                  s3[_2] = b.index;\n                  var p3 = l3[_2] = b.index;\n                  a4[_2] = t3.data[p3].dimensions, o4[_2] = t3.data[p3].dimensions.slice();\n                });\n                var c5 = function(v3, _2, b) {\n                  var p3 = o4[v3][_2], k4 = b.map(function(M4) {\n                    return M4.slice();\n                  }), E3 = "dimensions[" + _2 + "].constraintrange", S2 = n4._tracePreGUI[t3._fullData[s3[v3]]._fullInput.uid];\n                  if (S2[E3] === void 0) {\n                    var L3 = p3.constraintrange;\n                    S2[E3] = L3 || null;\n                  }\n                  var x2 = t3._fullData[s3[v3]].dimensions[_2];\n                  k4.length ? (k4.length === 1 && (k4 = k4[0]), p3.constraintrange = k4, x2.constraintrange = k4.slice(), k4 = [k4]) : (delete p3.constraintrange, delete x2.constraintrange, k4 = null);\n                  var C3 = {};\n                  C3[E3] = k4, t3.emit("plotly_restyle", [C3, [l3[v3]]]);\n                }, f4 = function(v3) {\n                  t3.emit("plotly_hover", v3);\n                }, h3 = function(v3) {\n                  t3.emit("plotly_unhover", v3);\n                }, d3 = function(v3, _2) {\n                  var b = WGt(_2, o4[v3].filter(OUe));\n                  a4[v3].sort(b), o4[v3].filter(function(p3) {\n                    return !OUe(p3);\n                  }).sort(function(p3) {\n                    return o4[v3].indexOf(p3);\n                  }).forEach(function(p3) {\n                    a4[v3].splice(a4[v3].indexOf(p3), 1), a4[v3].splice(o4[v3].indexOf(p3), 0, p3);\n                  }), t3.emit("plotly_restyle", [{ dimensions: [a4[v3]] }, [l3[v3]]]);\n                };\n                HGt(t3, r4, { width: u4.w, height: u4.h, margin: { t: u4.t, r: u4.r, b: u4.b, l: u4.l } }, { filterChanged: c5, hover: f4, unhover: h3, axesMoved: d3 });\n              }\n            };\n            BK.reglPrecompiled = BUe;\n          });\n          var VUe = ye((Dk) => {\n            "use strict";\n            var UUe = Oa(), XGt = Id().getModuleCalcData, ZGt = NK(), YGt = Wp();\n            Dk.name = "parcoords";\n            Dk.plot = function(e3) {\n              var t3 = XGt(e3.calcdata, "parcoords")[0];\n              t3.length && ZGt(e3, t3);\n            };\n            Dk.clean = function(e3, t3, r4, n4) {\n              var i3 = n4._has && n4._has("parcoords"), a4 = t3._has && t3._has("parcoords");\n              i3 && !a4 && (n4._paperdiv.selectAll(".parcoords").remove(), n4._glimages.selectAll("*").remove());\n            };\n            Dk.toSVG = function(e3) {\n              var t3 = e3._fullLayout._glimages, r4 = UUe.select(e3).selectAll(".svg-container"), n4 = r4.filter(function(a4, o4) {\n                return o4 === r4.size() - 1;\n              }).selectAll(".gl-canvas-context, .gl-canvas-focus");\n              function i3() {\n                var a4 = this, o4 = a4.toDataURL("image/png"), s3 = t3.append("svg:image");\n                s3.attr({ xmlns: YGt.svg, "xlink:href": o4, preserveAspectRatio: "none", x: 0, y: 0, width: a4.style.width, height: a4.style.height });\n              }\n              n4.each(i3), window.setTimeout(function() {\n                UUe.selectAll("#filterBarPattern").attr("id", "filterBarPattern");\n              }, 60);\n            };\n          });\n          var HUe = ye((K_r, GUe) => {\n            "use strict";\n            GUe.exports = { attributes: AK(), supplyDefaults: iUe(), calc: aUe(), colorbar: { container: "line", min: "cmin", max: "cmax" }, moduleType: "trace", name: "parcoords", basePlotModule: VUe(), categories: ["gl", "regl", "noOpacity", "noHover"], meta: {} };\n          });\n          var XUe = ye((J_r, WUe) => {\n            "use strict";\n            var jUe = HUe();\n            jUe.plot = NK();\n            WUe.exports = jUe;\n          });\n          var YUe = ye(($_r, ZUe) => {\n            "use strict";\n            ZUe.exports = XUe();\n          });\n          var UK = ye((Q_r, eVe) => {\n            "use strict";\n            var JUe = Ao().extendFlat, KGt = Gl(), KUe = ec(), JGt = Tu(), { hovertemplateAttrs: $Ue, templatefallbackAttrs: QUe } = Ll(), $Gt = Cc().attributes, QGt = JUe({ editType: "calc" }, JGt("line", { editTypeOverride: "calc" }), { shape: { valType: "enumerated", values: ["linear", "hspline"], dflt: "linear", editType: "plot" }, hovertemplate: $Ue({ editType: "plot", arrayOk: false }, { keys: ["count", "probability"] }), hovertemplatefallback: QUe({ editType: "plot" }) });\n            eVe.exports = { domain: $Gt({ name: "parcats", trace: true, editType: "calc" }), hoverinfo: JUe({}, KGt.hoverinfo, { flags: ["count", "probability"], editType: "plot", arrayOk: false }), hoveron: { valType: "enumerated", values: ["category", "color", "dimension"], dflt: "category", editType: "plot" }, hovertemplate: $Ue({ editType: "plot", arrayOk: false }, { keys: ["count", "probability", "category", "categorycount", "colorcount", "bandcolorcount"] }), hovertemplatefallback: QUe({ editType: "plot" }), arrangement: { valType: "enumerated", values: ["perpendicular", "freeform", "fixed"], dflt: "perpendicular", editType: "plot" }, bundlecolors: { valType: "boolean", dflt: true, editType: "plot" }, sortpaths: { valType: "enumerated", values: ["forward", "backward"], dflt: "forward", editType: "plot" }, labelfont: KUe({ editType: "calc" }), tickfont: KUe({ autoShadowDflt: true, editType: "calc" }), dimensions: { _isLinkedToArray: "dimension", label: { valType: "string", editType: "calc" }, categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, ticktext: { valType: "data_array", editType: "calc" }, values: { valType: "data_array", dflt: [], editType: "calc" }, displayindex: { valType: "integer", editType: "calc" }, editType: "calc", visible: { valType: "boolean", dflt: true, editType: "calc" } }, line: QGt, counts: { valType: "number", min: 0, dflt: 1, arrayOk: true, editType: "calc" }, customdata: void 0, hoverlabel: void 0, ids: void 0, legend: void 0, legendgroup: void 0, legendrank: void 0, opacity: void 0, selectedpoints: void 0, showlegend: void 0 };\n          });\n          var iVe = ye((exr, rVe) => {\n            "use strict";\n            var w5 = Dr(), eHt = pv().hasColorscale, tHt = Qh(), rHt = Cc().defaults, iHt = Yd(), tVe = UK(), nHt = kz(), aHt = vv().isTypedArraySpec;\n            function oHt(e3, t3, r4, n4, i3) {\n              i3("line.shape"), i3("line.hovertemplate"), i3("line.hovertemplatefallback");\n              var a4 = i3("line.color", n4.colorway[0]);\n              if (eHt(e3, "line") && w5.isArrayOrTypedArray(a4)) {\n                if (a4.length) return i3("line.colorscale"), tHt(e3, t3, n4, i3, { prefix: "line.", cLetter: "c" }), a4.length;\n                t3.line.color = r4;\n              }\n              return 1 / 0;\n            }\n            function sHt(e3, t3) {\n              function r4(u4, c5) {\n                return w5.coerce(e3, t3, tVe.dimensions, u4, c5);\n              }\n              var n4 = r4("values"), i3 = r4("visible");\n              if (n4 && n4.length || (i3 = t3.visible = false), i3) {\n                r4("label"), r4("displayindex", t3._index);\n                var a4 = e3.categoryarray, o4 = w5.isArrayOrTypedArray(a4) && a4.length > 0 || aHt(a4), s3;\n                o4 && (s3 = "array");\n                var l3 = r4("categoryorder", s3);\n                l3 === "array" ? (r4("categoryarray"), r4("ticktext")) : (delete e3.categoryarray, delete e3.ticktext), !o4 && l3 === "array" && (t3.categoryorder = "trace");\n              }\n            }\n            rVe.exports = function(t3, r4, n4, i3) {\n              function a4(u4, c5) {\n                return w5.coerce(t3, r4, tVe, u4, c5);\n              }\n              var o4 = iHt(t3, r4, { name: "dimensions", handleItemDefaults: sHt }), s3 = oHt(t3, r4, n4, i3, a4);\n              rHt(r4, i3, a4), (!Array.isArray(o4) || !o4.length) && (r4.visible = false), nHt(r4, o4, "values", s3), a4("hoveron"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("arrangement"), a4("bundlecolors"), a4("sortpaths"), a4("counts");\n              var l3 = i3.font;\n              w5.coerceFont(a4, "labelfont", l3, { overrideDflt: { size: Math.round(l3.size) } }), w5.coerceFont(a4, "tickfont", l3, { autoShadowDflt: true, overrideDflt: { size: Math.round(l3.size / 1.2) } });\n            };\n          });\n          var aVe = ye((txr, nVe) => {\n            "use strict";\n            var lHt = Jm().wrap, uHt = pv().hasColorscale, cHt = gv(), fHt = JO(), hHt = So(), Fk = Dr(), dHt = Eo();\n            nVe.exports = function(t3, r4) {\n              var n4 = Fk.filterVisible(r4.dimensions);\n              if (n4.length === 0) return [];\n              var i3 = n4.map(function(g3) {\n                var P3;\n                if (g3.categoryorder === "trace") P3 = null;\n                else if (g3.categoryorder === "array") P3 = g3.categoryarray;\n                else {\n                  P3 = fHt(g3.values);\n                  for (var T3 = true, z3 = 0; z3 < P3.length; z3++) if (!dHt(P3[z3])) {\n                    T3 = false;\n                    break;\n                  }\n                  P3.sort(T3 ? Fk.sorterAsc : void 0), g3.categoryorder === "category descending" && (P3 = P3.reverse());\n                }\n                return xHt(g3.values, P3);\n              }), a4, o4, s3;\n              Fk.isArrayOrTypedArray(r4.counts) ? a4 = r4.counts : a4 = [r4.counts], bHt(n4), n4.forEach(function(g3, P3) {\n                wHt(g3, i3[P3]);\n              });\n              var l3 = r4.line, u4;\n              l3 ? (uHt(r4, "line") && cHt(t3, r4, { vals: r4.line.color, containerStr: "line", cLetter: "c" }), u4 = hHt.tryColorscale(l3)) : u4 = Fk.identity;\n              function c5(g3) {\n                var P3, T3;\n                return Fk.isArrayOrTypedArray(l3.color) ? (P3 = l3.color[g3 % l3.color.length], T3 = P3) : P3 = l3.color, { color: u4(P3), rawColor: T3 };\n              }\n              var f4 = n4[0].values.length, h3 = {}, d3 = i3.map(function(g3) {\n                return g3.inds;\n              });\n              s3 = 0;\n              var v3, _2;\n              for (v3 = 0; v3 < f4; v3++) {\n                var b = [];\n                for (_2 = 0; _2 < d3.length; _2++) b.push(d3[_2][v3]);\n                o4 = a4[v3 % a4.length], s3 += o4;\n                var p3 = c5(v3), k4 = b + "-" + p3.rawColor;\n                h3[k4] === void 0 && (h3[k4] = yHt(b, p3.color, p3.rawColor)), _Ht(h3[k4], v3, o4);\n              }\n              var E3 = n4.map(function(g3, P3) {\n                return pHt(P3, g3._index, g3._displayindex, g3.label, s3);\n              });\n              for (v3 = 0; v3 < f4; v3++) for (o4 = a4[v3 % a4.length], _2 = 0; _2 < E3.length; _2++) {\n                var S2 = E3[_2].containerInd, L3 = i3[_2].inds[v3], x2 = E3[_2].categories;\n                if (x2[L3] === void 0) {\n                  var C3 = r4.dimensions[S2]._categoryarray[L3], M4 = r4.dimensions[S2]._ticktext[L3];\n                  x2[L3] = gHt(_2, L3, C3, M4);\n                }\n                mHt(x2[L3], v3, o4);\n              }\n              return lHt(vHt(E3, h3, s3));\n            };\n            function vHt(e3, t3, r4) {\n              var n4 = e3.map(function(i3) {\n                return i3.categories.length;\n              }).reduce(function(i3, a4) {\n                return Math.max(i3, a4);\n              });\n              return { dimensions: e3, paths: t3, trace: void 0, maxCats: n4, count: r4 };\n            }\n            function pHt(e3, t3, r4, n4, i3) {\n              return { dimensionInd: e3, containerInd: t3, displayInd: r4, dimensionLabel: n4, count: i3, categories: [], dragX: null };\n            }\n            function gHt(e3, t3, r4, n4) {\n              return { dimensionInd: e3, categoryInd: t3, categoryValue: r4, displayInd: t3, categoryLabel: n4, valueInds: [], count: 0, dragY: null };\n            }\n            function mHt(e3, t3, r4) {\n              e3.valueInds.push(t3), e3.count += r4;\n            }\n            function yHt(e3, t3, r4) {\n              return { categoryInds: e3, color: t3, rawColor: r4, valueInds: [], count: 0 };\n            }\n            function _Ht(e3, t3, r4) {\n              e3.valueInds.push(t3), e3.count += r4;\n            }\n            function xHt(e3, t3) {\n              t3 == null ? t3 = [] : t3 = t3.map(function(u4) {\n                return u4;\n              });\n              var r4 = {}, n4 = {}, i3 = [];\n              t3.forEach(function(u4, c5) {\n                r4[u4] = 0, n4[u4] = c5;\n              });\n              for (var a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4], s3;\n                r4[o4] === void 0 ? (r4[o4] = 1, s3 = t3.push(o4) - 1, n4[o4] = s3) : (r4[o4]++, s3 = n4[o4]), i3.push(s3);\n              }\n              var l3 = t3.map(function(u4) {\n                return r4[u4];\n              });\n              return { uniqueValues: t3, uniqueCounts: l3, inds: i3 };\n            }\n            function bHt(e3) {\n              var t3 = e3.map(function(n4) {\n                return n4.displayindex;\n              }), r4;\n              if (THt(t3)) for (r4 = 0; r4 < e3.length; r4++) e3[r4]._displayindex = e3[r4].displayindex;\n              else for (r4 = 0; r4 < e3.length; r4++) e3[r4]._displayindex = r4;\n            }\n            function wHt(e3, t3) {\n              e3._categoryarray = t3.uniqueValues, e3.ticktext === null || e3.ticktext === void 0 ? e3._ticktext = [] : e3._ticktext = e3.ticktext.slice();\n              for (var r4 = e3._ticktext.length; r4 < t3.uniqueValues.length; r4++) e3._ticktext.push(t3.uniqueValues[r4]);\n            }\n            function THt(e3) {\n              for (var t3 = new Array(e3.length), r4 = 0; r4 < e3.length; r4++) {\n                if (e3[r4] < 0 || e3[r4] >= e3.length || t3[e3[r4]] !== void 0) return false;\n                t3[e3[r4]] = true;\n              }\n              return true;\n            }\n          });\n          var vVe = ye((rxr, dVe) => {\n            "use strict";\n            var Fl = Oa(), AHt = (F2(), ob(D22)).interpolateNumber, SHt = HP(), qk = vf(), yx = Dr(), zk = yx.strTranslate, oVe = So(), VK = cd(), MHt = ru();\n            function EHt(e3, t3, r4, n4) {\n              var i3 = t3._context.staticPlot, a4 = e3.map(VHt.bind(0, t3, r4)), o4 = n4.selectAll("g.parcatslayer").data([null]);\n              o4.enter().append("g").attr("class", "parcatslayer").style("pointer-events", i3 ? "none" : "all");\n              var s3 = o4.selectAll("g.trace.parcats").data(a4, u1), l3 = s3.enter().append("g").attr("class", "trace parcats");\n              s3.attr("transform", function(k4) {\n                return zk(k4.x, k4.y);\n              }), l3.append("g").attr("class", "paths");\n              var u4 = s3.select("g.paths"), c5 = u4.selectAll("path.path").data(function(k4) {\n                return k4.paths;\n              }, u1);\n              c5.attr("fill", function(k4) {\n                return k4.model.color;\n              });\n              var f4 = c5.enter().append("path").attr("class", "path").attr("stroke-opacity", 0).attr("fill", function(k4) {\n                return k4.model.color;\n              }).attr("fill-opacity", 0);\n              jK(f4), c5.attr("d", function(k4) {\n                return k4.svgD;\n              }), f4.empty() || c5.sort(GK), c5.exit().remove(), c5.on("mouseover", kHt).on("mouseout", CHt).on("click", LHt), l3.append("g").attr("class", "dimensions");\n              var h3 = s3.select("g.dimensions"), d3 = h3.selectAll("g.dimension").data(function(k4) {\n                return k4.dimensions;\n              }, u1);\n              d3.enter().append("g").attr("class", "dimension"), d3.attr("transform", function(k4) {\n                return zk(k4.x, 0);\n              }), d3.exit().remove();\n              var v3 = d3.selectAll("g.category").data(function(k4) {\n                return k4.categories;\n              }, u1), _2 = v3.enter().append("g").attr("class", "category");\n              v3.attr("transform", function(k4) {\n                return zk(0, k4.y);\n              }), _2.append("rect").attr("class", "catrect").attr("pointer-events", "none"), v3.select("rect.catrect").attr("fill", "none").attr("width", function(k4) {\n                return k4.width;\n              }).attr("height", function(k4) {\n                return k4.height;\n              }), lVe(_2);\n              var b = v3.selectAll("rect.bandrect").data(function(k4) {\n                return k4.bands;\n              }, u1);\n              b.each(function() {\n                yx.raiseToTop(this);\n              }), b.attr("fill", function(k4) {\n                return k4.color;\n              });\n              var p3 = b.enter().append("rect").attr("class", "bandrect").attr("stroke-opacity", 0).attr("fill", function(k4) {\n                return k4.color;\n              }).attr("fill-opacity", 0);\n              b.attr("fill", function(k4) {\n                return k4.color;\n              }).attr("width", function(k4) {\n                return k4.width;\n              }).attr("height", function(k4) {\n                return k4.height;\n              }).attr("y", function(k4) {\n                return k4.y;\n              }).attr("cursor", function(k4) {\n                return k4.parcatsViewModel.arrangement === "fixed" ? "default" : k4.parcatsViewModel.arrangement === "perpendicular" ? "ns-resize" : "move";\n              }), XK(p3), b.exit().remove(), _2.append("text").attr("class", "catlabel").attr("pointer-events", "none"), v3.select("text.catlabel").attr("text-anchor", function(k4) {\n                return Ok(k4) ? "start" : "end";\n              }).attr("alignment-baseline", "middle").style("fill", "rgb(0, 0, 0)").attr("x", function(k4) {\n                return Ok(k4) ? k4.width + 5 : -5;\n              }).attr("y", function(k4) {\n                return k4.height / 2;\n              }).text(function(k4) {\n                return k4.model.categoryLabel;\n              }).each(function(k4) {\n                oVe.font(Fl.select(this), k4.parcatsViewModel.categorylabelfont), MHt.convertToTspans(Fl.select(this), t3);\n              }), _2.append("text").attr("class", "dimlabel"), v3.select("text.dimlabel").attr("text-anchor", "middle").attr("alignment-baseline", "baseline").attr("cursor", function(k4) {\n                return k4.parcatsViewModel.arrangement === "fixed" ? "default" : "ew-resize";\n              }).attr("x", function(k4) {\n                return k4.width / 2;\n              }).attr("y", -5).text(function(k4, E3) {\n                return E3 === 0 ? k4.parcatsViewModel.model.dimensions[k4.model.dimensionInd].dimensionLabel : null;\n              }).each(function(k4) {\n                oVe.font(Fl.select(this), k4.parcatsViewModel.labelfont);\n              }), v3.selectAll("rect.bandrect").on("mouseover", OHt).on("mouseout", qHt), v3.exit().remove(), d3.call(Fl.behavior.drag().origin(function(k4) {\n                return { x: k4.x, y: 0 };\n              }).on("dragstart", BHt).on("drag", NHt).on("dragend", UHt)), s3.each(function(k4) {\n                k4.traceSelection = Fl.select(this), k4.pathSelection = Fl.select(this).selectAll("g.paths").selectAll("path.path"), k4.dimensionSelection = Fl.select(this).selectAll("g.dimensions").selectAll("g.dimension");\n              }), s3.exit().remove();\n            }\n            dVe.exports = function(e3, t3, r4, n4) {\n              EHt(r4, e3, n4, t3);\n            };\n            function u1(e3) {\n              return e3.key;\n            }\n            function Ok(e3) {\n              var t3 = e3.parcatsViewModel.dimensions.length, r4 = e3.parcatsViewModel.dimensions[t3 - 1].model.dimensionInd;\n              return e3.model.dimensionInd === r4;\n            }\n            function GK(e3, t3) {\n              return e3.model.rawColor > t3.model.rawColor ? 1 : e3.model.rawColor < t3.model.rawColor ? -1 : 0;\n            }\n            function kHt(e3) {\n              if (!e3.parcatsViewModel.dragDimension && e3.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {\n                yx.raiseToTop(this), WK(Fl.select(this));\n                var t3 = Bk(e3), r4 = HK(e3);\n                if (e3.parcatsViewModel.graphDiv.emit("plotly_hover", { points: t3, event: Fl.event, constraints: r4 }), e3.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {\n                  var n4 = Fl.mouse(this)[0], i3 = e3.parcatsViewModel.graphDiv, a4 = e3.parcatsViewModel.trace, o4 = i3._fullLayout, s3 = o4._paperdiv.node().getBoundingClientRect(), l3 = e3.parcatsViewModel.graphDiv.getBoundingClientRect(), u4, c5, f4;\n                  for (f4 = 0; f4 < e3.leftXs.length - 1; f4++) if (e3.leftXs[f4] + e3.dimWidths[f4] - 2 <= n4 && n4 <= e3.leftXs[f4 + 1] + 2) {\n                    var h3 = e3.parcatsViewModel.dimensions[f4], d3 = e3.parcatsViewModel.dimensions[f4 + 1];\n                    u4 = (h3.x + h3.width + d3.x) / 2, c5 = (e3.topYs[f4] + e3.topYs[f4 + 1] + e3.height) / 2;\n                    break;\n                  }\n                  var v3 = e3.parcatsViewModel.x + u4, _2 = e3.parcatsViewModel.y + c5, b = VK.mostReadable(e3.model.color, ["black", "white"]), p3 = e3.model.count, k4 = p3 / e3.parcatsViewModel.model.count, E3 = { countLabel: p3, probabilityLabel: k4.toFixed(3) }, S2 = [];\n                  e3.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && S2.push(["Count:", E3.countLabel].join(" ")), e3.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && S2.push(["P:", E3.probabilityLabel].join(" "));\n                  var L3 = S2.join("<br>"), x2 = Fl.mouse(i3)[0];\n                  qk.loneHover({ trace: a4, x: v3 - s3.left + l3.left, y: _2 - s3.top + l3.top, text: L3, color: e3.model.color, borderColor: "black", fontFamily: \'Monaco, "Courier New", monospace\', fontSize: 10, fontColor: b, idealAlign: x2 < v3 ? "right" : "left", hovertemplate: (a4.line || {}).hovertemplate, hovertemplateLabels: E3, eventData: [{ data: a4._input, fullData: a4, count: p3, probability: k4 }] }, { container: o4._hoverlayer.node(), outerContainer: o4._paper.node(), gd: i3 });\n                }\n              }\n            }\n            function CHt(e3) {\n              if (!e3.parcatsViewModel.dragDimension && (jK(Fl.select(this)), qk.loneUnhover(e3.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node()), e3.parcatsViewModel.pathSelection.sort(GK), e3.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1)) {\n                var t3 = Bk(e3), r4 = HK(e3);\n                e3.parcatsViewModel.graphDiv.emit("plotly_unhover", { points: t3, event: Fl.event, constraints: r4 });\n              }\n            }\n            function Bk(e3) {\n              for (var t3 = [], r4 = cVe(e3.parcatsViewModel), n4 = 0; n4 < e3.model.valueInds.length; n4++) {\n                var i3 = e3.model.valueInds[n4];\n                t3.push({ curveNumber: r4, pointNumber: i3 });\n              }\n              return t3;\n            }\n            function HK(e3) {\n              for (var t3 = {}, r4 = e3.parcatsViewModel.model.dimensions, n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3.categories[e3.model.categoryInds[n4]];\n                t3[i3.containerInd] = a4.categoryValue;\n              }\n              return e3.model.rawColor !== void 0 && (t3.color = e3.model.rawColor), t3;\n            }\n            function LHt(e3) {\n              if (e3.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {\n                var t3 = Bk(e3), r4 = HK(e3);\n                e3.parcatsViewModel.graphDiv.emit("plotly_click", { points: t3, event: Fl.event, constraints: r4 });\n              }\n            }\n            function jK(e3) {\n              e3.attr("fill", function(t3) {\n                return t3.model.color;\n              }).attr("fill-opacity", 0.6).attr("stroke", "lightgray").attr("stroke-width", 0.2).attr("stroke-opacity", 1);\n            }\n            function WK(e3) {\n              e3.attr("fill-opacity", 0.8).attr("stroke", function(t3) {\n                return VK.mostReadable(t3.model.color, ["black", "white"]);\n              }).attr("stroke-width", 0.3);\n            }\n            function PHt(e3) {\n              e3.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 2.5);\n            }\n            function lVe(e3) {\n              e3.select("rect.catrect").attr("stroke", "black").attr("stroke-width", 1).attr("stroke-opacity", 1);\n            }\n            function IHt(e3) {\n              e3.attr("stroke", "black").attr("stroke-width", 1.5);\n            }\n            function XK(e3) {\n              e3.attr("stroke", "black").attr("stroke-width", 0.2).attr("stroke-opacity", 1).attr("fill-opacity", 1);\n            }\n            function Hz(e3) {\n              var t3 = e3.parcatsViewModel.pathSelection, r4 = e3.categoryViewModel.model.dimensionInd, n4 = e3.categoryViewModel.model.categoryInd;\n              return t3.filter(function(i3) {\n                return i3.model.categoryInds[r4] === n4 && i3.model.color === e3.color;\n              });\n            }\n            function RHt(e3) {\n              var t3 = Fl.select(e3.parentNode).selectAll("rect.bandrect");\n              t3.each(function(r4) {\n                var n4 = Hz(r4);\n                WK(n4), n4.each(function() {\n                  yx.raiseToTop(this);\n                });\n              }), PHt(Fl.select(e3.parentNode));\n            }\n            function DHt(e3) {\n              var t3 = Fl.select(e3).datum(), r4 = Hz(t3);\n              WK(r4), r4.each(function() {\n                yx.raiseToTop(this);\n              }), Fl.select(e3.parentNode).selectAll("rect.bandrect").filter(function(n4) {\n                return n4.color === t3.color;\n              }).each(function() {\n                yx.raiseToTop(this), IHt(Fl.select(this));\n              });\n            }\n            function ZK(e3, t3, r4) {\n              var n4 = Fl.select(e3).datum(), i3 = n4.categoryViewModel.model, a4 = n4.parcatsViewModel.graphDiv, o4 = Fl.select(e3.parentNode).selectAll("rect.bandrect"), s3 = [];\n              o4.each(function(u4) {\n                var c5 = Hz(u4);\n                c5.each(function(f4) {\n                  Array.prototype.push.apply(s3, Bk(f4));\n                });\n              });\n              var l3 = {};\n              l3[i3.dimensionInd] = i3.categoryValue, a4.emit(t3, { points: s3, event: r4, constraints: l3 });\n            }\n            function YK(e3, t3, r4) {\n              var n4 = Fl.select(e3).datum(), i3 = n4.categoryViewModel.model, a4 = n4.parcatsViewModel.graphDiv, o4 = Hz(n4), s3 = [];\n              o4.each(function(u4) {\n                Array.prototype.push.apply(s3, Bk(u4));\n              });\n              var l3 = {};\n              l3[i3.dimensionInd] = i3.categoryValue, n4.rawColor !== void 0 && (l3.color = n4.rawColor), a4.emit(t3, { points: s3, event: r4, constraints: l3 });\n            }\n            function uVe(e3, t3, r4) {\n              e3._fullLayout._calcInverseTransform(e3);\n              var n4 = e3._fullLayout._invScaleX, i3 = e3._fullLayout._invScaleY, a4 = Fl.select(r4.parentNode).select("rect.catrect"), o4 = a4.node().getBoundingClientRect(), s3 = a4.datum(), l3 = s3.parcatsViewModel, u4 = l3.model.dimensions[s3.model.dimensionInd], c5 = l3.trace, f4 = o4.top + o4.height / 2, h3, d3;\n              l3.dimensions.length > 1 && u4.displayInd === l3.dimensions.length - 1 ? (h3 = o4.left, d3 = "left") : (h3 = o4.left + o4.width, d3 = "right");\n              var v3 = s3.model.count, _2 = s3.model.categoryLabel, b = v3 / s3.parcatsViewModel.model.count, p3 = { countLabel: v3, categoryLabel: _2, probabilityLabel: b.toFixed(3) }, k4 = [];\n              s3.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && k4.push(["Count:", p3.countLabel].join(" ")), s3.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && k4.push(["P(" + p3.categoryLabel + "):", p3.probabilityLabel].join(" "));\n              var E3 = k4.join("<br>");\n              return { trace: c5, x: n4 * (h3 - t3.left), y: i3 * (f4 - t3.top), text: E3, color: "lightgray", borderColor: "black", fontFamily: \'Monaco, "Courier New", monospace\', fontSize: 12, fontColor: "black", idealAlign: d3, hovertemplate: c5.hovertemplate, hovertemplateLabels: p3, eventData: [{ data: c5._input, fullData: c5, count: v3, category: _2, probability: b }] };\n            }\n            function FHt(e3, t3, r4) {\n              var n4 = [];\n              return Fl.select(r4.parentNode.parentNode).selectAll("g.category").select("rect.catrect").each(function() {\n                var i3 = this;\n                n4.push(uVe(e3, t3, i3));\n              }), n4;\n            }\n            function zHt(e3, t3, r4) {\n              e3._fullLayout._calcInverseTransform(e3);\n              var n4 = e3._fullLayout._invScaleX, i3 = e3._fullLayout._invScaleY, a4 = r4.getBoundingClientRect(), o4 = Fl.select(r4).datum(), s3 = o4.categoryViewModel, l3 = s3.parcatsViewModel, u4 = l3.model.dimensions[s3.model.dimensionInd], c5 = l3.trace, f4 = a4.y + a4.height / 2, h3, d3;\n              l3.dimensions.length > 1 && u4.displayInd === l3.dimensions.length - 1 ? (h3 = a4.left, d3 = "left") : (h3 = a4.left + a4.width, d3 = "right");\n              var v3 = s3.model.categoryLabel, _2 = o4.parcatsViewModel.model.count, b = 0;\n              o4.categoryViewModel.bands.forEach(function(P3) {\n                P3.color === o4.color && (b += P3.count);\n              });\n              var p3 = s3.model.count, k4 = 0;\n              l3.pathSelection.each(function(P3) {\n                P3.model.color === o4.color && (k4 += P3.model.count);\n              });\n              var E3 = b / _2, S2 = b / k4, L3 = b / p3, x2 = { countLabel: b, categoryLabel: v3, probabilityLabel: E3.toFixed(3) }, C3 = [];\n              s3.parcatsViewModel.hoverinfoItems.indexOf("count") !== -1 && C3.push(["Count:", x2.countLabel].join(" ")), s3.parcatsViewModel.hoverinfoItems.indexOf("probability") !== -1 && (C3.push("P(color \\u2229 " + v3 + "): " + x2.probabilityLabel), C3.push("P(" + v3 + " | color): " + S2.toFixed(3)), C3.push("P(color | " + v3 + "): " + L3.toFixed(3)));\n              var M4 = C3.join("<br>"), g3 = VK.mostReadable(o4.color, ["black", "white"]);\n              return { trace: c5, x: n4 * (h3 - t3.left), y: i3 * (f4 - t3.top), text: M4, color: o4.color, borderColor: "black", fontFamily: \'Monaco, "Courier New", monospace\', fontColor: g3, fontSize: 10, idealAlign: d3, hovertemplate: c5.hovertemplate, hovertemplateLabels: x2, eventData: [{ data: c5._input, fullData: c5, category: v3, count: _2, probability: E3, categorycount: p3, colorcount: k4, bandcolorcount: b }] };\n            }\n            function OHt(e3) {\n              if (!e3.parcatsViewModel.dragDimension && e3.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1) {\n                var t3 = Fl.mouse(this)[1];\n                if (t3 < -1) return;\n                var r4 = e3.parcatsViewModel.graphDiv, n4 = r4._fullLayout, i3 = n4._paperdiv.node().getBoundingClientRect(), a4 = e3.parcatsViewModel.hoveron, o4 = this;\n                if (a4 === "color" ? (DHt(o4), YK(o4, "plotly_hover", Fl.event)) : (RHt(o4), ZK(o4, "plotly_hover", Fl.event)), e3.parcatsViewModel.hoverinfoItems.indexOf("none") === -1) {\n                  var s3;\n                  a4 === "category" ? s3 = uVe(r4, i3, o4) : a4 === "color" ? s3 = zHt(r4, i3, o4) : a4 === "dimension" && (s3 = FHt(r4, i3, o4)), s3 && qk.loneHover(s3, { container: n4._hoverlayer.node(), outerContainer: n4._paper.node(), gd: r4 });\n                }\n              }\n            }\n            function qHt(e3) {\n              var t3 = e3.parcatsViewModel;\n              if (!t3.dragDimension && (jK(t3.pathSelection), lVe(t3.dimensionSelection.selectAll("g.category")), XK(t3.dimensionSelection.selectAll("g.category").selectAll("rect.bandrect")), qk.loneUnhover(t3.graphDiv._fullLayout._hoverlayer.node()), t3.pathSelection.sort(GK), t3.hoverinfoItems.indexOf("skip") === -1)) {\n                var r4 = e3.parcatsViewModel.hoveron, n4 = this;\n                r4 === "color" ? YK(n4, "plotly_unhover", Fl.event) : ZK(n4, "plotly_unhover", Fl.event);\n              }\n            }\n            function BHt(e3) {\n              e3.parcatsViewModel.arrangement !== "fixed" && (e3.dragDimensionDisplayInd = e3.model.displayInd, e3.initialDragDimensionDisplayInds = e3.parcatsViewModel.model.dimensions.map(function(t3) {\n                return t3.displayInd;\n              }), e3.dragHasMoved = false, e3.dragCategoryDisplayInd = null, Fl.select(this).selectAll("g.category").select("rect.catrect").each(function(t3) {\n                var r4 = Fl.mouse(this)[0], n4 = Fl.mouse(this)[1];\n                -2 <= r4 && r4 <= t3.width + 2 && -2 <= n4 && n4 <= t3.height + 2 && (e3.dragCategoryDisplayInd = t3.model.displayInd, e3.initialDragCategoryDisplayInds = e3.model.categories.map(function(i3) {\n                  return i3.displayInd;\n                }), t3.model.dragY = t3.y, yx.raiseToTop(this.parentNode), Fl.select(this.parentNode).selectAll("rect.bandrect").each(function(i3) {\n                  i3.y < n4 && n4 <= i3.y + i3.height && (e3.potentialClickBand = this);\n                }));\n              }), e3.parcatsViewModel.dragDimension = e3, qk.loneUnhover(e3.parcatsViewModel.graphDiv._fullLayout._hoverlayer.node()));\n            }\n            function NHt(e3) {\n              if (e3.parcatsViewModel.arrangement !== "fixed" && (e3.dragHasMoved = true, e3.dragDimensionDisplayInd !== null)) {\n                var t3 = e3.dragDimensionDisplayInd, r4 = t3 - 1, n4 = t3 + 1, i3 = e3.parcatsViewModel.dimensions[t3];\n                if (e3.dragCategoryDisplayInd !== null) {\n                  var a4 = i3.categories[e3.dragCategoryDisplayInd];\n                  a4.model.dragY += Fl.event.dy;\n                  var o4 = a4.model.dragY, s3 = a4.model.displayInd, l3 = i3.categories, u4 = l3[s3 - 1], c5 = l3[s3 + 1];\n                  u4 !== void 0 && o4 < u4.y + u4.height / 2 && (a4.model.displayInd = u4.model.displayInd, u4.model.displayInd = s3), c5 !== void 0 && o4 + a4.height > c5.y + c5.height / 2 && (a4.model.displayInd = c5.model.displayInd, c5.model.displayInd = s3), e3.dragCategoryDisplayInd = a4.model.displayInd;\n                }\n                if (e3.dragCategoryDisplayInd === null || e3.parcatsViewModel.arrangement === "freeform") {\n                  i3.model.dragX = Fl.event.x;\n                  var f4 = e3.parcatsViewModel.dimensions[r4], h3 = e3.parcatsViewModel.dimensions[n4];\n                  f4 !== void 0 && i3.model.dragX < f4.x + f4.width && (i3.model.displayInd = f4.model.displayInd, f4.model.displayInd = t3), h3 !== void 0 && i3.model.dragX + i3.width > h3.x && (i3.model.displayInd = h3.model.displayInd, h3.model.displayInd = e3.dragDimensionDisplayInd), e3.dragDimensionDisplayInd = i3.model.displayInd;\n                }\n                JK(e3.parcatsViewModel), KK(e3.parcatsViewModel), hVe(e3.parcatsViewModel), fVe(e3.parcatsViewModel);\n              }\n            }\n            function UHt(e3) {\n              if (e3.parcatsViewModel.arrangement !== "fixed" && e3.dragDimensionDisplayInd !== null) {\n                Fl.select(this).selectAll("text").attr("font-weight", "normal");\n                var t3 = {}, r4 = cVe(e3.parcatsViewModel), n4 = e3.parcatsViewModel.model.dimensions.map(function(h3) {\n                  return h3.displayInd;\n                }), i3 = e3.initialDragDimensionDisplayInds.some(function(h3, d3) {\n                  return h3 !== n4[d3];\n                });\n                i3 && n4.forEach(function(h3, d3) {\n                  var v3 = e3.parcatsViewModel.model.dimensions[d3].containerInd;\n                  t3["dimensions[" + v3 + "].displayindex"] = h3;\n                });\n                var a4 = false;\n                if (e3.dragCategoryDisplayInd !== null) {\n                  var o4 = e3.model.categories.map(function(h3) {\n                    return h3.displayInd;\n                  });\n                  if (a4 = e3.initialDragCategoryDisplayInds.some(function(h3, d3) {\n                    return h3 !== o4[d3];\n                  }), a4) {\n                    var s3 = e3.model.categories.slice().sort(function(h3, d3) {\n                      return h3.displayInd - d3.displayInd;\n                    }), l3 = s3.map(function(h3) {\n                      return h3.categoryValue;\n                    }), u4 = s3.map(function(h3) {\n                      return h3.categoryLabel;\n                    });\n                    t3["dimensions[" + e3.model.containerInd + "].categoryarray"] = [l3], t3["dimensions[" + e3.model.containerInd + "].ticktext"] = [u4], t3["dimensions[" + e3.model.containerInd + "].categoryorder"] = "array";\n                  }\n                }\n                if (e3.parcatsViewModel.hoverinfoItems.indexOf("skip") === -1 && !e3.dragHasMoved && e3.potentialClickBand && (e3.parcatsViewModel.hoveron === "color" ? YK(e3.potentialClickBand, "plotly_click", Fl.event.sourceEvent) : ZK(e3.potentialClickBand, "plotly_click", Fl.event.sourceEvent)), e3.model.dragX = null, e3.dragCategoryDisplayInd !== null) {\n                  var c5 = e3.parcatsViewModel.dimensions[e3.dragDimensionDisplayInd].categories[e3.dragCategoryDisplayInd];\n                  c5.model.dragY = null, e3.dragCategoryDisplayInd = null;\n                }\n                e3.dragDimensionDisplayInd = null, e3.parcatsViewModel.dragDimension = null, e3.dragHasMoved = null, e3.potentialClickBand = null, JK(e3.parcatsViewModel), KK(e3.parcatsViewModel);\n                var f4 = Fl.transition().duration(300).ease("cubic-in-out");\n                f4.each(function() {\n                  hVe(e3.parcatsViewModel, true), fVe(e3.parcatsViewModel, true);\n                }).each("end", function() {\n                  (i3 || a4) && SHt.restyle(e3.parcatsViewModel.graphDiv, t3, [r4]);\n                });\n              }\n            }\n            function cVe(e3) {\n              for (var t3, r4 = e3.graphDiv._fullData, n4 = 0; n4 < r4.length; n4++) if (e3.key === r4[n4].uid) {\n                t3 = n4;\n                break;\n              }\n              return t3;\n            }\n            function fVe(e3, t3) {\n              t3 === void 0 && (t3 = false);\n              function r4(n4) {\n                return t3 ? n4.transition() : n4;\n              }\n              e3.pathSelection.data(function(n4) {\n                return n4.paths;\n              }, u1), r4(e3.pathSelection).attr("d", function(n4) {\n                return n4.svgD;\n              });\n            }\n            function hVe(e3, t3) {\n              t3 === void 0 && (t3 = false);\n              function r4(l3) {\n                return t3 ? l3.transition() : l3;\n              }\n              e3.dimensionSelection.data(function(l3) {\n                return l3.dimensions;\n              }, u1);\n              var n4 = e3.dimensionSelection.selectAll("g.category").data(function(l3) {\n                return l3.categories;\n              }, u1);\n              r4(e3.dimensionSelection).attr("transform", function(l3) {\n                return zk(l3.x, 0);\n              }), r4(n4).attr("transform", function(l3) {\n                return zk(0, l3.y);\n              });\n              var i3 = n4.select(".dimlabel");\n              i3.text(function(l3, u4) {\n                return u4 === 0 ? l3.parcatsViewModel.model.dimensions[l3.model.dimensionInd].dimensionLabel : null;\n              });\n              var a4 = n4.select(".catlabel");\n              a4.attr("text-anchor", function(l3) {\n                return Ok(l3) ? "start" : "end";\n              }).attr("x", function(l3) {\n                return Ok(l3) ? l3.width + 5 : -5;\n              }).each(function(l3) {\n                var u4, c5;\n                Ok(l3) ? (u4 = l3.width + 5, c5 = "start") : (u4 = -5, c5 = "end"), Fl.select(this).selectAll("tspan").attr("x", u4).attr("text-anchor", c5);\n              });\n              var o4 = n4.selectAll("rect.bandrect").data(function(l3) {\n                return l3.bands;\n              }, u1), s3 = o4.enter().append("rect").attr("class", "bandrect").attr("cursor", "move").attr("stroke-opacity", 0).attr("fill", function(l3) {\n                return l3.color;\n              }).attr("fill-opacity", 0);\n              o4.attr("fill", function(l3) {\n                return l3.color;\n              }).attr("width", function(l3) {\n                return l3.width;\n              }).attr("height", function(l3) {\n                return l3.height;\n              }).attr("y", function(l3) {\n                return l3.y;\n              }), XK(s3), o4.each(function() {\n                yx.raiseToTop(this);\n              }), o4.exit().remove();\n            }\n            function VHt(e3, t3, r4) {\n              var n4 = r4[0], i3 = t3.margin || { l: 80, r: 80, t: 100, b: 80 }, a4 = n4.trace, o4 = a4.domain, s3 = t3.width, l3 = t3.height, u4 = Math.floor(s3 * (o4.x[1] - o4.x[0])), c5 = Math.floor(l3 * (o4.y[1] - o4.y[0])), f4 = o4.x[0] * s3 + i3.l, h3 = t3.height - o4.y[1] * t3.height + i3.t, d3 = a4.line.shape, v3;\n              a4.hoverinfo === "all" ? v3 = ["count", "probability"] : v3 = (a4.hoverinfo || "").split("+");\n              var _2 = { trace: a4, key: a4.uid, model: n4, x: f4, y: h3, width: u4, height: c5, hoveron: a4.hoveron, hoverinfoItems: v3, arrangement: a4.arrangement, bundlecolors: a4.bundlecolors, sortpaths: a4.sortpaths, labelfont: a4.labelfont, categorylabelfont: a4.tickfont, pathShape: d3, dragDimension: null, margin: i3, paths: [], dimensions: [], graphDiv: e3, traceSelection: null, pathSelection: null, dimensionSelection: null };\n              return n4.dimensions && (JK(_2), KK(_2)), _2;\n            }\n            function sVe(e3, t3, r4, n4, i3) {\n              var a4 = [], o4 = [], s3, l3;\n              for (l3 = 0; l3 < r4.length - 1; l3++) s3 = AHt(r4[l3] + e3[l3], e3[l3 + 1]), a4.push(s3(i3)), o4.push(s3(1 - i3));\n              var u4 = "M " + e3[0] + "," + t3[0];\n              for (u4 += "l" + r4[0] + ",0 ", l3 = 1; l3 < r4.length; l3++) u4 += "C" + a4[l3 - 1] + "," + t3[l3 - 1] + " " + o4[l3 - 1] + "," + t3[l3] + " " + e3[l3] + "," + t3[l3], u4 += "l" + r4[l3] + ",0 ";\n              for (u4 += "l0," + n4 + " ", u4 += "l -" + r4[r4.length - 1] + ",0 ", l3 = r4.length - 2; l3 >= 0; l3--) u4 += "C" + o4[l3] + "," + (t3[l3 + 1] + n4) + " " + a4[l3] + "," + (t3[l3] + n4) + " " + (e3[l3] + r4[l3]) + "," + (t3[l3] + n4), u4 += "l-" + r4[l3] + ",0 ";\n              return u4 += "Z", u4;\n            }\n            function KK(e3) {\n              var t3 = e3.dimensions, r4 = e3.model, n4 = t3.map(function(O3) {\n                return O3.categories.map(function(V2) {\n                  return V2.y;\n                });\n              }), i3 = e3.model.dimensions.map(function(O3) {\n                return O3.categories.map(function(V2) {\n                  return V2.displayInd;\n                });\n              }), a4 = e3.model.dimensions.map(function(O3) {\n                return O3.displayInd;\n              }), o4 = e3.dimensions.map(function(O3) {\n                return O3.model.dimensionInd;\n              }), s3 = t3.map(function(O3) {\n                return O3.x;\n              }), l3 = t3.map(function(O3) {\n                return O3.width;\n              }), u4 = [];\n              for (var c5 in r4.paths) r4.paths.hasOwnProperty(c5) && u4.push(r4.paths[c5]);\n              function f4(O3) {\n                var V2 = O3.categoryInds.map(function(Z, j3) {\n                  return i3[j3][Z];\n                }), G2 = o4.map(function(Z) {\n                  return V2[Z];\n                });\n                return G2;\n              }\n              u4.sort(function(O3, V2) {\n                var G2 = f4(O3), Z = f4(V2);\n                return e3.sortpaths === "backward" && (G2.reverse(), Z.reverse()), G2.push(O3.valueInds[0]), Z.push(V2.valueInds[0]), e3.bundlecolors && (G2.unshift(O3.rawColor), Z.unshift(V2.rawColor)), G2 < Z ? -1 : G2 > Z ? 1 : 0;\n              });\n              for (var h3 = new Array(u4.length), d3 = t3[0].model.count, v3 = t3[0].categories.map(function(O3) {\n                return O3.height;\n              }).reduce(function(O3, V2) {\n                return O3 + V2;\n              }), _2 = 0; _2 < u4.length; _2++) {\n                var b = u4[_2], p3;\n                d3 > 0 ? p3 = v3 * (b.count / d3) : p3 = 0;\n                for (var k4 = new Array(n4.length), E3 = 0; E3 < b.categoryInds.length; E3++) {\n                  var S2 = b.categoryInds[E3], L3 = i3[E3][S2], x2 = a4[E3];\n                  k4[x2] = n4[x2][L3], n4[x2][L3] += p3;\n                  var C3 = e3.dimensions[x2].categories[L3], M4 = C3.bands.length, g3 = C3.bands[M4 - 1];\n                  if (g3 === void 0 || b.rawColor !== g3.rawColor) {\n                    var P3 = g3 === void 0 ? 0 : g3.y + g3.height;\n                    C3.bands.push({ key: P3, color: b.color, rawColor: b.rawColor, height: p3, width: C3.width, count: b.count, y: P3, categoryViewModel: C3, parcatsViewModel: e3 });\n                  } else {\n                    var T3 = C3.bands[M4 - 1];\n                    T3.height += p3, T3.count += b.count;\n                  }\n                }\n                var z3;\n                e3.pathShape === "hspline" ? z3 = sVe(s3, k4, l3, p3, 0.5) : z3 = sVe(s3, k4, l3, p3, 0), h3[_2] = { key: b.valueInds[0], model: b, height: p3, leftXs: s3, topYs: k4, dimWidths: l3, svgD: z3, parcatsViewModel: e3 };\n              }\n              e3.paths = h3;\n            }\n            function JK(e3) {\n              var t3 = e3.model.dimensions.map(function(o4) {\n                return { displayInd: o4.displayInd, dimensionInd: o4.dimensionInd };\n              });\n              t3.sort(function(o4, s3) {\n                return o4.displayInd - s3.displayInd;\n              });\n              var r4 = [];\n              for (var n4 in t3) {\n                var i3 = t3[n4].dimensionInd, a4 = e3.model.dimensions[i3];\n                r4.push(GHt(e3, a4));\n              }\n              e3.dimensions = r4;\n            }\n            function GHt(e3, t3) {\n              var r4 = 40, n4 = 16, i3 = e3.model.dimensions.length, a4 = t3.displayInd, o4, s3, l3;\n              i3 > 1 ? o4 = (e3.width - 2 * r4 - n4) / (i3 - 1) : o4 = 0, s3 = r4, l3 = s3 + o4 * a4;\n              var u4 = [], c5 = e3.model.maxCats, f4 = t3.categories.length, h3 = 8, d3 = t3.count, v3 = e3.height - h3 * (c5 - 1), _2, b, p3, k4, E3, S2 = (c5 - f4) * h3 / 2, L3 = t3.categories.map(function(x2) {\n                return { displayInd: x2.displayInd, categoryInd: x2.categoryInd };\n              });\n              for (L3.sort(function(x2, C3) {\n                return x2.displayInd - C3.displayInd;\n              }), E3 = 0; E3 < f4; E3++) k4 = L3[E3].categoryInd, b = t3.categories[k4], d3 > 0 ? _2 = b.count / d3 * v3 : _2 = 0, p3 = { key: b.valueInds[0], model: b, width: n4, height: _2, y: b.dragY !== null ? b.dragY : S2, bands: [], parcatsViewModel: e3 }, S2 = S2 + _2 + h3, u4.push(p3);\n              return { key: t3.dimensionInd, x: t3.dragX !== null ? t3.dragX : l3, y: 0, width: n4, model: t3, categories: u4, parcatsViewModel: e3, dragCategoryDisplayInd: null, dragDimensionDisplayInd: null, initialDragDimensionDisplayInds: null, initialDragCategoryDisplayInds: null, dragHasMoved: null, potentialClickBand: null };\n            }\n          });\n          var $K = ye((ixr, pVe) => {\n            "use strict";\n            var HHt = vVe();\n            pVe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._fullLayout, o4 = a4._paper, s3 = a4._size;\n              HHt(t3, o4, r4, { width: s3.w, height: s3.h, margin: { t: s3.t, r: s3.r, b: s3.b, l: s3.l } }, n4, i3);\n            };\n          });\n          var mVe = ye((jz) => {\n            "use strict";\n            var jHt = Id().getModuleCalcData, WHt = $K(), gVe = "parcats";\n            jz.name = gVe;\n            jz.plot = function(e3, t3, r4, n4) {\n              var i3 = jHt(e3.calcdata, gVe);\n              if (i3.length) {\n                var a4 = i3[0];\n                WHt(e3, a4, r4, n4);\n              }\n            };\n            jz.clean = function(e3, t3, r4, n4) {\n              var i3 = n4._has && n4._has("parcats"), a4 = t3._has && t3._has("parcats");\n              i3 && !a4 && n4._paperdiv.selectAll(".parcats").remove();\n            };\n          });\n          var _Ve = ye((axr, yVe) => {\n            "use strict";\n            yVe.exports = { attributes: UK(), supplyDefaults: iVe(), calc: aVe(), plot: $K(), colorbar: { container: "line", min: "cmin", max: "cmax" }, moduleType: "trace", name: "parcats", basePlotModule: mVe(), categories: ["noOpacity"], meta: {} };\n          });\n          var bVe = ye((oxr, xVe) => {\n            "use strict";\n            xVe.exports = _Ve();\n          });\n          var c1 = ye((sxr, kVe) => {\n            "use strict";\n            var XHt = Z1(), wVe = "1.13.4", MVe = \'\\xA9 <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors\', TVe = [\'\\xA9 <a target="_blank" href="https://carto.com/">Carto</a>\', MVe].join(" "), AVe = [\'Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>\', \'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>\', "|", \'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors\', \'under <a target="_blank" href="https://www.openstreetmap.org/copyright">ODbL</a>\'].join(" "), ZHt = [\'Map tiles by <a target="_blank" href="https://stamen.com">Stamen Design</a>\', \'under <a target="_blank" href="https://creativecommons.org/licenses/by/3.0">CC BY 3.0</a>\', "|", \'Data by <a target="_blank" href="https://openstreetmap.org">OpenStreetMap</a> contributors\', \'under <a target="_blank" href="https://creativecommons.org/licenses/by-sa/3.0">CC BY SA</a>\'].join(" "), EVe = { "open-street-map": { id: "osm", version: 8, sources: { "plotly-osm-tiles": { type: "raster", attribution: MVe, tiles: ["https://a.tile.openstreetmap.org/{z}/{x}/{y}.png", "https://b.tile.openstreetmap.org/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-osm-tiles", type: "raster", source: "plotly-osm-tiles", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "white-bg": { id: "white-bg", version: 8, sources: {}, layers: [{ id: "white-bg", type: "background", paint: { "background-color": "#FFFFFF" }, minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-positron": { id: "carto-positron", version: 8, sources: { "plotly-carto-positron": { type: "raster", attribution: TVe, tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-carto-positron", type: "raster", source: "plotly-carto-positron", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-darkmatter": { id: "carto-darkmatter", version: 8, sources: { "plotly-carto-darkmatter": { type: "raster", attribution: TVe, tiles: ["https://cartodb-basemaps-c.global.ssl.fastly.net/dark_all/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-carto-darkmatter", type: "raster", source: "plotly-carto-darkmatter", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-terrain": { id: "stamen-terrain", version: 8, sources: { "plotly-stamen-terrain": { type: "raster", attribution: AVe, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_terrain/{z}/{x}/{y}.png?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-terrain", type: "raster", source: "plotly-stamen-terrain", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-toner": { id: "stamen-toner", version: 8, sources: { "plotly-stamen-toner": { type: "raster", attribution: AVe, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_toner/{z}/{x}/{y}.png?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-toner", type: "raster", source: "plotly-stamen-toner", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "stamen-watercolor": { id: "stamen-watercolor", version: 8, sources: { "plotly-stamen-watercolor": { type: "raster", attribution: ZHt, tiles: ["https://tiles.stadiamaps.com/tiles/stamen_watercolor/{z}/{x}/{y}.jpg?api_key="], tileSize: 256 } }, layers: [{ id: "plotly-stamen-watercolor", type: "raster", source: "plotly-stamen-watercolor", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" } }, SVe = XHt(EVe);\n            kVe.exports = { requiredVersion: wVe, styleUrlPrefix: "mapbox://styles/mapbox/", styleUrlSuffix: "v9", styleValuesMapbox: ["basic", "streets", "outdoors", "light", "dark", "satellite", "satellite-streets"], styleValueDflt: "basic", stylesNonMapbox: EVe, styleValuesNonMapbox: SVe, traceLayerPrefix: "plotly-trace-layer-", layoutLayerPrefix: "plotly-layout-layer-", wrongVersionErrorMsg: ["Your custom plotly.js bundle is not using the correct mapbox-gl version", "Please install @plotly/mapbox-gl@" + wVe + "."].join(`\n`), noAccessTokenErrorMsg: ["Missing Mapbox access token.", "Mapbox trace type require a Mapbox access token to be registered.", "For example:", "  Plotly.newPlot(gd, data, layout, { mapboxAccessToken: \'my-access-token\' });", "More info here: https://www.mapbox.com/help/define-access-token/"].join(`\n`), missingStyleErrorMsg: ["No valid mapbox style found, please set `mapbox.style` to one of:", SVe.join(", "), "or register a Mapbox access token to use a Mapbox-served style."].join(`\n`), multipleTokensErrorMsg: ["Set multiple mapbox access token across different mapbox subplot,", "using first token found as mapbox-gl does not allow multipleaccess tokens on the same page."].join(`\n`), mapOnErrorMsg: "Mapbox error.", mapboxLogo: { path0: "m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z", path1: "M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z", path2: "M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z", polygon: "11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34" }, styleRules: { map: "overflow:hidden;position:relative;", "missing-css": "display:none;", canary: "background-color:salmon;", "ctrl-bottom-left": "position: absolute; pointer-events: none; z-index: 2; bottom: 0; left: 0;", "ctrl-bottom-right": "position: absolute; pointer-events: none; z-index: 2; right: 0; bottom: 0;", ctrl: "clear: both; pointer-events: auto; transform: translate(0, 0);", "ctrl-attrib.mapboxgl-compact .mapboxgl-ctrl-attrib-inner": "display: none;", "ctrl-attrib.mapboxgl-compact:hover .mapboxgl-ctrl-attrib-inner": "display: block; margin-top:2px", "ctrl-attrib.mapboxgl-compact:hover": "padding: 2px 24px 2px 4px; visibility: visible; margin-top: 6px;", "ctrl-attrib.mapboxgl-compact::after": `content: ""; cursor: pointer; position: absolute; background-image: url(\'data:image/svg+xml;charset=utf-8,%3Csvg viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"%3E %3Cpath fill="%23333333" fill-rule="evenodd" d="M4,10a6,6 0 1,0 12,0a6,6 0 1,0 -12,0 M9,7a1,1 0 1,0 2,0a1,1 0 1,0 -2,0 M9,10a1,1 0 1,1 2,0l0,3a1,1 0 1,1 -2,0"/%3E %3C/svg%3E\'); background-color: rgba(255, 255, 255, 0.5); width: 24px; height: 24px; box-sizing: border-box; border-radius: 12px;`, "ctrl-attrib.mapboxgl-compact": "min-height: 20px; padding: 0; margin: 10px; position: relative; background-color: #fff; border-radius: 3px 12px 12px 3px;", "ctrl-bottom-right > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; right: 0", "ctrl-bottom-left > .mapboxgl-ctrl-attrib.mapboxgl-compact::after": "bottom: 0; left: 0", "ctrl-bottom-left .mapboxgl-ctrl": "margin: 0 0 10px 10px; float: left;", "ctrl-bottom-right .mapboxgl-ctrl": "margin: 0 10px 10px 0; float: right;", "ctrl-attrib": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px", "ctrl-attrib a": "color: rgba(0, 0, 0, 0.75); text-decoration: none; font-size: 12px", "ctrl-attrib a:hover": "color: inherit; text-decoration: underline;", "ctrl-attrib .mapbox-improve-map": "font-weight: bold; margin-left: 2px;", "attrib-empty": "display: none;", "ctrl-logo": `display:block; width: 21px; height: 21px; background-image: url(\'data:image/svg+xml;charset=utf-8,%3C?xml version="1.0" encoding="utf-8"?%3E %3Csvg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 21 21" style="enable-background:new 0 0 21 21;" xml:space="preserve"%3E%3Cg transform="translate(0,0.01)"%3E%3Cpath d="m 10.5,1.24 c -5.11,0 -9.25,4.15 -9.25,9.25 0,5.1 4.15,9.25 9.25,9.25 5.1,0 9.25,-4.15 9.25,-9.25 0,-5.11 -4.14,-9.25 -9.25,-9.25 z m 4.39,11.53 c -1.93,1.93 -4.78,2.31 -6.7,2.31 -0.7,0 -1.41,-0.05 -2.1,-0.16 0,0 -1.02,-5.64 2.14,-8.81 0.83,-0.83 1.95,-1.28 3.13,-1.28 1.27,0 2.49,0.51 3.39,1.42 1.84,1.84 1.89,4.75 0.14,6.52 z" style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3Cpath d="M 10.5,-0.01 C 4.7,-0.01 0,4.7 0,10.49 c 0,5.79 4.7,10.5 10.5,10.5 5.8,0 10.5,-4.7 10.5,-10.5 C 20.99,4.7 16.3,-0.01 10.5,-0.01 Z m 0,19.75 c -5.11,0 -9.25,-4.15 -9.25,-9.25 0,-5.1 4.14,-9.26 9.25,-9.26 5.11,0 9.25,4.15 9.25,9.25 0,5.13 -4.14,9.26 -9.25,9.26 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpath d="M 14.74,6.25 C 12.9,4.41 9.98,4.35 8.23,6.1 5.07,9.27 6.09,14.91 6.09,14.91 c 0,0 5.64,1.02 8.81,-2.14 C 16.64,11 16.59,8.09 14.74,6.25 Z m -2.27,4.09 -0.91,1.87 -0.9,-1.87 -1.86,-0.91 1.86,-0.9 0.9,-1.87 0.91,1.87 1.86,0.9 z" style="opacity:0.35;enable-background:new" class="st1"/%3E%3Cpolygon points="11.56,12.21 10.66,10.34 8.8,9.43 10.66,8.53 11.56,6.66 12.47,8.53 14.33,9.43 12.47,10.34 " style="opacity:0.9;fill:%23ffffff;enable-background:new" class="st0"/%3E%3C/g%3E%3C/svg%3E\')` } };\n          });\n          var Nk = ye((lxr, IVe) => {\n            "use strict";\n            var CVe = Dr(), LVe = ka().defaultLine, YHt = Cc().attributes, KHt = ec(), JHt = pf().textposition, $Ht = mc().overrideAll, QHt = vl().templatedArray, QK = c1(), PVe = KHt({ noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true });\n            PVe.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";\n            var ejt = IVe.exports = $Ht({ _arrayAttrRegexps: [CVe.counterRegex("mapbox", ".layers", true)], domain: YHt({ name: "mapbox" }), accesstoken: { valType: "string", noBlank: true, strict: true }, style: { valType: "any", values: QK.styleValuesMapbox.concat(QK.styleValuesNonMapbox), dflt: QK.styleValueDflt }, center: { lon: { valType: "number", dflt: 0 }, lat: { valType: "number", dflt: 0 } }, zoom: { valType: "number", dflt: 1 }, bearing: { valType: "number", dflt: 0 }, pitch: { valType: "number", dflt: 0 }, bounds: { west: { valType: "number" }, east: { valType: "number" }, south: { valType: "number" }, north: { valType: "number" } }, layers: QHt("layer", { visible: { valType: "boolean", dflt: true }, sourcetype: { valType: "enumerated", values: ["geojson", "vector", "raster", "image"], dflt: "geojson" }, source: { valType: "any" }, sourcelayer: { valType: "string", dflt: "" }, sourceattribution: { valType: "string" }, type: { valType: "enumerated", values: ["circle", "line", "fill", "symbol", "raster"], dflt: "circle" }, coordinates: { valType: "any" }, below: { valType: "string" }, color: { valType: "color", dflt: LVe }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, minzoom: { valType: "number", min: 0, max: 24, dflt: 0 }, maxzoom: { valType: "number", min: 0, max: 24, dflt: 24 }, circle: { radius: { valType: "number", dflt: 15 } }, line: { width: { valType: "number", dflt: 2 }, dash: { valType: "data_array" } }, fill: { outlinecolor: { valType: "color", dflt: LVe } }, symbol: { icon: { valType: "string", dflt: "marker" }, iconsize: { valType: "number", dflt: 10 }, text: { valType: "string", dflt: "" }, placement: { valType: "enumerated", values: ["point", "line", "line-center"], dflt: "point" }, textfont: PVe, textposition: CVe.extendFlat({}, JHt, { arrayOk: false }) } }) }, "plot", "from-root");\n            ejt.uirevision = { valType: "any", editType: "none" };\n          });\n          var Wz = ye((uxr, zVe) => {\n            "use strict";\n            var { hovertemplateAttrs: tjt, texttemplateAttrs: rjt, templatefallbackAttrs: RVe } = Ll(), ijt = Cg(), Uk = j22(), T5 = pf(), DVe = Nk(), njt = Gl(), ajt = Tu(), rw = Ao().extendFlat, ojt = mc().overrideAll, sjt = Nk(), FVe = Uk.line, A5 = Uk.marker;\n            zVe.exports = ojt({ lon: Uk.lon, lat: Uk.lat, cluster: { enabled: { valType: "boolean" }, maxzoom: rw({}, sjt.layers.maxzoom, {}), step: { valType: "number", arrayOk: true, dflt: -1, min: -1 }, size: { valType: "number", arrayOk: true, dflt: 20, min: 0 }, color: { valType: "color", arrayOk: true }, opacity: rw({}, A5.opacity, { dflt: 1 }) }, mode: rw({}, T5.mode, { dflt: "markers" }), text: rw({}, T5.text, {}), texttemplate: rjt({ editType: "plot" }, { keys: ["lat", "lon", "text"] }), texttemplatefallback: RVe({ editType: "plot" }), hovertext: rw({}, T5.hovertext, {}), line: { color: FVe.color, width: FVe.width }, connectgaps: T5.connectgaps, marker: rw({ symbol: { valType: "string", dflt: "circle", arrayOk: true }, angle: { valType: "number", dflt: "auto", arrayOk: true }, allowoverlap: { valType: "boolean", dflt: false }, opacity: A5.opacity, size: A5.size, sizeref: A5.sizeref, sizemin: A5.sizemin, sizemode: A5.sizemode }, ajt("marker")), fill: Uk.fill, fillcolor: ijt(), textfont: DVe.layers.symbol.textfont, textposition: DVe.layers.symbol.textposition, below: { valType: "string" }, selected: { marker: T5.selected.marker }, unselected: { marker: T5.unselected.marker }, hoverinfo: rw({}, njt.hoverinfo, { flags: ["lon", "lat", "text", "name"] }), hovertemplate: tjt(), hovertemplatefallback: RVe() }, "calc", "nested");\n          });\n          var eJ = ye((cxr, OVe) => {\n            "use strict";\n            var ljt = ["Metropolis Black Italic", "Metropolis Black", "Metropolis Bold Italic", "Metropolis Bold", "Metropolis Extra Bold Italic", "Metropolis Extra Bold", "Metropolis Extra Light Italic", "Metropolis Extra Light", "Metropolis Light Italic", "Metropolis Light", "Metropolis Medium Italic", "Metropolis Medium", "Metropolis Regular Italic", "Metropolis Regular", "Metropolis Semi Bold Italic", "Metropolis Semi Bold", "Metropolis Thin Italic", "Metropolis Thin", "Open Sans Bold Italic", "Open Sans Bold", "Open Sans Extrabold Italic", "Open Sans Extrabold", "Open Sans Italic", "Open Sans Light Italic", "Open Sans Light", "Open Sans Regular", "Open Sans Semibold Italic", "Open Sans Semibold", "Klokantech Noto Sans Bold", "Klokantech Noto Sans CJK Bold", "Klokantech Noto Sans CJK Regular", "Klokantech Noto Sans Italic", "Klokantech Noto Sans Regular"];\n            OVe.exports = { isSupportedFont: function(e3) {\n              return ljt.indexOf(e3) !== -1;\n            } };\n          });\n          var NVe = ye((fxr, BVe) => {\n            "use strict";\n            var Vk = Dr(), tJ = Ru(), ujt = $p(), cjt = R0(), fjt = D0(), hjt = Rg(), qVe = Wz(), djt = eJ().isSupportedFont;\n            BVe.exports = function(t3, r4, n4, i3) {\n              function a4(p3, k4) {\n                return Vk.coerce(t3, r4, qVe, p3, k4);\n              }\n              function o4(p3, k4) {\n                return Vk.coerce2(t3, r4, qVe, p3, k4);\n              }\n              var s3 = vjt(t3, r4, a4);\n              if (!s3) {\n                r4.visible = false;\n                return;\n              }\n              if (a4("text"), a4("texttemplate"), a4("texttemplatefallback"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("mode"), a4("below"), tJ.hasMarkers(r4)) {\n                ujt(t3, r4, n4, i3, a4, { noLine: true, noAngle: true }), a4("marker.allowoverlap"), a4("marker.angle");\n                var l3 = r4.marker;\n                l3.symbol !== "circle" && (Vk.isArrayOrTypedArray(l3.size) && (l3.size = l3.size[0]), Vk.isArrayOrTypedArray(l3.color) && (l3.color = l3.color[0]));\n              }\n              tJ.hasLines(r4) && (cjt(t3, r4, n4, i3, a4, { noDash: true }), a4("connectgaps"));\n              var u4 = o4("cluster.maxzoom"), c5 = o4("cluster.step"), f4 = o4("cluster.color", r4.marker && r4.marker.color || n4), h3 = o4("cluster.size"), d3 = o4("cluster.opacity"), v3 = u4 !== false || c5 !== false || f4 !== false || h3 !== false || d3 !== false, _2 = a4("cluster.enabled", v3);\n              if (_2 || tJ.hasText(r4)) {\n                var b = i3.font.family;\n                fjt(t3, r4, i3, a4, { noSelect: true, noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true, font: { family: djt(b) ? b : "Open Sans Regular", weight: i3.font.weight, style: i3.font.style, size: i3.font.size, color: i3.font.color } });\n              }\n              a4("fill"), r4.fill !== "none" && hjt(t3, r4, n4, a4), Vk.coerceSelectionMarkerOpacity(r4, a4);\n            };\n            function vjt(e3, t3, r4) {\n              var n4 = r4("lon") || [], i3 = r4("lat") || [], a4 = Math.min(n4.length, i3.length);\n              return t3._length = a4, a4;\n            }\n          });\n          var rJ = ye((hxr, VVe) => {\n            "use strict";\n            var UVe = ho();\n            VVe.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.subplot]._subplot, o4 = a4.mockAxis, s3 = t3.lonlat;\n              return i3.lonLabel = UVe.tickText(o4, o4.c2l(s3[0]), true).text, i3.latLabel = UVe.tickText(o4, o4.c2l(s3[1]), true).text, i3;\n            };\n          });\n          var iJ = ye((dxr, HVe) => {\n            "use strict";\n            var GVe = Dr();\n            HVe.exports = function(t3, r4) {\n              var n4 = t3.split(" "), i3 = n4[0], a4 = n4[1], o4 = GVe.isArrayOrTypedArray(r4) ? GVe.mean(r4) : r4, s3 = 0.5 + o4 / 100, l3 = 1.5 + o4 / 100, u4 = ["", ""], c5 = [0, 0];\n              switch (i3) {\n                case "top":\n                  u4[0] = "top", c5[1] = -l3;\n                  break;\n                case "bottom":\n                  u4[0] = "bottom", c5[1] = l3;\n                  break;\n              }\n              switch (a4) {\n                case "left":\n                  u4[1] = "right", c5[0] = -s3;\n                  break;\n                case "right":\n                  u4[1] = "left", c5[0] = s3;\n                  break;\n              }\n              var f4;\n              return u4[0] && u4[1] ? f4 = u4.join("-") : u4[0] ? f4 = u4[0] : u4[1] ? f4 = u4[1] : f4 = "center", { anchor: f4, offset: c5 };\n            };\n          });\n          var KVe = ye((vxr, YVe) => {\n            "use strict";\n            var XVe = Eo(), av = Dr(), pjt = fs().BADNUM, Zz = tx(), jVe = tc(), gjt = So(), mjt = k3(), Yz = Ru(), yjt = eJ().isSupportedFont, _jt = iJ(), xjt = ip().appendArrayPointValue, bjt = ru().NEWLINES, wjt = ru().BR_TAG_ALL;\n            YVe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = n4.visible === true && n4._length !== 0, a4 = n4.fill !== "none", o4 = Yz.hasLines(n4), s3 = Yz.hasMarkers(n4), l3 = Yz.hasText(n4), u4 = s3 && n4.marker.symbol === "circle", c5 = s3 && n4.marker.symbol !== "circle", f4 = n4.cluster && n4.cluster.enabled, h3 = Xz("fill"), d3 = Xz("line"), v3 = Xz("circle"), _2 = Xz("symbol"), b = { fill: h3, line: d3, circle: v3, symbol: _2 };\n              if (!i3) return b;\n              var p3;\n              if ((a4 || o4) && (p3 = Zz.calcTraceToLineCoords(r4)), a4 && (h3.geojson = Zz.makePolygon(p3), h3.layout.visibility = "visible", av.extendFlat(h3.paint, { "fill-color": n4.fillcolor })), o4 && (d3.geojson = Zz.makeLine(p3), d3.layout.visibility = "visible", av.extendFlat(d3.paint, { "line-width": n4.line.width, "line-color": n4.line.color, "line-opacity": n4.opacity })), u4) {\n                var k4 = Tjt(r4);\n                v3.geojson = k4.geojson, v3.layout.visibility = "visible", f4 && (v3.filter = ["!", ["has", "point_count"]], b.cluster = { type: "circle", filter: ["has", "point_count"], layout: { visibility: "visible" }, paint: { "circle-color": aJ(n4.cluster.color, n4.cluster.step), "circle-radius": aJ(n4.cluster.size, n4.cluster.step), "circle-opacity": aJ(n4.cluster.opacity, n4.cluster.step) } }, b.clusterCount = { type: "symbol", filter: ["has", "point_count"], paint: {}, layout: { "text-field": "{point_count_abbreviated}", "text-font": WVe(n4), "text-size": 12 } }), av.extendFlat(v3.paint, { "circle-color": k4.mcc, "circle-radius": k4.mrc, "circle-opacity": k4.mo });\n              }\n              if (u4 && f4 && (v3.filter = ["!", ["has", "point_count"]]), (c5 || l3) && (_2.geojson = Ajt(r4, t3), av.extendFlat(_2.layout, { visibility: "visible", "icon-image": "{symbol}-15", "text-field": "{text}" }), c5 && (av.extendFlat(_2.layout, { "icon-size": n4.marker.size / 10 }), "angle" in n4.marker && n4.marker.angle !== "auto" && av.extendFlat(_2.layout, { "icon-rotate": { type: "identity", property: "angle" }, "icon-rotation-alignment": "map" }), _2.layout["icon-allow-overlap"] = n4.marker.allowoverlap, av.extendFlat(_2.paint, { "icon-opacity": n4.opacity * n4.marker.opacity, "icon-color": n4.marker.color })), l3)) {\n                var E3 = (n4.marker || {}).size, S2 = _jt(n4.textposition, E3);\n                av.extendFlat(_2.layout, { "text-size": n4.textfont.size, "text-anchor": S2.anchor, "text-offset": S2.offset, "text-font": WVe(n4) }), av.extendFlat(_2.paint, { "text-color": n4.textfont.color, "text-opacity": n4.opacity });\n              }\n              return b;\n            };\n            function Xz(e3) {\n              return { type: e3, geojson: Zz.makeBlank(), layout: { visibility: "none" }, filter: null, paint: {} };\n            }\n            function Tjt(e3) {\n              var t3 = e3[0].trace, r4 = t3.marker, n4 = t3.selectedpoints, i3 = av.isArrayOrTypedArray(r4.color), a4 = av.isArrayOrTypedArray(r4.size), o4 = av.isArrayOrTypedArray(r4.opacity), s3;\n              function l3(E3) {\n                return t3.opacity * E3;\n              }\n              function u4(E3) {\n                return E3 / 2;\n              }\n              var c5;\n              i3 && (jVe.hasColorscale(t3, "marker") ? c5 = jVe.makeColorScaleFuncFromTrace(r4) : c5 = av.identity);\n              var f4;\n              a4 && (f4 = mjt(t3));\n              var h3;\n              o4 && (h3 = function(E3) {\n                var S2 = XVe(E3) ? +av.constrain(E3, 0, 1) : 0;\n                return l3(S2);\n              });\n              var d3 = [];\n              for (s3 = 0; s3 < e3.length; s3++) {\n                var v3 = e3[s3], _2 = v3.lonlat;\n                if (!ZVe(_2)) {\n                  var b = {};\n                  c5 && (b.mcc = v3.mcc = c5(v3.mc)), f4 && (b.mrc = v3.mrc = f4(v3.ms)), h3 && (b.mo = h3(v3.mo)), n4 && (b.selected = v3.selected || 0), d3.push({ type: "Feature", id: s3 + 1, geometry: { type: "Point", coordinates: _2 }, properties: b });\n                }\n              }\n              var p3;\n              if (n4) for (p3 = gjt.makeSelectedPointStyleFns(t3), s3 = 0; s3 < d3.length; s3++) {\n                var k4 = d3[s3].properties;\n                p3.selectedOpacityFn && (k4.mo = l3(p3.selectedOpacityFn(k4))), p3.selectedColorFn && (k4.mcc = p3.selectedColorFn(k4)), p3.selectedSizeFn && (k4.mrc = p3.selectedSizeFn(k4));\n              }\n              return { geojson: { type: "FeatureCollection", features: d3 }, mcc: i3 || p3 && p3.selectedColorFn ? { type: "identity", property: "mcc" } : r4.color, mrc: a4 || p3 && p3.selectedSizeFn ? { type: "identity", property: "mrc" } : u4(r4.size), mo: o4 || p3 && p3.selectedOpacityFn ? { type: "identity", property: "mo" } : l3(r4.opacity) };\n            }\n            function Ajt(e3, t3) {\n              for (var r4 = t3._fullLayout, n4 = e3[0].trace, i3 = n4.marker || {}, a4 = i3.symbol, o4 = i3.angle, s3 = a4 !== "circle" ? nJ(a4) : Kz, l3 = o4 !== "auto" ? nJ(o4, true) : Kz, u4 = Yz.hasText(n4) ? nJ(n4.text) : Kz, c5 = [], f4 = 0; f4 < e3.length; f4++) {\n                var h3 = e3[f4];\n                if (!ZVe(h3.lonlat)) {\n                  var d3 = n4.texttemplate, v3;\n                  if (d3) {\n                    var _2 = Array.isArray(d3) ? d3[f4] || "" : d3, b = n4._module.formatLabels(h3, n4, r4), p3 = {};\n                    xjt(p3, n4, h3.i), v3 = av.texttemplateString({ data: [p3, h3, n4._meta], fallback: n4.texttemplatefallback, labels: b, locale: r4._d3locale, template: _2 });\n                  } else v3 = u4(f4);\n                  v3 && (v3 = v3.replace(bjt, "").replace(wjt, `\n`)), c5.push({ type: "Feature", geometry: { type: "Point", coordinates: h3.lonlat }, properties: { symbol: s3(f4), angle: l3(f4), text: v3 } });\n                }\n              }\n              return { type: "FeatureCollection", features: c5 };\n            }\n            function nJ(e3, t3) {\n              return av.isArrayOrTypedArray(e3) ? t3 ? function(r4) {\n                return XVe(e3[r4]) ? +e3[r4] : 0;\n              } : function(r4) {\n                return e3[r4];\n              } : e3 ? function() {\n                return e3;\n              } : Kz;\n            }\n            function Kz() {\n              return "";\n            }\n            function ZVe(e3) {\n              return e3[0] === pjt;\n            }\n            function aJ(e3, t3) {\n              var r4;\n              if (av.isArrayOrTypedArray(e3) && av.isArrayOrTypedArray(t3)) {\n                r4 = ["step", ["get", "point_count"], e3[0]];\n                for (var n4 = 1; n4 < e3.length; n4++) r4.push(t3[n4 - 1], e3[n4]);\n              } else r4 = e3;\n              return r4;\n            }\n            function WVe(e3) {\n              var t3 = e3.textfont, r4 = t3.family, n4 = t3.style, i3 = t3.weight, a4 = r4.split(" "), o4 = a4[a4.length - 1] === "Italic";\n              o4 && a4.pop(), o4 = o4 || n4 === "italic";\n              var s3 = a4.join(" ");\n              i3 === "bold" && a4.indexOf("Bold") === -1 ? s3 += " Bold" : i3 <= 1e3 && (a4[0] === "Metropolis" ? (s3 = "Metropolis", i3 > 850 ? s3 += " Black" : i3 > 750 ? s3 += " Extra Bold" : i3 > 650 ? s3 += " Bold" : i3 > 550 ? s3 += " Semi Bold" : i3 > 450 ? s3 += " Medium" : i3 > 350 ? s3 += " Regular" : i3 > 250 ? s3 += " Light" : i3 > 150 ? s3 += " Extra Light" : s3 += " Thin") : a4.slice(0, 2).join(" ") === "Open Sans" ? (s3 = "Open Sans", i3 > 750 ? s3 += " Extrabold" : i3 > 650 ? s3 += " Bold" : i3 > 550 ? s3 += " Semibold" : i3 > 350 ? s3 += " Regular" : s3 += " Light") : a4.slice(0, 3).join(" ") === "Klokantech Noto Sans" && (s3 = "Klokantech Noto Sans", a4[3] === "CJK" && (s3 += " CJK"), s3 += i3 > 500 ? " Bold" : " Regular")), o4 && (s3 += " Italic"), s3 === "Open Sans Regular Italic" ? s3 = "Open Sans Italic" : s3 === "Open Sans Regular Bold" ? s3 = "Open Sans Bold" : s3 === "Open Sans Regular Bold Italic" ? s3 = "Open Sans Bold Italic" : s3 === "Klokantech Noto Sans Regular Italic" && (s3 = "Klokantech Noto Sans Italic"), yjt(s3) || (s3 = r4);\n              var l3 = s3.split(", ");\n              return l3;\n            }\n          });\n          var eGe = ye((pxr, QVe) => {\n            "use strict";\n            var Sjt = Dr(), JVe = KVe(), S5 = c1().traceLayerPrefix, rg = { cluster: ["cluster", "clusterCount", "circle"], nonCluster: ["fill", "line", "circle", "symbol"] };\n            function $Ve(e3, t3, r4, n4) {\n              this.type = "scattermapbox", this.subplot = e3, this.uid = t3, this.clusterEnabled = r4, this.isHidden = n4, this.sourceIds = { fill: "source-" + t3 + "-fill", line: "source-" + t3 + "-line", circle: "source-" + t3 + "-circle", symbol: "source-" + t3 + "-symbol", cluster: "source-" + t3 + "-circle", clusterCount: "source-" + t3 + "-circle" }, this.layerIds = { fill: S5 + t3 + "-fill", line: S5 + t3 + "-line", circle: S5 + t3 + "-circle", symbol: S5 + t3 + "-symbol", cluster: S5 + t3 + "-cluster", clusterCount: S5 + t3 + "-cluster-count" }, this.below = null;\n            }\n            var Gk = $Ve.prototype;\n            Gk.addSource = function(e3, t3, r4) {\n              var n4 = { type: "geojson", data: t3.geojson };\n              r4 && r4.enabled && Sjt.extendFlat(n4, { cluster: true, clusterMaxZoom: r4.maxzoom });\n              var i3 = this.subplot.map.getSource(this.sourceIds[e3]);\n              i3 ? i3.setData(t3.geojson) : this.subplot.map.addSource(this.sourceIds[e3], n4);\n            };\n            Gk.setSourceData = function(e3, t3) {\n              this.subplot.map.getSource(this.sourceIds[e3]).setData(t3.geojson);\n            };\n            Gk.addLayer = function(e3, t3, r4) {\n              var n4 = { type: t3.type, id: this.layerIds[e3], source: this.sourceIds[e3], layout: t3.layout, paint: t3.paint };\n              t3.filter && (n4.filter = t3.filter);\n              for (var i3 = this.layerIds[e3], a4, o4 = this.subplot.getMapLayers(), s3 = 0; s3 < o4.length; s3++) if (o4[s3].id === i3) {\n                a4 = true;\n                break;\n              }\n              a4 ? (this.subplot.setOptions(i3, "setLayoutProperty", n4.layout), n4.layout.visibility === "visible" && this.subplot.setOptions(i3, "setPaintProperty", n4.paint)) : this.subplot.addLayer(n4, r4);\n            };\n            Gk.update = function(t3) {\n              var r4 = t3[0].trace, n4 = this.subplot, i3 = n4.map, a4 = JVe(n4.gd, t3), o4 = n4.belowLookup["trace-" + this.uid], s3 = !!(r4.cluster && r4.cluster.enabled), l3 = !!this.clusterEnabled, u4 = this;\n              function c5(E3) {\n                E3 || u4.addSource("circle", a4.circle, r4.cluster);\n                for (var S2 = rg.cluster, L3 = 0; L3 < S2.length; L3++) {\n                  var x2 = S2[L3], C3 = a4[x2];\n                  u4.addLayer(x2, C3, o4);\n                }\n              }\n              function f4(E3) {\n                for (var S2 = rg.cluster, L3 = S2.length - 1; L3 >= 0; L3--) {\n                  var x2 = S2[L3];\n                  i3.removeLayer(u4.layerIds[x2]);\n                }\n                E3 || i3.removeSource(u4.sourceIds.circle);\n              }\n              function h3(E3) {\n                for (var S2 = rg.nonCluster, L3 = 0; L3 < S2.length; L3++) {\n                  var x2 = S2[L3], C3 = a4[x2];\n                  E3 || u4.addSource(x2, C3), u4.addLayer(x2, C3, o4);\n                }\n              }\n              function d3(E3) {\n                for (var S2 = rg.nonCluster, L3 = S2.length - 1; L3 >= 0; L3--) {\n                  var x2 = S2[L3];\n                  i3.removeLayer(u4.layerIds[x2]), E3 || i3.removeSource(u4.sourceIds[x2]);\n                }\n              }\n              function v3(E3) {\n                l3 ? f4(E3) : d3(E3);\n              }\n              function _2(E3) {\n                s3 ? c5(E3) : h3(E3);\n              }\n              function b() {\n                for (var E3 = s3 ? rg.cluster : rg.nonCluster, S2 = 0; S2 < E3.length; S2++) {\n                  var L3 = E3[S2], x2 = a4[L3];\n                  x2 && (n4.setOptions(u4.layerIds[L3], "setLayoutProperty", x2.layout), x2.layout.visibility === "visible" && (L3 !== "cluster" && u4.setSourceData(L3, x2), n4.setOptions(u4.layerIds[L3], "setPaintProperty", x2.paint)));\n                }\n              }\n              var p3 = this.isHidden, k4 = r4.visible !== true;\n              k4 ? p3 || v3() : p3 ? k4 || _2() : l3 !== s3 ? (v3(), _2()) : (this.below !== o4 && (v3(true), _2(true)), b()), this.clusterEnabled = s3, this.isHidden = k4, this.below = o4, t3[0].trace._glTrace = this;\n            };\n            Gk.dispose = function() {\n              for (var t3 = this.subplot.map, r4 = this.clusterEnabled ? rg.cluster : rg.nonCluster, n4 = r4.length - 1; n4 >= 0; n4--) {\n                var i3 = r4[n4];\n                t3.removeLayer(this.layerIds[i3]), t3.removeSource(this.sourceIds[i3]);\n              }\n            };\n            QVe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = n4.cluster && n4.cluster.enabled, a4 = n4.visible !== true, o4 = new $Ve(t3, n4.uid, i3, a4), s3 = JVe(t3.gd, r4), l3 = o4.below = t3.belowLookup["trace-" + n4.uid], u4, c5, f4;\n              if (i3) for (o4.addSource("circle", s3.circle, n4.cluster), u4 = 0; u4 < rg.cluster.length; u4++) c5 = rg.cluster[u4], f4 = s3[c5], o4.addLayer(c5, f4, l3);\n              else for (u4 = 0; u4 < rg.nonCluster.length; u4++) c5 = rg.nonCluster[u4], f4 = s3[c5], o4.addSource(c5, f4, n4.cluster), o4.addLayer(c5, f4, l3);\n              return r4[0].trace._glTrace = o4, o4;\n            };\n          });\n          var Jz = ye((gxr, rGe) => {\n            "use strict";\n            var Mjt = vf(), oJ = Dr(), Ejt = cT(), kjt = oJ.fillText, Cjt = fs().BADNUM, Ljt = c1().traceLayerPrefix;\n            function Pjt(e3, t3, r4) {\n              var n4 = e3.cd, i3 = n4[0].trace, a4 = e3.xa, o4 = e3.ya, s3 = e3.subplot, l3 = [], u4 = Ljt + i3.uid + "-circle", c5 = i3.cluster && i3.cluster.enabled;\n              if (c5) {\n                var f4 = s3.map.queryRenderedFeatures(null, { layers: [u4] });\n                l3 = f4.map(function(M4) {\n                  return M4.id;\n                });\n              }\n              var h3 = t3 >= 0 ? Math.floor((t3 + 180) / 360) : Math.ceil((t3 - 180) / 360), d3 = h3 * 360, v3 = t3 - d3;\n              function _2(M4) {\n                var g3 = M4.lonlat;\n                if (g3[0] === Cjt || c5 && l3.indexOf(M4.i + 1) === -1) return 1 / 0;\n                var P3 = oJ.modHalf(g3[0], 360), T3 = g3[1], z3 = s3.project([P3, T3]), O3 = z3.x - a4.c2p([v3, T3]), V2 = z3.y - o4.c2p([P3, r4]), G2 = Math.max(3, M4.mrc || 0);\n                return Math.max(Math.sqrt(O3 * O3 + V2 * V2) - G2, 1 - 3 / G2);\n              }\n              if (Mjt.getClosest(n4, _2, e3), e3.index !== false) {\n                var b = n4[e3.index], p3 = b.lonlat, k4 = [oJ.modHalf(p3[0], 360) + d3, p3[1]], E3 = a4.c2p(k4), S2 = o4.c2p(k4), L3 = b.mrc || 1;\n                e3.x0 = E3 - L3, e3.x1 = E3 + L3, e3.y0 = S2 - L3, e3.y1 = S2 + L3;\n                var x2 = {};\n                x2[i3.subplot] = { _subplot: s3 };\n                var C3 = i3._module.formatLabels(b, i3, x2);\n                return e3.lonLabel = C3.lonLabel, e3.latLabel = C3.latLabel, e3.color = Ejt(i3, b), e3.extraText = tGe(i3, b, n4[0].t.labels), e3.hovertemplate = i3.hovertemplate, [e3];\n              }\n            }\n            function tGe(e3, t3, r4) {\n              if (e3.hovertemplate) return;\n              var n4 = t3.hi || e3.hoverinfo, i3 = n4.split("+"), a4 = i3.indexOf("all") !== -1, o4 = i3.indexOf("lon") !== -1, s3 = i3.indexOf("lat") !== -1, l3 = t3.lonlat, u4 = [];\n              function c5(f4) {\n                return f4 + "\\xB0";\n              }\n              return a4 || o4 && s3 ? u4.push("(" + c5(l3[1]) + ", " + c5(l3[0]) + ")") : o4 ? u4.push(r4.lon + c5(l3[0])) : s3 && u4.push(r4.lat + c5(l3[1])), (a4 || i3.indexOf("text") !== -1) && kjt(t3, e3, u4), u4.join("<br>");\n            }\n            rGe.exports = { hoverPoints: Pjt, getExtraText: tGe };\n          });\n          var nGe = ye((mxr, iGe) => {\n            "use strict";\n            iGe.exports = function(t3, r4) {\n              return t3.lon = r4.lon, t3.lat = r4.lat, t3;\n            };\n          });\n          var oGe = ye((yxr, aGe) => {\n            "use strict";\n            var Ijt = Dr(), Rjt = Ru(), Djt = fs().BADNUM;\n            aGe.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3 = n4[0].trace, l3;\n              if (!Rjt.hasMarkers(s3)) return [];\n              if (r4 === false) for (l3 = 0; l3 < n4.length; l3++) n4[l3].selected = 0;\n              else for (l3 = 0; l3 < n4.length; l3++) {\n                var u4 = n4[l3], c5 = u4.lonlat;\n                if (c5[0] !== Djt) {\n                  var f4 = [Ijt.modHalf(c5[0], 360), c5[1]], h3 = [i3.c2p(f4), a4.c2p(f4)];\n                  r4.contains(h3, null, l3, t3) ? (o4.push({ pointNumber: l3, lon: c5[0], lat: c5[1] }), u4.selected = 1) : u4.selected = 0;\n                }\n              }\n              return o4;\n            };\n          });\n          var uJ = ye((sJ, lJ) => {\n            (function(e3, t3) {\n              typeof sJ == "object" && typeof lJ != "undefined" ? lJ.exports = t3() : (e3 = e3 || self, e3.mapboxgl = t3());\n            })(sJ, function() {\n              "use strict";\n              var e3, t3, r4;\n              function n4(i3, a4) {\n                if (!e3) e3 = a4;\n                else if (!t3) t3 = a4;\n                else {\n                  var o4 = "var sharedChunk = {}; (" + e3 + ")(sharedChunk); (" + t3 + ")(sharedChunk);", s3 = {};\n                  e3(s3), r4 = a4(s3), typeof window != "undefined" && (r4.workerUrl = window.URL.createObjectURL(new Blob([o4], { type: "text/javascript" })));\n                }\n              }\n              return n4(["exports"], function(i3) {\n                "use strict";\n                function a4(m3, y3) {\n                  return y3 = { exports: {} }, m3(y3, y3.exports), y3.exports;\n                }\n                var o4 = "1.13.4", s3 = l3;\n                function l3(m3, y3, I3, U) {\n                  this.cx = 3 * m3, this.bx = 3 * (I3 - m3) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * y3, this.by = 3 * (U - y3) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = m3, this.p1y = U, this.p2x = I3, this.p2y = U;\n                }\n                l3.prototype.sampleCurveX = function(m3) {\n                  return ((this.ax * m3 + this.bx) * m3 + this.cx) * m3;\n                }, l3.prototype.sampleCurveY = function(m3) {\n                  return ((this.ay * m3 + this.by) * m3 + this.cy) * m3;\n                }, l3.prototype.sampleCurveDerivativeX = function(m3) {\n                  return (3 * this.ax * m3 + 2 * this.bx) * m3 + this.cx;\n                }, l3.prototype.solveCurveX = function(m3, y3) {\n                  typeof y3 == "undefined" && (y3 = 1e-6);\n                  var I3, U, $2, ae, he;\n                  for ($2 = m3, he = 0; he < 8; he++) {\n                    if (ae = this.sampleCurveX($2) - m3, Math.abs(ae) < y3) return $2;\n                    var Oe = this.sampleCurveDerivativeX($2);\n                    if (Math.abs(Oe) < 1e-6) break;\n                    $2 = $2 - ae / Oe;\n                  }\n                  if (I3 = 0, U = 1, $2 = m3, $2 < I3) return I3;\n                  if ($2 > U) return U;\n                  for (; I3 < U; ) {\n                    if (ae = this.sampleCurveX($2), Math.abs(ae - m3) < y3) return $2;\n                    m3 > ae ? I3 = $2 : U = $2, $2 = (U - I3) * 0.5 + I3;\n                  }\n                  return $2;\n                }, l3.prototype.solve = function(m3, y3) {\n                  return this.sampleCurveY(this.solveCurveX(m3, y3));\n                };\n                var u4 = c5;\n                function c5(m3, y3) {\n                  this.x = m3, this.y = y3;\n                }\n                c5.prototype = { clone: function() {\n                  return new c5(this.x, this.y);\n                }, add: function(m3) {\n                  return this.clone()._add(m3);\n                }, sub: function(m3) {\n                  return this.clone()._sub(m3);\n                }, multByPoint: function(m3) {\n                  return this.clone()._multByPoint(m3);\n                }, divByPoint: function(m3) {\n                  return this.clone()._divByPoint(m3);\n                }, mult: function(m3) {\n                  return this.clone()._mult(m3);\n                }, div: function(m3) {\n                  return this.clone()._div(m3);\n                }, rotate: function(m3) {\n                  return this.clone()._rotate(m3);\n                }, rotateAround: function(m3, y3) {\n                  return this.clone()._rotateAround(m3, y3);\n                }, matMult: function(m3) {\n                  return this.clone()._matMult(m3);\n                }, unit: function() {\n                  return this.clone()._unit();\n                }, perp: function() {\n                  return this.clone()._perp();\n                }, round: function() {\n                  return this.clone()._round();\n                }, mag: function() {\n                  return Math.sqrt(this.x * this.x + this.y * this.y);\n                }, equals: function(m3) {\n                  return this.x === m3.x && this.y === m3.y;\n                }, dist: function(m3) {\n                  return Math.sqrt(this.distSqr(m3));\n                }, distSqr: function(m3) {\n                  var y3 = m3.x - this.x, I3 = m3.y - this.y;\n                  return y3 * y3 + I3 * I3;\n                }, angle: function() {\n                  return Math.atan2(this.y, this.x);\n                }, angleTo: function(m3) {\n                  return Math.atan2(this.y - m3.y, this.x - m3.x);\n                }, angleWith: function(m3) {\n                  return this.angleWithSep(m3.x, m3.y);\n                }, angleWithSep: function(m3, y3) {\n                  return Math.atan2(this.x * y3 - this.y * m3, this.x * m3 + this.y * y3);\n                }, _matMult: function(m3) {\n                  var y3 = m3[0] * this.x + m3[1] * this.y, I3 = m3[2] * this.x + m3[3] * this.y;\n                  return this.x = y3, this.y = I3, this;\n                }, _add: function(m3) {\n                  return this.x += m3.x, this.y += m3.y, this;\n                }, _sub: function(m3) {\n                  return this.x -= m3.x, this.y -= m3.y, this;\n                }, _mult: function(m3) {\n                  return this.x *= m3, this.y *= m3, this;\n                }, _div: function(m3) {\n                  return this.x /= m3, this.y /= m3, this;\n                }, _multByPoint: function(m3) {\n                  return this.x *= m3.x, this.y *= m3.y, this;\n                }, _divByPoint: function(m3) {\n                  return this.x /= m3.x, this.y /= m3.y, this;\n                }, _unit: function() {\n                  return this._div(this.mag()), this;\n                }, _perp: function() {\n                  var m3 = this.y;\n                  return this.y = this.x, this.x = -m3, this;\n                }, _rotate: function(m3) {\n                  var y3 = Math.cos(m3), I3 = Math.sin(m3), U = y3 * this.x - I3 * this.y, $2 = I3 * this.x + y3 * this.y;\n                  return this.x = U, this.y = $2, this;\n                }, _rotateAround: function(m3, y3) {\n                  var I3 = Math.cos(m3), U = Math.sin(m3), $2 = y3.x + I3 * (this.x - y3.x) - U * (this.y - y3.y), ae = y3.y + U * (this.x - y3.x) + I3 * (this.y - y3.y);\n                  return this.x = $2, this.y = ae, this;\n                }, _round: function() {\n                  return this.x = Math.round(this.x), this.y = Math.round(this.y), this;\n                } }, c5.convert = function(m3) {\n                  return m3 instanceof c5 ? m3 : Array.isArray(m3) ? new c5(m3[0], m3[1]) : m3;\n                };\n                var f4 = typeof self != "undefined" ? self : {};\n                function h3(m3, y3) {\n                  if (Array.isArray(m3)) {\n                    if (!Array.isArray(y3) || m3.length !== y3.length) return false;\n                    for (var I3 = 0; I3 < m3.length; I3++) if (!h3(m3[I3], y3[I3])) return false;\n                    return true;\n                  }\n                  if (typeof m3 == "object" && m3 !== null && y3 !== null) {\n                    if (typeof y3 != "object") return false;\n                    var U = Object.keys(m3);\n                    if (U.length !== Object.keys(y3).length) return false;\n                    for (var $2 in m3) if (!h3(m3[$2], y3[$2])) return false;\n                    return true;\n                  }\n                  return m3 === y3;\n                }\n                var d3 = Math.pow(2, 53) - 1;\n                function v3(m3) {\n                  if (m3 <= 0) return 0;\n                  if (m3 >= 1) return 1;\n                  var y3 = m3 * m3, I3 = y3 * m3;\n                  return 4 * (m3 < 0.5 ? I3 : 3 * (m3 - y3) + I3 - 0.75);\n                }\n                function _2(m3, y3, I3, U) {\n                  var $2 = new s3(m3, y3, I3, U);\n                  return function(ae) {\n                    return $2.solve(ae);\n                  };\n                }\n                var b = _2(0.25, 0.1, 0.25, 1);\n                function p3(m3, y3, I3) {\n                  return Math.min(I3, Math.max(y3, m3));\n                }\n                function k4(m3, y3, I3) {\n                  var U = I3 - y3, $2 = ((m3 - y3) % U + U) % U + y3;\n                  return $2 === y3 ? I3 : $2;\n                }\n                function E3(m3, y3, I3) {\n                  if (!m3.length) return I3(null, []);\n                  var U = m3.length, $2 = new Array(m3.length), ae = null;\n                  m3.forEach(function(he, Oe) {\n                    y3(he, function(rt, gt) {\n                      rt && (ae = rt), $2[Oe] = gt, --U === 0 && I3(ae, $2);\n                    });\n                  });\n                }\n                function S2(m3) {\n                  var y3 = [];\n                  for (var I3 in m3) y3.push(m3[I3]);\n                  return y3;\n                }\n                function L3(m3, y3) {\n                  var I3 = [];\n                  for (var U in m3) U in y3 || I3.push(U);\n                  return I3;\n                }\n                function x2(m3) {\n                  for (var y3 = [], I3 = arguments.length - 1; I3-- > 0; ) y3[I3] = arguments[I3 + 1];\n                  for (var U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    for (var he in ae) m3[he] = ae[he];\n                  }\n                  return m3;\n                }\n                function C3(m3, y3) {\n                  for (var I3 = {}, U = 0; U < y3.length; U++) {\n                    var $2 = y3[U];\n                    $2 in m3 && (I3[$2] = m3[$2]);\n                  }\n                  return I3;\n                }\n                var M4 = 1;\n                function g3() {\n                  return M4++;\n                }\n                function P3() {\n                  function m3(y3) {\n                    return y3 ? (y3 ^ Math.random() * 16 >> y3 / 4).toString(16) : ([1e7] + -[1e3] + -4e3 + -8e3 + -1e11).replace(/[018]/g, m3);\n                  }\n                  return m3();\n                }\n                function T3(m3) {\n                  return m3 <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(m3) / Math.LN2));\n                }\n                function z3(m3) {\n                  return m3 ? /^[0-9a-f]{8}-[0-9a-f]{4}-[4][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(m3) : false;\n                }\n                function O3(m3, y3) {\n                  m3.forEach(function(I3) {\n                    y3[I3] && (y3[I3] = y3[I3].bind(y3));\n                  });\n                }\n                function V2(m3, y3) {\n                  return m3.indexOf(y3, m3.length - y3.length) !== -1;\n                }\n                function G2(m3, y3, I3) {\n                  var U = {};\n                  for (var $2 in m3) U[$2] = y3.call(I3 || this, m3[$2], $2, m3);\n                  return U;\n                }\n                function Z(m3, y3, I3) {\n                  var U = {};\n                  for (var $2 in m3) y3.call(I3 || this, m3[$2], $2, m3) && (U[$2] = m3[$2]);\n                  return U;\n                }\n                function j3(m3) {\n                  return Array.isArray(m3) ? m3.map(j3) : typeof m3 == "object" && m3 ? G2(m3, j3) : m3;\n                }\n                function N2(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) if (y3.indexOf(m3[I3]) >= 0) return true;\n                  return false;\n                }\n                var H = {};\n                function te(m3) {\n                  H[m3] || (typeof console != "undefined" && console.warn(m3), H[m3] = true);\n                }\n                function oe(m3, y3, I3) {\n                  return (I3.y - m3.y) * (y3.x - m3.x) > (y3.y - m3.y) * (I3.x - m3.x);\n                }\n                function _e(m3) {\n                  for (var y3 = 0, I3 = 0, U = m3.length, $2 = U - 1, ae = void 0, he = void 0; I3 < U; $2 = I3++) ae = m3[I3], he = m3[$2], y3 += (he.x - ae.x) * (ae.y + he.y);\n                  return y3;\n                }\n                function Ee(m3) {\n                  var y3 = m3[0], I3 = m3[1], U = m3[2];\n                  return I3 += 90, I3 *= Math.PI / 180, U *= Math.PI / 180, { x: y3 * Math.cos(I3) * Math.sin(U), y: y3 * Math.sin(I3) * Math.sin(U), z: y3 * Math.cos(U) };\n                }\n                function Ce() {\n                  return typeof WorkerGlobalScope != "undefined" && typeof self != "undefined" && self instanceof WorkerGlobalScope;\n                }\n                function me(m3) {\n                  var y3 = /(?:^|(?:\\s*\\,\\s*))([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)(?:\\=(?:([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)|(?:\\"((?:[^"\\\\]|\\\\.)*)\\")))?/g, I3 = {};\n                  if (m3.replace(y3, function($2, ae, he, Oe) {\n                    var rt = he || Oe;\n                    return I3[ae] = rt ? rt.toLowerCase() : true, "";\n                  }), I3["max-age"]) {\n                    var U = parseInt(I3["max-age"], 10);\n                    isNaN(U) ? delete I3["max-age"] : I3["max-age"] = U;\n                  }\n                  return I3;\n                }\n                var ie = null;\n                function Se(m3) {\n                  if (ie == null) {\n                    var y3 = m3.navigator ? m3.navigator.userAgent : null;\n                    ie = !!m3.safari || !!(y3 && (/\\b(iPad|iPhone|iPod)\\b/.test(y3) || y3.match("Safari") && !y3.match("Chrome")));\n                  }\n                  return ie;\n                }\n                function Le(m3) {\n                  try {\n                    var y3 = f4[m3];\n                    return y3.setItem("_mapbox_test_", 1), y3.removeItem("_mapbox_test_"), true;\n                  } catch (I3) {\n                    return false;\n                  }\n                }\n                function Ae(m3) {\n                  return f4.btoa(encodeURIComponent(m3).replace(/%([0-9A-F]{2})/g, function(y3, I3) {\n                    return String.fromCharCode(+("0x" + I3));\n                  }));\n                }\n                function Fe(m3) {\n                  return decodeURIComponent(f4.atob(m3).split("").map(function(y3) {\n                    return "%" + ("00" + y3.charCodeAt(0).toString(16)).slice(-2);\n                  }).join(""));\n                }\n                var Pe = f4.performance && f4.performance.now ? f4.performance.now.bind(f4.performance) : Date.now.bind(Date), ge = f4.requestAnimationFrame || f4.mozRequestAnimationFrame || f4.webkitRequestAnimationFrame || f4.msRequestAnimationFrame, Re = f4.cancelAnimationFrame || f4.mozCancelAnimationFrame || f4.webkitCancelAnimationFrame || f4.msCancelAnimationFrame, ce, Ze, ut = { now: Pe, frame: function(y3) {\n                  var I3 = ge(y3);\n                  return { cancel: function() {\n                    return Re(I3);\n                  } };\n                }, getImageData: function(y3, I3) {\n                  I3 === void 0 && (I3 = 0);\n                  var U = f4.document.createElement("canvas"), $2 = U.getContext("2d");\n                  if (!$2) throw new Error("failed to create canvas 2d context");\n                  return U.width = y3.width, U.height = y3.height, $2.drawImage(y3, 0, 0, y3.width, y3.height), $2.getImageData(-I3, -I3, y3.width + 2 * I3, y3.height + 2 * I3);\n                }, resolveURL: function(y3) {\n                  return ce || (ce = f4.document.createElement("a")), ce.href = y3, ce.href;\n                }, hardwareConcurrency: f4.navigator && f4.navigator.hardwareConcurrency || 4, get devicePixelRatio() {\n                  return f4.devicePixelRatio;\n                }, get prefersReducedMotion() {\n                  return f4.matchMedia ? (Ze == null && (Ze = f4.matchMedia("(prefers-reduced-motion: reduce)")), Ze.matches) : false;\n                } }, pt = { API_URL: "https://api.mapbox.com", get EVENTS_URL() {\n                  return this.API_URL ? this.API_URL.indexOf("https://api.mapbox.cn") === 0 ? "https://events.mapbox.cn/events/v2" : this.API_URL.indexOf("https://api.mapbox.com") === 0 ? "https://events.mapbox.com/events/v2" : null : null;\n                }, FEEDBACK_URL: "https://apps.mapbox.com/feedback", REQUIRE_ACCESS_TOKEN: true, ACCESS_TOKEN: null, MAX_PARALLEL_IMAGE_REQUESTS: 16 }, Zt = { supported: false, testSupport: Jt }, st, lt = false, Gt, Nt = false;\n                f4.document && (Gt = f4.document.createElement("img"), Gt.onload = function() {\n                  st && sr(st), st = null, Nt = true;\n                }, Gt.onerror = function() {\n                  lt = true, st = null;\n                }, Gt.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA=");\n                function Jt(m3) {\n                  lt || !Gt || (Nt ? sr(m3) : st = m3);\n                }\n                function sr(m3) {\n                  var y3 = m3.createTexture();\n                  m3.bindTexture(m3.TEXTURE_2D, y3);\n                  try {\n                    if (m3.texImage2D(m3.TEXTURE_2D, 0, m3.RGBA, m3.RGBA, m3.UNSIGNED_BYTE, Gt), m3.isContextLost()) return;\n                    Zt.supported = true;\n                  } catch (I3) {\n                  }\n                  m3.deleteTexture(y3), lt = true;\n                }\n                var wr = "01";\n                function cr() {\n                  for (var m3 = "1", y3 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", I3 = "", U = 0; U < 10; U++) I3 += y3[Math.floor(Math.random() * 62)];\n                  var $2 = 12 * 60 * 60 * 1e3, ae = [m3, wr, I3].join(""), he = Date.now() + $2;\n                  return { token: ae, tokenExpiresAt: he };\n                }\n                var $e = function(y3, I3) {\n                  this._transformRequestFn = y3, this._customAccessToken = I3, this._createSkuToken();\n                };\n                $e.prototype._createSkuToken = function() {\n                  var y3 = cr();\n                  this._skuToken = y3.token, this._skuTokenExpiresAt = y3.tokenExpiresAt;\n                }, $e.prototype._isSkuTokenExpired = function() {\n                  return Date.now() > this._skuTokenExpiresAt;\n                }, $e.prototype.transformRequest = function(y3, I3) {\n                  return this._transformRequestFn ? this._transformRequestFn(y3, I3) || { url: y3 } : { url: y3 };\n                }, $e.prototype.normalizeStyleURL = function(y3, I3) {\n                  if (!St(y3)) return y3;\n                  var U = er(y3);\n                  return U.path = "/styles/v1" + U.path, this._makeAPIURL(U, this._customAccessToken || I3);\n                }, $e.prototype.normalizeGlyphsURL = function(y3, I3) {\n                  if (!St(y3)) return y3;\n                  var U = er(y3);\n                  return U.path = "/fonts/v1" + U.path, this._makeAPIURL(U, this._customAccessToken || I3);\n                }, $e.prototype.normalizeSourceURL = function(y3, I3) {\n                  if (!St(y3)) return y3;\n                  var U = er(y3);\n                  return U.path = "/v4/" + U.authority + ".json", U.params.push("secure"), this._makeAPIURL(U, this._customAccessToken || I3);\n                }, $e.prototype.normalizeSpriteURL = function(y3, I3, U, $2) {\n                  var ae = er(y3);\n                  return St(y3) ? (ae.path = "/styles/v1" + ae.path + "/sprite" + I3 + U, this._makeAPIURL(ae, this._customAccessToken || $2)) : (ae.path += "" + I3 + U, lr(ae));\n                }, $e.prototype.normalizeTileURL = function(y3, I3) {\n                  if (this._isSkuTokenExpired() && this._createSkuToken(), y3 && !St(y3)) return y3;\n                  var U = er(y3), $2 = /(\\.(png|jpg)\\d*)(?=$)/, ae = /^.+\\/v4\\//, he = ut.devicePixelRatio >= 2 || I3 === 512 ? "@2x" : "", Oe = Zt.supported ? ".webp" : "$1";\n                  U.path = U.path.replace($2, "" + he + Oe), U.path = U.path.replace(ae, "/"), U.path = "/v4" + U.path;\n                  var rt = this._customAccessToken || It(U.params) || pt.ACCESS_TOKEN;\n                  return pt.REQUIRE_ACCESS_TOKEN && rt && this._skuToken && U.params.push("sku=" + this._skuToken), this._makeAPIURL(U, rt);\n                }, $e.prototype.canonicalizeTileURL = function(y3, I3) {\n                  var U = "/v4/", $2 = /\\.[\\w]+$/, ae = er(y3);\n                  if (!ae.path.match(/(^\\/v4\\/)/) || !ae.path.match($2)) return y3;\n                  var he = "mapbox://tiles/";\n                  he += ae.path.replace(U, "");\n                  var Oe = ae.params;\n                  return I3 && (Oe = Oe.filter(function(rt) {\n                    return !rt.match(/^access_token=/);\n                  })), Oe.length && (he += "?" + Oe.join("&")), he;\n                }, $e.prototype.canonicalizeTileset = function(y3, I3) {\n                  for (var U = I3 ? St(I3) : false, $2 = [], ae = 0, he = y3.tiles || []; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    Vt(Oe) ? $2.push(this.canonicalizeTileURL(Oe, U)) : $2.push(Oe);\n                  }\n                  return $2;\n                }, $e.prototype._makeAPIURL = function(y3, I3) {\n                  var U = "See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes", $2 = er(pt.API_URL);\n                  if (y3.protocol = $2.protocol, y3.authority = $2.authority, y3.protocol === "http") {\n                    var ae = y3.params.indexOf("secure");\n                    ae >= 0 && y3.params.splice(ae, 1);\n                  }\n                  if ($2.path !== "/" && (y3.path = "" + $2.path + y3.path), !pt.REQUIRE_ACCESS_TOKEN) return lr(y3);\n                  if (I3 = I3 || pt.ACCESS_TOKEN, !I3) throw new Error("An API access token is required to use Mapbox GL. " + U);\n                  if (I3[0] === "s") throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). " + U);\n                  return y3.params = y3.params.filter(function(he) {\n                    return he.indexOf("access_token") === -1;\n                  }), y3.params.push("access_token=" + I3), lr(y3);\n                };\n                function St(m3) {\n                  return m3.indexOf("mapbox:") === 0;\n                }\n                var Qt = /^((https?:)?\\/\\/)?([^\\/]+\\.)?mapbox\\.c(n|om)(\\/|\\?|$)/i;\n                function Vt(m3) {\n                  return Qt.test(m3);\n                }\n                function _t(m3) {\n                  return m3.indexOf("sku=") > 0 && Vt(m3);\n                }\n                function It(m3) {\n                  for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3], $2 = U.match(/^access_token=(.*)$/);\n                    if ($2) return $2[1];\n                  }\n                  return null;\n                }\n                var mt = /^(\\w+):\\/\\/([^/?]*)(\\/[^?]+)?\\??(.+)?/;\n                function er(m3) {\n                  var y3 = m3.match(mt);\n                  if (!y3) throw new Error("Unable to parse URL object");\n                  return { protocol: y3[1], authority: y3[2], path: y3[3] || "/", params: y3[4] ? y3[4].split("&") : [] };\n                }\n                function lr(m3) {\n                  var y3 = m3.params.length ? "?" + m3.params.join("&") : "";\n                  return m3.protocol + "://" + m3.authority + m3.path + y3;\n                }\n                var Tr = "mapbox.eventData";\n                function Lr(m3) {\n                  if (!m3) return null;\n                  var y3 = m3.split(".");\n                  if (!y3 || y3.length !== 3) return null;\n                  try {\n                    var I3 = JSON.parse(Fe(y3[1]));\n                    return I3;\n                  } catch (U) {\n                    return null;\n                  }\n                }\n                var ti = function(y3) {\n                  this.type = y3, this.anonId = null, this.eventData = {}, this.queue = [], this.pendingRequest = null;\n                };\n                ti.prototype.getStorageKey = function(y3) {\n                  var I3 = Lr(pt.ACCESS_TOKEN), U = "";\n                  return I3 && I3.u ? U = Ae(I3.u) : U = pt.ACCESS_TOKEN || "", y3 ? Tr + "." + y3 + ":" + U : Tr + ":" + U;\n                }, ti.prototype.fetchEventData = function() {\n                  var y3 = Le("localStorage"), I3 = this.getStorageKey(), U = this.getStorageKey("uuid");\n                  if (y3) try {\n                    var $2 = f4.localStorage.getItem(I3);\n                    $2 && (this.eventData = JSON.parse($2));\n                    var ae = f4.localStorage.getItem(U);\n                    ae && (this.anonId = ae);\n                  } catch (he) {\n                    te("Unable to read from LocalStorage");\n                  }\n                }, ti.prototype.saveEventData = function() {\n                  var y3 = Le("localStorage"), I3 = this.getStorageKey(), U = this.getStorageKey("uuid");\n                  if (y3) try {\n                    f4.localStorage.setItem(U, this.anonId), Object.keys(this.eventData).length >= 1 && f4.localStorage.setItem(I3, JSON.stringify(this.eventData));\n                  } catch ($2) {\n                    te("Unable to write to LocalStorage");\n                  }\n                }, ti.prototype.processRequests = function(y3) {\n                }, ti.prototype.postEvent = function(y3, I3, U, $2) {\n                  var ae = this;\n                  if (pt.EVENTS_URL) {\n                    var he = er(pt.EVENTS_URL);\n                    he.params.push("access_token=" + ($2 || pt.ACCESS_TOKEN || ""));\n                    var Oe = { event: this.type, created: new Date(y3).toISOString(), sdkIdentifier: "mapbox-gl-js", sdkVersion: o4, skuId: wr, userId: this.anonId }, rt = I3 ? x2(Oe, I3) : Oe, gt = { url: lr(he), headers: { "Content-Type": "text/plain" }, body: JSON.stringify([rt]) };\n                    this.pendingRequest = Qr(gt, function(Et) {\n                      ae.pendingRequest = null, U(Et), ae.saveEventData(), ae.processRequests($2);\n                    });\n                  }\n                }, ti.prototype.queueRequest = function(y3, I3) {\n                  this.queue.push(y3), this.processRequests(I3);\n                };\n                var Br = (function(m3) {\n                  function y3() {\n                    m3.call(this, "map.load"), this.success = {}, this.skuToken = "";\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.postMapLoadEvent = function(U, $2, ae, he) {\n                    this.skuToken = ae, (pt.EVENTS_URL && he || pt.ACCESS_TOKEN && Array.isArray(U) && U.some(function(Oe) {\n                      return St(Oe) || Vt(Oe);\n                    })) && this.queueRequest({ id: $2, timestamp: Date.now() }, he);\n                  }, y3.prototype.processRequests = function(U) {\n                    var $2 = this;\n                    if (!(this.pendingRequest || this.queue.length === 0)) {\n                      var ae = this.queue.shift(), he = ae.id, Oe = ae.timestamp;\n                      he && this.success[he] || (this.anonId || this.fetchEventData(), z3(this.anonId) || (this.anonId = P3()), this.postEvent(Oe, { skuToken: this.skuToken }, function(rt) {\n                        rt || he && ($2.success[he] = true);\n                      }, U));\n                    }\n                  }, y3;\n                })(ti), Vr = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, "appUserTurnstile"), this._customAccessToken = I3;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.postTurnstileEvent = function(U, $2) {\n                    pt.EVENTS_URL && pt.ACCESS_TOKEN && Array.isArray(U) && U.some(function(ae) {\n                      return St(ae) || Vt(ae);\n                    }) && this.queueRequest(Date.now(), $2);\n                  }, y3.prototype.processRequests = function(U) {\n                    var $2 = this;\n                    if (!(this.pendingRequest || this.queue.length === 0)) {\n                      (!this.anonId || !this.eventData.lastSuccess || !this.eventData.tokenU) && this.fetchEventData();\n                      var ae = Lr(pt.ACCESS_TOKEN), he = ae ? ae.u : pt.ACCESS_TOKEN, Oe = he !== this.eventData.tokenU;\n                      z3(this.anonId) || (this.anonId = P3(), Oe = true);\n                      var rt = this.queue.shift();\n                      if (this.eventData.lastSuccess) {\n                        var gt = new Date(this.eventData.lastSuccess), Et = new Date(rt), or = (rt - this.eventData.lastSuccess) / (24 * 60 * 60 * 1e3);\n                        Oe = Oe || or >= 1 || or < -1 || gt.getDate() !== Et.getDate();\n                      } else Oe = true;\n                      if (!Oe) return this.processRequests();\n                      this.postEvent(rt, { "enabled.telemetry": false }, function(_r) {\n                        _r || ($2.eventData.lastSuccess = rt, $2.eventData.tokenU = he);\n                      }, U);\n                    }\n                  }, y3;\n                })(ti), dt = new Vr(), Ge = dt.postTurnstileEvent.bind(dt), Je = new Br(), je = Je.postMapLoadEvent.bind(Je), tt = "mapbox-tiles", xt = 500, Ie = 50, xe = 1e3 * 60 * 7, ke;\n                function vt() {\n                  f4.caches && !ke && (ke = f4.caches.open(tt));\n                }\n                var ir;\n                function ar(m3, y3) {\n                  if (ir === void 0) try {\n                    new Response(new ReadableStream()), ir = true;\n                  } catch (I3) {\n                    ir = false;\n                  }\n                  ir ? y3(m3.body) : m3.blob().then(y3);\n                }\n                function vr(m3, y3, I3) {\n                  if (vt(), !!ke) {\n                    var U = { status: y3.status, statusText: y3.statusText, headers: new f4.Headers() };\n                    y3.headers.forEach(function(he, Oe) {\n                      return U.headers.set(Oe, he);\n                    });\n                    var $2 = me(y3.headers.get("Cache-Control") || "");\n                    if (!$2["no-store"]) {\n                      $2["max-age"] && U.headers.set("Expires", new Date(I3 + $2["max-age"] * 1e3).toUTCString());\n                      var ae = new Date(U.headers.get("Expires")).getTime() - I3;\n                      ae < xe || ar(y3, function(he) {\n                        var Oe = new f4.Response(he, U);\n                        vt(), ke && ke.then(function(rt) {\n                          return rt.put(ii(m3.url), Oe);\n                        }).catch(function(rt) {\n                          return te(rt.message);\n                        });\n                      });\n                    }\n                  }\n                }\n                function ii(m3) {\n                  var y3 = m3.indexOf("?");\n                  return y3 < 0 ? m3 : m3.slice(0, y3);\n                }\n                function pi(m3, y3) {\n                  if (vt(), !ke) return y3(null);\n                  var I3 = ii(m3.url);\n                  ke.then(function(U) {\n                    U.match(I3).then(function($2) {\n                      var ae = $r($2);\n                      U.delete(I3), ae && U.put(I3, $2.clone()), y3(null, $2, ae);\n                    }).catch(y3);\n                  }).catch(y3);\n                }\n                function $r(m3) {\n                  if (!m3) return false;\n                  var y3 = new Date(m3.headers.get("Expires") || 0), I3 = me(m3.headers.get("Cache-Control") || "");\n                  return y3 > Date.now() && !I3["no-cache"];\n                }\n                var di = 1 / 0;\n                function ji(m3) {\n                  di++, di > Ie && (m3.getActor().send("enforceCacheSizeLimit", xt), di = 0);\n                }\n                function In(m3) {\n                  vt(), ke && ke.then(function(y3) {\n                    y3.keys().then(function(I3) {\n                      for (var U = 0; U < I3.length - m3; U++) y3.delete(I3[U]);\n                    });\n                  });\n                }\n                function wi(m3) {\n                  var y3 = f4.caches.delete(tt);\n                  m3 && y3.catch(m3).then(function() {\n                    return m3();\n                  });\n                }\n                function On(m3, y3) {\n                  xt = m3, Ie = y3;\n                }\n                var qn;\n                function Fn() {\n                  return qn == null && (qn = f4.OffscreenCanvas && new f4.OffscreenCanvas(1, 1).getContext("2d") && typeof f4.createImageBitmap == "function"), qn;\n                }\n                var ra = { Unknown: "Unknown", Style: "Style", Source: "Source", Tile: "Tile", Glyphs: "Glyphs", SpriteImage: "SpriteImage", SpriteJSON: "SpriteJSON", Image: "Image" };\n                typeof Object.freeze == "function" && Object.freeze(ra);\n                var la = (function(m3) {\n                  function y3(I3, U, $2) {\n                    U === 401 && Vt($2) && (I3 += ": you may have provided an invalid Mapbox access token. See https://www.mapbox.com/api-documentation/#access-tokens-and-token-scopes"), m3.call(this, I3), this.status = U, this.url = $2, this.name = this.constructor.name, this.message = I3;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.toString = function() {\n                    return this.name + ": " + this.message + " (" + this.status + "): " + this.url;\n                  }, y3;\n                })(Error), Ut = Ce() ? function() {\n                  return self.worker && self.worker.referrer;\n                } : function() {\n                  return (f4.location.protocol === "blob:" ? f4.parent : f4).location.href;\n                }, wt = function(m3) {\n                  return /^file:/.test(m3) || /^file:/.test(Ut()) && !/^\\w+:/.test(m3);\n                };\n                function rr(m3, y3) {\n                  var I3 = new f4.AbortController(), U = new f4.Request(m3.url, { method: m3.method || "GET", body: m3.body, credentials: m3.credentials, headers: m3.headers, referrer: Ut(), signal: I3.signal }), $2 = false, ae = false, he = _t(U.url);\n                  m3.type === "json" && U.headers.set("Accept", "application/json");\n                  var Oe = function(gt, Et, or) {\n                    if (!ae) {\n                      if (gt && gt.message !== "SecurityError" && te(gt), Et && or) return rt(Et);\n                      var _r = Date.now();\n                      f4.fetch(U).then(function(pr) {\n                        if (pr.ok) {\n                          var Fr = he ? pr.clone() : null;\n                          return rt(pr, Fr, _r);\n                        } else return y3(new la(pr.statusText, pr.status, m3.url));\n                      }).catch(function(pr) {\n                        pr.code !== 20 && y3(new Error(pr.message));\n                      });\n                    }\n                  }, rt = function(gt, Et, or) {\n                    (m3.type === "arrayBuffer" ? gt.arrayBuffer() : m3.type === "json" ? gt.json() : gt.text()).then(function(_r) {\n                      ae || (Et && or && vr(U, Et, or), $2 = true, y3(null, _r, gt.headers.get("Cache-Control"), gt.headers.get("Expires")));\n                    }).catch(function(_r) {\n                      ae || y3(new Error(_r.message));\n                    });\n                  };\n                  return he ? pi(U, Oe) : Oe(null, null), { cancel: function() {\n                    ae = true, $2 || I3.abort();\n                  } };\n                }\n                function nr(m3, y3) {\n                  var I3 = new f4.XMLHttpRequest();\n                  I3.open(m3.method || "GET", m3.url, true), m3.type === "arrayBuffer" && (I3.responseType = "arraybuffer");\n                  for (var U in m3.headers) I3.setRequestHeader(U, m3.headers[U]);\n                  return m3.type === "json" && (I3.responseType = "text", I3.setRequestHeader("Accept", "application/json")), I3.withCredentials = m3.credentials === "include", I3.onerror = function() {\n                    y3(new Error(I3.statusText));\n                  }, I3.onload = function() {\n                    if ((I3.status >= 200 && I3.status < 300 || I3.status === 0) && I3.response !== null) {\n                      var $2 = I3.response;\n                      if (m3.type === "json") try {\n                        $2 = JSON.parse(I3.response);\n                      } catch (ae) {\n                        return y3(ae);\n                      }\n                      y3(null, $2, I3.getResponseHeader("Cache-Control"), I3.getResponseHeader("Expires"));\n                    } else y3(new la(I3.statusText, I3.status, m3.url));\n                  }, I3.send(m3.body), { cancel: function() {\n                    return I3.abort();\n                  } };\n                }\n                var Er = function(m3, y3) {\n                  if (!wt(m3.url)) {\n                    if (f4.fetch && f4.Request && f4.AbortController && f4.Request.prototype.hasOwnProperty("signal")) return rr(m3, y3);\n                    if (Ce() && self.worker && self.worker.actor) {\n                      var I3 = true;\n                      return self.worker.actor.send("getResource", m3, y3, void 0, I3);\n                    }\n                  }\n                  return nr(m3, y3);\n                }, Xr = function(m3, y3) {\n                  return Er(x2(m3, { type: "json" }), y3);\n                }, ri = function(m3, y3) {\n                  return Er(x2(m3, { type: "arrayBuffer" }), y3);\n                }, Qr = function(m3, y3) {\n                  return Er(x2(m3, { method: "POST" }), y3);\n                };\n                function Oi(m3) {\n                  var y3 = f4.document.createElement("a");\n                  return y3.href = m3, y3.protocol === f4.document.location.protocol && y3.host === f4.document.location.host;\n                }\n                var $i = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";\n                function tn(m3, y3, I3, U) {\n                  var $2 = new f4.Image(), ae = f4.URL;\n                  $2.onload = function() {\n                    y3(null, $2), ae.revokeObjectURL($2.src), $2.onload = null, f4.requestAnimationFrame(function() {\n                      $2.src = $i;\n                    });\n                  }, $2.onerror = function() {\n                    return y3(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));\n                  };\n                  var he = new f4.Blob([new Uint8Array(m3)], { type: "image/png" });\n                  $2.cacheControl = I3, $2.expires = U, $2.src = m3.byteLength ? ae.createObjectURL(he) : $i;\n                }\n                function fn(m3, y3) {\n                  var I3 = new f4.Blob([new Uint8Array(m3)], { type: "image/png" });\n                  f4.createImageBitmap(I3).then(function(U) {\n                    y3(null, U);\n                  }).catch(function(U) {\n                    y3(new Error("Could not load image because of " + U.message + ". Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));\n                  });\n                }\n                var yn, Sn, Ba = function() {\n                  yn = [], Sn = 0;\n                };\n                Ba();\n                var ua = function(m3, y3) {\n                  if (Zt.supported && (m3.headers || (m3.headers = {}), m3.headers.accept = "image/webp,*/*"), Sn >= pt.MAX_PARALLEL_IMAGE_REQUESTS) {\n                    var I3 = { requestParameters: m3, callback: y3, cancelled: false, cancel: function() {\n                      this.cancelled = true;\n                    } };\n                    return yn.push(I3), I3;\n                  }\n                  Sn++;\n                  var U = false, $2 = function() {\n                    if (!U) for (U = true, Sn--; yn.length && Sn < pt.MAX_PARALLEL_IMAGE_REQUESTS; ) {\n                      var he = yn.shift(), Oe = he.requestParameters, rt = he.callback, gt = he.cancelled;\n                      gt || (he.cancel = ua(Oe, rt).cancel);\n                    }\n                  }, ae = ri(m3, function(he, Oe, rt, gt) {\n                    $2(), he ? y3(he) : Oe && (Fn() ? fn(Oe, y3) : tn(Oe, y3, rt, gt));\n                  });\n                  return { cancel: function() {\n                    ae.cancel(), $2();\n                  } };\n                }, ma = function(m3, y3) {\n                  var I3 = f4.document.createElement("video");\n                  I3.muted = true, I3.onloadstart = function() {\n                    y3(null, I3);\n                  };\n                  for (var U = 0; U < m3.length; U++) {\n                    var $2 = f4.document.createElement("source");\n                    Oi(m3[U]) || (I3.crossOrigin = "Anonymous"), $2.src = m3[U], I3.appendChild($2);\n                  }\n                  return { cancel: function() {\n                  } };\n                };\n                function Wa(m3, y3, I3) {\n                  var U = I3[m3] && I3[m3].indexOf(y3) !== -1;\n                  U || (I3[m3] = I3[m3] || [], I3[m3].push(y3));\n                }\n                function Fa(m3, y3, I3) {\n                  if (I3 && I3[m3]) {\n                    var U = I3[m3].indexOf(y3);\n                    U !== -1 && I3[m3].splice(U, 1);\n                  }\n                }\n                var Wo = function(y3, I3) {\n                  I3 === void 0 && (I3 = {}), x2(this, I3), this.type = y3;\n                }, da = (function(m3) {\n                  function y3(I3, U) {\n                    U === void 0 && (U = {}), m3.call(this, "error", x2({ error: I3 }, U));\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3;\n                })(Wo), Wn = function() {\n                };\n                Wn.prototype.on = function(y3, I3) {\n                  return this._listeners = this._listeners || {}, Wa(y3, I3, this._listeners), this;\n                }, Wn.prototype.off = function(y3, I3) {\n                  return Fa(y3, I3, this._listeners), Fa(y3, I3, this._oneTimeListeners), this;\n                }, Wn.prototype.once = function(y3, I3) {\n                  return this._oneTimeListeners = this._oneTimeListeners || {}, Wa(y3, I3, this._oneTimeListeners), this;\n                }, Wn.prototype.fire = function(y3, I3) {\n                  typeof y3 == "string" && (y3 = new Wo(y3, I3 || {}));\n                  var U = y3.type;\n                  if (this.listens(U)) {\n                    y3.target = this;\n                    for (var $2 = this._listeners && this._listeners[U] ? this._listeners[U].slice() : [], ae = 0, he = $2; ae < he.length; ae += 1) {\n                      var Oe = he[ae];\n                      Oe.call(this, y3);\n                    }\n                    for (var rt = this._oneTimeListeners && this._oneTimeListeners[U] ? this._oneTimeListeners[U].slice() : [], gt = 0, Et = rt; gt < Et.length; gt += 1) {\n                      var or = Et[gt];\n                      Fa(U, or, this._oneTimeListeners), or.call(this, y3);\n                    }\n                    var _r = this._eventedParent;\n                    _r && (x2(y3, typeof this._eventedParentData == "function" ? this._eventedParentData() : this._eventedParentData), _r.fire(y3));\n                  } else y3 instanceof da && console.error(y3.error);\n                  return this;\n                }, Wn.prototype.listens = function(y3) {\n                  return this._listeners && this._listeners[y3] && this._listeners[y3].length > 0 || this._oneTimeListeners && this._oneTimeListeners[y3] && this._oneTimeListeners[y3].length > 0 || this._eventedParent && this._eventedParent.listens(y3);\n                }, Wn.prototype.setEventedParent = function(y3, I3) {\n                  return this._eventedParent = y3, this._eventedParentData = I3, this;\n                };\n                var Ha = 8, vo = { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, light: { type: "light" }, sources: { required: true, type: "sources" }, sprite: { type: "string" }, glyphs: { type: "string" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, jn = { "*": { type: "source" } }, Mt = ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], kr = { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, Jr = { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, vi = { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {} }, default: "mapbox" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, hn = { type: { required: true, type: "enum", values: { geojson: {} } }, data: { type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "*" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, An = { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, Mn = { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, Li = { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, _n = ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_background"], ya = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Jn = { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Ma = { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, _o = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, No = { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, po = { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Lo = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, ko = { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, Ds = { type: "array", value: "*" }, Fs = { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {}, within: {} } }, ll = { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, ul = { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, zl = { type: "array", value: "*", minimum: 1 }, us = { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, il = ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_background"], As = { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, cl = { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, Ks = { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, zs = { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Io = { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, ls = { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Zl = { "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, Su = { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, nc = { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, bs = { "*": { type: "string" } }, Rn = { $version: Ha, $root: vo, sources: jn, source: Mt, source_vector: kr, source_raster: Jr, source_raster_dem: vi, source_geojson: hn, source_video: An, source_image: Mn, layer: Li, layout: _n, layout_background: ya, layout_fill: Jn, layout_circle: Ma, layout_heatmap: _o, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_line: No, layout_symbol: po, layout_raster: Lo, layout_hillshade: ko, filter: Ds, filter_operator: Fs, geometry_type: ll, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: ul, expression: zl, light: us, paint: il, paint_fill: As, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: cl, paint_circle: Ks, paint_heatmap: zs, paint_symbol: Io, paint_raster: ls, paint_hillshade: Zl, paint_background: Su, transition: nc, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: bs }, _a = function(y3, I3, U, $2) {\n                  this.message = (y3 ? y3 + ": " : "") + U, $2 && (this.identifier = $2), I3 != null && I3.__line__ && (this.line = I3.__line__);\n                };\n                function Vu(m3) {\n                  var y3 = m3.key, I3 = m3.value;\n                  return I3 ? [new _a(y3, I3, "constants have been deprecated as of v8")] : [];\n                }\n                function Ol(m3) {\n                  for (var y3 = [], I3 = arguments.length - 1; I3-- > 0; ) y3[I3] = arguments[I3 + 1];\n                  for (var U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    for (var he in ae) m3[he] = ae[he];\n                  }\n                  return m3;\n                }\n                function xo(m3) {\n                  return m3 instanceof Number || m3 instanceof String || m3 instanceof Boolean ? m3.valueOf() : m3;\n                }\n                function Yl(m3) {\n                  if (Array.isArray(m3)) return m3.map(Yl);\n                  if (m3 instanceof Object && !(m3 instanceof Number || m3 instanceof String || m3 instanceof Boolean)) {\n                    var y3 = {};\n                    for (var I3 in m3) y3[I3] = Yl(m3[I3]);\n                    return y3;\n                  }\n                  return xo(m3);\n                }\n                var Ns = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, U), this.message = U, this.key = I3;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3;\n                })(Error), Hl = function(y3, I3) {\n                  I3 === void 0 && (I3 = []), this.parent = y3, this.bindings = {};\n                  for (var U = 0, $2 = I3; U < $2.length; U += 1) {\n                    var ae = $2[U], he = ae[0], Oe = ae[1];\n                    this.bindings[he] = Oe;\n                  }\n                };\n                Hl.prototype.concat = function(y3) {\n                  return new Hl(this, y3);\n                }, Hl.prototype.get = function(y3) {\n                  if (this.bindings[y3]) return this.bindings[y3];\n                  if (this.parent) return this.parent.get(y3);\n                  throw new Error(y3 + " not found in scope.");\n                }, Hl.prototype.has = function(y3) {\n                  return this.bindings[y3] ? true : this.parent ? this.parent.has(y3) : false;\n                };\n                var ac = { kind: "null" }, aa = { kind: "number" }, Oo = { kind: "string" }, qo = { kind: "boolean" }, ql = { kind: "color" }, Pc = { kind: "object" }, Do = { kind: "value" }, rf = { kind: "error" }, Uf = { kind: "collator" }, pl = { kind: "formatted" }, Zc = { kind: "resolvedImage" };\n                function Kl(m3, y3) {\n                  return { kind: "array", itemType: m3, N: y3 };\n                }\n                function Os(m3) {\n                  if (m3.kind === "array") {\n                    var y3 = Os(m3.itemType);\n                    return typeof m3.N == "number" ? "array<" + y3 + ", " + m3.N + ">" : m3.itemType.kind === "value" ? "array" : "array<" + y3 + ">";\n                  } else return m3.kind;\n                }\n                var yu = [ac, aa, Oo, qo, ql, pl, Pc, Kl(Do), Zc];\n                function oc(m3, y3) {\n                  if (y3.kind === "error") return null;\n                  if (m3.kind === "array") {\n                    if (y3.kind === "array" && (y3.N === 0 && y3.itemType.kind === "value" || !oc(m3.itemType, y3.itemType)) && (typeof m3.N != "number" || m3.N === y3.N)) return null;\n                  } else {\n                    if (m3.kind === y3.kind) return null;\n                    if (m3.kind === "value") for (var I3 = 0, U = yu; I3 < U.length; I3 += 1) {\n                      var $2 = U[I3];\n                      if (!oc($2, y3)) return null;\n                    }\n                  }\n                  return "Expected " + Os(m3) + " but found " + Os(y3) + " instead.";\n                }\n                function Cf(m3, y3) {\n                  return y3.some(function(I3) {\n                    return I3.kind === m3.kind;\n                  });\n                }\n                function sc(m3, y3) {\n                  return y3.some(function(I3) {\n                    return I3 === "null" ? m3 === null : I3 === "array" ? Array.isArray(m3) : I3 === "object" ? m3 && !Array.isArray(m3) && typeof m3 == "object" : I3 === typeof m3;\n                  });\n                }\n                var Vh = a4(function(m3, y3) {\n                  var I3 = { transparent: [0, 0, 0, 0], aliceblue: [240, 248, 255, 1], antiquewhite: [250, 235, 215, 1], aqua: [0, 255, 255, 1], aquamarine: [127, 255, 212, 1], azure: [240, 255, 255, 1], beige: [245, 245, 220, 1], bisque: [255, 228, 196, 1], black: [0, 0, 0, 1], blanchedalmond: [255, 235, 205, 1], blue: [0, 0, 255, 1], blueviolet: [138, 43, 226, 1], brown: [165, 42, 42, 1], burlywood: [222, 184, 135, 1], cadetblue: [95, 158, 160, 1], chartreuse: [127, 255, 0, 1], chocolate: [210, 105, 30, 1], coral: [255, 127, 80, 1], cornflowerblue: [100, 149, 237, 1], cornsilk: [255, 248, 220, 1], crimson: [220, 20, 60, 1], cyan: [0, 255, 255, 1], darkblue: [0, 0, 139, 1], darkcyan: [0, 139, 139, 1], darkgoldenrod: [184, 134, 11, 1], darkgray: [169, 169, 169, 1], darkgreen: [0, 100, 0, 1], darkgrey: [169, 169, 169, 1], darkkhaki: [189, 183, 107, 1], darkmagenta: [139, 0, 139, 1], darkolivegreen: [85, 107, 47, 1], darkorange: [255, 140, 0, 1], darkorchid: [153, 50, 204, 1], darkred: [139, 0, 0, 1], darksalmon: [233, 150, 122, 1], darkseagreen: [143, 188, 143, 1], darkslateblue: [72, 61, 139, 1], darkslategray: [47, 79, 79, 1], darkslategrey: [47, 79, 79, 1], darkturquoise: [0, 206, 209, 1], darkviolet: [148, 0, 211, 1], deeppink: [255, 20, 147, 1], deepskyblue: [0, 191, 255, 1], dimgray: [105, 105, 105, 1], dimgrey: [105, 105, 105, 1], dodgerblue: [30, 144, 255, 1], firebrick: [178, 34, 34, 1], floralwhite: [255, 250, 240, 1], forestgreen: [34, 139, 34, 1], fuchsia: [255, 0, 255, 1], gainsboro: [220, 220, 220, 1], ghostwhite: [248, 248, 255, 1], gold: [255, 215, 0, 1], goldenrod: [218, 165, 32, 1], gray: [128, 128, 128, 1], green: [0, 128, 0, 1], greenyellow: [173, 255, 47, 1], grey: [128, 128, 128, 1], honeydew: [240, 255, 240, 1], hotpink: [255, 105, 180, 1], indianred: [205, 92, 92, 1], indigo: [75, 0, 130, 1], ivory: [255, 255, 240, 1], khaki: [240, 230, 140, 1], lavender: [230, 230, 250, 1], lavenderblush: [255, 240, 245, 1], lawngreen: [124, 252, 0, 1], lemonchiffon: [255, 250, 205, 1], lightblue: [173, 216, 230, 1], lightcoral: [240, 128, 128, 1], lightcyan: [224, 255, 255, 1], lightgoldenrodyellow: [250, 250, 210, 1], lightgray: [211, 211, 211, 1], lightgreen: [144, 238, 144, 1], lightgrey: [211, 211, 211, 1], lightpink: [255, 182, 193, 1], lightsalmon: [255, 160, 122, 1], lightseagreen: [32, 178, 170, 1], lightskyblue: [135, 206, 250, 1], lightslategray: [119, 136, 153, 1], lightslategrey: [119, 136, 153, 1], lightsteelblue: [176, 196, 222, 1], lightyellow: [255, 255, 224, 1], lime: [0, 255, 0, 1], limegreen: [50, 205, 50, 1], linen: [250, 240, 230, 1], magenta: [255, 0, 255, 1], maroon: [128, 0, 0, 1], mediumaquamarine: [102, 205, 170, 1], mediumblue: [0, 0, 205, 1], mediumorchid: [186, 85, 211, 1], mediumpurple: [147, 112, 219, 1], mediumseagreen: [60, 179, 113, 1], mediumslateblue: [123, 104, 238, 1], mediumspringgreen: [0, 250, 154, 1], mediumturquoise: [72, 209, 204, 1], mediumvioletred: [199, 21, 133, 1], midnightblue: [25, 25, 112, 1], mintcream: [245, 255, 250, 1], mistyrose: [255, 228, 225, 1], moccasin: [255, 228, 181, 1], navajowhite: [255, 222, 173, 1], navy: [0, 0, 128, 1], oldlace: [253, 245, 230, 1], olive: [128, 128, 0, 1], olivedrab: [107, 142, 35, 1], orange: [255, 165, 0, 1], orangered: [255, 69, 0, 1], orchid: [218, 112, 214, 1], palegoldenrod: [238, 232, 170, 1], palegreen: [152, 251, 152, 1], paleturquoise: [175, 238, 238, 1], palevioletred: [219, 112, 147, 1], papayawhip: [255, 239, 213, 1], peachpuff: [255, 218, 185, 1], peru: [205, 133, 63, 1], pink: [255, 192, 203, 1], plum: [221, 160, 221, 1], powderblue: [176, 224, 230, 1], purple: [128, 0, 128, 1], rebeccapurple: [102, 51, 153, 1], red: [255, 0, 0, 1], rosybrown: [188, 143, 143, 1], royalblue: [65, 105, 225, 1], saddlebrown: [139, 69, 19, 1], salmon: [250, 128, 114, 1], sandybrown: [244, 164, 96, 1], seagreen: [46, 139, 87, 1], seashell: [255, 245, 238, 1], sienna: [160, 82, 45, 1], silver: [192, 192, 192, 1], skyblue: [135, 206, 235, 1], slateblue: [106, 90, 205, 1], slategray: [112, 128, 144, 1], slategrey: [112, 128, 144, 1], snow: [255, 250, 250, 1], springgreen: [0, 255, 127, 1], steelblue: [70, 130, 180, 1], tan: [210, 180, 140, 1], teal: [0, 128, 128, 1], thistle: [216, 191, 216, 1], tomato: [255, 99, 71, 1], turquoise: [64, 224, 208, 1], violet: [238, 130, 238, 1], wheat: [245, 222, 179, 1], white: [255, 255, 255, 1], whitesmoke: [245, 245, 245, 1], yellow: [255, 255, 0, 1], yellowgreen: [154, 205, 50, 1] };\n                  function U(gt) {\n                    return gt = Math.round(gt), gt < 0 ? 0 : gt > 255 ? 255 : gt;\n                  }\n                  function $2(gt) {\n                    return gt < 0 ? 0 : gt > 1 ? 1 : gt;\n                  }\n                  function ae(gt) {\n                    return gt[gt.length - 1] === "%" ? U(parseFloat(gt) / 100 * 255) : U(parseInt(gt));\n                  }\n                  function he(gt) {\n                    return gt[gt.length - 1] === "%" ? $2(parseFloat(gt) / 100) : $2(parseFloat(gt));\n                  }\n                  function Oe(gt, Et, or) {\n                    return or < 0 ? or += 1 : or > 1 && (or -= 1), or * 6 < 1 ? gt + (Et - gt) * or * 6 : or * 2 < 1 ? Et : or * 3 < 2 ? gt + (Et - gt) * (2 / 3 - or) * 6 : gt;\n                  }\n                  function rt(gt) {\n                    var Et = gt.replace(/ /g, "").toLowerCase();\n                    if (Et in I3) return I3[Et].slice();\n                    if (Et[0] === "#") {\n                      if (Et.length === 4) {\n                        var or = parseInt(Et.substr(1), 16);\n                        return or >= 0 && or <= 4095 ? [(or & 3840) >> 4 | (or & 3840) >> 8, or & 240 | (or & 240) >> 4, or & 15 | (or & 15) << 4, 1] : null;\n                      } else if (Et.length === 7) {\n                        var or = parseInt(Et.substr(1), 16);\n                        return or >= 0 && or <= 16777215 ? [(or & 16711680) >> 16, (or & 65280) >> 8, or & 255, 1] : null;\n                      }\n                      return null;\n                    }\n                    var _r = Et.indexOf("("), pr = Et.indexOf(")");\n                    if (_r !== -1 && pr + 1 === Et.length) {\n                      var Fr = Et.substr(0, _r), oi = Et.substr(_r + 1, pr - (_r + 1)).split(","), Hi = 1;\n                      switch (Fr) {\n                        case "rgba":\n                          if (oi.length !== 4) return null;\n                          Hi = he(oi.pop());\n                        case "rgb":\n                          return oi.length !== 3 ? null : [ae(oi[0]), ae(oi[1]), ae(oi[2]), Hi];\n                        case "hsla":\n                          if (oi.length !== 4) return null;\n                          Hi = he(oi.pop());\n                        case "hsl":\n                          if (oi.length !== 3) return null;\n                          var Ai = (parseFloat(oi[0]) % 360 + 360) % 360 / 360, bn = he(oi[1]), nn = he(oi[2]), xn = nn <= 0.5 ? nn * (bn + 1) : nn + bn - nn * bn, Pn = nn * 2 - xn;\n                          return [U(Oe(Pn, xn, Ai + 1 / 3) * 255), U(Oe(Pn, xn, Ai) * 255), U(Oe(Pn, xn, Ai - 1 / 3) * 255), Hi];\n                        default:\n                          return null;\n                      }\n                    }\n                    return null;\n                  }\n                  try {\n                    y3.parseCSSColor = rt;\n                  } catch (gt) {\n                  }\n                }), Lf = Vh.parseCSSColor, cs = function(y3, I3, U, $2) {\n                  $2 === void 0 && ($2 = 1), this.r = y3, this.g = I3, this.b = U, this.a = $2;\n                };\n                cs.parse = function(y3) {\n                  if (y3) {\n                    if (y3 instanceof cs) return y3;\n                    if (typeof y3 == "string") {\n                      var I3 = Lf(y3);\n                      if (I3) return new cs(I3[0] / 255 * I3[3], I3[1] / 255 * I3[3], I3[2] / 255 * I3[3], I3[3]);\n                    }\n                  }\n                }, cs.prototype.toString = function() {\n                  var y3 = this.toArray(), I3 = y3[0], U = y3[1], $2 = y3[2], ae = y3[3];\n                  return "rgba(" + Math.round(I3) + "," + Math.round(U) + "," + Math.round($2) + "," + ae + ")";\n                }, cs.prototype.toArray = function() {\n                  var y3 = this, I3 = y3.r, U = y3.g, $2 = y3.b, ae = y3.a;\n                  return ae === 0 ? [0, 0, 0, 0] : [I3 * 255 / ae, U * 255 / ae, $2 * 255 / ae, ae];\n                }, cs.black = new cs(0, 0, 0, 1), cs.white = new cs(1, 1, 1, 1), cs.transparent = new cs(0, 0, 0, 0), cs.red = new cs(1, 0, 0, 1);\n                var nf = function(y3, I3, U) {\n                  y3 ? this.sensitivity = I3 ? "variant" : "case" : this.sensitivity = I3 ? "accent" : "base", this.locale = U, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });\n                };\n                nf.prototype.compare = function(y3, I3) {\n                  return this.collator.compare(y3, I3);\n                }, nf.prototype.resolvedLocale = function() {\n                  return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;\n                };\n                var Vf = function(y3, I3, U, $2, ae) {\n                  this.text = y3, this.image = I3, this.scale = U, this.fontStack = $2, this.textColor = ae;\n                }, Jl = function(y3) {\n                  this.sections = y3;\n                };\n                Jl.fromString = function(y3) {\n                  return new Jl([new Vf(y3, null, null, null, null)]);\n                }, Jl.prototype.isEmpty = function() {\n                  return this.sections.length === 0 ? true : !this.sections.some(function(y3) {\n                    return y3.text.length !== 0 || y3.image && y3.image.name.length !== 0;\n                  });\n                }, Jl.factory = function(y3) {\n                  return y3 instanceof Jl ? y3 : Jl.fromString(y3);\n                }, Jl.prototype.toString = function() {\n                  return this.sections.length === 0 ? "" : this.sections.map(function(y3) {\n                    return y3.text;\n                  }).join("");\n                }, Jl.prototype.serialize = function() {\n                  for (var y3 = ["format"], I3 = 0, U = this.sections; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    if ($2.image) {\n                      y3.push(["image", $2.image.name]);\n                      continue;\n                    }\n                    y3.push($2.text);\n                    var ae = {};\n                    $2.fontStack && (ae["text-font"] = ["literal", $2.fontStack.split(",")]), $2.scale && (ae["font-scale"] = $2.scale), $2.textColor && (ae["text-color"] = ["rgba"].concat($2.textColor.toArray())), y3.push(ae);\n                  }\n                  return y3;\n                };\n                var fl = function(y3) {\n                  this.name = y3.name, this.available = y3.available;\n                };\n                fl.prototype.toString = function() {\n                  return this.name;\n                }, fl.fromString = function(y3) {\n                  return y3 ? new fl({ name: y3, available: false }) : null;\n                }, fl.prototype.serialize = function() {\n                  return ["image", this.name];\n                };\n                function lc(m3, y3, I3, U) {\n                  if (!(typeof m3 == "number" && m3 >= 0 && m3 <= 255 && typeof y3 == "number" && y3 >= 0 && y3 <= 255 && typeof I3 == "number" && I3 >= 0 && I3 <= 255)) {\n                    var $2 = typeof U == "number" ? [m3, y3, I3, U] : [m3, y3, I3];\n                    return "Invalid rgba value [" + $2.join(", ") + "]: \'r\', \'g\', and \'b\' must be between 0 and 255.";\n                  }\n                  return typeof U == "undefined" || typeof U == "number" && U >= 0 && U <= 1 ? null : "Invalid rgba value [" + [m3, y3, I3, U].join(", ") + "]: \'a\' must be between 0 and 1.";\n                }\n                function Fu(m3) {\n                  if (m3 === null) return true;\n                  if (typeof m3 == "string") return true;\n                  if (typeof m3 == "boolean") return true;\n                  if (typeof m3 == "number") return true;\n                  if (m3 instanceof cs) return true;\n                  if (m3 instanceof nf) return true;\n                  if (m3 instanceof Jl) return true;\n                  if (m3 instanceof fl) return true;\n                  if (Array.isArray(m3)) {\n                    for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                      var U = I3[y3];\n                      if (!Fu(U)) return false;\n                    }\n                    return true;\n                  } else if (typeof m3 == "object") {\n                    for (var $2 in m3) if (!Fu(m3[$2])) return false;\n                    return true;\n                  } else return false;\n                }\n                function Es(m3) {\n                  if (m3 === null) return ac;\n                  if (typeof m3 == "string") return Oo;\n                  if (typeof m3 == "boolean") return qo;\n                  if (typeof m3 == "number") return aa;\n                  if (m3 instanceof cs) return ql;\n                  if (m3 instanceof nf) return Uf;\n                  if (m3 instanceof Jl) return pl;\n                  if (m3 instanceof fl) return Zc;\n                  if (Array.isArray(m3)) {\n                    for (var y3 = m3.length, I3, U = 0, $2 = m3; U < $2.length; U += 1) {\n                      var ae = $2[U], he = Es(ae);\n                      if (!I3) I3 = he;\n                      else {\n                        if (I3 === he) continue;\n                        I3 = Do;\n                        break;\n                      }\n                    }\n                    return Kl(I3 || Do, y3);\n                  } else return Pc;\n                }\n                function Hs(m3) {\n                  var y3 = typeof m3;\n                  return m3 === null ? "" : y3 === "string" || y3 === "number" || y3 === "boolean" ? String(m3) : m3 instanceof cs || m3 instanceof Jl || m3 instanceof fl ? m3.toString() : JSON.stringify(m3);\n                }\n                var Go = function(y3, I3) {\n                  this.type = y3, this.value = I3;\n                };\n                Go.parse = function(y3, I3) {\n                  if (y3.length !== 2) return I3.error("\'literal\' expression requires exactly one argument, but found " + (y3.length - 1) + " instead.");\n                  if (!Fu(y3[1])) return I3.error("invalid value");\n                  var U = y3[1], $2 = Es(U), ae = I3.expectedType;\n                  return $2.kind === "array" && $2.N === 0 && ae && ae.kind === "array" && (typeof ae.N != "number" || ae.N === 0) && ($2 = ae), new Go($2, U);\n                }, Go.prototype.evaluate = function() {\n                  return this.value;\n                }, Go.prototype.eachChild = function() {\n                }, Go.prototype.outputDefined = function() {\n                  return true;\n                }, Go.prototype.serialize = function() {\n                  return this.type.kind === "array" || this.type.kind === "object" ? ["literal", this.value] : this.value instanceof cs ? ["rgba"].concat(this.value.toArray()) : this.value instanceof Jl ? this.value.serialize() : this.value;\n                };\n                var ps = function(y3) {\n                  this.name = "ExpressionEvaluationError", this.message = y3;\n                };\n                ps.prototype.toJSON = function() {\n                  return this.message;\n                };\n                var uc = { string: Oo, number: aa, boolean: qo, object: Pc }, xl = function(y3, I3) {\n                  this.type = y3, this.args = I3;\n                };\n                xl.parse = function(y3, I3) {\n                  if (y3.length < 2) return I3.error("Expected at least one argument.");\n                  var U = 1, $2, ae = y3[0];\n                  if (ae === "array") {\n                    var he;\n                    if (y3.length > 2) {\n                      var Oe = y3[1];\n                      if (typeof Oe != "string" || !(Oe in uc) || Oe === "object") return I3.error(\'The item type argument of "array" must be one of string, number, boolean\', 1);\n                      he = uc[Oe], U++;\n                    } else he = Do;\n                    var rt;\n                    if (y3.length > 3) {\n                      if (y3[2] !== null && (typeof y3[2] != "number" || y3[2] < 0 || y3[2] !== Math.floor(y3[2]))) return I3.error(\'The length argument to "array" must be a positive integer literal\', 2);\n                      rt = y3[2], U++;\n                    }\n                    $2 = Kl(he, rt);\n                  } else $2 = uc[ae];\n                  for (var gt = []; U < y3.length; U++) {\n                    var Et = I3.parse(y3[U], U, Do);\n                    if (!Et) return null;\n                    gt.push(Et);\n                  }\n                  return new xl($2, gt);\n                }, xl.prototype.evaluate = function(y3) {\n                  for (var I3 = 0; I3 < this.args.length; I3++) {\n                    var U = this.args[I3].evaluate(y3), $2 = oc(this.type, Es(U));\n                    if ($2) {\n                      if (I3 === this.args.length - 1) throw new ps("Expected value to be of type " + Os(this.type) + ", but found " + Os(Es(U)) + " instead.");\n                    } else return U;\n                  }\n                  return null;\n                }, xl.prototype.eachChild = function(y3) {\n                  this.args.forEach(y3);\n                }, xl.prototype.outputDefined = function() {\n                  return this.args.every(function(y3) {\n                    return y3.outputDefined();\n                  });\n                }, xl.prototype.serialize = function() {\n                  var y3 = this.type, I3 = [y3.kind];\n                  if (y3.kind === "array") {\n                    var U = y3.itemType;\n                    if (U.kind === "string" || U.kind === "number" || U.kind === "boolean") {\n                      I3.push(U.kind);\n                      var $2 = y3.N;\n                      (typeof $2 == "number" || this.args.length > 1) && I3.push($2);\n                    }\n                  }\n                  return I3.concat(this.args.map(function(ae) {\n                    return ae.serialize();\n                  }));\n                };\n                var Gu = function(y3) {\n                  this.type = pl, this.sections = y3;\n                };\n                Gu.parse = function(y3, I3) {\n                  if (y3.length < 2) return I3.error("Expected at least one argument.");\n                  var U = y3[1];\n                  if (!Array.isArray(U) && typeof U == "object") return I3.error("First argument must be an image or text section.");\n                  for (var $2 = [], ae = false, he = 1; he <= y3.length - 1; ++he) {\n                    var Oe = y3[he];\n                    if (ae && typeof Oe == "object" && !Array.isArray(Oe)) {\n                      ae = false;\n                      var rt = null;\n                      if (Oe["font-scale"] && (rt = I3.parse(Oe["font-scale"], 1, aa), !rt)) return null;\n                      var gt = null;\n                      if (Oe["text-font"] && (gt = I3.parse(Oe["text-font"], 1, Kl(Oo)), !gt)) return null;\n                      var Et = null;\n                      if (Oe["text-color"] && (Et = I3.parse(Oe["text-color"], 1, ql), !Et)) return null;\n                      var or = $2[$2.length - 1];\n                      or.scale = rt, or.font = gt, or.textColor = Et;\n                    } else {\n                      var _r = I3.parse(y3[he], 1, Do);\n                      if (!_r) return null;\n                      var pr = _r.type.kind;\n                      if (pr !== "string" && pr !== "value" && pr !== "null" && pr !== "resolvedImage") return I3.error("Formatted text type must be \'string\', \'value\', \'image\' or \'null\'.");\n                      ae = true, $2.push({ content: _r, scale: null, font: null, textColor: null });\n                    }\n                  }\n                  return new Gu($2);\n                }, Gu.prototype.evaluate = function(y3) {\n                  var I3 = function(U) {\n                    var $2 = U.content.evaluate(y3);\n                    return Es($2) === Zc ? new Vf("", $2, null, null, null) : new Vf(Hs($2), null, U.scale ? U.scale.evaluate(y3) : null, U.font ? U.font.evaluate(y3).join(",") : null, U.textColor ? U.textColor.evaluate(y3) : null);\n                  };\n                  return new Jl(this.sections.map(I3));\n                }, Gu.prototype.eachChild = function(y3) {\n                  for (var I3 = 0, U = this.sections; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3($2.content), $2.scale && y3($2.scale), $2.font && y3($2.font), $2.textColor && y3($2.textColor);\n                  }\n                }, Gu.prototype.outputDefined = function() {\n                  return false;\n                }, Gu.prototype.serialize = function() {\n                  for (var y3 = ["format"], I3 = 0, U = this.sections; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3.push($2.content.serialize());\n                    var ae = {};\n                    $2.scale && (ae["font-scale"] = $2.scale.serialize()), $2.font && (ae["text-font"] = $2.font.serialize()), $2.textColor && (ae["text-color"] = $2.textColor.serialize()), y3.push(ae);\n                  }\n                  return y3;\n                };\n                var qs = function(y3) {\n                  this.type = Zc, this.input = y3;\n                };\n                qs.parse = function(y3, I3) {\n                  if (y3.length !== 2) return I3.error("Expected two arguments.");\n                  var U = I3.parse(y3[1], 1, Oo);\n                  return U ? new qs(U) : I3.error("No image name provided.");\n                }, qs.prototype.evaluate = function(y3) {\n                  var I3 = this.input.evaluate(y3), U = fl.fromString(I3);\n                  return U && y3.availableImages && (U.available = y3.availableImages.indexOf(I3) > -1), U;\n                }, qs.prototype.eachChild = function(y3) {\n                  y3(this.input);\n                }, qs.prototype.outputDefined = function() {\n                  return false;\n                }, qs.prototype.serialize = function() {\n                  return ["image", this.input.serialize()];\n                };\n                var ad = { "to-boolean": qo, "to-color": ql, "to-number": aa, "to-string": Oo }, Po = function(y3, I3) {\n                  this.type = y3, this.args = I3;\n                };\n                Po.parse = function(y3, I3) {\n                  if (y3.length < 2) return I3.error("Expected at least one argument.");\n                  var U = y3[0];\n                  if ((U === "to-boolean" || U === "to-string") && y3.length !== 2) return I3.error("Expected one argument.");\n                  for (var $2 = ad[U], ae = [], he = 1; he < y3.length; he++) {\n                    var Oe = I3.parse(y3[he], he, Do);\n                    if (!Oe) return null;\n                    ae.push(Oe);\n                  }\n                  return new Po($2, ae);\n                }, Po.prototype.evaluate = function(y3) {\n                  if (this.type.kind === "boolean") return !!this.args[0].evaluate(y3);\n                  if (this.type.kind === "color") {\n                    for (var I3, U, $2 = 0, ae = this.args; $2 < ae.length; $2 += 1) {\n                      var he = ae[$2];\n                      if (I3 = he.evaluate(y3), U = null, I3 instanceof cs) return I3;\n                      if (typeof I3 == "string") {\n                        var Oe = y3.parseColor(I3);\n                        if (Oe) return Oe;\n                      } else if (Array.isArray(I3) && (I3.length < 3 || I3.length > 4 ? U = "Invalid rbga value " + JSON.stringify(I3) + ": expected an array containing either three or four numeric values." : U = lc(I3[0], I3[1], I3[2], I3[3]), !U)) return new cs(I3[0] / 255, I3[1] / 255, I3[2] / 255, I3[3]);\n                    }\n                    throw new ps(U || "Could not parse color from value \'" + (typeof I3 == "string" ? I3 : String(JSON.stringify(I3))) + "\'");\n                  } else if (this.type.kind === "number") {\n                    for (var rt = null, gt = 0, Et = this.args; gt < Et.length; gt += 1) {\n                      var or = Et[gt];\n                      if (rt = or.evaluate(y3), rt === null) return 0;\n                      var _r = Number(rt);\n                      if (!isNaN(_r)) return _r;\n                    }\n                    throw new ps("Could not convert " + JSON.stringify(rt) + " to number.");\n                  } else return this.type.kind === "formatted" ? Jl.fromString(Hs(this.args[0].evaluate(y3))) : this.type.kind === "resolvedImage" ? fl.fromString(Hs(this.args[0].evaluate(y3))) : Hs(this.args[0].evaluate(y3));\n                }, Po.prototype.eachChild = function(y3) {\n                  this.args.forEach(y3);\n                }, Po.prototype.outputDefined = function() {\n                  return this.args.every(function(y3) {\n                    return y3.outputDefined();\n                  });\n                }, Po.prototype.serialize = function() {\n                  if (this.type.kind === "formatted") return new Gu([{ content: this.args[0], scale: null, font: null, textColor: null }]).serialize();\n                  if (this.type.kind === "resolvedImage") return new qs(this.args[0]).serialize();\n                  var y3 = ["to-" + this.type.kind];\n                  return this.eachChild(function(I3) {\n                    y3.push(I3.serialize());\n                  }), y3;\n                };\n                var od = ["Unknown", "Point", "LineString", "Polygon"], Yo = function() {\n                  this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = {}, this.availableImages = null, this.canonical = null;\n                };\n                Yo.prototype.id = function() {\n                  return this.feature && "id" in this.feature ? this.feature.id : null;\n                }, Yo.prototype.geometryType = function() {\n                  return this.feature ? typeof this.feature.type == "number" ? od[this.feature.type] : this.feature.type : null;\n                }, Yo.prototype.geometry = function() {\n                  return this.feature && "geometry" in this.feature ? this.feature.geometry : null;\n                }, Yo.prototype.canonicalID = function() {\n                  return this.canonical;\n                }, Yo.prototype.properties = function() {\n                  return this.feature && this.feature.properties || {};\n                }, Yo.prototype.parseColor = function(y3) {\n                  var I3 = this._parseColorCache[y3];\n                  return I3 || (I3 = this._parseColorCache[y3] = cs.parse(y3)), I3;\n                };\n                var Pa = function(y3, I3, U, $2) {\n                  this.name = y3, this.type = I3, this._evaluate = U, this.args = $2;\n                };\n                Pa.prototype.evaluate = function(y3) {\n                  return this._evaluate(y3, this.args);\n                }, Pa.prototype.eachChild = function(y3) {\n                  this.args.forEach(y3);\n                }, Pa.prototype.outputDefined = function() {\n                  return false;\n                }, Pa.prototype.serialize = function() {\n                  return [this.name].concat(this.args.map(function(y3) {\n                    return y3.serialize();\n                  }));\n                }, Pa.parse = function(y3, I3) {\n                  var U, $2 = y3[0], ae = Pa.definitions[$2];\n                  if (!ae) return I3.error(\'Unknown expression "\' + $2 + \'". If you wanted a literal array, use ["literal", [...]].\', 0);\n                  for (var he = Array.isArray(ae) ? ae[0] : ae.type, Oe = Array.isArray(ae) ? [[ae[1], ae[2]]] : ae.overloads, rt = Oe.filter(function(to) {\n                    var ao = to[0];\n                    return !Array.isArray(ao) || ao.length === y3.length - 1;\n                  }), gt = null, Et = 0, or = rt; Et < or.length; Et += 1) {\n                    var _r = or[Et], pr = _r[0], Fr = _r[1];\n                    gt = new ks(I3.registry, I3.path, null, I3.scope);\n                    for (var oi = [], Hi = false, Ai = 1; Ai < y3.length; Ai++) {\n                      var bn = y3[Ai], nn = Array.isArray(pr) ? pr[Ai - 1] : pr.type, xn = gt.parse(bn, 1 + oi.length, nn);\n                      if (!xn) {\n                        Hi = true;\n                        break;\n                      }\n                      oi.push(xn);\n                    }\n                    if (!Hi) {\n                      if (Array.isArray(pr) && pr.length !== oi.length) {\n                        gt.error("Expected " + pr.length + " arguments, but found " + oi.length + " instead.");\n                        continue;\n                      }\n                      for (var Pn = 0; Pn < oi.length; Pn++) {\n                        var Zn = Array.isArray(pr) ? pr[Pn] : pr.type, ga = oi[Pn];\n                        gt.concat(Pn + 1).checkSubtype(Zn, ga.type);\n                      }\n                      if (gt.errors.length === 0) return new Pa($2, he, Fr, oi);\n                    }\n                  }\n                  if (rt.length === 1) (U = I3.errors).push.apply(U, gt.errors);\n                  else {\n                    for (var ha = rt.length ? rt : Oe, eo = ha.map(function(to) {\n                      var ao = to[0];\n                      return af(ao);\n                    }).join(" | "), za = [], Za = 1; Za < y3.length; Za++) {\n                      var Ko = I3.parse(y3[Za], 1 + za.length);\n                      if (!Ko) return null;\n                      za.push(Os(Ko.type));\n                    }\n                    I3.error("Expected arguments of type " + eo + ", but found (" + za.join(", ") + ") instead.");\n                  }\n                  return null;\n                }, Pa.register = function(y3, I3) {\n                  Pa.definitions = I3;\n                  for (var U in I3) y3[U] = Pa;\n                };\n                function af(m3) {\n                  return Array.isArray(m3) ? "(" + m3.map(Os).join(", ") + ")" : "(" + Os(m3.type) + "...)";\n                }\n                var Hu = function(y3, I3, U) {\n                  this.type = Uf, this.locale = U, this.caseSensitive = y3, this.diacriticSensitive = I3;\n                };\n                Hu.parse = function(y3, I3) {\n                  if (y3.length !== 2) return I3.error("Expected one argument.");\n                  var U = y3[1];\n                  if (typeof U != "object" || Array.isArray(U)) return I3.error("Collator options argument must be an object.");\n                  var $2 = I3.parse(U["case-sensitive"] === void 0 ? false : U["case-sensitive"], 1, qo);\n                  if (!$2) return null;\n                  var ae = I3.parse(U["diacritic-sensitive"] === void 0 ? false : U["diacritic-sensitive"], 1, qo);\n                  if (!ae) return null;\n                  var he = null;\n                  return U.locale && (he = I3.parse(U.locale, 1, Oo), !he) ? null : new Hu($2, ae, he);\n                }, Hu.prototype.evaluate = function(y3) {\n                  return new nf(this.caseSensitive.evaluate(y3), this.diacriticSensitive.evaluate(y3), this.locale ? this.locale.evaluate(y3) : null);\n                }, Hu.prototype.eachChild = function(y3) {\n                  y3(this.caseSensitive), y3(this.diacriticSensitive), this.locale && y3(this.locale);\n                }, Hu.prototype.outputDefined = function() {\n                  return false;\n                }, Hu.prototype.serialize = function() {\n                  var y3 = {};\n                  return y3["case-sensitive"] = this.caseSensitive.serialize(), y3["diacritic-sensitive"] = this.diacriticSensitive.serialize(), this.locale && (y3.locale = this.locale.serialize()), ["collator", y3];\n                };\n                var bl = 8192;\n                function Gf(m3, y3) {\n                  m3[0] = Math.min(m3[0], y3[0]), m3[1] = Math.min(m3[1], y3[1]), m3[2] = Math.max(m3[2], y3[0]), m3[3] = Math.max(m3[3], y3[1]);\n                }\n                function Ic(m3) {\n                  return (180 + m3) / 360;\n                }\n                function yf(m3) {\n                  return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + m3 * Math.PI / 360))) / 360;\n                }\n                function Bl(m3, y3) {\n                  return !(m3[0] <= y3[0] || m3[2] >= y3[2] || m3[1] <= y3[1] || m3[3] >= y3[3]);\n                }\n                function wh(m3, y3) {\n                  var I3 = Ic(m3[0]), U = yf(m3[1]), $2 = Math.pow(2, y3.z);\n                  return [Math.round(I3 * $2 * bl), Math.round(U * $2 * bl)];\n                }\n                function Qf(m3, y3, I3) {\n                  var U = m3[0] - y3[0], $2 = m3[1] - y3[1], ae = m3[0] - I3[0], he = m3[1] - I3[1];\n                  return U * he - ae * $2 === 0 && U * ae <= 0 && $2 * he <= 0;\n                }\n                function _f(m3, y3, I3) {\n                  return y3[1] > m3[1] != I3[1] > m3[1] && m3[0] < (I3[0] - y3[0]) * (m3[1] - y3[1]) / (I3[1] - y3[1]) + y3[0];\n                }\n                function Yc(m3, y3) {\n                  for (var I3 = false, U = 0, $2 = y3.length; U < $2; U++) for (var ae = y3[U], he = 0, Oe = ae.length; he < Oe - 1; he++) {\n                    if (Qf(m3, ae[he], ae[he + 1])) return false;\n                    _f(m3, ae[he], ae[he + 1]) && (I3 = !I3);\n                  }\n                  return I3;\n                }\n                function eh(m3, y3) {\n                  for (var I3 = 0; I3 < y3.length; I3++) if (Yc(m3, y3[I3])) return true;\n                  return false;\n                }\n                function th(m3, y3) {\n                  return m3[0] * y3[1] - m3[1] * y3[0];\n                }\n                function ju(m3, y3, I3, U) {\n                  var $2 = m3[0] - I3[0], ae = m3[1] - I3[1], he = y3[0] - I3[0], Oe = y3[1] - I3[1], rt = U[0] - I3[0], gt = U[1] - I3[1], Et = $2 * gt - rt * ae, or = he * gt - rt * Oe;\n                  return Et > 0 && or < 0 || Et < 0 && or > 0;\n                }\n                function Hf(m3, y3, I3, U) {\n                  var $2 = [y3[0] - m3[0], y3[1] - m3[1]], ae = [U[0] - I3[0], U[1] - I3[1]];\n                  return th(ae, $2) === 0 ? false : !!(ju(m3, y3, I3, U) && ju(I3, U, m3, y3));\n                }\n                function cc(m3, y3, I3) {\n                  for (var U = 0, $2 = I3; U < $2.length; U += 1) for (var ae = $2[U], he = 0; he < ae.length - 1; ++he) if (Hf(m3, y3, ae[he], ae[he + 1])) return true;\n                  return false;\n                }\n                function of(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; ++I3) if (!Yc(m3[I3], y3)) return false;\n                  for (var U = 0; U < m3.length - 1; ++U) if (cc(m3[U], m3[U + 1], y3)) return false;\n                  return true;\n                }\n                function Nl(m3, y3) {\n                  for (var I3 = 0; I3 < y3.length; I3++) if (of(m3, y3[I3])) return true;\n                  return false;\n                }\n                function Kc(m3, y3, I3) {\n                  for (var U = [], $2 = 0; $2 < m3.length; $2++) {\n                    for (var ae = [], he = 0; he < m3[$2].length; he++) {\n                      var Oe = wh(m3[$2][he], I3);\n                      Gf(y3, Oe), ae.push(Oe);\n                    }\n                    U.push(ae);\n                  }\n                  return U;\n                }\n                function Rc(m3, y3, I3) {\n                  for (var U = [], $2 = 0; $2 < m3.length; $2++) {\n                    var ae = Kc(m3[$2], y3, I3);\n                    U.push(ae);\n                  }\n                  return U;\n                }\n                function gs(m3, y3, I3, U) {\n                  if (m3[0] < I3[0] || m3[0] > I3[2]) {\n                    var $2 = U * 0.5, ae = m3[0] - I3[0] > $2 ? -U : I3[0] - m3[0] > $2 ? U : 0;\n                    ae === 0 && (ae = m3[0] - I3[2] > $2 ? -U : I3[2] - m3[0] > $2 ? U : 0), m3[0] += ae;\n                  }\n                  Gf(y3, m3);\n                }\n                function jf(m3) {\n                  m3[0] = m3[1] = 1 / 0, m3[2] = m3[3] = -1 / 0;\n                }\n                function Gh(m3, y3, I3, U) {\n                  for (var $2 = Math.pow(2, U.z) * bl, ae = [U.x * bl, U.y * bl], he = [], Oe = 0, rt = m3; Oe < rt.length; Oe += 1) for (var gt = rt[Oe], Et = 0, or = gt; Et < or.length; Et += 1) {\n                    var _r = or[Et], pr = [_r.x + ae[0], _r.y + ae[1]];\n                    gs(pr, y3, I3, $2), he.push(pr);\n                  }\n                  return he;\n                }\n                function rh(m3, y3, I3, U) {\n                  for (var $2 = Math.pow(2, U.z) * bl, ae = [U.x * bl, U.y * bl], he = [], Oe = 0, rt = m3; Oe < rt.length; Oe += 1) {\n                    for (var gt = rt[Oe], Et = [], or = 0, _r = gt; or < _r.length; or += 1) {\n                      var pr = _r[or], Fr = [pr.x + ae[0], pr.y + ae[1]];\n                      Gf(y3, Fr), Et.push(Fr);\n                    }\n                    he.push(Et);\n                  }\n                  if (y3[2] - y3[0] <= $2 / 2) {\n                    jf(y3);\n                    for (var oi = 0, Hi = he; oi < Hi.length; oi += 1) for (var Ai = Hi[oi], bn = 0, nn = Ai; bn < nn.length; bn += 1) {\n                      var xn = nn[bn];\n                      gs(xn, y3, I3, $2);\n                    }\n                  }\n                  return he;\n                }\n                function sf(m3, y3) {\n                  var I3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], U = [1 / 0, 1 / 0, -1 / 0, -1 / 0], $2 = m3.canonicalID();\n                  if (y3.type === "Polygon") {\n                    var ae = Kc(y3.coordinates, U, $2), he = Gh(m3.geometry(), I3, U, $2);\n                    if (!Bl(I3, U)) return false;\n                    for (var Oe = 0, rt = he; Oe < rt.length; Oe += 1) {\n                      var gt = rt[Oe];\n                      if (!Yc(gt, ae)) return false;\n                    }\n                  }\n                  if (y3.type === "MultiPolygon") {\n                    var Et = Rc(y3.coordinates, U, $2), or = Gh(m3.geometry(), I3, U, $2);\n                    if (!Bl(I3, U)) return false;\n                    for (var _r = 0, pr = or; _r < pr.length; _r += 1) {\n                      var Fr = pr[_r];\n                      if (!eh(Fr, Et)) return false;\n                    }\n                  }\n                  return true;\n                }\n                function Th(m3, y3) {\n                  var I3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0], U = [1 / 0, 1 / 0, -1 / 0, -1 / 0], $2 = m3.canonicalID();\n                  if (y3.type === "Polygon") {\n                    var ae = Kc(y3.coordinates, U, $2), he = rh(m3.geometry(), I3, U, $2);\n                    if (!Bl(I3, U)) return false;\n                    for (var Oe = 0, rt = he; Oe < rt.length; Oe += 1) {\n                      var gt = rt[Oe];\n                      if (!of(gt, ae)) return false;\n                    }\n                  }\n                  if (y3.type === "MultiPolygon") {\n                    var Et = Rc(y3.coordinates, U, $2), or = rh(m3.geometry(), I3, U, $2);\n                    if (!Bl(I3, U)) return false;\n                    for (var _r = 0, pr = or; _r < pr.length; _r += 1) {\n                      var Fr = pr[_r];\n                      if (!Nl(Fr, Et)) return false;\n                    }\n                  }\n                  return true;\n                }\n                var Mu = function(y3, I3) {\n                  this.type = qo, this.geojson = y3, this.geometries = I3;\n                };\n                Mu.parse = function(y3, I3) {\n                  if (y3.length !== 2) return I3.error("\'within\' expression requires exactly one argument, but found " + (y3.length - 1) + " instead.");\n                  if (Fu(y3[1])) {\n                    var U = y3[1];\n                    if (U.type === "FeatureCollection") for (var $2 = 0; $2 < U.features.length; ++$2) {\n                      var ae = U.features[$2].geometry.type;\n                      if (ae === "Polygon" || ae === "MultiPolygon") return new Mu(U, U.features[$2].geometry);\n                    }\n                    else if (U.type === "Feature") {\n                      var he = U.geometry.type;\n                      if (he === "Polygon" || he === "MultiPolygon") return new Mu(U, U.geometry);\n                    } else if (U.type === "Polygon" || U.type === "MultiPolygon") return new Mu(U, U);\n                  }\n                  return I3.error("\'within\' expression requires valid geojson object that contains polygon geometry type.");\n                }, Mu.prototype.evaluate = function(y3) {\n                  if (y3.geometry() != null && y3.canonicalID() != null) {\n                    if (y3.geometryType() === "Point") return sf(y3, this.geometries);\n                    if (y3.geometryType() === "LineString") return Th(y3, this.geometries);\n                  }\n                  return false;\n                }, Mu.prototype.eachChild = function() {\n                }, Mu.prototype.outputDefined = function() {\n                  return true;\n                }, Mu.prototype.serialize = function() {\n                  return ["within", this.geojson];\n                };\n                function ih(m3) {\n                  if (m3 instanceof Pa) {\n                    if (m3.name === "get" && m3.args.length === 1) return false;\n                    if (m3.name === "feature-state") return false;\n                    if (m3.name === "has" && m3.args.length === 1) return false;\n                    if (m3.name === "properties" || m3.name === "geometry-type" || m3.name === "id") return false;\n                    if (/^filter-/.test(m3.name)) return false;\n                  }\n                  if (m3 instanceof Mu) return false;\n                  var y3 = true;\n                  return m3.eachChild(function(I3) {\n                    y3 && !ih(I3) && (y3 = false);\n                  }), y3;\n                }\n                function js(m3) {\n                  if (m3 instanceof Pa && m3.name === "feature-state") return false;\n                  var y3 = true;\n                  return m3.eachChild(function(I3) {\n                    y3 && !js(I3) && (y3 = false);\n                  }), y3;\n                }\n                function Eu(m3, y3) {\n                  if (m3 instanceof Pa && y3.indexOf(m3.name) >= 0) return false;\n                  var I3 = true;\n                  return m3.eachChild(function(U) {\n                    I3 && !Eu(U, y3) && (I3 = false);\n                  }), I3;\n                }\n                var Dc = function(y3, I3) {\n                  this.type = I3.type, this.name = y3, this.boundExpression = I3;\n                };\n                Dc.parse = function(y3, I3) {\n                  if (y3.length !== 2 || typeof y3[1] != "string") return I3.error("\'var\' expression requires exactly one string literal argument.");\n                  var U = y3[1];\n                  return I3.scope.has(U) ? new Dc(U, I3.scope.get(U)) : I3.error(\'Unknown variable "\' + U + \'". Make sure "\' + U + \'" has been bound in an enclosing "let" expression before using it.\', 1);\n                }, Dc.prototype.evaluate = function(y3) {\n                  return this.boundExpression.evaluate(y3);\n                }, Dc.prototype.eachChild = function() {\n                }, Dc.prototype.outputDefined = function() {\n                  return false;\n                }, Dc.prototype.serialize = function() {\n                  return ["var", this.name];\n                };\n                var ks = function(y3, I3, U, $2, ae) {\n                  I3 === void 0 && (I3 = []), $2 === void 0 && ($2 = new Hl()), ae === void 0 && (ae = []), this.registry = y3, this.path = I3, this.key = I3.map(function(he) {\n                    return "[" + he + "]";\n                  }).join(""), this.scope = $2, this.errors = ae, this.expectedType = U;\n                };\n                ks.prototype.parse = function(y3, I3, U, $2, ae) {\n                  return ae === void 0 && (ae = {}), I3 ? this.concat(I3, U, $2)._parse(y3, ae) : this._parse(y3, ae);\n                }, ks.prototype._parse = function(y3, I3) {\n                  (y3 === null || typeof y3 == "string" || typeof y3 == "boolean" || typeof y3 == "number") && (y3 = ["literal", y3]);\n                  function U(Et, or, _r) {\n                    return _r === "assert" ? new xl(or, [Et]) : _r === "coerce" ? new Po(or, [Et]) : Et;\n                  }\n                  if (Array.isArray(y3)) {\n                    if (y3.length === 0) return this.error(\'Expected an array with at least one element. If you wanted a literal array, use ["literal", []].\');\n                    var $2 = y3[0];\n                    if (typeof $2 != "string") return this.error("Expression name must be a string, but found " + typeof $2 + \' instead. If you wanted a literal array, use ["literal", [...]].\', 0), null;\n                    var ae = this.registry[$2];\n                    if (ae) {\n                      var he = ae.parse(y3, this);\n                      if (!he) return null;\n                      if (this.expectedType) {\n                        var Oe = this.expectedType, rt = he.type;\n                        if ((Oe.kind === "string" || Oe.kind === "number" || Oe.kind === "boolean" || Oe.kind === "object" || Oe.kind === "array") && rt.kind === "value") he = U(he, Oe, I3.typeAnnotation || "assert");\n                        else if ((Oe.kind === "color" || Oe.kind === "formatted" || Oe.kind === "resolvedImage") && (rt.kind === "value" || rt.kind === "string")) he = U(he, Oe, I3.typeAnnotation || "coerce");\n                        else if (this.checkSubtype(Oe, rt)) return null;\n                      }\n                      if (!(he instanceof Go) && he.type.kind !== "resolvedImage" && bc(he)) {\n                        var gt = new Yo();\n                        try {\n                          he = new Go(he.type, he.evaluate(gt));\n                        } catch (Et) {\n                          return this.error(Et.message), null;\n                        }\n                      }\n                      return he;\n                    }\n                    return this.error(\'Unknown expression "\' + $2 + \'". If you wanted a literal array, use ["literal", [...]].\', 0);\n                  } else return typeof y3 == "undefined" ? this.error("\'undefined\' value invalid. Use null instead.") : typeof y3 == "object" ? this.error(\'Bare objects invalid. Use ["literal", {...}] instead.\') : this.error("Expected an array, but found " + typeof y3 + " instead.");\n                }, ks.prototype.concat = function(y3, I3, U) {\n                  var $2 = typeof y3 == "number" ? this.path.concat(y3) : this.path, ae = U ? this.scope.concat(U) : this.scope;\n                  return new ks(this.registry, $2, I3 || null, ae, this.errors);\n                }, ks.prototype.error = function(y3) {\n                  for (var I3 = [], U = arguments.length - 1; U-- > 0; ) I3[U] = arguments[U + 1];\n                  var $2 = "" + this.key + I3.map(function(ae) {\n                    return "[" + ae + "]";\n                  }).join("");\n                  this.errors.push(new Ns($2, y3));\n                }, ks.prototype.checkSubtype = function(y3, I3) {\n                  var U = oc(y3, I3);\n                  return U && this.error(U), U;\n                };\n                function bc(m3) {\n                  if (m3 instanceof Dc) return bc(m3.boundExpression);\n                  if (m3 instanceof Pa && m3.name === "error") return false;\n                  if (m3 instanceof Hu) return false;\n                  if (m3 instanceof Mu) return false;\n                  var y3 = m3 instanceof Po || m3 instanceof xl, I3 = true;\n                  return m3.eachChild(function(U) {\n                    y3 ? I3 = I3 && bc(U) : I3 = I3 && U instanceof Go;\n                  }), I3 ? ih(m3) && Eu(m3, ["zoom", "heatmap-density", "line-progress", "accumulated", "is-supported-script"]) : false;\n                }\n                function hu(m3, y3) {\n                  for (var I3 = m3.length - 1, U = 0, $2 = I3, ae = 0, he, Oe; U <= $2; ) if (ae = Math.floor((U + $2) / 2), he = m3[ae], Oe = m3[ae + 1], he <= y3) {\n                    if (ae === I3 || y3 < Oe) return ae;\n                    U = ae + 1;\n                  } else if (he > y3) $2 = ae - 1;\n                  else throw new ps("Input is not a number.");\n                  return 0;\n                }\n                var _u = function(y3, I3, U) {\n                  this.type = y3, this.input = I3, this.labels = [], this.outputs = [];\n                  for (var $2 = 0, ae = U; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2], Oe = he[0], rt = he[1];\n                    this.labels.push(Oe), this.outputs.push(rt);\n                  }\n                };\n                _u.parse = function(y3, I3) {\n                  if (y3.length - 1 < 4) return I3.error("Expected at least 4 arguments, but found only " + (y3.length - 1) + ".");\n                  if ((y3.length - 1) % 2 !== 0) return I3.error("Expected an even number of arguments.");\n                  var U = I3.parse(y3[1], 1, aa);\n                  if (!U) return null;\n                  var $2 = [], ae = null;\n                  I3.expectedType && I3.expectedType.kind !== "value" && (ae = I3.expectedType);\n                  for (var he = 1; he < y3.length; he += 2) {\n                    var Oe = he === 1 ? -1 / 0 : y3[he], rt = y3[he + 1], gt = he, Et = he + 1;\n                    if (typeof Oe != "number") return I3.error(\'Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.\', gt);\n                    if ($2.length && $2[$2.length - 1][0] >= Oe) return I3.error(\'Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.\', gt);\n                    var or = I3.parse(rt, Et, ae);\n                    if (!or) return null;\n                    ae = ae || or.type, $2.push([Oe, or]);\n                  }\n                  return new _u(ae, U, $2);\n                }, _u.prototype.evaluate = function(y3) {\n                  var I3 = this.labels, U = this.outputs;\n                  if (I3.length === 1) return U[0].evaluate(y3);\n                  var $2 = this.input.evaluate(y3);\n                  if ($2 <= I3[0]) return U[0].evaluate(y3);\n                  var ae = I3.length;\n                  if ($2 >= I3[ae - 1]) return U[ae - 1].evaluate(y3);\n                  var he = hu(I3, $2);\n                  return U[he].evaluate(y3);\n                }, _u.prototype.eachChild = function(y3) {\n                  y3(this.input);\n                  for (var I3 = 0, U = this.outputs; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3($2);\n                  }\n                }, _u.prototype.outputDefined = function() {\n                  return this.outputs.every(function(y3) {\n                    return y3.outputDefined();\n                  });\n                }, _u.prototype.serialize = function() {\n                  for (var y3 = ["step", this.input.serialize()], I3 = 0; I3 < this.labels.length; I3++) I3 > 0 && y3.push(this.labels[I3]), y3.push(this.outputs[I3].serialize());\n                  return y3;\n                };\n                function nl(m3, y3, I3) {\n                  return m3 * (1 - I3) + y3 * I3;\n                }\n                function nh(m3, y3, I3) {\n                  return new cs(nl(m3.r, y3.r, I3), nl(m3.g, y3.g, I3), nl(m3.b, y3.b, I3), nl(m3.a, y3.a, I3));\n                }\n                function Ah(m3, y3, I3) {\n                  return m3.map(function(U, $2) {\n                    return nl(U, y3[$2], I3);\n                  });\n                }\n                var zu = Object.freeze({ __proto__: null, number: nl, color: nh, array: Ah }), Fc = 0.95047, wc = 1, bd = 1.08883, xf = 4 / 29, Pf = 6 / 29, Ou = 3 * Pf * Pf, bf = Pf * Pf * Pf, jl = Math.PI / 180, lf = 180 / Math.PI;\n                function Hh(m3) {\n                  return m3 > bf ? Math.pow(m3, 1 / 3) : m3 / Ou + xf;\n                }\n                function If(m3) {\n                  return m3 > Pf ? m3 * m3 * m3 : Ou * (m3 - xf);\n                }\n                function Cs(m3) {\n                  return 255 * (m3 <= 31308e-7 ? 12.92 * m3 : 1.055 * Math.pow(m3, 1 / 2.4) - 0.055);\n                }\n                function du(m3) {\n                  return m3 /= 255, m3 <= 0.04045 ? m3 / 12.92 : Math.pow((m3 + 0.055) / 1.055, 2.4);\n                }\n                function ku(m3) {\n                  var y3 = du(m3.r), I3 = du(m3.g), U = du(m3.b), $2 = Hh((0.4124564 * y3 + 0.3575761 * I3 + 0.1804375 * U) / Fc), ae = Hh((0.2126729 * y3 + 0.7151522 * I3 + 0.072175 * U) / wc), he = Hh((0.0193339 * y3 + 0.119192 * I3 + 0.9503041 * U) / bd);\n                  return { l: 116 * ae - 16, a: 500 * ($2 - ae), b: 200 * (ae - he), alpha: m3.a };\n                }\n                function Wf(m3) {\n                  var y3 = (m3.l + 16) / 116, I3 = isNaN(m3.a) ? y3 : y3 + m3.a / 500, U = isNaN(m3.b) ? y3 : y3 - m3.b / 200;\n                  return y3 = wc * If(y3), I3 = Fc * If(I3), U = bd * If(U), new cs(Cs(3.2404542 * I3 - 1.5371385 * y3 - 0.4985314 * U), Cs(-0.969266 * I3 + 1.8760108 * y3 + 0.041556 * U), Cs(0.0556434 * I3 - 0.2040259 * y3 + 1.0572252 * U), m3.alpha);\n                }\n                function Us(m3, y3, I3) {\n                  return { l: nl(m3.l, y3.l, I3), a: nl(m3.a, y3.a, I3), b: nl(m3.b, y3.b, I3), alpha: nl(m3.alpha, y3.alpha, I3) };\n                }\n                function wf(m3) {\n                  var y3 = ku(m3), I3 = y3.l, U = y3.a, $2 = y3.b, ae = Math.atan2($2, U) * lf;\n                  return { h: ae < 0 ? ae + 360 : ae, c: Math.sqrt(U * U + $2 * $2), l: I3, alpha: m3.a };\n                }\n                function zc(m3) {\n                  var y3 = m3.h * jl, I3 = m3.c, U = m3.l;\n                  return Wf({ l: U, a: Math.cos(y3) * I3, b: Math.sin(y3) * I3, alpha: m3.alpha });\n                }\n                function Wu(m3, y3, I3) {\n                  var U = y3 - m3;\n                  return m3 + I3 * (U > 180 || U < -180 ? U - 360 * Math.round(U / 360) : U);\n                }\n                function Rf(m3, y3, I3) {\n                  return { h: Wu(m3.h, y3.h, I3), c: nl(m3.c, y3.c, I3), l: nl(m3.l, y3.l, I3), alpha: nl(m3.alpha, y3.alpha, I3) };\n                }\n                var Xu = { forward: ku, reverse: Wf, interpolate: Us }, uf = { forward: wf, reverse: zc, interpolate: Rf }, Xf = Object.freeze({ __proto__: null, lab: Xu, hcl: uf }), Wl = function(y3, I3, U, $2, ae) {\n                  this.type = y3, this.operator = I3, this.interpolation = U, this.input = $2, this.labels = [], this.outputs = [];\n                  for (var he = 0, Oe = ae; he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = rt[0], Et = rt[1];\n                    this.labels.push(gt), this.outputs.push(Et);\n                  }\n                };\n                Wl.interpolationFactor = function(y3, I3, U, $2) {\n                  var ae = 0;\n                  if (y3.name === "exponential") ae = ah(I3, y3.base, U, $2);\n                  else if (y3.name === "linear") ae = ah(I3, 1, U, $2);\n                  else if (y3.name === "cubic-bezier") {\n                    var he = y3.controlPoints, Oe = new s3(he[0], he[1], he[2], he[3]);\n                    ae = Oe.solve(ah(I3, 1, U, $2));\n                  }\n                  return ae;\n                }, Wl.parse = function(y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2], he = y3.slice(3);\n                  if (!Array.isArray($2) || $2.length === 0) return I3.error("Expected an interpolation type expression.", 1);\n                  if ($2[0] === "linear") $2 = { name: "linear" };\n                  else if ($2[0] === "exponential") {\n                    var Oe = $2[1];\n                    if (typeof Oe != "number") return I3.error("Exponential interpolation requires a numeric base.", 1, 1);\n                    $2 = { name: "exponential", base: Oe };\n                  } else if ($2[0] === "cubic-bezier") {\n                    var rt = $2.slice(1);\n                    if (rt.length !== 4 || rt.some(function(Ai) {\n                      return typeof Ai != "number" || Ai < 0 || Ai > 1;\n                    })) return I3.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);\n                    $2 = { name: "cubic-bezier", controlPoints: rt };\n                  } else return I3.error("Unknown interpolation type " + String($2[0]), 1, 0);\n                  if (y3.length - 1 < 4) return I3.error("Expected at least 4 arguments, but found only " + (y3.length - 1) + ".");\n                  if ((y3.length - 1) % 2 !== 0) return I3.error("Expected an even number of arguments.");\n                  if (ae = I3.parse(ae, 2, aa), !ae) return null;\n                  var gt = [], Et = null;\n                  U === "interpolate-hcl" || U === "interpolate-lab" ? Et = ql : I3.expectedType && I3.expectedType.kind !== "value" && (Et = I3.expectedType);\n                  for (var or = 0; or < he.length; or += 2) {\n                    var _r = he[or], pr = he[or + 1], Fr = or + 3, oi = or + 4;\n                    if (typeof _r != "number") return I3.error(\'Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.\', Fr);\n                    if (gt.length && gt[gt.length - 1][0] >= _r) return I3.error(\'Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.\', Fr);\n                    var Hi = I3.parse(pr, oi, Et);\n                    if (!Hi) return null;\n                    Et = Et || Hi.type, gt.push([_r, Hi]);\n                  }\n                  return Et.kind !== "number" && Et.kind !== "color" && !(Et.kind === "array" && Et.itemType.kind === "number" && typeof Et.N == "number") ? I3.error("Type " + Os(Et) + " is not interpolatable.") : new Wl(Et, U, $2, ae, gt);\n                }, Wl.prototype.evaluate = function(y3) {\n                  var I3 = this.labels, U = this.outputs;\n                  if (I3.length === 1) return U[0].evaluate(y3);\n                  var $2 = this.input.evaluate(y3);\n                  if ($2 <= I3[0]) return U[0].evaluate(y3);\n                  var ae = I3.length;\n                  if ($2 >= I3[ae - 1]) return U[ae - 1].evaluate(y3);\n                  var he = hu(I3, $2), Oe = I3[he], rt = I3[he + 1], gt = Wl.interpolationFactor(this.interpolation, $2, Oe, rt), Et = U[he].evaluate(y3), or = U[he + 1].evaluate(y3);\n                  return this.operator === "interpolate" ? zu[this.type.kind.toLowerCase()](Et, or, gt) : this.operator === "interpolate-hcl" ? uf.reverse(uf.interpolate(uf.forward(Et), uf.forward(or), gt)) : Xu.reverse(Xu.interpolate(Xu.forward(Et), Xu.forward(or), gt));\n                }, Wl.prototype.eachChild = function(y3) {\n                  y3(this.input);\n                  for (var I3 = 0, U = this.outputs; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3($2);\n                  }\n                }, Wl.prototype.outputDefined = function() {\n                  return this.outputs.every(function(y3) {\n                    return y3.outputDefined();\n                  });\n                }, Wl.prototype.serialize = function() {\n                  var y3;\n                  this.interpolation.name === "linear" ? y3 = ["linear"] : this.interpolation.name === "exponential" ? this.interpolation.base === 1 ? y3 = ["linear"] : y3 = ["exponential", this.interpolation.base] : y3 = ["cubic-bezier"].concat(this.interpolation.controlPoints);\n                  for (var I3 = [this.operator, y3, this.input.serialize()], U = 0; U < this.labels.length; U++) I3.push(this.labels[U], this.outputs[U].serialize());\n                  return I3;\n                };\n                function ah(m3, y3, I3, U) {\n                  var $2 = U - I3, ae = m3 - I3;\n                  return $2 === 0 ? 0 : y3 === 1 ? ae / $2 : (Math.pow(y3, ae) - 1) / (Math.pow(y3, $2) - 1);\n                }\n                var Zu = function(y3, I3) {\n                  this.type = y3, this.args = I3;\n                };\n                Zu.parse = function(y3, I3) {\n                  if (y3.length < 2) return I3.error("Expectected at least one argument.");\n                  var U = null, $2 = I3.expectedType;\n                  $2 && $2.kind !== "value" && (U = $2);\n                  for (var ae = [], he = 0, Oe = y3.slice(1); he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = I3.parse(rt, 1 + ae.length, U, void 0, { typeAnnotation: "omit" });\n                    if (!gt) return null;\n                    U = U || gt.type, ae.push(gt);\n                  }\n                  var Et = $2 && ae.some(function(or) {\n                    return oc($2, or.type);\n                  });\n                  return Et ? new Zu(Do, ae) : new Zu(U, ae);\n                }, Zu.prototype.evaluate = function(y3) {\n                  for (var I3 = null, U = 0, $2, ae = 0, he = this.args; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    if (U++, I3 = Oe.evaluate(y3), I3 && I3 instanceof fl && !I3.available && ($2 || ($2 = I3.name), I3 = null, U === this.args.length && (I3 = $2)), I3 !== null) break;\n                  }\n                  return I3;\n                }, Zu.prototype.eachChild = function(y3) {\n                  this.args.forEach(y3);\n                }, Zu.prototype.outputDefined = function() {\n                  return this.args.every(function(y3) {\n                    return y3.outputDefined();\n                  });\n                }, Zu.prototype.serialize = function() {\n                  var y3 = ["coalesce"];\n                  return this.eachChild(function(I3) {\n                    y3.push(I3.serialize());\n                  }), y3;\n                };\n                var Oc = function(y3, I3) {\n                  this.type = I3.type, this.bindings = [].concat(y3), this.result = I3;\n                };\n                Oc.prototype.evaluate = function(y3) {\n                  return this.result.evaluate(y3);\n                }, Oc.prototype.eachChild = function(y3) {\n                  for (var I3 = 0, U = this.bindings; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3($2[1]);\n                  }\n                  y3(this.result);\n                }, Oc.parse = function(y3, I3) {\n                  if (y3.length < 4) return I3.error("Expected at least 3 arguments, but found " + (y3.length - 1) + " instead.");\n                  for (var U = [], $2 = 1; $2 < y3.length - 1; $2 += 2) {\n                    var ae = y3[$2];\n                    if (typeof ae != "string") return I3.error("Expected string, but found " + typeof ae + " instead.", $2);\n                    if (/[^a-zA-Z0-9_]/.test(ae)) return I3.error("Variable names must contain only alphanumeric characters or \'_\'.", $2);\n                    var he = I3.parse(y3[$2 + 1], $2 + 1);\n                    if (!he) return null;\n                    U.push([ae, he]);\n                  }\n                  var Oe = I3.parse(y3[y3.length - 1], y3.length - 1, I3.expectedType, U);\n                  return Oe ? new Oc(U, Oe) : null;\n                }, Oc.prototype.outputDefined = function() {\n                  return this.result.outputDefined();\n                }, Oc.prototype.serialize = function() {\n                  for (var y3 = ["let"], I3 = 0, U = this.bindings; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3], ae = $2[0], he = $2[1];\n                    y3.push(ae, he.serialize());\n                  }\n                  return y3.push(this.result.serialize()), y3;\n                };\n                var Tc = function(y3, I3, U) {\n                  this.type = y3, this.index = I3, this.input = U;\n                };\n                Tc.parse = function(y3, I3) {\n                  if (y3.length !== 3) return I3.error("Expected 2 arguments, but found " + (y3.length - 1) + " instead.");\n                  var U = I3.parse(y3[1], 1, aa), $2 = I3.parse(y3[2], 2, Kl(I3.expectedType || Do));\n                  if (!U || !$2) return null;\n                  var ae = $2.type;\n                  return new Tc(ae.itemType, U, $2);\n                }, Tc.prototype.evaluate = function(y3) {\n                  var I3 = this.index.evaluate(y3), U = this.input.evaluate(y3);\n                  if (I3 < 0) throw new ps("Array index out of bounds: " + I3 + " < 0.");\n                  if (I3 >= U.length) throw new ps("Array index out of bounds: " + I3 + " > " + (U.length - 1) + ".");\n                  if (I3 !== Math.floor(I3)) throw new ps("Array index must be an integer, but found " + I3 + " instead.");\n                  return U[I3];\n                }, Tc.prototype.eachChild = function(y3) {\n                  y3(this.index), y3(this.input);\n                }, Tc.prototype.outputDefined = function() {\n                  return false;\n                }, Tc.prototype.serialize = function() {\n                  return ["at", this.index.serialize(), this.input.serialize()];\n                };\n                var wl = function(y3, I3) {\n                  this.type = qo, this.needle = y3, this.haystack = I3;\n                };\n                wl.parse = function(y3, I3) {\n                  if (y3.length !== 3) return I3.error("Expected 2 arguments, but found " + (y3.length - 1) + " instead.");\n                  var U = I3.parse(y3[1], 1, Do), $2 = I3.parse(y3[2], 2, Do);\n                  return !U || !$2 ? null : Cf(U.type, [qo, Oo, aa, ac, Do]) ? new wl(U, $2) : I3.error("Expected first argument to be of type boolean, string, number or null, but found " + Os(U.type) + " instead");\n                }, wl.prototype.evaluate = function(y3) {\n                  var I3 = this.needle.evaluate(y3), U = this.haystack.evaluate(y3);\n                  if (!U) return false;\n                  if (!sc(I3, ["boolean", "string", "number", "null"])) throw new ps("Expected first argument to be of type boolean, string, number or null, but found " + Os(Es(I3)) + " instead.");\n                  if (!sc(U, ["string", "array"])) throw new ps("Expected second argument to be of type array or string, but found " + Os(Es(U)) + " instead.");\n                  return U.indexOf(I3) >= 0;\n                }, wl.prototype.eachChild = function(y3) {\n                  y3(this.needle), y3(this.haystack);\n                }, wl.prototype.outputDefined = function() {\n                  return true;\n                }, wl.prototype.serialize = function() {\n                  return ["in", this.needle.serialize(), this.haystack.serialize()];\n                };\n                var vu = function(y3, I3, U) {\n                  this.type = aa, this.needle = y3, this.haystack = I3, this.fromIndex = U;\n                };\n                vu.parse = function(y3, I3) {\n                  if (y3.length <= 2 || y3.length >= 5) return I3.error("Expected 3 or 4 arguments, but found " + (y3.length - 1) + " instead.");\n                  var U = I3.parse(y3[1], 1, Do), $2 = I3.parse(y3[2], 2, Do);\n                  if (!U || !$2) return null;\n                  if (!Cf(U.type, [qo, Oo, aa, ac, Do])) return I3.error("Expected first argument to be of type boolean, string, number or null, but found " + Os(U.type) + " instead");\n                  if (y3.length === 4) {\n                    var ae = I3.parse(y3[3], 3, aa);\n                    return ae ? new vu(U, $2, ae) : null;\n                  } else return new vu(U, $2);\n                }, vu.prototype.evaluate = function(y3) {\n                  var I3 = this.needle.evaluate(y3), U = this.haystack.evaluate(y3);\n                  if (!sc(I3, ["boolean", "string", "number", "null"])) throw new ps("Expected first argument to be of type boolean, string, number or null, but found " + Os(Es(I3)) + " instead.");\n                  if (!sc(U, ["string", "array"])) throw new ps("Expected second argument to be of type array or string, but found " + Os(Es(U)) + " instead.");\n                  if (this.fromIndex) {\n                    var $2 = this.fromIndex.evaluate(y3);\n                    return U.indexOf(I3, $2);\n                  }\n                  return U.indexOf(I3);\n                }, vu.prototype.eachChild = function(y3) {\n                  y3(this.needle), y3(this.haystack), this.fromIndex && y3(this.fromIndex);\n                }, vu.prototype.outputDefined = function() {\n                  return false;\n                }, vu.prototype.serialize = function() {\n                  if (this.fromIndex != null && this.fromIndex !== void 0) {\n                    var y3 = this.fromIndex.serialize();\n                    return ["index-of", this.needle.serialize(), this.haystack.serialize(), y3];\n                  }\n                  return ["index-of", this.needle.serialize(), this.haystack.serialize()];\n                };\n                var qc = function(y3, I3, U, $2, ae, he) {\n                  this.inputType = y3, this.type = I3, this.input = U, this.cases = $2, this.outputs = ae, this.otherwise = he;\n                };\n                qc.parse = function(y3, I3) {\n                  if (y3.length < 5) return I3.error("Expected at least 4 arguments, but found only " + (y3.length - 1) + ".");\n                  if (y3.length % 2 !== 1) return I3.error("Expected an even number of arguments.");\n                  var U, $2;\n                  I3.expectedType && I3.expectedType.kind !== "value" && ($2 = I3.expectedType);\n                  for (var ae = {}, he = [], Oe = 2; Oe < y3.length - 1; Oe += 2) {\n                    var rt = y3[Oe], gt = y3[Oe + 1];\n                    Array.isArray(rt) || (rt = [rt]);\n                    var Et = I3.concat(Oe);\n                    if (rt.length === 0) return Et.error("Expected at least one branch label.");\n                    for (var or = 0, _r = rt; or < _r.length; or += 1) {\n                      var pr = _r[or];\n                      if (typeof pr != "number" && typeof pr != "string") return Et.error("Branch labels must be numbers or strings.");\n                      if (typeof pr == "number" && Math.abs(pr) > Number.MAX_SAFE_INTEGER) return Et.error("Branch labels must be integers no larger than " + Number.MAX_SAFE_INTEGER + ".");\n                      if (typeof pr == "number" && Math.floor(pr) !== pr) return Et.error("Numeric branch labels must be integer values.");\n                      if (!U) U = Es(pr);\n                      else if (Et.checkSubtype(U, Es(pr))) return null;\n                      if (typeof ae[String(pr)] != "undefined") return Et.error("Branch labels must be unique.");\n                      ae[String(pr)] = he.length;\n                    }\n                    var Fr = I3.parse(gt, Oe, $2);\n                    if (!Fr) return null;\n                    $2 = $2 || Fr.type, he.push(Fr);\n                  }\n                  var oi = I3.parse(y3[1], 1, Do);\n                  if (!oi) return null;\n                  var Hi = I3.parse(y3[y3.length - 1], y3.length - 1, $2);\n                  return !Hi || oi.type.kind !== "value" && I3.concat(1).checkSubtype(U, oi.type) ? null : new qc(U, $2, oi, ae, he, Hi);\n                }, qc.prototype.evaluate = function(y3) {\n                  var I3 = this.input.evaluate(y3), U = Es(I3) === this.inputType && this.outputs[this.cases[I3]] || this.otherwise;\n                  return U.evaluate(y3);\n                }, qc.prototype.eachChild = function(y3) {\n                  y3(this.input), this.outputs.forEach(y3), y3(this.otherwise);\n                }, qc.prototype.outputDefined = function() {\n                  return this.outputs.every(function(y3) {\n                    return y3.outputDefined();\n                  }) && this.otherwise.outputDefined();\n                }, qc.prototype.serialize = function() {\n                  for (var y3 = this, I3 = ["match", this.input.serialize()], U = Object.keys(this.cases).sort(), $2 = [], ae = {}, he = 0, Oe = U; he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = ae[this.cases[rt]];\n                    gt === void 0 ? (ae[this.cases[rt]] = $2.length, $2.push([this.cases[rt], [rt]])) : $2[gt][1].push(rt);\n                  }\n                  for (var Et = function(oi) {\n                    return y3.inputType.kind === "number" ? Number(oi) : oi;\n                  }, or = 0, _r = $2; or < _r.length; or += 1) {\n                    var pr = _r[or], gt = pr[0], Fr = pr[1];\n                    Fr.length === 1 ? I3.push(Et(Fr[0])) : I3.push(Fr.map(Et)), I3.push(this.outputs[outputIndex$1].serialize());\n                  }\n                  return I3.push(this.otherwise.serialize()), I3;\n                };\n                var cf = function(y3, I3, U) {\n                  this.type = y3, this.branches = I3, this.otherwise = U;\n                };\n                cf.parse = function(y3, I3) {\n                  if (y3.length < 4) return I3.error("Expected at least 3 arguments, but found only " + (y3.length - 1) + ".");\n                  if (y3.length % 2 !== 0) return I3.error("Expected an odd number of arguments.");\n                  var U;\n                  I3.expectedType && I3.expectedType.kind !== "value" && (U = I3.expectedType);\n                  for (var $2 = [], ae = 1; ae < y3.length - 1; ae += 2) {\n                    var he = I3.parse(y3[ae], ae, qo);\n                    if (!he) return null;\n                    var Oe = I3.parse(y3[ae + 1], ae + 1, U);\n                    if (!Oe) return null;\n                    $2.push([he, Oe]), U = U || Oe.type;\n                  }\n                  var rt = I3.parse(y3[y3.length - 1], y3.length - 1, U);\n                  return rt ? new cf(U, $2, rt) : null;\n                }, cf.prototype.evaluate = function(y3) {\n                  for (var I3 = 0, U = this.branches; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3], ae = $2[0], he = $2[1];\n                    if (ae.evaluate(y3)) return he.evaluate(y3);\n                  }\n                  return this.otherwise.evaluate(y3);\n                }, cf.prototype.eachChild = function(y3) {\n                  for (var I3 = 0, U = this.branches; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3], ae = $2[0], he = $2[1];\n                    y3(ae), y3(he);\n                  }\n                  y3(this.otherwise);\n                }, cf.prototype.outputDefined = function() {\n                  return this.branches.every(function(y3) {\n                    var I3 = y3[0], U = y3[1];\n                    return U.outputDefined();\n                  }) && this.otherwise.outputDefined();\n                }, cf.prototype.serialize = function() {\n                  var y3 = ["case"];\n                  return this.eachChild(function(I3) {\n                    y3.push(I3.serialize());\n                  }), y3;\n                };\n                var fc = function(y3, I3, U, $2) {\n                  this.type = y3, this.input = I3, this.beginIndex = U, this.endIndex = $2;\n                };\n                fc.parse = function(y3, I3) {\n                  if (y3.length <= 2 || y3.length >= 5) return I3.error("Expected 3 or 4 arguments, but found " + (y3.length - 1) + " instead.");\n                  var U = I3.parse(y3[1], 1, Do), $2 = I3.parse(y3[2], 2, aa);\n                  if (!U || !$2) return null;\n                  if (!Cf(U.type, [Kl(Do), Oo, Do])) return I3.error("Expected first argument to be of type array or string, but found " + Os(U.type) + " instead");\n                  if (y3.length === 4) {\n                    var ae = I3.parse(y3[3], 3, aa);\n                    return ae ? new fc(U.type, U, $2, ae) : null;\n                  } else return new fc(U.type, U, $2);\n                }, fc.prototype.evaluate = function(y3) {\n                  var I3 = this.input.evaluate(y3), U = this.beginIndex.evaluate(y3);\n                  if (!sc(I3, ["string", "array"])) throw new ps("Expected first argument to be of type array or string, but found " + Os(Es(I3)) + " instead.");\n                  if (this.endIndex) {\n                    var $2 = this.endIndex.evaluate(y3);\n                    return I3.slice(U, $2);\n                  }\n                  return I3.slice(U);\n                }, fc.prototype.eachChild = function(y3) {\n                  y3(this.input), y3(this.beginIndex), this.endIndex && y3(this.endIndex);\n                }, fc.prototype.outputDefined = function() {\n                  return false;\n                }, fc.prototype.serialize = function() {\n                  if (this.endIndex != null && this.endIndex !== void 0) {\n                    var y3 = this.endIndex.serialize();\n                    return ["slice", this.input.serialize(), this.beginIndex.serialize(), y3];\n                  }\n                  return ["slice", this.input.serialize(), this.beginIndex.serialize()];\n                };\n                function Bc(m3, y3) {\n                  return m3 === "==" || m3 === "!=" ? y3.kind === "boolean" || y3.kind === "string" || y3.kind === "number" || y3.kind === "null" || y3.kind === "value" : y3.kind === "string" || y3.kind === "number" || y3.kind === "value";\n                }\n                function At(m3, y3, I3) {\n                  return y3 === I3;\n                }\n                function Wt(m3, y3, I3) {\n                  return y3 !== I3;\n                }\n                function Cr(m3, y3, I3) {\n                  return y3 < I3;\n                }\n                function Ar(m3, y3, I3) {\n                  return y3 > I3;\n                }\n                function Kr(m3, y3, I3) {\n                  return y3 <= I3;\n                }\n                function ki(m3, y3, I3) {\n                  return y3 >= I3;\n                }\n                function Xi(m3, y3, I3, U) {\n                  return U.compare(y3, I3) === 0;\n                }\n                function dn(m3, y3, I3, U) {\n                  return !Xi(m3, y3, I3, U);\n                }\n                function wn(m3, y3, I3, U) {\n                  return U.compare(y3, I3) < 0;\n                }\n                function Nn(m3, y3, I3, U) {\n                  return U.compare(y3, I3) > 0;\n                }\n                function Yi(m3, y3, I3, U) {\n                  return U.compare(y3, I3) <= 0;\n                }\n                function Qi(m3, y3, I3, U) {\n                  return U.compare(y3, I3) >= 0;\n                }\n                function on(m3, y3, I3) {\n                  var U = m3 !== "==" && m3 !== "!=";\n                  return (function() {\n                    function $2(ae, he, Oe) {\n                      this.type = qo, this.lhs = ae, this.rhs = he, this.collator = Oe, this.hasUntypedArgument = ae.type.kind === "value" || he.type.kind === "value";\n                    }\n                    return $2.parse = function(he, Oe) {\n                      if (he.length !== 3 && he.length !== 4) return Oe.error("Expected two or three arguments.");\n                      var rt = he[0], gt = Oe.parse(he[1], 1, Do);\n                      if (!gt) return null;\n                      if (!Bc(rt, gt.type)) return Oe.concat(1).error(\'"\' + rt + `" comparisons are not supported for type \'` + Os(gt.type) + "\'.");\n                      var Et = Oe.parse(he[2], 2, Do);\n                      if (!Et) return null;\n                      if (!Bc(rt, Et.type)) return Oe.concat(2).error(\'"\' + rt + `" comparisons are not supported for type \'` + Os(Et.type) + "\'.");\n                      if (gt.type.kind !== Et.type.kind && gt.type.kind !== "value" && Et.type.kind !== "value") return Oe.error("Cannot compare types \'" + Os(gt.type) + "\' and \'" + Os(Et.type) + "\'.");\n                      U && (gt.type.kind === "value" && Et.type.kind !== "value" ? gt = new xl(Et.type, [gt]) : gt.type.kind !== "value" && Et.type.kind === "value" && (Et = new xl(gt.type, [Et])));\n                      var or = null;\n                      if (he.length === 4) {\n                        if (gt.type.kind !== "string" && Et.type.kind !== "string" && gt.type.kind !== "value" && Et.type.kind !== "value") return Oe.error("Cannot use collator to compare non-string types.");\n                        if (or = Oe.parse(he[3], 3, Uf), !or) return null;\n                      }\n                      return new $2(gt, Et, or);\n                    }, $2.prototype.evaluate = function(he) {\n                      var Oe = this.lhs.evaluate(he), rt = this.rhs.evaluate(he);\n                      if (U && this.hasUntypedArgument) {\n                        var gt = Es(Oe), Et = Es(rt);\n                        if (gt.kind !== Et.kind || !(gt.kind === "string" || gt.kind === "number")) throw new ps(\'Expected arguments for "\' + m3 + \'" to be (string, string) or (number, number), but found (\' + gt.kind + ", " + Et.kind + ") instead.");\n                      }\n                      if (this.collator && !U && this.hasUntypedArgument) {\n                        var or = Es(Oe), _r = Es(rt);\n                        if (or.kind !== "string" || _r.kind !== "string") return y3(he, Oe, rt);\n                      }\n                      return this.collator ? I3(he, Oe, rt, this.collator.evaluate(he)) : y3(he, Oe, rt);\n                    }, $2.prototype.eachChild = function(he) {\n                      he(this.lhs), he(this.rhs), this.collator && he(this.collator);\n                    }, $2.prototype.outputDefined = function() {\n                      return true;\n                    }, $2.prototype.serialize = function() {\n                      var he = [m3];\n                      return this.eachChild(function(Oe) {\n                        he.push(Oe.serialize());\n                      }), he;\n                    }, $2;\n                  })();\n                }\n                var Fi = on("==", At, Xi), $n = on("!=", Wt, dn), Ca = on("<", Cr, wn), Ra = on(">", Ar, Nn), La = on("<=", Kr, Yi), Na = on(">=", ki, Qi), Yn = function(y3, I3, U, $2, ae) {\n                  this.type = Oo, this.number = y3, this.locale = I3, this.currency = U, this.minFractionDigits = $2, this.maxFractionDigits = ae;\n                };\n                Yn.parse = function(y3, I3) {\n                  if (y3.length !== 3) return I3.error("Expected two arguments.");\n                  var U = I3.parse(y3[1], 1, aa);\n                  if (!U) return null;\n                  var $2 = y3[2];\n                  if (typeof $2 != "object" || Array.isArray($2)) return I3.error("NumberFormat options argument must be an object.");\n                  var ae = null;\n                  if ($2.locale && (ae = I3.parse($2.locale, 1, Oo), !ae)) return null;\n                  var he = null;\n                  if ($2.currency && (he = I3.parse($2.currency, 1, Oo), !he)) return null;\n                  var Oe = null;\n                  if ($2["min-fraction-digits"] && (Oe = I3.parse($2["min-fraction-digits"], 1, aa), !Oe)) return null;\n                  var rt = null;\n                  return $2["max-fraction-digits"] && (rt = I3.parse($2["max-fraction-digits"], 1, aa), !rt) ? null : new Yn(U, ae, he, Oe, rt);\n                }, Yn.prototype.evaluate = function(y3) {\n                  return new Intl.NumberFormat(this.locale ? this.locale.evaluate(y3) : [], { style: this.currency ? "currency" : "decimal", currency: this.currency ? this.currency.evaluate(y3) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(y3) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(y3) : void 0 }).format(this.number.evaluate(y3));\n                }, Yn.prototype.eachChild = function(y3) {\n                  y3(this.number), this.locale && y3(this.locale), this.currency && y3(this.currency), this.minFractionDigits && y3(this.minFractionDigits), this.maxFractionDigits && y3(this.maxFractionDigits);\n                }, Yn.prototype.outputDefined = function() {\n                  return false;\n                }, Yn.prototype.serialize = function() {\n                  var y3 = {};\n                  return this.locale && (y3.locale = this.locale.serialize()), this.currency && (y3.currency = this.currency.serialize()), this.minFractionDigits && (y3["min-fraction-digits"] = this.minFractionDigits.serialize()), this.maxFractionDigits && (y3["max-fraction-digits"] = this.maxFractionDigits.serialize()), ["number-format", this.number.serialize(), y3];\n                };\n                var Dn = function(y3) {\n                  this.type = aa, this.input = y3;\n                };\n                Dn.parse = function(y3, I3) {\n                  if (y3.length !== 2) return I3.error("Expected 1 argument, but found " + (y3.length - 1) + " instead.");\n                  var U = I3.parse(y3[1], 1);\n                  return U ? U.type.kind !== "array" && U.type.kind !== "string" && U.type.kind !== "value" ? I3.error("Expected argument of type string or array, but found " + Os(U.type) + " instead.") : new Dn(U) : null;\n                }, Dn.prototype.evaluate = function(y3) {\n                  var I3 = this.input.evaluate(y3);\n                  if (typeof I3 == "string") return I3.length;\n                  if (Array.isArray(I3)) return I3.length;\n                  throw new ps("Expected value to be of type string or array, but found " + Os(Es(I3)) + " instead.");\n                }, Dn.prototype.eachChild = function(y3) {\n                  y3(this.input);\n                }, Dn.prototype.outputDefined = function() {\n                  return false;\n                }, Dn.prototype.serialize = function() {\n                  var y3 = ["length"];\n                  return this.eachChild(function(I3) {\n                    y3.push(I3.serialize());\n                  }), y3;\n                };\n                var Ka = { "==": Fi, "!=": $n, ">": Ra, "<": Ca, ">=": Na, "<=": La, array: xl, at: Tc, boolean: xl, case: cf, coalesce: Zu, collator: Hu, format: Gu, image: qs, in: wl, "index-of": vu, interpolate: Wl, "interpolate-hcl": Wl, "interpolate-lab": Wl, length: Dn, let: Oc, literal: Go, match: qc, number: xl, "number-format": Yn, object: xl, slice: fc, step: _u, string: xl, "to-boolean": Po, "to-color": Po, "to-number": Po, "to-string": Po, var: Dc, within: Mu };\n                function bo(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = y3[2], ae = y3[3];\n                  I3 = I3.evaluate(m3), U = U.evaluate(m3), $2 = $2.evaluate(m3);\n                  var he = ae ? ae.evaluate(m3) : 1, Oe = lc(I3, U, $2, he);\n                  if (Oe) throw new ps(Oe);\n                  return new cs(I3 / 255 * he, U / 255 * he, $2 / 255 * he, he);\n                }\n                function Xo(m3, y3) {\n                  return m3 in y3;\n                }\n                function Ss(m3, y3) {\n                  var I3 = y3[m3];\n                  return typeof I3 == "undefined" ? null : I3;\n                }\n                function as(m3, y3, I3, U) {\n                  for (; I3 <= U; ) {\n                    var $2 = I3 + U >> 1;\n                    if (y3[$2] === m3) return true;\n                    y3[$2] > m3 ? U = $2 - 1 : I3 = $2 + 1;\n                  }\n                  return false;\n                }\n                function ws(m3) {\n                  return { type: m3 };\n                }\n                Pa.register(Ka, { error: [rf, [Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  throw new ps(I3.evaluate(m3));\n                }], typeof: [Oo, [Do], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Os(Es(I3.evaluate(m3)));\n                }], "to-rgba": [Kl(aa, 4), [ql], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.evaluate(m3).toArray();\n                }], rgb: [ql, [aa, aa, aa], bo], rgba: [ql, [aa, aa, aa, aa], bo], has: { type: qo, overloads: [[[Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Xo(I3.evaluate(m3), m3.properties());\n                }], [[Oo, Pc], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return Xo(I3.evaluate(m3), U.evaluate(m3));\n                }]] }, get: { type: Do, overloads: [[[Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Ss(I3.evaluate(m3), m3.properties());\n                }], [[Oo, Pc], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return Ss(I3.evaluate(m3), U.evaluate(m3));\n                }]] }, "feature-state": [Do, [Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Ss(I3.evaluate(m3), m3.featureState || {});\n                }], properties: [Pc, [], function(m3) {\n                  return m3.properties();\n                }], "geometry-type": [Oo, [], function(m3) {\n                  return m3.geometryType();\n                }], id: [Do, [], function(m3) {\n                  return m3.id();\n                }], zoom: [aa, [], function(m3) {\n                  return m3.globals.zoom;\n                }], "heatmap-density": [aa, [], function(m3) {\n                  return m3.globals.heatmapDensity || 0;\n                }], "line-progress": [aa, [], function(m3) {\n                  return m3.globals.lineProgress || 0;\n                }], accumulated: [Do, [], function(m3) {\n                  return m3.globals.accumulated === void 0 ? null : m3.globals.accumulated;\n                }], "+": [aa, ws(aa), function(m3, y3) {\n                  for (var I3 = 0, U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    I3 += ae.evaluate(m3);\n                  }\n                  return I3;\n                }], "*": [aa, ws(aa), function(m3, y3) {\n                  for (var I3 = 1, U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    I3 *= ae.evaluate(m3);\n                  }\n                  return I3;\n                }], "-": { type: aa, overloads: [[[aa, aa], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return I3.evaluate(m3) - U.evaluate(m3);\n                }], [[aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return -I3.evaluate(m3);\n                }]] }, "/": [aa, [aa, aa], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return I3.evaluate(m3) / U.evaluate(m3);\n                }], "%": [aa, [aa, aa], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return I3.evaluate(m3) % U.evaluate(m3);\n                }], ln2: [aa, [], function() {\n                  return Math.LN2;\n                }], pi: [aa, [], function() {\n                  return Math.PI;\n                }], e: [aa, [], function() {\n                  return Math.E;\n                }], "^": [aa, [aa, aa], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return Math.pow(I3.evaluate(m3), U.evaluate(m3));\n                }], sqrt: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.sqrt(I3.evaluate(m3));\n                }], log10: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.log(I3.evaluate(m3)) / Math.LN10;\n                }], ln: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.log(I3.evaluate(m3));\n                }], log2: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.log(I3.evaluate(m3)) / Math.LN2;\n                }], sin: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.sin(I3.evaluate(m3));\n                }], cos: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.cos(I3.evaluate(m3));\n                }], tan: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.tan(I3.evaluate(m3));\n                }], asin: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.asin(I3.evaluate(m3));\n                }], acos: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.acos(I3.evaluate(m3));\n                }], atan: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.atan(I3.evaluate(m3));\n                }], min: [aa, ws(aa), function(m3, y3) {\n                  return Math.min.apply(Math, y3.map(function(I3) {\n                    return I3.evaluate(m3);\n                  }));\n                }], max: [aa, ws(aa), function(m3, y3) {\n                  return Math.max.apply(Math, y3.map(function(I3) {\n                    return I3.evaluate(m3);\n                  }));\n                }], abs: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.abs(I3.evaluate(m3));\n                }], round: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0], U = I3.evaluate(m3);\n                  return U < 0 ? -Math.round(-U) : Math.round(U);\n                }], floor: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.floor(I3.evaluate(m3));\n                }], ceil: [aa, [aa], function(m3, y3) {\n                  var I3 = y3[0];\n                  return Math.ceil(I3.evaluate(m3));\n                }], "filter-==": [qo, [Oo, Do], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return m3.properties()[I3.value] === U.value;\n                }], "filter-id-==": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0];\n                  return m3.id() === I3.value;\n                }], "filter-type-==": [qo, [Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return m3.geometryType() === I3.value;\n                }], "filter-<": [qo, [Oo, Do], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = m3.properties()[I3.value], ae = U.value;\n                  return typeof $2 == typeof ae && $2 < ae;\n                }], "filter-id-<": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0], U = m3.id(), $2 = I3.value;\n                  return typeof U == typeof $2 && U < $2;\n                }], "filter->": [qo, [Oo, Do], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = m3.properties()[I3.value], ae = U.value;\n                  return typeof $2 == typeof ae && $2 > ae;\n                }], "filter-id->": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0], U = m3.id(), $2 = I3.value;\n                  return typeof U == typeof $2 && U > $2;\n                }], "filter-<=": [qo, [Oo, Do], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = m3.properties()[I3.value], ae = U.value;\n                  return typeof $2 == typeof ae && $2 <= ae;\n                }], "filter-id-<=": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0], U = m3.id(), $2 = I3.value;\n                  return typeof U == typeof $2 && U <= $2;\n                }], "filter->=": [qo, [Oo, Do], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = m3.properties()[I3.value], ae = U.value;\n                  return typeof $2 == typeof ae && $2 >= ae;\n                }], "filter-id->=": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0], U = m3.id(), $2 = I3.value;\n                  return typeof U == typeof $2 && U >= $2;\n                }], "filter-has": [qo, [Do], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.value in m3.properties();\n                }], "filter-has-id": [qo, [], function(m3) {\n                  return m3.id() !== null && m3.id() !== void 0;\n                }], "filter-type-in": [qo, [Kl(Oo)], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.value.indexOf(m3.geometryType()) >= 0;\n                }], "filter-id-in": [qo, [Kl(Do)], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.value.indexOf(m3.id()) >= 0;\n                }], "filter-in-small": [qo, [Oo, Kl(Do)], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return U.value.indexOf(m3.properties()[I3.value]) >= 0;\n                }], "filter-in-large": [qo, [Oo, Kl(Do)], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return as(m3.properties()[I3.value], U.value, 0, U.value.length - 1);\n                }], all: { type: qo, overloads: [[[qo, qo], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return I3.evaluate(m3) && U.evaluate(m3);\n                }], [ws(qo), function(m3, y3) {\n                  for (var I3 = 0, U = y3; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    if (!$2.evaluate(m3)) return false;\n                  }\n                  return true;\n                }]] }, any: { type: qo, overloads: [[[qo, qo], function(m3, y3) {\n                  var I3 = y3[0], U = y3[1];\n                  return I3.evaluate(m3) || U.evaluate(m3);\n                }], [ws(qo), function(m3, y3) {\n                  for (var I3 = 0, U = y3; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    if ($2.evaluate(m3)) return true;\n                  }\n                  return false;\n                }]] }, "!": [qo, [qo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return !I3.evaluate(m3);\n                }], "is-supported-script": [qo, [Oo], function(m3, y3) {\n                  var I3 = y3[0], U = m3.globals && m3.globals.isSupportedScript;\n                  return U ? U(I3.evaluate(m3)) : true;\n                }], upcase: [Oo, [Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.evaluate(m3).toUpperCase();\n                }], downcase: [Oo, [Oo], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.evaluate(m3).toLowerCase();\n                }], concat: [Oo, ws(Do), function(m3, y3) {\n                  return y3.map(function(I3) {\n                    return Hs(I3.evaluate(m3));\n                  }).join("");\n                }], "resolved-locale": [Oo, [Uf], function(m3, y3) {\n                  var I3 = y3[0];\n                  return I3.evaluate(m3).resolvedLocale();\n                }] });\n                function Ho(m3) {\n                  return { result: "success", value: m3 };\n                }\n                function ml(m3) {\n                  return { result: "error", value: m3 };\n                }\n                function Ws(m3) {\n                  return m3["property-type"] === "data-driven" || m3["property-type"] === "cross-faded-data-driven";\n                }\n                function Ls(m3) {\n                  return !!m3.expression && m3.expression.parameters.indexOf("zoom") > -1;\n                }\n                function va(m3) {\n                  return !!m3.expression && m3.expression.interpolated;\n                }\n                function no(m3) {\n                  return m3 instanceof Number ? "number" : m3 instanceof String ? "string" : m3 instanceof Boolean ? "boolean" : Array.isArray(m3) ? "array" : m3 === null ? "null" : typeof m3;\n                }\n                function ys(m3) {\n                  return typeof m3 == "object" && m3 !== null && !Array.isArray(m3);\n                }\n                function rs(m3) {\n                  return m3;\n                }\n                function $l(m3, y3) {\n                  var I3 = y3.type === "color", U = m3.stops && typeof m3.stops[0][0] == "object", $2 = U || m3.property !== void 0, ae = U || !$2, he = m3.type || (va(y3) ? "exponential" : "interval");\n                  if (I3 && (m3 = Ol({}, m3), m3.stops && (m3.stops = m3.stops.map(function(ha) {\n                    return [ha[0], cs.parse(ha[1])];\n                  })), m3.default ? m3.default = cs.parse(m3.default) : m3.default = cs.parse(y3.default)), m3.colorSpace && m3.colorSpace !== "rgb" && !Xf[m3.colorSpace]) throw new Error("Unknown color space: " + m3.colorSpace);\n                  var Oe, rt, gt;\n                  if (he === "exponential") Oe = pu;\n                  else if (he === "interval") Oe = Nc;\n                  else if (he === "categorical") {\n                    Oe = Yu, rt = /* @__PURE__ */ Object.create(null);\n                    for (var Et = 0, or = m3.stops; Et < or.length; Et += 1) {\n                      var _r = or[Et];\n                      rt[_r[0]] = _r[1];\n                    }\n                    gt = typeof m3.stops[0][0];\n                  } else if (he === "identity") Oe = Uc;\n                  else throw new Error(\'Unknown function type "\' + he + \'"\');\n                  if (U) {\n                    for (var pr = {}, Fr = [], oi = 0; oi < m3.stops.length; oi++) {\n                      var Hi = m3.stops[oi], Ai = Hi[0].zoom;\n                      pr[Ai] === void 0 && (pr[Ai] = { zoom: Ai, type: m3.type, property: m3.property, default: m3.default, stops: [] }, Fr.push(Ai)), pr[Ai].stops.push([Hi[0].value, Hi[1]]);\n                    }\n                    for (var bn = [], nn = 0, xn = Fr; nn < xn.length; nn += 1) {\n                      var Pn = xn[nn];\n                      bn.push([pr[Pn].zoom, $l(pr[Pn], y3)]);\n                    }\n                    var Zn = { name: "linear" };\n                    return { kind: "composite", interpolationType: Zn, interpolationFactor: Wl.interpolationFactor.bind(void 0, Zn), zoomStops: bn.map(function(ha) {\n                      return ha[0];\n                    }), evaluate: function(eo, za) {\n                      var Za = eo.zoom;\n                      return pu({ stops: bn, base: m3.base }, y3, Za).evaluate(Za, za);\n                    } };\n                  } else if (ae) {\n                    var ga = he === "exponential" ? { name: "exponential", base: m3.base !== void 0 ? m3.base : 1 } : null;\n                    return { kind: "camera", interpolationType: ga, interpolationFactor: Wl.interpolationFactor.bind(void 0, ga), zoomStops: m3.stops.map(function(ha) {\n                      return ha[0];\n                    }), evaluate: function(ha) {\n                      var eo = ha.zoom;\n                      return Oe(m3, y3, eo, rt, gt);\n                    } };\n                  } else return { kind: "source", evaluate: function(eo, za) {\n                    var Za = za && za.properties ? za.properties[m3.property] : void 0;\n                    return Za === void 0 ? Cu(m3.default, y3.default) : Oe(m3, y3, Za, rt, gt);\n                  } };\n                }\n                function Cu(m3, y3, I3) {\n                  if (m3 !== void 0) return m3;\n                  if (y3 !== void 0) return y3;\n                  if (I3 !== void 0) return I3;\n                }\n                function Yu(m3, y3, I3, U, $2) {\n                  var ae = typeof I3 === $2 ? U[I3] : void 0;\n                  return Cu(ae, m3.default, y3.default);\n                }\n                function Nc(m3, y3, I3) {\n                  if (no(I3) !== "number") return Cu(m3.default, y3.default);\n                  var U = m3.stops.length;\n                  if (U === 1 || I3 <= m3.stops[0][0]) return m3.stops[0][1];\n                  if (I3 >= m3.stops[U - 1][0]) return m3.stops[U - 1][1];\n                  var $2 = hu(m3.stops.map(function(ae) {\n                    return ae[0];\n                  }), I3);\n                  return m3.stops[$2][1];\n                }\n                function pu(m3, y3, I3) {\n                  var U = m3.base !== void 0 ? m3.base : 1;\n                  if (no(I3) !== "number") return Cu(m3.default, y3.default);\n                  var $2 = m3.stops.length;\n                  if ($2 === 1 || I3 <= m3.stops[0][0]) return m3.stops[0][1];\n                  if (I3 >= m3.stops[$2 - 1][0]) return m3.stops[$2 - 1][1];\n                  var ae = hu(m3.stops.map(function(or) {\n                    return or[0];\n                  }), I3), he = xu(I3, U, m3.stops[ae][0], m3.stops[ae + 1][0]), Oe = m3.stops[ae][1], rt = m3.stops[ae + 1][1], gt = zu[y3.type] || rs;\n                  if (m3.colorSpace && m3.colorSpace !== "rgb") {\n                    var Et = Xf[m3.colorSpace];\n                    gt = function(or, _r) {\n                      return Et.reverse(Et.interpolate(Et.forward(or), Et.forward(_r), he));\n                    };\n                  }\n                  return typeof Oe.evaluate == "function" ? { evaluate: function() {\n                    for (var _r = [], pr = arguments.length; pr--; ) _r[pr] = arguments[pr];\n                    var Fr = Oe.evaluate.apply(void 0, _r), oi = rt.evaluate.apply(void 0, _r);\n                    if (!(Fr === void 0 || oi === void 0)) return gt(Fr, oi, he);\n                  } } : gt(Oe, rt, he);\n                }\n                function Uc(m3, y3, I3) {\n                  return y3.type === "color" ? I3 = cs.parse(I3) : y3.type === "formatted" ? I3 = Jl.fromString(I3.toString()) : y3.type === "resolvedImage" ? I3 = fl.fromString(I3.toString()) : no(I3) !== y3.type && (y3.type !== "enum" || !y3.values[I3]) && (I3 = void 0), Cu(I3, m3.default, y3.default);\n                }\n                function xu(m3, y3, I3, U) {\n                  var $2 = U - I3, ae = m3 - I3;\n                  return $2 === 0 ? 0 : y3 === 1 ? ae / $2 : (Math.pow(y3, ae) - 1) / (Math.pow(y3, $2) - 1);\n                }\n                var Ac = function(y3, I3) {\n                  this.expression = y3, this._warningHistory = {}, this._evaluator = new Yo(), this._defaultValue = I3 ? ee(I3) : null, this._enumValues = I3 && I3.type === "enum" ? I3.values : null;\n                };\n                Ac.prototype.evaluateWithoutErrorHandling = function(y3, I3, U, $2, ae, he) {\n                  return this._evaluator.globals = y3, this._evaluator.feature = I3, this._evaluator.featureState = U, this._evaluator.canonical = $2, this._evaluator.availableImages = ae || null, this._evaluator.formattedSection = he, this.expression.evaluate(this._evaluator);\n                }, Ac.prototype.evaluate = function(y3, I3, U, $2, ae, he) {\n                  this._evaluator.globals = y3, this._evaluator.feature = I3 || null, this._evaluator.featureState = U || null, this._evaluator.canonical = $2, this._evaluator.availableImages = ae || null, this._evaluator.formattedSection = he || null;\n                  try {\n                    var Oe = this.expression.evaluate(this._evaluator);\n                    if (Oe == null || typeof Oe == "number" && Oe !== Oe) return this._defaultValue;\n                    if (this._enumValues && !(Oe in this._enumValues)) throw new ps("Expected value to be one of " + Object.keys(this._enumValues).map(function(rt) {\n                      return JSON.stringify(rt);\n                    }).join(", ") + ", but found " + JSON.stringify(Oe) + " instead.");\n                    return Oe;\n                  } catch (rt) {\n                    return this._warningHistory[rt.message] || (this._warningHistory[rt.message] = true, typeof console != "undefined" && console.warn(rt.message)), this._defaultValue;\n                  }\n                };\n                function Ua(m3) {\n                  return Array.isArray(m3) && m3.length > 0 && typeof m3[0] == "string" && m3[0] in Ka;\n                }\n                function oo(m3, y3) {\n                  var I3 = new ks(Ka, [], y3 ? Q(y3) : void 0), U = I3.parse(m3, void 0, void 0, void 0, y3 && y3.type === "string" ? { typeAnnotation: "coerce" } : void 0);\n                  return U ? Ho(new Ac(U, y3)) : ml(I3.errors);\n                }\n                var Vc = function(y3, I3) {\n                  this.kind = y3, this._styleExpression = I3, this.isStateDependent = y3 !== "constant" && !js(I3.expression);\n                };\n                Vc.prototype.evaluateWithoutErrorHandling = function(y3, I3, U, $2, ae, he) {\n                  return this._styleExpression.evaluateWithoutErrorHandling(y3, I3, U, $2, ae, he);\n                }, Vc.prototype.evaluate = function(y3, I3, U, $2, ae, he) {\n                  return this._styleExpression.evaluate(y3, I3, U, $2, ae, he);\n                };\n                var hc = function(y3, I3, U, $2) {\n                  this.kind = y3, this.zoomStops = U, this._styleExpression = I3, this.isStateDependent = y3 !== "camera" && !js(I3.expression), this.interpolationType = $2;\n                };\n                hc.prototype.evaluateWithoutErrorHandling = function(y3, I3, U, $2, ae, he) {\n                  return this._styleExpression.evaluateWithoutErrorHandling(y3, I3, U, $2, ae, he);\n                }, hc.prototype.evaluate = function(y3, I3, U, $2, ae, he) {\n                  return this._styleExpression.evaluate(y3, I3, U, $2, ae, he);\n                }, hc.prototype.interpolationFactor = function(y3, I3, U) {\n                  return this.interpolationType ? Wl.interpolationFactor(this.interpolationType, y3, I3, U) : 0;\n                };\n                function Ku(m3, y3) {\n                  if (m3 = oo(m3, y3), m3.result === "error") return m3;\n                  var I3 = m3.value.expression, U = ih(I3);\n                  if (!U && !Ws(y3)) return ml([new Ns("", "data expressions not supported")]);\n                  var $2 = Eu(I3, ["zoom"]);\n                  if (!$2 && !Ls(y3)) return ml([new Ns("", "zoom expressions not supported")]);\n                  var ae = B4(I3);\n                  if (!ae && !$2) return ml([new Ns("", \'"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.\')]);\n                  if (ae instanceof Ns) return ml([ae]);\n                  if (ae instanceof Wl && !va(y3)) return ml([new Ns("", \'"interpolate" expressions cannot be used with this property\')]);\n                  if (!ae) return Ho(U ? new Vc("constant", m3.value) : new Vc("source", m3.value));\n                  var he = ae instanceof Wl ? ae.interpolation : void 0;\n                  return Ho(U ? new hc("camera", m3.value, ae.labels, he) : new hc("composite", m3.value, ae.labels, he));\n                }\n                var ue = function(y3, I3) {\n                  this._parameters = y3, this._specification = I3, Ol(this, $l(this._parameters, this._specification));\n                };\n                ue.deserialize = function(y3) {\n                  return new ue(y3._parameters, y3._specification);\n                }, ue.serialize = function(y3) {\n                  return { _parameters: y3._parameters, _specification: y3._specification };\n                };\n                function w4(m3, y3) {\n                  if (ys(m3)) return new ue(m3, y3);\n                  if (Ua(m3)) {\n                    var I3 = Ku(m3, y3);\n                    if (I3.result === "error") throw new Error(I3.value.map(function($2) {\n                      return $2.key + ": " + $2.message;\n                    }).join(", "));\n                    return I3.value;\n                  } else {\n                    var U = m3;\n                    return typeof m3 == "string" && y3.type === "color" && (U = cs.parse(m3)), { kind: "constant", evaluate: function() {\n                      return U;\n                    } };\n                  }\n                }\n                function B4(m3) {\n                  var y3 = null;\n                  if (m3 instanceof Oc) y3 = B4(m3.result);\n                  else if (m3 instanceof Zu) for (var I3 = 0, U = m3.args; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    if (y3 = B4($2), y3) break;\n                  }\n                  else (m3 instanceof _u || m3 instanceof Wl) && m3.input instanceof Pa && m3.input.name === "zoom" && (y3 = m3);\n                  return y3 instanceof Ns || m3.eachChild(function(ae) {\n                    var he = B4(ae);\n                    he instanceof Ns ? y3 = he : !y3 && he ? y3 = new Ns("", \'"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.\') : y3 && he && y3 !== he && (y3 = new Ns("", \'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.\'));\n                  }), y3;\n                }\n                function Q(m3) {\n                  var y3 = { color: ql, string: Oo, number: aa, enum: Oo, boolean: qo, formatted: pl, resolvedImage: Zc };\n                  return m3.type === "array" ? Kl(y3[m3.value] || Do, m3.length) : y3[m3.type];\n                }\n                function ee(m3) {\n                  return m3.type === "color" && ys(m3.default) ? new cs(0, 0, 0, 0) : m3.type === "color" ? cs.parse(m3.default) || null : m3.default === void 0 ? null : m3.default;\n                }\n                function le(m3) {\n                  var y3 = m3.key, I3 = m3.value, U = m3.valueSpec || {}, $2 = m3.objectElementValidators || {}, ae = m3.style, he = m3.styleSpec, Oe = [], rt = no(I3);\n                  if (rt !== "object") return [new _a(y3, I3, "object expected, " + rt + " found")];\n                  for (var gt in I3) {\n                    var Et = gt.split(".")[0], or = U[Et] || U["*"], _r = void 0;\n                    if ($2[Et]) _r = $2[Et];\n                    else if (U[Et]) _r = Qa;\n                    else if ($2["*"]) _r = $2["*"];\n                    else if (U["*"]) _r = Qa;\n                    else {\n                      Oe.push(new _a(y3, I3[gt], \'unknown property "\' + gt + \'"\'));\n                      continue;\n                    }\n                    Oe = Oe.concat(_r({ key: (y3 && y3 + ".") + gt, value: I3[gt], valueSpec: or, style: ae, styleSpec: he, object: I3, objectKey: gt }, I3));\n                  }\n                  for (var pr in U) $2[pr] || U[pr].required && U[pr].default === void 0 && I3[pr] === void 0 && Oe.push(new _a(y3, I3, \'missing required property "\' + pr + \'"\'));\n                  return Oe;\n                }\n                function qe(m3) {\n                  var y3 = m3.value, I3 = m3.valueSpec, U = m3.style, $2 = m3.styleSpec, ae = m3.key, he = m3.arrayElementValidator || Qa;\n                  if (no(y3) !== "array") return [new _a(ae, y3, "array expected, " + no(y3) + " found")];\n                  if (I3.length && y3.length !== I3.length) return [new _a(ae, y3, "array length " + I3.length + " expected, length " + y3.length + " found")];\n                  if (I3["min-length"] && y3.length < I3["min-length"]) return [new _a(ae, y3, "array length at least " + I3["min-length"] + " expected, length " + y3.length + " found")];\n                  var Oe = { type: I3.value, values: I3.values };\n                  $2.$version < 7 && (Oe.function = I3.function), no(I3.value) === "object" && (Oe = I3.value);\n                  for (var rt = [], gt = 0; gt < y3.length; gt++) rt = rt.concat(he({ array: y3, arrayIndex: gt, value: y3[gt], valueSpec: Oe, style: U, styleSpec: $2, key: ae + "[" + gt + "]" }));\n                  return rt;\n                }\n                function Xe(m3) {\n                  var y3 = m3.key, I3 = m3.value, U = m3.valueSpec, $2 = no(I3);\n                  return $2 === "number" && I3 !== I3 && ($2 = "NaN"), $2 !== "number" ? [new _a(y3, I3, "number expected, " + $2 + " found")] : "minimum" in U && I3 < U.minimum ? [new _a(y3, I3, I3 + " is less than the minimum value " + U.minimum)] : "maximum" in U && I3 > U.maximum ? [new _a(y3, I3, I3 + " is greater than the maximum value " + U.maximum)] : [];\n                }\n                function ot(m3) {\n                  var y3 = m3.valueSpec, I3 = xo(m3.value.type), U, $2 = {}, ae, he, Oe = I3 !== "categorical" && m3.value.property === void 0, rt = !Oe, gt = no(m3.value.stops) === "array" && no(m3.value.stops[0]) === "array" && no(m3.value.stops[0][0]) === "object", Et = le({ key: m3.key, value: m3.value, valueSpec: m3.styleSpec.function, style: m3.style, styleSpec: m3.styleSpec, objectElementValidators: { stops: or, default: Fr } });\n                  return I3 === "identity" && Oe && Et.push(new _a(m3.key, m3.value, \'missing required property "property"\')), I3 !== "identity" && !m3.value.stops && Et.push(new _a(m3.key, m3.value, \'missing required property "stops"\')), I3 === "exponential" && m3.valueSpec.expression && !va(m3.valueSpec) && Et.push(new _a(m3.key, m3.value, "exponential functions not supported")), m3.styleSpec.$version >= 8 && (rt && !Ws(m3.valueSpec) ? Et.push(new _a(m3.key, m3.value, "property functions not supported")) : Oe && !Ls(m3.valueSpec) && Et.push(new _a(m3.key, m3.value, "zoom functions not supported"))), (I3 === "categorical" || gt) && m3.value.property === void 0 && Et.push(new _a(m3.key, m3.value, \'"property" property is required\')), Et;\n                  function or(oi) {\n                    if (I3 === "identity") return [new _a(oi.key, oi.value, \'identity function may not have a "stops" property\')];\n                    var Hi = [], Ai = oi.value;\n                    return Hi = Hi.concat(qe({ key: oi.key, value: Ai, valueSpec: oi.valueSpec, style: oi.style, styleSpec: oi.styleSpec, arrayElementValidator: _r })), no(Ai) === "array" && Ai.length === 0 && Hi.push(new _a(oi.key, Ai, "array must have at least one stop")), Hi;\n                  }\n                  function _r(oi) {\n                    var Hi = [], Ai = oi.value, bn = oi.key;\n                    if (no(Ai) !== "array") return [new _a(bn, Ai, "array expected, " + no(Ai) + " found")];\n                    if (Ai.length !== 2) return [new _a(bn, Ai, "array length 2 expected, length " + Ai.length + " found")];\n                    if (gt) {\n                      if (no(Ai[0]) !== "object") return [new _a(bn, Ai, "object expected, " + no(Ai[0]) + " found")];\n                      if (Ai[0].zoom === void 0) return [new _a(bn, Ai, "object stop key must have zoom")];\n                      if (Ai[0].value === void 0) return [new _a(bn, Ai, "object stop key must have value")];\n                      if (he && he > xo(Ai[0].zoom)) return [new _a(bn, Ai[0].zoom, "stop zoom values must appear in ascending order")];\n                      xo(Ai[0].zoom) !== he && (he = xo(Ai[0].zoom), ae = void 0, $2 = {}), Hi = Hi.concat(le({ key: bn + "[0]", value: Ai[0], valueSpec: { zoom: {} }, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { zoom: Xe, value: pr } }));\n                    } else Hi = Hi.concat(pr({ key: bn + "[0]", value: Ai[0], valueSpec: {}, style: oi.style, styleSpec: oi.styleSpec }, Ai));\n                    return Ua(Yl(Ai[1])) ? Hi.concat([new _a(bn + "[1]", Ai[1], "expressions are not allowed in function stops.")]) : Hi.concat(Qa({ key: bn + "[1]", value: Ai[1], valueSpec: y3, style: oi.style, styleSpec: oi.styleSpec }));\n                  }\n                  function pr(oi, Hi) {\n                    var Ai = no(oi.value), bn = xo(oi.value), nn = oi.value !== null ? oi.value : Hi;\n                    if (!U) U = Ai;\n                    else if (Ai !== U) return [new _a(oi.key, nn, Ai + " stop domain type must match previous stop domain type " + U)];\n                    if (Ai !== "number" && Ai !== "string" && Ai !== "boolean") return [new _a(oi.key, nn, "stop domain value must be a number, string, or boolean")];\n                    if (Ai !== "number" && I3 !== "categorical") {\n                      var xn = "number expected, " + Ai + " found";\n                      return Ws(y3) && I3 === void 0 && (xn += \'\\nIf you intended to use a categorical function, specify `"type": "categorical"`.\'), [new _a(oi.key, nn, xn)];\n                    }\n                    return I3 === "categorical" && Ai === "number" && (!isFinite(bn) || Math.floor(bn) !== bn) ? [new _a(oi.key, nn, "integer expected, found " + bn)] : I3 !== "categorical" && Ai === "number" && ae !== void 0 && bn < ae ? [new _a(oi.key, nn, "stop domain values must appear in ascending order")] : (ae = bn, I3 === "categorical" && bn in $2 ? [new _a(oi.key, nn, "stop domain values must be unique")] : ($2[bn] = true, []));\n                  }\n                  function Fr(oi) {\n                    return Qa({ key: oi.key, value: oi.value, valueSpec: y3, style: oi.style, styleSpec: oi.styleSpec });\n                  }\n                }\n                function Tt(m3) {\n                  var y3 = (m3.expressionContext === "property" ? Ku : oo)(Yl(m3.value), m3.valueSpec);\n                  if (y3.result === "error") return y3.value.map(function(U) {\n                    return new _a("" + m3.key + U.key, m3.value, U.message);\n                  });\n                  var I3 = y3.value.expression || y3.value._styleExpression.expression;\n                  if (m3.expressionContext === "property" && m3.propertyKey === "text-font" && !I3.outputDefined()) return [new _a(m3.key, m3.value, \'Invalid data expression for "\' + m3.propertyKey + \'". Output values must be contained as literals within the expression.\')];\n                  if (m3.expressionContext === "property" && m3.propertyType === "layout" && !js(I3)) return [new _a(m3.key, m3.value, \'"feature-state" data expressions are not supported with layout properties.\')];\n                  if (m3.expressionContext === "filter" && !js(I3)) return [new _a(m3.key, m3.value, \'"feature-state" data expressions are not supported with filters.\')];\n                  if (m3.expressionContext && m3.expressionContext.indexOf("cluster") === 0) {\n                    if (!Eu(I3, ["zoom", "feature-state"])) return [new _a(m3.key, m3.value, \'"zoom" and "feature-state" expressions are not supported with cluster properties.\')];\n                    if (m3.expressionContext === "cluster-initial" && !ih(I3)) return [new _a(m3.key, m3.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];\n                  }\n                  return [];\n                }\n                function Yt(m3) {\n                  var y3 = m3.value, I3 = m3.key, U = no(y3);\n                  return U !== "boolean" ? [new _a(I3, y3, "boolean expected, " + U + " found")] : [];\n                }\n                function Kt(m3) {\n                  var y3 = m3.key, I3 = m3.value, U = no(I3);\n                  return U !== "string" ? [new _a(y3, I3, "color expected, " + U + " found")] : Lf(I3) === null ? [new _a(y3, I3, \'color expected, "\' + I3 + \'" found\')] : [];\n                }\n                function xr(m3) {\n                  var y3 = m3.key, I3 = m3.value, U = m3.valueSpec, $2 = [];\n                  return Array.isArray(U.values) ? U.values.indexOf(xo(I3)) === -1 && $2.push(new _a(y3, I3, "expected one of [" + U.values.join(", ") + "], " + JSON.stringify(I3) + " found")) : Object.keys(U.values).indexOf(xo(I3)) === -1 && $2.push(new _a(y3, I3, "expected one of [" + Object.keys(U.values).join(", ") + "], " + JSON.stringify(I3) + " found")), $2;\n                }\n                function Ir(m3) {\n                  if (m3 === true || m3 === false) return true;\n                  if (!Array.isArray(m3) || m3.length === 0) return false;\n                  switch (m3[0]) {\n                    case "has":\n                      return m3.length >= 2 && m3[1] !== "$id" && m3[1] !== "$type";\n                    case "in":\n                      return m3.length >= 3 && (typeof m3[1] != "string" || Array.isArray(m3[2]));\n                    case "!in":\n                    case "!has":\n                    case "none":\n                      return false;\n                    case "==":\n                    case "!=":\n                    case ">":\n                    case ">=":\n                    case "<":\n                    case "<=":\n                      return m3.length !== 3 || Array.isArray(m3[1]) || Array.isArray(m3[2]);\n                    case "any":\n                    case "all":\n                      for (var y3 = 0, I3 = m3.slice(1); y3 < I3.length; y3 += 1) {\n                        var U = I3[y3];\n                        if (!Ir(U) && typeof U != "boolean") return false;\n                      }\n                      return true;\n                    default:\n                      return true;\n                  }\n                }\n                var ve = { type: "boolean", default: false, transition: false, "property-type": "data-driven", expression: { interpolated: false, parameters: ["zoom", "feature"] } };\n                function be(m3) {\n                  if (m3 == null) return { filter: function() {\n                    return true;\n                  }, needGeometry: false };\n                  Ir(m3) || (m3 = et(m3));\n                  var y3 = oo(m3, ve);\n                  if (y3.result === "error") throw new Error(y3.value.map(function(U) {\n                    return U.key + ": " + U.message;\n                  }).join(", "));\n                  var I3 = Be(m3);\n                  return { filter: function(U, $2, ae) {\n                    return y3.value.evaluate(U, $2, {}, ae);\n                  }, needGeometry: I3 };\n                }\n                function De(m3, y3) {\n                  return m3 < y3 ? -1 : m3 > y3 ? 1 : 0;\n                }\n                function Be(m3) {\n                  if (!Array.isArray(m3)) return false;\n                  if (m3[0] === "within") return true;\n                  for (var y3 = 1; y3 < m3.length; y3++) if (Be(m3[y3])) return true;\n                  return false;\n                }\n                function et(m3) {\n                  if (!m3) return true;\n                  var y3 = m3[0];\n                  if (m3.length <= 1) return y3 !== "any";\n                  var I3 = y3 === "==" ? We(m3[1], m3[2], "==") : y3 === "!=" ? tr(We(m3[1], m3[2], "==")) : y3 === "<" || y3 === ">" || y3 === "<=" || y3 === ">=" ? We(m3[1], m3[2], y3) : y3 === "any" ? it(m3.slice(1)) : y3 === "all" ? ["all"].concat(m3.slice(1).map(et)) : y3 === "none" ? ["all"].concat(m3.slice(1).map(et).map(tr)) : y3 === "in" ? Ft(m3[1], m3.slice(2)) : y3 === "!in" ? tr(Ft(m3[1], m3.slice(2))) : y3 === "has" ? Ht(m3[1]) : y3 === "!has" ? tr(Ht(m3[1])) : y3 === "within" ? m3 : true;\n                  return I3;\n                }\n                function We(m3, y3, I3) {\n                  switch (m3) {\n                    case "$type":\n                      return ["filter-type-" + I3, y3];\n                    case "$id":\n                      return ["filter-id-" + I3, y3];\n                    default:\n                      return ["filter-" + I3, m3, y3];\n                  }\n                }\n                function it(m3) {\n                  return ["any"].concat(m3.map(et));\n                }\n                function Ft(m3, y3) {\n                  if (y3.length === 0) return false;\n                  switch (m3) {\n                    case "$type":\n                      return ["filter-type-in", ["literal", y3]];\n                    case "$id":\n                      return ["filter-id-in", ["literal", y3]];\n                    default:\n                      return y3.length > 200 && !y3.some(function(I3) {\n                        return typeof I3 != typeof y3[0];\n                      }) ? ["filter-in-large", m3, ["literal", y3.sort(De)]] : ["filter-in-small", m3, ["literal", y3]];\n                  }\n                }\n                function Ht(m3) {\n                  switch (m3) {\n                    case "$type":\n                      return true;\n                    case "$id":\n                      return ["filter-has-id"];\n                    default:\n                      return ["filter-has", m3];\n                  }\n                }\n                function tr(m3) {\n                  return ["!", m3];\n                }\n                function dr(m3) {\n                  return Ir(Yl(m3.value)) ? Tt(Ol({}, m3, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Sr(m3);\n                }\n                function Sr(m3) {\n                  var y3 = m3.value, I3 = m3.key;\n                  if (no(y3) !== "array") return [new _a(I3, y3, "array expected, " + no(y3) + " found")];\n                  var U = m3.styleSpec, $2, ae = [];\n                  if (y3.length < 1) return [new _a(I3, y3, "filter array must have at least 1 element")];\n                  switch (ae = ae.concat(xr({ key: I3 + "[0]", value: y3[0], valueSpec: U.filter_operator, style: m3.style, styleSpec: m3.styleSpec })), xo(y3[0])) {\n                    case "<":\n                    case "<=":\n                    case ">":\n                    case ">=":\n                      y3.length >= 2 && xo(y3[1]) === "$type" && ae.push(new _a(I3, y3, \'"$type" cannot be use with operator "\' + y3[0] + \'"\'));\n                    case "==":\n                    case "!=":\n                      y3.length !== 3 && ae.push(new _a(I3, y3, \'filter array for operator "\' + y3[0] + \'" must have 3 elements\'));\n                    case "in":\n                    case "!in":\n                      y3.length >= 2 && ($2 = no(y3[1]), $2 !== "string" && ae.push(new _a(I3 + "[1]", y3[1], "string expected, " + $2 + " found")));\n                      for (var he = 2; he < y3.length; he++) $2 = no(y3[he]), xo(y3[1]) === "$type" ? ae = ae.concat(xr({ key: I3 + "[" + he + "]", value: y3[he], valueSpec: U.geometry_type, style: m3.style, styleSpec: m3.styleSpec })) : $2 !== "string" && $2 !== "number" && $2 !== "boolean" && ae.push(new _a(I3 + "[" + he + "]", y3[he], "string, number, or boolean expected, " + $2 + " found"));\n                      break;\n                    case "any":\n                    case "all":\n                    case "none":\n                      for (var Oe = 1; Oe < y3.length; Oe++) ae = ae.concat(Sr({ key: I3 + "[" + Oe + "]", value: y3[Oe], style: m3.style, styleSpec: m3.styleSpec }));\n                      break;\n                    case "has":\n                    case "!has":\n                      $2 = no(y3[1]), y3.length !== 2 ? ae.push(new _a(I3, y3, \'filter array for "\' + y3[0] + \'" operator must have 2 elements\')) : $2 !== "string" && ae.push(new _a(I3 + "[1]", y3[1], "string expected, " + $2 + " found"));\n                      break;\n                    case "within":\n                      $2 = no(y3[1]), y3.length !== 2 ? ae.push(new _a(I3, y3, \'filter array for "\' + y3[0] + \'" operator must have 2 elements\')) : $2 !== "object" && ae.push(new _a(I3 + "[1]", y3[1], "object expected, " + $2 + " found"));\n                      break;\n                  }\n                  return ae;\n                }\n                function Or(m3, y3) {\n                  var I3 = m3.key, U = m3.style, $2 = m3.styleSpec, ae = m3.value, he = m3.objectKey, Oe = $2[y3 + "_" + m3.layerType];\n                  if (!Oe) return [];\n                  var rt = he.match(/^(.*)-transition$/);\n                  if (y3 === "paint" && rt && Oe[rt[1]] && Oe[rt[1]].transition) return Qa({ key: I3, value: ae, valueSpec: $2.transition, style: U, styleSpec: $2 });\n                  var gt = m3.valueSpec || Oe[he];\n                  if (!gt) return [new _a(I3, ae, \'unknown property "\' + he + \'"\')];\n                  var Et;\n                  if (no(ae) === "string" && Ws(gt) && !gt.tokens && (Et = /^{([^}]+)}$/.exec(ae))) return [new _a(I3, ae, \'"\' + he + \'" does not support interpolation syntax\\nUse an identity property function instead: `{ "type": "identity", "property": \' + JSON.stringify(Et[1]) + " }`.")];\n                  var or = [];\n                  return m3.layerType === "symbol" && (he === "text-field" && U && !U.glyphs && or.push(new _a(I3, ae, \'use of "text-field" requires a style "glyphs" property\')), he === "text-font" && ys(Yl(ae)) && xo(ae.type) === "identity" && or.push(new _a(I3, ae, \'"text-font" does not support identity functions\'))), or.concat(Qa({ key: m3.key, value: ae, valueSpec: gt, style: U, styleSpec: $2, expressionContext: "property", propertyType: y3, propertyKey: he }));\n                }\n                function Wr(m3) {\n                  return Or(m3, "paint");\n                }\n                function ni(m3) {\n                  return Or(m3, "layout");\n                }\n                function Pi(m3) {\n                  var y3 = [], I3 = m3.value, U = m3.key, $2 = m3.style, ae = m3.styleSpec;\n                  !I3.type && !I3.ref && y3.push(new _a(U, I3, \'either "type" or "ref" is required\'));\n                  var he = xo(I3.type), Oe = xo(I3.ref);\n                  if (I3.id) for (var rt = xo(I3.id), gt = 0; gt < m3.arrayIndex; gt++) {\n                    var Et = $2.layers[gt];\n                    xo(Et.id) === rt && y3.push(new _a(U, I3.id, \'duplicate layer id "\' + I3.id + \'", previously used at line \' + Et.id.__line__));\n                  }\n                  if ("ref" in I3) {\n                    ["type", "source", "source-layer", "filter", "layout"].forEach(function(Fr) {\n                      Fr in I3 && y3.push(new _a(U, I3[Fr], \'"\' + Fr + \'" is prohibited for ref layers\'));\n                    });\n                    var or;\n                    $2.layers.forEach(function(Fr) {\n                      xo(Fr.id) === Oe && (or = Fr);\n                    }), or ? or.ref ? y3.push(new _a(U, I3.ref, "ref cannot reference another ref layer")) : he = xo(or.type) : y3.push(new _a(U, I3.ref, \'ref layer "\' + Oe + \'" not found\'));\n                  } else if (he !== "background") if (!I3.source) y3.push(new _a(U, I3, \'missing required property "source"\'));\n                  else {\n                    var _r = $2.sources && $2.sources[I3.source], pr = _r && xo(_r.type);\n                    _r ? pr === "vector" && he === "raster" ? y3.push(new _a(U, I3.source, \'layer "\' + I3.id + \'" requires a raster source\')) : pr === "raster" && he !== "raster" ? y3.push(new _a(U, I3.source, \'layer "\' + I3.id + \'" requires a vector source\')) : pr === "vector" && !I3["source-layer"] ? y3.push(new _a(U, I3, \'layer "\' + I3.id + \'" must specify a "source-layer"\')) : pr === "raster-dem" && he !== "hillshade" ? y3.push(new _a(U, I3.source, "raster-dem source can only be used with layer type \'hillshade\'.")) : he === "line" && I3.paint && I3.paint["line-gradient"] && (pr !== "geojson" || !_r.lineMetrics) && y3.push(new _a(U, I3, \'layer "\' + I3.id + \'" specifies a line-gradient, which requires a GeoJSON source with `lineMetrics` enabled.\')) : y3.push(new _a(U, I3.source, \'source "\' + I3.source + \'" not found\'));\n                  }\n                  return y3 = y3.concat(le({ key: U, value: I3, valueSpec: ae.layer, style: m3.style, styleSpec: m3.styleSpec, objectElementValidators: { "*": function() {\n                    return [];\n                  }, type: function() {\n                    return Qa({ key: U + ".type", value: I3.type, valueSpec: ae.layer.type, style: m3.style, styleSpec: m3.styleSpec, object: I3, objectKey: "type" });\n                  }, filter: dr, layout: function(oi) {\n                    return le({ layer: I3, key: oi.key, value: oi.value, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { "*": function(Ai) {\n                      return ni(Ol({ layerType: he }, Ai));\n                    } } });\n                  }, paint: function(oi) {\n                    return le({ layer: I3, key: oi.key, value: oi.value, style: oi.style, styleSpec: oi.styleSpec, objectElementValidators: { "*": function(Ai) {\n                      return Wr(Ol({ layerType: he }, Ai));\n                    } } });\n                  } } })), y3;\n                }\n                function cn(m3) {\n                  var y3 = m3.value, I3 = m3.key, U = no(y3);\n                  return U !== "string" ? [new _a(I3, y3, "string expected, " + U + " found")] : [];\n                }\n                var ln = { promoteId: Kn };\n                function Cn(m3) {\n                  var y3 = m3.value, I3 = m3.key, U = m3.styleSpec, $2 = m3.style;\n                  if (!y3.type) return [new _a(I3, y3, \'"type" is required\')];\n                  var ae = xo(y3.type), he;\n                  switch (ae) {\n                    case "vector":\n                    case "raster":\n                    case "raster-dem":\n                      return he = le({ key: I3, value: y3, valueSpec: U["source_" + ae.replace("-", "_")], style: m3.style, styleSpec: U, objectElementValidators: ln }), he;\n                    case "geojson":\n                      if (he = le({ key: I3, value: y3, valueSpec: U.source_geojson, style: $2, styleSpec: U, objectElementValidators: ln }), y3.cluster) for (var Oe in y3.clusterProperties) {\n                        var rt = y3.clusterProperties[Oe], gt = rt[0], Et = rt[1], or = typeof gt == "string" ? [gt, ["accumulated"], ["get", Oe]] : gt;\n                        he.push.apply(he, Tt({ key: I3 + "." + Oe + ".map", value: Et, expressionContext: "cluster-map" })), he.push.apply(he, Tt({ key: I3 + "." + Oe + ".reduce", value: or, expressionContext: "cluster-reduce" }));\n                      }\n                      return he;\n                    case "video":\n                      return le({ key: I3, value: y3, valueSpec: U.source_video, style: $2, styleSpec: U });\n                    case "image":\n                      return le({ key: I3, value: y3, valueSpec: U.source_image, style: $2, styleSpec: U });\n                    case "canvas":\n                      return [new _a(I3, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];\n                    default:\n                      return xr({ key: I3 + ".type", value: y3.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] }, style: $2, styleSpec: U });\n                  }\n                }\n                function Kn(m3) {\n                  var y3 = m3.key, I3 = m3.value;\n                  if (no(I3) === "string") return cn({ key: y3, value: I3 });\n                  var U = [];\n                  for (var $2 in I3) U.push.apply(U, cn({ key: y3 + "." + $2, value: I3[$2] }));\n                  return U;\n                }\n                function Ta(m3) {\n                  var y3 = m3.value, I3 = m3.styleSpec, U = I3.light, $2 = m3.style, ae = [], he = no(y3);\n                  if (y3 === void 0) return ae;\n                  if (he !== "object") return ae = ae.concat([new _a("light", y3, "object expected, " + he + " found")]), ae;\n                  for (var Oe in y3) {\n                    var rt = Oe.match(/^(.*)-transition$/);\n                    rt && U[rt[1]] && U[rt[1]].transition ? ae = ae.concat(Qa({ key: Oe, value: y3[Oe], valueSpec: I3.transition, style: $2, styleSpec: I3 })) : U[Oe] ? ae = ae.concat(Qa({ key: Oe, value: y3[Oe], valueSpec: U[Oe], style: $2, styleSpec: I3 })) : ae = ae.concat([new _a(Oe, y3[Oe], \'unknown property "\' + Oe + \'"\')]);\n                  }\n                  return ae;\n                }\n                function fa(m3) {\n                  return cn(m3).length === 0 ? [] : Tt(m3);\n                }\n                function $a(m3) {\n                  return cn(m3).length === 0 ? [] : Tt(m3);\n                }\n                var Co = { "*": function() {\n                  return [];\n                }, array: qe, boolean: Yt, number: Xe, color: Kt, constants: Vu, enum: xr, filter: dr, function: ot, layer: Pi, object: le, source: Cn, light: Ta, string: cn, formatted: fa, resolvedImage: $a };\n                function Qa(m3) {\n                  var y3 = m3.value, I3 = m3.valueSpec, U = m3.styleSpec;\n                  if (I3.expression && ys(xo(y3))) return ot(m3);\n                  if (I3.expression && Ua(Yl(y3))) return Tt(m3);\n                  if (I3.type && Co[I3.type]) return Co[I3.type](m3);\n                  var $2 = le(Ol({}, m3, { valueSpec: I3.type ? U[I3.type] : I3 }));\n                  return $2;\n                }\n                function mo(m3) {\n                  var y3 = m3.value, I3 = m3.key, U = cn(m3);\n                  return U.length || (y3.indexOf("{fontstack}") === -1 && U.push(new _a(I3, y3, \'"glyphs" url must include a "{fontstack}" token\')), y3.indexOf("{range}") === -1 && U.push(new _a(I3, y3, \'"glyphs" url must include a "{range}" token\'))), U;\n                }\n                function Bo(m3, y3) {\n                  y3 === void 0 && (y3 = Rn);\n                  var I3 = [];\n                  return I3 = I3.concat(Qa({ key: "", value: m3, valueSpec: y3.$root, styleSpec: y3, style: m3, objectElementValidators: { glyphs: mo, "*": function() {\n                    return [];\n                  } } })), m3.constants && (I3 = I3.concat(Vu({ key: "constants", value: m3.constants, style: m3, styleSpec: y3 }))), Ps(I3);\n                }\n                Bo.source = Ts(Cn), Bo.light = Ts(Ta), Bo.layer = Ts(Pi), Bo.filter = Ts(dr), Bo.paintProperty = Ts(Wr), Bo.layoutProperty = Ts(ni);\n                function Ps(m3) {\n                  return [].concat(m3).sort(function(y3, I3) {\n                    return y3.line - I3.line;\n                  });\n                }\n                function Ts(m3) {\n                  return function() {\n                    for (var y3 = [], I3 = arguments.length; I3--; ) y3[I3] = arguments[I3];\n                    return Ps(m3.apply(this, y3));\n                  };\n                }\n                var wo = Bo, To = wo.light, hl = wo.paintProperty, Ul = wo.layoutProperty;\n                function Lu(m3, y3) {\n                  var I3 = false;\n                  if (y3 && y3.length) for (var U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    m3.fire(new da(new Error(ae.message))), I3 = true;\n                  }\n                  return I3;\n                }\n                var au = Ql, Js = 3;\n                function Ql(m3, y3, I3) {\n                  var U = this.cells = [];\n                  if (m3 instanceof ArrayBuffer) {\n                    this.arrayBuffer = m3;\n                    var $2 = new Int32Array(this.arrayBuffer);\n                    m3 = $2[0], y3 = $2[1], I3 = $2[2], this.d = y3 + 2 * I3;\n                    for (var ae = 0; ae < this.d * this.d; ae++) {\n                      var he = $2[Js + ae], Oe = $2[Js + ae + 1];\n                      U.push(he === Oe ? null : $2.subarray(he, Oe));\n                    }\n                    var rt = $2[Js + U.length], gt = $2[Js + U.length + 1];\n                    this.keys = $2.subarray(rt, gt), this.bboxes = $2.subarray(gt), this.insert = this._insertReadonly;\n                  } else {\n                    this.d = y3 + 2 * I3;\n                    for (var Et = 0; Et < this.d * this.d; Et++) U.push([]);\n                    this.keys = [], this.bboxes = [];\n                  }\n                  this.n = y3, this.extent = m3, this.padding = I3, this.scale = y3 / m3, this.uid = 0;\n                  var or = I3 / y3 * m3;\n                  this.min = -or, this.max = m3 + or;\n                }\n                Ql.prototype.insert = function(m3, y3, I3, U, $2) {\n                  this._forEachCell(y3, I3, U, $2, this._insertCell, this.uid++), this.keys.push(m3), this.bboxes.push(y3), this.bboxes.push(I3), this.bboxes.push(U), this.bboxes.push($2);\n                }, Ql.prototype._insertReadonly = function() {\n                  throw "Cannot insert into a GridIndex created from an ArrayBuffer.";\n                }, Ql.prototype._insertCell = function(m3, y3, I3, U, $2, ae) {\n                  this.cells[$2].push(ae);\n                }, Ql.prototype.query = function(m3, y3, I3, U, $2) {\n                  var ae = this.min, he = this.max;\n                  if (m3 <= ae && y3 <= ae && he <= I3 && he <= U && !$2) return Array.prototype.slice.call(this.keys);\n                  var Oe = [], rt = {};\n                  return this._forEachCell(m3, y3, I3, U, this._queryCell, Oe, rt, $2), Oe;\n                }, Ql.prototype._queryCell = function(m3, y3, I3, U, $2, ae, he, Oe) {\n                  var rt = this.cells[$2];\n                  if (rt !== null) for (var gt = this.keys, Et = this.bboxes, or = 0; or < rt.length; or++) {\n                    var _r = rt[or];\n                    if (he[_r] === void 0) {\n                      var pr = _r * 4;\n                      (Oe ? Oe(Et[pr + 0], Et[pr + 1], Et[pr + 2], Et[pr + 3]) : m3 <= Et[pr + 2] && y3 <= Et[pr + 3] && I3 >= Et[pr + 0] && U >= Et[pr + 1]) ? (he[_r] = true, ae.push(gt[_r])) : he[_r] = false;\n                    }\n                  }\n                }, Ql.prototype._forEachCell = function(m3, y3, I3, U, $2, ae, he, Oe) {\n                  for (var rt = this._convertToCellCoord(m3), gt = this._convertToCellCoord(y3), Et = this._convertToCellCoord(I3), or = this._convertToCellCoord(U), _r = rt; _r <= Et; _r++) for (var pr = gt; pr <= or; pr++) {\n                    var Fr = this.d * pr + _r;\n                    if (!(Oe && !Oe(this._convertFromCellCoord(_r), this._convertFromCellCoord(pr), this._convertFromCellCoord(_r + 1), this._convertFromCellCoord(pr + 1))) && $2.call(this, m3, y3, I3, U, Fr, ae, he, Oe)) return;\n                  }\n                }, Ql.prototype._convertFromCellCoord = function(m3) {\n                  return (m3 - this.padding) / this.scale;\n                }, Ql.prototype._convertToCellCoord = function(m3) {\n                  return Math.max(0, Math.min(this.d - 1, Math.floor(m3 * this.scale) + this.padding));\n                }, Ql.prototype.toArrayBuffer = function() {\n                  if (this.arrayBuffer) return this.arrayBuffer;\n                  for (var m3 = this.cells, y3 = Js + this.cells.length + 1 + 1, I3 = 0, U = 0; U < this.cells.length; U++) I3 += this.cells[U].length;\n                  var $2 = new Int32Array(y3 + I3 + this.keys.length + this.bboxes.length);\n                  $2[0] = this.extent, $2[1] = this.n, $2[2] = this.padding;\n                  for (var ae = y3, he = 0; he < m3.length; he++) {\n                    var Oe = m3[he];\n                    $2[Js + he] = ae, $2.set(Oe, ae), ae += Oe.length;\n                  }\n                  return $2[Js + m3.length] = ae, $2.set(this.keys, ae), ae += this.keys.length, $2[Js + m3.length + 1] = ae, $2.set(this.bboxes, ae), ae += this.bboxes.length, $2.buffer;\n                };\n                var dc = f4.ImageData, Tl = f4.ImageBitmap, Al = {};\n                function X(m3, y3, I3) {\n                  I3 === void 0 && (I3 = {}), Object.defineProperty(y3, "_classRegistryKey", { value: m3, writeable: false }), Al[m3] = { klass: y3, omit: I3.omit || [], shallow: I3.shallow || [] };\n                }\n                X("Object", Object), au.serialize = function(y3, I3) {\n                  var U = y3.toArrayBuffer();\n                  return I3 && I3.push(U), { buffer: U };\n                }, au.deserialize = function(y3) {\n                  return new au(y3.buffer);\n                }, X("Grid", au), X("Color", cs), X("Error", Error), X("ResolvedImage", fl), X("StylePropertyFunction", ue), X("StyleExpression", Ac, { omit: ["_evaluator"] }), X("ZoomDependentExpression", hc), X("ZoomConstantExpression", Vc), X("CompoundExpression", Pa, { omit: ["_evaluate"] });\n                for (var se in Ka) Ka[se]._classRegistryKey || X("Expression_" + se, Ka[se]);\n                function Te(m3) {\n                  return m3 && typeof ArrayBuffer != "undefined" && (m3 instanceof ArrayBuffer || m3.constructor && m3.constructor.name === "ArrayBuffer");\n                }\n                function Ne(m3) {\n                  return Tl && m3 instanceof Tl;\n                }\n                function He(m3, y3) {\n                  if (m3 == null || typeof m3 == "boolean" || typeof m3 == "number" || typeof m3 == "string" || m3 instanceof Boolean || m3 instanceof Number || m3 instanceof String || m3 instanceof Date || m3 instanceof RegExp) return m3;\n                  if (Te(m3) || Ne(m3)) return y3 && y3.push(m3), m3;\n                  if (ArrayBuffer.isView(m3)) {\n                    var I3 = m3;\n                    return y3 && y3.push(I3.buffer), I3;\n                  }\n                  if (m3 instanceof dc) return y3 && y3.push(m3.data.buffer), m3;\n                  if (Array.isArray(m3)) {\n                    for (var U = [], $2 = 0, ae = m3; $2 < ae.length; $2 += 1) {\n                      var he = ae[$2];\n                      U.push(He(he, y3));\n                    }\n                    return U;\n                  }\n                  if (typeof m3 == "object") {\n                    var Oe = m3.constructor, rt = Oe._classRegistryKey;\n                    if (!rt) throw new Error("can\'t serialize object of unregistered class");\n                    var gt = Oe.serialize ? Oe.serialize(m3, y3) : {};\n                    if (!Oe.serialize) {\n                      for (var Et in m3) if (m3.hasOwnProperty(Et) && !(Al[rt].omit.indexOf(Et) >= 0)) {\n                        var or = m3[Et];\n                        gt[Et] = Al[rt].shallow.indexOf(Et) >= 0 ? or : He(or, y3);\n                      }\n                      m3 instanceof Error && (gt.message = m3.message);\n                    }\n                    if (gt.$name) throw new Error("$name property is reserved for worker serialization logic.");\n                    return rt !== "Object" && (gt.$name = rt), gt;\n                  }\n                  throw new Error("can\'t serialize object of type " + typeof m3);\n                }\n                function Ye(m3) {\n                  if (m3 == null || typeof m3 == "boolean" || typeof m3 == "number" || typeof m3 == "string" || m3 instanceof Boolean || m3 instanceof Number || m3 instanceof String || m3 instanceof Date || m3 instanceof RegExp || Te(m3) || Ne(m3) || ArrayBuffer.isView(m3) || m3 instanceof dc) return m3;\n                  if (Array.isArray(m3)) return m3.map(Ye);\n                  if (typeof m3 == "object") {\n                    var y3 = m3.$name || "Object", I3 = Al[y3], U = I3.klass;\n                    if (!U) throw new Error("can\'t deserialize unregistered class " + y3);\n                    if (U.deserialize) return U.deserialize(m3);\n                    for (var $2 = Object.create(U.prototype), ae = 0, he = Object.keys(m3); ae < he.length; ae += 1) {\n                      var Oe = he[ae];\n                      if (Oe !== "$name") {\n                        var rt = m3[Oe];\n                        $2[Oe] = Al[y3].shallow.indexOf(Oe) >= 0 ? rt : Ye(rt);\n                      }\n                    }\n                    return $2;\n                  }\n                  throw new Error("can\'t deserialize object of type " + typeof m3);\n                }\n                var kt = function() {\n                  this.first = true;\n                };\n                kt.prototype.update = function(y3, I3) {\n                  var U = Math.floor(y3);\n                  return this.first ? (this.first = false, this.lastIntegerZoom = U, this.lastIntegerZoomTime = 0, this.lastZoom = y3, this.lastFloorZoom = U, true) : (this.lastFloorZoom > U ? (this.lastIntegerZoom = U + 1, this.lastIntegerZoomTime = I3) : this.lastFloorZoom < U && (this.lastIntegerZoom = U, this.lastIntegerZoomTime = I3), y3 !== this.lastZoom ? (this.lastZoom = y3, this.lastFloorZoom = U, true) : false);\n                };\n                var nt = { "Latin-1 Supplement": function(m3) {\n                  return m3 >= 128 && m3 <= 255;\n                }, Arabic: function(m3) {\n                  return m3 >= 1536 && m3 <= 1791;\n                }, "Arabic Supplement": function(m3) {\n                  return m3 >= 1872 && m3 <= 1919;\n                }, "Arabic Extended-A": function(m3) {\n                  return m3 >= 2208 && m3 <= 2303;\n                }, "Hangul Jamo": function(m3) {\n                  return m3 >= 4352 && m3 <= 4607;\n                }, "Unified Canadian Aboriginal Syllabics": function(m3) {\n                  return m3 >= 5120 && m3 <= 5759;\n                }, Khmer: function(m3) {\n                  return m3 >= 6016 && m3 <= 6143;\n                }, "Unified Canadian Aboriginal Syllabics Extended": function(m3) {\n                  return m3 >= 6320 && m3 <= 6399;\n                }, "General Punctuation": function(m3) {\n                  return m3 >= 8192 && m3 <= 8303;\n                }, "Letterlike Symbols": function(m3) {\n                  return m3 >= 8448 && m3 <= 8527;\n                }, "Number Forms": function(m3) {\n                  return m3 >= 8528 && m3 <= 8591;\n                }, "Miscellaneous Technical": function(m3) {\n                  return m3 >= 8960 && m3 <= 9215;\n                }, "Control Pictures": function(m3) {\n                  return m3 >= 9216 && m3 <= 9279;\n                }, "Optical Character Recognition": function(m3) {\n                  return m3 >= 9280 && m3 <= 9311;\n                }, "Enclosed Alphanumerics": function(m3) {\n                  return m3 >= 9312 && m3 <= 9471;\n                }, "Geometric Shapes": function(m3) {\n                  return m3 >= 9632 && m3 <= 9727;\n                }, "Miscellaneous Symbols": function(m3) {\n                  return m3 >= 9728 && m3 <= 9983;\n                }, "Miscellaneous Symbols and Arrows": function(m3) {\n                  return m3 >= 11008 && m3 <= 11263;\n                }, "CJK Radicals Supplement": function(m3) {\n                  return m3 >= 11904 && m3 <= 12031;\n                }, "Kangxi Radicals": function(m3) {\n                  return m3 >= 12032 && m3 <= 12255;\n                }, "Ideographic Description Characters": function(m3) {\n                  return m3 >= 12272 && m3 <= 12287;\n                }, "CJK Symbols and Punctuation": function(m3) {\n                  return m3 >= 12288 && m3 <= 12351;\n                }, Hiragana: function(m3) {\n                  return m3 >= 12352 && m3 <= 12447;\n                }, Katakana: function(m3) {\n                  return m3 >= 12448 && m3 <= 12543;\n                }, Bopomofo: function(m3) {\n                  return m3 >= 12544 && m3 <= 12591;\n                }, "Hangul Compatibility Jamo": function(m3) {\n                  return m3 >= 12592 && m3 <= 12687;\n                }, Kanbun: function(m3) {\n                  return m3 >= 12688 && m3 <= 12703;\n                }, "Bopomofo Extended": function(m3) {\n                  return m3 >= 12704 && m3 <= 12735;\n                }, "CJK Strokes": function(m3) {\n                  return m3 >= 12736 && m3 <= 12783;\n                }, "Katakana Phonetic Extensions": function(m3) {\n                  return m3 >= 12784 && m3 <= 12799;\n                }, "Enclosed CJK Letters and Months": function(m3) {\n                  return m3 >= 12800 && m3 <= 13055;\n                }, "CJK Compatibility": function(m3) {\n                  return m3 >= 13056 && m3 <= 13311;\n                }, "CJK Unified Ideographs Extension A": function(m3) {\n                  return m3 >= 13312 && m3 <= 19903;\n                }, "Yijing Hexagram Symbols": function(m3) {\n                  return m3 >= 19904 && m3 <= 19967;\n                }, "CJK Unified Ideographs": function(m3) {\n                  return m3 >= 19968 && m3 <= 40959;\n                }, "Yi Syllables": function(m3) {\n                  return m3 >= 40960 && m3 <= 42127;\n                }, "Yi Radicals": function(m3) {\n                  return m3 >= 42128 && m3 <= 42191;\n                }, "Hangul Jamo Extended-A": function(m3) {\n                  return m3 >= 43360 && m3 <= 43391;\n                }, "Hangul Syllables": function(m3) {\n                  return m3 >= 44032 && m3 <= 55215;\n                }, "Hangul Jamo Extended-B": function(m3) {\n                  return m3 >= 55216 && m3 <= 55295;\n                }, "Private Use Area": function(m3) {\n                  return m3 >= 57344 && m3 <= 63743;\n                }, "CJK Compatibility Ideographs": function(m3) {\n                  return m3 >= 63744 && m3 <= 64255;\n                }, "Arabic Presentation Forms-A": function(m3) {\n                  return m3 >= 64336 && m3 <= 65023;\n                }, "Vertical Forms": function(m3) {\n                  return m3 >= 65040 && m3 <= 65055;\n                }, "CJK Compatibility Forms": function(m3) {\n                  return m3 >= 65072 && m3 <= 65103;\n                }, "Small Form Variants": function(m3) {\n                  return m3 >= 65104 && m3 <= 65135;\n                }, "Arabic Presentation Forms-B": function(m3) {\n                  return m3 >= 65136 && m3 <= 65279;\n                }, "Halfwidth and Fullwidth Forms": function(m3) {\n                  return m3 >= 65280 && m3 <= 65519;\n                } };\n                function jt(m3) {\n                  for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (qr(U.charCodeAt(0))) return true;\n                  }\n                  return false;\n                }\n                function gr(m3) {\n                  for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (!yr(U.charCodeAt(0))) return false;\n                  }\n                  return true;\n                }\n                function yr(m3) {\n                  return !(nt.Arabic(m3) || nt["Arabic Supplement"](m3) || nt["Arabic Extended-A"](m3) || nt["Arabic Presentation Forms-A"](m3) || nt["Arabic Presentation Forms-B"](m3));\n                }\n                function Hr(m3) {\n                  return m3 < 11904 ? false : !!(nt["Bopomofo Extended"](m3) || nt.Bopomofo(m3) || nt["CJK Compatibility Forms"](m3) || nt["CJK Compatibility Ideographs"](m3) || nt["CJK Compatibility"](m3) || nt["CJK Radicals Supplement"](m3) || nt["CJK Strokes"](m3) || nt["CJK Symbols and Punctuation"](m3) || nt["CJK Unified Ideographs Extension A"](m3) || nt["CJK Unified Ideographs"](m3) || nt["Enclosed CJK Letters and Months"](m3) || nt["Halfwidth and Fullwidth Forms"](m3) || nt.Hiragana(m3) || nt["Ideographic Description Characters"](m3) || nt["Kangxi Radicals"](m3) || nt["Katakana Phonetic Extensions"](m3) || nt.Katakana(m3) || nt["Vertical Forms"](m3) || nt["Yi Radicals"](m3) || nt["Yi Syllables"](m3));\n                }\n                function qr(m3) {\n                  return m3 === 746 || m3 === 747 ? true : m3 < 4352 ? false : !!(nt["Bopomofo Extended"](m3) || nt.Bopomofo(m3) || nt["CJK Compatibility Forms"](m3) && !(m3 >= 65097 && m3 <= 65103) || nt["CJK Compatibility Ideographs"](m3) || nt["CJK Compatibility"](m3) || nt["CJK Radicals Supplement"](m3) || nt["CJK Strokes"](m3) || nt["CJK Symbols and Punctuation"](m3) && !(m3 >= 12296 && m3 <= 12305) && !(m3 >= 12308 && m3 <= 12319) && m3 !== 12336 || nt["CJK Unified Ideographs Extension A"](m3) || nt["CJK Unified Ideographs"](m3) || nt["Enclosed CJK Letters and Months"](m3) || nt["Hangul Compatibility Jamo"](m3) || nt["Hangul Jamo Extended-A"](m3) || nt["Hangul Jamo Extended-B"](m3) || nt["Hangul Jamo"](m3) || nt["Hangul Syllables"](m3) || nt.Hiragana(m3) || nt["Ideographic Description Characters"](m3) || nt.Kanbun(m3) || nt["Kangxi Radicals"](m3) || nt["Katakana Phonetic Extensions"](m3) || nt.Katakana(m3) && m3 !== 12540 || nt["Halfwidth and Fullwidth Forms"](m3) && m3 !== 65288 && m3 !== 65289 && m3 !== 65293 && !(m3 >= 65306 && m3 <= 65310) && m3 !== 65339 && m3 !== 65341 && m3 !== 65343 && !(m3 >= 65371 && m3 <= 65503) && m3 !== 65507 && !(m3 >= 65512 && m3 <= 65519) || nt["Small Form Variants"](m3) && !(m3 >= 65112 && m3 <= 65118) && !(m3 >= 65123 && m3 <= 65126) || nt["Unified Canadian Aboriginal Syllabics"](m3) || nt["Unified Canadian Aboriginal Syllabics Extended"](m3) || nt["Vertical Forms"](m3) || nt["Yijing Hexagram Symbols"](m3) || nt["Yi Syllables"](m3) || nt["Yi Radicals"](m3));\n                }\n                function _i(m3) {\n                  return !!(nt["Latin-1 Supplement"](m3) && (m3 === 167 || m3 === 169 || m3 === 174 || m3 === 177 || m3 === 188 || m3 === 189 || m3 === 190 || m3 === 215 || m3 === 247) || nt["General Punctuation"](m3) && (m3 === 8214 || m3 === 8224 || m3 === 8225 || m3 === 8240 || m3 === 8241 || m3 === 8251 || m3 === 8252 || m3 === 8258 || m3 === 8263 || m3 === 8264 || m3 === 8265 || m3 === 8273) || nt["Letterlike Symbols"](m3) || nt["Number Forms"](m3) || nt["Miscellaneous Technical"](m3) && (m3 >= 8960 && m3 <= 8967 || m3 >= 8972 && m3 <= 8991 || m3 >= 8996 && m3 <= 9e3 || m3 === 9003 || m3 >= 9085 && m3 <= 9114 || m3 >= 9150 && m3 <= 9165 || m3 === 9167 || m3 >= 9169 && m3 <= 9179 || m3 >= 9186 && m3 <= 9215) || nt["Control Pictures"](m3) && m3 !== 9251 || nt["Optical Character Recognition"](m3) || nt["Enclosed Alphanumerics"](m3) || nt["Geometric Shapes"](m3) || nt["Miscellaneous Symbols"](m3) && !(m3 >= 9754 && m3 <= 9759) || nt["Miscellaneous Symbols and Arrows"](m3) && (m3 >= 11026 && m3 <= 11055 || m3 >= 11088 && m3 <= 11097 || m3 >= 11192 && m3 <= 11243) || nt["CJK Symbols and Punctuation"](m3) || nt.Katakana(m3) || nt["Private Use Area"](m3) || nt["CJK Compatibility Forms"](m3) || nt["Small Form Variants"](m3) || nt["Halfwidth and Fullwidth Forms"](m3) || m3 === 8734 || m3 === 8756 || m3 === 8757 || m3 >= 9984 && m3 <= 10087 || m3 >= 10102 && m3 <= 10131 || m3 === 65532 || m3 === 65533);\n                }\n                function bi(m3) {\n                  return !(qr(m3) || _i(m3));\n                }\n                function Zr(m3) {\n                  return nt.Arabic(m3) || nt["Arabic Supplement"](m3) || nt["Arabic Extended-A"](m3) || nt["Arabic Presentation Forms-A"](m3) || nt["Arabic Presentation Forms-B"](m3);\n                }\n                function ai(m3) {\n                  return m3 >= 1424 && m3 <= 2303 || nt["Arabic Presentation Forms-A"](m3) || nt["Arabic Presentation Forms-B"](m3);\n                }\n                function gi(m3, y3) {\n                  return !(!y3 && ai(m3) || m3 >= 2304 && m3 <= 3583 || m3 >= 3840 && m3 <= 4255 || nt.Khmer(m3));\n                }\n                function Ii(m3) {\n                  for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (ai(U.charCodeAt(0))) return true;\n                  }\n                  return false;\n                }\n                function Si(m3, y3) {\n                  for (var I3 = 0, U = m3; I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    if (!gi($2.charCodeAt(0), y3)) return false;\n                  }\n                  return true;\n                }\n                var ei = { unavailable: "unavailable", deferred: "deferred", loading: "loading", loaded: "loaded", error: "error" }, Ln = null, En = ei.unavailable, Un = null, ia = function(m3) {\n                  m3 && typeof m3 == "string" && m3.indexOf("NetworkError") > -1 && (En = ei.error), Ln && Ln(m3);\n                };\n                function Ea() {\n                  Ia.fire(new Wo("pluginStateChange", { pluginStatus: En, pluginURL: Un }));\n                }\n                var Ia = new Wn(), yo = function() {\n                  return En;\n                }, Da = function(m3) {\n                  return m3({ pluginStatus: En, pluginURL: Un }), Ia.on("pluginStateChange", m3), m3;\n                }, go = function(m3, y3, I3) {\n                  if (I3 === void 0 && (I3 = false), En === ei.deferred || En === ei.loading || En === ei.loaded) throw new Error("setRTLTextPlugin cannot be called multiple times.");\n                  Un = ut.resolveURL(m3), En = ei.deferred, Ln = y3, Ea(), I3 || Is();\n                }, Is = function() {\n                  if (En !== ei.deferred || !Un) throw new Error("rtl-text-plugin cannot be downloaded unless a pluginURL is specified");\n                  En = ei.loading, Ea(), Un && ri({ url: Un }, function(m3) {\n                    m3 ? ia(m3) : (En = ei.loaded, Ea());\n                  });\n                }, Ms = { applyArabicShaping: null, processBidirectionalText: null, processStyledBidirectionalText: null, isLoaded: function() {\n                  return En === ei.loaded || Ms.applyArabicShaping != null;\n                }, isLoading: function() {\n                  return En === ei.loading;\n                }, setState: function(y3) {\n                  En = y3.pluginStatus, Un = y3.pluginURL;\n                }, isParsed: function() {\n                  return Ms.applyArabicShaping != null && Ms.processBidirectionalText != null && Ms.processStyledBidirectionalText != null;\n                }, getPluginURL: function() {\n                  return Un;\n                } }, Xs = function() {\n                  !Ms.isLoading() && !Ms.isLoaded() && yo() === "deferred" && Is();\n                }, Gn = function(y3, I3) {\n                  this.zoom = y3, I3 ? (this.now = I3.now, this.fadeDuration = I3.fadeDuration, this.zoomHistory = I3.zoomHistory, this.transition = I3.transition) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new kt(), this.transition = {});\n                };\n                Gn.prototype.isSupportedScript = function(y3) {\n                  return Si(y3, Ms.isLoaded());\n                }, Gn.prototype.crossFadingFactor = function() {\n                  return this.fadeDuration === 0 ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);\n                }, Gn.prototype.getCrossfadeParameters = function() {\n                  var y3 = this.zoom, I3 = y3 - Math.floor(y3), U = this.crossFadingFactor();\n                  return y3 > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: I3 + (1 - I3) * U } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - U) * I3 };\n                };\n                var ja = function(y3, I3) {\n                  this.property = y3, this.value = I3, this.expression = w4(I3 === void 0 ? y3.specification.default : I3, y3.specification);\n                };\n                ja.prototype.isDataDriven = function() {\n                  return this.expression.kind === "source" || this.expression.kind === "composite";\n                }, ja.prototype.possiblyEvaluate = function(y3, I3, U) {\n                  return this.property.possiblyEvaluate(this, y3, I3, U);\n                };\n                var Fo = function(y3) {\n                  this.property = y3, this.value = new ja(y3, void 0);\n                };\n                Fo.prototype.transitioned = function(y3, I3) {\n                  return new $s(this.property, this.value, I3, x2({}, y3.transition, this.transition), y3.now);\n                }, Fo.prototype.untransitioned = function() {\n                  return new $s(this.property, this.value, null, {}, 0);\n                };\n                var Uo = function(y3) {\n                  this._properties = y3, this._values = Object.create(y3.defaultTransitionablePropertyValues);\n                };\n                Uo.prototype.getValue = function(y3) {\n                  return j3(this._values[y3].value.value);\n                }, Uo.prototype.setValue = function(y3, I3) {\n                  this._values.hasOwnProperty(y3) || (this._values[y3] = new Fo(this._values[y3].property)), this._values[y3].value = new ja(this._values[y3].property, I3 === null ? void 0 : j3(I3));\n                }, Uo.prototype.getTransition = function(y3) {\n                  return j3(this._values[y3].transition);\n                }, Uo.prototype.setTransition = function(y3, I3) {\n                  this._values.hasOwnProperty(y3) || (this._values[y3] = new Fo(this._values[y3].property)), this._values[y3].transition = j3(I3) || void 0;\n                }, Uo.prototype.serialize = function() {\n                  for (var y3 = {}, I3 = 0, U = Object.keys(this._values); I3 < U.length; I3 += 1) {\n                    var $2 = U[I3], ae = this.getValue($2);\n                    ae !== void 0 && (y3[$2] = ae);\n                    var he = this.getTransition($2);\n                    he !== void 0 && (y3[$2 + "-transition"] = he);\n                  }\n                  return y3;\n                }, Uo.prototype.transitioned = function(y3, I3) {\n                  for (var U = new Sl(this._properties), $2 = 0, ae = Object.keys(this._values); $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    U._values[he] = this._values[he].transitioned(y3, I3._values[he]);\n                  }\n                  return U;\n                }, Uo.prototype.untransitioned = function() {\n                  for (var y3 = new Sl(this._properties), I3 = 0, U = Object.keys(this._values); I3 < U.length; I3 += 1) {\n                    var $2 = U[I3];\n                    y3._values[$2] = this._values[$2].untransitioned();\n                  }\n                  return y3;\n                };\n                var $s = function(y3, I3, U, $2, ae) {\n                  this.property = y3, this.value = I3, this.begin = ae + $2.delay || 0, this.end = this.begin + $2.duration || 0, y3.specification.transition && ($2.delay || $2.duration) && (this.prior = U);\n                };\n                $s.prototype.possiblyEvaluate = function(y3, I3, U) {\n                  var $2 = y3.now || 0, ae = this.value.possiblyEvaluate(y3, I3, U), he = this.prior;\n                  if (he) {\n                    if ($2 > this.end) return this.prior = null, ae;\n                    if (this.value.isDataDriven()) return this.prior = null, ae;\n                    if ($2 < this.begin) return he.possiblyEvaluate(y3, I3, U);\n                    var Oe = ($2 - this.begin) / (this.end - this.begin);\n                    return this.property.interpolate(he.possiblyEvaluate(y3, I3, U), ae, v3(Oe));\n                  } else return ae;\n                };\n                var Sl = function(y3) {\n                  this._properties = y3, this._values = Object.create(y3.defaultTransitioningPropertyValues);\n                };\n                Sl.prototype.possiblyEvaluate = function(y3, I3, U) {\n                  for (var $2 = new Sc(this._properties), ae = 0, he = Object.keys(this._values); ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    $2._values[Oe] = this._values[Oe].possiblyEvaluate(y3, I3, U);\n                  }\n                  return $2;\n                }, Sl.prototype.hasTransition = function() {\n                  for (var y3 = 0, I3 = Object.keys(this._values); y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (this._values[U].prior) return true;\n                  }\n                  return false;\n                };\n                var bu = function(y3) {\n                  this._properties = y3, this._values = Object.create(y3.defaultPropertyValues);\n                };\n                bu.prototype.getValue = function(y3) {\n                  return j3(this._values[y3].value);\n                }, bu.prototype.setValue = function(y3, I3) {\n                  this._values[y3] = new ja(this._values[y3].property, I3 === null ? void 0 : j3(I3));\n                }, bu.prototype.serialize = function() {\n                  for (var y3 = {}, I3 = 0, U = Object.keys(this._values); I3 < U.length; I3 += 1) {\n                    var $2 = U[I3], ae = this.getValue($2);\n                    ae !== void 0 && (y3[$2] = ae);\n                  }\n                  return y3;\n                }, bu.prototype.possiblyEvaluate = function(y3, I3, U) {\n                  for (var $2 = new Sc(this._properties), ae = 0, he = Object.keys(this._values); ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    $2._values[Oe] = this._values[Oe].possiblyEvaluate(y3, I3, U);\n                  }\n                  return $2;\n                };\n                var dl = function(y3, I3, U) {\n                  this.property = y3, this.value = I3, this.parameters = U;\n                };\n                dl.prototype.isConstant = function() {\n                  return this.value.kind === "constant";\n                }, dl.prototype.constantOr = function(y3) {\n                  return this.value.kind === "constant" ? this.value.value : y3;\n                }, dl.prototype.evaluate = function(y3, I3, U, $2) {\n                  return this.property.evaluate(this.value, this.parameters, y3, I3, U, $2);\n                };\n                var Sc = function(y3) {\n                  this._properties = y3, this._values = Object.create(y3.defaultPossiblyEvaluatedValues);\n                };\n                Sc.prototype.get = function(y3) {\n                  return this._values[y3];\n                };\n                var Me = function(y3) {\n                  this.specification = y3;\n                };\n                Me.prototype.possiblyEvaluate = function(y3, I3) {\n                  return y3.expression.evaluate(I3);\n                }, Me.prototype.interpolate = function(y3, I3, U) {\n                  var $2 = zu[this.specification.type];\n                  return $2 ? $2(y3, I3, U) : y3;\n                };\n                var bt = function(y3, I3) {\n                  this.specification = y3, this.overrides = I3;\n                };\n                bt.prototype.possiblyEvaluate = function(y3, I3, U, $2) {\n                  return y3.expression.kind === "constant" || y3.expression.kind === "camera" ? new dl(this, { kind: "constant", value: y3.expression.evaluate(I3, null, {}, U, $2) }, I3) : new dl(this, y3.expression, I3);\n                }, bt.prototype.interpolate = function(y3, I3, U) {\n                  if (y3.value.kind !== "constant" || I3.value.kind !== "constant") return y3;\n                  if (y3.value.value === void 0 || I3.value.value === void 0) return new dl(this, { kind: "constant", value: void 0 }, y3.parameters);\n                  var $2 = zu[this.specification.type];\n                  return $2 ? new dl(this, { kind: "constant", value: $2(y3.value.value, I3.value.value, U) }, y3.parameters) : y3;\n                }, bt.prototype.evaluate = function(y3, I3, U, $2, ae, he) {\n                  return y3.kind === "constant" ? y3.value : y3.evaluate(I3, U, $2, ae, he);\n                };\n                var zt = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.possiblyEvaluate = function(U, $2, ae, he) {\n                    if (U.value === void 0) return new dl(this, { kind: "constant", value: void 0 }, $2);\n                    if (U.expression.kind === "constant") {\n                      var Oe = U.expression.evaluate($2, null, {}, ae, he), rt = U.property.specification.type === "resolvedImage", gt = rt && typeof Oe != "string" ? Oe.name : Oe, Et = this._calculate(gt, gt, gt, $2);\n                      return new dl(this, { kind: "constant", value: Et }, $2);\n                    } else if (U.expression.kind === "camera") {\n                      var or = this._calculate(U.expression.evaluate({ zoom: $2.zoom - 1 }), U.expression.evaluate({ zoom: $2.zoom }), U.expression.evaluate({ zoom: $2.zoom + 1 }), $2);\n                      return new dl(this, { kind: "constant", value: or }, $2);\n                    } else return new dl(this, U.expression, $2);\n                  }, y3.prototype.evaluate = function(U, $2, ae, he, Oe, rt) {\n                    if (U.kind === "source") {\n                      var gt = U.evaluate($2, ae, he, Oe, rt);\n                      return this._calculate(gt, gt, gt, $2);\n                    } else return U.kind === "composite" ? this._calculate(U.evaluate({ zoom: Math.floor($2.zoom) - 1 }, ae, he), U.evaluate({ zoom: Math.floor($2.zoom) }, ae, he), U.evaluate({ zoom: Math.floor($2.zoom) + 1 }, ae, he), $2) : U.value;\n                  }, y3.prototype._calculate = function(U, $2, ae, he) {\n                    var Oe = he.zoom;\n                    return Oe > he.zoomHistory.lastIntegerZoom ? { from: U, to: $2 } : { from: ae, to: $2 };\n                  }, y3.prototype.interpolate = function(U) {\n                    return U;\n                  }, y3;\n                })(bt), Rr = function(y3) {\n                  this.specification = y3;\n                };\n                Rr.prototype.possiblyEvaluate = function(y3, I3, U, $2) {\n                  if (y3.value !== void 0) if (y3.expression.kind === "constant") {\n                    var ae = y3.expression.evaluate(I3, null, {}, U, $2);\n                    return this._calculate(ae, ae, ae, I3);\n                  } else return this._calculate(y3.expression.evaluate(new Gn(Math.floor(I3.zoom - 1), I3)), y3.expression.evaluate(new Gn(Math.floor(I3.zoom), I3)), y3.expression.evaluate(new Gn(Math.floor(I3.zoom + 1), I3)), I3);\n                }, Rr.prototype._calculate = function(y3, I3, U, $2) {\n                  var ae = $2.zoom;\n                  return ae > $2.zoomHistory.lastIntegerZoom ? { from: y3, to: I3 } : { from: U, to: I3 };\n                }, Rr.prototype.interpolate = function(y3) {\n                  return y3;\n                };\n                var jr = function(y3) {\n                  this.specification = y3;\n                };\n                jr.prototype.possiblyEvaluate = function(y3, I3, U, $2) {\n                  return !!y3.expression.evaluate(I3, null, {}, U, $2);\n                }, jr.prototype.interpolate = function() {\n                  return false;\n                };\n                var Nr = function(y3) {\n                  this.properties = y3, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];\n                  for (var I3 in y3) {\n                    var U = y3[I3];\n                    U.specification.overridable && this.overridableProperties.push(I3);\n                    var $2 = this.defaultPropertyValues[I3] = new ja(U, void 0), ae = this.defaultTransitionablePropertyValues[I3] = new Fo(U);\n                    this.defaultTransitioningPropertyValues[I3] = ae.untransitioned(), this.defaultPossiblyEvaluatedValues[I3] = $2.possiblyEvaluate({});\n                  }\n                };\n                X("DataDrivenProperty", bt), X("DataConstantProperty", Me), X("CrossFadedDataDrivenProperty", zt), X("CrossFadedProperty", Rr), X("ColorRampProperty", jr);\n                var Gr = "-transition", mi = (function(m3) {\n                  function y3(I3, U) {\n                    if (m3.call(this), this.id = I3.id, this.type = I3.type, this._featureFilter = { filter: function() {\n                      return true;\n                    }, needGeometry: false }, I3.type !== "custom" && (I3 = I3, this.metadata = I3.metadata, this.minzoom = I3.minzoom, this.maxzoom = I3.maxzoom, I3.type !== "background" && (this.source = I3.source, this.sourceLayer = I3["source-layer"], this.filter = I3.filter), U.layout && (this._unevaluatedLayout = new bu(U.layout)), U.paint)) {\n                      this._transitionablePaint = new Uo(U.paint);\n                      for (var $2 in I3.paint) this.setPaintProperty($2, I3.paint[$2], { validate: false });\n                      for (var ae in I3.layout) this.setLayoutProperty(ae, I3.layout[ae], { validate: false });\n                      this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new Sc(U.paint);\n                    }\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.getCrossfadeParameters = function() {\n                    return this._crossfadeParameters;\n                  }, y3.prototype.getLayoutProperty = function(U) {\n                    return U === "visibility" ? this.visibility : this._unevaluatedLayout.getValue(U);\n                  }, y3.prototype.setLayoutProperty = function(U, $2, ae) {\n                    if (ae === void 0 && (ae = {}), $2 != null) {\n                      var he = "layers." + this.id + ".layout." + U;\n                      if (this._validate(Ul, he, U, $2, ae)) return;\n                    }\n                    if (U === "visibility") {\n                      this.visibility = $2;\n                      return;\n                    }\n                    this._unevaluatedLayout.setValue(U, $2);\n                  }, y3.prototype.getPaintProperty = function(U) {\n                    return V2(U, Gr) ? this._transitionablePaint.getTransition(U.slice(0, -Gr.length)) : this._transitionablePaint.getValue(U);\n                  }, y3.prototype.setPaintProperty = function(U, $2, ae) {\n                    if (ae === void 0 && (ae = {}), $2 != null) {\n                      var he = "layers." + this.id + ".paint." + U;\n                      if (this._validate(hl, he, U, $2, ae)) return false;\n                    }\n                    if (V2(U, Gr)) return this._transitionablePaint.setTransition(U.slice(0, -Gr.length), $2 || void 0), false;\n                    var Oe = this._transitionablePaint._values[U], rt = Oe.property.specification["property-type"] === "cross-faded-data-driven", gt = Oe.value.isDataDriven(), Et = Oe.value;\n                    this._transitionablePaint.setValue(U, $2), this._handleSpecialPaintPropertyUpdate(U);\n                    var or = this._transitionablePaint._values[U].value, _r = or.isDataDriven();\n                    return _r || gt || rt || this._handleOverridablePaintPropertyUpdate(U, Et, or);\n                  }, y3.prototype._handleSpecialPaintPropertyUpdate = function(U) {\n                  }, y3.prototype._handleOverridablePaintPropertyUpdate = function(U, $2, ae) {\n                    return false;\n                  }, y3.prototype.isHidden = function(U) {\n                    return this.minzoom && U < this.minzoom || this.maxzoom && U >= this.maxzoom ? true : this.visibility === "none";\n                  }, y3.prototype.updateTransitions = function(U) {\n                    this._transitioningPaint = this._transitionablePaint.transitioned(U, this._transitioningPaint);\n                  }, y3.prototype.hasTransition = function() {\n                    return this._transitioningPaint.hasTransition();\n                  }, y3.prototype.recalculate = function(U, $2) {\n                    U.getCrossfadeParameters && (this._crossfadeParameters = U.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(U, void 0, $2)), this.paint = this._transitioningPaint.possiblyEvaluate(U, void 0, $2);\n                  }, y3.prototype.serialize = function() {\n                    var U = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };\n                    return this.visibility && (U.layout = U.layout || {}, U.layout.visibility = this.visibility), Z(U, function($2, ae) {\n                      return $2 !== void 0 && !(ae === "layout" && !Object.keys($2).length) && !(ae === "paint" && !Object.keys($2).length);\n                    });\n                  }, y3.prototype._validate = function(U, $2, ae, he, Oe) {\n                    return Oe === void 0 && (Oe = {}), Oe && Oe.validate === false ? false : Lu(this, U.call(wo, { key: $2, layerType: this.type, objectKey: ae, value: he, styleSpec: Rn, style: { glyphs: true, sprite: true } }));\n                  }, y3.prototype.is3D = function() {\n                    return false;\n                  }, y3.prototype.isTileClipped = function() {\n                    return false;\n                  }, y3.prototype.hasOffscreenPass = function() {\n                    return false;\n                  }, y3.prototype.resize = function() {\n                  }, y3.prototype.isStateDependent = function() {\n                    for (var U in this.paint._values) {\n                      var $2 = this.paint.get(U);\n                      if (!(!($2 instanceof dl) || !Ws($2.property.specification)) && ($2.value.kind === "source" || $2.value.kind === "composite") && $2.value.isStateDependent) return true;\n                    }\n                    return false;\n                  }, y3;\n                })(Wn), Ui = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array }, qi = function(y3, I3) {\n                  this._structArray = y3, this._pos1 = I3 * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;\n                }, Ei = 128, Hn = 5, en = function() {\n                  this.isTransferred = false, this.capacity = -1, this.resize(0);\n                };\n                en.serialize = function(y3, I3) {\n                  return y3._trim(), I3 && (y3.isTransferred = true, I3.push(y3.arrayBuffer)), { length: y3.length, arrayBuffer: y3.arrayBuffer };\n                }, en.deserialize = function(y3) {\n                  var I3 = Object.create(this.prototype);\n                  return I3.arrayBuffer = y3.arrayBuffer, I3.length = y3.length, I3.capacity = y3.arrayBuffer.byteLength / I3.bytesPerElement, I3._refreshViews(), I3;\n                }, en.prototype._trim = function() {\n                  this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());\n                }, en.prototype.clear = function() {\n                  this.length = 0;\n                }, en.prototype.resize = function(y3) {\n                  this.reserve(y3), this.length = y3;\n                }, en.prototype.reserve = function(y3) {\n                  if (y3 > this.capacity) {\n                    this.capacity = Math.max(y3, Math.floor(this.capacity * Hn), Ei), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);\n                    var I3 = this.uint8;\n                    this._refreshViews(), I3 && this.uint8.set(I3);\n                  }\n                }, en.prototype._refreshViews = function() {\n                  throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");\n                };\n                function Wi(m3, y3) {\n                  y3 === void 0 && (y3 = 1);\n                  var I3 = 0, U = 0, $2 = m3.map(function(he) {\n                    var Oe = si(he.type), rt = I3 = Mr(I3, Math.max(y3, Oe)), gt = he.components || 1;\n                    return U = Math.max(U, Oe), I3 += Oe * gt, { name: he.name, type: he.type, components: gt, offset: rt };\n                  }), ae = Mr(I3, Math.max(U, y3));\n                  return { members: $2, size: ae, alignment: y3 };\n                }\n                function si(m3) {\n                  return Ui[m3].BYTES_PER_ELEMENT;\n                }\n                function Mr(m3, y3) {\n                  return Math.ceil(m3 / y3) * y3;\n                }\n                var Yr = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2) {\n                    var ae = this.length;\n                    return this.resize(ae + 1), this.emplace(ae, U, $2);\n                  }, y3.prototype.emplace = function(U, $2, ae) {\n                    var he = U * 2;\n                    return this.int16[he + 0] = $2, this.int16[he + 1] = ae, U;\n                  }, y3;\n                })(en);\n                Yr.prototype.bytesPerElement = 4, X("StructArrayLayout2i4", Yr);\n                var xi = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he) {\n                    var Oe = this.length;\n                    return this.resize(Oe + 1), this.emplace(Oe, U, $2, ae, he);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe) {\n                    var rt = U * 4;\n                    return this.int16[rt + 0] = $2, this.int16[rt + 1] = ae, this.int16[rt + 2] = he, this.int16[rt + 3] = Oe, U;\n                  }, y3;\n                })(en);\n                xi.prototype.bytesPerElement = 8, X("StructArrayLayout4i8", xi);\n                var Ri = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt) {\n                    var gt = this.length;\n                    return this.resize(gt + 1), this.emplace(gt, U, $2, ae, he, Oe, rt);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt) {\n                    var Et = U * 6;\n                    return this.int16[Et + 0] = $2, this.int16[Et + 1] = ae, this.int16[Et + 2] = he, this.int16[Et + 3] = Oe, this.int16[Et + 4] = rt, this.int16[Et + 5] = gt, U;\n                  }, y3;\n                })(en);\n                Ri.prototype.bytesPerElement = 12, X("StructArrayLayout2i4i12", Ri);\n                var ci = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt) {\n                    var gt = this.length;\n                    return this.resize(gt + 1), this.emplace(gt, U, $2, ae, he, Oe, rt);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt) {\n                    var Et = U * 4, or = U * 8;\n                    return this.int16[Et + 0] = $2, this.int16[Et + 1] = ae, this.uint8[or + 4] = he, this.uint8[or + 5] = Oe, this.uint8[or + 6] = rt, this.uint8[or + 7] = gt, U;\n                  }, y3;\n                })(en);\n                ci.prototype.bytesPerElement = 8, X("StructArrayLayout2i4ub8", ci);\n                var an = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2) {\n                    var ae = this.length;\n                    return this.resize(ae + 1), this.emplace(ae, U, $2);\n                  }, y3.prototype.emplace = function(U, $2, ae) {\n                    var he = U * 2;\n                    return this.float32[he + 0] = $2, this.float32[he + 1] = ae, U;\n                  }, y3;\n                })(en);\n                an.prototype.bytesPerElement = 8, X("StructArrayLayout2f8", an);\n                var Zi = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r) {\n                    var pr = this.length;\n                    return this.resize(pr + 1), this.emplace(pr, U, $2, ae, he, Oe, rt, gt, Et, or, _r);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr) {\n                    var Fr = U * 10;\n                    return this.uint16[Fr + 0] = $2, this.uint16[Fr + 1] = ae, this.uint16[Fr + 2] = he, this.uint16[Fr + 3] = Oe, this.uint16[Fr + 4] = rt, this.uint16[Fr + 5] = gt, this.uint16[Fr + 6] = Et, this.uint16[Fr + 7] = or, this.uint16[Fr + 8] = _r, this.uint16[Fr + 9] = pr, U;\n                  }, y3;\n                })(en);\n                Zi.prototype.bytesPerElement = 20, X("StructArrayLayout10ui20", Zi);\n                var Bn = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr) {\n                    var oi = this.length;\n                    return this.resize(oi + 1), this.emplace(oi, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi) {\n                    var Hi = U * 12;\n                    return this.int16[Hi + 0] = $2, this.int16[Hi + 1] = ae, this.int16[Hi + 2] = he, this.int16[Hi + 3] = Oe, this.uint16[Hi + 4] = rt, this.uint16[Hi + 5] = gt, this.uint16[Hi + 6] = Et, this.uint16[Hi + 7] = or, this.int16[Hi + 8] = _r, this.int16[Hi + 9] = pr, this.int16[Hi + 10] = Fr, this.int16[Hi + 11] = oi, U;\n                  }, y3;\n                })(en);\n                Bn.prototype.bytesPerElement = 24, X("StructArrayLayout4i4ui4i24", Bn);\n                var hi = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae) {\n                    var he = this.length;\n                    return this.resize(he + 1), this.emplace(he, U, $2, ae);\n                  }, y3.prototype.emplace = function(U, $2, ae, he) {\n                    var Oe = U * 3;\n                    return this.float32[Oe + 0] = $2, this.float32[Oe + 1] = ae, this.float32[Oe + 2] = he, U;\n                  }, y3;\n                })(en);\n                hi.prototype.bytesPerElement = 12, X("StructArrayLayout3f12", hi);\n                var li = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U) {\n                    var $2 = this.length;\n                    return this.resize($2 + 1), this.emplace($2, U);\n                  }, y3.prototype.emplace = function(U, $2) {\n                    var ae = U * 1;\n                    return this.uint32[ae + 0] = $2, U;\n                  }, y3;\n                })(en);\n                li.prototype.bytesPerElement = 4, X("StructArrayLayout1ul4", li);\n                var mn = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt, gt, Et, or) {\n                    var _r = this.length;\n                    return this.resize(_r + 1), this.emplace(_r, U, $2, ae, he, Oe, rt, gt, Et, or);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r) {\n                    var pr = U * 10, Fr = U * 5;\n                    return this.int16[pr + 0] = $2, this.int16[pr + 1] = ae, this.int16[pr + 2] = he, this.int16[pr + 3] = Oe, this.int16[pr + 4] = rt, this.int16[pr + 5] = gt, this.uint32[Fr + 3] = Et, this.uint16[pr + 8] = or, this.uint16[pr + 9] = _r, U;\n                  }, y3;\n                })(en);\n                mn.prototype.bytesPerElement = 20, X("StructArrayLayout6i1ul2ui20", mn);\n                var Ji = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt) {\n                    var gt = this.length;\n                    return this.resize(gt + 1), this.emplace(gt, U, $2, ae, he, Oe, rt);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt) {\n                    var Et = U * 6;\n                    return this.int16[Et + 0] = $2, this.int16[Et + 1] = ae, this.int16[Et + 2] = he, this.int16[Et + 3] = Oe, this.int16[Et + 4] = rt, this.int16[Et + 5] = gt, U;\n                  }, y3;\n                })(en);\n                Ji.prototype.bytesPerElement = 12, X("StructArrayLayout2i2i2i12", Ji);\n                var Vi = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe) {\n                    var rt = this.length;\n                    return this.resize(rt + 1), this.emplace(rt, U, $2, ae, he, Oe);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt) {\n                    var gt = U * 4, Et = U * 8;\n                    return this.float32[gt + 0] = $2, this.float32[gt + 1] = ae, this.float32[gt + 2] = he, this.int16[Et + 6] = Oe, this.int16[Et + 7] = rt, U;\n                  }, y3;\n                })(en);\n                Vi.prototype.bytesPerElement = 16, X("StructArrayLayout2f1f2i16", Vi);\n                var Ni = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he) {\n                    var Oe = this.length;\n                    return this.resize(Oe + 1), this.emplace(Oe, U, $2, ae, he);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe) {\n                    var rt = U * 12, gt = U * 3;\n                    return this.uint8[rt + 0] = $2, this.uint8[rt + 1] = ae, this.float32[gt + 1] = he, this.float32[gt + 2] = Oe, U;\n                  }, y3;\n                })(en);\n                Ni.prototype.bytesPerElement = 12, X("StructArrayLayout2ub2f12", Ni);\n                var pn = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae) {\n                    var he = this.length;\n                    return this.resize(he + 1), this.emplace(he, U, $2, ae);\n                  }, y3.prototype.emplace = function(U, $2, ae, he) {\n                    var Oe = U * 3;\n                    return this.uint16[Oe + 0] = $2, this.uint16[Oe + 1] = ae, this.uint16[Oe + 2] = he, U;\n                  }, y3;\n                })(en);\n                pn.prototype.bytesPerElement = 6, X("StructArrayLayout3ui6", pn);\n                var Vn = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn) {\n                    var xn = this.length;\n                    return this.resize(xn + 1), this.emplace(xn, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn) {\n                    var Pn = U * 24, Zn = U * 12, ga = U * 48;\n                    return this.int16[Pn + 0] = $2, this.int16[Pn + 1] = ae, this.uint16[Pn + 2] = he, this.uint16[Pn + 3] = Oe, this.uint32[Zn + 2] = rt, this.uint32[Zn + 3] = gt, this.uint32[Zn + 4] = Et, this.uint16[Pn + 10] = or, this.uint16[Pn + 11] = _r, this.uint16[Pn + 12] = pr, this.float32[Zn + 7] = Fr, this.float32[Zn + 8] = oi, this.uint8[ga + 36] = Hi, this.uint8[ga + 37] = Ai, this.uint8[ga + 38] = bn, this.uint32[Zn + 10] = nn, this.int16[Pn + 22] = xn, U;\n                  }, y3;\n                })(en);\n                Vn.prototype.bytesPerElement = 48, X("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", Vn);\n                var na = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Ko, to, ao) {\n                    var _s = this.length;\n                    return this.resize(_s + 1), this.emplace(_s, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Ko, to, ao);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha, eo, za, Za, Ko, to, ao, _s) {\n                    var jo = U * 34, El = U * 17;\n                    return this.int16[jo + 0] = $2, this.int16[jo + 1] = ae, this.int16[jo + 2] = he, this.int16[jo + 3] = Oe, this.int16[jo + 4] = rt, this.int16[jo + 5] = gt, this.int16[jo + 6] = Et, this.int16[jo + 7] = or, this.uint16[jo + 8] = _r, this.uint16[jo + 9] = pr, this.uint16[jo + 10] = Fr, this.uint16[jo + 11] = oi, this.uint16[jo + 12] = Hi, this.uint16[jo + 13] = Ai, this.uint16[jo + 14] = bn, this.uint16[jo + 15] = nn, this.uint16[jo + 16] = xn, this.uint16[jo + 17] = Pn, this.uint16[jo + 18] = Zn, this.uint16[jo + 19] = ga, this.uint16[jo + 20] = ha, this.uint16[jo + 21] = eo, this.uint16[jo + 22] = za, this.uint32[El + 12] = Za, this.float32[El + 13] = Ko, this.float32[El + 14] = to, this.float32[El + 15] = ao, this.float32[El + 16] = _s, U;\n                  }, y3;\n                })(en);\n                na.prototype.bytesPerElement = 68, X("StructArrayLayout8i15ui1ul4f68", na);\n                var Ki = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U) {\n                    var $2 = this.length;\n                    return this.resize($2 + 1), this.emplace($2, U);\n                  }, y3.prototype.emplace = function(U, $2) {\n                    var ae = U * 1;\n                    return this.float32[ae + 0] = $2, U;\n                  }, y3;\n                })(en);\n                Ki.prototype.bytesPerElement = 4, X("StructArrayLayout1f4", Ki);\n                var kn = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae) {\n                    var he = this.length;\n                    return this.resize(he + 1), this.emplace(he, U, $2, ae);\n                  }, y3.prototype.emplace = function(U, $2, ae, he) {\n                    var Oe = U * 3;\n                    return this.int16[Oe + 0] = $2, this.int16[Oe + 1] = ae, this.int16[Oe + 2] = he, U;\n                  }, y3;\n                })(en);\n                kn.prototype.bytesPerElement = 6, X("StructArrayLayout3i6", kn);\n                var ta = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae) {\n                    var he = this.length;\n                    return this.resize(he + 1), this.emplace(he, U, $2, ae);\n                  }, y3.prototype.emplace = function(U, $2, ae, he) {\n                    var Oe = U * 2, rt = U * 4;\n                    return this.uint32[Oe + 0] = $2, this.uint16[rt + 2] = ae, this.uint16[rt + 3] = he, U;\n                  }, y3;\n                })(en);\n                ta.prototype.bytesPerElement = 8, X("StructArrayLayout1ul2ui8", ta);\n                var oa = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2) {\n                    var ae = this.length;\n                    return this.resize(ae + 1), this.emplace(ae, U, $2);\n                  }, y3.prototype.emplace = function(U, $2, ae) {\n                    var he = U * 2;\n                    return this.uint16[he + 0] = $2, this.uint16[he + 1] = ae, U;\n                  }, y3;\n                })(en);\n                oa.prototype.bytesPerElement = 4, X("StructArrayLayout2ui4", oa);\n                var ba = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U) {\n                    var $2 = this.length;\n                    return this.resize($2 + 1), this.emplace($2, U);\n                  }, y3.prototype.emplace = function(U, $2) {\n                    var ae = U * 1;\n                    return this.uint16[ae + 0] = $2, U;\n                  }, y3;\n                })(en);\n                ba.prototype.bytesPerElement = 2, X("StructArrayLayout1ui2", ba);\n                var is = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._refreshViews = function() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }, y3.prototype.emplaceBack = function(U, $2, ae, he) {\n                    var Oe = this.length;\n                    return this.resize(Oe + 1), this.emplace(Oe, U, $2, ae, he);\n                  }, y3.prototype.emplace = function(U, $2, ae, he, Oe) {\n                    var rt = U * 4;\n                    return this.float32[rt + 0] = $2, this.float32[rt + 1] = ae, this.float32[rt + 2] = he, this.float32[rt + 3] = Oe, U;\n                  }, y3;\n                })(en);\n                is.prototype.bytesPerElement = 16, X("StructArrayLayout4f16", is);\n                var Zs = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3;\n                  var I3 = { anchorPointX: { configurable: true }, anchorPointY: { configurable: true }, x1: { configurable: true }, y1: { configurable: true }, x2: { configurable: true }, y2: { configurable: true }, featureIndex: { configurable: true }, sourceLayerIndex: { configurable: true }, bucketIndex: { configurable: true }, anchorPoint: { configurable: true } };\n                  return I3.anchorPointX.get = function() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }, I3.anchorPointY.get = function() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }, I3.x1.get = function() {\n                    return this._structArray.int16[this._pos2 + 2];\n                  }, I3.y1.get = function() {\n                    return this._structArray.int16[this._pos2 + 3];\n                  }, I3.x2.get = function() {\n                    return this._structArray.int16[this._pos2 + 4];\n                  }, I3.y2.get = function() {\n                    return this._structArray.int16[this._pos2 + 5];\n                  }, I3.featureIndex.get = function() {\n                    return this._structArray.uint32[this._pos4 + 3];\n                  }, I3.sourceLayerIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 8];\n                  }, I3.bucketIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 9];\n                  }, I3.anchorPoint.get = function() {\n                    return new u4(this.anchorPointX, this.anchorPointY);\n                  }, Object.defineProperties(y3.prototype, I3), y3;\n                })(qi);\n                Zs.prototype.size = 20;\n                var Va = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.get = function(U) {\n                    return new Zs(this, U);\n                  }, y3;\n                })(mn);\n                X("CollisionBoxArray", Va);\n                var Ml = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3;\n                  var I3 = { anchorX: { configurable: true }, anchorY: { configurable: true }, glyphStartIndex: { configurable: true }, numGlyphs: { configurable: true }, vertexStartIndex: { configurable: true }, lineStartIndex: { configurable: true }, lineLength: { configurable: true }, segment: { configurable: true }, lowerSize: { configurable: true }, upperSize: { configurable: true }, lineOffsetX: { configurable: true }, lineOffsetY: { configurable: true }, writingMode: { configurable: true }, placedOrientation: { configurable: true }, hidden: { configurable: true }, crossTileID: { configurable: true }, associatedIconIndex: { configurable: true } };\n                  return I3.anchorX.get = function() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }, I3.anchorY.get = function() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }, I3.glyphStartIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 2];\n                  }, I3.numGlyphs.get = function() {\n                    return this._structArray.uint16[this._pos2 + 3];\n                  }, I3.vertexStartIndex.get = function() {\n                    return this._structArray.uint32[this._pos4 + 2];\n                  }, I3.lineStartIndex.get = function() {\n                    return this._structArray.uint32[this._pos4 + 3];\n                  }, I3.lineLength.get = function() {\n                    return this._structArray.uint32[this._pos4 + 4];\n                  }, I3.segment.get = function() {\n                    return this._structArray.uint16[this._pos2 + 10];\n                  }, I3.lowerSize.get = function() {\n                    return this._structArray.uint16[this._pos2 + 11];\n                  }, I3.upperSize.get = function() {\n                    return this._structArray.uint16[this._pos2 + 12];\n                  }, I3.lineOffsetX.get = function() {\n                    return this._structArray.float32[this._pos4 + 7];\n                  }, I3.lineOffsetY.get = function() {\n                    return this._structArray.float32[this._pos4 + 8];\n                  }, I3.writingMode.get = function() {\n                    return this._structArray.uint8[this._pos1 + 36];\n                  }, I3.placedOrientation.get = function() {\n                    return this._structArray.uint8[this._pos1 + 37];\n                  }, I3.placedOrientation.set = function(U) {\n                    this._structArray.uint8[this._pos1 + 37] = U;\n                  }, I3.hidden.get = function() {\n                    return this._structArray.uint8[this._pos1 + 38];\n                  }, I3.hidden.set = function(U) {\n                    this._structArray.uint8[this._pos1 + 38] = U;\n                  }, I3.crossTileID.get = function() {\n                    return this._structArray.uint32[this._pos4 + 10];\n                  }, I3.crossTileID.set = function(U) {\n                    this._structArray.uint32[this._pos4 + 10] = U;\n                  }, I3.associatedIconIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 22];\n                  }, Object.defineProperties(y3.prototype, I3), y3;\n                })(qi);\n                Ml.prototype.size = 48;\n                var zo = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.get = function(U) {\n                    return new Ml(this, U);\n                  }, y3;\n                })(Vn);\n                X("PlacedSymbolArray", zo);\n                var Qs = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3;\n                  var I3 = { anchorX: { configurable: true }, anchorY: { configurable: true }, rightJustifiedTextSymbolIndex: { configurable: true }, centerJustifiedTextSymbolIndex: { configurable: true }, leftJustifiedTextSymbolIndex: { configurable: true }, verticalPlacedTextSymbolIndex: { configurable: true }, placedIconSymbolIndex: { configurable: true }, verticalPlacedIconSymbolIndex: { configurable: true }, key: { configurable: true }, textBoxStartIndex: { configurable: true }, textBoxEndIndex: { configurable: true }, verticalTextBoxStartIndex: { configurable: true }, verticalTextBoxEndIndex: { configurable: true }, iconBoxStartIndex: { configurable: true }, iconBoxEndIndex: { configurable: true }, verticalIconBoxStartIndex: { configurable: true }, verticalIconBoxEndIndex: { configurable: true }, featureIndex: { configurable: true }, numHorizontalGlyphVertices: { configurable: true }, numVerticalGlyphVertices: { configurable: true }, numIconVertices: { configurable: true }, numVerticalIconVertices: { configurable: true }, useRuntimeCollisionCircles: { configurable: true }, crossTileID: { configurable: true }, textBoxScale: { configurable: true }, textOffset0: { configurable: true }, textOffset1: { configurable: true }, collisionCircleDiameter: { configurable: true } };\n                  return I3.anchorX.get = function() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }, I3.anchorY.get = function() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }, I3.rightJustifiedTextSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 2];\n                  }, I3.centerJustifiedTextSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 3];\n                  }, I3.leftJustifiedTextSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 4];\n                  }, I3.verticalPlacedTextSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 5];\n                  }, I3.placedIconSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 6];\n                  }, I3.verticalPlacedIconSymbolIndex.get = function() {\n                    return this._structArray.int16[this._pos2 + 7];\n                  }, I3.key.get = function() {\n                    return this._structArray.uint16[this._pos2 + 8];\n                  }, I3.textBoxStartIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 9];\n                  }, I3.textBoxEndIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 10];\n                  }, I3.verticalTextBoxStartIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 11];\n                  }, I3.verticalTextBoxEndIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 12];\n                  }, I3.iconBoxStartIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 13];\n                  }, I3.iconBoxEndIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 14];\n                  }, I3.verticalIconBoxStartIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 15];\n                  }, I3.verticalIconBoxEndIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 16];\n                  }, I3.featureIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 17];\n                  }, I3.numHorizontalGlyphVertices.get = function() {\n                    return this._structArray.uint16[this._pos2 + 18];\n                  }, I3.numVerticalGlyphVertices.get = function() {\n                    return this._structArray.uint16[this._pos2 + 19];\n                  }, I3.numIconVertices.get = function() {\n                    return this._structArray.uint16[this._pos2 + 20];\n                  }, I3.numVerticalIconVertices.get = function() {\n                    return this._structArray.uint16[this._pos2 + 21];\n                  }, I3.useRuntimeCollisionCircles.get = function() {\n                    return this._structArray.uint16[this._pos2 + 22];\n                  }, I3.crossTileID.get = function() {\n                    return this._structArray.uint32[this._pos4 + 12];\n                  }, I3.crossTileID.set = function(U) {\n                    this._structArray.uint32[this._pos4 + 12] = U;\n                  }, I3.textBoxScale.get = function() {\n                    return this._structArray.float32[this._pos4 + 13];\n                  }, I3.textOffset0.get = function() {\n                    return this._structArray.float32[this._pos4 + 14];\n                  }, I3.textOffset1.get = function() {\n                    return this._structArray.float32[this._pos4 + 15];\n                  }, I3.collisionCircleDiameter.get = function() {\n                    return this._structArray.float32[this._pos4 + 16];\n                  }, Object.defineProperties(y3.prototype, I3), y3;\n                })(qi);\n                Qs.prototype.size = 68;\n                var al = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.get = function(U) {\n                    return new Qs(this, U);\n                  }, y3;\n                })(na);\n                X("SymbolInstanceArray", al);\n                var Vl = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.getoffsetX = function(U) {\n                    return this.float32[U * 1 + 0];\n                  }, y3;\n                })(Ki);\n                X("GlyphOffsetArray", Vl);\n                var ss = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.getx = function(U) {\n                    return this.int16[U * 3 + 0];\n                  }, y3.prototype.gety = function(U) {\n                    return this.int16[U * 3 + 1];\n                  }, y3.prototype.gettileUnitDistanceFromAnchor = function(U) {\n                    return this.int16[U * 3 + 2];\n                  }, y3;\n                })(kn);\n                X("SymbolLineVertexArray", ss);\n                var Vs = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3;\n                  var I3 = { featureIndex: { configurable: true }, sourceLayerIndex: { configurable: true }, bucketIndex: { configurable: true } };\n                  return I3.featureIndex.get = function() {\n                    return this._structArray.uint32[this._pos4 + 0];\n                  }, I3.sourceLayerIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 2];\n                  }, I3.bucketIndex.get = function() {\n                    return this._structArray.uint16[this._pos2 + 3];\n                  }, Object.defineProperties(y3.prototype, I3), y3;\n                })(qi);\n                Vs.prototype.size = 8;\n                var Ys = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.get = function(U) {\n                    return new Vs(this, U);\n                  }, y3;\n                })(ta);\n                X("FeatureIndexArray", Ys);\n                var wa = Wi([{ name: "a_pos", components: 2, type: "Int16" }], 4), ol = wa.members, io = function(y3) {\n                  y3 === void 0 && (y3 = []), this.segments = y3;\n                };\n                io.prototype.prepareSegment = function(y3, I3, U, $2) {\n                  var ae = this.segments[this.segments.length - 1];\n                  return y3 > io.MAX_VERTEX_ARRAY_LENGTH && te("Max vertices per segment is " + io.MAX_VERTEX_ARRAY_LENGTH + ": bucket requested " + y3), (!ae || ae.vertexLength + y3 > io.MAX_VERTEX_ARRAY_LENGTH || ae.sortKey !== $2) && (ae = { vertexOffset: I3.length, primitiveOffset: U.length, vertexLength: 0, primitiveLength: 0 }, $2 !== void 0 && (ae.sortKey = $2), this.segments.push(ae)), ae;\n                }, io.prototype.get = function() {\n                  return this.segments;\n                }, io.prototype.destroy = function() {\n                  for (var y3 = 0, I3 = this.segments; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    for (var $2 in U.vaos) U.vaos[$2].destroy();\n                  }\n                }, io.simpleSegment = function(y3, I3, U, $2) {\n                  return new io([{ vertexOffset: y3, primitiveOffset: I3, vertexLength: U, primitiveLength: $2, vaos: {}, sortKey: 0 }]);\n                }, io.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, X("SegmentVector", io);\n                function Y(m3, y3) {\n                  return m3 = p3(Math.floor(m3), 0, 255), y3 = p3(Math.floor(y3), 0, 255), 256 * m3 + y3;\n                }\n                var D3 = Wi([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]), J = a4(function(m3) {\n                  function y3(I3, U) {\n                    var $2, ae, he, Oe, rt, gt, Et, or;\n                    for ($2 = I3.length & 3, ae = I3.length - $2, he = U, rt = 3432918353, gt = 461845907, or = 0; or < ae; ) Et = I3.charCodeAt(or) & 255 | (I3.charCodeAt(++or) & 255) << 8 | (I3.charCodeAt(++or) & 255) << 16 | (I3.charCodeAt(++or) & 255) << 24, ++or, Et = (Et & 65535) * rt + (((Et >>> 16) * rt & 65535) << 16) & 4294967295, Et = Et << 15 | Et >>> 17, Et = (Et & 65535) * gt + (((Et >>> 16) * gt & 65535) << 16) & 4294967295, he ^= Et, he = he << 13 | he >>> 19, Oe = (he & 65535) * 5 + (((he >>> 16) * 5 & 65535) << 16) & 4294967295, he = (Oe & 65535) + 27492 + (((Oe >>> 16) + 58964 & 65535) << 16);\n                    switch (Et = 0, $2) {\n                      case 3:\n                        Et ^= (I3.charCodeAt(or + 2) & 255) << 16;\n                      case 2:\n                        Et ^= (I3.charCodeAt(or + 1) & 255) << 8;\n                      case 1:\n                        Et ^= I3.charCodeAt(or) & 255, Et = (Et & 65535) * rt + (((Et >>> 16) * rt & 65535) << 16) & 4294967295, Et = Et << 15 | Et >>> 17, Et = (Et & 65535) * gt + (((Et >>> 16) * gt & 65535) << 16) & 4294967295, he ^= Et;\n                    }\n                    return he ^= I3.length, he ^= he >>> 16, he = (he & 65535) * 2246822507 + (((he >>> 16) * 2246822507 & 65535) << 16) & 4294967295, he ^= he >>> 13, he = (he & 65535) * 3266489909 + (((he >>> 16) * 3266489909 & 65535) << 16) & 4294967295, he ^= he >>> 16, he >>> 0;\n                  }\n                  m3.exports = y3;\n                }), q2 = a4(function(m3) {\n                  function y3(I3, U) {\n                    for (var $2 = I3.length, ae = U ^ $2, he = 0, Oe; $2 >= 4; ) Oe = I3.charCodeAt(he) & 255 | (I3.charCodeAt(++he) & 255) << 8 | (I3.charCodeAt(++he) & 255) << 16 | (I3.charCodeAt(++he) & 255) << 24, Oe = (Oe & 65535) * 1540483477 + (((Oe >>> 16) * 1540483477 & 65535) << 16), Oe ^= Oe >>> 24, Oe = (Oe & 65535) * 1540483477 + (((Oe >>> 16) * 1540483477 & 65535) << 16), ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16) ^ Oe, $2 -= 4, ++he;\n                    switch ($2) {\n                      case 3:\n                        ae ^= (I3.charCodeAt(he + 2) & 255) << 16;\n                      case 2:\n                        ae ^= (I3.charCodeAt(he + 1) & 255) << 8;\n                      case 1:\n                        ae ^= I3.charCodeAt(he) & 255, ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16);\n                    }\n                    return ae ^= ae >>> 13, ae = (ae & 65535) * 1540483477 + (((ae >>> 16) * 1540483477 & 65535) << 16), ae ^= ae >>> 15, ae >>> 0;\n                  }\n                  m3.exports = y3;\n                }), K = J, de = J, ne = q2;\n                K.murmur3 = de, K.murmur2 = ne;\n                var we = function() {\n                  this.ids = [], this.positions = [], this.indexed = false;\n                };\n                we.prototype.add = function(y3, I3, U, $2) {\n                  this.ids.push(ft(y3)), this.positions.push(I3, U, $2);\n                }, we.prototype.getPositions = function(y3) {\n                  for (var I3 = ft(y3), U = 0, $2 = this.ids.length - 1; U < $2; ) {\n                    var ae = U + $2 >> 1;\n                    this.ids[ae] >= I3 ? $2 = ae : U = ae + 1;\n                  }\n                  for (var he = []; this.ids[U] === I3; ) {\n                    var Oe = this.positions[3 * U], rt = this.positions[3 * U + 1], gt = this.positions[3 * U + 2];\n                    he.push({ index: Oe, start: rt, end: gt }), U++;\n                  }\n                  return he;\n                }, we.serialize = function(y3, I3) {\n                  var U = new Float64Array(y3.ids), $2 = new Uint32Array(y3.positions);\n                  return Xt(U, $2, 0, U.length - 1), I3 && I3.push(U.buffer, $2.buffer), { ids: U, positions: $2 };\n                }, we.deserialize = function(y3) {\n                  var I3 = new we();\n                  return I3.ids = y3.ids, I3.positions = y3.positions, I3.indexed = true, I3;\n                };\n                var Ue = Math.pow(2, 53) - 1;\n                function ft(m3) {\n                  var y3 = +m3;\n                  return !isNaN(y3) && y3 <= Ue ? y3 : K(String(m3));\n                }\n                function Xt(m3, y3, I3, U) {\n                  for (; I3 < U; ) {\n                    for (var $2 = m3[I3 + U >> 1], ae = I3 - 1, he = U + 1; ; ) {\n                      do\n                        ae++;\n                      while (m3[ae] < $2);\n                      do\n                        he--;\n                      while (m3[he] > $2);\n                      if (ae >= he) break;\n                      hr(m3, ae, he), hr(y3, 3 * ae, 3 * he), hr(y3, 3 * ae + 1, 3 * he + 1), hr(y3, 3 * ae + 2, 3 * he + 2);\n                    }\n                    he - I3 < U - he ? (Xt(m3, y3, I3, he), I3 = he + 1) : (Xt(m3, y3, he + 1, U), U = he);\n                  }\n                }\n                function hr(m3, y3, I3) {\n                  var U = m3[y3];\n                  m3[y3] = m3[I3], m3[I3] = U;\n                }\n                X("FeaturePositionMap", we);\n                var qt = function(y3, I3) {\n                  this.gl = y3.gl, this.location = I3;\n                }, Ve = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = 0;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    this.current !== U && (this.current = U, this.gl.uniform1i(this.location, U));\n                  }, y3;\n                })(qt), Qe = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = 0;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    this.current !== U && (this.current = U, this.gl.uniform1f(this.location, U));\n                  }, y3;\n                })(qt), at = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = [0, 0];\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    (U[0] !== this.current[0] || U[1] !== this.current[1]) && (this.current = U, this.gl.uniform2f(this.location, U[0], U[1]));\n                  }, y3;\n                })(qt), Ct = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = [0, 0, 0];\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    (U[0] !== this.current[0] || U[1] !== this.current[1] || U[2] !== this.current[2]) && (this.current = U, this.gl.uniform3f(this.location, U[0], U[1], U[2]));\n                  }, y3;\n                })(qt), Ot = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = [0, 0, 0, 0];\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    (U[0] !== this.current[0] || U[1] !== this.current[1] || U[2] !== this.current[2] || U[3] !== this.current[3]) && (this.current = U, this.gl.uniform4f(this.location, U[0], U[1], U[2], U[3]));\n                  }, y3;\n                })(qt), Rt = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = cs.transparent;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    (U.r !== this.current.r || U.g !== this.current.g || U.b !== this.current.b || U.a !== this.current.a) && (this.current = U, this.gl.uniform4f(this.location, U.r, U.g, U.b, U.a));\n                  }, y3;\n                })(qt), Bt = new Float32Array(16), Dt = (function(m3) {\n                  function y3(I3, U) {\n                    m3.call(this, I3, U), this.current = Bt;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.set = function(U) {\n                    if (U[12] !== this.current[12] || U[0] !== this.current[0]) {\n                      this.current = U, this.gl.uniformMatrix4fv(this.location, false, U);\n                      return;\n                    }\n                    for (var $2 = 1; $2 < 16; $2++) if (U[$2] !== this.current[$2]) {\n                      this.current = U, this.gl.uniformMatrix4fv(this.location, false, U);\n                      break;\n                    }\n                  }, y3;\n                })(qt);\n                function yt(m3) {\n                  return [Y(255 * m3.r, 255 * m3.g), Y(255 * m3.b, 255 * m3.a)];\n                }\n                var Pt = function(y3, I3, U) {\n                  this.value = y3, this.uniformNames = I3.map(function($2) {\n                    return "u_" + $2;\n                  }), this.type = U;\n                };\n                Pt.prototype.setUniform = function(y3, I3, U) {\n                  y3.set(U.constantOr(this.value));\n                }, Pt.prototype.getBinding = function(y3, I3, U) {\n                  return this.type === "color" ? new Rt(y3, I3) : new Qe(y3, I3);\n                };\n                var ht = function(y3, I3) {\n                  this.uniformNames = I3.map(function(U) {\n                    return "u_" + U;\n                  }), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;\n                };\n                ht.prototype.setConstantPatternPositions = function(y3, I3) {\n                  this.pixelRatioFrom = I3.pixelRatio, this.pixelRatioTo = y3.pixelRatio, this.patternFrom = I3.tlbr, this.patternTo = y3.tlbr;\n                }, ht.prototype.setUniform = function(y3, I3, U, $2) {\n                  var ae = $2 === "u_pattern_to" ? this.patternTo : $2 === "u_pattern_from" ? this.patternFrom : $2 === "u_pixel_ratio_to" ? this.pixelRatioTo : $2 === "u_pixel_ratio_from" ? this.pixelRatioFrom : null;\n                  ae && y3.set(ae);\n                }, ht.prototype.getBinding = function(y3, I3, U) {\n                  return U.substr(0, 9) === "u_pattern" ? new Ot(y3, I3) : new Qe(y3, I3);\n                };\n                var ur = function(y3, I3, U, $2) {\n                  this.expression = y3, this.type = U, this.maxValue = 0, this.paintVertexAttributes = I3.map(function(ae) {\n                    return { name: "a_" + ae, type: "Float32", components: U === "color" ? 2 : 1, offset: 0 };\n                  }), this.paintVertexArray = new $2();\n                };\n                ur.prototype.populatePaintArray = function(y3, I3, U, $2, ae) {\n                  var he = this.paintVertexArray.length, Oe = this.expression.evaluate(new Gn(0), I3, {}, $2, [], ae);\n                  this.paintVertexArray.resize(y3), this._setPaintValue(he, y3, Oe);\n                }, ur.prototype.updatePaintArray = function(y3, I3, U, $2) {\n                  var ae = this.expression.evaluate({ zoom: 0 }, U, $2);\n                  this._setPaintValue(y3, I3, ae);\n                }, ur.prototype._setPaintValue = function(y3, I3, U) {\n                  if (this.type === "color") for (var $2 = yt(U), ae = y3; ae < I3; ae++) this.paintVertexArray.emplace(ae, $2[0], $2[1]);\n                  else {\n                    for (var he = y3; he < I3; he++) this.paintVertexArray.emplace(he, U);\n                    this.maxValue = Math.max(this.maxValue, Math.abs(U));\n                  }\n                }, ur.prototype.upload = function(y3) {\n                  this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = y3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));\n                }, ur.prototype.destroy = function() {\n                  this.paintVertexBuffer && this.paintVertexBuffer.destroy();\n                };\n                var br = function(y3, I3, U, $2, ae, he) {\n                  this.expression = y3, this.uniformNames = I3.map(function(Oe) {\n                    return "u_" + Oe + "_t";\n                  }), this.type = U, this.useIntegerZoom = $2, this.zoom = ae, this.maxValue = 0, this.paintVertexAttributes = I3.map(function(Oe) {\n                    return { name: "a_" + Oe, type: "Float32", components: U === "color" ? 4 : 2, offset: 0 };\n                  }), this.paintVertexArray = new he();\n                };\n                br.prototype.populatePaintArray = function(y3, I3, U, $2, ae) {\n                  var he = this.expression.evaluate(new Gn(this.zoom), I3, {}, $2, [], ae), Oe = this.expression.evaluate(new Gn(this.zoom + 1), I3, {}, $2, [], ae), rt = this.paintVertexArray.length;\n                  this.paintVertexArray.resize(y3), this._setPaintValue(rt, y3, he, Oe);\n                }, br.prototype.updatePaintArray = function(y3, I3, U, $2) {\n                  var ae = this.expression.evaluate({ zoom: this.zoom }, U, $2), he = this.expression.evaluate({ zoom: this.zoom + 1 }, U, $2);\n                  this._setPaintValue(y3, I3, ae, he);\n                }, br.prototype._setPaintValue = function(y3, I3, U, $2) {\n                  if (this.type === "color") for (var ae = yt(U), he = yt($2), Oe = y3; Oe < I3; Oe++) this.paintVertexArray.emplace(Oe, ae[0], ae[1], he[0], he[1]);\n                  else {\n                    for (var rt = y3; rt < I3; rt++) this.paintVertexArray.emplace(rt, U, $2);\n                    this.maxValue = Math.max(this.maxValue, Math.abs(U), Math.abs($2));\n                  }\n                }, br.prototype.upload = function(y3) {\n                  this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = y3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));\n                }, br.prototype.destroy = function() {\n                  this.paintVertexBuffer && this.paintVertexBuffer.destroy();\n                }, br.prototype.setUniform = function(y3, I3) {\n                  var U = this.useIntegerZoom ? Math.floor(I3.zoom) : I3.zoom, $2 = p3(this.expression.interpolationFactor(U, this.zoom, this.zoom + 1), 0, 1);\n                  y3.set($2);\n                }, br.prototype.getBinding = function(y3, I3, U) {\n                  return new Qe(y3, I3);\n                };\n                var Ur = function(y3, I3, U, $2, ae, he) {\n                  this.expression = y3, this.type = I3, this.useIntegerZoom = U, this.zoom = $2, this.layerId = he, this.zoomInPaintVertexArray = new ae(), this.zoomOutPaintVertexArray = new ae();\n                };\n                Ur.prototype.populatePaintArray = function(y3, I3, U) {\n                  var $2 = this.zoomInPaintVertexArray.length;\n                  this.zoomInPaintVertexArray.resize(y3), this.zoomOutPaintVertexArray.resize(y3), this._setPaintValues($2, y3, I3.patterns && I3.patterns[this.layerId], U);\n                }, Ur.prototype.updatePaintArray = function(y3, I3, U, $2, ae) {\n                  this._setPaintValues(y3, I3, U.patterns && U.patterns[this.layerId], ae);\n                }, Ur.prototype._setPaintValues = function(y3, I3, U, $2) {\n                  if (!(!$2 || !U)) {\n                    var ae = U.min, he = U.mid, Oe = U.max, rt = $2[ae], gt = $2[he], Et = $2[Oe];\n                    if (!(!rt || !gt || !Et)) for (var or = y3; or < I3; or++) this.zoomInPaintVertexArray.emplace(or, gt.tl[0], gt.tl[1], gt.br[0], gt.br[1], rt.tl[0], rt.tl[1], rt.br[0], rt.br[1], gt.pixelRatio, rt.pixelRatio), this.zoomOutPaintVertexArray.emplace(or, gt.tl[0], gt.tl[1], gt.br[0], gt.br[1], Et.tl[0], Et.tl[1], Et.br[0], Et.br[1], gt.pixelRatio, Et.pixelRatio);\n                  }\n                }, Ur.prototype.upload = function(y3) {\n                  this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer && (this.zoomInPaintVertexBuffer = y3.createVertexBuffer(this.zoomInPaintVertexArray, D3.members, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = y3.createVertexBuffer(this.zoomOutPaintVertexArray, D3.members, this.expression.isStateDependent));\n                }, Ur.prototype.destroy = function() {\n                  this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();\n                };\n                var Di = function(y3, I3, U) {\n                  this.binders = {}, this._buffers = [];\n                  var $2 = [];\n                  for (var ae in y3.paint._values) if (U(ae)) {\n                    var he = y3.paint.get(ae);\n                    if (!(!(he instanceof dl) || !Ws(he.property.specification))) {\n                      var Oe = Ti(ae, y3.type), rt = he.value, gt = he.property.specification.type, Et = he.property.useIntegerZoom, or = he.property.specification["property-type"], _r = or === "cross-faded" || or === "cross-faded-data-driven";\n                      if (rt.kind === "constant") this.binders[ae] = _r ? new ht(rt.value, Oe) : new Pt(rt.value, Oe, gt), $2.push("/u_" + ae);\n                      else if (rt.kind === "source" || _r) {\n                        var pr = rn(ae, gt, "source");\n                        this.binders[ae] = _r ? new Ur(rt, gt, Et, I3, pr, y3.id) : new ur(rt, Oe, gt, pr), $2.push("/a_" + ae);\n                      } else {\n                        var Fr = rn(ae, gt, "composite");\n                        this.binders[ae] = new br(rt, Oe, gt, Et, I3, Fr), $2.push("/z_" + ae);\n                      }\n                    }\n                  }\n                  this.cacheKey = $2.sort().join("");\n                };\n                Di.prototype.getMaxValue = function(y3) {\n                  var I3 = this.binders[y3];\n                  return I3 instanceof ur || I3 instanceof br ? I3.maxValue : 0;\n                }, Di.prototype.populatePaintArrays = function(y3, I3, U, $2, ae) {\n                  for (var he in this.binders) {\n                    var Oe = this.binders[he];\n                    (Oe instanceof ur || Oe instanceof br || Oe instanceof Ur) && Oe.populatePaintArray(y3, I3, U, $2, ae);\n                  }\n                }, Di.prototype.setConstantPatternPositions = function(y3, I3) {\n                  for (var U in this.binders) {\n                    var $2 = this.binders[U];\n                    $2 instanceof ht && $2.setConstantPatternPositions(y3, I3);\n                  }\n                }, Di.prototype.updatePaintArrays = function(y3, I3, U, $2, ae) {\n                  var he = false;\n                  for (var Oe in y3) for (var rt = I3.getPositions(Oe), gt = 0, Et = rt; gt < Et.length; gt += 1) {\n                    var or = Et[gt], _r = U.feature(or.index);\n                    for (var pr in this.binders) {\n                      var Fr = this.binders[pr];\n                      if ((Fr instanceof ur || Fr instanceof br || Fr instanceof Ur) && Fr.expression.isStateDependent === true) {\n                        var oi = $2.paint.get(pr);\n                        Fr.expression = oi.value, Fr.updatePaintArray(or.start, or.end, _r, y3[Oe], ae), he = true;\n                      }\n                    }\n                  }\n                  return he;\n                }, Di.prototype.defines = function() {\n                  var y3 = [];\n                  for (var I3 in this.binders) {\n                    var U = this.binders[I3];\n                    (U instanceof Pt || U instanceof ht) && y3.push.apply(y3, U.uniformNames.map(function($2) {\n                      return "#define HAS_UNIFORM_" + $2;\n                    }));\n                  }\n                  return y3;\n                }, Di.prototype.getBinderAttributes = function() {\n                  var y3 = [];\n                  for (var I3 in this.binders) {\n                    var U = this.binders[I3];\n                    if (U instanceof ur || U instanceof br) for (var $2 = 0; $2 < U.paintVertexAttributes.length; $2++) y3.push(U.paintVertexAttributes[$2].name);\n                    else if (U instanceof Ur) for (var ae = 0; ae < D3.members.length; ae++) y3.push(D3.members[ae].name);\n                  }\n                  return y3;\n                }, Di.prototype.getBinderUniforms = function() {\n                  var y3 = [];\n                  for (var I3 in this.binders) {\n                    var U = this.binders[I3];\n                    if (U instanceof Pt || U instanceof ht || U instanceof br) for (var $2 = 0, ae = U.uniformNames; $2 < ae.length; $2 += 1) {\n                      var he = ae[$2];\n                      y3.push(he);\n                    }\n                  }\n                  return y3;\n                }, Di.prototype.getPaintVertexBuffers = function() {\n                  return this._buffers;\n                }, Di.prototype.getUniforms = function(y3, I3) {\n                  var U = [];\n                  for (var $2 in this.binders) {\n                    var ae = this.binders[$2];\n                    if (ae instanceof Pt || ae instanceof ht || ae instanceof br) for (var he = 0, Oe = ae.uniformNames; he < Oe.length; he += 1) {\n                      var rt = Oe[he];\n                      if (I3[rt]) {\n                        var gt = ae.getBinding(y3, I3[rt], rt);\n                        U.push({ name: rt, property: $2, binding: gt });\n                      }\n                    }\n                  }\n                  return U;\n                }, Di.prototype.setUniforms = function(y3, I3, U, $2) {\n                  for (var ae = 0, he = I3; ae < he.length; ae += 1) {\n                    var Oe = he[ae], rt = Oe.name, gt = Oe.property, Et = Oe.binding;\n                    this.binders[gt].setUniform(Et, $2, U.get(gt), rt);\n                  }\n                }, Di.prototype.updatePaintBuffers = function(y3) {\n                  this._buffers = [];\n                  for (var I3 in this.binders) {\n                    var U = this.binders[I3];\n                    if (y3 && U instanceof Ur) {\n                      var $2 = y3.fromScale === 2 ? U.zoomInPaintVertexBuffer : U.zoomOutPaintVertexBuffer;\n                      $2 && this._buffers.push($2);\n                    } else (U instanceof ur || U instanceof br) && U.paintVertexBuffer && this._buffers.push(U.paintVertexBuffer);\n                  }\n                }, Di.prototype.upload = function(y3) {\n                  for (var I3 in this.binders) {\n                    var U = this.binders[I3];\n                    (U instanceof ur || U instanceof br || U instanceof Ur) && U.upload(y3);\n                  }\n                  this.updatePaintBuffers();\n                }, Di.prototype.destroy = function() {\n                  for (var y3 in this.binders) {\n                    var I3 = this.binders[y3];\n                    (I3 instanceof ur || I3 instanceof br || I3 instanceof Ur) && I3.destroy();\n                  }\n                };\n                var fi = function(y3, I3, U) {\n                  U === void 0 && (U = function() {\n                    return true;\n                  }), this.programConfigurations = {};\n                  for (var $2 = 0, ae = y3; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    this.programConfigurations[he.id] = new Di(he, I3, U);\n                  }\n                  this.needsUpload = false, this._featureMap = new we(), this._bufferOffset = 0;\n                };\n                fi.prototype.populatePaintArrays = function(y3, I3, U, $2, ae, he) {\n                  for (var Oe in this.programConfigurations) this.programConfigurations[Oe].populatePaintArrays(y3, I3, $2, ae, he);\n                  I3.id !== void 0 && this._featureMap.add(I3.id, U, this._bufferOffset, y3), this._bufferOffset = y3, this.needsUpload = true;\n                }, fi.prototype.updatePaintArrays = function(y3, I3, U, $2) {\n                  for (var ae = 0, he = U; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    this.needsUpload = this.programConfigurations[Oe.id].updatePaintArrays(y3, this._featureMap, I3, Oe, $2) || this.needsUpload;\n                  }\n                }, fi.prototype.get = function(y3) {\n                  return this.programConfigurations[y3];\n                }, fi.prototype.upload = function(y3) {\n                  if (this.needsUpload) {\n                    for (var I3 in this.programConfigurations) this.programConfigurations[I3].upload(y3);\n                    this.needsUpload = false;\n                  }\n                }, fi.prototype.destroy = function() {\n                  for (var y3 in this.programConfigurations) this.programConfigurations[y3].destroy();\n                };\n                function Ti(m3, y3) {\n                  var I3 = { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] };\n                  return I3[m3] || [m3.replace(y3 + "-", "").replace(/-/g, "_")];\n                }\n                function gn(m3) {\n                  var y3 = { "line-pattern": { source: Zi, composite: Zi }, "fill-pattern": { source: Zi, composite: Zi }, "fill-extrusion-pattern": { source: Zi, composite: Zi } };\n                  return y3[m3];\n                }\n                function rn(m3, y3, I3) {\n                  var U = { color: { source: an, composite: is }, number: { source: Ki, composite: an } }, $2 = gn(m3);\n                  return $2 && $2[I3] || U[y3][I3];\n                }\n                X("ConstantBinder", Pt), X("CrossFadedConstantBinder", ht), X("SourceExpressionBinder", ur), X("CrossFadedCompositeBinder", Ur), X("CompositeExpressionBinder", br), X("ProgramConfiguration", Di, { omit: ["_buffers"] }), X("ProgramConfigurationSet", fi);\n                var Ci = 8192, Bi = 15, Gi = Math.pow(2, Bi - 1) - 1, sn = -Gi - 1;\n                function zn(m3) {\n                  for (var y3 = Ci / m3.extent, I3 = m3.loadGeometry(), U = 0; U < I3.length; U++) for (var $2 = I3[U], ae = 0; ae < $2.length; ae++) {\n                    var he = $2[ae], Oe = Math.round(he.x * y3), rt = Math.round(he.y * y3);\n                    he.x = p3(Oe, sn, Gi), he.y = p3(rt, sn, Gi), (Oe < he.x || Oe > he.x + 1 || rt < he.y || rt > he.y + 1) && te("Geometry exceeds allowed extent, reduce your vector tile buffer size");\n                  }\n                  return I3;\n                }\n                function Ja(m3, y3) {\n                  return { type: m3.type, id: m3.id, properties: m3.properties, geometry: y3 ? zn(m3) : [] };\n                }\n                function co(m3, y3, I3, U, $2) {\n                  m3.emplaceBack(y3 * 2 + (U + 1) / 2, I3 * 2 + ($2 + 1) / 2);\n                }\n                var ts = function(y3) {\n                  this.zoom = y3.zoom, this.overscaling = y3.overscaling, this.layers = y3.layers, this.layerIds = this.layers.map(function(I3) {\n                    return I3.id;\n                  }), this.index = y3.index, this.hasPattern = false, this.layoutVertexArray = new Yr(), this.indexArray = new pn(), this.segments = new io(), this.programConfigurations = new fi(y3.layers, y3.zoom), this.stateDependentLayerIds = this.layers.filter(function(I3) {\n                    return I3.isStateDependent();\n                  }).map(function(I3) {\n                    return I3.id;\n                  });\n                };\n                ts.prototype.populate = function(y3, I3, U) {\n                  var $2 = this.layers[0], ae = [], he = null;\n                  $2.type === "circle" && (he = $2.layout.get("circle-sort-key"));\n                  for (var Oe = 0, rt = y3; Oe < rt.length; Oe += 1) {\n                    var gt = rt[Oe], Et = gt.feature, or = gt.id, _r = gt.index, pr = gt.sourceLayerIndex, Fr = this.layers[0]._featureFilter.needGeometry, oi = Ja(Et, Fr);\n                    if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), oi, U)) {\n                      var Hi = he ? he.evaluate(oi, {}, U) : void 0, Ai = { id: or, properties: Et.properties, type: Et.type, sourceLayerIndex: pr, index: _r, geometry: Fr ? oi.geometry : zn(Et), patterns: {}, sortKey: Hi };\n                      ae.push(Ai);\n                    }\n                  }\n                  he && ae.sort(function(za, Za) {\n                    return za.sortKey - Za.sortKey;\n                  });\n                  for (var bn = 0, nn = ae; bn < nn.length; bn += 1) {\n                    var xn = nn[bn], Pn = xn, Zn = Pn.geometry, ga = Pn.index, ha = Pn.sourceLayerIndex, eo = y3[ga].feature;\n                    this.addFeature(xn, Zn, ga, U), I3.featureIndex.insert(eo, Zn, ga, ha, this.index);\n                  }\n                }, ts.prototype.update = function(y3, I3, U) {\n                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y3, I3, this.stateDependentLayers, U);\n                }, ts.prototype.isEmpty = function() {\n                  return this.layoutVertexArray.length === 0;\n                }, ts.prototype.uploadPending = function() {\n                  return !this.uploaded || this.programConfigurations.needsUpload;\n                }, ts.prototype.upload = function(y3) {\n                  this.uploaded || (this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, ol), this.indexBuffer = y3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y3), this.uploaded = true;\n                }, ts.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());\n                }, ts.prototype.addFeature = function(y3, I3, U, $2) {\n                  for (var ae = 0, he = I3; ae < he.length; ae += 1) for (var Oe = he[ae], rt = 0, gt = Oe; rt < gt.length; rt += 1) {\n                    var Et = gt[rt], or = Et.x, _r = Et.y;\n                    if (!(or < 0 || or >= Ci || _r < 0 || _r >= Ci)) {\n                      var pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, y3.sortKey), Fr = pr.vertexLength;\n                      co(this.layoutVertexArray, or, _r, -1, -1), co(this.layoutVertexArray, or, _r, 1, -1), co(this.layoutVertexArray, or, _r, 1, 1), co(this.layoutVertexArray, or, _r, -1, 1), this.indexArray.emplaceBack(Fr, Fr + 1, Fr + 2), this.indexArray.emplaceBack(Fr, Fr + 3, Fr + 2), pr.vertexLength += 4, pr.primitiveLength += 2;\n                    }\n                  }\n                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y3, U, {}, $2);\n                }, X("CircleBucket", ts, { omit: ["layers"] });\n                function so(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) if (Td(y3, m3[I3])) return true;\n                  for (var U = 0; U < y3.length; U++) if (Td(m3, y3[U])) return true;\n                  return !!Lv(m3, y3);\n                }\n                function Zo(m3, y3, I3) {\n                  return !!(Td(m3, y3) || Kv(y3, m3, I3));\n                }\n                function ms(m3, y3) {\n                  if (m3.length === 1) return pp(y3, m3[0]);\n                  for (var I3 = 0; I3 < y3.length; I3++) for (var U = y3[I3], $2 = 0; $2 < U.length; $2++) if (Td(m3, U[$2])) return true;\n                  for (var ae = 0; ae < m3.length; ae++) if (pp(y3, m3[ae])) return true;\n                  for (var he = 0; he < y3.length; he++) if (Lv(m3, y3[he])) return true;\n                  return false;\n                }\n                function ou(m3, y3, I3) {\n                  for (var U = 0; U < y3.length; U++) {\n                    var $2 = y3[U];\n                    if (m3.length >= 3) {\n                      for (var ae = 0; ae < $2.length; ae++) if (Td(m3, $2[ae])) return true;\n                    }\n                    if (Cv(m3, $2, I3)) return true;\n                  }\n                  return false;\n                }\n                function Cv(m3, y3, I3) {\n                  if (m3.length > 1) {\n                    if (Lv(m3, y3)) return true;\n                    for (var U = 0; U < y3.length; U++) if (Kv(y3[U], m3, I3)) return true;\n                  }\n                  for (var $2 = 0; $2 < m3.length; $2++) if (Kv(m3[$2], y3, I3)) return true;\n                  return false;\n                }\n                function Lv(m3, y3) {\n                  if (m3.length === 0 || y3.length === 0) return false;\n                  for (var I3 = 0; I3 < m3.length - 1; I3++) for (var U = m3[I3], $2 = m3[I3 + 1], ae = 0; ae < y3.length - 1; ae++) {\n                    var he = y3[ae], Oe = y3[ae + 1];\n                    if (wd(U, $2, he, Oe)) return true;\n                  }\n                  return false;\n                }\n                function wd(m3, y3, I3, U) {\n                  return oe(m3, I3, U) !== oe(y3, I3, U) && oe(m3, y3, I3) !== oe(m3, y3, U);\n                }\n                function Kv(m3, y3, I3) {\n                  var U = I3 * I3;\n                  if (y3.length === 1) return m3.distSqr(y3[0]) < U;\n                  for (var $2 = 1; $2 < y3.length; $2++) {\n                    var ae = y3[$2 - 1], he = y3[$2];\n                    if (cg(m3, ae, he) < U) return true;\n                  }\n                  return false;\n                }\n                function cg(m3, y3, I3) {\n                  var U = y3.distSqr(I3);\n                  if (U === 0) return m3.distSqr(y3);\n                  var $2 = ((m3.x - y3.x) * (I3.x - y3.x) + (m3.y - y3.y) * (I3.y - y3.y)) / U;\n                  return $2 < 0 ? m3.distSqr(y3) : $2 > 1 ? m3.distSqr(I3) : m3.distSqr(I3.sub(y3)._mult($2)._add(y3));\n                }\n                function pp(m3, y3) {\n                  for (var I3 = false, U, $2, ae, he = 0; he < m3.length; he++) {\n                    U = m3[he];\n                    for (var Oe = 0, rt = U.length - 1; Oe < U.length; rt = Oe++) $2 = U[Oe], ae = U[rt], $2.y > y3.y != ae.y > y3.y && y3.x < (ae.x - $2.x) * (y3.y - $2.y) / (ae.y - $2.y) + $2.x && (I3 = !I3);\n                  }\n                  return I3;\n                }\n                function Td(m3, y3) {\n                  for (var I3 = false, U = 0, $2 = m3.length - 1; U < m3.length; $2 = U++) {\n                    var ae = m3[U], he = m3[$2];\n                    ae.y > y3.y != he.y > y3.y && y3.x < (he.x - ae.x) * (y3.y - ae.y) / (he.y - ae.y) + ae.x && (I3 = !I3);\n                  }\n                  return I3;\n                }\n                function gp(m3, y3, I3, U, $2) {\n                  for (var ae = 0, he = m3; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    if (y3 <= Oe.x && I3 <= Oe.y && U >= Oe.x && $2 >= Oe.y) return true;\n                  }\n                  var rt = [new u4(y3, I3), new u4(y3, $2), new u4(U, $2), new u4(U, I3)];\n                  if (m3.length > 2) for (var gt = 0, Et = rt; gt < Et.length; gt += 1) {\n                    var or = Et[gt];\n                    if (Td(m3, or)) return true;\n                  }\n                  for (var _r = 0; _r < m3.length - 1; _r++) {\n                    var pr = m3[_r], Fr = m3[_r + 1];\n                    if (Vd(pr, Fr, rt)) return true;\n                  }\n                  return false;\n                }\n                function Vd(m3, y3, I3) {\n                  var U = I3[0], $2 = I3[2];\n                  if (m3.x < U.x && y3.x < U.x || m3.x > $2.x && y3.x > $2.x || m3.y < U.y && y3.y < U.y || m3.y > $2.y && y3.y > $2.y) return false;\n                  var ae = oe(m3, y3, I3[0]);\n                  return ae !== oe(m3, y3, I3[1]) || ae !== oe(m3, y3, I3[2]) || ae !== oe(m3, y3, I3[3]);\n                }\n                function Ad(m3, y3, I3) {\n                  var U = y3.paint.get(m3).value;\n                  return U.kind === "constant" ? U.value : I3.programConfigurations.get(y3.id).getMaxValue(m3);\n                }\n                function Pv(m3) {\n                  return Math.sqrt(m3[0] * m3[0] + m3[1] * m3[1]);\n                }\n                function Jv(m3, y3, I3, U, $2) {\n                  if (!y3[0] && !y3[1]) return m3;\n                  var ae = u4.convert(y3)._mult($2);\n                  I3 === "viewport" && ae._rotate(-U);\n                  for (var he = [], Oe = 0; Oe < m3.length; Oe++) {\n                    var rt = m3[Oe];\n                    he.push(rt.sub(ae));\n                  }\n                  return he;\n                }\n                var Iv = new Nr({ "circle-sort-key": new bt(Rn.layout_circle["circle-sort-key"]) }), ay = new Nr({ "circle-radius": new bt(Rn.paint_circle["circle-radius"]), "circle-color": new bt(Rn.paint_circle["circle-color"]), "circle-blur": new bt(Rn.paint_circle["circle-blur"]), "circle-opacity": new bt(Rn.paint_circle["circle-opacity"]), "circle-translate": new Me(Rn.paint_circle["circle-translate"]), "circle-translate-anchor": new Me(Rn.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new Me(Rn.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new Me(Rn.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new bt(Rn.paint_circle["circle-stroke-width"]), "circle-stroke-color": new bt(Rn.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new bt(Rn.paint_circle["circle-stroke-opacity"]) }), fg = { paint: ay, layout: Iv }, oh = typeof Float32Array != "undefined" ? Float32Array : Array;\n                Math.hypot || (Math.hypot = function() {\n                  for (var m3 = arguments, y3 = 0, I3 = arguments.length; I3--; ) y3 += m3[I3] * m3[I3];\n                  return Math.sqrt(y3);\n                });\n                function hg() {\n                  var m3 = new oh(4);\n                  return oh != Float32Array && (m3[1] = 0, m3[2] = 0), m3[0] = 1, m3[3] = 1, m3;\n                }\n                function oy(m3, y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2], he = y3[3], Oe = Math.sin(I3), rt = Math.cos(I3);\n                  return m3[0] = U * rt + ae * Oe, m3[1] = $2 * rt + he * Oe, m3[2] = U * -Oe + ae * rt, m3[3] = $2 * -Oe + he * rt, m3;\n                }\n                function jh() {\n                  var m3 = new oh(9);\n                  return oh != Float32Array && (m3[1] = 0, m3[2] = 0, m3[3] = 0, m3[5] = 0, m3[6] = 0, m3[7] = 0), m3[0] = 1, m3[4] = 1, m3[8] = 1, m3;\n                }\n                function im(m3, y3) {\n                  var I3 = Math.sin(y3), U = Math.cos(y3);\n                  return m3[0] = U, m3[1] = I3, m3[2] = 0, m3[3] = -I3, m3[4] = U, m3[5] = 0, m3[6] = 0, m3[7] = 0, m3[8] = 1, m3;\n                }\n                function b1() {\n                  var m3 = new oh(16);\n                  return oh != Float32Array && (m3[1] = 0, m3[2] = 0, m3[3] = 0, m3[4] = 0, m3[6] = 0, m3[7] = 0, m3[8] = 0, m3[9] = 0, m3[11] = 0, m3[12] = 0, m3[13] = 0, m3[14] = 0), m3[0] = 1, m3[5] = 1, m3[10] = 1, m3[15] = 1, m3;\n                }\n                function w1(m3) {\n                  var y3 = new oh(16);\n                  return y3[0] = m3[0], y3[1] = m3[1], y3[2] = m3[2], y3[3] = m3[3], y3[4] = m3[4], y3[5] = m3[5], y3[6] = m3[6], y3[7] = m3[7], y3[8] = m3[8], y3[9] = m3[9], y3[10] = m3[10], y3[11] = m3[11], y3[12] = m3[12], y3[13] = m3[13], y3[14] = m3[14], y3[15] = m3[15], y3;\n                }\n                function sy(m3) {\n                  return m3[0] = 1, m3[1] = 0, m3[2] = 0, m3[3] = 0, m3[4] = 0, m3[5] = 1, m3[6] = 0, m3[7] = 0, m3[8] = 0, m3[9] = 0, m3[10] = 1, m3[11] = 0, m3[12] = 0, m3[13] = 0, m3[14] = 0, m3[15] = 1, m3;\n                }\n                function nm(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = y3[2], ae = y3[3], he = y3[4], Oe = y3[5], rt = y3[6], gt = y3[7], Et = y3[8], or = y3[9], _r = y3[10], pr = y3[11], Fr = y3[12], oi = y3[13], Hi = y3[14], Ai = y3[15], bn = I3 * Oe - U * he, nn = I3 * rt - $2 * he, xn = I3 * gt - ae * he, Pn = U * rt - $2 * Oe, Zn = U * gt - ae * Oe, ga = $2 * gt - ae * rt, ha = Et * oi - or * Fr, eo = Et * Hi - _r * Fr, za = Et * Ai - pr * Fr, Za = or * Hi - _r * oi, Ko = or * Ai - pr * oi, to = _r * Ai - pr * Hi, ao = bn * to - nn * Ko + xn * Za + Pn * za - Zn * eo + ga * ha;\n                  return ao ? (ao = 1 / ao, m3[0] = (Oe * to - rt * Ko + gt * Za) * ao, m3[1] = ($2 * Ko - U * to - ae * Za) * ao, m3[2] = (oi * ga - Hi * Zn + Ai * Pn) * ao, m3[3] = (_r * Zn - or * ga - pr * Pn) * ao, m3[4] = (rt * za - he * to - gt * eo) * ao, m3[5] = (I3 * to - $2 * za + ae * eo) * ao, m3[6] = (Hi * xn - Fr * ga - Ai * nn) * ao, m3[7] = (Et * ga - _r * xn + pr * nn) * ao, m3[8] = (he * Ko - Oe * za + gt * ha) * ao, m3[9] = (U * za - I3 * Ko - ae * ha) * ao, m3[10] = (Fr * Zn - oi * xn + Ai * bn) * ao, m3[11] = (or * xn - Et * Zn - pr * bn) * ao, m3[12] = (Oe * eo - he * Za - rt * ha) * ao, m3[13] = (I3 * Za - U * eo + $2 * ha) * ao, m3[14] = (oi * nn - Fr * Pn - Hi * bn) * ao, m3[15] = (Et * Pn - or * nn + _r * bn) * ao, m3) : null;\n                }\n                function am(m3, y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2], he = y3[3], Oe = y3[4], rt = y3[5], gt = y3[6], Et = y3[7], or = y3[8], _r = y3[9], pr = y3[10], Fr = y3[11], oi = y3[12], Hi = y3[13], Ai = y3[14], bn = y3[15], nn = I3[0], xn = I3[1], Pn = I3[2], Zn = I3[3];\n                  return m3[0] = nn * U + xn * Oe + Pn * or + Zn * oi, m3[1] = nn * $2 + xn * rt + Pn * _r + Zn * Hi, m3[2] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m3[3] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I3[4], xn = I3[5], Pn = I3[6], Zn = I3[7], m3[4] = nn * U + xn * Oe + Pn * or + Zn * oi, m3[5] = nn * $2 + xn * rt + Pn * _r + Zn * Hi, m3[6] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m3[7] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I3[8], xn = I3[9], Pn = I3[10], Zn = I3[11], m3[8] = nn * U + xn * Oe + Pn * or + Zn * oi, m3[9] = nn * $2 + xn * rt + Pn * _r + Zn * Hi, m3[10] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m3[11] = nn * he + xn * Et + Pn * Fr + Zn * bn, nn = I3[12], xn = I3[13], Pn = I3[14], Zn = I3[15], m3[12] = nn * U + xn * Oe + Pn * or + Zn * oi, m3[13] = nn * $2 + xn * rt + Pn * _r + Zn * Hi, m3[14] = nn * ae + xn * gt + Pn * pr + Zn * Ai, m3[15] = nn * he + xn * Et + Pn * Fr + Zn * bn, m3;\n                }\n                function vc(m3, y3, I3) {\n                  var U = I3[0], $2 = I3[1], ae = I3[2], he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai;\n                  return y3 === m3 ? (m3[12] = y3[0] * U + y3[4] * $2 + y3[8] * ae + y3[12], m3[13] = y3[1] * U + y3[5] * $2 + y3[9] * ae + y3[13], m3[14] = y3[2] * U + y3[6] * $2 + y3[10] * ae + y3[14], m3[15] = y3[3] * U + y3[7] * $2 + y3[11] * ae + y3[15]) : (he = y3[0], Oe = y3[1], rt = y3[2], gt = y3[3], Et = y3[4], or = y3[5], _r = y3[6], pr = y3[7], Fr = y3[8], oi = y3[9], Hi = y3[10], Ai = y3[11], m3[0] = he, m3[1] = Oe, m3[2] = rt, m3[3] = gt, m3[4] = Et, m3[5] = or, m3[6] = _r, m3[7] = pr, m3[8] = Fr, m3[9] = oi, m3[10] = Hi, m3[11] = Ai, m3[12] = he * U + Et * $2 + Fr * ae + y3[12], m3[13] = Oe * U + or * $2 + oi * ae + y3[13], m3[14] = rt * U + _r * $2 + Hi * ae + y3[14], m3[15] = gt * U + pr * $2 + Ai * ae + y3[15]), m3;\n                }\n                function eu(m3, y3, I3) {\n                  var U = I3[0], $2 = I3[1], ae = I3[2];\n                  return m3[0] = y3[0] * U, m3[1] = y3[1] * U, m3[2] = y3[2] * U, m3[3] = y3[3] * U, m3[4] = y3[4] * $2, m3[5] = y3[5] * $2, m3[6] = y3[6] * $2, m3[7] = y3[7] * $2, m3[8] = y3[8] * ae, m3[9] = y3[9] * ae, m3[10] = y3[10] * ae, m3[11] = y3[11] * ae, m3[12] = y3[12], m3[13] = y3[13], m3[14] = y3[14], m3[15] = y3[15], m3;\n                }\n                function Sd(m3, y3, I3) {\n                  var U = Math.sin(I3), $2 = Math.cos(I3), ae = y3[4], he = y3[5], Oe = y3[6], rt = y3[7], gt = y3[8], Et = y3[9], or = y3[10], _r = y3[11];\n                  return y3 !== m3 && (m3[0] = y3[0], m3[1] = y3[1], m3[2] = y3[2], m3[3] = y3[3], m3[12] = y3[12], m3[13] = y3[13], m3[14] = y3[14], m3[15] = y3[15]), m3[4] = ae * $2 + gt * U, m3[5] = he * $2 + Et * U, m3[6] = Oe * $2 + or * U, m3[7] = rt * $2 + _r * U, m3[8] = gt * $2 - ae * U, m3[9] = Et * $2 - he * U, m3[10] = or * $2 - Oe * U, m3[11] = _r * $2 - rt * U, m3;\n                }\n                function ly(m3, y3, I3) {\n                  var U = Math.sin(I3), $2 = Math.cos(I3), ae = y3[0], he = y3[1], Oe = y3[2], rt = y3[3], gt = y3[4], Et = y3[5], or = y3[6], _r = y3[7];\n                  return y3 !== m3 && (m3[8] = y3[8], m3[9] = y3[9], m3[10] = y3[10], m3[11] = y3[11], m3[12] = y3[12], m3[13] = y3[13], m3[14] = y3[14], m3[15] = y3[15]), m3[0] = ae * $2 + gt * U, m3[1] = he * $2 + Et * U, m3[2] = Oe * $2 + or * U, m3[3] = rt * $2 + _r * U, m3[4] = gt * $2 - ae * U, m3[5] = Et * $2 - he * U, m3[6] = or * $2 - Oe * U, m3[7] = _r * $2 - rt * U, m3;\n                }\n                function T1(m3, y3, I3, U, $2) {\n                  var ae = 1 / Math.tan(y3 / 2), he;\n                  return m3[0] = ae / I3, m3[1] = 0, m3[2] = 0, m3[3] = 0, m3[4] = 0, m3[5] = ae, m3[6] = 0, m3[7] = 0, m3[8] = 0, m3[9] = 0, m3[11] = -1, m3[12] = 0, m3[13] = 0, m3[15] = 0, $2 != null && $2 !== 1 / 0 ? (he = 1 / (U - $2), m3[10] = ($2 + U) * he, m3[14] = 2 * $2 * U * he) : (m3[10] = -1, m3[14] = -2 * U), m3;\n                }\n                function wu(m3, y3, I3, U, $2, ae, he) {\n                  var Oe = 1 / (y3 - I3), rt = 1 / (U - $2), gt = 1 / (ae - he);\n                  return m3[0] = -2 * Oe, m3[1] = 0, m3[2] = 0, m3[3] = 0, m3[4] = 0, m3[5] = -2 * rt, m3[6] = 0, m3[7] = 0, m3[8] = 0, m3[9] = 0, m3[10] = 2 * gt, m3[11] = 0, m3[12] = (y3 + I3) * Oe, m3[13] = ($2 + U) * rt, m3[14] = (he + ae) * gt, m3[15] = 1, m3;\n                }\n                var Nx = am;\n                function om() {\n                  var m3 = new oh(3);\n                  return oh != Float32Array && (m3[0] = 0, m3[1] = 0, m3[2] = 0), m3;\n                }\n                function kw(m3) {\n                  var y3 = new oh(3);\n                  return y3[0] = m3[0], y3[1] = m3[1], y3[2] = m3[2], y3;\n                }\n                function Rv(m3, y3, I3) {\n                  return m3[0] = y3[0] + I3[0], m3[1] = y3[1] + I3[1], m3[2] = y3[2] + I3[2], m3;\n                }\n                function sm(m3, y3, I3) {\n                  return m3[0] = y3[0] - I3[0], m3[1] = y3[1] - I3[1], m3[2] = y3[2] - I3[2], m3;\n                }\n                function Cw(m3, y3, I3) {\n                  return m3[0] = y3[0] * I3, m3[1] = y3[1] * I3, m3[2] = y3[2] * I3, m3;\n                }\n                function Ux(m3, y3) {\n                  var I3 = y3[0], U = y3[1], $2 = y3[2], ae = I3 * I3 + U * U + $2 * $2;\n                  return ae > 0 && (ae = 1 / Math.sqrt(ae)), m3[0] = y3[0] * ae, m3[1] = y3[1] * ae, m3[2] = y3[2] * ae, m3;\n                }\n                function q9(m3, y3) {\n                  return m3[0] * y3[0] + m3[1] * y3[1] + m3[2] * y3[2];\n                }\n                function B9(m3, y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2], he = I3[0], Oe = I3[1], rt = I3[2];\n                  return m3[0] = $2 * rt - ae * Oe, m3[1] = ae * he - U * rt, m3[2] = U * Oe - $2 * he, m3;\n                }\n                function N9(m3, y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2];\n                  return m3[0] = U * I3[0] + $2 * I3[3] + ae * I3[6], m3[1] = U * I3[1] + $2 * I3[4] + ae * I3[7], m3[2] = U * I3[2] + $2 * I3[5] + ae * I3[8], m3;\n                }\n                var U9 = sm, LQ = (function() {\n                  var m3 = om();\n                  return function(y3, I3, U, $2, ae, he) {\n                    var Oe, rt;\n                    for (I3 || (I3 = 3), U || (U = 0), $2 ? rt = Math.min($2 * I3 + U, y3.length) : rt = y3.length, Oe = U; Oe < rt; Oe += I3) m3[0] = y3[Oe], m3[1] = y3[Oe + 1], m3[2] = y3[Oe + 2], ae(m3, m3, he), y3[Oe] = m3[0], y3[Oe + 1] = m3[1], y3[Oe + 2] = m3[2];\n                    return y3;\n                  };\n                })();\n                function V9() {\n                  var m3 = new oh(4);\n                  return oh != Float32Array && (m3[0] = 0, m3[1] = 0, m3[2] = 0, m3[3] = 0), m3;\n                }\n                function G9(m3, y3, I3) {\n                  return m3[0] = y3[0] * I3, m3[1] = y3[1] * I3, m3[2] = y3[2] * I3, m3[3] = y3[3] * I3, m3;\n                }\n                function H9(m3, y3) {\n                  return m3[0] * y3[0] + m3[1] * y3[1] + m3[2] * y3[2] + m3[3] * y3[3];\n                }\n                function uy(m3, y3, I3) {\n                  var U = y3[0], $2 = y3[1], ae = y3[2], he = y3[3];\n                  return m3[0] = I3[0] * U + I3[4] * $2 + I3[8] * ae + I3[12] * he, m3[1] = I3[1] * U + I3[5] * $2 + I3[9] * ae + I3[13] * he, m3[2] = I3[2] * U + I3[6] * $2 + I3[10] * ae + I3[14] * he, m3[3] = I3[3] * U + I3[7] * $2 + I3[11] * ae + I3[15] * he, m3;\n                }\n                var Vx = (function() {\n                  var m3 = V9();\n                  return function(y3, I3, U, $2, ae, he) {\n                    var Oe, rt;\n                    for (I3 || (I3 = 4), U || (U = 0), $2 ? rt = Math.min($2 * I3 + U, y3.length) : rt = y3.length, Oe = U; Oe < rt; Oe += I3) m3[0] = y3[Oe], m3[1] = y3[Oe + 1], m3[2] = y3[Oe + 2], m3[3] = y3[Oe + 3], ae(m3, m3, he), y3[Oe] = m3[0], y3[Oe + 1] = m3[1], y3[Oe + 2] = m3[2], y3[Oe + 3] = m3[3];\n                    return y3;\n                  };\n                })();\n                function mC() {\n                  var m3 = new oh(2);\n                  return oh != Float32Array && (m3[0] = 0, m3[1] = 0), m3;\n                }\n                function nS(m3) {\n                  var y3 = m3[0], I3 = m3[1];\n                  return y3 * y3 + I3 * I3;\n                }\n                var aS = nS, PQ = (function() {\n                  var m3 = mC();\n                  return function(y3, I3, U, $2, ae, he) {\n                    var Oe, rt;\n                    for (I3 || (I3 = 2), U || (U = 0), $2 ? rt = Math.min($2 * I3 + U, y3.length) : rt = y3.length, Oe = U; Oe < rt; Oe += I3) m3[0] = y3[Oe], m3[1] = y3[Oe + 1], ae(m3, m3, he), y3[Oe] = m3[0], y3[Oe + 1] = m3[1];\n                    return y3;\n                  };\n                })(), j9 = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, fg);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.createBucket = function(U) {\n                    return new ts(U);\n                  }, y3.prototype.queryRadius = function(U) {\n                    var $2 = U;\n                    return Ad("circle-radius", this, $2) + Ad("circle-stroke-width", this, $2) + Pv(this.paint.get("circle-translate"));\n                  }, y3.prototype.queryIntersectsFeature = function(U, $2, ae, he, Oe, rt, gt, Et) {\n                    for (var or = Jv(U, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), rt.angle, gt), _r = this.paint.get("circle-radius").evaluate($2, ae), pr = this.paint.get("circle-stroke-width").evaluate($2, ae), Fr = _r + pr, oi = this.paint.get("circle-pitch-alignment") === "map", Hi = oi ? or : _C(or, Et), Ai = oi ? Fr * gt : Fr, bn = 0, nn = he; bn < nn.length; bn += 1) for (var xn = nn[bn], Pn = 0, Zn = xn; Pn < Zn.length; Pn += 1) {\n                      var ga = Zn[Pn], ha = oi ? ga : yC(ga, Et), eo = Ai, za = uy([], [ga.x, ga.y, 0, 1], Et);\n                      if (this.paint.get("circle-pitch-scale") === "viewport" && this.paint.get("circle-pitch-alignment") === "map" ? eo *= za[3] / rt.cameraToCenterDistance : this.paint.get("circle-pitch-scale") === "map" && this.paint.get("circle-pitch-alignment") === "viewport" && (eo *= rt.cameraToCenterDistance / za[3]), Zo(Hi, ha, eo)) return true;\n                    }\n                    return false;\n                  }, y3;\n                })(mi);\n                function yC(m3, y3) {\n                  var I3 = uy([], [m3.x, m3.y, 0, 1], y3);\n                  return new u4(I3[0] / I3[3], I3[1] / I3[3]);\n                }\n                function _C(m3, y3) {\n                  return m3.map(function(I3) {\n                    return yC(I3, y3);\n                  });\n                }\n                var oS = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3;\n                })(ts);\n                X("HeatmapBucket", oS, { omit: ["layers"] });\n                function Md(m3, y3, I3, U) {\n                  var $2 = y3.width, ae = y3.height;\n                  if (!U) U = new Uint8Array($2 * ae * I3);\n                  else if (U instanceof Uint8ClampedArray) U = new Uint8Array(U.buffer);\n                  else if (U.length !== $2 * ae * I3) throw new RangeError("mismatched image size");\n                  return m3.width = $2, m3.height = ae, m3.data = U, m3;\n                }\n                function Lw(m3, y3, I3) {\n                  var U = y3.width, $2 = y3.height;\n                  if (!(U === m3.width && $2 === m3.height)) {\n                    var ae = Md({}, { width: U, height: $2 }, I3);\n                    Pw(m3, ae, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(m3.width, U), height: Math.min(m3.height, $2) }, I3), m3.width = U, m3.height = $2, m3.data = ae.data;\n                  }\n                }\n                function Pw(m3, y3, I3, U, $2, ae) {\n                  if ($2.width === 0 || $2.height === 0) return y3;\n                  if ($2.width > m3.width || $2.height > m3.height || I3.x > m3.width - $2.width || I3.y > m3.height - $2.height) throw new RangeError("out of range source coordinates for image copy");\n                  if ($2.width > y3.width || $2.height > y3.height || U.x > y3.width - $2.width || U.y > y3.height - $2.height) throw new RangeError("out of range destination coordinates for image copy");\n                  for (var he = m3.data, Oe = y3.data, rt = 0; rt < $2.height; rt++) for (var gt = ((I3.y + rt) * m3.width + I3.x) * ae, Et = ((U.y + rt) * y3.width + U.x) * ae, or = 0; or < $2.width * ae; or++) Oe[Et + or] = he[gt + or];\n                  return y3;\n                }\n                var Dv = function(y3, I3) {\n                  Md(this, y3, 1, I3);\n                };\n                Dv.prototype.resize = function(y3) {\n                  Lw(this, y3, 1);\n                }, Dv.prototype.clone = function() {\n                  return new Dv({ width: this.width, height: this.height }, new Uint8Array(this.data));\n                }, Dv.copy = function(y3, I3, U, $2, ae) {\n                  Pw(y3, I3, U, $2, ae, 1);\n                };\n                var Sh = function(y3, I3) {\n                  Md(this, y3, 4, I3);\n                };\n                Sh.prototype.resize = function(y3) {\n                  Lw(this, y3, 4);\n                }, Sh.prototype.replace = function(y3, I3) {\n                  I3 ? this.data.set(y3) : y3 instanceof Uint8ClampedArray ? this.data = new Uint8Array(y3.buffer) : this.data = y3;\n                }, Sh.prototype.clone = function() {\n                  return new Sh({ width: this.width, height: this.height }, new Uint8Array(this.data));\n                }, Sh.copy = function(y3, I3, U, $2, ae) {\n                  Pw(y3, I3, U, $2, ae, 4);\n                }, X("AlphaImage", Dv), X("RGBAImage", Sh);\n                var Gx = new Nr({ "heatmap-radius": new bt(Rn.paint_heatmap["heatmap-radius"]), "heatmap-weight": new bt(Rn.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new Me(Rn.paint_heatmap["heatmap-intensity"]), "heatmap-color": new jr(Rn.paint_heatmap["heatmap-color"]), "heatmap-opacity": new Me(Rn.paint_heatmap["heatmap-opacity"]) }), A1 = { paint: Gx };\n                function Hx(m3) {\n                  var y3 = {}, I3 = m3.resolution || 256, U = m3.clips ? m3.clips.length : 1, $2 = m3.image || new Sh({ width: I3, height: U }), ae = function(bn, nn, xn) {\n                    y3[m3.evaluationKey] = xn;\n                    var Pn = m3.expression.evaluate(y3);\n                    $2.data[bn + nn + 0] = Math.floor(Pn.r * 255 / Pn.a), $2.data[bn + nn + 1] = Math.floor(Pn.g * 255 / Pn.a), $2.data[bn + nn + 2] = Math.floor(Pn.b * 255 / Pn.a), $2.data[bn + nn + 3] = Math.floor(Pn.a * 255);\n                  };\n                  if (m3.clips) for (var gt = 0, Et = 0; gt < U; ++gt, Et += I3 * 4) for (var or = 0, _r = 0; or < I3; or++, _r += 4) {\n                    var pr = or / (I3 - 1), Fr = m3.clips[gt], oi = Fr.start, Hi = Fr.end, Ai = oi * (1 - pr) + Hi * pr;\n                    ae(Et, _r, Ai);\n                  }\n                  else for (var he = 0, Oe = 0; he < I3; he++, Oe += 4) {\n                    var rt = he / (I3 - 1);\n                    ae(0, Oe, rt);\n                  }\n                  return $2;\n                }\n                var Iw = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, A1), this._updateColorRamp();\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.createBucket = function(U) {\n                    return new oS(U);\n                  }, y3.prototype._handleSpecialPaintPropertyUpdate = function(U) {\n                    U === "heatmap-color" && this._updateColorRamp();\n                  }, y3.prototype._updateColorRamp = function() {\n                    var U = this._transitionablePaint._values["heatmap-color"].value.expression;\n                    this.colorRamp = Hx({ expression: U, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;\n                  }, y3.prototype.resize = function() {\n                    this.heatmapFbo && (this.heatmapFbo.destroy(), this.heatmapFbo = null);\n                  }, y3.prototype.queryRadius = function() {\n                    return 0;\n                  }, y3.prototype.queryIntersectsFeature = function() {\n                    return false;\n                  }, y3.prototype.hasOffscreenPass = function() {\n                    return this.paint.get("heatmap-opacity") !== 0 && this.visibility !== "none";\n                  }, y3;\n                })(mi), W9 = new Nr({ "hillshade-illumination-direction": new Me(Rn.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-anchor": new Me(Rn.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new Me(Rn.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new Me(Rn.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new Me(Rn.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new Me(Rn.paint_hillshade["hillshade-accent-color"]) }), X9 = { paint: W9 }, xC = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, X9);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.hasOffscreenPass = function() {\n                    return this.paint.get("hillshade-exaggeration") !== 0 && this.visibility !== "none";\n                  }, y3;\n                })(mi), bC = Wi([{ name: "a_pos", components: 2, type: "Int16" }], 4), Z9 = bC.members, Rw = S1, wC = S1;\n                function S1(m3, y3, I3) {\n                  I3 = I3 || 2;\n                  var U = y3 && y3.length, $2 = U ? y3[0] * I3 : m3.length, ae = Dw(m3, 0, $2, I3, true), he = [];\n                  if (!ae || ae.next === ae.prev) return he;\n                  var Oe, rt, gt, Et, or, _r, pr;\n                  if (U && (ae = um(m3, y3, ae, I3)), m3.length > 80 * I3) {\n                    Oe = gt = m3[0], rt = Et = m3[1];\n                    for (var Fr = I3; Fr < $2; Fr += I3) or = m3[Fr], _r = m3[Fr + 1], or < Oe && (Oe = or), _r < rt && (rt = _r), or > gt && (gt = or), _r > Et && (Et = _r);\n                    pr = Math.max(gt - Oe, Et - rt), pr = pr !== 0 ? 1 / pr : 0;\n                  }\n                  return jx(ae, he, I3, Oe, rt, pr), he;\n                }\n                function Dw(m3, y3, I3, U, $2) {\n                  var ae, he;\n                  if ($2 === dS(m3, y3, I3, U) > 0) for (ae = y3; ae < I3; ae += U) he = EC(ae, m3[ae], m3[ae + 1], he);\n                  else for (ae = I3 - U; ae >= y3; ae -= U) he = EC(ae, m3[ae], m3[ae + 1], he);\n                  return he && Xx(he, he.next) && (Kx(he), he = he.next), he;\n                }\n                function lm(m3, y3) {\n                  if (!m3) return m3;\n                  y3 || (y3 = m3);\n                  var I3 = m3, U;\n                  do\n                    if (U = false, !I3.steiner && (Xx(I3, I3.next) || Tf(I3.prev, I3, I3.next) === 0)) {\n                      if (Kx(I3), I3 = y3 = I3.prev, I3 === I3.next) break;\n                      U = true;\n                    } else I3 = I3.next;\n                  while (U || I3 !== y3);\n                  return y3;\n                }\n                function jx(m3, y3, I3, U, $2, ae, he) {\n                  if (m3) {\n                    !he && ae && Fw(m3, U, $2, ae);\n                    for (var Oe = m3, rt, gt; m3.prev !== m3.next; ) {\n                      if (rt = m3.prev, gt = m3.next, ae ? AC(m3, U, $2, ae) : TC(m3)) {\n                        y3.push(rt.i / I3), y3.push(m3.i / I3), y3.push(gt.i / I3), Kx(m3), m3 = gt.next, Oe = gt.next;\n                        continue;\n                      }\n                      if (m3 = gt, m3 === Oe) {\n                        he ? he === 1 ? (m3 = Wx(lm(m3), y3, I3), jx(m3, y3, I3, U, $2, ae, 2)) : he === 2 && d0(m3, y3, I3, U, $2, ae) : jx(lm(m3), y3, I3, U, $2, ae, 1);\n                        break;\n                      }\n                    }\n                  }\n                }\n                function TC(m3) {\n                  var y3 = m3.prev, I3 = m3, U = m3.next;\n                  if (Tf(y3, I3, U) >= 0) return false;\n                  for (var $2 = m3.next.next; $2 !== m3.prev; ) {\n                    if (cm(y3.x, y3.y, I3.x, I3.y, U.x, U.y, $2.x, $2.y) && Tf($2.prev, $2, $2.next) >= 0) return false;\n                    $2 = $2.next;\n                  }\n                  return true;\n                }\n                function AC(m3, y3, I3, U) {\n                  var $2 = m3.prev, ae = m3, he = m3.next;\n                  if (Tf($2, ae, he) >= 0) return false;\n                  for (var Oe = $2.x < ae.x ? $2.x < he.x ? $2.x : he.x : ae.x < he.x ? ae.x : he.x, rt = $2.y < ae.y ? $2.y < he.y ? $2.y : he.y : ae.y < he.y ? ae.y : he.y, gt = $2.x > ae.x ? $2.x > he.x ? $2.x : he.x : ae.x > he.x ? ae.x : he.x, Et = $2.y > ae.y ? $2.y > he.y ? $2.y : he.y : ae.y > he.y ? ae.y : he.y, or = uS(Oe, rt, y3, I3, U), _r = uS(gt, Et, y3, I3, U), pr = m3.prevZ, Fr = m3.nextZ; pr && pr.z >= or && Fr && Fr.z <= _r; ) {\n                    if (pr !== m3.prev && pr !== m3.next && cm($2.x, $2.y, ae.x, ae.y, he.x, he.y, pr.x, pr.y) && Tf(pr.prev, pr, pr.next) >= 0 || (pr = pr.prevZ, Fr !== m3.prev && Fr !== m3.next && cm($2.x, $2.y, ae.x, ae.y, he.x, he.y, Fr.x, Fr.y) && Tf(Fr.prev, Fr, Fr.next) >= 0)) return false;\n                    Fr = Fr.nextZ;\n                  }\n                  for (; pr && pr.z >= or; ) {\n                    if (pr !== m3.prev && pr !== m3.next && cm($2.x, $2.y, ae.x, ae.y, he.x, he.y, pr.x, pr.y) && Tf(pr.prev, pr, pr.next) >= 0) return false;\n                    pr = pr.prevZ;\n                  }\n                  for (; Fr && Fr.z <= _r; ) {\n                    if (Fr !== m3.prev && Fr !== m3.next && cm($2.x, $2.y, ae.x, ae.y, he.x, he.y, Fr.x, Fr.y) && Tf(Fr.prev, Fr, Fr.next) >= 0) return false;\n                    Fr = Fr.nextZ;\n                  }\n                  return true;\n                }\n                function Wx(m3, y3, I3) {\n                  var U = m3;\n                  do {\n                    var $2 = U.prev, ae = U.next.next;\n                    !Xx($2, ae) && zw($2, U, U.next, ae) && Yx($2, ae) && Yx(ae, $2) && (y3.push($2.i / I3), y3.push(U.i / I3), y3.push(ae.i / I3), Kx(U), Kx(U.next), U = m3 = ae), U = U.next;\n                  } while (U !== m3);\n                  return lm(U);\n                }\n                function d0(m3, y3, I3, U, $2, ae) {\n                  var he = m3;\n                  do {\n                    for (var Oe = he.next.next; Oe !== he.prev; ) {\n                      if (he.i !== Oe.i && M1(he, Oe)) {\n                        var rt = fS(he, Oe);\n                        he = lm(he, he.next), rt = lm(rt, rt.next), jx(he, y3, I3, U, $2, ae), jx(rt, y3, I3, U, $2, ae);\n                        return;\n                      }\n                      Oe = Oe.next;\n                    }\n                    he = he.next;\n                  } while (he !== m3);\n                }\n                function um(m3, y3, I3, U) {\n                  var $2 = [], ae, he, Oe, rt, gt;\n                  for (ae = 0, he = y3.length; ae < he; ae++) Oe = y3[ae] * U, rt = ae < he - 1 ? y3[ae + 1] * U : m3.length, gt = Dw(m3, Oe, rt, U, false), gt === gt.next && (gt.steiner = true), $2.push(cS(gt));\n                  for ($2.sort(SC), ae = 0; ae < $2.length; ae++) sS($2[ae], I3), I3 = lm(I3, I3.next);\n                  return I3;\n                }\n                function SC(m3, y3) {\n                  return m3.x - y3.x;\n                }\n                function sS(m3, y3) {\n                  if (y3 = Y9(m3, y3), y3) {\n                    var I3 = fS(y3, m3);\n                    lm(y3, y3.next), lm(I3, I3.next);\n                  }\n                }\n                function Y9(m3, y3) {\n                  var I3 = y3, U = m3.x, $2 = m3.y, ae = -1 / 0, he;\n                  do {\n                    if ($2 <= I3.y && $2 >= I3.next.y && I3.next.y !== I3.y) {\n                      var Oe = I3.x + ($2 - I3.y) * (I3.next.x - I3.x) / (I3.next.y - I3.y);\n                      if (Oe <= U && Oe > ae) {\n                        if (ae = Oe, Oe === U) {\n                          if ($2 === I3.y) return I3;\n                          if ($2 === I3.next.y) return I3.next;\n                        }\n                        he = I3.x < I3.next.x ? I3 : I3.next;\n                      }\n                    }\n                    I3 = I3.next;\n                  } while (I3 !== y3);\n                  if (!he) return null;\n                  if (U === ae) return he;\n                  var rt = he, gt = he.x, Et = he.y, or = 1 / 0, _r;\n                  I3 = he;\n                  do\n                    U >= I3.x && I3.x >= gt && U !== I3.x && cm($2 < Et ? U : ae, $2, gt, Et, $2 < Et ? ae : U, $2, I3.x, I3.y) && (_r = Math.abs($2 - I3.y) / (U - I3.x), Yx(I3, m3) && (_r < or || _r === or && (I3.x > he.x || I3.x === he.x && K9(he, I3))) && (he = I3, or = _r)), I3 = I3.next;\n                  while (I3 !== rt);\n                  return he;\n                }\n                function K9(m3, y3) {\n                  return Tf(m3.prev, m3, y3.prev) < 0 && Tf(y3.next, m3, m3.next) < 0;\n                }\n                function Fw(m3, y3, I3, U) {\n                  var $2 = m3;\n                  do\n                    $2.z === null && ($2.z = uS($2.x, $2.y, y3, I3, U)), $2.prevZ = $2.prev, $2.nextZ = $2.next, $2 = $2.next;\n                  while ($2 !== m3);\n                  $2.prevZ.nextZ = null, $2.prevZ = null, lS($2);\n                }\n                function lS(m3) {\n                  var y3, I3, U, $2, ae, he, Oe, rt, gt = 1;\n                  do {\n                    for (I3 = m3, m3 = null, ae = null, he = 0; I3; ) {\n                      for (he++, U = I3, Oe = 0, y3 = 0; y3 < gt && (Oe++, U = U.nextZ, !!U); y3++) ;\n                      for (rt = gt; Oe > 0 || rt > 0 && U; ) Oe !== 0 && (rt === 0 || !U || I3.z <= U.z) ? ($2 = I3, I3 = I3.nextZ, Oe--) : ($2 = U, U = U.nextZ, rt--), ae ? ae.nextZ = $2 : m3 = $2, $2.prevZ = ae, ae = $2;\n                      I3 = U;\n                    }\n                    ae.nextZ = null, gt *= 2;\n                  } while (he > 1);\n                  return m3;\n                }\n                function uS(m3, y3, I3, U, $2) {\n                  return m3 = 32767 * (m3 - I3) * $2, y3 = 32767 * (y3 - U) * $2, m3 = (m3 | m3 << 8) & 16711935, m3 = (m3 | m3 << 4) & 252645135, m3 = (m3 | m3 << 2) & 858993459, m3 = (m3 | m3 << 1) & 1431655765, y3 = (y3 | y3 << 8) & 16711935, y3 = (y3 | y3 << 4) & 252645135, y3 = (y3 | y3 << 2) & 858993459, y3 = (y3 | y3 << 1) & 1431655765, m3 | y3 << 1;\n                }\n                function cS(m3) {\n                  var y3 = m3, I3 = m3;\n                  do\n                    (y3.x < I3.x || y3.x === I3.x && y3.y < I3.y) && (I3 = y3), y3 = y3.next;\n                  while (y3 !== m3);\n                  return I3;\n                }\n                function cm(m3, y3, I3, U, $2, ae, he, Oe) {\n                  return ($2 - he) * (y3 - Oe) - (m3 - he) * (ae - Oe) >= 0 && (m3 - he) * (U - Oe) - (I3 - he) * (y3 - Oe) >= 0 && (I3 - he) * (ae - Oe) - ($2 - he) * (U - Oe) >= 0;\n                }\n                function M1(m3, y3) {\n                  return m3.next.i !== y3.i && m3.prev.i !== y3.i && !MC(m3, y3) && (Yx(m3, y3) && Yx(y3, m3) && J9(m3, y3) && (Tf(m3.prev, m3, y3.prev) || Tf(m3, y3.prev, y3)) || Xx(m3, y3) && Tf(m3.prev, m3, m3.next) > 0 && Tf(y3.prev, y3, y3.next) > 0);\n                }\n                function Tf(m3, y3, I3) {\n                  return (y3.y - m3.y) * (I3.x - y3.x) - (y3.x - m3.x) * (I3.y - y3.y);\n                }\n                function Xx(m3, y3) {\n                  return m3.x === y3.x && m3.y === y3.y;\n                }\n                function zw(m3, y3, I3, U) {\n                  var $2 = cy(Tf(m3, y3, I3)), ae = cy(Tf(m3, y3, U)), he = cy(Tf(I3, U, m3)), Oe = cy(Tf(I3, U, y3));\n                  return !!($2 !== ae && he !== Oe || $2 === 0 && Zx(m3, I3, y3) || ae === 0 && Zx(m3, U, y3) || he === 0 && Zx(I3, m3, U) || Oe === 0 && Zx(I3, y3, U));\n                }\n                function Zx(m3, y3, I3) {\n                  return y3.x <= Math.max(m3.x, I3.x) && y3.x >= Math.min(m3.x, I3.x) && y3.y <= Math.max(m3.y, I3.y) && y3.y >= Math.min(m3.y, I3.y);\n                }\n                function cy(m3) {\n                  return m3 > 0 ? 1 : m3 < 0 ? -1 : 0;\n                }\n                function MC(m3, y3) {\n                  var I3 = m3;\n                  do {\n                    if (I3.i !== m3.i && I3.next.i !== m3.i && I3.i !== y3.i && I3.next.i !== y3.i && zw(I3, I3.next, m3, y3)) return true;\n                    I3 = I3.next;\n                  } while (I3 !== m3);\n                  return false;\n                }\n                function Yx(m3, y3) {\n                  return Tf(m3.prev, m3, m3.next) < 0 ? Tf(m3, y3, m3.next) >= 0 && Tf(m3, m3.prev, y3) >= 0 : Tf(m3, y3, m3.prev) < 0 || Tf(m3, m3.next, y3) < 0;\n                }\n                function J9(m3, y3) {\n                  var I3 = m3, U = false, $2 = (m3.x + y3.x) / 2, ae = (m3.y + y3.y) / 2;\n                  do\n                    I3.y > ae != I3.next.y > ae && I3.next.y !== I3.y && $2 < (I3.next.x - I3.x) * (ae - I3.y) / (I3.next.y - I3.y) + I3.x && (U = !U), I3 = I3.next;\n                  while (I3 !== m3);\n                  return U;\n                }\n                function fS(m3, y3) {\n                  var I3 = new hS(m3.i, m3.x, m3.y), U = new hS(y3.i, y3.x, y3.y), $2 = m3.next, ae = y3.prev;\n                  return m3.next = y3, y3.prev = m3, I3.next = $2, $2.prev = I3, U.next = I3, I3.prev = U, ae.next = U, U.prev = ae, U;\n                }\n                function EC(m3, y3, I3, U) {\n                  var $2 = new hS(m3, y3, I3);\n                  return U ? ($2.next = U.next, $2.prev = U, U.next.prev = $2, U.next = $2) : ($2.prev = $2, $2.next = $2), $2;\n                }\n                function Kx(m3) {\n                  m3.next.prev = m3.prev, m3.prev.next = m3.next, m3.prevZ && (m3.prevZ.nextZ = m3.nextZ), m3.nextZ && (m3.nextZ.prevZ = m3.prevZ);\n                }\n                function hS(m3, y3, I3) {\n                  this.i = m3, this.x = y3, this.y = I3, this.prev = null, this.next = null, this.z = null, this.prevZ = null, this.nextZ = null, this.steiner = false;\n                }\n                S1.deviation = function(m3, y3, I3, U) {\n                  var $2 = y3 && y3.length, ae = $2 ? y3[0] * I3 : m3.length, he = Math.abs(dS(m3, 0, ae, I3));\n                  if ($2) for (var Oe = 0, rt = y3.length; Oe < rt; Oe++) {\n                    var gt = y3[Oe] * I3, Et = Oe < rt - 1 ? y3[Oe + 1] * I3 : m3.length;\n                    he -= Math.abs(dS(m3, gt, Et, I3));\n                  }\n                  var or = 0;\n                  for (Oe = 0; Oe < U.length; Oe += 3) {\n                    var _r = U[Oe] * I3, pr = U[Oe + 1] * I3, Fr = U[Oe + 2] * I3;\n                    or += Math.abs((m3[_r] - m3[Fr]) * (m3[pr + 1] - m3[_r + 1]) - (m3[_r] - m3[pr]) * (m3[Fr + 1] - m3[_r + 1]));\n                  }\n                  return he === 0 && or === 0 ? 0 : Math.abs((or - he) / he);\n                };\n                function dS(m3, y3, I3, U) {\n                  for (var $2 = 0, ae = y3, he = I3 - U; ae < I3; ae += U) $2 += (m3[he] - m3[ae]) * (m3[ae + 1] + m3[he + 1]), he = ae;\n                  return $2;\n                }\n                S1.flatten = function(m3) {\n                  for (var y3 = m3[0][0].length, I3 = { vertices: [], holes: [], dimensions: y3 }, U = 0, $2 = 0; $2 < m3.length; $2++) {\n                    for (var ae = 0; ae < m3[$2].length; ae++) for (var he = 0; he < y3; he++) I3.vertices.push(m3[$2][ae][he]);\n                    $2 > 0 && (U += m3[$2 - 1].length, I3.holes.push(U));\n                  }\n                  return I3;\n                }, Rw.default = wC;\n                function vS(m3, y3, I3, U, $2) {\n                  dg(m3, y3, I3 || 0, U || m3.length - 1, $2 || kC);\n                }\n                function dg(m3, y3, I3, U, $2) {\n                  for (; U > I3; ) {\n                    if (U - I3 > 600) {\n                      var ae = U - I3 + 1, he = y3 - I3 + 1, Oe = Math.log(ae), rt = 0.5 * Math.exp(2 * Oe / 3), gt = 0.5 * Math.sqrt(Oe * rt * (ae - rt) / ae) * (he - ae / 2 < 0 ? -1 : 1), Et = Math.max(I3, Math.floor(y3 - he * rt / ae + gt)), or = Math.min(U, Math.floor(y3 + (ae - he) * rt / ae + gt));\n                      dg(m3, y3, Et, or, $2);\n                    }\n                    var _r = m3[y3], pr = I3, Fr = U;\n                    for (E1(m3, I3, y3), $2(m3[U], _r) > 0 && E1(m3, I3, U); pr < Fr; ) {\n                      for (E1(m3, pr, Fr), pr++, Fr--; $2(m3[pr], _r) < 0; ) pr++;\n                      for (; $2(m3[Fr], _r) > 0; ) Fr--;\n                    }\n                    $2(m3[I3], _r) === 0 ? E1(m3, I3, Fr) : (Fr++, E1(m3, Fr, U)), Fr <= y3 && (I3 = Fr + 1), y3 <= Fr && (U = Fr - 1);\n                  }\n                }\n                function E1(m3, y3, I3) {\n                  var U = m3[y3];\n                  m3[y3] = m3[I3], m3[I3] = U;\n                }\n                function kC(m3, y3) {\n                  return m3 < y3 ? -1 : m3 > y3 ? 1 : 0;\n                }\n                function Ow(m3, y3) {\n                  var I3 = m3.length;\n                  if (I3 <= 1) return [m3];\n                  for (var U = [], $2, ae, he = 0; he < I3; he++) {\n                    var Oe = _e(m3[he]);\n                    Oe !== 0 && (m3[he].area = Math.abs(Oe), ae === void 0 && (ae = Oe < 0), ae === Oe < 0 ? ($2 && U.push($2), $2 = [m3[he]]) : $2.push(m3[he]));\n                  }\n                  if ($2 && U.push($2), y3 > 1) for (var rt = 0; rt < U.length; rt++) U[rt].length <= y3 || (vS(U[rt], y3, 1, U[rt].length - 1, CC), U[rt] = U[rt].slice(0, y3));\n                  return U;\n                }\n                function CC(m3, y3) {\n                  return y3.area - m3.area;\n                }\n                function qw(m3, y3, I3) {\n                  for (var U = I3.patternDependencies, $2 = false, ae = 0, he = y3; ae < he.length; ae += 1) {\n                    var Oe = he[ae], rt = Oe.paint.get(m3 + "-pattern");\n                    rt.isConstant() || ($2 = true);\n                    var gt = rt.constantOr(null);\n                    gt && ($2 = true, U[gt.to] = true, U[gt.from] = true);\n                  }\n                  return $2;\n                }\n                function Jx(m3, y3, I3, U, $2) {\n                  for (var ae = $2.patternDependencies, he = 0, Oe = y3; he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = rt.paint.get(m3 + "-pattern"), Et = gt.value;\n                    if (Et.kind !== "constant") {\n                      var or = Et.evaluate({ zoom: U - 1 }, I3, {}, $2.availableImages), _r = Et.evaluate({ zoom: U }, I3, {}, $2.availableImages), pr = Et.evaluate({ zoom: U + 1 }, I3, {}, $2.availableImages);\n                      or = or && or.name ? or.name : or, _r = _r && _r.name ? _r.name : _r, pr = pr && pr.name ? pr.name : pr, ae[or] = true, ae[_r] = true, ae[pr] = true, I3.patterns[rt.id] = { min: or, mid: _r, max: pr };\n                    }\n                  }\n                  return I3;\n                }\n                var $x = 500, mp = function(y3) {\n                  this.zoom = y3.zoom, this.overscaling = y3.overscaling, this.layers = y3.layers, this.layerIds = this.layers.map(function(I3) {\n                    return I3.id;\n                  }), this.index = y3.index, this.hasPattern = false, this.patternFeatures = [], this.layoutVertexArray = new Yr(), this.indexArray = new pn(), this.indexArray2 = new oa(), this.programConfigurations = new fi(y3.layers, y3.zoom), this.segments = new io(), this.segments2 = new io(), this.stateDependentLayerIds = this.layers.filter(function(I3) {\n                    return I3.isStateDependent();\n                  }).map(function(I3) {\n                    return I3.id;\n                  });\n                };\n                mp.prototype.populate = function(y3, I3, U) {\n                  this.hasPattern = qw("fill", this.layers, I3);\n                  for (var $2 = this.layers[0].layout.get("fill-sort-key"), ae = [], he = 0, Oe = y3; he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = rt.feature, Et = rt.id, or = rt.index, _r = rt.sourceLayerIndex, pr = this.layers[0]._featureFilter.needGeometry, Fr = Ja(gt, pr);\n                    if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), Fr, U)) {\n                      var oi = $2 ? $2.evaluate(Fr, {}, U, I3.availableImages) : void 0, Hi = { id: Et, properties: gt.properties, type: gt.type, sourceLayerIndex: _r, index: or, geometry: pr ? Fr.geometry : zn(gt), patterns: {}, sortKey: oi };\n                      ae.push(Hi);\n                    }\n                  }\n                  $2 && ae.sort(function(za, Za) {\n                    return za.sortKey - Za.sortKey;\n                  });\n                  for (var Ai = 0, bn = ae; Ai < bn.length; Ai += 1) {\n                    var nn = bn[Ai], xn = nn, Pn = xn.geometry, Zn = xn.index, ga = xn.sourceLayerIndex;\n                    if (this.hasPattern) {\n                      var ha = Jx("fill", this.layers, nn, this.zoom, I3);\n                      this.patternFeatures.push(ha);\n                    } else this.addFeature(nn, Pn, Zn, U, {});\n                    var eo = y3[Zn].feature;\n                    I3.featureIndex.insert(eo, Pn, Zn, ga, this.index);\n                  }\n                }, mp.prototype.update = function(y3, I3, U) {\n                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y3, I3, this.stateDependentLayers, U);\n                }, mp.prototype.addFeatures = function(y3, I3, U) {\n                  for (var $2 = 0, ae = this.patternFeatures; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    this.addFeature(he, he.geometry, he.index, I3, U);\n                  }\n                }, mp.prototype.isEmpty = function() {\n                  return this.layoutVertexArray.length === 0;\n                }, mp.prototype.uploadPending = function() {\n                  return !this.uploaded || this.programConfigurations.needsUpload;\n                }, mp.prototype.upload = function(y3) {\n                  this.uploaded || (this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, Z9), this.indexBuffer = y3.createIndexBuffer(this.indexArray), this.indexBuffer2 = y3.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(y3), this.uploaded = true;\n                }, mp.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());\n                }, mp.prototype.addFeature = function(y3, I3, U, $2, ae) {\n                  for (var he = 0, Oe = Ow(I3, $x); he < Oe.length; he += 1) {\n                    for (var rt = Oe[he], gt = 0, Et = 0, or = rt; Et < or.length; Et += 1) {\n                      var _r = or[Et];\n                      gt += _r.length;\n                    }\n                    for (var pr = this.segments.prepareSegment(gt, this.layoutVertexArray, this.indexArray), Fr = pr.vertexLength, oi = [], Hi = [], Ai = 0, bn = rt; Ai < bn.length; Ai += 1) {\n                      var nn = bn[Ai];\n                      if (nn.length !== 0) {\n                        nn !== rt[0] && Hi.push(oi.length / 2);\n                        var xn = this.segments2.prepareSegment(nn.length, this.layoutVertexArray, this.indexArray2), Pn = xn.vertexLength;\n                        this.layoutVertexArray.emplaceBack(nn[0].x, nn[0].y), this.indexArray2.emplaceBack(Pn + nn.length - 1, Pn), oi.push(nn[0].x), oi.push(nn[0].y);\n                        for (var Zn = 1; Zn < nn.length; Zn++) this.layoutVertexArray.emplaceBack(nn[Zn].x, nn[Zn].y), this.indexArray2.emplaceBack(Pn + Zn - 1, Pn + Zn), oi.push(nn[Zn].x), oi.push(nn[Zn].y);\n                        xn.vertexLength += nn.length, xn.primitiveLength += nn.length;\n                      }\n                    }\n                    for (var ga = Rw(oi, Hi), ha = 0; ha < ga.length; ha += 3) this.indexArray.emplaceBack(Fr + ga[ha], Fr + ga[ha + 1], Fr + ga[ha + 2]);\n                    pr.vertexLength += gt, pr.primitiveLength += ga.length / 3;\n                  }\n                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y3, U, ae, $2);\n                }, X("FillBucket", mp, { omit: ["layers", "patternFeatures"] });\n                var pS = new Nr({ "fill-sort-key": new bt(Rn.layout_fill["fill-sort-key"]) }), LC = new Nr({ "fill-antialias": new Me(Rn.paint_fill["fill-antialias"]), "fill-opacity": new bt(Rn.paint_fill["fill-opacity"]), "fill-color": new bt(Rn.paint_fill["fill-color"]), "fill-outline-color": new bt(Rn.paint_fill["fill-outline-color"]), "fill-translate": new Me(Rn.paint_fill["fill-translate"]), "fill-translate-anchor": new Me(Rn.paint_fill["fill-translate-anchor"]), "fill-pattern": new zt(Rn.paint_fill["fill-pattern"]) }), $v = { paint: LC, layout: pS }, Qx = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, $v);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.recalculate = function(U, $2) {\n                    m3.prototype.recalculate.call(this, U, $2);\n                    var ae = this.paint._values["fill-outline-color"];\n                    ae.value.kind === "constant" && ae.value.value === void 0 && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);\n                  }, y3.prototype.createBucket = function(U) {\n                    return new mp(U);\n                  }, y3.prototype.queryRadius = function() {\n                    return Pv(this.paint.get("fill-translate"));\n                  }, y3.prototype.queryIntersectsFeature = function(U, $2, ae, he, Oe, rt, gt) {\n                    var Et = Jv(U, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), rt.angle, gt);\n                    return ms(Et, he);\n                  }, y3.prototype.isTileClipped = function() {\n                    return true;\n                  }, y3;\n                })(mi), PC = Wi([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), IC = PC.members, gS = fy;\n                function fy(m3, y3, I3, U, $2) {\n                  this.properties = {}, this.extent = I3, this.type = 0, this._pbf = m3, this._geometry = -1, this._keys = U, this._values = $2, m3.readFields(RC, this, y3);\n                }\n                function RC(m3, y3, I3) {\n                  m3 == 1 ? y3.id = I3.readVarint() : m3 == 2 ? DC(I3, y3) : m3 == 3 ? y3.type = I3.readVarint() : m3 == 4 && (y3._geometry = I3.pos);\n                }\n                function DC(m3, y3) {\n                  for (var I3 = m3.readVarint() + m3.pos; m3.pos < I3; ) {\n                    var U = y3._keys[m3.readVarint()], $2 = y3._values[m3.readVarint()];\n                    y3.properties[U] = $2;\n                  }\n                }\n                fy.types = ["Unknown", "Point", "LineString", "Polygon"], fy.prototype.loadGeometry = function() {\n                  var m3 = this._pbf;\n                  m3.pos = this._geometry;\n                  for (var y3 = m3.readVarint() + m3.pos, I3 = 1, U = 0, $2 = 0, ae = 0, he = [], Oe; m3.pos < y3; ) {\n                    if (U <= 0) {\n                      var rt = m3.readVarint();\n                      I3 = rt & 7, U = rt >> 3;\n                    }\n                    if (U--, I3 === 1 || I3 === 2) $2 += m3.readSVarint(), ae += m3.readSVarint(), I3 === 1 && (Oe && he.push(Oe), Oe = []), Oe.push(new u4($2, ae));\n                    else if (I3 === 7) Oe && Oe.push(Oe[0].clone());\n                    else throw new Error("unknown command " + I3);\n                  }\n                  return Oe && he.push(Oe), he;\n                }, fy.prototype.bbox = function() {\n                  var m3 = this._pbf;\n                  m3.pos = this._geometry;\n                  for (var y3 = m3.readVarint() + m3.pos, I3 = 1, U = 0, $2 = 0, ae = 0, he = 1 / 0, Oe = -1 / 0, rt = 1 / 0, gt = -1 / 0; m3.pos < y3; ) {\n                    if (U <= 0) {\n                      var Et = m3.readVarint();\n                      I3 = Et & 7, U = Et >> 3;\n                    }\n                    if (U--, I3 === 1 || I3 === 2) $2 += m3.readSVarint(), ae += m3.readSVarint(), $2 < he && (he = $2), $2 > Oe && (Oe = $2), ae < rt && (rt = ae), ae > gt && (gt = ae);\n                    else if (I3 !== 7) throw new Error("unknown command " + I3);\n                  }\n                  return [he, rt, Oe, gt];\n                }, fy.prototype.toGeoJSON = function(m3, y3, I3) {\n                  var U = this.extent * Math.pow(2, I3), $2 = this.extent * m3, ae = this.extent * y3, he = this.loadGeometry(), Oe = fy.types[this.type], rt, gt;\n                  function Et(pr) {\n                    for (var Fr = 0; Fr < pr.length; Fr++) {\n                      var oi = pr[Fr], Hi = 180 - (oi.y + ae) * 360 / U;\n                      pr[Fr] = [(oi.x + $2) * 360 / U - 180, 360 / Math.PI * Math.atan(Math.exp(Hi * Math.PI / 180)) - 90];\n                    }\n                  }\n                  switch (this.type) {\n                    case 1:\n                      var or = [];\n                      for (rt = 0; rt < he.length; rt++) or[rt] = he[rt][0];\n                      he = or, Et(he);\n                      break;\n                    case 2:\n                      for (rt = 0; rt < he.length; rt++) Et(he[rt]);\n                      break;\n                    case 3:\n                      for (he = $9(he), rt = 0; rt < he.length; rt++) for (gt = 0; gt < he[rt].length; gt++) Et(he[rt][gt]);\n                      break;\n                  }\n                  he.length === 1 ? he = he[0] : Oe = "Multi" + Oe;\n                  var _r = { type: "Feature", geometry: { type: Oe, coordinates: he }, properties: this.properties };\n                  return "id" in this && (_r.id = this.id), _r;\n                };\n                function $9(m3) {\n                  var y3 = m3.length;\n                  if (y3 <= 1) return [m3];\n                  for (var I3 = [], U, $2, ae = 0; ae < y3; ae++) {\n                    var he = FC(m3[ae]);\n                    he !== 0 && ($2 === void 0 && ($2 = he < 0), $2 === he < 0 ? (U && I3.push(U), U = [m3[ae]]) : U.push(m3[ae]));\n                  }\n                  return U && I3.push(U), I3;\n                }\n                function FC(m3) {\n                  for (var y3 = 0, I3 = 0, U = m3.length, $2 = U - 1, ae, he; I3 < U; $2 = I3++) ae = m3[I3], he = m3[$2], y3 += (he.x - ae.x) * (ae.y + he.y);\n                  return y3;\n                }\n                var vg = mS;\n                function mS(m3, y3) {\n                  this.version = 1, this.name = null, this.extent = 4096, this.length = 0, this._pbf = m3, this._keys = [], this._values = [], this._features = [], m3.readFields(zC, this, y3), this.length = this._features.length;\n                }\n                function zC(m3, y3, I3) {\n                  m3 === 15 ? y3.version = I3.readVarint() : m3 === 1 ? y3.name = I3.readString() : m3 === 5 ? y3.extent = I3.readVarint() : m3 === 2 ? y3._features.push(I3.pos) : m3 === 3 ? y3._keys.push(I3.readString()) : m3 === 4 && y3._values.push(OC(I3));\n                }\n                function OC(m3) {\n                  for (var y3 = null, I3 = m3.readVarint() + m3.pos; m3.pos < I3; ) {\n                    var U = m3.readVarint() >> 3;\n                    y3 = U === 1 ? m3.readString() : U === 2 ? m3.readFloat() : U === 3 ? m3.readDouble() : U === 4 ? m3.readVarint64() : U === 5 ? m3.readVarint() : U === 6 ? m3.readSVarint() : U === 7 ? m3.readBoolean() : null;\n                  }\n                  return y3;\n                }\n                mS.prototype.feature = function(m3) {\n                  if (m3 < 0 || m3 >= this._features.length) throw new Error("feature index out of bounds");\n                  this._pbf.pos = this._features[m3];\n                  var y3 = this._pbf.readVarint() + this._pbf.pos;\n                  return new gS(this._pbf, y3, this.extent, this._keys, this._values);\n                };\n                var qC = Q9;\n                function Q9(m3, y3) {\n                  this.layers = m3.readFields(eO, {}, y3);\n                }\n                function eO(m3, y3, I3) {\n                  if (m3 === 3) {\n                    var U = new vg(I3, I3.readVarint() + I3.pos);\n                    U.length && (y3[U.name] = U);\n                  }\n                }\n                var BC = qC, k1 = gS, NC = vg, pg = { VectorTile: BC, VectorTileFeature: k1, VectorTileLayer: NC }, UC = pg.VectorTileFeature.types, Bw = 500, C1 = Math.pow(2, 13);\n                function fm(m3, y3, I3, U, $2, ae, he, Oe) {\n                  m3.emplaceBack(y3, I3, Math.floor(U * C1) * 2 + he, $2 * C1 * 2, ae * C1 * 2, Math.round(Oe));\n                }\n                var Vp = function(y3) {\n                  this.zoom = y3.zoom, this.overscaling = y3.overscaling, this.layers = y3.layers, this.layerIds = this.layers.map(function(I3) {\n                    return I3.id;\n                  }), this.index = y3.index, this.hasPattern = false, this.layoutVertexArray = new Ri(), this.indexArray = new pn(), this.programConfigurations = new fi(y3.layers, y3.zoom), this.segments = new io(), this.stateDependentLayerIds = this.layers.filter(function(I3) {\n                    return I3.isStateDependent();\n                  }).map(function(I3) {\n                    return I3.id;\n                  });\n                };\n                Vp.prototype.populate = function(y3, I3, U) {\n                  this.features = [], this.hasPattern = qw("fill-extrusion", this.layers, I3);\n                  for (var $2 = 0, ae = y3; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2], Oe = he.feature, rt = he.id, gt = he.index, Et = he.sourceLayerIndex, or = this.layers[0]._featureFilter.needGeometry, _r = Ja(Oe, or);\n                    if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), _r, U)) {\n                      var pr = { id: rt, sourceLayerIndex: Et, index: gt, geometry: or ? _r.geometry : zn(Oe), properties: Oe.properties, type: Oe.type, patterns: {} };\n                      this.hasPattern ? this.features.push(Jx("fill-extrusion", this.layers, pr, this.zoom, I3)) : this.addFeature(pr, pr.geometry, gt, U, {}), I3.featureIndex.insert(Oe, pr.geometry, gt, Et, this.index, true);\n                    }\n                  }\n                }, Vp.prototype.addFeatures = function(y3, I3, U) {\n                  for (var $2 = 0, ae = this.features; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2], Oe = he.geometry;\n                    this.addFeature(he, Oe, he.index, I3, U);\n                  }\n                }, Vp.prototype.update = function(y3, I3, U) {\n                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y3, I3, this.stateDependentLayers, U);\n                }, Vp.prototype.isEmpty = function() {\n                  return this.layoutVertexArray.length === 0;\n                }, Vp.prototype.uploadPending = function() {\n                  return !this.uploaded || this.programConfigurations.needsUpload;\n                }, Vp.prototype.upload = function(y3) {\n                  this.uploaded || (this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, IC), this.indexBuffer = y3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y3), this.uploaded = true;\n                }, Vp.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());\n                }, Vp.prototype.addFeature = function(y3, I3, U, $2, ae) {\n                  for (var he = 0, Oe = Ow(I3, Bw); he < Oe.length; he += 1) {\n                    for (var rt = Oe[he], gt = 0, Et = 0, or = rt; Et < or.length; Et += 1) {\n                      var _r = or[Et];\n                      gt += _r.length;\n                    }\n                    for (var pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray), Fr = 0, oi = rt; Fr < oi.length; Fr += 1) {\n                      var Hi = oi[Fr];\n                      if (Hi.length !== 0 && !rO(Hi)) for (var Ai = 0, bn = 0; bn < Hi.length; bn++) {\n                        var nn = Hi[bn];\n                        if (bn >= 1) {\n                          var xn = Hi[bn - 1];\n                          if (!tO(nn, xn)) {\n                            pr.vertexLength + 4 > io.MAX_VERTEX_ARRAY_LENGTH && (pr = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));\n                            var Pn = nn.sub(xn)._perp()._unit(), Zn = xn.dist(nn);\n                            Ai + Zn > 32768 && (Ai = 0), fm(this.layoutVertexArray, nn.x, nn.y, Pn.x, Pn.y, 0, 0, Ai), fm(this.layoutVertexArray, nn.x, nn.y, Pn.x, Pn.y, 0, 1, Ai), Ai += Zn, fm(this.layoutVertexArray, xn.x, xn.y, Pn.x, Pn.y, 0, 0, Ai), fm(this.layoutVertexArray, xn.x, xn.y, Pn.x, Pn.y, 0, 1, Ai);\n                            var ga = pr.vertexLength;\n                            this.indexArray.emplaceBack(ga, ga + 2, ga + 1), this.indexArray.emplaceBack(ga + 1, ga + 2, ga + 3), pr.vertexLength += 4, pr.primitiveLength += 2;\n                          }\n                        }\n                      }\n                    }\n                    if (pr.vertexLength + gt > io.MAX_VERTEX_ARRAY_LENGTH && (pr = this.segments.prepareSegment(gt, this.layoutVertexArray, this.indexArray)), UC[y3.type] === "Polygon") {\n                      for (var ha = [], eo = [], za = pr.vertexLength, Za = 0, Ko = rt; Za < Ko.length; Za += 1) {\n                        var to = Ko[Za];\n                        if (to.length !== 0) {\n                          to !== rt[0] && eo.push(ha.length / 2);\n                          for (var ao = 0; ao < to.length; ao++) {\n                            var _s = to[ao];\n                            fm(this.layoutVertexArray, _s.x, _s.y, 0, 0, 1, 1, 0), ha.push(_s.x), ha.push(_s.y);\n                          }\n                        }\n                      }\n                      for (var jo = Rw(ha, eo), El = 0; El < jo.length; El += 3) this.indexArray.emplaceBack(za + jo[El], za + jo[El + 2], za + jo[El + 1]);\n                      pr.primitiveLength += jo.length / 3, pr.vertexLength += gt;\n                    }\n                  }\n                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y3, U, ae, $2);\n                }, X("FillExtrusionBucket", Vp, { omit: ["layers", "features"] });\n                function tO(m3, y3) {\n                  return m3.x === y3.x && (m3.x < 0 || m3.x > Ci) || m3.y === y3.y && (m3.y < 0 || m3.y > Ci);\n                }\n                function rO(m3) {\n                  return m3.every(function(y3) {\n                    return y3.x < 0;\n                  }) || m3.every(function(y3) {\n                    return y3.x > Ci;\n                  }) || m3.every(function(y3) {\n                    return y3.y < 0;\n                  }) || m3.every(function(y3) {\n                    return y3.y > Ci;\n                  });\n                }\n                var L1 = new Nr({ "fill-extrusion-opacity": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new zt(Rn["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new bt(Rn["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new Me(Rn["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) }), sd = { paint: L1 }, hm = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, sd);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.createBucket = function(U) {\n                    return new Vp(U);\n                  }, y3.prototype.queryRadius = function() {\n                    return Pv(this.paint.get("fill-extrusion-translate"));\n                  }, y3.prototype.is3D = function() {\n                    return true;\n                  }, y3.prototype.queryIntersectsFeature = function(U, $2, ae, he, Oe, rt, gt, Et) {\n                    var or = Jv(U, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), rt.angle, gt), _r = this.paint.get("fill-extrusion-height").evaluate($2, ae), pr = this.paint.get("fill-extrusion-base").evaluate($2, ae), Fr = iO(or, Et, rt, 0), oi = _S(he, pr, _r, Et), Hi = oi[0], Ai = oi[1];\n                    return VC(Hi, Ai, Fr);\n                  }, y3;\n                })(mi);\n                function hy(m3, y3) {\n                  return m3.x * y3.x + m3.y * y3.y;\n                }\n                function yS(m3, y3) {\n                  if (m3.length === 1) {\n                    for (var I3 = 0, U = y3[I3++], $2; !$2 || U.equals($2); ) if ($2 = y3[I3++], !$2) return 1 / 0;\n                    for (; I3 < y3.length; I3++) {\n                      var ae = y3[I3], he = m3[0], Oe = $2.sub(U), rt = ae.sub(U), gt = he.sub(U), Et = hy(Oe, Oe), or = hy(Oe, rt), _r = hy(rt, rt), pr = hy(gt, Oe), Fr = hy(gt, rt), oi = Et * _r - or * or, Hi = (_r * pr - or * Fr) / oi, Ai = (Et * Fr - or * pr) / oi, bn = 1 - Hi - Ai, nn = U.z * bn + $2.z * Hi + ae.z * Ai;\n                      if (isFinite(nn)) return nn;\n                    }\n                    return 1 / 0;\n                  } else {\n                    for (var xn = 1 / 0, Pn = 0, Zn = y3; Pn < Zn.length; Pn += 1) {\n                      var ga = Zn[Pn];\n                      xn = Math.min(xn, ga.z);\n                    }\n                    return xn;\n                  }\n                }\n                function VC(m3, y3, I3) {\n                  var U = 1 / 0;\n                  ms(I3, y3) && (U = yS(I3, y3[0]));\n                  for (var $2 = 0; $2 < y3.length; $2++) for (var ae = y3[$2], he = m3[$2], Oe = 0; Oe < ae.length - 1; Oe++) {\n                    var rt = ae[Oe], gt = ae[Oe + 1], Et = he[Oe], or = he[Oe + 1], _r = [rt, gt, or, Et, rt];\n                    so(I3, _r) && (U = Math.min(U, yS(I3, _r)));\n                  }\n                  return U === 1 / 0 ? false : U;\n                }\n                function _S(m3, y3, I3, U) {\n                  for (var $2 = [], ae = [], he = U[8] * y3, Oe = U[9] * y3, rt = U[10] * y3, gt = U[11] * y3, Et = U[8] * I3, or = U[9] * I3, _r = U[10] * I3, pr = U[11] * I3, Fr = 0, oi = m3; Fr < oi.length; Fr += 1) {\n                    for (var Hi = oi[Fr], Ai = [], bn = [], nn = 0, xn = Hi; nn < xn.length; nn += 1) {\n                      var Pn = xn[nn], Zn = Pn.x, ga = Pn.y, ha = U[0] * Zn + U[4] * ga + U[12], eo = U[1] * Zn + U[5] * ga + U[13], za = U[2] * Zn + U[6] * ga + U[14], Za = U[3] * Zn + U[7] * ga + U[15], Ko = ha + he, to = eo + Oe, ao = za + rt, _s = Za + gt, jo = ha + Et, El = eo + or, Iu = za + _r, kl = Za + pr, Cl = new u4(Ko / _s, to / _s);\n                      Cl.z = ao / _s, Ai.push(Cl);\n                      var yl = new u4(jo / kl, El / kl);\n                      yl.z = Iu / kl, bn.push(yl);\n                    }\n                    $2.push(Ai), ae.push(bn);\n                  }\n                  return [$2, ae];\n                }\n                function iO(m3, y3, I3, U) {\n                  for (var $2 = [], ae = 0, he = m3; ae < he.length; ae += 1) {\n                    var Oe = he[ae], rt = [Oe.x, Oe.y, U, 1];\n                    uy(rt, rt, y3), $2.push(new u4(rt[0] / rt[3], rt[1] / rt[3]));\n                  }\n                  return $2;\n                }\n                var GC = Wi([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), HC = GC.members, nO = Wi([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), jC = nO.members, xS = pg.VectorTileFeature.types, Nw = 63, WC = Math.cos(75 / 2 * (Math.PI / 180)), eb = 15, bS = 20, XC = 15, Uw = 1 / 2, tb = Math.pow(2, XC - 1) / Uw, sh = function(y3) {\n                  var I3 = this;\n                  this.zoom = y3.zoom, this.overscaling = y3.overscaling, this.layers = y3.layers, this.layerIds = this.layers.map(function(U) {\n                    return U.id;\n                  }), this.index = y3.index, this.hasPattern = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach(function(U) {\n                    I3.gradients[U.id] = {};\n                  }), this.layoutVertexArray = new ci(), this.layoutVertexArray2 = new an(), this.indexArray = new pn(), this.programConfigurations = new fi(y3.layers, y3.zoom), this.segments = new io(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter(function(U) {\n                    return U.isStateDependent();\n                  }).map(function(U) {\n                    return U.id;\n                  });\n                };\n                sh.prototype.populate = function(y3, I3, U) {\n                  this.hasPattern = qw("line", this.layers, I3);\n                  for (var $2 = this.layers[0].layout.get("line-sort-key"), ae = [], he = 0, Oe = y3; he < Oe.length; he += 1) {\n                    var rt = Oe[he], gt = rt.feature, Et = rt.id, or = rt.index, _r = rt.sourceLayerIndex, pr = this.layers[0]._featureFilter.needGeometry, Fr = Ja(gt, pr);\n                    if (this.layers[0]._featureFilter.filter(new Gn(this.zoom), Fr, U)) {\n                      var oi = $2 ? $2.evaluate(Fr, {}, U) : void 0, Hi = { id: Et, properties: gt.properties, type: gt.type, sourceLayerIndex: _r, index: or, geometry: pr ? Fr.geometry : zn(gt), patterns: {}, sortKey: oi };\n                      ae.push(Hi);\n                    }\n                  }\n                  $2 && ae.sort(function(za, Za) {\n                    return za.sortKey - Za.sortKey;\n                  });\n                  for (var Ai = 0, bn = ae; Ai < bn.length; Ai += 1) {\n                    var nn = bn[Ai], xn = nn, Pn = xn.geometry, Zn = xn.index, ga = xn.sourceLayerIndex;\n                    if (this.hasPattern) {\n                      var ha = Jx("line", this.layers, nn, this.zoom, I3);\n                      this.patternFeatures.push(ha);\n                    } else this.addFeature(nn, Pn, Zn, U, {});\n                    var eo = y3[Zn].feature;\n                    I3.featureIndex.insert(eo, Pn, Zn, ga, this.index);\n                  }\n                }, sh.prototype.update = function(y3, I3, U) {\n                  this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(y3, I3, this.stateDependentLayers, U);\n                }, sh.prototype.addFeatures = function(y3, I3, U) {\n                  for (var $2 = 0, ae = this.patternFeatures; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    this.addFeature(he, he.geometry, he.index, I3, U);\n                  }\n                }, sh.prototype.isEmpty = function() {\n                  return this.layoutVertexArray.length === 0;\n                }, sh.prototype.uploadPending = function() {\n                  return !this.uploaded || this.programConfigurations.needsUpload;\n                }, sh.prototype.upload = function(y3) {\n                  this.uploaded || (this.layoutVertexArray2.length !== 0 && (this.layoutVertexBuffer2 = y3.createVertexBuffer(this.layoutVertexArray2, jC)), this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, HC), this.indexBuffer = y3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(y3), this.uploaded = true;\n                }, sh.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());\n                }, sh.prototype.lineFeatureClips = function(y3) {\n                  if (y3.properties && y3.properties.hasOwnProperty("mapbox_clip_start") && y3.properties.hasOwnProperty("mapbox_clip_end")) {\n                    var I3 = +y3.properties.mapbox_clip_start, U = +y3.properties.mapbox_clip_end;\n                    return { start: I3, end: U };\n                  }\n                }, sh.prototype.addFeature = function(y3, I3, U, $2, ae) {\n                  var he = this.layers[0].layout, Oe = he.get("line-join").evaluate(y3, {}), rt = he.get("line-cap"), gt = he.get("line-miter-limit"), Et = he.get("line-round-limit");\n                  this.lineClips = this.lineFeatureClips(y3);\n                  for (var or = 0, _r = I3; or < _r.length; or += 1) {\n                    var pr = _r[or];\n                    this.addLine(pr, y3, Oe, rt, gt, Et);\n                  }\n                  this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, y3, U, ae, $2);\n                }, sh.prototype.addLine = function(y3, I3, U, $2, ae, he) {\n                  if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, this.lineClips) {\n                    this.lineClipsArray.push(this.lineClips);\n                    for (var Oe = 0; Oe < y3.length - 1; Oe++) this.totalDistance += y3[Oe].dist(y3[Oe + 1]);\n                    this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);\n                  }\n                  for (var rt = xS[I3.type] === "Polygon", gt = y3.length; gt >= 2 && y3[gt - 1].equals(y3[gt - 2]); ) gt--;\n                  for (var Et = 0; Et < gt - 1 && y3[Et].equals(y3[Et + 1]); ) Et++;\n                  if (!(gt < (rt ? 3 : 2))) {\n                    U === "bevel" && (ae = 1.05);\n                    var or = this.overscaling <= 16 ? eb * Ci / (512 * this.overscaling) : 0, _r = this.segments.prepareSegment(gt * 10, this.layoutVertexArray, this.indexArray), pr, Fr = void 0, oi = void 0, Hi = void 0, Ai = void 0;\n                    this.e1 = this.e2 = -1, rt && (pr = y3[gt - 2], Ai = y3[Et].sub(pr)._unit()._perp());\n                    for (var bn = Et; bn < gt; bn++) if (oi = bn === gt - 1 ? rt ? y3[Et + 1] : void 0 : y3[bn + 1], !(oi && y3[bn].equals(oi))) {\n                      Ai && (Hi = Ai), pr && (Fr = pr), pr = y3[bn], Ai = oi ? oi.sub(pr)._unit()._perp() : Hi, Hi = Hi || Ai;\n                      var nn = Hi.add(Ai);\n                      (nn.x !== 0 || nn.y !== 0) && nn._unit();\n                      var xn = Hi.x * Ai.x + Hi.y * Ai.y, Pn = nn.x * Ai.x + nn.y * Ai.y, Zn = Pn !== 0 ? 1 / Pn : 1 / 0, ga = 2 * Math.sqrt(2 - 2 * Pn), ha = Pn < WC && Fr && oi, eo = Hi.x * Ai.y - Hi.y * Ai.x > 0;\n                      if (ha && bn > Et) {\n                        var za = pr.dist(Fr);\n                        if (za > 2 * or) {\n                          var Za = pr.sub(pr.sub(Fr)._mult(or / za)._round());\n                          this.updateDistance(Fr, Za), this.addCurrentVertex(Za, Hi, 0, 0, _r), Fr = Za;\n                        }\n                      }\n                      var Ko = Fr && oi, to = Ko ? U : rt ? "butt" : $2;\n                      if (Ko && to === "round" && (Zn < he ? to = "miter" : Zn <= 2 && (to = "fakeround")), to === "miter" && Zn > ae && (to = "bevel"), to === "bevel" && (Zn > 2 && (to = "flipbevel"), Zn < ae && (to = "miter")), Fr && this.updateDistance(Fr, pr), to === "miter") nn._mult(Zn), this.addCurrentVertex(pr, nn, 0, 0, _r);\n                      else if (to === "flipbevel") {\n                        if (Zn > 100) nn = Ai.mult(-1);\n                        else {\n                          var ao = Zn * Hi.add(Ai).mag() / Hi.sub(Ai).mag();\n                          nn._perp()._mult(ao * (eo ? -1 : 1));\n                        }\n                        this.addCurrentVertex(pr, nn, 0, 0, _r), this.addCurrentVertex(pr, nn.mult(-1), 0, 0, _r);\n                      } else if (to === "bevel" || to === "fakeround") {\n                        var _s = -Math.sqrt(Zn * Zn - 1), jo = eo ? _s : 0, El = eo ? 0 : _s;\n                        if (Fr && this.addCurrentVertex(pr, Hi, jo, El, _r), to === "fakeround") for (var Iu = Math.round(ga * 180 / Math.PI / bS), kl = 1; kl < Iu; kl++) {\n                          var Cl = kl / Iu;\n                          if (Cl !== 0.5) {\n                            var yl = Cl - 0.5, Qu = 1.0904 + xn * (-3.2452 + xn * (3.55645 - xn * 1.43519)), gc = 0.848013 + xn * (-1.06021 + xn * 0.215638);\n                            Cl = Cl + Cl * yl * (Cl - 1) * (Qu * yl * yl + gc);\n                          }\n                          var Sf = Ai.sub(Hi)._mult(Cl)._add(Hi)._unit()._mult(eo ? -1 : 1);\n                          this.addHalfVertex(pr, Sf.x, Sf.y, false, eo, 0, _r);\n                        }\n                        oi && this.addCurrentVertex(pr, Ai, -jo, -El, _r);\n                      } else if (to === "butt") this.addCurrentVertex(pr, nn, 0, 0, _r);\n                      else if (to === "square") {\n                        var Ff = Fr ? 1 : -1;\n                        this.addCurrentVertex(pr, nn, Ff, Ff, _r);\n                      } else to === "round" && (Fr && (this.addCurrentVertex(pr, Hi, 0, 0, _r), this.addCurrentVertex(pr, Hi, 1, 1, _r, true)), oi && (this.addCurrentVertex(pr, Ai, -1, -1, _r, true), this.addCurrentVertex(pr, Ai, 0, 0, _r)));\n                      if (ha && bn < gt - 1) {\n                        var Yh = pr.dist(oi);\n                        if (Yh > 2 * or) {\n                          var ch = pr.add(oi.sub(pr)._mult(or / Yh)._round());\n                          this.updateDistance(pr, ch), this.addCurrentVertex(ch, Ai, 0, 0, _r), pr = ch;\n                        }\n                      }\n                    }\n                  }\n                }, sh.prototype.addCurrentVertex = function(y3, I3, U, $2, ae, he) {\n                  he === void 0 && (he = false);\n                  var Oe = I3.x + I3.y * U, rt = I3.y - I3.x * U, gt = -I3.x + I3.y * $2, Et = -I3.y - I3.x * $2;\n                  this.addHalfVertex(y3, Oe, rt, he, false, U, ae), this.addHalfVertex(y3, gt, Et, he, true, -$2, ae), this.distance > tb / 2 && this.totalDistance === 0 && (this.distance = 0, this.addCurrentVertex(y3, I3, U, $2, ae, he));\n                }, sh.prototype.addHalfVertex = function(y3, I3, U, $2, ae, he, Oe) {\n                  var rt = y3.x, gt = y3.y, Et = this.lineClips ? this.scaledDistance * (tb - 1) : this.scaledDistance, or = Et * Uw;\n                  if (this.layoutVertexArray.emplaceBack((rt << 1) + ($2 ? 1 : 0), (gt << 1) + (ae ? 1 : 0), Math.round(Nw * I3) + 128, Math.round(Nw * U) + 128, (he === 0 ? 0 : he < 0 ? -1 : 1) + 1 | (or & 63) << 2, or >> 6), this.lineClips) {\n                    var _r = this.scaledDistance - this.lineClips.start, pr = this.lineClips.end - this.lineClips.start, Fr = _r / pr;\n                    this.layoutVertexArray2.emplaceBack(Fr, this.lineClipsArray.length);\n                  }\n                  var oi = Oe.vertexLength++;\n                  this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, this.e2, oi), Oe.primitiveLength++), ae ? this.e2 = oi : this.e1 = oi;\n                }, sh.prototype.updateScaledDistance = function() {\n                  this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;\n                }, sh.prototype.updateDistance = function(y3, I3) {\n                  this.distance += y3.dist(I3), this.updateScaledDistance();\n                }, X("LineBucket", sh, { omit: ["layers", "patternFeatures"] });\n                var wS = new Nr({ "line-cap": new Me(Rn.layout_line["line-cap"]), "line-join": new bt(Rn.layout_line["line-join"]), "line-miter-limit": new Me(Rn.layout_line["line-miter-limit"]), "line-round-limit": new Me(Rn.layout_line["line-round-limit"]), "line-sort-key": new bt(Rn.layout_line["line-sort-key"]) }), TS = new Nr({ "line-opacity": new bt(Rn.paint_line["line-opacity"]), "line-color": new bt(Rn.paint_line["line-color"]), "line-translate": new Me(Rn.paint_line["line-translate"]), "line-translate-anchor": new Me(Rn.paint_line["line-translate-anchor"]), "line-width": new bt(Rn.paint_line["line-width"]), "line-gap-width": new bt(Rn.paint_line["line-gap-width"]), "line-offset": new bt(Rn.paint_line["line-offset"]), "line-blur": new bt(Rn.paint_line["line-blur"]), "line-dasharray": new Rr(Rn.paint_line["line-dasharray"]), "line-pattern": new zt(Rn.paint_line["line-pattern"]), "line-gradient": new jr(Rn.paint_line["line-gradient"]) }), Vw = { paint: TS, layout: wS }, aO = (function(m3) {\n                  function y3() {\n                    m3.apply(this, arguments);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.possiblyEvaluate = function(U, $2) {\n                    return $2 = new Gn(Math.floor($2.zoom), { now: $2.now, fadeDuration: $2.fadeDuration, zoomHistory: $2.zoomHistory, transition: $2.transition }), m3.prototype.possiblyEvaluate.call(this, U, $2);\n                  }, y3.prototype.evaluate = function(U, $2, ae, he) {\n                    return $2 = x2({}, $2, { zoom: Math.floor($2.zoom) }), m3.prototype.evaluate.call(this, U, $2, ae, he);\n                  }, y3;\n                })(bt), R = new aO(Vw.paint.properties["line-width"].specification);\n                R.useIntegerZoom = true;\n                var A3 = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, Vw), this.gradientVersion = 0;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype._handleSpecialPaintPropertyUpdate = function(U) {\n                    if (U === "line-gradient") {\n                      var $2 = this._transitionablePaint._values["line-gradient"].value.expression;\n                      this.stepInterpolant = $2._styleExpression.expression instanceof _u, this.gradientVersion = (this.gradientVersion + 1) % d3;\n                    }\n                  }, y3.prototype.gradientExpression = function() {\n                    return this._transitionablePaint._values["line-gradient"].value.expression;\n                  }, y3.prototype.recalculate = function(U, $2) {\n                    m3.prototype.recalculate.call(this, U, $2), this.paint._values["line-floorwidth"] = R.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, U);\n                  }, y3.prototype.createBucket = function(U) {\n                    return new sh(U);\n                  }, y3.prototype.queryRadius = function(U) {\n                    var $2 = U, ae = F3(Ad("line-width", this, $2), Ad("line-gap-width", this, $2)), he = Ad("line-offset", this, $2);\n                    return ae / 2 + Math.abs(he) + Pv(this.paint.get("line-translate"));\n                  }, y3.prototype.queryIntersectsFeature = function(U, $2, ae, he, Oe, rt, gt) {\n                    var Et = Jv(U, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), rt.angle, gt), or = gt / 2 * F3(this.paint.get("line-width").evaluate($2, ae), this.paint.get("line-gap-width").evaluate($2, ae)), _r = this.paint.get("line-offset").evaluate($2, ae);\n                    return _r && (he = W(he, _r * gt)), ou(Et, he, or);\n                  }, y3.prototype.isTileClipped = function() {\n                    return true;\n                  }, y3;\n                })(mi);\n                function F3(m3, y3) {\n                  return y3 > 0 ? y3 + 2 * m3 : m3;\n                }\n                function W(m3, y3) {\n                  for (var I3 = [], U = new u4(0, 0), $2 = 0; $2 < m3.length; $2++) {\n                    for (var ae = m3[$2], he = [], Oe = 0; Oe < ae.length; Oe++) {\n                      var rt = ae[Oe - 1], gt = ae[Oe], Et = ae[Oe + 1], or = Oe === 0 ? U : gt.sub(rt)._unit()._perp(), _r = Oe === ae.length - 1 ? U : Et.sub(gt)._unit()._perp(), pr = or._add(_r)._unit(), Fr = pr.x * _r.x + pr.y * _r.y;\n                      pr._mult(1 / Fr), he.push(pr._mult(y3)._add(gt));\n                    }\n                    I3.push(he);\n                  }\n                  return I3;\n                }\n                var re = Wi([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), fe = Wi([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4), pe = Wi([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4), ze = Wi([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }]), Ke = Wi([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]), ct = Wi([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), Lt = Wi([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4), $t = Wi([{ name: "triangle", components: 3, type: "Uint16" }]), fr = Wi([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]), mr = Wi([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", components: 2, name: "textOffset" }, { type: "Float32", name: "collisionCircleDiameter" }]), Pr = Wi([{ type: "Float32", name: "offsetX" }]), zr = Wi([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]);\n                function ui(m3, y3, I3) {\n                  var U = y3.layout.get("text-transform").evaluate(I3, {});\n                  return U === "uppercase" ? m3 = m3.toLocaleUpperCase() : U === "lowercase" && (m3 = m3.toLocaleLowerCase()), Ms.applyArabicShaping && (m3 = Ms.applyArabicShaping(m3)), m3;\n                }\n                function yi(m3, y3, I3) {\n                  return m3.sections.forEach(function(U) {\n                    U.text = ui(U.text, y3, I3);\n                  }), m3;\n                }\n                function vn(m3) {\n                  var y3 = {}, I3 = {}, U = [], $2 = 0;\n                  function ae(Ai) {\n                    U.push(m3[Ai]), $2++;\n                  }\n                  function he(Ai, bn, nn) {\n                    var xn = I3[Ai];\n                    return delete I3[Ai], I3[bn] = xn, U[xn].geometry[0].pop(), U[xn].geometry[0] = U[xn].geometry[0].concat(nn[0]), xn;\n                  }\n                  function Oe(Ai, bn, nn) {\n                    var xn = y3[bn];\n                    return delete y3[bn], y3[Ai] = xn, U[xn].geometry[0].shift(), U[xn].geometry[0] = nn[0].concat(U[xn].geometry[0]), xn;\n                  }\n                  function rt(Ai, bn, nn) {\n                    var xn = nn ? bn[0][bn[0].length - 1] : bn[0][0];\n                    return Ai + ":" + xn.x + ":" + xn.y;\n                  }\n                  for (var gt = 0; gt < m3.length; gt++) {\n                    var Et = m3[gt], or = Et.geometry, _r = Et.text ? Et.text.toString() : null;\n                    if (!_r) {\n                      ae(gt);\n                      continue;\n                    }\n                    var pr = rt(_r, or), Fr = rt(_r, or, true);\n                    if (pr in I3 && Fr in y3 && I3[pr] !== y3[Fr]) {\n                      var oi = Oe(pr, Fr, or), Hi = he(pr, Fr, U[oi].geometry);\n                      delete y3[pr], delete I3[Fr], I3[rt(_r, U[Hi].geometry, true)] = Hi, U[oi].geometry = null;\n                    } else pr in I3 ? he(pr, Fr, or) : Fr in y3 ? Oe(pr, Fr, or) : (ae(gt), y3[pr] = $2 - 1, I3[Fr] = $2 - 1);\n                  }\n                  return U.filter(function(Ai) {\n                    return Ai.geometry;\n                  });\n                }\n                var zi = { "!": "\\uFE15", "#": "\\uFF03", $: "\\uFF04", "%": "\\uFF05", "&": "\\uFF06", "(": "\\uFE35", ")": "\\uFE36", "*": "\\uFF0A", "+": "\\uFF0B", ",": "\\uFE10", "-": "\\uFE32", ".": "\\u30FB", "/": "\\uFF0F", ":": "\\uFE13", ";": "\\uFE14", "<": "\\uFE3F", "=": "\\uFF1D", ">": "\\uFE40", "?": "\\uFE16", "@": "\\uFF20", "[": "\\uFE47", "\\\\": "\\uFF3C", "]": "\\uFE48", "^": "\\uFF3E", _: "\\uFE33", "`": "\\uFF40", "{": "\\uFE37", "|": "\\u2015", "}": "\\uFE38", "~": "\\uFF5E", "\\xA2": "\\uFFE0", "\\xA3": "\\uFFE1", "\\xA5": "\\uFFE5", "\\xA6": "\\uFFE4", "\\xAC": "\\uFFE2", "\\xAF": "\\uFFE3", "\\u2013": "\\uFE32", "\\u2014": "\\uFE31", "\\u2018": "\\uFE43", "\\u2019": "\\uFE44", "\\u201C": "\\uFE41", "\\u201D": "\\uFE42", "\\u2026": "\\uFE19", "\\u2027": "\\u30FB", "\\u20A9": "\\uFFE6", "\\u3001": "\\uFE11", "\\u3002": "\\uFE12", "\\u3008": "\\uFE3F", "\\u3009": "\\uFE40", "\\u300A": "\\uFE3D", "\\u300B": "\\uFE3E", "\\u300C": "\\uFE41", "\\u300D": "\\uFE42", "\\u300E": "\\uFE43", "\\u300F": "\\uFE44", "\\u3010": "\\uFE3B", "\\u3011": "\\uFE3C", "\\u3014": "\\uFE39", "\\u3015": "\\uFE3A", "\\u3016": "\\uFE17", "\\u3017": "\\uFE18", "\\uFF01": "\\uFE15", "\\uFF08": "\\uFE35", "\\uFF09": "\\uFE36", "\\uFF0C": "\\uFE10", "\\uFF0D": "\\uFE32", "\\uFF0E": "\\u30FB", "\\uFF1A": "\\uFE13", "\\uFF1B": "\\uFE14", "\\uFF1C": "\\uFE3F", "\\uFF1E": "\\uFE40", "\\uFF1F": "\\uFE16", "\\uFF3B": "\\uFE47", "\\uFF3D": "\\uFE48", "\\uFF3F": "\\uFE33", "\\uFF5B": "\\uFE37", "\\uFF5C": "\\u2015", "\\uFF5D": "\\uFE38", "\\uFF5F": "\\uFE35", "\\uFF60": "\\uFE36", "\\uFF61": "\\uFE12", "\\uFF62": "\\uFE41", "\\uFF63": "\\uFE42" };\n                function un(m3) {\n                  for (var y3 = "", I3 = 0; I3 < m3.length; I3++) {\n                    var U = m3.charCodeAt(I3 + 1) || null, $2 = m3.charCodeAt(I3 - 1) || null, ae = (!U || !bi(U) || zi[m3[I3 + 1]]) && (!$2 || !bi($2) || zi[m3[I3 - 1]]);\n                    ae && zi[m3[I3]] ? y3 += zi[m3[I3]] : y3 += m3[I3];\n                  }\n                  return y3;\n                }\n                var Tn = 24, pa = function(m3, y3, I3, U, $2) {\n                  var ae, he, Oe = $2 * 8 - U - 1, rt = (1 << Oe) - 1, gt = rt >> 1, Et = -7, or = I3 ? $2 - 1 : 0, _r = I3 ? -1 : 1, pr = m3[y3 + or];\n                  for (or += _r, ae = pr & (1 << -Et) - 1, pr >>= -Et, Et += Oe; Et > 0; ae = ae * 256 + m3[y3 + or], or += _r, Et -= 8) ;\n                  for (he = ae & (1 << -Et) - 1, ae >>= -Et, Et += U; Et > 0; he = he * 256 + m3[y3 + or], or += _r, Et -= 8) ;\n                  if (ae === 0) ae = 1 - gt;\n                  else {\n                    if (ae === rt) return he ? NaN : (pr ? -1 : 1) * (1 / 0);\n                    he = he + Math.pow(2, U), ae = ae - gt;\n                  }\n                  return (pr ? -1 : 1) * he * Math.pow(2, ae - U);\n                }, ro = function(m3, y3, I3, U, $2, ae) {\n                  var he, Oe, rt, gt = ae * 8 - $2 - 1, Et = (1 << gt) - 1, or = Et >> 1, _r = $2 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, pr = U ? 0 : ae - 1, Fr = U ? 1 : -1, oi = y3 < 0 || y3 === 0 && 1 / y3 < 0 ? 1 : 0;\n                  for (y3 = Math.abs(y3), isNaN(y3) || y3 === 1 / 0 ? (Oe = isNaN(y3) ? 1 : 0, he = Et) : (he = Math.floor(Math.log(y3) / Math.LN2), y3 * (rt = Math.pow(2, -he)) < 1 && (he--, rt *= 2), he + or >= 1 ? y3 += _r / rt : y3 += _r * Math.pow(2, 1 - or), y3 * rt >= 2 && (he++, rt /= 2), he + or >= Et ? (Oe = 0, he = Et) : he + or >= 1 ? (Oe = (y3 * rt - 1) * Math.pow(2, $2), he = he + or) : (Oe = y3 * Math.pow(2, or - 1) * Math.pow(2, $2), he = 0)); $2 >= 8; m3[I3 + pr] = Oe & 255, pr += Fr, Oe /= 256, $2 -= 8) ;\n                  for (he = he << $2 | Oe, gt += $2; gt > 0; m3[I3 + pr] = he & 255, pr += Fr, he /= 256, gt -= 8) ;\n                  m3[I3 + pr - Fr] |= oi * 128;\n                }, Vo = { read: pa, write: ro }, Xa = sa;\n                function sa(m3) {\n                  this.buf = ArrayBuffer.isView && ArrayBuffer.isView(m3) ? m3 : new Uint8Array(m3 || 0), this.pos = 0, this.type = 0, this.length = this.buf.length;\n                }\n                sa.Varint = 0, sa.Fixed64 = 1, sa.Bytes = 2, sa.Fixed32 = 5;\n                var Mo = 65536 * 65536, fo = 1 / Mo, lo = 12, Xn = typeof TextDecoder == "undefined" ? null : new TextDecoder("utf8");\n                sa.prototype = { destroy: function() {\n                  this.buf = null;\n                }, readFields: function(m3, y3, I3) {\n                  for (I3 = I3 || this.length; this.pos < I3; ) {\n                    var U = this.readVarint(), $2 = U >> 3, ae = this.pos;\n                    this.type = U & 7, m3($2, y3, this), this.pos === ae && this.skip(U);\n                  }\n                  return y3;\n                }, readMessage: function(m3, y3) {\n                  return this.readFields(m3, y3, this.readVarint() + this.pos);\n                }, readFixed32: function() {\n                  var m3 = Wh(this.buf, this.pos);\n                  return this.pos += 4, m3;\n                }, readSFixed32: function() {\n                  var m3 = Fv(this.buf, this.pos);\n                  return this.pos += 4, m3;\n                }, readFixed64: function() {\n                  var m3 = Wh(this.buf, this.pos) + Wh(this.buf, this.pos + 4) * Mo;\n                  return this.pos += 8, m3;\n                }, readSFixed64: function() {\n                  var m3 = Wh(this.buf, this.pos) + Fv(this.buf, this.pos + 4) * Mo;\n                  return this.pos += 8, m3;\n                }, readFloat: function() {\n                  var m3 = Vo.read(this.buf, this.pos, true, 23, 4);\n                  return this.pos += 4, m3;\n                }, readDouble: function() {\n                  var m3 = Vo.read(this.buf, this.pos, true, 52, 8);\n                  return this.pos += 8, m3;\n                }, readVarint: function(m3) {\n                  var y3 = this.buf, I3, U;\n                  return U = y3[this.pos++], I3 = U & 127, U < 128 || (U = y3[this.pos++], I3 |= (U & 127) << 7, U < 128) || (U = y3[this.pos++], I3 |= (U & 127) << 14, U < 128) || (U = y3[this.pos++], I3 |= (U & 127) << 21, U < 128) ? I3 : (U = y3[this.pos], I3 |= (U & 15) << 28, Ro(I3, m3, this));\n                }, readVarint64: function() {\n                  return this.readVarint(true);\n                }, readSVarint: function() {\n                  var m3 = this.readVarint();\n                  return m3 % 2 === 1 ? (m3 + 1) / -2 : m3 / 2;\n                }, readBoolean: function() {\n                  return !!this.readVarint();\n                }, readString: function() {\n                  var m3 = this.readVarint() + this.pos, y3 = this.pos;\n                  return this.pos = m3, m3 - y3 >= lo && Xn ? tu(this.buf, y3, m3) : lv(this.buf, y3, m3);\n                }, readBytes: function() {\n                  var m3 = this.readVarint() + this.pos, y3 = this.buf.subarray(this.pos, m3);\n                  return this.pos = m3, y3;\n                }, readPackedVarint: function(m3, y3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readVarint(y3));\n                  var I3 = uo(this);\n                  for (m3 = m3 || []; this.pos < I3; ) m3.push(this.readVarint(y3));\n                  return m3;\n                }, readPackedSVarint: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readSVarint());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readSVarint());\n                  return m3;\n                }, readPackedBoolean: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readBoolean());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readBoolean());\n                  return m3;\n                }, readPackedFloat: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readFloat());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readFloat());\n                  return m3;\n                }, readPackedDouble: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readDouble());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readDouble());\n                  return m3;\n                }, readPackedFixed32: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readFixed32());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readFixed32());\n                  return m3;\n                }, readPackedSFixed32: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readSFixed32());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readSFixed32());\n                  return m3;\n                }, readPackedFixed64: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readFixed64());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readFixed64());\n                  return m3;\n                }, readPackedSFixed64: function(m3) {\n                  if (this.type !== sa.Bytes) return m3.push(this.readSFixed64());\n                  var y3 = uo(this);\n                  for (m3 = m3 || []; this.pos < y3; ) m3.push(this.readSFixed64());\n                  return m3;\n                }, skip: function(m3) {\n                  var y3 = m3 & 7;\n                  if (y3 === sa.Varint) for (; this.buf[this.pos++] > 127; ) ;\n                  else if (y3 === sa.Bytes) this.pos = this.readVarint() + this.pos;\n                  else if (y3 === sa.Fixed32) this.pos += 4;\n                  else if (y3 === sa.Fixed64) this.pos += 8;\n                  else throw new Error("Unimplemented type: " + y3);\n                }, writeTag: function(m3, y3) {\n                  this.writeVarint(m3 << 3 | y3);\n                }, realloc: function(m3) {\n                  for (var y3 = this.length || 16; y3 < this.pos + m3; ) y3 *= 2;\n                  if (y3 !== this.length) {\n                    var I3 = new Uint8Array(y3);\n                    I3.set(this.buf), this.buf = I3, this.length = y3;\n                  }\n                }, finish: function() {\n                  return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);\n                }, writeFixed32: function(m3) {\n                  this.realloc(4), Df(this.buf, m3, this.pos), this.pos += 4;\n                }, writeSFixed32: function(m3) {\n                  this.realloc(4), Df(this.buf, m3, this.pos), this.pos += 4;\n                }, writeFixed64: function(m3) {\n                  this.realloc(8), Df(this.buf, m3 & -1, this.pos), Df(this.buf, Math.floor(m3 * fo), this.pos + 4), this.pos += 8;\n                }, writeSFixed64: function(m3) {\n                  this.realloc(8), Df(this.buf, m3 & -1, this.pos), Df(this.buf, Math.floor(m3 * fo), this.pos + 4), this.pos += 8;\n                }, writeVarint: function(m3) {\n                  if (m3 = +m3 || 0, m3 > 268435455 || m3 < 0) {\n                    Ju(m3, this);\n                    return;\n                  }\n                  this.realloc(4), this.buf[this.pos++] = m3 & 127 | (m3 > 127 ? 128 : 0), !(m3 <= 127) && (this.buf[this.pos++] = (m3 >>>= 7) & 127 | (m3 > 127 ? 128 : 0), !(m3 <= 127) && (this.buf[this.pos++] = (m3 >>>= 7) & 127 | (m3 > 127 ? 128 : 0), !(m3 <= 127) && (this.buf[this.pos++] = m3 >>> 7 & 127)));\n                }, writeSVarint: function(m3) {\n                  this.writeVarint(m3 < 0 ? -m3 * 2 - 1 : m3 * 2);\n                }, writeBoolean: function(m3) {\n                  this.writeVarint(!!m3);\n                }, writeString: function(m3) {\n                  m3 = String(m3), this.realloc(m3.length * 4), this.pos++;\n                  var y3 = this.pos;\n                  this.pos = pc(this.buf, m3, this.pos);\n                  var I3 = this.pos - y3;\n                  I3 >= 128 && Qv(y3, I3, this), this.pos = y3 - 1, this.writeVarint(I3), this.pos += I3;\n                }, writeFloat: function(m3) {\n                  this.realloc(4), Vo.write(this.buf, m3, this.pos, true, 23, 4), this.pos += 4;\n                }, writeDouble: function(m3) {\n                  this.realloc(8), Vo.write(this.buf, m3, this.pos, true, 52, 8), this.pos += 8;\n                }, writeBytes: function(m3) {\n                  var y3 = m3.length;\n                  this.writeVarint(y3), this.realloc(y3);\n                  for (var I3 = 0; I3 < y3; I3++) this.buf[this.pos++] = m3[I3];\n                }, writeRawMessage: function(m3, y3) {\n                  this.pos++;\n                  var I3 = this.pos;\n                  m3(y3, this);\n                  var U = this.pos - I3;\n                  U >= 128 && Qv(I3, U, this), this.pos = I3 - 1, this.writeVarint(U), this.pos += U;\n                }, writeMessage: function(m3, y3, I3) {\n                  this.writeTag(m3, sa.Bytes), this.writeRawMessage(y3, I3);\n                }, writePackedVarint: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, ld, y3);\n                }, writePackedSVarint: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, Eh, y3);\n                }, writePackedBoolean: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, jd, y3);\n                }, writePackedFloat: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, Gd, y3);\n                }, writePackedDouble: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, Hd, y3);\n                }, writePackedFixed32: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, Af, y3);\n                }, writePackedSFixed32: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, kh, y3);\n                }, writePackedFixed64: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, Ed, y3);\n                }, writePackedSFixed64: function(m3, y3) {\n                  y3.length && this.writeMessage(m3, ud, y3);\n                }, writeBytesField: function(m3, y3) {\n                  this.writeTag(m3, sa.Bytes), this.writeBytes(y3);\n                }, writeFixed32Field: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed32), this.writeFixed32(y3);\n                }, writeSFixed32Field: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed32), this.writeSFixed32(y3);\n                }, writeFixed64Field: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed64), this.writeFixed64(y3);\n                }, writeSFixed64Field: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed64), this.writeSFixed64(y3);\n                }, writeVarintField: function(m3, y3) {\n                  this.writeTag(m3, sa.Varint), this.writeVarint(y3);\n                }, writeSVarintField: function(m3, y3) {\n                  this.writeTag(m3, sa.Varint), this.writeSVarint(y3);\n                }, writeStringField: function(m3, y3) {\n                  this.writeTag(m3, sa.Bytes), this.writeString(y3);\n                }, writeFloatField: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed32), this.writeFloat(y3);\n                }, writeDoubleField: function(m3, y3) {\n                  this.writeTag(m3, sa.Fixed64), this.writeDouble(y3);\n                }, writeBooleanField: function(m3, y3) {\n                  this.writeVarintField(m3, !!y3);\n                } };\n                function Ro(m3, y3, I3) {\n                  var U = I3.buf, $2, ae;\n                  if (ae = U[I3.pos++], $2 = (ae & 112) >> 4, ae < 128 || (ae = U[I3.pos++], $2 |= (ae & 127) << 3, ae < 128) || (ae = U[I3.pos++], $2 |= (ae & 127) << 10, ae < 128) || (ae = U[I3.pos++], $2 |= (ae & 127) << 17, ae < 128) || (ae = U[I3.pos++], $2 |= (ae & 127) << 24, ae < 128) || (ae = U[I3.pos++], $2 |= (ae & 1) << 31, ae < 128)) return $o(m3, $2, y3);\n                  throw new Error("Expected varint not more than 10 bytes");\n                }\n                function uo(m3) {\n                  return m3.type === sa.Bytes ? m3.readVarint() + m3.pos : m3.pos + 1;\n                }\n                function $o(m3, y3, I3) {\n                  return I3 ? y3 * 4294967296 + (m3 >>> 0) : (y3 >>> 0) * 4294967296 + (m3 >>> 0);\n                }\n                function Ju(m3, y3) {\n                  var I3, U;\n                  if (m3 >= 0 ? (I3 = m3 % 4294967296 | 0, U = m3 / 4294967296 | 0) : (I3 = ~(-m3 % 4294967296), U = ~(-m3 / 4294967296), I3 ^ 4294967295 ? I3 = I3 + 1 | 0 : (I3 = 0, U = U + 1 | 0)), m3 >= 18446744073709552e3 || m3 < -18446744073709552e3) throw new Error("Given varint doesn\'t fit into 10 bytes");\n                  y3.realloc(10), qu(I3, U, y3), Mh(U, y3);\n                }\n                function qu(m3, y3, I3) {\n                  I3.buf[I3.pos++] = m3 & 127 | 128, m3 >>>= 7, I3.buf[I3.pos++] = m3 & 127 | 128, m3 >>>= 7, I3.buf[I3.pos++] = m3 & 127 | 128, m3 >>>= 7, I3.buf[I3.pos++] = m3 & 127 | 128, m3 >>>= 7, I3.buf[I3.pos] = m3 & 127;\n                }\n                function Mh(m3, y3) {\n                  var I3 = (m3 & 7) << 4;\n                  y3.buf[y3.pos++] |= I3 | ((m3 >>>= 3) ? 128 : 0), m3 && (y3.buf[y3.pos++] = m3 & 127 | ((m3 >>>= 7) ? 128 : 0), m3 && (y3.buf[y3.pos++] = m3 & 127 | ((m3 >>>= 7) ? 128 : 0), m3 && (y3.buf[y3.pos++] = m3 & 127 | ((m3 >>>= 7) ? 128 : 0), m3 && (y3.buf[y3.pos++] = m3 & 127 | ((m3 >>>= 7) ? 128 : 0), m3 && (y3.buf[y3.pos++] = m3 & 127)))));\n                }\n                function Qv(m3, y3, I3) {\n                  var U = y3 <= 16383 ? 1 : y3 <= 2097151 ? 2 : y3 <= 268435455 ? 3 : Math.floor(Math.log(y3) / (Math.LN2 * 7));\n                  I3.realloc(U);\n                  for (var $2 = I3.pos - 1; $2 >= m3; $2--) I3.buf[$2 + U] = I3.buf[$2];\n                }\n                function ld(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeVarint(m3[I3]);\n                }\n                function Eh(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeSVarint(m3[I3]);\n                }\n                function Gd(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeFloat(m3[I3]);\n                }\n                function Hd(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeDouble(m3[I3]);\n                }\n                function jd(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeBoolean(m3[I3]);\n                }\n                function Af(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeFixed32(m3[I3]);\n                }\n                function kh(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeSFixed32(m3[I3]);\n                }\n                function Ed(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeFixed64(m3[I3]);\n                }\n                function ud(m3, y3) {\n                  for (var I3 = 0; I3 < m3.length; I3++) y3.writeSFixed64(m3[I3]);\n                }\n                function Wh(m3, y3) {\n                  return (m3[y3] | m3[y3 + 1] << 8 | m3[y3 + 2] << 16) + m3[y3 + 3] * 16777216;\n                }\n                function Df(m3, y3, I3) {\n                  m3[I3] = y3, m3[I3 + 1] = y3 >>> 8, m3[I3 + 2] = y3 >>> 16, m3[I3 + 3] = y3 >>> 24;\n                }\n                function Fv(m3, y3) {\n                  return (m3[y3] | m3[y3 + 1] << 8 | m3[y3 + 2] << 16) + (m3[y3 + 3] << 24);\n                }\n                function lv(m3, y3, I3) {\n                  for (var U = "", $2 = y3; $2 < I3; ) {\n                    var ae = m3[$2], he = null, Oe = ae > 239 ? 4 : ae > 223 ? 3 : ae > 191 ? 2 : 1;\n                    if ($2 + Oe > I3) break;\n                    var rt, gt, Et;\n                    Oe === 1 ? ae < 128 && (he = ae) : Oe === 2 ? (rt = m3[$2 + 1], (rt & 192) === 128 && (he = (ae & 31) << 6 | rt & 63, he <= 127 && (he = null))) : Oe === 3 ? (rt = m3[$2 + 1], gt = m3[$2 + 2], (rt & 192) === 128 && (gt & 192) === 128 && (he = (ae & 15) << 12 | (rt & 63) << 6 | gt & 63, (he <= 2047 || he >= 55296 && he <= 57343) && (he = null))) : Oe === 4 && (rt = m3[$2 + 1], gt = m3[$2 + 2], Et = m3[$2 + 3], (rt & 192) === 128 && (gt & 192) === 128 && (Et & 192) === 128 && (he = (ae & 15) << 18 | (rt & 63) << 12 | (gt & 63) << 6 | Et & 63, (he <= 65535 || he >= 1114112) && (he = null))), he === null ? (he = 65533, Oe = 1) : he > 65535 && (he -= 65536, U += String.fromCharCode(he >>> 10 & 1023 | 55296), he = 56320 | he & 1023), U += String.fromCharCode(he), $2 += Oe;\n                  }\n                  return U;\n                }\n                function tu(m3, y3, I3) {\n                  return Xn.decode(m3.subarray(y3, I3));\n                }\n                function pc(m3, y3, I3) {\n                  for (var U = 0, $2, ae; U < y3.length; U++) {\n                    if ($2 = y3.charCodeAt(U), $2 > 55295 && $2 < 57344) if (ae) if ($2 < 56320) {\n                      m3[I3++] = 239, m3[I3++] = 191, m3[I3++] = 189, ae = $2;\n                      continue;\n                    } else $2 = ae - 55296 << 10 | $2 - 56320 | 65536, ae = null;\n                    else {\n                      $2 > 56319 || U + 1 === y3.length ? (m3[I3++] = 239, m3[I3++] = 191, m3[I3++] = 189) : ae = $2;\n                      continue;\n                    }\n                    else ae && (m3[I3++] = 239, m3[I3++] = 191, m3[I3++] = 189, ae = null);\n                    $2 < 128 ? m3[I3++] = $2 : ($2 < 2048 ? m3[I3++] = $2 >> 6 | 192 : ($2 < 65536 ? m3[I3++] = $2 >> 12 | 224 : (m3[I3++] = $2 >> 18 | 240, m3[I3++] = $2 >> 12 & 63 | 128), m3[I3++] = $2 >> 6 & 63 | 128), m3[I3++] = $2 & 63 | 128);\n                  }\n                  return I3;\n                }\n                var $u = 3;\n                function zv(m3, y3, I3) {\n                  m3 === 1 && I3.readMessage(ff, y3);\n                }\n                function ff(m3, y3, I3) {\n                  if (m3 === 3) {\n                    var U = I3.readMessage(P1, {}), $2 = U.id, ae = U.bitmap, he = U.width, Oe = U.height, rt = U.left, gt = U.top, Et = U.advance;\n                    y3.push({ id: $2, bitmap: new Dv({ width: he + 2 * $u, height: Oe + 2 * $u }, ae), metrics: { width: he, height: Oe, left: rt, top: gt, advance: Et } });\n                  }\n                }\n                function P1(m3, y3, I3) {\n                  m3 === 1 ? y3.id = I3.readVarint() : m3 === 2 ? y3.bitmap = I3.readBytes() : m3 === 3 ? y3.width = I3.readVarint() : m3 === 4 ? y3.height = I3.readVarint() : m3 === 5 ? y3.left = I3.readSVarint() : m3 === 6 ? y3.top = I3.readSVarint() : m3 === 7 && (y3.advance = I3.readVarint());\n                }\n                function v0(m3) {\n                  return new Xa(m3).readFields(zv, []);\n                }\n                var Gp = $u;\n                function ep(m3) {\n                  for (var y3 = 0, I3 = 0, U = 0, $2 = m3; U < $2.length; U += 1) {\n                    var ae = $2[U];\n                    y3 += ae.w * ae.h, I3 = Math.max(I3, ae.w);\n                  }\n                  m3.sort(function(Hi, Ai) {\n                    return Ai.h - Hi.h;\n                  });\n                  for (var he = Math.max(Math.ceil(Math.sqrt(y3 / 0.95)), I3), Oe = [{ x: 0, y: 0, w: he, h: 1 / 0 }], rt = 0, gt = 0, Et = 0, or = m3; Et < or.length; Et += 1) for (var _r = or[Et], pr = Oe.length - 1; pr >= 0; pr--) {\n                    var Fr = Oe[pr];\n                    if (!(_r.w > Fr.w || _r.h > Fr.h)) {\n                      if (_r.x = Fr.x, _r.y = Fr.y, gt = Math.max(gt, _r.y + _r.h), rt = Math.max(rt, _r.x + _r.w), _r.w === Fr.w && _r.h === Fr.h) {\n                        var oi = Oe.pop();\n                        pr < Oe.length && (Oe[pr] = oi);\n                      } else _r.h === Fr.h ? (Fr.x += _r.w, Fr.w -= _r.w) : _r.w === Fr.w ? (Fr.y += _r.h, Fr.h -= _r.h) : (Oe.push({ x: Fr.x + _r.w, y: Fr.y, w: Fr.w - _r.w, h: _r.h }), Fr.y += _r.h, Fr.h -= _r.h);\n                      break;\n                    }\n                  }\n                  return { w: rt, h: gt, fill: y3 / (rt * gt) || 0 };\n                }\n                var Gc = 1, Zf = function(y3, I3) {\n                  var U = I3.pixelRatio, $2 = I3.version, ae = I3.stretchX, he = I3.stretchY, Oe = I3.content;\n                  this.paddedRect = y3, this.pixelRatio = U, this.stretchX = ae, this.stretchY = he, this.content = Oe, this.version = $2;\n                }, tp = { tl: { configurable: true }, br: { configurable: true }, tlbr: { configurable: true }, displaySize: { configurable: true } };\n                tp.tl.get = function() {\n                  return [this.paddedRect.x + Gc, this.paddedRect.y + Gc];\n                }, tp.br.get = function() {\n                  return [this.paddedRect.x + this.paddedRect.w - Gc, this.paddedRect.y + this.paddedRect.h - Gc];\n                }, tp.tlbr.get = function() {\n                  return this.tl.concat(this.br);\n                }, tp.displaySize.get = function() {\n                  return [(this.paddedRect.w - Gc * 2) / this.pixelRatio, (this.paddedRect.h - Gc * 2) / this.pixelRatio];\n                }, Object.defineProperties(Zf.prototype, tp);\n                var gg = function(y3, I3) {\n                  var U = {}, $2 = {};\n                  this.haveRenderCallbacks = [];\n                  var ae = [];\n                  this.addImages(y3, U, ae), this.addImages(I3, $2, ae);\n                  var he = ep(ae), Oe = he.w, rt = he.h, gt = new Sh({ width: Oe || 1, height: rt || 1 });\n                  for (var Et in y3) {\n                    var or = y3[Et], _r = U[Et].paddedRect;\n                    Sh.copy(or.data, gt, { x: 0, y: 0 }, { x: _r.x + Gc, y: _r.y + Gc }, or.data);\n                  }\n                  for (var pr in I3) {\n                    var Fr = I3[pr], oi = $2[pr].paddedRect, Hi = oi.x + Gc, Ai = oi.y + Gc, bn = Fr.data.width, nn = Fr.data.height;\n                    Sh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi, y: Ai }, Fr.data), Sh.copy(Fr.data, gt, { x: 0, y: nn - 1 }, { x: Hi, y: Ai - 1 }, { width: bn, height: 1 }), Sh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi, y: Ai + nn }, { width: bn, height: 1 }), Sh.copy(Fr.data, gt, { x: bn - 1, y: 0 }, { x: Hi - 1, y: Ai }, { width: 1, height: nn }), Sh.copy(Fr.data, gt, { x: 0, y: 0 }, { x: Hi + bn, y: Ai }, { width: 1, height: nn });\n                  }\n                  this.image = gt, this.iconPositions = U, this.patternPositions = $2;\n                };\n                gg.prototype.addImages = function(y3, I3, U) {\n                  for (var $2 in y3) {\n                    var ae = y3[$2], he = { x: 0, y: 0, w: ae.data.width + 2 * Gc, h: ae.data.height + 2 * Gc };\n                    U.push(he), I3[$2] = new Zf(he, ae), ae.hasRenderCallback && this.haveRenderCallbacks.push($2);\n                  }\n                }, gg.prototype.patchUpdatedImages = function(y3, I3) {\n                  y3.dispatchRenderCallbacks(this.haveRenderCallbacks);\n                  for (var U in y3.updatedImages) this.patchUpdatedImage(this.iconPositions[U], y3.getImage(U), I3), this.patchUpdatedImage(this.patternPositions[U], y3.getImage(U), I3);\n                }, gg.prototype.patchUpdatedImage = function(y3, I3, U) {\n                  if (!(!y3 || !I3) && y3.version !== I3.version) {\n                    y3.version = I3.version;\n                    var $2 = y3.tl, ae = $2[0], he = $2[1];\n                    U.update(I3.data, void 0, { x: ae, y: he });\n                  }\n                }, X("ImagePosition", Zf), X("ImageAtlas", gg);\n                var uv = { horizontal: 1, vertical: 2, horizontalOnly: 3 }, I1 = -17;\n                function AS(m3) {\n                  for (var y3 = 0, I3 = m3; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (U.positionedGlyphs.length !== 0) return false;\n                  }\n                  return true;\n                }\n                var Gw = 57344, p0 = 63743, dy = function() {\n                  this.scale = 1, this.fontStack = "", this.imageName = null;\n                };\n                dy.forText = function(y3, I3) {\n                  var U = new dy();\n                  return U.scale = y3 || 1, U.fontStack = I3, U;\n                }, dy.forImage = function(y3) {\n                  var I3 = new dy();\n                  return I3.imageName = y3, I3;\n                };\n                var Xh = function() {\n                  this.text = "", this.sectionIndex = [], this.sections = [], this.imageSectionID = null;\n                };\n                Xh.fromFeature = function(y3, I3) {\n                  for (var U = new Xh(), $2 = 0; $2 < y3.sections.length; $2++) {\n                    var ae = y3.sections[$2];\n                    ae.image ? U.addImageSection(ae) : U.addTextSection(ae, I3);\n                  }\n                  return U;\n                }, Xh.prototype.length = function() {\n                  return this.text.length;\n                }, Xh.prototype.getSection = function(y3) {\n                  return this.sections[this.sectionIndex[y3]];\n                }, Xh.prototype.getSectionIndex = function(y3) {\n                  return this.sectionIndex[y3];\n                }, Xh.prototype.getCharCode = function(y3) {\n                  return this.text.charCodeAt(y3);\n                }, Xh.prototype.verticalizePunctuation = function() {\n                  this.text = un(this.text);\n                }, Xh.prototype.trim = function() {\n                  for (var y3 = 0, I3 = 0; I3 < this.text.length && g0[this.text.charCodeAt(I3)]; I3++) y3++;\n                  for (var U = this.text.length, $2 = this.text.length - 1; $2 >= 0 && $2 >= y3 && g0[this.text.charCodeAt($2)]; $2--) U--;\n                  this.text = this.text.substring(y3, U), this.sectionIndex = this.sectionIndex.slice(y3, U);\n                }, Xh.prototype.substring = function(y3, I3) {\n                  var U = new Xh();\n                  return U.text = this.text.substring(y3, I3), U.sectionIndex = this.sectionIndex.slice(y3, I3), U.sections = this.sections, U;\n                }, Xh.prototype.toString = function() {\n                  return this.text;\n                }, Xh.prototype.getMaxScale = function() {\n                  var y3 = this;\n                  return this.sectionIndex.reduce(function(I3, U) {\n                    return Math.max(I3, y3.sections[U].scale);\n                  }, 0);\n                }, Xh.prototype.addTextSection = function(y3, I3) {\n                  this.text += y3.text, this.sections.push(dy.forText(y3.scale, y3.fontStack || I3));\n                  for (var U = this.sections.length - 1, $2 = 0; $2 < y3.text.length; ++$2) this.sectionIndex.push(U);\n                }, Xh.prototype.addImageSection = function(y3) {\n                  var I3 = y3.image ? y3.image.name : "";\n                  if (I3.length === 0) {\n                    te("Can\'t add FormattedSection with an empty image.");\n                    return;\n                  }\n                  var U = this.getNextImageSectionCharCode();\n                  if (!U) {\n                    te("Reached maximum number of images " + (p0 - Gw + 2));\n                    return;\n                  }\n                  this.text += String.fromCharCode(U), this.sections.push(dy.forImage(I3)), this.sectionIndex.push(this.sections.length - 1);\n                }, Xh.prototype.getNextImageSectionCharCode = function() {\n                  return this.imageSectionID ? this.imageSectionID >= p0 ? null : ++this.imageSectionID : (this.imageSectionID = Gw, this.imageSectionID);\n                };\n                function oO(m3, y3) {\n                  for (var I3 = [], U = m3.text, $2 = 0, ae = 0, he = y3; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    I3.push(m3.substring($2, Oe)), $2 = Oe;\n                  }\n                  return $2 < U.length && I3.push(m3.substring($2, U.length)), I3;\n                }\n                function Hw(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi) {\n                  var Hi = Xh.fromFeature(m3, $2);\n                  or === uv.vertical && Hi.verticalizePunctuation();\n                  var Ai, bn = Ms.processBidirectionalText, nn = Ms.processStyledBidirectionalText;\n                  if (bn && Hi.sections.length === 1) {\n                    Ai = [];\n                    for (var xn = bn(Hi.toString(), jw(Hi, gt, ae, y3, U, pr, Fr)), Pn = 0, Zn = xn; Pn < Zn.length; Pn += 1) {\n                      var ga = Zn[Pn], ha = new Xh();\n                      ha.text = ga, ha.sections = Hi.sections;\n                      for (var eo = 0; eo < ga.length; eo++) ha.sectionIndex.push(0);\n                      Ai.push(ha);\n                    }\n                  } else if (nn) {\n                    Ai = [];\n                    for (var za = nn(Hi.text, Hi.sectionIndex, jw(Hi, gt, ae, y3, U, pr, Fr)), Za = 0, Ko = za; Za < Ko.length; Za += 1) {\n                      var to = Ko[Za], ao = new Xh();\n                      ao.text = to[0], ao.sectionIndex = to[1], ao.sections = Hi.sections, Ai.push(ao);\n                    }\n                  } else Ai = oO(Hi, jw(Hi, gt, ae, y3, U, pr, Fr));\n                  var _s = [], jo = { positionedLines: _s, text: Hi.toString(), top: Et[1], bottom: Et[1], left: Et[0], right: Et[0], writingMode: or, iconsInText: false, verticalizable: false };\n                  return uO(jo, y3, I3, U, Ai, he, Oe, rt, or, gt, _r, oi), AS(_s) ? false : jo;\n                }\n                var g0 = {};\n                g0[9] = true, g0[10] = true, g0[11] = true, g0[12] = true, g0[13] = true, g0[32] = true;\n                var cv = {};\n                cv[10] = true, cv[32] = true, cv[38] = true, cv[40] = true, cv[41] = true, cv[43] = true, cv[45] = true, cv[47] = true, cv[173] = true, cv[183] = true, cv[8203] = true, cv[8208] = true, cv[8211] = true, cv[8231] = true;\n                function ZC(m3, y3, I3, U, $2, ae) {\n                  if (y3.imageName) {\n                    var rt = U[y3.imageName];\n                    return rt ? rt.displaySize[0] * y3.scale * Tn / ae + $2 : 0;\n                  } else {\n                    var he = I3[y3.fontStack], Oe = he && he[m3];\n                    return Oe ? Oe.metrics.advance * y3.scale + $2 : 0;\n                  }\n                }\n                function sO(m3, y3, I3, U, $2, ae) {\n                  for (var he = 0, Oe = 0; Oe < m3.length(); Oe++) {\n                    var rt = m3.getSection(Oe);\n                    he += ZC(m3.getCharCode(Oe), rt, U, $2, y3, ae);\n                  }\n                  var gt = Math.max(1, Math.ceil(he / I3));\n                  return he / gt;\n                }\n                function YC(m3, y3, I3, U) {\n                  var $2 = Math.pow(m3 - y3, 2);\n                  return U ? m3 < y3 ? $2 / 2 : $2 * 2 : $2 + Math.abs(I3) * I3;\n                }\n                function lO(m3, y3, I3) {\n                  var U = 0;\n                  return m3 === 10 && (U -= 1e4), I3 && (U += 150), (m3 === 40 || m3 === 65288) && (U += 50), (y3 === 41 || y3 === 65289) && (U += 50), U;\n                }\n                function yp(m3, y3, I3, U, $2, ae) {\n                  for (var he = null, Oe = YC(y3, I3, $2, ae), rt = 0, gt = U; rt < gt.length; rt += 1) {\n                    var Et = gt[rt], or = y3 - Et.x, _r = YC(or, I3, $2, ae) + Et.badness;\n                    _r <= Oe && (he = Et, Oe = _r);\n                  }\n                  return { index: m3, x: y3, priorBreak: he, badness: Oe };\n                }\n                function rb(m3) {\n                  return m3 ? rb(m3.priorBreak).concat(m3.index) : [];\n                }\n                function jw(m3, y3, I3, U, $2, ae, he) {\n                  if (ae !== "point") return [];\n                  if (!m3) return [];\n                  for (var Oe = [], rt = sO(m3, y3, I3, U, $2, he), gt = m3.text.indexOf("\\u200B") >= 0, Et = 0, or = 0; or < m3.length(); or++) {\n                    var _r = m3.getSection(or), pr = m3.getCharCode(or);\n                    if (g0[pr] || (Et += ZC(pr, _r, U, $2, y3, he)), or < m3.length() - 1) {\n                      var Fr = Hr(pr);\n                      (cv[pr] || Fr || _r.imageName) && Oe.push(yp(or + 1, Et, rt, Oe, lO(pr, m3.getCharCode(or + 1), Fr && gt), false));\n                    }\n                  }\n                  return rb(yp(m3.length(), Et, rt, Oe, 0, true));\n                }\n                function SS(m3) {\n                  var y3 = 0.5, I3 = 0.5;\n                  switch (m3) {\n                    case "right":\n                    case "top-right":\n                    case "bottom-right":\n                      y3 = 1;\n                      break;\n                    case "left":\n                    case "top-left":\n                    case "bottom-left":\n                      y3 = 0;\n                      break;\n                  }\n                  switch (m3) {\n                    case "bottom":\n                    case "bottom-right":\n                    case "bottom-left":\n                      I3 = 1;\n                      break;\n                    case "top":\n                    case "top-right":\n                    case "top-left":\n                      I3 = 0;\n                      break;\n                  }\n                  return { horizontalAlign: y3, verticalAlign: I3 };\n                }\n                function uO(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or) {\n                  for (var _r = 0, pr = I1, Fr = 0, oi = 0, Hi = Oe === "right" ? 1 : Oe === "left" ? 0 : 0.5, Ai = 0, bn = 0, nn = $2; bn < nn.length; bn += 1) {\n                    var xn = nn[bn];\n                    xn.trim();\n                    var Pn = xn.getMaxScale(), Zn = (Pn - 1) * Tn, ga = { positionedGlyphs: [], lineOffset: 0 };\n                    m3.positionedLines[Ai] = ga;\n                    var ha = ga.positionedGlyphs, eo = 0;\n                    if (!xn.length()) {\n                      pr += ae, ++Ai;\n                      continue;\n                    }\n                    for (var za = 0; za < xn.length(); za++) {\n                      var Za = xn.getSection(za), Ko = xn.getSectionIndex(za), to = xn.getCharCode(za), ao = 0, _s = null, jo = null, El = null, Iu = Tn, kl = !(rt === uv.horizontal || !Et && !qr(to) || Et && (g0[to] || Zr(to)));\n                      if (Za.imageName) {\n                        var Sf = U[Za.imageName];\n                        if (!Sf) continue;\n                        El = Za.imageName, m3.iconsInText = m3.iconsInText || true, jo = Sf.paddedRect;\n                        var Ff = Sf.displaySize;\n                        Za.scale = Za.scale * Tn / or, _s = { width: Ff[0], height: Ff[1], left: Gc, top: -Gp, advance: kl ? Ff[1] : Ff[0] };\n                        var Yh = Tn - Ff[1] * Za.scale;\n                        ao = Zn + Yh, Iu = _s.advance;\n                        var ch = kl ? Ff[0] * Za.scale - Tn * Pn : Ff[1] * Za.scale - Tn * Pn;\n                        ch > 0 && ch > eo && (eo = ch);\n                      } else {\n                        var Cl = I3[Za.fontStack], yl = Cl && Cl[to];\n                        if (yl && yl.rect) jo = yl.rect, _s = yl.metrics;\n                        else {\n                          var Qu = y3[Za.fontStack], gc = Qu && Qu[to];\n                          if (!gc) continue;\n                          _s = gc.metrics;\n                        }\n                        ao = (Pn - Za.scale) * Tn;\n                      }\n                      kl ? (m3.verticalizable = true, ha.push({ glyph: to, imageName: El, x: _r, y: pr + ao, vertical: kl, scale: Za.scale, fontStack: Za.fontStack, sectionIndex: Ko, metrics: _s, rect: jo }), _r += Iu * Za.scale + gt) : (ha.push({ glyph: to, imageName: El, x: _r, y: pr + ao, vertical: kl, scale: Za.scale, fontStack: Za.fontStack, sectionIndex: Ko, metrics: _s, rect: jo }), _r += _s.advance * Za.scale + gt);\n                    }\n                    if (ha.length !== 0) {\n                      var Xd = _r - gt;\n                      Fr = Math.max(Xd, Fr), cO(ha, 0, ha.length - 1, Hi, eo);\n                    }\n                    _r = 0;\n                    var Zd = ae * Pn + eo;\n                    ga.lineOffset = Math.max(eo, Zn), pr += Zd, oi = Math.max(Zd, oi), ++Ai;\n                  }\n                  var Kh = pr - I1, fv = SS(he), hv = fv.horizontalAlign, Ch = fv.verticalAlign;\n                  kd(m3.positionedLines, Hi, hv, Ch, Fr, oi, ae, Kh, $2.length), m3.top += -Ch * Kh, m3.bottom = m3.top + Kh, m3.left += -hv * Fr, m3.right = m3.left + Fr;\n                }\n                function cO(m3, y3, I3, U, $2) {\n                  if (!(!U && !$2)) for (var ae = m3[I3], he = ae.metrics.advance * ae.scale, Oe = (m3[I3].x + he) * U, rt = y3; rt <= I3; rt++) m3[rt].x -= Oe, m3[rt].y += $2;\n                }\n                function kd(m3, y3, I3, U, $2, ae, he, Oe, rt) {\n                  var gt = (y3 - I3) * $2, Et = 0;\n                  ae !== he ? Et = -Oe * U - I1 : Et = (-U * rt + 0.5) * he;\n                  for (var or = 0, _r = m3; or < _r.length; or += 1) for (var pr = _r[or], Fr = 0, oi = pr.positionedGlyphs; Fr < oi.length; Fr += 1) {\n                    var Hi = oi[Fr];\n                    Hi.x += gt, Hi.y += Et;\n                  }\n                }\n                function rp(m3, y3, I3) {\n                  var U = SS(I3), $2 = U.horizontalAlign, ae = U.verticalAlign, he = y3[0], Oe = y3[1], rt = he - m3.displaySize[0] * $2, gt = rt + m3.displaySize[0], Et = Oe - m3.displaySize[1] * ae, or = Et + m3.displaySize[1];\n                  return { image: m3, top: Et, bottom: or, left: rt, right: gt };\n                }\n                function dm(m3, y3, I3, U, $2, ae) {\n                  var he = m3.image, Oe;\n                  if (he.content) {\n                    var rt = he.content, gt = he.pixelRatio || 1;\n                    Oe = [rt[0] / gt, rt[1] / gt, he.displaySize[0] - rt[2] / gt, he.displaySize[1] - rt[3] / gt];\n                  }\n                  var Et = y3.left * ae, or = y3.right * ae, _r, pr, Fr, oi;\n                  I3 === "width" || I3 === "both" ? (oi = $2[0] + Et - U[3], pr = $2[0] + or + U[1]) : (oi = $2[0] + (Et + or - he.displaySize[0]) / 2, pr = oi + he.displaySize[0]);\n                  var Hi = y3.top * ae, Ai = y3.bottom * ae;\n                  return I3 === "height" || I3 === "both" ? (_r = $2[1] + Hi - U[0], Fr = $2[1] + Ai + U[2]) : (_r = $2[1] + (Hi + Ai - he.displaySize[1]) / 2, Fr = _r + he.displaySize[1]), { image: he, top: _r, right: pr, bottom: Fr, left: oi, collisionPadding: Oe };\n                }\n                var Wd = (function(m3) {\n                  function y3(I3, U, $2, ae) {\n                    m3.call(this, I3, U), this.angle = $2, ae !== void 0 && (this.segment = ae);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.clone = function() {\n                    return new y3(this.x, this.y, this.angle, this.segment);\n                  }, y3;\n                })(u4);\n                X("Anchor", Wd);\n                var Cd = 128;\n                function _p(m3, y3) {\n                  var I3 = y3.expression;\n                  if (I3.kind === "constant") {\n                    var U = I3.evaluate(new Gn(m3 + 1));\n                    return { kind: "constant", layoutSize: U };\n                  } else {\n                    if (I3.kind === "source") return { kind: "source" };\n                    for (var $2 = I3.zoomStops, ae = I3.interpolationType, he = 0; he < $2.length && $2[he] <= m3; ) he++;\n                    he = Math.max(0, he - 1);\n                    for (var Oe = he; Oe < $2.length && $2[Oe] < m3 + 1; ) Oe++;\n                    Oe = Math.min($2.length - 1, Oe);\n                    var rt = $2[he], gt = $2[Oe];\n                    if (I3.kind === "composite") return { kind: "composite", minZoom: rt, maxZoom: gt, interpolationType: ae };\n                    var Et = I3.evaluate(new Gn(rt)), or = I3.evaluate(new Gn(gt));\n                    return { kind: "camera", minZoom: rt, maxZoom: gt, minSize: Et, maxSize: or, interpolationType: ae };\n                  }\n                }\n                function IQ(m3, y3, I3) {\n                  var U = y3.uSize, $2 = y3.uSizeT, ae = I3.lowerSize, he = I3.upperSize;\n                  return m3.kind === "source" ? ae / Cd : m3.kind === "composite" ? nl(ae / Cd, he / Cd, $2) : U;\n                }\n                function RQ(m3, y3) {\n                  var I3 = 0, U = 0;\n                  if (m3.kind === "constant") U = m3.layoutSize;\n                  else if (m3.kind !== "source") {\n                    var $2 = m3.interpolationType, ae = m3.minZoom, he = m3.maxZoom, Oe = $2 ? p3(Wl.interpolationFactor($2, y3, ae, he), 0, 1) : 0;\n                    m3.kind === "camera" ? U = nl(m3.minSize, m3.maxSize, Oe) : I3 = Oe;\n                  }\n                  return { uSizeT: I3, uSize: U };\n                }\n                var Aet = Object.freeze({ __proto__: null, getSizeData: _p, evaluateSizeForFeature: IQ, evaluateSizeForZoom: RQ, SIZE_PACK_FACTOR: Cd });\n                function DQ(m3, y3, I3, U, $2) {\n                  if (y3.segment === void 0) return true;\n                  for (var ae = y3, he = y3.segment + 1, Oe = 0; Oe > -I3 / 2; ) {\n                    if (he--, he < 0) return false;\n                    Oe -= m3[he].dist(ae), ae = m3[he];\n                  }\n                  Oe += m3[he].dist(m3[he + 1]), he++;\n                  for (var rt = [], gt = 0; Oe < I3 / 2; ) {\n                    var Et = m3[he - 1], or = m3[he], _r = m3[he + 1];\n                    if (!_r) return false;\n                    var pr = Et.angleTo(or) - or.angleTo(_r);\n                    for (pr = Math.abs((pr + 3 * Math.PI) % (Math.PI * 2) - Math.PI), rt.push({ distance: Oe, angleDelta: pr }), gt += pr; Oe - rt[0].distance > U; ) gt -= rt.shift().angleDelta;\n                    if (gt > $2) return false;\n                    he++, Oe += or.dist(_r);\n                  }\n                  return true;\n                }\n                function FQ(m3) {\n                  for (var y3 = 0, I3 = 0; I3 < m3.length - 1; I3++) y3 += m3[I3].dist(m3[I3 + 1]);\n                  return y3;\n                }\n                function zQ(m3, y3, I3) {\n                  return m3 ? 3 / 5 * y3 * I3 : 0;\n                }\n                function OQ(m3, y3) {\n                  return Math.max(m3 ? m3.right - m3.left : 0, y3 ? y3.right - y3.left : 0);\n                }\n                function Met(m3, y3, I3, U, $2, ae) {\n                  for (var he = zQ(I3, $2, ae), Oe = OQ(I3, U) * ae, rt = 0, gt = FQ(m3) / 2, Et = 0; Et < m3.length - 1; Et++) {\n                    var or = m3[Et], _r = m3[Et + 1], pr = or.dist(_r);\n                    if (rt + pr > gt) {\n                      var Fr = (gt - rt) / pr, oi = nl(or.x, _r.x, Fr), Hi = nl(or.y, _r.y, Fr), Ai = new Wd(oi, Hi, _r.angleTo(or), Et);\n                      return Ai._round(), !he || DQ(m3, Ai, Oe, he, y3) ? Ai : void 0;\n                    }\n                    rt += pr;\n                  }\n                }\n                function Eet(m3, y3, I3, U, $2, ae, he, Oe, rt) {\n                  var gt = zQ(U, ae, he), Et = OQ(U, $2), or = Et * he, _r = m3[0].x === 0 || m3[0].x === rt || m3[0].y === 0 || m3[0].y === rt;\n                  y3 - or < y3 / 4 && (y3 = or + y3 / 4);\n                  var pr = ae * 2, Fr = _r ? y3 / 2 * Oe % y3 : (Et / 2 + pr) * he * Oe % y3;\n                  return qQ(m3, Fr, y3, gt, I3, or, _r, false, rt);\n                }\n                function qQ(m3, y3, I3, U, $2, ae, he, Oe, rt) {\n                  for (var gt = ae / 2, Et = FQ(m3), or = 0, _r = y3 - I3, pr = [], Fr = 0; Fr < m3.length - 1; Fr++) {\n                    for (var oi = m3[Fr], Hi = m3[Fr + 1], Ai = oi.dist(Hi), bn = Hi.angleTo(oi); _r + I3 < or + Ai; ) {\n                      _r += I3;\n                      var nn = (_r - or) / Ai, xn = nl(oi.x, Hi.x, nn), Pn = nl(oi.y, Hi.y, nn);\n                      if (xn >= 0 && xn < rt && Pn >= 0 && Pn < rt && _r - gt >= 0 && _r + gt <= Et) {\n                        var Zn = new Wd(xn, Pn, bn, Fr);\n                        Zn._round(), (!U || DQ(m3, Zn, ae, U, $2)) && pr.push(Zn);\n                      }\n                    }\n                    or += Ai;\n                  }\n                  return !Oe && !pr.length && !he && (pr = qQ(m3, or / 2, I3, U, $2, ae, he, true, rt)), pr;\n                }\n                function BQ(m3, y3, I3, U, $2) {\n                  for (var ae = [], he = 0; he < m3.length; he++) for (var Oe = m3[he], rt = void 0, gt = 0; gt < Oe.length - 1; gt++) {\n                    var Et = Oe[gt], or = Oe[gt + 1];\n                    Et.x < y3 && or.x < y3 || (Et.x < y3 ? Et = new u4(y3, Et.y + (or.y - Et.y) * ((y3 - Et.x) / (or.x - Et.x)))._round() : or.x < y3 && (or = new u4(y3, Et.y + (or.y - Et.y) * ((y3 - Et.x) / (or.x - Et.x)))._round()), !(Et.y < I3 && or.y < I3) && (Et.y < I3 ? Et = new u4(Et.x + (or.x - Et.x) * ((I3 - Et.y) / (or.y - Et.y)), I3)._round() : or.y < I3 && (or = new u4(Et.x + (or.x - Et.x) * ((I3 - Et.y) / (or.y - Et.y)), I3)._round()), !(Et.x >= U && or.x >= U) && (Et.x >= U ? Et = new u4(U, Et.y + (or.y - Et.y) * ((U - Et.x) / (or.x - Et.x)))._round() : or.x >= U && (or = new u4(U, Et.y + (or.y - Et.y) * ((U - Et.x) / (or.x - Et.x)))._round()), !(Et.y >= $2 && or.y >= $2) && (Et.y >= $2 ? Et = new u4(Et.x + (or.x - Et.x) * (($2 - Et.y) / (or.y - Et.y)), $2)._round() : or.y >= $2 && (or = new u4(Et.x + (or.x - Et.x) * (($2 - Et.y) / (or.y - Et.y)), $2)._round()), (!rt || !Et.equals(rt[rt.length - 1])) && (rt = [Et], ae.push(rt)), rt.push(or)))));\n                  }\n                  return ae;\n                }\n                var Ww = Gc;\n                function NQ(m3, y3, I3, U) {\n                  var $2 = [], ae = m3.image, he = ae.pixelRatio, Oe = ae.paddedRect.w - 2 * Ww, rt = ae.paddedRect.h - 2 * Ww, gt = m3.right - m3.left, Et = m3.bottom - m3.top, or = ae.stretchX || [[0, Oe]], _r = ae.stretchY || [[0, rt]], pr = function(Cl, yl) {\n                    return Cl + yl[1] - yl[0];\n                  }, Fr = or.reduce(pr, 0), oi = _r.reduce(pr, 0), Hi = Oe - Fr, Ai = rt - oi, bn = 0, nn = Fr, xn = 0, Pn = oi, Zn = 0, ga = Hi, ha = 0, eo = Ai;\n                  if (ae.content && U) {\n                    var za = ae.content;\n                    bn = KC(or, 0, za[0]), xn = KC(_r, 0, za[1]), nn = KC(or, za[0], za[2]), Pn = KC(_r, za[1], za[3]), Zn = za[0] - bn, ha = za[1] - xn, ga = za[2] - za[0] - nn, eo = za[3] - za[1] - Pn;\n                  }\n                  var Za = function(Cl, yl, Qu, gc) {\n                    var Sf = JC(Cl.stretch - bn, nn, gt, m3.left), Ff = $C(Cl.fixed - Zn, ga, Cl.stretch, Fr), Yh = JC(yl.stretch - xn, Pn, Et, m3.top), ch = $C(yl.fixed - ha, eo, yl.stretch, oi), Xd = JC(Qu.stretch - bn, nn, gt, m3.left), Zd = $C(Qu.fixed - Zn, ga, Qu.stretch, Fr), Kh = JC(gc.stretch - xn, Pn, Et, m3.top), fv = $C(gc.fixed - ha, eo, gc.stretch, oi), hv = new u4(Sf, Yh), Ch = new u4(Xd, Yh), dv = new u4(Xd, Kh), xp = new u4(Sf, Kh), gy = new u4(Ff / he, ch / he), F1 = new u4(Zd / he, fv / he), z1 = y3 * Math.PI / 180;\n                    if (z1) {\n                      var O1 = Math.sin(z1), e32 = Math.cos(z1), m0 = [e32, -O1, O1, e32];\n                      hv._matMult(m0), Ch._matMult(m0), xp._matMult(m0), dv._matMult(m0);\n                    }\n                    var n6 = Cl.stretch + Cl.fixed, yO = Qu.stretch + Qu.fixed, a6 = yl.stretch + yl.fixed, _O = gc.stretch + gc.fixed, Hp = { x: ae.paddedRect.x + Ww + n6, y: ae.paddedRect.y + Ww + a6, w: yO - n6, h: _O - a6 }, t32 = ga / he / gt, o6 = eo / he / Et;\n                    return { tl: hv, tr: Ch, bl: xp, br: dv, tex: Hp, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: gy, pixelOffsetBR: F1, minFontScaleX: t32, minFontScaleY: o6, isSDF: I3 };\n                  };\n                  if (!U || !ae.stretchX && !ae.stretchY) $2.push(Za({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: Oe + 1 }, { fixed: 0, stretch: rt + 1 }));\n                  else for (var Ko = UQ(or, Hi, Fr), to = UQ(_r, Ai, oi), ao = 0; ao < Ko.length - 1; ao++) for (var _s = Ko[ao], jo = Ko[ao + 1], El = 0; El < to.length - 1; El++) {\n                    var Iu = to[El], kl = to[El + 1];\n                    $2.push(Za(_s, Iu, jo, kl));\n                  }\n                  return $2;\n                }\n                function KC(m3, y3, I3) {\n                  for (var U = 0, $2 = 0, ae = m3; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    U += Math.max(y3, Math.min(I3, he[1])) - Math.max(y3, Math.min(I3, he[0]));\n                  }\n                  return U;\n                }\n                function UQ(m3, y3, I3) {\n                  for (var U = [{ fixed: -Ww, stretch: 0 }], $2 = 0, ae = m3; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2], Oe = he[0], rt = he[1], gt = U[U.length - 1];\n                    U.push({ fixed: Oe - gt.stretch, stretch: gt.stretch }), U.push({ fixed: Oe - gt.stretch, stretch: gt.stretch + (rt - Oe) });\n                  }\n                  return U.push({ fixed: y3 + Ww, stretch: I3 }), U;\n                }\n                function JC(m3, y3, I3, U) {\n                  return m3 / y3 * I3 + U;\n                }\n                function $C(m3, y3, I3, U) {\n                  return m3 - y3 * I3 / U;\n                }\n                function ket(m3, y3, I3, U, $2, ae, he, Oe) {\n                  for (var rt = U.layout.get("text-rotate").evaluate(ae, {}) * Math.PI / 180, gt = [], Et = 0, or = y3.positionedLines; Et < or.length; Et += 1) for (var _r = or[Et], pr = 0, Fr = _r.positionedGlyphs; pr < Fr.length; pr += 1) {\n                    var oi = Fr[pr];\n                    if (oi.rect) {\n                      var Hi = oi.rect || {}, Ai = 1, bn = Gp + Ai, nn = true, xn = 1, Pn = 0, Zn = ($2 || Oe) && oi.vertical, ga = oi.metrics.advance * oi.scale / 2;\n                      if (Oe && y3.verticalizable) {\n                        var ha = (oi.scale - 1) * Tn, eo = (Tn - oi.metrics.width * oi.scale) / 2;\n                        Pn = _r.lineOffset / 2 - (oi.imageName ? -eo : ha);\n                      }\n                      if (oi.imageName) {\n                        var za = he[oi.imageName];\n                        nn = za.sdf, xn = za.pixelRatio, bn = Gc / xn;\n                      }\n                      var Za = $2 ? [oi.x + ga, oi.y] : [0, 0], Ko = $2 ? [0, 0] : [oi.x + ga + I3[0], oi.y + I3[1] - Pn], to = [0, 0];\n                      Zn && (to = Ko, Ko = [0, 0]);\n                      var ao = (oi.metrics.left - bn) * oi.scale - ga + Ko[0], _s = (-oi.metrics.top - bn) * oi.scale + Ko[1], jo = ao + Hi.w * oi.scale / xn, El = _s + Hi.h * oi.scale / xn, Iu = new u4(ao, _s), kl = new u4(jo, _s), Cl = new u4(ao, El), yl = new u4(jo, El);\n                      if (Zn) {\n                        var Qu = new u4(-ga, ga - I1), gc = -Math.PI / 2, Sf = Tn / 2 - ga, Ff = oi.imageName ? Sf : 0, Yh = new u4(5 - I1 - Sf, -Ff), ch = new (Function.prototype.bind.apply(u4, [null].concat(to)))();\n                        Iu._rotateAround(gc, Qu)._add(Yh)._add(ch), kl._rotateAround(gc, Qu)._add(Yh)._add(ch), Cl._rotateAround(gc, Qu)._add(Yh)._add(ch), yl._rotateAround(gc, Qu)._add(Yh)._add(ch);\n                      }\n                      if (rt) {\n                        var Xd = Math.sin(rt), Zd = Math.cos(rt), Kh = [Zd, -Xd, Xd, Zd];\n                        Iu._matMult(Kh), kl._matMult(Kh), Cl._matMult(Kh), yl._matMult(Kh);\n                      }\n                      var fv = new u4(0, 0), hv = new u4(0, 0), Ch = 0, dv = 0;\n                      gt.push({ tl: Iu, tr: kl, bl: Cl, br: yl, tex: Hi, writingMode: y3.writingMode, glyphOffset: Za, sectionIndex: oi.sectionIndex, isSDF: nn, pixelOffsetTL: fv, pixelOffsetBR: hv, minFontScaleX: Ch, minFontScaleY: dv });\n                    }\n                  }\n                  return gt;\n                }\n                var QC = function(y3, I3, U, $2, ae, he, Oe, rt, gt, Et) {\n                  if (this.boxStartIndex = y3.length, gt) {\n                    var or = he.top, _r = he.bottom, pr = he.collisionPadding;\n                    pr && (or -= pr[1], _r += pr[3]);\n                    var Fr = _r - or;\n                    Fr > 0 && (Fr = Math.max(10, Fr), this.circleDiameter = Fr);\n                  } else {\n                    var oi = he.top * Oe - rt, Hi = he.bottom * Oe + rt, Ai = he.left * Oe - rt, bn = he.right * Oe + rt, nn = he.collisionPadding;\n                    if (nn && (Ai -= nn[0] * Oe, oi -= nn[1] * Oe, bn += nn[2] * Oe, Hi += nn[3] * Oe), Et) {\n                      var xn = new u4(Ai, oi), Pn = new u4(bn, oi), Zn = new u4(Ai, Hi), ga = new u4(bn, Hi), ha = Et * Math.PI / 180;\n                      xn._rotate(ha), Pn._rotate(ha), Zn._rotate(ha), ga._rotate(ha), Ai = Math.min(xn.x, Pn.x, Zn.x, ga.x), bn = Math.max(xn.x, Pn.x, Zn.x, ga.x), oi = Math.min(xn.y, Pn.y, Zn.y, ga.y), Hi = Math.max(xn.y, Pn.y, Zn.y, ga.y);\n                    }\n                    y3.emplaceBack(I3.x, I3.y, Ai, oi, bn, Hi, U, $2, ae);\n                  }\n                  this.boxEndIndex = y3.length;\n                }, Xw = function(y3, I3) {\n                  if (y3 === void 0 && (y3 = []), I3 === void 0 && (I3 = Cet), this.data = y3, this.length = this.data.length, this.compare = I3, this.length > 0) for (var U = (this.length >> 1) - 1; U >= 0; U--) this._down(U);\n                };\n                Xw.prototype.push = function(y3) {\n                  this.data.push(y3), this.length++, this._up(this.length - 1);\n                }, Xw.prototype.pop = function() {\n                  if (this.length !== 0) {\n                    var y3 = this.data[0], I3 = this.data.pop();\n                    return this.length--, this.length > 0 && (this.data[0] = I3, this._down(0)), y3;\n                  }\n                }, Xw.prototype.peek = function() {\n                  return this.data[0];\n                }, Xw.prototype._up = function(y3) {\n                  for (var I3 = this, U = I3.data, $2 = I3.compare, ae = U[y3]; y3 > 0; ) {\n                    var he = y3 - 1 >> 1, Oe = U[he];\n                    if ($2(ae, Oe) >= 0) break;\n                    U[y3] = Oe, y3 = he;\n                  }\n                  U[y3] = ae;\n                }, Xw.prototype._down = function(y3) {\n                  for (var I3 = this, U = I3.data, $2 = I3.compare, ae = this.length >> 1, he = U[y3]; y3 < ae; ) {\n                    var Oe = (y3 << 1) + 1, rt = U[Oe], gt = Oe + 1;\n                    if (gt < this.length && $2(U[gt], rt) < 0 && (Oe = gt, rt = U[gt]), $2(rt, he) >= 0) break;\n                    U[y3] = rt, y3 = Oe;\n                  }\n                  U[y3] = he;\n                };\n                function Cet(m3, y3) {\n                  return m3 < y3 ? -1 : m3 > y3 ? 1 : 0;\n                }\n                function Let(m3, y3, I3) {\n                  y3 === void 0 && (y3 = 1), I3 === void 0 && (I3 = false);\n                  for (var U = 1 / 0, $2 = 1 / 0, ae = -1 / 0, he = -1 / 0, Oe = m3[0], rt = 0; rt < Oe.length; rt++) {\n                    var gt = Oe[rt];\n                    (!rt || gt.x < U) && (U = gt.x), (!rt || gt.y < $2) && ($2 = gt.y), (!rt || gt.x > ae) && (ae = gt.x), (!rt || gt.y > he) && (he = gt.y);\n                  }\n                  var Et = ae - U, or = he - $2, _r = Math.min(Et, or), pr = _r / 2, Fr = new Xw([], Pet);\n                  if (_r === 0) return new u4(U, $2);\n                  for (var oi = U; oi < ae; oi += _r) for (var Hi = $2; Hi < he; Hi += _r) Fr.push(new Zw(oi + pr, Hi + pr, pr, m3));\n                  for (var Ai = Ret(m3), bn = Fr.length; Fr.length; ) {\n                    var nn = Fr.pop();\n                    (nn.d > Ai.d || !Ai.d) && (Ai = nn, I3 && console.log("found best %d after %d probes", Math.round(1e4 * nn.d) / 1e4, bn)), !(nn.max - Ai.d <= y3) && (pr = nn.h / 2, Fr.push(new Zw(nn.p.x - pr, nn.p.y - pr, pr, m3)), Fr.push(new Zw(nn.p.x + pr, nn.p.y - pr, pr, m3)), Fr.push(new Zw(nn.p.x - pr, nn.p.y + pr, pr, m3)), Fr.push(new Zw(nn.p.x + pr, nn.p.y + pr, pr, m3)), bn += 4);\n                  }\n                  return I3 && (console.log("num probes: " + bn), console.log("best distance: " + Ai.d)), Ai.p;\n                }\n                function Pet(m3, y3) {\n                  return y3.max - m3.max;\n                }\n                function Zw(m3, y3, I3, U) {\n                  this.p = new u4(m3, y3), this.h = I3, this.d = Iet(this.p, U), this.max = this.d + this.h * Math.SQRT2;\n                }\n                function Iet(m3, y3) {\n                  for (var I3 = false, U = 1 / 0, $2 = 0; $2 < y3.length; $2++) for (var ae = y3[$2], he = 0, Oe = ae.length, rt = Oe - 1; he < Oe; rt = he++) {\n                    var gt = ae[he], Et = ae[rt];\n                    gt.y > m3.y != Et.y > m3.y && m3.x < (Et.x - gt.x) * (m3.y - gt.y) / (Et.y - gt.y) + gt.x && (I3 = !I3), U = Math.min(U, cg(m3, gt, Et));\n                  }\n                  return (I3 ? 1 : -1) * Math.sqrt(U);\n                }\n                function Ret(m3) {\n                  for (var y3 = 0, I3 = 0, U = 0, $2 = m3[0], ae = 0, he = $2.length, Oe = he - 1; ae < he; Oe = ae++) {\n                    var rt = $2[ae], gt = $2[Oe], Et = rt.x * gt.y - gt.x * rt.y;\n                    I3 += (rt.x + gt.x) * Et, U += (rt.y + gt.y) * Et, y3 += Et * 3;\n                  }\n                  return new Zw(I3 / y3, U / y3, 0, m3);\n                }\n                var Yw = 7, fO = Number.POSITIVE_INFINITY;\n                function VQ(m3, y3) {\n                  function I3($2, ae) {\n                    var he = 0, Oe = 0;\n                    ae < 0 && (ae = 0);\n                    var rt = ae / Math.sqrt(2);\n                    switch ($2) {\n                      case "top-right":\n                      case "top-left":\n                        Oe = rt - Yw;\n                        break;\n                      case "bottom-right":\n                      case "bottom-left":\n                        Oe = -rt + Yw;\n                        break;\n                      case "bottom":\n                        Oe = -ae + Yw;\n                        break;\n                      case "top":\n                        Oe = ae - Yw;\n                        break;\n                    }\n                    switch ($2) {\n                      case "top-right":\n                      case "bottom-right":\n                        he = -rt;\n                        break;\n                      case "top-left":\n                      case "bottom-left":\n                        he = rt;\n                        break;\n                      case "left":\n                        he = ae;\n                        break;\n                      case "right":\n                        he = -ae;\n                        break;\n                    }\n                    return [he, Oe];\n                  }\n                  function U($2, ae, he) {\n                    var Oe = 0, rt = 0;\n                    switch (ae = Math.abs(ae), he = Math.abs(he), $2) {\n                      case "top-right":\n                      case "top-left":\n                      case "top":\n                        rt = he - Yw;\n                        break;\n                      case "bottom-right":\n                      case "bottom-left":\n                      case "bottom":\n                        rt = -he + Yw;\n                        break;\n                    }\n                    switch ($2) {\n                      case "top-right":\n                      case "bottom-right":\n                      case "right":\n                        Oe = -ae;\n                        break;\n                      case "top-left":\n                      case "bottom-left":\n                      case "left":\n                        Oe = ae;\n                        break;\n                    }\n                    return [Oe, rt];\n                  }\n                  return y3[1] !== fO ? U(m3, y3[0], y3[1]) : I3(m3, y3[0]);\n                }\n                function Det(m3, y3, I3, U, $2, ae, he) {\n                  m3.createArrays();\n                  var Oe = 512 * m3.overscaling;\n                  m3.tilePixelRatio = Ci / Oe, m3.compareText = {}, m3.iconsNeedLinear = false;\n                  var rt = m3.layers[0].layout, gt = m3.layers[0]._unevaluatedLayout._values, Et = {};\n                  if (m3.textSizeData.kind === "composite") {\n                    var or = m3.textSizeData, _r = or.minZoom, pr = or.maxZoom;\n                    Et.compositeTextSizes = [gt["text-size"].possiblyEvaluate(new Gn(_r), he), gt["text-size"].possiblyEvaluate(new Gn(pr), he)];\n                  }\n                  if (m3.iconSizeData.kind === "composite") {\n                    var Fr = m3.iconSizeData, oi = Fr.minZoom, Hi = Fr.maxZoom;\n                    Et.compositeIconSizes = [gt["icon-size"].possiblyEvaluate(new Gn(oi), he), gt["icon-size"].possiblyEvaluate(new Gn(Hi), he)];\n                  }\n                  Et.layoutTextSize = gt["text-size"].possiblyEvaluate(new Gn(m3.zoom + 1), he), Et.layoutIconSize = gt["icon-size"].possiblyEvaluate(new Gn(m3.zoom + 1), he), Et.textMaxSize = gt["text-size"].possiblyEvaluate(new Gn(18));\n                  for (var Ai = rt.get("text-line-height") * Tn, bn = rt.get("text-rotation-alignment") === "map" && rt.get("symbol-placement") !== "point", nn = rt.get("text-keep-upright"), xn = rt.get("text-size"), Pn = function() {\n                    var ha = ga[Zn], eo = rt.get("text-font").evaluate(ha, {}, he).join(","), za = xn.evaluate(ha, {}, he), Za = Et.layoutTextSize.evaluate(ha, {}, he), Ko = Et.layoutIconSize.evaluate(ha, {}, he), to = { horizontal: {}, vertical: void 0 }, ao = ha.text, _s = [0, 0];\n                    if (ao) {\n                      var jo = ao.toString(), El = rt.get("text-letter-spacing").evaluate(ha, {}, he) * Tn, Iu = gr(jo) ? El : 0, kl = rt.get("text-anchor").evaluate(ha, {}, he), Cl = rt.get("text-variable-anchor");\n                      if (!Cl) {\n                        var yl = rt.get("text-radial-offset").evaluate(ha, {}, he);\n                        yl ? _s = VQ(kl, [yl * Tn, fO]) : _s = rt.get("text-offset").evaluate(ha, {}, he).map(function(gy) {\n                          return gy * Tn;\n                        });\n                      }\n                      var Qu = bn ? "center" : rt.get("text-justify").evaluate(ha, {}, he), gc = rt.get("symbol-placement"), Sf = gc === "point" ? rt.get("text-max-width").evaluate(ha, {}, he) * Tn : 0, Ff = function() {\n                        m3.allowVerticalPlacement && jt(jo) && (to.vertical = Hw(ao, y3, I3, $2, eo, Sf, Ai, kl, "left", Iu, _s, uv.vertical, true, gc, Za, za));\n                      };\n                      if (!bn && Cl) {\n                        for (var Yh = Qu === "auto" ? Cl.map(function(gy) {\n                          return hO(gy);\n                        }) : [Qu], ch = false, Xd = 0; Xd < Yh.length; Xd++) {\n                          var Zd = Yh[Xd];\n                          if (!to.horizontal[Zd]) if (ch) to.horizontal[Zd] = to.horizontal[0];\n                          else {\n                            var Kh = Hw(ao, y3, I3, $2, eo, Sf, Ai, "center", Zd, Iu, _s, uv.horizontal, false, gc, Za, za);\n                            Kh && (to.horizontal[Zd] = Kh, ch = Kh.positionedLines.length === 1);\n                          }\n                        }\n                        Ff();\n                      } else {\n                        Qu === "auto" && (Qu = hO(kl));\n                        var fv = Hw(ao, y3, I3, $2, eo, Sf, Ai, kl, Qu, Iu, _s, uv.horizontal, false, gc, Za, za);\n                        fv && (to.horizontal[Qu] = fv), Ff(), jt(jo) && bn && nn && (to.vertical = Hw(ao, y3, I3, $2, eo, Sf, Ai, kl, Qu, Iu, _s, uv.vertical, false, gc, Za, za));\n                      }\n                    }\n                    var hv = void 0, Ch = false;\n                    if (ha.icon && ha.icon.name) {\n                      var dv = U[ha.icon.name];\n                      dv && (hv = rp($2[ha.icon.name], rt.get("icon-offset").evaluate(ha, {}, he), rt.get("icon-anchor").evaluate(ha, {}, he)), Ch = dv.sdf, m3.sdfIcons === void 0 ? m3.sdfIcons = dv.sdf : m3.sdfIcons !== dv.sdf && te("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (dv.pixelRatio !== m3.pixelRatio || rt.get("icon-rotate").constantOr(1) !== 0) && (m3.iconsNeedLinear = true));\n                    }\n                    var xp = HQ(to.horizontal) || to.vertical;\n                    m3.iconsInText = xp ? xp.iconsInText : false, (xp || hv) && Fet(m3, ha, to, hv, U, Et, Za, Ko, _s, Ch, he);\n                  }, Zn = 0, ga = m3.features; Zn < ga.length; Zn += 1) Pn();\n                  ae && m3.generateCollisionDebugBuffers();\n                }\n                function hO(m3) {\n                  switch (m3) {\n                    case "right":\n                    case "top-right":\n                    case "bottom-right":\n                      return "right";\n                    case "left":\n                    case "top-left":\n                    case "bottom-left":\n                      return "left";\n                  }\n                  return "center";\n                }\n                function Fet(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et) {\n                  var or = ae.textMaxSize.evaluate(y3, {});\n                  or === void 0 && (or = he);\n                  var _r = m3.layers[0].layout, pr = _r.get("icon-offset").evaluate(y3, {}, Et), Fr = HQ(I3.horizontal), oi = 24, Hi = he / oi, Ai = m3.tilePixelRatio * Hi, bn = m3.tilePixelRatio * or / oi, nn = m3.tilePixelRatio * Oe, xn = m3.tilePixelRatio * _r.get("symbol-spacing"), Pn = _r.get("text-padding") * m3.tilePixelRatio, Zn = _r.get("icon-padding") * m3.tilePixelRatio, ga = _r.get("text-max-angle") / 180 * Math.PI, ha = _r.get("text-rotation-alignment") === "map" && _r.get("symbol-placement") !== "point", eo = _r.get("icon-rotation-alignment") === "map" && _r.get("symbol-placement") !== "point", za = _r.get("symbol-placement"), Za = xn / 2, Ko = _r.get("icon-text-fit"), to;\n                  U && Ko !== "none" && (m3.allowVerticalPlacement && I3.vertical && (to = dm(U, I3.vertical, Ko, _r.get("icon-text-fit-padding"), pr, Hi)), Fr && (U = dm(U, Fr, Ko, _r.get("icon-text-fit-padding"), pr, Hi)));\n                  var ao = function(e32, m0) {\n                    m0.x < 0 || m0.x >= Ci || m0.y < 0 || m0.y >= Ci || zet(m3, m0, e32, I3, U, $2, to, m3.layers[0], m3.collisionBoxArray, y3.index, y3.sourceLayerIndex, m3.index, Ai, Pn, ha, rt, nn, Zn, eo, pr, y3, ae, gt, Et, he);\n                  };\n                  if (za === "line") for (var _s = 0, jo = BQ(y3.geometry, 0, 0, Ci, Ci); _s < jo.length; _s += 1) for (var El = jo[_s], Iu = Eet(El, xn, ga, I3.vertical || Fr, U, oi, bn, m3.overscaling, Ci), kl = 0, Cl = Iu; kl < Cl.length; kl += 1) {\n                    var yl = Cl[kl], Qu = Fr;\n                    (!Qu || !Oet(m3, Qu.text, Za, yl)) && ao(El, yl);\n                  }\n                  else if (za === "line-center") for (var gc = 0, Sf = y3.geometry; gc < Sf.length; gc += 1) {\n                    var Ff = Sf[gc];\n                    if (Ff.length > 1) {\n                      var Yh = Met(Ff, ga, I3.vertical || Fr, U, oi, bn);\n                      Yh && ao(Ff, Yh);\n                    }\n                  }\n                  else if (y3.type === "Polygon") for (var ch = 0, Xd = Ow(y3.geometry, 0); ch < Xd.length; ch += 1) {\n                    var Zd = Xd[ch], Kh = Let(Zd, 16);\n                    ao(Zd[0], new Wd(Kh.x, Kh.y, 0));\n                  }\n                  else if (y3.type === "LineString") for (var fv = 0, hv = y3.geometry; fv < hv.length; fv += 1) {\n                    var Ch = hv[fv];\n                    ao(Ch, new Wd(Ch[0].x, Ch[0].y, 0));\n                  }\n                  else if (y3.type === "Point") for (var dv = 0, xp = y3.geometry; dv < xp.length; dv += 1) for (var gy = xp[dv], F1 = 0, z1 = gy; F1 < z1.length; F1 += 1) {\n                    var O1 = z1[F1];\n                    ao([O1], new Wd(O1.x, O1.y, 0));\n                  }\n                }\n                var MS = 255, R1 = MS * Cd;\n                function GQ(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr) {\n                  var oi = ket(y3, I3, Oe, $2, ae, he, U, m3.allowVerticalPlacement), Hi = m3.textSizeData, Ai = null;\n                  Hi.kind === "source" ? (Ai = [Cd * $2.layout.get("text-size").evaluate(he, {})], Ai[0] > R1 && te(m3.layerIds[0] + \': Value for "text-size" is >= \' + MS + \'. Reduce your "text-size".\')) : Hi.kind === "composite" && (Ai = [Cd * pr.compositeTextSizes[0].evaluate(he, {}, Fr), Cd * pr.compositeTextSizes[1].evaluate(he, {}, Fr)], (Ai[0] > R1 || Ai[1] > R1) && te(m3.layerIds[0] + \': Value for "text-size" is >= \' + MS + \'. Reduce your "text-size".\')), m3.addSymbols(m3.text, oi, Ai, Oe, ae, he, gt, y3, rt.lineStartIndex, rt.lineLength, _r, Fr);\n                  for (var bn = 0, nn = Et; bn < nn.length; bn += 1) {\n                    var xn = nn[bn];\n                    or[xn] = m3.text.placedSymbolArray.length - 1;\n                  }\n                  return oi.length * 4;\n                }\n                function HQ(m3) {\n                  for (var y3 in m3) return m3[y3];\n                  return null;\n                }\n                function zet(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or, _r, pr, Fr, oi, Hi, Ai, bn, nn, xn, Pn, Zn, ga, ha) {\n                  var eo, za = m3.addToLineVertexArray(y3, I3), Za, Ko, to, ao, _s = 0, jo = 0, El = 0, Iu = 0, kl = -1, Cl = -1, yl = {}, Qu = K(""), gc = 0, Sf = 0;\n                  if (Oe._unevaluatedLayout.getValue("text-radial-offset") === void 0 ? (eo = Oe.layout.get("text-offset").evaluate(xn, {}, ga).map(function(CS) {\n                    return CS * Tn;\n                  }), gc = eo[0], Sf = eo[1]) : (gc = Oe.layout.get("text-radial-offset").evaluate(xn, {}, ga) * Tn, Sf = fO), m3.allowVerticalPlacement && U.vertical) {\n                    var Ff = Oe.layout.get("text-rotate").evaluate(xn, {}, ga), Yh = Ff + 90, ch = U.vertical;\n                    to = new QC(rt, y3, gt, Et, or, ch, _r, pr, Fr, Yh), he && (ao = new QC(rt, y3, gt, Et, or, he, Hi, Ai, Fr, Yh));\n                  }\n                  if ($2) {\n                    var Xd = Oe.layout.get("icon-rotate").evaluate(xn, {}), Zd = Oe.layout.get("icon-text-fit") !== "none", Kh = NQ($2, Xd, Zn, Zd), fv = he ? NQ(he, Xd, Zn, Zd) : void 0;\n                    Ko = new QC(rt, y3, gt, Et, or, $2, Hi, Ai, false, Xd), _s = Kh.length * 4;\n                    var hv = m3.iconSizeData, Ch = null;\n                    hv.kind === "source" ? (Ch = [Cd * Oe.layout.get("icon-size").evaluate(xn, {})], Ch[0] > R1 && te(m3.layerIds[0] + \': Value for "icon-size" is >= \' + MS + \'. Reduce your "icon-size".\')) : hv.kind === "composite" && (Ch = [Cd * Pn.compositeIconSizes[0].evaluate(xn, {}, ga), Cd * Pn.compositeIconSizes[1].evaluate(xn, {}, ga)], (Ch[0] > R1 || Ch[1] > R1) && te(m3.layerIds[0] + \': Value for "icon-size" is >= \' + MS + \'. Reduce your "icon-size".\')), m3.addSymbols(m3.icon, Kh, Ch, nn, bn, xn, false, y3, za.lineStartIndex, za.lineLength, -1, ga), kl = m3.icon.placedSymbolArray.length - 1, fv && (jo = fv.length * 4, m3.addSymbols(m3.icon, fv, Ch, nn, bn, xn, uv.vertical, y3, za.lineStartIndex, za.lineLength, -1, ga), Cl = m3.icon.placedSymbolArray.length - 1);\n                  }\n                  for (var dv in U.horizontal) {\n                    var xp = U.horizontal[dv];\n                    if (!Za) {\n                      Qu = K(xp.text);\n                      var gy = Oe.layout.get("text-rotate").evaluate(xn, {}, ga);\n                      Za = new QC(rt, y3, gt, Et, or, xp, _r, pr, Fr, gy);\n                    }\n                    var F1 = xp.positionedLines.length === 1;\n                    if (El += GQ(m3, y3, xp, ae, Oe, Fr, xn, oi, za, U.vertical ? uv.horizontal : uv.horizontalOnly, F1 ? Object.keys(U.horizontal) : [dv], yl, kl, Pn, ga), F1) break;\n                  }\n                  U.vertical && (Iu += GQ(m3, y3, U.vertical, ae, Oe, Fr, xn, oi, za, uv.vertical, ["vertical"], yl, Cl, Pn, ga));\n                  var z1 = Za ? Za.boxStartIndex : m3.collisionBoxArray.length, O1 = Za ? Za.boxEndIndex : m3.collisionBoxArray.length, e32 = to ? to.boxStartIndex : m3.collisionBoxArray.length, m0 = to ? to.boxEndIndex : m3.collisionBoxArray.length, n6 = Ko ? Ko.boxStartIndex : m3.collisionBoxArray.length, yO = Ko ? Ko.boxEndIndex : m3.collisionBoxArray.length, a6 = ao ? ao.boxStartIndex : m3.collisionBoxArray.length, _O = ao ? ao.boxEndIndex : m3.collisionBoxArray.length, Hp = -1, t32 = function(CS, oee) {\n                    return CS && CS.circleDiameter ? Math.max(CS.circleDiameter, oee) : oee;\n                  };\n                  Hp = t32(Za, Hp), Hp = t32(to, Hp), Hp = t32(Ko, Hp), Hp = t32(ao, Hp);\n                  var o6 = Hp > -1 ? 1 : 0;\n                  o6 && (Hp *= ha / Tn), m3.glyphOffsetArray.length >= Pu.MAX_GLYPHS && te("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), xn.sortKey !== void 0 && m3.addToSortKeyRanges(m3.symbolInstances.length, xn.sortKey), m3.symbolInstances.emplaceBack(y3.x, y3.y, yl.right >= 0 ? yl.right : -1, yl.center >= 0 ? yl.center : -1, yl.left >= 0 ? yl.left : -1, yl.vertical || -1, kl, Cl, Qu, z1, O1, e32, m0, n6, yO, a6, _O, gt, El, Iu, _s, jo, o6, 0, _r, gc, Sf, Hp);\n                }\n                function Oet(m3, y3, I3, U) {\n                  var $2 = m3.compareText;\n                  if (!(y3 in $2)) $2[y3] = [];\n                  else for (var ae = $2[y3], he = ae.length - 1; he >= 0; he--) if (U.dist(ae[he]) < I3) return true;\n                  return $2[y3].push(U), false;\n                }\n                var qet = pg.VectorTileFeature.types, Bet = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];\n                function e6(m3, y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or, _r) {\n                  var pr = Oe ? Math.min(R1, Math.round(Oe[0])) : 0, Fr = Oe ? Math.min(R1, Math.round(Oe[1])) : 0;\n                  m3.emplaceBack(y3, I3, Math.round(U * 32), Math.round($2 * 32), ae, he, (pr << 1) + (rt ? 1 : 0), Fr, gt * 16, Et * 16, or * 256, _r * 256);\n                }\n                function dO(m3, y3, I3) {\n                  m3.emplaceBack(y3.x, y3.y, I3), m3.emplaceBack(y3.x, y3.y, I3), m3.emplaceBack(y3.x, y3.y, I3), m3.emplaceBack(y3.x, y3.y, I3);\n                }\n                function Net(m3) {\n                  for (var y3 = 0, I3 = m3.sections; y3 < I3.length; y3 += 1) {\n                    var U = I3[y3];\n                    if (Ii(U.text)) return true;\n                  }\n                  return false;\n                }\n                var Kw = function(y3) {\n                  this.layoutVertexArray = new Bn(), this.indexArray = new pn(), this.programConfigurations = y3, this.segments = new io(), this.dynamicLayoutVertexArray = new hi(), this.opacityVertexArray = new li(), this.placedSymbolArray = new zo();\n                };\n                Kw.prototype.isEmpty = function() {\n                  return this.layoutVertexArray.length === 0 && this.indexArray.length === 0 && this.dynamicLayoutVertexArray.length === 0 && this.opacityVertexArray.length === 0;\n                }, Kw.prototype.upload = function(y3, I3, U, $2) {\n                  this.isEmpty() || (U && (this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, re.members), this.indexBuffer = y3.createIndexBuffer(this.indexArray, I3), this.dynamicLayoutVertexBuffer = y3.createVertexBuffer(this.dynamicLayoutVertexArray, fe.members, true), this.opacityVertexBuffer = y3.createVertexBuffer(this.opacityVertexArray, Bet, true), this.opacityVertexBuffer.itemSize = 1), (U || $2) && this.programConfigurations.upload(y3));\n                }, Kw.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());\n                }, X("SymbolBuffers", Kw);\n                var ES = function(y3, I3, U) {\n                  this.layoutVertexArray = new y3(), this.layoutAttributes = I3, this.indexArray = new U(), this.segments = new io(), this.collisionVertexArray = new Ni();\n                };\n                ES.prototype.upload = function(y3) {\n                  this.layoutVertexBuffer = y3.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = y3.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = y3.createVertexBuffer(this.collisionVertexArray, ze.members, true);\n                }, ES.prototype.destroy = function() {\n                  this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());\n                }, X("CollisionBuffers", ES);\n                var Pu = function(y3) {\n                  this.collisionBoxArray = y3.collisionBoxArray, this.zoom = y3.zoom, this.overscaling = y3.overscaling, this.layers = y3.layers, this.layerIds = this.layers.map(function(rt) {\n                    return rt.id;\n                  }), this.index = y3.index, this.pixelRatio = y3.pixelRatio, this.sourceLayerIndex = y3.sourceLayerIndex, this.hasPattern = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [], this.placementInvProjMatrix = sy([]), this.placementViewportMatrix = sy([]);\n                  var I3 = this.layers[0], U = I3._unevaluatedLayout._values;\n                  this.textSizeData = _p(this.zoom, U["text-size"]), this.iconSizeData = _p(this.zoom, U["icon-size"]);\n                  var $2 = this.layers[0].layout, ae = $2.get("symbol-sort-key"), he = $2.get("symbol-z-order");\n                  this.canOverlap = $2.get("text-allow-overlap") || $2.get("icon-allow-overlap") || $2.get("text-ignore-placement") || $2.get("icon-ignore-placement"), this.sortFeaturesByKey = he !== "viewport-y" && ae.constantOr(1) !== void 0;\n                  var Oe = he === "viewport-y" || he === "auto" && !this.sortFeaturesByKey;\n                  this.sortFeaturesByY = Oe && this.canOverlap, $2.get("symbol-placement") === "point" && (this.writingModes = $2.get("text-writing-mode").map(function(rt) {\n                    return uv[rt];\n                  })), this.stateDependentLayerIds = this.layers.filter(function(rt) {\n                    return rt.isStateDependent();\n                  }).map(function(rt) {\n                    return rt.id;\n                  }), this.sourceID = y3.sourceID;\n                };\n                Pu.prototype.createArrays = function() {\n                  this.text = new Kw(new fi(this.layers, this.zoom, function(y3) {\n                    return /^text/.test(y3);\n                  })), this.icon = new Kw(new fi(this.layers, this.zoom, function(y3) {\n                    return /^icon/.test(y3);\n                  })), this.glyphOffsetArray = new Vl(), this.lineVertexArray = new ss(), this.symbolInstances = new al();\n                }, Pu.prototype.calculateGlyphDependencies = function(y3, I3, U, $2, ae) {\n                  for (var he = 0; he < y3.length; he++) if (I3[y3.charCodeAt(he)] = true, (U || $2) && ae) {\n                    var Oe = zi[y3.charAt(he)];\n                    Oe && (I3[Oe.charCodeAt(0)] = true);\n                  }\n                }, Pu.prototype.populate = function(y3, I3, U) {\n                  var $2 = this.layers[0], ae = $2.layout, he = ae.get("text-font"), Oe = ae.get("text-field"), rt = ae.get("icon-image"), gt = (Oe.value.kind !== "constant" || Oe.value.value instanceof Jl && !Oe.value.value.isEmpty() || Oe.value.value.toString().length > 0) && (he.value.kind !== "constant" || he.value.value.length > 0), Et = rt.value.kind !== "constant" || !!rt.value.value || Object.keys(rt.parameters).length > 0, or = ae.get("symbol-sort-key");\n                  if (this.features = [], !(!gt && !Et)) {\n                    for (var _r = I3.iconDependencies, pr = I3.glyphDependencies, Fr = I3.availableImages, oi = new Gn(this.zoom), Hi = 0, Ai = y3; Hi < Ai.length; Hi += 1) {\n                      var bn = Ai[Hi], nn = bn.feature, xn = bn.id, Pn = bn.index, Zn = bn.sourceLayerIndex, ga = $2._featureFilter.needGeometry, ha = Ja(nn, ga);\n                      if ($2._featureFilter.filter(oi, ha, U)) {\n                        ga || (ha.geometry = zn(nn));\n                        var eo = void 0;\n                        if (gt) {\n                          var za = $2.getValueAndResolveTokens("text-field", ha, U, Fr), Za = Jl.factory(za);\n                          Net(Za) && (this.hasRTLText = true), (!this.hasRTLText || yo() === "unavailable" || this.hasRTLText && Ms.isParsed()) && (eo = yi(Za, $2, ha));\n                        }\n                        var Ko = void 0;\n                        if (Et) {\n                          var to = $2.getValueAndResolveTokens("icon-image", ha, U, Fr);\n                          to instanceof fl ? Ko = to : Ko = fl.fromString(to);\n                        }\n                        if (!(!eo && !Ko)) {\n                          var ao = this.sortFeaturesByKey ? or.evaluate(ha, {}, U) : void 0, _s = { id: xn, text: eo, icon: Ko, index: Pn, sourceLayerIndex: Zn, geometry: ha.geometry, properties: nn.properties, type: qet[nn.type], sortKey: ao };\n                          if (this.features.push(_s), Ko && (_r[Ko.name] = true), eo) {\n                            var jo = he.evaluate(ha, {}, U).join(","), El = ae.get("text-rotation-alignment") === "map" && ae.get("symbol-placement") !== "point";\n                            this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(uv.vertical) >= 0;\n                            for (var Iu = 0, kl = eo.sections; Iu < kl.length; Iu += 1) {\n                              var Cl = kl[Iu];\n                              if (Cl.image) _r[Cl.image.name] = true;\n                              else {\n                                var yl = jt(eo.toString()), Qu = Cl.fontStack || jo, gc = pr[Qu] = pr[Qu] || {};\n                                this.calculateGlyphDependencies(Cl.text, gc, El, this.allowVerticalPlacement, yl);\n                              }\n                            }\n                          }\n                        }\n                      }\n                    }\n                    ae.get("symbol-placement") === "line" && (this.features = vn(this.features)), this.sortFeaturesByKey && this.features.sort(function(Sf, Ff) {\n                      return Sf.sortKey - Ff.sortKey;\n                    });\n                  }\n                }, Pu.prototype.update = function(y3, I3, U) {\n                  this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(y3, I3, this.layers, U), this.icon.programConfigurations.updatePaintArrays(y3, I3, this.layers, U));\n                }, Pu.prototype.isEmpty = function() {\n                  return this.symbolInstances.length === 0 && !this.hasRTLText;\n                }, Pu.prototype.uploadPending = function() {\n                  return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;\n                }, Pu.prototype.upload = function(y3) {\n                  !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(y3), this.iconCollisionBox.upload(y3)), this.text.upload(y3, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(y3, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;\n                }, Pu.prototype.destroyDebugData = function() {\n                  this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();\n                }, Pu.prototype.destroy = function() {\n                  this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();\n                }, Pu.prototype.addToLineVertexArray = function(y3, I3) {\n                  var U = this.lineVertexArray.length;\n                  if (y3.segment !== void 0) {\n                    for (var $2 = y3.dist(I3[y3.segment + 1]), ae = y3.dist(I3[y3.segment]), he = {}, Oe = y3.segment + 1; Oe < I3.length; Oe++) he[Oe] = { x: I3[Oe].x, y: I3[Oe].y, tileUnitDistanceFromAnchor: $2 }, Oe < I3.length - 1 && ($2 += I3[Oe + 1].dist(I3[Oe]));\n                    for (var rt = y3.segment || 0; rt >= 0; rt--) he[rt] = { x: I3[rt].x, y: I3[rt].y, tileUnitDistanceFromAnchor: ae }, rt > 0 && (ae += I3[rt - 1].dist(I3[rt]));\n                    for (var gt = 0; gt < I3.length; gt++) {\n                      var Et = he[gt];\n                      this.lineVertexArray.emplaceBack(Et.x, Et.y, Et.tileUnitDistanceFromAnchor);\n                    }\n                  }\n                  return { lineStartIndex: U, lineLength: this.lineVertexArray.length - U };\n                }, Pu.prototype.addSymbols = function(y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or, _r) {\n                  for (var pr = y3.indexArray, Fr = y3.layoutVertexArray, oi = y3.segments.prepareSegment(4 * I3.length, Fr, pr, this.canOverlap ? he.sortKey : void 0), Hi = this.glyphOffsetArray.length, Ai = oi.vertexLength, bn = this.allowVerticalPlacement && Oe === uv.vertical ? Math.PI / 2 : 0, nn = he.text && he.text.sections, xn = 0; xn < I3.length; xn++) {\n                    var Pn = I3[xn], Zn = Pn.tl, ga = Pn.tr, ha = Pn.bl, eo = Pn.br, za = Pn.tex, Za = Pn.pixelOffsetTL, Ko = Pn.pixelOffsetBR, to = Pn.minFontScaleX, ao = Pn.minFontScaleY, _s = Pn.glyphOffset, jo = Pn.isSDF, El = Pn.sectionIndex, Iu = oi.vertexLength, kl = _s[1];\n                    e6(Fr, rt.x, rt.y, Zn.x, kl + Zn.y, za.x, za.y, U, jo, Za.x, Za.y, to, ao), e6(Fr, rt.x, rt.y, ga.x, kl + ga.y, za.x + za.w, za.y, U, jo, Ko.x, Za.y, to, ao), e6(Fr, rt.x, rt.y, ha.x, kl + ha.y, za.x, za.y + za.h, U, jo, Za.x, Ko.y, to, ao), e6(Fr, rt.x, rt.y, eo.x, kl + eo.y, za.x + za.w, za.y + za.h, U, jo, Ko.x, Ko.y, to, ao), dO(y3.dynamicLayoutVertexArray, rt, bn), pr.emplaceBack(Iu, Iu + 1, Iu + 2), pr.emplaceBack(Iu + 1, Iu + 2, Iu + 3), oi.vertexLength += 4, oi.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(_s[0]), (xn === I3.length - 1 || El !== I3[xn + 1].sectionIndex) && y3.programConfigurations.populatePaintArrays(Fr.length, he, he.index, {}, _r, nn && nn[El]);\n                  }\n                  y3.placedSymbolArray.emplaceBack(rt.x, rt.y, Hi, this.glyphOffsetArray.length - Hi, Ai, gt, Et, rt.segment, U ? U[0] : 0, U ? U[1] : 0, $2[0], $2[1], Oe, 0, false, 0, or);\n                }, Pu.prototype._addCollisionDebugVertex = function(y3, I3, U, $2, ae, he) {\n                  return I3.emplaceBack(0, 0), y3.emplaceBack(U.x, U.y, $2, ae, Math.round(he.x), Math.round(he.y));\n                }, Pu.prototype.addCollisionDebugVertices = function(y3, I3, U, $2, ae, he, Oe) {\n                  var rt = ae.segments.prepareSegment(4, ae.layoutVertexArray, ae.indexArray), gt = rt.vertexLength, Et = ae.layoutVertexArray, or = ae.collisionVertexArray, _r = Oe.anchorX, pr = Oe.anchorY;\n                  this._addCollisionDebugVertex(Et, or, he, _r, pr, new u4(y3, I3)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u4(U, I3)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u4(U, $2)), this._addCollisionDebugVertex(Et, or, he, _r, pr, new u4(y3, $2)), rt.vertexLength += 4;\n                  var Fr = ae.indexArray;\n                  Fr.emplaceBack(gt, gt + 1), Fr.emplaceBack(gt + 1, gt + 2), Fr.emplaceBack(gt + 2, gt + 3), Fr.emplaceBack(gt + 3, gt), rt.primitiveLength += 4;\n                }, Pu.prototype.addDebugCollisionBoxes = function(y3, I3, U, $2) {\n                  for (var ae = y3; ae < I3; ae++) {\n                    var he = this.collisionBoxArray.get(ae), Oe = he.x1, rt = he.y1, gt = he.x2, Et = he.y2;\n                    this.addCollisionDebugVertices(Oe, rt, gt, Et, $2 ? this.textCollisionBox : this.iconCollisionBox, he.anchorPoint, U);\n                  }\n                }, Pu.prototype.generateCollisionDebugBuffers = function() {\n                  this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new ES(Ji, ct.members, oa), this.iconCollisionBox = new ES(Ji, ct.members, oa);\n                  for (var y3 = 0; y3 < this.symbolInstances.length; y3++) {\n                    var I3 = this.symbolInstances.get(y3);\n                    this.addDebugCollisionBoxes(I3.textBoxStartIndex, I3.textBoxEndIndex, I3, true), this.addDebugCollisionBoxes(I3.verticalTextBoxStartIndex, I3.verticalTextBoxEndIndex, I3, true), this.addDebugCollisionBoxes(I3.iconBoxStartIndex, I3.iconBoxEndIndex, I3, false), this.addDebugCollisionBoxes(I3.verticalIconBoxStartIndex, I3.verticalIconBoxEndIndex, I3, false);\n                  }\n                }, Pu.prototype._deserializeCollisionBoxesForSymbol = function(y3, I3, U, $2, ae, he, Oe, rt, gt) {\n                  for (var Et = {}, or = I3; or < U; or++) {\n                    var _r = y3.get(or);\n                    Et.textBox = { x1: _r.x1, y1: _r.y1, x2: _r.x2, y2: _r.y2, anchorPointX: _r.anchorPointX, anchorPointY: _r.anchorPointY }, Et.textFeatureIndex = _r.featureIndex;\n                    break;\n                  }\n                  for (var pr = $2; pr < ae; pr++) {\n                    var Fr = y3.get(pr);\n                    Et.verticalTextBox = { x1: Fr.x1, y1: Fr.y1, x2: Fr.x2, y2: Fr.y2, anchorPointX: Fr.anchorPointX, anchorPointY: Fr.anchorPointY }, Et.verticalTextFeatureIndex = Fr.featureIndex;\n                    break;\n                  }\n                  for (var oi = he; oi < Oe; oi++) {\n                    var Hi = y3.get(oi);\n                    Et.iconBox = { x1: Hi.x1, y1: Hi.y1, x2: Hi.x2, y2: Hi.y2, anchorPointX: Hi.anchorPointX, anchorPointY: Hi.anchorPointY }, Et.iconFeatureIndex = Hi.featureIndex;\n                    break;\n                  }\n                  for (var Ai = rt; Ai < gt; Ai++) {\n                    var bn = y3.get(Ai);\n                    Et.verticalIconBox = { x1: bn.x1, y1: bn.y1, x2: bn.x2, y2: bn.y2, anchorPointX: bn.anchorPointX, anchorPointY: bn.anchorPointY }, Et.verticalIconFeatureIndex = bn.featureIndex;\n                    break;\n                  }\n                  return Et;\n                }, Pu.prototype.deserializeCollisionBoxes = function(y3) {\n                  this.collisionArrays = [];\n                  for (var I3 = 0; I3 < this.symbolInstances.length; I3++) {\n                    var U = this.symbolInstances.get(I3);\n                    this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(y3, U.textBoxStartIndex, U.textBoxEndIndex, U.verticalTextBoxStartIndex, U.verticalTextBoxEndIndex, U.iconBoxStartIndex, U.iconBoxEndIndex, U.verticalIconBoxStartIndex, U.verticalIconBoxEndIndex));\n                  }\n                }, Pu.prototype.hasTextData = function() {\n                  return this.text.segments.get().length > 0;\n                }, Pu.prototype.hasIconData = function() {\n                  return this.icon.segments.get().length > 0;\n                }, Pu.prototype.hasDebugData = function() {\n                  return this.textCollisionBox && this.iconCollisionBox;\n                }, Pu.prototype.hasTextCollisionBoxData = function() {\n                  return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;\n                }, Pu.prototype.hasIconCollisionBoxData = function() {\n                  return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;\n                }, Pu.prototype.addIndicesForPlacedSymbol = function(y3, I3) {\n                  for (var U = y3.placedSymbolArray.get(I3), $2 = U.vertexStartIndex + U.numGlyphs * 4, ae = U.vertexStartIndex; ae < $2; ae += 4) y3.indexArray.emplaceBack(ae, ae + 1, ae + 2), y3.indexArray.emplaceBack(ae + 1, ae + 2, ae + 3);\n                }, Pu.prototype.getSortedSymbolIndexes = function(y3) {\n                  if (this.sortedAngle === y3 && this.symbolInstanceIndexes !== void 0) return this.symbolInstanceIndexes;\n                  for (var I3 = Math.sin(y3), U = Math.cos(y3), $2 = [], ae = [], he = [], Oe = 0; Oe < this.symbolInstances.length; ++Oe) {\n                    he.push(Oe);\n                    var rt = this.symbolInstances.get(Oe);\n                    $2.push(Math.round(I3 * rt.anchorX + U * rt.anchorY) | 0), ae.push(rt.featureIndex);\n                  }\n                  return he.sort(function(gt, Et) {\n                    return $2[gt] - $2[Et] || ae[Et] - ae[gt];\n                  }), he;\n                }, Pu.prototype.addToSortKeyRanges = function(y3, I3) {\n                  var U = this.sortKeyRanges[this.sortKeyRanges.length - 1];\n                  U && U.sortKey === I3 ? U.symbolInstanceEnd = y3 + 1 : this.sortKeyRanges.push({ sortKey: I3, symbolInstanceStart: y3, symbolInstanceEnd: y3 + 1 });\n                }, Pu.prototype.sortFeatures = function(y3) {\n                  var I3 = this;\n                  if (this.sortFeaturesByY && this.sortedAngle !== y3 && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {\n                    this.symbolInstanceIndexes = this.getSortedSymbolIndexes(y3), this.sortedAngle = y3, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];\n                    for (var U = 0, $2 = this.symbolInstanceIndexes; U < $2.length; U += 1) {\n                      var ae = $2[U], he = this.symbolInstances.get(ae);\n                      this.featureSortOrder.push(he.featureIndex), [he.rightJustifiedTextSymbolIndex, he.centerJustifiedTextSymbolIndex, he.leftJustifiedTextSymbolIndex].forEach(function(Oe, rt, gt) {\n                        Oe >= 0 && gt.indexOf(Oe) === rt && I3.addIndicesForPlacedSymbol(I3.text, Oe);\n                      }), he.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, he.verticalPlacedTextSymbolIndex), he.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, he.placedIconSymbolIndex), he.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, he.verticalPlacedIconSymbolIndex);\n                    }\n                    this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);\n                  }\n                }, X("SymbolBucket", Pu, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), Pu.MAX_GLYPHS = 65535, Pu.addDynamicAttributes = dO;\n                function Uet(m3, y3) {\n                  return y3.replace(/{([^{}]+)}/g, function(I3, U) {\n                    return U in m3 ? String(m3[U]) : "";\n                  });\n                }\n                var Vet = new Nr({ "symbol-placement": new Me(Rn.layout_symbol["symbol-placement"]), "symbol-spacing": new Me(Rn.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new Me(Rn.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new bt(Rn.layout_symbol["symbol-sort-key"]), "symbol-z-order": new Me(Rn.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new Me(Rn.layout_symbol["icon-allow-overlap"]), "icon-ignore-placement": new Me(Rn.layout_symbol["icon-ignore-placement"]), "icon-optional": new Me(Rn.layout_symbol["icon-optional"]), "icon-rotation-alignment": new Me(Rn.layout_symbol["icon-rotation-alignment"]), "icon-size": new bt(Rn.layout_symbol["icon-size"]), "icon-text-fit": new Me(Rn.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new Me(Rn.layout_symbol["icon-text-fit-padding"]), "icon-image": new bt(Rn.layout_symbol["icon-image"]), "icon-rotate": new bt(Rn.layout_symbol["icon-rotate"]), "icon-padding": new Me(Rn.layout_symbol["icon-padding"]), "icon-keep-upright": new Me(Rn.layout_symbol["icon-keep-upright"]), "icon-offset": new bt(Rn.layout_symbol["icon-offset"]), "icon-anchor": new bt(Rn.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new Me(Rn.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new Me(Rn.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new Me(Rn.layout_symbol["text-rotation-alignment"]), "text-field": new bt(Rn.layout_symbol["text-field"]), "text-font": new bt(Rn.layout_symbol["text-font"]), "text-size": new bt(Rn.layout_symbol["text-size"]), "text-max-width": new bt(Rn.layout_symbol["text-max-width"]), "text-line-height": new Me(Rn.layout_symbol["text-line-height"]), "text-letter-spacing": new bt(Rn.layout_symbol["text-letter-spacing"]), "text-justify": new bt(Rn.layout_symbol["text-justify"]), "text-radial-offset": new bt(Rn.layout_symbol["text-radial-offset"]), "text-variable-anchor": new Me(Rn.layout_symbol["text-variable-anchor"]), "text-anchor": new bt(Rn.layout_symbol["text-anchor"]), "text-max-angle": new Me(Rn.layout_symbol["text-max-angle"]), "text-writing-mode": new Me(Rn.layout_symbol["text-writing-mode"]), "text-rotate": new bt(Rn.layout_symbol["text-rotate"]), "text-padding": new Me(Rn.layout_symbol["text-padding"]), "text-keep-upright": new Me(Rn.layout_symbol["text-keep-upright"]), "text-transform": new bt(Rn.layout_symbol["text-transform"]), "text-offset": new bt(Rn.layout_symbol["text-offset"]), "text-allow-overlap": new Me(Rn.layout_symbol["text-allow-overlap"]), "text-ignore-placement": new Me(Rn.layout_symbol["text-ignore-placement"]), "text-optional": new Me(Rn.layout_symbol["text-optional"]) }), Get = new Nr({ "icon-opacity": new bt(Rn.paint_symbol["icon-opacity"]), "icon-color": new bt(Rn.paint_symbol["icon-color"]), "icon-halo-color": new bt(Rn.paint_symbol["icon-halo-color"]), "icon-halo-width": new bt(Rn.paint_symbol["icon-halo-width"]), "icon-halo-blur": new bt(Rn.paint_symbol["icon-halo-blur"]), "icon-translate": new Me(Rn.paint_symbol["icon-translate"]), "icon-translate-anchor": new Me(Rn.paint_symbol["icon-translate-anchor"]), "text-opacity": new bt(Rn.paint_symbol["text-opacity"]), "text-color": new bt(Rn.paint_symbol["text-color"], { runtimeType: ql, getOverride: function(m3) {\n                  return m3.textColor;\n                }, hasOverride: function(m3) {\n                  return !!m3.textColor;\n                } }), "text-halo-color": new bt(Rn.paint_symbol["text-halo-color"]), "text-halo-width": new bt(Rn.paint_symbol["text-halo-width"]), "text-halo-blur": new bt(Rn.paint_symbol["text-halo-blur"]), "text-translate": new Me(Rn.paint_symbol["text-translate"]), "text-translate-anchor": new Me(Rn.paint_symbol["text-translate-anchor"]) }), vO = { paint: Get, layout: Vet }, Jw = function(y3) {\n                  this.type = y3.property.overrides ? y3.property.overrides.runtimeType : ac, this.defaultValue = y3;\n                };\n                Jw.prototype.evaluate = function(y3) {\n                  if (y3.formattedSection) {\n                    var I3 = this.defaultValue.property.overrides;\n                    if (I3 && I3.hasOverride(y3.formattedSection)) return I3.getOverride(y3.formattedSection);\n                  }\n                  return y3.feature && y3.featureState ? this.defaultValue.evaluate(y3.feature, y3.featureState) : this.defaultValue.property.specification.default;\n                }, Jw.prototype.eachChild = function(y3) {\n                  if (!this.defaultValue.isConstant()) {\n                    var I3 = this.defaultValue.value;\n                    y3(I3._styleExpression.expression);\n                  }\n                }, Jw.prototype.outputDefined = function() {\n                  return false;\n                }, Jw.prototype.serialize = function() {\n                  return null;\n                }, X("FormatSectionOverride", Jw, { omit: ["defaultValue"] });\n                var Het = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, vO);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.recalculate = function(U, $2) {\n                    if (m3.prototype.recalculate.call(this, U, $2), this.layout.get("icon-rotation-alignment") === "auto" && (this.layout.get("symbol-placement") !== "point" ? this.layout._values["icon-rotation-alignment"] = "map" : this.layout._values["icon-rotation-alignment"] = "viewport"), this.layout.get("text-rotation-alignment") === "auto" && (this.layout.get("symbol-placement") !== "point" ? this.layout._values["text-rotation-alignment"] = "map" : this.layout._values["text-rotation-alignment"] = "viewport"), this.layout.get("text-pitch-alignment") === "auto" && (this.layout._values["text-pitch-alignment"] = this.layout.get("text-rotation-alignment")), this.layout.get("icon-pitch-alignment") === "auto" && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), this.layout.get("symbol-placement") === "point") {\n                      var ae = this.layout.get("text-writing-mode");\n                      if (ae) {\n                        for (var he = [], Oe = 0, rt = ae; Oe < rt.length; Oe += 1) {\n                          var gt = rt[Oe];\n                          he.indexOf(gt) < 0 && he.push(gt);\n                        }\n                        this.layout._values["text-writing-mode"] = he;\n                      } else this.layout._values["text-writing-mode"] = ["horizontal"];\n                    }\n                    this._setPaintOverrides();\n                  }, y3.prototype.getValueAndResolveTokens = function(U, $2, ae, he) {\n                    var Oe = this.layout.get(U).evaluate($2, {}, ae, he), rt = this._unevaluatedLayout._values[U];\n                    return !rt.isDataDriven() && !Ua(rt.value) && Oe ? Uet($2.properties, Oe) : Oe;\n                  }, y3.prototype.createBucket = function(U) {\n                    return new Pu(U);\n                  }, y3.prototype.queryRadius = function() {\n                    return 0;\n                  }, y3.prototype.queryIntersectsFeature = function() {\n                    return false;\n                  }, y3.prototype._setPaintOverrides = function() {\n                    for (var U = 0, $2 = vO.paint.overridableProperties; U < $2.length; U += 1) {\n                      var ae = $2[U];\n                      if (y3.hasPaintOverride(this.layout, ae)) {\n                        var he = this.paint.get(ae), Oe = new Jw(he), rt = new Ac(Oe, he.property.specification), gt = null;\n                        he.value.kind === "constant" || he.value.kind === "source" ? gt = new Vc("source", rt) : gt = new hc("composite", rt, he.value.zoomStops, he.value._interpolationType), this.paint._values[ae] = new dl(he.property, gt, he.parameters);\n                      }\n                    }\n                  }, y3.prototype._handleOverridablePaintPropertyUpdate = function(U, $2, ae) {\n                    return !this.layout || $2.isDataDriven() || ae.isDataDriven() ? false : y3.hasPaintOverride(this.layout, U);\n                  }, y3.hasPaintOverride = function(U, $2) {\n                    var ae = U.get("text-field"), he = vO.paint.properties[$2], Oe = false, rt = function(or) {\n                      for (var _r = 0, pr = or; _r < pr.length; _r += 1) {\n                        var Fr = pr[_r];\n                        if (he.overrides && he.overrides.hasOverride(Fr)) {\n                          Oe = true;\n                          return;\n                        }\n                      }\n                    };\n                    if (ae.value.kind === "constant" && ae.value.value instanceof Jl) rt(ae.value.value.sections);\n                    else if (ae.value.kind === "source") {\n                      var gt = function(or) {\n                        if (!Oe) if (or instanceof Go && Es(or.value) === pl) {\n                          var _r = or.value;\n                          rt(_r.sections);\n                        } else or instanceof Gu ? rt(or.sections) : or.eachChild(gt);\n                      }, Et = ae.value;\n                      Et._styleExpression && gt(Et._styleExpression.expression);\n                    }\n                    return Oe;\n                  }, y3;\n                })(mi), jet = new Nr({ "background-color": new Me(Rn.paint_background["background-color"]), "background-pattern": new Rr(Rn.paint_background["background-pattern"]), "background-opacity": new Me(Rn.paint_background["background-opacity"]) }), Wet = { paint: jet }, Xet = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, Wet);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3;\n                })(mi), Zet = new Nr({ "raster-opacity": new Me(Rn.paint_raster["raster-opacity"]), "raster-hue-rotate": new Me(Rn.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new Me(Rn.paint_raster["raster-brightness-min"]), "raster-brightness-max": new Me(Rn.paint_raster["raster-brightness-max"]), "raster-saturation": new Me(Rn.paint_raster["raster-saturation"]), "raster-contrast": new Me(Rn.paint_raster["raster-contrast"]), "raster-resampling": new Me(Rn.paint_raster["raster-resampling"]), "raster-fade-duration": new Me(Rn.paint_raster["raster-fade-duration"]) }), Yet = { paint: Zet }, Ket = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, Yet);\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3;\n                })(mi);\n                function Jet(m3) {\n                  var y3 = [], I3 = m3.id;\n                  return I3 === void 0 && y3.push({ message: "layers." + I3 + \': missing required property "id"\' }), m3.render === void 0 && y3.push({ message: "layers." + I3 + \': missing required method "render"\' }), m3.renderingMode && m3.renderingMode !== "2d" && m3.renderingMode !== "3d" && y3.push({ message: "layers." + I3 + \': property "renderingMode" must be either "2d" or "3d"\' }), y3;\n                }\n                var $et = (function(m3) {\n                  function y3(I3) {\n                    m3.call(this, I3, {}), this.implementation = I3;\n                  }\n                  return m3 && (y3.__proto__ = m3), y3.prototype = Object.create(m3 && m3.prototype), y3.prototype.constructor = y3, y3.prototype.is3D = function() {\n                    return this.implementation.renderingMode === "3d";\n                  }, y3.prototype.hasOffscreenPass = function() {\n                    return this.implementation.prerender !== void 0;\n                  }, y3.prototype.recalculate = function() {\n                  }, y3.prototype.updateTransitions = function() {\n                  }, y3.prototype.hasTransition = function() {\n                  }, y3.prototype.serialize = function() {\n                  }, y3.prototype.onAdd = function(U) {\n                    this.implementation.onAdd && this.implementation.onAdd(U, U.painter.context.gl);\n                  }, y3.prototype.onRemove = function(U) {\n                    this.implementation.onRemove && this.implementation.onRemove(U, U.painter.context.gl);\n                  }, y3;\n                })(mi), Qet = { circle: j9, heatmap: Iw, hillshade: xC, fill: Qx, "fill-extrusion": hm, line: A3, symbol: Het, background: Xet, raster: Ket };\n                function ett(m3) {\n                  return m3.type === "custom" ? new $et(m3) : new Qet[m3.type](m3);\n                }\n                var jQ = f4.HTMLImageElement, WQ = f4.HTMLCanvasElement, XQ = f4.HTMLVideoElement, ZQ = f4.ImageData, t6 = f4.ImageBitmap, ib = function(y3, I3, U, $2) {\n                  this.context = y3, this.format = U, this.texture = y3.gl.createTexture(), this.update(I3, $2);\n                };\n                ib.prototype.update = function(y3, I3, U) {\n                  var $2 = y3.width, ae = y3.height, he = (!this.size || this.size[0] !== $2 || this.size[1] !== ae) && !U, Oe = this, rt = Oe.context, gt = rt.gl;\n                  if (this.useMipmap = !!(I3 && I3.useMipmap), gt.bindTexture(gt.TEXTURE_2D, this.texture), rt.pixelStoreUnpackFlipY.set(false), rt.pixelStoreUnpack.set(1), rt.pixelStoreUnpackPremultiplyAlpha.set(this.format === gt.RGBA && (!I3 || I3.premultiply !== false)), he) this.size = [$2, ae], y3 instanceof jQ || y3 instanceof WQ || y3 instanceof XQ || y3 instanceof ZQ || t6 && y3 instanceof t6 ? gt.texImage2D(gt.TEXTURE_2D, 0, this.format, this.format, gt.UNSIGNED_BYTE, y3) : gt.texImage2D(gt.TEXTURE_2D, 0, this.format, $2, ae, 0, this.format, gt.UNSIGNED_BYTE, y3.data);\n                  else {\n                    var Et = U || { x: 0, y: 0 }, or = Et.x, _r = Et.y;\n                    y3 instanceof jQ || y3 instanceof WQ || y3 instanceof XQ || y3 instanceof ZQ || t6 && y3 instanceof t6 ? gt.texSubImage2D(gt.TEXTURE_2D, 0, or, _r, gt.RGBA, gt.UNSIGNED_BYTE, y3) : gt.texSubImage2D(gt.TEXTURE_2D, 0, or, _r, $2, ae, gt.RGBA, gt.UNSIGNED_BYTE, y3.data);\n                  }\n                  this.useMipmap && this.isSizePowerOfTwo() && gt.generateMipmap(gt.TEXTURE_2D);\n                }, ib.prototype.bind = function(y3, I3, U) {\n                  var $2 = this, ae = $2.context, he = ae.gl;\n                  he.bindTexture(he.TEXTURE_2D, this.texture), U === he.LINEAR_MIPMAP_NEAREST && !this.isSizePowerOfTwo() && (U = he.LINEAR), y3 !== this.filter && (he.texParameteri(he.TEXTURE_2D, he.TEXTURE_MAG_FILTER, y3), he.texParameteri(he.TEXTURE_2D, he.TEXTURE_MIN_FILTER, U || y3), this.filter = y3), I3 !== this.wrap && (he.texParameteri(he.TEXTURE_2D, he.TEXTURE_WRAP_S, I3), he.texParameteri(he.TEXTURE_2D, he.TEXTURE_WRAP_T, I3), this.wrap = I3);\n                }, ib.prototype.isSizePowerOfTwo = function() {\n                  return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 === 0;\n                }, ib.prototype.destroy = function() {\n                  var y3 = this.context, I3 = y3.gl;\n                  I3.deleteTexture(this.texture), this.texture = null;\n                };\n                var pO = function(y3) {\n                  var I3 = this;\n                  this._callback = y3, this._triggered = false, typeof MessageChannel != "undefined" && (this._channel = new MessageChannel(), this._channel.port2.onmessage = function() {\n                    I3._triggered = false, I3._callback();\n                  });\n                };\n                pO.prototype.trigger = function() {\n                  var y3 = this;\n                  this._triggered || (this._triggered = true, this._channel ? this._channel.port1.postMessage(true) : setTimeout(function() {\n                    y3._triggered = false, y3._callback();\n                  }, 0));\n                }, pO.prototype.remove = function() {\n                  delete this._channel, this._callback = function() {\n                  };\n                };\n                var $w = function(y3, I3, U) {\n                  this.target = y3, this.parent = I3, this.mapId = U, this.callbacks = {}, this.tasks = {}, this.taskQueue = [], this.cancelCallbacks = {}, O3(["receive", "process"], this), this.invoker = new pO(this.process), this.target.addEventListener("message", this.receive, false), this.globalScope = Ce() ? y3 : f4;\n                };\n                $w.prototype.send = function(y3, I3, U, $2, ae) {\n                  var he = this;\n                  ae === void 0 && (ae = false);\n                  var Oe = Math.round(Math.random() * 1e18).toString(36).substring(0, 10);\n                  U && (this.callbacks[Oe] = U);\n                  var rt = Se(this.globalScope) ? void 0 : [];\n                  return this.target.postMessage({ id: Oe, type: y3, hasCallback: !!U, targetMapId: $2, mustQueue: ae, sourceMapId: this.mapId, data: He(I3, rt) }, rt), { cancel: function() {\n                    U && delete he.callbacks[Oe], he.target.postMessage({ id: Oe, type: "<cancel>", targetMapId: $2, sourceMapId: he.mapId });\n                  } };\n                }, $w.prototype.receive = function(y3) {\n                  var I3 = y3.data, U = I3.id;\n                  if (U && !(I3.targetMapId && this.mapId !== I3.targetMapId)) if (I3.type === "<cancel>") {\n                    delete this.tasks[U];\n                    var $2 = this.cancelCallbacks[U];\n                    delete this.cancelCallbacks[U], $2 && $2();\n                  } else Ce() || I3.mustQueue ? (this.tasks[U] = I3, this.taskQueue.push(U), this.invoker.trigger()) : this.processTask(U, I3);\n                }, $w.prototype.process = function() {\n                  if (this.taskQueue.length) {\n                    var y3 = this.taskQueue.shift(), I3 = this.tasks[y3];\n                    delete this.tasks[y3], this.taskQueue.length && this.invoker.trigger(), I3 && this.processTask(y3, I3);\n                  }\n                }, $w.prototype.processTask = function(y3, I3) {\n                  var U = this;\n                  if (I3.type === "<response>") {\n                    var $2 = this.callbacks[y3];\n                    delete this.callbacks[y3], $2 && (I3.error ? $2(Ye(I3.error)) : $2(null, Ye(I3.data)));\n                  } else {\n                    var ae = false, he = Se(this.globalScope) ? void 0 : [], Oe = I3.hasCallback ? function(_r, pr) {\n                      ae = true, delete U.cancelCallbacks[y3], U.target.postMessage({ id: y3, type: "<response>", sourceMapId: U.mapId, error: _r ? He(_r) : null, data: He(pr, he) }, he);\n                    } : function(_r) {\n                      ae = true;\n                    }, rt = null, gt = Ye(I3.data);\n                    if (this.parent[I3.type]) rt = this.parent[I3.type](I3.sourceMapId, gt, Oe);\n                    else if (this.parent.getWorkerSource) {\n                      var Et = I3.type.split("."), or = this.parent.getWorkerSource(I3.sourceMapId, Et[0], gt.source);\n                      rt = or[Et[1]](gt, Oe);\n                    } else Oe(new Error("Could not find function " + I3.type));\n                    !ae && rt && rt.cancel && (this.cancelCallbacks[y3] = rt.cancel);\n                  }\n                }, $w.prototype.remove = function() {\n                  this.invoker.remove(), this.target.removeEventListener("message", this.receive, false);\n                };\n                function ttt(m3, y3, I3) {\n                  y3 = Math.pow(2, I3) - y3 - 1;\n                  var U = YQ(m3 * 256, y3 * 256, I3), $2 = YQ((m3 + 1) * 256, (y3 + 1) * 256, I3);\n                  return U[0] + "," + U[1] + "," + $2[0] + "," + $2[1];\n                }\n                function YQ(m3, y3, I3) {\n                  var U = 2 * Math.PI * 6378137 / 256 / Math.pow(2, I3), $2 = m3 * U - 2 * Math.PI * 6378137 / 2, ae = y3 * U - 2 * Math.PI * 6378137 / 2;\n                  return [$2, ae];\n                }\n                var lh = function(y3, I3) {\n                  y3 && (I3 ? this.setSouthWest(y3).setNorthEast(I3) : y3.length === 4 ? this.setSouthWest([y3[0], y3[1]]).setNorthEast([y3[2], y3[3]]) : this.setSouthWest(y3[0]).setNorthEast(y3[1]));\n                };\n                lh.prototype.setNorthEast = function(y3) {\n                  return this._ne = y3 instanceof Hc ? new Hc(y3.lng, y3.lat) : Hc.convert(y3), this;\n                }, lh.prototype.setSouthWest = function(y3) {\n                  return this._sw = y3 instanceof Hc ? new Hc(y3.lng, y3.lat) : Hc.convert(y3), this;\n                }, lh.prototype.extend = function(y3) {\n                  var I3 = this._sw, U = this._ne, $2, ae;\n                  if (y3 instanceof Hc) $2 = y3, ae = y3;\n                  else if (y3 instanceof lh) {\n                    if ($2 = y3._sw, ae = y3._ne, !$2 || !ae) return this;\n                  } else {\n                    if (Array.isArray(y3)) if (y3.length === 4 || y3.every(Array.isArray)) {\n                      var he = y3;\n                      return this.extend(lh.convert(he));\n                    } else {\n                      var Oe = y3;\n                      return this.extend(Hc.convert(Oe));\n                    }\n                    return this;\n                  }\n                  return !I3 && !U ? (this._sw = new Hc($2.lng, $2.lat), this._ne = new Hc(ae.lng, ae.lat)) : (I3.lng = Math.min($2.lng, I3.lng), I3.lat = Math.min($2.lat, I3.lat), U.lng = Math.max(ae.lng, U.lng), U.lat = Math.max(ae.lat, U.lat)), this;\n                }, lh.prototype.getCenter = function() {\n                  return new Hc((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);\n                }, lh.prototype.getSouthWest = function() {\n                  return this._sw;\n                }, lh.prototype.getNorthEast = function() {\n                  return this._ne;\n                }, lh.prototype.getNorthWest = function() {\n                  return new Hc(this.getWest(), this.getNorth());\n                }, lh.prototype.getSouthEast = function() {\n                  return new Hc(this.getEast(), this.getSouth());\n                }, lh.prototype.getWest = function() {\n                  return this._sw.lng;\n                }, lh.prototype.getSouth = function() {\n                  return this._sw.lat;\n                }, lh.prototype.getEast = function() {\n                  return this._ne.lng;\n                }, lh.prototype.getNorth = function() {\n                  return this._ne.lat;\n                }, lh.prototype.toArray = function() {\n                  return [this._sw.toArray(), this._ne.toArray()];\n                }, lh.prototype.toString = function() {\n                  return "LngLatBounds(" + this._sw.toString() + ", " + this._ne.toString() + ")";\n                }, lh.prototype.isEmpty = function() {\n                  return !(this._sw && this._ne);\n                }, lh.prototype.contains = function(y3) {\n                  var I3 = Hc.convert(y3), U = I3.lng, $2 = I3.lat, ae = this._sw.lat <= $2 && $2 <= this._ne.lat, he = this._sw.lng <= U && U <= this._ne.lng;\n                  return this._sw.lng > this._ne.lng && (he = this._sw.lng >= U && U >= this._ne.lng), ae && he;\n                }, lh.convert = function(y3) {\n                  return !y3 || y3 instanceof lh ? y3 : new lh(y3);\n                };\n                var KQ = 63710088e-1, Hc = function(y3, I3) {\n                  if (isNaN(y3) || isNaN(I3)) throw new Error("Invalid LngLat object: (" + y3 + ", " + I3 + ")");\n                  if (this.lng = +y3, this.lat = +I3, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");\n                };\n                Hc.prototype.wrap = function() {\n                  return new Hc(k4(this.lng, -180, 180), this.lat);\n                }, Hc.prototype.toArray = function() {\n                  return [this.lng, this.lat];\n                }, Hc.prototype.toString = function() {\n                  return "LngLat(" + this.lng + ", " + this.lat + ")";\n                }, Hc.prototype.distanceTo = function(y3) {\n                  var I3 = Math.PI / 180, U = this.lat * I3, $2 = y3.lat * I3, ae = Math.sin(U) * Math.sin($2) + Math.cos(U) * Math.cos($2) * Math.cos((y3.lng - this.lng) * I3), he = KQ * Math.acos(Math.min(ae, 1));\n                  return he;\n                }, Hc.prototype.toBounds = function(y3) {\n                  y3 === void 0 && (y3 = 0);\n                  var I3 = 40075017, U = 360 * y3 / I3, $2 = U / Math.cos(Math.PI / 180 * this.lat);\n                  return new lh(new Hc(this.lng - $2, this.lat - U), new Hc(this.lng + $2, this.lat + U));\n                }, Hc.convert = function(y3) {\n                  if (y3 instanceof Hc) return y3;\n                  if (Array.isArray(y3) && (y3.length === 2 || y3.length === 3)) return new Hc(Number(y3[0]), Number(y3[1]));\n                  if (!Array.isArray(y3) && typeof y3 == "object" && y3 !== null) return new Hc(Number("lng" in y3 ? y3.lng : y3.lon), Number(y3.lat));\n                  throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");\n                };\n                var JQ = 2 * Math.PI * KQ;\n                function $Q(m3) {\n                  return JQ * Math.cos(m3 * Math.PI / 180);\n                }\n                function QQ(m3) {\n                  return (180 + m3) / 360;\n                }\n                function eee(m3) {\n                  return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + m3 * Math.PI / 360))) / 360;\n                }\n                function tee(m3, y3) {\n                  return m3 / $Q(y3);\n                }\n                function rtt(m3) {\n                  return m3 * 360 - 180;\n                }\n                function gO(m3) {\n                  var y3 = 180 - m3 * 360;\n                  return 360 / Math.PI * Math.atan(Math.exp(y3 * Math.PI / 180)) - 90;\n                }\n                function itt(m3, y3) {\n                  return m3 * $Q(gO(y3));\n                }\n                function ntt(m3) {\n                  return 1 / Math.cos(m3 * Math.PI / 180);\n                }\n                var nb = function(y3, I3, U) {\n                  U === void 0 && (U = 0), this.x = +y3, this.y = +I3, this.z = +U;\n                };\n                nb.fromLngLat = function(y3, I3) {\n                  I3 === void 0 && (I3 = 0);\n                  var U = Hc.convert(y3);\n                  return new nb(QQ(U.lng), eee(U.lat), tee(I3, U.lat));\n                }, nb.prototype.toLngLat = function() {\n                  return new Hc(rtt(this.x), gO(this.y));\n                }, nb.prototype.toAltitude = function() {\n                  return itt(this.z, this.y);\n                }, nb.prototype.meterInMercatorCoordinateUnits = function() {\n                  return 1 / JQ * ntt(gO(this.y));\n                };\n                var ab = function(y3, I3, U) {\n                  this.z = y3, this.x = I3, this.y = U, this.key = kS(0, y3, y3, I3, U);\n                };\n                ab.prototype.equals = function(y3) {\n                  return this.z === y3.z && this.x === y3.x && this.y === y3.y;\n                }, ab.prototype.url = function(y3, I3) {\n                  var U = ttt(this.x, this.y, this.z), $2 = att(this.z, this.x, this.y);\n                  return y3[(this.x + this.y) % y3.length].replace("{prefix}", (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace("{z}", String(this.z)).replace("{x}", String(this.x)).replace("{y}", String(I3 === "tms" ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace("{quadkey}", $2).replace("{bbox-epsg-3857}", U);\n                }, ab.prototype.getTilePoint = function(y3) {\n                  var I3 = Math.pow(2, this.z);\n                  return new u4((y3.x * I3 - this.x) * Ci, (y3.y * I3 - this.y) * Ci);\n                }, ab.prototype.toString = function() {\n                  return this.z + "/" + this.x + "/" + this.y;\n                };\n                var ree = function(y3, I3) {\n                  this.wrap = y3, this.canonical = I3, this.key = kS(y3, I3.z, I3.z, I3.x, I3.y);\n                }, uh = function(y3, I3, U, $2, ae) {\n                  this.overscaledZ = y3, this.wrap = I3, this.canonical = new ab(U, +$2, +ae), this.key = kS(I3, y3, U, $2, ae);\n                };\n                uh.prototype.equals = function(y3) {\n                  return this.overscaledZ === y3.overscaledZ && this.wrap === y3.wrap && this.canonical.equals(y3.canonical);\n                }, uh.prototype.scaledTo = function(y3) {\n                  var I3 = this.canonical.z - y3;\n                  return y3 > this.canonical.z ? new uh(y3, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new uh(y3, this.wrap, y3, this.canonical.x >> I3, this.canonical.y >> I3);\n                }, uh.prototype.calculateScaledKey = function(y3, I3) {\n                  var U = this.canonical.z - y3;\n                  return y3 > this.canonical.z ? kS(this.wrap * +I3, y3, this.canonical.z, this.canonical.x, this.canonical.y) : kS(this.wrap * +I3, y3, y3, this.canonical.x >> U, this.canonical.y >> U);\n                }, uh.prototype.isChildOf = function(y3) {\n                  if (y3.wrap !== this.wrap) return false;\n                  var I3 = this.canonical.z - y3.canonical.z;\n                  return y3.overscaledZ === 0 || y3.overscaledZ < this.overscaledZ && y3.canonical.x === this.canonical.x >> I3 && y3.canonical.y === this.canonical.y >> I3;\n                }, uh.prototype.children = function(y3) {\n                  if (this.overscaledZ >= y3) return [new uh(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];\n                  var I3 = this.canonical.z + 1, U = this.canonical.x * 2, $2 = this.canonical.y * 2;\n                  return [new uh(I3, this.wrap, I3, U, $2), new uh(I3, this.wrap, I3, U + 1, $2), new uh(I3, this.wrap, I3, U, $2 + 1), new uh(I3, this.wrap, I3, U + 1, $2 + 1)];\n                }, uh.prototype.isLessThan = function(y3) {\n                  return this.wrap < y3.wrap ? true : this.wrap > y3.wrap ? false : this.overscaledZ < y3.overscaledZ ? true : this.overscaledZ > y3.overscaledZ ? false : this.canonical.x < y3.canonical.x ? true : this.canonical.x > y3.canonical.x ? false : this.canonical.y < y3.canonical.y;\n                }, uh.prototype.wrapped = function() {\n                  return new uh(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);\n                }, uh.prototype.unwrapTo = function(y3) {\n                  return new uh(this.overscaledZ, y3, this.canonical.z, this.canonical.x, this.canonical.y);\n                }, uh.prototype.overscaleFactor = function() {\n                  return Math.pow(2, this.overscaledZ - this.canonical.z);\n                }, uh.prototype.toUnwrapped = function() {\n                  return new ree(this.wrap, this.canonical);\n                }, uh.prototype.toString = function() {\n                  return this.overscaledZ + "/" + this.canonical.x + "/" + this.canonical.y;\n                }, uh.prototype.getTilePoint = function(y3) {\n                  return this.canonical.getTilePoint(new nb(y3.x - this.wrap, y3.y));\n                };\n                function kS(m3, y3, I3, U, $2) {\n                  m3 *= 2, m3 < 0 && (m3 = m3 * -1 - 1);\n                  var ae = 1 << I3;\n                  return (ae * ae * m3 + ae * $2 + U).toString(36) + I3.toString(36) + y3.toString(36);\n                }\n                function att(m3, y3, I3) {\n                  for (var U = "", $2, ae = m3; ae > 0; ae--) $2 = 1 << ae - 1, U += (y3 & $2 ? 1 : 0) + (I3 & $2 ? 2 : 0);\n                  return U;\n                }\n                X("CanonicalTileID", ab), X("OverscaledTileID", uh, { omit: ["posMatrix"] });\n                var vy = function(y3, I3, U) {\n                  if (this.uid = y3, I3.height !== I3.width) throw new RangeError("DEM tiles must be square");\n                  if (U && U !== "mapbox" && U !== "terrarium") return te(\'"\' + U + \'" is not a valid encoding type. Valid types include "mapbox" and "terrarium".\');\n                  this.stride = I3.height;\n                  var $2 = this.dim = I3.height - 2;\n                  this.data = new Uint32Array(I3.data.buffer), this.encoding = U || "mapbox";\n                  for (var ae = 0; ae < $2; ae++) this.data[this._idx(-1, ae)] = this.data[this._idx(0, ae)], this.data[this._idx($2, ae)] = this.data[this._idx($2 - 1, ae)], this.data[this._idx(ae, -1)] = this.data[this._idx(ae, 0)], this.data[this._idx(ae, $2)] = this.data[this._idx(ae, $2 - 1)];\n                  this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx($2, -1)] = this.data[this._idx($2 - 1, 0)], this.data[this._idx(-1, $2)] = this.data[this._idx(0, $2 - 1)], this.data[this._idx($2, $2)] = this.data[this._idx($2 - 1, $2 - 1)];\n                };\n                vy.prototype.get = function(y3, I3) {\n                  var U = new Uint8Array(this.data.buffer), $2 = this._idx(y3, I3) * 4, ae = this.encoding === "terrarium" ? this._unpackTerrarium : this._unpackMapbox;\n                  return ae(U[$2], U[$2 + 1], U[$2 + 2]);\n                }, vy.prototype.getUnpackVector = function() {\n                  return this.encoding === "terrarium" ? [256, 1, 1 / 256, 32768] : [6553.6, 25.6, 0.1, 1e4];\n                }, vy.prototype._idx = function(y3, I3) {\n                  if (y3 < -1 || y3 >= this.dim + 1 || I3 < -1 || I3 >= this.dim + 1) throw new RangeError("out of range source coordinates for DEM data");\n                  return (I3 + 1) * this.stride + (y3 + 1);\n                }, vy.prototype._unpackMapbox = function(y3, I3, U) {\n                  return (y3 * 256 * 256 + I3 * 256 + U) / 10 - 1e4;\n                }, vy.prototype._unpackTerrarium = function(y3, I3, U) {\n                  return y3 * 256 + I3 + U / 256 - 32768;\n                }, vy.prototype.getPixels = function() {\n                  return new Sh({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));\n                }, vy.prototype.backfillBorder = function(y3, I3, U) {\n                  if (this.dim !== y3.dim) throw new Error("dem dimension mismatch");\n                  var $2 = I3 * this.dim, ae = I3 * this.dim + this.dim, he = U * this.dim, Oe = U * this.dim + this.dim;\n                  switch (I3) {\n                    case -1:\n                      $2 = ae - 1;\n                      break;\n                    case 1:\n                      ae = $2 + 1;\n                      break;\n                  }\n                  switch (U) {\n                    case -1:\n                      he = Oe - 1;\n                      break;\n                    case 1:\n                      Oe = he + 1;\n                      break;\n                  }\n                  for (var rt = -I3 * this.dim, gt = -U * this.dim, Et = he; Et < Oe; Et++) for (var or = $2; or < ae; or++) this.data[this._idx(or, Et)] = y3.data[this._idx(or + rt, Et + gt)];\n                }, X("DEMData", vy);\n                function ott(m3, y3) {\n                  var I3 = {};\n                  if (!y3) return I3;\n                  for (var U = function() {\n                    var he = ae[$2], Oe = he.layerIds.map(function(or) {\n                      return y3.getLayer(or);\n                    }).filter(Boolean);\n                    if (Oe.length !== 0) {\n                      he.layers = Oe, he.stateDependentLayerIds && (he.stateDependentLayers = he.stateDependentLayerIds.map(function(or) {\n                        return Oe.filter(function(_r) {\n                          return _r.id === or;\n                        })[0];\n                      }));\n                      for (var rt = 0, gt = Oe; rt < gt.length; rt += 1) {\n                        var Et = gt[rt];\n                        I3[Et.id] = he;\n                      }\n                    }\n                  }, $2 = 0, ae = m3; $2 < ae.length; $2 += 1) U();\n                  return I3;\n                }\n                var r6 = function(y3) {\n                  this._stringToNumber = {}, this._numberToString = [];\n                  for (var I3 = 0; I3 < y3.length; I3++) {\n                    var U = y3[I3];\n                    this._stringToNumber[U] = I3, this._numberToString[I3] = U;\n                  }\n                };\n                r6.prototype.encode = function(y3) {\n                  return this._stringToNumber[y3];\n                }, r6.prototype.decode = function(y3) {\n                  return this._numberToString[y3];\n                };\n                var i6 = function(y3, I3, U, $2, ae) {\n                  this.type = "Feature", this._vectorTileFeature = y3, y3._z = I3, y3._x = U, y3._y = $2, this.properties = y3.properties, this.id = ae;\n                }, mO = { geometry: { configurable: true } };\n                mO.geometry.get = function() {\n                  return this._geometry === void 0 && (this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry), this._geometry;\n                }, mO.geometry.set = function(m3) {\n                  this._geometry = m3;\n                }, i6.prototype.toJSON = function() {\n                  var y3 = { geometry: this.geometry };\n                  for (var I3 in this) I3 === "_geometry" || I3 === "_vectorTileFeature" || (y3[I3] = this[I3]);\n                  return y3;\n                }, Object.defineProperties(i6.prototype, mO);\n                var Qw = function() {\n                  this.state = {}, this.stateChanges = {}, this.deletedStates = {};\n                };\n                Qw.prototype.updateState = function(y3, I3, U) {\n                  var $2 = String(I3);\n                  if (this.stateChanges[y3] = this.stateChanges[y3] || {}, this.stateChanges[y3][$2] = this.stateChanges[y3][$2] || {}, x2(this.stateChanges[y3][$2], U), this.deletedStates[y3] === null) {\n                    this.deletedStates[y3] = {};\n                    for (var ae in this.state[y3]) ae !== $2 && (this.deletedStates[y3][ae] = null);\n                  } else {\n                    var he = this.deletedStates[y3] && this.deletedStates[y3][$2] === null;\n                    if (he) {\n                      this.deletedStates[y3][$2] = {};\n                      for (var Oe in this.state[y3][$2]) U[Oe] || (this.deletedStates[y3][$2][Oe] = null);\n                    } else for (var rt in U) {\n                      var gt = this.deletedStates[y3] && this.deletedStates[y3][$2] && this.deletedStates[y3][$2][rt] === null;\n                      gt && delete this.deletedStates[y3][$2][rt];\n                    }\n                  }\n                }, Qw.prototype.removeFeatureState = function(y3, I3, U) {\n                  var $2 = this.deletedStates[y3] === null;\n                  if (!$2) {\n                    var ae = String(I3);\n                    if (this.deletedStates[y3] = this.deletedStates[y3] || {}, U && I3 !== void 0) this.deletedStates[y3][ae] !== null && (this.deletedStates[y3][ae] = this.deletedStates[y3][ae] || {}, this.deletedStates[y3][ae][U] = null);\n                    else if (I3 !== void 0) {\n                      var he = this.stateChanges[y3] && this.stateChanges[y3][ae];\n                      if (he) {\n                        this.deletedStates[y3][ae] = {};\n                        for (U in this.stateChanges[y3][ae]) this.deletedStates[y3][ae][U] = null;\n                      } else this.deletedStates[y3][ae] = null;\n                    } else this.deletedStates[y3] = null;\n                  }\n                }, Qw.prototype.getState = function(y3, I3) {\n                  var U = String(I3), $2 = this.state[y3] || {}, ae = this.stateChanges[y3] || {}, he = x2({}, $2[U], ae[U]);\n                  if (this.deletedStates[y3] === null) return {};\n                  if (this.deletedStates[y3]) {\n                    var Oe = this.deletedStates[y3][I3];\n                    if (Oe === null) return {};\n                    for (var rt in Oe) delete he[rt];\n                  }\n                  return he;\n                }, Qw.prototype.initializeTileState = function(y3, I3) {\n                  y3.setFeatureState(this.state, I3);\n                }, Qw.prototype.coalesceChanges = function(y3, I3) {\n                  var U = {};\n                  for (var $2 in this.stateChanges) {\n                    this.state[$2] = this.state[$2] || {};\n                    var ae = {};\n                    for (var he in this.stateChanges[$2]) this.state[$2][he] || (this.state[$2][he] = {}), x2(this.state[$2][he], this.stateChanges[$2][he]), ae[he] = this.state[$2][he];\n                    U[$2] = ae;\n                  }\n                  for (var Oe in this.deletedStates) {\n                    this.state[Oe] = this.state[Oe] || {};\n                    var rt = {};\n                    if (this.deletedStates[Oe] === null) for (var gt in this.state[Oe]) rt[gt] = {}, this.state[Oe][gt] = {};\n                    else for (var Et in this.deletedStates[Oe]) {\n                      var or = this.deletedStates[Oe][Et] === null;\n                      if (or) this.state[Oe][Et] = {};\n                      else for (var _r = 0, pr = Object.keys(this.deletedStates[Oe][Et]); _r < pr.length; _r += 1) {\n                        var Fr = pr[_r];\n                        delete this.state[Oe][Et][Fr];\n                      }\n                      rt[Et] = this.state[Oe][Et];\n                    }\n                    U[Oe] = U[Oe] || {}, x2(U[Oe], rt);\n                  }\n                  if (this.stateChanges = {}, this.deletedStates = {}, Object.keys(U).length !== 0) for (var oi in y3) {\n                    var Hi = y3[oi];\n                    Hi.setFeatureState(U, I3);\n                  }\n                };\n                var py = function(y3, I3) {\n                  this.tileID = y3, this.x = y3.canonical.x, this.y = y3.canonical.y, this.z = y3.canonical.z, this.grid = new au(Ci, 16, 0), this.grid3D = new au(Ci, 16, 0), this.featureIndexArray = new Ys(), this.promoteId = I3;\n                };\n                py.prototype.insert = function(y3, I3, U, $2, ae, he) {\n                  var Oe = this.featureIndexArray.length;\n                  this.featureIndexArray.emplaceBack(U, $2, ae);\n                  for (var rt = he ? this.grid3D : this.grid, gt = 0; gt < I3.length; gt++) {\n                    for (var Et = I3[gt], or = [1 / 0, 1 / 0, -1 / 0, -1 / 0], _r = 0; _r < Et.length; _r++) {\n                      var pr = Et[_r];\n                      or[0] = Math.min(or[0], pr.x), or[1] = Math.min(or[1], pr.y), or[2] = Math.max(or[2], pr.x), or[3] = Math.max(or[3], pr.y);\n                    }\n                    or[0] < Ci && or[1] < Ci && or[2] >= 0 && or[3] >= 0 && rt.insert(Oe, or[0], or[1], or[2], or[3]);\n                  }\n                }, py.prototype.loadVTLayers = function() {\n                  return this.vtLayers || (this.vtLayers = new pg.VectorTile(new Xa(this.rawTileData)).layers, this.sourceLayerCoder = new r6(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"])), this.vtLayers;\n                }, py.prototype.query = function(y3, I3, U, $2) {\n                  var ae = this;\n                  this.loadVTLayers();\n                  for (var he = y3.params || {}, Oe = Ci / y3.tileSize / y3.scale, rt = be(he.filter), gt = y3.queryGeometry, Et = y3.queryPadding * Oe, or = nee(gt), _r = this.grid.query(or.minX - Et, or.minY - Et, or.maxX + Et, or.maxY + Et), pr = nee(y3.cameraQueryGeometry), Fr = this.grid3D.query(pr.minX - Et, pr.minY - Et, pr.maxX + Et, pr.maxY + Et, function(Zn, ga, ha, eo) {\n                    return gp(y3.cameraQueryGeometry, Zn - Et, ga - Et, ha + Et, eo + Et);\n                  }), oi = 0, Hi = Fr; oi < Hi.length; oi += 1) {\n                    var Ai = Hi[oi];\n                    _r.push(Ai);\n                  }\n                  _r.sort(stt);\n                  for (var bn = {}, nn, xn = function(Zn) {\n                    var ga = _r[Zn];\n                    if (ga !== nn) {\n                      nn = ga;\n                      var ha = ae.featureIndexArray.get(ga), eo = null;\n                      ae.loadMatchingFeature(bn, ha.bucketIndex, ha.sourceLayerIndex, ha.featureIndex, rt, he.layers, he.availableImages, I3, U, $2, function(za, Za, Ko) {\n                        return eo || (eo = zn(za)), Za.queryIntersectsFeature(gt, za, Ko, eo, ae.z, y3.transform, Oe, y3.pixelPosMatrix);\n                      });\n                    }\n                  }, Pn = 0; Pn < _r.length; Pn++) xn(Pn);\n                  return bn;\n                }, py.prototype.loadMatchingFeature = function(y3, I3, U, $2, ae, he, Oe, rt, gt, Et, or) {\n                  var _r = this.bucketLayerIDs[I3];\n                  if (!(he && !N2(he, _r))) {\n                    var pr = this.sourceLayerCoder.decode(U), Fr = this.vtLayers[pr], oi = Fr.feature($2);\n                    if (ae.needGeometry) {\n                      var Hi = Ja(oi, true);\n                      if (!ae.filter(new Gn(this.tileID.overscaledZ), Hi, this.tileID.canonical)) return;\n                    } else if (!ae.filter(new Gn(this.tileID.overscaledZ), oi)) return;\n                    for (var Ai = this.getId(oi, pr), bn = 0; bn < _r.length; bn++) {\n                      var nn = _r[bn];\n                      if (!(he && he.indexOf(nn) < 0)) {\n                        var xn = rt[nn];\n                        if (xn) {\n                          var Pn = {};\n                          Ai !== void 0 && Et && (Pn = Et.getState(xn.sourceLayer || "_geojsonTileLayer", Ai));\n                          var Zn = x2({}, gt[nn]);\n                          Zn.paint = iee(Zn.paint, xn.paint, oi, Pn, Oe), Zn.layout = iee(Zn.layout, xn.layout, oi, Pn, Oe);\n                          var ga = !or || or(oi, xn, Pn);\n                          if (ga) {\n                            var ha = new i6(oi, this.z, this.x, this.y, Ai);\n                            ha.layer = Zn;\n                            var eo = y3[nn];\n                            eo === void 0 && (eo = y3[nn] = []), eo.push({ featureIndex: $2, feature: ha, intersectionZ: ga });\n                          }\n                        }\n                      }\n                    }\n                  }\n                }, py.prototype.lookupSymbolFeatures = function(y3, I3, U, $2, ae, he, Oe, rt) {\n                  var gt = {};\n                  this.loadVTLayers();\n                  for (var Et = be(ae), or = 0, _r = y3; or < _r.length; or += 1) {\n                    var pr = _r[or];\n                    this.loadMatchingFeature(gt, U, $2, pr, Et, he, Oe, rt, I3);\n                  }\n                  return gt;\n                }, py.prototype.hasLayer = function(y3) {\n                  for (var I3 = 0, U = this.bucketLayerIDs; I3 < U.length; I3 += 1) for (var $2 = U[I3], ae = 0, he = $2; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    if (y3 === Oe) return true;\n                  }\n                  return false;\n                }, py.prototype.getId = function(y3, I3) {\n                  var U = y3.id;\n                  if (this.promoteId) {\n                    var $2 = typeof this.promoteId == "string" ? this.promoteId : this.promoteId[I3];\n                    U = y3.properties[$2], typeof U == "boolean" && (U = Number(U));\n                  }\n                  return U;\n                }, X("FeatureIndex", py, { omit: ["rawTileData", "sourceLayerCoder"] });\n                function iee(m3, y3, I3, U, $2) {\n                  return G2(m3, function(ae, he) {\n                    var Oe = y3 instanceof Sc ? y3.get(he) : null;\n                    return Oe && Oe.evaluate ? Oe.evaluate(I3, U, $2) : Oe;\n                  });\n                }\n                function nee(m3) {\n                  for (var y3 = 1 / 0, I3 = 1 / 0, U = -1 / 0, $2 = -1 / 0, ae = 0, he = m3; ae < he.length; ae += 1) {\n                    var Oe = he[ae];\n                    y3 = Math.min(y3, Oe.x), I3 = Math.min(I3, Oe.y), U = Math.max(U, Oe.x), $2 = Math.max($2, Oe.y);\n                  }\n                  return { minX: y3, minY: I3, maxX: U, maxY: $2 };\n                }\n                function stt(m3, y3) {\n                  return y3 - m3;\n                }\n                var ltt = 3e4, Zh = function(y3, I3) {\n                  this.tileID = y3, this.uid = g3(), this.uses = 0, this.tileSize = I3, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.expiredRequestCount = 0, this.state = "loading";\n                };\n                Zh.prototype.registerFadeDuration = function(y3) {\n                  var I3 = y3 + this.timeAdded;\n                  I3 < ut.now() || this.fadeEndTime && I3 < this.fadeEndTime || (this.fadeEndTime = I3);\n                }, Zh.prototype.wasRequested = function() {\n                  return this.state === "errored" || this.state === "loaded" || this.state === "reloading";\n                }, Zh.prototype.loadVectorData = function(y3, I3, U) {\n                  if (this.hasData() && this.unloadVectorData(), this.state = "loaded", !y3) {\n                    this.collisionBoxArray = new Va();\n                    return;\n                  }\n                  y3.featureIndex && (this.latestFeatureIndex = y3.featureIndex, y3.rawTileData ? (this.latestRawTileData = y3.rawTileData, this.latestFeatureIndex.rawTileData = y3.rawTileData) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData)), this.collisionBoxArray = y3.collisionBoxArray, this.buckets = ott(y3.buckets, I3.style), this.hasSymbolBuckets = false;\n                  for (var $2 in this.buckets) {\n                    var ae = this.buckets[$2];\n                    if (ae instanceof Pu) if (this.hasSymbolBuckets = true, U) ae.justReloaded = true;\n                    else break;\n                  }\n                  if (this.hasRTLText = false, this.hasSymbolBuckets) for (var he in this.buckets) {\n                    var Oe = this.buckets[he];\n                    if (Oe instanceof Pu && Oe.hasRTLText) {\n                      this.hasRTLText = true, Xs();\n                      break;\n                    }\n                  }\n                  this.queryPadding = 0;\n                  for (var rt in this.buckets) {\n                    var gt = this.buckets[rt];\n                    this.queryPadding = Math.max(this.queryPadding, I3.style.getLayer(rt).queryRadius(gt));\n                  }\n                  y3.imageAtlas && (this.imageAtlas = y3.imageAtlas), y3.glyphAtlasImage && (this.glyphAtlasImage = y3.glyphAtlasImage);\n                }, Zh.prototype.unloadVectorData = function() {\n                  for (var y3 in this.buckets) this.buckets[y3].destroy();\n                  this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.latestFeatureIndex = null, this.state = "unloaded";\n                }, Zh.prototype.getBucket = function(y3) {\n                  return this.buckets[y3.id];\n                }, Zh.prototype.upload = function(y3) {\n                  for (var I3 in this.buckets) {\n                    var U = this.buckets[I3];\n                    U.uploadPending() && U.upload(y3);\n                  }\n                  var $2 = y3.gl;\n                  this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new ib(y3, this.imageAtlas.image, $2.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new ib(y3, this.glyphAtlasImage, $2.ALPHA), this.glyphAtlasImage = null);\n                }, Zh.prototype.prepare = function(y3) {\n                  this.imageAtlas && this.imageAtlas.patchUpdatedImages(y3, this.imageAtlasTexture);\n                }, Zh.prototype.queryRenderedFeatures = function(y3, I3, U, $2, ae, he, Oe, rt, gt, Et) {\n                  return !this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData ? {} : this.latestFeatureIndex.query({ queryGeometry: $2, cameraQueryGeometry: ae, scale: he, tileSize: this.tileSize, pixelPosMatrix: Et, transform: rt, params: Oe, queryPadding: this.queryPadding * gt }, y3, I3, U);\n                }, Zh.prototype.querySourceFeatures = function(y3, I3) {\n                  var U = this.latestFeatureIndex;\n                  if (!(!U || !U.rawTileData)) {\n                    var $2 = U.loadVTLayers(), ae = I3 ? I3.sourceLayer : "", he = $2._geojsonTileLayer || $2[ae];\n                    if (he) for (var Oe = be(I3 && I3.filter), rt = this.tileID.canonical, gt = rt.z, Et = rt.x, or = rt.y, _r = { z: gt, x: Et, y: or }, pr = 0; pr < he.length; pr++) {\n                      var Fr = he.feature(pr);\n                      if (Oe.needGeometry) {\n                        var oi = Ja(Fr, true);\n                        if (!Oe.filter(new Gn(this.tileID.overscaledZ), oi, this.tileID.canonical)) continue;\n                      } else if (!Oe.filter(new Gn(this.tileID.overscaledZ), Fr)) continue;\n                      var Hi = U.getId(Fr, ae), Ai = new i6(Fr, gt, Et, or, Hi);\n                      Ai.tile = _r, y3.push(Ai);\n                    }\n                  }\n                }, Zh.prototype.hasData = function() {\n                  return this.state === "loaded" || this.state === "reloading" || this.state === "expired";\n                }, Zh.prototype.patternsLoaded = function() {\n                  return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;\n                }, Zh.prototype.setExpiryData = function(y3) {\n                  var I3 = this.expirationTime;\n                  if (y3.cacheControl) {\n                    var U = me(y3.cacheControl);\n                    U["max-age"] && (this.expirationTime = Date.now() + U["max-age"] * 1e3);\n                  } else y3.expires && (this.expirationTime = new Date(y3.expires).getTime());\n                  if (this.expirationTime) {\n                    var $2 = Date.now(), ae = false;\n                    if (this.expirationTime > $2) ae = false;\n                    else if (!I3) ae = true;\n                    else if (this.expirationTime < I3) ae = true;\n                    else {\n                      var he = this.expirationTime - I3;\n                      he ? this.expirationTime = $2 + Math.max(he, ltt) : ae = true;\n                    }\n                    ae ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;\n                  }\n                }, Zh.prototype.getExpiryTimeout = function() {\n                  if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);\n                }, Zh.prototype.setFeatureState = function(y3, I3) {\n                  if (!(!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || Object.keys(y3).length === 0)) {\n                    var U = this.latestFeatureIndex.loadVTLayers();\n                    for (var $2 in this.buckets) if (I3.style.hasLayer($2)) {\n                      var ae = this.buckets[$2], he = ae.layers[0].sourceLayer || "_geojsonTileLayer", Oe = U[he], rt = y3[he];\n                      if (!(!Oe || !rt || Object.keys(rt).length === 0)) {\n                        ae.update(rt, Oe, this.imageAtlas && this.imageAtlas.patternPositions || {});\n                        var gt = I3 && I3.style && I3.style.getLayer($2);\n                        gt && (this.queryPadding = Math.max(this.queryPadding, gt.queryRadius(ae)));\n                      }\n                    }\n                  }\n                }, Zh.prototype.holdingForFade = function() {\n                  return this.symbolFadeHoldUntil !== void 0;\n                }, Zh.prototype.symbolFadeFinished = function() {\n                  return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < ut.now();\n                }, Zh.prototype.clearFadeHold = function() {\n                  this.symbolFadeHoldUntil = void 0;\n                }, Zh.prototype.setHoldDuration = function(y3) {\n                  this.symbolFadeHoldUntil = ut.now() + y3;\n                }, Zh.prototype.setDependencies = function(y3, I3) {\n                  for (var U = {}, $2 = 0, ae = I3; $2 < ae.length; $2 += 1) {\n                    var he = ae[$2];\n                    U[he] = true;\n                  }\n                  this.dependencies[y3] = U;\n                }, Zh.prototype.hasDependency = function(y3, I3) {\n                  for (var U = 0, $2 = y3; U < $2.length; U += 1) {\n                    var ae = $2[U], he = this.dependencies[ae];\n                    if (he) for (var Oe = 0, rt = I3; Oe < rt.length; Oe += 1) {\n                      var gt = rt[Oe];\n                      if (he[gt]) return true;\n                    }\n                  }\n                  return false;\n                };\n                var utt = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"], D1 = f4.performance, aee = function(y3) {\n                  this._marks = { start: [y3.url, "start"].join("#"), end: [y3.url, "end"].join("#"), measure: y3.url.toString() }, D1.mark(this._marks.start);\n                };\n                aee.prototype.finish = function() {\n                  D1.mark(this._marks.end);\n                  var y3 = D1.getEntriesByName(this._marks.measure);\n                  return y3.length === 0 && (D1.measure(this._marks.measure, this._marks.start, this._marks.end), y3 = D1.getEntriesByName(this._marks.measure), D1.clearMarks(this._marks.start), D1.clearMarks(this._marks.end), D1.clearMeasures(this._marks.measure)), y3;\n                }, i3.Actor = $w, i3.AlphaImage = Dv, i3.CanonicalTileID = ab, i3.CollisionBoxArray = Va, i3.Color = cs, i3.DEMData = vy, i3.DataConstantProperty = Me, i3.DictionaryCoder = r6, i3.EXTENT = Ci, i3.ErrorEvent = da, i3.EvaluationParameters = Gn, i3.Event = Wo, i3.Evented = Wn, i3.FeatureIndex = py, i3.FillBucket = mp, i3.FillExtrusionBucket = Vp, i3.ImageAtlas = gg, i3.ImagePosition = Zf, i3.LineBucket = sh, i3.LngLat = Hc, i3.LngLatBounds = lh, i3.MercatorCoordinate = nb, i3.ONE_EM = Tn, i3.OverscaledTileID = uh, i3.Point = u4, i3.Point$1 = u4, i3.Properties = Nr, i3.Protobuf = Xa, i3.RGBAImage = Sh, i3.RequestManager = $e, i3.RequestPerformance = aee, i3.ResourceType = ra, i3.SegmentVector = io, i3.SourceFeatureState = Qw, i3.StructArrayLayout1ui2 = ba, i3.StructArrayLayout2f1f2i16 = Vi, i3.StructArrayLayout2i4 = Yr, i3.StructArrayLayout3ui6 = pn, i3.StructArrayLayout4i8 = xi, i3.SymbolBucket = Pu, i3.Texture = ib, i3.Tile = Zh, i3.Transitionable = Uo, i3.Uniform1f = Qe, i3.Uniform1i = Ve, i3.Uniform2f = at, i3.Uniform3f = Ct, i3.Uniform4f = Ot, i3.UniformColor = Rt, i3.UniformMatrix4f = Dt, i3.UnwrappedTileID = ree, i3.ValidationError = _a, i3.WritingMode = uv, i3.ZoomHistory = kt, i3.add = Rv, i3.addDynamicAttributes = dO, i3.asyncAll = E3, i3.bezier = _2, i3.bindAll = O3, i3.browser = ut, i3.cacheEntryPossiblyAdded = ji, i3.clamp = p3, i3.clearTileCache = wi, i3.clipLine = BQ, i3.clone = w1, i3.clone$1 = j3, i3.clone$2 = kw, i3.collisionCircleLayout = Lt, i3.config = pt, i3.create = b1, i3.create$1 = jh, i3.create$2 = hg, i3.createCommonjsModule = a4, i3.createExpression = oo, i3.createLayout = Wi, i3.createStyleLayer = ett, i3.cross = B9, i3.deepEqual = h3, i3.dot = q9, i3.dot$1 = H9, i3.ease = b, i3.emitValidationErrors = Lu, i3.endsWith = V2, i3.enforceCacheSizeLimit = In, i3.evaluateSizeForFeature = IQ, i3.evaluateSizeForZoom = RQ, i3.evaluateVariableOffset = VQ, i3.evented = Ia, i3.extend = x2, i3.featureFilter = be, i3.filterObject = Z, i3.fromRotation = im, i3.getAnchorAlignment = SS, i3.getAnchorJustification = hO, i3.getArrayBuffer = ri, i3.getImage = ua, i3.getJSON = Xr, i3.getRTLTextPluginStatus = yo, i3.getReferrer = Ut, i3.getVideo = ma, i3.identity = sy, i3.invert = nm, i3.isChar = nt, i3.isMapboxURL = St, i3.keysDifference = L3, i3.makeRequest = Er, i3.mapObject = G2, i3.mercatorXfromLng = QQ, i3.mercatorYfromLat = eee, i3.mercatorZfromAltitude = tee, i3.mul = Nx, i3.multiply = am, i3.mvt = pg, i3.nextPowerOfTwo = T3, i3.normalize = Ux, i3.number = nl, i3.offscreenCanvasSupported = Fn, i3.ortho = wu, i3.parseGlyphPBF = v0, i3.pbf = Xa, i3.performSymbolLayout = Det, i3.perspective = T1, i3.pick = C3, i3.plugin = Ms, i3.polygonIntersectsPolygon = so, i3.postMapLoadEvent = je, i3.postTurnstileEvent = Ge, i3.potpack = ep, i3.refProperties = utt, i3.register = X, i3.registerForPluginStateChange = Da, i3.renderColorRamp = Hx, i3.rotate = oy, i3.rotateX = Sd, i3.rotateZ = ly, i3.scale = eu, i3.scale$1 = G9, i3.scale$2 = Cw, i3.setCacheLimits = On, i3.setRTLTextPlugin = go, i3.sphericalToCartesian = Ee, i3.sqrLen = aS, i3.styleSpec = Rn, i3.sub = U9, i3.symbolSize = Aet, i3.transformMat3 = N9, i3.transformMat4 = uy, i3.translate = vc, i3.triggerPluginCompletionEvent = ia, i3.uniqueId = g3, i3.validateCustomStyleLayer = Jet, i3.validateLight = To, i3.validateStyle = wo, i3.values = S2, i3.vectorTile = pg, i3.version = o4, i3.warnOnce = te, i3.webpSupported = Zt, i3.window = f4, i3.wrap = k4;\n              }), n4(["./shared"], function(i3) {\n                "use strict";\n                function a4(Ut) {\n                  var wt = typeof Ut;\n                  if (wt === "number" || wt === "boolean" || wt === "string" || Ut === void 0 || Ut === null) return JSON.stringify(Ut);\n                  if (Array.isArray(Ut)) {\n                    for (var rr = "[", nr = 0, Er = Ut; nr < Er.length; nr += 1) {\n                      var Xr = Er[nr];\n                      rr += a4(Xr) + ",";\n                    }\n                    return rr + "]";\n                  }\n                  for (var ri = Object.keys(Ut).sort(), Qr = "{", Oi = 0; Oi < ri.length; Oi++) Qr += JSON.stringify(ri[Oi]) + ":" + a4(Ut[ri[Oi]]) + ",";\n                  return Qr + "}";\n                }\n                function o4(Ut) {\n                  for (var wt = "", rr = 0, nr = i3.refProperties; rr < nr.length; rr += 1) {\n                    var Er = nr[rr];\n                    wt += "/" + a4(Ut[Er]);\n                  }\n                  return wt;\n                }\n                function s3(Ut, wt) {\n                  for (var rr = {}, nr = 0; nr < Ut.length; nr++) {\n                    var Er = wt && wt[Ut[nr].id] || o4(Ut[nr]);\n                    wt && (wt[Ut[nr].id] = Er);\n                    var Xr = rr[Er];\n                    Xr || (Xr = rr[Er] = []), Xr.push(Ut[nr]);\n                  }\n                  var ri = [];\n                  for (var Qr in rr) ri.push(rr[Qr]);\n                  return ri;\n                }\n                var l3 = function(wt) {\n                  this.keyCache = {}, wt && this.replace(wt);\n                };\n                l3.prototype.replace = function(wt) {\n                  this._layerConfigs = {}, this._layers = {}, this.update(wt, []);\n                }, l3.prototype.update = function(wt, rr) {\n                  for (var nr = this, Er = 0, Xr = wt; Er < Xr.length; Er += 1) {\n                    var ri = Xr[Er];\n                    this._layerConfigs[ri.id] = ri;\n                    var Qr = this._layers[ri.id] = i3.createStyleLayer(ri);\n                    Qr._featureFilter = i3.featureFilter(Qr.filter), this.keyCache[ri.id] && delete this.keyCache[ri.id];\n                  }\n                  for (var Oi = 0, $i = rr; Oi < $i.length; Oi += 1) {\n                    var tn = $i[Oi];\n                    delete this.keyCache[tn], delete this._layerConfigs[tn], delete this._layers[tn];\n                  }\n                  this.familiesBySource = {};\n                  for (var fn = s3(i3.values(this._layerConfigs), this.keyCache), yn = 0, Sn = fn; yn < Sn.length; yn += 1) {\n                    var Ba = Sn[yn], ua = Ba.map(function(Wn) {\n                      return nr._layers[Wn.id];\n                    }), ma = ua[0];\n                    if (ma.visibility !== "none") {\n                      var Wa = ma.source || "", Fa = this.familiesBySource[Wa];\n                      Fa || (Fa = this.familiesBySource[Wa] = {});\n                      var Wo = ma.sourceLayer || "_geojsonTileLayer", da = Fa[Wo];\n                      da || (da = Fa[Wo] = []), da.push(ua);\n                    }\n                  }\n                };\n                var u4 = 1, c5 = function(wt) {\n                  var rr = {}, nr = [];\n                  for (var Er in wt) {\n                    var Xr = wt[Er], ri = rr[Er] = {};\n                    for (var Qr in Xr) {\n                      var Oi = Xr[+Qr];\n                      if (!(!Oi || Oi.bitmap.width === 0 || Oi.bitmap.height === 0)) {\n                        var $i = { x: 0, y: 0, w: Oi.bitmap.width + 2 * u4, h: Oi.bitmap.height + 2 * u4 };\n                        nr.push($i), ri[Qr] = { rect: $i, metrics: Oi.metrics };\n                      }\n                    }\n                  }\n                  var tn = i3.potpack(nr), fn = tn.w, yn = tn.h, Sn = new i3.AlphaImage({ width: fn || 1, height: yn || 1 });\n                  for (var Ba in wt) {\n                    var ua = wt[Ba];\n                    for (var ma in ua) {\n                      var Wa = ua[+ma];\n                      if (!(!Wa || Wa.bitmap.width === 0 || Wa.bitmap.height === 0)) {\n                        var Fa = rr[Ba][ma].rect;\n                        i3.AlphaImage.copy(Wa.bitmap, Sn, { x: 0, y: 0 }, { x: Fa.x + u4, y: Fa.y + u4 }, Wa.bitmap);\n                      }\n                    }\n                  }\n                  this.image = Sn, this.positions = rr;\n                };\n                i3.register("GlyphAtlas", c5);\n                var f4 = function(wt) {\n                  this.tileID = new i3.OverscaledTileID(wt.tileID.overscaledZ, wt.tileID.wrap, wt.tileID.canonical.z, wt.tileID.canonical.x, wt.tileID.canonical.y), this.uid = wt.uid, this.zoom = wt.zoom, this.pixelRatio = wt.pixelRatio, this.tileSize = wt.tileSize, this.source = wt.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = wt.showCollisionBoxes, this.collectResourceTiming = !!wt.collectResourceTiming, this.returnDependencies = !!wt.returnDependencies, this.promoteId = wt.promoteId;\n                };\n                f4.prototype.parse = function(wt, rr, nr, Er, Xr) {\n                  var ri = this;\n                  this.status = "parsing", this.data = wt, this.collisionBoxArray = new i3.CollisionBoxArray();\n                  var Qr = new i3.DictionaryCoder(Object.keys(wt.layers).sort()), Oi = new i3.FeatureIndex(this.tileID, this.promoteId);\n                  Oi.bucketLayerIDs = [];\n                  var $i = {}, tn = { featureIndex: Oi, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, availableImages: nr }, fn = rr.familiesBySource[this.source];\n                  for (var yn in fn) {\n                    var Sn = wt.layers[yn];\n                    if (Sn) {\n                      Sn.version === 1 && i3.warnOnce(\'Vector tile source "\' + this.source + \'" layer "\' + yn + \'" does not use vector tile spec v2 and therefore may have some rendering errors.\');\n                      for (var Ba = Qr.encode(yn), ua = [], ma = 0; ma < Sn.length; ma++) {\n                        var Wa = Sn.feature(ma), Fa = Oi.getId(Wa, yn);\n                        ua.push({ feature: Wa, id: Fa, index: ma, sourceLayerIndex: Ba });\n                      }\n                      for (var Wo = 0, da = fn[yn]; Wo < da.length; Wo += 1) {\n                        var Wn = da[Wo], Ha = Wn[0];\n                        if (!(Ha.minzoom && this.zoom < Math.floor(Ha.minzoom)) && !(Ha.maxzoom && this.zoom >= Ha.maxzoom) && Ha.visibility !== "none") {\n                          h3(Wn, this.zoom, nr);\n                          var vo = $i[Ha.id] = Ha.createBucket({ index: Oi.bucketLayerIDs.length, layers: Wn, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: Ba, sourceID: this.source });\n                          vo.populate(ua, tn, this.tileID.canonical), Oi.bucketLayerIDs.push(Wn.map(function(Li) {\n                            return Li.id;\n                          }));\n                        }\n                      }\n                    }\n                  }\n                  var jn, Mt, kr, Jr, vi = i3.mapObject(tn.glyphDependencies, function(Li) {\n                    return Object.keys(Li).map(Number);\n                  });\n                  Object.keys(vi).length ? Er.send("getGlyphs", { uid: this.uid, stacks: vi }, function(Li, _n) {\n                    jn || (jn = Li, Mt = _n, Mn.call(ri));\n                  }) : Mt = {};\n                  var hn = Object.keys(tn.iconDependencies);\n                  hn.length ? Er.send("getImages", { icons: hn, source: this.source, tileID: this.tileID, type: "icons" }, function(Li, _n) {\n                    jn || (jn = Li, kr = _n, Mn.call(ri));\n                  }) : kr = {};\n                  var An = Object.keys(tn.patternDependencies);\n                  An.length ? Er.send("getImages", { icons: An, source: this.source, tileID: this.tileID, type: "patterns" }, function(Li, _n) {\n                    jn || (jn = Li, Jr = _n, Mn.call(ri));\n                  }) : Jr = {}, Mn.call(this);\n                  function Mn() {\n                    if (jn) return Xr(jn);\n                    if (Mt && kr && Jr) {\n                      var Li = new c5(Mt), _n = new i3.ImageAtlas(kr, Jr);\n                      for (var ya in $i) {\n                        var Jn = $i[ya];\n                        Jn instanceof i3.SymbolBucket ? (h3(Jn.layers, this.zoom, nr), i3.performSymbolLayout(Jn, Mt, Li.positions, kr, _n.iconPositions, this.showCollisionBoxes, this.tileID.canonical)) : Jn.hasPattern && (Jn instanceof i3.LineBucket || Jn instanceof i3.FillBucket || Jn instanceof i3.FillExtrusionBucket) && (h3(Jn.layers, this.zoom, nr), Jn.addFeatures(tn, this.tileID.canonical, _n.patternPositions));\n                      }\n                      this.status = "done", Xr(null, { buckets: i3.values($i).filter(function(Ma) {\n                        return !Ma.isEmpty();\n                      }), featureIndex: Oi, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: Li.image, imageAtlas: _n, glyphMap: this.returnDependencies ? Mt : null, iconMap: this.returnDependencies ? kr : null, glyphPositions: this.returnDependencies ? Li.positions : null });\n                    }\n                  }\n                };\n                function h3(Ut, wt, rr) {\n                  for (var nr = new i3.EvaluationParameters(wt), Er = 0, Xr = Ut; Er < Xr.length; Er += 1) {\n                    var ri = Xr[Er];\n                    ri.recalculate(nr, rr);\n                  }\n                }\n                function d3(Ut, wt) {\n                  var rr = i3.getArrayBuffer(Ut.request, function(nr, Er, Xr, ri) {\n                    nr ? wt(nr) : Er && wt(null, { vectorTile: new i3.vectorTile.VectorTile(new i3.pbf(Er)), rawData: Er, cacheControl: Xr, expires: ri });\n                  });\n                  return function() {\n                    rr.cancel(), wt();\n                  };\n                }\n                var v3 = function(wt, rr, nr, Er) {\n                  this.actor = wt, this.layerIndex = rr, this.availableImages = nr, this.loadVectorData = Er || d3, this.loading = {}, this.loaded = {};\n                };\n                v3.prototype.loadTile = function(wt, rr) {\n                  var nr = this, Er = wt.uid;\n                  this.loading || (this.loading = {});\n                  var Xr = wt && wt.request && wt.request.collectResourceTiming ? new i3.RequestPerformance(wt.request) : false, ri = this.loading[Er] = new f4(wt);\n                  ri.abort = this.loadVectorData(wt, function(Qr, Oi) {\n                    if (delete nr.loading[Er], Qr || !Oi) return ri.status = "done", nr.loaded[Er] = ri, rr(Qr);\n                    var $i = Oi.rawData, tn = {};\n                    Oi.expires && (tn.expires = Oi.expires), Oi.cacheControl && (tn.cacheControl = Oi.cacheControl);\n                    var fn = {};\n                    if (Xr) {\n                      var yn = Xr.finish();\n                      yn && (fn.resourceTiming = JSON.parse(JSON.stringify(yn)));\n                    }\n                    ri.vectorTile = Oi.vectorTile, ri.parse(Oi.vectorTile, nr.layerIndex, nr.availableImages, nr.actor, function(Sn, Ba) {\n                      if (Sn || !Ba) return rr(Sn);\n                      rr(null, i3.extend({ rawTileData: $i.slice(0) }, Ba, tn, fn));\n                    }), nr.loaded = nr.loaded || {}, nr.loaded[Er] = ri;\n                  });\n                }, v3.prototype.reloadTile = function(wt, rr) {\n                  var nr = this, Er = this.loaded, Xr = wt.uid, ri = this;\n                  if (Er && Er[Xr]) {\n                    var Qr = Er[Xr];\n                    Qr.showCollisionBoxes = wt.showCollisionBoxes;\n                    var Oi = function($i, tn) {\n                      var fn = Qr.reloadCallback;\n                      fn && (delete Qr.reloadCallback, Qr.parse(Qr.vectorTile, ri.layerIndex, nr.availableImages, ri.actor, fn)), rr($i, tn);\n                    };\n                    Qr.status === "parsing" ? Qr.reloadCallback = Oi : Qr.status === "done" && (Qr.vectorTile ? Qr.parse(Qr.vectorTile, this.layerIndex, this.availableImages, this.actor, Oi) : Oi());\n                  }\n                }, v3.prototype.abortTile = function(wt, rr) {\n                  var nr = this.loading, Er = wt.uid;\n                  nr && nr[Er] && nr[Er].abort && (nr[Er].abort(), delete nr[Er]), rr();\n                }, v3.prototype.removeTile = function(wt, rr) {\n                  var nr = this.loaded, Er = wt.uid;\n                  nr && nr[Er] && delete nr[Er], rr();\n                };\n                var _2 = i3.window.ImageBitmap, b = function() {\n                  this.loaded = {};\n                };\n                b.prototype.loadTile = function(wt, rr) {\n                  var nr = wt.uid, Er = wt.encoding, Xr = wt.rawImageData, ri = _2 && Xr instanceof _2 ? this.getImageData(Xr) : Xr, Qr = new i3.DEMData(nr, ri, Er);\n                  this.loaded = this.loaded || {}, this.loaded[nr] = Qr, rr(null, Qr);\n                }, b.prototype.getImageData = function(wt) {\n                  (!this.offscreenCanvas || !this.offscreenCanvasContext) && (this.offscreenCanvas = new OffscreenCanvas(wt.width, wt.height), this.offscreenCanvasContext = this.offscreenCanvas.getContext("2d")), this.offscreenCanvas.width = wt.width, this.offscreenCanvas.height = wt.height, this.offscreenCanvasContext.drawImage(wt, 0, 0, wt.width, wt.height);\n                  var rr = this.offscreenCanvasContext.getImageData(-1, -1, wt.width + 2, wt.height + 2);\n                  return this.offscreenCanvasContext.clearRect(0, 0, this.offscreenCanvas.width, this.offscreenCanvas.height), new i3.RGBAImage({ width: rr.width, height: rr.height }, rr.data);\n                }, b.prototype.removeTile = function(wt) {\n                  var rr = this.loaded, nr = wt.uid;\n                  rr && rr[nr] && delete rr[nr];\n                };\n                var p3 = k4;\n                function k4(Ut, wt) {\n                  var rr = Ut && Ut.type, nr;\n                  if (rr === "FeatureCollection") for (nr = 0; nr < Ut.features.length; nr++) k4(Ut.features[nr], wt);\n                  else if (rr === "GeometryCollection") for (nr = 0; nr < Ut.geometries.length; nr++) k4(Ut.geometries[nr], wt);\n                  else if (rr === "Feature") k4(Ut.geometry, wt);\n                  else if (rr === "Polygon") E3(Ut.coordinates, wt);\n                  else if (rr === "MultiPolygon") for (nr = 0; nr < Ut.coordinates.length; nr++) E3(Ut.coordinates[nr], wt);\n                  return Ut;\n                }\n                function E3(Ut, wt) {\n                  if (Ut.length !== 0) {\n                    S2(Ut[0], wt);\n                    for (var rr = 1; rr < Ut.length; rr++) S2(Ut[rr], !wt);\n                  }\n                }\n                function S2(Ut, wt) {\n                  for (var rr = 0, nr = 0, Er = Ut.length, Xr = Er - 1; nr < Er; Xr = nr++) rr += (Ut[nr][0] - Ut[Xr][0]) * (Ut[Xr][1] + Ut[nr][1]);\n                  rr >= 0 != !!wt && Ut.reverse();\n                }\n                var L3 = i3.vectorTile.VectorTileFeature.prototype.toGeoJSON, x2 = function(wt) {\n                  this._feature = wt, this.extent = i3.EXTENT, this.type = wt.type, this.properties = wt.tags, "id" in wt && !isNaN(wt.id) && (this.id = parseInt(wt.id, 10));\n                };\n                x2.prototype.loadGeometry = function() {\n                  if (this._feature.type === 1) {\n                    for (var wt = [], rr = 0, nr = this._feature.geometry; rr < nr.length; rr += 1) {\n                      var Er = nr[rr];\n                      wt.push([new i3.Point$1(Er[0], Er[1])]);\n                    }\n                    return wt;\n                  } else {\n                    for (var Xr = [], ri = 0, Qr = this._feature.geometry; ri < Qr.length; ri += 1) {\n                      for (var Oi = Qr[ri], $i = [], tn = 0, fn = Oi; tn < fn.length; tn += 1) {\n                        var yn = fn[tn];\n                        $i.push(new i3.Point$1(yn[0], yn[1]));\n                      }\n                      Xr.push($i);\n                    }\n                    return Xr;\n                  }\n                }, x2.prototype.toGeoJSON = function(wt, rr, nr) {\n                  return L3.call(this, wt, rr, nr);\n                };\n                var C3 = function(wt) {\n                  this.layers = { _geojsonTileLayer: this }, this.name = "_geojsonTileLayer", this.extent = i3.EXTENT, this.length = wt.length, this._features = wt;\n                };\n                C3.prototype.feature = function(wt) {\n                  return new x2(this._features[wt]);\n                };\n                var M4 = i3.vectorTile.VectorTileFeature, g3 = P3;\n                function P3(Ut, wt) {\n                  this.options = wt || {}, this.features = Ut, this.length = Ut.length;\n                }\n                P3.prototype.feature = function(Ut) {\n                  return new T3(this.features[Ut], this.options.extent);\n                };\n                function T3(Ut, wt) {\n                  this.id = typeof Ut.id == "number" ? Ut.id : void 0, this.type = Ut.type, this.rawGeometry = Ut.type === 1 ? [Ut.geometry] : Ut.geometry, this.properties = Ut.tags, this.extent = wt || 4096;\n                }\n                T3.prototype.loadGeometry = function() {\n                  var Ut = this.rawGeometry;\n                  this.geometry = [];\n                  for (var wt = 0; wt < Ut.length; wt++) {\n                    for (var rr = Ut[wt], nr = [], Er = 0; Er < rr.length; Er++) nr.push(new i3.Point$1(rr[Er][0], rr[Er][1]));\n                    this.geometry.push(nr);\n                  }\n                  return this.geometry;\n                }, T3.prototype.bbox = function() {\n                  this.geometry || this.loadGeometry();\n                  for (var Ut = this.geometry, wt = 1 / 0, rr = -1 / 0, nr = 1 / 0, Er = -1 / 0, Xr = 0; Xr < Ut.length; Xr++) for (var ri = Ut[Xr], Qr = 0; Qr < ri.length; Qr++) {\n                    var Oi = ri[Qr];\n                    wt = Math.min(wt, Oi.x), rr = Math.max(rr, Oi.x), nr = Math.min(nr, Oi.y), Er = Math.max(Er, Oi.y);\n                  }\n                  return [wt, nr, rr, Er];\n                }, T3.prototype.toGeoJSON = M4.prototype.toGeoJSON;\n                var z3 = Z, O3 = Z, V2 = j3, G2 = g3;\n                function Z(Ut) {\n                  var wt = new i3.pbf();\n                  return N2(Ut, wt), wt.finish();\n                }\n                function j3(Ut, wt) {\n                  wt = wt || {};\n                  var rr = {};\n                  for (var nr in Ut) rr[nr] = new g3(Ut[nr].features, wt), rr[nr].name = nr, rr[nr].version = wt.version, rr[nr].extent = wt.extent;\n                  return Z({ layers: rr });\n                }\n                function N2(Ut, wt) {\n                  for (var rr in Ut.layers) wt.writeMessage(3, H, Ut.layers[rr]);\n                }\n                function H(Ut, wt) {\n                  wt.writeVarintField(15, Ut.version || 1), wt.writeStringField(1, Ut.name || ""), wt.writeVarintField(5, Ut.extent || 4096);\n                  var rr, nr = { keys: [], values: [], keycache: {}, valuecache: {} };\n                  for (rr = 0; rr < Ut.length; rr++) nr.feature = Ut.feature(rr), wt.writeMessage(2, te, nr);\n                  var Er = nr.keys;\n                  for (rr = 0; rr < Er.length; rr++) wt.writeStringField(3, Er[rr]);\n                  var Xr = nr.values;\n                  for (rr = 0; rr < Xr.length; rr++) wt.writeMessage(4, me, Xr[rr]);\n                }\n                function te(Ut, wt) {\n                  var rr = Ut.feature;\n                  rr.id !== void 0 && wt.writeVarintField(1, rr.id), wt.writeMessage(2, oe, Ut), wt.writeVarintField(3, rr.type), wt.writeMessage(4, Ce, rr);\n                }\n                function oe(Ut, wt) {\n                  var rr = Ut.feature, nr = Ut.keys, Er = Ut.values, Xr = Ut.keycache, ri = Ut.valuecache;\n                  for (var Qr in rr.properties) {\n                    var Oi = Xr[Qr];\n                    typeof Oi == "undefined" && (nr.push(Qr), Oi = nr.length - 1, Xr[Qr] = Oi), wt.writeVarint(Oi);\n                    var $i = rr.properties[Qr], tn = typeof $i;\n                    tn !== "string" && tn !== "boolean" && tn !== "number" && ($i = JSON.stringify($i));\n                    var fn = tn + ":" + $i, yn = ri[fn];\n                    typeof yn == "undefined" && (Er.push($i), yn = Er.length - 1, ri[fn] = yn), wt.writeVarint(yn);\n                  }\n                }\n                function _e(Ut, wt) {\n                  return (wt << 3) + (Ut & 7);\n                }\n                function Ee(Ut) {\n                  return Ut << 1 ^ Ut >> 31;\n                }\n                function Ce(Ut, wt) {\n                  for (var rr = Ut.loadGeometry(), nr = Ut.type, Er = 0, Xr = 0, ri = rr.length, Qr = 0; Qr < ri; Qr++) {\n                    var Oi = rr[Qr], $i = 1;\n                    nr === 1 && ($i = Oi.length), wt.writeVarint(_e(1, $i));\n                    for (var tn = nr === 3 ? Oi.length - 1 : Oi.length, fn = 0; fn < tn; fn++) {\n                      fn === 1 && nr !== 1 && wt.writeVarint(_e(2, tn - 1));\n                      var yn = Oi[fn].x - Er, Sn = Oi[fn].y - Xr;\n                      wt.writeVarint(Ee(yn)), wt.writeVarint(Ee(Sn)), Er += yn, Xr += Sn;\n                    }\n                    nr === 3 && wt.writeVarint(_e(7, 1));\n                  }\n                }\n                function me(Ut, wt) {\n                  var rr = typeof Ut;\n                  rr === "string" ? wt.writeStringField(1, Ut) : rr === "boolean" ? wt.writeBooleanField(7, Ut) : rr === "number" && (Ut % 1 !== 0 ? wt.writeDoubleField(3, Ut) : Ut < 0 ? wt.writeSVarintField(6, Ut) : wt.writeVarintField(5, Ut));\n                }\n                z3.fromVectorTileJs = O3, z3.fromGeojsonVt = V2, z3.GeoJSONWrapper = G2;\n                function ie(Ut, wt, rr, nr, Er, Xr) {\n                  if (!(Er - nr <= rr)) {\n                    var ri = nr + Er >> 1;\n                    Se(Ut, wt, ri, nr, Er, Xr % 2), ie(Ut, wt, rr, nr, ri - 1, Xr + 1), ie(Ut, wt, rr, ri + 1, Er, Xr + 1);\n                  }\n                }\n                function Se(Ut, wt, rr, nr, Er, Xr) {\n                  for (; Er > nr; ) {\n                    if (Er - nr > 600) {\n                      var ri = Er - nr + 1, Qr = rr - nr + 1, Oi = Math.log(ri), $i = 0.5 * Math.exp(2 * Oi / 3), tn = 0.5 * Math.sqrt(Oi * $i * (ri - $i) / ri) * (Qr - ri / 2 < 0 ? -1 : 1), fn = Math.max(nr, Math.floor(rr - Qr * $i / ri + tn)), yn = Math.min(Er, Math.floor(rr + (ri - Qr) * $i / ri + tn));\n                      Se(Ut, wt, rr, fn, yn, Xr);\n                    }\n                    var Sn = wt[2 * rr + Xr], Ba = nr, ua = Er;\n                    for (Le(Ut, wt, nr, rr), wt[2 * Er + Xr] > Sn && Le(Ut, wt, nr, Er); Ba < ua; ) {\n                      for (Le(Ut, wt, Ba, ua), Ba++, ua--; wt[2 * Ba + Xr] < Sn; ) Ba++;\n                      for (; wt[2 * ua + Xr] > Sn; ) ua--;\n                    }\n                    wt[2 * nr + Xr] === Sn ? Le(Ut, wt, nr, ua) : (ua++, Le(Ut, wt, ua, Er)), ua <= rr && (nr = ua + 1), rr <= ua && (Er = ua - 1);\n                  }\n                }\n                function Le(Ut, wt, rr, nr) {\n                  Ae(Ut, rr, nr), Ae(wt, 2 * rr, 2 * nr), Ae(wt, 2 * rr + 1, 2 * nr + 1);\n                }\n                function Ae(Ut, wt, rr) {\n                  var nr = Ut[wt];\n                  Ut[wt] = Ut[rr], Ut[rr] = nr;\n                }\n                function Fe(Ut, wt, rr, nr, Er, Xr, ri) {\n                  for (var Qr = [0, Ut.length - 1, 0], Oi = [], $i, tn; Qr.length; ) {\n                    var fn = Qr.pop(), yn = Qr.pop(), Sn = Qr.pop();\n                    if (yn - Sn <= ri) {\n                      for (var Ba = Sn; Ba <= yn; Ba++) $i = wt[2 * Ba], tn = wt[2 * Ba + 1], $i >= rr && $i <= Er && tn >= nr && tn <= Xr && Oi.push(Ut[Ba]);\n                      continue;\n                    }\n                    var ua = Math.floor((Sn + yn) / 2);\n                    $i = wt[2 * ua], tn = wt[2 * ua + 1], $i >= rr && $i <= Er && tn >= nr && tn <= Xr && Oi.push(Ut[ua]);\n                    var ma = (fn + 1) % 2;\n                    (fn === 0 ? rr <= $i : nr <= tn) && (Qr.push(Sn), Qr.push(ua - 1), Qr.push(ma)), (fn === 0 ? Er >= $i : Xr >= tn) && (Qr.push(ua + 1), Qr.push(yn), Qr.push(ma));\n                  }\n                  return Oi;\n                }\n                function Pe(Ut, wt, rr, nr, Er, Xr) {\n                  for (var ri = [0, Ut.length - 1, 0], Qr = [], Oi = Er * Er; ri.length; ) {\n                    var $i = ri.pop(), tn = ri.pop(), fn = ri.pop();\n                    if (tn - fn <= Xr) {\n                      for (var yn = fn; yn <= tn; yn++) ge(wt[2 * yn], wt[2 * yn + 1], rr, nr) <= Oi && Qr.push(Ut[yn]);\n                      continue;\n                    }\n                    var Sn = Math.floor((fn + tn) / 2), Ba = wt[2 * Sn], ua = wt[2 * Sn + 1];\n                    ge(Ba, ua, rr, nr) <= Oi && Qr.push(Ut[Sn]);\n                    var ma = ($i + 1) % 2;\n                    ($i === 0 ? rr - Er <= Ba : nr - Er <= ua) && (ri.push(fn), ri.push(Sn - 1), ri.push(ma)), ($i === 0 ? rr + Er >= Ba : nr + Er >= ua) && (ri.push(Sn + 1), ri.push(tn), ri.push(ma));\n                  }\n                  return Qr;\n                }\n                function ge(Ut, wt, rr, nr) {\n                  var Er = Ut - rr, Xr = wt - nr;\n                  return Er * Er + Xr * Xr;\n                }\n                var Re = function(Ut) {\n                  return Ut[0];\n                }, ce = function(Ut) {\n                  return Ut[1];\n                }, Ze = function(wt, rr, nr, Er, Xr) {\n                  rr === void 0 && (rr = Re), nr === void 0 && (nr = ce), Er === void 0 && (Er = 64), Xr === void 0 && (Xr = Float64Array), this.nodeSize = Er, this.points = wt;\n                  for (var ri = wt.length < 65536 ? Uint16Array : Uint32Array, Qr = this.ids = new ri(wt.length), Oi = this.coords = new Xr(wt.length * 2), $i = 0; $i < wt.length; $i++) Qr[$i] = $i, Oi[2 * $i] = rr(wt[$i]), Oi[2 * $i + 1] = nr(wt[$i]);\n                  ie(Qr, Oi, Er, 0, Qr.length - 1, 0);\n                };\n                Ze.prototype.range = function(wt, rr, nr, Er) {\n                  return Fe(this.ids, this.coords, wt, rr, nr, Er, this.nodeSize);\n                }, Ze.prototype.within = function(wt, rr, nr) {\n                  return Pe(this.ids, this.coords, wt, rr, nr, this.nodeSize);\n                };\n                var ut = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: function(Ut) {\n                  return Ut;\n                } }, pt = function(wt) {\n                  this.options = cr(Object.create(ut), wt), this.trees = new Array(this.options.maxZoom + 1);\n                };\n                pt.prototype.load = function(wt) {\n                  var rr = this.options, nr = rr.log, Er = rr.minZoom, Xr = rr.maxZoom, ri = rr.nodeSize;\n                  nr && console.time("total time");\n                  var Qr = "prepare " + wt.length + " points";\n                  nr && console.time(Qr), this.points = wt;\n                  for (var Oi = [], $i = 0; $i < wt.length; $i++) wt[$i].geometry && Oi.push(st(wt[$i], $i));\n                  this.trees[Xr + 1] = new Ze(Oi, $e, St, ri, Float32Array), nr && console.timeEnd(Qr);\n                  for (var tn = Xr; tn >= Er; tn--) {\n                    var fn = +Date.now();\n                    Oi = this._cluster(Oi, tn), this.trees[tn] = new Ze(Oi, $e, St, ri, Float32Array), nr && console.log("z%d: %d clusters in %dms", tn, Oi.length, +Date.now() - fn);\n                  }\n                  return nr && console.timeEnd("total time"), this;\n                }, pt.prototype.getClusters = function(wt, rr) {\n                  var nr = ((wt[0] + 180) % 360 + 360) % 360 - 180, Er = Math.max(-90, Math.min(90, wt[1])), Xr = wt[2] === 180 ? 180 : ((wt[2] + 180) % 360 + 360) % 360 - 180, ri = Math.max(-90, Math.min(90, wt[3]));\n                  if (wt[2] - wt[0] >= 360) nr = -180, Xr = 180;\n                  else if (nr > Xr) {\n                    var Qr = this.getClusters([nr, Er, 180, ri], rr), Oi = this.getClusters([-180, Er, Xr, ri], rr);\n                    return Qr.concat(Oi);\n                  }\n                  for (var $i = this.trees[this._limitZoom(rr)], tn = $i.range(Nt(nr), Jt(ri), Nt(Xr), Jt(Er)), fn = [], yn = 0, Sn = tn; yn < Sn.length; yn += 1) {\n                    var Ba = Sn[yn], ua = $i.points[Ba];\n                    fn.push(ua.numPoints ? lt(ua) : this.points[ua.index]);\n                  }\n                  return fn;\n                }, pt.prototype.getChildren = function(wt) {\n                  var rr = this._getOriginId(wt), nr = this._getOriginZoom(wt), Er = "No cluster with the specified id.", Xr = this.trees[nr];\n                  if (!Xr) throw new Error(Er);\n                  var ri = Xr.points[rr];\n                  if (!ri) throw new Error(Er);\n                  for (var Qr = this.options.radius / (this.options.extent * Math.pow(2, nr - 1)), Oi = Xr.within(ri.x, ri.y, Qr), $i = [], tn = 0, fn = Oi; tn < fn.length; tn += 1) {\n                    var yn = fn[tn], Sn = Xr.points[yn];\n                    Sn.parentId === wt && $i.push(Sn.numPoints ? lt(Sn) : this.points[Sn.index]);\n                  }\n                  if ($i.length === 0) throw new Error(Er);\n                  return $i;\n                }, pt.prototype.getLeaves = function(wt, rr, nr) {\n                  rr = rr || 10, nr = nr || 0;\n                  var Er = [];\n                  return this._appendLeaves(Er, wt, rr, nr, 0), Er;\n                }, pt.prototype.getTile = function(wt, rr, nr) {\n                  var Er = this.trees[this._limitZoom(wt)], Xr = Math.pow(2, wt), ri = this.options, Qr = ri.extent, Oi = ri.radius, $i = Oi / Qr, tn = (nr - $i) / Xr, fn = (nr + 1 + $i) / Xr, yn = { features: [] };\n                  return this._addTileFeatures(Er.range((rr - $i) / Xr, tn, (rr + 1 + $i) / Xr, fn), Er.points, rr, nr, Xr, yn), rr === 0 && this._addTileFeatures(Er.range(1 - $i / Xr, tn, 1, fn), Er.points, Xr, nr, Xr, yn), rr === Xr - 1 && this._addTileFeatures(Er.range(0, tn, $i / Xr, fn), Er.points, -1, nr, Xr, yn), yn.features.length ? yn : null;\n                }, pt.prototype.getClusterExpansionZoom = function(wt) {\n                  for (var rr = this._getOriginZoom(wt) - 1; rr <= this.options.maxZoom; ) {\n                    var nr = this.getChildren(wt);\n                    if (rr++, nr.length !== 1) break;\n                    wt = nr[0].properties.cluster_id;\n                  }\n                  return rr;\n                }, pt.prototype._appendLeaves = function(wt, rr, nr, Er, Xr) {\n                  for (var ri = this.getChildren(rr), Qr = 0, Oi = ri; Qr < Oi.length; Qr += 1) {\n                    var $i = Oi[Qr], tn = $i.properties;\n                    if (tn && tn.cluster ? Xr + tn.point_count <= Er ? Xr += tn.point_count : Xr = this._appendLeaves(wt, tn.cluster_id, nr, Er, Xr) : Xr < Er ? Xr++ : wt.push($i), wt.length === nr) break;\n                  }\n                  return Xr;\n                }, pt.prototype._addTileFeatures = function(wt, rr, nr, Er, Xr, ri) {\n                  for (var Qr = 0, Oi = wt; Qr < Oi.length; Qr += 1) {\n                    var $i = Oi[Qr], tn = rr[$i], fn = tn.numPoints, yn = { type: 1, geometry: [[Math.round(this.options.extent * (tn.x * Xr - nr)), Math.round(this.options.extent * (tn.y * Xr - Er))]], tags: fn ? Gt(tn) : this.points[tn.index].properties }, Sn = void 0;\n                    fn ? Sn = tn.id : this.options.generateId ? Sn = tn.index : this.points[tn.index].id && (Sn = this.points[tn.index].id), Sn !== void 0 && (yn.id = Sn), ri.features.push(yn);\n                  }\n                }, pt.prototype._limitZoom = function(wt) {\n                  return Math.max(this.options.minZoom, Math.min(+wt, this.options.maxZoom + 1));\n                }, pt.prototype._cluster = function(wt, rr) {\n                  for (var nr = [], Er = this.options, Xr = Er.radius, ri = Er.extent, Qr = Er.reduce, Oi = Er.minPoints, $i = Xr / (ri * Math.pow(2, rr)), tn = 0; tn < wt.length; tn++) {\n                    var fn = wt[tn];\n                    if (!(fn.zoom <= rr)) {\n                      fn.zoom = rr;\n                      for (var yn = this.trees[rr + 1], Sn = yn.within(fn.x, fn.y, $i), Ba = fn.numPoints || 1, ua = Ba, ma = 0, Wa = Sn; ma < Wa.length; ma += 1) {\n                        var Fa = Wa[ma], Wo = yn.points[Fa];\n                        Wo.zoom > rr && (ua += Wo.numPoints || 1);\n                      }\n                      if (ua >= Oi) {\n                        for (var da = fn.x * Ba, Wn = fn.y * Ba, Ha = Qr && Ba > 1 ? this._map(fn, true) : null, vo = (tn << 5) + (rr + 1) + this.points.length, jn = 0, Mt = Sn; jn < Mt.length; jn += 1) {\n                          var kr = Mt[jn], Jr = yn.points[kr];\n                          if (!(Jr.zoom <= rr)) {\n                            Jr.zoom = rr;\n                            var vi = Jr.numPoints || 1;\n                            da += Jr.x * vi, Wn += Jr.y * vi, Jr.parentId = vo, Qr && (Ha || (Ha = this._map(fn, true)), Qr(Ha, this._map(Jr)));\n                          }\n                        }\n                        fn.parentId = vo, nr.push(Zt(da / ua, Wn / ua, vo, ua, Ha));\n                      } else if (nr.push(fn), ua > 1) for (var hn = 0, An = Sn; hn < An.length; hn += 1) {\n                        var Mn = An[hn], Li = yn.points[Mn];\n                        Li.zoom <= rr || (Li.zoom = rr, nr.push(Li));\n                      }\n                    }\n                  }\n                  return nr;\n                }, pt.prototype._getOriginId = function(wt) {\n                  return wt - this.points.length >> 5;\n                }, pt.prototype._getOriginZoom = function(wt) {\n                  return (wt - this.points.length) % 32;\n                }, pt.prototype._map = function(wt, rr) {\n                  if (wt.numPoints) return rr ? cr({}, wt.properties) : wt.properties;\n                  var nr = this.points[wt.index].properties, Er = this.options.map(nr);\n                  return rr && Er === nr ? cr({}, Er) : Er;\n                };\n                function Zt(Ut, wt, rr, nr, Er) {\n                  return { x: Ut, y: wt, zoom: 1 / 0, id: rr, parentId: -1, numPoints: nr, properties: Er };\n                }\n                function st(Ut, wt) {\n                  var rr = Ut.geometry.coordinates, nr = rr[0], Er = rr[1];\n                  return { x: Nt(nr), y: Jt(Er), zoom: 1 / 0, index: wt, parentId: -1 };\n                }\n                function lt(Ut) {\n                  return { type: "Feature", id: Ut.id, properties: Gt(Ut), geometry: { type: "Point", coordinates: [sr(Ut.x), wr(Ut.y)] } };\n                }\n                function Gt(Ut) {\n                  var wt = Ut.numPoints, rr = wt >= 1e4 ? Math.round(wt / 1e3) + "k" : wt >= 1e3 ? Math.round(wt / 100) / 10 + "k" : wt;\n                  return cr(cr({}, Ut.properties), { cluster: true, cluster_id: Ut.id, point_count: wt, point_count_abbreviated: rr });\n                }\n                function Nt(Ut) {\n                  return Ut / 360 + 0.5;\n                }\n                function Jt(Ut) {\n                  var wt = Math.sin(Ut * Math.PI / 180), rr = 0.5 - 0.25 * Math.log((1 + wt) / (1 - wt)) / Math.PI;\n                  return rr < 0 ? 0 : rr > 1 ? 1 : rr;\n                }\n                function sr(Ut) {\n                  return (Ut - 0.5) * 360;\n                }\n                function wr(Ut) {\n                  var wt = (180 - Ut * 360) * Math.PI / 180;\n                  return 360 * Math.atan(Math.exp(wt)) / Math.PI - 90;\n                }\n                function cr(Ut, wt) {\n                  for (var rr in wt) Ut[rr] = wt[rr];\n                  return Ut;\n                }\n                function $e(Ut) {\n                  return Ut.x;\n                }\n                function St(Ut) {\n                  return Ut.y;\n                }\n                function Qt(Ut, wt, rr, nr) {\n                  for (var Er = nr, Xr = rr - wt >> 1, ri = rr - wt, Qr, Oi = Ut[wt], $i = Ut[wt + 1], tn = Ut[rr], fn = Ut[rr + 1], yn = wt + 3; yn < rr; yn += 3) {\n                    var Sn = Vt(Ut[yn], Ut[yn + 1], Oi, $i, tn, fn);\n                    if (Sn > Er) Qr = yn, Er = Sn;\n                    else if (Sn === Er) {\n                      var Ba = Math.abs(yn - Xr);\n                      Ba < ri && (Qr = yn, ri = Ba);\n                    }\n                  }\n                  Er > nr && (Qr - wt > 3 && Qt(Ut, wt, Qr, nr), Ut[Qr + 2] = Er, rr - Qr > 3 && Qt(Ut, Qr, rr, nr));\n                }\n                function Vt(Ut, wt, rr, nr, Er, Xr) {\n                  var ri = Er - rr, Qr = Xr - nr;\n                  if (ri !== 0 || Qr !== 0) {\n                    var Oi = ((Ut - rr) * ri + (wt - nr) * Qr) / (ri * ri + Qr * Qr);\n                    Oi > 1 ? (rr = Er, nr = Xr) : Oi > 0 && (rr += ri * Oi, nr += Qr * Oi);\n                  }\n                  return ri = Ut - rr, Qr = wt - nr, ri * ri + Qr * Qr;\n                }\n                function _t(Ut, wt, rr, nr) {\n                  var Er = { id: typeof Ut == "undefined" ? null : Ut, type: wt, geometry: rr, tags: nr, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };\n                  return It(Er), Er;\n                }\n                function It(Ut) {\n                  var wt = Ut.geometry, rr = Ut.type;\n                  if (rr === "Point" || rr === "MultiPoint" || rr === "LineString") mt(Ut, wt);\n                  else if (rr === "Polygon" || rr === "MultiLineString") for (var nr = 0; nr < wt.length; nr++) mt(Ut, wt[nr]);\n                  else if (rr === "MultiPolygon") for (nr = 0; nr < wt.length; nr++) for (var Er = 0; Er < wt[nr].length; Er++) mt(Ut, wt[nr][Er]);\n                }\n                function mt(Ut, wt) {\n                  for (var rr = 0; rr < wt.length; rr += 3) Ut.minX = Math.min(Ut.minX, wt[rr]), Ut.minY = Math.min(Ut.minY, wt[rr + 1]), Ut.maxX = Math.max(Ut.maxX, wt[rr]), Ut.maxY = Math.max(Ut.maxY, wt[rr + 1]);\n                }\n                function er(Ut, wt) {\n                  var rr = [];\n                  if (Ut.type === "FeatureCollection") for (var nr = 0; nr < Ut.features.length; nr++) lr(rr, Ut.features[nr], wt, nr);\n                  else Ut.type === "Feature" ? lr(rr, Ut, wt) : lr(rr, { geometry: Ut }, wt);\n                  return rr;\n                }\n                function lr(Ut, wt, rr, nr) {\n                  if (wt.geometry) {\n                    var Er = wt.geometry.coordinates, Xr = wt.geometry.type, ri = Math.pow(rr.tolerance / ((1 << rr.maxZoom) * rr.extent), 2), Qr = [], Oi = wt.id;\n                    if (rr.promoteId ? Oi = wt.properties[rr.promoteId] : rr.generateId && (Oi = nr || 0), Xr === "Point") Tr(Er, Qr);\n                    else if (Xr === "MultiPoint") for (var $i = 0; $i < Er.length; $i++) Tr(Er[$i], Qr);\n                    else if (Xr === "LineString") Lr(Er, Qr, ri, false);\n                    else if (Xr === "MultiLineString") if (rr.lineMetrics) {\n                      for ($i = 0; $i < Er.length; $i++) Qr = [], Lr(Er[$i], Qr, ri, false), Ut.push(_t(Oi, "LineString", Qr, wt.properties));\n                      return;\n                    } else ti(Er, Qr, ri, false);\n                    else if (Xr === "Polygon") ti(Er, Qr, ri, true);\n                    else if (Xr === "MultiPolygon") for ($i = 0; $i < Er.length; $i++) {\n                      var tn = [];\n                      ti(Er[$i], tn, ri, true), Qr.push(tn);\n                    }\n                    else if (Xr === "GeometryCollection") {\n                      for ($i = 0; $i < wt.geometry.geometries.length; $i++) lr(Ut, { id: Oi, geometry: wt.geometry.geometries[$i], properties: wt.properties }, rr, nr);\n                      return;\n                    } else throw new Error("Input data is not a valid GeoJSON object.");\n                    Ut.push(_t(Oi, Xr, Qr, wt.properties));\n                  }\n                }\n                function Tr(Ut, wt) {\n                  wt.push(Br(Ut[0])), wt.push(Vr(Ut[1])), wt.push(0);\n                }\n                function Lr(Ut, wt, rr, nr) {\n                  for (var Er, Xr, ri = 0, Qr = 0; Qr < Ut.length; Qr++) {\n                    var Oi = Br(Ut[Qr][0]), $i = Vr(Ut[Qr][1]);\n                    wt.push(Oi), wt.push($i), wt.push(0), Qr > 0 && (nr ? ri += (Er * $i - Oi * Xr) / 2 : ri += Math.sqrt(Math.pow(Oi - Er, 2) + Math.pow($i - Xr, 2))), Er = Oi, Xr = $i;\n                  }\n                  var tn = wt.length - 3;\n                  wt[2] = 1, Qt(wt, 0, tn, rr), wt[tn + 2] = 1, wt.size = Math.abs(ri), wt.start = 0, wt.end = wt.size;\n                }\n                function ti(Ut, wt, rr, nr) {\n                  for (var Er = 0; Er < Ut.length; Er++) {\n                    var Xr = [];\n                    Lr(Ut[Er], Xr, rr, nr), wt.push(Xr);\n                  }\n                }\n                function Br(Ut) {\n                  return Ut / 360 + 0.5;\n                }\n                function Vr(Ut) {\n                  var wt = Math.sin(Ut * Math.PI / 180), rr = 0.5 - 0.25 * Math.log((1 + wt) / (1 - wt)) / Math.PI;\n                  return rr < 0 ? 0 : rr > 1 ? 1 : rr;\n                }\n                function dt(Ut, wt, rr, nr, Er, Xr, ri, Qr) {\n                  if (rr /= wt, nr /= wt, Xr >= rr && ri < nr) return Ut;\n                  if (ri < rr || Xr >= nr) return null;\n                  for (var Oi = [], $i = 0; $i < Ut.length; $i++) {\n                    var tn = Ut[$i], fn = tn.geometry, yn = tn.type, Sn = Er === 0 ? tn.minX : tn.minY, Ba = Er === 0 ? tn.maxX : tn.maxY;\n                    if (Sn >= rr && Ba < nr) {\n                      Oi.push(tn);\n                      continue;\n                    } else if (Ba < rr || Sn >= nr) continue;\n                    var ua = [];\n                    if (yn === "Point" || yn === "MultiPoint") Ge(fn, ua, rr, nr, Er);\n                    else if (yn === "LineString") Je(fn, ua, rr, nr, Er, false, Qr.lineMetrics);\n                    else if (yn === "MultiLineString") tt(fn, ua, rr, nr, Er, false);\n                    else if (yn === "Polygon") tt(fn, ua, rr, nr, Er, true);\n                    else if (yn === "MultiPolygon") for (var ma = 0; ma < fn.length; ma++) {\n                      var Wa = [];\n                      tt(fn[ma], Wa, rr, nr, Er, true), Wa.length && ua.push(Wa);\n                    }\n                    if (ua.length) {\n                      if (Qr.lineMetrics && yn === "LineString") {\n                        for (ma = 0; ma < ua.length; ma++) Oi.push(_t(tn.id, yn, ua[ma], tn.tags));\n                        continue;\n                      }\n                      (yn === "LineString" || yn === "MultiLineString") && (ua.length === 1 ? (yn = "LineString", ua = ua[0]) : yn = "MultiLineString"), (yn === "Point" || yn === "MultiPoint") && (yn = ua.length === 3 ? "Point" : "MultiPoint"), Oi.push(_t(tn.id, yn, ua, tn.tags));\n                    }\n                  }\n                  return Oi.length ? Oi : null;\n                }\n                function Ge(Ut, wt, rr, nr, Er) {\n                  for (var Xr = 0; Xr < Ut.length; Xr += 3) {\n                    var ri = Ut[Xr + Er];\n                    ri >= rr && ri <= nr && (wt.push(Ut[Xr]), wt.push(Ut[Xr + 1]), wt.push(Ut[Xr + 2]));\n                  }\n                }\n                function Je(Ut, wt, rr, nr, Er, Xr, ri) {\n                  for (var Qr = je(Ut), Oi = Er === 0 ? Ie : xe, $i = Ut.start, tn, fn, yn = 0; yn < Ut.length - 3; yn += 3) {\n                    var Sn = Ut[yn], Ba = Ut[yn + 1], ua = Ut[yn + 2], ma = Ut[yn + 3], Wa = Ut[yn + 4], Fa = Er === 0 ? Sn : Ba, Wo = Er === 0 ? ma : Wa, da = false;\n                    ri && (tn = Math.sqrt(Math.pow(Sn - ma, 2) + Math.pow(Ba - Wa, 2))), Fa < rr ? Wo > rr && (fn = Oi(Qr, Sn, Ba, ma, Wa, rr), ri && (Qr.start = $i + tn * fn)) : Fa > nr ? Wo < nr && (fn = Oi(Qr, Sn, Ba, ma, Wa, nr), ri && (Qr.start = $i + tn * fn)) : xt(Qr, Sn, Ba, ua), Wo < rr && Fa >= rr && (fn = Oi(Qr, Sn, Ba, ma, Wa, rr), da = true), Wo > nr && Fa <= nr && (fn = Oi(Qr, Sn, Ba, ma, Wa, nr), da = true), !Xr && da && (ri && (Qr.end = $i + tn * fn), wt.push(Qr), Qr = je(Ut)), ri && ($i += tn);\n                  }\n                  var Wn = Ut.length - 3;\n                  Sn = Ut[Wn], Ba = Ut[Wn + 1], ua = Ut[Wn + 2], Fa = Er === 0 ? Sn : Ba, Fa >= rr && Fa <= nr && xt(Qr, Sn, Ba, ua), Wn = Qr.length - 3, Xr && Wn >= 3 && (Qr[Wn] !== Qr[0] || Qr[Wn + 1] !== Qr[1]) && xt(Qr, Qr[0], Qr[1], Qr[2]), Qr.length && wt.push(Qr);\n                }\n                function je(Ut) {\n                  var wt = [];\n                  return wt.size = Ut.size, wt.start = Ut.start, wt.end = Ut.end, wt;\n                }\n                function tt(Ut, wt, rr, nr, Er, Xr) {\n                  for (var ri = 0; ri < Ut.length; ri++) Je(Ut[ri], wt, rr, nr, Er, Xr, false);\n                }\n                function xt(Ut, wt, rr, nr) {\n                  Ut.push(wt), Ut.push(rr), Ut.push(nr);\n                }\n                function Ie(Ut, wt, rr, nr, Er, Xr) {\n                  var ri = (Xr - wt) / (nr - wt);\n                  return Ut.push(Xr), Ut.push(rr + (Er - rr) * ri), Ut.push(1), ri;\n                }\n                function xe(Ut, wt, rr, nr, Er, Xr) {\n                  var ri = (Xr - rr) / (Er - rr);\n                  return Ut.push(wt + (nr - wt) * ri), Ut.push(Xr), Ut.push(1), ri;\n                }\n                function ke(Ut, wt) {\n                  var rr = wt.buffer / wt.extent, nr = Ut, Er = dt(Ut, 1, -1 - rr, rr, 0, -1, 2, wt), Xr = dt(Ut, 1, 1 - rr, 2 + rr, 0, -1, 2, wt);\n                  return (Er || Xr) && (nr = dt(Ut, 1, -rr, 1 + rr, 0, -1, 2, wt) || [], Er && (nr = vt(Er, 1).concat(nr)), Xr && (nr = nr.concat(vt(Xr, -1)))), nr;\n                }\n                function vt(Ut, wt) {\n                  for (var rr = [], nr = 0; nr < Ut.length; nr++) {\n                    var Er = Ut[nr], Xr = Er.type, ri;\n                    if (Xr === "Point" || Xr === "MultiPoint" || Xr === "LineString") ri = ir(Er.geometry, wt);\n                    else if (Xr === "MultiLineString" || Xr === "Polygon") {\n                      ri = [];\n                      for (var Qr = 0; Qr < Er.geometry.length; Qr++) ri.push(ir(Er.geometry[Qr], wt));\n                    } else if (Xr === "MultiPolygon") for (ri = [], Qr = 0; Qr < Er.geometry.length; Qr++) {\n                      for (var Oi = [], $i = 0; $i < Er.geometry[Qr].length; $i++) Oi.push(ir(Er.geometry[Qr][$i], wt));\n                      ri.push(Oi);\n                    }\n                    rr.push(_t(Er.id, Xr, ri, Er.tags));\n                  }\n                  return rr;\n                }\n                function ir(Ut, wt) {\n                  var rr = [];\n                  rr.size = Ut.size, Ut.start !== void 0 && (rr.start = Ut.start, rr.end = Ut.end);\n                  for (var nr = 0; nr < Ut.length; nr += 3) rr.push(Ut[nr] + wt, Ut[nr + 1], Ut[nr + 2]);\n                  return rr;\n                }\n                function ar(Ut, wt) {\n                  if (Ut.transformed) return Ut;\n                  var rr = 1 << Ut.z, nr = Ut.x, Er = Ut.y, Xr, ri, Qr;\n                  for (Xr = 0; Xr < Ut.features.length; Xr++) {\n                    var Oi = Ut.features[Xr], $i = Oi.geometry, tn = Oi.type;\n                    if (Oi.geometry = [], tn === 1) for (ri = 0; ri < $i.length; ri += 2) Oi.geometry.push(vr($i[ri], $i[ri + 1], wt, rr, nr, Er));\n                    else for (ri = 0; ri < $i.length; ri++) {\n                      var fn = [];\n                      for (Qr = 0; Qr < $i[ri].length; Qr += 2) fn.push(vr($i[ri][Qr], $i[ri][Qr + 1], wt, rr, nr, Er));\n                      Oi.geometry.push(fn);\n                    }\n                  }\n                  return Ut.transformed = true, Ut;\n                }\n                function vr(Ut, wt, rr, nr, Er, Xr) {\n                  return [Math.round(rr * (Ut * nr - Er)), Math.round(rr * (wt * nr - Xr))];\n                }\n                function ii(Ut, wt, rr, nr, Er) {\n                  for (var Xr = wt === Er.maxZoom ? 0 : Er.tolerance / ((1 << wt) * Er.extent), ri = { features: [], numPoints: 0, numSimplified: 0, numFeatures: 0, source: null, x: rr, y: nr, z: wt, transformed: false, minX: 2, minY: 1, maxX: -1, maxY: 0 }, Qr = 0; Qr < Ut.length; Qr++) {\n                    ri.numFeatures++, pi(ri, Ut[Qr], Xr, Er);\n                    var Oi = Ut[Qr].minX, $i = Ut[Qr].minY, tn = Ut[Qr].maxX, fn = Ut[Qr].maxY;\n                    Oi < ri.minX && (ri.minX = Oi), $i < ri.minY && (ri.minY = $i), tn > ri.maxX && (ri.maxX = tn), fn > ri.maxY && (ri.maxY = fn);\n                  }\n                  return ri;\n                }\n                function pi(Ut, wt, rr, nr) {\n                  var Er = wt.geometry, Xr = wt.type, ri = [];\n                  if (Xr === "Point" || Xr === "MultiPoint") for (var Qr = 0; Qr < Er.length; Qr += 3) ri.push(Er[Qr]), ri.push(Er[Qr + 1]), Ut.numPoints++, Ut.numSimplified++;\n                  else if (Xr === "LineString") $r(ri, Er, Ut, rr, false, false);\n                  else if (Xr === "MultiLineString" || Xr === "Polygon") for (Qr = 0; Qr < Er.length; Qr++) $r(ri, Er[Qr], Ut, rr, Xr === "Polygon", Qr === 0);\n                  else if (Xr === "MultiPolygon") for (var Oi = 0; Oi < Er.length; Oi++) {\n                    var $i = Er[Oi];\n                    for (Qr = 0; Qr < $i.length; Qr++) $r(ri, $i[Qr], Ut, rr, true, Qr === 0);\n                  }\n                  if (ri.length) {\n                    var tn = wt.tags || null;\n                    if (Xr === "LineString" && nr.lineMetrics) {\n                      tn = {};\n                      for (var fn in wt.tags) tn[fn] = wt.tags[fn];\n                      tn.mapbox_clip_start = Er.start / Er.size, tn.mapbox_clip_end = Er.end / Er.size;\n                    }\n                    var yn = { geometry: ri, type: Xr === "Polygon" || Xr === "MultiPolygon" ? 3 : Xr === "LineString" || Xr === "MultiLineString" ? 2 : 1, tags: tn };\n                    wt.id !== null && (yn.id = wt.id), Ut.features.push(yn);\n                  }\n                }\n                function $r(Ut, wt, rr, nr, Er, Xr) {\n                  var ri = nr * nr;\n                  if (nr > 0 && wt.size < (Er ? ri : nr)) {\n                    rr.numPoints += wt.length / 3;\n                    return;\n                  }\n                  for (var Qr = [], Oi = 0; Oi < wt.length; Oi += 3) (nr === 0 || wt[Oi + 2] > ri) && (rr.numSimplified++, Qr.push(wt[Oi]), Qr.push(wt[Oi + 1])), rr.numPoints++;\n                  Er && di(Qr, Xr), Ut.push(Qr);\n                }\n                function di(Ut, wt) {\n                  for (var rr = 0, nr = 0, Er = Ut.length, Xr = Er - 2; nr < Er; Xr = nr, nr += 2) rr += (Ut[nr] - Ut[Xr]) * (Ut[nr + 1] + Ut[Xr + 1]);\n                  if (rr > 0 === wt) for (nr = 0, Er = Ut.length; nr < Er / 2; nr += 2) {\n                    var ri = Ut[nr], Qr = Ut[nr + 1];\n                    Ut[nr] = Ut[Er - 2 - nr], Ut[nr + 1] = Ut[Er - 1 - nr], Ut[Er - 2 - nr] = ri, Ut[Er - 1 - nr] = Qr;\n                  }\n                }\n                function ji(Ut, wt) {\n                  return new In(Ut, wt);\n                }\n                function In(Ut, wt) {\n                  wt = this.options = On(Object.create(this.options), wt);\n                  var rr = wt.debug;\n                  if (rr && console.time("preprocess data"), wt.maxZoom < 0 || wt.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");\n                  if (wt.promoteId && wt.generateId) throw new Error("promoteId and generateId cannot be used together.");\n                  var nr = er(Ut, wt);\n                  this.tiles = {}, this.tileCoords = [], rr && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", wt.indexMaxZoom, wt.indexMaxPoints), console.time("generate tiles"), this.stats = {}, this.total = 0), nr = ke(nr, wt), nr.length && this.splitTile(nr, 0, 0, 0), rr && (nr.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));\n                }\n                In.prototype.options = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, debug: 0 }, In.prototype.splitTile = function(Ut, wt, rr, nr, Er, Xr, ri) {\n                  for (var Qr = [Ut, wt, rr, nr], Oi = this.options, $i = Oi.debug; Qr.length; ) {\n                    nr = Qr.pop(), rr = Qr.pop(), wt = Qr.pop(), Ut = Qr.pop();\n                    var tn = 1 << wt, fn = wi(wt, rr, nr), yn = this.tiles[fn];\n                    if (!yn && ($i > 1 && console.time("creation"), yn = this.tiles[fn] = ii(Ut, wt, rr, nr, Oi), this.tileCoords.push({ z: wt, x: rr, y: nr }), $i)) {\n                      $i > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", wt, rr, nr, yn.numFeatures, yn.numPoints, yn.numSimplified), console.timeEnd("creation"));\n                      var Sn = "z" + wt;\n                      this.stats[Sn] = (this.stats[Sn] || 0) + 1, this.total++;\n                    }\n                    if (yn.source = Ut, Er) {\n                      if (wt === Oi.maxZoom || wt === Er) continue;\n                      var Ba = 1 << Er - wt;\n                      if (rr !== Math.floor(Xr / Ba) || nr !== Math.floor(ri / Ba)) continue;\n                    } else if (wt === Oi.indexMaxZoom || yn.numPoints <= Oi.indexMaxPoints) continue;\n                    if (yn.source = null, Ut.length !== 0) {\n                      $i > 1 && console.time("clipping");\n                      var ua = 0.5 * Oi.buffer / Oi.extent, ma = 0.5 - ua, Wa = 0.5 + ua, Fa = 1 + ua, Wo, da, Wn, Ha, vo, jn;\n                      Wo = da = Wn = Ha = null, vo = dt(Ut, tn, rr - ua, rr + Wa, 0, yn.minX, yn.maxX, Oi), jn = dt(Ut, tn, rr + ma, rr + Fa, 0, yn.minX, yn.maxX, Oi), Ut = null, vo && (Wo = dt(vo, tn, nr - ua, nr + Wa, 1, yn.minY, yn.maxY, Oi), da = dt(vo, tn, nr + ma, nr + Fa, 1, yn.minY, yn.maxY, Oi), vo = null), jn && (Wn = dt(jn, tn, nr - ua, nr + Wa, 1, yn.minY, yn.maxY, Oi), Ha = dt(jn, tn, nr + ma, nr + Fa, 1, yn.minY, yn.maxY, Oi), jn = null), $i > 1 && console.timeEnd("clipping"), Qr.push(Wo || [], wt + 1, rr * 2, nr * 2), Qr.push(da || [], wt + 1, rr * 2, nr * 2 + 1), Qr.push(Wn || [], wt + 1, rr * 2 + 1, nr * 2), Qr.push(Ha || [], wt + 1, rr * 2 + 1, nr * 2 + 1);\n                    }\n                  }\n                }, In.prototype.getTile = function(Ut, wt, rr) {\n                  var nr = this.options, Er = nr.extent, Xr = nr.debug;\n                  if (Ut < 0 || Ut > 24) return null;\n                  var ri = 1 << Ut;\n                  wt = (wt % ri + ri) % ri;\n                  var Qr = wi(Ut, wt, rr);\n                  if (this.tiles[Qr]) return ar(this.tiles[Qr], Er);\n                  Xr > 1 && console.log("drilling down to z%d-%d-%d", Ut, wt, rr);\n                  for (var Oi = Ut, $i = wt, tn = rr, fn; !fn && Oi > 0; ) Oi--, $i = Math.floor($i / 2), tn = Math.floor(tn / 2), fn = this.tiles[wi(Oi, $i, tn)];\n                  return !fn || !fn.source ? null : (Xr > 1 && console.log("found parent tile z%d-%d-%d", Oi, $i, tn), Xr > 1 && console.time("drilling down"), this.splitTile(fn.source, Oi, $i, tn, Ut, wt, rr), Xr > 1 && console.timeEnd("drilling down"), this.tiles[Qr] ? ar(this.tiles[Qr], Er) : null);\n                };\n                function wi(Ut, wt, rr) {\n                  return ((1 << Ut) * rr + wt) * 32 + Ut;\n                }\n                function On(Ut, wt) {\n                  for (var rr in wt) Ut[rr] = wt[rr];\n                  return Ut;\n                }\n                function qn(Ut, wt) {\n                  var rr = Ut.tileID.canonical;\n                  if (!this._geoJSONIndex) return wt(null, null);\n                  var nr = this._geoJSONIndex.getTile(rr.z, rr.x, rr.y);\n                  if (!nr) return wt(null, null);\n                  var Er = new C3(nr.features), Xr = z3(Er);\n                  (Xr.byteOffset !== 0 || Xr.byteLength !== Xr.buffer.byteLength) && (Xr = new Uint8Array(Xr)), wt(null, { vectorTile: Er, rawData: Xr.buffer });\n                }\n                var Fn = (function(Ut) {\n                  function wt(rr, nr, Er, Xr) {\n                    Ut.call(this, rr, nr, Er, qn), Xr && (this.loadGeoJSON = Xr);\n                  }\n                  return Ut && (wt.__proto__ = Ut), wt.prototype = Object.create(Ut && Ut.prototype), wt.prototype.constructor = wt, wt.prototype.loadData = function(nr, Er) {\n                    this._pendingCallback && this._pendingCallback(null, { abandoned: true }), this._pendingCallback = Er, this._pendingLoadDataParams = nr, this._state && this._state !== "Idle" ? this._state = "NeedsLoadData" : (this._state = "Coalescing", this._loadData());\n                  }, wt.prototype._loadData = function() {\n                    var nr = this;\n                    if (!(!this._pendingCallback || !this._pendingLoadDataParams)) {\n                      var Er = this._pendingCallback, Xr = this._pendingLoadDataParams;\n                      delete this._pendingCallback, delete this._pendingLoadDataParams;\n                      var ri = Xr && Xr.request && Xr.request.collectResourceTiming ? new i3.RequestPerformance(Xr.request) : false;\n                      this.loadGeoJSON(Xr, function(Qr, Oi) {\n                        if (Qr || !Oi) return Er(Qr);\n                        if (typeof Oi != "object") return Er(new Error("Input data given to \'" + Xr.source + "\' is not a valid GeoJSON object."));\n                        p3(Oi, true);\n                        try {\n                          if (Xr.filter) {\n                            var $i = i3.createExpression(Xr.filter, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });\n                            if ($i.result === "error") throw new Error($i.value.map(function(Sn) {\n                              return Sn.key + ": " + Sn.message;\n                            }).join(", "));\n                            var tn = Oi.features.filter(function(Sn) {\n                              return $i.value.evaluate({ zoom: 0 }, Sn);\n                            });\n                            Oi = { type: "FeatureCollection", features: tn };\n                          }\n                          nr._geoJSONIndex = Xr.cluster ? new pt(ra(Xr)).load(Oi.features) : ji(Oi, Xr.geojsonVtOptions);\n                        } catch (Sn) {\n                          return Er(Sn);\n                        }\n                        nr.loaded = {};\n                        var fn = {};\n                        if (ri) {\n                          var yn = ri.finish();\n                          yn && (fn.resourceTiming = {}, fn.resourceTiming[Xr.source] = JSON.parse(JSON.stringify(yn)));\n                        }\n                        Er(null, fn);\n                      });\n                    }\n                  }, wt.prototype.coalesce = function() {\n                    this._state === "Coalescing" ? this._state = "Idle" : this._state === "NeedsLoadData" && (this._state = "Coalescing", this._loadData());\n                  }, wt.prototype.reloadTile = function(nr, Er) {\n                    var Xr = this.loaded, ri = nr.uid;\n                    return Xr && Xr[ri] ? Ut.prototype.reloadTile.call(this, nr, Er) : this.loadTile(nr, Er);\n                  }, wt.prototype.loadGeoJSON = function(nr, Er) {\n                    if (nr.request) i3.getJSON(nr.request, Er);\n                    else if (typeof nr.data == "string") try {\n                      return Er(null, JSON.parse(nr.data));\n                    } catch (Xr) {\n                      return Er(new Error("Input data given to \'" + nr.source + "\' is not a valid GeoJSON object."));\n                    }\n                    else return Er(new Error("Input data given to \'" + nr.source + "\' is not a valid GeoJSON object."));\n                  }, wt.prototype.removeSource = function(nr, Er) {\n                    this._pendingCallback && this._pendingCallback(null, { abandoned: true }), Er();\n                  }, wt.prototype.getClusterExpansionZoom = function(nr, Er) {\n                    try {\n                      Er(null, this._geoJSONIndex.getClusterExpansionZoom(nr.clusterId));\n                    } catch (Xr) {\n                      Er(Xr);\n                    }\n                  }, wt.prototype.getClusterChildren = function(nr, Er) {\n                    try {\n                      Er(null, this._geoJSONIndex.getChildren(nr.clusterId));\n                    } catch (Xr) {\n                      Er(Xr);\n                    }\n                  }, wt.prototype.getClusterLeaves = function(nr, Er) {\n                    try {\n                      Er(null, this._geoJSONIndex.getLeaves(nr.clusterId, nr.limit, nr.offset));\n                    } catch (Xr) {\n                      Er(Xr);\n                    }\n                  }, wt;\n                })(v3);\n                function ra(Ut) {\n                  var wt = Ut.superclusterOptions, rr = Ut.clusterProperties;\n                  if (!rr || !wt) return wt;\n                  for (var nr = {}, Er = {}, Xr = { accumulated: null, zoom: 0 }, ri = { properties: null }, Qr = Object.keys(rr), Oi = 0, $i = Qr; Oi < $i.length; Oi += 1) {\n                    var tn = $i[Oi], fn = rr[tn], yn = fn[0], Sn = fn[1], Ba = i3.createExpression(Sn), ua = i3.createExpression(typeof yn == "string" ? [yn, ["accumulated"], ["get", tn]] : yn);\n                    nr[tn] = Ba.value, Er[tn] = ua.value;\n                  }\n                  return wt.map = function(ma) {\n                    ri.properties = ma;\n                    for (var Wa = {}, Fa = 0, Wo = Qr; Fa < Wo.length; Fa += 1) {\n                      var da = Wo[Fa];\n                      Wa[da] = nr[da].evaluate(Xr, ri);\n                    }\n                    return Wa;\n                  }, wt.reduce = function(ma, Wa) {\n                    ri.properties = Wa;\n                    for (var Fa = 0, Wo = Qr; Fa < Wo.length; Fa += 1) {\n                      var da = Wo[Fa];\n                      Xr.accumulated = ma[da], ma[da] = Er[da].evaluate(Xr, ri);\n                    }\n                  }, wt;\n                }\n                var la = function(wt) {\n                  var rr = this;\n                  this.self = wt, this.actor = new i3.Actor(wt, this), this.layerIndexes = {}, this.availableImages = {}, this.workerSourceTypes = { vector: v3, geojson: Fn }, this.workerSources = {}, this.demWorkerSources = {}, this.self.registerWorkerSource = function(nr, Er) {\n                    if (rr.workerSourceTypes[nr]) throw new Error(\'Worker source with name "\' + nr + \'" already registered.\');\n                    rr.workerSourceTypes[nr] = Er;\n                  }, this.self.registerRTLTextPlugin = function(nr) {\n                    if (i3.plugin.isParsed()) throw new Error("RTL text plugin already registered.");\n                    i3.plugin.applyArabicShaping = nr.applyArabicShaping, i3.plugin.processBidirectionalText = nr.processBidirectionalText, i3.plugin.processStyledBidirectionalText = nr.processStyledBidirectionalText;\n                  };\n                };\n                return la.prototype.setReferrer = function(wt, rr) {\n                  this.referrer = rr;\n                }, la.prototype.setImages = function(wt, rr, nr) {\n                  this.availableImages[wt] = rr;\n                  for (var Er in this.workerSources[wt]) {\n                    var Xr = this.workerSources[wt][Er];\n                    for (var ri in Xr) Xr[ri].availableImages = rr;\n                  }\n                  nr();\n                }, la.prototype.setLayers = function(wt, rr, nr) {\n                  this.getLayerIndex(wt).replace(rr), nr();\n                }, la.prototype.updateLayers = function(wt, rr, nr) {\n                  this.getLayerIndex(wt).update(rr.layers, rr.removedIds), nr();\n                }, la.prototype.loadTile = function(wt, rr, nr) {\n                  this.getWorkerSource(wt, rr.type, rr.source).loadTile(rr, nr);\n                }, la.prototype.loadDEMTile = function(wt, rr, nr) {\n                  this.getDEMWorkerSource(wt, rr.source).loadTile(rr, nr);\n                }, la.prototype.reloadTile = function(wt, rr, nr) {\n                  this.getWorkerSource(wt, rr.type, rr.source).reloadTile(rr, nr);\n                }, la.prototype.abortTile = function(wt, rr, nr) {\n                  this.getWorkerSource(wt, rr.type, rr.source).abortTile(rr, nr);\n                }, la.prototype.removeTile = function(wt, rr, nr) {\n                  this.getWorkerSource(wt, rr.type, rr.source).removeTile(rr, nr);\n                }, la.prototype.removeDEMTile = function(wt, rr) {\n                  this.getDEMWorkerSource(wt, rr.source).removeTile(rr);\n                }, la.prototype.removeSource = function(wt, rr, nr) {\n                  if (!(!this.workerSources[wt] || !this.workerSources[wt][rr.type] || !this.workerSources[wt][rr.type][rr.source])) {\n                    var Er = this.workerSources[wt][rr.type][rr.source];\n                    delete this.workerSources[wt][rr.type][rr.source], Er.removeSource !== void 0 ? Er.removeSource(rr, nr) : nr();\n                  }\n                }, la.prototype.loadWorkerSource = function(wt, rr, nr) {\n                  try {\n                    this.self.importScripts(rr.url), nr();\n                  } catch (Er) {\n                    nr(Er.toString());\n                  }\n                }, la.prototype.syncRTLPluginState = function(wt, rr, nr) {\n                  try {\n                    i3.plugin.setState(rr);\n                    var Er = i3.plugin.getPluginURL();\n                    if (i3.plugin.isLoaded() && !i3.plugin.isParsed() && Er != null) {\n                      this.self.importScripts(Er);\n                      var Xr = i3.plugin.isParsed(), ri = Xr ? void 0 : new Error("RTL Text Plugin failed to import scripts from " + Er);\n                      nr(ri, Xr);\n                    }\n                  } catch (Qr) {\n                    nr(Qr.toString());\n                  }\n                }, la.prototype.getAvailableImages = function(wt) {\n                  var rr = this.availableImages[wt];\n                  return rr || (rr = []), rr;\n                }, la.prototype.getLayerIndex = function(wt) {\n                  var rr = this.layerIndexes[wt];\n                  return rr || (rr = this.layerIndexes[wt] = new l3()), rr;\n                }, la.prototype.getWorkerSource = function(wt, rr, nr) {\n                  var Er = this;\n                  if (this.workerSources[wt] || (this.workerSources[wt] = {}), this.workerSources[wt][rr] || (this.workerSources[wt][rr] = {}), !this.workerSources[wt][rr][nr]) {\n                    var Xr = { send: function(ri, Qr, Oi) {\n                      Er.actor.send(ri, Qr, Oi, wt);\n                    } };\n                    this.workerSources[wt][rr][nr] = new this.workerSourceTypes[rr](Xr, this.getLayerIndex(wt), this.getAvailableImages(wt));\n                  }\n                  return this.workerSources[wt][rr][nr];\n                }, la.prototype.getDEMWorkerSource = function(wt, rr) {\n                  return this.demWorkerSources[wt] || (this.demWorkerSources[wt] = {}), this.demWorkerSources[wt][rr] || (this.demWorkerSources[wt][rr] = new b()), this.demWorkerSources[wt][rr];\n                }, la.prototype.enforceCacheSizeLimit = function(wt, rr) {\n                  i3.enforceCacheSizeLimit(rr);\n                }, typeof WorkerGlobalScope != "undefined" && typeof self != "undefined" && self instanceof WorkerGlobalScope && (self.worker = new la(self)), la;\n              }), n4(["./shared"], function(i3) {\n                "use strict";\n                var a4 = i3.createCommonjsModule(function(Y) {\n                  Y.exports ? Y.exports = D3 : window && (window.mapboxgl = window.mapboxgl || {}, window.mapboxgl.supported = D3, window.mapboxgl.notSupportedReason = J);\n                  function D3(Ct) {\n                    return !J(Ct);\n                  }\n                  function J(Ct) {\n                    if (!q2()) return "not a browser";\n                    if (!K()) return "insufficent Array support";\n                    if (!de()) return "insufficient Function support";\n                    if (!ne()) return "insufficient Object support";\n                    if (!we()) return "insufficient JSON support";\n                    if (!Ue()) return "insufficient worker support";\n                    if (!ft()) return "insufficient Uint8ClampedArray support";\n                    if (!Xt()) return "insufficient ArrayBuffer support";\n                    if (!hr()) return "insufficient Canvas/getImageData support";\n                    if (!Ve(Ct && Ct.failIfMajorPerformanceCaveat)) return "insufficient WebGL support";\n                  }\n                  function q2() {\n                    return typeof window != "undefined" && typeof document != "undefined";\n                  }\n                  function K() {\n                    return Array.prototype && Array.prototype.every && Array.prototype.filter && Array.prototype.forEach && Array.prototype.indexOf && Array.prototype.lastIndexOf && Array.prototype.map && Array.prototype.some && Array.prototype.reduce && Array.prototype.reduceRight && Array.isArray;\n                  }\n                  function de() {\n                    return Function.prototype && Function.prototype.bind;\n                  }\n                  function ne() {\n                    return Object.keys && Object.create && Object.getPrototypeOf && Object.getOwnPropertyNames && Object.isSealed && Object.isFrozen && Object.isExtensible && Object.getOwnPropertyDescriptor && Object.defineProperty && Object.defineProperties && Object.seal && Object.freeze && Object.preventExtensions;\n                  }\n                  function we() {\n                    return "JSON" in window && "parse" in JSON && "stringify" in JSON;\n                  }\n                  function Ue() {\n                    if (!("Worker" in window && "Blob" in window && "URL" in window)) return false;\n                    var Ct = new Blob([""], { type: "text/javascript" }), Ot = URL.createObjectURL(Ct), Rt, Bt;\n                    try {\n                      Bt = new Worker(Ot), Rt = true;\n                    } catch (Dt) {\n                      Rt = false;\n                    }\n                    return Bt && Bt.terminate(), URL.revokeObjectURL(Ot), Rt;\n                  }\n                  function ft() {\n                    return "Uint8ClampedArray" in window;\n                  }\n                  function Xt() {\n                    return ArrayBuffer.isView;\n                  }\n                  function hr() {\n                    var Ct = document.createElement("canvas");\n                    Ct.width = Ct.height = 1;\n                    var Ot = Ct.getContext("2d");\n                    if (!Ot) return false;\n                    var Rt = Ot.getImageData(0, 0, 1, 1);\n                    return Rt && Rt.width === Ct.width;\n                  }\n                  var qt = {};\n                  function Ve(Ct) {\n                    return qt[Ct] === void 0 && (qt[Ct] = at(Ct)), qt[Ct];\n                  }\n                  D3.webGLContextAttributes = { antialias: false, alpha: true, stencil: true, depth: true };\n                  function Qe(Ct) {\n                    var Ot = document.createElement("canvas"), Rt = Object.create(D3.webGLContextAttributes);\n                    return Rt.failIfMajorPerformanceCaveat = Ct, Ot.probablySupportsContext ? Ot.probablySupportsContext("webgl", Rt) || Ot.probablySupportsContext("experimental-webgl", Rt) : Ot.supportsContext ? Ot.supportsContext("webgl", Rt) || Ot.supportsContext("experimental-webgl", Rt) : Ot.getContext("webgl", Rt) || Ot.getContext("experimental-webgl", Rt);\n                  }\n                  function at(Ct) {\n                    var Ot = Qe(Ct);\n                    if (!Ot) return false;\n                    var Rt = Ot.createShader(Ot.VERTEX_SHADER);\n                    return !Rt || Ot.isContextLost() ? false : (Ot.shaderSource(Rt, "void main() {}"), Ot.compileShader(Rt), Ot.getShaderParameter(Rt, Ot.COMPILE_STATUS) === true);\n                  }\n                }), o4 = {};\n                o4.create = function(Y, D3, J) {\n                  var q2 = i3.window.document.createElement(Y);\n                  return D3 !== void 0 && (q2.className = D3), J && J.appendChild(q2), q2;\n                }, o4.createNS = function(Y, D3) {\n                  var J = i3.window.document.createElementNS(Y, D3);\n                  return J;\n                };\n                var s3 = i3.window.document && i3.window.document.documentElement.style;\n                function l3(Y) {\n                  if (!s3) return Y[0];\n                  for (var D3 = 0; D3 < Y.length; D3++) if (Y[D3] in s3) return Y[D3];\n                  return Y[0];\n                }\n                var u4 = l3(["userSelect", "MozUserSelect", "WebkitUserSelect", "msUserSelect"]), c5;\n                o4.disableDrag = function() {\n                  s3 && u4 && (c5 = s3[u4], s3[u4] = "none");\n                }, o4.enableDrag = function() {\n                  s3 && u4 && (s3[u4] = c5);\n                };\n                var f4 = l3(["transform", "WebkitTransform"]);\n                o4.setTransform = function(Y, D3) {\n                  Y.style[f4] = D3;\n                };\n                var h3 = false;\n                try {\n                  var d3 = Object.defineProperty({}, "passive", { get: function() {\n                    h3 = true;\n                  } });\n                  i3.window.addEventListener("test", d3, d3), i3.window.removeEventListener("test", d3, d3);\n                } catch (Y) {\n                  h3 = false;\n                }\n                o4.addEventListener = function(Y, D3, J, q2) {\n                  q2 === void 0 && (q2 = {}), "passive" in q2 && h3 ? Y.addEventListener(D3, J, q2) : Y.addEventListener(D3, J, q2.capture);\n                }, o4.removeEventListener = function(Y, D3, J, q2) {\n                  q2 === void 0 && (q2 = {}), "passive" in q2 && h3 ? Y.removeEventListener(D3, J, q2) : Y.removeEventListener(D3, J, q2.capture);\n                };\n                var v3 = function(Y) {\n                  Y.preventDefault(), Y.stopPropagation(), i3.window.removeEventListener("click", v3, true);\n                };\n                o4.suppressClick = function() {\n                  i3.window.addEventListener("click", v3, true), i3.window.setTimeout(function() {\n                    i3.window.removeEventListener("click", v3, true);\n                  }, 0);\n                }, o4.mousePos = function(Y, D3) {\n                  var J = Y.getBoundingClientRect();\n                  return new i3.Point(D3.clientX - J.left - Y.clientLeft, D3.clientY - J.top - Y.clientTop);\n                }, o4.touchPos = function(Y, D3) {\n                  for (var J = Y.getBoundingClientRect(), q2 = [], K = 0; K < D3.length; K++) q2.push(new i3.Point(D3[K].clientX - J.left - Y.clientLeft, D3[K].clientY - J.top - Y.clientTop));\n                  return q2;\n                }, o4.mouseButton = function(Y) {\n                  return typeof i3.window.InstallTrigger != "undefined" && Y.button === 2 && Y.ctrlKey && i3.window.navigator.platform.toUpperCase().indexOf("MAC") >= 0 ? 0 : Y.button;\n                }, o4.remove = function(Y) {\n                  Y.parentNode && Y.parentNode.removeChild(Y);\n                };\n                function _2(Y, D3, J) {\n                  var q2, K, de, ne = i3.browser.devicePixelRatio > 1 ? "@2x" : "", we = i3.getJSON(D3.transformRequest(D3.normalizeSpriteURL(Y, ne, ".json"), i3.ResourceType.SpriteJSON), function(Xt, hr) {\n                    we = null, de || (de = Xt, q2 = hr, ft());\n                  }), Ue = i3.getImage(D3.transformRequest(D3.normalizeSpriteURL(Y, ne, ".png"), i3.ResourceType.SpriteImage), function(Xt, hr) {\n                    Ue = null, de || (de = Xt, K = hr, ft());\n                  });\n                  function ft() {\n                    if (de) J(de);\n                    else if (q2 && K) {\n                      var Xt = i3.browser.getImageData(K), hr = {};\n                      for (var qt in q2) {\n                        var Ve = q2[qt], Qe = Ve.width, at = Ve.height, Ct = Ve.x, Ot = Ve.y, Rt = Ve.sdf, Bt = Ve.pixelRatio, Dt = Ve.stretchX, yt = Ve.stretchY, Pt = Ve.content, ht = new i3.RGBAImage({ width: Qe, height: at });\n                        i3.RGBAImage.copy(Xt, ht, { x: Ct, y: Ot }, { x: 0, y: 0 }, { width: Qe, height: at }), hr[qt] = { data: ht, pixelRatio: Bt, sdf: Rt, stretchX: Dt, stretchY: yt, content: Pt };\n                      }\n                      J(null, hr);\n                    }\n                  }\n                  return { cancel: function() {\n                    we && (we.cancel(), we = null), Ue && (Ue.cancel(), Ue = null);\n                  } };\n                }\n                function b(Y) {\n                  var D3 = Y.userImage;\n                  if (D3 && D3.render) {\n                    var J = D3.render();\n                    if (J) return Y.data.replace(new Uint8Array(D3.data.buffer)), true;\n                  }\n                  return false;\n                }\n                var p3 = 1, k4 = (function(Y) {\n                  function D3() {\n                    Y.call(this), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new i3.RGBAImage({ width: 1, height: 1 }), this.dirty = true;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.isLoaded = function() {\n                    return this.loaded;\n                  }, D3.prototype.setLoaded = function(q2) {\n                    if (this.loaded !== q2 && (this.loaded = q2, q2)) {\n                      for (var K = 0, de = this.requestors; K < de.length; K += 1) {\n                        var ne = de[K], we = ne.ids, Ue = ne.callback;\n                        this._notify(we, Ue);\n                      }\n                      this.requestors = [];\n                    }\n                  }, D3.prototype.getImage = function(q2) {\n                    return this.images[q2];\n                  }, D3.prototype.addImage = function(q2, K) {\n                    this._validate(q2, K) && (this.images[q2] = K);\n                  }, D3.prototype._validate = function(q2, K) {\n                    var de = true;\n                    return this._validateStretch(K.stretchX, K.data && K.data.width) || (this.fire(new i3.ErrorEvent(new Error(\'Image "\' + q2 + \'" has invalid "stretchX" value\'))), de = false), this._validateStretch(K.stretchY, K.data && K.data.height) || (this.fire(new i3.ErrorEvent(new Error(\'Image "\' + q2 + \'" has invalid "stretchY" value\'))), de = false), this._validateContent(K.content, K) || (this.fire(new i3.ErrorEvent(new Error(\'Image "\' + q2 + \'" has invalid "content" value\'))), de = false), de;\n                  }, D3.prototype._validateStretch = function(q2, K) {\n                    if (!q2) return true;\n                    for (var de = 0, ne = 0, we = q2; ne < we.length; ne += 1) {\n                      var Ue = we[ne];\n                      if (Ue[0] < de || Ue[1] < Ue[0] || K < Ue[1]) return false;\n                      de = Ue[1];\n                    }\n                    return true;\n                  }, D3.prototype._validateContent = function(q2, K) {\n                    return q2 ? !(q2.length !== 4 || q2[0] < 0 || K.data.width < q2[0] || q2[1] < 0 || K.data.height < q2[1] || q2[2] < 0 || K.data.width < q2[2] || q2[3] < 0 || K.data.height < q2[3] || q2[2] < q2[0] || q2[3] < q2[1]) : true;\n                  }, D3.prototype.updateImage = function(q2, K) {\n                    var de = this.images[q2];\n                    K.version = de.version + 1, this.images[q2] = K, this.updatedImages[q2] = true;\n                  }, D3.prototype.removeImage = function(q2) {\n                    var K = this.images[q2];\n                    delete this.images[q2], delete this.patterns[q2], K.userImage && K.userImage.onRemove && K.userImage.onRemove();\n                  }, D3.prototype.listImages = function() {\n                    return Object.keys(this.images);\n                  }, D3.prototype.getImages = function(q2, K) {\n                    var de = true;\n                    if (!this.isLoaded()) for (var ne = 0, we = q2; ne < we.length; ne += 1) {\n                      var Ue = we[ne];\n                      this.images[Ue] || (de = false);\n                    }\n                    this.isLoaded() || de ? this._notify(q2, K) : this.requestors.push({ ids: q2, callback: K });\n                  }, D3.prototype._notify = function(q2, K) {\n                    for (var de = {}, ne = 0, we = q2; ne < we.length; ne += 1) {\n                      var Ue = we[ne];\n                      this.images[Ue] || this.fire(new i3.Event("styleimagemissing", { id: Ue }));\n                      var ft = this.images[Ue];\n                      ft ? de[Ue] = { data: ft.data.clone(), pixelRatio: ft.pixelRatio, sdf: ft.sdf, version: ft.version, stretchX: ft.stretchX, stretchY: ft.stretchY, content: ft.content, hasRenderCallback: !!(ft.userImage && ft.userImage.render) } : i3.warnOnce(\'Image "\' + Ue + \'" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.\');\n                    }\n                    K(null, de);\n                  }, D3.prototype.getPixelSize = function() {\n                    var q2 = this.atlasImage, K = q2.width, de = q2.height;\n                    return { width: K, height: de };\n                  }, D3.prototype.getPattern = function(q2) {\n                    var K = this.patterns[q2], de = this.getImage(q2);\n                    if (!de) return null;\n                    if (K && K.position.version === de.version) return K.position;\n                    if (K) K.position.version = de.version;\n                    else {\n                      var ne = de.data.width + p3 * 2, we = de.data.height + p3 * 2, Ue = { w: ne, h: we, x: 0, y: 0 }, ft = new i3.ImagePosition(Ue, de);\n                      this.patterns[q2] = { bin: Ue, position: ft };\n                    }\n                    return this._updatePatternAtlas(), this.patterns[q2].position;\n                  }, D3.prototype.bind = function(q2) {\n                    var K = q2.gl;\n                    this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new i3.Texture(q2, this.atlasImage, K.RGBA), this.atlasTexture.bind(K.LINEAR, K.CLAMP_TO_EDGE);\n                  }, D3.prototype._updatePatternAtlas = function() {\n                    var q2 = [];\n                    for (var K in this.patterns) q2.push(this.patterns[K].bin);\n                    var de = i3.potpack(q2), ne = de.w, we = de.h, Ue = this.atlasImage;\n                    Ue.resize({ width: ne || 1, height: we || 1 });\n                    for (var ft in this.patterns) {\n                      var Xt = this.patterns[ft], hr = Xt.bin, qt = hr.x + p3, Ve = hr.y + p3, Qe = this.images[ft].data, at = Qe.width, Ct = Qe.height;\n                      i3.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt, y: Ve }, { width: at, height: Ct }), i3.RGBAImage.copy(Qe, Ue, { x: 0, y: Ct - 1 }, { x: qt, y: Ve - 1 }, { width: at, height: 1 }), i3.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt, y: Ve + Ct }, { width: at, height: 1 }), i3.RGBAImage.copy(Qe, Ue, { x: at - 1, y: 0 }, { x: qt - 1, y: Ve }, { width: 1, height: Ct }), i3.RGBAImage.copy(Qe, Ue, { x: 0, y: 0 }, { x: qt + at, y: Ve }, { width: 1, height: Ct });\n                    }\n                    this.dirty = true;\n                  }, D3.prototype.beginFrame = function() {\n                    this.callbackDispatchedThisFrame = {};\n                  }, D3.prototype.dispatchRenderCallbacks = function(q2) {\n                    for (var K = 0, de = q2; K < de.length; K += 1) {\n                      var ne = de[K];\n                      if (!this.callbackDispatchedThisFrame[ne]) {\n                        this.callbackDispatchedThisFrame[ne] = true;\n                        var we = this.images[ne], Ue = b(we);\n                        Ue && this.updateImage(ne, we);\n                      }\n                    }\n                  }, D3;\n                })(i3.Evented);\n                function E3(Y, D3, J, q2, K) {\n                  var de = D3 * 256, ne = de + 255, we = q2.transformRequest(q2.normalizeGlyphsURL(J).replace("{fontstack}", Y).replace("{range}", de + "-" + ne), i3.ResourceType.Glyphs);\n                  i3.getArrayBuffer(we, function(Ue, ft) {\n                    if (Ue) K(Ue);\n                    else if (ft) {\n                      for (var Xt = {}, hr = 0, qt = i3.parseGlyphPBF(ft); hr < qt.length; hr += 1) {\n                        var Ve = qt[hr];\n                        Xt[Ve.id] = Ve;\n                      }\n                      K(null, Xt);\n                    }\n                  });\n                }\n                var S2 = C3, L3 = C3, x2 = 1e20;\n                function C3(Y, D3, J, q2, K, de) {\n                  this.fontSize = Y || 24, this.buffer = D3 === void 0 ? 3 : D3, this.cutoff = q2 || 0.25, this.fontFamily = K || "sans-serif", this.fontWeight = de || "normal", this.radius = J || 8;\n                  var ne = this.size = this.fontSize + this.buffer * 2;\n                  this.canvas = document.createElement("canvas"), this.canvas.width = this.canvas.height = ne, this.ctx = this.canvas.getContext("2d"), this.ctx.font = this.fontWeight + " " + this.fontSize + "px " + this.fontFamily, this.ctx.textBaseline = "middle", this.ctx.fillStyle = "black", this.gridOuter = new Float64Array(ne * ne), this.gridInner = new Float64Array(ne * ne), this.f = new Float64Array(ne), this.d = new Float64Array(ne), this.z = new Float64Array(ne + 1), this.v = new Int16Array(ne), this.middle = Math.round(ne / 2 * (navigator.userAgent.indexOf("Gecko/") >= 0 ? 1.2 : 1));\n                }\n                C3.prototype.draw = function(Y) {\n                  this.ctx.clearRect(0, 0, this.size, this.size), this.ctx.fillText(Y, this.buffer, this.middle);\n                  for (var D3 = this.ctx.getImageData(0, 0, this.size, this.size), J = new Uint8ClampedArray(this.size * this.size), q2 = 0; q2 < this.size * this.size; q2++) {\n                    var K = D3.data[q2 * 4 + 3] / 255;\n                    this.gridOuter[q2] = K === 1 ? 0 : K === 0 ? x2 : Math.pow(Math.max(0, 0.5 - K), 2), this.gridInner[q2] = K === 1 ? x2 : K === 0 ? 0 : Math.pow(Math.max(0, K - 0.5), 2);\n                  }\n                  for (M4(this.gridOuter, this.size, this.size, this.f, this.d, this.v, this.z), M4(this.gridInner, this.size, this.size, this.f, this.d, this.v, this.z), q2 = 0; q2 < this.size * this.size; q2++) {\n                    var de = this.gridOuter[q2] - this.gridInner[q2];\n                    J[q2] = Math.max(0, Math.min(255, Math.round(255 - 255 * (de / this.radius + this.cutoff))));\n                  }\n                  return J;\n                };\n                function M4(Y, D3, J, q2, K, de, ne) {\n                  for (var we = 0; we < D3; we++) {\n                    for (var Ue = 0; Ue < J; Ue++) q2[Ue] = Y[Ue * D3 + we];\n                    for (g3(q2, K, de, ne, J), Ue = 0; Ue < J; Ue++) Y[Ue * D3 + we] = K[Ue];\n                  }\n                  for (Ue = 0; Ue < J; Ue++) {\n                    for (we = 0; we < D3; we++) q2[we] = Y[Ue * D3 + we];\n                    for (g3(q2, K, de, ne, D3), we = 0; we < D3; we++) Y[Ue * D3 + we] = Math.sqrt(K[we]);\n                  }\n                }\n                function g3(Y, D3, J, q2, K) {\n                  J[0] = 0, q2[0] = -x2, q2[1] = +x2;\n                  for (var de = 1, ne = 0; de < K; de++) {\n                    for (var we = (Y[de] + de * de - (Y[J[ne]] + J[ne] * J[ne])) / (2 * de - 2 * J[ne]); we <= q2[ne]; ) ne--, we = (Y[de] + de * de - (Y[J[ne]] + J[ne] * J[ne])) / (2 * de - 2 * J[ne]);\n                    ne++, J[ne] = de, q2[ne] = we, q2[ne + 1] = +x2;\n                  }\n                  for (de = 0, ne = 0; de < K; de++) {\n                    for (; q2[ne + 1] < de; ) ne++;\n                    D3[de] = (de - J[ne]) * (de - J[ne]) + Y[J[ne]];\n                  }\n                }\n                S2.default = L3;\n                var P3 = function(D3, J) {\n                  this.requestManager = D3, this.localIdeographFontFamily = J, this.entries = {};\n                };\n                P3.prototype.setURL = function(D3) {\n                  this.url = D3;\n                }, P3.prototype.getGlyphs = function(D3, J) {\n                  var q2 = this, K = [];\n                  for (var de in D3) for (var ne = 0, we = D3[de]; ne < we.length; ne += 1) {\n                    var Ue = we[ne];\n                    K.push({ stack: de, id: Ue });\n                  }\n                  i3.asyncAll(K, function(ft, Xt) {\n                    var hr = ft.stack, qt = ft.id, Ve = q2.entries[hr];\n                    Ve || (Ve = q2.entries[hr] = { glyphs: {}, requests: {}, ranges: {} });\n                    var Qe = Ve.glyphs[qt];\n                    if (Qe !== void 0) {\n                      Xt(null, { stack: hr, id: qt, glyph: Qe });\n                      return;\n                    }\n                    if (Qe = q2._tinySDF(Ve, hr, qt), Qe) {\n                      Ve.glyphs[qt] = Qe, Xt(null, { stack: hr, id: qt, glyph: Qe });\n                      return;\n                    }\n                    var at = Math.floor(qt / 256);\n                    if (at * 256 > 65535) {\n                      Xt(new Error("glyphs > 65535 not supported"));\n                      return;\n                    }\n                    if (Ve.ranges[at]) {\n                      Xt(null, { stack: hr, id: qt, glyph: Qe });\n                      return;\n                    }\n                    var Ct = Ve.requests[at];\n                    Ct || (Ct = Ve.requests[at] = [], P3.loadGlyphRange(hr, at, q2.url, q2.requestManager, function(Ot, Rt) {\n                      if (Rt) {\n                        for (var Bt in Rt) q2._doesCharSupportLocalGlyph(+Bt) || (Ve.glyphs[+Bt] = Rt[+Bt]);\n                        Ve.ranges[at] = true;\n                      }\n                      for (var Dt = 0, yt = Ct; Dt < yt.length; Dt += 1) {\n                        var Pt = yt[Dt];\n                        Pt(Ot, Rt);\n                      }\n                      delete Ve.requests[at];\n                    })), Ct.push(function(Ot, Rt) {\n                      Ot ? Xt(Ot) : Rt && Xt(null, { stack: hr, id: qt, glyph: Rt[qt] || null });\n                    });\n                  }, function(ft, Xt) {\n                    if (ft) J(ft);\n                    else if (Xt) {\n                      for (var hr = {}, qt = 0, Ve = Xt; qt < Ve.length; qt += 1) {\n                        var Qe = Ve[qt], at = Qe.stack, Ct = Qe.id, Ot = Qe.glyph;\n                        (hr[at] || (hr[at] = {}))[Ct] = Ot && { id: Ot.id, bitmap: Ot.bitmap.clone(), metrics: Ot.metrics };\n                      }\n                      J(null, hr);\n                    }\n                  });\n                }, P3.prototype._doesCharSupportLocalGlyph = function(D3) {\n                  return !!this.localIdeographFontFamily && (i3.isChar["CJK Unified Ideographs"](D3) || i3.isChar["Hangul Syllables"](D3) || i3.isChar.Hiragana(D3) || i3.isChar.Katakana(D3));\n                }, P3.prototype._tinySDF = function(D3, J, q2) {\n                  var K = this.localIdeographFontFamily;\n                  if (K && this._doesCharSupportLocalGlyph(q2)) {\n                    var de = D3.tinySDF;\n                    if (!de) {\n                      var ne = "400";\n                      /bold/i.test(J) ? ne = "900" : /medium/i.test(J) ? ne = "500" : /light/i.test(J) && (ne = "200"), de = D3.tinySDF = new P3.TinySDF(24, 3, 8, 0.25, K, ne);\n                    }\n                    return { id: q2, bitmap: new i3.AlphaImage({ width: 30, height: 30 }, de.draw(String.fromCharCode(q2))), metrics: { width: 24, height: 24, left: 0, top: -8, advance: 24 } };\n                  }\n                }, P3.loadGlyphRange = E3, P3.TinySDF = S2;\n                var T3 = function() {\n                  this.specification = i3.styleSpec.light.position;\n                };\n                T3.prototype.possiblyEvaluate = function(D3, J) {\n                  return i3.sphericalToCartesian(D3.expression.evaluate(J));\n                }, T3.prototype.interpolate = function(D3, J, q2) {\n                  return { x: i3.number(D3.x, J.x, q2), y: i3.number(D3.y, J.y, q2), z: i3.number(D3.z, J.z, q2) };\n                };\n                var z3 = new i3.Properties({ anchor: new i3.DataConstantProperty(i3.styleSpec.light.anchor), position: new T3(), color: new i3.DataConstantProperty(i3.styleSpec.light.color), intensity: new i3.DataConstantProperty(i3.styleSpec.light.intensity) }), O3 = "-transition", V2 = (function(Y) {\n                  function D3(J) {\n                    Y.call(this), this._transitionable = new i3.Transitionable(z3), this.setLight(J), this._transitioning = this._transitionable.untransitioned();\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getLight = function() {\n                    return this._transitionable.serialize();\n                  }, D3.prototype.setLight = function(q2, K) {\n                    if (K === void 0 && (K = {}), !this._validate(i3.validateLight, q2, K)) for (var de in q2) {\n                      var ne = q2[de];\n                      i3.endsWith(de, O3) ? this._transitionable.setTransition(de.slice(0, -O3.length), ne) : this._transitionable.setValue(de, ne);\n                    }\n                  }, D3.prototype.updateTransitions = function(q2) {\n                    this._transitioning = this._transitionable.transitioned(q2, this._transitioning);\n                  }, D3.prototype.hasTransition = function() {\n                    return this._transitioning.hasTransition();\n                  }, D3.prototype.recalculate = function(q2) {\n                    this.properties = this._transitioning.possiblyEvaluate(q2);\n                  }, D3.prototype._validate = function(q2, K, de) {\n                    return de && de.validate === false ? false : i3.emitValidationErrors(this, q2.call(i3.validateStyle, i3.extend({ value: K, style: { glyphs: true, sprite: true }, styleSpec: i3.styleSpec })));\n                  }, D3;\n                })(i3.Evented), G2 = function(D3, J) {\n                  this.width = D3, this.height = J, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};\n                };\n                G2.prototype.getDash = function(D3, J) {\n                  var q2 = D3.join(",") + String(J);\n                  return this.dashEntry[q2] || (this.dashEntry[q2] = this.addDash(D3, J)), this.dashEntry[q2];\n                }, G2.prototype.getDashRanges = function(D3, J, q2) {\n                  var K = D3.length % 2 === 1, de = [], ne = K ? -D3[D3.length - 1] * q2 : 0, we = D3[0] * q2, Ue = true;\n                  de.push({ left: ne, right: we, isDash: Ue, zeroLength: D3[0] === 0 });\n                  for (var ft = D3[0], Xt = 1; Xt < D3.length; Xt++) {\n                    Ue = !Ue;\n                    var hr = D3[Xt];\n                    ne = ft * q2, ft += hr, we = ft * q2, de.push({ left: ne, right: we, isDash: Ue, zeroLength: hr === 0 });\n                  }\n                  return de;\n                }, G2.prototype.addRoundDash = function(D3, J, q2) {\n                  for (var K = J / 2, de = -q2; de <= q2; de++) for (var ne = this.nextRow + q2 + de, we = this.width * ne, Ue = 0, ft = D3[Ue], Xt = 0; Xt < this.width; Xt++) {\n                    Xt / ft.right > 1 && (ft = D3[++Ue]);\n                    var hr = Math.abs(Xt - ft.left), qt = Math.abs(Xt - ft.right), Ve = Math.min(hr, qt), Qe = void 0, at = de / q2 * (K + 1);\n                    if (ft.isDash) {\n                      var Ct = K - Math.abs(at);\n                      Qe = Math.sqrt(Ve * Ve + Ct * Ct);\n                    } else Qe = K - Math.sqrt(Ve * Ve + at * at);\n                    this.data[we + Xt] = Math.max(0, Math.min(255, Qe + 128));\n                  }\n                }, G2.prototype.addRegularDash = function(D3) {\n                  for (var J = D3.length - 1; J >= 0; --J) {\n                    var q2 = D3[J], K = D3[J + 1];\n                    q2.zeroLength ? D3.splice(J, 1) : K && K.isDash === q2.isDash && (K.left = q2.left, D3.splice(J, 1));\n                  }\n                  var de = D3[0], ne = D3[D3.length - 1];\n                  de.isDash === ne.isDash && (de.left = ne.left - this.width, ne.right = de.right + this.width);\n                  for (var we = this.width * this.nextRow, Ue = 0, ft = D3[Ue], Xt = 0; Xt < this.width; Xt++) {\n                    Xt / ft.right > 1 && (ft = D3[++Ue]);\n                    var hr = Math.abs(Xt - ft.left), qt = Math.abs(Xt - ft.right), Ve = Math.min(hr, qt), Qe = ft.isDash ? Ve : -Ve;\n                    this.data[we + Xt] = Math.max(0, Math.min(255, Qe + 128));\n                  }\n                }, G2.prototype.addDash = function(D3, J) {\n                  var q2 = J ? 7 : 0, K = 2 * q2 + 1;\n                  if (this.nextRow + K > this.height) return i3.warnOnce("LineAtlas out of space"), null;\n                  for (var de = 0, ne = 0; ne < D3.length; ne++) de += D3[ne];\n                  if (de !== 0) {\n                    var we = this.width / de, Ue = this.getDashRanges(D3, this.width, we);\n                    J ? this.addRoundDash(Ue, we, q2) : this.addRegularDash(Ue);\n                  }\n                  var ft = { y: (this.nextRow + q2 + 0.5) / this.height, height: 2 * q2 / this.height, width: de };\n                  return this.nextRow += K, this.dirty = true, ft;\n                }, G2.prototype.bind = function(D3) {\n                  var J = D3.gl;\n                  this.texture ? (J.bindTexture(J.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, J.texSubImage2D(J.TEXTURE_2D, 0, 0, 0, this.width, this.height, J.ALPHA, J.UNSIGNED_BYTE, this.data))) : (this.texture = J.createTexture(), J.bindTexture(J.TEXTURE_2D, this.texture), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_WRAP_S, J.REPEAT), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_WRAP_T, J.REPEAT), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_MIN_FILTER, J.LINEAR), J.texParameteri(J.TEXTURE_2D, J.TEXTURE_MAG_FILTER, J.LINEAR), J.texImage2D(J.TEXTURE_2D, 0, J.ALPHA, this.width, this.height, 0, J.ALPHA, J.UNSIGNED_BYTE, this.data));\n                };\n                var Z = function Y(D3, J) {\n                  this.workerPool = D3, this.actors = [], this.currentActor = 0, this.id = i3.uniqueId();\n                  for (var q2 = this.workerPool.acquire(this.id), K = 0; K < q2.length; K++) {\n                    var de = q2[K], ne = new Y.Actor(de, J, this.id);\n                    ne.name = "Worker " + K, this.actors.push(ne);\n                  }\n                };\n                Z.prototype.broadcast = function(D3, J, q2) {\n                  q2 = q2 || function() {\n                  }, i3.asyncAll(this.actors, function(K, de) {\n                    K.send(D3, J, de);\n                  }, q2);\n                }, Z.prototype.getActor = function() {\n                  return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];\n                }, Z.prototype.remove = function() {\n                  this.actors.forEach(function(D3) {\n                    D3.remove();\n                  }), this.actors = [], this.workerPool.release(this.id);\n                }, Z.Actor = i3.Actor;\n                function j3(Y, D3, J) {\n                  var q2 = function(K, de) {\n                    if (K) return J(K);\n                    if (de) {\n                      var ne = i3.pick(i3.extend(de, Y), ["tiles", "minzoom", "maxzoom", "attribution", "mapbox_logo", "bounds", "scheme", "tileSize", "encoding"]);\n                      de.vector_layers && (ne.vectorLayers = de.vector_layers, ne.vectorLayerIds = ne.vectorLayers.map(function(we) {\n                        return we.id;\n                      })), ne.tiles = D3.canonicalizeTileset(ne, Y.url), J(null, ne);\n                    }\n                  };\n                  return Y.url ? i3.getJSON(D3.transformRequest(D3.normalizeSourceURL(Y.url), i3.ResourceType.Source), q2) : i3.browser.frame(function() {\n                    return q2(null, Y);\n                  });\n                }\n                var N2 = function(D3, J, q2) {\n                  this.bounds = i3.LngLatBounds.convert(this.validateBounds(D3)), this.minzoom = J || 0, this.maxzoom = q2 || 24;\n                };\n                N2.prototype.validateBounds = function(D3) {\n                  return !Array.isArray(D3) || D3.length !== 4 ? [-180, -90, 180, 90] : [Math.max(-180, D3[0]), Math.max(-90, D3[1]), Math.min(180, D3[2]), Math.min(90, D3[3])];\n                }, N2.prototype.contains = function(D3) {\n                  var J = Math.pow(2, D3.z), q2 = { minX: Math.floor(i3.mercatorXfromLng(this.bounds.getWest()) * J), minY: Math.floor(i3.mercatorYfromLat(this.bounds.getNorth()) * J), maxX: Math.ceil(i3.mercatorXfromLng(this.bounds.getEast()) * J), maxY: Math.ceil(i3.mercatorYfromLat(this.bounds.getSouth()) * J) }, K = D3.x >= q2.minX && D3.x < q2.maxX && D3.y >= q2.minY && D3.y < q2.maxY;\n                  return K;\n                };\n                var H = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    if (Y.call(this), this.id = J, this.dispatcher = K, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, i3.extend(this, i3.pick(q2, ["url", "scheme", "tileSize", "promoteId"])), this._options = i3.extend({ type: "vector" }, q2), this._collectResourceTiming = q2.collectResourceTiming, this.tileSize !== 512) throw new Error("vector tile sources must have a tileSize of 512");\n                    this.setEventedParent(de);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function() {\n                    var q2 = this;\n                    this._loaded = false, this.fire(new i3.Event("dataloading", { dataType: "source" })), this._tileJSONRequest = j3(this._options, this.map._requestManager, function(K, de) {\n                      q2._tileJSONRequest = null, q2._loaded = true, K ? q2.fire(new i3.ErrorEvent(K)) : de && (i3.extend(q2, de), de.bounds && (q2.tileBounds = new N2(de.bounds, q2.minzoom, q2.maxzoom)), i3.postTurnstileEvent(de.tiles, q2.map._requestManager._customAccessToken), i3.postMapLoadEvent(de.tiles, q2.map._getMapId(), q2.map._requestManager._skuToken, q2.map._requestManager._customAccessToken), q2.fire(new i3.Event("data", { dataType: "source", sourceDataType: "metadata" })), q2.fire(new i3.Event("data", { dataType: "source", sourceDataType: "content" })));\n                    });\n                  }, D3.prototype.loaded = function() {\n                    return this._loaded;\n                  }, D3.prototype.hasTile = function(q2) {\n                    return !this.tileBounds || this.tileBounds.contains(q2.canonical);\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this.load();\n                  }, D3.prototype.setSourceProperty = function(q2) {\n                    this._tileJSONRequest && this._tileJSONRequest.cancel(), q2();\n                    var K = this.map.style.sourceCaches[this.id];\n                    K.clearTiles(), this.load();\n                  }, D3.prototype.setTiles = function(q2) {\n                    var K = this;\n                    return this.setSourceProperty(function() {\n                      K._options.tiles = q2;\n                    }), this;\n                  }, D3.prototype.setUrl = function(q2) {\n                    var K = this;\n                    return this.setSourceProperty(function() {\n                      K.url = q2, K._options.url = q2;\n                    }), this;\n                  }, D3.prototype.onRemove = function() {\n                    this._tileJSONRequest && (this._tileJSONRequest.cancel(), this._tileJSONRequest = null);\n                  }, D3.prototype.serialize = function() {\n                    return i3.extend({}, this._options);\n                  }, D3.prototype.loadTile = function(q2, K) {\n                    var de = this.map._requestManager.normalizeTileURL(q2.tileID.canonical.url(this.tiles, this.scheme)), ne = { request: this.map._requestManager.transformRequest(de, i3.ResourceType.Tile), uid: q2.uid, tileID: q2.tileID, zoom: q2.tileID.overscaledZ, tileSize: this.tileSize * q2.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: i3.browser.devicePixelRatio, showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };\n                    ne.request.collectResourceTiming = this._collectResourceTiming, !q2.actor || q2.state === "expired" ? (q2.actor = this.dispatcher.getActor(), q2.request = q2.actor.send("loadTile", ne, we.bind(this))) : q2.state === "loading" ? q2.reloadCallback = K : q2.request = q2.actor.send("reloadTile", ne, we.bind(this));\n                    function we(Ue, ft) {\n                      if (delete q2.request, q2.aborted) return K(null);\n                      if (Ue && Ue.status !== 404) return K(Ue);\n                      ft && ft.resourceTiming && (q2.resourceTiming = ft.resourceTiming), this.map._refreshExpiredTiles && ft && q2.setExpiryData(ft), q2.loadVectorData(ft, this.map.painter), i3.cacheEntryPossiblyAdded(this.dispatcher), K(null), q2.reloadCallback && (this.loadTile(q2, q2.reloadCallback), q2.reloadCallback = null);\n                    }\n                  }, D3.prototype.abortTile = function(q2) {\n                    q2.request && (q2.request.cancel(), delete q2.request), q2.actor && q2.actor.send("abortTile", { uid: q2.uid, type: this.type, source: this.id }, void 0);\n                  }, D3.prototype.unloadTile = function(q2) {\n                    q2.unloadVectorData(), q2.actor && q2.actor.send("removeTile", { uid: q2.uid, type: this.type, source: this.id }, void 0);\n                  }, D3.prototype.hasTransition = function() {\n                    return false;\n                  }, D3;\n                })(i3.Evented), te = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this), this.id = J, this.dispatcher = K, this.setEventedParent(de), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = i3.extend({ type: "raster" }, q2), i3.extend(this, i3.pick(q2, ["url", "scheme", "tileSize"]));\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function() {\n                    var q2 = this;\n                    this._loaded = false, this.fire(new i3.Event("dataloading", { dataType: "source" })), this._tileJSONRequest = j3(this._options, this.map._requestManager, function(K, de) {\n                      q2._tileJSONRequest = null, q2._loaded = true, K ? q2.fire(new i3.ErrorEvent(K)) : de && (i3.extend(q2, de), de.bounds && (q2.tileBounds = new N2(de.bounds, q2.minzoom, q2.maxzoom)), i3.postTurnstileEvent(de.tiles), i3.postMapLoadEvent(de.tiles, q2.map._getMapId(), q2.map._requestManager._skuToken), q2.fire(new i3.Event("data", { dataType: "source", sourceDataType: "metadata" })), q2.fire(new i3.Event("data", { dataType: "source", sourceDataType: "content" })));\n                    });\n                  }, D3.prototype.loaded = function() {\n                    return this._loaded;\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this.load();\n                  }, D3.prototype.onRemove = function() {\n                    this._tileJSONRequest && (this._tileJSONRequest.cancel(), this._tileJSONRequest = null);\n                  }, D3.prototype.serialize = function() {\n                    return i3.extend({}, this._options);\n                  }, D3.prototype.hasTile = function(q2) {\n                    return !this.tileBounds || this.tileBounds.contains(q2.canonical);\n                  }, D3.prototype.loadTile = function(q2, K) {\n                    var de = this, ne = this.map._requestManager.normalizeTileURL(q2.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);\n                    q2.request = i3.getImage(this.map._requestManager.transformRequest(ne, i3.ResourceType.Tile), function(we, Ue) {\n                      if (delete q2.request, q2.aborted) q2.state = "unloaded", K(null);\n                      else if (we) q2.state = "errored", K(we);\n                      else if (Ue) {\n                        de.map._refreshExpiredTiles && q2.setExpiryData(Ue), delete Ue.cacheControl, delete Ue.expires;\n                        var ft = de.map.painter.context, Xt = ft.gl;\n                        q2.texture = de.map.painter.getTileTexture(Ue.width), q2.texture ? q2.texture.update(Ue, { useMipmap: true }) : (q2.texture = new i3.Texture(ft, Ue, Xt.RGBA, { useMipmap: true }), q2.texture.bind(Xt.LINEAR, Xt.CLAMP_TO_EDGE, Xt.LINEAR_MIPMAP_NEAREST), ft.extTextureFilterAnisotropic && Xt.texParameterf(Xt.TEXTURE_2D, ft.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, ft.extTextureFilterAnisotropicMax)), q2.state = "loaded", i3.cacheEntryPossiblyAdded(de.dispatcher), K(null);\n                      }\n                    });\n                  }, D3.prototype.abortTile = function(q2, K) {\n                    q2.request && (q2.request.cancel(), delete q2.request), K();\n                  }, D3.prototype.unloadTile = function(q2, K) {\n                    q2.texture && this.map.painter.saveTileTexture(q2.texture), K();\n                  }, D3.prototype.hasTransition = function() {\n                    return false;\n                  }, D3;\n                })(i3.Evented), oe = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this, J, q2, K, de), this.type = "raster-dem", this.maxzoom = 22, this._options = i3.extend({ type: "raster-dem" }, q2), this.encoding = q2.encoding || "mapbox";\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.serialize = function() {\n                    return { type: "raster-dem", url: this.url, tileSize: this.tileSize, tiles: this.tiles, bounds: this.bounds, encoding: this.encoding };\n                  }, D3.prototype.loadTile = function(q2, K) {\n                    var de = this.map._requestManager.normalizeTileURL(q2.tileID.canonical.url(this.tiles, this.scheme), this.tileSize);\n                    q2.request = i3.getImage(this.map._requestManager.transformRequest(de, i3.ResourceType.Tile), ne.bind(this)), q2.neighboringTiles = this._getNeighboringTiles(q2.tileID);\n                    function ne(Ue, ft) {\n                      if (delete q2.request, q2.aborted) q2.state = "unloaded", K(null);\n                      else if (Ue) q2.state = "errored", K(Ue);\n                      else if (ft) {\n                        this.map._refreshExpiredTiles && q2.setExpiryData(ft), delete ft.cacheControl, delete ft.expires;\n                        var Xt = i3.window.ImageBitmap && ft instanceof i3.window.ImageBitmap && i3.offscreenCanvasSupported(), hr = Xt ? ft : i3.browser.getImageData(ft, 1), qt = { uid: q2.uid, coord: q2.tileID, source: this.id, rawImageData: hr, encoding: this.encoding };\n                        (!q2.actor || q2.state === "expired") && (q2.actor = this.dispatcher.getActor(), q2.actor.send("loadDEMTile", qt, we.bind(this)));\n                      }\n                    }\n                    function we(Ue, ft) {\n                      Ue && (q2.state = "errored", K(Ue)), ft && (q2.dem = ft, q2.needsHillshadePrepare = true, q2.state = "loaded", K(null));\n                    }\n                  }, D3.prototype._getNeighboringTiles = function(q2) {\n                    var K = q2.canonical, de = Math.pow(2, K.z), ne = (K.x - 1 + de) % de, we = K.x === 0 ? q2.wrap - 1 : q2.wrap, Ue = (K.x + 1 + de) % de, ft = K.x + 1 === de ? q2.wrap + 1 : q2.wrap, Xt = {};\n                    return Xt[new i3.OverscaledTileID(q2.overscaledZ, we, K.z, ne, K.y).key] = { backfilled: false }, Xt[new i3.OverscaledTileID(q2.overscaledZ, ft, K.z, Ue, K.y).key] = { backfilled: false }, K.y > 0 && (Xt[new i3.OverscaledTileID(q2.overscaledZ, we, K.z, ne, K.y - 1).key] = { backfilled: false }, Xt[new i3.OverscaledTileID(q2.overscaledZ, q2.wrap, K.z, K.x, K.y - 1).key] = { backfilled: false }, Xt[new i3.OverscaledTileID(q2.overscaledZ, ft, K.z, Ue, K.y - 1).key] = { backfilled: false }), K.y + 1 < de && (Xt[new i3.OverscaledTileID(q2.overscaledZ, we, K.z, ne, K.y + 1).key] = { backfilled: false }, Xt[new i3.OverscaledTileID(q2.overscaledZ, q2.wrap, K.z, K.x, K.y + 1).key] = { backfilled: false }, Xt[new i3.OverscaledTileID(q2.overscaledZ, ft, K.z, Ue, K.y + 1).key] = { backfilled: false }), Xt;\n                  }, D3.prototype.unloadTile = function(q2) {\n                    q2.demTexture && this.map.painter.saveTileTexture(q2.demTexture), q2.fbo && (q2.fbo.destroy(), delete q2.fbo), q2.dem && delete q2.dem, delete q2.neighboringTiles, q2.state = "unloaded", q2.actor && q2.actor.send("removeDEMTile", { uid: q2.uid, source: this.id });\n                  }, D3;\n                })(te), _e = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this), this.id = J, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._loaded = false, this.actor = K.getActor(), this.setEventedParent(de), this._data = q2.data, this._options = i3.extend({}, q2), this._collectResourceTiming = q2.collectResourceTiming, this._resourceTiming = [], q2.maxzoom !== void 0 && (this.maxzoom = q2.maxzoom), q2.type && (this.type = q2.type), q2.attribution && (this.attribution = q2.attribution), this.promoteId = q2.promoteId;\n                    var ne = i3.EXTENT / this.tileSize;\n                    this.workerOptions = i3.extend({ source: this.id, cluster: q2.cluster || false, geojsonVtOptions: { buffer: (q2.buffer !== void 0 ? q2.buffer : 128) * ne, tolerance: (q2.tolerance !== void 0 ? q2.tolerance : 0.375) * ne, extent: i3.EXTENT, maxZoom: this.maxzoom, lineMetrics: q2.lineMetrics || false, generateId: q2.generateId || false }, superclusterOptions: { maxZoom: q2.clusterMaxZoom !== void 0 ? Math.min(q2.clusterMaxZoom, this.maxzoom - 1) : this.maxzoom - 1, minPoints: Math.max(2, q2.clusterMinPoints || 2), extent: i3.EXTENT, radius: (q2.clusterRadius || 50) * ne, log: false, generateId: q2.generateId || false }, clusterProperties: q2.clusterProperties, filter: q2.filter }, q2.workerOptions);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function() {\n                    var q2 = this;\n                    this.fire(new i3.Event("dataloading", { dataType: "source" })), this._updateWorkerData(function(K) {\n                      if (K) {\n                        q2.fire(new i3.ErrorEvent(K));\n                        return;\n                      }\n                      var de = { dataType: "source", sourceDataType: "metadata" };\n                      q2._collectResourceTiming && q2._resourceTiming && q2._resourceTiming.length > 0 && (de.resourceTiming = q2._resourceTiming, q2._resourceTiming = []), q2.fire(new i3.Event("data", de));\n                    });\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this.load();\n                  }, D3.prototype.setData = function(q2) {\n                    var K = this;\n                    return this._data = q2, this.fire(new i3.Event("dataloading", { dataType: "source" })), this._updateWorkerData(function(de) {\n                      if (de) {\n                        K.fire(new i3.ErrorEvent(de));\n                        return;\n                      }\n                      var ne = { dataType: "source", sourceDataType: "content" };\n                      K._collectResourceTiming && K._resourceTiming && K._resourceTiming.length > 0 && (ne.resourceTiming = K._resourceTiming, K._resourceTiming = []), K.fire(new i3.Event("data", ne));\n                    }), this;\n                  }, D3.prototype.getClusterExpansionZoom = function(q2, K) {\n                    return this.actor.send("geojson.getClusterExpansionZoom", { clusterId: q2, source: this.id }, K), this;\n                  }, D3.prototype.getClusterChildren = function(q2, K) {\n                    return this.actor.send("geojson.getClusterChildren", { clusterId: q2, source: this.id }, K), this;\n                  }, D3.prototype.getClusterLeaves = function(q2, K, de, ne) {\n                    return this.actor.send("geojson.getClusterLeaves", { source: this.id, clusterId: q2, limit: K, offset: de }, ne), this;\n                  }, D3.prototype._updateWorkerData = function(q2) {\n                    var K = this;\n                    this._loaded = false;\n                    var de = i3.extend({}, this.workerOptions), ne = this._data;\n                    typeof ne == "string" ? (de.request = this.map._requestManager.transformRequest(i3.browser.resolveURL(ne), i3.ResourceType.Source), de.request.collectResourceTiming = this._collectResourceTiming) : de.data = JSON.stringify(ne), this.actor.send(this.type + ".loadData", de, function(we, Ue) {\n                      K._removed || Ue && Ue.abandoned || (K._loaded = true, Ue && Ue.resourceTiming && Ue.resourceTiming[K.id] && (K._resourceTiming = Ue.resourceTiming[K.id].slice(0)), K.actor.send(K.type + ".coalesce", { source: de.source }, null), q2(we));\n                    });\n                  }, D3.prototype.loaded = function() {\n                    return this._loaded;\n                  }, D3.prototype.loadTile = function(q2, K) {\n                    var de = this, ne = q2.actor ? "reloadTile" : "loadTile";\n                    q2.actor = this.actor;\n                    var we = { type: this.type, uid: q2.uid, tileID: q2.tileID, zoom: q2.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: i3.browser.devicePixelRatio, showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };\n                    q2.request = this.actor.send(ne, we, function(Ue, ft) {\n                      return delete q2.request, q2.unloadVectorData(), q2.aborted ? K(null) : Ue ? K(Ue) : (q2.loadVectorData(ft, de.map.painter, ne === "reloadTile"), K(null));\n                    });\n                  }, D3.prototype.abortTile = function(q2) {\n                    q2.request && (q2.request.cancel(), delete q2.request), q2.aborted = true;\n                  }, D3.prototype.unloadTile = function(q2) {\n                    q2.unloadVectorData(), this.actor.send("removeTile", { uid: q2.uid, type: this.type, source: this.id });\n                  }, D3.prototype.onRemove = function() {\n                    this._removed = true, this.actor.send("removeSource", { type: this.type, source: this.id });\n                  }, D3.prototype.serialize = function() {\n                    return i3.extend({}, this._options, { type: this.type, data: this._data });\n                  }, D3.prototype.hasTransition = function() {\n                    return false;\n                  }, D3;\n                })(i3.Evented), Ee = i3.createLayout([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]), Ce = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this), this.id = J, this.dispatcher = K, this.coordinates = q2.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(de), this.options = q2;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function(q2, K) {\n                    var de = this;\n                    this._loaded = false, this.fire(new i3.Event("dataloading", { dataType: "source" })), this.url = this.options.url, i3.getImage(this.map._requestManager.transformRequest(this.url, i3.ResourceType.Image), function(ne, we) {\n                      de._loaded = true, ne ? de.fire(new i3.ErrorEvent(ne)) : we && (de.image = we, q2 && (de.coordinates = q2), K && K(), de._finishLoading());\n                    });\n                  }, D3.prototype.loaded = function() {\n                    return this._loaded;\n                  }, D3.prototype.updateImage = function(q2) {\n                    var K = this;\n                    return !this.image || !q2.url ? this : (this.options.url = q2.url, this.load(q2.coordinates, function() {\n                      K.texture = null;\n                    }), this);\n                  }, D3.prototype._finishLoading = function() {\n                    this.map && (this.setCoordinates(this.coordinates), this.fire(new i3.Event("data", { dataType: "source", sourceDataType: "metadata" })));\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this.load();\n                  }, D3.prototype.setCoordinates = function(q2) {\n                    var K = this;\n                    this.coordinates = q2;\n                    var de = q2.map(i3.MercatorCoordinate.fromLngLat);\n                    this.tileID = me(de), this.minzoom = this.maxzoom = this.tileID.z;\n                    var ne = de.map(function(we) {\n                      return K.tileID.getTilePoint(we)._round();\n                    });\n                    return this._boundsArray = new i3.StructArrayLayout4i8(), this._boundsArray.emplaceBack(ne[0].x, ne[0].y, 0, 0), this._boundsArray.emplaceBack(ne[1].x, ne[1].y, i3.EXTENT, 0), this._boundsArray.emplaceBack(ne[3].x, ne[3].y, 0, i3.EXTENT), this._boundsArray.emplaceBack(ne[2].x, ne[2].y, i3.EXTENT, i3.EXTENT), this.boundsBuffer && (this.boundsBuffer.destroy(), delete this.boundsBuffer), this.fire(new i3.Event("data", { dataType: "source", sourceDataType: "content" })), this;\n                  }, D3.prototype.prepare = function() {\n                    if (!(Object.keys(this.tiles).length === 0 || !this.image)) {\n                      var q2 = this.map.painter.context, K = q2.gl;\n                      this.boundsBuffer || (this.boundsBuffer = q2.createVertexBuffer(this._boundsArray, Ee.members)), this.boundsSegments || (this.boundsSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture || (this.texture = new i3.Texture(q2, this.image, K.RGBA), this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE));\n                      for (var de in this.tiles) {\n                        var ne = this.tiles[de];\n                        ne.state !== "loaded" && (ne.state = "loaded", ne.texture = this.texture);\n                      }\n                    }\n                  }, D3.prototype.loadTile = function(q2, K) {\n                    this.tileID && this.tileID.equals(q2.tileID.canonical) ? (this.tiles[String(q2.tileID.wrap)] = q2, q2.buckets = {}, K(null)) : (q2.state = "errored", K(null));\n                  }, D3.prototype.serialize = function() {\n                    return { type: "image", url: this.options.url, coordinates: this.coordinates };\n                  }, D3.prototype.hasTransition = function() {\n                    return false;\n                  }, D3;\n                })(i3.Evented);\n                function me(Y) {\n                  for (var D3 = 1 / 0, J = 1 / 0, q2 = -1 / 0, K = -1 / 0, de = 0, ne = Y; de < ne.length; de += 1) {\n                    var we = ne[de];\n                    D3 = Math.min(D3, we.x), J = Math.min(J, we.y), q2 = Math.max(q2, we.x), K = Math.max(K, we.y);\n                  }\n                  var Ue = q2 - D3, ft = K - J, Xt = Math.max(Ue, ft), hr = Math.max(0, Math.floor(-Math.log(Xt) / Math.LN2)), qt = Math.pow(2, hr);\n                  return new i3.CanonicalTileID(hr, Math.floor((D3 + q2) / 2 * qt), Math.floor((J + K) / 2 * qt));\n                }\n                var ie = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this, J, q2, K, de), this.roundZoom = true, this.type = "video", this.options = q2;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function() {\n                    var q2 = this;\n                    this._loaded = false;\n                    var K = this.options;\n                    this.urls = [];\n                    for (var de = 0, ne = K.urls; de < ne.length; de += 1) {\n                      var we = ne[de];\n                      this.urls.push(this.map._requestManager.transformRequest(we, i3.ResourceType.Source).url);\n                    }\n                    i3.getVideo(this.urls, function(Ue, ft) {\n                      q2._loaded = true, Ue ? q2.fire(new i3.ErrorEvent(Ue)) : ft && (q2.video = ft, q2.video.loop = true, q2.video.addEventListener("playing", function() {\n                        q2.map.triggerRepaint();\n                      }), q2.map && q2.video.play(), q2._finishLoading());\n                    });\n                  }, D3.prototype.pause = function() {\n                    this.video && this.video.pause();\n                  }, D3.prototype.play = function() {\n                    this.video && this.video.play();\n                  }, D3.prototype.seek = function(q2) {\n                    if (this.video) {\n                      var K = this.video.seekable;\n                      q2 < K.start(0) || q2 > K.end(0) ? this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + this.id, null, "Playback for this video can be set only between the " + K.start(0) + " and " + K.end(0) + "-second mark."))) : this.video.currentTime = q2;\n                    }\n                  }, D3.prototype.getVideo = function() {\n                    return this.video;\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map || (this.map = q2, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));\n                  }, D3.prototype.prepare = function() {\n                    if (!(Object.keys(this.tiles).length === 0 || this.video.readyState < 2)) {\n                      var q2 = this.map.painter.context, K = q2.gl;\n                      this.boundsBuffer || (this.boundsBuffer = q2.createVertexBuffer(this._boundsArray, Ee.members)), this.boundsSegments || (this.boundsSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture ? this.video.paused || (this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE), K.texSubImage2D(K.TEXTURE_2D, 0, 0, 0, K.RGBA, K.UNSIGNED_BYTE, this.video)) : (this.texture = new i3.Texture(q2, this.video, K.RGBA), this.texture.bind(K.LINEAR, K.CLAMP_TO_EDGE));\n                      for (var de in this.tiles) {\n                        var ne = this.tiles[de];\n                        ne.state !== "loaded" && (ne.state = "loaded", ne.texture = this.texture);\n                      }\n                    }\n                  }, D3.prototype.serialize = function() {\n                    return { type: "video", urls: this.urls, coordinates: this.coordinates };\n                  }, D3.prototype.hasTransition = function() {\n                    return this.video && !this.video.paused;\n                  }, D3;\n                })(Ce), Se = (function(Y) {\n                  function D3(J, q2, K, de) {\n                    Y.call(this, J, q2, K, de), q2.coordinates ? (!Array.isArray(q2.coordinates) || q2.coordinates.length !== 4 || q2.coordinates.some(function(ne) {\n                      return !Array.isArray(ne) || ne.length !== 2 || ne.some(function(we) {\n                        return typeof we != "number";\n                      });\n                    })) && this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + J, null, \'"coordinates" property must be an array of 4 longitude/latitude array pairs\'))) : this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + J, null, \'missing required property "coordinates"\'))), q2.animate && typeof q2.animate != "boolean" && this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + J, null, \'optional "animate" property must be a boolean value\'))), q2.canvas ? typeof q2.canvas != "string" && !(q2.canvas instanceof i3.window.HTMLCanvasElement) && this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + J, null, \'"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance\'))) : this.fire(new i3.ErrorEvent(new i3.ValidationError("sources." + J, null, \'missing required property "canvas"\'))), this.options = q2, this.animate = q2.animate !== void 0 ? q2.animate : true;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.load = function() {\n                    if (this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof i3.window.HTMLCanvasElement ? this.options.canvas : i3.window.document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions()) {\n                      this.fire(new i3.ErrorEvent(new Error("Canvas dimensions cannot be less than or equal to zero.")));\n                      return;\n                    }\n                    this.play = function() {\n                      this._playing = true, this.map.triggerRepaint();\n                    }, this.pause = function() {\n                      this._playing && (this.prepare(), this._playing = false);\n                    }, this._finishLoading();\n                  }, D3.prototype.getCanvas = function() {\n                    return this.canvas;\n                  }, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this.load(), this.canvas && this.animate && this.play();\n                  }, D3.prototype.onRemove = function() {\n                    this.pause();\n                  }, D3.prototype.prepare = function() {\n                    var q2 = false;\n                    if (this.canvas.width !== this.width && (this.width = this.canvas.width, q2 = true), this.canvas.height !== this.height && (this.height = this.canvas.height, q2 = true), !this._hasInvalidDimensions() && Object.keys(this.tiles).length !== 0) {\n                      var K = this.map.painter.context, de = K.gl;\n                      this.boundsBuffer || (this.boundsBuffer = K.createVertexBuffer(this._boundsArray, Ee.members)), this.boundsSegments || (this.boundsSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2)), this.texture ? (q2 || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : this.texture = new i3.Texture(K, this.canvas, de.RGBA, { premultiply: true });\n                      for (var ne in this.tiles) {\n                        var we = this.tiles[ne];\n                        we.state !== "loaded" && (we.state = "loaded", we.texture = this.texture);\n                      }\n                    }\n                  }, D3.prototype.serialize = function() {\n                    return { type: "canvas", coordinates: this.coordinates };\n                  }, D3.prototype.hasTransition = function() {\n                    return this._playing;\n                  }, D3.prototype._hasInvalidDimensions = function() {\n                    for (var q2 = 0, K = [this.canvas.width, this.canvas.height]; q2 < K.length; q2 += 1) {\n                      var de = K[q2];\n                      if (isNaN(de) || de <= 0) return true;\n                    }\n                    return false;\n                  }, D3;\n                })(Ce), Le = { vector: H, raster: te, "raster-dem": oe, geojson: _e, video: ie, image: Ce, canvas: Se }, Ae = function(Y, D3, J, q2) {\n                  var K = new Le[D3.type](Y, D3, J, q2);\n                  if (K.id !== Y) throw new Error("Expected Source id to be " + Y + " instead of " + K.id);\n                  return i3.bindAll(["load", "abort", "unload", "serialize", "prepare"], K), K;\n                }, Fe = function(Y) {\n                  return Le[Y];\n                }, Pe = function(Y, D3) {\n                  Le[Y] = D3;\n                };\n                function ge(Y, D3) {\n                  var J = i3.identity([]);\n                  return i3.translate(J, J, [1, 1, 0]), i3.scale(J, J, [Y.width * 0.5, Y.height * 0.5, 1]), i3.multiply(J, J, Y.calculatePosMatrix(D3.toUnwrapped()));\n                }\n                function Re(Y, D3, J) {\n                  if (Y) for (var q2 = 0, K = Y; q2 < K.length; q2 += 1) {\n                    var de = K[q2], ne = D3[de];\n                    if (ne && ne.source === J && ne.type === "fill-extrusion") return true;\n                  }\n                  else for (var we in D3) {\n                    var Ue = D3[we];\n                    if (Ue.source === J && Ue.type === "fill-extrusion") return true;\n                  }\n                  return false;\n                }\n                function ce(Y, D3, J, q2, K, de) {\n                  var ne = Re(K && K.layers, D3, Y.id), we = de.maxPitchScaleFactor(), Ue = Y.tilesIn(q2, we, ne);\n                  Ue.sort(pt);\n                  for (var ft = [], Xt = 0, hr = Ue; Xt < hr.length; Xt += 1) {\n                    var qt = hr[Xt];\n                    ft.push({ wrappedTileID: qt.tileID.wrapped().key, queryResults: qt.tile.queryRenderedFeatures(D3, J, Y._state, qt.queryGeometry, qt.cameraQueryGeometry, qt.scale, K, de, we, ge(Y.transform, qt.tileID)) });\n                  }\n                  var Ve = Zt(ft);\n                  for (var Qe in Ve) Ve[Qe].forEach(function(at) {\n                    var Ct = at.feature, Ot = Y.getFeatureState(Ct.layer["source-layer"], Ct.id);\n                    Ct.source = Ct.layer.source, Ct.layer["source-layer"] && (Ct.sourceLayer = Ct.layer["source-layer"]), Ct.state = Ot;\n                  });\n                  return Ve;\n                }\n                function Ze(Y, D3, J, q2, K, de, ne) {\n                  for (var we = {}, Ue = de.queryRenderedSymbols(q2), ft = [], Xt = 0, hr = Object.keys(Ue).map(Number); Xt < hr.length; Xt += 1) {\n                    var qt = hr[Xt];\n                    ft.push(ne[qt]);\n                  }\n                  ft.sort(pt);\n                  for (var Ve = function() {\n                    var Rt = at[Qe], Bt = Rt.featureIndex.lookupSymbolFeatures(Ue[Rt.bucketInstanceId], D3, Rt.bucketIndex, Rt.sourceLayerIndex, K.filter, K.layers, K.availableImages, Y);\n                    for (var Dt in Bt) {\n                      var yt = we[Dt] = we[Dt] || [], Pt = Bt[Dt];\n                      Pt.sort(function(Ur, Di) {\n                        var fi = Rt.featureSortOrder;\n                        if (fi) {\n                          var Ti = fi.indexOf(Ur.featureIndex), gn = fi.indexOf(Di.featureIndex);\n                          return gn - Ti;\n                        } else return Di.featureIndex - Ur.featureIndex;\n                      });\n                      for (var ht = 0, ur = Pt; ht < ur.length; ht += 1) {\n                        var br = ur[ht];\n                        yt.push(br);\n                      }\n                    }\n                  }, Qe = 0, at = ft; Qe < at.length; Qe += 1) Ve();\n                  var Ct = function(Rt) {\n                    we[Rt].forEach(function(Bt) {\n                      var Dt = Bt.feature, yt = Y[Rt], Pt = J[yt.source], ht = Pt.getFeatureState(Dt.layer["source-layer"], Dt.id);\n                      Dt.source = Dt.layer.source, Dt.layer["source-layer"] && (Dt.sourceLayer = Dt.layer["source-layer"]), Dt.state = ht;\n                    });\n                  };\n                  for (var Ot in we) Ct(Ot);\n                  return we;\n                }\n                function ut(Y, D3) {\n                  for (var J = Y.getRenderableIds().map(function(Ue) {\n                    return Y.getTileByID(Ue);\n                  }), q2 = [], K = {}, de = 0; de < J.length; de++) {\n                    var ne = J[de], we = ne.tileID.canonical.key;\n                    K[we] || (K[we] = true, ne.querySourceFeatures(q2, D3));\n                  }\n                  return q2;\n                }\n                function pt(Y, D3) {\n                  var J = Y.tileID, q2 = D3.tileID;\n                  return J.overscaledZ - q2.overscaledZ || J.canonical.y - q2.canonical.y || J.wrap - q2.wrap || J.canonical.x - q2.canonical.x;\n                }\n                function Zt(Y) {\n                  for (var D3 = {}, J = {}, q2 = 0, K = Y; q2 < K.length; q2 += 1) {\n                    var de = K[q2], ne = de.queryResults, we = de.wrappedTileID, Ue = J[we] = J[we] || {};\n                    for (var ft in ne) for (var Xt = ne[ft], hr = Ue[ft] = Ue[ft] || {}, qt = D3[ft] = D3[ft] || [], Ve = 0, Qe = Xt; Ve < Qe.length; Ve += 1) {\n                      var at = Qe[Ve];\n                      hr[at.featureIndex] || (hr[at.featureIndex] = true, qt.push(at));\n                    }\n                  }\n                  return D3;\n                }\n                var st = function(D3, J) {\n                  this.max = D3, this.onRemove = J, this.reset();\n                };\n                st.prototype.reset = function() {\n                  for (var D3 in this.data) for (var J = 0, q2 = this.data[D3]; J < q2.length; J += 1) {\n                    var K = q2[J];\n                    K.timeout && clearTimeout(K.timeout), this.onRemove(K.value);\n                  }\n                  return this.data = {}, this.order = [], this;\n                }, st.prototype.add = function(D3, J, q2) {\n                  var K = this, de = D3.wrapped().key;\n                  this.data[de] === void 0 && (this.data[de] = []);\n                  var ne = { value: J, timeout: void 0 };\n                  if (q2 !== void 0 && (ne.timeout = setTimeout(function() {\n                    K.remove(D3, ne);\n                  }, q2)), this.data[de].push(ne), this.order.push(de), this.order.length > this.max) {\n                    var we = this._getAndRemoveByKey(this.order[0]);\n                    we && this.onRemove(we);\n                  }\n                  return this;\n                }, st.prototype.has = function(D3) {\n                  return D3.wrapped().key in this.data;\n                }, st.prototype.getAndRemove = function(D3) {\n                  return this.has(D3) ? this._getAndRemoveByKey(D3.wrapped().key) : null;\n                }, st.prototype._getAndRemoveByKey = function(D3) {\n                  var J = this.data[D3].shift();\n                  return J.timeout && clearTimeout(J.timeout), this.data[D3].length === 0 && delete this.data[D3], this.order.splice(this.order.indexOf(D3), 1), J.value;\n                }, st.prototype.getByKey = function(D3) {\n                  var J = this.data[D3];\n                  return J ? J[0].value : null;\n                }, st.prototype.get = function(D3) {\n                  if (!this.has(D3)) return null;\n                  var J = this.data[D3.wrapped().key][0];\n                  return J.value;\n                }, st.prototype.remove = function(D3, J) {\n                  if (!this.has(D3)) return this;\n                  var q2 = D3.wrapped().key, K = J === void 0 ? 0 : this.data[q2].indexOf(J), de = this.data[q2][K];\n                  return this.data[q2].splice(K, 1), de.timeout && clearTimeout(de.timeout), this.data[q2].length === 0 && delete this.data[q2], this.onRemove(de.value), this.order.splice(this.order.indexOf(q2), 1), this;\n                }, st.prototype.setMaxSize = function(D3) {\n                  for (this.max = D3; this.order.length > this.max; ) {\n                    var J = this._getAndRemoveByKey(this.order[0]);\n                    J && this.onRemove(J);\n                  }\n                  return this;\n                }, st.prototype.filter = function(D3) {\n                  var J = [];\n                  for (var q2 in this.data) for (var K = 0, de = this.data[q2]; K < de.length; K += 1) {\n                    var ne = de[K];\n                    D3(ne.value) || J.push(ne);\n                  }\n                  for (var we = 0, Ue = J; we < Ue.length; we += 1) {\n                    var ft = Ue[we];\n                    this.remove(ft.value.tileID, ft);\n                  }\n                };\n                var lt = function(D3, J, q2) {\n                  this.context = D3;\n                  var K = D3.gl;\n                  this.buffer = K.createBuffer(), this.dynamicDraw = !!q2, this.context.unbindVAO(), D3.bindElementBuffer.set(this.buffer), K.bufferData(K.ELEMENT_ARRAY_BUFFER, J.arrayBuffer, this.dynamicDraw ? K.DYNAMIC_DRAW : K.STATIC_DRAW), this.dynamicDraw || delete J.arrayBuffer;\n                };\n                lt.prototype.bind = function() {\n                  this.context.bindElementBuffer.set(this.buffer);\n                }, lt.prototype.updateData = function(D3) {\n                  var J = this.context.gl;\n                  this.context.unbindVAO(), this.bind(), J.bufferSubData(J.ELEMENT_ARRAY_BUFFER, 0, D3.arrayBuffer);\n                }, lt.prototype.destroy = function() {\n                  var D3 = this.context.gl;\n                  this.buffer && (D3.deleteBuffer(this.buffer), delete this.buffer);\n                };\n                var Gt = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" }, Nt = function(D3, J, q2, K) {\n                  this.length = J.length, this.attributes = q2, this.itemSize = J.bytesPerElement, this.dynamicDraw = K, this.context = D3;\n                  var de = D3.gl;\n                  this.buffer = de.createBuffer(), D3.bindVertexBuffer.set(this.buffer), de.bufferData(de.ARRAY_BUFFER, J.arrayBuffer, this.dynamicDraw ? de.DYNAMIC_DRAW : de.STATIC_DRAW), this.dynamicDraw || delete J.arrayBuffer;\n                };\n                Nt.prototype.bind = function() {\n                  this.context.bindVertexBuffer.set(this.buffer);\n                }, Nt.prototype.updateData = function(D3) {\n                  var J = this.context.gl;\n                  this.bind(), J.bufferSubData(J.ARRAY_BUFFER, 0, D3.arrayBuffer);\n                }, Nt.prototype.enableAttributes = function(D3, J) {\n                  for (var q2 = 0; q2 < this.attributes.length; q2++) {\n                    var K = this.attributes[q2], de = J.attributes[K.name];\n                    de !== void 0 && D3.enableVertexAttribArray(de);\n                  }\n                }, Nt.prototype.setVertexAttribPointers = function(D3, J, q2) {\n                  for (var K = 0; K < this.attributes.length; K++) {\n                    var de = this.attributes[K], ne = J.attributes[de.name];\n                    ne !== void 0 && D3.vertexAttribPointer(ne, de.components, D3[Gt[de.type]], false, this.itemSize, de.offset + this.itemSize * (q2 || 0));\n                  }\n                }, Nt.prototype.destroy = function() {\n                  var D3 = this.context.gl;\n                  this.buffer && (D3.deleteBuffer(this.buffer), delete this.buffer);\n                };\n                var Jt = function(D3) {\n                  this.gl = D3.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;\n                };\n                Jt.prototype.get = function() {\n                  return this.current;\n                }, Jt.prototype.set = function(D3) {\n                }, Jt.prototype.getDefault = function() {\n                  return this.default;\n                }, Jt.prototype.setDefault = function() {\n                  this.set(this.default);\n                };\n                var sr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return i3.Color.transparent;\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2.r === K.r && q2.g === K.g && q2.b === K.b && q2.a === K.a && !this.dirty || (this.gl.clearColor(q2.r, q2.g, q2.b, q2.a), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), wr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return 1;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.clearDepth(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), cr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return 0;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.clearStencil(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), $e = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return [true, true, true, true];\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2[0] === K[0] && q2[1] === K[1] && q2[2] === K[2] && q2[3] === K[3] && !this.dirty || (this.gl.colorMask(q2[0], q2[1], q2[2], q2[3]), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), St = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return true;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.depthMask(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Qt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return 255;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.stencilMask(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Vt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return { func: this.gl.ALWAYS, ref: 0, mask: 255 };\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2.func === K.func && q2.ref === K.ref && q2.mask === K.mask && !this.dirty || (this.gl.stencilFunc(q2.func, q2.ref, q2.mask), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), _t = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    var q2 = this.gl;\n                    return [q2.KEEP, q2.KEEP, q2.KEEP];\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2[0] === K[0] && q2[1] === K[1] && q2[2] === K[2] && !this.dirty || (this.gl.stencilOp(q2[0], q2[1], q2[2]), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), It = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      q2 ? K.enable(K.STENCIL_TEST) : K.disable(K.STENCIL_TEST), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), mt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return [0, 1];\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2[0] === K[0] && q2[1] === K[1] && !this.dirty || (this.gl.depthRange(q2[0], q2[1]), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), er = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      q2 ? K.enable(K.DEPTH_TEST) : K.disable(K.DEPTH_TEST), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), lr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return this.gl.LESS;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.depthFunc(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Tr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      q2 ? K.enable(K.BLEND) : K.disable(K.BLEND), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), Lr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    var q2 = this.gl;\n                    return [q2.ONE, q2.ZERO];\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2[0] === K[0] && q2[1] === K[1] && !this.dirty || (this.gl.blendFunc(q2[0], q2[1]), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), ti = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return i3.Color.transparent;\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2.r === K.r && q2.g === K.g && q2.b === K.b && q2.a === K.a && !this.dirty || (this.gl.blendColor(q2.r, q2.g, q2.b, q2.a), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Br = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return this.gl.FUNC_ADD;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.blendEquation(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Vr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      q2 ? K.enable(K.CULL_FACE) : K.disable(K.CULL_FACE), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), dt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return this.gl.BACK;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.cullFace(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Ge = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return this.gl.CCW;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.frontFace(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), Je = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.useProgram(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), je = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return this.gl.TEXTURE0;\n                  }, D3.prototype.set = function(q2) {\n                    q2 === this.current && !this.dirty || (this.gl.activeTexture(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), tt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    var q2 = this.gl;\n                    return [0, 0, q2.drawingBufferWidth, q2.drawingBufferHeight];\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.current;\n                    q2[0] === K[0] && q2[1] === K[1] && q2[2] === K[2] && q2[3] === K[3] && !this.dirty || (this.gl.viewport(q2[0], q2[1], q2[2], q2[3]), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), xt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.bindFramebuffer(K.FRAMEBUFFER, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), Ie = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.bindRenderbuffer(K.RENDERBUFFER, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), xe = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.bindTexture(K.TEXTURE_2D, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), ke = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.bindBuffer(K.ARRAY_BUFFER, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), vt = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    var K = this.gl;\n                    K.bindBuffer(K.ELEMENT_ARRAY_BUFFER, q2), this.current = q2, this.dirty = false;\n                  }, D3;\n                })(Jt), ir = (function(Y) {\n                  function D3(J) {\n                    Y.call(this, J), this.vao = J.extVertexArrayObject;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3.prototype.set = function(q2) {\n                    !this.vao || q2 === this.current && !this.dirty || (this.vao.bindVertexArrayOES(q2), this.current = q2, this.dirty = false);\n                  }, D3;\n                })(Jt), ar = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return 4;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.pixelStorei(K.UNPACK_ALIGNMENT, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), vr = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.pixelStorei(K.UNPACK_PREMULTIPLY_ALPHA_WEBGL, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), ii = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return false;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      var K = this.gl;\n                      K.pixelStorei(K.UNPACK_FLIP_Y_WEBGL, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(Jt), pi = (function(Y) {\n                  function D3(J, q2) {\n                    Y.call(this, J), this.context = J, this.parent = q2;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getDefault = function() {\n                    return null;\n                  }, D3;\n                })(Jt), $r = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.setDirty = function() {\n                    this.dirty = true;\n                  }, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      this.context.bindFramebuffer.set(this.parent);\n                      var K = this.gl;\n                      K.framebufferTexture2D(K.FRAMEBUFFER, K.COLOR_ATTACHMENT0, K.TEXTURE_2D, q2, 0), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(pi), di = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.set = function(q2) {\n                    if (!(q2 === this.current && !this.dirty)) {\n                      this.context.bindFramebuffer.set(this.parent);\n                      var K = this.gl;\n                      K.framebufferRenderbuffer(K.FRAMEBUFFER, K.DEPTH_ATTACHMENT, K.RENDERBUFFER, q2), this.current = q2, this.dirty = false;\n                    }\n                  }, D3;\n                })(pi), ji = function(D3, J, q2, K) {\n                  this.context = D3, this.width = J, this.height = q2;\n                  var de = D3.gl, ne = this.framebuffer = de.createFramebuffer();\n                  this.colorAttachment = new $r(D3, ne), K && (this.depthAttachment = new di(D3, ne));\n                };\n                ji.prototype.destroy = function() {\n                  var D3 = this.context.gl, J = this.colorAttachment.get();\n                  if (J && D3.deleteTexture(J), this.depthAttachment) {\n                    var q2 = this.depthAttachment.get();\n                    q2 && D3.deleteRenderbuffer(q2);\n                  }\n                  D3.deleteFramebuffer(this.framebuffer);\n                };\n                var In = 519, wi = function(D3, J, q2) {\n                  this.func = D3, this.mask = J, this.range = q2;\n                };\n                wi.ReadOnly = false, wi.ReadWrite = true, wi.disabled = new wi(In, wi.ReadOnly, [0, 1]);\n                var On = 519, qn = 7680, Fn = function(D3, J, q2, K, de, ne) {\n                  this.test = D3, this.ref = J, this.mask = q2, this.fail = K, this.depthFail = de, this.pass = ne;\n                };\n                Fn.disabled = new Fn({ func: On, mask: 0 }, 0, 0, qn, qn, qn);\n                var ra = 0, la = 1, Ut = 771, wt = function(D3, J, q2) {\n                  this.blendFunction = D3, this.blendColor = J, this.mask = q2;\n                };\n                wt.Replace = [la, ra], wt.disabled = new wt(wt.Replace, i3.Color.transparent, [false, false, false, false]), wt.unblended = new wt(wt.Replace, i3.Color.transparent, [true, true, true, true]), wt.alphaBlended = new wt([la, Ut], i3.Color.transparent, [true, true, true, true]);\n                var rr = 1029, nr = 2305, Er = function(D3, J, q2) {\n                  this.enable = D3, this.mode = J, this.frontFace = q2;\n                };\n                Er.disabled = new Er(false, rr, nr), Er.backCCW = new Er(true, rr, nr);\n                var Xr = function(D3) {\n                  this.gl = D3, this.extVertexArrayObject = this.gl.getExtension("OES_vertex_array_object"), this.clearColor = new sr(this), this.clearDepth = new wr(this), this.clearStencil = new cr(this), this.colorMask = new $e(this), this.depthMask = new St(this), this.stencilMask = new Qt(this), this.stencilFunc = new Vt(this), this.stencilOp = new _t(this), this.stencilTest = new It(this), this.depthRange = new mt(this), this.depthTest = new er(this), this.depthFunc = new lr(this), this.blend = new Tr(this), this.blendFunc = new Lr(this), this.blendColor = new ti(this), this.blendEquation = new Br(this), this.cullFace = new Vr(this), this.cullFaceSide = new dt(this), this.frontFace = new Ge(this), this.program = new Je(this), this.activeTexture = new je(this), this.viewport = new tt(this), this.bindFramebuffer = new xt(this), this.bindRenderbuffer = new Ie(this), this.bindTexture = new xe(this), this.bindVertexBuffer = new ke(this), this.bindElementBuffer = new vt(this), this.bindVertexArrayOES = this.extVertexArrayObject && new ir(this), this.pixelStoreUnpack = new ar(this), this.pixelStoreUnpackPremultiplyAlpha = new vr(this), this.pixelStoreUnpackFlipY = new ii(this), this.extTextureFilterAnisotropic = D3.getExtension("EXT_texture_filter_anisotropic") || D3.getExtension("MOZ_EXT_texture_filter_anisotropic") || D3.getExtension("WEBKIT_EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = D3.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.extTextureHalfFloat = D3.getExtension("OES_texture_half_float"), this.extTextureHalfFloat && (D3.getExtension("OES_texture_half_float_linear"), this.extRenderToTextureHalfFloat = D3.getExtension("EXT_color_buffer_half_float")), this.extTimerQuery = D3.getExtension("EXT_disjoint_timer_query"), this.maxTextureSize = D3.getParameter(D3.MAX_TEXTURE_SIZE);\n                };\n                Xr.prototype.setDefault = function() {\n                  this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();\n                }, Xr.prototype.setDirty = function() {\n                  this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.extVertexArrayObject && (this.bindVertexArrayOES.dirty = true), this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;\n                }, Xr.prototype.createIndexBuffer = function(D3, J) {\n                  return new lt(this, D3, J);\n                }, Xr.prototype.createVertexBuffer = function(D3, J, q2) {\n                  return new Nt(this, D3, J, q2);\n                }, Xr.prototype.createRenderbuffer = function(D3, J, q2) {\n                  var K = this.gl, de = K.createRenderbuffer();\n                  return this.bindRenderbuffer.set(de), K.renderbufferStorage(K.RENDERBUFFER, D3, J, q2), this.bindRenderbuffer.set(null), de;\n                }, Xr.prototype.createFramebuffer = function(D3, J, q2) {\n                  return new ji(this, D3, J, q2);\n                }, Xr.prototype.clear = function(D3) {\n                  var J = D3.color, q2 = D3.depth, K = this.gl, de = 0;\n                  J && (de |= K.COLOR_BUFFER_BIT, this.clearColor.set(J), this.colorMask.set([true, true, true, true])), typeof q2 != "undefined" && (de |= K.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(q2), this.depthMask.set(true)), K.clear(de);\n                }, Xr.prototype.setCullFace = function(D3) {\n                  D3.enable === false ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(D3.mode), this.frontFace.set(D3.frontFace));\n                }, Xr.prototype.setDepthMode = function(D3) {\n                  D3.func === this.gl.ALWAYS && !D3.mask ? this.depthTest.set(false) : (this.depthTest.set(true), this.depthFunc.set(D3.func), this.depthMask.set(D3.mask), this.depthRange.set(D3.range));\n                }, Xr.prototype.setStencilMode = function(D3) {\n                  D3.test.func === this.gl.ALWAYS && !D3.mask ? this.stencilTest.set(false) : (this.stencilTest.set(true), this.stencilMask.set(D3.mask), this.stencilOp.set([D3.fail, D3.depthFail, D3.pass]), this.stencilFunc.set({ func: D3.test.func, ref: D3.ref, mask: D3.test.mask }));\n                }, Xr.prototype.setColorMode = function(D3) {\n                  i3.deepEqual(D3.blendFunction, wt.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(D3.blendFunction), this.blendColor.set(D3.blendColor)), this.colorMask.set(D3.mask);\n                }, Xr.prototype.unbindVAO = function() {\n                  this.extVertexArrayObject && this.bindVertexArrayOES.set(null);\n                };\n                var ri = (function(Y) {\n                  function D3(J, q2, K) {\n                    var de = this;\n                    Y.call(this), this.id = J, this.dispatcher = K, this.on("data", function(ne) {\n                      ne.dataType === "source" && ne.sourceDataType === "metadata" && (de._sourceLoaded = true), de._sourceLoaded && !de._paused && ne.dataType === "source" && ne.sourceDataType === "content" && (de.reload(), de.transform && de.update(de.transform));\n                    }), this.on("error", function() {\n                      de._sourceErrored = true;\n                    }), this._source = Ae(J, q2, K, this), this._tiles = {}, this._cache = new st(0, this._unloadTile.bind(this)), this._timers = {}, this._cacheTimers = {}, this._maxTileCacheSize = null, this._loadedParentTiles = {}, this._coveredTiles = {}, this._state = new i3.SourceFeatureState();\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.onAdd = function(q2) {\n                    this.map = q2, this._maxTileCacheSize = q2 ? q2._maxTileCacheSize : null, this._source && this._source.onAdd && this._source.onAdd(q2);\n                  }, D3.prototype.onRemove = function(q2) {\n                    this._source && this._source.onRemove && this._source.onRemove(q2);\n                  }, D3.prototype.loaded = function() {\n                    if (this._sourceErrored) return true;\n                    if (!this._sourceLoaded || !this._source.loaded()) return false;\n                    for (var q2 in this._tiles) {\n                      var K = this._tiles[q2];\n                      if (K.state !== "loaded" && K.state !== "errored") return false;\n                    }\n                    return true;\n                  }, D3.prototype.getSource = function() {\n                    return this._source;\n                  }, D3.prototype.pause = function() {\n                    this._paused = true;\n                  }, D3.prototype.resume = function() {\n                    if (this._paused) {\n                      var q2 = this._shouldReloadOnResume;\n                      this._paused = false, this._shouldReloadOnResume = false, q2 && this.reload(), this.transform && this.update(this.transform);\n                    }\n                  }, D3.prototype._loadTile = function(q2, K) {\n                    return this._source.loadTile(q2, K);\n                  }, D3.prototype._unloadTile = function(q2) {\n                    if (this._source.unloadTile) return this._source.unloadTile(q2, function() {\n                    });\n                  }, D3.prototype._abortTile = function(q2) {\n                    if (this._source.abortTile) return this._source.abortTile(q2, function() {\n                    });\n                  }, D3.prototype.serialize = function() {\n                    return this._source.serialize();\n                  }, D3.prototype.prepare = function(q2) {\n                    this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);\n                    for (var K in this._tiles) {\n                      var de = this._tiles[K];\n                      de.upload(q2), de.prepare(this.map.style.imageManager);\n                    }\n                  }, D3.prototype.getIds = function() {\n                    return i3.values(this._tiles).map(function(q2) {\n                      return q2.tileID;\n                    }).sort(Qr).map(function(q2) {\n                      return q2.key;\n                    });\n                  }, D3.prototype.getRenderableIds = function(q2) {\n                    var K = this, de = [];\n                    for (var ne in this._tiles) this._isIdRenderable(ne, q2) && de.push(this._tiles[ne]);\n                    return q2 ? de.sort(function(we, Ue) {\n                      var ft = we.tileID, Xt = Ue.tileID, hr = new i3.Point(ft.canonical.x, ft.canonical.y)._rotate(K.transform.angle), qt = new i3.Point(Xt.canonical.x, Xt.canonical.y)._rotate(K.transform.angle);\n                      return ft.overscaledZ - Xt.overscaledZ || qt.y - hr.y || qt.x - hr.x;\n                    }).map(function(we) {\n                      return we.tileID.key;\n                    }) : de.map(function(we) {\n                      return we.tileID;\n                    }).sort(Qr).map(function(we) {\n                      return we.key;\n                    });\n                  }, D3.prototype.hasRenderableParent = function(q2) {\n                    var K = this.findLoadedParent(q2, 0);\n                    return K ? this._isIdRenderable(K.tileID.key) : false;\n                  }, D3.prototype._isIdRenderable = function(q2, K) {\n                    return this._tiles[q2] && this._tiles[q2].hasData() && !this._coveredTiles[q2] && (K || !this._tiles[q2].holdingForFade());\n                  }, D3.prototype.reload = function() {\n                    if (this._paused) {\n                      this._shouldReloadOnResume = true;\n                      return;\n                    }\n                    this._cache.reset();\n                    for (var q2 in this._tiles) this._tiles[q2].state !== "errored" && this._reloadTile(q2, "reloading");\n                  }, D3.prototype._reloadTile = function(q2, K) {\n                    var de = this._tiles[q2];\n                    de && (de.state !== "loading" && (de.state = K), this._loadTile(de, this._tileLoaded.bind(this, de, q2, K)));\n                  }, D3.prototype._tileLoaded = function(q2, K, de, ne) {\n                    if (ne) {\n                      q2.state = "errored", ne.status !== 404 ? this._source.fire(new i3.ErrorEvent(ne, { tile: q2 })) : this.update(this.transform);\n                      return;\n                    }\n                    q2.timeAdded = i3.browser.now(), de === "expired" && (q2.refreshedUponExpiration = true), this._setTileReloadTimer(K, q2), this.getSource().type === "raster-dem" && q2.dem && this._backfillDEM(q2), this._state.initializeTileState(q2, this.map ? this.map.painter : null), this._source.fire(new i3.Event("data", { dataType: "source", tile: q2, coord: q2.tileID }));\n                  }, D3.prototype._backfillDEM = function(q2) {\n                    for (var K = this.getRenderableIds(), de = 0; de < K.length; de++) {\n                      var ne = K[de];\n                      if (q2.neighboringTiles && q2.neighboringTiles[ne]) {\n                        var we = this.getTileByID(ne);\n                        Ue(q2, we), Ue(we, q2);\n                      }\n                    }\n                    function Ue(ft, Xt) {\n                      ft.needsHillshadePrepare = true;\n                      var hr = Xt.tileID.canonical.x - ft.tileID.canonical.x, qt = Xt.tileID.canonical.y - ft.tileID.canonical.y, Ve = Math.pow(2, ft.tileID.canonical.z), Qe = Xt.tileID.key;\n                      hr === 0 && qt === 0 || Math.abs(qt) > 1 || (Math.abs(hr) > 1 && (Math.abs(hr + Ve) === 1 ? hr += Ve : Math.abs(hr - Ve) === 1 && (hr -= Ve)), !(!Xt.dem || !ft.dem) && (ft.dem.backfillBorder(Xt.dem, hr, qt), ft.neighboringTiles && ft.neighboringTiles[Qe] && (ft.neighboringTiles[Qe].backfilled = true)));\n                    }\n                  }, D3.prototype.getTile = function(q2) {\n                    return this.getTileByID(q2.key);\n                  }, D3.prototype.getTileByID = function(q2) {\n                    return this._tiles[q2];\n                  }, D3.prototype._retainLoadedChildren = function(q2, K, de, ne) {\n                    for (var we in this._tiles) {\n                      var Ue = this._tiles[we];\n                      if (!(ne[we] || !Ue.hasData() || Ue.tileID.overscaledZ <= K || Ue.tileID.overscaledZ > de)) {\n                        for (var ft = Ue.tileID; Ue && Ue.tileID.overscaledZ > K + 1; ) {\n                          var Xt = Ue.tileID.scaledTo(Ue.tileID.overscaledZ - 1);\n                          Ue = this._tiles[Xt.key], Ue && Ue.hasData() && (ft = Xt);\n                        }\n                        for (var hr = ft; hr.overscaledZ > K; ) if (hr = hr.scaledTo(hr.overscaledZ - 1), q2[hr.key]) {\n                          ne[ft.key] = ft;\n                          break;\n                        }\n                      }\n                    }\n                  }, D3.prototype.findLoadedParent = function(q2, K) {\n                    if (q2.key in this._loadedParentTiles) {\n                      var de = this._loadedParentTiles[q2.key];\n                      return de && de.tileID.overscaledZ >= K ? de : null;\n                    }\n                    for (var ne = q2.overscaledZ - 1; ne >= K; ne--) {\n                      var we = q2.scaledTo(ne), Ue = this._getLoadedTile(we);\n                      if (Ue) return Ue;\n                    }\n                  }, D3.prototype._getLoadedTile = function(q2) {\n                    var K = this._tiles[q2.key];\n                    if (K && K.hasData()) return K;\n                    var de = this._cache.getByKey(q2.wrapped().key);\n                    return de;\n                  }, D3.prototype.updateCacheSize = function(q2) {\n                    var K = Math.ceil(q2.width / this._source.tileSize) + 1, de = Math.ceil(q2.height / this._source.tileSize) + 1, ne = K * de, we = 5, Ue = Math.floor(ne * we), ft = typeof this._maxTileCacheSize == "number" ? Math.min(this._maxTileCacheSize, Ue) : Ue;\n                    this._cache.setMaxSize(ft);\n                  }, D3.prototype.handleWrapJump = function(q2) {\n                    var K = this._prevLng === void 0 ? q2 : this._prevLng, de = q2 - K, ne = de / 360, we = Math.round(ne);\n                    if (this._prevLng = q2, we) {\n                      var Ue = {};\n                      for (var ft in this._tiles) {\n                        var Xt = this._tiles[ft];\n                        Xt.tileID = Xt.tileID.unwrapTo(Xt.tileID.wrap + we), Ue[Xt.tileID.key] = Xt;\n                      }\n                      this._tiles = Ue;\n                      for (var hr in this._timers) clearTimeout(this._timers[hr]), delete this._timers[hr];\n                      for (var qt in this._tiles) {\n                        var Ve = this._tiles[qt];\n                        this._setTileReloadTimer(qt, Ve);\n                      }\n                    }\n                  }, D3.prototype.update = function(q2) {\n                    var K = this;\n                    if (this.transform = q2, !(!this._sourceLoaded || this._paused)) {\n                      this.updateCacheSize(q2), this.handleWrapJump(this.transform.center.lng), this._coveredTiles = {};\n                      var de;\n                      this.used ? this._source.tileID ? de = q2.getVisibleUnwrappedCoordinates(this._source.tileID).map(function(Ur) {\n                        return new i3.OverscaledTileID(Ur.canonical.z, Ur.wrap, Ur.canonical.z, Ur.canonical.x, Ur.canonical.y);\n                      }) : (de = q2.coveringTiles({ tileSize: this._source.tileSize, minzoom: this._source.minzoom, maxzoom: this._source.maxzoom, roundZoom: this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled }), this._source.hasTile && (de = de.filter(function(Ur) {\n                        return K._source.hasTile(Ur);\n                      }))) : de = [];\n                      var ne = q2.coveringZoomLevel(this._source), we = Math.max(ne - D3.maxOverzooming, this._source.minzoom), Ue = Math.max(ne + D3.maxUnderzooming, this._source.minzoom), ft = this._updateRetainedTiles(de, ne);\n                      if (Oi(this._source.type)) {\n                        for (var Xt = {}, hr = {}, qt = Object.keys(ft), Ve = 0, Qe = qt; Ve < Qe.length; Ve += 1) {\n                          var at = Qe[Ve], Ct = ft[at], Ot = this._tiles[at];\n                          if (!(!Ot || Ot.fadeEndTime && Ot.fadeEndTime <= i3.browser.now())) {\n                            var Rt = this.findLoadedParent(Ct, we);\n                            Rt && (this._addTile(Rt.tileID), Xt[Rt.tileID.key] = Rt.tileID), hr[at] = Ct;\n                          }\n                        }\n                        this._retainLoadedChildren(hr, ne, Ue, ft);\n                        for (var Bt in Xt) ft[Bt] || (this._coveredTiles[Bt] = true, ft[Bt] = Xt[Bt]);\n                      }\n                      for (var Dt in ft) this._tiles[Dt].clearFadeHold();\n                      for (var yt = i3.keysDifference(this._tiles, ft), Pt = 0, ht = yt; Pt < ht.length; Pt += 1) {\n                        var ur = ht[Pt], br = this._tiles[ur];\n                        br.hasSymbolBuckets && !br.holdingForFade() ? br.setHoldDuration(this.map._fadeDuration) : (!br.hasSymbolBuckets || br.symbolFadeFinished()) && this._removeTile(ur);\n                      }\n                      this._updateLoadedParentTileCache();\n                    }\n                  }, D3.prototype.releaseSymbolFadeTiles = function() {\n                    for (var q2 in this._tiles) this._tiles[q2].holdingForFade() && this._removeTile(q2);\n                  }, D3.prototype._updateRetainedTiles = function(q2, K) {\n                    for (var de = {}, ne = {}, we = Math.max(K - D3.maxOverzooming, this._source.minzoom), Ue = Math.max(K + D3.maxUnderzooming, this._source.minzoom), ft = {}, Xt = 0, hr = q2; Xt < hr.length; Xt += 1) {\n                      var qt = hr[Xt], Ve = this._addTile(qt);\n                      de[qt.key] = qt, !Ve.hasData() && K < this._source.maxzoom && (ft[qt.key] = qt);\n                    }\n                    this._retainLoadedChildren(ft, K, Ue, de);\n                    for (var Qe = 0, at = q2; Qe < at.length; Qe += 1) {\n                      var Ct = at[Qe], Ot = this._tiles[Ct.key];\n                      if (!Ot.hasData()) {\n                        if (K + 1 > this._source.maxzoom) {\n                          var Rt = Ct.children(this._source.maxzoom)[0], Bt = this.getTile(Rt);\n                          if (Bt && Bt.hasData()) {\n                            de[Rt.key] = Rt;\n                            continue;\n                          }\n                        } else {\n                          var Dt = Ct.children(this._source.maxzoom);\n                          if (de[Dt[0].key] && de[Dt[1].key] && de[Dt[2].key] && de[Dt[3].key]) continue;\n                        }\n                        for (var yt = Ot.wasRequested(), Pt = Ct.overscaledZ - 1; Pt >= we; --Pt) {\n                          var ht = Ct.scaledTo(Pt);\n                          if (ne[ht.key] || (ne[ht.key] = true, Ot = this.getTile(ht), !Ot && yt && (Ot = this._addTile(ht)), Ot && (de[ht.key] = ht, yt = Ot.wasRequested(), Ot.hasData()))) break;\n                        }\n                      }\n                    }\n                    return de;\n                  }, D3.prototype._updateLoadedParentTileCache = function() {\n                    this._loadedParentTiles = {};\n                    for (var q2 in this._tiles) {\n                      for (var K = [], de = void 0, ne = this._tiles[q2].tileID; ne.overscaledZ > 0; ) {\n                        if (ne.key in this._loadedParentTiles) {\n                          de = this._loadedParentTiles[ne.key];\n                          break;\n                        }\n                        K.push(ne.key);\n                        var we = ne.scaledTo(ne.overscaledZ - 1);\n                        if (de = this._getLoadedTile(we), de) break;\n                        ne = we;\n                      }\n                      for (var Ue = 0, ft = K; Ue < ft.length; Ue += 1) {\n                        var Xt = ft[Ue];\n                        this._loadedParentTiles[Xt] = de;\n                      }\n                    }\n                  }, D3.prototype._addTile = function(q2) {\n                    var K = this._tiles[q2.key];\n                    if (K) return K;\n                    K = this._cache.getAndRemove(q2), K && (this._setTileReloadTimer(q2.key, K), K.tileID = q2, this._state.initializeTileState(K, this.map ? this.map.painter : null), this._cacheTimers[q2.key] && (clearTimeout(this._cacheTimers[q2.key]), delete this._cacheTimers[q2.key], this._setTileReloadTimer(q2.key, K)));\n                    var de = !!K;\n                    return de || (K = new i3.Tile(q2, this._source.tileSize * q2.overscaleFactor()), this._loadTile(K, this._tileLoaded.bind(this, K, q2.key, K.state))), K ? (K.uses++, this._tiles[q2.key] = K, de || this._source.fire(new i3.Event("dataloading", { tile: K, coord: K.tileID, dataType: "source" })), K) : null;\n                  }, D3.prototype._setTileReloadTimer = function(q2, K) {\n                    var de = this;\n                    q2 in this._timers && (clearTimeout(this._timers[q2]), delete this._timers[q2]);\n                    var ne = K.getExpiryTimeout();\n                    ne && (this._timers[q2] = setTimeout(function() {\n                      de._reloadTile(q2, "expired"), delete de._timers[q2];\n                    }, ne));\n                  }, D3.prototype._removeTile = function(q2) {\n                    var K = this._tiles[q2];\n                    K && (K.uses--, delete this._tiles[q2], this._timers[q2] && (clearTimeout(this._timers[q2]), delete this._timers[q2]), !(K.uses > 0) && (K.hasData() && K.state !== "reloading" ? this._cache.add(K.tileID, K, K.getExpiryTimeout()) : (K.aborted = true, this._abortTile(K), this._unloadTile(K))));\n                  }, D3.prototype.clearTiles = function() {\n                    this._shouldReloadOnResume = false, this._paused = false;\n                    for (var q2 in this._tiles) this._removeTile(q2);\n                    this._cache.reset();\n                  }, D3.prototype.tilesIn = function(q2, K, de) {\n                    var ne = this, we = [], Ue = this.transform;\n                    if (!Ue) return we;\n                    for (var ft = de ? Ue.getCameraQueryGeometry(q2) : q2, Xt = q2.map(function(Pt) {\n                      return Ue.pointCoordinate(Pt);\n                    }), hr = ft.map(function(Pt) {\n                      return Ue.pointCoordinate(Pt);\n                    }), qt = this.getIds(), Ve = 1 / 0, Qe = 1 / 0, at = -1 / 0, Ct = -1 / 0, Ot = 0, Rt = hr; Ot < Rt.length; Ot += 1) {\n                      var Bt = Rt[Ot];\n                      Ve = Math.min(Ve, Bt.x), Qe = Math.min(Qe, Bt.y), at = Math.max(at, Bt.x), Ct = Math.max(Ct, Bt.y);\n                    }\n                    for (var Dt = function(Pt) {\n                      var ht = ne._tiles[qt[Pt]];\n                      if (!ht.holdingForFade()) {\n                        var ur = ht.tileID, br = Math.pow(2, Ue.zoom - ht.tileID.overscaledZ), Ur = K * ht.queryPadding * i3.EXTENT / ht.tileSize / br, Di = [ur.getTilePoint(new i3.MercatorCoordinate(Ve, Qe)), ur.getTilePoint(new i3.MercatorCoordinate(at, Ct))];\n                        if (Di[0].x - Ur < i3.EXTENT && Di[0].y - Ur < i3.EXTENT && Di[1].x + Ur >= 0 && Di[1].y + Ur >= 0) {\n                          var fi = Xt.map(function(gn) {\n                            return ur.getTilePoint(gn);\n                          }), Ti = hr.map(function(gn) {\n                            return ur.getTilePoint(gn);\n                          });\n                          we.push({ tile: ht, tileID: ur, queryGeometry: fi, cameraQueryGeometry: Ti, scale: br });\n                        }\n                      }\n                    }, yt = 0; yt < qt.length; yt++) Dt(yt);\n                    return we;\n                  }, D3.prototype.getVisibleCoordinates = function(q2) {\n                    for (var K = this, de = this.getRenderableIds(q2).map(function(ft) {\n                      return K._tiles[ft].tileID;\n                    }), ne = 0, we = de; ne < we.length; ne += 1) {\n                      var Ue = we[ne];\n                      Ue.posMatrix = this.transform.calculatePosMatrix(Ue.toUnwrapped());\n                    }\n                    return de;\n                  }, D3.prototype.hasTransition = function() {\n                    if (this._source.hasTransition()) return true;\n                    if (Oi(this._source.type)) for (var q2 in this._tiles) {\n                      var K = this._tiles[q2];\n                      if (K.fadeEndTime !== void 0 && K.fadeEndTime >= i3.browser.now()) return true;\n                    }\n                    return false;\n                  }, D3.prototype.setFeatureState = function(q2, K, de) {\n                    q2 = q2 || "_geojsonTileLayer", this._state.updateState(q2, K, de);\n                  }, D3.prototype.removeFeatureState = function(q2, K, de) {\n                    q2 = q2 || "_geojsonTileLayer", this._state.removeFeatureState(q2, K, de);\n                  }, D3.prototype.getFeatureState = function(q2, K) {\n                    return q2 = q2 || "_geojsonTileLayer", this._state.getState(q2, K);\n                  }, D3.prototype.setDependencies = function(q2, K, de) {\n                    var ne = this._tiles[q2];\n                    ne && ne.setDependencies(K, de);\n                  }, D3.prototype.reloadTilesForDependencies = function(q2, K) {\n                    for (var de in this._tiles) {\n                      var ne = this._tiles[de];\n                      ne.hasDependency(q2, K) && this._reloadTile(de, "reloading");\n                    }\n                    this._cache.filter(function(we) {\n                      return !we.hasDependency(q2, K);\n                    });\n                  }, D3;\n                })(i3.Evented);\n                ri.maxOverzooming = 10, ri.maxUnderzooming = 3;\n                function Qr(Y, D3) {\n                  var J = Math.abs(Y.wrap * 2) - +(Y.wrap < 0), q2 = Math.abs(D3.wrap * 2) - +(D3.wrap < 0);\n                  return Y.overscaledZ - D3.overscaledZ || q2 - J || D3.canonical.y - Y.canonical.y || D3.canonical.x - Y.canonical.x;\n                }\n                function Oi(Y) {\n                  return Y === "raster" || Y === "image" || Y === "video";\n                }\n                function $i() {\n                  return new i3.window.Worker(io.workerUrl);\n                }\n                var tn = "mapboxgl_preloaded_worker_pool", fn = function() {\n                  this.active = {};\n                };\n                fn.prototype.acquire = function(D3) {\n                  if (!this.workers) for (this.workers = []; this.workers.length < fn.workerCount; ) this.workers.push(new $i());\n                  return this.active[D3] = true, this.workers.slice();\n                }, fn.prototype.release = function(D3) {\n                  delete this.active[D3], this.numActive() === 0 && (this.workers.forEach(function(J) {\n                    J.terminate();\n                  }), this.workers = null);\n                }, fn.prototype.isPreloaded = function() {\n                  return !!this.active[tn];\n                }, fn.prototype.numActive = function() {\n                  return Object.keys(this.active).length;\n                };\n                var yn = Math.floor(i3.browser.hardwareConcurrency / 2);\n                fn.workerCount = Math.max(Math.min(yn, 6), 1);\n                var Sn;\n                function Ba() {\n                  return Sn || (Sn = new fn()), Sn;\n                }\n                function ua() {\n                  var Y = Ba();\n                  Y.acquire(tn);\n                }\n                function ma() {\n                  var Y = Sn;\n                  Y && (Y.isPreloaded() && Y.numActive() === 1 ? (Y.release(tn), Sn = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));\n                }\n                function Wa(Y, D3) {\n                  var J = {};\n                  for (var q2 in Y) q2 !== "ref" && (J[q2] = Y[q2]);\n                  return i3.refProperties.forEach(function(K) {\n                    K in D3 && (J[K] = D3[K]);\n                  }), J;\n                }\n                function Fa(Y) {\n                  Y = Y.slice();\n                  for (var D3 = /* @__PURE__ */ Object.create(null), J = 0; J < Y.length; J++) D3[Y[J].id] = Y[J];\n                  for (var q2 = 0; q2 < Y.length; q2++) "ref" in Y[q2] && (Y[q2] = Wa(Y[q2], D3[Y[q2].ref]));\n                  return Y;\n                }\n                function Wo() {\n                  var Y = {}, D3 = i3.styleSpec.$version;\n                  for (var J in i3.styleSpec.$root) {\n                    var q2 = i3.styleSpec.$root[J];\n                    if (q2.required) {\n                      var K = null;\n                      J === "version" ? K = D3 : q2.type === "array" ? K = [] : K = {}, K != null && (Y[J] = K);\n                    }\n                  }\n                  return Y;\n                }\n                var da = { setStyle: "setStyle", addLayer: "addLayer", removeLayer: "removeLayer", setPaintProperty: "setPaintProperty", setLayoutProperty: "setLayoutProperty", setFilter: "setFilter", addSource: "addSource", removeSource: "removeSource", setGeoJSONSourceData: "setGeoJSONSourceData", setLayerZoomRange: "setLayerZoomRange", setLayerProperty: "setLayerProperty", setCenter: "setCenter", setZoom: "setZoom", setBearing: "setBearing", setPitch: "setPitch", setSprite: "setSprite", setGlyphs: "setGlyphs", setTransition: "setTransition", setLight: "setLight" };\n                function Wn(Y, D3, J) {\n                  J.push({ command: da.addSource, args: [Y, D3[Y]] });\n                }\n                function Ha(Y, D3, J) {\n                  D3.push({ command: da.removeSource, args: [Y] }), J[Y] = true;\n                }\n                function vo(Y, D3, J, q2) {\n                  Ha(Y, J, q2), Wn(Y, D3, J);\n                }\n                function jn(Y, D3, J) {\n                  var q2;\n                  for (q2 in Y[J]) if (Y[J].hasOwnProperty(q2) && q2 !== "data" && !i3.deepEqual(Y[J][q2], D3[J][q2])) return false;\n                  for (q2 in D3[J]) if (D3[J].hasOwnProperty(q2) && q2 !== "data" && !i3.deepEqual(Y[J][q2], D3[J][q2])) return false;\n                  return true;\n                }\n                function Mt(Y, D3, J, q2) {\n                  Y = Y || {}, D3 = D3 || {};\n                  var K;\n                  for (K in Y) Y.hasOwnProperty(K) && (D3.hasOwnProperty(K) || Ha(K, J, q2));\n                  for (K in D3) D3.hasOwnProperty(K) && (Y.hasOwnProperty(K) ? i3.deepEqual(Y[K], D3[K]) || (Y[K].type === "geojson" && D3[K].type === "geojson" && jn(Y, D3, K) ? J.push({ command: da.setGeoJSONSourceData, args: [K, D3[K].data] }) : vo(K, D3, J, q2)) : Wn(K, D3, J));\n                }\n                function kr(Y, D3, J, q2, K, de) {\n                  Y = Y || {}, D3 = D3 || {};\n                  var ne;\n                  for (ne in Y) Y.hasOwnProperty(ne) && (i3.deepEqual(Y[ne], D3[ne]) || J.push({ command: de, args: [q2, ne, D3[ne], K] }));\n                  for (ne in D3) !D3.hasOwnProperty(ne) || Y.hasOwnProperty(ne) || i3.deepEqual(Y[ne], D3[ne]) || J.push({ command: de, args: [q2, ne, D3[ne], K] });\n                }\n                function Jr(Y) {\n                  return Y.id;\n                }\n                function vi(Y, D3) {\n                  return Y[D3.id] = D3, Y;\n                }\n                function hn(Y, D3, J) {\n                  Y = Y || [], D3 = D3 || [];\n                  var q2 = Y.map(Jr), K = D3.map(Jr), de = Y.reduce(vi, {}), ne = D3.reduce(vi, {}), we = q2.slice(), Ue = /* @__PURE__ */ Object.create(null), ft, Xt, hr, qt, Ve, Qe, at;\n                  for (ft = 0, Xt = 0; ft < q2.length; ft++) hr = q2[ft], ne.hasOwnProperty(hr) ? Xt++ : (J.push({ command: da.removeLayer, args: [hr] }), we.splice(we.indexOf(hr, Xt), 1));\n                  for (ft = 0, Xt = 0; ft < K.length; ft++) hr = K[K.length - 1 - ft], we[we.length - 1 - ft] !== hr && (de.hasOwnProperty(hr) ? (J.push({ command: da.removeLayer, args: [hr] }), we.splice(we.lastIndexOf(hr, we.length - Xt), 1)) : Xt++, Qe = we[we.length - ft], J.push({ command: da.addLayer, args: [ne[hr], Qe] }), we.splice(we.length - ft, 0, hr), Ue[hr] = true);\n                  for (ft = 0; ft < K.length; ft++) if (hr = K[ft], qt = de[hr], Ve = ne[hr], !(Ue[hr] || i3.deepEqual(qt, Ve))) {\n                    if (!i3.deepEqual(qt.source, Ve.source) || !i3.deepEqual(qt["source-layer"], Ve["source-layer"]) || !i3.deepEqual(qt.type, Ve.type)) {\n                      J.push({ command: da.removeLayer, args: [hr] }), Qe = we[we.lastIndexOf(hr) + 1], J.push({ command: da.addLayer, args: [Ve, Qe] });\n                      continue;\n                    }\n                    kr(qt.layout, Ve.layout, J, hr, null, da.setLayoutProperty), kr(qt.paint, Ve.paint, J, hr, null, da.setPaintProperty), i3.deepEqual(qt.filter, Ve.filter) || J.push({ command: da.setFilter, args: [hr, Ve.filter] }), (!i3.deepEqual(qt.minzoom, Ve.minzoom) || !i3.deepEqual(qt.maxzoom, Ve.maxzoom)) && J.push({ command: da.setLayerZoomRange, args: [hr, Ve.minzoom, Ve.maxzoom] });\n                    for (at in qt) qt.hasOwnProperty(at) && (at === "layout" || at === "paint" || at === "filter" || at === "metadata" || at === "minzoom" || at === "maxzoom" || (at.indexOf("paint.") === 0 ? kr(qt[at], Ve[at], J, hr, at.slice(6), da.setPaintProperty) : i3.deepEqual(qt[at], Ve[at]) || J.push({ command: da.setLayerProperty, args: [hr, at, Ve[at]] })));\n                    for (at in Ve) !Ve.hasOwnProperty(at) || qt.hasOwnProperty(at) || at === "layout" || at === "paint" || at === "filter" || at === "metadata" || at === "minzoom" || at === "maxzoom" || (at.indexOf("paint.") === 0 ? kr(qt[at], Ve[at], J, hr, at.slice(6), da.setPaintProperty) : i3.deepEqual(qt[at], Ve[at]) || J.push({ command: da.setLayerProperty, args: [hr, at, Ve[at]] }));\n                  }\n                }\n                function An(Y, D3) {\n                  if (!Y) return [{ command: da.setStyle, args: [D3] }];\n                  var J = [];\n                  try {\n                    if (!i3.deepEqual(Y.version, D3.version)) return [{ command: da.setStyle, args: [D3] }];\n                    i3.deepEqual(Y.center, D3.center) || J.push({ command: da.setCenter, args: [D3.center] }), i3.deepEqual(Y.zoom, D3.zoom) || J.push({ command: da.setZoom, args: [D3.zoom] }), i3.deepEqual(Y.bearing, D3.bearing) || J.push({ command: da.setBearing, args: [D3.bearing] }), i3.deepEqual(Y.pitch, D3.pitch) || J.push({ command: da.setPitch, args: [D3.pitch] }), i3.deepEqual(Y.sprite, D3.sprite) || J.push({ command: da.setSprite, args: [D3.sprite] }), i3.deepEqual(Y.glyphs, D3.glyphs) || J.push({ command: da.setGlyphs, args: [D3.glyphs] }), i3.deepEqual(Y.transition, D3.transition) || J.push({ command: da.setTransition, args: [D3.transition] }), i3.deepEqual(Y.light, D3.light) || J.push({ command: da.setLight, args: [D3.light] });\n                    var q2 = {}, K = [];\n                    Mt(Y.sources, D3.sources, K, q2);\n                    var de = [];\n                    Y.layers && Y.layers.forEach(function(ne) {\n                      q2[ne.source] ? J.push({ command: da.removeLayer, args: [ne.id] }) : de.push(ne);\n                    }), J = J.concat(K), hn(de, D3.layers, J);\n                  } catch (ne) {\n                    console.warn("Unable to compute style diff:", ne), J = [{ command: da.setStyle, args: [D3] }];\n                  }\n                  return J;\n                }\n                var Mn = function(D3, J) {\n                  this.reset(D3, J);\n                };\n                Mn.prototype.reset = function(D3, J) {\n                  this.points = D3 || [], this._distances = [0];\n                  for (var q2 = 1; q2 < this.points.length; q2++) this._distances[q2] = this._distances[q2 - 1] + this.points[q2].dist(this.points[q2 - 1]);\n                  this.length = this._distances[this._distances.length - 1], this.padding = Math.min(J || 0, this.length * 0.5), this.paddedLength = this.length - this.padding * 2;\n                }, Mn.prototype.lerp = function(D3) {\n                  if (this.points.length === 1) return this.points[0];\n                  D3 = i3.clamp(D3, 0, 1);\n                  for (var J = 1, q2 = this._distances[J], K = D3 * this.paddedLength + this.padding; q2 < K && J < this._distances.length; ) q2 = this._distances[++J];\n                  var de = J - 1, ne = this._distances[de], we = q2 - ne, Ue = we > 0 ? (K - ne) / we : 0;\n                  return this.points[de].mult(1 - Ue).add(this.points[J].mult(Ue));\n                };\n                var Li = function(D3, J, q2) {\n                  var K = this.boxCells = [], de = this.circleCells = [];\n                  this.xCellCount = Math.ceil(D3 / q2), this.yCellCount = Math.ceil(J / q2);\n                  for (var ne = 0; ne < this.xCellCount * this.yCellCount; ne++) K.push([]), de.push([]);\n                  this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = D3, this.height = J, this.xScale = this.xCellCount / D3, this.yScale = this.yCellCount / J, this.boxUid = 0, this.circleUid = 0;\n                };\n                Li.prototype.keysLength = function() {\n                  return this.boxKeys.length + this.circleKeys.length;\n                }, Li.prototype.insert = function(D3, J, q2, K, de) {\n                  this._forEachCell(J, q2, K, de, this._insertBoxCell, this.boxUid++), this.boxKeys.push(D3), this.bboxes.push(J), this.bboxes.push(q2), this.bboxes.push(K), this.bboxes.push(de);\n                }, Li.prototype.insertCircle = function(D3, J, q2, K) {\n                  this._forEachCell(J - K, q2 - K, J + K, q2 + K, this._insertCircleCell, this.circleUid++), this.circleKeys.push(D3), this.circles.push(J), this.circles.push(q2), this.circles.push(K);\n                }, Li.prototype._insertBoxCell = function(D3, J, q2, K, de, ne) {\n                  this.boxCells[de].push(ne);\n                }, Li.prototype._insertCircleCell = function(D3, J, q2, K, de, ne) {\n                  this.circleCells[de].push(ne);\n                }, Li.prototype._query = function(D3, J, q2, K, de, ne) {\n                  if (q2 < 0 || D3 > this.width || K < 0 || J > this.height) return de ? false : [];\n                  var we = [];\n                  if (D3 <= 0 && J <= 0 && this.width <= q2 && this.height <= K) {\n                    if (de) return true;\n                    for (var Ue = 0; Ue < this.boxKeys.length; Ue++) we.push({ key: this.boxKeys[Ue], x1: this.bboxes[Ue * 4], y1: this.bboxes[Ue * 4 + 1], x2: this.bboxes[Ue * 4 + 2], y2: this.bboxes[Ue * 4 + 3] });\n                    for (var ft = 0; ft < this.circleKeys.length; ft++) {\n                      var Xt = this.circles[ft * 3], hr = this.circles[ft * 3 + 1], qt = this.circles[ft * 3 + 2];\n                      we.push({ key: this.circleKeys[ft], x1: Xt - qt, y1: hr - qt, x2: Xt + qt, y2: hr + qt });\n                    }\n                    return ne ? we.filter(ne) : we;\n                  } else {\n                    var Ve = { hitTest: de, seenUids: { box: {}, circle: {} } };\n                    return this._forEachCell(D3, J, q2, K, this._queryCell, we, Ve, ne), de ? we.length > 0 : we;\n                  }\n                }, Li.prototype._queryCircle = function(D3, J, q2, K, de) {\n                  var ne = D3 - q2, we = D3 + q2, Ue = J - q2, ft = J + q2;\n                  if (we < 0 || ne > this.width || ft < 0 || Ue > this.height) return K ? false : [];\n                  var Xt = [], hr = { hitTest: K, circle: { x: D3, y: J, radius: q2 }, seenUids: { box: {}, circle: {} } };\n                  return this._forEachCell(ne, Ue, we, ft, this._queryCellCircle, Xt, hr, de), K ? Xt.length > 0 : Xt;\n                }, Li.prototype.query = function(D3, J, q2, K, de) {\n                  return this._query(D3, J, q2, K, false, de);\n                }, Li.prototype.hitTest = function(D3, J, q2, K, de) {\n                  return this._query(D3, J, q2, K, true, de);\n                }, Li.prototype.hitTestCircle = function(D3, J, q2, K) {\n                  return this._queryCircle(D3, J, q2, true, K);\n                }, Li.prototype._queryCell = function(D3, J, q2, K, de, ne, we, Ue) {\n                  var ft = we.seenUids, Xt = this.boxCells[de];\n                  if (Xt !== null) for (var hr = this.bboxes, qt = 0, Ve = Xt; qt < Ve.length; qt += 1) {\n                    var Qe = Ve[qt];\n                    if (!ft.box[Qe]) {\n                      ft.box[Qe] = true;\n                      var at = Qe * 4;\n                      if (D3 <= hr[at + 2] && J <= hr[at + 3] && q2 >= hr[at + 0] && K >= hr[at + 1] && (!Ue || Ue(this.boxKeys[Qe]))) {\n                        if (we.hitTest) return ne.push(true), true;\n                        ne.push({ key: this.boxKeys[Qe], x1: hr[at], y1: hr[at + 1], x2: hr[at + 2], y2: hr[at + 3] });\n                      }\n                    }\n                  }\n                  var Ct = this.circleCells[de];\n                  if (Ct !== null) for (var Ot = this.circles, Rt = 0, Bt = Ct; Rt < Bt.length; Rt += 1) {\n                    var Dt = Bt[Rt];\n                    if (!ft.circle[Dt]) {\n                      ft.circle[Dt] = true;\n                      var yt = Dt * 3;\n                      if (this._circleAndRectCollide(Ot[yt], Ot[yt + 1], Ot[yt + 2], D3, J, q2, K) && (!Ue || Ue(this.circleKeys[Dt]))) {\n                        if (we.hitTest) return ne.push(true), true;\n                        var Pt = Ot[yt], ht = Ot[yt + 1], ur = Ot[yt + 2];\n                        ne.push({ key: this.circleKeys[Dt], x1: Pt - ur, y1: ht - ur, x2: Pt + ur, y2: ht + ur });\n                      }\n                    }\n                  }\n                }, Li.prototype._queryCellCircle = function(D3, J, q2, K, de, ne, we, Ue) {\n                  var ft = we.circle, Xt = we.seenUids, hr = this.boxCells[de];\n                  if (hr !== null) for (var qt = this.bboxes, Ve = 0, Qe = hr; Ve < Qe.length; Ve += 1) {\n                    var at = Qe[Ve];\n                    if (!Xt.box[at]) {\n                      Xt.box[at] = true;\n                      var Ct = at * 4;\n                      if (this._circleAndRectCollide(ft.x, ft.y, ft.radius, qt[Ct + 0], qt[Ct + 1], qt[Ct + 2], qt[Ct + 3]) && (!Ue || Ue(this.boxKeys[at]))) return ne.push(true), true;\n                    }\n                  }\n                  var Ot = this.circleCells[de];\n                  if (Ot !== null) for (var Rt = this.circles, Bt = 0, Dt = Ot; Bt < Dt.length; Bt += 1) {\n                    var yt = Dt[Bt];\n                    if (!Xt.circle[yt]) {\n                      Xt.circle[yt] = true;\n                      var Pt = yt * 3;\n                      if (this._circlesCollide(Rt[Pt], Rt[Pt + 1], Rt[Pt + 2], ft.x, ft.y, ft.radius) && (!Ue || Ue(this.circleKeys[yt]))) return ne.push(true), true;\n                    }\n                  }\n                }, Li.prototype._forEachCell = function(D3, J, q2, K, de, ne, we, Ue) {\n                  for (var ft = this._convertToXCellCoord(D3), Xt = this._convertToYCellCoord(J), hr = this._convertToXCellCoord(q2), qt = this._convertToYCellCoord(K), Ve = ft; Ve <= hr; Ve++) for (var Qe = Xt; Qe <= qt; Qe++) {\n                    var at = this.xCellCount * Qe + Ve;\n                    if (de.call(this, D3, J, q2, K, at, ne, we, Ue)) return;\n                  }\n                }, Li.prototype._convertToXCellCoord = function(D3) {\n                  return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(D3 * this.xScale)));\n                }, Li.prototype._convertToYCellCoord = function(D3) {\n                  return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(D3 * this.yScale)));\n                }, Li.prototype._circlesCollide = function(D3, J, q2, K, de, ne) {\n                  var we = K - D3, Ue = de - J, ft = q2 + ne;\n                  return ft * ft > we * we + Ue * Ue;\n                }, Li.prototype._circleAndRectCollide = function(D3, J, q2, K, de, ne, we) {\n                  var Ue = (ne - K) / 2, ft = Math.abs(D3 - (K + Ue));\n                  if (ft > Ue + q2) return false;\n                  var Xt = (we - de) / 2, hr = Math.abs(J - (de + Xt));\n                  if (hr > Xt + q2) return false;\n                  if (ft <= Ue || hr <= Xt) return true;\n                  var qt = ft - Ue, Ve = hr - Xt;\n                  return qt * qt + Ve * Ve <= q2 * q2;\n                };\n                function _n(Y, D3, J, q2, K) {\n                  var de = i3.create();\n                  return D3 ? (i3.scale(de, de, [1 / K, 1 / K, 1]), J || i3.rotateZ(de, de, q2.angle)) : i3.multiply(de, q2.labelPlaneMatrix, Y), de;\n                }\n                function ya(Y, D3, J, q2, K) {\n                  if (D3) {\n                    var de = i3.clone(Y);\n                    return i3.scale(de, de, [K, K, 1]), J || i3.rotateZ(de, de, -q2.angle), de;\n                  } else return q2.glCoordMatrix;\n                }\n                function Jn(Y, D3) {\n                  var J = [Y.x, Y.y, 0, 1];\n                  zl(J, J, D3);\n                  var q2 = J[3];\n                  return { point: new i3.Point(J[0] / q2, J[1] / q2), signedDistanceFromCamera: q2 };\n                }\n                function Ma(Y, D3) {\n                  return 0.5 + 0.5 * (Y / D3);\n                }\n                function _o(Y, D3) {\n                  var J = Y[0] / Y[3], q2 = Y[1] / Y[3], K = J >= -D3[0] && J <= D3[0] && q2 >= -D3[1] && q2 <= D3[1];\n                  return K;\n                }\n                function No(Y, D3, J, q2, K, de, ne, we) {\n                  var Ue = q2 ? Y.textSizeData : Y.iconSizeData, ft = i3.evaluateSizeForZoom(Ue, J.transform.zoom), Xt = [256 / J.width * 2 + 1, 256 / J.height * 2 + 1], hr = q2 ? Y.text.dynamicLayoutVertexArray : Y.icon.dynamicLayoutVertexArray;\n                  hr.clear();\n                  for (var qt = Y.lineVertexArray, Ve = q2 ? Y.text.placedSymbolArray : Y.icon.placedSymbolArray, Qe = J.transform.width / J.transform.height, at = false, Ct = 0; Ct < Ve.length; Ct++) {\n                    var Ot = Ve.get(Ct);\n                    if (Ot.hidden || Ot.writingMode === i3.WritingMode.vertical && !at) {\n                      ul(Ot.numGlyphs, hr);\n                      continue;\n                    }\n                    at = false;\n                    var Rt = [Ot.anchorX, Ot.anchorY, 0, 1];\n                    if (i3.transformMat4(Rt, Rt, D3), !_o(Rt, Xt)) {\n                      ul(Ot.numGlyphs, hr);\n                      continue;\n                    }\n                    var Bt = Rt[3], Dt = Ma(J.transform.cameraToCenterDistance, Bt), yt = i3.evaluateSizeForFeature(Ue, ft, Ot), Pt = ne ? yt / Dt : yt * Dt, ht = new i3.Point(Ot.anchorX, Ot.anchorY), ur = Jn(ht, K).point, br = {}, Ur = ko(Ot, Pt, false, we, D3, K, de, Y.glyphOffsetArray, qt, hr, ur, ht, br, Qe);\n                    at = Ur.useVertical, (Ur.notEnoughRoom || at || Ur.needsFlipping && ko(Ot, Pt, true, we, D3, K, de, Y.glyphOffsetArray, qt, hr, ur, ht, br, Qe).notEnoughRoom) && ul(Ot.numGlyphs, hr);\n                  }\n                  q2 ? Y.text.dynamicLayoutVertexBuffer.updateData(hr) : Y.icon.dynamicLayoutVertexBuffer.updateData(hr);\n                }\n                function po(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt) {\n                  var hr = we.glyphStartIndex + we.numGlyphs, qt = we.lineStartIndex, Ve = we.lineStartIndex + we.lineLength, Qe = D3.getoffsetX(we.glyphStartIndex), at = D3.getoffsetX(hr - 1), Ct = Fs(Y * Qe, J, q2, K, de, ne, we.segment, qt, Ve, Ue, ft, Xt);\n                  if (!Ct) return null;\n                  var Ot = Fs(Y * at, J, q2, K, de, ne, we.segment, qt, Ve, Ue, ft, Xt);\n                  return Ot ? { first: Ct, last: Ot } : null;\n                }\n                function Lo(Y, D3, J, q2) {\n                  if (Y === i3.WritingMode.horizontal) {\n                    var K = Math.abs(J.y - D3.y), de = Math.abs(J.x - D3.x) * q2;\n                    if (K > de) return { useVertical: true };\n                  }\n                  return (Y === i3.WritingMode.vertical ? D3.y < J.y : D3.x > J.x) ? { needsFlipping: true } : null;\n                }\n                function ko(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr, qt, Ve) {\n                  var Qe = D3 / 24, at = Y.lineOffsetX * Qe, Ct = Y.lineOffsetY * Qe, Ot;\n                  if (Y.numGlyphs > 1) {\n                    var Rt = Y.glyphStartIndex + Y.numGlyphs, Bt = Y.lineStartIndex, Dt = Y.lineStartIndex + Y.lineLength, yt = po(Qe, we, at, Ct, J, Xt, hr, Y, Ue, de, qt);\n                    if (!yt) return { notEnoughRoom: true };\n                    var Pt = Jn(yt.first.point, ne).point, ht = Jn(yt.last.point, ne).point;\n                    if (q2 && !J) {\n                      var ur = Lo(Y.writingMode, Pt, ht, Ve);\n                      if (ur) return ur;\n                    }\n                    Ot = [yt.first];\n                    for (var br = Y.glyphStartIndex + 1; br < Rt - 1; br++) Ot.push(Fs(Qe * we.getoffsetX(br), at, Ct, J, Xt, hr, Y.segment, Bt, Dt, Ue, de, qt));\n                    Ot.push(yt.last);\n                  } else {\n                    if (q2 && !J) {\n                      var Ur = Jn(hr, K).point, Di = Y.lineStartIndex + Y.segment + 1, fi = new i3.Point(Ue.getx(Di), Ue.gety(Di)), Ti = Jn(fi, K), gn = Ti.signedDistanceFromCamera > 0 ? Ti.point : Ds(hr, fi, Ur, 1, K), rn = Lo(Y.writingMode, Ur, gn, Ve);\n                      if (rn) return rn;\n                    }\n                    var Ci = Fs(Qe * we.getoffsetX(Y.glyphStartIndex), at, Ct, J, Xt, hr, Y.segment, Y.lineStartIndex, Y.lineStartIndex + Y.lineLength, Ue, de, qt);\n                    if (!Ci) return { notEnoughRoom: true };\n                    Ot = [Ci];\n                  }\n                  for (var Bi = 0, Gi = Ot; Bi < Gi.length; Bi += 1) {\n                    var sn = Gi[Bi];\n                    i3.addDynamicAttributes(ft, sn.point, sn.angle);\n                  }\n                  return {};\n                }\n                function Ds(Y, D3, J, q2, K) {\n                  var de = Jn(Y.add(Y.sub(D3)._unit()), K).point, ne = J.sub(de);\n                  return J.add(ne._mult(q2 / ne.mag()));\n                }\n                function Fs(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr) {\n                  var qt = q2 ? Y - D3 : Y + D3, Ve = qt > 0 ? 1 : -1, Qe = 0;\n                  q2 && (Ve *= -1, Qe = Math.PI), Ve < 0 && (Qe += Math.PI);\n                  for (var at = Ve > 0 ? we + ne : we + ne + 1, Ct = K, Ot = K, Rt = 0, Bt = 0, Dt = Math.abs(qt), yt = []; Rt + Bt <= Dt; ) {\n                    if (at += Ve, at < we || at >= Ue) return null;\n                    if (Ot = Ct, yt.push(Ct), Ct = hr[at], Ct === void 0) {\n                      var Pt = new i3.Point(ft.getx(at), ft.gety(at)), ht = Jn(Pt, Xt);\n                      if (ht.signedDistanceFromCamera > 0) Ct = hr[at] = ht.point;\n                      else {\n                        var ur = at - Ve, br = Rt === 0 ? de : new i3.Point(ft.getx(ur), ft.gety(ur));\n                        Ct = Ds(br, Pt, Ot, Dt - Rt + 1, Xt);\n                      }\n                    }\n                    Rt += Bt, Bt = Ot.dist(Ct);\n                  }\n                  var Ur = (Dt - Rt) / Bt, Di = Ct.sub(Ot), fi = Di.mult(Ur)._add(Ot);\n                  fi._add(Di._unit()._perp()._mult(J * Ve));\n                  var Ti = Qe + Math.atan2(Ct.y - Ot.y, Ct.x - Ot.x);\n                  return yt.push(fi), { point: fi, angle: Ti, path: yt };\n                }\n                var ll = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);\n                function ul(Y, D3) {\n                  for (var J = 0; J < Y; J++) {\n                    var q2 = D3.length;\n                    D3.resize(q2 + 4), D3.float32.set(ll, q2 * 3);\n                  }\n                }\n                function zl(Y, D3, J) {\n                  var q2 = D3[0], K = D3[1];\n                  return Y[0] = J[0] * q2 + J[4] * K + J[12], Y[1] = J[1] * q2 + J[5] * K + J[13], Y[3] = J[3] * q2 + J[7] * K + J[15], Y;\n                }\n                var us = 100, il = function(D3, J, q2) {\n                  J === void 0 && (J = new Li(D3.width + 2 * us, D3.height + 2 * us, 25)), q2 === void 0 && (q2 = new Li(D3.width + 2 * us, D3.height + 2 * us, 25)), this.transform = D3, this.grid = J, this.ignoredGrid = q2, this.pitchfactor = Math.cos(D3._pitch) * D3.cameraToCenterDistance, this.screenRightBoundary = D3.width + us, this.screenBottomBoundary = D3.height + us, this.gridRightBoundary = D3.width + 2 * us, this.gridBottomBoundary = D3.height + 2 * us;\n                };\n                il.prototype.placeCollisionBox = function(D3, J, q2, K, de) {\n                  var ne = this.projectAndGetPerspectiveRatio(K, D3.anchorPointX, D3.anchorPointY), we = q2 * ne.perspectiveRatio, Ue = D3.x1 * we + ne.point.x, ft = D3.y1 * we + ne.point.y, Xt = D3.x2 * we + ne.point.x, hr = D3.y2 * we + ne.point.y;\n                  return !this.isInsideGrid(Ue, ft, Xt, hr) || !J && this.grid.hitTest(Ue, ft, Xt, hr, de) ? { box: [], offscreen: false } : { box: [Ue, ft, Xt, hr], offscreen: this.isOffscreen(Ue, ft, Xt, hr) };\n                }, il.prototype.placeCollisionCircles = function(D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr, qt, Ve) {\n                  var Qe = [], at = new i3.Point(J.anchorX, J.anchorY), Ct = Jn(at, ne), Ot = Ma(this.transform.cameraToCenterDistance, Ct.signedDistanceFromCamera), Rt = Xt ? de / Ot : de * Ot, Bt = Rt / i3.ONE_EM, Dt = Jn(at, we).point, yt = {}, Pt = J.lineOffsetX * Bt, ht = J.lineOffsetY * Bt, ur = po(Bt, K, Pt, ht, false, Dt, at, J, q2, we, yt), br = false, Ur = false, Di = true;\n                  if (ur) {\n                    for (var fi = qt * 0.5 * Ot + Ve, Ti = new i3.Point(-us, -us), gn = new i3.Point(this.screenRightBoundary, this.screenBottomBoundary), rn = new Mn(), Ci = ur.first, Bi = ur.last, Gi = [], sn = Ci.path.length - 1; sn >= 1; sn--) Gi.push(Ci.path[sn]);\n                    for (var zn = 1; zn < Bi.path.length; zn++) Gi.push(Bi.path[zn]);\n                    var Ja = fi * 2.5;\n                    if (Ue) {\n                      var co = Gi.map(function(Iv) {\n                        return Jn(Iv, Ue);\n                      });\n                      co.some(function(Iv) {\n                        return Iv.signedDistanceFromCamera <= 0;\n                      }) ? Gi = [] : Gi = co.map(function(Iv) {\n                        return Iv.point;\n                      });\n                    }\n                    var ts = [];\n                    if (Gi.length > 0) {\n                      for (var so = Gi[0].clone(), Zo = Gi[0].clone(), ms = 1; ms < Gi.length; ms++) so.x = Math.min(so.x, Gi[ms].x), so.y = Math.min(so.y, Gi[ms].y), Zo.x = Math.max(Zo.x, Gi[ms].x), Zo.y = Math.max(Zo.y, Gi[ms].y);\n                      so.x >= Ti.x && Zo.x <= gn.x && so.y >= Ti.y && Zo.y <= gn.y ? ts = [Gi] : Zo.x < Ti.x || so.x > gn.x || Zo.y < Ti.y || so.y > gn.y ? ts = [] : ts = i3.clipLine([Gi], Ti.x, Ti.y, gn.x, gn.y);\n                    }\n                    for (var ou = 0, Cv = ts; ou < Cv.length; ou += 1) {\n                      var Lv = Cv[ou];\n                      rn.reset(Lv, fi * 0.25);\n                      var wd = 0;\n                      rn.length <= 0.5 * fi ? wd = 1 : wd = Math.ceil(rn.paddedLength / Ja) + 1;\n                      for (var Kv = 0; Kv < wd; Kv++) {\n                        var cg = Kv / Math.max(wd - 1, 1), pp = rn.lerp(cg), Td = pp.x + us, gp = pp.y + us;\n                        Qe.push(Td, gp, fi, 0);\n                        var Vd = Td - fi, Ad = gp - fi, Pv = Td + fi, Jv = gp + fi;\n                        if (Di = Di && this.isOffscreen(Vd, Ad, Pv, Jv), Ur = Ur || this.isInsideGrid(Vd, Ad, Pv, Jv), !D3 && this.grid.hitTestCircle(Td, gp, fi, hr) && (br = true, !ft)) return { circles: [], offscreen: false, collisionDetected: br };\n                      }\n                    }\n                  }\n                  return { circles: !ft && br || !Ur ? [] : Qe, offscreen: Di, collisionDetected: br };\n                }, il.prototype.queryRenderedSymbols = function(D3) {\n                  if (D3.length === 0 || this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0) return {};\n                  for (var J = [], q2 = 1 / 0, K = 1 / 0, de = -1 / 0, ne = -1 / 0, we = 0, Ue = D3; we < Ue.length; we += 1) {\n                    var ft = Ue[we], Xt = new i3.Point(ft.x + us, ft.y + us);\n                    q2 = Math.min(q2, Xt.x), K = Math.min(K, Xt.y), de = Math.max(de, Xt.x), ne = Math.max(ne, Xt.y), J.push(Xt);\n                  }\n                  for (var hr = this.grid.query(q2, K, de, ne).concat(this.ignoredGrid.query(q2, K, de, ne)), qt = {}, Ve = {}, Qe = 0, at = hr; Qe < at.length; Qe += 1) {\n                    var Ct = at[Qe], Ot = Ct.key;\n                    if (qt[Ot.bucketInstanceId] === void 0 && (qt[Ot.bucketInstanceId] = {}), !qt[Ot.bucketInstanceId][Ot.featureIndex]) {\n                      var Rt = [new i3.Point(Ct.x1, Ct.y1), new i3.Point(Ct.x2, Ct.y1), new i3.Point(Ct.x2, Ct.y2), new i3.Point(Ct.x1, Ct.y2)];\n                      i3.polygonIntersectsPolygon(J, Rt) && (qt[Ot.bucketInstanceId][Ot.featureIndex] = true, Ve[Ot.bucketInstanceId] === void 0 && (Ve[Ot.bucketInstanceId] = []), Ve[Ot.bucketInstanceId].push(Ot.featureIndex));\n                    }\n                  }\n                  return Ve;\n                }, il.prototype.insertCollisionBox = function(D3, J, q2, K, de) {\n                  var ne = J ? this.ignoredGrid : this.grid, we = { bucketInstanceId: q2, featureIndex: K, collisionGroupID: de };\n                  ne.insert(we, D3[0], D3[1], D3[2], D3[3]);\n                }, il.prototype.insertCollisionCircles = function(D3, J, q2, K, de) {\n                  for (var ne = J ? this.ignoredGrid : this.grid, we = { bucketInstanceId: q2, featureIndex: K, collisionGroupID: de }, Ue = 0; Ue < D3.length; Ue += 4) ne.insertCircle(we, D3[Ue], D3[Ue + 1], D3[Ue + 2]);\n                }, il.prototype.projectAndGetPerspectiveRatio = function(D3, J, q2) {\n                  var K = [J, q2, 0, 1];\n                  zl(K, K, D3);\n                  var de = new i3.Point((K[0] / K[3] + 1) / 2 * this.transform.width + us, (-K[1] / K[3] + 1) / 2 * this.transform.height + us);\n                  return { point: de, perspectiveRatio: 0.5 + 0.5 * (this.transform.cameraToCenterDistance / K[3]) };\n                }, il.prototype.isOffscreen = function(D3, J, q2, K) {\n                  return q2 < us || D3 >= this.screenRightBoundary || K < us || J > this.screenBottomBoundary;\n                }, il.prototype.isInsideGrid = function(D3, J, q2, K) {\n                  return q2 >= 0 && D3 < this.gridRightBoundary && K >= 0 && J < this.gridBottomBoundary;\n                }, il.prototype.getViewportMatrix = function() {\n                  var D3 = i3.identity([]);\n                  return i3.translate(D3, D3, [-us, -us, 0]), D3;\n                };\n                function As(Y, D3, J) {\n                  return D3 * (i3.EXTENT / (Y.tileSize * Math.pow(2, J - Y.tileID.overscaledZ)));\n                }\n                var cl = function(D3, J, q2, K) {\n                  D3 ? this.opacity = Math.max(0, Math.min(1, D3.opacity + (D3.placed ? J : -J))) : this.opacity = K && q2 ? 1 : 0, this.placed = q2;\n                };\n                cl.prototype.isHidden = function() {\n                  return this.opacity === 0 && !this.placed;\n                };\n                var Ks = function(D3, J, q2, K, de) {\n                  this.text = new cl(D3 ? D3.text : null, J, q2, de), this.icon = new cl(D3 ? D3.icon : null, J, K, de);\n                };\n                Ks.prototype.isHidden = function() {\n                  return this.text.isHidden() && this.icon.isHidden();\n                };\n                var zs = function(D3, J, q2) {\n                  this.text = D3, this.icon = J, this.skipFade = q2;\n                }, Io = function() {\n                  this.invProjMatrix = i3.create(), this.viewportMatrix = i3.create(), this.circles = [];\n                }, ls = function(D3, J, q2, K, de) {\n                  this.bucketInstanceId = D3, this.featureIndex = J, this.sourceLayerIndex = q2, this.bucketIndex = K, this.tileID = de;\n                }, Zl = function(D3) {\n                  this.crossSourceCollisions = D3, this.maxGroupID = 0, this.collisionGroups = {};\n                };\n                Zl.prototype.get = function(D3) {\n                  if (this.crossSourceCollisions) return { ID: 0, predicate: null };\n                  if (!this.collisionGroups[D3]) {\n                    var J = ++this.maxGroupID;\n                    this.collisionGroups[D3] = { ID: J, predicate: function(q2) {\n                      return q2.collisionGroupID === J;\n                    } };\n                  }\n                  return this.collisionGroups[D3];\n                };\n                function Su(Y, D3, J, q2, K) {\n                  var de = i3.getAnchorAlignment(Y), ne = de.horizontalAlign, we = de.verticalAlign, Ue = -(ne - 0.5) * D3, ft = -(we - 0.5) * J, Xt = i3.evaluateVariableOffset(Y, q2);\n                  return new i3.Point(Ue + Xt[0] * K, ft + Xt[1] * K);\n                }\n                function nc(Y, D3, J, q2, K, de) {\n                  var ne = Y.x1, we = Y.x2, Ue = Y.y1, ft = Y.y2, Xt = Y.anchorPointX, hr = Y.anchorPointY, qt = new i3.Point(D3, J);\n                  return q2 && qt._rotate(K ? de : -de), { x1: ne + qt.x, y1: Ue + qt.y, x2: we + qt.x, y2: ft + qt.y, anchorPointX: Xt, anchorPointY: hr };\n                }\n                var bs = function(D3, J, q2, K) {\n                  this.transform = D3.clone(), this.collisionIndex = new il(this.transform), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = J, this.retainedQueryData = {}, this.collisionGroups = new Zl(q2), this.collisionCircleArrays = {}, this.prevPlacement = K, K && (K.prevPlacement = void 0), this.placedOrientations = {};\n                };\n                bs.prototype.getBucketParts = function(D3, J, q2, K) {\n                  var de = q2.getBucket(J), ne = q2.latestFeatureIndex;\n                  if (!(!de || !ne || J.id !== de.layerIds[0])) {\n                    var we = q2.collisionBoxArray, Ue = de.layers[0].layout, ft = Math.pow(2, this.transform.zoom - q2.tileID.overscaledZ), Xt = q2.tileSize / i3.EXTENT, hr = this.transform.calculatePosMatrix(q2.tileID.toUnwrapped()), qt = Ue.get("text-pitch-alignment") === "map", Ve = Ue.get("text-rotation-alignment") === "map", Qe = As(q2, 1, this.transform.zoom), at = _n(hr, qt, Ve, this.transform, Qe), Ct = null;\n                    if (qt) {\n                      var Ot = ya(hr, qt, Ve, this.transform, Qe);\n                      Ct = i3.multiply([], this.transform.labelPlaneMatrix, Ot);\n                    }\n                    this.retainedQueryData[de.bucketInstanceId] = new ls(de.bucketInstanceId, ne, de.sourceLayerIndex, de.index, q2.tileID);\n                    var Rt = { bucket: de, layout: Ue, posMatrix: hr, textLabelPlaneMatrix: at, labelToScreenMatrix: Ct, scale: ft, textPixelRatio: Xt, holdingForFade: q2.holdingForFade(), collisionBoxArray: we, partiallyEvaluatedTextSize: i3.evaluateSizeForZoom(de.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(de.sourceID) };\n                    if (K) for (var Bt = 0, Dt = de.sortKeyRanges; Bt < Dt.length; Bt += 1) {\n                      var yt = Dt[Bt], Pt = yt.sortKey, ht = yt.symbolInstanceStart, ur = yt.symbolInstanceEnd;\n                      D3.push({ sortKey: Pt, symbolInstanceStart: ht, symbolInstanceEnd: ur, parameters: Rt });\n                    }\n                    else D3.push({ symbolInstanceStart: 0, symbolInstanceEnd: de.symbolInstances.length, parameters: Rt });\n                  }\n                }, bs.prototype.attemptAnchorPlacement = function(D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr, qt, Ve, Qe, at) {\n                  var Ct = [qt.textOffset0, qt.textOffset1], Ot = Su(D3, q2, K, Ct, de), Rt = this.collisionIndex.placeCollisionBox(nc(J, Ot.x, Ot.y, ne, we, this.transform.angle), hr, Ue, ft, Xt.predicate);\n                  if (at) {\n                    var Bt = this.collisionIndex.placeCollisionBox(nc(at, Ot.x, Ot.y, ne, we, this.transform.angle), hr, Ue, ft, Xt.predicate);\n                    if (Bt.box.length === 0) return;\n                  }\n                  if (Rt.box.length > 0) {\n                    var Dt;\n                    return this.prevPlacement && this.prevPlacement.variableOffsets[qt.crossTileID] && this.prevPlacement.placements[qt.crossTileID] && this.prevPlacement.placements[qt.crossTileID].text && (Dt = this.prevPlacement.variableOffsets[qt.crossTileID].anchor), this.variableOffsets[qt.crossTileID] = { textOffset: Ct, width: q2, height: K, anchor: D3, textBoxScale: de, prevAnchor: Dt }, this.markUsedJustification(Ve, D3, qt, Qe), Ve.allowVerticalPlacement && (this.markUsedOrientation(Ve, Qe, qt), this.placedOrientations[qt.crossTileID] = Qe), { shift: Ot, placedGlyphBoxes: Rt };\n                  }\n                }, bs.prototype.placeLayerBucketPart = function(D3, J, q2) {\n                  var K = this, de = D3.parameters, ne = de.bucket, we = de.layout, Ue = de.posMatrix, ft = de.textLabelPlaneMatrix, Xt = de.labelToScreenMatrix, hr = de.textPixelRatio, qt = de.holdingForFade, Ve = de.collisionBoxArray, Qe = de.partiallyEvaluatedTextSize, at = de.collisionGroup, Ct = we.get("text-optional"), Ot = we.get("icon-optional"), Rt = we.get("text-allow-overlap"), Bt = we.get("icon-allow-overlap"), Dt = we.get("text-rotation-alignment") === "map", yt = we.get("text-pitch-alignment") === "map", Pt = we.get("icon-text-fit") !== "none", ht = we.get("symbol-z-order") === "viewport-y", ur = Rt && (Bt || !ne.hasIconData() || Ot), br = Bt && (Rt || !ne.hasTextData() || Ct);\n                  !ne.collisionArrays && Ve && ne.deserializeCollisionBoxes(Ve);\n                  var Ur = function(Ci, Bi) {\n                    if (!J[Ci.crossTileID]) {\n                      if (qt) {\n                        K.placements[Ci.crossTileID] = new zs(false, false, false);\n                        return;\n                      }\n                      var Gi = false, sn = false, zn = true, Ja = null, co = { box: null, offscreen: null }, ts = { box: null, offscreen: null }, so = null, Zo = null, ms = null, ou = 0, Cv = 0, Lv = 0;\n                      Bi.textFeatureIndex ? ou = Bi.textFeatureIndex : Ci.useRuntimeCollisionCircles && (ou = Ci.featureIndex), Bi.verticalTextFeatureIndex && (Cv = Bi.verticalTextFeatureIndex);\n                      var wd = Bi.textBox;\n                      if (wd) {\n                        var Kv = function(vc) {\n                          var eu = i3.WritingMode.horizontal;\n                          if (ne.allowVerticalPlacement && !vc && K.prevPlacement) {\n                            var Sd = K.prevPlacement.placedOrientations[Ci.crossTileID];\n                            Sd && (K.placedOrientations[Ci.crossTileID] = Sd, eu = Sd, K.markUsedOrientation(ne, eu, Ci));\n                          }\n                          return eu;\n                        }, cg = function(vc, eu) {\n                          if (ne.allowVerticalPlacement && Ci.numVerticalGlyphVertices > 0 && Bi.verticalTextBox) for (var Sd = 0, ly = ne.writingModes; Sd < ly.length; Sd += 1) {\n                            var T1 = ly[Sd];\n                            if (T1 === i3.WritingMode.vertical ? (co = eu(), ts = co) : co = vc(), co && co.box && co.box.length) break;\n                          }\n                          else co = vc();\n                        };\n                        if (we.get("text-variable-anchor")) {\n                          var Vd = we.get("text-variable-anchor");\n                          if (K.prevPlacement && K.prevPlacement.variableOffsets[Ci.crossTileID]) {\n                            var Ad = K.prevPlacement.variableOffsets[Ci.crossTileID];\n                            Vd.indexOf(Ad.anchor) > 0 && (Vd = Vd.filter(function(vc) {\n                              return vc !== Ad.anchor;\n                            }), Vd.unshift(Ad.anchor));\n                          }\n                          var Pv = function(vc, eu, Sd) {\n                            for (var ly = vc.x2 - vc.x1, T1 = vc.y2 - vc.y1, wu = Ci.textBoxScale, Nx = Pt && !Bt ? eu : null, om = { box: [], offscreen: false }, kw = Rt ? Vd.length * 2 : Vd.length, Rv = 0; Rv < kw; ++Rv) {\n                              var sm = Vd[Rv % Vd.length], Cw = Rv >= Vd.length, Ux = K.attemptAnchorPlacement(sm, vc, ly, T1, wu, Dt, yt, hr, Ue, at, Cw, Ci, ne, Sd, Nx);\n                              if (Ux && (om = Ux.placedGlyphBoxes, om && om.box && om.box.length)) {\n                                Gi = true, Ja = Ux.shift;\n                                break;\n                              }\n                            }\n                            return om;\n                          }, Jv = function() {\n                            return Pv(wd, Bi.iconBox, i3.WritingMode.horizontal);\n                          }, Iv = function() {\n                            var vc = Bi.verticalTextBox, eu = co && co.box && co.box.length;\n                            return ne.allowVerticalPlacement && !eu && Ci.numVerticalGlyphVertices > 0 && vc ? Pv(vc, Bi.verticalIconBox, i3.WritingMode.vertical) : { box: null, offscreen: null };\n                          };\n                          cg(Jv, Iv), co && (Gi = co.box, zn = co.offscreen);\n                          var ay = Kv(co && co.box);\n                          if (!Gi && K.prevPlacement) {\n                            var fg = K.prevPlacement.variableOffsets[Ci.crossTileID];\n                            fg && (K.variableOffsets[Ci.crossTileID] = fg, K.markUsedJustification(ne, fg.anchor, Ci, ay));\n                          }\n                        } else {\n                          var pp = function(vc, eu) {\n                            var Sd = K.collisionIndex.placeCollisionBox(vc, Rt, hr, Ue, at.predicate);\n                            return Sd && Sd.box && Sd.box.length && (K.markUsedOrientation(ne, eu, Ci), K.placedOrientations[Ci.crossTileID] = eu), Sd;\n                          }, Td = function() {\n                            return pp(wd, i3.WritingMode.horizontal);\n                          }, gp = function() {\n                            var vc = Bi.verticalTextBox;\n                            return ne.allowVerticalPlacement && Ci.numVerticalGlyphVertices > 0 && vc ? pp(vc, i3.WritingMode.vertical) : { box: null, offscreen: null };\n                          };\n                          cg(Td, gp), Kv(co && co.box && co.box.length);\n                        }\n                      }\n                      if (so = co, Gi = so && so.box && so.box.length > 0, zn = so && so.offscreen, Ci.useRuntimeCollisionCircles) {\n                        var oh = ne.text.placedSymbolArray.get(Ci.centerJustifiedTextSymbolIndex), hg = i3.evaluateSizeForFeature(ne.textSizeData, Qe, oh), oy = we.get("text-padding"), jh = Ci.collisionCircleDiameter;\n                        Zo = K.collisionIndex.placeCollisionCircles(Rt, oh, ne.lineVertexArray, ne.glyphOffsetArray, hg, Ue, ft, Xt, q2, yt, at.predicate, jh, oy), Gi = Rt || Zo.circles.length > 0 && !Zo.collisionDetected, zn = zn && Zo.offscreen;\n                      }\n                      if (Bi.iconFeatureIndex && (Lv = Bi.iconFeatureIndex), Bi.iconBox) {\n                        var im = function(vc) {\n                          var eu = Pt && Ja ? nc(vc, Ja.x, Ja.y, Dt, yt, K.transform.angle) : vc;\n                          return K.collisionIndex.placeCollisionBox(eu, Bt, hr, Ue, at.predicate);\n                        };\n                        ts && ts.box && ts.box.length && Bi.verticalIconBox ? (ms = im(Bi.verticalIconBox), sn = ms.box.length > 0) : (ms = im(Bi.iconBox), sn = ms.box.length > 0), zn = zn && ms.offscreen;\n                      }\n                      var b1 = Ct || Ci.numHorizontalGlyphVertices === 0 && Ci.numVerticalGlyphVertices === 0, w1 = Ot || Ci.numIconVertices === 0;\n                      if (!b1 && !w1 ? sn = Gi = sn && Gi : w1 ? b1 || (sn = sn && Gi) : Gi = sn && Gi, Gi && so && so.box && (ts && ts.box && Cv ? K.collisionIndex.insertCollisionBox(so.box, we.get("text-ignore-placement"), ne.bucketInstanceId, Cv, at.ID) : K.collisionIndex.insertCollisionBox(so.box, we.get("text-ignore-placement"), ne.bucketInstanceId, ou, at.ID)), sn && ms && K.collisionIndex.insertCollisionBox(ms.box, we.get("icon-ignore-placement"), ne.bucketInstanceId, Lv, at.ID), Zo && (Gi && K.collisionIndex.insertCollisionCircles(Zo.circles, we.get("text-ignore-placement"), ne.bucketInstanceId, ou, at.ID), q2)) {\n                        var sy = ne.bucketInstanceId, nm = K.collisionCircleArrays[sy];\n                        nm === void 0 && (nm = K.collisionCircleArrays[sy] = new Io());\n                        for (var am = 0; am < Zo.circles.length; am += 4) nm.circles.push(Zo.circles[am + 0]), nm.circles.push(Zo.circles[am + 1]), nm.circles.push(Zo.circles[am + 2]), nm.circles.push(Zo.collisionDetected ? 1 : 0);\n                      }\n                      K.placements[Ci.crossTileID] = new zs(Gi || ur, sn || br, zn || ne.justReloaded), J[Ci.crossTileID] = true;\n                    }\n                  };\n                  if (ht) for (var Di = ne.getSortedSymbolIndexes(this.transform.angle), fi = Di.length - 1; fi >= 0; --fi) {\n                    var Ti = Di[fi];\n                    Ur(ne.symbolInstances.get(Ti), ne.collisionArrays[Ti]);\n                  }\n                  else for (var gn = D3.symbolInstanceStart; gn < D3.symbolInstanceEnd; gn++) Ur(ne.symbolInstances.get(gn), ne.collisionArrays[gn]);\n                  if (q2 && ne.bucketInstanceId in this.collisionCircleArrays) {\n                    var rn = this.collisionCircleArrays[ne.bucketInstanceId];\n                    i3.invert(rn.invProjMatrix, Ue), rn.viewportMatrix = this.collisionIndex.getViewportMatrix();\n                  }\n                  ne.justReloaded = false;\n                }, bs.prototype.markUsedJustification = function(D3, J, q2, K) {\n                  var de = { left: q2.leftJustifiedTextSymbolIndex, center: q2.centerJustifiedTextSymbolIndex, right: q2.rightJustifiedTextSymbolIndex }, ne;\n                  K === i3.WritingMode.vertical ? ne = q2.verticalPlacedTextSymbolIndex : ne = de[i3.getAnchorJustification(J)];\n                  for (var we = [q2.leftJustifiedTextSymbolIndex, q2.centerJustifiedTextSymbolIndex, q2.rightJustifiedTextSymbolIndex, q2.verticalPlacedTextSymbolIndex], Ue = 0, ft = we; Ue < ft.length; Ue += 1) {\n                    var Xt = ft[Ue];\n                    Xt >= 0 && (ne >= 0 && Xt !== ne ? D3.text.placedSymbolArray.get(Xt).crossTileID = 0 : D3.text.placedSymbolArray.get(Xt).crossTileID = q2.crossTileID);\n                  }\n                }, bs.prototype.markUsedOrientation = function(D3, J, q2) {\n                  for (var K = J === i3.WritingMode.horizontal || J === i3.WritingMode.horizontalOnly ? J : 0, de = J === i3.WritingMode.vertical ? J : 0, ne = [q2.leftJustifiedTextSymbolIndex, q2.centerJustifiedTextSymbolIndex, q2.rightJustifiedTextSymbolIndex], we = 0, Ue = ne; we < Ue.length; we += 1) {\n                    var ft = Ue[we];\n                    D3.text.placedSymbolArray.get(ft).placedOrientation = K;\n                  }\n                  q2.verticalPlacedTextSymbolIndex && (D3.text.placedSymbolArray.get(q2.verticalPlacedTextSymbolIndex).placedOrientation = de);\n                }, bs.prototype.commit = function(D3) {\n                  this.commitTime = D3, this.zoomAtLastRecencyCheck = this.transform.zoom;\n                  var J = this.prevPlacement, q2 = false;\n                  this.prevZoomAdjustment = J ? J.zoomAdjustment(this.transform.zoom) : 0;\n                  var K = J ? J.symbolFadeChange(D3) : 1, de = J ? J.opacities : {}, ne = J ? J.variableOffsets : {}, we = J ? J.placedOrientations : {};\n                  for (var Ue in this.placements) {\n                    var ft = this.placements[Ue], Xt = de[Ue];\n                    Xt ? (this.opacities[Ue] = new Ks(Xt, K, ft.text, ft.icon), q2 = q2 || ft.text !== Xt.text.placed || ft.icon !== Xt.icon.placed) : (this.opacities[Ue] = new Ks(null, K, ft.text, ft.icon, ft.skipFade), q2 = q2 || ft.text || ft.icon);\n                  }\n                  for (var hr in de) {\n                    var qt = de[hr];\n                    if (!this.opacities[hr]) {\n                      var Ve = new Ks(qt, K, false, false);\n                      Ve.isHidden() || (this.opacities[hr] = Ve, q2 = q2 || qt.text.placed || qt.icon.placed);\n                    }\n                  }\n                  for (var Qe in ne) !this.variableOffsets[Qe] && this.opacities[Qe] && !this.opacities[Qe].isHidden() && (this.variableOffsets[Qe] = ne[Qe]);\n                  for (var at in we) !this.placedOrientations[at] && this.opacities[at] && !this.opacities[at].isHidden() && (this.placedOrientations[at] = we[at]);\n                  q2 ? this.lastPlacementChangeTime = D3 : typeof this.lastPlacementChangeTime != "number" && (this.lastPlacementChangeTime = J ? J.lastPlacementChangeTime : D3);\n                }, bs.prototype.updateLayerOpacities = function(D3, J) {\n                  for (var q2 = {}, K = 0, de = J; K < de.length; K += 1) {\n                    var ne = de[K], we = ne.getBucket(D3);\n                    we && ne.latestFeatureIndex && D3.id === we.layerIds[0] && this.updateBucketOpacities(we, q2, ne.collisionBoxArray);\n                  }\n                }, bs.prototype.updateBucketOpacities = function(D3, J, q2) {\n                  var K = this;\n                  D3.hasTextData() && D3.text.opacityVertexArray.clear(), D3.hasIconData() && D3.icon.opacityVertexArray.clear(), D3.hasIconCollisionBoxData() && D3.iconCollisionBox.collisionVertexArray.clear(), D3.hasTextCollisionBoxData() && D3.textCollisionBox.collisionVertexArray.clear();\n                  var de = D3.layers[0].layout, ne = new Ks(null, 0, false, false, true), we = de.get("text-allow-overlap"), Ue = de.get("icon-allow-overlap"), ft = de.get("text-variable-anchor"), Xt = de.get("text-rotation-alignment") === "map", hr = de.get("text-pitch-alignment") === "map", qt = de.get("icon-text-fit") !== "none", Ve = new Ks(null, 0, we && (Ue || !D3.hasIconData() || de.get("icon-optional")), Ue && (we || !D3.hasTextData() || de.get("text-optional")), true);\n                  !D3.collisionArrays && q2 && (D3.hasIconCollisionBoxData() || D3.hasTextCollisionBoxData()) && D3.deserializeCollisionBoxes(q2);\n                  for (var Qe = function(Rt, Bt, Dt) {\n                    for (var yt = 0; yt < Bt / 4; yt++) Rt.opacityVertexArray.emplaceBack(Dt);\n                  }, at = function(Rt) {\n                    var Bt = D3.symbolInstances.get(Rt), Dt = Bt.numHorizontalGlyphVertices, yt = Bt.numVerticalGlyphVertices, Pt = Bt.crossTileID, ht = J[Pt], ur = K.opacities[Pt];\n                    ht ? ur = ne : ur || (ur = Ve, K.opacities[Pt] = ur), J[Pt] = true;\n                    var br = Dt > 0 || yt > 0, Ur = Bt.numIconVertices > 0, Di = K.placedOrientations[Bt.crossTileID], fi = Di === i3.WritingMode.vertical, Ti = Di === i3.WritingMode.horizontal || Di === i3.WritingMode.horizontalOnly;\n                    if (br) {\n                      var gn = ac(ur.text), rn = fi ? aa : gn;\n                      Qe(D3.text, Dt, rn);\n                      var Ci = Ti ? aa : gn;\n                      Qe(D3.text, yt, Ci);\n                      var Bi = ur.text.isHidden();\n                      [Bt.rightJustifiedTextSymbolIndex, Bt.centerJustifiedTextSymbolIndex, Bt.leftJustifiedTextSymbolIndex].forEach(function(Lv) {\n                        Lv >= 0 && (D3.text.placedSymbolArray.get(Lv).hidden = Bi || fi ? 1 : 0);\n                      }), Bt.verticalPlacedTextSymbolIndex >= 0 && (D3.text.placedSymbolArray.get(Bt.verticalPlacedTextSymbolIndex).hidden = Bi || Ti ? 1 : 0);\n                      var Gi = K.variableOffsets[Bt.crossTileID];\n                      Gi && K.markUsedJustification(D3, Gi.anchor, Bt, Di);\n                      var sn = K.placedOrientations[Bt.crossTileID];\n                      sn && (K.markUsedJustification(D3, "left", Bt, sn), K.markUsedOrientation(D3, sn, Bt));\n                    }\n                    if (Ur) {\n                      var zn = ac(ur.icon), Ja = !(qt && Bt.verticalPlacedIconSymbolIndex && fi);\n                      if (Bt.placedIconSymbolIndex >= 0) {\n                        var co = Ja ? zn : aa;\n                        Qe(D3.icon, Bt.numIconVertices, co), D3.icon.placedSymbolArray.get(Bt.placedIconSymbolIndex).hidden = ur.icon.isHidden();\n                      }\n                      if (Bt.verticalPlacedIconSymbolIndex >= 0) {\n                        var ts = Ja ? aa : zn;\n                        Qe(D3.icon, Bt.numVerticalIconVertices, ts), D3.icon.placedSymbolArray.get(Bt.verticalPlacedIconSymbolIndex).hidden = ur.icon.isHidden();\n                      }\n                    }\n                    if (D3.hasIconCollisionBoxData() || D3.hasTextCollisionBoxData()) {\n                      var so = D3.collisionArrays[Rt];\n                      if (so) {\n                        var Zo = new i3.Point(0, 0);\n                        if (so.textBox || so.verticalTextBox) {\n                          var ms = true;\n                          if (ft) {\n                            var ou = K.variableOffsets[Pt];\n                            ou ? (Zo = Su(ou.anchor, ou.width, ou.height, ou.textOffset, ou.textBoxScale), Xt && Zo._rotate(hr ? K.transform.angle : -K.transform.angle)) : ms = false;\n                          }\n                          so.textBox && Rn(D3.textCollisionBox.collisionVertexArray, ur.text.placed, !ms || fi, Zo.x, Zo.y), so.verticalTextBox && Rn(D3.textCollisionBox.collisionVertexArray, ur.text.placed, !ms || Ti, Zo.x, Zo.y);\n                        }\n                        var Cv = !!(!Ti && so.verticalIconBox);\n                        so.iconBox && Rn(D3.iconCollisionBox.collisionVertexArray, ur.icon.placed, Cv, qt ? Zo.x : 0, qt ? Zo.y : 0), so.verticalIconBox && Rn(D3.iconCollisionBox.collisionVertexArray, ur.icon.placed, !Cv, qt ? Zo.x : 0, qt ? Zo.y : 0);\n                      }\n                    }\n                  }, Ct = 0; Ct < D3.symbolInstances.length; Ct++) at(Ct);\n                  if (D3.sortFeatures(this.transform.angle), this.retainedQueryData[D3.bucketInstanceId] && (this.retainedQueryData[D3.bucketInstanceId].featureSortOrder = D3.featureSortOrder), D3.hasTextData() && D3.text.opacityVertexBuffer && D3.text.opacityVertexBuffer.updateData(D3.text.opacityVertexArray), D3.hasIconData() && D3.icon.opacityVertexBuffer && D3.icon.opacityVertexBuffer.updateData(D3.icon.opacityVertexArray), D3.hasIconCollisionBoxData() && D3.iconCollisionBox.collisionVertexBuffer && D3.iconCollisionBox.collisionVertexBuffer.updateData(D3.iconCollisionBox.collisionVertexArray), D3.hasTextCollisionBoxData() && D3.textCollisionBox.collisionVertexBuffer && D3.textCollisionBox.collisionVertexBuffer.updateData(D3.textCollisionBox.collisionVertexArray), D3.bucketInstanceId in this.collisionCircleArrays) {\n                    var Ot = this.collisionCircleArrays[D3.bucketInstanceId];\n                    D3.placementInvProjMatrix = Ot.invProjMatrix, D3.placementViewportMatrix = Ot.viewportMatrix, D3.collisionCircleArray = Ot.circles, delete this.collisionCircleArrays[D3.bucketInstanceId];\n                  }\n                }, bs.prototype.symbolFadeChange = function(D3) {\n                  return this.fadeDuration === 0 ? 1 : (D3 - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;\n                }, bs.prototype.zoomAdjustment = function(D3) {\n                  return Math.max(0, (this.transform.zoom - D3) / 1.5);\n                }, bs.prototype.hasTransitions = function(D3) {\n                  return this.stale || D3 - this.lastPlacementChangeTime < this.fadeDuration;\n                }, bs.prototype.stillRecent = function(D3, J) {\n                  var q2 = this.zoomAtLastRecencyCheck === J ? 1 - this.zoomAdjustment(J) : 1;\n                  return this.zoomAtLastRecencyCheck = J, this.commitTime + this.fadeDuration * q2 > D3;\n                }, bs.prototype.setStale = function() {\n                  this.stale = true;\n                };\n                function Rn(Y, D3, J, q2, K) {\n                  Y.emplaceBack(D3 ? 1 : 0, J ? 1 : 0, q2 || 0, K || 0), Y.emplaceBack(D3 ? 1 : 0, J ? 1 : 0, q2 || 0, K || 0), Y.emplaceBack(D3 ? 1 : 0, J ? 1 : 0, q2 || 0, K || 0), Y.emplaceBack(D3 ? 1 : 0, J ? 1 : 0, q2 || 0, K || 0);\n                }\n                var _a = Math.pow(2, 25), Vu = Math.pow(2, 24), Ol = Math.pow(2, 17), xo = Math.pow(2, 16), Yl = Math.pow(2, 9), Ns = Math.pow(2, 8), Hl = Math.pow(2, 1);\n                function ac(Y) {\n                  if (Y.opacity === 0 && !Y.placed) return 0;\n                  if (Y.opacity === 1 && Y.placed) return 4294967295;\n                  var D3 = Y.placed ? 1 : 0, J = Math.floor(Y.opacity * 127);\n                  return J * _a + D3 * Vu + J * Ol + D3 * xo + J * Yl + D3 * Ns + J * Hl + D3;\n                }\n                var aa = 0, Oo = function(D3) {\n                  this._sortAcrossTiles = D3.layout.get("symbol-z-order") !== "viewport-y" && D3.layout.get("symbol-sort-key").constantOr(1) !== void 0, this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];\n                };\n                Oo.prototype.continuePlacement = function(D3, J, q2, K, de) {\n                  for (var ne = this._bucketParts; this._currentTileIndex < D3.length; ) {\n                    var we = D3[this._currentTileIndex];\n                    if (J.getBucketParts(ne, K, we, this._sortAcrossTiles), this._currentTileIndex++, de()) return true;\n                  }\n                  for (this._sortAcrossTiles && (this._sortAcrossTiles = false, ne.sort(function(ft, Xt) {\n                    return ft.sortKey - Xt.sortKey;\n                  })); this._currentPartIndex < ne.length; ) {\n                    var Ue = ne[this._currentPartIndex];\n                    if (J.placeLayerBucketPart(Ue, this._seenCrossTileIDs, q2), this._currentPartIndex++, de()) return true;\n                  }\n                  return false;\n                };\n                var qo = function(D3, J, q2, K, de, ne, we) {\n                  this.placement = new bs(D3, de, ne, we), this._currentPlacementIndex = J.length - 1, this._forceFullPlacement = q2, this._showCollisionBoxes = K, this._done = false;\n                };\n                qo.prototype.isDone = function() {\n                  return this._done;\n                }, qo.prototype.continuePlacement = function(D3, J, q2) {\n                  for (var K = this, de = i3.browser.now(), ne = function() {\n                    var hr = i3.browser.now() - de;\n                    return K._forceFullPlacement ? false : hr > 2;\n                  }; this._currentPlacementIndex >= 0; ) {\n                    var we = D3[this._currentPlacementIndex], Ue = J[we], ft = this.placement.collisionIndex.transform.zoom;\n                    if (Ue.type === "symbol" && (!Ue.minzoom || Ue.minzoom <= ft) && (!Ue.maxzoom || Ue.maxzoom > ft)) {\n                      this._inProgressLayer || (this._inProgressLayer = new Oo(Ue));\n                      var Xt = this._inProgressLayer.continuePlacement(q2[Ue.source], this.placement, this._showCollisionBoxes, Ue, ne);\n                      if (Xt) return;\n                      delete this._inProgressLayer;\n                    }\n                    this._currentPlacementIndex--;\n                  }\n                  this._done = true;\n                }, qo.prototype.commit = function(D3) {\n                  return this.placement.commit(D3), this.placement;\n                };\n                var ql = 512 / i3.EXTENT / 2, Pc = function(D3, J, q2) {\n                  this.tileID = D3, this.indexedSymbolInstances = {}, this.bucketInstanceId = q2;\n                  for (var K = 0; K < J.length; K++) {\n                    var de = J.get(K), ne = de.key;\n                    this.indexedSymbolInstances[ne] || (this.indexedSymbolInstances[ne] = []), this.indexedSymbolInstances[ne].push({ crossTileID: de.crossTileID, coord: this.getScaledCoordinates(de, D3) });\n                  }\n                };\n                Pc.prototype.getScaledCoordinates = function(D3, J) {\n                  var q2 = J.canonical.z - this.tileID.canonical.z, K = ql / Math.pow(2, q2);\n                  return { x: Math.floor((J.canonical.x * i3.EXTENT + D3.anchorX) * K), y: Math.floor((J.canonical.y * i3.EXTENT + D3.anchorY) * K) };\n                }, Pc.prototype.findMatches = function(D3, J, q2) {\n                  for (var K = this.tileID.canonical.z < J.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - J.canonical.z), de = 0; de < D3.length; de++) {\n                    var ne = D3.get(de);\n                    if (!ne.crossTileID) {\n                      var we = this.indexedSymbolInstances[ne.key];\n                      if (we) for (var Ue = this.getScaledCoordinates(ne, J), ft = 0, Xt = we; ft < Xt.length; ft += 1) {\n                        var hr = Xt[ft];\n                        if (Math.abs(hr.coord.x - Ue.x) <= K && Math.abs(hr.coord.y - Ue.y) <= K && !q2[hr.crossTileID]) {\n                          q2[hr.crossTileID] = true, ne.crossTileID = hr.crossTileID;\n                          break;\n                        }\n                      }\n                    }\n                  }\n                };\n                var Do = function() {\n                  this.maxCrossTileID = 0;\n                };\n                Do.prototype.generate = function() {\n                  return ++this.maxCrossTileID;\n                };\n                var rf = function() {\n                  this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;\n                };\n                rf.prototype.handleWrapJump = function(D3) {\n                  var J = Math.round((D3 - this.lng) / 360);\n                  if (J !== 0) for (var q2 in this.indexes) {\n                    var K = this.indexes[q2], de = {};\n                    for (var ne in K) {\n                      var we = K[ne];\n                      we.tileID = we.tileID.unwrapTo(we.tileID.wrap + J), de[we.tileID.key] = we;\n                    }\n                    this.indexes[q2] = de;\n                  }\n                  this.lng = D3;\n                }, rf.prototype.addBucket = function(D3, J, q2) {\n                  if (this.indexes[D3.overscaledZ] && this.indexes[D3.overscaledZ][D3.key]) {\n                    if (this.indexes[D3.overscaledZ][D3.key].bucketInstanceId === J.bucketInstanceId) return false;\n                    this.removeBucketCrossTileIDs(D3.overscaledZ, this.indexes[D3.overscaledZ][D3.key]);\n                  }\n                  for (var K = 0; K < J.symbolInstances.length; K++) {\n                    var de = J.symbolInstances.get(K);\n                    de.crossTileID = 0;\n                  }\n                  this.usedCrossTileIDs[D3.overscaledZ] || (this.usedCrossTileIDs[D3.overscaledZ] = {});\n                  var ne = this.usedCrossTileIDs[D3.overscaledZ];\n                  for (var we in this.indexes) {\n                    var Ue = this.indexes[we];\n                    if (Number(we) > D3.overscaledZ) for (var ft in Ue) {\n                      var Xt = Ue[ft];\n                      Xt.tileID.isChildOf(D3) && Xt.findMatches(J.symbolInstances, D3, ne);\n                    }\n                    else {\n                      var hr = D3.scaledTo(Number(we)), qt = Ue[hr.key];\n                      qt && qt.findMatches(J.symbolInstances, D3, ne);\n                    }\n                  }\n                  for (var Ve = 0; Ve < J.symbolInstances.length; Ve++) {\n                    var Qe = J.symbolInstances.get(Ve);\n                    Qe.crossTileID || (Qe.crossTileID = q2.generate(), ne[Qe.crossTileID] = true);\n                  }\n                  return this.indexes[D3.overscaledZ] === void 0 && (this.indexes[D3.overscaledZ] = {}), this.indexes[D3.overscaledZ][D3.key] = new Pc(D3, J.symbolInstances, J.bucketInstanceId), true;\n                }, rf.prototype.removeBucketCrossTileIDs = function(D3, J) {\n                  for (var q2 in J.indexedSymbolInstances) for (var K = 0, de = J.indexedSymbolInstances[q2]; K < de.length; K += 1) {\n                    var ne = de[K];\n                    delete this.usedCrossTileIDs[D3][ne.crossTileID];\n                  }\n                }, rf.prototype.removeStaleBuckets = function(D3) {\n                  var J = false;\n                  for (var q2 in this.indexes) {\n                    var K = this.indexes[q2];\n                    for (var de in K) D3[K[de].bucketInstanceId] || (this.removeBucketCrossTileIDs(q2, K[de]), delete K[de], J = true);\n                  }\n                  return J;\n                };\n                var Uf = function() {\n                  this.layerIndexes = {}, this.crossTileIDs = new Do(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};\n                };\n                Uf.prototype.addLayer = function(D3, J, q2) {\n                  var K = this.layerIndexes[D3.id];\n                  K === void 0 && (K = this.layerIndexes[D3.id] = new rf());\n                  var de = false, ne = {};\n                  K.handleWrapJump(q2);\n                  for (var we = 0, Ue = J; we < Ue.length; we += 1) {\n                    var ft = Ue[we], Xt = ft.getBucket(D3);\n                    !Xt || D3.id !== Xt.layerIds[0] || (Xt.bucketInstanceId || (Xt.bucketInstanceId = ++this.maxBucketInstanceId), K.addBucket(ft.tileID, Xt, this.crossTileIDs) && (de = true), ne[Xt.bucketInstanceId] = true);\n                  }\n                  return K.removeStaleBuckets(ne) && (de = true), de;\n                }, Uf.prototype.pruneUnusedLayers = function(D3) {\n                  var J = {};\n                  D3.forEach(function(K) {\n                    J[K] = true;\n                  });\n                  for (var q2 in this.layerIndexes) J[q2] || delete this.layerIndexes[q2];\n                };\n                var pl = function(Y, D3) {\n                  return i3.emitValidationErrors(Y, D3 && D3.filter(function(J) {\n                    return J.identifier !== "source.canvas";\n                  }));\n                }, Zc = i3.pick(da, ["addLayer", "removeLayer", "setPaintProperty", "setLayoutProperty", "setFilter", "addSource", "removeSource", "setLayerZoomRange", "setLight", "setTransition", "setGeoJSONSourceData"]), Kl = i3.pick(da, ["setCenter", "setZoom", "setBearing", "setPitch"]), Os = Wo(), yu = (function(Y) {\n                  function D3(J, q2) {\n                    var K = this;\n                    q2 === void 0 && (q2 = {}), Y.call(this), this.map = J, this.dispatcher = new Z(Ba(), this), this.imageManager = new k4(), this.imageManager.setEventedParent(this), this.glyphManager = new P3(J._requestManager, q2.localIdeographFontFamily), this.lineAtlas = new G2(256, 512), this.crossTileSymbolIndex = new Uf(), this._layers = {}, this._serializedLayers = {}, this._order = [], this.sourceCaches = {}, this.zoomHistory = new i3.ZoomHistory(), this._loaded = false, this._availableImages = [], this._resetUpdates(), this.dispatcher.broadcast("setReferrer", i3.getReferrer());\n                    var de = this;\n                    this._rtlTextPluginCallback = D3.registerForPluginStateChange(function(ne) {\n                      var we = { pluginStatus: ne.pluginStatus, pluginURL: ne.pluginURL };\n                      de.dispatcher.broadcast("syncRTLPluginState", we, function(Ue, ft) {\n                        if (i3.triggerPluginCompletionEvent(Ue), ft) {\n                          var Xt = ft.every(function(qt) {\n                            return qt;\n                          });\n                          if (Xt) for (var hr in de.sourceCaches) de.sourceCaches[hr].reload();\n                        }\n                      });\n                    }), this.on("data", function(ne) {\n                      if (!(ne.dataType !== "source" || ne.sourceDataType !== "metadata")) {\n                        var we = K.sourceCaches[ne.sourceId];\n                        if (we) {\n                          var Ue = we.getSource();\n                          if (!(!Ue || !Ue.vectorLayerIds)) for (var ft in K._layers) {\n                            var Xt = K._layers[ft];\n                            Xt.source === Ue.id && K._validateLayer(Xt);\n                          }\n                        }\n                      }\n                    });\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.loadURL = function(q2, K) {\n                    var de = this;\n                    K === void 0 && (K = {}), this.fire(new i3.Event("dataloading", { dataType: "style" }));\n                    var ne = typeof K.validate == "boolean" ? K.validate : !i3.isMapboxURL(q2);\n                    q2 = this.map._requestManager.normalizeStyleURL(q2, K.accessToken);\n                    var we = this.map._requestManager.transformRequest(q2, i3.ResourceType.Style);\n                    this._request = i3.getJSON(we, function(Ue, ft) {\n                      de._request = null, Ue ? de.fire(new i3.ErrorEvent(Ue)) : ft && de._load(ft, ne);\n                    });\n                  }, D3.prototype.loadJSON = function(q2, K) {\n                    var de = this;\n                    K === void 0 && (K = {}), this.fire(new i3.Event("dataloading", { dataType: "style" })), this._request = i3.browser.frame(function() {\n                      de._request = null, de._load(q2, K.validate !== false);\n                    });\n                  }, D3.prototype.loadEmpty = function() {\n                    this.fire(new i3.Event("dataloading", { dataType: "style" })), this._load(Os, false);\n                  }, D3.prototype._load = function(q2, K) {\n                    if (!(K && pl(this, i3.validateStyle(q2)))) {\n                      this._loaded = true, this.stylesheet = q2;\n                      for (var de in q2.sources) this.addSource(de, q2.sources[de], { validate: false });\n                      q2.sprite ? this._loadSprite(q2.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(q2.glyphs);\n                      var ne = Fa(this.stylesheet.layers);\n                      this._order = ne.map(function(Xt) {\n                        return Xt.id;\n                      }), this._layers = {}, this._serializedLayers = {};\n                      for (var we = 0, Ue = ne; we < Ue.length; we += 1) {\n                        var ft = Ue[we];\n                        ft = i3.createStyleLayer(ft), ft.setEventedParent(this, { layer: { id: ft.id } }), this._layers[ft.id] = ft, this._serializedLayers[ft.id] = ft.serialize();\n                      }\n                      this.dispatcher.broadcast("setLayers", this._serializeLayers(this._order)), this.light = new V2(this.stylesheet.light), this.fire(new i3.Event("data", { dataType: "style" })), this.fire(new i3.Event("style.load"));\n                    }\n                  }, D3.prototype._loadSprite = function(q2) {\n                    var K = this;\n                    this._spriteRequest = _2(q2, this.map._requestManager, function(de, ne) {\n                      if (K._spriteRequest = null, de) K.fire(new i3.ErrorEvent(de));\n                      else if (ne) for (var we in ne) K.imageManager.addImage(we, ne[we]);\n                      K.imageManager.setLoaded(true), K._availableImages = K.imageManager.listImages(), K.dispatcher.broadcast("setImages", K._availableImages), K.fire(new i3.Event("data", { dataType: "style" }));\n                    });\n                  }, D3.prototype._validateLayer = function(q2) {\n                    var K = this.sourceCaches[q2.source];\n                    if (K) {\n                      var de = q2.sourceLayer;\n                      if (de) {\n                        var ne = K.getSource();\n                        (ne.type === "geojson" || ne.vectorLayerIds && ne.vectorLayerIds.indexOf(de) === -1) && this.fire(new i3.ErrorEvent(new Error(\'Source layer "\' + de + \'" does not exist on source "\' + ne.id + \'" as specified by style layer "\' + q2.id + \'"\')));\n                      }\n                    }\n                  }, D3.prototype.loaded = function() {\n                    if (!this._loaded || Object.keys(this._updatedSources).length) return false;\n                    for (var q2 in this.sourceCaches) if (!this.sourceCaches[q2].loaded()) return false;\n                    return !!this.imageManager.isLoaded();\n                  }, D3.prototype._serializeLayers = function(q2) {\n                    for (var K = [], de = 0, ne = q2; de < ne.length; de += 1) {\n                      var we = ne[de], Ue = this._layers[we];\n                      Ue.type !== "custom" && K.push(Ue.serialize());\n                    }\n                    return K;\n                  }, D3.prototype.hasTransitions = function() {\n                    if (this.light && this.light.hasTransition()) return true;\n                    for (var q2 in this.sourceCaches) if (this.sourceCaches[q2].hasTransition()) return true;\n                    for (var K in this._layers) if (this._layers[K].hasTransition()) return true;\n                    return false;\n                  }, D3.prototype._checkLoaded = function() {\n                    if (!this._loaded) throw new Error("Style is not done loading");\n                  }, D3.prototype.update = function(q2) {\n                    if (this._loaded) {\n                      var K = this._changed;\n                      if (this._changed) {\n                        var de = Object.keys(this._updatedLayers), ne = Object.keys(this._removedLayers);\n                        (de.length || ne.length) && this._updateWorkerLayers(de, ne);\n                        for (var we in this._updatedSources) {\n                          var Ue = this._updatedSources[we];\n                          Ue === "reload" ? this._reloadSource(we) : Ue === "clear" && this._clearSource(we);\n                        }\n                        this._updateTilesForChangedImages();\n                        for (var ft in this._updatedPaintProps) this._layers[ft].updateTransitions(q2);\n                        this.light.updateTransitions(q2), this._resetUpdates();\n                      }\n                      var Xt = {};\n                      for (var hr in this.sourceCaches) {\n                        var qt = this.sourceCaches[hr];\n                        Xt[hr] = qt.used, qt.used = false;\n                      }\n                      for (var Ve = 0, Qe = this._order; Ve < Qe.length; Ve += 1) {\n                        var at = Qe[Ve], Ct = this._layers[at];\n                        Ct.recalculate(q2, this._availableImages), !Ct.isHidden(q2.zoom) && Ct.source && (this.sourceCaches[Ct.source].used = true);\n                      }\n                      for (var Ot in Xt) {\n                        var Rt = this.sourceCaches[Ot];\n                        Xt[Ot] !== Rt.used && Rt.fire(new i3.Event("data", { sourceDataType: "visibility", dataType: "source", sourceId: Ot }));\n                      }\n                      this.light.recalculate(q2), this.z = q2.zoom, K && this.fire(new i3.Event("data", { dataType: "style" }));\n                    }\n                  }, D3.prototype._updateTilesForChangedImages = function() {\n                    var q2 = Object.keys(this._changedImages);\n                    if (q2.length) {\n                      for (var K in this.sourceCaches) this.sourceCaches[K].reloadTilesForDependencies(["icons", "patterns"], q2);\n                      this._changedImages = {};\n                    }\n                  }, D3.prototype._updateWorkerLayers = function(q2, K) {\n                    this.dispatcher.broadcast("updateLayers", { layers: this._serializeLayers(q2), removedIds: K });\n                  }, D3.prototype._resetUpdates = function() {\n                    this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {};\n                  }, D3.prototype.setState = function(q2) {\n                    var K = this;\n                    if (this._checkLoaded(), pl(this, i3.validateStyle(q2))) return false;\n                    q2 = i3.clone$1(q2), q2.layers = Fa(q2.layers);\n                    var de = An(this.serialize(), q2).filter(function(we) {\n                      return !(we.command in Kl);\n                    });\n                    if (de.length === 0) return false;\n                    var ne = de.filter(function(we) {\n                      return !(we.command in Zc);\n                    });\n                    if (ne.length > 0) throw new Error("Unimplemented: " + ne.map(function(we) {\n                      return we.command;\n                    }).join(", ") + ".");\n                    return de.forEach(function(we) {\n                      we.command !== "setTransition" && K[we.command].apply(K, we.args);\n                    }), this.stylesheet = q2, true;\n                  }, D3.prototype.addImage = function(q2, K) {\n                    if (this.getImage(q2)) return this.fire(new i3.ErrorEvent(new Error("An image with this name already exists.")));\n                    this.imageManager.addImage(q2, K), this._afterImageUpdated(q2);\n                  }, D3.prototype.updateImage = function(q2, K) {\n                    this.imageManager.updateImage(q2, K);\n                  }, D3.prototype.getImage = function(q2) {\n                    return this.imageManager.getImage(q2);\n                  }, D3.prototype.removeImage = function(q2) {\n                    if (!this.getImage(q2)) return this.fire(new i3.ErrorEvent(new Error("No image with this name exists.")));\n                    this.imageManager.removeImage(q2), this._afterImageUpdated(q2);\n                  }, D3.prototype._afterImageUpdated = function(q2) {\n                    this._availableImages = this.imageManager.listImages(), this._changedImages[q2] = true, this._changed = true, this.dispatcher.broadcast("setImages", this._availableImages), this.fire(new i3.Event("data", { dataType: "style" }));\n                  }, D3.prototype.listImages = function() {\n                    return this._checkLoaded(), this.imageManager.listImages();\n                  }, D3.prototype.addSource = function(q2, K, de) {\n                    var ne = this;\n                    if (de === void 0 && (de = {}), this._checkLoaded(), this.sourceCaches[q2] !== void 0) throw new Error("There is already a source with this ID");\n                    if (!K.type) throw new Error("The type property must be defined, but only the following properties were given: " + Object.keys(K).join(", ") + ".");\n                    var we = ["vector", "raster", "geojson", "video", "image"], Ue = we.indexOf(K.type) >= 0;\n                    if (!(Ue && this._validate(i3.validateStyle.source, "sources." + q2, K, null, de))) {\n                      this.map && this.map._collectResourceTiming && (K.collectResourceTiming = true);\n                      var ft = this.sourceCaches[q2] = new ri(q2, K, this.dispatcher);\n                      ft.style = this, ft.setEventedParent(this, function() {\n                        return { isSourceLoaded: ne.loaded(), source: ft.serialize(), sourceId: q2 };\n                      }), ft.onAdd(this.map), this._changed = true;\n                    }\n                  }, D3.prototype.removeSource = function(q2) {\n                    if (this._checkLoaded(), this.sourceCaches[q2] === void 0) throw new Error("There is no source with this ID");\n                    for (var K in this._layers) if (this._layers[K].source === q2) return this.fire(new i3.ErrorEvent(new Error(\'Source "\' + q2 + \'" cannot be removed while layer "\' + K + \'" is using it.\')));\n                    var de = this.sourceCaches[q2];\n                    delete this.sourceCaches[q2], delete this._updatedSources[q2], de.fire(new i3.Event("data", { sourceDataType: "metadata", dataType: "source", sourceId: q2 })), de.setEventedParent(null), de.clearTiles(), de.onRemove && de.onRemove(this.map), this._changed = true;\n                  }, D3.prototype.setGeoJSONSourceData = function(q2, K) {\n                    this._checkLoaded();\n                    var de = this.sourceCaches[q2].getSource();\n                    de.setData(K), this._changed = true;\n                  }, D3.prototype.getSource = function(q2) {\n                    return this.sourceCaches[q2] && this.sourceCaches[q2].getSource();\n                  }, D3.prototype.addLayer = function(q2, K, de) {\n                    de === void 0 && (de = {}), this._checkLoaded();\n                    var ne = q2.id;\n                    if (this.getLayer(ne)) {\n                      this.fire(new i3.ErrorEvent(new Error(\'Layer with id "\' + ne + \'" already exists on this map\')));\n                      return;\n                    }\n                    var we;\n                    if (q2.type === "custom") {\n                      if (pl(this, i3.validateCustomStyleLayer(q2))) return;\n                      we = i3.createStyleLayer(q2);\n                    } else {\n                      if (typeof q2.source == "object" && (this.addSource(ne, q2.source), q2 = i3.clone$1(q2), q2 = i3.extend(q2, { source: ne })), this._validate(i3.validateStyle.layer, "layers." + ne, q2, { arrayIndex: -1 }, de)) return;\n                      we = i3.createStyleLayer(q2), this._validateLayer(we), we.setEventedParent(this, { layer: { id: ne } }), this._serializedLayers[we.id] = we.serialize();\n                    }\n                    var Ue = K ? this._order.indexOf(K) : this._order.length;\n                    if (K && Ue === -1) {\n                      this.fire(new i3.ErrorEvent(new Error(\'Layer with id "\' + K + \'" does not exist on this map.\')));\n                      return;\n                    }\n                    if (this._order.splice(Ue, 0, ne), this._layerOrderChanged = true, this._layers[ne] = we, this._removedLayers[ne] && we.source && we.type !== "custom") {\n                      var ft = this._removedLayers[ne];\n                      delete this._removedLayers[ne], ft.type !== we.type ? this._updatedSources[we.source] = "clear" : (this._updatedSources[we.source] = "reload", this.sourceCaches[we.source].pause());\n                    }\n                    this._updateLayer(we), we.onAdd && we.onAdd(this.map);\n                  }, D3.prototype.moveLayer = function(q2, K) {\n                    this._checkLoaded(), this._changed = true;\n                    var de = this._layers[q2];\n                    if (!de) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot be moved.")));\n                      return;\n                    }\n                    if (q2 !== K) {\n                      var ne = this._order.indexOf(q2);\n                      this._order.splice(ne, 1);\n                      var we = K ? this._order.indexOf(K) : this._order.length;\n                      if (K && we === -1) {\n                        this.fire(new i3.ErrorEvent(new Error(\'Layer with id "\' + K + \'" does not exist on this map.\')));\n                        return;\n                      }\n                      this._order.splice(we, 0, q2), this._layerOrderChanged = true;\n                    }\n                  }, D3.prototype.removeLayer = function(q2) {\n                    this._checkLoaded();\n                    var K = this._layers[q2];\n                    if (!K) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot be removed.")));\n                      return;\n                    }\n                    K.setEventedParent(null);\n                    var de = this._order.indexOf(q2);\n                    this._order.splice(de, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[q2] = K, delete this._layers[q2], delete this._serializedLayers[q2], delete this._updatedLayers[q2], delete this._updatedPaintProps[q2], K.onRemove && K.onRemove(this.map);\n                  }, D3.prototype.getLayer = function(q2) {\n                    return this._layers[q2];\n                  }, D3.prototype.hasLayer = function(q2) {\n                    return q2 in this._layers;\n                  }, D3.prototype.setLayerZoomRange = function(q2, K, de) {\n                    this._checkLoaded();\n                    var ne = this.getLayer(q2);\n                    if (!ne) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot have zoom extent.")));\n                      return;\n                    }\n                    ne.minzoom === K && ne.maxzoom === de || (K != null && (ne.minzoom = K), de != null && (ne.maxzoom = de), this._updateLayer(ne));\n                  }, D3.prototype.setFilter = function(q2, K, de) {\n                    de === void 0 && (de = {}), this._checkLoaded();\n                    var ne = this.getLayer(q2);\n                    if (!ne) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot be filtered.")));\n                      return;\n                    }\n                    if (!i3.deepEqual(ne.filter, K)) {\n                      if (K == null) {\n                        ne.filter = void 0, this._updateLayer(ne);\n                        return;\n                      }\n                      this._validate(i3.validateStyle.filter, "layers." + ne.id + ".filter", K, null, de) || (ne.filter = i3.clone$1(K), this._updateLayer(ne));\n                    }\n                  }, D3.prototype.getFilter = function(q2) {\n                    return i3.clone$1(this.getLayer(q2).filter);\n                  }, D3.prototype.setLayoutProperty = function(q2, K, de, ne) {\n                    ne === void 0 && (ne = {}), this._checkLoaded();\n                    var we = this.getLayer(q2);\n                    if (!we) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot be styled.")));\n                      return;\n                    }\n                    i3.deepEqual(we.getLayoutProperty(K), de) || (we.setLayoutProperty(K, de, ne), this._updateLayer(we));\n                  }, D3.prototype.getLayoutProperty = function(q2, K) {\n                    var de = this.getLayer(q2);\n                    if (!de) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style.")));\n                      return;\n                    }\n                    return de.getLayoutProperty(K);\n                  }, D3.prototype.setPaintProperty = function(q2, K, de, ne) {\n                    ne === void 0 && (ne = {}), this._checkLoaded();\n                    var we = this.getLayer(q2);\n                    if (!we) {\n                      this.fire(new i3.ErrorEvent(new Error("The layer \'" + q2 + "\' does not exist in the map\'s style and cannot be styled.")));\n                      return;\n                    }\n                    if (!i3.deepEqual(we.getPaintProperty(K), de)) {\n                      var Ue = we.setPaintProperty(K, de, ne);\n                      Ue && this._updateLayer(we), this._changed = true, this._updatedPaintProps[q2] = true;\n                    }\n                  }, D3.prototype.getPaintProperty = function(q2, K) {\n                    return this.getLayer(q2).getPaintProperty(K);\n                  }, D3.prototype.setFeatureState = function(q2, K) {\n                    this._checkLoaded();\n                    var de = q2.source, ne = q2.sourceLayer, we = this.sourceCaches[de];\n                    if (we === void 0) {\n                      this.fire(new i3.ErrorEvent(new Error("The source \'" + de + "\' does not exist in the map\'s style.")));\n                      return;\n                    }\n                    var Ue = we.getSource().type;\n                    if (Ue === "geojson" && ne) {\n                      this.fire(new i3.ErrorEvent(new Error("GeoJSON sources cannot have a sourceLayer parameter.")));\n                      return;\n                    }\n                    if (Ue === "vector" && !ne) {\n                      this.fire(new i3.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                      return;\n                    }\n                    q2.id === void 0 && this.fire(new i3.ErrorEvent(new Error("The feature id parameter must be provided."))), we.setFeatureState(ne, q2.id, K);\n                  }, D3.prototype.removeFeatureState = function(q2, K) {\n                    this._checkLoaded();\n                    var de = q2.source, ne = this.sourceCaches[de];\n                    if (ne === void 0) {\n                      this.fire(new i3.ErrorEvent(new Error("The source \'" + de + "\' does not exist in the map\'s style.")));\n                      return;\n                    }\n                    var we = ne.getSource().type, Ue = we === "vector" ? q2.sourceLayer : void 0;\n                    if (we === "vector" && !Ue) {\n                      this.fire(new i3.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                      return;\n                    }\n                    if (K && typeof q2.id != "string" && typeof q2.id != "number") {\n                      this.fire(new i3.ErrorEvent(new Error("A feature id is required to remove its specific state property.")));\n                      return;\n                    }\n                    ne.removeFeatureState(Ue, q2.id, K);\n                  }, D3.prototype.getFeatureState = function(q2) {\n                    this._checkLoaded();\n                    var K = q2.source, de = q2.sourceLayer, ne = this.sourceCaches[K];\n                    if (ne === void 0) {\n                      this.fire(new i3.ErrorEvent(new Error("The source \'" + K + "\' does not exist in the map\'s style.")));\n                      return;\n                    }\n                    var we = ne.getSource().type;\n                    if (we === "vector" && !de) {\n                      this.fire(new i3.ErrorEvent(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                      return;\n                    }\n                    return q2.id === void 0 && this.fire(new i3.ErrorEvent(new Error("The feature id parameter must be provided."))), ne.getFeatureState(de, q2.id);\n                  }, D3.prototype.getTransition = function() {\n                    return i3.extend({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);\n                  }, D3.prototype.serialize = function() {\n                    return i3.filterObject({ version: this.stylesheet.version, name: this.stylesheet.name, metadata: this.stylesheet.metadata, light: this.stylesheet.light, center: this.stylesheet.center, zoom: this.stylesheet.zoom, bearing: this.stylesheet.bearing, pitch: this.stylesheet.pitch, sprite: this.stylesheet.sprite, glyphs: this.stylesheet.glyphs, transition: this.stylesheet.transition, sources: i3.mapObject(this.sourceCaches, function(q2) {\n                      return q2.serialize();\n                    }), layers: this._serializeLayers(this._order) }, function(q2) {\n                      return q2 !== void 0;\n                    });\n                  }, D3.prototype._updateLayer = function(q2) {\n                    this._updatedLayers[q2.id] = true, q2.source && !this._updatedSources[q2.source] && this.sourceCaches[q2.source].getSource().type !== "raster" && (this._updatedSources[q2.source] = "reload", this.sourceCaches[q2.source].pause()), this._changed = true;\n                  }, D3.prototype._flattenAndSortRenderedFeatures = function(q2) {\n                    for (var K = this, de = function(Ti) {\n                      return K._layers[Ti].type === "fill-extrusion";\n                    }, ne = {}, we = [], Ue = this._order.length - 1; Ue >= 0; Ue--) {\n                      var ft = this._order[Ue];\n                      if (de(ft)) {\n                        ne[ft] = Ue;\n                        for (var Xt = 0, hr = q2; Xt < hr.length; Xt += 1) {\n                          var qt = hr[Xt], Ve = qt[ft];\n                          if (Ve) for (var Qe = 0, at = Ve; Qe < at.length; Qe += 1) {\n                            var Ct = at[Qe];\n                            we.push(Ct);\n                          }\n                        }\n                      }\n                    }\n                    we.sort(function(Ti, gn) {\n                      return gn.intersectionZ - Ti.intersectionZ;\n                    });\n                    for (var Ot = [], Rt = this._order.length - 1; Rt >= 0; Rt--) {\n                      var Bt = this._order[Rt];\n                      if (de(Bt)) for (var Dt = we.length - 1; Dt >= 0; Dt--) {\n                        var yt = we[Dt].feature;\n                        if (ne[yt.layer.id] < Rt) break;\n                        Ot.push(yt), we.pop();\n                      }\n                      else for (var Pt = 0, ht = q2; Pt < ht.length; Pt += 1) {\n                        var ur = ht[Pt], br = ur[Bt];\n                        if (br) for (var Ur = 0, Di = br; Ur < Di.length; Ur += 1) {\n                          var fi = Di[Ur];\n                          Ot.push(fi.feature);\n                        }\n                      }\n                    }\n                    return Ot;\n                  }, D3.prototype.queryRenderedFeatures = function(q2, K, de) {\n                    K && K.filter && this._validate(i3.validateStyle.filter, "queryRenderedFeatures.filter", K.filter, null, K);\n                    var ne = {};\n                    if (K && K.layers) {\n                      if (!Array.isArray(K.layers)) return this.fire(new i3.ErrorEvent(new Error("parameters.layers must be an Array."))), [];\n                      for (var we = 0, Ue = K.layers; we < Ue.length; we += 1) {\n                        var ft = Ue[we], Xt = this._layers[ft];\n                        if (!Xt) return this.fire(new i3.ErrorEvent(new Error("The layer \'" + ft + "\' does not exist in the map\'s style and cannot be queried for features."))), [];\n                        ne[Xt.source] = true;\n                      }\n                    }\n                    var hr = [];\n                    K.availableImages = this._availableImages;\n                    for (var qt in this.sourceCaches) K.layers && !ne[qt] || hr.push(ce(this.sourceCaches[qt], this._layers, this._serializedLayers, q2, K, de));\n                    return this.placement && hr.push(Ze(this._layers, this._serializedLayers, this.sourceCaches, q2, K, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(hr);\n                  }, D3.prototype.querySourceFeatures = function(q2, K) {\n                    K && K.filter && this._validate(i3.validateStyle.filter, "querySourceFeatures.filter", K.filter, null, K);\n                    var de = this.sourceCaches[q2];\n                    return de ? ut(de, K) : [];\n                  }, D3.prototype.addSourceType = function(q2, K, de) {\n                    if (D3.getSourceType(q2)) return de(new Error(\'A source type called "\' + q2 + \'" already exists.\'));\n                    if (D3.setSourceType(q2, K), !K.workerSourceURL) return de(null, null);\n                    this.dispatcher.broadcast("loadWorkerSource", { name: q2, url: K.workerSourceURL }, de);\n                  }, D3.prototype.getLight = function() {\n                    return this.light.getLight();\n                  }, D3.prototype.setLight = function(q2, K) {\n                    K === void 0 && (K = {}), this._checkLoaded();\n                    var de = this.light.getLight(), ne = false;\n                    for (var we in q2) if (!i3.deepEqual(q2[we], de[we])) {\n                      ne = true;\n                      break;\n                    }\n                    if (ne) {\n                      var Ue = { now: i3.browser.now(), transition: i3.extend({ duration: 300, delay: 0 }, this.stylesheet.transition) };\n                      this.light.setLight(q2, K), this.light.updateTransitions(Ue);\n                    }\n                  }, D3.prototype._validate = function(q2, K, de, ne, we) {\n                    return we === void 0 && (we = {}), we && we.validate === false ? false : pl(this, q2.call(i3.validateStyle, i3.extend({ key: K, style: this.serialize(), value: de, styleSpec: i3.styleSpec }, ne)));\n                  }, D3.prototype._remove = function() {\n                    this._request && (this._request.cancel(), this._request = null), this._spriteRequest && (this._spriteRequest.cancel(), this._spriteRequest = null), i3.evented.off("pluginStateChange", this._rtlTextPluginCallback);\n                    for (var q2 in this._layers) {\n                      var K = this._layers[q2];\n                      K.setEventedParent(null);\n                    }\n                    for (var de in this.sourceCaches) this.sourceCaches[de].clearTiles(), this.sourceCaches[de].setEventedParent(null);\n                    this.imageManager.setEventedParent(null), this.setEventedParent(null), this.dispatcher.remove();\n                  }, D3.prototype._clearSource = function(q2) {\n                    this.sourceCaches[q2].clearTiles();\n                  }, D3.prototype._reloadSource = function(q2) {\n                    this.sourceCaches[q2].resume(), this.sourceCaches[q2].reload();\n                  }, D3.prototype._updateSources = function(q2) {\n                    for (var K in this.sourceCaches) this.sourceCaches[K].update(q2);\n                  }, D3.prototype._generateCollisionBoxes = function() {\n                    for (var q2 in this.sourceCaches) this._reloadSource(q2);\n                  }, D3.prototype._updatePlacement = function(q2, K, de, ne, we) {\n                    we === void 0 && (we = false);\n                    for (var Ue = false, ft = false, Xt = {}, hr = 0, qt = this._order; hr < qt.length; hr += 1) {\n                      var Ve = qt[hr], Qe = this._layers[Ve];\n                      if (Qe.type === "symbol") {\n                        if (!Xt[Qe.source]) {\n                          var at = this.sourceCaches[Qe.source];\n                          Xt[Qe.source] = at.getRenderableIds(true).map(function(Pt) {\n                            return at.getTileByID(Pt);\n                          }).sort(function(Pt, ht) {\n                            return ht.tileID.overscaledZ - Pt.tileID.overscaledZ || (Pt.tileID.isLessThan(ht.tileID) ? -1 : 1);\n                          });\n                        }\n                        var Ct = this.crossTileSymbolIndex.addLayer(Qe, Xt[Qe.source], q2.center.lng);\n                        Ue = Ue || Ct;\n                      }\n                    }\n                    if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), we = we || this._layerOrderChanged || de === 0, (we || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(i3.browser.now(), q2.zoom)) && (this.pauseablePlacement = new qo(q2, this._order, we, K, de, ne, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, Xt), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(i3.browser.now()), ft = true), Ue && this.pauseablePlacement.placement.setStale()), ft || Ue) for (var Ot = 0, Rt = this._order; Ot < Rt.length; Ot += 1) {\n                      var Bt = Rt[Ot], Dt = this._layers[Bt];\n                      Dt.type === "symbol" && this.placement.updateLayerOpacities(Dt, Xt[Dt.source]);\n                    }\n                    var yt = !this.pauseablePlacement.isDone() || this.placement.hasTransitions(i3.browser.now());\n                    return yt;\n                  }, D3.prototype._releaseSymbolFadeTiles = function() {\n                    for (var q2 in this.sourceCaches) this.sourceCaches[q2].releaseSymbolFadeTiles();\n                  }, D3.prototype.getImages = function(q2, K, de) {\n                    this.imageManager.getImages(K.icons, de), this._updateTilesForChangedImages();\n                    var ne = this.sourceCaches[K.source];\n                    ne && ne.setDependencies(K.tileID.key, K.type, K.icons);\n                  }, D3.prototype.getGlyphs = function(q2, K, de) {\n                    this.glyphManager.getGlyphs(K.stacks, de);\n                  }, D3.prototype.getResource = function(q2, K, de) {\n                    return i3.makeRequest(K, de);\n                  }, D3;\n                })(i3.Evented);\n                yu.getSourceType = Fe, yu.setSourceType = Pe, yu.registerForPluginStateChange = i3.registerForPluginStateChange;\n                var oc = i3.createLayout([{ name: "a_pos", type: "Int16", components: 2 }]), Cf = `#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif`, sc = `#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}`, Vh = `uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Lf = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}", cs = `uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, nf = "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}", Vf = `varying vec3 v_data;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);lowp float antialiasblur=v_data.z;float antialiased_blur=-max(blur,antialiasblur);float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Jl = `uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,0,1);} else {gl_Position=u_matrix*vec4(circle_center,0,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}lowp float antialiasblur=1.0/u_device_pixel_ratio/(radius+stroke_width);v_data=vec3(extrude.x,extrude.y,antialiasblur);}`, fl = "void main() {gl_FragColor=vec4(1.0);}", lc = "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}", Fu = `uniform highp float u_intensity;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma mapbox: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Es = `uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#pragma mapbox: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma mapbox: initialize highp float weight\n#pragma mapbox: initialize mediump float radius\nvec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,0,1);gl_Position=u_matrix*pos;}`, Hs = `uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(0.0);\n#endif\n}`, Go = "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}", ps = "varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}", uc = "attribute vec2 a_pos;attribute vec2 a_anchor_pos;attribute vec2 a_extrude;attribute vec2 a_placed;attribute vec2 a_shift;uniform mat4 u_matrix;uniform vec2 u_extrude_scale;uniform float u_camera_to_center_distance;varying float v_placed;varying float v_notUsed;void main() {vec4 projectedPoint=u_matrix*vec4(a_anchor_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);gl_Position=u_matrix*vec4(a_pos,0.0,1.0);gl_Position.xy+=(a_extrude+a_shift)*u_extrude_scale*gl_Position.w*collision_perspective_ratio;v_placed=a_placed.x;v_notUsed=a_placed.y;}", xl = "varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}", Gu = "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}", qs = "uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}", ad = "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,0,1);}", Po = `#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_FragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, od = `attribute vec2 a_pos;uniform mat4 u_matrix;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);}`, Yo = `varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Pa = `attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`, af = `uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Hu = `uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`, bl = `uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Gf = `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}`, Ic = `varying vec4 v_color;void main() {gl_FragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, yf = `uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec4 v_color;\n#pragma mapbox: define highp float base\n#pragma mapbox: define highp float height\n#pragma mapbox: define highp vec4 color\nvoid main() {\n#pragma mapbox: initialize highp float base\n#pragma mapbox: initialize highp float height\n#pragma mapbox: initialize highp vec4 color\nvec3 normal=a_normal_ed.xyz;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}`, Bl = `uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, wh = `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;base=max(0.0,base);height=max(0.0,height);float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}`, Qf = `#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, _f = "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}", Yc = `uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;\n#define PI 3.141592653589793\nvoid main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, eh = "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}", th = `uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, ju = `\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}`, Hf = `uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, cc = `\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_width2=vec2(outset,inset);}`, of = `uniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Nl = `\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}`, Kc = `uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Rc = `\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;float extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;v_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}`, gs = `uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, jf = "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}", Gh = `uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, rh = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0),0.0,1.0);v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;v_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));}`, sf = `#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, Th = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}`, Mu = `#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, ih = `const float PI=3.141592653589793;attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec4 projectedPoint=u_matrix*vec4(a_pos,0,1);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=u_matrix*vec4(a_pos+vec2(1,0),0,1);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy,0.0,1.0);gl_Position=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale),0.0,1.0);float gamma_scale=gl_Position.w;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(1.0,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}`, js = Us(Cf, sc), Eu = Us(Vh, Lf), Dc = Us(cs, nf), ks = Us(Vf, Jl), bc = Us(fl, lc), hu = Us(Fu, Es), _u = Us(Hs, Go), nl = Us(ps, uc), nh = Us(xl, Gu), Ah = Us(qs, ad), zu = Us(Po, od), Fc = Us(Yo, Pa), wc = Us(af, Hu), bd = Us(bl, Gf), xf = Us(Ic, yf), Pf = Us(Bl, wh), Ou = Us(Qf, _f), bf = Us(Yc, eh), jl = Us(th, ju), lf = Us(Hf, cc), Hh = Us(of, Nl), If = Us(Kc, Rc), Cs = Us(gs, jf), du = Us(Gh, rh), ku = Us(sf, Th), Wf = Us(Mu, ih);\n                function Us(Y, D3) {\n                  var J = /#pragma mapbox: ([\\w]+) ([\\w]+) ([\\w]+) ([\\w]+)/g, q2 = D3.match(/attribute ([\\w]+) ([\\w]+)/g), K = Y.match(/uniform ([\\w]+) ([\\w]+)([\\s]*)([\\w]*)/g), de = D3.match(/uniform ([\\w]+) ([\\w]+)([\\s]*)([\\w]*)/g), ne = de ? de.concat(K) : K, we = {};\n                  return Y = Y.replace(J, function(Ue, ft, Xt, hr, qt) {\n                    return we[qt] = true, ft === "define" ? `\n#ifndef HAS_UNIFORM_u_` + qt + `\nvarying ` + Xt + " " + hr + " " + qt + `;\n#else\nuniform ` + Xt + " " + hr + " u_" + qt + `;\n#endif\n` : `\n#ifdef HAS_UNIFORM_u_` + qt + `\n    ` + Xt + " " + hr + " " + qt + " = u_" + qt + `;\n#endif\n`;\n                  }), D3 = D3.replace(J, function(Ue, ft, Xt, hr, qt) {\n                    var Ve = hr === "float" ? "vec2" : "vec4", Qe = qt.match(/color/) ? "color" : Ve;\n                    return we[qt] ? ft === "define" ? `\n#ifndef HAS_UNIFORM_u_` + qt + `\nuniform lowp float u_` + qt + `_t;\nattribute ` + Xt + " " + Ve + " a_" + qt + `;\nvarying ` + Xt + " " + hr + " " + qt + `;\n#else\nuniform ` + Xt + " " + hr + " u_" + qt + `;\n#endif\n` : Qe === "vec4" ? `\n#ifndef HAS_UNIFORM_u_` + qt + `\n    ` + qt + " = a_" + qt + `;\n#else\n    ` + Xt + " " + hr + " " + qt + " = u_" + qt + `;\n#endif\n` : `\n#ifndef HAS_UNIFORM_u_` + qt + `\n    ` + qt + " = unpack_mix_" + Qe + "(a_" + qt + ", u_" + qt + `_t);\n#else\n    ` + Xt + " " + hr + " " + qt + " = u_" + qt + `;\n#endif\n` : ft === "define" ? `\n#ifndef HAS_UNIFORM_u_` + qt + `\nuniform lowp float u_` + qt + `_t;\nattribute ` + Xt + " " + Ve + " a_" + qt + `;\n#else\nuniform ` + Xt + " " + hr + " u_" + qt + `;\n#endif\n` : Qe === "vec4" ? `\n#ifndef HAS_UNIFORM_u_` + qt + `\n    ` + Xt + " " + hr + " " + qt + " = a_" + qt + `;\n#else\n    ` + Xt + " " + hr + " " + qt + " = u_" + qt + `;\n#endif\n` : `\n#ifndef HAS_UNIFORM_u_` + qt + `\n    ` + Xt + " " + hr + " " + qt + " = unpack_mix_" + Qe + "(a_" + qt + ", u_" + qt + `_t);\n#else\n    ` + Xt + " " + hr + " " + qt + " = u_" + qt + `;\n#endif\n`;\n                  }), { fragmentSource: Y, vertexSource: D3, staticAttributes: q2, staticUniforms: ne };\n                }\n                var wf = Object.freeze({ __proto__: null, prelude: js, background: Eu, backgroundPattern: Dc, circle: ks, clippingMask: bc, heatmap: hu, heatmapTexture: _u, collisionBox: nl, collisionCircle: nh, debug: Ah, fill: zu, fillOutline: Fc, fillOutlinePattern: wc, fillPattern: bd, fillExtrusion: xf, fillExtrusionPattern: Pf, hillshadePrepare: Ou, hillshade: bf, line: jl, lineGradient: lf, linePattern: Hh, lineSDF: If, raster: Cs, symbolIcon: du, symbolSDF: ku, symbolTextAndIcon: Wf }), zc = function() {\n                  this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;\n                };\n                zc.prototype.bind = function(D3, J, q2, K, de, ne, we, Ue) {\n                  this.context = D3;\n                  for (var ft = this.boundPaintVertexBuffers.length !== K.length, Xt = 0; !ft && Xt < K.length; Xt++) this.boundPaintVertexBuffers[Xt] !== K[Xt] && (ft = true);\n                  var hr = !this.vao || this.boundProgram !== J || this.boundLayoutVertexBuffer !== q2 || ft || this.boundIndexBuffer !== de || this.boundVertexOffset !== ne || this.boundDynamicVertexBuffer !== we || this.boundDynamicVertexBuffer2 !== Ue;\n                  !D3.extVertexArrayObject || hr ? this.freshBind(J, q2, K, de, ne, we, Ue) : (D3.bindVertexArrayOES.set(this.vao), we && we.bind(), de && de.dynamicDraw && de.bind(), Ue && Ue.bind());\n                }, zc.prototype.freshBind = function(D3, J, q2, K, de, ne, we) {\n                  var Ue, ft = D3.numAttributes, Xt = this.context, hr = Xt.gl;\n                  if (Xt.extVertexArrayObject) this.vao && this.destroy(), this.vao = Xt.extVertexArrayObject.createVertexArrayOES(), Xt.bindVertexArrayOES.set(this.vao), Ue = 0, this.boundProgram = D3, this.boundLayoutVertexBuffer = J, this.boundPaintVertexBuffers = q2, this.boundIndexBuffer = K, this.boundVertexOffset = de, this.boundDynamicVertexBuffer = ne, this.boundDynamicVertexBuffer2 = we;\n                  else {\n                    Ue = Xt.currentNumAttributes || 0;\n                    for (var qt = ft; qt < Ue; qt++) hr.disableVertexAttribArray(qt);\n                  }\n                  J.enableAttributes(hr, D3);\n                  for (var Ve = 0, Qe = q2; Ve < Qe.length; Ve += 1) {\n                    var at = Qe[Ve];\n                    at.enableAttributes(hr, D3);\n                  }\n                  ne && ne.enableAttributes(hr, D3), we && we.enableAttributes(hr, D3), J.bind(), J.setVertexAttribPointers(hr, D3, de);\n                  for (var Ct = 0, Ot = q2; Ct < Ot.length; Ct += 1) {\n                    var Rt = Ot[Ct];\n                    Rt.bind(), Rt.setVertexAttribPointers(hr, D3, de);\n                  }\n                  ne && (ne.bind(), ne.setVertexAttribPointers(hr, D3, de)), K && K.bind(), we && (we.bind(), we.setVertexAttribPointers(hr, D3, de)), Xt.currentNumAttributes = ft;\n                }, zc.prototype.destroy = function() {\n                  this.vao && (this.context.extVertexArrayObject.deleteVertexArrayOES(this.vao), this.vao = null);\n                };\n                function Wu(Y) {\n                  for (var D3 = [], J = 0; J < Y.length; J++) if (Y[J] !== null) {\n                    var q2 = Y[J].split(" ");\n                    D3.push(q2.pop());\n                  }\n                  return D3;\n                }\n                var Rf = function(D3, J, q2, K, de, ne) {\n                  var we = D3.gl;\n                  this.program = we.createProgram();\n                  for (var Ue = Wu(q2.staticAttributes), ft = K ? K.getBinderAttributes() : [], Xt = Ue.concat(ft), hr = q2.staticUniforms ? Wu(q2.staticUniforms) : [], qt = K ? K.getBinderUniforms() : [], Ve = hr.concat(qt), Qe = [], at = 0, Ct = Ve; at < Ct.length; at += 1) {\n                    var Ot = Ct[at];\n                    Qe.indexOf(Ot) < 0 && Qe.push(Ot);\n                  }\n                  var Rt = K ? K.defines() : [];\n                  ne && Rt.push("#define OVERDRAW_INSPECTOR;");\n                  var Bt = Rt.concat(js.fragmentSource, q2.fragmentSource).join(`\n`), Dt = Rt.concat(js.vertexSource, q2.vertexSource).join(`\n`), yt = we.createShader(we.FRAGMENT_SHADER);\n                  if (we.isContextLost()) {\n                    this.failedToCreate = true;\n                    return;\n                  }\n                  we.shaderSource(yt, Bt), we.compileShader(yt), we.attachShader(this.program, yt);\n                  var Pt = we.createShader(we.VERTEX_SHADER);\n                  if (we.isContextLost()) {\n                    this.failedToCreate = true;\n                    return;\n                  }\n                  we.shaderSource(Pt, Dt), we.compileShader(Pt), we.attachShader(this.program, Pt), this.attributes = {};\n                  var ht = {};\n                  this.numAttributes = Xt.length;\n                  for (var ur = 0; ur < this.numAttributes; ur++) Xt[ur] && (we.bindAttribLocation(this.program, ur, Xt[ur]), this.attributes[Xt[ur]] = ur);\n                  we.linkProgram(this.program), we.deleteShader(Pt), we.deleteShader(yt);\n                  for (var br = 0; br < Qe.length; br++) {\n                    var Ur = Qe[br];\n                    if (Ur && !ht[Ur]) {\n                      var Di = we.getUniformLocation(this.program, Ur);\n                      Di && (ht[Ur] = Di);\n                    }\n                  }\n                  this.fixedUniforms = de(D3, ht), this.binderUniforms = K ? K.getUniforms(D3, ht) : [];\n                };\n                Rf.prototype.draw = function(D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr, qt, Ve, Qe, at, Ct) {\n                  var Ot, Rt = D3.gl;\n                  if (!this.failedToCreate) {\n                    D3.program.set(this.program), D3.setDepthMode(q2), D3.setStencilMode(K), D3.setColorMode(de), D3.setCullFace(ne);\n                    for (var Bt in this.fixedUniforms) this.fixedUniforms[Bt].set(we[Bt]);\n                    Qe && Qe.setUniforms(D3, this.binderUniforms, qt, { zoom: Ve });\n                    for (var Dt = (Ot = {}, Ot[Rt.LINES] = 2, Ot[Rt.TRIANGLES] = 3, Ot[Rt.LINE_STRIP] = 1, Ot)[J], yt = 0, Pt = hr.get(); yt < Pt.length; yt += 1) {\n                      var ht = Pt[yt], ur = ht.vaos || (ht.vaos = {}), br = ur[Ue] || (ur[Ue] = new zc());\n                      br.bind(D3, this, ft, Qe ? Qe.getPaintVertexBuffers() : [], Xt, ht.vertexOffset, at, Ct), Rt.drawElements(J, ht.primitiveLength * Dt, Rt.UNSIGNED_SHORT, ht.primitiveOffset * Dt * 2);\n                    }\n                  }\n                };\n                function Xu(Y, D3, J) {\n                  var q2 = 1 / As(J, 1, D3.transform.tileZoom), K = Math.pow(2, J.tileID.overscaledZ), de = J.tileSize * Math.pow(2, D3.transform.tileZoom) / K, ne = de * (J.tileID.canonical.x + J.tileID.wrap * K), we = de * J.tileID.canonical.y;\n                  return { u_image: 0, u_texsize: J.imageAtlasTexture.size, u_scale: [q2, Y.fromScale, Y.toScale], u_fade: Y.t, u_pixel_coord_upper: [ne >> 16, we >> 16], u_pixel_coord_lower: [ne & 65535, we & 65535] };\n                }\n                function uf(Y, D3, J, q2) {\n                  var K = J.imageManager.getPattern(Y.from.toString()), de = J.imageManager.getPattern(Y.to.toString()), ne = J.imageManager.getPixelSize(), we = ne.width, Ue = ne.height, ft = Math.pow(2, q2.tileID.overscaledZ), Xt = q2.tileSize * Math.pow(2, J.transform.tileZoom) / ft, hr = Xt * (q2.tileID.canonical.x + q2.tileID.wrap * ft), qt = Xt * q2.tileID.canonical.y;\n                  return { u_image: 0, u_pattern_tl_a: K.tl, u_pattern_br_a: K.br, u_pattern_tl_b: de.tl, u_pattern_br_b: de.br, u_texsize: [we, Ue], u_mix: D3.t, u_pattern_size_a: K.displaySize, u_pattern_size_b: de.displaySize, u_scale_a: D3.fromScale, u_scale_b: D3.toScale, u_tile_units_to_pixels: 1 / As(q2, 1, J.transform.tileZoom), u_pixel_coord_upper: [hr >> 16, qt >> 16], u_pixel_coord_lower: [hr & 65535, qt & 65535] };\n                }\n                var Xf = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_lightpos: new i3.Uniform3f(Y, D3.u_lightpos), u_lightintensity: new i3.Uniform1f(Y, D3.u_lightintensity), u_lightcolor: new i3.Uniform3f(Y, D3.u_lightcolor), u_vertical_gradient: new i3.Uniform1f(Y, D3.u_vertical_gradient), u_opacity: new i3.Uniform1f(Y, D3.u_opacity) };\n                }, Wl = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_lightpos: new i3.Uniform3f(Y, D3.u_lightpos), u_lightintensity: new i3.Uniform1f(Y, D3.u_lightintensity), u_lightcolor: new i3.Uniform3f(Y, D3.u_lightcolor), u_vertical_gradient: new i3.Uniform1f(Y, D3.u_vertical_gradient), u_height_factor: new i3.Uniform1f(Y, D3.u_height_factor), u_image: new i3.Uniform1i(Y, D3.u_image), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_pixel_coord_upper: new i3.Uniform2f(Y, D3.u_pixel_coord_upper), u_pixel_coord_lower: new i3.Uniform2f(Y, D3.u_pixel_coord_lower), u_scale: new i3.Uniform3f(Y, D3.u_scale), u_fade: new i3.Uniform1f(Y, D3.u_fade), u_opacity: new i3.Uniform1f(Y, D3.u_opacity) };\n                }, ah = function(Y, D3, J, q2) {\n                  var K = D3.style.light, de = K.properties.get("position"), ne = [de.x, de.y, de.z], we = i3.create$1();\n                  K.properties.get("anchor") === "viewport" && i3.fromRotation(we, -D3.transform.angle), i3.transformMat3(ne, ne, we);\n                  var Ue = K.properties.get("color");\n                  return { u_matrix: Y, u_lightpos: ne, u_lightintensity: K.properties.get("intensity"), u_lightcolor: [Ue.r, Ue.g, Ue.b], u_vertical_gradient: +J, u_opacity: q2 };\n                }, Zu = function(Y, D3, J, q2, K, de, ne) {\n                  return i3.extend(ah(Y, D3, J, q2), Xu(de, D3, ne), { u_height_factor: -Math.pow(2, K.overscaledZ) / ne.tileSize / 8 });\n                }, Oc = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix) };\n                }, Tc = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_image: new i3.Uniform1i(Y, D3.u_image), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_pixel_coord_upper: new i3.Uniform2f(Y, D3.u_pixel_coord_upper), u_pixel_coord_lower: new i3.Uniform2f(Y, D3.u_pixel_coord_lower), u_scale: new i3.Uniform3f(Y, D3.u_scale), u_fade: new i3.Uniform1f(Y, D3.u_fade) };\n                }, wl = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_world: new i3.Uniform2f(Y, D3.u_world) };\n                }, vu = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_world: new i3.Uniform2f(Y, D3.u_world), u_image: new i3.Uniform1i(Y, D3.u_image), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_pixel_coord_upper: new i3.Uniform2f(Y, D3.u_pixel_coord_upper), u_pixel_coord_lower: new i3.Uniform2f(Y, D3.u_pixel_coord_lower), u_scale: new i3.Uniform3f(Y, D3.u_scale), u_fade: new i3.Uniform1f(Y, D3.u_fade) };\n                }, qc = function(Y) {\n                  return { u_matrix: Y };\n                }, cf = function(Y, D3, J, q2) {\n                  return i3.extend(qc(Y), Xu(J, D3, q2));\n                }, fc = function(Y, D3) {\n                  return { u_matrix: Y, u_world: D3 };\n                }, Bc = function(Y, D3, J, q2, K) {\n                  return i3.extend(cf(Y, D3, J, q2), { u_world: K });\n                }, At = function(Y, D3) {\n                  return { u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_scale_with_map: new i3.Uniform1i(Y, D3.u_scale_with_map), u_pitch_with_map: new i3.Uniform1i(Y, D3.u_pitch_with_map), u_extrude_scale: new i3.Uniform2f(Y, D3.u_extrude_scale), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix) };\n                }, Wt = function(Y, D3, J, q2) {\n                  var K = Y.transform, de, ne;\n                  if (q2.paint.get("circle-pitch-alignment") === "map") {\n                    var we = As(J, 1, K.zoom);\n                    de = true, ne = [we, we];\n                  } else de = false, ne = K.pixelsToGLUnits;\n                  return { u_camera_to_center_distance: K.cameraToCenterDistance, u_scale_with_map: +(q2.paint.get("circle-pitch-scale") === "map"), u_matrix: Y.translatePosMatrix(D3.posMatrix, J, q2.paint.get("circle-translate"), q2.paint.get("circle-translate-anchor")), u_pitch_with_map: +de, u_device_pixel_ratio: i3.browser.devicePixelRatio, u_extrude_scale: ne };\n                }, Cr = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_pixels_to_tile_units: new i3.Uniform1f(Y, D3.u_pixels_to_tile_units), u_extrude_scale: new i3.Uniform2f(Y, D3.u_extrude_scale), u_overscale_factor: new i3.Uniform1f(Y, D3.u_overscale_factor) };\n                }, Ar = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_inv_matrix: new i3.UniformMatrix4f(Y, D3.u_inv_matrix), u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_viewport_size: new i3.Uniform2f(Y, D3.u_viewport_size) };\n                }, Kr = function(Y, D3, J) {\n                  var q2 = As(J, 1, D3.zoom), K = Math.pow(2, D3.zoom - J.tileID.overscaledZ), de = J.tileID.overscaleFactor();\n                  return { u_matrix: Y, u_camera_to_center_distance: D3.cameraToCenterDistance, u_pixels_to_tile_units: q2, u_extrude_scale: [D3.pixelsToGLUnits[0] / (q2 * K), D3.pixelsToGLUnits[1] / (q2 * K)], u_overscale_factor: de };\n                }, ki = function(Y, D3, J) {\n                  return { u_matrix: Y, u_inv_matrix: D3, u_camera_to_center_distance: J.cameraToCenterDistance, u_viewport_size: [J.width, J.height] };\n                }, Xi = function(Y, D3) {\n                  return { u_color: new i3.UniformColor(Y, D3.u_color), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_overlay: new i3.Uniform1i(Y, D3.u_overlay), u_overlay_scale: new i3.Uniform1f(Y, D3.u_overlay_scale) };\n                }, dn = function(Y, D3, J) {\n                  return J === void 0 && (J = 1), { u_matrix: Y, u_color: D3, u_overlay: 0, u_overlay_scale: J };\n                }, wn = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix) };\n                }, Nn = function(Y) {\n                  return { u_matrix: Y };\n                }, Yi = function(Y, D3) {\n                  return { u_extrude_scale: new i3.Uniform1f(Y, D3.u_extrude_scale), u_intensity: new i3.Uniform1f(Y, D3.u_intensity), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix) };\n                }, Qi = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_world: new i3.Uniform2f(Y, D3.u_world), u_image: new i3.Uniform1i(Y, D3.u_image), u_color_ramp: new i3.Uniform1i(Y, D3.u_color_ramp), u_opacity: new i3.Uniform1f(Y, D3.u_opacity) };\n                }, on = function(Y, D3, J, q2) {\n                  return { u_matrix: Y, u_extrude_scale: As(D3, 1, J), u_intensity: q2 };\n                }, Fi = function(Y, D3, J, q2) {\n                  var K = i3.create();\n                  i3.ortho(K, 0, Y.width, Y.height, 0, 0, 1);\n                  var de = Y.context.gl;\n                  return { u_matrix: K, u_world: [de.drawingBufferWidth, de.drawingBufferHeight], u_image: J, u_color_ramp: q2, u_opacity: D3.paint.get("heatmap-opacity") };\n                }, $n = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_image: new i3.Uniform1i(Y, D3.u_image), u_latrange: new i3.Uniform2f(Y, D3.u_latrange), u_light: new i3.Uniform2f(Y, D3.u_light), u_shadow: new i3.UniformColor(Y, D3.u_shadow), u_highlight: new i3.UniformColor(Y, D3.u_highlight), u_accent: new i3.UniformColor(Y, D3.u_accent) };\n                }, Ca = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_image: new i3.Uniform1i(Y, D3.u_image), u_dimension: new i3.Uniform2f(Y, D3.u_dimension), u_zoom: new i3.Uniform1f(Y, D3.u_zoom), u_unpack: new i3.Uniform4f(Y, D3.u_unpack) };\n                }, Ra = function(Y, D3, J) {\n                  var q2 = J.paint.get("hillshade-shadow-color"), K = J.paint.get("hillshade-highlight-color"), de = J.paint.get("hillshade-accent-color"), ne = J.paint.get("hillshade-illumination-direction") * (Math.PI / 180);\n                  J.paint.get("hillshade-illumination-anchor") === "viewport" && (ne -= Y.transform.angle);\n                  var we = !Y.options.moving;\n                  return { u_matrix: Y.transform.calculatePosMatrix(D3.tileID.toUnwrapped(), we), u_image: 0, u_latrange: Na(Y, D3.tileID), u_light: [J.paint.get("hillshade-exaggeration"), ne], u_shadow: q2, u_highlight: K, u_accent: de };\n                }, La = function(Y, D3) {\n                  var J = D3.stride, q2 = i3.create();\n                  return i3.ortho(q2, 0, i3.EXTENT, -i3.EXTENT, 0, 0, 1), i3.translate(q2, q2, [0, -i3.EXTENT, 0]), { u_matrix: q2, u_image: 1, u_dimension: [J, J], u_zoom: Y.overscaledZ, u_unpack: D3.getUnpackVector() };\n                };\n                function Na(Y, D3) {\n                  var J = Math.pow(2, D3.canonical.z), q2 = D3.canonical.y;\n                  return [new i3.MercatorCoordinate(0, q2 / J).toLngLat().lat, new i3.MercatorCoordinate(0, (q2 + 1) / J).toLngLat().lat];\n                }\n                var Yn = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_ratio: new i3.Uniform1f(Y, D3.u_ratio), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_units_to_pixels: new i3.Uniform2f(Y, D3.u_units_to_pixels) };\n                }, Dn = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_ratio: new i3.Uniform1f(Y, D3.u_ratio), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_units_to_pixels: new i3.Uniform2f(Y, D3.u_units_to_pixels), u_image: new i3.Uniform1i(Y, D3.u_image), u_image_height: new i3.Uniform1f(Y, D3.u_image_height) };\n                }, Ka = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_ratio: new i3.Uniform1f(Y, D3.u_ratio), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_image: new i3.Uniform1i(Y, D3.u_image), u_units_to_pixels: new i3.Uniform2f(Y, D3.u_units_to_pixels), u_scale: new i3.Uniform3f(Y, D3.u_scale), u_fade: new i3.Uniform1f(Y, D3.u_fade) };\n                }, bo = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_ratio: new i3.Uniform1f(Y, D3.u_ratio), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_units_to_pixels: new i3.Uniform2f(Y, D3.u_units_to_pixels), u_patternscale_a: new i3.Uniform2f(Y, D3.u_patternscale_a), u_patternscale_b: new i3.Uniform2f(Y, D3.u_patternscale_b), u_sdfgamma: new i3.Uniform1f(Y, D3.u_sdfgamma), u_image: new i3.Uniform1i(Y, D3.u_image), u_tex_y_a: new i3.Uniform1f(Y, D3.u_tex_y_a), u_tex_y_b: new i3.Uniform1f(Y, D3.u_tex_y_b), u_mix: new i3.Uniform1f(Y, D3.u_mix) };\n                }, Xo = function(Y, D3, J) {\n                  var q2 = Y.transform;\n                  return { u_matrix: ml(Y, D3, J), u_ratio: 1 / As(D3, 1, q2.zoom), u_device_pixel_ratio: i3.browser.devicePixelRatio, u_units_to_pixels: [1 / q2.pixelsToGLUnits[0], 1 / q2.pixelsToGLUnits[1]] };\n                }, Ss = function(Y, D3, J, q2) {\n                  return i3.extend(Xo(Y, D3, J), { u_image: 0, u_image_height: q2 });\n                }, as = function(Y, D3, J, q2) {\n                  var K = Y.transform, de = Ho(D3, K);\n                  return { u_matrix: ml(Y, D3, J), u_texsize: D3.imageAtlasTexture.size, u_ratio: 1 / As(D3, 1, K.zoom), u_device_pixel_ratio: i3.browser.devicePixelRatio, u_image: 0, u_scale: [de, q2.fromScale, q2.toScale], u_fade: q2.t, u_units_to_pixels: [1 / K.pixelsToGLUnits[0], 1 / K.pixelsToGLUnits[1]] };\n                }, ws = function(Y, D3, J, q2, K) {\n                  var de = Y.transform, ne = Y.lineAtlas, we = Ho(D3, de), Ue = J.layout.get("line-cap") === "round", ft = ne.getDash(q2.from, Ue), Xt = ne.getDash(q2.to, Ue), hr = ft.width * K.fromScale, qt = Xt.width * K.toScale;\n                  return i3.extend(Xo(Y, D3, J), { u_patternscale_a: [we / hr, -ft.height / 2], u_patternscale_b: [we / qt, -Xt.height / 2], u_sdfgamma: ne.width / (Math.min(hr, qt) * 256 * i3.browser.devicePixelRatio) / 2, u_image: 0, u_tex_y_a: ft.y, u_tex_y_b: Xt.y, u_mix: K.t });\n                };\n                function Ho(Y, D3) {\n                  return 1 / As(Y, 1, D3.tileZoom);\n                }\n                function ml(Y, D3, J) {\n                  return Y.translatePosMatrix(D3.tileID.posMatrix, D3, J.paint.get("line-translate"), J.paint.get("line-translate-anchor"));\n                }\n                var Ws = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_tl_parent: new i3.Uniform2f(Y, D3.u_tl_parent), u_scale_parent: new i3.Uniform1f(Y, D3.u_scale_parent), u_buffer_scale: new i3.Uniform1f(Y, D3.u_buffer_scale), u_fade_t: new i3.Uniform1f(Y, D3.u_fade_t), u_opacity: new i3.Uniform1f(Y, D3.u_opacity), u_image0: new i3.Uniform1i(Y, D3.u_image0), u_image1: new i3.Uniform1i(Y, D3.u_image1), u_brightness_low: new i3.Uniform1f(Y, D3.u_brightness_low), u_brightness_high: new i3.Uniform1f(Y, D3.u_brightness_high), u_saturation_factor: new i3.Uniform1f(Y, D3.u_saturation_factor), u_contrast_factor: new i3.Uniform1f(Y, D3.u_contrast_factor), u_spin_weights: new i3.Uniform3f(Y, D3.u_spin_weights) };\n                }, Ls = function(Y, D3, J, q2, K) {\n                  return { u_matrix: Y, u_tl_parent: D3, u_scale_parent: J, u_buffer_scale: 1, u_fade_t: q2.mix, u_opacity: q2.opacity * K.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: K.paint.get("raster-brightness-min"), u_brightness_high: K.paint.get("raster-brightness-max"), u_saturation_factor: ys(K.paint.get("raster-saturation")), u_contrast_factor: no(K.paint.get("raster-contrast")), u_spin_weights: va(K.paint.get("raster-hue-rotate")) };\n                };\n                function va(Y) {\n                  Y *= Math.PI / 180;\n                  var D3 = Math.sin(Y), J = Math.cos(Y);\n                  return [(2 * J + 1) / 3, (-Math.sqrt(3) * D3 - J + 1) / 3, (Math.sqrt(3) * D3 - J + 1) / 3];\n                }\n                function no(Y) {\n                  return Y > 0 ? 1 / (1 - Y) : 1 + Y;\n                }\n                function ys(Y) {\n                  return Y > 0 ? 1 - 1 / (1.001 - Y) : -Y;\n                }\n                var rs = function(Y, D3) {\n                  return { u_is_size_zoom_constant: new i3.Uniform1i(Y, D3.u_is_size_zoom_constant), u_is_size_feature_constant: new i3.Uniform1i(Y, D3.u_is_size_feature_constant), u_size_t: new i3.Uniform1f(Y, D3.u_size_t), u_size: new i3.Uniform1f(Y, D3.u_size), u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_pitch: new i3.Uniform1f(Y, D3.u_pitch), u_rotate_symbol: new i3.Uniform1i(Y, D3.u_rotate_symbol), u_aspect_ratio: new i3.Uniform1f(Y, D3.u_aspect_ratio), u_fade_change: new i3.Uniform1f(Y, D3.u_fade_change), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_label_plane_matrix: new i3.UniformMatrix4f(Y, D3.u_label_plane_matrix), u_coord_matrix: new i3.UniformMatrix4f(Y, D3.u_coord_matrix), u_is_text: new i3.Uniform1i(Y, D3.u_is_text), u_pitch_with_map: new i3.Uniform1i(Y, D3.u_pitch_with_map), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_texture: new i3.Uniform1i(Y, D3.u_texture) };\n                }, $l = function(Y, D3) {\n                  return { u_is_size_zoom_constant: new i3.Uniform1i(Y, D3.u_is_size_zoom_constant), u_is_size_feature_constant: new i3.Uniform1i(Y, D3.u_is_size_feature_constant), u_size_t: new i3.Uniform1f(Y, D3.u_size_t), u_size: new i3.Uniform1f(Y, D3.u_size), u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_pitch: new i3.Uniform1f(Y, D3.u_pitch), u_rotate_symbol: new i3.Uniform1i(Y, D3.u_rotate_symbol), u_aspect_ratio: new i3.Uniform1f(Y, D3.u_aspect_ratio), u_fade_change: new i3.Uniform1f(Y, D3.u_fade_change), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_label_plane_matrix: new i3.UniformMatrix4f(Y, D3.u_label_plane_matrix), u_coord_matrix: new i3.UniformMatrix4f(Y, D3.u_coord_matrix), u_is_text: new i3.Uniform1i(Y, D3.u_is_text), u_pitch_with_map: new i3.Uniform1i(Y, D3.u_pitch_with_map), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_texture: new i3.Uniform1i(Y, D3.u_texture), u_gamma_scale: new i3.Uniform1f(Y, D3.u_gamma_scale), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_is_halo: new i3.Uniform1i(Y, D3.u_is_halo) };\n                }, Cu = function(Y, D3) {\n                  return { u_is_size_zoom_constant: new i3.Uniform1i(Y, D3.u_is_size_zoom_constant), u_is_size_feature_constant: new i3.Uniform1i(Y, D3.u_is_size_feature_constant), u_size_t: new i3.Uniform1f(Y, D3.u_size_t), u_size: new i3.Uniform1f(Y, D3.u_size), u_camera_to_center_distance: new i3.Uniform1f(Y, D3.u_camera_to_center_distance), u_pitch: new i3.Uniform1f(Y, D3.u_pitch), u_rotate_symbol: new i3.Uniform1i(Y, D3.u_rotate_symbol), u_aspect_ratio: new i3.Uniform1f(Y, D3.u_aspect_ratio), u_fade_change: new i3.Uniform1f(Y, D3.u_fade_change), u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_label_plane_matrix: new i3.UniformMatrix4f(Y, D3.u_label_plane_matrix), u_coord_matrix: new i3.UniformMatrix4f(Y, D3.u_coord_matrix), u_is_text: new i3.Uniform1i(Y, D3.u_is_text), u_pitch_with_map: new i3.Uniform1i(Y, D3.u_pitch_with_map), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_texsize_icon: new i3.Uniform2f(Y, D3.u_texsize_icon), u_texture: new i3.Uniform1i(Y, D3.u_texture), u_texture_icon: new i3.Uniform1i(Y, D3.u_texture_icon), u_gamma_scale: new i3.Uniform1f(Y, D3.u_gamma_scale), u_device_pixel_ratio: new i3.Uniform1f(Y, D3.u_device_pixel_ratio), u_is_halo: new i3.Uniform1i(Y, D3.u_is_halo) };\n                }, Yu = function(Y, D3, J, q2, K, de, ne, we, Ue, ft) {\n                  var Xt = K.transform;\n                  return { u_is_size_zoom_constant: +(Y === "constant" || Y === "source"), u_is_size_feature_constant: +(Y === "constant" || Y === "camera"), u_size_t: D3 ? D3.uSizeT : 0, u_size: D3 ? D3.uSize : 0, u_camera_to_center_distance: Xt.cameraToCenterDistance, u_pitch: Xt.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +J, u_aspect_ratio: Xt.width / Xt.height, u_fade_change: K.options.fadeDuration ? K.symbolFadeChange : 1, u_matrix: de, u_label_plane_matrix: ne, u_coord_matrix: we, u_is_text: +Ue, u_pitch_with_map: +q2, u_texsize: ft, u_texture: 0 };\n                }, Nc = function(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt) {\n                  var hr = K.transform;\n                  return i3.extend(Yu(Y, D3, J, q2, K, de, ne, we, Ue, ft), { u_gamma_scale: q2 ? Math.cos(hr._pitch) * hr.cameraToCenterDistance : 1, u_device_pixel_ratio: i3.browser.devicePixelRatio, u_is_halo: +Xt });\n                }, pu = function(Y, D3, J, q2, K, de, ne, we, Ue, ft) {\n                  return i3.extend(Nc(Y, D3, J, q2, K, de, ne, we, true, Ue, true), { u_texsize_icon: ft, u_texture_icon: 1 });\n                }, Uc = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_opacity: new i3.Uniform1f(Y, D3.u_opacity), u_color: new i3.UniformColor(Y, D3.u_color) };\n                }, xu = function(Y, D3) {\n                  return { u_matrix: new i3.UniformMatrix4f(Y, D3.u_matrix), u_opacity: new i3.Uniform1f(Y, D3.u_opacity), u_image: new i3.Uniform1i(Y, D3.u_image), u_pattern_tl_a: new i3.Uniform2f(Y, D3.u_pattern_tl_a), u_pattern_br_a: new i3.Uniform2f(Y, D3.u_pattern_br_a), u_pattern_tl_b: new i3.Uniform2f(Y, D3.u_pattern_tl_b), u_pattern_br_b: new i3.Uniform2f(Y, D3.u_pattern_br_b), u_texsize: new i3.Uniform2f(Y, D3.u_texsize), u_mix: new i3.Uniform1f(Y, D3.u_mix), u_pattern_size_a: new i3.Uniform2f(Y, D3.u_pattern_size_a), u_pattern_size_b: new i3.Uniform2f(Y, D3.u_pattern_size_b), u_scale_a: new i3.Uniform1f(Y, D3.u_scale_a), u_scale_b: new i3.Uniform1f(Y, D3.u_scale_b), u_pixel_coord_upper: new i3.Uniform2f(Y, D3.u_pixel_coord_upper), u_pixel_coord_lower: new i3.Uniform2f(Y, D3.u_pixel_coord_lower), u_tile_units_to_pixels: new i3.Uniform1f(Y, D3.u_tile_units_to_pixels) };\n                }, Ac = function(Y, D3, J) {\n                  return { u_matrix: Y, u_opacity: D3, u_color: J };\n                }, Ua = function(Y, D3, J, q2, K, de) {\n                  return i3.extend(uf(q2, de, J, K), { u_matrix: Y, u_opacity: D3 });\n                }, oo = { fillExtrusion: Xf, fillExtrusionPattern: Wl, fill: Oc, fillPattern: Tc, fillOutline: wl, fillOutlinePattern: vu, circle: At, collisionBox: Cr, collisionCircle: Ar, debug: Xi, clippingMask: wn, heatmap: Yi, heatmapTexture: Qi, hillshade: $n, hillshadePrepare: Ca, line: Yn, lineGradient: Dn, linePattern: Ka, lineSDF: bo, raster: Ws, symbolIcon: rs, symbolSDF: $l, symbolTextAndIcon: Cu, background: Uc, backgroundPattern: xu }, Vc;\n                function hc(Y, D3, J, q2, K, de, ne) {\n                  for (var we = Y.context, Ue = we.gl, ft = Y.useProgram("collisionBox"), Xt = [], hr = 0, qt = 0, Ve = 0; Ve < q2.length; Ve++) {\n                    var Qe = q2[Ve], at = D3.getTile(Qe), Ct = at.getBucket(J);\n                    if (Ct) {\n                      var Ot = Qe.posMatrix;\n                      (K[0] !== 0 || K[1] !== 0) && (Ot = Y.translatePosMatrix(Qe.posMatrix, at, K, de));\n                      var Rt = ne ? Ct.textCollisionBox : Ct.iconCollisionBox, Bt = Ct.collisionCircleArray;\n                      if (Bt.length > 0) {\n                        var Dt = i3.create(), yt = Ot;\n                        i3.mul(Dt, Ct.placementInvProjMatrix, Y.transform.glCoordMatrix), i3.mul(Dt, Dt, Ct.placementViewportMatrix), Xt.push({ circleArray: Bt, circleOffset: qt, transform: yt, invTransform: Dt }), hr += Bt.length / 4, qt = hr;\n                      }\n                      Rt && ft.draw(we, Ue.LINES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, Kr(Ot, Y.transform, at), J.id, Rt.layoutVertexBuffer, Rt.indexBuffer, Rt.segments, null, Y.transform.zoom, null, null, Rt.collisionVertexBuffer);\n                    }\n                  }\n                  if (!(!ne || !Xt.length)) {\n                    var Pt = Y.useProgram("collisionCircle"), ht = new i3.StructArrayLayout2f1f2i16();\n                    ht.resize(hr * 4), ht._trim();\n                    for (var ur = 0, br = 0, Ur = Xt; br < Ur.length; br += 1) for (var Di = Ur[br], fi = 0; fi < Di.circleArray.length / 4; fi++) {\n                      var Ti = fi * 4, gn = Di.circleArray[Ti + 0], rn = Di.circleArray[Ti + 1], Ci = Di.circleArray[Ti + 2], Bi = Di.circleArray[Ti + 3];\n                      ht.emplace(ur++, gn, rn, Ci, Bi, 0), ht.emplace(ur++, gn, rn, Ci, Bi, 1), ht.emplace(ur++, gn, rn, Ci, Bi, 2), ht.emplace(ur++, gn, rn, Ci, Bi, 3);\n                    }\n                    (!Vc || Vc.length < hr * 2) && (Vc = Ku(hr));\n                    for (var Gi = we.createIndexBuffer(Vc, true), sn = we.createVertexBuffer(ht, i3.collisionCircleLayout.members, true), zn = 0, Ja = Xt; zn < Ja.length; zn += 1) {\n                      var co = Ja[zn], ts = ki(co.transform, co.invTransform, Y.transform);\n                      Pt.draw(we, Ue.TRIANGLES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, ts, J.id, sn, Gi, i3.SegmentVector.simpleSegment(0, co.circleOffset * 2, co.circleArray.length, co.circleArray.length / 2), null, Y.transform.zoom, null, null, null);\n                    }\n                    sn.destroy(), Gi.destroy();\n                  }\n                }\n                function Ku(Y) {\n                  var D3 = Y * 2, J = new i3.StructArrayLayout3ui6();\n                  J.resize(D3), J._trim();\n                  for (var q2 = 0; q2 < D3; q2++) {\n                    var K = q2 * 6;\n                    J.uint16[K + 0] = q2 * 4 + 0, J.uint16[K + 1] = q2 * 4 + 1, J.uint16[K + 2] = q2 * 4 + 2, J.uint16[K + 3] = q2 * 4 + 2, J.uint16[K + 4] = q2 * 4 + 3, J.uint16[K + 5] = q2 * 4 + 0;\n                  }\n                  return J;\n                }\n                var ue = i3.identity(new Float32Array(16));\n                function w4(Y, D3, J, q2, K) {\n                  if (Y.renderPass === "translucent") {\n                    var de = Fn.disabled, ne = Y.colorModeForRenderPass(), we = J.layout.get("text-variable-anchor");\n                    we && Q(q2, Y, J, D3, J.layout.get("text-rotation-alignment"), J.layout.get("text-pitch-alignment"), K), J.paint.get("icon-opacity").constantOr(1) !== 0 && qe(Y, D3, J, q2, false, J.paint.get("icon-translate"), J.paint.get("icon-translate-anchor"), J.layout.get("icon-rotation-alignment"), J.layout.get("icon-pitch-alignment"), J.layout.get("icon-keep-upright"), de, ne), J.paint.get("text-opacity").constantOr(1) !== 0 && qe(Y, D3, J, q2, true, J.paint.get("text-translate"), J.paint.get("text-translate-anchor"), J.layout.get("text-rotation-alignment"), J.layout.get("text-pitch-alignment"), J.layout.get("text-keep-upright"), de, ne), D3.map.showCollisionBoxes && (hc(Y, D3, J, q2, J.paint.get("text-translate"), J.paint.get("text-translate-anchor"), true), hc(Y, D3, J, q2, J.paint.get("icon-translate"), J.paint.get("icon-translate-anchor"), false));\n                  }\n                }\n                function B4(Y, D3, J, q2, K, de) {\n                  var ne = i3.getAnchorAlignment(Y), we = ne.horizontalAlign, Ue = ne.verticalAlign, ft = -(we - 0.5) * D3, Xt = -(Ue - 0.5) * J, hr = i3.evaluateVariableOffset(Y, q2);\n                  return new i3.Point((ft / K + hr[0]) * de, (Xt / K + hr[1]) * de);\n                }\n                function Q(Y, D3, J, q2, K, de, ne) {\n                  for (var we = D3.transform, Ue = K === "map", ft = de === "map", Xt = 0, hr = Y; Xt < hr.length; Xt += 1) {\n                    var qt = hr[Xt], Ve = q2.getTile(qt), Qe = Ve.getBucket(J);\n                    if (!(!Qe || !Qe.text || !Qe.text.segments.get().length)) {\n                      var at = Qe.textSizeData, Ct = i3.evaluateSizeForZoom(at, we.zoom), Ot = As(Ve, 1, D3.transform.zoom), Rt = _n(qt.posMatrix, ft, Ue, D3.transform, Ot), Bt = J.layout.get("icon-text-fit") !== "none" && Qe.hasIconData();\n                      if (Ct) {\n                        var Dt = Math.pow(2, we.zoom - Ve.tileID.overscaledZ);\n                        ee(Qe, Ue, ft, ne, i3.symbolSize, we, Rt, qt.posMatrix, Dt, Ct, Bt);\n                      }\n                    }\n                  }\n                }\n                function ee(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt) {\n                  var hr = Y.text.placedSymbolArray, qt = Y.text.dynamicLayoutVertexArray, Ve = Y.icon.dynamicLayoutVertexArray, Qe = {};\n                  qt.clear();\n                  for (var at = 0; at < hr.length; at++) {\n                    var Ct = hr.get(at), Ot = Y.allowVerticalPlacement && !Ct.placedOrientation, Rt = !Ct.hidden && Ct.crossTileID && !Ot ? q2[Ct.crossTileID] : null;\n                    if (!Rt) ul(Ct.numGlyphs, qt);\n                    else {\n                      var Bt = new i3.Point(Ct.anchorX, Ct.anchorY), Dt = Jn(Bt, J ? we : ne), yt = Ma(de.cameraToCenterDistance, Dt.signedDistanceFromCamera), Pt = K.evaluateSizeForFeature(Y.textSizeData, ft, Ct) * yt / i3.ONE_EM;\n                      J && (Pt *= Y.tilePixelRatio / Ue);\n                      for (var ht = Rt.width, ur = Rt.height, br = Rt.anchor, Ur = Rt.textOffset, Di = Rt.textBoxScale, fi = B4(br, ht, ur, Ur, Di, Pt), Ti = J ? Jn(Bt.add(fi), ne).point : Dt.point.add(D3 ? fi.rotate(-de.angle) : fi), gn = Y.allowVerticalPlacement && Ct.placedOrientation === i3.WritingMode.vertical ? Math.PI / 2 : 0, rn = 0; rn < Ct.numGlyphs; rn++) i3.addDynamicAttributes(qt, Ti, gn);\n                      Xt && Ct.associatedIconIndex >= 0 && (Qe[Ct.associatedIconIndex] = { shiftedAnchor: Ti, angle: gn });\n                    }\n                  }\n                  if (Xt) {\n                    Ve.clear();\n                    for (var Ci = Y.icon.placedSymbolArray, Bi = 0; Bi < Ci.length; Bi++) {\n                      var Gi = Ci.get(Bi);\n                      if (Gi.hidden) ul(Gi.numGlyphs, Ve);\n                      else {\n                        var sn = Qe[Bi];\n                        if (!sn) ul(Gi.numGlyphs, Ve);\n                        else for (var zn = 0; zn < Gi.numGlyphs; zn++) i3.addDynamicAttributes(Ve, sn.shiftedAnchor, sn.angle);\n                      }\n                    }\n                    Y.icon.dynamicLayoutVertexBuffer.updateData(Ve);\n                  }\n                  Y.text.dynamicLayoutVertexBuffer.updateData(qt);\n                }\n                function le(Y, D3, J) {\n                  return J.iconsInText && D3 ? "symbolTextAndIcon" : Y ? "symbolSDF" : "symbolIcon";\n                }\n                function qe(Y, D3, J, q2, K, de, ne, we, Ue, ft, Xt, hr) {\n                  for (var qt = Y.context, Ve = qt.gl, Qe = Y.transform, at = we === "map", Ct = Ue === "map", Ot = at && J.layout.get("symbol-placement") !== "point", Rt = at && !Ct && !Ot, Bt = J.layout.get("symbol-sort-key").constantOr(1) !== void 0, Dt = false, yt = Y.depthModeForSublayer(0, wi.ReadOnly), Pt = J.layout.get("text-variable-anchor"), ht = [], ur = 0, br = q2; ur < br.length; ur += 1) {\n                    var Ur = br[ur], Di = D3.getTile(Ur), fi = Di.getBucket(J);\n                    if (fi) {\n                      var Ti = K ? fi.text : fi.icon;\n                      if (!(!Ti || !Ti.segments.get().length)) {\n                        var gn = Ti.programConfigurations.get(J.id), rn = K || fi.sdfIcons, Ci = K ? fi.textSizeData : fi.iconSizeData, Bi = Ct || Qe.pitch !== 0, Gi = Y.useProgram(le(rn, K, fi), gn), sn = i3.evaluateSizeForZoom(Ci, Qe.zoom), zn = void 0, Ja = [0, 0], co = void 0, ts = void 0, so = null, Zo = void 0;\n                        if (K) {\n                          if (co = Di.glyphAtlasTexture, ts = Ve.LINEAR, zn = Di.glyphAtlasTexture.size, fi.iconsInText) {\n                            Ja = Di.imageAtlasTexture.size, so = Di.imageAtlasTexture;\n                            var ms = Ci.kind === "composite" || Ci.kind === "camera";\n                            Zo = Bi || Y.options.rotating || Y.options.zooming || ms ? Ve.LINEAR : Ve.NEAREST;\n                          }\n                        } else {\n                          var ou = J.layout.get("icon-size").constantOr(0) !== 1 || fi.iconsNeedLinear;\n                          co = Di.imageAtlasTexture, ts = rn || Y.options.rotating || Y.options.zooming || ou || Bi ? Ve.LINEAR : Ve.NEAREST, zn = Di.imageAtlasTexture.size;\n                        }\n                        var Cv = As(Di, 1, Y.transform.zoom), Lv = _n(Ur.posMatrix, Ct, at, Y.transform, Cv), wd = ya(Ur.posMatrix, Ct, at, Y.transform, Cv), Kv = Pt && fi.hasTextData(), cg = J.layout.get("icon-text-fit") !== "none" && Kv && fi.hasIconData();\n                        Ot && No(fi, Ur.posMatrix, Y, K, Lv, wd, Ct, ft);\n                        var pp = Y.translatePosMatrix(Ur.posMatrix, Di, de, ne), Td = Ot || K && Pt || cg ? ue : Lv, gp = Y.translatePosMatrix(wd, Di, de, ne, true), Vd = rn && J.paint.get(K ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0, Ad = void 0;\n                        rn ? fi.iconsInText ? Ad = pu(Ci.kind, sn, Rt, Ct, Y, pp, Td, gp, zn, Ja) : Ad = Nc(Ci.kind, sn, Rt, Ct, Y, pp, Td, gp, K, zn, true) : Ad = Yu(Ci.kind, sn, Rt, Ct, Y, pp, Td, gp, K, zn);\n                        var Pv = { program: Gi, buffers: Ti, uniformValues: Ad, atlasTexture: co, atlasTextureIcon: so, atlasInterpolation: ts, atlasInterpolationIcon: Zo, isSDF: rn, hasHalo: Vd };\n                        if (Bt && fi.canOverlap) {\n                          Dt = true;\n                          for (var Jv = Ti.segments.get(), Iv = 0, ay = Jv; Iv < ay.length; Iv += 1) {\n                            var fg = ay[Iv];\n                            ht.push({ segments: new i3.SegmentVector([fg]), sortKey: fg.sortKey, state: Pv });\n                          }\n                        } else ht.push({ segments: Ti.segments, sortKey: 0, state: Pv });\n                      }\n                    }\n                  }\n                  Dt && ht.sort(function(b1, w1) {\n                    return b1.sortKey - w1.sortKey;\n                  });\n                  for (var oh = 0, hg = ht; oh < hg.length; oh += 1) {\n                    var oy = hg[oh], jh = oy.state;\n                    if (qt.activeTexture.set(Ve.TEXTURE0), jh.atlasTexture.bind(jh.atlasInterpolation, Ve.CLAMP_TO_EDGE), jh.atlasTextureIcon && (qt.activeTexture.set(Ve.TEXTURE1), jh.atlasTextureIcon && jh.atlasTextureIcon.bind(jh.atlasInterpolationIcon, Ve.CLAMP_TO_EDGE)), jh.isSDF) {\n                      var im = jh.uniformValues;\n                      jh.hasHalo && (im.u_is_halo = 1, Xe(jh.buffers, oy.segments, J, Y, jh.program, yt, Xt, hr, im)), im.u_is_halo = 0;\n                    }\n                    Xe(jh.buffers, oy.segments, J, Y, jh.program, yt, Xt, hr, jh.uniformValues);\n                  }\n                }\n                function Xe(Y, D3, J, q2, K, de, ne, we, Ue) {\n                  var ft = q2.context, Xt = ft.gl;\n                  K.draw(ft, Xt.TRIANGLES, de, ne, we, Er.disabled, Ue, J.id, Y.layoutVertexBuffer, Y.indexBuffer, D3, J.paint, q2.transform.zoom, Y.programConfigurations.get(J.id), Y.dynamicLayoutVertexBuffer, Y.opacityVertexBuffer);\n                }\n                function ot(Y, D3, J, q2) {\n                  if (Y.renderPass === "translucent") {\n                    var K = J.paint.get("circle-opacity"), de = J.paint.get("circle-stroke-width"), ne = J.paint.get("circle-stroke-opacity"), we = J.layout.get("circle-sort-key").constantOr(1) !== void 0;\n                    if (!(K.constantOr(1) === 0 && (de.constantOr(1) === 0 || ne.constantOr(1) === 0))) {\n                      for (var Ue = Y.context, ft = Ue.gl, Xt = Y.depthModeForSublayer(0, wi.ReadOnly), hr = Fn.disabled, qt = Y.colorModeForRenderPass(), Ve = [], Qe = 0; Qe < q2.length; Qe++) {\n                        var at = q2[Qe], Ct = D3.getTile(at), Ot = Ct.getBucket(J);\n                        if (Ot) {\n                          var Rt = Ot.programConfigurations.get(J.id), Bt = Y.useProgram("circle", Rt), Dt = Ot.layoutVertexBuffer, yt = Ot.indexBuffer, Pt = Wt(Y, at, Ct, J), ht = { programConfiguration: Rt, program: Bt, layoutVertexBuffer: Dt, indexBuffer: yt, uniformValues: Pt };\n                          if (we) for (var ur = Ot.segments.get(), br = 0, Ur = ur; br < Ur.length; br += 1) {\n                            var Di = Ur[br];\n                            Ve.push({ segments: new i3.SegmentVector([Di]), sortKey: Di.sortKey, state: ht });\n                          }\n                          else Ve.push({ segments: Ot.segments, sortKey: 0, state: ht });\n                        }\n                      }\n                      we && Ve.sort(function(co, ts) {\n                        return co.sortKey - ts.sortKey;\n                      });\n                      for (var fi = 0, Ti = Ve; fi < Ti.length; fi += 1) {\n                        var gn = Ti[fi], rn = gn.state, Ci = rn.programConfiguration, Bi = rn.program, Gi = rn.layoutVertexBuffer, sn = rn.indexBuffer, zn = rn.uniformValues, Ja = gn.segments;\n                        Bi.draw(Ue, ft.TRIANGLES, Xt, hr, qt, Er.disabled, zn, J.id, Gi, sn, Ja, J.paint, Y.transform.zoom, Ci);\n                      }\n                    }\n                  }\n                }\n                function Tt(Y, D3, J, q2) {\n                  if (J.paint.get("heatmap-opacity") !== 0) if (Y.renderPass === "offscreen") {\n                    var K = Y.context, de = K.gl, ne = Fn.disabled, we = new wt([de.ONE, de.ONE], i3.Color.transparent, [true, true, true, true]);\n                    Yt(K, Y, J), K.clear({ color: i3.Color.transparent });\n                    for (var Ue = 0; Ue < q2.length; Ue++) {\n                      var ft = q2[Ue];\n                      if (!D3.hasRenderableParent(ft)) {\n                        var Xt = D3.getTile(ft), hr = Xt.getBucket(J);\n                        if (hr) {\n                          var qt = hr.programConfigurations.get(J.id), Ve = Y.useProgram("heatmap", qt), Qe = Y.transform, at = Qe.zoom;\n                          Ve.draw(K, de.TRIANGLES, wi.disabled, ne, we, Er.disabled, on(ft.posMatrix, Xt, at, J.paint.get("heatmap-intensity")), J.id, hr.layoutVertexBuffer, hr.indexBuffer, hr.segments, J.paint, Y.transform.zoom, qt);\n                        }\n                      }\n                    }\n                    K.viewport.set([0, 0, Y.width, Y.height]);\n                  } else Y.renderPass === "translucent" && (Y.context.setColorMode(Y.colorModeForRenderPass()), xr(Y, J));\n                }\n                function Yt(Y, D3, J) {\n                  var q2 = Y.gl;\n                  Y.activeTexture.set(q2.TEXTURE1), Y.viewport.set([0, 0, D3.width / 4, D3.height / 4]);\n                  var K = J.heatmapFbo;\n                  if (K) q2.bindTexture(q2.TEXTURE_2D, K.colorAttachment.get()), Y.bindFramebuffer.set(K.framebuffer);\n                  else {\n                    var de = q2.createTexture();\n                    q2.bindTexture(q2.TEXTURE_2D, de), q2.texParameteri(q2.TEXTURE_2D, q2.TEXTURE_WRAP_S, q2.CLAMP_TO_EDGE), q2.texParameteri(q2.TEXTURE_2D, q2.TEXTURE_WRAP_T, q2.CLAMP_TO_EDGE), q2.texParameteri(q2.TEXTURE_2D, q2.TEXTURE_MIN_FILTER, q2.LINEAR), q2.texParameteri(q2.TEXTURE_2D, q2.TEXTURE_MAG_FILTER, q2.LINEAR), K = J.heatmapFbo = Y.createFramebuffer(D3.width / 4, D3.height / 4, false), Kt(Y, D3, de, K);\n                  }\n                }\n                function Kt(Y, D3, J, q2) {\n                  var K = Y.gl, de = Y.extRenderToTextureHalfFloat ? Y.extTextureHalfFloat.HALF_FLOAT_OES : K.UNSIGNED_BYTE;\n                  K.texImage2D(K.TEXTURE_2D, 0, K.RGBA, D3.width / 4, D3.height / 4, 0, K.RGBA, de, null), q2.colorAttachment.set(J);\n                }\n                function xr(Y, D3) {\n                  var J = Y.context, q2 = J.gl, K = D3.heatmapFbo;\n                  if (K) {\n                    J.activeTexture.set(q2.TEXTURE0), q2.bindTexture(q2.TEXTURE_2D, K.colorAttachment.get()), J.activeTexture.set(q2.TEXTURE1);\n                    var de = D3.colorRampTexture;\n                    de || (de = D3.colorRampTexture = new i3.Texture(J, D3.colorRamp, q2.RGBA)), de.bind(q2.LINEAR, q2.CLAMP_TO_EDGE), Y.useProgram("heatmapTexture").draw(J, q2.TRIANGLES, wi.disabled, Fn.disabled, Y.colorModeForRenderPass(), Er.disabled, Fi(Y, D3, 0, 1), D3.id, Y.viewportBuffer, Y.quadTriangleIndexBuffer, Y.viewportSegments, D3.paint, Y.transform.zoom);\n                  }\n                }\n                function Ir(Y, D3, J, q2) {\n                  if (Y.renderPass === "translucent") {\n                    var K = J.paint.get("line-opacity"), de = J.paint.get("line-width");\n                    if (!(K.constantOr(1) === 0 || de.constantOr(1) === 0)) for (var ne = Y.depthModeForSublayer(0, wi.ReadOnly), we = Y.colorModeForRenderPass(), Ue = J.paint.get("line-dasharray"), ft = J.paint.get("line-pattern"), Xt = ft.constantOr(1), hr = J.paint.get("line-gradient"), qt = J.getCrossfadeParameters(), Ve = Xt ? "linePattern" : Ue ? "lineSDF" : hr ? "lineGradient" : "line", Qe = Y.context, at = Qe.gl, Ct = true, Ot = 0, Rt = q2; Ot < Rt.length; Ot += 1) {\n                      var Bt = Rt[Ot], Dt = D3.getTile(Bt);\n                      if (!(Xt && !Dt.patternsLoaded())) {\n                        var yt = Dt.getBucket(J);\n                        if (yt) {\n                          var Pt = yt.programConfigurations.get(J.id), ht = Y.context.program.get(), ur = Y.useProgram(Ve, Pt), br = Ct || ur.program !== ht, Ur = ft.constantOr(null);\n                          if (Ur && Dt.imageAtlas) {\n                            var Di = Dt.imageAtlas, fi = Di.patternPositions[Ur.to.toString()], Ti = Di.patternPositions[Ur.from.toString()];\n                            fi && Ti && Pt.setConstantPatternPositions(fi, Ti);\n                          }\n                          var gn = Xt ? as(Y, Dt, J, qt) : Ue ? ws(Y, Dt, J, Ue, qt) : hr ? Ss(Y, Dt, J, yt.lineClipsArray.length) : Xo(Y, Dt, J);\n                          if (Xt) Qe.activeTexture.set(at.TEXTURE0), Dt.imageAtlasTexture.bind(at.LINEAR, at.CLAMP_TO_EDGE), Pt.updatePaintBuffers(qt);\n                          else if (Ue && (br || Y.lineAtlas.dirty)) Qe.activeTexture.set(at.TEXTURE0), Y.lineAtlas.bind(Qe);\n                          else if (hr) {\n                            var rn = yt.gradients[J.id], Ci = rn.texture;\n                            if (J.gradientVersion !== rn.version) {\n                              var Bi = 256;\n                              if (J.stepInterpolant) {\n                                var Gi = D3.getSource().maxzoom, sn = Bt.canonical.z === Gi ? Math.ceil(1 << Y.transform.maxZoom - Bt.canonical.z) : 1, zn = yt.maxLineLength / i3.EXTENT, Ja = 1024, co = zn * Ja * sn;\n                                Bi = i3.clamp(i3.nextPowerOfTwo(co), 256, Qe.maxTextureSize);\n                              }\n                              rn.gradient = i3.renderColorRamp({ expression: J.gradientExpression(), evaluationKey: "lineProgress", resolution: Bi, image: rn.gradient || void 0, clips: yt.lineClipsArray }), rn.texture ? rn.texture.update(rn.gradient) : rn.texture = new i3.Texture(Qe, rn.gradient, at.RGBA), rn.version = J.gradientVersion, Ci = rn.texture;\n                            }\n                            Qe.activeTexture.set(at.TEXTURE0), Ci.bind(J.stepInterpolant ? at.NEAREST : at.LINEAR, at.CLAMP_TO_EDGE);\n                          }\n                          ur.draw(Qe, at.TRIANGLES, ne, Y.stencilModeForClipping(Bt), we, Er.disabled, gn, J.id, yt.layoutVertexBuffer, yt.indexBuffer, yt.segments, J.paint, Y.transform.zoom, Pt, yt.layoutVertexBuffer2), Ct = false;\n                        }\n                      }\n                    }\n                  }\n                }\n                function ve(Y, D3, J, q2) {\n                  var K = J.paint.get("fill-color"), de = J.paint.get("fill-opacity");\n                  if (de.constantOr(1) !== 0) {\n                    var ne = Y.colorModeForRenderPass(), we = J.paint.get("fill-pattern"), Ue = Y.opaquePassEnabledForLayer() && !we.constantOr(1) && K.constantOr(i3.Color.transparent).a === 1 && de.constantOr(0) === 1 ? "opaque" : "translucent";\n                    if (Y.renderPass === Ue) {\n                      var ft = Y.depthModeForSublayer(1, Y.renderPass === "opaque" ? wi.ReadWrite : wi.ReadOnly);\n                      be(Y, D3, J, q2, ft, ne, false);\n                    }\n                    if (Y.renderPass === "translucent" && J.paint.get("fill-antialias")) {\n                      var Xt = Y.depthModeForSublayer(J.getPaintProperty("fill-outline-color") ? 2 : 0, wi.ReadOnly);\n                      be(Y, D3, J, q2, Xt, ne, true);\n                    }\n                  }\n                }\n                function be(Y, D3, J, q2, K, de, ne) {\n                  var we = Y.context.gl, Ue = J.paint.get("fill-pattern"), ft = Ue && Ue.constantOr(1), Xt = J.getCrossfadeParameters(), hr, qt, Ve, Qe, at;\n                  ne ? (qt = ft && !J.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", hr = we.LINES) : (qt = ft ? "fillPattern" : "fill", hr = we.TRIANGLES);\n                  for (var Ct = 0, Ot = q2; Ct < Ot.length; Ct += 1) {\n                    var Rt = Ot[Ct], Bt = D3.getTile(Rt);\n                    if (!(ft && !Bt.patternsLoaded())) {\n                      var Dt = Bt.getBucket(J);\n                      if (Dt) {\n                        var yt = Dt.programConfigurations.get(J.id), Pt = Y.useProgram(qt, yt);\n                        ft && (Y.context.activeTexture.set(we.TEXTURE0), Bt.imageAtlasTexture.bind(we.LINEAR, we.CLAMP_TO_EDGE), yt.updatePaintBuffers(Xt));\n                        var ht = Ue.constantOr(null);\n                        if (ht && Bt.imageAtlas) {\n                          var ur = Bt.imageAtlas, br = ur.patternPositions[ht.to.toString()], Ur = ur.patternPositions[ht.from.toString()];\n                          br && Ur && yt.setConstantPatternPositions(br, Ur);\n                        }\n                        var Di = Y.translatePosMatrix(Rt.posMatrix, Bt, J.paint.get("fill-translate"), J.paint.get("fill-translate-anchor"));\n                        if (!ne) Qe = Dt.indexBuffer, at = Dt.segments, Ve = ft ? cf(Di, Y, Xt, Bt) : qc(Di);\n                        else {\n                          Qe = Dt.indexBuffer2, at = Dt.segments2;\n                          var fi = [we.drawingBufferWidth, we.drawingBufferHeight];\n                          Ve = qt === "fillOutlinePattern" && ft ? Bc(Di, Y, Xt, Bt, fi) : fc(Di, fi);\n                        }\n                        Pt.draw(Y.context, hr, K, Y.stencilModeForClipping(Rt), de, Er.disabled, Ve, J.id, Dt.layoutVertexBuffer, Qe, at, J.paint, Y.transform.zoom, yt);\n                      }\n                    }\n                  }\n                }\n                function De(Y, D3, J, q2) {\n                  var K = J.paint.get("fill-extrusion-opacity");\n                  if (K !== 0 && Y.renderPass === "translucent") {\n                    var de = new wi(Y.context.gl.LEQUAL, wi.ReadWrite, Y.depthRangeFor3D);\n                    if (K === 1 && !J.paint.get("fill-extrusion-pattern").constantOr(1)) {\n                      var ne = Y.colorModeForRenderPass();\n                      Be(Y, D3, J, q2, de, Fn.disabled, ne);\n                    } else Be(Y, D3, J, q2, de, Fn.disabled, wt.disabled), Be(Y, D3, J, q2, de, Y.stencilModeFor3D(), Y.colorModeForRenderPass());\n                  }\n                }\n                function Be(Y, D3, J, q2, K, de, ne) {\n                  for (var we = Y.context, Ue = we.gl, ft = J.paint.get("fill-extrusion-pattern"), Xt = ft.constantOr(1), hr = J.getCrossfadeParameters(), qt = J.paint.get("fill-extrusion-opacity"), Ve = 0, Qe = q2; Ve < Qe.length; Ve += 1) {\n                    var at = Qe[Ve], Ct = D3.getTile(at), Ot = Ct.getBucket(J);\n                    if (Ot) {\n                      var Rt = Ot.programConfigurations.get(J.id), Bt = Y.useProgram(Xt ? "fillExtrusionPattern" : "fillExtrusion", Rt);\n                      Xt && (Y.context.activeTexture.set(Ue.TEXTURE0), Ct.imageAtlasTexture.bind(Ue.LINEAR, Ue.CLAMP_TO_EDGE), Rt.updatePaintBuffers(hr));\n                      var Dt = ft.constantOr(null);\n                      if (Dt && Ct.imageAtlas) {\n                        var yt = Ct.imageAtlas, Pt = yt.patternPositions[Dt.to.toString()], ht = yt.patternPositions[Dt.from.toString()];\n                        Pt && ht && Rt.setConstantPatternPositions(Pt, ht);\n                      }\n                      var ur = Y.translatePosMatrix(at.posMatrix, Ct, J.paint.get("fill-extrusion-translate"), J.paint.get("fill-extrusion-translate-anchor")), br = J.paint.get("fill-extrusion-vertical-gradient"), Ur = Xt ? Zu(ur, Y, br, qt, at, hr, Ct) : ah(ur, Y, br, qt);\n                      Bt.draw(we, we.gl.TRIANGLES, K, de, ne, Er.backCCW, Ur, J.id, Ot.layoutVertexBuffer, Ot.indexBuffer, Ot.segments, J.paint, Y.transform.zoom, Rt);\n                    }\n                  }\n                }\n                function et(Y, D3, J, q2) {\n                  if (!(Y.renderPass !== "offscreen" && Y.renderPass !== "translucent")) {\n                    for (var K = Y.context, de = Y.depthModeForSublayer(0, wi.ReadOnly), ne = Y.colorModeForRenderPass(), we = Y.renderPass === "translucent" ? Y.stencilConfigForOverlap(q2) : [{}, q2], Ue = we[0], ft = we[1], Xt = 0, hr = ft; Xt < hr.length; Xt += 1) {\n                      var qt = hr[Xt], Ve = D3.getTile(qt);\n                      Ve.needsHillshadePrepare && Y.renderPass === "offscreen" ? it(Y, Ve, J, de, Fn.disabled, ne) : Y.renderPass === "translucent" && We(Y, Ve, J, de, Ue[qt.overscaledZ], ne);\n                    }\n                    K.viewport.set([0, 0, Y.width, Y.height]);\n                  }\n                }\n                function We(Y, D3, J, q2, K, de) {\n                  var ne = Y.context, we = ne.gl, Ue = D3.fbo;\n                  if (Ue) {\n                    var ft = Y.useProgram("hillshade");\n                    ne.activeTexture.set(we.TEXTURE0), we.bindTexture(we.TEXTURE_2D, Ue.colorAttachment.get());\n                    var Xt = Ra(Y, D3, J);\n                    ft.draw(ne, we.TRIANGLES, q2, K, de, Er.disabled, Xt, J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments);\n                  }\n                }\n                function it(Y, D3, J, q2, K, de) {\n                  var ne = Y.context, we = ne.gl, Ue = D3.dem;\n                  if (Ue && Ue.data) {\n                    var ft = Ue.dim, Xt = Ue.stride, hr = Ue.getPixels();\n                    if (ne.activeTexture.set(we.TEXTURE1), ne.pixelStoreUnpackPremultiplyAlpha.set(false), D3.demTexture = D3.demTexture || Y.getTileTexture(Xt), D3.demTexture) {\n                      var qt = D3.demTexture;\n                      qt.update(hr, { premultiply: false }), qt.bind(we.NEAREST, we.CLAMP_TO_EDGE);\n                    } else D3.demTexture = new i3.Texture(ne, hr, we.RGBA, { premultiply: false }), D3.demTexture.bind(we.NEAREST, we.CLAMP_TO_EDGE);\n                    ne.activeTexture.set(we.TEXTURE0);\n                    var Ve = D3.fbo;\n                    if (!Ve) {\n                      var Qe = new i3.Texture(ne, { width: ft, height: ft, data: null }, we.RGBA);\n                      Qe.bind(we.LINEAR, we.CLAMP_TO_EDGE), Ve = D3.fbo = ne.createFramebuffer(ft, ft, true), Ve.colorAttachment.set(Qe.texture);\n                    }\n                    ne.bindFramebuffer.set(Ve.framebuffer), ne.viewport.set([0, 0, ft, ft]), Y.useProgram("hillshadePrepare").draw(ne, we.TRIANGLES, q2, K, de, Er.disabled, La(D3.tileID, Ue), J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments), D3.needsHillshadePrepare = false;\n                  }\n                }\n                function Ft(Y, D3, J, q2) {\n                  if (Y.renderPass === "translucent" && J.paint.get("raster-opacity") !== 0 && q2.length) for (var K = Y.context, de = K.gl, ne = D3.getSource(), we = Y.useProgram("raster"), Ue = Y.colorModeForRenderPass(), ft = ne instanceof Ce ? [{}, q2] : Y.stencilConfigForOverlap(q2), Xt = ft[0], hr = ft[1], qt = hr[hr.length - 1].overscaledZ, Ve = !Y.options.moving, Qe = 0, at = hr; Qe < at.length; Qe += 1) {\n                    var Ct = at[Qe], Ot = Y.depthModeForSublayer(Ct.overscaledZ - qt, J.paint.get("raster-opacity") === 1 ? wi.ReadWrite : wi.ReadOnly, de.LESS), Rt = D3.getTile(Ct), Bt = Y.transform.calculatePosMatrix(Ct.toUnwrapped(), Ve);\n                    Rt.registerFadeDuration(J.paint.get("raster-fade-duration"));\n                    var Dt = D3.findLoadedParent(Ct, 0), yt = Ht(Rt, Dt, D3, J, Y.transform), Pt = void 0, ht = void 0, ur = J.paint.get("raster-resampling") === "nearest" ? de.NEAREST : de.LINEAR;\n                    K.activeTexture.set(de.TEXTURE0), Rt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST), K.activeTexture.set(de.TEXTURE1), Dt ? (Dt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST), Pt = Math.pow(2, Dt.tileID.overscaledZ - Rt.tileID.overscaledZ), ht = [Rt.tileID.canonical.x * Pt % 1, Rt.tileID.canonical.y * Pt % 1]) : Rt.texture.bind(ur, de.CLAMP_TO_EDGE, de.LINEAR_MIPMAP_NEAREST);\n                    var br = Ls(Bt, ht || [0, 0], Pt || 1, yt, J);\n                    ne instanceof Ce ? we.draw(K, de.TRIANGLES, Ot, Fn.disabled, Ue, Er.disabled, br, J.id, ne.boundsBuffer, Y.quadTriangleIndexBuffer, ne.boundsSegments) : we.draw(K, de.TRIANGLES, Ot, Xt[Ct.overscaledZ], Ue, Er.disabled, br, J.id, Y.rasterBoundsBuffer, Y.quadTriangleIndexBuffer, Y.rasterBoundsSegments);\n                  }\n                }\n                function Ht(Y, D3, J, q2, K) {\n                  var de = q2.paint.get("raster-fade-duration");\n                  if (de > 0) {\n                    var ne = i3.browser.now(), we = (ne - Y.timeAdded) / de, Ue = D3 ? (ne - D3.timeAdded) / de : -1, ft = J.getSource(), Xt = K.coveringZoomLevel({ tileSize: ft.tileSize, roundZoom: ft.roundZoom }), hr = !D3 || Math.abs(D3.tileID.overscaledZ - Xt) > Math.abs(Y.tileID.overscaledZ - Xt), qt = hr && Y.refreshedUponExpiration ? 1 : i3.clamp(hr ? we : 1 - Ue, 0, 1);\n                    return Y.refreshedUponExpiration && we >= 1 && (Y.refreshedUponExpiration = false), D3 ? { opacity: 1, mix: 1 - qt } : { opacity: qt, mix: 0 };\n                  } else return { opacity: 1, mix: 0 };\n                }\n                function tr(Y, D3, J) {\n                  var q2 = J.paint.get("background-color"), K = J.paint.get("background-opacity");\n                  if (K !== 0) {\n                    var de = Y.context, ne = de.gl, we = Y.transform, Ue = we.tileSize, ft = J.paint.get("background-pattern");\n                    if (!Y.isPatternMissing(ft)) {\n                      var Xt = !ft && q2.a === 1 && K === 1 && Y.opaquePassEnabledForLayer() ? "opaque" : "translucent";\n                      if (Y.renderPass === Xt) {\n                        var hr = Fn.disabled, qt = Y.depthModeForSublayer(0, Xt === "opaque" ? wi.ReadWrite : wi.ReadOnly), Ve = Y.colorModeForRenderPass(), Qe = Y.useProgram(ft ? "backgroundPattern" : "background"), at = we.coveringTiles({ tileSize: Ue });\n                        ft && (de.activeTexture.set(ne.TEXTURE0), Y.imageManager.bind(Y.context));\n                        for (var Ct = J.getCrossfadeParameters(), Ot = 0, Rt = at; Ot < Rt.length; Ot += 1) {\n                          var Bt = Rt[Ot], Dt = Y.transform.calculatePosMatrix(Bt.toUnwrapped()), yt = ft ? Ua(Dt, K, Y, ft, { tileID: Bt, tileSize: Ue }, Ct) : Ac(Dt, K, q2);\n                          Qe.draw(de, ne.TRIANGLES, qt, hr, Ve, Er.disabled, yt, J.id, Y.tileExtentBuffer, Y.quadTriangleIndexBuffer, Y.tileExtentSegments);\n                        }\n                      }\n                    }\n                  }\n                }\n                var dr = new i3.Color(1, 0, 0, 1), Sr = new i3.Color(0, 1, 0, 1), Or = new i3.Color(0, 0, 1, 1), Wr = new i3.Color(1, 0, 1, 1), ni = new i3.Color(0, 1, 1, 1);\n                function Pi(Y) {\n                  var D3 = Y.transform.padding, J = 3;\n                  ln(Y, Y.transform.height - (D3.top || 0), J, dr), ln(Y, D3.bottom || 0, J, Sr), Cn(Y, D3.left || 0, J, Or), Cn(Y, Y.transform.width - (D3.right || 0), J, Wr);\n                  var q2 = Y.transform.centerPoint;\n                  cn(Y, q2.x, Y.transform.height - q2.y, ni);\n                }\n                function cn(Y, D3, J, q2) {\n                  var K = 20, de = 2;\n                  Kn(Y, D3 - de / 2, J - K / 2, de, K, q2), Kn(Y, D3 - K / 2, J - de / 2, K, de, q2);\n                }\n                function ln(Y, D3, J, q2) {\n                  Kn(Y, 0, D3 + J / 2, Y.transform.width, J, q2);\n                }\n                function Cn(Y, D3, J, q2) {\n                  Kn(Y, D3 - J / 2, 0, J, Y.transform.height, q2);\n                }\n                function Kn(Y, D3, J, q2, K, de) {\n                  var ne = Y.context, we = ne.gl;\n                  we.enable(we.SCISSOR_TEST), we.scissor(D3 * i3.browser.devicePixelRatio, J * i3.browser.devicePixelRatio, q2 * i3.browser.devicePixelRatio, K * i3.browser.devicePixelRatio), ne.clear({ color: de }), we.disable(we.SCISSOR_TEST);\n                }\n                function Ta(Y, D3, J) {\n                  for (var q2 = 0; q2 < J.length; q2++) fa(Y, D3, J[q2]);\n                }\n                function fa(Y, D3, J) {\n                  var q2 = Y.context, K = q2.gl, de = J.posMatrix, ne = Y.useProgram("debug"), we = wi.disabled, Ue = Fn.disabled, ft = Y.colorModeForRenderPass(), Xt = "$debug";\n                  q2.activeTexture.set(K.TEXTURE0), Y.emptyTexture.bind(K.LINEAR, K.CLAMP_TO_EDGE), ne.draw(q2, K.LINE_STRIP, we, Ue, ft, Er.disabled, dn(de, i3.Color.red), Xt, Y.debugBuffer, Y.tileBorderIndexBuffer, Y.debugSegments);\n                  var hr = D3.getTileByID(J.key).latestRawTileData, qt = hr && hr.byteLength || 0, Ve = Math.floor(qt / 1024), Qe = D3.getTile(J).tileSize, at = 512 / Math.min(Qe, 512) * (J.overscaledZ / Y.transform.zoom) * 0.5, Ct = J.canonical.toString();\n                  J.overscaledZ !== J.canonical.z && (Ct += " => " + J.overscaledZ);\n                  var Ot = Ct + " " + Ve + "kb";\n                  $a(Y, Ot), ne.draw(q2, K.TRIANGLES, we, Ue, wt.alphaBlended, Er.disabled, dn(de, i3.Color.transparent, at), Xt, Y.debugBuffer, Y.quadTriangleIndexBuffer, Y.debugSegments);\n                }\n                function $a(Y, D3) {\n                  Y.initDebugOverlayCanvas();\n                  var J = Y.debugOverlayCanvas, q2 = Y.context.gl, K = Y.debugOverlayCanvas.getContext("2d");\n                  K.clearRect(0, 0, J.width, J.height), K.shadowColor = "white", K.shadowBlur = 2, K.lineWidth = 1.5, K.strokeStyle = "white", K.textBaseline = "top", K.font = "bold 36px Open Sans, sans-serif", K.fillText(D3, 5, 5), K.strokeText(D3, 5, 5), Y.debugOverlayTexture.update(J), Y.debugOverlayTexture.bind(q2.LINEAR, q2.CLAMP_TO_EDGE);\n                }\n                function Co(Y, D3, J) {\n                  var q2 = Y.context, K = J.implementation;\n                  if (Y.renderPass === "offscreen") {\n                    var de = K.prerender;\n                    de && (Y.setCustomLayerDefaults(), q2.setColorMode(Y.colorModeForRenderPass()), de.call(K, q2.gl, Y.transform.customLayerMatrix()), q2.setDirty(), Y.setBaseState());\n                  } else if (Y.renderPass === "translucent") {\n                    Y.setCustomLayerDefaults(), q2.setColorMode(Y.colorModeForRenderPass()), q2.setStencilMode(Fn.disabled);\n                    var ne = K.renderingMode === "3d" ? new wi(Y.context.gl.LEQUAL, wi.ReadWrite, Y.depthRangeFor3D) : Y.depthModeForSublayer(0, wi.ReadOnly);\n                    q2.setDepthMode(ne), K.render(q2.gl, Y.transform.customLayerMatrix()), q2.setDirty(), Y.setBaseState(), q2.bindFramebuffer.set(null);\n                  }\n                }\n                var Qa = { symbol: w4, circle: ot, heatmap: Tt, line: Ir, fill: ve, "fill-extrusion": De, hillshade: et, raster: Ft, background: tr, debug: Ta, custom: Co }, mo = function(D3, J) {\n                  this.context = new Xr(D3), this.transform = J, this._tileTextures = {}, this.setup(), this.numSublayers = ri.maxUnderzooming + ri.maxOverzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new Uf(), this.gpuTimers = {};\n                };\n                mo.prototype.resize = function(D3, J) {\n                  if (this.width = D3 * i3.browser.devicePixelRatio, this.height = J * i3.browser.devicePixelRatio, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (var q2 = 0, K = this.style._order; q2 < K.length; q2 += 1) {\n                    var de = K[q2];\n                    this.style._layers[de].resize();\n                  }\n                }, mo.prototype.setup = function() {\n                  var D3 = this.context, J = new i3.StructArrayLayout2i4();\n                  J.emplaceBack(0, 0), J.emplaceBack(i3.EXTENT, 0), J.emplaceBack(0, i3.EXTENT), J.emplaceBack(i3.EXTENT, i3.EXTENT), this.tileExtentBuffer = D3.createVertexBuffer(J, oc.members), this.tileExtentSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2);\n                  var q2 = new i3.StructArrayLayout2i4();\n                  q2.emplaceBack(0, 0), q2.emplaceBack(i3.EXTENT, 0), q2.emplaceBack(0, i3.EXTENT), q2.emplaceBack(i3.EXTENT, i3.EXTENT), this.debugBuffer = D3.createVertexBuffer(q2, oc.members), this.debugSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 5);\n                  var K = new i3.StructArrayLayout4i8();\n                  K.emplaceBack(0, 0, 0, 0), K.emplaceBack(i3.EXTENT, 0, i3.EXTENT, 0), K.emplaceBack(0, i3.EXTENT, 0, i3.EXTENT), K.emplaceBack(i3.EXTENT, i3.EXTENT, i3.EXTENT, i3.EXTENT), this.rasterBoundsBuffer = D3.createVertexBuffer(K, Ee.members), this.rasterBoundsSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2);\n                  var de = new i3.StructArrayLayout2i4();\n                  de.emplaceBack(0, 0), de.emplaceBack(1, 0), de.emplaceBack(0, 1), de.emplaceBack(1, 1), this.viewportBuffer = D3.createVertexBuffer(de, oc.members), this.viewportSegments = i3.SegmentVector.simpleSegment(0, 0, 4, 2);\n                  var ne = new i3.StructArrayLayout1ui2();\n                  ne.emplaceBack(0), ne.emplaceBack(1), ne.emplaceBack(3), ne.emplaceBack(2), ne.emplaceBack(0), this.tileBorderIndexBuffer = D3.createIndexBuffer(ne);\n                  var we = new i3.StructArrayLayout3ui6();\n                  we.emplaceBack(0, 1, 2), we.emplaceBack(2, 1, 3), this.quadTriangleIndexBuffer = D3.createIndexBuffer(we), this.emptyTexture = new i3.Texture(D3, { width: 1, height: 1, data: new Uint8Array([0, 0, 0, 0]) }, D3.gl.RGBA);\n                  var Ue = this.context.gl;\n                  this.stencilClearMode = new Fn({ func: Ue.ALWAYS, mask: 0 }, 0, 255, Ue.ZERO, Ue.ZERO, Ue.ZERO);\n                }, mo.prototype.clearStencil = function() {\n                  var D3 = this.context, J = D3.gl;\n                  this.nextStencilID = 1, this.currentStencilSource = void 0;\n                  var q2 = i3.create();\n                  i3.ortho(q2, 0, this.width, this.height, 0, 0, 1), i3.scale(q2, q2, [J.drawingBufferWidth, J.drawingBufferHeight, 0]), this.useProgram("clippingMask").draw(D3, J.TRIANGLES, wi.disabled, this.stencilClearMode, wt.disabled, Er.disabled, Nn(q2), "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);\n                }, mo.prototype._renderTileClippingMasks = function(D3, J) {\n                  if (!(this.currentStencilSource === D3.source || !D3.isTileClipped() || !J || !J.length)) {\n                    this.currentStencilSource = D3.source;\n                    var q2 = this.context, K = q2.gl;\n                    this.nextStencilID + J.length > 256 && this.clearStencil(), q2.setColorMode(wt.disabled), q2.setDepthMode(wi.disabled);\n                    var de = this.useProgram("clippingMask");\n                    this._tileClippingMaskIDs = {};\n                    for (var ne = 0, we = J; ne < we.length; ne += 1) {\n                      var Ue = we[ne], ft = this._tileClippingMaskIDs[Ue.key] = this.nextStencilID++;\n                      de.draw(q2, K.TRIANGLES, wi.disabled, new Fn({ func: K.ALWAYS, mask: 0 }, ft, 255, K.KEEP, K.KEEP, K.REPLACE), wt.disabled, Er.disabled, Nn(Ue.posMatrix), "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);\n                    }\n                  }\n                }, mo.prototype.stencilModeFor3D = function() {\n                  this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();\n                  var D3 = this.nextStencilID++, J = this.context.gl;\n                  return new Fn({ func: J.NOTEQUAL, mask: 255 }, D3, 255, J.KEEP, J.KEEP, J.REPLACE);\n                }, mo.prototype.stencilModeForClipping = function(D3) {\n                  var J = this.context.gl;\n                  return new Fn({ func: J.EQUAL, mask: 255 }, this._tileClippingMaskIDs[D3.key], 0, J.KEEP, J.KEEP, J.REPLACE);\n                }, mo.prototype.stencilConfigForOverlap = function(D3) {\n                  var J, q2 = this.context.gl, K = D3.sort(function(ft, Xt) {\n                    return Xt.overscaledZ - ft.overscaledZ;\n                  }), de = K[K.length - 1].overscaledZ, ne = K[0].overscaledZ - de + 1;\n                  if (ne > 1) {\n                    this.currentStencilSource = void 0, this.nextStencilID + ne > 256 && this.clearStencil();\n                    for (var we = {}, Ue = 0; Ue < ne; Ue++) we[Ue + de] = new Fn({ func: q2.GEQUAL, mask: 255 }, Ue + this.nextStencilID, 255, q2.KEEP, q2.KEEP, q2.REPLACE);\n                    return this.nextStencilID += ne, [we, K];\n                  }\n                  return [(J = {}, J[de] = Fn.disabled, J), K];\n                }, mo.prototype.colorModeForRenderPass = function() {\n                  var D3 = this.context.gl;\n                  if (this._showOverdrawInspector) {\n                    var J = 8, q2 = 1 / J;\n                    return new wt([D3.CONSTANT_COLOR, D3.ONE], new i3.Color(q2, q2, q2, 0), [true, true, true, true]);\n                  } else return this.renderPass === "opaque" ? wt.unblended : wt.alphaBlended;\n                }, mo.prototype.depthModeForSublayer = function(D3, J, q2) {\n                  if (!this.opaquePassEnabledForLayer()) return wi.disabled;\n                  var K = 1 - ((1 + this.currentLayer) * this.numSublayers + D3) * this.depthEpsilon;\n                  return new wi(q2 || this.context.gl.LEQUAL, J, [K, K]);\n                }, mo.prototype.opaquePassEnabledForLayer = function() {\n                  return this.currentLayer < this.opaquePassCutoff;\n                }, mo.prototype.render = function(D3, J) {\n                  var q2 = this;\n                  this.style = D3, this.options = J, this.lineAtlas = D3.lineAtlas, this.imageManager = D3.imageManager, this.glyphManager = D3.glyphManager, this.symbolFadeChange = D3.placement.symbolFadeChange(i3.browser.now()), this.imageManager.beginFrame();\n                  var K = this.style._order, de = this.style.sourceCaches;\n                  for (var ne in de) {\n                    var we = de[ne];\n                    we.used && we.prepare(this.context);\n                  }\n                  var Ue = {}, ft = {}, Xt = {};\n                  for (var hr in de) {\n                    var qt = de[hr];\n                    Ue[hr] = qt.getVisibleCoordinates(), ft[hr] = Ue[hr].slice().reverse(), Xt[hr] = qt.getVisibleCoordinates(true).reverse();\n                  }\n                  this.opaquePassCutoff = 1 / 0;\n                  for (var Ve = 0; Ve < K.length; Ve++) {\n                    var Qe = K[Ve];\n                    if (this.style._layers[Qe].is3D()) {\n                      this.opaquePassCutoff = Ve;\n                      break;\n                    }\n                  }\n                  this.renderPass = "offscreen";\n                  for (var at = 0, Ct = K; at < Ct.length; at += 1) {\n                    var Ot = Ct[at], Rt = this.style._layers[Ot];\n                    if (!(!Rt.hasOffscreenPass() || Rt.isHidden(this.transform.zoom))) {\n                      var Bt = ft[Rt.source];\n                      Rt.type !== "custom" && !Bt.length || this.renderLayer(this, de[Rt.source], Rt, Bt);\n                    }\n                  }\n                  for (this.context.bindFramebuffer.set(null), this.context.clear({ color: J.showOverdrawInspector ? i3.Color.black : i3.Color.transparent, depth: 1 }), this.clearStencil(), this._showOverdrawInspector = J.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (D3._order.length + 2) * this.numSublayers * this.depthEpsilon], this.renderPass = "opaque", this.currentLayer = K.length - 1; this.currentLayer >= 0; this.currentLayer--) {\n                    var Dt = this.style._layers[K[this.currentLayer]], yt = de[Dt.source], Pt = Ue[Dt.source];\n                    this._renderTileClippingMasks(Dt, Pt), this.renderLayer(this, yt, Dt, Pt);\n                  }\n                  for (this.renderPass = "translucent", this.currentLayer = 0; this.currentLayer < K.length; this.currentLayer++) {\n                    var ht = this.style._layers[K[this.currentLayer]], ur = de[ht.source], br = (ht.type === "symbol" ? Xt : ft)[ht.source];\n                    this._renderTileClippingMasks(ht, Ue[ht.source]), this.renderLayer(this, ur, ht, br);\n                  }\n                  if (this.options.showTileBoundaries) {\n                    var Ur, Di, fi = i3.values(this.style._layers);\n                    fi.forEach(function(Ti) {\n                      Ti.source && !Ti.isHidden(q2.transform.zoom) && (Ti.source !== (Di && Di.id) && (Di = q2.style.sourceCaches[Ti.source]), (!Ur || Ur.getSource().maxzoom < Di.getSource().maxzoom) && (Ur = Di));\n                    }), Ur && Qa.debug(this, Ur, Ur.getVisibleCoordinates());\n                  }\n                  this.options.showPadding && Pi(this), this.context.setDefault();\n                }, mo.prototype.renderLayer = function(D3, J, q2, K) {\n                  q2.isHidden(this.transform.zoom) || q2.type !== "background" && q2.type !== "custom" && !K.length || (this.id = q2.id, this.gpuTimingStart(q2), Qa[q2.type](D3, J, q2, K, this.style.placement.variableOffsets), this.gpuTimingEnd());\n                }, mo.prototype.gpuTimingStart = function(D3) {\n                  if (this.options.gpuTiming) {\n                    var J = this.context.extTimerQuery, q2 = this.gpuTimers[D3.id];\n                    q2 || (q2 = this.gpuTimers[D3.id] = { calls: 0, cpuTime: 0, query: J.createQueryEXT() }), q2.calls++, J.beginQueryEXT(J.TIME_ELAPSED_EXT, q2.query);\n                  }\n                }, mo.prototype.gpuTimingEnd = function() {\n                  if (this.options.gpuTiming) {\n                    var D3 = this.context.extTimerQuery;\n                    D3.endQueryEXT(D3.TIME_ELAPSED_EXT);\n                  }\n                }, mo.prototype.collectGpuTimers = function() {\n                  var D3 = this.gpuTimers;\n                  return this.gpuTimers = {}, D3;\n                }, mo.prototype.queryGpuTimers = function(D3) {\n                  var J = {};\n                  for (var q2 in D3) {\n                    var K = D3[q2], de = this.context.extTimerQuery, ne = de.getQueryObjectEXT(K.query, de.QUERY_RESULT_EXT) / (1e3 * 1e3);\n                    de.deleteQueryEXT(K.query), J[q2] = ne;\n                  }\n                  return J;\n                }, mo.prototype.translatePosMatrix = function(D3, J, q2, K, de) {\n                  if (!q2[0] && !q2[1]) return D3;\n                  var ne = de ? K === "map" ? this.transform.angle : 0 : K === "viewport" ? -this.transform.angle : 0;\n                  if (ne) {\n                    var we = Math.sin(ne), Ue = Math.cos(ne);\n                    q2 = [q2[0] * Ue - q2[1] * we, q2[0] * we + q2[1] * Ue];\n                  }\n                  var ft = [de ? q2[0] : As(J, q2[0], this.transform.zoom), de ? q2[1] : As(J, q2[1], this.transform.zoom), 0], Xt = new Float32Array(16);\n                  return i3.translate(Xt, D3, ft), Xt;\n                }, mo.prototype.saveTileTexture = function(D3) {\n                  var J = this._tileTextures[D3.size[0]];\n                  J ? J.push(D3) : this._tileTextures[D3.size[0]] = [D3];\n                }, mo.prototype.getTileTexture = function(D3) {\n                  var J = this._tileTextures[D3];\n                  return J && J.length > 0 ? J.pop() : null;\n                }, mo.prototype.isPatternMissing = function(D3) {\n                  if (!D3) return false;\n                  if (!D3.from || !D3.to) return true;\n                  var J = this.imageManager.getPattern(D3.from.toString()), q2 = this.imageManager.getPattern(D3.to.toString());\n                  return !J || !q2;\n                }, mo.prototype.useProgram = function(D3, J) {\n                  this.cache = this.cache || {};\n                  var q2 = "" + D3 + (J ? J.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "");\n                  return this.cache[q2] || (this.cache[q2] = new Rf(this.context, D3, wf[D3], J, oo[D3], this._showOverdrawInspector)), this.cache[q2];\n                }, mo.prototype.setCustomLayerDefaults = function() {\n                  this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();\n                }, mo.prototype.setBaseState = function() {\n                  var D3 = this.context.gl;\n                  this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(D3.FUNC_ADD);\n                }, mo.prototype.initDebugOverlayCanvas = function() {\n                  if (this.debugOverlayCanvas == null) {\n                    this.debugOverlayCanvas = i3.window.document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512;\n                    var D3 = this.context.gl;\n                    this.debugOverlayTexture = new i3.Texture(this.context, this.debugOverlayCanvas, D3.RGBA);\n                  }\n                }, mo.prototype.destroy = function() {\n                  this.emptyTexture.destroy(), this.debugOverlayTexture && this.debugOverlayTexture.destroy();\n                };\n                var Bo = function(D3, J) {\n                  this.points = D3, this.planes = J;\n                };\n                Bo.fromInvProjectionMatrix = function(D3, J, q2) {\n                  var K = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]], de = Math.pow(2, q2), ne = K.map(function(ft) {\n                    return i3.transformMat4([], ft, D3);\n                  }).map(function(ft) {\n                    return i3.scale$1([], ft, 1 / ft[3] / J * de);\n                  }), we = [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]], Ue = we.map(function(ft) {\n                    var Xt = i3.sub([], ne[ft[0]], ne[ft[1]]), hr = i3.sub([], ne[ft[2]], ne[ft[1]]), qt = i3.normalize([], i3.cross([], Xt, hr)), Ve = -i3.dot(qt, ne[ft[1]]);\n                    return qt.concat(Ve);\n                  });\n                  return new Bo(ne, Ue);\n                };\n                var Ps = function(D3, J) {\n                  this.min = D3, this.max = J, this.center = i3.scale$2([], i3.add([], this.min, this.max), 0.5);\n                };\n                Ps.prototype.quadrant = function(D3) {\n                  for (var J = [D3 % 2 === 0, D3 < 2], q2 = i3.clone$2(this.min), K = i3.clone$2(this.max), de = 0; de < J.length; de++) q2[de] = J[de] ? this.min[de] : this.center[de], K[de] = J[de] ? this.center[de] : this.max[de];\n                  return K[2] = this.max[2], new Ps(q2, K);\n                }, Ps.prototype.distanceX = function(D3) {\n                  var J = Math.max(Math.min(this.max[0], D3[0]), this.min[0]);\n                  return J - D3[0];\n                }, Ps.prototype.distanceY = function(D3) {\n                  var J = Math.max(Math.min(this.max[1], D3[1]), this.min[1]);\n                  return J - D3[1];\n                }, Ps.prototype.intersects = function(D3) {\n                  for (var J = [[this.min[0], this.min[1], 0, 1], [this.max[0], this.min[1], 0, 1], [this.max[0], this.max[1], 0, 1], [this.min[0], this.max[1], 0, 1]], q2 = true, K = 0; K < D3.planes.length; K++) {\n                    for (var de = D3.planes[K], ne = 0, we = 0; we < J.length; we++) ne += i3.dot$1(de, J[we]) >= 0;\n                    if (ne === 0) return 0;\n                    ne !== J.length && (q2 = false);\n                  }\n                  if (q2) return 2;\n                  for (var Ue = 0; Ue < 3; Ue++) {\n                    for (var ft = Number.MAX_VALUE, Xt = -Number.MAX_VALUE, hr = 0; hr < D3.points.length; hr++) {\n                      var qt = D3.points[hr][Ue] - this.min[Ue];\n                      ft = Math.min(ft, qt), Xt = Math.max(Xt, qt);\n                    }\n                    if (Xt < 0 || ft > this.max[Ue] - this.min[Ue]) return 0;\n                  }\n                  return 1;\n                };\n                var Ts = function(D3, J, q2, K) {\n                  if (D3 === void 0 && (D3 = 0), J === void 0 && (J = 0), q2 === void 0 && (q2 = 0), K === void 0 && (K = 0), isNaN(D3) || D3 < 0 || isNaN(J) || J < 0 || isNaN(q2) || q2 < 0 || isNaN(K) || K < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");\n                  this.top = D3, this.bottom = J, this.left = q2, this.right = K;\n                };\n                Ts.prototype.interpolate = function(D3, J, q2) {\n                  return J.top != null && D3.top != null && (this.top = i3.number(D3.top, J.top, q2)), J.bottom != null && D3.bottom != null && (this.bottom = i3.number(D3.bottom, J.bottom, q2)), J.left != null && D3.left != null && (this.left = i3.number(D3.left, J.left, q2)), J.right != null && D3.right != null && (this.right = i3.number(D3.right, J.right, q2)), this;\n                }, Ts.prototype.getCenter = function(D3, J) {\n                  var q2 = i3.clamp((this.left + D3 - this.right) / 2, 0, D3), K = i3.clamp((this.top + J - this.bottom) / 2, 0, J);\n                  return new i3.Point(q2, K);\n                }, Ts.prototype.equals = function(D3) {\n                  return this.top === D3.top && this.bottom === D3.bottom && this.left === D3.left && this.right === D3.right;\n                }, Ts.prototype.clone = function() {\n                  return new Ts(this.top, this.bottom, this.left, this.right);\n                }, Ts.prototype.toJSON = function() {\n                  return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };\n                };\n                var wo = function(D3, J, q2, K, de) {\n                  this.tileSize = 512, this.maxValidLatitude = 85.051129, this._renderWorldCopies = de === void 0 ? true : de, this._minZoom = D3 || 0, this._maxZoom = J || 22, this._minPitch = q2 == null ? 0 : q2, this._maxPitch = K == null ? 60 : K, this.setMaxBounds(), this.width = 0, this.height = 0, this._center = new i3.LngLat(0, 0), this.zoom = 0, this.angle = 0, this._fov = 0.6435011087932844, this._pitch = 0, this._unmodified = true, this._edgeInsets = new Ts(), this._posMatrixCache = {}, this._alignedPosMatrixCache = {};\n                }, To = { minZoom: { configurable: true }, maxZoom: { configurable: true }, minPitch: { configurable: true }, maxPitch: { configurable: true }, renderWorldCopies: { configurable: true }, worldSize: { configurable: true }, centerOffset: { configurable: true }, size: { configurable: true }, bearing: { configurable: true }, pitch: { configurable: true }, fov: { configurable: true }, zoom: { configurable: true }, center: { configurable: true }, padding: { configurable: true }, centerPoint: { configurable: true }, unmodified: { configurable: true }, point: { configurable: true } };\n                wo.prototype.clone = function() {\n                  var D3 = new wo(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);\n                  return D3.tileSize = this.tileSize, D3.latRange = this.latRange, D3.width = this.width, D3.height = this.height, D3._center = this._center, D3.zoom = this.zoom, D3.angle = this.angle, D3._fov = this._fov, D3._pitch = this._pitch, D3._unmodified = this._unmodified, D3._edgeInsets = this._edgeInsets.clone(), D3._calcMatrices(), D3;\n                }, To.minZoom.get = function() {\n                  return this._minZoom;\n                }, To.minZoom.set = function(Y) {\n                  this._minZoom !== Y && (this._minZoom = Y, this.zoom = Math.max(this.zoom, Y));\n                }, To.maxZoom.get = function() {\n                  return this._maxZoom;\n                }, To.maxZoom.set = function(Y) {\n                  this._maxZoom !== Y && (this._maxZoom = Y, this.zoom = Math.min(this.zoom, Y));\n                }, To.minPitch.get = function() {\n                  return this._minPitch;\n                }, To.minPitch.set = function(Y) {\n                  this._minPitch !== Y && (this._minPitch = Y, this.pitch = Math.max(this.pitch, Y));\n                }, To.maxPitch.get = function() {\n                  return this._maxPitch;\n                }, To.maxPitch.set = function(Y) {\n                  this._maxPitch !== Y && (this._maxPitch = Y, this.pitch = Math.min(this.pitch, Y));\n                }, To.renderWorldCopies.get = function() {\n                  return this._renderWorldCopies;\n                }, To.renderWorldCopies.set = function(Y) {\n                  Y === void 0 ? Y = true : Y === null && (Y = false), this._renderWorldCopies = Y;\n                }, To.worldSize.get = function() {\n                  return this.tileSize * this.scale;\n                }, To.centerOffset.get = function() {\n                  return this.centerPoint._sub(this.size._div(2));\n                }, To.size.get = function() {\n                  return new i3.Point(this.width, this.height);\n                }, To.bearing.get = function() {\n                  return -this.angle / Math.PI * 180;\n                }, To.bearing.set = function(Y) {\n                  var D3 = -i3.wrap(Y, -180, 180) * Math.PI / 180;\n                  this.angle !== D3 && (this._unmodified = false, this.angle = D3, this._calcMatrices(), this.rotationMatrix = i3.create$2(), i3.rotate(this.rotationMatrix, this.rotationMatrix, this.angle));\n                }, To.pitch.get = function() {\n                  return this._pitch / Math.PI * 180;\n                }, To.pitch.set = function(Y) {\n                  var D3 = i3.clamp(Y, this.minPitch, this.maxPitch) / 180 * Math.PI;\n                  this._pitch !== D3 && (this._unmodified = false, this._pitch = D3, this._calcMatrices());\n                }, To.fov.get = function() {\n                  return this._fov / Math.PI * 180;\n                }, To.fov.set = function(Y) {\n                  Y = Math.max(0.01, Math.min(60, Y)), this._fov !== Y && (this._unmodified = false, this._fov = Y / 180 * Math.PI, this._calcMatrices());\n                }, To.zoom.get = function() {\n                  return this._zoom;\n                }, To.zoom.set = function(Y) {\n                  var D3 = Math.min(Math.max(Y, this.minZoom), this.maxZoom);\n                  this._zoom !== D3 && (this._unmodified = false, this._zoom = D3, this.scale = this.zoomScale(D3), this.tileZoom = Math.floor(D3), this.zoomFraction = D3 - this.tileZoom, this._constrain(), this._calcMatrices());\n                }, To.center.get = function() {\n                  return this._center;\n                }, To.center.set = function(Y) {\n                  Y.lat === this._center.lat && Y.lng === this._center.lng || (this._unmodified = false, this._center = Y, this._constrain(), this._calcMatrices());\n                }, To.padding.get = function() {\n                  return this._edgeInsets.toJSON();\n                }, To.padding.set = function(Y) {\n                  this._edgeInsets.equals(Y) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, Y, 1), this._calcMatrices());\n                }, To.centerPoint.get = function() {\n                  return this._edgeInsets.getCenter(this.width, this.height);\n                }, wo.prototype.isPaddingEqual = function(D3) {\n                  return this._edgeInsets.equals(D3);\n                }, wo.prototype.interpolatePadding = function(D3, J, q2) {\n                  this._unmodified = false, this._edgeInsets.interpolate(D3, J, q2), this._constrain(), this._calcMatrices();\n                }, wo.prototype.coveringZoomLevel = function(D3) {\n                  var J = (D3.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / D3.tileSize));\n                  return Math.max(0, J);\n                }, wo.prototype.getVisibleUnwrappedCoordinates = function(D3) {\n                  var J = [new i3.UnwrappedTileID(0, D3)];\n                  if (this._renderWorldCopies) for (var q2 = this.pointCoordinate(new i3.Point(0, 0)), K = this.pointCoordinate(new i3.Point(this.width, 0)), de = this.pointCoordinate(new i3.Point(this.width, this.height)), ne = this.pointCoordinate(new i3.Point(0, this.height)), we = Math.floor(Math.min(q2.x, K.x, de.x, ne.x)), Ue = Math.floor(Math.max(q2.x, K.x, de.x, ne.x)), ft = 1, Xt = we - ft; Xt <= Ue + ft; Xt++) Xt !== 0 && J.push(new i3.UnwrappedTileID(Xt, D3));\n                  return J;\n                }, wo.prototype.coveringTiles = function(D3) {\n                  var J = this.coveringZoomLevel(D3), q2 = J;\n                  if (D3.minzoom !== void 0 && J < D3.minzoom) return [];\n                  D3.maxzoom !== void 0 && J > D3.maxzoom && (J = D3.maxzoom);\n                  var K = i3.MercatorCoordinate.fromLngLat(this.center), de = Math.pow(2, J), ne = [de * K.x, de * K.y, 0], we = Bo.fromInvProjectionMatrix(this.invProjMatrix, this.worldSize, J), Ue = D3.minzoom || 0;\n                  this.pitch <= 60 && this._edgeInsets.top < 0.1 && (Ue = J);\n                  var ft = 3, Xt = function(fi) {\n                    return { aabb: new Ps([fi * de, 0, 0], [(fi + 1) * de, de, 0]), zoom: 0, x: 0, y: 0, wrap: fi, fullyVisible: false };\n                  }, hr = [], qt = [], Ve = J, Qe = D3.reparseOverscaled ? q2 : J;\n                  if (this._renderWorldCopies) for (var at = 1; at <= 3; at++) hr.push(Xt(-at)), hr.push(Xt(at));\n                  for (hr.push(Xt(0)); hr.length > 0; ) {\n                    var Ct = hr.pop(), Ot = Ct.x, Rt = Ct.y, Bt = Ct.fullyVisible;\n                    if (!Bt) {\n                      var Dt = Ct.aabb.intersects(we);\n                      if (Dt === 0) continue;\n                      Bt = Dt === 2;\n                    }\n                    var yt = Ct.aabb.distanceX(ne), Pt = Ct.aabb.distanceY(ne), ht = Math.max(Math.abs(yt), Math.abs(Pt)), ur = ft + (1 << Ve - Ct.zoom) - 2;\n                    if (Ct.zoom === Ve || ht > ur && Ct.zoom >= Ue) {\n                      qt.push({ tileID: new i3.OverscaledTileID(Ct.zoom === Ve ? Qe : Ct.zoom, Ct.wrap, Ct.zoom, Ot, Rt), distanceSq: i3.sqrLen([ne[0] - 0.5 - Ot, ne[1] - 0.5 - Rt]) });\n                      continue;\n                    }\n                    for (var br = 0; br < 4; br++) {\n                      var Ur = (Ot << 1) + br % 2, Di = (Rt << 1) + (br >> 1);\n                      hr.push({ aabb: Ct.aabb.quadrant(br), zoom: Ct.zoom + 1, x: Ur, y: Di, wrap: Ct.wrap, fullyVisible: Bt });\n                    }\n                  }\n                  return qt.sort(function(fi, Ti) {\n                    return fi.distanceSq - Ti.distanceSq;\n                  }).map(function(fi) {\n                    return fi.tileID;\n                  });\n                }, wo.prototype.resize = function(D3, J) {\n                  this.width = D3, this.height = J, this.pixelsToGLUnits = [2 / D3, -2 / J], this._constrain(), this._calcMatrices();\n                }, To.unmodified.get = function() {\n                  return this._unmodified;\n                }, wo.prototype.zoomScale = function(D3) {\n                  return Math.pow(2, D3);\n                }, wo.prototype.scaleZoom = function(D3) {\n                  return Math.log(D3) / Math.LN2;\n                }, wo.prototype.project = function(D3) {\n                  var J = i3.clamp(D3.lat, -this.maxValidLatitude, this.maxValidLatitude);\n                  return new i3.Point(i3.mercatorXfromLng(D3.lng) * this.worldSize, i3.mercatorYfromLat(J) * this.worldSize);\n                }, wo.prototype.unproject = function(D3) {\n                  return new i3.MercatorCoordinate(D3.x / this.worldSize, D3.y / this.worldSize).toLngLat();\n                }, To.point.get = function() {\n                  return this.project(this.center);\n                }, wo.prototype.setLocationAtPoint = function(D3, J) {\n                  var q2 = this.pointCoordinate(J), K = this.pointCoordinate(this.centerPoint), de = this.locationCoordinate(D3), ne = new i3.MercatorCoordinate(de.x - (q2.x - K.x), de.y - (q2.y - K.y));\n                  this.center = this.coordinateLocation(ne), this._renderWorldCopies && (this.center = this.center.wrap());\n                }, wo.prototype.locationPoint = function(D3) {\n                  return this.coordinatePoint(this.locationCoordinate(D3));\n                }, wo.prototype.pointLocation = function(D3) {\n                  return this.coordinateLocation(this.pointCoordinate(D3));\n                }, wo.prototype.locationCoordinate = function(D3) {\n                  return i3.MercatorCoordinate.fromLngLat(D3);\n                }, wo.prototype.coordinateLocation = function(D3) {\n                  return D3.toLngLat();\n                }, wo.prototype.pointCoordinate = function(D3) {\n                  var J = 0, q2 = [D3.x, D3.y, 0, 1], K = [D3.x, D3.y, 1, 1];\n                  i3.transformMat4(q2, q2, this.pixelMatrixInverse), i3.transformMat4(K, K, this.pixelMatrixInverse);\n                  var de = q2[3], ne = K[3], we = q2[0] / de, Ue = K[0] / ne, ft = q2[1] / de, Xt = K[1] / ne, hr = q2[2] / de, qt = K[2] / ne, Ve = hr === qt ? 0 : (J - hr) / (qt - hr);\n                  return new i3.MercatorCoordinate(i3.number(we, Ue, Ve) / this.worldSize, i3.number(ft, Xt, Ve) / this.worldSize);\n                }, wo.prototype.coordinatePoint = function(D3) {\n                  var J = [D3.x * this.worldSize, D3.y * this.worldSize, 0, 1];\n                  return i3.transformMat4(J, J, this.pixelMatrix), new i3.Point(J[0] / J[3], J[1] / J[3]);\n                }, wo.prototype.getBounds = function() {\n                  return new i3.LngLatBounds().extend(this.pointLocation(new i3.Point(0, 0))).extend(this.pointLocation(new i3.Point(this.width, 0))).extend(this.pointLocation(new i3.Point(this.width, this.height))).extend(this.pointLocation(new i3.Point(0, this.height)));\n                }, wo.prototype.getMaxBounds = function() {\n                  return !this.latRange || this.latRange.length !== 2 || !this.lngRange || this.lngRange.length !== 2 ? null : new i3.LngLatBounds([this.lngRange[0], this.latRange[0]], [this.lngRange[1], this.latRange[1]]);\n                }, wo.prototype.setMaxBounds = function(D3) {\n                  D3 ? (this.lngRange = [D3.getWest(), D3.getEast()], this.latRange = [D3.getSouth(), D3.getNorth()], this._constrain()) : (this.lngRange = null, this.latRange = [-this.maxValidLatitude, this.maxValidLatitude]);\n                }, wo.prototype.calculatePosMatrix = function(D3, J) {\n                  J === void 0 && (J = false);\n                  var q2 = D3.key, K = J ? this._alignedPosMatrixCache : this._posMatrixCache;\n                  if (K[q2]) return K[q2];\n                  var de = D3.canonical, ne = this.worldSize / this.zoomScale(de.z), we = de.x + Math.pow(2, de.z) * D3.wrap, Ue = i3.identity(new Float64Array(16));\n                  return i3.translate(Ue, Ue, [we * ne, de.y * ne, 0]), i3.scale(Ue, Ue, [ne / i3.EXTENT, ne / i3.EXTENT, 1]), i3.multiply(Ue, J ? this.alignedProjMatrix : this.projMatrix, Ue), K[q2] = new Float32Array(Ue), K[q2];\n                }, wo.prototype.customLayerMatrix = function() {\n                  return this.mercatorMatrix.slice();\n                }, wo.prototype._constrain = function() {\n                  if (!(!this.center || !this.width || !this.height || this._constraining)) {\n                    this._constraining = true;\n                    var D3 = -90, J = 90, q2 = -180, K = 180, de, ne, we, Ue, ft = this.size, Xt = this._unmodified;\n                    if (this.latRange) {\n                      var hr = this.latRange;\n                      D3 = i3.mercatorYfromLat(hr[1]) * this.worldSize, J = i3.mercatorYfromLat(hr[0]) * this.worldSize, de = J - D3 < ft.y ? ft.y / (J - D3) : 0;\n                    }\n                    if (this.lngRange) {\n                      var qt = this.lngRange;\n                      q2 = i3.mercatorXfromLng(qt[0]) * this.worldSize, K = i3.mercatorXfromLng(qt[1]) * this.worldSize, ne = K - q2 < ft.x ? ft.x / (K - q2) : 0;\n                    }\n                    var Ve = this.point, Qe = Math.max(ne || 0, de || 0);\n                    if (Qe) {\n                      this.center = this.unproject(new i3.Point(ne ? (K + q2) / 2 : Ve.x, de ? (J + D3) / 2 : Ve.y)), this.zoom += this.scaleZoom(Qe), this._unmodified = Xt, this._constraining = false;\n                      return;\n                    }\n                    if (this.latRange) {\n                      var at = Ve.y, Ct = ft.y / 2;\n                      at - Ct < D3 && (Ue = D3 + Ct), at + Ct > J && (Ue = J - Ct);\n                    }\n                    if (this.lngRange) {\n                      var Ot = Ve.x, Rt = ft.x / 2;\n                      Ot - Rt < q2 && (we = q2 + Rt), Ot + Rt > K && (we = K - Rt);\n                    }\n                    (we !== void 0 || Ue !== void 0) && (this.center = this.unproject(new i3.Point(we !== void 0 ? we : Ve.x, Ue !== void 0 ? Ue : Ve.y))), this._unmodified = Xt, this._constraining = false;\n                  }\n                }, wo.prototype._calcMatrices = function() {\n                  if (this.height) {\n                    var D3 = this._fov / 2, J = this.centerOffset;\n                    this.cameraToCenterDistance = 0.5 / Math.tan(D3) * this.height;\n                    var q2 = Math.PI / 2 + this._pitch, K = this._fov * (0.5 + J.y / this.height), de = Math.sin(K) * this.cameraToCenterDistance / Math.sin(i3.clamp(Math.PI - q2 - K, 0.01, Math.PI - 0.01)), ne = this.point, we = ne.x, Ue = ne.y, ft = Math.cos(Math.PI / 2 - this._pitch) * de + this.cameraToCenterDistance, Xt = ft * 1.01, hr = this.height / 50, qt = new Float64Array(16);\n                    i3.perspective(qt, this._fov, this.width / this.height, hr, Xt), qt[8] = -J.x * 2 / this.width, qt[9] = J.y * 2 / this.height, i3.scale(qt, qt, [1, -1, 1]), i3.translate(qt, qt, [0, 0, -this.cameraToCenterDistance]), i3.rotateX(qt, qt, this._pitch), i3.rotateZ(qt, qt, this.angle), i3.translate(qt, qt, [-we, -Ue, 0]), this.mercatorMatrix = i3.scale([], qt, [this.worldSize, this.worldSize, this.worldSize]), i3.scale(qt, qt, [1, 1, i3.mercatorZfromAltitude(1, this.center.lat) * this.worldSize, 1]), this.projMatrix = qt, this.invProjMatrix = i3.invert([], this.projMatrix);\n                    var Ve = this.width % 2 / 2, Qe = this.height % 2 / 2, at = Math.cos(this.angle), Ct = Math.sin(this.angle), Ot = we - Math.round(we) + at * Ve + Ct * Qe, Rt = Ue - Math.round(Ue) + at * Qe + Ct * Ve, Bt = new Float64Array(qt);\n                    if (i3.translate(Bt, Bt, [Ot > 0.5 ? Ot - 1 : Ot, Rt > 0.5 ? Rt - 1 : Rt, 0]), this.alignedProjMatrix = Bt, qt = i3.create(), i3.scale(qt, qt, [this.width / 2, -this.height / 2, 1]), i3.translate(qt, qt, [1, -1, 0]), this.labelPlaneMatrix = qt, qt = i3.create(), i3.scale(qt, qt, [1, -1, 1]), i3.translate(qt, qt, [-1, -1, 0]), i3.scale(qt, qt, [2 / this.width, 2 / this.height, 1]), this.glCoordMatrix = qt, this.pixelMatrix = i3.multiply(new Float64Array(16), this.labelPlaneMatrix, this.projMatrix), qt = i3.invert(new Float64Array(16), this.pixelMatrix), !qt) throw new Error("failed to invert matrix");\n                    this.pixelMatrixInverse = qt, this._posMatrixCache = {}, this._alignedPosMatrixCache = {};\n                  }\n                }, wo.prototype.maxPitchScaleFactor = function() {\n                  if (!this.pixelMatrixInverse) return 1;\n                  var D3 = this.pointCoordinate(new i3.Point(0, 0)), J = [D3.x * this.worldSize, D3.y * this.worldSize, 0, 1], q2 = i3.transformMat4(J, J, this.pixelMatrix);\n                  return q2[3] / this.cameraToCenterDistance;\n                }, wo.prototype.getCameraPoint = function() {\n                  var D3 = this._pitch, J = Math.tan(D3) * (this.cameraToCenterDistance || 1);\n                  return this.centerPoint.add(new i3.Point(0, J));\n                }, wo.prototype.getCameraQueryGeometry = function(D3) {\n                  var J = this.getCameraPoint();\n                  if (D3.length === 1) return [D3[0], J];\n                  for (var q2 = J.x, K = J.y, de = J.x, ne = J.y, we = 0, Ue = D3; we < Ue.length; we += 1) {\n                    var ft = Ue[we];\n                    q2 = Math.min(q2, ft.x), K = Math.min(K, ft.y), de = Math.max(de, ft.x), ne = Math.max(ne, ft.y);\n                  }\n                  return [new i3.Point(q2, K), new i3.Point(de, K), new i3.Point(de, ne), new i3.Point(q2, ne), new i3.Point(q2, K)];\n                }, Object.defineProperties(wo.prototype, To);\n                function hl(Y, D3) {\n                  var J = false, q2 = null, K = function() {\n                    q2 = null, J && (Y(), q2 = setTimeout(K, D3), J = false);\n                  };\n                  return function() {\n                    return J = true, q2 || K(), q2;\n                  };\n                }\n                var Ul = function(D3) {\n                  this._hashName = D3 && encodeURIComponent(D3), i3.bindAll(["_getCurrentHash", "_onHashChange", "_updateHash"], this), this._updateHash = hl(this._updateHashUnthrottled.bind(this), 30 * 1e3 / 100);\n                };\n                Ul.prototype.addTo = function(D3) {\n                  return this._map = D3, i3.window.addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;\n                }, Ul.prototype.remove = function() {\n                  return i3.window.removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), delete this._map, this;\n                }, Ul.prototype.getHashString = function(D3) {\n                  var J = this._map.getCenter(), q2 = Math.round(this._map.getZoom() * 100) / 100, K = Math.ceil((q2 * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), de = Math.pow(10, K), ne = Math.round(J.lng * de) / de, we = Math.round(J.lat * de) / de, Ue = this._map.getBearing(), ft = this._map.getPitch(), Xt = "";\n                  if (D3 ? Xt += "/" + ne + "/" + we + "/" + q2 : Xt += q2 + "/" + we + "/" + ne, (Ue || ft) && (Xt += "/" + Math.round(Ue * 10) / 10), ft && (Xt += "/" + Math.round(ft)), this._hashName) {\n                    var hr = this._hashName, qt = false, Ve = i3.window.location.hash.slice(1).split("&").map(function(Qe) {\n                      var at = Qe.split("=")[0];\n                      return at === hr ? (qt = true, at + "=" + Xt) : Qe;\n                    }).filter(function(Qe) {\n                      return Qe;\n                    });\n                    return qt || Ve.push(hr + "=" + Xt), "#" + Ve.join("&");\n                  }\n                  return "#" + Xt;\n                }, Ul.prototype._getCurrentHash = function() {\n                  var D3 = this, J = i3.window.location.hash.replace("#", "");\n                  if (this._hashName) {\n                    var q2;\n                    return J.split("&").map(function(K) {\n                      return K.split("=");\n                    }).forEach(function(K) {\n                      K[0] === D3._hashName && (q2 = K);\n                    }), (q2 && q2[1] || "").split("/");\n                  }\n                  return J.split("/");\n                }, Ul.prototype._onHashChange = function() {\n                  var D3 = this._getCurrentHash();\n                  if (D3.length >= 3 && !D3.some(function(q2) {\n                    return isNaN(q2);\n                  })) {\n                    var J = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(D3[3] || 0) : this._map.getBearing();\n                    return this._map.jumpTo({ center: [+D3[2], +D3[1]], zoom: +D3[0], bearing: J, pitch: +(D3[4] || 0) }), true;\n                  }\n                  return false;\n                }, Ul.prototype._updateHashUnthrottled = function() {\n                  var D3 = i3.window.location.href.replace(/(#.+)?$/, this.getHashString());\n                  try {\n                    i3.window.history.replaceState(i3.window.history.state, null, D3);\n                  } catch (J) {\n                  }\n                };\n                var Lu = { linearity: 0.3, easing: i3.bezier(0, 0, 0.3, 1) }, au = i3.extend({ deceleration: 2500, maxSpeed: 1400 }, Lu), Js = i3.extend({ deceleration: 20, maxSpeed: 1400 }, Lu), Ql = i3.extend({ deceleration: 1e3, maxSpeed: 360 }, Lu), dc = i3.extend({ deceleration: 1e3, maxSpeed: 90 }, Lu), Tl = function(D3) {\n                  this._map = D3, this.clear();\n                };\n                Tl.prototype.clear = function() {\n                  this._inertiaBuffer = [];\n                }, Tl.prototype.record = function(D3) {\n                  this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: i3.browser.now(), settings: D3 });\n                }, Tl.prototype._drainInertiaBuffer = function() {\n                  for (var D3 = this._inertiaBuffer, J = i3.browser.now(), q2 = 160; D3.length > 0 && J - D3[0].time > q2; ) D3.shift();\n                }, Tl.prototype._onMoveEnd = function(D3) {\n                  if (this._drainInertiaBuffer(), !(this._inertiaBuffer.length < 2)) {\n                    for (var J = { zoom: 0, bearing: 0, pitch: 0, pan: new i3.Point(0, 0), pinchAround: void 0, around: void 0 }, q2 = 0, K = this._inertiaBuffer; q2 < K.length; q2 += 1) {\n                      var de = K[q2], ne = de.settings;\n                      J.zoom += ne.zoomDelta || 0, J.bearing += ne.bearingDelta || 0, J.pitch += ne.pitchDelta || 0, ne.panDelta && J.pan._add(ne.panDelta), ne.around && (J.around = ne.around), ne.pinchAround && (J.pinchAround = ne.pinchAround);\n                    }\n                    var we = this._inertiaBuffer[this._inertiaBuffer.length - 1], Ue = we.time - this._inertiaBuffer[0].time, ft = {};\n                    if (J.pan.mag()) {\n                      var Xt = X(J.pan.mag(), Ue, i3.extend({}, au, D3 || {}));\n                      ft.offset = J.pan.mult(Xt.amount / J.pan.mag()), ft.center = this._map.transform.center, Al(ft, Xt);\n                    }\n                    if (J.zoom) {\n                      var hr = X(J.zoom, Ue, Js);\n                      ft.zoom = this._map.transform.zoom + hr.amount, Al(ft, hr);\n                    }\n                    if (J.bearing) {\n                      var qt = X(J.bearing, Ue, Ql);\n                      ft.bearing = this._map.transform.bearing + i3.clamp(qt.amount, -179, 179), Al(ft, qt);\n                    }\n                    if (J.pitch) {\n                      var Ve = X(J.pitch, Ue, dc);\n                      ft.pitch = this._map.transform.pitch + Ve.amount, Al(ft, Ve);\n                    }\n                    if (ft.zoom || ft.bearing) {\n                      var Qe = J.pinchAround === void 0 ? J.around : J.pinchAround;\n                      ft.around = Qe ? this._map.unproject(Qe) : this._map.getCenter();\n                    }\n                    return this.clear(), i3.extend(ft, { noMoveStart: true });\n                  }\n                };\n                function Al(Y, D3) {\n                  (!Y.duration || Y.duration < D3.duration) && (Y.duration = D3.duration, Y.easing = D3.easing);\n                }\n                function X(Y, D3, J) {\n                  var q2 = J.maxSpeed, K = J.linearity, de = J.deceleration, ne = i3.clamp(Y * K / (D3 / 1e3), -q2, q2), we = Math.abs(ne) / (de * K);\n                  return { easing: J.easing, duration: we * 1e3, amount: ne * (we / 2) };\n                }\n                var se = (function(Y) {\n                  function D3(q2, K, de, ne) {\n                    ne === void 0 && (ne = {});\n                    var we = o4.mousePos(K.getCanvasContainer(), de), Ue = K.unproject(we);\n                    Y.call(this, q2, i3.extend({ point: we, lngLat: Ue, originalEvent: de }, ne)), this._defaultPrevented = false, this.target = K;\n                  }\n                  Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3;\n                  var J = { defaultPrevented: { configurable: true } };\n                  return D3.prototype.preventDefault = function() {\n                    this._defaultPrevented = true;\n                  }, J.defaultPrevented.get = function() {\n                    return this._defaultPrevented;\n                  }, Object.defineProperties(D3.prototype, J), D3;\n                })(i3.Event), Te = (function(Y) {\n                  function D3(q2, K, de) {\n                    var ne = q2 === "touchend" ? de.changedTouches : de.touches, we = o4.touchPos(K.getCanvasContainer(), ne), Ue = we.map(function(hr) {\n                      return K.unproject(hr);\n                    }), ft = we.reduce(function(hr, qt, Ve, Qe) {\n                      return hr.add(qt.div(Qe.length));\n                    }, new i3.Point(0, 0)), Xt = K.unproject(ft);\n                    Y.call(this, q2, { points: we, point: ft, lngLats: Ue, lngLat: Xt, originalEvent: de }), this._defaultPrevented = false;\n                  }\n                  Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3;\n                  var J = { defaultPrevented: { configurable: true } };\n                  return D3.prototype.preventDefault = function() {\n                    this._defaultPrevented = true;\n                  }, J.defaultPrevented.get = function() {\n                    return this._defaultPrevented;\n                  }, Object.defineProperties(D3.prototype, J), D3;\n                })(i3.Event), Ne = (function(Y) {\n                  function D3(q2, K, de) {\n                    Y.call(this, q2, { originalEvent: de }), this._defaultPrevented = false;\n                  }\n                  Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3;\n                  var J = { defaultPrevented: { configurable: true } };\n                  return D3.prototype.preventDefault = function() {\n                    this._defaultPrevented = true;\n                  }, J.defaultPrevented.get = function() {\n                    return this._defaultPrevented;\n                  }, Object.defineProperties(D3.prototype, J), D3;\n                })(i3.Event), He = function(D3, J) {\n                  this._map = D3, this._clickTolerance = J.clickTolerance;\n                };\n                He.prototype.reset = function() {\n                  delete this._mousedownPos;\n                }, He.prototype.wheel = function(D3) {\n                  return this._firePreventable(new Ne(D3.type, this._map, D3));\n                }, He.prototype.mousedown = function(D3, J) {\n                  return this._mousedownPos = J, this._firePreventable(new se(D3.type, this._map, D3));\n                }, He.prototype.mouseup = function(D3) {\n                  this._map.fire(new se(D3.type, this._map, D3));\n                }, He.prototype.click = function(D3, J) {\n                  this._mousedownPos && this._mousedownPos.dist(J) >= this._clickTolerance || this._map.fire(new se(D3.type, this._map, D3));\n                }, He.prototype.dblclick = function(D3) {\n                  return this._firePreventable(new se(D3.type, this._map, D3));\n                }, He.prototype.mouseover = function(D3) {\n                  this._map.fire(new se(D3.type, this._map, D3));\n                }, He.prototype.mouseout = function(D3) {\n                  this._map.fire(new se(D3.type, this._map, D3));\n                }, He.prototype.touchstart = function(D3) {\n                  return this._firePreventable(new Te(D3.type, this._map, D3));\n                }, He.prototype.touchmove = function(D3) {\n                  this._map.fire(new Te(D3.type, this._map, D3));\n                }, He.prototype.touchend = function(D3) {\n                  this._map.fire(new Te(D3.type, this._map, D3));\n                }, He.prototype.touchcancel = function(D3) {\n                  this._map.fire(new Te(D3.type, this._map, D3));\n                }, He.prototype._firePreventable = function(D3) {\n                  if (this._map.fire(D3), D3.defaultPrevented) return {};\n                }, He.prototype.isEnabled = function() {\n                  return true;\n                }, He.prototype.isActive = function() {\n                  return false;\n                }, He.prototype.enable = function() {\n                }, He.prototype.disable = function() {\n                };\n                var Ye = function(D3) {\n                  this._map = D3;\n                };\n                Ye.prototype.reset = function() {\n                  this._delayContextMenu = false, delete this._contextMenuEvent;\n                }, Ye.prototype.mousemove = function(D3) {\n                  this._map.fire(new se(D3.type, this._map, D3));\n                }, Ye.prototype.mousedown = function() {\n                  this._delayContextMenu = true;\n                }, Ye.prototype.mouseup = function() {\n                  this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new se("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);\n                }, Ye.prototype.contextmenu = function(D3) {\n                  this._delayContextMenu ? this._contextMenuEvent = D3 : this._map.fire(new se(D3.type, this._map, D3)), this._map.listens("contextmenu") && D3.preventDefault();\n                }, Ye.prototype.isEnabled = function() {\n                  return true;\n                }, Ye.prototype.isActive = function() {\n                  return false;\n                }, Ye.prototype.enable = function() {\n                }, Ye.prototype.disable = function() {\n                };\n                var kt = function(D3, J) {\n                  this._map = D3, this._el = D3.getCanvasContainer(), this._container = D3.getContainer(), this._clickTolerance = J.clickTolerance || 1;\n                };\n                kt.prototype.isEnabled = function() {\n                  return !!this._enabled;\n                }, kt.prototype.isActive = function() {\n                  return !!this._active;\n                }, kt.prototype.enable = function() {\n                  this.isEnabled() || (this._enabled = true);\n                }, kt.prototype.disable = function() {\n                  this.isEnabled() && (this._enabled = false);\n                }, kt.prototype.mousedown = function(D3, J) {\n                  this.isEnabled() && D3.shiftKey && D3.button === 0 && (o4.disableDrag(), this._startPos = this._lastPos = J, this._active = true);\n                }, kt.prototype.mousemoveWindow = function(D3, J) {\n                  if (this._active) {\n                    var q2 = J;\n                    if (!(this._lastPos.equals(q2) || !this._box && q2.dist(this._startPos) < this._clickTolerance)) {\n                      var K = this._startPos;\n                      this._lastPos = q2, this._box || (this._box = o4.create("div", "mapboxgl-boxzoom", this._container), this._container.classList.add("mapboxgl-crosshair"), this._fireEvent("boxzoomstart", D3));\n                      var de = Math.min(K.x, q2.x), ne = Math.max(K.x, q2.x), we = Math.min(K.y, q2.y), Ue = Math.max(K.y, q2.y);\n                      o4.setTransform(this._box, "translate(" + de + "px," + we + "px)"), this._box.style.width = ne - de + "px", this._box.style.height = Ue - we + "px";\n                    }\n                  }\n                }, kt.prototype.mouseupWindow = function(D3, J) {\n                  var q2 = this;\n                  if (this._active && D3.button === 0) {\n                    var K = this._startPos, de = J;\n                    if (this.reset(), o4.suppressClick(), K.x === de.x && K.y === de.y) this._fireEvent("boxzoomcancel", D3);\n                    else return this._map.fire(new i3.Event("boxzoomend", { originalEvent: D3 })), { cameraAnimation: function(ne) {\n                      return ne.fitScreenCoordinates(K, de, q2._map.getBearing(), { linear: true });\n                    } };\n                  }\n                }, kt.prototype.keydown = function(D3) {\n                  this._active && D3.keyCode === 27 && (this.reset(), this._fireEvent("boxzoomcancel", D3));\n                }, kt.prototype.reset = function() {\n                  this._active = false, this._container.classList.remove("mapboxgl-crosshair"), this._box && (o4.remove(this._box), this._box = null), o4.enableDrag(), delete this._startPos, delete this._lastPos;\n                }, kt.prototype._fireEvent = function(D3, J) {\n                  return this._map.fire(new i3.Event(D3, { originalEvent: J }));\n                };\n                function nt(Y, D3) {\n                  for (var J = {}, q2 = 0; q2 < Y.length; q2++) J[Y[q2].identifier] = D3[q2];\n                  return J;\n                }\n                function jt(Y) {\n                  for (var D3 = new i3.Point(0, 0), J = 0, q2 = Y; J < q2.length; J += 1) {\n                    var K = q2[J];\n                    D3._add(K);\n                  }\n                  return D3.div(Y.length);\n                }\n                var gr = 500, yr = 500, Hr = 30, qr = function(D3) {\n                  this.reset(), this.numTouches = D3.numTouches;\n                };\n                qr.prototype.reset = function() {\n                  delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;\n                }, qr.prototype.touchstart = function(D3, J, q2) {\n                  (this.centroid || q2.length > this.numTouches) && (this.aborted = true), !this.aborted && (this.startTime === void 0 && (this.startTime = D3.timeStamp), q2.length === this.numTouches && (this.centroid = jt(J), this.touches = nt(q2, J)));\n                }, qr.prototype.touchmove = function(D3, J, q2) {\n                  if (!(this.aborted || !this.centroid)) {\n                    var K = nt(q2, J);\n                    for (var de in this.touches) {\n                      var ne = this.touches[de], we = K[de];\n                      (!we || we.dist(ne) > Hr) && (this.aborted = true);\n                    }\n                  }\n                }, qr.prototype.touchend = function(D3, J, q2) {\n                  if ((!this.centroid || D3.timeStamp - this.startTime > yr) && (this.aborted = true), q2.length === 0) {\n                    var K = !this.aborted && this.centroid;\n                    if (this.reset(), K) return K;\n                  }\n                };\n                var _i = function(D3) {\n                  this.singleTap = new qr(D3), this.numTaps = D3.numTaps, this.reset();\n                };\n                _i.prototype.reset = function() {\n                  this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();\n                }, _i.prototype.touchstart = function(D3, J, q2) {\n                  this.singleTap.touchstart(D3, J, q2);\n                }, _i.prototype.touchmove = function(D3, J, q2) {\n                  this.singleTap.touchmove(D3, J, q2);\n                }, _i.prototype.touchend = function(D3, J, q2) {\n                  var K = this.singleTap.touchend(D3, J, q2);\n                  if (K) {\n                    var de = D3.timeStamp - this.lastTime < gr, ne = !this.lastTap || this.lastTap.dist(K) < Hr;\n                    if ((!de || !ne) && this.reset(), this.count++, this.lastTime = D3.timeStamp, this.lastTap = K, this.count === this.numTaps) return this.reset(), K;\n                  }\n                };\n                var bi = function() {\n                  this._zoomIn = new _i({ numTouches: 1, numTaps: 2 }), this._zoomOut = new _i({ numTouches: 2, numTaps: 1 }), this.reset();\n                };\n                bi.prototype.reset = function() {\n                  this._active = false, this._zoomIn.reset(), this._zoomOut.reset();\n                }, bi.prototype.touchstart = function(D3, J, q2) {\n                  this._zoomIn.touchstart(D3, J, q2), this._zoomOut.touchstart(D3, J, q2);\n                }, bi.prototype.touchmove = function(D3, J, q2) {\n                  this._zoomIn.touchmove(D3, J, q2), this._zoomOut.touchmove(D3, J, q2);\n                }, bi.prototype.touchend = function(D3, J, q2) {\n                  var K = this, de = this._zoomIn.touchend(D3, J, q2), ne = this._zoomOut.touchend(D3, J, q2);\n                  if (de) return this._active = true, D3.preventDefault(), setTimeout(function() {\n                    return K.reset();\n                  }, 0), { cameraAnimation: function(we) {\n                    return we.easeTo({ duration: 300, zoom: we.getZoom() + 1, around: we.unproject(de) }, { originalEvent: D3 });\n                  } };\n                  if (ne) return this._active = true, D3.preventDefault(), setTimeout(function() {\n                    return K.reset();\n                  }, 0), { cameraAnimation: function(we) {\n                    return we.easeTo({ duration: 300, zoom: we.getZoom() - 1, around: we.unproject(ne) }, { originalEvent: D3 });\n                  } };\n                }, bi.prototype.touchcancel = function() {\n                  this.reset();\n                }, bi.prototype.enable = function() {\n                  this._enabled = true;\n                }, bi.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, bi.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, bi.prototype.isActive = function() {\n                  return this._active;\n                };\n                var Zr = 0, ai = 2, gi = {};\n                gi[Zr] = 1, gi[ai] = 2;\n                function Ii(Y, D3) {\n                  var J = gi[D3];\n                  return Y.buttons === void 0 || (Y.buttons & J) !== J;\n                }\n                var Si = function(D3) {\n                  this.reset(), this._clickTolerance = D3.clickTolerance || 1;\n                };\n                Si.prototype.reset = function() {\n                  this._active = false, this._moved = false, delete this._lastPoint, delete this._eventButton;\n                }, Si.prototype._correctButton = function(D3, J) {\n                  return false;\n                }, Si.prototype._move = function(D3, J) {\n                  return {};\n                }, Si.prototype.mousedown = function(D3, J) {\n                  if (!this._lastPoint) {\n                    var q2 = o4.mouseButton(D3);\n                    this._correctButton(D3, q2) && (this._lastPoint = J, this._eventButton = q2);\n                  }\n                }, Si.prototype.mousemoveWindow = function(D3, J) {\n                  var q2 = this._lastPoint;\n                  if (q2) {\n                    if (D3.preventDefault(), Ii(D3, this._eventButton)) {\n                      this.reset();\n                      return;\n                    }\n                    if (!(!this._moved && J.dist(q2) < this._clickTolerance)) return this._moved = true, this._lastPoint = J, this._move(q2, J);\n                  }\n                }, Si.prototype.mouseupWindow = function(D3) {\n                  if (this._lastPoint) {\n                    var J = o4.mouseButton(D3);\n                    J === this._eventButton && (this._moved && o4.suppressClick(), this.reset());\n                  }\n                }, Si.prototype.enable = function() {\n                  this._enabled = true;\n                }, Si.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, Si.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, Si.prototype.isActive = function() {\n                  return this._active;\n                };\n                var ei = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.mousedown = function(q2, K) {\n                    Y.prototype.mousedown.call(this, q2, K), this._lastPoint && (this._active = true);\n                  }, D3.prototype._correctButton = function(q2, K) {\n                    return K === Zr && !q2.ctrlKey;\n                  }, D3.prototype._move = function(q2, K) {\n                    return { around: K, panDelta: K.sub(q2) };\n                  }, D3;\n                })(Si), Ln = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype._correctButton = function(q2, K) {\n                    return K === Zr && q2.ctrlKey || K === ai;\n                  }, D3.prototype._move = function(q2, K) {\n                    var de = 0.8, ne = (K.x - q2.x) * de;\n                    if (ne) return this._active = true, { bearingDelta: ne };\n                  }, D3.prototype.contextmenu = function(q2) {\n                    q2.preventDefault();\n                  }, D3;\n                })(Si), En = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype._correctButton = function(q2, K) {\n                    return K === Zr && q2.ctrlKey || K === ai;\n                  }, D3.prototype._move = function(q2, K) {\n                    var de = -0.5, ne = (K.y - q2.y) * de;\n                    if (ne) return this._active = true, { pitchDelta: ne };\n                  }, D3.prototype.contextmenu = function(q2) {\n                    q2.preventDefault();\n                  }, D3;\n                })(Si), Un = function(D3) {\n                  this._minTouches = 1, this._clickTolerance = D3.clickTolerance || 1, this.reset();\n                };\n                Un.prototype.reset = function() {\n                  this._active = false, this._touches = {}, this._sum = new i3.Point(0, 0);\n                }, Un.prototype.touchstart = function(D3, J, q2) {\n                  return this._calculateTransform(D3, J, q2);\n                }, Un.prototype.touchmove = function(D3, J, q2) {\n                  if (!(!this._active || q2.length < this._minTouches)) return D3.preventDefault(), this._calculateTransform(D3, J, q2);\n                }, Un.prototype.touchend = function(D3, J, q2) {\n                  this._calculateTransform(D3, J, q2), this._active && q2.length < this._minTouches && this.reset();\n                }, Un.prototype.touchcancel = function() {\n                  this.reset();\n                }, Un.prototype._calculateTransform = function(D3, J, q2) {\n                  q2.length > 0 && (this._active = true);\n                  var K = nt(q2, J), de = new i3.Point(0, 0), ne = new i3.Point(0, 0), we = 0;\n                  for (var Ue in K) {\n                    var ft = K[Ue], Xt = this._touches[Ue];\n                    Xt && (de._add(ft), ne._add(ft.sub(Xt)), we++, K[Ue] = ft);\n                  }\n                  if (this._touches = K, !(we < this._minTouches || !ne.mag())) {\n                    var hr = ne.div(we);\n                    if (this._sum._add(hr), !(this._sum.mag() < this._clickTolerance)) {\n                      var qt = de.div(we);\n                      return { around: qt, panDelta: hr };\n                    }\n                  }\n                }, Un.prototype.enable = function() {\n                  this._enabled = true;\n                }, Un.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, Un.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, Un.prototype.isActive = function() {\n                  return this._active;\n                };\n                var ia = function() {\n                  this.reset();\n                };\n                ia.prototype.reset = function() {\n                  this._active = false, delete this._firstTwoTouches;\n                }, ia.prototype._start = function(D3) {\n                }, ia.prototype._move = function(D3, J, q2) {\n                  return {};\n                }, ia.prototype.touchstart = function(D3, J, q2) {\n                  this._firstTwoTouches || q2.length < 2 || (this._firstTwoTouches = [q2[0].identifier, q2[1].identifier], this._start([J[0], J[1]]));\n                }, ia.prototype.touchmove = function(D3, J, q2) {\n                  if (this._firstTwoTouches) {\n                    D3.preventDefault();\n                    var K = this._firstTwoTouches, de = K[0], ne = K[1], we = Ea(q2, J, de), Ue = Ea(q2, J, ne);\n                    if (!(!we || !Ue)) {\n                      var ft = this._aroundCenter ? null : we.add(Ue).div(2);\n                      return this._move([we, Ue], ft, D3);\n                    }\n                  }\n                }, ia.prototype.touchend = function(D3, J, q2) {\n                  if (this._firstTwoTouches) {\n                    var K = this._firstTwoTouches, de = K[0], ne = K[1], we = Ea(q2, J, de), Ue = Ea(q2, J, ne);\n                    we && Ue || (this._active && o4.suppressClick(), this.reset());\n                  }\n                }, ia.prototype.touchcancel = function() {\n                  this.reset();\n                }, ia.prototype.enable = function(D3) {\n                  this._enabled = true, this._aroundCenter = !!D3 && D3.around === "center";\n                }, ia.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, ia.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, ia.prototype.isActive = function() {\n                  return this._active;\n                };\n                function Ea(Y, D3, J) {\n                  for (var q2 = 0; q2 < Y.length; q2++) if (Y[q2].identifier === J) return D3[q2];\n                }\n                var Ia = 0.1;\n                function yo(Y, D3) {\n                  return Math.log(Y / D3) / Math.LN2;\n                }\n                var Da = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.reset = function() {\n                    Y.prototype.reset.call(this), delete this._distance, delete this._startDistance;\n                  }, D3.prototype._start = function(q2) {\n                    this._startDistance = this._distance = q2[0].dist(q2[1]);\n                  }, D3.prototype._move = function(q2, K) {\n                    var de = this._distance;\n                    if (this._distance = q2[0].dist(q2[1]), !(!this._active && Math.abs(yo(this._distance, this._startDistance)) < Ia)) return this._active = true, { zoomDelta: yo(this._distance, de), pinchAround: K };\n                  }, D3;\n                })(ia), go = 25;\n                function Is(Y, D3) {\n                  return Y.angleWith(D3) * 180 / Math.PI;\n                }\n                var Ms = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.reset = function() {\n                    Y.prototype.reset.call(this), delete this._minDiameter, delete this._startVector, delete this._vector;\n                  }, D3.prototype._start = function(q2) {\n                    this._startVector = this._vector = q2[0].sub(q2[1]), this._minDiameter = q2[0].dist(q2[1]);\n                  }, D3.prototype._move = function(q2, K) {\n                    var de = this._vector;\n                    if (this._vector = q2[0].sub(q2[1]), !(!this._active && this._isBelowThreshold(this._vector))) return this._active = true, { bearingDelta: Is(this._vector, de), pinchAround: K };\n                  }, D3.prototype._isBelowThreshold = function(q2) {\n                    this._minDiameter = Math.min(this._minDiameter, q2.mag());\n                    var K = Math.PI * this._minDiameter, de = go / K * 360, ne = Is(q2, this._startVector);\n                    return Math.abs(ne) < de;\n                  }, D3;\n                })(ia);\n                function Xs(Y) {\n                  return Math.abs(Y.y) > Math.abs(Y.x);\n                }\n                var Gn = 100, ja = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.reset = function() {\n                    Y.prototype.reset.call(this), this._valid = void 0, delete this._firstMove, delete this._lastPoints;\n                  }, D3.prototype._start = function(q2) {\n                    this._lastPoints = q2, Xs(q2[0].sub(q2[1])) && (this._valid = false);\n                  }, D3.prototype._move = function(q2, K, de) {\n                    var ne = q2[0].sub(this._lastPoints[0]), we = q2[1].sub(this._lastPoints[1]);\n                    if (this._valid = this.gestureBeginsVertically(ne, we, de.timeStamp), !!this._valid) {\n                      this._lastPoints = q2, this._active = true;\n                      var Ue = (ne.y + we.y) / 2, ft = -0.5;\n                      return { pitchDelta: Ue * ft };\n                    }\n                  }, D3.prototype.gestureBeginsVertically = function(q2, K, de) {\n                    if (this._valid !== void 0) return this._valid;\n                    var ne = 2, we = q2.mag() >= ne, Ue = K.mag() >= ne;\n                    if (!(!we && !Ue)) {\n                      if (!we || !Ue) return this._firstMove === void 0 && (this._firstMove = de), de - this._firstMove < Gn ? void 0 : false;\n                      var ft = q2.y > 0 == K.y > 0;\n                      return Xs(q2) && Xs(K) && ft;\n                    }\n                  }, D3;\n                })(ia), Fo = { panStep: 100, bearingStep: 15, pitchStep: 10 }, Uo = function() {\n                  var D3 = Fo;\n                  this._panStep = D3.panStep, this._bearingStep = D3.bearingStep, this._pitchStep = D3.pitchStep, this._rotationDisabled = false;\n                };\n                Uo.prototype.reset = function() {\n                  this._active = false;\n                }, Uo.prototype.keydown = function(D3) {\n                  var J = this;\n                  if (!(D3.altKey || D3.ctrlKey || D3.metaKey)) {\n                    var q2 = 0, K = 0, de = 0, ne = 0, we = 0;\n                    switch (D3.keyCode) {\n                      case 61:\n                      case 107:\n                      case 171:\n                      case 187:\n                        q2 = 1;\n                        break;\n                      case 189:\n                      case 109:\n                      case 173:\n                        q2 = -1;\n                        break;\n                      case 37:\n                        D3.shiftKey ? K = -1 : (D3.preventDefault(), ne = -1);\n                        break;\n                      case 39:\n                        D3.shiftKey ? K = 1 : (D3.preventDefault(), ne = 1);\n                        break;\n                      case 38:\n                        D3.shiftKey ? de = 1 : (D3.preventDefault(), we = -1);\n                        break;\n                      case 40:\n                        D3.shiftKey ? de = -1 : (D3.preventDefault(), we = 1);\n                        break;\n                      default:\n                        return;\n                    }\n                    return this._rotationDisabled && (K = 0, de = 0), { cameraAnimation: function(Ue) {\n                      var ft = Ue.getZoom();\n                      Ue.easeTo({ duration: 300, easeId: "keyboardHandler", easing: $s, zoom: q2 ? Math.round(ft) + q2 * (D3.shiftKey ? 2 : 1) : ft, bearing: Ue.getBearing() + K * J._bearingStep, pitch: Ue.getPitch() + de * J._pitchStep, offset: [-ne * J._panStep, -we * J._panStep], center: Ue.getCenter() }, { originalEvent: D3 });\n                    } };\n                  }\n                }, Uo.prototype.enable = function() {\n                  this._enabled = true;\n                }, Uo.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, Uo.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, Uo.prototype.isActive = function() {\n                  return this._active;\n                }, Uo.prototype.disableRotation = function() {\n                  this._rotationDisabled = true;\n                }, Uo.prototype.enableRotation = function() {\n                  this._rotationDisabled = false;\n                };\n                function $s(Y) {\n                  return Y * (2 - Y);\n                }\n                var Sl = 4.000244140625, bu = 1 / 100, dl = 1 / 450, Sc = 2, Me = function(D3, J) {\n                  this._map = D3, this._el = D3.getCanvasContainer(), this._handler = J, this._delta = 0, this._defaultZoomRate = bu, this._wheelZoomRate = dl, i3.bindAll(["_onTimeout"], this);\n                };\n                Me.prototype.setZoomRate = function(D3) {\n                  this._defaultZoomRate = D3;\n                }, Me.prototype.setWheelZoomRate = function(D3) {\n                  this._wheelZoomRate = D3;\n                }, Me.prototype.isEnabled = function() {\n                  return !!this._enabled;\n                }, Me.prototype.isActive = function() {\n                  return !!this._active || this._finishTimeout !== void 0;\n                }, Me.prototype.isZooming = function() {\n                  return !!this._zooming;\n                }, Me.prototype.enable = function(D3) {\n                  this.isEnabled() || (this._enabled = true, this._aroundCenter = D3 && D3.around === "center");\n                }, Me.prototype.disable = function() {\n                  this.isEnabled() && (this._enabled = false);\n                }, Me.prototype.wheel = function(D3) {\n                  if (this.isEnabled()) {\n                    var J = D3.deltaMode === i3.window.WheelEvent.DOM_DELTA_LINE ? D3.deltaY * 40 : D3.deltaY, q2 = i3.browser.now(), K = q2 - (this._lastWheelEventTime || 0);\n                    this._lastWheelEventTime = q2, J !== 0 && J % Sl === 0 ? this._type = "wheel" : J !== 0 && Math.abs(J) < 4 ? this._type = "trackpad" : K > 400 ? (this._type = null, this._lastValue = J, this._timeout = setTimeout(this._onTimeout, 40, D3)) : this._type || (this._type = Math.abs(K * J) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, J += this._lastValue)), D3.shiftKey && J && (J = J / 4), this._type && (this._lastWheelEvent = D3, this._delta -= J, this._active || this._start(D3)), D3.preventDefault();\n                  }\n                }, Me.prototype._onTimeout = function(D3) {\n                  this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(D3);\n                }, Me.prototype._start = function(D3) {\n                  if (this._delta) {\n                    this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);\n                    var J = o4.mousePos(this._el, D3);\n                    this._around = i3.LngLat.convert(this._aroundCenter ? this._map.getCenter() : this._map.unproject(J)), this._aroundPoint = this._map.transform.locationPoint(this._around), this._frameId || (this._frameId = true, this._handler._triggerRenderFrame());\n                  }\n                }, Me.prototype.renderFrame = function() {\n                  var D3 = this;\n                  if (this._frameId && (this._frameId = null, !!this.isActive())) {\n                    var J = this._map.transform;\n                    if (this._delta !== 0) {\n                      var q2 = this._type === "wheel" && Math.abs(this._delta) > Sl ? this._wheelZoomRate : this._defaultZoomRate, K = Sc / (1 + Math.exp(-Math.abs(this._delta * q2)));\n                      this._delta < 0 && K !== 0 && (K = 1 / K);\n                      var de = typeof this._targetZoom == "number" ? J.zoomScale(this._targetZoom) : J.scale;\n                      this._targetZoom = Math.min(J.maxZoom, Math.max(J.minZoom, J.scaleZoom(de * K))), this._type === "wheel" && (this._startZoom = J.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;\n                    }\n                    var ne = typeof this._targetZoom == "number" ? this._targetZoom : J.zoom, we = this._startZoom, Ue = this._easing, ft = false, Xt;\n                    if (this._type === "wheel" && we && Ue) {\n                      var hr = Math.min((i3.browser.now() - this._lastWheelEventTime) / 200, 1), qt = Ue(hr);\n                      Xt = i3.number(we, ne, qt), hr < 1 ? this._frameId || (this._frameId = true) : ft = true;\n                    } else Xt = ne, ft = true;\n                    return this._active = true, ft && (this._active = false, this._finishTimeout = setTimeout(function() {\n                      D3._zooming = false, D3._handler._triggerRenderFrame(), delete D3._targetZoom, delete D3._finishTimeout;\n                    }, 200)), { noInertia: true, needsRenderFrame: !ft, zoomDelta: Xt - J.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };\n                  }\n                }, Me.prototype._smoothOutEasing = function(D3) {\n                  var J = i3.ease;\n                  if (this._prevEase) {\n                    var q2 = this._prevEase, K = (i3.browser.now() - q2.start) / q2.duration, de = q2.easing(K + 0.01) - q2.easing(K), ne = 0.27 / Math.sqrt(de * de + 1e-4) * 0.01, we = Math.sqrt(0.27 * 0.27 - ne * ne);\n                    J = i3.bezier(ne, we, 0.25, 1);\n                  }\n                  return this._prevEase = { start: i3.browser.now(), duration: D3, easing: J }, J;\n                }, Me.prototype.reset = function() {\n                  this._active = false;\n                };\n                var bt = function(D3, J) {\n                  this._clickZoom = D3, this._tapZoom = J;\n                };\n                bt.prototype.enable = function() {\n                  this._clickZoom.enable(), this._tapZoom.enable();\n                }, bt.prototype.disable = function() {\n                  this._clickZoom.disable(), this._tapZoom.disable();\n                }, bt.prototype.isEnabled = function() {\n                  return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();\n                }, bt.prototype.isActive = function() {\n                  return this._clickZoom.isActive() || this._tapZoom.isActive();\n                };\n                var zt = function() {\n                  this.reset();\n                };\n                zt.prototype.reset = function() {\n                  this._active = false;\n                }, zt.prototype.dblclick = function(D3, J) {\n                  return D3.preventDefault(), { cameraAnimation: function(q2) {\n                    q2.easeTo({ duration: 300, zoom: q2.getZoom() + (D3.shiftKey ? -1 : 1), around: q2.unproject(J) }, { originalEvent: D3 });\n                  } };\n                }, zt.prototype.enable = function() {\n                  this._enabled = true;\n                }, zt.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, zt.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, zt.prototype.isActive = function() {\n                  return this._active;\n                };\n                var Rr = function() {\n                  this._tap = new _i({ numTouches: 1, numTaps: 1 }), this.reset();\n                };\n                Rr.prototype.reset = function() {\n                  this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, this._tap.reset();\n                }, Rr.prototype.touchstart = function(D3, J, q2) {\n                  this._swipePoint || (this._tapTime && D3.timeStamp - this._tapTime > gr && this.reset(), this._tapTime ? q2.length > 0 && (this._swipePoint = J[0], this._swipeTouch = q2[0].identifier) : this._tap.touchstart(D3, J, q2));\n                }, Rr.prototype.touchmove = function(D3, J, q2) {\n                  if (!this._tapTime) this._tap.touchmove(D3, J, q2);\n                  else if (this._swipePoint) {\n                    if (q2[0].identifier !== this._swipeTouch) return;\n                    var K = J[0], de = K.y - this._swipePoint.y;\n                    return this._swipePoint = K, D3.preventDefault(), this._active = true, { zoomDelta: de / 128 };\n                  }\n                }, Rr.prototype.touchend = function(D3, J, q2) {\n                  if (this._tapTime) this._swipePoint && q2.length === 0 && this.reset();\n                  else {\n                    var K = this._tap.touchend(D3, J, q2);\n                    K && (this._tapTime = D3.timeStamp);\n                  }\n                }, Rr.prototype.touchcancel = function() {\n                  this.reset();\n                }, Rr.prototype.enable = function() {\n                  this._enabled = true;\n                }, Rr.prototype.disable = function() {\n                  this._enabled = false, this.reset();\n                }, Rr.prototype.isEnabled = function() {\n                  return this._enabled;\n                }, Rr.prototype.isActive = function() {\n                  return this._active;\n                };\n                var jr = function(D3, J, q2) {\n                  this._el = D3, this._mousePan = J, this._touchPan = q2;\n                };\n                jr.prototype.enable = function(D3) {\n                  this._inertiaOptions = D3 || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("mapboxgl-touch-drag-pan");\n                }, jr.prototype.disable = function() {\n                  this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("mapboxgl-touch-drag-pan");\n                }, jr.prototype.isEnabled = function() {\n                  return this._mousePan.isEnabled() && this._touchPan.isEnabled();\n                }, jr.prototype.isActive = function() {\n                  return this._mousePan.isActive() || this._touchPan.isActive();\n                };\n                var Nr = function(D3, J, q2) {\n                  this._pitchWithRotate = D3.pitchWithRotate, this._mouseRotate = J, this._mousePitch = q2;\n                };\n                Nr.prototype.enable = function() {\n                  this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable();\n                }, Nr.prototype.disable = function() {\n                  this._mouseRotate.disable(), this._mousePitch.disable();\n                }, Nr.prototype.isEnabled = function() {\n                  return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());\n                }, Nr.prototype.isActive = function() {\n                  return this._mouseRotate.isActive() || this._mousePitch.isActive();\n                };\n                var Gr = function(D3, J, q2, K) {\n                  this._el = D3, this._touchZoom = J, this._touchRotate = q2, this._tapDragZoom = K, this._rotationDisabled = false, this._enabled = true;\n                };\n                Gr.prototype.enable = function(D3) {\n                  this._touchZoom.enable(D3), this._rotationDisabled || this._touchRotate.enable(D3), this._tapDragZoom.enable(), this._el.classList.add("mapboxgl-touch-zoom-rotate");\n                }, Gr.prototype.disable = function() {\n                  this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("mapboxgl-touch-zoom-rotate");\n                }, Gr.prototype.isEnabled = function() {\n                  return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();\n                }, Gr.prototype.isActive = function() {\n                  return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();\n                }, Gr.prototype.disableRotation = function() {\n                  this._rotationDisabled = true, this._touchRotate.disable();\n                }, Gr.prototype.enableRotation = function() {\n                  this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();\n                };\n                var mi = function(Y) {\n                  return Y.zoom || Y.drag || Y.pitch || Y.rotate;\n                }, Ui = (function(Y) {\n                  function D3() {\n                    Y.apply(this, arguments);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3;\n                })(i3.Event);\n                function qi(Y) {\n                  return Y.panDelta && Y.panDelta.mag() || Y.zoomDelta || Y.bearingDelta || Y.pitchDelta;\n                }\n                var Ei = function(D3, J) {\n                  this._map = D3, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Tl(D3), this._bearingSnap = J.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(J), i3.bindAll(["handleEvent", "handleWindowEvent"], this);\n                  var q2 = this._el;\n                  this._listeners = [[q2, "touchstart", { passive: true }], [q2, "touchmove", { passive: false }], [q2, "touchend", void 0], [q2, "touchcancel", void 0], [q2, "mousedown", void 0], [q2, "mousemove", void 0], [q2, "mouseup", void 0], [i3.window.document, "mousemove", { capture: true }], [i3.window.document, "mouseup", void 0], [q2, "mouseover", void 0], [q2, "mouseout", void 0], [q2, "dblclick", void 0], [q2, "click", void 0], [q2, "keydown", { capture: false }], [q2, "keyup", void 0], [q2, "wheel", { passive: false }], [q2, "contextmenu", void 0], [i3.window, "blur", void 0]];\n                  for (var K = 0, de = this._listeners; K < de.length; K += 1) {\n                    var ne = de[K], we = ne[0], Ue = ne[1], ft = ne[2];\n                    o4.addEventListener(we, Ue, we === i3.window.document ? this.handleWindowEvent : this.handleEvent, ft);\n                  }\n                };\n                Ei.prototype.destroy = function() {\n                  for (var D3 = 0, J = this._listeners; D3 < J.length; D3 += 1) {\n                    var q2 = J[D3], K = q2[0], de = q2[1], ne = q2[2];\n                    o4.removeEventListener(K, de, K === i3.window.document ? this.handleWindowEvent : this.handleEvent, ne);\n                  }\n                }, Ei.prototype._addDefaultHandlers = function(D3) {\n                  var J = this._map, q2 = J.getCanvasContainer();\n                  this._add("mapEvent", new He(J, D3));\n                  var K = J.boxZoom = new kt(J, D3);\n                  this._add("boxZoom", K);\n                  var de = new bi(), ne = new zt();\n                  J.doubleClickZoom = new bt(ne, de), this._add("tapZoom", de), this._add("clickZoom", ne);\n                  var we = new Rr();\n                  this._add("tapDragZoom", we);\n                  var Ue = J.touchPitch = new ja();\n                  this._add("touchPitch", Ue);\n                  var ft = new Ln(D3), Xt = new En(D3);\n                  J.dragRotate = new Nr(D3, ft, Xt), this._add("mouseRotate", ft, ["mousePitch"]), this._add("mousePitch", Xt, ["mouseRotate"]);\n                  var hr = new ei(D3), qt = new Un(D3);\n                  J.dragPan = new jr(q2, hr, qt), this._add("mousePan", hr), this._add("touchPan", qt, ["touchZoom", "touchRotate"]);\n                  var Ve = new Ms(), Qe = new Da();\n                  J.touchZoomRotate = new Gr(q2, Qe, Ve, we), this._add("touchRotate", Ve, ["touchPan", "touchZoom"]), this._add("touchZoom", Qe, ["touchPan", "touchRotate"]);\n                  var at = J.scrollZoom = new Me(J, this);\n                  this._add("scrollZoom", at, ["mousePan"]);\n                  var Ct = J.keyboard = new Uo();\n                  this._add("keyboard", Ct), this._add("blockableMapEvent", new Ye(J));\n                  for (var Ot = 0, Rt = ["boxZoom", "doubleClickZoom", "tapDragZoom", "touchPitch", "dragRotate", "dragPan", "touchZoomRotate", "scrollZoom", "keyboard"]; Ot < Rt.length; Ot += 1) {\n                    var Bt = Rt[Ot];\n                    D3.interactive && D3[Bt] && J[Bt].enable(D3[Bt]);\n                  }\n                }, Ei.prototype._add = function(D3, J, q2) {\n                  this._handlers.push({ handlerName: D3, handler: J, allowed: q2 }), this._handlersById[D3] = J;\n                }, Ei.prototype.stop = function(D3) {\n                  if (!this._updatingCamera) {\n                    for (var J = 0, q2 = this._handlers; J < q2.length; J += 1) {\n                      var K = q2[J], de = K.handler;\n                      de.reset();\n                    }\n                    this._inertia.clear(), this._fireEvents({}, {}, D3), this._changes = [];\n                  }\n                }, Ei.prototype.isActive = function() {\n                  for (var D3 = 0, J = this._handlers; D3 < J.length; D3 += 1) {\n                    var q2 = J[D3], K = q2.handler;\n                    if (K.isActive()) return true;\n                  }\n                  return false;\n                }, Ei.prototype.isZooming = function() {\n                  return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();\n                }, Ei.prototype.isRotating = function() {\n                  return !!this._eventsInProgress.rotate;\n                }, Ei.prototype.isMoving = function() {\n                  return !!mi(this._eventsInProgress) || this.isZooming();\n                }, Ei.prototype._blockedByActive = function(D3, J, q2) {\n                  for (var K in D3) if (K !== q2 && (!J || J.indexOf(K) < 0)) return true;\n                  return false;\n                }, Ei.prototype.handleWindowEvent = function(D3) {\n                  this.handleEvent(D3, D3.type + "Window");\n                }, Ei.prototype._getMapTouches = function(D3) {\n                  for (var J = [], q2 = 0, K = D3; q2 < K.length; q2 += 1) {\n                    var de = K[q2], ne = de.target;\n                    this._el.contains(ne) && J.push(de);\n                  }\n                  return J;\n                }, Ei.prototype.handleEvent = function(D3, J) {\n                  if (D3.type === "blur") {\n                    this.stop(true);\n                    return;\n                  }\n                  this._updatingCamera = true;\n                  for (var q2 = D3.type === "renderFrame" ? void 0 : D3, K = { needsRenderFrame: false }, de = {}, ne = {}, we = D3.touches ? this._getMapTouches(D3.touches) : void 0, Ue = we ? o4.touchPos(this._el, we) : o4.mousePos(this._el, D3), ft = 0, Xt = this._handlers; ft < Xt.length; ft += 1) {\n                    var hr = Xt[ft], qt = hr.handlerName, Ve = hr.handler, Qe = hr.allowed;\n                    if (Ve.isEnabled()) {\n                      var at = void 0;\n                      this._blockedByActive(ne, Qe, qt) ? Ve.reset() : Ve[J || D3.type] && (at = Ve[J || D3.type](D3, Ue, we), this.mergeHandlerResult(K, de, at, qt, q2), at && at.needsRenderFrame && this._triggerRenderFrame()), (at || Ve.isActive()) && (ne[qt] = Ve);\n                    }\n                  }\n                  var Ct = {};\n                  for (var Ot in this._previousActiveHandlers) ne[Ot] || (Ct[Ot] = q2);\n                  this._previousActiveHandlers = ne, (Object.keys(Ct).length || qi(K)) && (this._changes.push([K, de, Ct]), this._triggerRenderFrame()), (Object.keys(ne).length || qi(K)) && this._map._stop(true), this._updatingCamera = false;\n                  var Rt = K.cameraAnimation;\n                  Rt && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], Rt(this._map));\n                }, Ei.prototype.mergeHandlerResult = function(D3, J, q2, K, de) {\n                  if (q2) {\n                    i3.extend(D3, q2);\n                    var ne = { handlerName: K, originalEvent: q2.originalEvent || de };\n                    q2.zoomDelta !== void 0 && (J.zoom = ne), q2.panDelta !== void 0 && (J.drag = ne), q2.pitchDelta !== void 0 && (J.pitch = ne), q2.bearingDelta !== void 0 && (J.rotate = ne);\n                  }\n                }, Ei.prototype._applyChanges = function() {\n                  for (var D3 = {}, J = {}, q2 = {}, K = 0, de = this._changes; K < de.length; K += 1) {\n                    var ne = de[K], we = ne[0], Ue = ne[1], ft = ne[2];\n                    we.panDelta && (D3.panDelta = (D3.panDelta || new i3.Point(0, 0))._add(we.panDelta)), we.zoomDelta && (D3.zoomDelta = (D3.zoomDelta || 0) + we.zoomDelta), we.bearingDelta && (D3.bearingDelta = (D3.bearingDelta || 0) + we.bearingDelta), we.pitchDelta && (D3.pitchDelta = (D3.pitchDelta || 0) + we.pitchDelta), we.around !== void 0 && (D3.around = we.around), we.pinchAround !== void 0 && (D3.pinchAround = we.pinchAround), we.noInertia && (D3.noInertia = we.noInertia), i3.extend(J, Ue), i3.extend(q2, ft);\n                  }\n                  this._updateMapTransform(D3, J, q2), this._changes = [];\n                }, Ei.prototype._updateMapTransform = function(D3, J, q2) {\n                  var K = this._map, de = K.transform;\n                  if (!qi(D3)) return this._fireEvents(J, q2, true);\n                  var ne = D3.panDelta, we = D3.zoomDelta, Ue = D3.bearingDelta, ft = D3.pitchDelta, Xt = D3.around, hr = D3.pinchAround;\n                  hr !== void 0 && (Xt = hr), K._stop(true), Xt = Xt || K.transform.centerPoint;\n                  var qt = de.pointLocation(ne ? Xt.sub(ne) : Xt);\n                  Ue && (de.bearing += Ue), ft && (de.pitch += ft), we && (de.zoom += we), de.setLocationAtPoint(qt, Xt), this._map._update(), D3.noInertia || this._inertia.record(D3), this._fireEvents(J, q2, true);\n                }, Ei.prototype._fireEvents = function(D3, J, q2) {\n                  var K = this, de = mi(this._eventsInProgress), ne = mi(D3), we = {};\n                  for (var Ue in D3) {\n                    var ft = D3[Ue], Xt = ft.originalEvent;\n                    this._eventsInProgress[Ue] || (we[Ue + "start"] = Xt), this._eventsInProgress[Ue] = D3[Ue];\n                  }\n                  !de && ne && this._fireEvent("movestart", ne.originalEvent);\n                  for (var hr in we) this._fireEvent(hr, we[hr]);\n                  ne && this._fireEvent("move", ne.originalEvent);\n                  for (var qt in D3) {\n                    var Ve = D3[qt], Qe = Ve.originalEvent;\n                    this._fireEvent(qt, Qe);\n                  }\n                  var at = {}, Ct;\n                  for (var Ot in this._eventsInProgress) {\n                    var Rt = this._eventsInProgress[Ot], Bt = Rt.handlerName, Dt = Rt.originalEvent;\n                    this._handlersById[Bt].isActive() || (delete this._eventsInProgress[Ot], Ct = J[Bt] || Dt, at[Ot + "end"] = Ct);\n                  }\n                  for (var yt in at) this._fireEvent(yt, at[yt]);\n                  var Pt = mi(this._eventsInProgress);\n                  if (q2 && (de || ne) && !Pt) {\n                    this._updatingCamera = true;\n                    var ht = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), ur = function(br) {\n                      return br !== 0 && -K._bearingSnap < br && br < K._bearingSnap;\n                    };\n                    ht ? (ur(ht.bearing || this._map.getBearing()) && (ht.bearing = 0), this._map.easeTo(ht, { originalEvent: Ct })) : (this._map.fire(new i3.Event("moveend", { originalEvent: Ct })), ur(this._map.getBearing()) && this._map.resetNorth()), this._updatingCamera = false;\n                  }\n                }, Ei.prototype._fireEvent = function(D3, J) {\n                  this._map.fire(new i3.Event(D3, J ? { originalEvent: J } : {}));\n                }, Ei.prototype._requestFrame = function() {\n                  var D3 = this;\n                  return this._map.triggerRepaint(), this._map._renderTaskQueue.add(function(J) {\n                    delete D3._frameId, D3.handleEvent(new Ui("renderFrame", { timeStamp: J })), D3._applyChanges();\n                  });\n                }, Ei.prototype._triggerRenderFrame = function() {\n                  this._frameId === void 0 && (this._frameId = this._requestFrame());\n                };\n                var Hn = (function(Y) {\n                  function D3(J, q2) {\n                    Y.call(this), this._moving = false, this._zooming = false, this.transform = J, this._bearingSnap = q2.bearingSnap, i3.bindAll(["_renderFrameCallback"], this);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.getCenter = function() {\n                    return new i3.LngLat(this.transform.center.lng, this.transform.center.lat);\n                  }, D3.prototype.setCenter = function(q2, K) {\n                    return this.jumpTo({ center: q2 }, K);\n                  }, D3.prototype.panBy = function(q2, K, de) {\n                    return q2 = i3.Point.convert(q2).mult(-1), this.panTo(this.transform.center, i3.extend({ offset: q2 }, K), de);\n                  }, D3.prototype.panTo = function(q2, K, de) {\n                    return this.easeTo(i3.extend({ center: q2 }, K), de);\n                  }, D3.prototype.getZoom = function() {\n                    return this.transform.zoom;\n                  }, D3.prototype.setZoom = function(q2, K) {\n                    return this.jumpTo({ zoom: q2 }, K), this;\n                  }, D3.prototype.zoomTo = function(q2, K, de) {\n                    return this.easeTo(i3.extend({ zoom: q2 }, K), de);\n                  }, D3.prototype.zoomIn = function(q2, K) {\n                    return this.zoomTo(this.getZoom() + 1, q2, K), this;\n                  }, D3.prototype.zoomOut = function(q2, K) {\n                    return this.zoomTo(this.getZoom() - 1, q2, K), this;\n                  }, D3.prototype.getBearing = function() {\n                    return this.transform.bearing;\n                  }, D3.prototype.setBearing = function(q2, K) {\n                    return this.jumpTo({ bearing: q2 }, K), this;\n                  }, D3.prototype.getPadding = function() {\n                    return this.transform.padding;\n                  }, D3.prototype.setPadding = function(q2, K) {\n                    return this.jumpTo({ padding: q2 }, K), this;\n                  }, D3.prototype.rotateTo = function(q2, K, de) {\n                    return this.easeTo(i3.extend({ bearing: q2 }, K), de);\n                  }, D3.prototype.resetNorth = function(q2, K) {\n                    return this.rotateTo(0, i3.extend({ duration: 1e3 }, q2), K), this;\n                  }, D3.prototype.resetNorthPitch = function(q2, K) {\n                    return this.easeTo(i3.extend({ bearing: 0, pitch: 0, duration: 1e3 }, q2), K), this;\n                  }, D3.prototype.snapToNorth = function(q2, K) {\n                    return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(q2, K) : this;\n                  }, D3.prototype.getPitch = function() {\n                    return this.transform.pitch;\n                  }, D3.prototype.setPitch = function(q2, K) {\n                    return this.jumpTo({ pitch: q2 }, K), this;\n                  }, D3.prototype.cameraForBounds = function(q2, K) {\n                    q2 = i3.LngLatBounds.convert(q2);\n                    var de = K && K.bearing || 0;\n                    return this._cameraForBoxAndBearing(q2.getNorthWest(), q2.getSouthEast(), de, K);\n                  }, D3.prototype._cameraForBoxAndBearing = function(q2, K, de, ne) {\n                    var we = { top: 0, bottom: 0, right: 0, left: 0 };\n                    if (ne = i3.extend({ padding: we, offset: [0, 0], maxZoom: this.transform.maxZoom }, ne), typeof ne.padding == "number") {\n                      var Ue = ne.padding;\n                      ne.padding = { top: Ue, bottom: Ue, right: Ue, left: Ue };\n                    }\n                    ne.padding = i3.extend(we, ne.padding);\n                    var ft = this.transform, Xt = ft.padding, hr = ft.project(i3.LngLat.convert(q2)), qt = ft.project(i3.LngLat.convert(K)), Ve = hr.rotate(-de * Math.PI / 180), Qe = qt.rotate(-de * Math.PI / 180), at = new i3.Point(Math.max(Ve.x, Qe.x), Math.max(Ve.y, Qe.y)), Ct = new i3.Point(Math.min(Ve.x, Qe.x), Math.min(Ve.y, Qe.y)), Ot = at.sub(Ct), Rt = (ft.width - (Xt.left + Xt.right + ne.padding.left + ne.padding.right)) / Ot.x, Bt = (ft.height - (Xt.top + Xt.bottom + ne.padding.top + ne.padding.bottom)) / Ot.y;\n                    if (Bt < 0 || Rt < 0) {\n                      i3.warnOnce("Map cannot fit within canvas with the given bounds, padding, and/or offset.");\n                      return;\n                    }\n                    var Dt = Math.min(ft.scaleZoom(ft.scale * Math.min(Rt, Bt)), ne.maxZoom), yt = typeof ne.offset.x == "number" ? new i3.Point(ne.offset.x, ne.offset.y) : i3.Point.convert(ne.offset), Pt = (ne.padding.left - ne.padding.right) / 2, ht = (ne.padding.top - ne.padding.bottom) / 2, ur = new i3.Point(Pt, ht), br = ur.rotate(de * Math.PI / 180), Ur = yt.add(br), Di = Ur.mult(ft.scale / ft.zoomScale(Dt)), fi = ft.unproject(hr.add(qt).div(2).sub(Di));\n                    return { center: fi, zoom: Dt, bearing: de };\n                  }, D3.prototype.fitBounds = function(q2, K, de) {\n                    return this._fitInternal(this.cameraForBounds(q2, K), K, de);\n                  }, D3.prototype.fitScreenCoordinates = function(q2, K, de, ne, we) {\n                    return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(i3.Point.convert(q2)), this.transform.pointLocation(i3.Point.convert(K)), de, ne), ne, we);\n                  }, D3.prototype._fitInternal = function(q2, K, de) {\n                    return q2 ? (K = i3.extend(q2, K), delete K.padding, K.linear ? this.easeTo(K, de) : this.flyTo(K, de)) : this;\n                  }, D3.prototype.jumpTo = function(q2, K) {\n                    this.stop();\n                    var de = this.transform, ne = false, we = false, Ue = false;\n                    return "zoom" in q2 && de.zoom !== +q2.zoom && (ne = true, de.zoom = +q2.zoom), q2.center !== void 0 && (de.center = i3.LngLat.convert(q2.center)), "bearing" in q2 && de.bearing !== +q2.bearing && (we = true, de.bearing = +q2.bearing), "pitch" in q2 && de.pitch !== +q2.pitch && (Ue = true, de.pitch = +q2.pitch), q2.padding != null && !de.isPaddingEqual(q2.padding) && (de.padding = q2.padding), this.fire(new i3.Event("movestart", K)).fire(new i3.Event("move", K)), ne && this.fire(new i3.Event("zoomstart", K)).fire(new i3.Event("zoom", K)).fire(new i3.Event("zoomend", K)), we && this.fire(new i3.Event("rotatestart", K)).fire(new i3.Event("rotate", K)).fire(new i3.Event("rotateend", K)), Ue && this.fire(new i3.Event("pitchstart", K)).fire(new i3.Event("pitch", K)).fire(new i3.Event("pitchend", K)), this.fire(new i3.Event("moveend", K));\n                  }, D3.prototype.easeTo = function(q2, K) {\n                    var de = this;\n                    this._stop(false, q2.easeId), q2 = i3.extend({ offset: [0, 0], duration: 500, easing: i3.ease }, q2), (q2.animate === false || !q2.essential && i3.browser.prefersReducedMotion) && (q2.duration = 0);\n                    var ne = this.transform, we = this.getZoom(), Ue = this.getBearing(), ft = this.getPitch(), Xt = this.getPadding(), hr = "zoom" in q2 ? +q2.zoom : we, qt = "bearing" in q2 ? this._normalizeBearing(q2.bearing, Ue) : Ue, Ve = "pitch" in q2 ? +q2.pitch : ft, Qe = "padding" in q2 ? q2.padding : ne.padding, at = i3.Point.convert(q2.offset), Ct = ne.centerPoint.add(at), Ot = ne.pointLocation(Ct), Rt = i3.LngLat.convert(q2.center || Ot);\n                    this._normalizeCenter(Rt);\n                    var Bt = ne.project(Ot), Dt = ne.project(Rt).sub(Bt), yt = ne.zoomScale(hr - we), Pt, ht;\n                    q2.around && (Pt = i3.LngLat.convert(q2.around), ht = ne.locationPoint(Pt));\n                    var ur = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching };\n                    return this._zooming = this._zooming || hr !== we, this._rotating = this._rotating || Ue !== qt, this._pitching = this._pitching || Ve !== ft, this._padding = !ne.isPaddingEqual(Qe), this._easeId = q2.easeId, this._prepareEase(K, q2.noMoveStart, ur), this._ease(function(br) {\n                      if (de._zooming && (ne.zoom = i3.number(we, hr, br)), de._rotating && (ne.bearing = i3.number(Ue, qt, br)), de._pitching && (ne.pitch = i3.number(ft, Ve, br)), de._padding && (ne.interpolatePadding(Xt, Qe, br), Ct = ne.centerPoint.add(at)), Pt) ne.setLocationAtPoint(Pt, ht);\n                      else {\n                        var Ur = ne.zoomScale(ne.zoom - we), Di = hr > we ? Math.min(2, yt) : Math.max(0.5, yt), fi = Math.pow(Di, 1 - br), Ti = ne.unproject(Bt.add(Dt.mult(br * fi)).mult(Ur));\n                        ne.setLocationAtPoint(ne.renderWorldCopies ? Ti.wrap() : Ti, Ct);\n                      }\n                      de._fireMoveEvents(K);\n                    }, function(br) {\n                      de._afterEase(K, br);\n                    }, q2), this;\n                  }, D3.prototype._prepareEase = function(q2, K, de) {\n                    de === void 0 && (de = {}), this._moving = true, !K && !de.moving && this.fire(new i3.Event("movestart", q2)), this._zooming && !de.zooming && this.fire(new i3.Event("zoomstart", q2)), this._rotating && !de.rotating && this.fire(new i3.Event("rotatestart", q2)), this._pitching && !de.pitching && this.fire(new i3.Event("pitchstart", q2));\n                  }, D3.prototype._fireMoveEvents = function(q2) {\n                    this.fire(new i3.Event("move", q2)), this._zooming && this.fire(new i3.Event("zoom", q2)), this._rotating && this.fire(new i3.Event("rotate", q2)), this._pitching && this.fire(new i3.Event("pitch", q2));\n                  }, D3.prototype._afterEase = function(q2, K) {\n                    if (!(this._easeId && K && this._easeId === K)) {\n                      delete this._easeId;\n                      var de = this._zooming, ne = this._rotating, we = this._pitching;\n                      this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._padding = false, de && this.fire(new i3.Event("zoomend", q2)), ne && this.fire(new i3.Event("rotateend", q2)), we && this.fire(new i3.Event("pitchend", q2)), this.fire(new i3.Event("moveend", q2));\n                    }\n                  }, D3.prototype.flyTo = function(q2, K) {\n                    var de = this;\n                    if (!q2.essential && i3.browser.prefersReducedMotion) {\n                      var ne = i3.pick(q2, ["center", "zoom", "bearing", "pitch", "around"]);\n                      return this.jumpTo(ne, K);\n                    }\n                    this.stop(), q2 = i3.extend({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: i3.ease }, q2);\n                    var we = this.transform, Ue = this.getZoom(), ft = this.getBearing(), Xt = this.getPitch(), hr = this.getPadding(), qt = "zoom" in q2 ? i3.clamp(+q2.zoom, we.minZoom, we.maxZoom) : Ue, Ve = "bearing" in q2 ? this._normalizeBearing(q2.bearing, ft) : ft, Qe = "pitch" in q2 ? +q2.pitch : Xt, at = "padding" in q2 ? q2.padding : we.padding, Ct = we.zoomScale(qt - Ue), Ot = i3.Point.convert(q2.offset), Rt = we.centerPoint.add(Ot), Bt = we.pointLocation(Rt), Dt = i3.LngLat.convert(q2.center || Bt);\n                    this._normalizeCenter(Dt);\n                    var yt = we.project(Bt), Pt = we.project(Dt).sub(yt), ht = q2.curve, ur = Math.max(we.width, we.height), br = ur / Ct, Ur = Pt.mag();\n                    if ("minZoom" in q2) {\n                      var Di = i3.clamp(Math.min(q2.minZoom, Ue, qt), we.minZoom, we.maxZoom), fi = ur / we.zoomScale(Di - Ue);\n                      ht = Math.sqrt(fi / Ur * 2);\n                    }\n                    var Ti = ht * ht;\n                    function gn(so) {\n                      var Zo = (br * br - ur * ur + (so ? -1 : 1) * Ti * Ti * Ur * Ur) / (2 * (so ? br : ur) * Ti * Ur);\n                      return Math.log(Math.sqrt(Zo * Zo + 1) - Zo);\n                    }\n                    function rn(so) {\n                      return (Math.exp(so) - Math.exp(-so)) / 2;\n                    }\n                    function Ci(so) {\n                      return (Math.exp(so) + Math.exp(-so)) / 2;\n                    }\n                    function Bi(so) {\n                      return rn(so) / Ci(so);\n                    }\n                    var Gi = gn(0), sn = function(so) {\n                      return Ci(Gi) / Ci(Gi + ht * so);\n                    }, zn = function(so) {\n                      return ur * ((Ci(Gi) * Bi(Gi + ht * so) - rn(Gi)) / Ti) / Ur;\n                    }, Ja = (gn(1) - Gi) / ht;\n                    if (Math.abs(Ur) < 1e-6 || !isFinite(Ja)) {\n                      if (Math.abs(ur - br) < 1e-6) return this.easeTo(q2, K);\n                      var co = br < ur ? -1 : 1;\n                      Ja = Math.abs(Math.log(br / ur)) / ht, zn = function() {\n                        return 0;\n                      }, sn = function(so) {\n                        return Math.exp(co * ht * so);\n                      };\n                    }\n                    if ("duration" in q2) q2.duration = +q2.duration;\n                    else {\n                      var ts = "screenSpeed" in q2 ? +q2.screenSpeed / ht : +q2.speed;\n                      q2.duration = 1e3 * Ja / ts;\n                    }\n                    return q2.maxDuration && q2.duration > q2.maxDuration && (q2.duration = 0), this._zooming = true, this._rotating = ft !== Ve, this._pitching = Qe !== Xt, this._padding = !we.isPaddingEqual(at), this._prepareEase(K, false), this._ease(function(so) {\n                      var Zo = so * Ja, ms = 1 / sn(Zo);\n                      we.zoom = so === 1 ? qt : Ue + we.scaleZoom(ms), de._rotating && (we.bearing = i3.number(ft, Ve, so)), de._pitching && (we.pitch = i3.number(Xt, Qe, so)), de._padding && (we.interpolatePadding(hr, at, so), Rt = we.centerPoint.add(Ot));\n                      var ou = so === 1 ? Dt : we.unproject(yt.add(Pt.mult(zn(Zo))).mult(ms));\n                      we.setLocationAtPoint(we.renderWorldCopies ? ou.wrap() : ou, Rt), de._fireMoveEvents(K);\n                    }, function() {\n                      return de._afterEase(K);\n                    }, q2), this;\n                  }, D3.prototype.isEasing = function() {\n                    return !!this._easeFrameId;\n                  }, D3.prototype.stop = function() {\n                    return this._stop();\n                  }, D3.prototype._stop = function(q2, K) {\n                    if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {\n                      var de = this._onEaseEnd;\n                      delete this._onEaseEnd, de.call(this, K);\n                    }\n                    if (!q2) {\n                      var ne = this.handlers;\n                      ne && ne.stop(false);\n                    }\n                    return this;\n                  }, D3.prototype._ease = function(q2, K, de) {\n                    de.animate === false || de.duration === 0 ? (q2(1), K()) : (this._easeStart = i3.browser.now(), this._easeOptions = de, this._onEaseFrame = q2, this._onEaseEnd = K, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));\n                  }, D3.prototype._renderFrameCallback = function() {\n                    var q2 = Math.min((i3.browser.now() - this._easeStart) / this._easeOptions.duration, 1);\n                    this._onEaseFrame(this._easeOptions.easing(q2)), q2 < 1 ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();\n                  }, D3.prototype._normalizeBearing = function(q2, K) {\n                    q2 = i3.wrap(q2, -180, 180);\n                    var de = Math.abs(q2 - K);\n                    return Math.abs(q2 - 360 - K) < de && (q2 -= 360), Math.abs(q2 + 360 - K) < de && (q2 += 360), q2;\n                  }, D3.prototype._normalizeCenter = function(q2) {\n                    var K = this.transform;\n                    if (!(!K.renderWorldCopies || K.lngRange)) {\n                      var de = q2.lng - K.center.lng;\n                      q2.lng += de > 180 ? -360 : de < -180 ? 360 : 0;\n                    }\n                  }, D3;\n                })(i3.Evented), en = function(D3) {\n                  D3 === void 0 && (D3 = {}), this.options = D3, i3.bindAll(["_toggleAttribution", "_updateEditLink", "_updateData", "_updateCompact"], this);\n                };\n                en.prototype.getDefaultPosition = function() {\n                  return "bottom-right";\n                }, en.prototype.onAdd = function(D3) {\n                  var J = this.options && this.options.compact;\n                  return this._map = D3, this._container = o4.create("div", "mapboxgl-ctrl mapboxgl-ctrl-attrib"), this._compactButton = o4.create("button", "mapboxgl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = o4.create("div", "mapboxgl-ctrl-attrib-inner", this._container), this._innerContainer.setAttribute("role", "list"), J && this._container.classList.add("mapboxgl-compact"), this._updateAttributions(), this._updateEditLink(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("moveend", this._updateEditLink), J === void 0 && (this._map.on("resize", this._updateCompact), this._updateCompact()), this._container;\n                }, en.prototype.onRemove = function() {\n                  o4.remove(this._container), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("moveend", this._updateEditLink), this._map.off("resize", this._updateCompact), this._map = void 0, this._attribHTML = void 0;\n                }, en.prototype._setElementTitle = function(D3, J) {\n                  var q2 = this._map._getUIString("AttributionControl." + J);\n                  D3.title = q2, D3.setAttribute("aria-label", q2);\n                }, en.prototype._toggleAttribution = function() {\n                  this._container.classList.contains("mapboxgl-compact-show") ? (this._container.classList.remove("mapboxgl-compact-show"), this._compactButton.setAttribute("aria-pressed", "false")) : (this._container.classList.add("mapboxgl-compact-show"), this._compactButton.setAttribute("aria-pressed", "true"));\n                }, en.prototype._updateEditLink = function() {\n                  var D3 = this._editLink;\n                  D3 || (D3 = this._editLink = this._container.querySelector(".mapbox-improve-map"));\n                  var J = [{ key: "owner", value: this.styleOwner }, { key: "id", value: this.styleId }, { key: "access_token", value: this._map._requestManager._customAccessToken || i3.config.ACCESS_TOKEN }];\n                  if (D3) {\n                    var q2 = J.reduce(function(K, de, ne) {\n                      return de.value && (K += de.key + "=" + de.value + (ne < J.length - 1 ? "&" : "")), K;\n                    }, "?");\n                    D3.href = i3.config.FEEDBACK_URL + "/" + q2 + (this._map._hash ? this._map._hash.getHashString(true) : ""), D3.rel = "noopener nofollow", this._setElementTitle(D3, "MapFeedback");\n                  }\n                }, en.prototype._updateData = function(D3) {\n                  D3 && (D3.sourceDataType === "metadata" || D3.sourceDataType === "visibility" || D3.dataType === "style") && (this._updateAttributions(), this._updateEditLink());\n                }, en.prototype._updateAttributions = function() {\n                  if (this._map.style) {\n                    var D3 = [];\n                    if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? D3 = D3.concat(this.options.customAttribution.map(function(Ue) {\n                      return typeof Ue != "string" ? "" : Ue;\n                    })) : typeof this.options.customAttribution == "string" && D3.push(this.options.customAttribution)), this._map.style.stylesheet) {\n                      var J = this._map.style.stylesheet;\n                      this.styleOwner = J.owner, this.styleId = J.id;\n                    }\n                    var q2 = this._map.style.sourceCaches;\n                    for (var K in q2) {\n                      var de = q2[K];\n                      if (de.used) {\n                        var ne = de.getSource();\n                        ne.attribution && D3.indexOf(ne.attribution) < 0 && D3.push(ne.attribution);\n                      }\n                    }\n                    D3.sort(function(Ue, ft) {\n                      return Ue.length - ft.length;\n                    }), D3 = D3.filter(function(Ue, ft) {\n                      for (var Xt = ft + 1; Xt < D3.length; Xt++) if (D3[Xt].indexOf(Ue) >= 0) return false;\n                      return true;\n                    });\n                    var we = D3.join(" | ");\n                    we !== this._attribHTML && (this._attribHTML = we, D3.length ? (this._innerContainer.innerHTML = we, this._container.classList.remove("mapboxgl-attrib-empty")) : this._container.classList.add("mapboxgl-attrib-empty"), this._editLink = null);\n                  }\n                }, en.prototype._updateCompact = function() {\n                  this._map.getCanvasContainer().offsetWidth <= 640 ? this._container.classList.add("mapboxgl-compact") : this._container.classList.remove("mapboxgl-compact", "mapboxgl-compact-show");\n                };\n                var Wi = function() {\n                  i3.bindAll(["_updateLogo"], this), i3.bindAll(["_updateCompact"], this);\n                };\n                Wi.prototype.onAdd = function(D3) {\n                  this._map = D3, this._container = o4.create("div", "mapboxgl-ctrl");\n                  var J = o4.create("a", "mapboxgl-ctrl-logo");\n                  return J.target = "_blank", J.rel = "noopener nofollow", J.href = "https://www.mapbox.com/", J.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), J.setAttribute("rel", "noopener nofollow"), this._container.appendChild(J), this._container.style.display = "none", this._map.on("sourcedata", this._updateLogo), this._updateLogo(), this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;\n                }, Wi.prototype.onRemove = function() {\n                  o4.remove(this._container), this._map.off("sourcedata", this._updateLogo), this._map.off("resize", this._updateCompact);\n                }, Wi.prototype.getDefaultPosition = function() {\n                  return "bottom-left";\n                }, Wi.prototype._updateLogo = function(D3) {\n                  (!D3 || D3.sourceDataType === "metadata") && (this._container.style.display = this._logoRequired() ? "block" : "none");\n                }, Wi.prototype._logoRequired = function() {\n                  if (this._map.style) {\n                    var D3 = this._map.style.sourceCaches;\n                    for (var J in D3) {\n                      var q2 = D3[J].getSource();\n                      if (q2.mapbox_logo) return true;\n                    }\n                    return false;\n                  }\n                }, Wi.prototype._updateCompact = function() {\n                  var D3 = this._container.children;\n                  if (D3.length) {\n                    var J = D3[0];\n                    this._map.getCanvasContainer().offsetWidth < 250 ? J.classList.add("mapboxgl-compact") : J.classList.remove("mapboxgl-compact");\n                  }\n                };\n                var si = function() {\n                  this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;\n                };\n                si.prototype.add = function(D3) {\n                  var J = ++this._id, q2 = this._queue;\n                  return q2.push({ callback: D3, id: J, cancelled: false }), J;\n                }, si.prototype.remove = function(D3) {\n                  for (var J = this._currentlyRunning, q2 = J ? this._queue.concat(J) : this._queue, K = 0, de = q2; K < de.length; K += 1) {\n                    var ne = de[K];\n                    if (ne.id === D3) {\n                      ne.cancelled = true;\n                      return;\n                    }\n                  }\n                }, si.prototype.run = function(D3) {\n                  D3 === void 0 && (D3 = 0);\n                  var J = this._currentlyRunning = this._queue;\n                  this._queue = [];\n                  for (var q2 = 0, K = J; q2 < K.length; q2 += 1) {\n                    var de = K[q2];\n                    if (!de.cancelled && (de.callback(D3), this._cleared)) break;\n                  }\n                  this._cleared = false, this._currentlyRunning = false;\n                }, si.prototype.clear = function() {\n                  this._currentlyRunning && (this._cleared = true), this._queue = [];\n                };\n                var Mr = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "Mapbox logo", "NavigationControl.ResetBearing": "Reset bearing to north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm" }, Yr = i3.window.HTMLImageElement, xi = i3.window.HTMLElement, Ri = i3.window.ImageBitmap, ci = -2, an = 22, Zi = 0, Bn = 60, hi = { center: [0, 0], zoom: 0, bearing: 0, pitch: 0, minZoom: ci, maxZoom: an, minPitch: Zi, maxPitch: Bn, interactive: true, scrollZoom: true, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, bearingSnap: 7, clickTolerance: 3, pitchWithRotate: true, hash: false, attributionControl: true, failIfMajorPerformanceCaveat: false, preserveDrawingBuffer: false, trackResize: true, renderWorldCopies: true, refreshExpiredTiles: true, maxTileCacheSize: null, localIdeographFontFamily: "sans-serif", transformRequest: null, accessToken: null, fadeDuration: 300, crossSourceCollisions: true }, li = (function(Y) {\n                  function D3(q2) {\n                    var K = this;\n                    if (q2 = i3.extend({}, hi, q2), q2.minZoom != null && q2.maxZoom != null && q2.minZoom > q2.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");\n                    if (q2.minPitch != null && q2.maxPitch != null && q2.minPitch > q2.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");\n                    if (q2.minPitch != null && q2.minPitch < Zi) throw new Error("minPitch must be greater than or equal to " + Zi);\n                    if (q2.maxPitch != null && q2.maxPitch > Bn) throw new Error("maxPitch must be less than or equal to " + Bn);\n                    var de = new wo(q2.minZoom, q2.maxZoom, q2.minPitch, q2.maxPitch, q2.renderWorldCopies);\n                    if (Y.call(this, de, q2), this._interactive = q2.interactive, this._maxTileCacheSize = q2.maxTileCacheSize, this._failIfMajorPerformanceCaveat = q2.failIfMajorPerformanceCaveat, this._preserveDrawingBuffer = q2.preserveDrawingBuffer, this._antialias = q2.antialias, this._trackResize = q2.trackResize, this._bearingSnap = q2.bearingSnap, this._refreshExpiredTiles = q2.refreshExpiredTiles, this._fadeDuration = q2.fadeDuration, this._crossSourceCollisions = q2.crossSourceCollisions, this._crossFadingFactor = 1, this._collectResourceTiming = q2.collectResourceTiming, this._renderTaskQueue = new si(), this._controls = [], this._mapId = i3.uniqueId(), this._locale = i3.extend({}, Mr, q2.locale), this._clickTolerance = q2.clickTolerance, this._requestManager = new i3.RequestManager(q2.transformRequest, q2.accessToken), typeof q2.container == "string") {\n                      if (this._container = i3.window.document.getElementById(q2.container), !this._container) throw new Error("Container \'" + q2.container + "\' not found.");\n                    } else if (q2.container instanceof xi) this._container = q2.container;\n                    else throw new Error("Invalid type: \'container\' must be a String or HTMLElement.");\n                    if (q2.maxBounds && this.setMaxBounds(q2.maxBounds), i3.bindAll(["_onWindowOnline", "_onWindowResize", "_onMapScroll", "_contextLost", "_contextRestored"], this), this._setupContainer(), this._setupPainter(), this.painter === void 0) throw new Error("Failed to initialize WebGL.");\n                    this.on("move", function() {\n                      return K._update(false);\n                    }), this.on("moveend", function() {\n                      return K._update(false);\n                    }), this.on("zoom", function() {\n                      return K._update(true);\n                    }), typeof i3.window != "undefined" && (i3.window.addEventListener("online", this._onWindowOnline, false), i3.window.addEventListener("resize", this._onWindowResize, false), i3.window.addEventListener("orientationchange", this._onWindowResize, false)), this.handlers = new Ei(this, q2);\n                    var ne = typeof q2.hash == "string" && q2.hash || void 0;\n                    this._hash = q2.hash && new Ul(ne).addTo(this), (!this._hash || !this._hash._onHashChange()) && (this.jumpTo({ center: q2.center, zoom: q2.zoom, bearing: q2.bearing, pitch: q2.pitch }), q2.bounds && (this.resize(), this.fitBounds(q2.bounds, i3.extend({}, q2.fitBoundsOptions, { duration: 0 })))), this.resize(), this._localIdeographFontFamily = q2.localIdeographFontFamily, q2.style && this.setStyle(q2.style, { localIdeographFontFamily: q2.localIdeographFontFamily }), q2.attributionControl && this.addControl(new en({ customAttribution: q2.customAttribution })), this.addControl(new Wi(), q2.logoPosition), this.on("style.load", function() {\n                      K.transform.unmodified && K.jumpTo(K.style.stylesheet);\n                    }), this.on("data", function(we) {\n                      K._update(we.dataType === "style"), K.fire(new i3.Event(we.dataType + "data", we));\n                    }), this.on("dataloading", function(we) {\n                      K.fire(new i3.Event(we.dataType + "dataloading", we));\n                    });\n                  }\n                  Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3;\n                  var J = { showTileBoundaries: { configurable: true }, showPadding: { configurable: true }, showCollisionBoxes: { configurable: true }, showOverdrawInspector: { configurable: true }, repaint: { configurable: true }, vertices: { configurable: true }, version: { configurable: true } };\n                  return D3.prototype._getMapId = function() {\n                    return this._mapId;\n                  }, D3.prototype.addControl = function(K, de) {\n                    if (de === void 0 && (K.getDefaultPosition ? de = K.getDefaultPosition() : de = "top-right"), !K || !K.onAdd) return this.fire(new i3.ErrorEvent(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));\n                    var ne = K.onAdd(this);\n                    this._controls.push(K);\n                    var we = this._controlPositions[de];\n                    return de.indexOf("bottom") !== -1 ? we.insertBefore(ne, we.firstChild) : we.appendChild(ne), this;\n                  }, D3.prototype.removeControl = function(K) {\n                    if (!K || !K.onRemove) return this.fire(new i3.ErrorEvent(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));\n                    var de = this._controls.indexOf(K);\n                    return de > -1 && this._controls.splice(de, 1), K.onRemove(this), this;\n                  }, D3.prototype.hasControl = function(K) {\n                    return this._controls.indexOf(K) > -1;\n                  }, D3.prototype.resize = function(K) {\n                    var de = this._containerDimensions(), ne = de[0], we = de[1];\n                    this._resizeCanvas(ne, we), this.transform.resize(ne, we), this.painter.resize(ne, we);\n                    var Ue = !this._moving;\n                    return Ue && (this.stop(), this.fire(new i3.Event("movestart", K)).fire(new i3.Event("move", K))), this.fire(new i3.Event("resize", K)), Ue && this.fire(new i3.Event("moveend", K)), this;\n                  }, D3.prototype.getBounds = function() {\n                    return this.transform.getBounds();\n                  }, D3.prototype.getMaxBounds = function() {\n                    return this.transform.getMaxBounds();\n                  }, D3.prototype.setMaxBounds = function(K) {\n                    return this.transform.setMaxBounds(i3.LngLatBounds.convert(K)), this._update();\n                  }, D3.prototype.setMinZoom = function(K) {\n                    if (K = K == null ? ci : K, K >= ci && K <= this.transform.maxZoom) return this.transform.minZoom = K, this._update(), this.getZoom() < K && this.setZoom(K), this;\n                    throw new Error("minZoom must be between " + ci + " and the current maxZoom, inclusive");\n                  }, D3.prototype.getMinZoom = function() {\n                    return this.transform.minZoom;\n                  }, D3.prototype.setMaxZoom = function(K) {\n                    if (K = K == null ? an : K, K >= this.transform.minZoom) return this.transform.maxZoom = K, this._update(), this.getZoom() > K && this.setZoom(K), this;\n                    throw new Error("maxZoom must be greater than the current minZoom");\n                  }, D3.prototype.getMaxZoom = function() {\n                    return this.transform.maxZoom;\n                  }, D3.prototype.setMinPitch = function(K) {\n                    if (K = K == null ? Zi : K, K < Zi) throw new Error("minPitch must be greater than or equal to " + Zi);\n                    if (K >= Zi && K <= this.transform.maxPitch) return this.transform.minPitch = K, this._update(), this.getPitch() < K && this.setPitch(K), this;\n                    throw new Error("minPitch must be between " + Zi + " and the current maxPitch, inclusive");\n                  }, D3.prototype.getMinPitch = function() {\n                    return this.transform.minPitch;\n                  }, D3.prototype.setMaxPitch = function(K) {\n                    if (K = K == null ? Bn : K, K > Bn) throw new Error("maxPitch must be less than or equal to " + Bn);\n                    if (K >= this.transform.minPitch) return this.transform.maxPitch = K, this._update(), this.getPitch() > K && this.setPitch(K), this;\n                    throw new Error("maxPitch must be greater than the current minPitch");\n                  }, D3.prototype.getMaxPitch = function() {\n                    return this.transform.maxPitch;\n                  }, D3.prototype.getRenderWorldCopies = function() {\n                    return this.transform.renderWorldCopies;\n                  }, D3.prototype.setRenderWorldCopies = function(K) {\n                    return this.transform.renderWorldCopies = K, this._update();\n                  }, D3.prototype.project = function(K) {\n                    return this.transform.locationPoint(i3.LngLat.convert(K));\n                  }, D3.prototype.unproject = function(K) {\n                    return this.transform.pointLocation(i3.Point.convert(K));\n                  }, D3.prototype.isMoving = function() {\n                    return this._moving || this.handlers.isMoving();\n                  }, D3.prototype.isZooming = function() {\n                    return this._zooming || this.handlers.isZooming();\n                  }, D3.prototype.isRotating = function() {\n                    return this._rotating || this.handlers.isRotating();\n                  }, D3.prototype._createDelegatedListener = function(K, de, ne) {\n                    var we = this, Ue;\n                    if (K === "mouseenter" || K === "mouseover") {\n                      var ft = false, Xt = function(Ct) {\n                        var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];\n                        Ot.length ? ft || (ft = true, ne.call(we, new se(K, we, Ct.originalEvent, { features: Ot }))) : ft = false;\n                      }, hr = function() {\n                        ft = false;\n                      };\n                      return { layer: de, listener: ne, delegates: { mousemove: Xt, mouseout: hr } };\n                    } else if (K === "mouseleave" || K === "mouseout") {\n                      var qt = false, Ve = function(Ct) {\n                        var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];\n                        Ot.length ? qt = true : qt && (qt = false, ne.call(we, new se(K, we, Ct.originalEvent)));\n                      }, Qe = function(Ct) {\n                        qt && (qt = false, ne.call(we, new se(K, we, Ct.originalEvent)));\n                      };\n                      return { layer: de, listener: ne, delegates: { mousemove: Ve, mouseout: Qe } };\n                    } else {\n                      var at = function(Ct) {\n                        var Ot = we.getLayer(de) ? we.queryRenderedFeatures(Ct.point, { layers: [de] }) : [];\n                        Ot.length && (Ct.features = Ot, ne.call(we, Ct), delete Ct.features);\n                      };\n                      return { layer: de, listener: ne, delegates: (Ue = {}, Ue[K] = at, Ue) };\n                    }\n                  }, D3.prototype.on = function(K, de, ne) {\n                    if (ne === void 0) return Y.prototype.on.call(this, K, de);\n                    var we = this._createDelegatedListener(K, de, ne);\n                    this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[K] = this._delegatedListeners[K] || [], this._delegatedListeners[K].push(we);\n                    for (var Ue in we.delegates) this.on(Ue, we.delegates[Ue]);\n                    return this;\n                  }, D3.prototype.once = function(K, de, ne) {\n                    if (ne === void 0) return Y.prototype.once.call(this, K, de);\n                    var we = this._createDelegatedListener(K, de, ne);\n                    for (var Ue in we.delegates) this.once(Ue, we.delegates[Ue]);\n                    return this;\n                  }, D3.prototype.off = function(K, de, ne) {\n                    var we = this;\n                    if (ne === void 0) return Y.prototype.off.call(this, K, de);\n                    var Ue = function(ft) {\n                      for (var Xt = ft[K], hr = 0; hr < Xt.length; hr++) {\n                        var qt = Xt[hr];\n                        if (qt.layer === de && qt.listener === ne) {\n                          for (var Ve in qt.delegates) we.off(Ve, qt.delegates[Ve]);\n                          return Xt.splice(hr, 1), we;\n                        }\n                      }\n                    };\n                    return this._delegatedListeners && this._delegatedListeners[K] && Ue(this._delegatedListeners), this;\n                  }, D3.prototype.queryRenderedFeatures = function(K, de) {\n                    if (!this.style) return [];\n                    de === void 0 && K !== void 0 && !(K instanceof i3.Point) && !Array.isArray(K) && (de = K, K = void 0), de = de || {}, K = K || [[0, 0], [this.transform.width, this.transform.height]];\n                    var ne;\n                    if (K instanceof i3.Point || typeof K[0] == "number") ne = [i3.Point.convert(K)];\n                    else {\n                      var we = i3.Point.convert(K[0]), Ue = i3.Point.convert(K[1]);\n                      ne = [we, new i3.Point(Ue.x, we.y), Ue, new i3.Point(we.x, Ue.y), we];\n                    }\n                    return this.style.queryRenderedFeatures(ne, de, this.transform);\n                  }, D3.prototype.querySourceFeatures = function(K, de) {\n                    return this.style.querySourceFeatures(K, de);\n                  }, D3.prototype.setStyle = function(K, de) {\n                    return de = i3.extend({}, { localIdeographFontFamily: this._localIdeographFontFamily }, de), de.diff !== false && de.localIdeographFontFamily === this._localIdeographFontFamily && this.style && K ? (this._diffStyle(K, de), this) : (this._localIdeographFontFamily = de.localIdeographFontFamily, this._updateStyle(K, de));\n                  }, D3.prototype._getUIString = function(K) {\n                    var de = this._locale[K];\n                    if (de == null) throw new Error("Missing UI string \'" + K + "\'");\n                    return de;\n                  }, D3.prototype._updateStyle = function(K, de) {\n                    if (this.style && (this.style.setEventedParent(null), this.style._remove()), K) this.style = new yu(this, de || {});\n                    else return delete this.style, this;\n                    return this.style.setEventedParent(this, { style: this.style }), typeof K == "string" ? this.style.loadURL(K) : this.style.loadJSON(K), this;\n                  }, D3.prototype._lazyInitEmptyStyle = function() {\n                    this.style || (this.style = new yu(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());\n                  }, D3.prototype._diffStyle = function(K, de) {\n                    var ne = this;\n                    if (typeof K == "string") {\n                      var we = this._requestManager.normalizeStyleURL(K), Ue = this._requestManager.transformRequest(we, i3.ResourceType.Style);\n                      i3.getJSON(Ue, function(ft, Xt) {\n                        ft ? ne.fire(new i3.ErrorEvent(ft)) : Xt && ne._updateDiff(Xt, de);\n                      });\n                    } else typeof K == "object" && this._updateDiff(K, de);\n                  }, D3.prototype._updateDiff = function(K, de) {\n                    try {\n                      this.style.setState(K) && this._update(true);\n                    } catch (ne) {\n                      i3.warnOnce("Unable to perform style diff: " + (ne.message || ne.error || ne) + ".  Rebuilding the style from scratch."), this._updateStyle(K, de);\n                    }\n                  }, D3.prototype.getStyle = function() {\n                    if (this.style) return this.style.serialize();\n                  }, D3.prototype.isStyleLoaded = function() {\n                    return this.style ? this.style.loaded() : i3.warnOnce("There is no style added to the map.");\n                  }, D3.prototype.addSource = function(K, de) {\n                    return this._lazyInitEmptyStyle(), this.style.addSource(K, de), this._update(true);\n                  }, D3.prototype.isSourceLoaded = function(K) {\n                    var de = this.style && this.style.sourceCaches[K];\n                    if (de === void 0) {\n                      this.fire(new i3.ErrorEvent(new Error("There is no source with ID \'" + K + "\'")));\n                      return;\n                    }\n                    return de.loaded();\n                  }, D3.prototype.areTilesLoaded = function() {\n                    var K = this.style && this.style.sourceCaches;\n                    for (var de in K) {\n                      var ne = K[de], we = ne._tiles;\n                      for (var Ue in we) {\n                        var ft = we[Ue];\n                        if (!(ft.state === "loaded" || ft.state === "errored")) return false;\n                      }\n                    }\n                    return true;\n                  }, D3.prototype.addSourceType = function(K, de, ne) {\n                    return this._lazyInitEmptyStyle(), this.style.addSourceType(K, de, ne);\n                  }, D3.prototype.removeSource = function(K) {\n                    return this.style.removeSource(K), this._update(true);\n                  }, D3.prototype.getSource = function(K) {\n                    return this.style.getSource(K);\n                  }, D3.prototype.addImage = function(K, de, ne) {\n                    ne === void 0 && (ne = {});\n                    var we = ne.pixelRatio;\n                    we === void 0 && (we = 1);\n                    var Ue = ne.sdf;\n                    Ue === void 0 && (Ue = false);\n                    var ft = ne.stretchX, Xt = ne.stretchY, hr = ne.content;\n                    this._lazyInitEmptyStyle();\n                    var qt = 0;\n                    if (de instanceof Yr || Ri && de instanceof Ri) {\n                      var Ve = i3.browser.getImageData(de), Qe = Ve.width, at = Ve.height, Ct = Ve.data;\n                      this.style.addImage(K, { data: new i3.RGBAImage({ width: Qe, height: at }, Ct), pixelRatio: we, stretchX: ft, stretchY: Xt, content: hr, sdf: Ue, version: qt });\n                    } else {\n                      if (de.width === void 0 || de.height === void 0) return this.fire(new i3.ErrorEvent(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));\n                      var Ot = de.width, Rt = de.height, Bt = de.data, Dt = de;\n                      this.style.addImage(K, { data: new i3.RGBAImage({ width: Ot, height: Rt }, new Uint8Array(Bt)), pixelRatio: we, stretchX: ft, stretchY: Xt, content: hr, sdf: Ue, version: qt, userImage: Dt }), Dt.onAdd && Dt.onAdd(this, K);\n                    }\n                  }, D3.prototype.updateImage = function(K, de) {\n                    var ne = this.style.getImage(K);\n                    if (!ne) return this.fire(new i3.ErrorEvent(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));\n                    var we = de instanceof Yr || Ri && de instanceof Ri ? i3.browser.getImageData(de) : de, Ue = we.width, ft = we.height, Xt = we.data;\n                    if (Ue === void 0 || ft === void 0) return this.fire(new i3.ErrorEvent(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));\n                    if (Ue !== ne.data.width || ft !== ne.data.height) return this.fire(new i3.ErrorEvent(new Error("The width and height of the updated image must be that same as the previous version of the image")));\n                    var hr = !(de instanceof Yr || Ri && de instanceof Ri);\n                    ne.data.replace(Xt, hr), this.style.updateImage(K, ne);\n                  }, D3.prototype.hasImage = function(K) {\n                    return K ? !!this.style.getImage(K) : (this.fire(new i3.ErrorEvent(new Error("Missing required image id"))), false);\n                  }, D3.prototype.removeImage = function(K) {\n                    this.style.removeImage(K);\n                  }, D3.prototype.loadImage = function(K, de) {\n                    i3.getImage(this._requestManager.transformRequest(K, i3.ResourceType.Image), de);\n                  }, D3.prototype.listImages = function() {\n                    return this.style.listImages();\n                  }, D3.prototype.addLayer = function(K, de) {\n                    return this._lazyInitEmptyStyle(), this.style.addLayer(K, de), this._update(true);\n                  }, D3.prototype.moveLayer = function(K, de) {\n                    return this.style.moveLayer(K, de), this._update(true);\n                  }, D3.prototype.removeLayer = function(K) {\n                    return this.style.removeLayer(K), this._update(true);\n                  }, D3.prototype.getLayer = function(K) {\n                    return this.style.getLayer(K);\n                  }, D3.prototype.setLayerZoomRange = function(K, de, ne) {\n                    return this.style.setLayerZoomRange(K, de, ne), this._update(true);\n                  }, D3.prototype.setFilter = function(K, de, ne) {\n                    return ne === void 0 && (ne = {}), this.style.setFilter(K, de, ne), this._update(true);\n                  }, D3.prototype.getFilter = function(K) {\n                    return this.style.getFilter(K);\n                  }, D3.prototype.setPaintProperty = function(K, de, ne, we) {\n                    return we === void 0 && (we = {}), this.style.setPaintProperty(K, de, ne, we), this._update(true);\n                  }, D3.prototype.getPaintProperty = function(K, de) {\n                    return this.style.getPaintProperty(K, de);\n                  }, D3.prototype.setLayoutProperty = function(K, de, ne, we) {\n                    return we === void 0 && (we = {}), this.style.setLayoutProperty(K, de, ne, we), this._update(true);\n                  }, D3.prototype.getLayoutProperty = function(K, de) {\n                    return this.style.getLayoutProperty(K, de);\n                  }, D3.prototype.setLight = function(K, de) {\n                    return de === void 0 && (de = {}), this._lazyInitEmptyStyle(), this.style.setLight(K, de), this._update(true);\n                  }, D3.prototype.getLight = function() {\n                    return this.style.getLight();\n                  }, D3.prototype.setFeatureState = function(K, de) {\n                    return this.style.setFeatureState(K, de), this._update();\n                  }, D3.prototype.removeFeatureState = function(K, de) {\n                    return this.style.removeFeatureState(K, de), this._update();\n                  }, D3.prototype.getFeatureState = function(K) {\n                    return this.style.getFeatureState(K);\n                  }, D3.prototype.getContainer = function() {\n                    return this._container;\n                  }, D3.prototype.getCanvasContainer = function() {\n                    return this._canvasContainer;\n                  }, D3.prototype.getCanvas = function() {\n                    return this._canvas;\n                  }, D3.prototype._containerDimensions = function() {\n                    var K = 0, de = 0;\n                    return this._container && (K = this._container.clientWidth || 400, de = this._container.clientHeight || 300), [K, de];\n                  }, D3.prototype._detectMissingCSS = function() {\n                    var K = i3.window.getComputedStyle(this._missingCSSCanary).getPropertyValue("background-color");\n                    K !== "rgb(250, 128, 114)" && i3.warnOnce("This page appears to be missing CSS declarations for Mapbox GL JS, which may cause the map to display incorrectly. Please ensure your page includes mapbox-gl.css, as described in https://www.mapbox.com/mapbox-gl-js/api/.");\n                  }, D3.prototype._setupContainer = function() {\n                    var K = this._container;\n                    K.classList.add("mapboxgl-map");\n                    var de = this._missingCSSCanary = o4.create("div", "mapboxgl-canary", K);\n                    de.style.visibility = "hidden", this._detectMissingCSS();\n                    var ne = this._canvasContainer = o4.create("div", "mapboxgl-canvas-container", K);\n                    this._interactive && ne.classList.add("mapboxgl-interactive"), this._canvas = o4.create("canvas", "mapboxgl-canvas", ne), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", "0"), this._canvas.setAttribute("aria-label", "Map"), this._canvas.setAttribute("role", "region");\n                    var we = this._containerDimensions();\n                    this._resizeCanvas(we[0], we[1]);\n                    var Ue = this._controlContainer = o4.create("div", "mapboxgl-control-container", K), ft = this._controlPositions = {};\n                    ["top-left", "top-right", "bottom-left", "bottom-right"].forEach(function(Xt) {\n                      ft[Xt] = o4.create("div", "mapboxgl-ctrl-" + Xt, Ue);\n                    }), this._container.addEventListener("scroll", this._onMapScroll, false);\n                  }, D3.prototype._resizeCanvas = function(K, de) {\n                    var ne = i3.browser.devicePixelRatio || 1;\n                    this._canvas.width = ne * K, this._canvas.height = ne * de, this._canvas.style.width = K + "px", this._canvas.style.height = de + "px";\n                  }, D3.prototype._setupPainter = function() {\n                    var K = i3.extend({}, a4.webGLContextAttributes, { failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat, preserveDrawingBuffer: this._preserveDrawingBuffer, antialias: this._antialias || false }), de = this._canvas.getContext("webgl", K) || this._canvas.getContext("experimental-webgl", K);\n                    if (!de) {\n                      this.fire(new i3.ErrorEvent(new Error("Failed to initialize WebGL")));\n                      return;\n                    }\n                    this.painter = new mo(de, this.transform), i3.webpSupported.testSupport(de);\n                  }, D3.prototype._contextLost = function(K) {\n                    K.preventDefault(), this._frame && (this._frame.cancel(), this._frame = null), this.fire(new i3.Event("webglcontextlost", { originalEvent: K }));\n                  }, D3.prototype._contextRestored = function(K) {\n                    this._setupPainter(), this.resize(), this._update(), this.fire(new i3.Event("webglcontextrestored", { originalEvent: K }));\n                  }, D3.prototype._onMapScroll = function(K) {\n                    if (K.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;\n                  }, D3.prototype.loaded = function() {\n                    return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();\n                  }, D3.prototype._update = function(K) {\n                    return this.style ? (this._styleDirty = this._styleDirty || K, this._sourcesDirty = true, this.triggerRepaint(), this) : this;\n                  }, D3.prototype._requestRenderFrame = function(K) {\n                    return this._update(), this._renderTaskQueue.add(K);\n                  }, D3.prototype._cancelRenderFrame = function(K) {\n                    this._renderTaskQueue.remove(K);\n                  }, D3.prototype._render = function(K) {\n                    var de = this, ne, we = 0, Ue = this.painter.context.extTimerQuery;\n                    if (this.listens("gpu-timing-frame") && (ne = Ue.createQueryEXT(), Ue.beginQueryEXT(Ue.TIME_ELAPSED_EXT, ne), we = i3.browser.now()), this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(K), !this._removed) {\n                      var ft = false;\n                      if (this.style && this._styleDirty) {\n                        this._styleDirty = false;\n                        var Xt = this.transform.zoom, hr = i3.browser.now();\n                        this.style.zoomHistory.update(Xt, hr);\n                        var qt = new i3.EvaluationParameters(Xt, { now: hr, fadeDuration: this._fadeDuration, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), Ve = qt.crossFadingFactor();\n                        (Ve !== 1 || Ve !== this._crossFadingFactor) && (ft = true, this._crossFadingFactor = Ve), this.style.update(qt);\n                      }\n                      if (this.style && this._sourcesDirty && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, this._fadeDuration, this._crossSourceCollisions), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: this._fadeDuration, showPadding: this.showPadding, gpuTiming: !!this.listens("gpu-timing-layer") }), this.fire(new i3.Event("render")), this.loaded() && !this._loaded && (this._loaded = true, this.fire(new i3.Event("load"))), this.style && (this.style.hasTransitions() || ft) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles(), this.listens("gpu-timing-frame")) {\n                        var Qe = i3.browser.now() - we;\n                        Ue.endQueryEXT(Ue.TIME_ELAPSED_EXT, ne), setTimeout(function() {\n                          var Ot = Ue.getQueryObjectEXT(ne, Ue.QUERY_RESULT_EXT) / 1e6;\n                          Ue.deleteQueryEXT(ne), de.fire(new i3.Event("gpu-timing-frame", { cpuTime: Qe, gpuTime: Ot }));\n                        }, 50);\n                      }\n                      if (this.listens("gpu-timing-layer")) {\n                        var at = this.painter.collectGpuTimers();\n                        setTimeout(function() {\n                          var Ot = de.painter.queryGpuTimers(at);\n                          de.fire(new i3.Event("gpu-timing-layer", { layerTimes: Ot }));\n                        }, 50);\n                      }\n                      var Ct = this._sourcesDirty || this._styleDirty || this._placementDirty;\n                      return Ct || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new i3.Event("idle")), this._loaded && !this._fullyLoaded && !Ct && (this._fullyLoaded = true), this;\n                    }\n                  }, D3.prototype.remove = function() {\n                    this._hash && this._hash.remove();\n                    for (var K = 0, de = this._controls; K < de.length; K += 1) {\n                      var ne = de[K];\n                      ne.onRemove(this);\n                    }\n                    this._controls = [], this._frame && (this._frame.cancel(), this._frame = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), typeof i3.window != "undefined" && (i3.window.removeEventListener("resize", this._onWindowResize, false), i3.window.removeEventListener("orientationchange", this._onWindowResize, false), i3.window.removeEventListener("online", this._onWindowOnline, false));\n                    var we = this.painter.context.gl.getExtension("WEBGL_lose_context");\n                    we && we.loseContext && we.loseContext(), mn(this._canvasContainer), mn(this._controlContainer), mn(this._missingCSSCanary), this._container.classList.remove("mapboxgl-map"), this._removed = true, this.fire(new i3.Event("remove"));\n                  }, D3.prototype.triggerRepaint = function() {\n                    var K = this;\n                    this.style && !this._frame && (this._frame = i3.browser.frame(function(de) {\n                      K._frame = null, K._render(de);\n                    }));\n                  }, D3.prototype._onWindowOnline = function() {\n                    this._update();\n                  }, D3.prototype._onWindowResize = function(K) {\n                    this._trackResize && this.resize({ originalEvent: K })._update();\n                  }, J.showTileBoundaries.get = function() {\n                    return !!this._showTileBoundaries;\n                  }, J.showTileBoundaries.set = function(q2) {\n                    this._showTileBoundaries !== q2 && (this._showTileBoundaries = q2, this._update());\n                  }, J.showPadding.get = function() {\n                    return !!this._showPadding;\n                  }, J.showPadding.set = function(q2) {\n                    this._showPadding !== q2 && (this._showPadding = q2, this._update());\n                  }, J.showCollisionBoxes.get = function() {\n                    return !!this._showCollisionBoxes;\n                  }, J.showCollisionBoxes.set = function(q2) {\n                    this._showCollisionBoxes !== q2 && (this._showCollisionBoxes = q2, q2 ? this.style._generateCollisionBoxes() : this._update());\n                  }, J.showOverdrawInspector.get = function() {\n                    return !!this._showOverdrawInspector;\n                  }, J.showOverdrawInspector.set = function(q2) {\n                    this._showOverdrawInspector !== q2 && (this._showOverdrawInspector = q2, this._update());\n                  }, J.repaint.get = function() {\n                    return !!this._repaint;\n                  }, J.repaint.set = function(q2) {\n                    this._repaint !== q2 && (this._repaint = q2, this.triggerRepaint());\n                  }, J.vertices.get = function() {\n                    return !!this._vertices;\n                  }, J.vertices.set = function(q2) {\n                    this._vertices = q2, this._update();\n                  }, D3.prototype._setCacheLimits = function(K, de) {\n                    i3.setCacheLimits(K, de);\n                  }, J.version.get = function() {\n                    return i3.version;\n                  }, Object.defineProperties(D3.prototype, J), D3;\n                })(Hn);\n                function mn(Y) {\n                  Y.parentNode && Y.parentNode.removeChild(Y);\n                }\n                var Ji = { showCompass: true, showZoom: true, visualizePitch: false }, Vi = function(D3) {\n                  var J = this;\n                  this.options = i3.extend({}, Ji, D3), this._container = o4.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), this._container.addEventListener("contextmenu", function(q2) {\n                    return q2.preventDefault();\n                  }), this.options.showZoom && (i3.bindAll(["_setButtonTitle", "_updateZoomButtons"], this), this._zoomInButton = this._createButton("mapboxgl-ctrl-zoom-in", function(q2) {\n                    return J._map.zoomIn({}, { originalEvent: q2 });\n                  }), o4.create("span", "mapboxgl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", true), this._zoomOutButton = this._createButton("mapboxgl-ctrl-zoom-out", function(q2) {\n                    return J._map.zoomOut({}, { originalEvent: q2 });\n                  }), o4.create("span", "mapboxgl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", true)), this.options.showCompass && (i3.bindAll(["_rotateCompassArrow"], this), this._compass = this._createButton("mapboxgl-ctrl-compass", function(q2) {\n                    J.options.visualizePitch ? J._map.resetNorthPitch({}, { originalEvent: q2 }) : J._map.resetNorth({}, { originalEvent: q2 });\n                  }), this._compassIcon = o4.create("span", "mapboxgl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", true));\n                };\n                Vi.prototype._updateZoomButtons = function() {\n                  var D3 = this._map.getZoom(), J = D3 === this._map.getMaxZoom(), q2 = D3 === this._map.getMinZoom();\n                  this._zoomInButton.disabled = J, this._zoomOutButton.disabled = q2, this._zoomInButton.setAttribute("aria-disabled", J.toString()), this._zoomOutButton.setAttribute("aria-disabled", q2.toString());\n                }, Vi.prototype._rotateCompassArrow = function() {\n                  var D3 = this.options.visualizePitch ? "scale(" + 1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5) + ") rotateX(" + this._map.transform.pitch + "deg) rotateZ(" + this._map.transform.angle * (180 / Math.PI) + "deg)" : "rotate(" + this._map.transform.angle * (180 / Math.PI) + "deg)";\n                  this._compassIcon.style.transform = D3;\n                }, Vi.prototype.onAdd = function(D3) {\n                  return this._map = D3, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new Ni(this._map, this._compass, this.options.visualizePitch)), this._container;\n                }, Vi.prototype.onRemove = function() {\n                  o4.remove(this._container), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;\n                }, Vi.prototype._createButton = function(D3, J) {\n                  var q2 = o4.create("button", D3, this._container);\n                  return q2.type = "button", q2.addEventListener("click", J), q2;\n                }, Vi.prototype._setButtonTitle = function(D3, J) {\n                  var q2 = this._map._getUIString("NavigationControl." + J);\n                  D3.title = q2, D3.setAttribute("aria-label", q2);\n                };\n                var Ni = function(D3, J, q2) {\n                  q2 === void 0 && (q2 = false), this._clickTolerance = 10, this.element = J, this.mouseRotate = new Ln({ clickTolerance: D3.dragRotate._mouseRotate._clickTolerance }), this.map = D3, q2 && (this.mousePitch = new En({ clickTolerance: D3.dragRotate._mousePitch._clickTolerance })), i3.bindAll(["mousedown", "mousemove", "mouseup", "touchstart", "touchmove", "touchend", "reset"], this), o4.addEventListener(J, "mousedown", this.mousedown), o4.addEventListener(J, "touchstart", this.touchstart, { passive: false }), o4.addEventListener(J, "touchmove", this.touchmove), o4.addEventListener(J, "touchend", this.touchend), o4.addEventListener(J, "touchcancel", this.reset);\n                };\n                Ni.prototype.down = function(D3, J) {\n                  this.mouseRotate.mousedown(D3, J), this.mousePitch && this.mousePitch.mousedown(D3, J), o4.disableDrag();\n                }, Ni.prototype.move = function(D3, J) {\n                  var q2 = this.map, K = this.mouseRotate.mousemoveWindow(D3, J);\n                  if (K && K.bearingDelta && q2.setBearing(q2.getBearing() + K.bearingDelta), this.mousePitch) {\n                    var de = this.mousePitch.mousemoveWindow(D3, J);\n                    de && de.pitchDelta && q2.setPitch(q2.getPitch() + de.pitchDelta);\n                  }\n                }, Ni.prototype.off = function() {\n                  var D3 = this.element;\n                  o4.removeEventListener(D3, "mousedown", this.mousedown), o4.removeEventListener(D3, "touchstart", this.touchstart, { passive: false }), o4.removeEventListener(D3, "touchmove", this.touchmove), o4.removeEventListener(D3, "touchend", this.touchend), o4.removeEventListener(D3, "touchcancel", this.reset), this.offTemp();\n                }, Ni.prototype.offTemp = function() {\n                  o4.enableDrag(), o4.removeEventListener(i3.window, "mousemove", this.mousemove), o4.removeEventListener(i3.window, "mouseup", this.mouseup);\n                }, Ni.prototype.mousedown = function(D3) {\n                  this.down(i3.extend({}, D3, { ctrlKey: true, preventDefault: function() {\n                    return D3.preventDefault();\n                  } }), o4.mousePos(this.element, D3)), o4.addEventListener(i3.window, "mousemove", this.mousemove), o4.addEventListener(i3.window, "mouseup", this.mouseup);\n                }, Ni.prototype.mousemove = function(D3) {\n                  this.move(D3, o4.mousePos(this.element, D3));\n                }, Ni.prototype.mouseup = function(D3) {\n                  this.mouseRotate.mouseupWindow(D3), this.mousePitch && this.mousePitch.mouseupWindow(D3), this.offTemp();\n                }, Ni.prototype.touchstart = function(D3) {\n                  D3.targetTouches.length !== 1 ? this.reset() : (this._startPos = this._lastPos = o4.touchPos(this.element, D3.targetTouches)[0], this.down({ type: "mousedown", button: 0, ctrlKey: true, preventDefault: function() {\n                    return D3.preventDefault();\n                  } }, this._startPos));\n                }, Ni.prototype.touchmove = function(D3) {\n                  D3.targetTouches.length !== 1 ? this.reset() : (this._lastPos = o4.touchPos(this.element, D3.targetTouches)[0], this.move({ preventDefault: function() {\n                    return D3.preventDefault();\n                  } }, this._lastPos));\n                }, Ni.prototype.touchend = function(D3) {\n                  D3.targetTouches.length === 0 && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), this.reset();\n                }, Ni.prototype.reset = function() {\n                  this.mouseRotate.reset(), this.mousePitch && this.mousePitch.reset(), delete this._startPos, delete this._lastPos, this.offTemp();\n                };\n                function pn(Y, D3, J) {\n                  if (Y = new i3.LngLat(Y.lng, Y.lat), D3) {\n                    var q2 = new i3.LngLat(Y.lng - 360, Y.lat), K = new i3.LngLat(Y.lng + 360, Y.lat), de = J.locationPoint(Y).distSqr(D3);\n                    J.locationPoint(q2).distSqr(D3) < de ? Y = q2 : J.locationPoint(K).distSqr(D3) < de && (Y = K);\n                  }\n                  for (; Math.abs(Y.lng - J.center.lng) > 180; ) {\n                    var ne = J.locationPoint(Y);\n                    if (ne.x >= 0 && ne.y >= 0 && ne.x <= J.width && ne.y <= J.height) break;\n                    Y.lng > J.center.lng ? Y.lng -= 360 : Y.lng += 360;\n                  }\n                  return Y;\n                }\n                var Vn = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };\n                function na(Y, D3, J) {\n                  var q2 = Y.classList;\n                  for (var K in Vn) q2.remove("mapboxgl-" + J + "-anchor-" + K);\n                  q2.add("mapboxgl-" + J + "-anchor-" + D3);\n                }\n                var Ki = (function(Y) {\n                  function D3(J, q2) {\n                    if (Y.call(this), (J instanceof i3.window.HTMLElement || q2) && (J = i3.extend({ element: J }, q2)), i3.bindAll(["_update", "_onMove", "_onUp", "_addDragHandler", "_onMapClick", "_onKeyPress"], this), this._anchor = J && J.anchor || "center", this._color = J && J.color || "#3FB1CE", this._scale = J && J.scale || 1, this._draggable = J && J.draggable || false, this._clickTolerance = J && J.clickTolerance || 0, this._isDragging = false, this._state = "inactive", this._rotation = J && J.rotation || 0, this._rotationAlignment = J && J.rotationAlignment || "auto", this._pitchAlignment = J && J.pitchAlignment && J.pitchAlignment !== "auto" ? J.pitchAlignment : this._rotationAlignment, !J || !J.element) {\n                      this._defaultMarker = true, this._element = o4.create("div"), this._element.setAttribute("aria-label", "Map marker");\n                      var K = o4.createNS("http://www.w3.org/2000/svg", "svg"), de = 41, ne = 27;\n                      K.setAttributeNS(null, "display", "block"), K.setAttributeNS(null, "height", de + "px"), K.setAttributeNS(null, "width", ne + "px"), K.setAttributeNS(null, "viewBox", "0 0 " + ne + " " + de);\n                      var we = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      we.setAttributeNS(null, "stroke", "none"), we.setAttributeNS(null, "stroke-width", "1"), we.setAttributeNS(null, "fill", "none"), we.setAttributeNS(null, "fill-rule", "evenodd");\n                      var Ue = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      Ue.setAttributeNS(null, "fill-rule", "nonzero");\n                      var ft = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      ft.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), ft.setAttributeNS(null, "fill", "#000000");\n                      for (var Xt = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }], hr = 0, qt = Xt; hr < qt.length; hr += 1) {\n                        var Ve = qt[hr], Qe = o4.createNS("http://www.w3.org/2000/svg", "ellipse");\n                        Qe.setAttributeNS(null, "opacity", "0.04"), Qe.setAttributeNS(null, "cx", "10.5"), Qe.setAttributeNS(null, "cy", "5.80029008"), Qe.setAttributeNS(null, "rx", Ve.rx), Qe.setAttributeNS(null, "ry", Ve.ry), ft.appendChild(Qe);\n                      }\n                      var at = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      at.setAttributeNS(null, "fill", this._color);\n                      var Ct = o4.createNS("http://www.w3.org/2000/svg", "path");\n                      Ct.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), at.appendChild(Ct);\n                      var Ot = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      Ot.setAttributeNS(null, "opacity", "0.25"), Ot.setAttributeNS(null, "fill", "#000000");\n                      var Rt = o4.createNS("http://www.w3.org/2000/svg", "path");\n                      Rt.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), Ot.appendChild(Rt);\n                      var Bt = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      Bt.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), Bt.setAttributeNS(null, "fill", "#FFFFFF");\n                      var Dt = o4.createNS("http://www.w3.org/2000/svg", "g");\n                      Dt.setAttributeNS(null, "transform", "translate(8.0, 8.0)");\n                      var yt = o4.createNS("http://www.w3.org/2000/svg", "circle");\n                      yt.setAttributeNS(null, "fill", "#000000"), yt.setAttributeNS(null, "opacity", "0.25"), yt.setAttributeNS(null, "cx", "5.5"), yt.setAttributeNS(null, "cy", "5.5"), yt.setAttributeNS(null, "r", "5.4999962");\n                      var Pt = o4.createNS("http://www.w3.org/2000/svg", "circle");\n                      Pt.setAttributeNS(null, "fill", "#FFFFFF"), Pt.setAttributeNS(null, "cx", "5.5"), Pt.setAttributeNS(null, "cy", "5.5"), Pt.setAttributeNS(null, "r", "5.4999962"), Dt.appendChild(yt), Dt.appendChild(Pt), Ue.appendChild(ft), Ue.appendChild(at), Ue.appendChild(Ot), Ue.appendChild(Bt), Ue.appendChild(Dt), K.appendChild(Ue), K.setAttributeNS(null, "height", de * this._scale + "px"), K.setAttributeNS(null, "width", ne * this._scale + "px"), this._element.appendChild(K), this._offset = i3.Point.convert(J && J.offset || [0, -14]);\n                    } else this._element = J.element, this._offset = i3.Point.convert(J && J.offset || [0, 0]);\n                    this._element.classList.add("mapboxgl-marker"), this._element.addEventListener("dragstart", function(ht) {\n                      ht.preventDefault();\n                    }), this._element.addEventListener("mousedown", function(ht) {\n                      ht.preventDefault();\n                    }), na(this._element, this._anchor, "marker"), this._popup = null;\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.addTo = function(q2) {\n                    return this.remove(), this._map = q2, q2.getCanvasContainer().appendChild(this._element), q2.on("move", this._update), q2.on("moveend", this._update), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;\n                  }, D3.prototype.remove = function() {\n                    return this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), o4.remove(this._element), this._popup && this._popup.remove(), this;\n                  }, D3.prototype.getLngLat = function() {\n                    return this._lngLat;\n                  }, D3.prototype.setLngLat = function(q2) {\n                    return this._lngLat = i3.LngLat.convert(q2), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;\n                  }, D3.prototype.getElement = function() {\n                    return this._element;\n                  }, D3.prototype.setPopup = function(q2) {\n                    if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), q2) {\n                      if (!("offset" in q2.options)) {\n                        var K = 38.1, de = 13.5, ne = Math.sqrt(Math.pow(de, 2) / 2);\n                        q2.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -K], "bottom-left": [ne, (K - de + ne) * -1], "bottom-right": [-ne, (K - de + ne) * -1], left: [de, (K - de) * -1], right: [-de, (K - de) * -1] } : this._offset;\n                      }\n                      this._popup = q2, this._lngLat && this._popup.setLngLat(this._lngLat), this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);\n                    }\n                    return this;\n                  }, D3.prototype._onKeyPress = function(q2) {\n                    var K = q2.code, de = q2.charCode || q2.keyCode;\n                    (K === "Space" || K === "Enter" || de === 32 || de === 13) && this.togglePopup();\n                  }, D3.prototype._onMapClick = function(q2) {\n                    var K = q2.originalEvent.target, de = this._element;\n                    this._popup && (K === de || de.contains(K)) && this.togglePopup();\n                  }, D3.prototype.getPopup = function() {\n                    return this._popup;\n                  }, D3.prototype.togglePopup = function() {\n                    var q2 = this._popup;\n                    if (q2) q2.isOpen() ? q2.remove() : q2.addTo(this._map);\n                    else return this;\n                    return this;\n                  }, D3.prototype._update = function(q2) {\n                    if (this._map) {\n                      this._map.transform.renderWorldCopies && (this._lngLat = pn(this._lngLat, this._pos, this._map.transform)), this._pos = this._map.project(this._lngLat)._add(this._offset);\n                      var K = "";\n                      this._rotationAlignment === "viewport" || this._rotationAlignment === "auto" ? K = "rotateZ(" + this._rotation + "deg)" : this._rotationAlignment === "map" && (K = "rotateZ(" + (this._rotation - this._map.getBearing()) + "deg)");\n                      var de = "";\n                      this._pitchAlignment === "viewport" || this._pitchAlignment === "auto" ? de = "rotateX(0deg)" : this._pitchAlignment === "map" && (de = "rotateX(" + this._map.getPitch() + "deg)"), (!q2 || q2.type === "moveend") && (this._pos = this._pos.round()), o4.setTransform(this._element, Vn[this._anchor] + " translate(" + this._pos.x + "px, " + this._pos.y + "px) " + de + " " + K);\n                    }\n                  }, D3.prototype.getOffset = function() {\n                    return this._offset;\n                  }, D3.prototype.setOffset = function(q2) {\n                    return this._offset = i3.Point.convert(q2), this._update(), this;\n                  }, D3.prototype._onMove = function(q2) {\n                    if (!this._isDragging) {\n                      var K = this._clickTolerance || this._map._clickTolerance;\n                      this._isDragging = q2.point.dist(this._pointerdownPos) >= K;\n                    }\n                    this._isDragging && (this._pos = q2.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", this._state === "pending" && (this._state = "active", this.fire(new i3.Event("dragstart"))), this.fire(new i3.Event("drag")));\n                  }, D3.prototype._onUp = function() {\n                    this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), this._state === "active" && this.fire(new i3.Event("dragend")), this._state = "inactive";\n                  }, D3.prototype._addDragHandler = function(q2) {\n                    this._element.contains(q2.originalEvent.target) && (q2.preventDefault(), this._positionDelta = q2.point.sub(this._pos).add(this._offset), this._pointerdownPos = q2.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));\n                  }, D3.prototype.setDraggable = function(q2) {\n                    return this._draggable = !!q2, this._map && (q2 ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;\n                  }, D3.prototype.isDraggable = function() {\n                    return this._draggable;\n                  }, D3.prototype.setRotation = function(q2) {\n                    return this._rotation = q2 || 0, this._update(), this;\n                  }, D3.prototype.getRotation = function() {\n                    return this._rotation;\n                  }, D3.prototype.setRotationAlignment = function(q2) {\n                    return this._rotationAlignment = q2 || "auto", this._update(), this;\n                  }, D3.prototype.getRotationAlignment = function() {\n                    return this._rotationAlignment;\n                  }, D3.prototype.setPitchAlignment = function(q2) {\n                    return this._pitchAlignment = q2 && q2 !== "auto" ? q2 : this._rotationAlignment, this._update(), this;\n                  }, D3.prototype.getPitchAlignment = function() {\n                    return this._pitchAlignment;\n                  }, D3;\n                })(i3.Evented), kn = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true }, ta;\n                function oa(Y) {\n                  ta !== void 0 ? Y(ta) : i3.window.navigator.permissions !== void 0 ? i3.window.navigator.permissions.query({ name: "geolocation" }).then(function(D3) {\n                    ta = D3.state !== "denied", Y(ta);\n                  }) : (ta = !!i3.window.navigator.geolocation, Y(ta));\n                }\n                var ba = 0, is = false, Zs = (function(Y) {\n                  function D3(J) {\n                    Y.call(this), this.options = i3.extend({}, kn, J), i3.bindAll(["_onSuccess", "_onError", "_onZoom", "_finish", "_setupUI", "_updateCamera", "_updateMarker"], this);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.onAdd = function(q2) {\n                    return this._map = q2, this._container = o4.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), oa(this._setupUI), this._container;\n                  }, D3.prototype.onRemove = function() {\n                    this._geolocationWatchID !== void 0 && (i3.window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), o4.remove(this._container), this._map.off("zoom", this._onZoom), this._map = void 0, ba = 0, is = false;\n                  }, D3.prototype._isOutOfMapMaxBounds = function(q2) {\n                    var K = this._map.getMaxBounds(), de = q2.coords;\n                    return K && (de.longitude < K.getWest() || de.longitude > K.getEast() || de.latitude < K.getSouth() || de.latitude > K.getNorth());\n                  }, D3.prototype._setErrorState = function() {\n                    switch (this._watchState) {\n                      case "WAITING_ACTIVE":\n                        this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");\n                        break;\n                      case "ACTIVE_LOCK":\n                        this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");\n                        break;\n                      case "BACKGROUND":\n                        this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");\n                        break;\n                    }\n                  }, D3.prototype._onSuccess = function(q2) {\n                    if (this._map) {\n                      if (this._isOutOfMapMaxBounds(q2)) {\n                        this._setErrorState(), this.fire(new i3.Event("outofmaxbounds", q2)), this._updateMarker(), this._finish();\n                        return;\n                      }\n                      if (this.options.trackUserLocation) switch (this._lastKnownPosition = q2, this._watchState) {\n                        case "WAITING_ACTIVE":\n                        case "ACTIVE_LOCK":\n                        case "ACTIVE_ERROR":\n                          this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");\n                          break;\n                        case "BACKGROUND":\n                        case "BACKGROUND_ERROR":\n                          this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");\n                          break;\n                      }\n                      this.options.showUserLocation && this._watchState !== "OFF" && this._updateMarker(q2), (!this.options.trackUserLocation || this._watchState === "ACTIVE_LOCK") && this._updateCamera(q2), this.options.showUserLocation && this._dotElement.classList.remove("mapboxgl-user-location-dot-stale"), this.fire(new i3.Event("geolocate", q2)), this._finish();\n                    }\n                  }, D3.prototype._updateCamera = function(q2) {\n                    var K = new i3.LngLat(q2.coords.longitude, q2.coords.latitude), de = q2.coords.accuracy, ne = this._map.getBearing(), we = i3.extend({ bearing: ne }, this.options.fitBoundsOptions);\n                    this._map.fitBounds(K.toBounds(de), we, { geolocateSource: true });\n                  }, D3.prototype._updateMarker = function(q2) {\n                    if (q2) {\n                      var K = new i3.LngLat(q2.coords.longitude, q2.coords.latitude);\n                      this._accuracyCircleMarker.setLngLat(K).addTo(this._map), this._userLocationDotMarker.setLngLat(K).addTo(this._map), this._accuracy = q2.coords.accuracy, this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();\n                    } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();\n                  }, D3.prototype._updateCircleRadius = function() {\n                    var q2 = this._map._container.clientHeight / 2, K = this._map.unproject([0, q2]), de = this._map.unproject([1, q2]), ne = K.distanceTo(de), we = Math.ceil(2 * this._accuracy / ne);\n                    this._circleElement.style.width = we + "px", this._circleElement.style.height = we + "px";\n                  }, D3.prototype._onZoom = function() {\n                    this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();\n                  }, D3.prototype._onError = function(q2) {\n                    if (this._map) {\n                      if (this.options.trackUserLocation) if (q2.code === 1) {\n                        this._watchState = "OFF", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;\n                        var K = this._map._getUIString("GeolocateControl.LocationNotAvailable");\n                        this._geolocateButton.title = K, this._geolocateButton.setAttribute("aria-label", K), this._geolocationWatchID !== void 0 && this._clearWatch();\n                      } else {\n                        if (q2.code === 3 && is) return;\n                        this._setErrorState();\n                      }\n                      this._watchState !== "OFF" && this.options.showUserLocation && this._dotElement.classList.add("mapboxgl-user-location-dot-stale"), this.fire(new i3.Event("error", q2)), this._finish();\n                    }\n                  }, D3.prototype._finish = function() {\n                    this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;\n                  }, D3.prototype._setupUI = function(q2) {\n                    var K = this;\n                    if (this._container.addEventListener("contextmenu", function(we) {\n                      return we.preventDefault();\n                    }), this._geolocateButton = o4.create("button", "mapboxgl-ctrl-geolocate", this._container), o4.create("span", "mapboxgl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", true), this._geolocateButton.type = "button", q2 === false) {\n                      i3.warnOnce("Geolocation support is not available so the GeolocateControl will be disabled.");\n                      var de = this._map._getUIString("GeolocateControl.LocationNotAvailable");\n                      this._geolocateButton.disabled = true, this._geolocateButton.title = de, this._geolocateButton.setAttribute("aria-label", de);\n                    } else {\n                      var ne = this._map._getUIString("GeolocateControl.FindMyLocation");\n                      this._geolocateButton.title = ne, this._geolocateButton.setAttribute("aria-label", ne);\n                    }\n                    this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = o4.create("div", "mapboxgl-user-location-dot"), this._userLocationDotMarker = new Ki(this._dotElement), this._circleElement = o4.create("div", "mapboxgl-user-location-accuracy-circle"), this._accuracyCircleMarker = new Ki({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onZoom)), this._geolocateButton.addEventListener("click", this.trigger.bind(this)), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", function(we) {\n                      var Ue = we.originalEvent && we.originalEvent.type === "resize";\n                      !we.geolocateSource && K._watchState === "ACTIVE_LOCK" && !Ue && (K._watchState = "BACKGROUND", K._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background"), K._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), K.fire(new i3.Event("trackuserlocationend")));\n                    });\n                  }, D3.prototype.trigger = function() {\n                    if (!this._setup) return i3.warnOnce("Geolocate control triggered before added to a map"), false;\n                    if (this.options.trackUserLocation) {\n                      switch (this._watchState) {\n                        case "OFF":\n                          this._watchState = "WAITING_ACTIVE", this.fire(new i3.Event("trackuserlocationstart"));\n                          break;\n                        case "WAITING_ACTIVE":\n                        case "ACTIVE_LOCK":\n                        case "ACTIVE_ERROR":\n                        case "BACKGROUND_ERROR":\n                          ba--, is = false, this._watchState = "OFF", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"), this.fire(new i3.Event("trackuserlocationend"));\n                          break;\n                        case "BACKGROUND":\n                          this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new i3.Event("trackuserlocationstart"));\n                          break;\n                      }\n                      switch (this._watchState) {\n                        case "WAITING_ACTIVE":\n                          this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");\n                          break;\n                        case "ACTIVE_LOCK":\n                          this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");\n                          break;\n                        case "ACTIVE_ERROR":\n                          this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");\n                          break;\n                        case "BACKGROUND":\n                          this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");\n                          break;\n                        case "BACKGROUND_ERROR":\n                          this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error");\n                          break;\n                      }\n                      if (this._watchState === "OFF" && this._geolocationWatchID !== void 0) this._clearWatch();\n                      else if (this._geolocationWatchID === void 0) {\n                        this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), ba++;\n                        var q2;\n                        ba > 1 ? (q2 = { maximumAge: 6e5, timeout: 0 }, is = true) : (q2 = this.options.positionOptions, is = false), this._geolocationWatchID = i3.window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, q2);\n                      }\n                    } else i3.window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);\n                    return true;\n                  }, D3.prototype._clearWatch = function() {\n                    i3.window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);\n                  }, D3;\n                })(i3.Evented), Va = { maxWidth: 100, unit: "metric" }, Ml = function(D3) {\n                  this.options = i3.extend({}, Va, D3), i3.bindAll(["_onMove", "setUnit"], this);\n                };\n                Ml.prototype.getDefaultPosition = function() {\n                  return "bottom-left";\n                }, Ml.prototype._onMove = function() {\n                  zo(this._map, this._container, this.options);\n                }, Ml.prototype.onAdd = function(D3) {\n                  return this._map = D3, this._container = o4.create("div", "mapboxgl-ctrl mapboxgl-ctrl-scale", D3.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;\n                }, Ml.prototype.onRemove = function() {\n                  o4.remove(this._container), this._map.off("move", this._onMove), this._map = void 0;\n                }, Ml.prototype.setUnit = function(D3) {\n                  this.options.unit = D3, zo(this._map, this._container, this.options);\n                };\n                function zo(Y, D3, J) {\n                  var q2 = J && J.maxWidth || 100, K = Y._container.clientHeight / 2, de = Y.unproject([0, K]), ne = Y.unproject([q2, K]), we = de.distanceTo(ne);\n                  if (J && J.unit === "imperial") {\n                    var Ue = 3.2808 * we;\n                    if (Ue > 5280) {\n                      var ft = Ue / 5280;\n                      Qs(D3, q2, ft, Y._getUIString("ScaleControl.Miles"));\n                    } else Qs(D3, q2, Ue, Y._getUIString("ScaleControl.Feet"));\n                  } else if (J && J.unit === "nautical") {\n                    var Xt = we / 1852;\n                    Qs(D3, q2, Xt, Y._getUIString("ScaleControl.NauticalMiles"));\n                  } else we >= 1e3 ? Qs(D3, q2, we / 1e3, Y._getUIString("ScaleControl.Kilometers")) : Qs(D3, q2, we, Y._getUIString("ScaleControl.Meters"));\n                }\n                function Qs(Y, D3, J, q2) {\n                  var K = Vl(J), de = K / J;\n                  Y.style.width = D3 * de + "px", Y.innerHTML = K + "&nbsp;" + q2;\n                }\n                function al(Y) {\n                  var D3 = Math.pow(10, Math.ceil(-Math.log(Y) / Math.LN10));\n                  return Math.round(Y * D3) / D3;\n                }\n                function Vl(Y) {\n                  var D3 = Math.pow(10, ("" + Math.floor(Y)).length - 1), J = Y / D3;\n                  return J = J >= 10 ? 10 : J >= 5 ? 5 : J >= 3 ? 3 : J >= 2 ? 2 : J >= 1 ? 1 : al(J), D3 * J;\n                }\n                var ss = function(D3) {\n                  this._fullscreen = false, D3 && D3.container && (D3.container instanceof i3.window.HTMLElement ? this._container = D3.container : i3.warnOnce("Full screen control \'container\' must be a DOM element.")), i3.bindAll(["_onClickFullscreen", "_changeIcon"], this), "onfullscreenchange" in i3.window.document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in i3.window.document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in i3.window.document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in i3.window.document && (this._fullscreenchange = "MSFullscreenChange");\n                };\n                ss.prototype.onAdd = function(D3) {\n                  return this._map = D3, this._container || (this._container = this._map.getContainer()), this._controlContainer = o4.create("div", "mapboxgl-ctrl mapboxgl-ctrl-group"), this._checkFullscreenSupport() ? this._setupUI() : (this._controlContainer.style.display = "none", i3.warnOnce("This device does not support fullscreen mode.")), this._controlContainer;\n                }, ss.prototype.onRemove = function() {\n                  o4.remove(this._controlContainer), this._map = null, i3.window.document.removeEventListener(this._fullscreenchange, this._changeIcon);\n                }, ss.prototype._checkFullscreenSupport = function() {\n                  return !!(i3.window.document.fullscreenEnabled || i3.window.document.mozFullScreenEnabled || i3.window.document.msFullscreenEnabled || i3.window.document.webkitFullscreenEnabled);\n                }, ss.prototype._setupUI = function() {\n                  var D3 = this._fullscreenButton = o4.create("button", "mapboxgl-ctrl-fullscreen", this._controlContainer);\n                  o4.create("span", "mapboxgl-ctrl-icon", D3).setAttribute("aria-hidden", true), D3.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), i3.window.document.addEventListener(this._fullscreenchange, this._changeIcon);\n                }, ss.prototype._updateTitle = function() {\n                  var D3 = this._getTitle();\n                  this._fullscreenButton.setAttribute("aria-label", D3), this._fullscreenButton.title = D3;\n                }, ss.prototype._getTitle = function() {\n                  return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");\n                }, ss.prototype._isFullscreen = function() {\n                  return this._fullscreen;\n                }, ss.prototype._changeIcon = function() {\n                  var D3 = i3.window.document.fullscreenElement || i3.window.document.mozFullScreenElement || i3.window.document.webkitFullscreenElement || i3.window.document.msFullscreenElement;\n                  D3 === this._container !== this._fullscreen && (this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("mapboxgl-ctrl-shrink"), this._fullscreenButton.classList.toggle("mapboxgl-ctrl-fullscreen"), this._updateTitle());\n                }, ss.prototype._onClickFullscreen = function() {\n                  this._isFullscreen() ? i3.window.document.exitFullscreen ? i3.window.document.exitFullscreen() : i3.window.document.mozCancelFullScreen ? i3.window.document.mozCancelFullScreen() : i3.window.document.msExitFullscreen ? i3.window.document.msExitFullscreen() : i3.window.document.webkitCancelFullScreen && i3.window.document.webkitCancelFullScreen() : this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.mozRequestFullScreen ? this._container.mozRequestFullScreen() : this._container.msRequestFullscreen ? this._container.msRequestFullscreen() : this._container.webkitRequestFullscreen && this._container.webkitRequestFullscreen();\n                };\n                var Vs = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px" }, Ys = ["a[href]", "[tabindex]:not([tabindex=\'-1\'])", "[contenteditable]:not([contenteditable=\'false\'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", "), wa = (function(Y) {\n                  function D3(J) {\n                    Y.call(this), this.options = i3.extend(Object.create(Vs), J), i3.bindAll(["_update", "_onClose", "remove", "_onMouseMove", "_onMouseUp", "_onDrag"], this);\n                  }\n                  return Y && (D3.__proto__ = Y), D3.prototype = Object.create(Y && Y.prototype), D3.prototype.constructor = D3, D3.prototype.addTo = function(q2) {\n                    return this._map && this.remove(), this._map = q2, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._onMouseMove), this._map.on("mouseup", this._onMouseUp), this._container && this._container.classList.add("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.add("mapboxgl-track-pointer")) : this._map.on("move", this._update), this.fire(new i3.Event("open")), this;\n                  }, D3.prototype.isOpen = function() {\n                    return !!this._map;\n                  }, D3.prototype.remove = function() {\n                    return this._content && o4.remove(this._content), this._container && (o4.remove(this._container), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._onMouseMove), this._map.off("mouseup", this._onMouseUp), this._map.off("drag", this._onDrag), delete this._map), this.fire(new i3.Event("close")), this;\n                  }, D3.prototype.getLngLat = function() {\n                    return this._lngLat;\n                  }, D3.prototype.setLngLat = function(q2) {\n                    return this._lngLat = i3.LngLat.convert(q2), this._pos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._onMouseMove), this._container && this._container.classList.remove("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.remove("mapboxgl-track-pointer")), this;\n                  }, D3.prototype.trackPointer = function() {\n                    return this._trackPointer = true, this._pos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._onMouseMove), this._map.on("drag", this._onDrag), this._container && this._container.classList.add("mapboxgl-popup-track-pointer"), this._map._canvasContainer.classList.add("mapboxgl-track-pointer")), this;\n                  }, D3.prototype.getElement = function() {\n                    return this._container;\n                  }, D3.prototype.setText = function(q2) {\n                    return this.setDOMContent(i3.window.document.createTextNode(q2));\n                  }, D3.prototype.setHTML = function(q2) {\n                    var K = i3.window.document.createDocumentFragment(), de = i3.window.document.createElement("body"), ne;\n                    for (de.innerHTML = q2; ne = de.firstChild, !!ne; ) K.appendChild(ne);\n                    return this.setDOMContent(K);\n                  }, D3.prototype.getMaxWidth = function() {\n                    return this._container && this._container.style.maxWidth;\n                  }, D3.prototype.setMaxWidth = function(q2) {\n                    return this.options.maxWidth = q2, this._update(), this;\n                  }, D3.prototype.setDOMContent = function(q2) {\n                    if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);\n                    else this._content = o4.create("div", "mapboxgl-popup-content", this._container);\n                    return this._content.appendChild(q2), this._createCloseButton(), this._update(), this._focusFirstElement(), this;\n                  }, D3.prototype.addClassName = function(q2) {\n                    this._container && this._container.classList.add(q2);\n                  }, D3.prototype.removeClassName = function(q2) {\n                    this._container && this._container.classList.remove(q2);\n                  }, D3.prototype.setOffset = function(q2) {\n                    return this.options.offset = q2, this._update(), this;\n                  }, D3.prototype.toggleClassName = function(q2) {\n                    if (this._container) return this._container.classList.toggle(q2);\n                  }, D3.prototype._createCloseButton = function() {\n                    this.options.closeButton && (this._closeButton = o4.create("button", "mapboxgl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.setAttribute("aria-label", "Close popup"), this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));\n                  }, D3.prototype._onMouseUp = function(q2) {\n                    this._update(q2.point);\n                  }, D3.prototype._onMouseMove = function(q2) {\n                    this._update(q2.point);\n                  }, D3.prototype._onDrag = function(q2) {\n                    this._update(q2.point);\n                  }, D3.prototype._update = function(q2) {\n                    var K = this, de = this._lngLat || this._trackPointer;\n                    if (!(!this._map || !de || !this._content) && (this._container || (this._container = o4.create("div", "mapboxgl-popup", this._map.getContainer()), this._tip = o4.create("div", "mapboxgl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className && this.options.className.split(" ").forEach(function(Ve) {\n                      return K._container.classList.add(Ve);\n                    }), this._trackPointer && this._container.classList.add("mapboxgl-popup-track-pointer")), this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._map.transform.renderWorldCopies && !this._trackPointer && (this._lngLat = pn(this._lngLat, this._pos, this._map.transform)), !(this._trackPointer && !q2))) {\n                      var ne = this._pos = this._trackPointer && q2 ? q2 : this._map.project(this._lngLat), we = this.options.anchor, Ue = ol(this.options.offset);\n                      if (!we) {\n                        var ft = this._container.offsetWidth, Xt = this._container.offsetHeight, hr;\n                        ne.y + Ue.bottom.y < Xt ? hr = ["top"] : ne.y > this._map.transform.height - Xt ? hr = ["bottom"] : hr = [], ne.x < ft / 2 ? hr.push("left") : ne.x > this._map.transform.width - ft / 2 && hr.push("right"), hr.length === 0 ? we = "bottom" : we = hr.join("-");\n                      }\n                      var qt = ne.add(Ue[we]).round();\n                      o4.setTransform(this._container, Vn[we] + " translate(" + qt.x + "px," + qt.y + "px)"), na(this._container, we, "popup");\n                    }\n                  }, D3.prototype._focusFirstElement = function() {\n                    if (!(!this.options.focusAfterOpen || !this._container)) {\n                      var q2 = this._container.querySelector(Ys);\n                      q2 && q2.focus();\n                    }\n                  }, D3.prototype._onClose = function() {\n                    this.remove();\n                  }, D3;\n                })(i3.Evented);\n                function ol(Y) {\n                  if (Y) if (typeof Y == "number") {\n                    var D3 = Math.round(Math.sqrt(0.5 * Math.pow(Y, 2)));\n                    return { center: new i3.Point(0, 0), top: new i3.Point(0, Y), "top-left": new i3.Point(D3, D3), "top-right": new i3.Point(-D3, D3), bottom: new i3.Point(0, -Y), "bottom-left": new i3.Point(D3, -D3), "bottom-right": new i3.Point(-D3, -D3), left: new i3.Point(Y, 0), right: new i3.Point(-Y, 0) };\n                  } else if (Y instanceof i3.Point || Array.isArray(Y)) {\n                    var J = i3.Point.convert(Y);\n                    return { center: J, top: J, "top-left": J, "top-right": J, bottom: J, "bottom-left": J, "bottom-right": J, left: J, right: J };\n                  } else return { center: i3.Point.convert(Y.center || [0, 0]), top: i3.Point.convert(Y.top || [0, 0]), "top-left": i3.Point.convert(Y["top-left"] || [0, 0]), "top-right": i3.Point.convert(Y["top-right"] || [0, 0]), bottom: i3.Point.convert(Y.bottom || [0, 0]), "bottom-left": i3.Point.convert(Y["bottom-left"] || [0, 0]), "bottom-right": i3.Point.convert(Y["bottom-right"] || [0, 0]), left: i3.Point.convert(Y.left || [0, 0]), right: i3.Point.convert(Y.right || [0, 0]) };\n                  else return ol(new i3.Point(0, 0));\n                }\n                var io = { version: i3.version, supported: a4, setRTLTextPlugin: i3.setRTLTextPlugin, getRTLTextPluginStatus: i3.getRTLTextPluginStatus, Map: li, NavigationControl: Vi, GeolocateControl: Zs, AttributionControl: en, ScaleControl: Ml, FullscreenControl: ss, Popup: wa, Marker: Ki, Style: yu, LngLat: i3.LngLat, LngLatBounds: i3.LngLatBounds, Point: i3.Point, MercatorCoordinate: i3.MercatorCoordinate, Evented: i3.Evented, config: i3.config, prewarm: ua, clearPrewarmedResources: ma, get accessToken() {\n                  return i3.config.ACCESS_TOKEN;\n                }, set accessToken(Y) {\n                  i3.config.ACCESS_TOKEN = Y;\n                }, get baseApiUrl() {\n                  return i3.config.API_URL;\n                }, set baseApiUrl(Y) {\n                  i3.config.API_URL = Y;\n                }, get workerCount() {\n                  return fn.workerCount;\n                }, set workerCount(Y) {\n                  fn.workerCount = Y;\n                }, get maxParallelImageRequests() {\n                  return i3.config.MAX_PARALLEL_IMAGE_REQUESTS;\n                }, set maxParallelImageRequests(Y) {\n                  i3.config.MAX_PARALLEL_IMAGE_REQUESTS = Y;\n                }, clearStorage: function(D3) {\n                  i3.clearTileCache(D3);\n                }, workerUrl: "" };\n                return io;\n              }), r4;\n            });\n          });\n          var fGe = ye((_xr, cGe) => {\n            "use strict";\n            var iw = Dr(), Fjt = ru().sanitizeHTML, zjt = iJ(), sGe = c1();\n            function lGe(e3, t3) {\n              this.subplot = e3, this.uid = e3.uid + "-" + t3, this.index = t3, this.idSource = "source-" + this.uid, this.idLayer = sGe.layoutLayerPrefix + this.uid, this.sourceType = null, this.source = null, this.layerType = null, this.below = null, this.visible = false;\n            }\n            var ig = lGe.prototype;\n            ig.update = function(t3) {\n              this.visible ? this.needsNewImage(t3) ? this.updateImage(t3) : this.needsNewSource(t3) ? (this.removeLayer(), this.updateSource(t3), this.updateLayer(t3)) : this.needsNewLayer(t3) ? this.updateLayer(t3) : this.updateStyle(t3) : (this.updateSource(t3), this.updateLayer(t3)), this.visible = $z(t3);\n            };\n            ig.needsNewImage = function(e3) {\n              var t3 = this.subplot.map;\n              return t3.getSource(this.idSource) && this.sourceType === "image" && e3.sourcetype === "image" && (this.source !== e3.source || JSON.stringify(this.coordinates) !== JSON.stringify(e3.coordinates));\n            };\n            ig.needsNewSource = function(e3) {\n              return this.sourceType !== e3.sourcetype || JSON.stringify(this.source) !== JSON.stringify(e3.source) || this.layerType !== e3.type;\n            };\n            ig.needsNewLayer = function(e3) {\n              return this.layerType !== e3.type || this.below !== this.subplot.belowLookup["layout-" + this.index];\n            };\n            ig.lookupBelow = function() {\n              return this.subplot.belowLookup["layout-" + this.index];\n            };\n            ig.updateImage = function(e3) {\n              var t3 = this.subplot.map;\n              t3.getSource(this.idSource).updateImage({ url: e3.source, coordinates: e3.coordinates });\n              var r4 = this.findFollowingMapboxLayerId(this.lookupBelow());\n              r4 !== null && this.subplot.map.moveLayer(this.idLayer, r4);\n            };\n            ig.updateSource = function(e3) {\n              var t3 = this.subplot.map;\n              if (t3.getSource(this.idSource) && t3.removeSource(this.idSource), this.sourceType = e3.sourcetype, this.source = e3.source, !!$z(e3)) {\n                var r4 = Ojt(e3);\n                t3.addSource(this.idSource, r4);\n              }\n            };\n            ig.findFollowingMapboxLayerId = function(e3) {\n              if (e3 === "traces") for (var t3 = this.subplot.getMapLayers(), r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4].id;\n                if (typeof n4 == "string" && n4.indexOf(sGe.traceLayerPrefix) === 0) {\n                  e3 = n4;\n                  break;\n                }\n              }\n              return e3;\n            };\n            ig.updateLayer = function(e3) {\n              var t3 = this.subplot, r4 = uGe(e3), n4 = this.lookupBelow(), i3 = this.findFollowingMapboxLayerId(n4);\n              this.removeLayer(), $z(e3) && t3.addLayer({ id: this.idLayer, source: this.idSource, "source-layer": e3.sourcelayer || "", type: e3.type, minzoom: e3.minzoom, maxzoom: e3.maxzoom, layout: r4.layout, paint: r4.paint }, i3), this.layerType = e3.type, this.below = n4;\n            };\n            ig.updateStyle = function(e3) {\n              if ($z(e3)) {\n                var t3 = uGe(e3);\n                this.subplot.setOptions(this.idLayer, "setLayoutProperty", t3.layout), this.subplot.setOptions(this.idLayer, "setPaintProperty", t3.paint);\n              }\n            };\n            ig.removeLayer = function() {\n              var e3 = this.subplot.map;\n              e3.getLayer(this.idLayer) && e3.removeLayer(this.idLayer);\n            };\n            ig.dispose = function() {\n              var e3 = this.subplot.map;\n              e3.getLayer(this.idLayer) && e3.removeLayer(this.idLayer), e3.getSource(this.idSource) && e3.removeSource(this.idSource);\n            };\n            function $z(e3) {\n              if (!e3.visible) return false;\n              var t3 = e3.source;\n              if (Array.isArray(t3) && t3.length > 0) {\n                for (var r4 = 0; r4 < t3.length; r4++) if (typeof t3[r4] != "string" || t3[r4].length === 0) return false;\n                return true;\n              }\n              return iw.isPlainObject(t3) || typeof t3 == "string" && t3.length > 0;\n            }\n            function uGe(e3) {\n              var t3 = {}, r4 = {};\n              switch (e3.type) {\n                case "circle":\n                  iw.extendFlat(r4, { "circle-radius": e3.circle.radius, "circle-color": e3.color, "circle-opacity": e3.opacity });\n                  break;\n                case "line":\n                  iw.extendFlat(r4, { "line-width": e3.line.width, "line-color": e3.color, "line-opacity": e3.opacity, "line-dasharray": e3.line.dash });\n                  break;\n                case "fill":\n                  iw.extendFlat(r4, { "fill-color": e3.color, "fill-outline-color": e3.fill.outlinecolor, "fill-opacity": e3.opacity });\n                  break;\n                case "symbol":\n                  var n4 = e3.symbol, i3 = zjt(n4.textposition, n4.iconsize);\n                  iw.extendFlat(t3, { "icon-image": n4.icon + "-15", "icon-size": n4.iconsize / 10, "text-field": n4.text, "text-size": n4.textfont.size, "text-anchor": i3.anchor, "text-offset": i3.offset, "symbol-placement": n4.placement }), iw.extendFlat(r4, { "icon-color": e3.color, "text-color": n4.textfont.color, "text-opacity": e3.opacity });\n                  break;\n                case "raster":\n                  iw.extendFlat(r4, { "raster-fade-duration": 0, "raster-opacity": e3.opacity });\n                  break;\n              }\n              return { layout: t3, paint: r4 };\n            }\n            function Ojt(e3) {\n              var t3 = e3.sourcetype, r4 = e3.source, n4 = { type: t3 }, i3;\n              return t3 === "geojson" ? i3 = "data" : t3 === "vector" ? i3 = typeof r4 == "string" ? "url" : "tiles" : t3 === "raster" ? (i3 = "tiles", n4.tileSize = 256) : t3 === "image" && (i3 = "url", n4.coordinates = e3.coordinates), n4[i3] = r4, e3.sourceattribution && (n4.attribution = Fjt(e3.sourceattribution)), n4;\n            }\n            cGe.exports = function(t3, r4, n4) {\n              var i3 = new lGe(t3, r4);\n              return i3.update(n4), i3;\n            };\n          });\n          var xGe = ye((xxr, _Ge) => {\n            "use strict";\n            var cJ = uJ(), fJ = Dr(), pGe = ix(), hGe = qa(), qjt = ho(), Bjt = yv(), Qz = vf(), gGe = Eg(), Njt = gGe.drawMode, Ujt = gGe.selectMode, Vjt = Of().prepSelect, Gjt = Of().clearOutline, Hjt = Of().clearSelectionsCache, jjt = Of().selectOnClick, _x = c1(), Wjt = fGe();\n            function mGe(e3, t3) {\n              this.id = t3, this.gd = e3;\n              var r4 = e3._fullLayout, n4 = e3._context;\n              this.container = r4._glcontainer.node(), this.isStatic = n4.staticPlot, this.uid = r4._uid + "-" + this.id, this.div = null, this.xaxis = null, this.yaxis = null, this.createFramework(r4), this.map = null, this.accessToken = null, this.styleObj = null, this.traceHash = {}, this.layerList = [], this.belowLookup = {}, this.dragging = false, this.wheeling = false;\n            }\n            var Nh = mGe.prototype;\n            Nh.plot = function(e3, t3, r4) {\n              var n4 = this, i3 = t3[n4.id];\n              n4.map && i3.accesstoken !== n4.accessToken && (n4.map.remove(), n4.map = null, n4.styleObj = null, n4.traceHash = {}, n4.layerList = []);\n              var a4;\n              n4.map ? a4 = new Promise(function(o4, s3) {\n                n4.updateMap(e3, t3, o4, s3);\n              }) : a4 = new Promise(function(o4, s3) {\n                n4.createMap(e3, t3, o4, s3);\n              }), r4.push(a4);\n            };\n            Nh.createMap = function(e3, t3, r4, n4) {\n              var i3 = this, a4 = t3[i3.id], o4 = i3.styleObj = yGe(a4.style, t3);\n              i3.accessToken = a4.accesstoken;\n              var s3 = a4.bounds, l3 = s3 ? [[s3.west, s3.south], [s3.east, s3.north]] : null, u4 = i3.map = new cJ.Map({ container: i3.div, style: o4.style, center: hJ(a4.center), zoom: a4.zoom, bearing: a4.bearing, pitch: a4.pitch, maxBounds: l3, interactive: !i3.isStatic, preserveDrawingBuffer: i3.isStatic, doubleClickZoom: false, boxZoom: false, attributionControl: false }).addControl(new cJ.AttributionControl({ compact: true }));\n              u4._canvas.style.left = "0px", u4._canvas.style.top = "0px", i3.rejectOnError(n4), i3.isStatic || i3.initFx(e3, t3);\n              var c5 = [];\n              c5.push(new Promise(function(f4) {\n                u4.once("load", f4);\n              })), c5 = c5.concat(pGe.fetchTraceGeoData(e3)), Promise.all(c5).then(function() {\n                i3.fillBelowLookup(e3, t3), i3.updateData(e3), i3.updateLayout(t3), i3.resolveOnRender(r4);\n              }).catch(n4);\n            };\n            Nh.updateMap = function(e3, t3, r4, n4) {\n              var i3 = this, a4 = i3.map, o4 = t3[this.id];\n              i3.rejectOnError(n4);\n              var s3 = [], l3 = yGe(o4.style, t3);\n              JSON.stringify(i3.styleObj) !== JSON.stringify(l3) && (i3.styleObj = l3, a4.setStyle(l3.style), i3.traceHash = {}, s3.push(new Promise(function(u4) {\n                a4.once("styledata", u4);\n              }))), s3 = s3.concat(pGe.fetchTraceGeoData(e3)), Promise.all(s3).then(function() {\n                i3.fillBelowLookup(e3, t3), i3.updateData(e3), i3.updateLayout(t3), i3.resolveOnRender(r4);\n              }).catch(n4);\n            };\n            Nh.fillBelowLookup = function(e3, t3) {\n              var r4 = t3[this.id], n4 = r4.layers, i3, a4, o4 = this.belowLookup = {}, s3 = false;\n              for (i3 = 0; i3 < e3.length; i3++) {\n                var l3 = e3[i3][0].trace, u4 = l3._module;\n                typeof l3.below == "string" ? a4 = l3.below : u4.getBelow && (a4 = u4.getBelow(l3, this)), a4 === "" && (s3 = true), o4["trace-" + l3.uid] = a4 || "";\n              }\n              for (i3 = 0; i3 < n4.length; i3++) {\n                var c5 = n4[i3];\n                typeof c5.below == "string" ? a4 = c5.below : s3 ? a4 = "traces" : a4 = "", o4["layout-" + i3] = a4;\n              }\n              var f4 = {}, h3, d3;\n              for (h3 in o4) a4 = o4[h3], f4[a4] ? f4[a4].push(h3) : f4[a4] = [h3];\n              for (a4 in f4) {\n                var v3 = f4[a4];\n                if (v3.length > 1) for (i3 = 0; i3 < v3.length; i3++) h3 = v3[i3], h3.indexOf("trace-") === 0 ? (d3 = h3.split("trace-")[1], this.traceHash[d3] && (this.traceHash[d3].below = null)) : h3.indexOf("layout-") === 0 && (d3 = h3.split("layout-")[1], this.layerList[d3] && (this.layerList[d3].below = null));\n              }\n            };\n            var dGe = { choroplethmapbox: 0, densitymapbox: 1, scattermapbox: 2 };\n            Nh.updateData = function(e3) {\n              var t3 = this.traceHash, r4, n4, i3, a4, o4 = e3.slice().sort(function(f4, h3) {\n                return dGe[f4[0].trace.type] - dGe[h3[0].trace.type];\n              });\n              for (i3 = 0; i3 < o4.length; i3++) {\n                var s3 = o4[i3];\n                n4 = s3[0].trace, r4 = t3[n4.uid];\n                var l3 = false;\n                r4 && (r4.type === n4.type ? (r4.update(s3), l3 = true) : r4.dispose()), !l3 && n4._module && (t3[n4.uid] = n4._module.plot(this, s3));\n              }\n              var u4 = Object.keys(t3);\n              e: for (i3 = 0; i3 < u4.length; i3++) {\n                var c5 = u4[i3];\n                for (a4 = 0; a4 < e3.length; a4++) if (n4 = e3[a4][0].trace, c5 === n4.uid) continue e;\n                r4 = t3[c5], r4.dispose(), delete t3[c5];\n              }\n            };\n            Nh.updateLayout = function(e3) {\n              var t3 = this.map, r4 = e3[this.id];\n              !this.dragging && !this.wheeling && (t3.setCenter(hJ(r4.center)), t3.setZoom(r4.zoom), t3.setBearing(r4.bearing), t3.setPitch(r4.pitch)), this.updateLayers(e3), this.updateFramework(e3), this.updateFx(e3), this.map.resize(), this.gd._context._scrollZoom.mapbox ? t3.scrollZoom.enable() : t3.scrollZoom.disable();\n            };\n            Nh.resolveOnRender = function(e3) {\n              var t3 = this.map;\n              t3.on("render", function r4() {\n                t3.loaded() && (t3.off("render", r4), setTimeout(e3, 10));\n              });\n            };\n            Nh.rejectOnError = function(e3) {\n              var t3 = this.map;\n              function r4() {\n                e3(new Error(_x.mapOnErrorMsg));\n              }\n              t3.once("error", r4), t3.once("style.error", r4), t3.once("source.error", r4), t3.once("tile.error", r4), t3.once("layer.error", r4);\n            };\n            Nh.createFramework = function(e3) {\n              var t3 = this, r4 = t3.div = document.createElement("div");\n              r4.id = t3.uid, r4.style.position = "absolute", t3.container.appendChild(r4), t3.xaxis = { _id: "x", c2p: function(n4) {\n                return t3.project(n4).x;\n              } }, t3.yaxis = { _id: "y", c2p: function(n4) {\n                return t3.project(n4).y;\n              } }, t3.updateFramework(e3), t3.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, qjt.setConvert(t3.mockAxis, e3);\n            };\n            Nh.initFx = function(e3, t3) {\n              var r4 = this, n4 = r4.gd, i3 = r4.map;\n              i3.on("moveend", function(s3) {\n                if (r4.map) {\n                  var l3 = n4._fullLayout;\n                  if (s3.originalEvent || r4.wheeling) {\n                    var u4 = l3[r4.id];\n                    hGe.call("_storeDirectGUIEdit", n4.layout, l3._preGUI, r4.getViewEdits(u4));\n                    var c5 = r4.getView();\n                    u4._input.center = u4.center = c5.center, u4._input.zoom = u4.zoom = c5.zoom, u4._input.bearing = u4.bearing = c5.bearing, u4._input.pitch = u4.pitch = c5.pitch, n4.emit("plotly_relayout", r4.getViewEditsWithDerived(c5));\n                  }\n                  s3.originalEvent && s3.originalEvent.type === "mouseup" ? r4.dragging = false : r4.wheeling && (r4.wheeling = false), l3._rehover && l3._rehover();\n                }\n              }), i3.on("wheel", function() {\n                r4.wheeling = true;\n              }), i3.on("mousemove", function(s3) {\n                var l3 = r4.div.getBoundingClientRect(), u4 = [s3.originalEvent.offsetX, s3.originalEvent.offsetY];\n                s3.target.getBoundingClientRect = function() {\n                  return l3;\n                }, r4.xaxis.p2c = function() {\n                  return i3.unproject(u4).lng;\n                }, r4.yaxis.p2c = function() {\n                  return i3.unproject(u4).lat;\n                }, n4._fullLayout._rehover = function() {\n                  n4._fullLayout._hoversubplot === r4.id && n4._fullLayout[r4.id] && Qz.hover(n4, s3, r4.id);\n                }, Qz.hover(n4, s3, r4.id), n4._fullLayout._hoversubplot = r4.id;\n              });\n              function a4() {\n                Qz.loneUnhover(t3._hoverlayer);\n              }\n              i3.on("dragstart", function() {\n                r4.dragging = true, a4();\n              }), i3.on("zoomstart", a4), i3.on("mouseout", function() {\n                n4._fullLayout._hoversubplot = null;\n              });\n              function o4() {\n                var s3 = r4.getView();\n                n4.emit("plotly_relayouting", r4.getViewEditsWithDerived(s3));\n              }\n              i3.on("drag", o4), i3.on("zoom", o4), i3.on("dblclick", function() {\n                var s3 = n4._fullLayout[r4.id];\n                hGe.call("_storeDirectGUIEdit", n4.layout, n4._fullLayout._preGUI, r4.getViewEdits(s3));\n                var l3 = r4.viewInitial;\n                i3.setCenter(hJ(l3.center)), i3.setZoom(l3.zoom), i3.setBearing(l3.bearing), i3.setPitch(l3.pitch);\n                var u4 = r4.getView();\n                s3._input.center = s3.center = u4.center, s3._input.zoom = s3.zoom = u4.zoom, s3._input.bearing = s3.bearing = u4.bearing, s3._input.pitch = s3.pitch = u4.pitch, n4.emit("plotly_doubleclick", null), n4.emit("plotly_relayout", r4.getViewEditsWithDerived(u4));\n              }), r4.clearOutline = function() {\n                Hjt(r4.dragOptions), Gjt(r4.dragOptions.gd);\n              }, r4.onClickInPanFn = function(s3) {\n                return function(l3) {\n                  var u4 = n4._fullLayout.clickmode;\n                  u4.indexOf("select") > -1 && jjt(l3.originalEvent, n4, [r4.xaxis], [r4.yaxis], r4.id, s3), u4.indexOf("event") > -1 && Qz.click(n4, l3.originalEvent);\n                };\n              };\n            };\n            Nh.updateFx = function(e3) {\n              var t3 = this, r4 = t3.map, n4 = t3.gd;\n              if (t3.isStatic) return;\n              function i3(l3) {\n                var u4 = t3.map.unproject(l3);\n                return [u4.lng, u4.lat];\n              }\n              var a4 = e3.dragmode, o4;\n              o4 = function(l3, u4) {\n                if (u4.isRect) {\n                  var c5 = l3.range = {};\n                  c5[t3.id] = [i3([u4.xmin, u4.ymin]), i3([u4.xmax, u4.ymax])];\n                } else {\n                  var f4 = l3.lassoPoints = {};\n                  f4[t3.id] = u4.map(i3);\n                }\n              };\n              var s3 = t3.dragOptions;\n              t3.dragOptions = fJ.extendDeep(s3 || {}, { dragmode: e3.dragmode, element: t3.div, gd: n4, plotinfo: { id: t3.id, domain: e3[t3.id].domain, xaxis: t3.xaxis, yaxis: t3.yaxis, fillRangeItems: o4 }, xaxes: [t3.xaxis], yaxes: [t3.yaxis], subplot: t3.id }), r4.off("click", t3.onClickInPanHandler), Ujt(a4) || Njt(a4) ? (r4.dragPan.disable(), r4.on("zoomstart", t3.clearOutline), t3.dragOptions.prepFn = function(l3, u4, c5) {\n                Vjt(l3, u4, c5, t3.dragOptions, a4);\n              }, Bjt.init(t3.dragOptions)) : (r4.dragPan.enable(), r4.off("zoomstart", t3.clearOutline), t3.div.onmousedown = null, t3.div.ontouchstart = null, t3.div.removeEventListener("touchstart", t3.div._ontouchstart), t3.onClickInPanHandler = t3.onClickInPanFn(t3.dragOptions), r4.on("click", t3.onClickInPanHandler));\n            };\n            Nh.updateFramework = function(e3) {\n              var t3 = e3[this.id].domain, r4 = e3._size, n4 = this.div.style;\n              n4.width = r4.w * (t3.x[1] - t3.x[0]) + "px", n4.height = r4.h * (t3.y[1] - t3.y[0]) + "px", n4.left = r4.l + t3.x[0] * r4.w + "px", n4.top = r4.t + (1 - t3.y[1]) * r4.h + "px", this.xaxis._offset = r4.l + t3.x[0] * r4.w, this.xaxis._length = r4.w * (t3.x[1] - t3.x[0]), this.yaxis._offset = r4.t + (1 - t3.y[1]) * r4.h, this.yaxis._length = r4.h * (t3.y[1] - t3.y[0]);\n            };\n            Nh.updateLayers = function(e3) {\n              var t3 = e3[this.id], r4 = t3.layers, n4 = this.layerList, i3;\n              if (r4.length !== n4.length) {\n                for (i3 = 0; i3 < n4.length; i3++) n4[i3].dispose();\n                for (n4 = this.layerList = [], i3 = 0; i3 < r4.length; i3++) n4.push(Wjt(this, i3, r4[i3]));\n              } else for (i3 = 0; i3 < r4.length; i3++) n4[i3].update(r4[i3]);\n            };\n            Nh.destroy = function() {\n              this.map && (this.map.remove(), this.map = null, this.container.removeChild(this.div));\n            };\n            Nh.toImage = function() {\n              return this.map.stop(), this.map.getCanvas().toDataURL();\n            };\n            Nh.setOptions = function(e3, t3, r4) {\n              for (var n4 in r4) this.map[t3](e3, n4, r4[n4]);\n            };\n            Nh.getMapLayers = function() {\n              return this.map.getStyle().layers;\n            };\n            Nh.addLayer = function(e3, t3) {\n              var r4 = this.map;\n              if (typeof t3 == "string") {\n                if (t3 === "") {\n                  r4.addLayer(e3, t3);\n                  return;\n                }\n                for (var n4 = this.getMapLayers(), i3 = 0; i3 < n4.length; i3++) if (t3 === n4[i3].id) {\n                  r4.addLayer(e3, t3);\n                  return;\n                }\n                fJ.warn(["Trying to add layer with *below* value", t3, "referencing a layer that does not exist", "or that does not yet exist."].join(" "));\n              }\n              r4.addLayer(e3);\n            };\n            Nh.project = function(e3) {\n              return this.map.project(new cJ.LngLat(e3[0], e3[1]));\n            };\n            Nh.getView = function() {\n              var e3 = this.map, t3 = e3.getCenter(), r4 = t3.lng, n4 = t3.lat, i3 = { lon: r4, lat: n4 }, a4 = e3.getCanvas(), o4 = parseInt(a4.style.width), s3 = parseInt(a4.style.height);\n              return { center: i3, zoom: e3.getZoom(), bearing: e3.getBearing(), pitch: e3.getPitch(), _derived: { coordinates: [e3.unproject([0, 0]).toArray(), e3.unproject([o4, 0]).toArray(), e3.unproject([o4, s3]).toArray(), e3.unproject([0, s3]).toArray()] } };\n            };\n            Nh.getViewEdits = function(e3) {\n              for (var t3 = this.id, r4 = ["center", "zoom", "bearing", "pitch"], n4 = {}, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3];\n                n4[t3 + "." + a4] = e3[a4];\n              }\n              return n4;\n            };\n            Nh.getViewEditsWithDerived = function(e3) {\n              var t3 = this.id, r4 = this.getViewEdits(e3);\n              return r4[t3 + "._derived"] = e3._derived, r4;\n            };\n            function yGe(e3, t3) {\n              var r4 = {};\n              if (fJ.isPlainObject(e3)) r4.id = e3.id, r4.style = e3;\n              else if (typeof e3 == "string") if (r4.id = e3, _x.styleValuesMapbox.indexOf(e3) !== -1) r4.style = vGe(e3);\n              else if (_x.stylesNonMapbox[e3]) {\n                r4.style = _x.stylesNonMapbox[e3];\n                var n4 = r4.style.sources["plotly-" + e3], i3 = n4 ? n4.tiles : void 0;\n                i3 && i3[0] && i3[0].slice(-9) === "?api_key=" && (i3[0] += t3._mapboxAccessToken);\n              } else r4.style = e3;\n              else r4.id = _x.styleValueDflt, r4.style = vGe(_x.styleValueDflt);\n              return r4.transition = { duration: 0, delay: 0 }, r4;\n            }\n            function vGe(e3) {\n              return _x.styleUrlPrefix + e3 + "-" + _x.styleUrlSuffix;\n            }\n            function hJ(e3) {\n              return [e3.lon, e3.lat];\n            }\n            _Ge.exports = mGe;\n          });\n          var TGe = ye((bxr, wGe) => {\n            "use strict";\n            var dJ = Dr(), Xjt = k_(), Zjt = Yd(), bGe = Nk();\n            wGe.exports = function(t3, r4, n4) {\n              Xjt(t3, r4, n4, { type: "mapbox", attributes: bGe, handleDefaults: Yjt, partition: "y", accessToken: r4._mapboxAccessToken });\n            };\n            function Yjt(e3, t3, r4, n4) {\n              r4("accesstoken", n4.accessToken), r4("style"), r4("center.lon"), r4("center.lat"), r4("zoom"), r4("bearing"), r4("pitch");\n              var i3 = r4("bounds.west"), a4 = r4("bounds.east"), o4 = r4("bounds.south"), s3 = r4("bounds.north");\n              (i3 === void 0 || a4 === void 0 || o4 === void 0 || s3 === void 0) && delete t3.bounds, Zjt(e3, t3, { name: "layers", handleItemDefaults: Kjt }), t3._input = e3;\n            }\n            function Kjt(e3, t3) {\n              function r4(l3, u4) {\n                return dJ.coerce(e3, t3, bGe.layers, l3, u4);\n              }\n              var n4 = r4("visible");\n              if (n4) {\n                var i3 = r4("sourcetype"), a4 = i3 === "raster" || i3 === "image";\n                r4("source"), r4("sourceattribution"), i3 === "vector" && r4("sourcelayer"), i3 === "image" && r4("coordinates");\n                var o4;\n                a4 && (o4 = "raster");\n                var s3 = r4("type", o4);\n                a4 && s3 !== "raster" && (s3 = t3.type = "raster", dJ.log("Source types *raster* and *image* must drawn *raster* layer type.")), r4("below"), r4("color"), r4("opacity"), r4("minzoom"), r4("maxzoom"), s3 === "circle" && r4("circle.radius"), s3 === "line" && (r4("line.width"), r4("line.dash")), s3 === "fill" && r4("fill.outlinecolor"), s3 === "symbol" && (r4("symbol.icon"), r4("symbol.iconsize"), r4("symbol.text"), dJ.coerceFont(r4, "symbol.textfont", void 0, { noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }), r4("symbol.textposition"), r4("symbol.placement"));\n              }\n            }\n          });\n          var e7 = ye((Np) => {\n            "use strict";\n            var AGe = uJ(), rm = Dr(), vJ = rm.strTranslate, Jjt = rm.strScale, $jt = Id().getSubplotCalcData, Qjt = Wp(), eWt = Oa(), SGe = So(), tWt = ru(), rWt = xGe(), xx = "mapbox", ey = Np.constants = c1();\n            Np.name = xx;\n            Np.attr = "subplot";\n            Np.idRoot = xx;\n            Np.idRegex = Np.attrRegex = rm.counterRegex(xx);\n            var iWt = ["mapbox subplots and traces are deprecated!", "Please consider switching to `map` subplots and traces.", "Learn more at: https://plotly.com/python/maplibre-migration/", "as well as https://plotly.com/javascript/maplibre-migration/"].join(" ");\n            Np.attributes = { subplot: { valType: "subplotid", dflt: "mapbox", editType: "calc" } };\n            Np.layoutAttributes = Nk();\n            Np.supplyLayoutDefaults = TGe();\n            var MGe = true;\n            Np.plot = function(t3) {\n              MGe && (MGe = false, rm.warn(iWt));\n              var r4 = t3._fullLayout, n4 = t3.calcdata, i3 = r4._subplots[xx];\n              if (AGe.version !== ey.requiredVersion) throw new Error(ey.wrongVersionErrorMsg);\n              var a4 = nWt(t3, i3);\n              AGe.accessToken = a4;\n              for (var o4 = 0; o4 < i3.length; o4++) {\n                var s3 = i3[o4], l3 = $jt(n4, xx, s3), u4 = r4[s3], c5 = u4._subplot;\n                c5 || (c5 = new rWt(t3, s3), r4[s3]._subplot = c5), c5.viewInitial || (c5.viewInitial = { center: rm.extendFlat({}, u4.center), zoom: u4.zoom, bearing: u4.bearing, pitch: u4.pitch }), c5.plot(l3, r4, t3._promises);\n              }\n            };\n            Np.clean = function(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[xx] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                !t3[o4] && n4[o4]._subplot && n4[o4]._subplot.destroy();\n              }\n            };\n            Np.toSVG = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[xx], n4 = t3._size, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = t3[r4[i3]], o4 = a4.domain, s3 = a4._subplot, l3 = s3.toImage("png"), u4 = t3._glimages.append("svg:image");\n                u4.attr({ xmlns: Qjt.svg, "xlink:href": l3, x: n4.l + n4.w * o4.x[0], y: n4.t + n4.h * (1 - o4.y[1]), width: n4.w * (o4.x[1] - o4.x[0]), height: n4.h * (o4.y[1] - o4.y[0]), preserveAspectRatio: "none" });\n                var c5 = eWt.select(a4._subplot.div), f4 = c5.select(".mapboxgl-ctrl-logo").node().offsetParent === null;\n                if (!f4) {\n                  var h3 = t3._glimages.append("g");\n                  h3.attr("transform", vJ(n4.l + n4.w * o4.x[0] + 10, n4.t + n4.h * (1 - o4.y[0]) - 31)), h3.append("path").attr("d", ey.mapboxLogo.path0).style({ opacity: 0.9, fill: "#ffffff", "enable-background": "new" }), h3.append("path").attr("d", ey.mapboxLogo.path1).style("opacity", 0.35).style("enable-background", "new"), h3.append("path").attr("d", ey.mapboxLogo.path2).style("opacity", 0.35).style("enable-background", "new"), h3.append("polygon").attr("points", ey.mapboxLogo.polygon).style({ opacity: 0.9, fill: "#ffffff", "enable-background": "new" });\n                }\n                var d3 = c5.select(".mapboxgl-ctrl-attrib").text().replace("Improve this map", ""), v3 = t3._glimages.append("g"), _2 = v3.append("text");\n                _2.text(d3).classed("static-attribution", true).attr({ "font-size": 12, "font-family": "Arial", color: "rgba(0, 0, 0, 0.75)", "text-anchor": "end", "data-unformatted": d3 });\n                var b = SGe.bBox(_2.node()), p3 = n4.w * (o4.x[1] - o4.x[0]);\n                if (b.width > p3 / 2) {\n                  var k4 = d3.split("|").join("<br>");\n                  _2.text(k4).attr("data-unformatted", k4).call(tWt.convertToTspans, e3), b = SGe.bBox(_2.node());\n                }\n                _2.attr("transform", vJ(-3, -b.height + 8)), v3.insert("rect", ".static-attribution").attr({ x: -b.width - 6, y: -b.height - 3, width: b.width + 6, height: b.height + 3, fill: "rgba(255, 255, 255, 0.75)" });\n                var E3 = 1;\n                b.width + 6 > p3 && (E3 = p3 / (b.width + 6));\n                var S2 = [n4.l + n4.w * o4.x[1], n4.t + n4.h * (1 - o4.y[0])];\n                v3.attr("transform", vJ(S2[0], S2[1]) + Jjt(E3));\n              }\n            };\n            function nWt(e3, t3) {\n              var r4 = e3._fullLayout, n4 = e3._context;\n              if (n4.mapboxAccessToken === "") return "";\n              for (var i3 = [], a4 = [], o4 = false, s3 = false, l3 = 0; l3 < t3.length; l3++) {\n                var u4 = r4[t3[l3]], c5 = u4.accesstoken;\n                EGe(u4.style) && (c5 ? rm.pushUnique(i3, c5) : (EGe(u4._input.style) && (rm.error("Uses Mapbox map style, but did not set an access token."), o4 = true), s3 = true)), c5 && rm.pushUnique(a4, c5);\n              }\n              if (s3) {\n                var f4 = o4 ? ey.noAccessTokenErrorMsg : ey.missingStyleErrorMsg;\n                throw rm.error(f4), new Error(f4);\n              }\n              return i3.length ? (i3.length > 1 && rm.warn(ey.multipleTokensErrorMsg), i3[0]) : (a4.length && rm.log(["Listed mapbox access token(s)", a4.join(","), "but did not use a Mapbox map style, ignoring token(s)."].join(" ")), "");\n            }\n            function EGe(e3) {\n              return typeof e3 == "string" && (ey.styleValuesMapbox.indexOf(e3) !== -1 || e3.indexOf("mapbox://") === 0 || e3.indexOf("stamen") === 0);\n            }\n            Np.updateFx = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[xx], n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]]._subplot;\n                i3.updateFx(t3);\n              }\n            };\n          });\n          var CGe = ye((Axr, kGe) => {\n            "use strict";\n            var Txr = ["*scattermapbox* trace is deprecated!", "Please consider switching to the *scattermap* trace type and `map` subplots.", "Learn more at: https://plotly.com/python/maplibre-migration/", "as well as https://plotly.com/javascript/maplibre-migration/"].join(" ");\n            kGe.exports = { attributes: Wz(), supplyDefaults: NVe(), colorbar: $d(), formatLabels: rJ(), calc: pF(), plot: eGe(), hoverPoints: Jz().hoverPoints, eventData: nGe(), selectPoints: oGe(), styleOnSelect: function(e3, t3) {\n              if (t3) {\n                var r4 = t3[0].trace;\n                r4._glTrace.update(t3);\n              }\n            }, moduleType: "trace", name: "scattermapbox", basePlotModule: e7(), categories: ["mapbox", "gl", "symbols", "showLegend", "scatter-like"], meta: {} };\n          });\n          var PGe = ye((Sxr, LGe) => {\n            "use strict";\n            LGe.exports = CGe();\n          });\n          var pJ = ye((Mxr, IGe) => {\n            "use strict";\n            var f1 = t5(), aWt = Tu(), { hovertemplateAttrs: oWt, templatefallbackAttrs: sWt } = Ll(), lWt = Gl(), bx = Ao().extendFlat;\n            IGe.exports = bx({ locations: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, geojson: { valType: "any", editType: "calc" }, featureidkey: bx({}, f1.featureidkey, {}), below: { valType: "string", editType: "plot" }, text: f1.text, hovertext: f1.hovertext, marker: { line: { color: bx({}, f1.marker.line.color, { editType: "plot" }), width: bx({}, f1.marker.line.width, { editType: "plot" }), editType: "calc" }, opacity: bx({}, f1.marker.opacity, { editType: "plot" }), editType: "calc" }, selected: { marker: { opacity: bx({}, f1.selected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: bx({}, f1.unselected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, hoverinfo: f1.hoverinfo, hovertemplate: oWt({}, { keys: ["properties"] }), hovertemplatefallback: sWt(), showlegend: bx({}, lWt.showlegend, { dflt: false }) }, aWt("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var DGe = ye((Exr, RGe) => {\n            "use strict";\n            var Hk = Dr(), uWt = Qh(), cWt = pJ();\n            RGe.exports = function(t3, r4, n4, i3) {\n              function a4(c5, f4) {\n                return Hk.coerce(t3, r4, cWt, c5, f4);\n              }\n              var o4 = a4("locations"), s3 = a4("z"), l3 = a4("geojson");\n              if (!Hk.isArrayOrTypedArray(o4) || !o4.length || !Hk.isArrayOrTypedArray(s3) || !s3.length || !(typeof l3 == "string" && l3 !== "" || Hk.isPlainObject(l3))) {\n                r4.visible = false;\n                return;\n              }\n              a4("featureidkey"), r4._length = Math.min(o4.length, s3.length), a4("below"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var u4 = a4("marker.line.width");\n              u4 && a4("marker.line.color"), a4("marker.opacity"), uWt(t3, r4, i3, a4, { prefix: "", cLetter: "z" }), Hk.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var gJ = ye((kxr, OGe) => {\n            "use strict";\n            var fWt = Eo(), h1 = Dr(), hWt = tc(), dWt = So(), vWt = tx().makeBlank, FGe = ix();\n            function pWt(e3) {\n              var t3 = e3[0].trace, r4 = t3.visible === true && t3._length !== 0, n4 = { layout: { visibility: "none" }, paint: {} }, i3 = { layout: { visibility: "none" }, paint: {} }, a4 = t3._opts = { fill: n4, line: i3, geojson: vWt() };\n              if (!r4) return a4;\n              var o4 = FGe.extractTraceFeature(e3);\n              if (!o4) return a4;\n              var s3 = hWt.makeColorScaleFuncFromTrace(t3), l3 = t3.marker, u4 = l3.line || {}, c5;\n              h1.isArrayOrTypedArray(l3.opacity) && (c5 = function(k4) {\n                var E3 = k4.mo;\n                return fWt(E3) ? +h1.constrain(E3, 0, 1) : 0;\n              });\n              var f4;\n              h1.isArrayOrTypedArray(u4.color) && (f4 = function(k4) {\n                return k4.mlc;\n              });\n              var h3;\n              h1.isArrayOrTypedArray(u4.width) && (h3 = function(k4) {\n                return k4.mlw;\n              });\n              for (var d3 = 0; d3 < e3.length; d3++) {\n                var v3 = e3[d3], _2 = v3.fOut;\n                if (_2) {\n                  var b = _2.properties;\n                  b.fc = s3(v3.z), c5 && (b.mo = c5(v3)), f4 && (b.mlc = f4(v3)), h3 && (b.mlw = h3(v3)), v3.ct = b.ct, v3._polygons = FGe.feature2polygons(_2);\n                }\n              }\n              var p3 = c5 ? { type: "identity", property: "mo" } : l3.opacity;\n              return h1.extendFlat(n4.paint, { "fill-color": { type: "identity", property: "fc" }, "fill-opacity": p3 }), h1.extendFlat(i3.paint, { "line-color": f4 ? { type: "identity", property: "mlc" } : u4.color, "line-width": h3 ? { type: "identity", property: "mlw" } : u4.width, "line-opacity": p3 }), n4.layout.visibility = "visible", i3.layout.visibility = "visible", a4.geojson = { type: "FeatureCollection", features: o4 }, zGe(e3), a4;\n            }\n            function zGe(e3) {\n              var t3 = e3[0].trace, r4 = t3._opts, n4;\n              if (t3.selectedpoints) {\n                for (var i3 = dWt.makeSelectedPointStyleFns(t3), a4 = 0; a4 < e3.length; a4++) {\n                  var o4 = e3[a4];\n                  o4.fOut && (o4.fOut.properties.mo2 = i3.selectedOpacityFn(o4));\n                }\n                n4 = { type: "identity", property: "mo2" };\n              } else n4 = h1.isArrayOrTypedArray(t3.marker.opacity) ? { type: "identity", property: "mo" } : t3.marker.opacity;\n              return h1.extendFlat(r4.fill.paint, { "fill-opacity": n4 }), h1.extendFlat(r4.line.paint, { "line-opacity": n4 }), r4;\n            }\n            OGe.exports = { convert: pWt, convertOnSelect: zGe };\n          });\n          var VGe = ye((Cxr, UGe) => {\n            "use strict";\n            var BGe = gJ().convert, gWt = gJ().convertOnSelect, qGe = c1().traceLayerPrefix;\n            function NGe(e3, t3) {\n              this.type = "choroplethmapbox", this.subplot = e3, this.uid = t3, this.sourceId = "source-" + t3, this.layerList = [["fill", qGe + t3 + "-fill"], ["line", qGe + t3 + "-line"]], this.below = null;\n            }\n            var M5 = NGe.prototype;\n            M5.update = function(e3) {\n              this._update(BGe(e3)), e3[0].trace._glTrace = this;\n            };\n            M5.updateOnSelect = function(e3) {\n              this._update(gWt(e3));\n            };\n            M5._update = function(e3) {\n              var t3 = this.subplot, r4 = this.layerList, n4 = t3.belowLookup["trace-" + this.uid];\n              t3.map.getSource(this.sourceId).setData(e3.geojson), n4 !== this.below && (this._removeLayers(), this._addLayers(e3, n4), this.below = n4);\n              for (var i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3], o4 = a4[0], s3 = a4[1], l3 = e3[o4];\n                t3.setOptions(s3, "setLayoutProperty", l3.layout), l3.layout.visibility === "visible" && t3.setOptions(s3, "setPaintProperty", l3.paint);\n              }\n            };\n            M5._addLayers = function(e3, t3) {\n              for (var r4 = this.subplot, n4 = this.layerList, i3 = this.sourceId, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = o4[0], l3 = e3[s3];\n                r4.addLayer({ type: s3, id: o4[1], source: i3, layout: l3.layout, paint: l3.paint }, t3);\n              }\n            };\n            M5._removeLayers = function() {\n              for (var e3 = this.subplot.map, t3 = this.layerList, r4 = t3.length - 1; r4 >= 0; r4--) e3.removeLayer(t3[r4][1]);\n            };\n            M5.dispose = function() {\n              var e3 = this.subplot.map;\n              this._removeLayers(), e3.removeSource(this.sourceId);\n            };\n            UGe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = new NGe(t3, n4.uid), a4 = i3.sourceId, o4 = BGe(r4), s3 = i3.below = t3.belowLookup["trace-" + n4.uid];\n              return t3.map.addSource(a4, { type: "geojson", data: o4.geojson }), i3._addLayers(o4, s3), r4[0].trace._glTrace = i3, i3;\n            };\n          });\n          var HGe = ye((Pxr, GGe) => {\n            "use strict";\n            var Lxr = ["*choroplethmapbox* trace is deprecated!", "Please consider switching to the *choroplethmap* trace type and `map` subplots.", "Learn more at: https://plotly.com/python/maplibre-migration/", "as well as https://plotly.com/javascript/maplibre-migration/"].join(" ");\n            GGe.exports = { attributes: pJ(), supplyDefaults: DGe(), colorbar: S_(), calc: zF(), plot: VGe(), hoverPoints: qF(), eventData: BF(), selectPoints: NF(), styleOnSelect: function(e3, t3) {\n              if (t3) {\n                var r4 = t3[0].trace;\n                r4._glTrace.updateOnSelect(t3);\n              }\n            }, getBelow: function(e3, t3) {\n              for (var r4 = t3.getMapLayers(), n4 = r4.length - 2; n4 >= 0; n4--) {\n                var i3 = r4[n4].id;\n                if (typeof i3 == "string" && i3.indexOf("water") === 0) {\n                  for (var a4 = n4 + 1; a4 < r4.length; a4++) if (i3 = r4[a4].id, typeof i3 == "string" && i3.indexOf("plotly-") === -1) return i3;\n                }\n              }\n            }, moduleType: "trace", name: "choroplethmapbox", basePlotModule: e7(), categories: ["mapbox", "gl", "noOpacity", "showLegend"], meta: { hr_name: "choropleth_mapbox" } };\n          });\n          var WGe = ye((Ixr, jGe) => {\n            "use strict";\n            jGe.exports = HGe();\n          });\n          var yJ = ye((Rxr, ZGe) => {\n            "use strict";\n            var mWt = Tu(), { hovertemplateAttrs: yWt, templatefallbackAttrs: _Wt } = Ll(), XGe = Gl(), t7 = Wz(), mJ = Ao().extendFlat;\n            ZGe.exports = mJ({ lon: t7.lon, lat: t7.lat, z: { valType: "data_array", editType: "calc" }, radius: { valType: "number", editType: "plot", arrayOk: true, min: 1, dflt: 30 }, below: { valType: "string", editType: "plot" }, text: t7.text, hovertext: t7.hovertext, hoverinfo: mJ({}, XGe.hoverinfo, { flags: ["lon", "lat", "z", "text", "name"] }), hovertemplate: yWt(), hovertemplatefallback: _Wt(), showlegend: mJ({}, XGe.showlegend, { dflt: false }) }, mWt("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var KGe = ye((Dxr, YGe) => {\n            "use strict";\n            var xWt = Dr(), bWt = Qh(), wWt = yJ();\n            YGe.exports = function(t3, r4, n4, i3) {\n              function a4(u4, c5) {\n                return xWt.coerce(t3, r4, wWt, u4, c5);\n              }\n              var o4 = a4("lon") || [], s3 = a4("lat") || [], l3 = Math.min(o4.length, s3.length);\n              if (!l3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = l3, a4("z"), a4("radius"), a4("below"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), bWt(t3, r4, i3, a4, { prefix: "", cLetter: "z" });\n            };\n          });\n          var QGe = ye((Fxr, $Ge) => {\n            "use strict";\n            var _J = Eo(), TWt = Dr().isArrayOrTypedArray, xJ = fs().BADNUM, AWt = gv(), JGe = Dr()._;\n            $Ge.exports = function(t3, r4) {\n              for (var n4 = r4._length, i3 = new Array(n4), a4 = r4.z, o4 = TWt(a4) && a4.length, s3 = 0; s3 < n4; s3++) {\n                var l3 = i3[s3] = {}, u4 = r4.lon[s3], c5 = r4.lat[s3];\n                if (l3.lonlat = _J(u4) && _J(c5) ? [+u4, +c5] : [xJ, xJ], o4) {\n                  var f4 = a4[s3];\n                  l3.z = _J(f4) ? f4 : xJ;\n                }\n              }\n              return AWt(t3, r4, { vals: o4 ? a4 : [0, 1], containerStr: "", cLetter: "z" }), n4 && (i3[0].t = { labels: { lat: JGe(t3, "lat:") + " ", lon: JGe(t3, "lon:") + " " } }), i3;\n            };\n          });\n          var nHe = ye((zxr, iHe) => {\n            "use strict";\n            var SWt = Eo(), bJ = Dr(), eHe = ka(), tHe = tc(), rHe = fs().BADNUM, MWt = tx().makeBlank;\n            iHe.exports = function(t3) {\n              var r4 = t3[0].trace, n4 = r4.visible === true && r4._length !== 0, i3 = { layout: { visibility: "none" }, paint: {} }, a4 = r4._opts = { heatmap: i3, geojson: MWt() };\n              if (!n4) return a4;\n              var o4 = [], s3, l3 = r4.z, u4 = r4.radius, c5 = bJ.isArrayOrTypedArray(l3) && l3.length, f4 = bJ.isArrayOrTypedArray(u4);\n              for (s3 = 0; s3 < t3.length; s3++) {\n                var h3 = t3[s3], d3 = h3.lonlat;\n                if (d3[0] !== rHe) {\n                  var v3 = {};\n                  if (c5) {\n                    var _2 = h3.z;\n                    v3.z = _2 !== rHe ? _2 : 0;\n                  }\n                  f4 && (v3.r = SWt(u4[s3]) && u4[s3] > 0 ? +u4[s3] : 0), o4.push({ type: "Feature", geometry: { type: "Point", coordinates: d3 }, properties: v3 });\n                }\n              }\n              var b = tHe.extractOpts(r4), p3 = b.reversescale ? tHe.flipScale(b.colorscale) : b.colorscale, k4 = p3[0][1], E3 = eHe.opacity(k4) < 1 ? k4 : eHe.addOpacity(k4, 0), S2 = ["interpolate", ["linear"], ["heatmap-density"], 0, E3];\n              for (s3 = 1; s3 < p3.length; s3++) S2.push(p3[s3][0], p3[s3][1]);\n              var L3 = ["interpolate", ["linear"], ["get", "z"], b.min, 0, b.max, 1];\n              return bJ.extendFlat(a4.heatmap.paint, { "heatmap-weight": c5 ? L3 : 1 / (b.max - b.min), "heatmap-color": S2, "heatmap-radius": f4 ? { type: "identity", property: "r" } : r4.radius, "heatmap-opacity": r4.opacity }), a4.geojson = { type: "FeatureCollection", features: o4 }, a4.heatmap.layout.visibility = "visible", a4;\n            };\n          });\n          var lHe = ye((Oxr, sHe) => {\n            "use strict";\n            var aHe = nHe(), EWt = c1().traceLayerPrefix;\n            function oHe(e3, t3) {\n              this.type = "densitymapbox", this.subplot = e3, this.uid = t3, this.sourceId = "source-" + t3, this.layerList = [["heatmap", EWt + t3 + "-heatmap"]], this.below = null;\n            }\n            var r7 = oHe.prototype;\n            r7.update = function(e3) {\n              var t3 = this.subplot, r4 = this.layerList, n4 = aHe(e3), i3 = t3.belowLookup["trace-" + this.uid];\n              t3.map.getSource(this.sourceId).setData(n4.geojson), i3 !== this.below && (this._removeLayers(), this._addLayers(n4, i3), this.below = i3);\n              for (var a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4], s3 = o4[0], l3 = o4[1], u4 = n4[s3];\n                t3.setOptions(l3, "setLayoutProperty", u4.layout), u4.layout.visibility === "visible" && t3.setOptions(l3, "setPaintProperty", u4.paint);\n              }\n            };\n            r7._addLayers = function(e3, t3) {\n              for (var r4 = this.subplot, n4 = this.layerList, i3 = this.sourceId, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = o4[0], l3 = e3[s3];\n                r4.addLayer({ type: s3, id: o4[1], source: i3, layout: l3.layout, paint: l3.paint }, t3);\n              }\n            };\n            r7._removeLayers = function() {\n              for (var e3 = this.subplot.map, t3 = this.layerList, r4 = t3.length - 1; r4 >= 0; r4--) e3.removeLayer(t3[r4][1]);\n            };\n            r7.dispose = function() {\n              var e3 = this.subplot.map;\n              this._removeLayers(), e3.removeSource(this.sourceId);\n            };\n            sHe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = new oHe(t3, n4.uid), a4 = i3.sourceId, o4 = aHe(r4), s3 = i3.below = t3.belowLookup["trace-" + n4.uid];\n              return t3.map.addSource(a4, { type: "geojson", data: o4.geojson }), i3._addLayers(o4, s3), i3;\n            };\n          });\n          var cHe = ye((qxr, uHe) => {\n            "use strict";\n            var kWt = ho(), CWt = Jz().hoverPoints, LWt = Jz().getExtraText;\n            uHe.exports = function(t3, r4, n4) {\n              var i3 = CWt(t3, r4, n4);\n              if (i3) {\n                var a4 = i3[0], o4 = a4.cd, s3 = o4[0].trace, l3 = o4[a4.index];\n                if (delete a4.color, "z" in l3) {\n                  var u4 = a4.subplot.mockAxis;\n                  a4.z = l3.z, a4.zLabel = kWt.tickText(u4, u4.c2l(l3.z), "hover").text;\n                }\n                return a4.extraText = LWt(s3, l3, o4[0].t.labels), [a4];\n              }\n            };\n          });\n          var hHe = ye((Bxr, fHe) => {\n            "use strict";\n            fHe.exports = function(t3, r4) {\n              return t3.lon = r4.lon, t3.lat = r4.lat, t3.z = r4.z, t3;\n            };\n          });\n          var vHe = ye((Uxr, dHe) => {\n            "use strict";\n            var Nxr = ["*densitymapbox* trace is deprecated!", "Please consider switching to the *densitymap* trace type and `map` subplots.", "Learn more at: https://plotly.com/python/maplibre-migration/", "as well as https://plotly.com/javascript/maplibre-migration/"].join(" ");\n            dHe.exports = { attributes: yJ(), supplyDefaults: KGe(), colorbar: S_(), formatLabels: rJ(), calc: QGe(), plot: lHe(), hoverPoints: cHe(), eventData: hHe(), getBelow: function(e3, t3) {\n              for (var r4 = t3.getMapLayers(), n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3.id;\n                if (i3.type === "symbol" && typeof a4 == "string" && a4.indexOf("plotly-") === -1) return a4;\n              }\n            }, moduleType: "trace", name: "densitymapbox", basePlotModule: e7(), categories: ["mapbox", "gl", "showLegend"], meta: { hr_name: "density_mapbox" } };\n          });\n          var gHe = ye((Vxr, pHe) => {\n            "use strict";\n            pHe.exports = vHe();\n          });\n          var yHe = ye((Gxr, mHe) => {\n            mHe.exports = { version: 8, name: "orto", metadata: { "maputnik:renderer": "mlgljs" }, center: [1.537786, 41.837539], zoom: 12, bearing: 0, pitch: 0, light: { anchor: "viewport", color: "white", intensity: 0.4, position: [1.15, 45, 30] }, sources: { ortoEsri: { type: "raster", tiles: ["https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"], tileSize: 256, maxzoom: 18, attribution: "ESRI &copy; <a href=\'http://www.esri.com\'>ESRI</a>" }, ortoInstaMaps: { type: "raster", tiles: ["https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"], tileSize: 256, maxzoom: 13 }, ortoICGC: { type: "raster", tiles: ["https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"], tileSize: 256, minzoom: 13.1, maxzoom: 20 }, openmaptiles: { type: "vector", url: "https://geoserveis.icgc.cat/contextmaps/basemap.json" } }, sprite: "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1", glyphs: "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf", layers: [{ id: "background", type: "background", paint: { "background-color": "#F4F9F4" } }, { id: "ortoEsri", type: "raster", source: "ortoEsri", maxzoom: 16, layout: { visibility: "visible" } }, { id: "ortoICGC", type: "raster", source: "ortoICGC", minzoom: 13.1, maxzoom: 19, layout: { visibility: "visible" } }, { id: "ortoInstaMaps", type: "raster", source: "ortoInstaMaps", maxzoom: 13, layout: { visibility: "visible" } }, { id: "waterway_tunnel", type: "line", source: "openmaptiles", "source-layer": "waterway", minzoom: 14, filter: ["all", ["in", "class", "river", "stream", "canal"], ["==", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 6]] }, "line-dasharray": [2, 4] } }, { id: "waterway-other", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["!in", "class", "canal", "river", "stream"], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 2]] } } }, { id: "waterway-stream-canal", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["all", ["in", "class", "canal", "stream"], ["!=", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.3, stops: [[13, 0.5], [20, 6]] } } }, { id: "waterway-river", type: "line", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "waterway", filter: ["all", ["==", "class", "river"], ["!=", "brunnel", "tunnel"]], layout: { "line-cap": "round" }, paint: { "line-color": "#a0c8f0", "line-width": { base: 1.2, stops: [[10, 0.8], [20, 4]] }, "line-opacity": 0.5 } }, { id: "water-offset", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", maxzoom: 8, filter: ["==", "$type", "Polygon"], layout: { visibility: "visible" }, paint: { "fill-opacity": 0, "fill-color": "#a0c8f0", "fill-translate": { base: 1, stops: [[6, [2, 0]], [8, [0, 0]]] } } }, { id: "water", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", layout: { visibility: "visible" }, paint: { "fill-color": "hsl(210, 67%, 85%)", "fill-opacity": 0 } }, { id: "water-pattern", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "water", layout: { visibility: "visible" }, paint: { "fill-translate": [0, 2.5], "fill-pattern": "wave", "fill-opacity": 1 } }, { id: "landcover-ice-shelf", type: "fill", metadata: { "mapbox:group": "1444849382550.77" }, source: "openmaptiles", "source-layer": "landcover", filter: ["==", "subclass", "ice_shelf"], layout: { visibility: "visible" }, paint: { "fill-color": "#fff", "fill-opacity": { base: 1, stops: [[0, 0.9], [10, 0.3]] } } }, { id: "tunnel-service-track-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "service", "track"]], layout: { "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-dasharray": [0.5, 0.25], "line-width": { base: 1.2, stops: [[15, 1], [16, 4], [20, 11]] } } }, { id: "tunnel-minor-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor"]], layout: { "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-opacity": { stops: [[12, 0], [12.5, 1]] }, "line-width": { base: 1.2, stops: [[12, 0.5], [13, 1], [14, 4], [20, 15]] } } }, { id: "tunnel-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 17]] } } }, { id: "tunnel-trunk-primary-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.7 } }, { id: "tunnel-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "motorway"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-dasharray": [0.5, 0.25], "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.5 } }, { id: "tunnel-path", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "tunnel"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-dasharray": [1.5, 0.75], "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] } } }, { id: "tunnel-service-track", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "service", "track"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff", "line-width": { base: 1.2, stops: [[15.5, 0], [16, 2], [20, 7.5]] } } }, { id: "tunnel-minor", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor_road"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff", "line-opacity": 1, "line-width": { base: 1.2, stops: [[13.5, 0], [14, 2.5], [20, 11.5]] } } }, { id: "tunnel-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff4c6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 10]] } } }, { id: "tunnel-trunk-primary", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#fff4c6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "tunnel-motorway", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "motorway"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "#ffdaa6", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "tunnel-railway", type: "line", metadata: { "mapbox:group": "1444849354174.1904" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "tunnel"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] }, "line-dasharray": [2, 2] } }, { id: "ferry", type: "line", source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["in", "class", "ferry"]], layout: { "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(108, 159, 182, 1)", "line-width": 1.1, "line-dasharray": [2, 2] } }, { id: "aeroway-taxiway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 12, filter: ["all", ["in", "class", "taxiway"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(153, 153, 153, 1)", "line-width": { base: 1.5, stops: [[11, 2], [17, 12]] }, "line-opacity": 1 } }, { id: "aeroway-runway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 12, filter: ["all", ["in", "class", "runway"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(153, 153, 153, 1)", "line-width": { base: 1.5, stops: [[11, 5], [17, 55]] }, "line-opacity": 1 } }, { id: "aeroway-taxiway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 4, filter: ["all", ["in", "class", "taxiway"], ["==", "$type", "LineString"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(255, 255, 255, 1)", "line-width": { base: 1.5, stops: [[11, 1], [17, 10]] }, "line-opacity": { base: 1, stops: [[11, 0], [12, 1]] } } }, { id: "aeroway-runway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "aeroway", minzoom: 4, filter: ["all", ["in", "class", "runway"], ["==", "$type", "LineString"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "rgba(255, 255, 255, 1)", "line-width": { base: 1.5, stops: [[11, 4], [17, 50]] }, "line-opacity": { base: 1, stops: [[11, 0], [12, 1]] } } }, { id: "highway-motorway-link-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 12, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway_link"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "highway-link-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "highway-minor-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!=", "brunnel", "tunnel"], ["in", "class", "minor", "service", "track"]]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#cfcdca", "line-opacity": { stops: [[12, 0], [12.5, 0]] }, "line-width": { base: 1.2, stops: [[12, 0.5], [13, 1], [14, 4], [20, 15]] } } }, { id: "highway-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": 0.5, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 17]] } } }, { id: "highway-primary-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": { stops: [[7, 0], [8, 0.6]] }, "line-width": { base: 1.2, stops: [[7, 0], [8, 0.6], [9, 1.5], [20, 22]] } } }, { id: "highway-trunk-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "trunk"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-opacity": { stops: [[5, 0], [6, 0.5]] }, "line-width": { base: 1.2, stops: [[5, 0], [6, 0.6], [7, 1.5], [20, 22]] } } }, { id: "highway-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 4, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway"]], layout: { "line-cap": "butt", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[4, 0], [5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": { stops: [[4, 0], [5, 0.5]] } } }, { id: "highway-path", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-dasharray": [1.5, 0.75], "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] } } }, { id: "highway-motorway-link", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 12, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway_link"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "highway-link", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "highway-minor", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!=", "brunnel", "tunnel"], ["in", "class", "minor", "service", "track"]]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fff", "line-opacity": 0.5, "line-width": { base: 1.2, stops: [[13.5, 0], [14, 2.5], [20, 11.5]] } } }, { id: "highway-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "secondary", "tertiary"]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [8, 0.5], [20, 13]] }, "line-opacity": 0.5 } }, { id: "highway-primary", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "primary"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[8.5, 0], [9, 0.5], [20, 18]] }, "line-opacity": 0 } }, { id: "highway-trunk", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["in", "class", "trunk"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "highway-motorway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", minzoom: 5, filter: ["all", ["==", "$type", "LineString"], ["all", ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "motorway"]]], layout: { "line-cap": "round", "line-join": "round", visibility: "visible" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "railway-transit", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.77)", "line-width": { base: 1.4, stops: [[14, 0.4], [20, 1]] } } }, { id: "railway-transit-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "transit"], ["!in", "brunnel", "tunnel"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.68)", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 2], [20, 6]] } } }, { id: "railway-service", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "rail"], ["has", "service"]]], paint: { "line-color": "hsla(0, 0%, 73%, 0.77)", "line-width": { base: 1.4, stops: [[14, 0.4], [20, 1]] } } }, { id: "railway-service-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "class", "rail"], ["has", "service"]]], layout: { visibility: "visible" }, paint: { "line-color": "hsla(0, 0%, 73%, 0.68)", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 2], [20, 6]] } } }, { id: "railway", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!has", "service"], ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "rail"]]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] } } }, { id: "railway-hatching", type: "line", metadata: { "mapbox:group": "1444849345966.4436" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["!has", "service"], ["!in", "brunnel", "bridge", "tunnel"], ["==", "class", "rail"]]], paint: { "line-color": "#bbb", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 3], [20, 8]] } } }, { id: "bridge-motorway-link-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "bridge-link-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[12, 1], [13, 3], [14, 4], [20, 15]] } } }, { id: "bridge-secondary-tertiary-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-opacity": 1, "line-width": { base: 1.2, stops: [[8, 1.5], [20, 28]] } } }, { id: "bridge-trunk-primary-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "hsl(28, 76%, 67%)", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 26]] } } }, { id: "bridge-motorway-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway"]], layout: { "line-join": "round" }, paint: { "line-color": "#e9ac77", "line-width": { base: 1.2, stops: [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] }, "line-opacity": 0.5 } }, { id: "bridge-path-casing", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]], paint: { "line-color": "#f8f4f0", "line-width": { base: 1.2, stops: [[15, 1.2], [20, 18]] } } }, { id: "bridge-path", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "$type", "LineString"], ["all", ["==", "brunnel", "bridge"], ["==", "class", "path"]]], paint: { "line-color": "#cba", "line-width": { base: 1.2, stops: [[15, 1.2], [20, 4]] }, "line-dasharray": [1.5, 0.75] } }, { id: "bridge-motorway-link", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "bridge-link", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary_link", "secondary_link", "tertiary_link", "trunk_link"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] } } }, { id: "bridge-secondary-tertiary", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "secondary", "tertiary"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 20]] } } }, { id: "bridge-trunk-primary", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["in", "class", "primary", "trunk"]], layout: { "line-join": "round" }, paint: { "line-color": "#fea", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] } } }, { id: "bridge-motorway", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "motorway"]], layout: { "line-join": "round" }, paint: { "line-color": "#fc8", "line-width": { base: 1.2, stops: [[6.5, 0], [7, 0.5], [20, 18]] }, "line-opacity": 0.5 } }, { id: "bridge-railway", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-width": { base: 1.4, stops: [[14, 0.4], [15, 0.75], [20, 2]] } } }, { id: "bridge-railway-hatching", type: "line", metadata: { "mapbox:group": "1444849334699.1902" }, source: "openmaptiles", "source-layer": "transportation", filter: ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], paint: { "line-color": "#bbb", "line-dasharray": [0.2, 8], "line-width": { base: 1.4, stops: [[14.5, 0], [15, 3], [20, 8]] } } }, { id: "cablecar", type: "line", source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["==", "class", "cable_car"], layout: { visibility: "visible", "line-cap": "round" }, paint: { "line-color": "hsl(0, 0%, 70%)", "line-width": { base: 1, stops: [[11, 1], [19, 2.5]] } } }, { id: "cablecar-dash", type: "line", source: "openmaptiles", "source-layer": "transportation", minzoom: 13, filter: ["==", "class", "cable_car"], layout: { visibility: "visible", "line-cap": "round" }, paint: { "line-color": "hsl(0, 0%, 70%)", "line-width": { base: 1, stops: [[11, 3], [19, 5.5]] }, "line-dasharray": [2, 3] } }, { id: "boundary-land-level-4", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", [">=", "admin_level", 4], ["<=", "admin_level", 8], ["!=", "maritime", 1]], layout: { "line-join": "round" }, paint: { "line-color": "#9e9cab", "line-dasharray": [3, 1, 1, 1], "line-width": { base: 1.4, stops: [[4, 0.4], [5, 1], [12, 3]] }, "line-opacity": 0.6 } }, { id: "boundary-land-level-2", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["==", "admin_level", 2], ["!=", "maritime", 1], ["!=", "disputed", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "hsl(248, 7%, 66%)", "line-width": { base: 1, stops: [[0, 0.6], [4, 1.4], [5, 2], [12, 2]] } } }, { id: "boundary-land-disputed", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["!=", "maritime", 1], ["==", "disputed", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "hsl(248, 7%, 70%)", "line-dasharray": [1, 3], "line-width": { base: 1, stops: [[0, 0.6], [4, 1.4], [5, 2], [12, 8]] } } }, { id: "boundary-water", type: "line", source: "openmaptiles", "source-layer": "boundary", filter: ["all", ["in", "admin_level", 2, 4], ["==", "maritime", 1]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "rgba(154, 189, 214, 1)", "line-width": { base: 1, stops: [[0, 0.6], [4, 1], [5, 1], [12, 1]] }, "line-opacity": { stops: [[6, 0], [10, 0]] } } }, { id: "waterway-name", type: "symbol", source: "openmaptiles", "source-layer": "waterway", minzoom: 13, filter: ["all", ["==", "$type", "LineString"], ["has", "name"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": "{name:latin} {name:nonlatin}", "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "line", "text-letter-spacing": 0.2, "symbol-spacing": 350 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-lakeline", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["==", "$type", "LineString"], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "line", "symbol-spacing": 350, "text-letter-spacing": 0.2 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-ocean", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["all", ["==", "$type", "Point"], ["==", "class", "ocean"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": 14, "text-field": "{name:latin}", "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "point", "symbol-spacing": 350, "text-letter-spacing": 0.2 }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "water-name-other", type: "symbol", source: "openmaptiles", "source-layer": "water_name", filter: ["all", ["==", "$type", "Point"], ["!in", "class", "ocean"]], layout: { "text-font": ["Noto Sans Italic"], "text-size": { stops: [[0, 10], [6, 14]] }, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 5, "text-rotation-alignment": "map", "symbol-placement": "point", "symbol-spacing": 350, "text-letter-spacing": 0.2, visibility: "visible" }, paint: { "text-color": "#74aee9", "text-halo-width": 1.5, "text-halo-color": "rgba(255,255,255,0.7)" } }, { id: "poi-level-3", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 16, filter: ["all", ["==", "$type", "Point"], [">=", "rank", 25]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}\n{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "poi-level-2", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 15, filter: ["all", ["==", "$type", "Point"], ["<=", "rank", 24], [">=", "rank", 15]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}\n{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "poi-level-1", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 14, filter: ["all", ["==", "$type", "Point"], ["<=", "rank", 14], ["has", "name"]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}\n{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 11, "text-max-width": 9 }, paint: { "text-halo-blur": 0.5, "text-color": "rgba(191, 228, 172, 1)", "text-halo-width": 1, "text-halo-color": "rgba(30, 29, 29, 1)" } }, { id: "poi-railway", type: "symbol", source: "openmaptiles", "source-layer": "poi", minzoom: 13, filter: ["all", ["==", "$type", "Point"], ["has", "name"], ["==", "class", "railway"], ["==", "subclass", "station"]], layout: { "text-padding": 2, "text-font": ["Noto Sans Regular"], "text-anchor": "top", "icon-image": "{class}_11", "text-field": `{name:latin}\n{name:nonlatin}`, "text-offset": [0, 0.6], "text-size": 12, "text-max-width": 9, "icon-optional": false, "icon-ignore-placement": false, "icon-allow-overlap": false, "text-ignore-placement": false, "text-allow-overlap": false, "text-optional": true }, paint: { "text-halo-blur": 0.5, "text-color": "#666", "text-halo-width": 1, "text-halo-color": "#ffffff" } }, { id: "road_oneway", type: "symbol", source: "openmaptiles", "source-layer": "transportation", minzoom: 15, filter: ["all", ["==", "oneway", 1], ["in", "class", "motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service"]], layout: { "symbol-placement": "line", "icon-image": "oneway", "symbol-spacing": 75, "icon-padding": 2, "icon-rotation-alignment": "map", "icon-rotate": 90, "icon-size": { stops: [[15, 0.5], [19, 1]] } }, paint: { "icon-opacity": 0.5 } }, { id: "road_oneway_opposite", type: "symbol", source: "openmaptiles", "source-layer": "transportation", minzoom: 15, filter: ["all", ["==", "oneway", -1], ["in", "class", "motorway", "trunk", "primary", "secondary", "tertiary", "minor", "service"]], layout: { "symbol-placement": "line", "icon-image": "oneway", "symbol-spacing": 75, "icon-padding": 2, "icon-rotation-alignment": "map", "icon-rotate": -90, "icon-size": { stops: [[15, 0.5], [19, 1]] } }, paint: { "icon-opacity": 0.5 } }, { id: "highway-name-path", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 15.5, filter: ["==", "class", "path"], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-color": "#f8f4f0", "text-color": "hsl(30, 23%, 62%)", "text-halo-width": 0.5 } }, { id: "highway-name-minor", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 15, filter: ["all", ["==", "$type", "LineString"], ["in", "class", "minor", "service", "track"]], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-blur": 0.5, "text-color": "#765", "text-halo-width": 1 } }, { id: "highway-name-major", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 12.2, filter: ["in", "class", "primary", "secondary", "tertiary", "trunk"], layout: { "text-size": { base: 1, stops: [[13, 12], [14, 13]] }, "text-font": ["Noto Sans Regular"], "text-field": "{name:latin} {name:nonlatin}", "symbol-placement": "line", "text-rotation-alignment": "map" }, paint: { "text-halo-blur": 0.5, "text-color": "#765", "text-halo-width": 1 } }, { id: "highway-shield", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 8, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["!in", "network", "us-interstate", "us-highway", "us-state"]], layout: { "text-size": 10, "icon-image": "road_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[10, "point"], [11, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-opacity": 1, "text-color": "rgba(20, 19, 19, 1)", "text-halo-color": "rgba(230, 221, 221, 0)", "text-halo-width": 2, "icon-color": "rgba(183, 18, 18, 1)", "icon-opacity": 0.3, "icon-halo-color": "rgba(183, 55, 55, 0)" } }, { id: "highway-shield-us-interstate", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 7, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["in", "network", "us-interstate"]], layout: { "text-size": 10, "icon-image": "{network}_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[7, "point"], [7, "line"], [8, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-color": "rgba(0, 0, 0, 1)" } }, { id: "highway-shield-us-other", type: "symbol", source: "openmaptiles", "source-layer": "transportation_name", minzoom: 9, filter: ["all", ["<=", "ref_length", 6], ["==", "$type", "LineString"], ["in", "network", "us-highway", "us-state"]], layout: { "text-size": 10, "icon-image": "{network}_{ref_length}", "icon-rotation-alignment": "viewport", "symbol-spacing": 200, "text-font": ["Noto Sans Regular"], "symbol-placement": { base: 1, stops: [[10, "point"], [11, "line"]] }, "text-rotation-alignment": "viewport", "icon-size": 1, "text-field": "{ref}" }, paint: { "text-color": "rgba(0, 0, 0, 1)" } }, { id: "place-other", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", minzoom: 12, filter: ["!in", "class", "city", "town", "village", "country", "continent"], layout: { "text-letter-spacing": 0.1, "text-size": { base: 1.2, stops: [[12, 10], [15, 14]] }, "text-font": ["Noto Sans Bold"], "text-field": `{name:latin}\n{name:nonlatin}`, "text-transform": "uppercase", "text-max-width": 9, visibility: "visible" }, paint: { "text-color": "rgba(255,255,255,1)", "text-halo-width": 1.2, "text-halo-color": "rgba(57, 28, 28, 1)" } }, { id: "place-village", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", minzoom: 10, filter: ["==", "class", "village"], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[10, 12], [15, 16]] }, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(255, 255, 255, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(10, 9, 9, 0.8)" } }, { id: "place-town", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["==", "class", "town"], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[10, 14], [15, 24]] }, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(255, 255, 255, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(22, 22, 22, 0.8)" } }, { id: "place-city", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["!=", "capital", 2], ["==", "class", "city"]], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[7, 14], [11, 24]] }, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 8, visibility: "visible" }, paint: { "text-color": "rgba(0, 0, 0, 1)", "text-halo-width": 1.2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-city-capital", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "capital", 2], ["==", "class", "city"]], layout: { "text-font": ["Noto Sans Regular"], "text-size": { base: 1.2, stops: [[7, 14], [11, 24]] }, "text-field": `{name:latin}\n{name:nonlatin}`, "text-max-width": 8, "icon-image": "star_11", "text-offset": [0.4, 0], "icon-size": 0.8, "text-anchor": "left", visibility: "visible" }, paint: { "text-color": "#333", "text-halo-width": 1.2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-other", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], [">=", "rank", 3], ["!has", "iso_a2"]], layout: { "text-font": ["Noto Sans Italic"], "text-field": "{name:latin}", "text-size": { stops: [[3, 11], [7, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-3", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], [">=", "rank", 3], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[3, 11], [7, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-2", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], ["==", "rank", 2], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[2, 11], [5, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-country-1", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", filter: ["all", ["==", "class", "country"], ["==", "rank", 1], ["has", "iso_a2"]], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": { stops: [[1, 11], [4, 17]] }, "text-transform": "uppercase", "text-max-width": 6.25, visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }, { id: "place-continent", type: "symbol", metadata: { "mapbox:group": "1444849242106.713" }, source: "openmaptiles", "source-layer": "place", maxzoom: 1, filter: ["==", "class", "continent"], layout: { "text-font": ["Noto Sans Bold"], "text-field": "{name:latin}", "text-size": 14, "text-max-width": 6.25, "text-transform": "uppercase", visibility: "visible" }, paint: { "text-halo-blur": 1, "text-color": "#334", "text-halo-width": 2, "text-halo-color": "rgba(255,255,255,0.8)" } }], id: "qebnlkra6" };\n          });\n          var xHe = ye((Hxr, _He) => {\n            _He.exports = { version: 8, name: "orto", metadata: {}, center: [1.537786, 41.837539], zoom: 12, bearing: 0, pitch: 0, light: { anchor: "viewport", color: "white", intensity: 0.4, position: [1.15, 45, 30] }, sources: { ortoEsri: { type: "raster", tiles: ["https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"], tileSize: 256, maxzoom: 18, attribution: "ESRI &copy; <a href=\'http://www.esri.com\'>ESRI</a>" }, ortoInstaMaps: { type: "raster", tiles: ["https://tilemaps.icgc.cat/mapfactory/wmts/orto_8_12/CAT3857/{z}/{x}/{y}.png"], tileSize: 256, maxzoom: 13 }, ortoICGC: { type: "raster", tiles: ["https://geoserveis.icgc.cat/icc_mapesmultibase/noutm/wmts/orto/GRID3857/{z}/{x}/{y}.jpeg"], tileSize: 256, minzoom: 13.1, maxzoom: 20 }, openmaptiles: { type: "vector", url: "https://geoserveis.icgc.cat/contextmaps/basemap.json" } }, sprite: "https://geoserveis.icgc.cat/contextmaps/sprites/sprite@1", glyphs: "https://geoserveis.icgc.cat/contextmaps/glyphs/{fontstack}/{range}.pbf", layers: [{ id: "background", type: "background", paint: { "background-color": "#F4F9F4" } }, { id: "ortoEsri", type: "raster", source: "ortoEsri", maxzoom: 16, layout: { visibility: "visible" } }, { id: "ortoICGC", type: "raster", source: "ortoICGC", minzoom: 13.1, maxzoom: 19, layout: { visibility: "visible" } }, { id: "ortoInstaMaps", type: "raster", source: "ortoInstaMaps", maxzoom: 13, layout: { visibility: "visible" } }] };\n          });\n          var wx = ye((jxr, SHe) => {\n            "use strict";\n            var PWt = Z1(), IWt = yHe(), RWt = xHe(), DWt = \'\\xA9 <a target="_blank" href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors\', bHe = "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json", wHe = "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json", i7 = "https://basemaps.cartocdn.com/gl/voyager-gl-style/style.json", FWt = "https://basemaps.cartocdn.com/gl/positron-nolabels-gl-style/style.json", zWt = "https://basemaps.cartocdn.com/gl/dark-matter-nolabels-gl-style/style.json", OWt = "https://basemaps.cartocdn.com/gl/voyager-nolabels-gl-style/style.json", AHe = { basic: i7, streets: i7, outdoors: i7, light: bHe, dark: wHe, satellite: RWt, "satellite-streets": IWt, "open-street-map": { id: "osm", version: 8, sources: { "plotly-osm-tiles": { type: "raster", attribution: DWt, tiles: ["https://tile.openstreetmap.org/{z}/{x}/{y}.png"], tileSize: 256 } }, layers: [{ id: "plotly-osm-tiles", type: "raster", source: "plotly-osm-tiles", minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "white-bg": { id: "white-bg", version: 8, sources: {}, layers: [{ id: "white-bg", type: "background", paint: { "background-color": "#FFFFFF" }, minzoom: 0, maxzoom: 22 }], glyphs: "https://fonts.openmaptiles.org/{fontstack}/{range}.pbf" }, "carto-positron": bHe, "carto-darkmatter": wHe, "carto-voyager": i7, "carto-positron-nolabels": FWt, "carto-darkmatter-nolabels": zWt, "carto-voyager-nolabels": OWt }, THe = PWt(AHe);\n            SHe.exports = { styleValueDflt: "basic", stylesMap: AHe, styleValuesMap: THe, traceLayerPrefix: "plotly-trace-layer-", layoutLayerPrefix: "plotly-layout-layer-", missingStyleErrorMsg: ["No valid maplibre style found, please set `map.style` to one of:", THe.join(", "), "or use a tile service."].join(`\n`), mapOnErrorMsg: "Map error." };\n          });\n          var jk = ye((Wxr, LHe) => {\n            "use strict";\n            var MHe = Dr(), EHe = ka().defaultLine, qWt = Cc().attributes, BWt = ec(), NWt = pf().textposition, UWt = mc().overrideAll, VWt = vl().templatedArray, kHe = wx(), CHe = BWt({ noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true });\n            CHe.family.dflt = "Open Sans Regular, Arial Unicode MS Regular";\n            var GWt = LHe.exports = UWt({ _arrayAttrRegexps: [MHe.counterRegex("map", ".layers", true)], domain: qWt({ name: "map" }), style: { valType: "any", values: kHe.styleValuesMap, dflt: kHe.styleValueDflt }, center: { lon: { valType: "number", dflt: 0 }, lat: { valType: "number", dflt: 0 } }, zoom: { valType: "number", dflt: 1 }, bearing: { valType: "number", dflt: 0 }, pitch: { valType: "number", dflt: 0 }, bounds: { west: { valType: "number" }, east: { valType: "number" }, south: { valType: "number" }, north: { valType: "number" } }, layers: VWt("layer", { visible: { valType: "boolean", dflt: true }, sourcetype: { valType: "enumerated", values: ["geojson", "vector", "raster", "image"], dflt: "geojson" }, source: { valType: "any" }, sourcelayer: { valType: "string", dflt: "" }, sourceattribution: { valType: "string" }, type: { valType: "enumerated", values: ["circle", "line", "fill", "symbol", "raster"], dflt: "circle" }, coordinates: { valType: "any" }, below: { valType: "string" }, color: { valType: "color", dflt: EHe }, opacity: { valType: "number", min: 0, max: 1, dflt: 1 }, minzoom: { valType: "number", min: 0, max: 24, dflt: 0 }, maxzoom: { valType: "number", min: 0, max: 24, dflt: 24 }, circle: { radius: { valType: "number", dflt: 15 } }, line: { width: { valType: "number", dflt: 2 }, dash: { valType: "data_array" } }, fill: { outlinecolor: { valType: "color", dflt: EHe } }, symbol: { icon: { valType: "string", dflt: "marker" }, iconsize: { valType: "number", dflt: 10 }, text: { valType: "string", dflt: "" }, placement: { valType: "enumerated", values: ["point", "line", "line-center"], dflt: "point" }, textfont: CHe, textposition: MHe.extendFlat({}, NWt, { arrayOk: false }) } }) }, "plot", "from-root");\n            GWt.uirevision = { valType: "any", editType: "none" };\n          });\n          var n7 = ye((Xxr, DHe) => {\n            "use strict";\n            var { hovertemplateAttrs: HWt, texttemplateAttrs: jWt, templatefallbackAttrs: PHe } = Ll(), WWt = Cg(), Wk = j22(), E5 = pf(), IHe = jk(), XWt = Gl(), ZWt = Tu(), nw = Ao().extendFlat, YWt = mc().overrideAll, KWt = jk(), RHe = Wk.line, k5 = Wk.marker;\n            DHe.exports = YWt({ lon: Wk.lon, lat: Wk.lat, cluster: { enabled: { valType: "boolean" }, maxzoom: nw({}, KWt.layers.maxzoom, {}), step: { valType: "number", arrayOk: true, dflt: -1, min: -1 }, size: { valType: "number", arrayOk: true, dflt: 20, min: 0 }, color: { valType: "color", arrayOk: true }, opacity: nw({}, k5.opacity, { dflt: 1 }) }, mode: nw({}, E5.mode, { dflt: "markers" }), text: nw({}, E5.text, {}), texttemplate: jWt({ editType: "plot" }, { keys: ["lat", "lon", "text"] }), texttemplatefallback: PHe({ editType: "plot" }), hovertext: nw({}, E5.hovertext, {}), line: { color: RHe.color, width: RHe.width }, connectgaps: E5.connectgaps, marker: nw({ symbol: { valType: "string", dflt: "circle", arrayOk: true }, angle: { valType: "number", dflt: "auto", arrayOk: true }, allowoverlap: { valType: "boolean", dflt: false }, opacity: k5.opacity, size: k5.size, sizeref: k5.sizeref, sizemin: k5.sizemin, sizemode: k5.sizemode }, ZWt("marker")), fill: Wk.fill, fillcolor: WWt(), textfont: IHe.layers.symbol.textfont, textposition: IHe.layers.symbol.textposition, below: { valType: "string" }, selected: { marker: E5.selected.marker }, unselected: { marker: E5.unselected.marker }, hoverinfo: nw({}, XWt.hoverinfo, { flags: ["lon", "lat", "text", "name"] }), hovertemplate: HWt(), hovertemplatefallback: PHe() }, "calc", "nested");\n          });\n          var wJ = ye((Zxr, FHe) => {\n            "use strict";\n            var JWt = ["Metropolis Black Italic", "Metropolis Black", "Metropolis Bold Italic", "Metropolis Bold", "Metropolis Extra Bold Italic", "Metropolis Extra Bold", "Metropolis Extra Light Italic", "Metropolis Extra Light", "Metropolis Light Italic", "Metropolis Light", "Metropolis Medium Italic", "Metropolis Medium", "Metropolis Regular Italic", "Metropolis Regular", "Metropolis Semi Bold Italic", "Metropolis Semi Bold", "Metropolis Thin Italic", "Metropolis Thin", "Open Sans Bold Italic", "Open Sans Bold", "Open Sans Extrabold Italic", "Open Sans Extrabold", "Open Sans Italic", "Open Sans Light Italic", "Open Sans Light", "Open Sans Regular", "Open Sans Semibold Italic", "Open Sans Semibold", "Klokantech Noto Sans Bold", "Klokantech Noto Sans CJK Bold", "Klokantech Noto Sans CJK Regular", "Klokantech Noto Sans Italic", "Klokantech Noto Sans Regular"];\n            FHe.exports = { isSupportedFont: function(e3) {\n              return JWt.indexOf(e3) !== -1;\n            } };\n          });\n          var qHe = ye((Yxr, OHe) => {\n            "use strict";\n            var Xk = Dr(), TJ = Ru(), $Wt = $p(), QWt = R0(), eXt = D0(), tXt = Rg(), zHe = n7(), rXt = wJ().isSupportedFont;\n            OHe.exports = function(t3, r4, n4, i3) {\n              function a4(p3, k4) {\n                return Xk.coerce(t3, r4, zHe, p3, k4);\n              }\n              function o4(p3, k4) {\n                return Xk.coerce2(t3, r4, zHe, p3, k4);\n              }\n              var s3 = iXt(t3, r4, a4);\n              if (!s3) {\n                r4.visible = false;\n                return;\n              }\n              if (a4("text"), a4("texttemplate"), a4("texttemplatefallback"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("mode"), a4("below"), TJ.hasMarkers(r4)) {\n                $Wt(t3, r4, n4, i3, a4, { noLine: true, noAngle: true }), a4("marker.allowoverlap"), a4("marker.angle");\n                var l3 = r4.marker;\n                l3.symbol !== "circle" && (Xk.isArrayOrTypedArray(l3.size) && (l3.size = l3.size[0]), Xk.isArrayOrTypedArray(l3.color) && (l3.color = l3.color[0]));\n              }\n              TJ.hasLines(r4) && (QWt(t3, r4, n4, i3, a4, { noDash: true }), a4("connectgaps"));\n              var u4 = o4("cluster.maxzoom"), c5 = o4("cluster.step"), f4 = o4("cluster.color", r4.marker && r4.marker.color || n4), h3 = o4("cluster.size"), d3 = o4("cluster.opacity"), v3 = u4 !== false || c5 !== false || f4 !== false || h3 !== false || d3 !== false, _2 = a4("cluster.enabled", v3);\n              if (_2 || TJ.hasText(r4)) {\n                var b = i3.font.family;\n                eXt(t3, r4, i3, a4, { noSelect: true, noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true, font: { family: rXt(b) ? b : "Open Sans Regular", weight: i3.font.weight, style: i3.font.style, size: i3.font.size, color: i3.font.color } });\n              }\n              a4("fill"), r4.fill !== "none" && tXt(t3, r4, n4, a4), Xk.coerceSelectionMarkerOpacity(r4, a4);\n            };\n            function iXt(e3, t3, r4) {\n              var n4 = r4("lon") || [], i3 = r4("lat") || [], a4 = Math.min(n4.length, i3.length);\n              return t3._length = a4, a4;\n            }\n          });\n          var AJ = ye((Kxr, NHe) => {\n            "use strict";\n            var BHe = ho();\n            NHe.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.subplot]._subplot, o4 = a4.mockAxis, s3 = t3.lonlat;\n              return i3.lonLabel = BHe.tickText(o4, o4.c2l(s3[0]), true).text, i3.latLabel = BHe.tickText(o4, o4.c2l(s3[1]), true).text, i3;\n            };\n          });\n          var SJ = ye((Jxr, VHe) => {\n            "use strict";\n            var UHe = Dr();\n            VHe.exports = function(t3, r4) {\n              var n4 = t3.split(" "), i3 = n4[0], a4 = n4[1], o4 = UHe.isArrayOrTypedArray(r4) ? UHe.mean(r4) : r4, s3 = 0.5 + o4 / 100, l3 = 1.5 + o4 / 100, u4 = ["", ""], c5 = [0, 0];\n              switch (i3) {\n                case "top":\n                  u4[0] = "top", c5[1] = -l3;\n                  break;\n                case "bottom":\n                  u4[0] = "bottom", c5[1] = l3;\n                  break;\n              }\n              switch (a4) {\n                case "left":\n                  u4[1] = "right", c5[0] = -s3;\n                  break;\n                case "right":\n                  u4[1] = "left", c5[0] = s3;\n                  break;\n              }\n              var f4;\n              return u4[0] && u4[1] ? f4 = u4.join("-") : u4[0] ? f4 = u4[0] : u4[1] ? f4 = u4[1] : f4 = "center", { anchor: f4, offset: c5 };\n            };\n          });\n          var ZHe = ye(($xr, XHe) => {\n            "use strict";\n            var jHe = Eo(), ov = Dr(), nXt = fs().BADNUM, o7 = tx(), GHe = tc(), aXt = So(), oXt = k3(), s7 = Ru(), sXt = wJ().isSupportedFont, lXt = SJ(), uXt = ip().appendArrayPointValue, cXt = ru().NEWLINES, fXt = ru().BR_TAG_ALL;\n            XHe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = n4.visible === true && n4._length !== 0, a4 = n4.fill !== "none", o4 = s7.hasLines(n4), s3 = s7.hasMarkers(n4), l3 = s7.hasText(n4), u4 = s3 && n4.marker.symbol === "circle", c5 = s3 && n4.marker.symbol !== "circle", f4 = n4.cluster && n4.cluster.enabled, h3 = a7("fill"), d3 = a7("line"), v3 = a7("circle"), _2 = a7("symbol"), b = { fill: h3, line: d3, circle: v3, symbol: _2 };\n              if (!i3) return b;\n              var p3;\n              if ((a4 || o4) && (p3 = o7.calcTraceToLineCoords(r4)), a4 && (h3.geojson = o7.makePolygon(p3), h3.layout.visibility = "visible", ov.extendFlat(h3.paint, { "fill-color": n4.fillcolor })), o4 && (d3.geojson = o7.makeLine(p3), d3.layout.visibility = "visible", ov.extendFlat(d3.paint, { "line-width": n4.line.width, "line-color": n4.line.color, "line-opacity": n4.opacity })), u4) {\n                var k4 = hXt(r4);\n                v3.geojson = k4.geojson, v3.layout.visibility = "visible", f4 && (v3.filter = ["!", ["has", "point_count"]], b.cluster = { type: "circle", filter: ["has", "point_count"], layout: { visibility: "visible" }, paint: { "circle-color": EJ(n4.cluster.color, n4.cluster.step), "circle-radius": EJ(n4.cluster.size, n4.cluster.step), "circle-opacity": EJ(n4.cluster.opacity, n4.cluster.step) } }, b.clusterCount = { type: "symbol", filter: ["has", "point_count"], paint: {}, layout: { "text-field": "{point_count_abbreviated}", "text-font": HHe(n4), "text-size": 12 } }), ov.extendFlat(v3.paint, { "circle-color": k4.mcc, "circle-radius": k4.mrc, "circle-opacity": k4.mo });\n              }\n              if (u4 && f4 && (v3.filter = ["!", ["has", "point_count"]]), (c5 || l3) && (_2.geojson = dXt(r4, t3), ov.extendFlat(_2.layout, { visibility: "visible", "icon-image": "{symbol}-15", "text-field": "{text}" }), c5 && (ov.extendFlat(_2.layout, { "icon-size": n4.marker.size / 10 }), "angle" in n4.marker && n4.marker.angle !== "auto" && ov.extendFlat(_2.layout, { "icon-rotate": { type: "identity", property: "angle" }, "icon-rotation-alignment": "map" }), _2.layout["icon-allow-overlap"] = n4.marker.allowoverlap, ov.extendFlat(_2.paint, { "icon-opacity": n4.opacity * n4.marker.opacity, "icon-color": n4.marker.color })), l3)) {\n                var E3 = (n4.marker || {}).size, S2 = lXt(n4.textposition, E3);\n                ov.extendFlat(_2.layout, { "text-size": n4.textfont.size, "text-anchor": S2.anchor, "text-offset": S2.offset, "text-font": HHe(n4) }), ov.extendFlat(_2.paint, { "text-color": n4.textfont.color, "text-opacity": n4.opacity });\n              }\n              return b;\n            };\n            function a7(e3) {\n              return { type: e3, geojson: o7.makeBlank(), layout: { visibility: "none" }, filter: null, paint: {} };\n            }\n            function hXt(e3) {\n              var t3 = e3[0].trace, r4 = t3.marker, n4 = t3.selectedpoints, i3 = ov.isArrayOrTypedArray(r4.color), a4 = ov.isArrayOrTypedArray(r4.size), o4 = ov.isArrayOrTypedArray(r4.opacity), s3;\n              function l3(E3) {\n                return t3.opacity * E3;\n              }\n              function u4(E3) {\n                return E3 / 2;\n              }\n              var c5;\n              i3 && (GHe.hasColorscale(t3, "marker") ? c5 = GHe.makeColorScaleFuncFromTrace(r4) : c5 = ov.identity);\n              var f4;\n              a4 && (f4 = oXt(t3));\n              var h3;\n              o4 && (h3 = function(E3) {\n                var S2 = jHe(E3) ? +ov.constrain(E3, 0, 1) : 0;\n                return l3(S2);\n              });\n              var d3 = [];\n              for (s3 = 0; s3 < e3.length; s3++) {\n                var v3 = e3[s3], _2 = v3.lonlat;\n                if (!WHe(_2)) {\n                  var b = {};\n                  c5 && (b.mcc = v3.mcc = c5(v3.mc)), f4 && (b.mrc = v3.mrc = f4(v3.ms)), h3 && (b.mo = h3(v3.mo)), n4 && (b.selected = v3.selected || 0), d3.push({ type: "Feature", id: s3 + 1, geometry: { type: "Point", coordinates: _2 }, properties: b });\n                }\n              }\n              var p3;\n              if (n4) for (p3 = aXt.makeSelectedPointStyleFns(t3), s3 = 0; s3 < d3.length; s3++) {\n                var k4 = d3[s3].properties;\n                p3.selectedOpacityFn && (k4.mo = l3(p3.selectedOpacityFn(k4))), p3.selectedColorFn && (k4.mcc = p3.selectedColorFn(k4)), p3.selectedSizeFn && (k4.mrc = p3.selectedSizeFn(k4));\n              }\n              return { geojson: { type: "FeatureCollection", features: d3 }, mcc: i3 || p3 && p3.selectedColorFn ? { type: "identity", property: "mcc" } : r4.color, mrc: a4 || p3 && p3.selectedSizeFn ? { type: "identity", property: "mrc" } : u4(r4.size), mo: o4 || p3 && p3.selectedOpacityFn ? { type: "identity", property: "mo" } : l3(r4.opacity) };\n            }\n            function dXt(e3, t3) {\n              for (var r4 = t3._fullLayout, n4 = e3[0].trace, i3 = n4.marker || {}, a4 = i3.symbol, o4 = i3.angle, s3 = a4 !== "circle" ? MJ(a4) : l7, l3 = o4 !== "auto" ? MJ(o4, true) : l7, u4 = s7.hasText(n4) ? MJ(n4.text) : l7, c5 = [], f4 = 0; f4 < e3.length; f4++) {\n                var h3 = e3[f4];\n                if (!WHe(h3.lonlat)) {\n                  var d3 = n4.texttemplate, v3;\n                  if (d3) {\n                    var _2 = Array.isArray(d3) ? d3[f4] || "" : d3, b = n4._module.formatLabels(h3, n4, r4), p3 = {};\n                    uXt(p3, n4, h3.i), v3 = ov.texttemplateString({ data: [p3, h3, n4._meta], fallback: n4.texttemplatefallback, labels: b, locale: r4._d3locale, template: _2 });\n                  } else v3 = u4(f4);\n                  v3 && (v3 = v3.replace(cXt, "").replace(fXt, `\n`)), c5.push({ type: "Feature", geometry: { type: "Point", coordinates: h3.lonlat }, properties: { symbol: s3(f4), angle: l3(f4), text: v3 } });\n                }\n              }\n              return { type: "FeatureCollection", features: c5 };\n            }\n            function MJ(e3, t3) {\n              return ov.isArrayOrTypedArray(e3) ? t3 ? function(r4) {\n                return jHe(e3[r4]) ? +e3[r4] : 0;\n              } : function(r4) {\n                return e3[r4];\n              } : e3 ? function() {\n                return e3;\n              } : l7;\n            }\n            function l7() {\n              return "";\n            }\n            function WHe(e3) {\n              return e3[0] === nXt;\n            }\n            function EJ(e3, t3) {\n              var r4;\n              if (ov.isArrayOrTypedArray(e3) && ov.isArrayOrTypedArray(t3)) {\n                r4 = ["step", ["get", "point_count"], e3[0]];\n                for (var n4 = 1; n4 < e3.length; n4++) r4.push(t3[n4 - 1], e3[n4]);\n              } else r4 = e3;\n              return r4;\n            }\n            function HHe(e3) {\n              var t3 = e3.textfont, r4 = t3.family, n4 = t3.style, i3 = t3.weight, a4 = r4.split(" "), o4 = a4[a4.length - 1] === "Italic";\n              o4 && a4.pop(), o4 = o4 || n4 === "italic";\n              var s3 = a4.join(" ");\n              i3 === "bold" && a4.indexOf("Bold") === -1 ? s3 += " Bold" : i3 <= 1e3 && (a4[0] === "Metropolis" ? (s3 = "Metropolis", i3 > 850 ? s3 += " Black" : i3 > 750 ? s3 += " Extra Bold" : i3 > 650 ? s3 += " Bold" : i3 > 550 ? s3 += " Semi Bold" : i3 > 450 ? s3 += " Medium" : i3 > 350 ? s3 += " Regular" : i3 > 250 ? s3 += " Light" : i3 > 150 ? s3 += " Extra Light" : s3 += " Thin") : a4.slice(0, 2).join(" ") === "Open Sans" ? (s3 = "Open Sans", i3 > 750 ? s3 += " Extrabold" : i3 > 650 ? s3 += " Bold" : i3 > 550 ? s3 += " Semibold" : i3 > 350 ? s3 += " Regular" : s3 += " Light") : a4.slice(0, 3).join(" ") === "Klokantech Noto Sans" && (s3 = "Klokantech Noto Sans", a4[3] === "CJK" && (s3 += " CJK"), s3 += i3 > 500 ? " Bold" : " Regular")), o4 && (s3 += " Italic"), s3 === "Open Sans Regular Italic" ? s3 = "Open Sans Italic" : s3 === "Open Sans Regular Bold" ? s3 = "Open Sans Bold" : s3 === "Open Sans Regular Bold Italic" ? s3 = "Open Sans Bold Italic" : s3 === "Klokantech Noto Sans Regular Italic" && (s3 = "Klokantech Noto Sans Italic"), sXt(s3) || (s3 = r4);\n              var l3 = s3.split(", ");\n              return l3;\n            }\n          });\n          var $He = ye((Qxr, JHe) => {\n            "use strict";\n            var vXt = Dr(), YHe = ZHe(), C5 = wx().traceLayerPrefix, ng = { cluster: ["cluster", "clusterCount", "circle"], nonCluster: ["fill", "line", "circle", "symbol"] };\n            function KHe(e3, t3, r4, n4) {\n              this.type = "scattermap", this.subplot = e3, this.uid = t3, this.clusterEnabled = r4, this.isHidden = n4, this.sourceIds = { fill: "source-" + t3 + "-fill", line: "source-" + t3 + "-line", circle: "source-" + t3 + "-circle", symbol: "source-" + t3 + "-symbol", cluster: "source-" + t3 + "-circle", clusterCount: "source-" + t3 + "-circle" }, this.layerIds = { fill: C5 + t3 + "-fill", line: C5 + t3 + "-line", circle: C5 + t3 + "-circle", symbol: C5 + t3 + "-symbol", cluster: C5 + t3 + "-cluster", clusterCount: C5 + t3 + "-cluster-count" }, this.below = null;\n            }\n            var Zk = KHe.prototype;\n            Zk.addSource = function(e3, t3, r4) {\n              var n4 = { type: "geojson", data: t3.geojson };\n              r4 && r4.enabled && vXt.extendFlat(n4, { cluster: true, clusterMaxZoom: r4.maxzoom });\n              var i3 = this.subplot.map.getSource(this.sourceIds[e3]);\n              i3 ? i3.setData(t3.geojson) : this.subplot.map.addSource(this.sourceIds[e3], n4);\n            };\n            Zk.setSourceData = function(e3, t3) {\n              this.subplot.map.getSource(this.sourceIds[e3]).setData(t3.geojson);\n            };\n            Zk.addLayer = function(e3, t3, r4) {\n              var n4 = { type: t3.type, id: this.layerIds[e3], source: this.sourceIds[e3], layout: t3.layout, paint: t3.paint };\n              t3.filter && (n4.filter = t3.filter);\n              for (var i3 = this.layerIds[e3], a4, o4 = this.subplot.getMapLayers(), s3 = 0; s3 < o4.length; s3++) if (o4[s3].id === i3) {\n                a4 = true;\n                break;\n              }\n              a4 ? (this.subplot.setOptions(i3, "setLayoutProperty", n4.layout), n4.layout.visibility === "visible" && this.subplot.setOptions(i3, "setPaintProperty", n4.paint)) : this.subplot.addLayer(n4, r4);\n            };\n            Zk.update = function(t3) {\n              var r4 = t3[0].trace, n4 = this.subplot, i3 = n4.map, a4 = YHe(n4.gd, t3), o4 = n4.belowLookup["trace-" + this.uid], s3 = !!(r4.cluster && r4.cluster.enabled), l3 = !!this.clusterEnabled, u4 = this;\n              function c5(E3) {\n                E3 || u4.addSource("circle", a4.circle, r4.cluster);\n                for (var S2 = ng.cluster, L3 = 0; L3 < S2.length; L3++) {\n                  var x2 = S2[L3], C3 = a4[x2];\n                  u4.addLayer(x2, C3, o4);\n                }\n              }\n              function f4(E3) {\n                for (var S2 = ng.cluster, L3 = S2.length - 1; L3 >= 0; L3--) {\n                  var x2 = S2[L3];\n                  i3.removeLayer(u4.layerIds[x2]);\n                }\n                E3 || i3.removeSource(u4.sourceIds.circle);\n              }\n              function h3(E3) {\n                for (var S2 = ng.nonCluster, L3 = 0; L3 < S2.length; L3++) {\n                  var x2 = S2[L3], C3 = a4[x2];\n                  E3 || u4.addSource(x2, C3), u4.addLayer(x2, C3, o4);\n                }\n              }\n              function d3(E3) {\n                for (var S2 = ng.nonCluster, L3 = S2.length - 1; L3 >= 0; L3--) {\n                  var x2 = S2[L3];\n                  i3.removeLayer(u4.layerIds[x2]), E3 || i3.removeSource(u4.sourceIds[x2]);\n                }\n              }\n              function v3(E3) {\n                l3 ? f4(E3) : d3(E3);\n              }\n              function _2(E3) {\n                s3 ? c5(E3) : h3(E3);\n              }\n              function b() {\n                for (var E3 = s3 ? ng.cluster : ng.nonCluster, S2 = 0; S2 < E3.length; S2++) {\n                  var L3 = E3[S2], x2 = a4[L3];\n                  x2 && (n4.setOptions(u4.layerIds[L3], "setLayoutProperty", x2.layout), x2.layout.visibility === "visible" && (L3 !== "cluster" && u4.setSourceData(L3, x2), n4.setOptions(u4.layerIds[L3], "setPaintProperty", x2.paint)));\n                }\n              }\n              var p3 = this.isHidden, k4 = r4.visible !== true;\n              k4 ? p3 || v3() : p3 ? k4 || _2() : l3 !== s3 ? (v3(), _2()) : (this.below !== o4 && (v3(true), _2(true)), b()), this.clusterEnabled = s3, this.isHidden = k4, this.below = o4, t3[0].trace._glTrace = this;\n            };\n            Zk.dispose = function() {\n              for (var t3 = this.subplot.map, r4 = this.clusterEnabled ? ng.cluster : ng.nonCluster, n4 = r4.length - 1; n4 >= 0; n4--) {\n                var i3 = r4[n4];\n                t3.removeLayer(this.layerIds[i3]), t3.removeSource(this.sourceIds[i3]);\n              }\n            };\n            JHe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = n4.cluster && n4.cluster.enabled, a4 = n4.visible !== true, o4 = new KHe(t3, n4.uid, i3, a4), s3 = YHe(t3.gd, r4), l3 = o4.below = t3.belowLookup["trace-" + n4.uid], u4, c5, f4;\n              if (i3) for (o4.addSource("circle", s3.circle, n4.cluster), u4 = 0; u4 < ng.cluster.length; u4++) c5 = ng.cluster[u4], f4 = s3[c5], o4.addLayer(c5, f4, l3);\n              else for (u4 = 0; u4 < ng.nonCluster.length; u4++) c5 = ng.nonCluster[u4], f4 = s3[c5], o4.addSource(c5, f4, n4.cluster), o4.addLayer(c5, f4, l3);\n              return r4[0].trace._glTrace = o4, o4;\n            };\n          });\n          var u7 = ye((ebr, eje) => {\n            "use strict";\n            var pXt = vf(), kJ = Dr(), gXt = cT(), mXt = kJ.fillText, yXt = fs().BADNUM, _Xt = wx().traceLayerPrefix;\n            function xXt(e3, t3, r4) {\n              var n4 = e3.cd, i3 = n4[0].trace, a4 = e3.xa, o4 = e3.ya, s3 = e3.subplot, l3 = [], u4 = _Xt + i3.uid + "-circle", c5 = i3.cluster && i3.cluster.enabled;\n              if (c5) {\n                var f4 = s3.map.queryRenderedFeatures(null, { layers: [u4] });\n                l3 = f4.map(function(M4) {\n                  return M4.id;\n                });\n              }\n              var h3 = t3 >= 0 ? Math.floor((t3 + 180) / 360) : Math.ceil((t3 - 180) / 360), d3 = h3 * 360, v3 = t3 - d3;\n              function _2(M4) {\n                var g3 = M4.lonlat;\n                if (g3[0] === yXt || c5 && l3.indexOf(M4.i + 1) === -1) return 1 / 0;\n                var P3 = kJ.modHalf(g3[0], 360), T3 = g3[1], z3 = s3.project([P3, T3]), O3 = z3.x - a4.c2p([v3, T3]), V2 = z3.y - o4.c2p([P3, r4]), G2 = Math.max(3, M4.mrc || 0);\n                return Math.max(Math.sqrt(O3 * O3 + V2 * V2) - G2, 1 - 3 / G2);\n              }\n              if (pXt.getClosest(n4, _2, e3), e3.index !== false) {\n                var b = n4[e3.index], p3 = b.lonlat, k4 = [kJ.modHalf(p3[0], 360) + d3, p3[1]], E3 = a4.c2p(k4), S2 = o4.c2p(k4), L3 = b.mrc || 1;\n                e3.x0 = E3 - L3, e3.x1 = E3 + L3, e3.y0 = S2 - L3, e3.y1 = S2 + L3;\n                var x2 = {};\n                x2[i3.subplot] = { _subplot: s3 };\n                var C3 = i3._module.formatLabels(b, i3, x2);\n                return e3.lonLabel = C3.lonLabel, e3.latLabel = C3.latLabel, e3.color = gXt(i3, b), e3.extraText = QHe(i3, b, n4[0].t.labels), e3.hovertemplate = i3.hovertemplate, [e3];\n              }\n            }\n            function QHe(e3, t3, r4) {\n              if (e3.hovertemplate) return;\n              var n4 = t3.hi || e3.hoverinfo, i3 = n4.split("+"), a4 = i3.indexOf("all") !== -1, o4 = i3.indexOf("lon") !== -1, s3 = i3.indexOf("lat") !== -1, l3 = t3.lonlat, u4 = [];\n              function c5(f4) {\n                return f4 + "\\xB0";\n              }\n              return a4 || o4 && s3 ? u4.push("(" + c5(l3[1]) + ", " + c5(l3[0]) + ")") : o4 ? u4.push(r4.lon + c5(l3[0])) : s3 && u4.push(r4.lat + c5(l3[1])), (a4 || i3.indexOf("text") !== -1) && mXt(t3, e3, u4), u4.join("<br>");\n            }\n            eje.exports = { hoverPoints: xXt, getExtraText: QHe };\n          });\n          var rje = ye((tbr, tje) => {\n            "use strict";\n            tje.exports = function(t3, r4) {\n              return t3.lon = r4.lon, t3.lat = r4.lat, t3;\n            };\n          });\n          var nje = ye((rbr, ije) => {\n            "use strict";\n            var bXt = Dr(), wXt = Ru(), TXt = fs().BADNUM;\n            ije.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3 = n4[0].trace, l3;\n              if (!wXt.hasMarkers(s3)) return [];\n              if (r4 === false) for (l3 = 0; l3 < n4.length; l3++) n4[l3].selected = 0;\n              else for (l3 = 0; l3 < n4.length; l3++) {\n                var u4 = n4[l3], c5 = u4.lonlat;\n                if (c5[0] !== TXt) {\n                  var f4 = [bXt.modHalf(c5[0], 360), c5[1]], h3 = [i3.c2p(f4), a4.c2p(f4)];\n                  r4.contains(h3, null, l3, t3) ? (o4.push({ pointNumber: l3, lon: c5[0], lat: c5[1] }), u4.selected = 1) : u4.selected = 0;\n                }\n              }\n              return o4;\n            };\n          });\n          var oje = ye((CJ, LJ) => {\n            (function(e3, t3) {\n              typeof CJ == "object" && typeof LJ != "undefined" ? LJ.exports = t3() : (e3 = typeof globalThis != "undefined" ? globalThis : e3 || self, e3.maplibregl = t3());\n            })(CJ, function() {\n              "use strict";\n              var e3 = {}, t3 = {};\n              function r4(i3, a4, o4) {\n                if (t3[i3] = o4, i3 === "index") {\n                  var s3 = "var sharedModule = {}; (" + t3.shared + ")(sharedModule); (" + t3.worker + ")(sharedModule);", l3 = {};\n                  return t3.shared(l3), t3.index(e3, l3), typeof window != "undefined" && e3.setWorkerUrl(window.URL.createObjectURL(new Blob([s3], { type: "text/javascript" }))), e3;\n                }\n              }\n              r4("shared", ["exports"], function(i3) {\n                "use strict";\n                function a4(R, A3, F3, W) {\n                  return new (F3 || (F3 = Promise))(function(re, fe) {\n                    function pe(ct) {\n                      try {\n                        Ke(W.next(ct));\n                      } catch (Lt) {\n                        fe(Lt);\n                      }\n                    }\n                    function ze(ct) {\n                      try {\n                        Ke(W.throw(ct));\n                      } catch (Lt) {\n                        fe(Lt);\n                      }\n                    }\n                    function Ke(ct) {\n                      var Lt;\n                      ct.done ? re(ct.value) : (Lt = ct.value, Lt instanceof F3 ? Lt : new F3(function($t) {\n                        $t(Lt);\n                      })).then(pe, ze);\n                    }\n                    Ke((W = W.apply(R, A3 || [])).next());\n                  });\n                }\n                function o4(R) {\n                  return R && R.__esModule && Object.prototype.hasOwnProperty.call(R, "default") ? R.default : R;\n                }\n                typeof SuppressedError == "function" && SuppressedError;\n                var s3 = l3;\n                function l3(R, A3) {\n                  this.x = R, this.y = A3;\n                }\n                l3.prototype = { clone: function() {\n                  return new l3(this.x, this.y);\n                }, add: function(R) {\n                  return this.clone()._add(R);\n                }, sub: function(R) {\n                  return this.clone()._sub(R);\n                }, multByPoint: function(R) {\n                  return this.clone()._multByPoint(R);\n                }, divByPoint: function(R) {\n                  return this.clone()._divByPoint(R);\n                }, mult: function(R) {\n                  return this.clone()._mult(R);\n                }, div: function(R) {\n                  return this.clone()._div(R);\n                }, rotate: function(R) {\n                  return this.clone()._rotate(R);\n                }, rotateAround: function(R, A3) {\n                  return this.clone()._rotateAround(R, A3);\n                }, matMult: function(R) {\n                  return this.clone()._matMult(R);\n                }, unit: function() {\n                  return this.clone()._unit();\n                }, perp: function() {\n                  return this.clone()._perp();\n                }, round: function() {\n                  return this.clone()._round();\n                }, mag: function() {\n                  return Math.sqrt(this.x * this.x + this.y * this.y);\n                }, equals: function(R) {\n                  return this.x === R.x && this.y === R.y;\n                }, dist: function(R) {\n                  return Math.sqrt(this.distSqr(R));\n                }, distSqr: function(R) {\n                  var A3 = R.x - this.x, F3 = R.y - this.y;\n                  return A3 * A3 + F3 * F3;\n                }, angle: function() {\n                  return Math.atan2(this.y, this.x);\n                }, angleTo: function(R) {\n                  return Math.atan2(this.y - R.y, this.x - R.x);\n                }, angleWith: function(R) {\n                  return this.angleWithSep(R.x, R.y);\n                }, angleWithSep: function(R, A3) {\n                  return Math.atan2(this.x * A3 - this.y * R, this.x * R + this.y * A3);\n                }, _matMult: function(R) {\n                  var A3 = R[2] * this.x + R[3] * this.y;\n                  return this.x = R[0] * this.x + R[1] * this.y, this.y = A3, this;\n                }, _add: function(R) {\n                  return this.x += R.x, this.y += R.y, this;\n                }, _sub: function(R) {\n                  return this.x -= R.x, this.y -= R.y, this;\n                }, _mult: function(R) {\n                  return this.x *= R, this.y *= R, this;\n                }, _div: function(R) {\n                  return this.x /= R, this.y /= R, this;\n                }, _multByPoint: function(R) {\n                  return this.x *= R.x, this.y *= R.y, this;\n                }, _divByPoint: function(R) {\n                  return this.x /= R.x, this.y /= R.y, this;\n                }, _unit: function() {\n                  return this._div(this.mag()), this;\n                }, _perp: function() {\n                  var R = this.y;\n                  return this.y = this.x, this.x = -R, this;\n                }, _rotate: function(R) {\n                  var A3 = Math.cos(R), F3 = Math.sin(R), W = F3 * this.x + A3 * this.y;\n                  return this.x = A3 * this.x - F3 * this.y, this.y = W, this;\n                }, _rotateAround: function(R, A3) {\n                  var F3 = Math.cos(R), W = Math.sin(R), re = A3.y + W * (this.x - A3.x) + F3 * (this.y - A3.y);\n                  return this.x = A3.x + F3 * (this.x - A3.x) - W * (this.y - A3.y), this.y = re, this;\n                }, _round: function() {\n                  return this.x = Math.round(this.x), this.y = Math.round(this.y), this;\n                } }, l3.convert = function(R) {\n                  return R instanceof l3 ? R : Array.isArray(R) ? new l3(R[0], R[1]) : R;\n                };\n                var u4 = o4(s3), c5 = f4;\n                function f4(R, A3, F3, W) {\n                  this.cx = 3 * R, this.bx = 3 * (F3 - R) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * A3, this.by = 3 * (W - A3) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = R, this.p1y = A3, this.p2x = F3, this.p2y = W;\n                }\n                f4.prototype = { sampleCurveX: function(R) {\n                  return ((this.ax * R + this.bx) * R + this.cx) * R;\n                }, sampleCurveY: function(R) {\n                  return ((this.ay * R + this.by) * R + this.cy) * R;\n                }, sampleCurveDerivativeX: function(R) {\n                  return (3 * this.ax * R + 2 * this.bx) * R + this.cx;\n                }, solveCurveX: function(R, A3) {\n                  if (A3 === void 0 && (A3 = 1e-6), R < 0) return 0;\n                  if (R > 1) return 1;\n                  for (var F3 = R, W = 0; W < 8; W++) {\n                    var re = this.sampleCurveX(F3) - R;\n                    if (Math.abs(re) < A3) return F3;\n                    var fe = this.sampleCurveDerivativeX(F3);\n                    if (Math.abs(fe) < 1e-6) break;\n                    F3 -= re / fe;\n                  }\n                  var pe = 0, ze = 1;\n                  for (F3 = R, W = 0; W < 20 && (re = this.sampleCurveX(F3), !(Math.abs(re - R) < A3)); W++) R > re ? pe = F3 : ze = F3, F3 = 0.5 * (ze - pe) + pe;\n                  return F3;\n                }, solve: function(R, A3) {\n                  return this.sampleCurveY(this.solveCurveX(R, A3));\n                } };\n                var h3 = o4(c5);\n                let d3, v3;\n                function _2() {\n                  return d3 == null && (d3 = typeof OffscreenCanvas != "undefined" && new OffscreenCanvas(1, 1).getContext("2d") && typeof createImageBitmap == "function"), d3;\n                }\n                function b() {\n                  if (v3 == null && (v3 = false, _2())) {\n                    let A3 = new OffscreenCanvas(5, 5).getContext("2d", { willReadFrequently: true });\n                    if (A3) {\n                      for (let W = 0; W < 5 * 5; W++) {\n                        let re = 4 * W;\n                        A3.fillStyle = `rgb(${re},${re + 1},${re + 2})`, A3.fillRect(W % 5, Math.floor(W / 5), 1, 1);\n                      }\n                      let F3 = A3.getImageData(0, 0, 5, 5).data;\n                      for (let W = 0; W < 5 * 5 * 4; W++) if (W % 4 != 3 && F3[W] !== W) {\n                        v3 = true;\n                        break;\n                      }\n                    }\n                  }\n                  return v3 || false;\n                }\n                function p3(R, A3, F3, W) {\n                  let re = new h3(R, A3, F3, W);\n                  return (fe) => re.solve(fe);\n                }\n                let k4 = p3(0.25, 0.1, 0.25, 1);\n                function E3(R, A3, F3) {\n                  return Math.min(F3, Math.max(A3, R));\n                }\n                function S2(R, A3, F3) {\n                  let W = F3 - A3, re = ((R - A3) % W + W) % W + A3;\n                  return re === A3 ? F3 : re;\n                }\n                function L3(R, ...A3) {\n                  for (let F3 of A3) for (let W in F3) R[W] = F3[W];\n                  return R;\n                }\n                let x2 = 1;\n                function C3(R, A3, F3) {\n                  let W = {};\n                  for (let re in R) W[re] = A3.call(this, R[re], re, R);\n                  return W;\n                }\n                function M4(R, A3, F3) {\n                  let W = {};\n                  for (let re in R) A3.call(this, R[re], re, R) && (W[re] = R[re]);\n                  return W;\n                }\n                function g3(R) {\n                  return Array.isArray(R) ? R.map(g3) : typeof R == "object" && R ? C3(R, g3) : R;\n                }\n                let P3 = {};\n                function T3(R) {\n                  P3[R] || (typeof console != "undefined" && console.warn(R), P3[R] = true);\n                }\n                function z3(R, A3, F3) {\n                  return (F3.y - R.y) * (A3.x - R.x) > (A3.y - R.y) * (F3.x - R.x);\n                }\n                function O3(R) {\n                  return typeof WorkerGlobalScope != "undefined" && R !== void 0 && R instanceof WorkerGlobalScope;\n                }\n                let V2 = null;\n                function G2(R) {\n                  return typeof ImageBitmap != "undefined" && R instanceof ImageBitmap;\n                }\n                let Z = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII=";\n                function j3(R, A3, F3, W, re) {\n                  return a4(this, void 0, void 0, function* () {\n                    if (typeof VideoFrame == "undefined") throw new Error("VideoFrame not supported");\n                    let fe = new VideoFrame(R, { timestamp: 0 });\n                    try {\n                      let pe = fe == null ? void 0 : fe.format;\n                      if (!pe || !pe.startsWith("BGR") && !pe.startsWith("RGB")) throw new Error(`Unrecognized format ${pe}`);\n                      let ze = pe.startsWith("BGR"), Ke = new Uint8ClampedArray(W * re * 4);\n                      if (yield fe.copyTo(Ke, (function(ct, Lt, $t, fr, mr) {\n                        let Pr = 4 * Math.max(-Lt, 0), zr = (Math.max(0, $t) - $t) * fr * 4 + Pr, ui = 4 * fr, yi = Math.max(0, Lt), vn = Math.max(0, $t);\n                        return { rect: { x: yi, y: vn, width: Math.min(ct.width, Lt + fr) - yi, height: Math.min(ct.height, $t + mr) - vn }, layout: [{ offset: zr, stride: ui }] };\n                      })(R, A3, F3, W, re)), ze) for (let ct = 0; ct < Ke.length; ct += 4) {\n                        let Lt = Ke[ct];\n                        Ke[ct] = Ke[ct + 2], Ke[ct + 2] = Lt;\n                      }\n                      return Ke;\n                    } finally {\n                      fe.close();\n                    }\n                  });\n                }\n                let N2, H, te = "AbortError";\n                function oe() {\n                  return new Error(te);\n                }\n                let _e = { MAX_PARALLEL_IMAGE_REQUESTS: 16, MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME: 8, MAX_TILE_CACHE_ZOOM_LEVELS: 5, REGISTERED_PROTOCOLS: {}, WORKER_URL: "" };\n                function Ee(R) {\n                  return _e.REGISTERED_PROTOCOLS[R.substring(0, R.indexOf("://"))];\n                }\n                let Ce = "global-dispatcher";\n                class me extends Error {\n                  constructor(A3, F3, W, re) {\n                    super(`AJAXError: ${F3} (${A3}): ${W}`), this.status = A3, this.statusText = F3, this.url = W, this.body = re;\n                  }\n                }\n                let ie = () => O3(self) ? self.worker && self.worker.referrer : (window.location.protocol === "blob:" ? window.parent : window).location.href, Se = function(R, A3) {\n                  if (/:\\/\\//.test(R.url) && !/^https?:|^file:/.test(R.url)) {\n                    let W = Ee(R.url);\n                    if (W) return W(R, A3);\n                    if (O3(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: R, targetMapId: Ce }, A3);\n                  }\n                  if (!(/^file:/.test(F3 = R.url) || /^file:/.test(ie()) && !/^\\w+:/.test(F3))) {\n                    if (fetch && Request && AbortController && Object.prototype.hasOwnProperty.call(Request.prototype, "signal")) return (function(W, re) {\n                      return a4(this, void 0, void 0, function* () {\n                        let fe = new Request(W.url, { method: W.method || "GET", body: W.body, credentials: W.credentials, headers: W.headers, cache: W.cache, referrer: ie(), signal: re.signal });\n                        W.type !== "json" || fe.headers.has("Accept") || fe.headers.set("Accept", "application/json");\n                        let pe = yield fetch(fe);\n                        if (!pe.ok) {\n                          let ct = yield pe.blob();\n                          throw new me(pe.status, pe.statusText, W.url, ct);\n                        }\n                        let ze;\n                        ze = W.type === "arrayBuffer" || W.type === "image" ? pe.arrayBuffer() : W.type === "json" ? pe.json() : pe.text();\n                        let Ke = yield ze;\n                        if (re.signal.aborted) throw oe();\n                        return { data: Ke, cacheControl: pe.headers.get("Cache-Control"), expires: pe.headers.get("Expires") };\n                      });\n                    })(R, A3);\n                    if (O3(self) && self.worker && self.worker.actor) return self.worker.actor.sendAsync({ type: "GR", data: R, mustQueue: true, targetMapId: Ce }, A3);\n                  }\n                  var F3;\n                  return (function(W, re) {\n                    return new Promise((fe, pe) => {\n                      var ze;\n                      let Ke = new XMLHttpRequest();\n                      Ke.open(W.method || "GET", W.url, true), W.type !== "arrayBuffer" && W.type !== "image" || (Ke.responseType = "arraybuffer");\n                      for (let ct in W.headers) Ke.setRequestHeader(ct, W.headers[ct]);\n                      W.type === "json" && (Ke.responseType = "text", !((ze = W.headers) === null || ze === void 0) && ze.Accept || Ke.setRequestHeader("Accept", "application/json")), Ke.withCredentials = W.credentials === "include", Ke.onerror = () => {\n                        pe(new Error(Ke.statusText));\n                      }, Ke.onload = () => {\n                        if (!re.signal.aborted) if ((Ke.status >= 200 && Ke.status < 300 || Ke.status === 0) && Ke.response !== null) {\n                          let ct = Ke.response;\n                          if (W.type === "json") try {\n                            ct = JSON.parse(Ke.response);\n                          } catch (Lt) {\n                            return void pe(Lt);\n                          }\n                          fe({ data: ct, cacheControl: Ke.getResponseHeader("Cache-Control"), expires: Ke.getResponseHeader("Expires") });\n                        } else {\n                          let ct = new Blob([Ke.response], { type: Ke.getResponseHeader("Content-Type") });\n                          pe(new me(Ke.status, Ke.statusText, W.url, ct));\n                        }\n                      }, re.signal.addEventListener("abort", () => {\n                        Ke.abort(), pe(oe());\n                      }), Ke.send(W.body);\n                    });\n                  })(R, A3);\n                };\n                function Le(R) {\n                  if (!R || R.indexOf("://") <= 0 || R.indexOf("data:image/") === 0 || R.indexOf("blob:") === 0) return true;\n                  let A3 = new URL(R), F3 = window.location;\n                  return A3.protocol === F3.protocol && A3.host === F3.host;\n                }\n                function Ae(R, A3, F3) {\n                  F3[R] && F3[R].indexOf(A3) !== -1 || (F3[R] = F3[R] || [], F3[R].push(A3));\n                }\n                function Fe(R, A3, F3) {\n                  if (F3 && F3[R]) {\n                    let W = F3[R].indexOf(A3);\n                    W !== -1 && F3[R].splice(W, 1);\n                  }\n                }\n                class Pe {\n                  constructor(A3, F3 = {}) {\n                    L3(this, F3), this.type = A3;\n                  }\n                }\n                class ge extends Pe {\n                  constructor(A3, F3 = {}) {\n                    super("error", L3({ error: A3 }, F3));\n                  }\n                }\n                class Re {\n                  on(A3, F3) {\n                    return this._listeners = this._listeners || {}, Ae(A3, F3, this._listeners), this;\n                  }\n                  off(A3, F3) {\n                    return Fe(A3, F3, this._listeners), Fe(A3, F3, this._oneTimeListeners), this;\n                  }\n                  once(A3, F3) {\n                    return F3 ? (this._oneTimeListeners = this._oneTimeListeners || {}, Ae(A3, F3, this._oneTimeListeners), this) : new Promise((W) => this.once(A3, W));\n                  }\n                  fire(A3, F3) {\n                    typeof A3 == "string" && (A3 = new Pe(A3, F3 || {}));\n                    let W = A3.type;\n                    if (this.listens(W)) {\n                      A3.target = this;\n                      let re = this._listeners && this._listeners[W] ? this._listeners[W].slice() : [];\n                      for (let ze of re) ze.call(this, A3);\n                      let fe = this._oneTimeListeners && this._oneTimeListeners[W] ? this._oneTimeListeners[W].slice() : [];\n                      for (let ze of fe) Fe(W, ze, this._oneTimeListeners), ze.call(this, A3);\n                      let pe = this._eventedParent;\n                      pe && (L3(A3, typeof this._eventedParentData == "function" ? this._eventedParentData() : this._eventedParentData), pe.fire(A3));\n                    } else A3 instanceof ge && console.error(A3.error);\n                    return this;\n                  }\n                  listens(A3) {\n                    return this._listeners && this._listeners[A3] && this._listeners[A3].length > 0 || this._oneTimeListeners && this._oneTimeListeners[A3] && this._oneTimeListeners[A3].length > 0 || this._eventedParent && this._eventedParent.listens(A3);\n                  }\n                  setEventedParent(A3, F3) {\n                    return this._eventedParent = A3, this._eventedParentData = F3, this;\n                  }\n                }\n                var ce = { $version: 8, $root: { version: { required: true, type: "enum", values: [8] }, name: { type: "string" }, metadata: { type: "*" }, center: { type: "array", value: "number" }, zoom: { type: "number" }, bearing: { type: "number", default: 0, period: 360, units: "degrees" }, pitch: { type: "number", default: 0, units: "degrees" }, light: { type: "light" }, sky: { type: "sky" }, projection: { type: "projection" }, terrain: { type: "terrain" }, sources: { required: true, type: "sources" }, sprite: { type: "sprite" }, glyphs: { type: "string" }, transition: { type: "transition" }, layers: { required: true, type: "array", value: "layer" } }, sources: { "*": { type: "source" } }, source: ["source_vector", "source_raster", "source_raster_dem", "source_geojson", "source_video", "source_image"], source_vector: { type: { required: true, type: "enum", values: { vector: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, attribution: { type: "string" }, promoteId: { type: "promoteId" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster: { type: { required: true, type: "enum", values: { raster: {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, scheme: { type: "enum", values: { xyz: {}, tms: {} }, default: "xyz" }, attribution: { type: "string" }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_raster_dem: { type: { required: true, type: "enum", values: { "raster-dem": {} } }, url: { type: "string" }, tiles: { type: "array", value: "string" }, bounds: { type: "array", value: "number", length: 4, default: [-180, -85.051129, 180, 85.051129] }, minzoom: { type: "number", default: 0 }, maxzoom: { type: "number", default: 22 }, tileSize: { type: "number", default: 512, units: "pixels" }, attribution: { type: "string" }, encoding: { type: "enum", values: { terrarium: {}, mapbox: {}, custom: {} }, default: "mapbox" }, redFactor: { type: "number", default: 1 }, blueFactor: { type: "number", default: 1 }, greenFactor: { type: "number", default: 1 }, baseShift: { type: "number", default: 0 }, volatile: { type: "boolean", default: false }, "*": { type: "*" } }, source_geojson: { type: { required: true, type: "enum", values: { geojson: {} } }, data: { required: true, type: "*" }, maxzoom: { type: "number", default: 18 }, attribution: { type: "string" }, buffer: { type: "number", default: 128, maximum: 512, minimum: 0 }, filter: { type: "*" }, tolerance: { type: "number", default: 0.375 }, cluster: { type: "boolean", default: false }, clusterRadius: { type: "number", default: 50, minimum: 0 }, clusterMaxZoom: { type: "number" }, clusterMinPoints: { type: "number" }, clusterProperties: { type: "*" }, lineMetrics: { type: "boolean", default: false }, generateId: { type: "boolean", default: false }, promoteId: { type: "promoteId" } }, source_video: { type: { required: true, type: "enum", values: { video: {} } }, urls: { required: true, type: "array", value: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, source_image: { type: { required: true, type: "enum", values: { image: {} } }, url: { required: true, type: "string" }, coordinates: { required: true, type: "array", length: 4, value: { type: "array", length: 2, value: "number" } } }, layer: { id: { type: "string", required: true }, type: { type: "enum", values: { fill: {}, line: {}, symbol: {}, circle: {}, heatmap: {}, "fill-extrusion": {}, raster: {}, hillshade: {}, background: {} }, required: true }, metadata: { type: "*" }, source: { type: "string" }, "source-layer": { type: "string" }, minzoom: { type: "number", minimum: 0, maximum: 24 }, maxzoom: { type: "number", minimum: 0, maximum: 24 }, filter: { type: "filter" }, layout: { type: "layout" }, paint: { type: "paint" } }, layout: ["layout_fill", "layout_line", "layout_circle", "layout_heatmap", "layout_fill-extrusion", "layout_symbol", "layout_raster", "layout_hillshade", "layout_background"], layout_background: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_fill: { "fill-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_circle: { "circle-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_heatmap: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, "layout_fill-extrusion": { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_line: { "line-cap": { type: "enum", values: { butt: {}, round: {}, square: {} }, default: "butt", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-join": { type: "enum", values: { bevel: {}, round: {}, miter: {} }, default: "miter", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "line-miter-limit": { type: "number", default: 2, requires: [{ "line-join": "miter" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-round-limit": { type: "number", default: 1.05, requires: [{ "line-join": "round" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_symbol: { "symbol-placement": { type: "enum", values: { point: {}, line: {}, "line-center": {} }, default: "point", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-spacing": { type: "number", default: 250, minimum: 1, units: "pixels", requires: [{ "symbol-placement": "line" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-avoid-edges": { type: "boolean", default: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "symbol-sort-key": { type: "number", expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "symbol-z-order": { type: "enum", values: { auto: {}, "viewport-y": {}, source: {} }, default: "auto", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-allow-overlap": { type: "boolean", default: false, requires: ["icon-image", { "!": "icon-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-ignore-placement": { type: "boolean", default: false, requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-optional": { type: "boolean", default: false, requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-size": { type: "number", default: 1, minimum: 0, units: "factor of the original icon size", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-text-fit": { type: "enum", values: { none: {}, width: {}, height: {}, both: {} }, default: "none", requires: ["icon-image", "text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-text-fit-padding": { type: "array", value: "number", length: 4, default: [0, 0, 0, 0], units: "pixels", requires: ["icon-image", "text-field", { "icon-text-fit": ["both", "width", "height"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-image": { type: "resolvedImage", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-padding": { type: "padding", default: [2], units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-keep-upright": { type: "boolean", default: false, requires: ["icon-image", { "icon-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-offset": { type: "array", value: "number", length: 2, default: [0, 0], requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "icon-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-pitch-alignment": { type: "enum", values: { map: {}, viewport: {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotation-alignment": { type: "enum", values: { map: {}, viewport: {}, "viewport-glyph": {}, auto: {} }, default: "auto", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-field": { type: "formatted", default: "", tokens: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-font": { type: "array", value: "string", default: ["Open Sans Regular", "Arial Unicode MS Regular"], requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-size": { type: "number", default: 16, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-width": { type: "number", default: 10, minimum: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-line-height": { type: "number", default: 1.2, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-letter-spacing": { type: "number", default: 0, units: "ems", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-justify": { type: "enum", values: { auto: {}, left: {}, center: {}, right: {} }, default: "center", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-radial-offset": { type: "number", units: "ems", default: 0, requires: ["text-field"], "property-type": "data-driven", expression: { interpolated: true, parameters: ["zoom", "feature"] } }, "text-variable-anchor": { type: "array", value: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-variable-anchor-offset": { type: "variableAnchorOffsetCollection", requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-anchor": { type: "enum", values: { center: {}, left: {}, right: {}, top: {}, bottom: {}, "top-left": {}, "top-right": {}, "bottom-left": {}, "bottom-right": {} }, default: "center", requires: ["text-field", { "!": "text-variable-anchor" }], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-max-angle": { type: "number", default: 45, units: "degrees", requires: ["text-field", { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-writing-mode": { type: "array", value: "enum", values: { horizontal: {}, vertical: {} }, requires: ["text-field", { "symbol-placement": ["point"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-rotate": { type: "number", default: 0, period: 360, units: "degrees", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-padding": { type: "number", default: 2, minimum: 0, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-keep-upright": { type: "boolean", default: true, requires: ["text-field", { "text-rotation-alignment": "map" }, { "symbol-placement": ["line", "line-center"] }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-transform": { type: "enum", values: { none: {}, uppercase: {}, lowercase: {} }, default: "none", requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-offset": { type: "array", value: "number", units: "ems", length: 2, default: [0, 0], requires: ["text-field", { "!": "text-radial-offset" }], expression: { interpolated: true, parameters: ["zoom", "feature"] }, "property-type": "data-driven" }, "text-allow-overlap": { type: "boolean", default: false, requires: ["text-field", { "!": "text-overlap" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-overlap": { type: "enum", values: { never: {}, always: {}, cooperative: {} }, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-ignore-placement": { type: "boolean", default: false, requires: ["text-field"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-optional": { type: "boolean", default: false, requires: ["text-field", "icon-image"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_raster: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, layout_hillshade: { visibility: { type: "enum", values: { visible: {}, none: {} }, default: "visible", "property-type": "constant" } }, filter: { type: "array", value: "*" }, filter_operator: { type: "enum", values: { "==": {}, "!=": {}, ">": {}, ">=": {}, "<": {}, "<=": {}, in: {}, "!in": {}, all: {}, any: {}, none: {}, has: {}, "!has": {} } }, geometry_type: { type: "enum", values: { Point: {}, LineString: {}, Polygon: {} } }, function: { expression: { type: "expression" }, stops: { type: "array", value: "function_stop" }, base: { type: "number", default: 1, minimum: 0 }, property: { type: "string", default: "$zoom" }, type: { type: "enum", values: { identity: {}, exponential: {}, interval: {}, categorical: {} }, default: "exponential" }, colorSpace: { type: "enum", values: { rgb: {}, lab: {}, hcl: {} }, default: "rgb" }, default: { type: "*", required: false } }, function_stop: { type: "array", minimum: 0, maximum: 24, value: ["number", "color"], length: 2 }, expression: { type: "array", value: "*", minimum: 1 }, light: { anchor: { type: "enum", default: "viewport", values: { map: {}, viewport: {} }, "property-type": "data-constant", transition: false, expression: { interpolated: false, parameters: ["zoom"] } }, position: { type: "array", default: [1.15, 210, 30], length: 3, value: "number", "property-type": "data-constant", transition: true, expression: { interpolated: true, parameters: ["zoom"] } }, color: { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, intensity: { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, sky: { "sky-color": { type: "color", "property-type": "data-constant", default: "#88C6FC", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-color": { type: "color", "property-type": "data-constant", default: "#ffffff", expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "fog-ground-blend": { type: "number", "property-type": "data-constant", default: 0.5, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "horizon-fog-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "sky-horizon-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true }, "atmosphere-blend": { type: "number", "property-type": "data-constant", default: 0.8, minimum: 0, maximum: 1, expression: { interpolated: true, parameters: ["zoom"] }, transition: true } }, terrain: { source: { type: "string", required: true }, exaggeration: { type: "number", minimum: 0, default: 1 } }, projection: { type: { type: "enum", default: "mercator", values: { mercator: {}, globe: {} } } }, paint: ["paint_fill", "paint_line", "paint_circle", "paint_heatmap", "paint_fill-extrusion", "paint_symbol", "paint_raster", "paint_hillshade", "paint_background"], paint_fill: { "fill-antialias": { type: "boolean", default: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-outline-color": { type: "color", transition: true, requires: [{ "!": "fill-pattern" }, { "fill-antialias": true }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" } }, "paint_fill-extrusion": { "fill-extrusion-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "fill-extrusion-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["fill-extrusion-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "fill-extrusion-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "fill-extrusion-height": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-base": { type: "number", default: 0, minimum: 0, units: "meters", transition: true, requires: ["fill-extrusion-height"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "fill-extrusion-vertical-gradient": { type: "boolean", default: true, transition: false, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_line: { "line-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "line-pattern" }], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["line-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "line-width": { type: "number", default: 1, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-gap-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-offset": { type: "number", default: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "line-dasharray": { type: "array", value: "number", minimum: 0, transition: true, units: "line widths", requires: [{ "!": "line-pattern" }], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "line-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom", "feature"] }, "property-type": "cross-faded-data-driven" }, "line-gradient": { type: "color", transition: false, requires: [{ "!": "line-dasharray" }, { "!": "line-pattern" }, { source: "geojson", has: { lineMetrics: true } }], expression: { interpolated: true, parameters: ["line-progress"] }, "property-type": "color-ramp" } }, paint_circle: { "circle-radius": { type: "number", default: 5, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-blur": { type: "number", default: 0, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["circle-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-scale": { type: "enum", values: { map: {}, viewport: {} }, default: "map", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-pitch-alignment": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "circle-stroke-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "circle-stroke-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" } }, paint_heatmap: { "heatmap-radius": { type: "number", default: 30, minimum: 1, transition: true, units: "pixels", expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-weight": { type: "number", default: 1, minimum: 0, transition: false, expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "heatmap-intensity": { type: "number", default: 1, minimum: 0, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "heatmap-color": { type: "color", default: ["interpolate", ["linear"], ["heatmap-density"], 0, "rgba(0, 0, 255, 0)", 0.1, "royalblue", 0.3, "cyan", 0.5, "lime", 0.7, "yellow", 1, "red"], transition: false, expression: { interpolated: true, parameters: ["heatmap-density"] }, "property-type": "color-ramp" }, "heatmap-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_symbol: { "icon-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-color": { type: "color", default: "#000000", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "icon-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["icon-image"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "icon-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["icon-image", "icon-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-color": { type: "color", default: "#000000", transition: true, overridable: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-color": { type: "color", default: "rgba(0, 0, 0, 0)", transition: true, requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-width": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-halo-blur": { type: "number", default: 0, minimum: 0, transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom", "feature", "feature-state"] }, "property-type": "data-driven" }, "text-translate": { type: "array", value: "number", length: 2, default: [0, 0], transition: true, units: "pixels", requires: ["text-field"], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "text-translate-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "map", requires: ["text-field", "text-translate"], expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_raster: { "raster-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-hue-rotate": { type: "number", default: 0, period: 360, transition: true, units: "degrees", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-min": { type: "number", default: 0, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-brightness-max": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-saturation": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-contrast": { type: "number", default: 0, minimum: -1, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-resampling": { type: "enum", values: { linear: {}, nearest: {} }, default: "linear", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "raster-fade-duration": { type: "number", default: 300, minimum: 0, transition: false, units: "milliseconds", expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_hillshade: { "hillshade-illumination-direction": { type: "number", default: 335, minimum: 0, maximum: 359, transition: false, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-illumination-anchor": { type: "enum", values: { map: {}, viewport: {} }, default: "viewport", expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-exaggeration": { type: "number", default: 0.5, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-shadow-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-highlight-color": { type: "color", default: "#FFFFFF", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "hillshade-accent-color": { type: "color", default: "#000000", transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, paint_background: { "background-color": { type: "color", default: "#000000", transition: true, requires: [{ "!": "background-pattern" }], expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" }, "background-pattern": { type: "resolvedImage", transition: true, expression: { interpolated: false, parameters: ["zoom"] }, "property-type": "cross-faded" }, "background-opacity": { type: "number", default: 1, minimum: 0, maximum: 1, transition: true, expression: { interpolated: true, parameters: ["zoom"] }, "property-type": "data-constant" } }, transition: { duration: { type: "number", default: 300, minimum: 0, units: "milliseconds" }, delay: { type: "number", default: 0, minimum: 0, units: "milliseconds" } }, "property-type": { "data-driven": { type: "property-type" }, "cross-faded": { type: "property-type" }, "cross-faded-data-driven": { type: "property-type" }, "color-ramp": { type: "property-type" }, "data-constant": { type: "property-type" }, constant: { type: "property-type" } }, promoteId: { "*": { type: "string" } } };\n                let Ze = ["type", "source", "source-layer", "minzoom", "maxzoom", "filter", "layout"];\n                function ut(R, A3) {\n                  let F3 = {};\n                  for (let W in R) W !== "ref" && (F3[W] = R[W]);\n                  return Ze.forEach((W) => {\n                    W in A3 && (F3[W] = A3[W]);\n                  }), F3;\n                }\n                function pt(R, A3) {\n                  if (Array.isArray(R)) {\n                    if (!Array.isArray(A3) || R.length !== A3.length) return false;\n                    for (let F3 = 0; F3 < R.length; F3++) if (!pt(R[F3], A3[F3])) return false;\n                    return true;\n                  }\n                  if (typeof R == "object" && R !== null && A3 !== null) {\n                    if (typeof A3 != "object" || Object.keys(R).length !== Object.keys(A3).length) return false;\n                    for (let F3 in R) if (!pt(R[F3], A3[F3])) return false;\n                    return true;\n                  }\n                  return R === A3;\n                }\n                function Zt(R, A3) {\n                  R.push(A3);\n                }\n                function st(R, A3, F3) {\n                  Zt(F3, { command: "addSource", args: [R, A3[R]] });\n                }\n                function lt(R, A3, F3) {\n                  Zt(A3, { command: "removeSource", args: [R] }), F3[R] = true;\n                }\n                function Gt(R, A3, F3, W) {\n                  lt(R, F3, W), st(R, A3, F3);\n                }\n                function Nt(R, A3, F3) {\n                  let W;\n                  for (W in R[F3]) if (Object.prototype.hasOwnProperty.call(R[F3], W) && W !== "data" && !pt(R[F3][W], A3[F3][W])) return false;\n                  for (W in A3[F3]) if (Object.prototype.hasOwnProperty.call(A3[F3], W) && W !== "data" && !pt(R[F3][W], A3[F3][W])) return false;\n                  return true;\n                }\n                function Jt(R, A3, F3, W, re, fe) {\n                  R = R || {}, A3 = A3 || {};\n                  for (let pe in R) Object.prototype.hasOwnProperty.call(R, pe) && (pt(R[pe], A3[pe]) || F3.push({ command: fe, args: [W, pe, A3[pe], re] }));\n                  for (let pe in A3) Object.prototype.hasOwnProperty.call(A3, pe) && !Object.prototype.hasOwnProperty.call(R, pe) && (pt(R[pe], A3[pe]) || F3.push({ command: fe, args: [W, pe, A3[pe], re] }));\n                }\n                function sr(R) {\n                  return R.id;\n                }\n                function wr(R, A3) {\n                  return R[A3.id] = A3, R;\n                }\n                class cr {\n                  constructor(A3, F3, W, re) {\n                    this.message = (A3 ? `${A3}: ` : "") + W, re && (this.identifier = re), F3 != null && F3.__line__ && (this.line = F3.__line__);\n                  }\n                }\n                function $e(R, ...A3) {\n                  for (let F3 of A3) for (let W in F3) R[W] = F3[W];\n                  return R;\n                }\n                class St extends Error {\n                  constructor(A3, F3) {\n                    super(F3), this.message = F3, this.key = A3;\n                  }\n                }\n                class Qt {\n                  constructor(A3, F3 = []) {\n                    this.parent = A3, this.bindings = {};\n                    for (let [W, re] of F3) this.bindings[W] = re;\n                  }\n                  concat(A3) {\n                    return new Qt(this, A3);\n                  }\n                  get(A3) {\n                    if (this.bindings[A3]) return this.bindings[A3];\n                    if (this.parent) return this.parent.get(A3);\n                    throw new Error(`${A3} not found in scope.`);\n                  }\n                  has(A3) {\n                    return !!this.bindings[A3] || !!this.parent && this.parent.has(A3);\n                  }\n                }\n                let Vt = { kind: "null" }, _t = { kind: "number" }, It = { kind: "string" }, mt = { kind: "boolean" }, er = { kind: "color" }, lr = { kind: "object" }, Tr = { kind: "value" }, Lr = { kind: "collator" }, ti = { kind: "formatted" }, Br = { kind: "padding" }, Vr = { kind: "resolvedImage" }, dt = { kind: "variableAnchorOffsetCollection" };\n                function Ge(R, A3) {\n                  return { kind: "array", itemType: R, N: A3 };\n                }\n                function Je(R) {\n                  if (R.kind === "array") {\n                    let A3 = Je(R.itemType);\n                    return typeof R.N == "number" ? `array<${A3}, ${R.N}>` : R.itemType.kind === "value" ? "array" : `array<${A3}>`;\n                  }\n                  return R.kind;\n                }\n                let je = [Vt, _t, It, mt, er, ti, lr, Ge(Tr), Br, Vr, dt];\n                function tt(R, A3) {\n                  if (A3.kind === "error") return null;\n                  if (R.kind === "array") {\n                    if (A3.kind === "array" && (A3.N === 0 && A3.itemType.kind === "value" || !tt(R.itemType, A3.itemType)) && (typeof R.N != "number" || R.N === A3.N)) return null;\n                  } else {\n                    if (R.kind === A3.kind) return null;\n                    if (R.kind === "value") {\n                      for (let F3 of je) if (!tt(F3, A3)) return null;\n                    }\n                  }\n                  return `Expected ${Je(R)} but found ${Je(A3)} instead.`;\n                }\n                function xt(R, A3) {\n                  return A3.some((F3) => F3.kind === R.kind);\n                }\n                function Ie(R, A3) {\n                  return A3.some((F3) => F3 === "null" ? R === null : F3 === "array" ? Array.isArray(R) : F3 === "object" ? R && !Array.isArray(R) && typeof R == "object" : F3 === typeof R);\n                }\n                function xe(R, A3) {\n                  return R.kind === "array" && A3.kind === "array" ? R.itemType.kind === A3.itemType.kind && typeof R.N == "number" : R.kind === A3.kind;\n                }\n                let ke = 0.96422, vt = 0.82521, ir = 4 / 29, ar = 6 / 29, vr = 3 * ar * ar, ii = ar * ar * ar, pi = Math.PI / 180, $r = 180 / Math.PI;\n                function di(R) {\n                  return (R %= 360) < 0 && (R += 360), R;\n                }\n                function ji([R, A3, F3, W]) {\n                  let re, fe, pe = wi((0.2225045 * (R = In(R)) + 0.7168786 * (A3 = In(A3)) + 0.0606169 * (F3 = In(F3))) / 1);\n                  R === A3 && A3 === F3 ? re = fe = pe : (re = wi((0.4360747 * R + 0.3850649 * A3 + 0.1430804 * F3) / ke), fe = wi((0.0139322 * R + 0.0971045 * A3 + 0.7141733 * F3) / vt));\n                  let ze = 116 * pe - 16;\n                  return [ze < 0 ? 0 : ze, 500 * (re - pe), 200 * (pe - fe), W];\n                }\n                function In(R) {\n                  return R <= 0.04045 ? R / 12.92 : Math.pow((R + 0.055) / 1.055, 2.4);\n                }\n                function wi(R) {\n                  return R > ii ? Math.pow(R, 1 / 3) : R / vr + ir;\n                }\n                function On([R, A3, F3, W]) {\n                  let re = (R + 16) / 116, fe = isNaN(A3) ? re : re + A3 / 500, pe = isNaN(F3) ? re : re - F3 / 200;\n                  return re = 1 * Fn(re), fe = ke * Fn(fe), pe = vt * Fn(pe), [qn(3.1338561 * fe - 1.6168667 * re - 0.4906146 * pe), qn(-0.9787684 * fe + 1.9161415 * re + 0.033454 * pe), qn(0.0719453 * fe - 0.2289914 * re + 1.4052427 * pe), W];\n                }\n                function qn(R) {\n                  return (R = R <= 304e-5 ? 12.92 * R : 1.055 * Math.pow(R, 1 / 2.4) - 0.055) < 0 ? 0 : R > 1 ? 1 : R;\n                }\n                function Fn(R) {\n                  return R > ar ? R * R * R : vr * (R - ir);\n                }\n                function ra(R) {\n                  return parseInt(R.padEnd(2, R), 16) / 255;\n                }\n                function la(R, A3) {\n                  return Ut(A3 ? R / 100 : R, 0, 1);\n                }\n                function Ut(R, A3, F3) {\n                  return Math.min(Math.max(A3, R), F3);\n                }\n                function wt(R) {\n                  return !R.some(Number.isNaN);\n                }\n                let rr = { aliceblue: [240, 248, 255], antiquewhite: [250, 235, 215], aqua: [0, 255, 255], aquamarine: [127, 255, 212], azure: [240, 255, 255], beige: [245, 245, 220], bisque: [255, 228, 196], black: [0, 0, 0], blanchedalmond: [255, 235, 205], blue: [0, 0, 255], blueviolet: [138, 43, 226], brown: [165, 42, 42], burlywood: [222, 184, 135], cadetblue: [95, 158, 160], chartreuse: [127, 255, 0], chocolate: [210, 105, 30], coral: [255, 127, 80], cornflowerblue: [100, 149, 237], cornsilk: [255, 248, 220], crimson: [220, 20, 60], cyan: [0, 255, 255], darkblue: [0, 0, 139], darkcyan: [0, 139, 139], darkgoldenrod: [184, 134, 11], darkgray: [169, 169, 169], darkgreen: [0, 100, 0], darkgrey: [169, 169, 169], darkkhaki: [189, 183, 107], darkmagenta: [139, 0, 139], darkolivegreen: [85, 107, 47], darkorange: [255, 140, 0], darkorchid: [153, 50, 204], darkred: [139, 0, 0], darksalmon: [233, 150, 122], darkseagreen: [143, 188, 143], darkslateblue: [72, 61, 139], darkslategray: [47, 79, 79], darkslategrey: [47, 79, 79], darkturquoise: [0, 206, 209], darkviolet: [148, 0, 211], deeppink: [255, 20, 147], deepskyblue: [0, 191, 255], dimgray: [105, 105, 105], dimgrey: [105, 105, 105], dodgerblue: [30, 144, 255], firebrick: [178, 34, 34], floralwhite: [255, 250, 240], forestgreen: [34, 139, 34], fuchsia: [255, 0, 255], gainsboro: [220, 220, 220], ghostwhite: [248, 248, 255], gold: [255, 215, 0], goldenrod: [218, 165, 32], gray: [128, 128, 128], green: [0, 128, 0], greenyellow: [173, 255, 47], grey: [128, 128, 128], honeydew: [240, 255, 240], hotpink: [255, 105, 180], indianred: [205, 92, 92], indigo: [75, 0, 130], ivory: [255, 255, 240], khaki: [240, 230, 140], lavender: [230, 230, 250], lavenderblush: [255, 240, 245], lawngreen: [124, 252, 0], lemonchiffon: [255, 250, 205], lightblue: [173, 216, 230], lightcoral: [240, 128, 128], lightcyan: [224, 255, 255], lightgoldenrodyellow: [250, 250, 210], lightgray: [211, 211, 211], lightgreen: [144, 238, 144], lightgrey: [211, 211, 211], lightpink: [255, 182, 193], lightsalmon: [255, 160, 122], lightseagreen: [32, 178, 170], lightskyblue: [135, 206, 250], lightslategray: [119, 136, 153], lightslategrey: [119, 136, 153], lightsteelblue: [176, 196, 222], lightyellow: [255, 255, 224], lime: [0, 255, 0], limegreen: [50, 205, 50], linen: [250, 240, 230], magenta: [255, 0, 255], maroon: [128, 0, 0], mediumaquamarine: [102, 205, 170], mediumblue: [0, 0, 205], mediumorchid: [186, 85, 211], mediumpurple: [147, 112, 219], mediumseagreen: [60, 179, 113], mediumslateblue: [123, 104, 238], mediumspringgreen: [0, 250, 154], mediumturquoise: [72, 209, 204], mediumvioletred: [199, 21, 133], midnightblue: [25, 25, 112], mintcream: [245, 255, 250], mistyrose: [255, 228, 225], moccasin: [255, 228, 181], navajowhite: [255, 222, 173], navy: [0, 0, 128], oldlace: [253, 245, 230], olive: [128, 128, 0], olivedrab: [107, 142, 35], orange: [255, 165, 0], orangered: [255, 69, 0], orchid: [218, 112, 214], palegoldenrod: [238, 232, 170], palegreen: [152, 251, 152], paleturquoise: [175, 238, 238], palevioletred: [219, 112, 147], papayawhip: [255, 239, 213], peachpuff: [255, 218, 185], peru: [205, 133, 63], pink: [255, 192, 203], plum: [221, 160, 221], powderblue: [176, 224, 230], purple: [128, 0, 128], rebeccapurple: [102, 51, 153], red: [255, 0, 0], rosybrown: [188, 143, 143], royalblue: [65, 105, 225], saddlebrown: [139, 69, 19], salmon: [250, 128, 114], sandybrown: [244, 164, 96], seagreen: [46, 139, 87], seashell: [255, 245, 238], sienna: [160, 82, 45], silver: [192, 192, 192], skyblue: [135, 206, 235], slateblue: [106, 90, 205], slategray: [112, 128, 144], slategrey: [112, 128, 144], snow: [255, 250, 250], springgreen: [0, 255, 127], steelblue: [70, 130, 180], tan: [210, 180, 140], teal: [0, 128, 128], thistle: [216, 191, 216], tomato: [255, 99, 71], turquoise: [64, 224, 208], violet: [238, 130, 238], wheat: [245, 222, 179], white: [255, 255, 255], whitesmoke: [245, 245, 245], yellow: [255, 255, 0], yellowgreen: [154, 205, 50] };\n                class nr {\n                  constructor(A3, F3, W, re = 1, fe = true) {\n                    this.r = A3, this.g = F3, this.b = W, this.a = re, fe || (this.r *= re, this.g *= re, this.b *= re, re || this.overwriteGetter("rgb", [A3, F3, W, re]));\n                  }\n                  static parse(A3) {\n                    if (A3 instanceof nr) return A3;\n                    if (typeof A3 != "string") return;\n                    let F3 = (function(W) {\n                      if ((W = W.toLowerCase().trim()) === "transparent") return [0, 0, 0, 0];\n                      let re = rr[W];\n                      if (re) {\n                        let [pe, ze, Ke] = re;\n                        return [pe / 255, ze / 255, Ke / 255, 1];\n                      }\n                      if (W.startsWith("#") && /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(W)) {\n                        let pe = W.length < 6 ? 1 : 2, ze = 1;\n                        return [ra(W.slice(ze, ze += pe)), ra(W.slice(ze, ze += pe)), ra(W.slice(ze, ze += pe)), ra(W.slice(ze, ze + pe) || "ff")];\n                      }\n                      if (W.startsWith("rgb")) {\n                        let pe = W.match(/^rgba?\\(\\s*([\\de.+-]+)(%)?(?:\\s+|\\s*(,)\\s*)([\\de.+-]+)(%)?(?:\\s+|\\s*(,)\\s*)([\\de.+-]+)(%)?(?:\\s*([,\\/])\\s*([\\de.+-]+)(%)?)?\\s*\\)$/);\n                        if (pe) {\n                          let [ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi, vn] = pe, zi = [Lt || " ", mr || " ", ui].join("");\n                          if (zi === "  " || zi === "  /" || zi === ",," || zi === ",,,") {\n                            let un = [ct, fr, zr].join(""), Tn = un === "%%%" ? 100 : un === "" ? 255 : 0;\n                            if (Tn) {\n                              let pa = [Ut(+Ke / Tn, 0, 1), Ut(+$t / Tn, 0, 1), Ut(+Pr / Tn, 0, 1), yi ? la(+yi, vn) : 1];\n                              if (wt(pa)) return pa;\n                            }\n                          }\n                          return;\n                        }\n                      }\n                      let fe = W.match(/^hsla?\\(\\s*([\\de.+-]+)(?:deg)?(?:\\s+|\\s*(,)\\s*)([\\de.+-]+)%(?:\\s+|\\s*(,)\\s*)([\\de.+-]+)%(?:\\s*([,\\/])\\s*([\\de.+-]+)(%)?)?\\s*\\)$/);\n                      if (fe) {\n                        let [pe, ze, Ke, ct, Lt, $t, fr, mr, Pr] = fe, zr = [Ke || " ", Lt || " ", fr].join("");\n                        if (zr === "  " || zr === "  /" || zr === ",," || zr === ",,,") {\n                          let ui = [+ze, Ut(+ct, 0, 100), Ut(+$t, 0, 100), mr ? la(+mr, Pr) : 1];\n                          if (wt(ui)) return (function([yi, vn, zi, un]) {\n                            function Tn(pa) {\n                              let ro = (pa + yi / 30) % 12, Vo = vn * Math.min(zi, 1 - zi);\n                              return zi - Vo * Math.max(-1, Math.min(ro - 3, 9 - ro, 1));\n                            }\n                            return yi = di(yi), vn /= 100, zi /= 100, [Tn(0), Tn(8), Tn(4), un];\n                          })(ui);\n                        }\n                      }\n                    })(A3);\n                    return F3 ? new nr(...F3, false) : void 0;\n                  }\n                  get rgb() {\n                    let { r: A3, g: F3, b: W, a: re } = this, fe = re || 1 / 0;\n                    return this.overwriteGetter("rgb", [A3 / fe, F3 / fe, W / fe, re]);\n                  }\n                  get hcl() {\n                    return this.overwriteGetter("hcl", (function(A3) {\n                      let [F3, W, re, fe] = ji(A3), pe = Math.sqrt(W * W + re * re);\n                      return [Math.round(1e4 * pe) ? di(Math.atan2(re, W) * $r) : NaN, pe, F3, fe];\n                    })(this.rgb));\n                  }\n                  get lab() {\n                    return this.overwriteGetter("lab", ji(this.rgb));\n                  }\n                  overwriteGetter(A3, F3) {\n                    return Object.defineProperty(this, A3, { value: F3 }), F3;\n                  }\n                  toString() {\n                    let [A3, F3, W, re] = this.rgb;\n                    return `rgba(${[A3, F3, W].map((fe) => Math.round(255 * fe)).join(",")},${re})`;\n                  }\n                }\n                nr.black = new nr(0, 0, 0, 1), nr.white = new nr(1, 1, 1, 1), nr.transparent = new nr(0, 0, 0, 0), nr.red = new nr(1, 0, 0, 1);\n                class Er {\n                  constructor(A3, F3, W) {\n                    this.sensitivity = A3 ? F3 ? "variant" : "case" : F3 ? "accent" : "base", this.locale = W, this.collator = new Intl.Collator(this.locale ? this.locale : [], { sensitivity: this.sensitivity, usage: "search" });\n                  }\n                  compare(A3, F3) {\n                    return this.collator.compare(A3, F3);\n                  }\n                  resolvedLocale() {\n                    return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;\n                  }\n                }\n                class Xr {\n                  constructor(A3, F3, W, re, fe) {\n                    this.text = A3, this.image = F3, this.scale = W, this.fontStack = re, this.textColor = fe;\n                  }\n                }\n                class ri {\n                  constructor(A3) {\n                    this.sections = A3;\n                  }\n                  static fromString(A3) {\n                    return new ri([new Xr(A3, null, null, null, null)]);\n                  }\n                  isEmpty() {\n                    return this.sections.length === 0 || !this.sections.some((A3) => A3.text.length !== 0 || A3.image && A3.image.name.length !== 0);\n                  }\n                  static factory(A3) {\n                    return A3 instanceof ri ? A3 : ri.fromString(A3);\n                  }\n                  toString() {\n                    return this.sections.length === 0 ? "" : this.sections.map((A3) => A3.text).join("");\n                  }\n                }\n                class Qr {\n                  constructor(A3) {\n                    this.values = A3.slice();\n                  }\n                  static parse(A3) {\n                    if (A3 instanceof Qr) return A3;\n                    if (typeof A3 == "number") return new Qr([A3, A3, A3, A3]);\n                    if (Array.isArray(A3) && !(A3.length < 1 || A3.length > 4)) {\n                      for (let F3 of A3) if (typeof F3 != "number") return;\n                      switch (A3.length) {\n                        case 1:\n                          A3 = [A3[0], A3[0], A3[0], A3[0]];\n                          break;\n                        case 2:\n                          A3 = [A3[0], A3[1], A3[0], A3[1]];\n                          break;\n                        case 3:\n                          A3 = [A3[0], A3[1], A3[2], A3[1]];\n                      }\n                      return new Qr(A3);\n                    }\n                  }\n                  toString() {\n                    return JSON.stringify(this.values);\n                  }\n                }\n                let Oi = /* @__PURE__ */ new Set(["center", "left", "right", "top", "bottom", "top-left", "top-right", "bottom-left", "bottom-right"]);\n                class $i {\n                  constructor(A3) {\n                    this.values = A3.slice();\n                  }\n                  static parse(A3) {\n                    if (A3 instanceof $i) return A3;\n                    if (Array.isArray(A3) && !(A3.length < 1) && A3.length % 2 == 0) {\n                      for (let F3 = 0; F3 < A3.length; F3 += 2) {\n                        let W = A3[F3], re = A3[F3 + 1];\n                        if (typeof W != "string" || !Oi.has(W) || !Array.isArray(re) || re.length !== 2 || typeof re[0] != "number" || typeof re[1] != "number") return;\n                      }\n                      return new $i(A3);\n                    }\n                  }\n                  toString() {\n                    return JSON.stringify(this.values);\n                  }\n                }\n                class tn {\n                  constructor(A3) {\n                    this.name = A3.name, this.available = A3.available;\n                  }\n                  toString() {\n                    return this.name;\n                  }\n                  static fromString(A3) {\n                    return A3 ? new tn({ name: A3, available: false }) : null;\n                  }\n                }\n                function fn(R, A3, F3, W) {\n                  return typeof R == "number" && R >= 0 && R <= 255 && typeof A3 == "number" && A3 >= 0 && A3 <= 255 && typeof F3 == "number" && F3 >= 0 && F3 <= 255 ? W === void 0 || typeof W == "number" && W >= 0 && W <= 1 ? null : `Invalid rgba value [${[R, A3, F3, W].join(", ")}]: \'a\' must be between 0 and 1.` : `Invalid rgba value [${(typeof W == "number" ? [R, A3, F3, W] : [R, A3, F3]).join(", ")}]: \'r\', \'g\', and \'b\' must be between 0 and 255.`;\n                }\n                function yn(R) {\n                  if (R === null || typeof R == "string" || typeof R == "boolean" || typeof R == "number" || R instanceof nr || R instanceof Er || R instanceof ri || R instanceof Qr || R instanceof $i || R instanceof tn) return true;\n                  if (Array.isArray(R)) {\n                    for (let A3 of R) if (!yn(A3)) return false;\n                    return true;\n                  }\n                  if (typeof R == "object") {\n                    for (let A3 in R) if (!yn(R[A3])) return false;\n                    return true;\n                  }\n                  return false;\n                }\n                function Sn(R) {\n                  if (R === null) return Vt;\n                  if (typeof R == "string") return It;\n                  if (typeof R == "boolean") return mt;\n                  if (typeof R == "number") return _t;\n                  if (R instanceof nr) return er;\n                  if (R instanceof Er) return Lr;\n                  if (R instanceof ri) return ti;\n                  if (R instanceof Qr) return Br;\n                  if (R instanceof $i) return dt;\n                  if (R instanceof tn) return Vr;\n                  if (Array.isArray(R)) {\n                    let A3 = R.length, F3;\n                    for (let W of R) {\n                      let re = Sn(W);\n                      if (F3) {\n                        if (F3 === re) continue;\n                        F3 = Tr;\n                        break;\n                      }\n                      F3 = re;\n                    }\n                    return Ge(F3 || Tr, A3);\n                  }\n                  return lr;\n                }\n                function Ba(R) {\n                  let A3 = typeof R;\n                  return R === null ? "" : A3 === "string" || A3 === "number" || A3 === "boolean" ? String(R) : R instanceof nr || R instanceof ri || R instanceof Qr || R instanceof $i || R instanceof tn ? R.toString() : JSON.stringify(R);\n                }\n                class ua {\n                  constructor(A3, F3) {\n                    this.type = A3, this.value = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error(`\'literal\' expression requires exactly one argument, but found ${A3.length - 1} instead.`);\n                    if (!yn(A3[1])) return F3.error("invalid value");\n                    let W = A3[1], re = Sn(W), fe = F3.expectedType;\n                    return re.kind !== "array" || re.N !== 0 || !fe || fe.kind !== "array" || typeof fe.N == "number" && fe.N !== 0 || (re = fe), new ua(re, W);\n                  }\n                  evaluate() {\n                    return this.value;\n                  }\n                  eachChild() {\n                  }\n                  outputDefined() {\n                    return true;\n                  }\n                }\n                class ma {\n                  constructor(A3) {\n                    this.name = "ExpressionEvaluationError", this.message = A3;\n                  }\n                  toJSON() {\n                    return this.message;\n                  }\n                }\n                let Wa = { string: It, number: _t, boolean: mt, object: lr };\n                class Fa {\n                  constructor(A3, F3) {\n                    this.type = A3, this.args = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 2) return F3.error("Expected at least one argument.");\n                    let W, re = 1, fe = A3[0];\n                    if (fe === "array") {\n                      let ze, Ke;\n                      if (A3.length > 2) {\n                        let ct = A3[1];\n                        if (typeof ct != "string" || !(ct in Wa) || ct === "object") return F3.error(\'The item type argument of "array" must be one of string, number, boolean\', 1);\n                        ze = Wa[ct], re++;\n                      } else ze = Tr;\n                      if (A3.length > 3) {\n                        if (A3[2] !== null && (typeof A3[2] != "number" || A3[2] < 0 || A3[2] !== Math.floor(A3[2]))) return F3.error(\'The length argument to "array" must be a positive integer literal\', 2);\n                        Ke = A3[2], re++;\n                      }\n                      W = Ge(ze, Ke);\n                    } else {\n                      if (!Wa[fe]) throw new Error(`Types doesn\'t contain name = ${fe}`);\n                      W = Wa[fe];\n                    }\n                    let pe = [];\n                    for (; re < A3.length; re++) {\n                      let ze = F3.parse(A3[re], re, Tr);\n                      if (!ze) return null;\n                      pe.push(ze);\n                    }\n                    return new Fa(W, pe);\n                  }\n                  evaluate(A3) {\n                    for (let F3 = 0; F3 < this.args.length; F3++) {\n                      let W = this.args[F3].evaluate(A3);\n                      if (!tt(this.type, Sn(W))) return W;\n                      if (F3 === this.args.length - 1) throw new ma(`Expected value to be of type ${Je(this.type)}, but found ${Je(Sn(W))} instead.`);\n                    }\n                    throw new Error();\n                  }\n                  eachChild(A3) {\n                    this.args.forEach(A3);\n                  }\n                  outputDefined() {\n                    return this.args.every((A3) => A3.outputDefined());\n                  }\n                }\n                let Wo = { "to-boolean": mt, "to-color": er, "to-number": _t, "to-string": It };\n                class da {\n                  constructor(A3, F3) {\n                    this.type = A3, this.args = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 2) return F3.error("Expected at least one argument.");\n                    let W = A3[0];\n                    if (!Wo[W]) throw new Error(`Can\'t parse ${W} as it is not part of the known types`);\n                    if ((W === "to-boolean" || W === "to-string") && A3.length !== 2) return F3.error("Expected one argument.");\n                    let re = Wo[W], fe = [];\n                    for (let pe = 1; pe < A3.length; pe++) {\n                      let ze = F3.parse(A3[pe], pe, Tr);\n                      if (!ze) return null;\n                      fe.push(ze);\n                    }\n                    return new da(re, fe);\n                  }\n                  evaluate(A3) {\n                    switch (this.type.kind) {\n                      case "boolean":\n                        return !!this.args[0].evaluate(A3);\n                      case "color": {\n                        let F3, W;\n                        for (let re of this.args) {\n                          if (F3 = re.evaluate(A3), W = null, F3 instanceof nr) return F3;\n                          if (typeof F3 == "string") {\n                            let fe = A3.parseColor(F3);\n                            if (fe) return fe;\n                          } else if (Array.isArray(F3) && (W = F3.length < 3 || F3.length > 4 ? `Invalid rbga value ${JSON.stringify(F3)}: expected an array containing either three or four numeric values.` : fn(F3[0], F3[1], F3[2], F3[3]), !W)) return new nr(F3[0] / 255, F3[1] / 255, F3[2] / 255, F3[3]);\n                        }\n                        throw new ma(W || `Could not parse color from value \'${typeof F3 == "string" ? F3 : JSON.stringify(F3)}\'`);\n                      }\n                      case "padding": {\n                        let F3;\n                        for (let W of this.args) {\n                          F3 = W.evaluate(A3);\n                          let re = Qr.parse(F3);\n                          if (re) return re;\n                        }\n                        throw new ma(`Could not parse padding from value \'${typeof F3 == "string" ? F3 : JSON.stringify(F3)}\'`);\n                      }\n                      case "variableAnchorOffsetCollection": {\n                        let F3;\n                        for (let W of this.args) {\n                          F3 = W.evaluate(A3);\n                          let re = $i.parse(F3);\n                          if (re) return re;\n                        }\n                        throw new ma(`Could not parse variableAnchorOffsetCollection from value \'${typeof F3 == "string" ? F3 : JSON.stringify(F3)}\'`);\n                      }\n                      case "number": {\n                        let F3 = null;\n                        for (let W of this.args) {\n                          if (F3 = W.evaluate(A3), F3 === null) return 0;\n                          let re = Number(F3);\n                          if (!isNaN(re)) return re;\n                        }\n                        throw new ma(`Could not convert ${JSON.stringify(F3)} to number.`);\n                      }\n                      case "formatted":\n                        return ri.fromString(Ba(this.args[0].evaluate(A3)));\n                      case "resolvedImage":\n                        return tn.fromString(Ba(this.args[0].evaluate(A3)));\n                      default:\n                        return Ba(this.args[0].evaluate(A3));\n                    }\n                  }\n                  eachChild(A3) {\n                    this.args.forEach(A3);\n                  }\n                  outputDefined() {\n                    return this.args.every((A3) => A3.outputDefined());\n                  }\n                }\n                let Wn = ["Unknown", "Point", "LineString", "Polygon"];\n                class Ha {\n                  constructor() {\n                    this.globals = null, this.feature = null, this.featureState = null, this.formattedSection = null, this._parseColorCache = {}, this.availableImages = null, this.canonical = null;\n                  }\n                  id() {\n                    return this.feature && "id" in this.feature ? this.feature.id : null;\n                  }\n                  geometryType() {\n                    return this.feature ? typeof this.feature.type == "number" ? Wn[this.feature.type] : this.feature.type : null;\n                  }\n                  geometry() {\n                    return this.feature && "geometry" in this.feature ? this.feature.geometry : null;\n                  }\n                  canonicalID() {\n                    return this.canonical;\n                  }\n                  properties() {\n                    return this.feature && this.feature.properties || {};\n                  }\n                  parseColor(A3) {\n                    let F3 = this._parseColorCache[A3];\n                    return F3 || (F3 = this._parseColorCache[A3] = nr.parse(A3)), F3;\n                  }\n                }\n                class vo {\n                  constructor(A3, F3, W = [], re, fe = new Qt(), pe = []) {\n                    this.registry = A3, this.path = W, this.key = W.map((ze) => `[${ze}]`).join(""), this.scope = fe, this.errors = pe, this.expectedType = re, this._isConstant = F3;\n                  }\n                  parse(A3, F3, W, re, fe = {}) {\n                    return F3 ? this.concat(F3, W, re)._parse(A3, fe) : this._parse(A3, fe);\n                  }\n                  _parse(A3, F3) {\n                    function W(re, fe, pe) {\n                      return pe === "assert" ? new Fa(fe, [re]) : pe === "coerce" ? new da(fe, [re]) : re;\n                    }\n                    if (A3 !== null && typeof A3 != "string" && typeof A3 != "boolean" && typeof A3 != "number" || (A3 = ["literal", A3]), Array.isArray(A3)) {\n                      if (A3.length === 0) return this.error(\'Expected an array with at least one element. If you wanted a literal array, use ["literal", []].\');\n                      let re = A3[0];\n                      if (typeof re != "string") return this.error(`Expression name must be a string, but found ${typeof re} instead. If you wanted a literal array, use ["literal", [...]].`, 0), null;\n                      let fe = this.registry[re];\n                      if (fe) {\n                        let pe = fe.parse(A3, this);\n                        if (!pe) return null;\n                        if (this.expectedType) {\n                          let ze = this.expectedType, Ke = pe.type;\n                          if (ze.kind !== "string" && ze.kind !== "number" && ze.kind !== "boolean" && ze.kind !== "object" && ze.kind !== "array" || Ke.kind !== "value") if (ze.kind !== "color" && ze.kind !== "formatted" && ze.kind !== "resolvedImage" || Ke.kind !== "value" && Ke.kind !== "string") if (ze.kind !== "padding" || Ke.kind !== "value" && Ke.kind !== "number" && Ke.kind !== "array") if (ze.kind !== "variableAnchorOffsetCollection" || Ke.kind !== "value" && Ke.kind !== "array") {\n                            if (this.checkSubtype(ze, Ke)) return null;\n                          } else pe = W(pe, ze, F3.typeAnnotation || "coerce");\n                          else pe = W(pe, ze, F3.typeAnnotation || "coerce");\n                          else pe = W(pe, ze, F3.typeAnnotation || "coerce");\n                          else pe = W(pe, ze, F3.typeAnnotation || "assert");\n                        }\n                        if (!(pe instanceof ua) && pe.type.kind !== "resolvedImage" && this._isConstant(pe)) {\n                          let ze = new Ha();\n                          try {\n                            pe = new ua(pe.type, pe.evaluate(ze));\n                          } catch (Ke) {\n                            return this.error(Ke.message), null;\n                          }\n                        }\n                        return pe;\n                      }\n                      return this.error(`Unknown expression "${re}". If you wanted a literal array, use ["literal", [...]].`, 0);\n                    }\n                    return this.error(A3 === void 0 ? "\'undefined\' value invalid. Use null instead." : typeof A3 == "object" ? \'Bare objects invalid. Use ["literal", {...}] instead.\' : `Expected an array, but found ${typeof A3} instead.`);\n                  }\n                  concat(A3, F3, W) {\n                    let re = typeof A3 == "number" ? this.path.concat(A3) : this.path, fe = W ? this.scope.concat(W) : this.scope;\n                    return new vo(this.registry, this._isConstant, re, F3 || null, fe, this.errors);\n                  }\n                  error(A3, ...F3) {\n                    let W = `${this.key}${F3.map((re) => `[${re}]`).join("")}`;\n                    this.errors.push(new St(W, A3));\n                  }\n                  checkSubtype(A3, F3) {\n                    let W = tt(A3, F3);\n                    return W && this.error(W), W;\n                  }\n                }\n                class jn {\n                  constructor(A3, F3) {\n                    this.type = F3.type, this.bindings = [].concat(A3), this.result = F3;\n                  }\n                  evaluate(A3) {\n                    return this.result.evaluate(A3);\n                  }\n                  eachChild(A3) {\n                    for (let F3 of this.bindings) A3(F3[1]);\n                    A3(this.result);\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 4) return F3.error(`Expected at least 3 arguments, but found ${A3.length - 1} instead.`);\n                    let W = [];\n                    for (let fe = 1; fe < A3.length - 1; fe += 2) {\n                      let pe = A3[fe];\n                      if (typeof pe != "string") return F3.error(`Expected string, but found ${typeof pe} instead.`, fe);\n                      if (/[^a-zA-Z0-9_]/.test(pe)) return F3.error("Variable names must contain only alphanumeric characters or \'_\'.", fe);\n                      let ze = F3.parse(A3[fe + 1], fe + 1);\n                      if (!ze) return null;\n                      W.push([pe, ze]);\n                    }\n                    let re = F3.parse(A3[A3.length - 1], A3.length - 1, F3.expectedType, W);\n                    return re ? new jn(W, re) : null;\n                  }\n                  outputDefined() {\n                    return this.result.outputDefined();\n                  }\n                }\n                class Mt {\n                  constructor(A3, F3) {\n                    this.type = F3.type, this.name = A3, this.boundExpression = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2 || typeof A3[1] != "string") return F3.error("\'var\' expression requires exactly one string literal argument.");\n                    let W = A3[1];\n                    return F3.scope.has(W) ? new Mt(W, F3.scope.get(W)) : F3.error(`Unknown variable "${W}". Make sure "${W}" has been bound in an enclosing "let" expression before using it.`, 1);\n                  }\n                  evaluate(A3) {\n                    return this.boundExpression.evaluate(A3);\n                  }\n                  eachChild() {\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class kr {\n                  constructor(A3, F3, W) {\n                    this.type = A3, this.index = F3, this.input = W;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 3) return F3.error(`Expected 2 arguments, but found ${A3.length - 1} instead.`);\n                    let W = F3.parse(A3[1], 1, _t), re = F3.parse(A3[2], 2, Ge(F3.expectedType || Tr));\n                    return W && re ? new kr(re.type.itemType, W, re) : null;\n                  }\n                  evaluate(A3) {\n                    let F3 = this.index.evaluate(A3), W = this.input.evaluate(A3);\n                    if (F3 < 0) throw new ma(`Array index out of bounds: ${F3} < 0.`);\n                    if (F3 >= W.length) throw new ma(`Array index out of bounds: ${F3} > ${W.length - 1}.`);\n                    if (F3 !== Math.floor(F3)) throw new ma(`Array index must be an integer, but found ${F3} instead.`);\n                    return W[F3];\n                  }\n                  eachChild(A3) {\n                    A3(this.index), A3(this.input);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class Jr {\n                  constructor(A3, F3) {\n                    this.type = mt, this.needle = A3, this.haystack = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 3) return F3.error(`Expected 2 arguments, but found ${A3.length - 1} instead.`);\n                    let W = F3.parse(A3[1], 1, Tr), re = F3.parse(A3[2], 2, Tr);\n                    return W && re ? xt(W.type, [mt, It, _t, Vt, Tr]) ? new Jr(W, re) : F3.error(`Expected first argument to be of type boolean, string, number or null, but found ${Je(W.type)} instead`) : null;\n                  }\n                  evaluate(A3) {\n                    let F3 = this.needle.evaluate(A3), W = this.haystack.evaluate(A3);\n                    if (!W) return false;\n                    if (!Ie(F3, ["boolean", "string", "number", "null"])) throw new ma(`Expected first argument to be of type boolean, string, number or null, but found ${Je(Sn(F3))} instead.`);\n                    if (!Ie(W, ["string", "array"])) throw new ma(`Expected second argument to be of type array or string, but found ${Je(Sn(W))} instead.`);\n                    return W.indexOf(F3) >= 0;\n                  }\n                  eachChild(A3) {\n                    A3(this.needle), A3(this.haystack);\n                  }\n                  outputDefined() {\n                    return true;\n                  }\n                }\n                class vi {\n                  constructor(A3, F3, W) {\n                    this.type = _t, this.needle = A3, this.haystack = F3, this.fromIndex = W;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length <= 2 || A3.length >= 5) return F3.error(`Expected 3 or 4 arguments, but found ${A3.length - 1} instead.`);\n                    let W = F3.parse(A3[1], 1, Tr), re = F3.parse(A3[2], 2, Tr);\n                    if (!W || !re) return null;\n                    if (!xt(W.type, [mt, It, _t, Vt, Tr])) return F3.error(`Expected first argument to be of type boolean, string, number or null, but found ${Je(W.type)} instead`);\n                    if (A3.length === 4) {\n                      let fe = F3.parse(A3[3], 3, _t);\n                      return fe ? new vi(W, re, fe) : null;\n                    }\n                    return new vi(W, re);\n                  }\n                  evaluate(A3) {\n                    let F3 = this.needle.evaluate(A3), W = this.haystack.evaluate(A3);\n                    if (!Ie(F3, ["boolean", "string", "number", "null"])) throw new ma(`Expected first argument to be of type boolean, string, number or null, but found ${Je(Sn(F3))} instead.`);\n                    let re;\n                    if (this.fromIndex && (re = this.fromIndex.evaluate(A3)), Ie(W, ["string"])) {\n                      let fe = W.indexOf(F3, re);\n                      return fe === -1 ? -1 : [...W.slice(0, fe)].length;\n                    }\n                    if (Ie(W, ["array"])) return W.indexOf(F3, re);\n                    throw new ma(`Expected second argument to be of type array or string, but found ${Je(Sn(W))} instead.`);\n                  }\n                  eachChild(A3) {\n                    A3(this.needle), A3(this.haystack), this.fromIndex && A3(this.fromIndex);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class hn {\n                  constructor(A3, F3, W, re, fe, pe) {\n                    this.inputType = A3, this.type = F3, this.input = W, this.cases = re, this.outputs = fe, this.otherwise = pe;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 5) return F3.error(`Expected at least 4 arguments, but found only ${A3.length - 1}.`);\n                    if (A3.length % 2 != 1) return F3.error("Expected an even number of arguments.");\n                    let W, re;\n                    F3.expectedType && F3.expectedType.kind !== "value" && (re = F3.expectedType);\n                    let fe = {}, pe = [];\n                    for (let ct = 2; ct < A3.length - 1; ct += 2) {\n                      let Lt = A3[ct], $t = A3[ct + 1];\n                      Array.isArray(Lt) || (Lt = [Lt]);\n                      let fr = F3.concat(ct);\n                      if (Lt.length === 0) return fr.error("Expected at least one branch label.");\n                      for (let Pr of Lt) {\n                        if (typeof Pr != "number" && typeof Pr != "string") return fr.error("Branch labels must be numbers or strings.");\n                        if (typeof Pr == "number" && Math.abs(Pr) > Number.MAX_SAFE_INTEGER) return fr.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);\n                        if (typeof Pr == "number" && Math.floor(Pr) !== Pr) return fr.error("Numeric branch labels must be integer values.");\n                        if (W) {\n                          if (fr.checkSubtype(W, Sn(Pr))) return null;\n                        } else W = Sn(Pr);\n                        if (fe[String(Pr)] !== void 0) return fr.error("Branch labels must be unique.");\n                        fe[String(Pr)] = pe.length;\n                      }\n                      let mr = F3.parse($t, ct, re);\n                      if (!mr) return null;\n                      re = re || mr.type, pe.push(mr);\n                    }\n                    let ze = F3.parse(A3[1], 1, Tr);\n                    if (!ze) return null;\n                    let Ke = F3.parse(A3[A3.length - 1], A3.length - 1, re);\n                    return Ke ? ze.type.kind !== "value" && F3.concat(1).checkSubtype(W, ze.type) ? null : new hn(W, re, ze, fe, pe, Ke) : null;\n                  }\n                  evaluate(A3) {\n                    let F3 = this.input.evaluate(A3);\n                    return (Sn(F3) === this.inputType && this.outputs[this.cases[F3]] || this.otherwise).evaluate(A3);\n                  }\n                  eachChild(A3) {\n                    A3(this.input), this.outputs.forEach(A3), A3(this.otherwise);\n                  }\n                  outputDefined() {\n                    return this.outputs.every((A3) => A3.outputDefined()) && this.otherwise.outputDefined();\n                  }\n                }\n                class An {\n                  constructor(A3, F3, W) {\n                    this.type = A3, this.branches = F3, this.otherwise = W;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 4) return F3.error(`Expected at least 3 arguments, but found only ${A3.length - 1}.`);\n                    if (A3.length % 2 != 0) return F3.error("Expected an odd number of arguments.");\n                    let W;\n                    F3.expectedType && F3.expectedType.kind !== "value" && (W = F3.expectedType);\n                    let re = [];\n                    for (let pe = 1; pe < A3.length - 1; pe += 2) {\n                      let ze = F3.parse(A3[pe], pe, mt);\n                      if (!ze) return null;\n                      let Ke = F3.parse(A3[pe + 1], pe + 1, W);\n                      if (!Ke) return null;\n                      re.push([ze, Ke]), W = W || Ke.type;\n                    }\n                    let fe = F3.parse(A3[A3.length - 1], A3.length - 1, W);\n                    if (!fe) return null;\n                    if (!W) throw new Error("Can\'t infer output type");\n                    return new An(W, re, fe);\n                  }\n                  evaluate(A3) {\n                    for (let [F3, W] of this.branches) if (F3.evaluate(A3)) return W.evaluate(A3);\n                    return this.otherwise.evaluate(A3);\n                  }\n                  eachChild(A3) {\n                    for (let [F3, W] of this.branches) A3(F3), A3(W);\n                    A3(this.otherwise);\n                  }\n                  outputDefined() {\n                    return this.branches.every(([A3, F3]) => F3.outputDefined()) && this.otherwise.outputDefined();\n                  }\n                }\n                class Mn {\n                  constructor(A3, F3, W, re) {\n                    this.type = A3, this.input = F3, this.beginIndex = W, this.endIndex = re;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length <= 2 || A3.length >= 5) return F3.error(`Expected 3 or 4 arguments, but found ${A3.length - 1} instead.`);\n                    let W = F3.parse(A3[1], 1, Tr), re = F3.parse(A3[2], 2, _t);\n                    if (!W || !re) return null;\n                    if (!xt(W.type, [Ge(Tr), It, Tr])) return F3.error(`Expected first argument to be of type array or string, but found ${Je(W.type)} instead`);\n                    if (A3.length === 4) {\n                      let fe = F3.parse(A3[3], 3, _t);\n                      return fe ? new Mn(W.type, W, re, fe) : null;\n                    }\n                    return new Mn(W.type, W, re);\n                  }\n                  evaluate(A3) {\n                    let F3 = this.input.evaluate(A3), W = this.beginIndex.evaluate(A3), re;\n                    if (this.endIndex && (re = this.endIndex.evaluate(A3)), Ie(F3, ["string"])) return [...F3].slice(W, re).join("");\n                    if (Ie(F3, ["array"])) return F3.slice(W, re);\n                    throw new ma(`Expected first argument to be of type array or string, but found ${Je(Sn(F3))} instead.`);\n                  }\n                  eachChild(A3) {\n                    A3(this.input), A3(this.beginIndex), this.endIndex && A3(this.endIndex);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                function Li(R, A3) {\n                  let F3 = R.length - 1, W, re, fe = 0, pe = F3, ze = 0;\n                  for (; fe <= pe; ) if (ze = Math.floor((fe + pe) / 2), W = R[ze], re = R[ze + 1], W <= A3) {\n                    if (ze === F3 || A3 < re) return ze;\n                    fe = ze + 1;\n                  } else {\n                    if (!(W > A3)) throw new ma("Input is not a number.");\n                    pe = ze - 1;\n                  }\n                  return 0;\n                }\n                class _n {\n                  constructor(A3, F3, W) {\n                    this.type = A3, this.input = F3, this.labels = [], this.outputs = [];\n                    for (let [re, fe] of W) this.labels.push(re), this.outputs.push(fe);\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length - 1 < 4) return F3.error(`Expected at least 4 arguments, but found only ${A3.length - 1}.`);\n                    if ((A3.length - 1) % 2 != 0) return F3.error("Expected an even number of arguments.");\n                    let W = F3.parse(A3[1], 1, _t);\n                    if (!W) return null;\n                    let re = [], fe = null;\n                    F3.expectedType && F3.expectedType.kind !== "value" && (fe = F3.expectedType);\n                    for (let pe = 1; pe < A3.length; pe += 2) {\n                      let ze = pe === 1 ? -1 / 0 : A3[pe], Ke = A3[pe + 1], ct = pe, Lt = pe + 1;\n                      if (typeof ze != "number") return F3.error(\'Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.\', ct);\n                      if (re.length && re[re.length - 1][0] >= ze) return F3.error(\'Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.\', ct);\n                      let $t = F3.parse(Ke, Lt, fe);\n                      if (!$t) return null;\n                      fe = fe || $t.type, re.push([ze, $t]);\n                    }\n                    return new _n(fe, W, re);\n                  }\n                  evaluate(A3) {\n                    let F3 = this.labels, W = this.outputs;\n                    if (F3.length === 1) return W[0].evaluate(A3);\n                    let re = this.input.evaluate(A3);\n                    if (re <= F3[0]) return W[0].evaluate(A3);\n                    let fe = F3.length;\n                    return re >= F3[fe - 1] ? W[fe - 1].evaluate(A3) : W[Li(F3, re)].evaluate(A3);\n                  }\n                  eachChild(A3) {\n                    A3(this.input);\n                    for (let F3 of this.outputs) A3(F3);\n                  }\n                  outputDefined() {\n                    return this.outputs.every((A3) => A3.outputDefined());\n                  }\n                }\n                function ya(R) {\n                  return R && R.__esModule && Object.prototype.hasOwnProperty.call(R, "default") ? R.default : R;\n                }\n                var Jn = Ma;\n                function Ma(R, A3, F3, W) {\n                  this.cx = 3 * R, this.bx = 3 * (F3 - R) - this.cx, this.ax = 1 - this.cx - this.bx, this.cy = 3 * A3, this.by = 3 * (W - A3) - this.cy, this.ay = 1 - this.cy - this.by, this.p1x = R, this.p1y = A3, this.p2x = F3, this.p2y = W;\n                }\n                Ma.prototype = { sampleCurveX: function(R) {\n                  return ((this.ax * R + this.bx) * R + this.cx) * R;\n                }, sampleCurveY: function(R) {\n                  return ((this.ay * R + this.by) * R + this.cy) * R;\n                }, sampleCurveDerivativeX: function(R) {\n                  return (3 * this.ax * R + 2 * this.bx) * R + this.cx;\n                }, solveCurveX: function(R, A3) {\n                  if (A3 === void 0 && (A3 = 1e-6), R < 0) return 0;\n                  if (R > 1) return 1;\n                  for (var F3 = R, W = 0; W < 8; W++) {\n                    var re = this.sampleCurveX(F3) - R;\n                    if (Math.abs(re) < A3) return F3;\n                    var fe = this.sampleCurveDerivativeX(F3);\n                    if (Math.abs(fe) < 1e-6) break;\n                    F3 -= re / fe;\n                  }\n                  var pe = 0, ze = 1;\n                  for (F3 = R, W = 0; W < 20 && (re = this.sampleCurveX(F3), !(Math.abs(re - R) < A3)); W++) R > re ? pe = F3 : ze = F3, F3 = 0.5 * (ze - pe) + pe;\n                  return F3;\n                }, solve: function(R, A3) {\n                  return this.sampleCurveY(this.solveCurveX(R, A3));\n                } };\n                var _o = ya(Jn);\n                function No(R, A3, F3) {\n                  return R + F3 * (A3 - R);\n                }\n                function po(R, A3, F3) {\n                  return R.map((W, re) => No(W, A3[re], F3));\n                }\n                let Lo = { number: No, color: function(R, A3, F3, W = "rgb") {\n                  switch (W) {\n                    case "rgb": {\n                      let [re, fe, pe, ze] = po(R.rgb, A3.rgb, F3);\n                      return new nr(re, fe, pe, ze, false);\n                    }\n                    case "hcl": {\n                      let [re, fe, pe, ze] = R.hcl, [Ke, ct, Lt, $t] = A3.hcl, fr, mr;\n                      if (isNaN(re) || isNaN(Ke)) isNaN(re) ? isNaN(Ke) ? fr = NaN : (fr = Ke, pe !== 1 && pe !== 0 || (mr = ct)) : (fr = re, Lt !== 1 && Lt !== 0 || (mr = fe));\n                      else {\n                        let vn = Ke - re;\n                        Ke > re && vn > 180 ? vn -= 360 : Ke < re && re - Ke > 180 && (vn += 360), fr = re + F3 * vn;\n                      }\n                      let [Pr, zr, ui, yi] = (function([vn, zi, un, Tn]) {\n                        return vn = isNaN(vn) ? 0 : vn * pi, On([un, Math.cos(vn) * zi, Math.sin(vn) * zi, Tn]);\n                      })([fr, mr != null ? mr : No(fe, ct, F3), No(pe, Lt, F3), No(ze, $t, F3)]);\n                      return new nr(Pr, zr, ui, yi, false);\n                    }\n                    case "lab": {\n                      let [re, fe, pe, ze] = On(po(R.lab, A3.lab, F3));\n                      return new nr(re, fe, pe, ze, false);\n                    }\n                  }\n                }, array: po, padding: function(R, A3, F3) {\n                  return new Qr(po(R.values, A3.values, F3));\n                }, variableAnchorOffsetCollection: function(R, A3, F3) {\n                  let W = R.values, re = A3.values;\n                  if (W.length !== re.length) throw new ma(`Cannot interpolate values of different length. from: ${R.toString()}, to: ${A3.toString()}`);\n                  let fe = [];\n                  for (let pe = 0; pe < W.length; pe += 2) {\n                    if (W[pe] !== re[pe]) throw new ma(`Cannot interpolate values containing mismatched anchors. from[${pe}]: ${W[pe]}, to[${pe}]: ${re[pe]}`);\n                    fe.push(W[pe]);\n                    let [ze, Ke] = W[pe + 1], [ct, Lt] = re[pe + 1];\n                    fe.push([No(ze, ct, F3), No(Ke, Lt, F3)]);\n                  }\n                  return new $i(fe);\n                } };\n                class ko {\n                  constructor(A3, F3, W, re, fe) {\n                    this.type = A3, this.operator = F3, this.interpolation = W, this.input = re, this.labels = [], this.outputs = [];\n                    for (let [pe, ze] of fe) this.labels.push(pe), this.outputs.push(ze);\n                  }\n                  static interpolationFactor(A3, F3, W, re) {\n                    let fe = 0;\n                    if (A3.name === "exponential") fe = Ds(F3, A3.base, W, re);\n                    else if (A3.name === "linear") fe = Ds(F3, 1, W, re);\n                    else if (A3.name === "cubic-bezier") {\n                      let pe = A3.controlPoints;\n                      fe = new _o(pe[0], pe[1], pe[2], pe[3]).solve(Ds(F3, 1, W, re));\n                    }\n                    return fe;\n                  }\n                  static parse(A3, F3) {\n                    let [W, re, fe, ...pe] = A3;\n                    if (!Array.isArray(re) || re.length === 0) return F3.error("Expected an interpolation type expression.", 1);\n                    if (re[0] === "linear") re = { name: "linear" };\n                    else if (re[0] === "exponential") {\n                      let ct = re[1];\n                      if (typeof ct != "number") return F3.error("Exponential interpolation requires a numeric base.", 1, 1);\n                      re = { name: "exponential", base: ct };\n                    } else {\n                      if (re[0] !== "cubic-bezier") return F3.error(`Unknown interpolation type ${String(re[0])}`, 1, 0);\n                      {\n                        let ct = re.slice(1);\n                        if (ct.length !== 4 || ct.some((Lt) => typeof Lt != "number" || Lt < 0 || Lt > 1)) return F3.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.", 1);\n                        re = { name: "cubic-bezier", controlPoints: ct };\n                      }\n                    }\n                    if (A3.length - 1 < 4) return F3.error(`Expected at least 4 arguments, but found only ${A3.length - 1}.`);\n                    if ((A3.length - 1) % 2 != 0) return F3.error("Expected an even number of arguments.");\n                    if (fe = F3.parse(fe, 2, _t), !fe) return null;\n                    let ze = [], Ke = null;\n                    W === "interpolate-hcl" || W === "interpolate-lab" ? Ke = er : F3.expectedType && F3.expectedType.kind !== "value" && (Ke = F3.expectedType);\n                    for (let ct = 0; ct < pe.length; ct += 2) {\n                      let Lt = pe[ct], $t = pe[ct + 1], fr = ct + 3, mr = ct + 4;\n                      if (typeof Lt != "number") return F3.error(\'Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.\', fr);\n                      if (ze.length && ze[ze.length - 1][0] >= Lt) return F3.error(\'Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.\', fr);\n                      let Pr = F3.parse($t, mr, Ke);\n                      if (!Pr) return null;\n                      Ke = Ke || Pr.type, ze.push([Lt, Pr]);\n                    }\n                    return xe(Ke, _t) || xe(Ke, er) || xe(Ke, Br) || xe(Ke, dt) || xe(Ke, Ge(_t)) ? new ko(Ke, W, re, fe, ze) : F3.error(`Type ${Je(Ke)} is not interpolatable.`);\n                  }\n                  evaluate(A3) {\n                    let F3 = this.labels, W = this.outputs;\n                    if (F3.length === 1) return W[0].evaluate(A3);\n                    let re = this.input.evaluate(A3);\n                    if (re <= F3[0]) return W[0].evaluate(A3);\n                    let fe = F3.length;\n                    if (re >= F3[fe - 1]) return W[fe - 1].evaluate(A3);\n                    let pe = Li(F3, re), ze = ko.interpolationFactor(this.interpolation, re, F3[pe], F3[pe + 1]), Ke = W[pe].evaluate(A3), ct = W[pe + 1].evaluate(A3);\n                    switch (this.operator) {\n                      case "interpolate":\n                        return Lo[this.type.kind](Ke, ct, ze);\n                      case "interpolate-hcl":\n                        return Lo.color(Ke, ct, ze, "hcl");\n                      case "interpolate-lab":\n                        return Lo.color(Ke, ct, ze, "lab");\n                    }\n                  }\n                  eachChild(A3) {\n                    A3(this.input);\n                    for (let F3 of this.outputs) A3(F3);\n                  }\n                  outputDefined() {\n                    return this.outputs.every((A3) => A3.outputDefined());\n                  }\n                }\n                function Ds(R, A3, F3, W) {\n                  let re = W - F3, fe = R - F3;\n                  return re === 0 ? 0 : A3 === 1 ? fe / re : (Math.pow(A3, fe) - 1) / (Math.pow(A3, re) - 1);\n                }\n                class Fs {\n                  constructor(A3, F3) {\n                    this.type = A3, this.args = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 2) return F3.error("Expectected at least one argument.");\n                    let W = null, re = F3.expectedType;\n                    re && re.kind !== "value" && (W = re);\n                    let fe = [];\n                    for (let ze of A3.slice(1)) {\n                      let Ke = F3.parse(ze, 1 + fe.length, W, void 0, { typeAnnotation: "omit" });\n                      if (!Ke) return null;\n                      W = W || Ke.type, fe.push(Ke);\n                    }\n                    if (!W) throw new Error("No output type");\n                    let pe = re && fe.some((ze) => tt(re, ze.type));\n                    return new Fs(pe ? Tr : W, fe);\n                  }\n                  evaluate(A3) {\n                    let F3, W = null, re = 0;\n                    for (let fe of this.args) if (re++, W = fe.evaluate(A3), W && W instanceof tn && !W.available && (F3 || (F3 = W.name), W = null, re === this.args.length && (W = F3)), W !== null) break;\n                    return W;\n                  }\n                  eachChild(A3) {\n                    this.args.forEach(A3);\n                  }\n                  outputDefined() {\n                    return this.args.every((A3) => A3.outputDefined());\n                  }\n                }\n                function ll(R, A3) {\n                  return R === "==" || R === "!=" ? A3.kind === "boolean" || A3.kind === "string" || A3.kind === "number" || A3.kind === "null" || A3.kind === "value" : A3.kind === "string" || A3.kind === "number" || A3.kind === "value";\n                }\n                function ul(R, A3, F3, W) {\n                  return W.compare(A3, F3) === 0;\n                }\n                function zl(R, A3, F3) {\n                  let W = R !== "==" && R !== "!=";\n                  return class aje {\n                    constructor(fe, pe, ze) {\n                      this.type = mt, this.lhs = fe, this.rhs = pe, this.collator = ze, this.hasUntypedArgument = fe.type.kind === "value" || pe.type.kind === "value";\n                    }\n                    static parse(fe, pe) {\n                      if (fe.length !== 3 && fe.length !== 4) return pe.error("Expected two or three arguments.");\n                      let ze = fe[0], Ke = pe.parse(fe[1], 1, Tr);\n                      if (!Ke) return null;\n                      if (!ll(ze, Ke.type)) return pe.concat(1).error(`"${ze}" comparisons are not supported for type \'${Je(Ke.type)}\'.`);\n                      let ct = pe.parse(fe[2], 2, Tr);\n                      if (!ct) return null;\n                      if (!ll(ze, ct.type)) return pe.concat(2).error(`"${ze}" comparisons are not supported for type \'${Je(ct.type)}\'.`);\n                      if (Ke.type.kind !== ct.type.kind && Ke.type.kind !== "value" && ct.type.kind !== "value") return pe.error(`Cannot compare types \'${Je(Ke.type)}\' and \'${Je(ct.type)}\'.`);\n                      W && (Ke.type.kind === "value" && ct.type.kind !== "value" ? Ke = new Fa(ct.type, [Ke]) : Ke.type.kind !== "value" && ct.type.kind === "value" && (ct = new Fa(Ke.type, [ct])));\n                      let Lt = null;\n                      if (fe.length === 4) {\n                        if (Ke.type.kind !== "string" && ct.type.kind !== "string" && Ke.type.kind !== "value" && ct.type.kind !== "value") return pe.error("Cannot use collator to compare non-string types.");\n                        if (Lt = pe.parse(fe[3], 3, Lr), !Lt) return null;\n                      }\n                      return new aje(Ke, ct, Lt);\n                    }\n                    evaluate(fe) {\n                      let pe = this.lhs.evaluate(fe), ze = this.rhs.evaluate(fe);\n                      if (W && this.hasUntypedArgument) {\n                        let Ke = Sn(pe), ct = Sn(ze);\n                        if (Ke.kind !== ct.kind || Ke.kind !== "string" && Ke.kind !== "number") throw new ma(`Expected arguments for "${R}" to be (string, string) or (number, number), but found (${Ke.kind}, ${ct.kind}) instead.`);\n                      }\n                      if (this.collator && !W && this.hasUntypedArgument) {\n                        let Ke = Sn(pe), ct = Sn(ze);\n                        if (Ke.kind !== "string" || ct.kind !== "string") return A3(fe, pe, ze);\n                      }\n                      return this.collator ? F3(fe, pe, ze, this.collator.evaluate(fe)) : A3(fe, pe, ze);\n                    }\n                    eachChild(fe) {\n                      fe(this.lhs), fe(this.rhs), this.collator && fe(this.collator);\n                    }\n                    outputDefined() {\n                      return true;\n                    }\n                  };\n                }\n                let us = zl("==", function(R, A3, F3) {\n                  return A3 === F3;\n                }, ul), il = zl("!=", function(R, A3, F3) {\n                  return A3 !== F3;\n                }, function(R, A3, F3, W) {\n                  return !ul(0, A3, F3, W);\n                }), As = zl("<", function(R, A3, F3) {\n                  return A3 < F3;\n                }, function(R, A3, F3, W) {\n                  return W.compare(A3, F3) < 0;\n                }), cl = zl(">", function(R, A3, F3) {\n                  return A3 > F3;\n                }, function(R, A3, F3, W) {\n                  return W.compare(A3, F3) > 0;\n                }), Ks = zl("<=", function(R, A3, F3) {\n                  return A3 <= F3;\n                }, function(R, A3, F3, W) {\n                  return W.compare(A3, F3) <= 0;\n                }), zs = zl(">=", function(R, A3, F3) {\n                  return A3 >= F3;\n                }, function(R, A3, F3, W) {\n                  return W.compare(A3, F3) >= 0;\n                });\n                class Io {\n                  constructor(A3, F3, W) {\n                    this.type = Lr, this.locale = W, this.caseSensitive = A3, this.diacriticSensitive = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error("Expected one argument.");\n                    let W = A3[1];\n                    if (typeof W != "object" || Array.isArray(W)) return F3.error("Collator options argument must be an object.");\n                    let re = F3.parse(W["case-sensitive"] !== void 0 && W["case-sensitive"], 1, mt);\n                    if (!re) return null;\n                    let fe = F3.parse(W["diacritic-sensitive"] !== void 0 && W["diacritic-sensitive"], 1, mt);\n                    if (!fe) return null;\n                    let pe = null;\n                    return W.locale && (pe = F3.parse(W.locale, 1, It), !pe) ? null : new Io(re, fe, pe);\n                  }\n                  evaluate(A3) {\n                    return new Er(this.caseSensitive.evaluate(A3), this.diacriticSensitive.evaluate(A3), this.locale ? this.locale.evaluate(A3) : null);\n                  }\n                  eachChild(A3) {\n                    A3(this.caseSensitive), A3(this.diacriticSensitive), this.locale && A3(this.locale);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class ls {\n                  constructor(A3, F3, W, re, fe) {\n                    this.type = It, this.number = A3, this.locale = F3, this.currency = W, this.minFractionDigits = re, this.maxFractionDigits = fe;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 3) return F3.error("Expected two arguments.");\n                    let W = F3.parse(A3[1], 1, _t);\n                    if (!W) return null;\n                    let re = A3[2];\n                    if (typeof re != "object" || Array.isArray(re)) return F3.error("NumberFormat options argument must be an object.");\n                    let fe = null;\n                    if (re.locale && (fe = F3.parse(re.locale, 1, It), !fe)) return null;\n                    let pe = null;\n                    if (re.currency && (pe = F3.parse(re.currency, 1, It), !pe)) return null;\n                    let ze = null;\n                    if (re["min-fraction-digits"] && (ze = F3.parse(re["min-fraction-digits"], 1, _t), !ze)) return null;\n                    let Ke = null;\n                    return re["max-fraction-digits"] && (Ke = F3.parse(re["max-fraction-digits"], 1, _t), !Ke) ? null : new ls(W, fe, pe, ze, Ke);\n                  }\n                  evaluate(A3) {\n                    return new Intl.NumberFormat(this.locale ? this.locale.evaluate(A3) : [], { style: this.currency ? "currency" : "decimal", currency: this.currency ? this.currency.evaluate(A3) : void 0, minimumFractionDigits: this.minFractionDigits ? this.minFractionDigits.evaluate(A3) : void 0, maximumFractionDigits: this.maxFractionDigits ? this.maxFractionDigits.evaluate(A3) : void 0 }).format(this.number.evaluate(A3));\n                  }\n                  eachChild(A3) {\n                    A3(this.number), this.locale && A3(this.locale), this.currency && A3(this.currency), this.minFractionDigits && A3(this.minFractionDigits), this.maxFractionDigits && A3(this.maxFractionDigits);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class Zl {\n                  constructor(A3) {\n                    this.type = ti, this.sections = A3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length < 2) return F3.error("Expected at least one argument.");\n                    let W = A3[1];\n                    if (!Array.isArray(W) && typeof W == "object") return F3.error("First argument must be an image or text section.");\n                    let re = [], fe = false;\n                    for (let pe = 1; pe <= A3.length - 1; ++pe) {\n                      let ze = A3[pe];\n                      if (fe && typeof ze == "object" && !Array.isArray(ze)) {\n                        fe = false;\n                        let Ke = null;\n                        if (ze["font-scale"] && (Ke = F3.parse(ze["font-scale"], 1, _t), !Ke)) return null;\n                        let ct = null;\n                        if (ze["text-font"] && (ct = F3.parse(ze["text-font"], 1, Ge(It)), !ct)) return null;\n                        let Lt = null;\n                        if (ze["text-color"] && (Lt = F3.parse(ze["text-color"], 1, er), !Lt)) return null;\n                        let $t = re[re.length - 1];\n                        $t.scale = Ke, $t.font = ct, $t.textColor = Lt;\n                      } else {\n                        let Ke = F3.parse(A3[pe], 1, Tr);\n                        if (!Ke) return null;\n                        let ct = Ke.type.kind;\n                        if (ct !== "string" && ct !== "value" && ct !== "null" && ct !== "resolvedImage") return F3.error("Formatted text type must be \'string\', \'value\', \'image\' or \'null\'.");\n                        fe = true, re.push({ content: Ke, scale: null, font: null, textColor: null });\n                      }\n                    }\n                    return new Zl(re);\n                  }\n                  evaluate(A3) {\n                    return new ri(this.sections.map((F3) => {\n                      let W = F3.content.evaluate(A3);\n                      return Sn(W) === Vr ? new Xr("", W, null, null, null) : new Xr(Ba(W), null, F3.scale ? F3.scale.evaluate(A3) : null, F3.font ? F3.font.evaluate(A3).join(",") : null, F3.textColor ? F3.textColor.evaluate(A3) : null);\n                    }));\n                  }\n                  eachChild(A3) {\n                    for (let F3 of this.sections) A3(F3.content), F3.scale && A3(F3.scale), F3.font && A3(F3.font), F3.textColor && A3(F3.textColor);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class Su {\n                  constructor(A3) {\n                    this.type = Vr, this.input = A3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error("Expected two arguments.");\n                    let W = F3.parse(A3[1], 1, It);\n                    return W ? new Su(W) : F3.error("No image name provided.");\n                  }\n                  evaluate(A3) {\n                    let F3 = this.input.evaluate(A3), W = tn.fromString(F3);\n                    return W && A3.availableImages && (W.available = A3.availableImages.indexOf(F3) > -1), W;\n                  }\n                  eachChild(A3) {\n                    A3(this.input);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                class nc {\n                  constructor(A3) {\n                    this.type = _t, this.input = A3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error(`Expected 1 argument, but found ${A3.length - 1} instead.`);\n                    let W = F3.parse(A3[1], 1);\n                    return W ? W.type.kind !== "array" && W.type.kind !== "string" && W.type.kind !== "value" ? F3.error(`Expected argument of type string or array, but found ${Je(W.type)} instead.`) : new nc(W) : null;\n                  }\n                  evaluate(A3) {\n                    let F3 = this.input.evaluate(A3);\n                    if (typeof F3 == "string") return [...F3].length;\n                    if (Array.isArray(F3)) return F3.length;\n                    throw new ma(`Expected value to be of type string or array, but found ${Je(Sn(F3))} instead.`);\n                  }\n                  eachChild(A3) {\n                    A3(this.input);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                }\n                let bs = 8192;\n                function Rn(R, A3) {\n                  let F3 = (180 + R[0]) / 360, W = (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + R[1] * Math.PI / 360))) / 360, re = Math.pow(2, A3.z);\n                  return [Math.round(F3 * re * bs), Math.round(W * re * bs)];\n                }\n                function _a(R, A3) {\n                  let F3 = Math.pow(2, A3.z);\n                  return [(re = (R[0] / bs + A3.x) / F3, 360 * re - 180), (W = (R[1] / bs + A3.y) / F3, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * W) * Math.PI / 180)) - 90)];\n                  var W, re;\n                }\n                function Vu(R, A3) {\n                  R[0] = Math.min(R[0], A3[0]), R[1] = Math.min(R[1], A3[1]), R[2] = Math.max(R[2], A3[0]), R[3] = Math.max(R[3], A3[1]);\n                }\n                function Ol(R, A3) {\n                  return !(R[0] <= A3[0] || R[2] >= A3[2] || R[1] <= A3[1] || R[3] >= A3[3]);\n                }\n                function xo(R, A3, F3) {\n                  let W = R[0] - A3[0], re = R[1] - A3[1], fe = R[0] - F3[0], pe = R[1] - F3[1];\n                  return W * pe - fe * re == 0 && W * fe <= 0 && re * pe <= 0;\n                }\n                function Yl(R, A3, F3, W) {\n                  return (re = [W[0] - F3[0], W[1] - F3[1]])[0] * (fe = [A3[0] - R[0], A3[1] - R[1]])[1] - re[1] * fe[0] != 0 && !(!qo(R, A3, F3, W) || !qo(F3, W, R, A3));\n                  var re, fe;\n                }\n                function Ns(R, A3, F3) {\n                  for (let W of F3) for (let re = 0; re < W.length - 1; ++re) if (Yl(R, A3, W[re], W[re + 1])) return true;\n                  return false;\n                }\n                function Hl(R, A3, F3 = false) {\n                  let W = false;\n                  for (let ze of A3) for (let Ke = 0; Ke < ze.length - 1; Ke++) {\n                    if (xo(R, ze[Ke], ze[Ke + 1])) return F3;\n                    (fe = ze[Ke])[1] > (re = R)[1] != (pe = ze[Ke + 1])[1] > re[1] && re[0] < (pe[0] - fe[0]) * (re[1] - fe[1]) / (pe[1] - fe[1]) + fe[0] && (W = !W);\n                  }\n                  var re, fe, pe;\n                  return W;\n                }\n                function ac(R, A3) {\n                  for (let F3 of A3) if (Hl(R, F3)) return true;\n                  return false;\n                }\n                function aa(R, A3) {\n                  for (let F3 of R) if (!Hl(F3, A3)) return false;\n                  for (let F3 = 0; F3 < R.length - 1; ++F3) if (Ns(R[F3], R[F3 + 1], A3)) return false;\n                  return true;\n                }\n                function Oo(R, A3) {\n                  for (let F3 of A3) if (aa(R, F3)) return true;\n                  return false;\n                }\n                function qo(R, A3, F3, W) {\n                  let re = W[0] - F3[0], fe = W[1] - F3[1], pe = (R[0] - F3[0]) * fe - re * (R[1] - F3[1]), ze = (A3[0] - F3[0]) * fe - re * (A3[1] - F3[1]);\n                  return pe > 0 && ze < 0 || pe < 0 && ze > 0;\n                }\n                function ql(R, A3, F3) {\n                  let W = [];\n                  for (let re = 0; re < R.length; re++) {\n                    let fe = [];\n                    for (let pe = 0; pe < R[re].length; pe++) {\n                      let ze = Rn(R[re][pe], F3);\n                      Vu(A3, ze), fe.push(ze);\n                    }\n                    W.push(fe);\n                  }\n                  return W;\n                }\n                function Pc(R, A3, F3) {\n                  let W = [];\n                  for (let re = 0; re < R.length; re++) {\n                    let fe = ql(R[re], A3, F3);\n                    W.push(fe);\n                  }\n                  return W;\n                }\n                function Do(R, A3, F3, W) {\n                  if (R[0] < F3[0] || R[0] > F3[2]) {\n                    let re = 0.5 * W, fe = R[0] - F3[0] > re ? -W : F3[0] - R[0] > re ? W : 0;\n                    fe === 0 && (fe = R[0] - F3[2] > re ? -W : F3[2] - R[0] > re ? W : 0), R[0] += fe;\n                  }\n                  Vu(A3, R);\n                }\n                function rf(R, A3, F3, W) {\n                  let re = Math.pow(2, W.z) * bs, fe = [W.x * bs, W.y * bs], pe = [];\n                  for (let ze of R) for (let Ke of ze) {\n                    let ct = [Ke.x + fe[0], Ke.y + fe[1]];\n                    Do(ct, A3, F3, re), pe.push(ct);\n                  }\n                  return pe;\n                }\n                function Uf(R, A3, F3, W) {\n                  let re = Math.pow(2, W.z) * bs, fe = [W.x * bs, W.y * bs], pe = [];\n                  for (let Ke of R) {\n                    let ct = [];\n                    for (let Lt of Ke) {\n                      let $t = [Lt.x + fe[0], Lt.y + fe[1]];\n                      Vu(A3, $t), ct.push($t);\n                    }\n                    pe.push(ct);\n                  }\n                  if (A3[2] - A3[0] <= re / 2) {\n                    (ze = A3)[0] = ze[1] = 1 / 0, ze[2] = ze[3] = -1 / 0;\n                    for (let Ke of pe) for (let ct of Ke) Do(ct, A3, F3, re);\n                  }\n                  var ze;\n                  return pe;\n                }\n                class pl {\n                  constructor(A3, F3) {\n                    this.type = mt, this.geojson = A3, this.geometries = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error(`\'within\' expression requires exactly one argument, but found ${A3.length - 1} instead.`);\n                    if (yn(A3[1])) {\n                      let W = A3[1];\n                      if (W.type === "FeatureCollection") {\n                        let re = [];\n                        for (let fe of W.features) {\n                          let { type: pe, coordinates: ze } = fe.geometry;\n                          pe === "Polygon" && re.push(ze), pe === "MultiPolygon" && re.push(...ze);\n                        }\n                        if (re.length) return new pl(W, { type: "MultiPolygon", coordinates: re });\n                      } else if (W.type === "Feature") {\n                        let re = W.geometry.type;\n                        if (re === "Polygon" || re === "MultiPolygon") return new pl(W, W.geometry);\n                      } else if (W.type === "Polygon" || W.type === "MultiPolygon") return new pl(W, W);\n                    }\n                    return F3.error("\'within\' expression requires valid geojson object that contains polygon geometry type.");\n                  }\n                  evaluate(A3) {\n                    if (A3.geometry() != null && A3.canonicalID() != null) {\n                      if (A3.geometryType() === "Point") return (function(F3, W) {\n                        let re = [1 / 0, 1 / 0, -1 / 0, -1 / 0], fe = [1 / 0, 1 / 0, -1 / 0, -1 / 0], pe = F3.canonicalID();\n                        if (W.type === "Polygon") {\n                          let ze = ql(W.coordinates, fe, pe), Ke = rf(F3.geometry(), re, fe, pe);\n                          if (!Ol(re, fe)) return false;\n                          for (let ct of Ke) if (!Hl(ct, ze)) return false;\n                        }\n                        if (W.type === "MultiPolygon") {\n                          let ze = Pc(W.coordinates, fe, pe), Ke = rf(F3.geometry(), re, fe, pe);\n                          if (!Ol(re, fe)) return false;\n                          for (let ct of Ke) if (!ac(ct, ze)) return false;\n                        }\n                        return true;\n                      })(A3, this.geometries);\n                      if (A3.geometryType() === "LineString") return (function(F3, W) {\n                        let re = [1 / 0, 1 / 0, -1 / 0, -1 / 0], fe = [1 / 0, 1 / 0, -1 / 0, -1 / 0], pe = F3.canonicalID();\n                        if (W.type === "Polygon") {\n                          let ze = ql(W.coordinates, fe, pe), Ke = Uf(F3.geometry(), re, fe, pe);\n                          if (!Ol(re, fe)) return false;\n                          for (let ct of Ke) if (!aa(ct, ze)) return false;\n                        }\n                        if (W.type === "MultiPolygon") {\n                          let ze = Pc(W.coordinates, fe, pe), Ke = Uf(F3.geometry(), re, fe, pe);\n                          if (!Ol(re, fe)) return false;\n                          for (let ct of Ke) if (!Oo(ct, ze)) return false;\n                        }\n                        return true;\n                      })(A3, this.geometries);\n                    }\n                    return false;\n                  }\n                  eachChild() {\n                  }\n                  outputDefined() {\n                    return true;\n                  }\n                }\n                let Zc = class {\n                  constructor(R = [], A3 = (F3, W) => F3 < W ? -1 : F3 > W ? 1 : 0) {\n                    if (this.data = R, this.length = this.data.length, this.compare = A3, this.length > 0) for (let F3 = (this.length >> 1) - 1; F3 >= 0; F3--) this._down(F3);\n                  }\n                  push(R) {\n                    this.data.push(R), this._up(this.length++);\n                  }\n                  pop() {\n                    if (this.length === 0) return;\n                    let R = this.data[0], A3 = this.data.pop();\n                    return --this.length > 0 && (this.data[0] = A3, this._down(0)), R;\n                  }\n                  peek() {\n                    return this.data[0];\n                  }\n                  _up(R) {\n                    let { data: A3, compare: F3 } = this, W = A3[R];\n                    for (; R > 0; ) {\n                      let re = R - 1 >> 1, fe = A3[re];\n                      if (F3(W, fe) >= 0) break;\n                      A3[R] = fe, R = re;\n                    }\n                    A3[R] = W;\n                  }\n                  _down(R) {\n                    let { data: A3, compare: F3 } = this, W = this.length >> 1, re = A3[R];\n                    for (; R < W; ) {\n                      let fe = 1 + (R << 1), pe = fe + 1;\n                      if (pe < this.length && F3(A3[pe], A3[fe]) < 0 && (fe = pe), F3(A3[fe], re) >= 0) break;\n                      A3[R] = A3[fe], R = fe;\n                    }\n                    A3[R] = re;\n                  }\n                };\n                function Kl(R, A3, F3, W, re) {\n                  Os(R, A3, F3, W || R.length - 1, re || oc);\n                }\n                function Os(R, A3, F3, W, re) {\n                  for (; W > F3; ) {\n                    if (W - F3 > 600) {\n                      var fe = W - F3 + 1, pe = A3 - F3 + 1, ze = Math.log(fe), Ke = 0.5 * Math.exp(2 * ze / 3), ct = 0.5 * Math.sqrt(ze * Ke * (fe - Ke) / fe) * (pe - fe / 2 < 0 ? -1 : 1);\n                      Os(R, A3, Math.max(F3, Math.floor(A3 - pe * Ke / fe + ct)), Math.min(W, Math.floor(A3 + (fe - pe) * Ke / fe + ct)), re);\n                    }\n                    var Lt = R[A3], $t = F3, fr = W;\n                    for (yu(R, F3, A3), re(R[W], Lt) > 0 && yu(R, F3, W); $t < fr; ) {\n                      for (yu(R, $t, fr), $t++, fr--; re(R[$t], Lt) < 0; ) $t++;\n                      for (; re(R[fr], Lt) > 0; ) fr--;\n                    }\n                    re(R[F3], Lt) === 0 ? yu(R, F3, fr) : yu(R, ++fr, W), fr <= A3 && (F3 = fr + 1), A3 <= fr && (W = fr - 1);\n                  }\n                }\n                function yu(R, A3, F3) {\n                  var W = R[A3];\n                  R[A3] = R[F3], R[F3] = W;\n                }\n                function oc(R, A3) {\n                  return R < A3 ? -1 : R > A3 ? 1 : 0;\n                }\n                function Cf(R, A3) {\n                  if (R.length <= 1) return [R];\n                  let F3 = [], W, re;\n                  for (let fe of R) {\n                    let pe = Vh(fe);\n                    pe !== 0 && (fe.area = Math.abs(pe), re === void 0 && (re = pe < 0), re === pe < 0 ? (W && F3.push(W), W = [fe]) : W.push(fe));\n                  }\n                  if (W && F3.push(W), A3 > 1) for (let fe = 0; fe < F3.length; fe++) F3[fe].length <= A3 || (Kl(F3[fe], A3, 1, F3[fe].length - 1, sc), F3[fe] = F3[fe].slice(0, A3));\n                  return F3;\n                }\n                function sc(R, A3) {\n                  return A3.area - R.area;\n                }\n                function Vh(R) {\n                  let A3 = 0;\n                  for (let F3, W, re = 0, fe = R.length, pe = fe - 1; re < fe; pe = re++) F3 = R[re], W = R[pe], A3 += (W.x - F3.x) * (F3.y + W.y);\n                  return A3;\n                }\n                let Lf = 1 / 298.257223563, cs = Lf * (2 - Lf), nf = Math.PI / 180;\n                class Vf {\n                  constructor(A3) {\n                    let F3 = 6378.137 * nf * 1e3, W = Math.cos(A3 * nf), re = 1 / (1 - cs * (1 - W * W)), fe = Math.sqrt(re);\n                    this.kx = F3 * fe * W, this.ky = F3 * fe * re * (1 - cs);\n                  }\n                  distance(A3, F3) {\n                    let W = this.wrap(A3[0] - F3[0]) * this.kx, re = (A3[1] - F3[1]) * this.ky;\n                    return Math.sqrt(W * W + re * re);\n                  }\n                  pointOnLine(A3, F3) {\n                    let W, re, fe, pe, ze = 1 / 0;\n                    for (let Ke = 0; Ke < A3.length - 1; Ke++) {\n                      let ct = A3[Ke][0], Lt = A3[Ke][1], $t = this.wrap(A3[Ke + 1][0] - ct) * this.kx, fr = (A3[Ke + 1][1] - Lt) * this.ky, mr = 0;\n                      $t === 0 && fr === 0 || (mr = (this.wrap(F3[0] - ct) * this.kx * $t + (F3[1] - Lt) * this.ky * fr) / ($t * $t + fr * fr), mr > 1 ? (ct = A3[Ke + 1][0], Lt = A3[Ke + 1][1]) : mr > 0 && (ct += $t / this.kx * mr, Lt += fr / this.ky * mr)), $t = this.wrap(F3[0] - ct) * this.kx, fr = (F3[1] - Lt) * this.ky;\n                      let Pr = $t * $t + fr * fr;\n                      Pr < ze && (ze = Pr, W = ct, re = Lt, fe = Ke, pe = mr);\n                    }\n                    return { point: [W, re], index: fe, t: Math.max(0, Math.min(1, pe)) };\n                  }\n                  wrap(A3) {\n                    for (; A3 < -180; ) A3 += 360;\n                    for (; A3 > 180; ) A3 -= 360;\n                    return A3;\n                  }\n                }\n                function Jl(R, A3) {\n                  return A3[0] - R[0];\n                }\n                function fl(R) {\n                  return R[1] - R[0] + 1;\n                }\n                function lc(R, A3) {\n                  return R[1] >= R[0] && R[1] < A3;\n                }\n                function Fu(R, A3) {\n                  if (R[0] > R[1]) return [null, null];\n                  let F3 = fl(R);\n                  if (A3) {\n                    if (F3 === 2) return [R, null];\n                    let re = Math.floor(F3 / 2);\n                    return [[R[0], R[0] + re], [R[0] + re, R[1]]];\n                  }\n                  if (F3 === 1) return [R, null];\n                  let W = Math.floor(F3 / 2) - 1;\n                  return [[R[0], R[0] + W], [R[0] + W + 1, R[1]]];\n                }\n                function Es(R, A3) {\n                  if (!lc(A3, R.length)) return [1 / 0, 1 / 0, -1 / 0, -1 / 0];\n                  let F3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];\n                  for (let W = A3[0]; W <= A3[1]; ++W) Vu(F3, R[W]);\n                  return F3;\n                }\n                function Hs(R) {\n                  let A3 = [1 / 0, 1 / 0, -1 / 0, -1 / 0];\n                  for (let F3 of R) for (let W of F3) Vu(A3, W);\n                  return A3;\n                }\n                function Go(R) {\n                  return R[0] !== -1 / 0 && R[1] !== -1 / 0 && R[2] !== 1 / 0 && R[3] !== 1 / 0;\n                }\n                function ps(R, A3, F3) {\n                  if (!Go(R) || !Go(A3)) return NaN;\n                  let W = 0, re = 0;\n                  return R[2] < A3[0] && (W = A3[0] - R[2]), R[0] > A3[2] && (W = R[0] - A3[2]), R[1] > A3[3] && (re = R[1] - A3[3]), R[3] < A3[1] && (re = A3[1] - R[3]), F3.distance([0, 0], [W, re]);\n                }\n                function uc(R, A3, F3) {\n                  let W = F3.pointOnLine(A3, R);\n                  return F3.distance(R, W.point);\n                }\n                function xl(R, A3, F3, W, re) {\n                  let fe = Math.min(uc(R, [F3, W], re), uc(A3, [F3, W], re)), pe = Math.min(uc(F3, [R, A3], re), uc(W, [R, A3], re));\n                  return Math.min(fe, pe);\n                }\n                function Gu(R, A3, F3, W, re) {\n                  if (!lc(A3, R.length) || !lc(W, F3.length)) return 1 / 0;\n                  let fe = 1 / 0;\n                  for (let pe = A3[0]; pe < A3[1]; ++pe) {\n                    let ze = R[pe], Ke = R[pe + 1];\n                    for (let ct = W[0]; ct < W[1]; ++ct) {\n                      let Lt = F3[ct], $t = F3[ct + 1];\n                      if (Yl(ze, Ke, Lt, $t)) return 0;\n                      fe = Math.min(fe, xl(ze, Ke, Lt, $t, re));\n                    }\n                  }\n                  return fe;\n                }\n                function qs(R, A3, F3, W, re) {\n                  if (!lc(A3, R.length) || !lc(W, F3.length)) return NaN;\n                  let fe = 1 / 0;\n                  for (let pe = A3[0]; pe <= A3[1]; ++pe) for (let ze = W[0]; ze <= W[1]; ++ze) if (fe = Math.min(fe, re.distance(R[pe], F3[ze])), fe === 0) return fe;\n                  return fe;\n                }\n                function ad(R, A3, F3) {\n                  if (Hl(R, A3, true)) return 0;\n                  let W = 1 / 0;\n                  for (let re of A3) {\n                    let fe = re[0], pe = re[re.length - 1];\n                    if (fe !== pe && (W = Math.min(W, uc(R, [pe, fe], F3)), W === 0)) return W;\n                    let ze = F3.pointOnLine(re, R);\n                    if (W = Math.min(W, F3.distance(R, ze.point)), W === 0) return W;\n                  }\n                  return W;\n                }\n                function Po(R, A3, F3, W) {\n                  if (!lc(A3, R.length)) return NaN;\n                  for (let fe = A3[0]; fe <= A3[1]; ++fe) if (Hl(R[fe], F3, true)) return 0;\n                  let re = 1 / 0;\n                  for (let fe = A3[0]; fe < A3[1]; ++fe) {\n                    let pe = R[fe], ze = R[fe + 1];\n                    for (let Ke of F3) for (let ct = 0, Lt = Ke.length, $t = Lt - 1; ct < Lt; $t = ct++) {\n                      let fr = Ke[$t], mr = Ke[ct];\n                      if (Yl(pe, ze, fr, mr)) return 0;\n                      re = Math.min(re, xl(pe, ze, fr, mr, W));\n                    }\n                  }\n                  return re;\n                }\n                function od(R, A3) {\n                  for (let F3 of R) for (let W of F3) if (Hl(W, A3, true)) return true;\n                  return false;\n                }\n                function Yo(R, A3, F3, W = 1 / 0) {\n                  let re = Hs(R), fe = Hs(A3);\n                  if (W !== 1 / 0 && ps(re, fe, F3) >= W) return W;\n                  if (Ol(re, fe)) {\n                    if (od(R, A3)) return 0;\n                  } else if (od(A3, R)) return 0;\n                  let pe = 1 / 0;\n                  for (let ze of R) for (let Ke = 0, ct = ze.length, Lt = ct - 1; Ke < ct; Lt = Ke++) {\n                    let $t = ze[Lt], fr = ze[Ke];\n                    for (let mr of A3) for (let Pr = 0, zr = mr.length, ui = zr - 1; Pr < zr; ui = Pr++) {\n                      let yi = mr[ui], vn = mr[Pr];\n                      if (Yl($t, fr, yi, vn)) return 0;\n                      pe = Math.min(pe, xl($t, fr, yi, vn, F3));\n                    }\n                  }\n                  return pe;\n                }\n                function Pa(R, A3, F3, W, re, fe) {\n                  if (!fe) return;\n                  let pe = ps(Es(W, fe), re, F3);\n                  pe < A3 && R.push([pe, fe, [0, 0]]);\n                }\n                function af(R, A3, F3, W, re, fe, pe) {\n                  if (!fe || !pe) return;\n                  let ze = ps(Es(W, fe), Es(re, pe), F3);\n                  ze < A3 && R.push([ze, fe, pe]);\n                }\n                function Hu(R, A3, F3, W, re = 1 / 0) {\n                  let fe = Math.min(W.distance(R[0], F3[0][0]), re);\n                  if (fe === 0) return fe;\n                  let pe = new Zc([[0, [0, R.length - 1], [0, 0]]], Jl), ze = Hs(F3);\n                  for (; pe.length > 0; ) {\n                    let Ke = pe.pop();\n                    if (Ke[0] >= fe) continue;\n                    let ct = Ke[1], Lt = A3 ? 50 : 100;\n                    if (fl(ct) <= Lt) {\n                      if (!lc(ct, R.length)) return NaN;\n                      if (A3) {\n                        let $t = Po(R, ct, F3, W);\n                        if (isNaN($t) || $t === 0) return $t;\n                        fe = Math.min(fe, $t);\n                      } else for (let $t = ct[0]; $t <= ct[1]; ++$t) {\n                        let fr = ad(R[$t], F3, W);\n                        if (fe = Math.min(fe, fr), fe === 0) return 0;\n                      }\n                    } else {\n                      let $t = Fu(ct, A3);\n                      Pa(pe, fe, W, R, ze, $t[0]), Pa(pe, fe, W, R, ze, $t[1]);\n                    }\n                  }\n                  return fe;\n                }\n                function bl(R, A3, F3, W, re, fe = 1 / 0) {\n                  let pe = Math.min(fe, re.distance(R[0], F3[0]));\n                  if (pe === 0) return pe;\n                  let ze = new Zc([[0, [0, R.length - 1], [0, F3.length - 1]]], Jl);\n                  for (; ze.length > 0; ) {\n                    let Ke = ze.pop();\n                    if (Ke[0] >= pe) continue;\n                    let ct = Ke[1], Lt = Ke[2], $t = A3 ? 50 : 100, fr = W ? 50 : 100;\n                    if (fl(ct) <= $t && fl(Lt) <= fr) {\n                      if (!lc(ct, R.length) && lc(Lt, F3.length)) return NaN;\n                      let mr;\n                      if (A3 && W) mr = Gu(R, ct, F3, Lt, re), pe = Math.min(pe, mr);\n                      else if (A3 && !W) {\n                        let Pr = R.slice(ct[0], ct[1] + 1);\n                        for (let zr = Lt[0]; zr <= Lt[1]; ++zr) if (mr = uc(F3[zr], Pr, re), pe = Math.min(pe, mr), pe === 0) return pe;\n                      } else if (!A3 && W) {\n                        let Pr = F3.slice(Lt[0], Lt[1] + 1);\n                        for (let zr = ct[0]; zr <= ct[1]; ++zr) if (mr = uc(R[zr], Pr, re), pe = Math.min(pe, mr), pe === 0) return pe;\n                      } else mr = qs(R, ct, F3, Lt, re), pe = Math.min(pe, mr);\n                    } else {\n                      let mr = Fu(ct, A3), Pr = Fu(Lt, W);\n                      af(ze, pe, re, R, F3, mr[0], Pr[0]), af(ze, pe, re, R, F3, mr[0], Pr[1]), af(ze, pe, re, R, F3, mr[1], Pr[0]), af(ze, pe, re, R, F3, mr[1], Pr[1]);\n                    }\n                  }\n                  return pe;\n                }\n                function Gf(R) {\n                  return R.type === "MultiPolygon" ? R.coordinates.map((A3) => ({ type: "Polygon", coordinates: A3 })) : R.type === "MultiLineString" ? R.coordinates.map((A3) => ({ type: "LineString", coordinates: A3 })) : R.type === "MultiPoint" ? R.coordinates.map((A3) => ({ type: "Point", coordinates: A3 })) : [R];\n                }\n                class Ic {\n                  constructor(A3, F3) {\n                    this.type = _t, this.geojson = A3, this.geometries = F3;\n                  }\n                  static parse(A3, F3) {\n                    if (A3.length !== 2) return F3.error(`\'distance\' expression requires exactly one argument, but found ${A3.length - 1} instead.`);\n                    if (yn(A3[1])) {\n                      let W = A3[1];\n                      if (W.type === "FeatureCollection") return new Ic(W, W.features.map((re) => Gf(re.geometry)).flat());\n                      if (W.type === "Feature") return new Ic(W, Gf(W.geometry));\n                      if ("type" in W && "coordinates" in W) return new Ic(W, Gf(W));\n                    }\n                    return F3.error("\'distance\' expression requires valid geojson object that contains polygon geometry type.");\n                  }\n                  evaluate(A3) {\n                    if (A3.geometry() != null && A3.canonicalID() != null) {\n                      if (A3.geometryType() === "Point") return (function(F3, W) {\n                        let re = F3.geometry(), fe = re.flat().map((Ke) => _a([Ke.x, Ke.y], F3.canonical));\n                        if (re.length === 0) return NaN;\n                        let pe = new Vf(fe[0][1]), ze = 1 / 0;\n                        for (let Ke of W) {\n                          switch (Ke.type) {\n                            case "Point":\n                              ze = Math.min(ze, bl(fe, false, [Ke.coordinates], false, pe, ze));\n                              break;\n                            case "LineString":\n                              ze = Math.min(ze, bl(fe, false, Ke.coordinates, true, pe, ze));\n                              break;\n                            case "Polygon":\n                              ze = Math.min(ze, Hu(fe, false, Ke.coordinates, pe, ze));\n                          }\n                          if (ze === 0) return ze;\n                        }\n                        return ze;\n                      })(A3, this.geometries);\n                      if (A3.geometryType() === "LineString") return (function(F3, W) {\n                        let re = F3.geometry(), fe = re.flat().map((Ke) => _a([Ke.x, Ke.y], F3.canonical));\n                        if (re.length === 0) return NaN;\n                        let pe = new Vf(fe[0][1]), ze = 1 / 0;\n                        for (let Ke of W) {\n                          switch (Ke.type) {\n                            case "Point":\n                              ze = Math.min(ze, bl(fe, true, [Ke.coordinates], false, pe, ze));\n                              break;\n                            case "LineString":\n                              ze = Math.min(ze, bl(fe, true, Ke.coordinates, true, pe, ze));\n                              break;\n                            case "Polygon":\n                              ze = Math.min(ze, Hu(fe, true, Ke.coordinates, pe, ze));\n                          }\n                          if (ze === 0) return ze;\n                        }\n                        return ze;\n                      })(A3, this.geometries);\n                      if (A3.geometryType() === "Polygon") return (function(F3, W) {\n                        let re = F3.geometry();\n                        if (re.length === 0 || re[0].length === 0) return NaN;\n                        let fe = Cf(re, 0).map((Ke) => Ke.map((ct) => ct.map((Lt) => _a([Lt.x, Lt.y], F3.canonical)))), pe = new Vf(fe[0][0][0][1]), ze = 1 / 0;\n                        for (let Ke of W) for (let ct of fe) {\n                          switch (Ke.type) {\n                            case "Point":\n                              ze = Math.min(ze, Hu([Ke.coordinates], false, ct, pe, ze));\n                              break;\n                            case "LineString":\n                              ze = Math.min(ze, Hu(Ke.coordinates, true, ct, pe, ze));\n                              break;\n                            case "Polygon":\n                              ze = Math.min(ze, Yo(ct, Ke.coordinates, pe, ze));\n                          }\n                          if (ze === 0) return ze;\n                        }\n                        return ze;\n                      })(A3, this.geometries);\n                    }\n                    return NaN;\n                  }\n                  eachChild() {\n                  }\n                  outputDefined() {\n                    return true;\n                  }\n                }\n                let yf = { "==": us, "!=": il, ">": cl, "<": As, ">=": zs, "<=": Ks, array: Fa, at: kr, boolean: Fa, case: An, coalesce: Fs, collator: Io, format: Zl, image: Su, in: Jr, "index-of": vi, interpolate: ko, "interpolate-hcl": ko, "interpolate-lab": ko, length: nc, let: jn, literal: ua, match: hn, number: Fa, "number-format": ls, object: Fa, slice: Mn, step: _n, string: Fa, "to-boolean": da, "to-color": da, "to-number": da, "to-string": da, var: Mt, within: pl, distance: Ic };\n                class Bl {\n                  constructor(A3, F3, W, re) {\n                    this.name = A3, this.type = F3, this._evaluate = W, this.args = re;\n                  }\n                  evaluate(A3) {\n                    return this._evaluate(A3, this.args);\n                  }\n                  eachChild(A3) {\n                    this.args.forEach(A3);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                  static parse(A3, F3) {\n                    let W = A3[0], re = Bl.definitions[W];\n                    if (!re) return F3.error(`Unknown expression "${W}". If you wanted a literal array, use ["literal", [...]].`, 0);\n                    let fe = Array.isArray(re) ? re[0] : re.type, pe = Array.isArray(re) ? [[re[1], re[2]]] : re.overloads, ze = pe.filter(([ct]) => !Array.isArray(ct) || ct.length === A3.length - 1), Ke = null;\n                    for (let [ct, Lt] of ze) {\n                      Ke = new vo(F3.registry, eh, F3.path, null, F3.scope);\n                      let $t = [], fr = false;\n                      for (let mr = 1; mr < A3.length; mr++) {\n                        let Pr = A3[mr], zr = Array.isArray(ct) ? ct[mr - 1] : ct.type, ui = Ke.parse(Pr, 1 + $t.length, zr);\n                        if (!ui) {\n                          fr = true;\n                          break;\n                        }\n                        $t.push(ui);\n                      }\n                      if (!fr) if (Array.isArray(ct) && ct.length !== $t.length) Ke.error(`Expected ${ct.length} arguments, but found ${$t.length} instead.`);\n                      else {\n                        for (let mr = 0; mr < $t.length; mr++) {\n                          let Pr = Array.isArray(ct) ? ct[mr] : ct.type, zr = $t[mr];\n                          Ke.concat(mr + 1).checkSubtype(Pr, zr.type);\n                        }\n                        if (Ke.errors.length === 0) return new Bl(W, fe, Lt, $t);\n                      }\n                    }\n                    if (ze.length === 1) F3.errors.push(...Ke.errors);\n                    else {\n                      let ct = (ze.length ? ze : pe).map(([$t]) => {\n                        return fr = $t, Array.isArray(fr) ? `(${fr.map(Je).join(", ")})` : `(${Je(fr.type)}...)`;\n                        var fr;\n                      }).join(" | "), Lt = [];\n                      for (let $t = 1; $t < A3.length; $t++) {\n                        let fr = F3.parse(A3[$t], 1 + Lt.length);\n                        if (!fr) return null;\n                        Lt.push(Je(fr.type));\n                      }\n                      F3.error(`Expected arguments of type ${ct}, but found (${Lt.join(", ")}) instead.`);\n                    }\n                    return null;\n                  }\n                  static register(A3, F3) {\n                    Bl.definitions = F3;\n                    for (let W in F3) A3[W] = Bl;\n                  }\n                }\n                function wh(R, [A3, F3, W, re]) {\n                  A3 = A3.evaluate(R), F3 = F3.evaluate(R), W = W.evaluate(R);\n                  let fe = re ? re.evaluate(R) : 1, pe = fn(A3, F3, W, fe);\n                  if (pe) throw new ma(pe);\n                  return new nr(A3 / 255, F3 / 255, W / 255, fe, false);\n                }\n                function Qf(R, A3) {\n                  return R in A3;\n                }\n                function _f(R, A3) {\n                  let F3 = A3[R];\n                  return F3 === void 0 ? null : F3;\n                }\n                function Yc(R) {\n                  return { type: R };\n                }\n                function eh(R) {\n                  if (R instanceof Mt) return eh(R.boundExpression);\n                  if (R instanceof Bl && R.name === "error" || R instanceof Io || R instanceof pl || R instanceof Ic) return false;\n                  let A3 = R instanceof da || R instanceof Fa, F3 = true;\n                  return R.eachChild((W) => {\n                    F3 = A3 ? F3 && eh(W) : F3 && W instanceof ua;\n                  }), !!F3 && th(R) && Hf(R, ["zoom", "heatmap-density", "line-progress", "accumulated", "is-supported-script"]);\n                }\n                function th(R) {\n                  if (R instanceof Bl && (R.name === "get" && R.args.length === 1 || R.name === "feature-state" || R.name === "has" && R.args.length === 1 || R.name === "properties" || R.name === "geometry-type" || R.name === "id" || /^filter-/.test(R.name)) || R instanceof pl || R instanceof Ic) return false;\n                  let A3 = true;\n                  return R.eachChild((F3) => {\n                    A3 && !th(F3) && (A3 = false);\n                  }), A3;\n                }\n                function ju(R) {\n                  if (R instanceof Bl && R.name === "feature-state") return false;\n                  let A3 = true;\n                  return R.eachChild((F3) => {\n                    A3 && !ju(F3) && (A3 = false);\n                  }), A3;\n                }\n                function Hf(R, A3) {\n                  if (R instanceof Bl && A3.indexOf(R.name) >= 0) return false;\n                  let F3 = true;\n                  return R.eachChild((W) => {\n                    F3 && !Hf(W, A3) && (F3 = false);\n                  }), F3;\n                }\n                function cc(R) {\n                  return { result: "success", value: R };\n                }\n                function of(R) {\n                  return { result: "error", value: R };\n                }\n                function Nl(R) {\n                  return R["property-type"] === "data-driven" || R["property-type"] === "cross-faded-data-driven";\n                }\n                function Kc(R) {\n                  return !!R.expression && R.expression.parameters.indexOf("zoom") > -1;\n                }\n                function Rc(R) {\n                  return !!R.expression && R.expression.interpolated;\n                }\n                function gs(R) {\n                  return R instanceof Number ? "number" : R instanceof String ? "string" : R instanceof Boolean ? "boolean" : Array.isArray(R) ? "array" : R === null ? "null" : typeof R;\n                }\n                function jf(R) {\n                  return typeof R == "object" && R !== null && !Array.isArray(R);\n                }\n                function Gh(R) {\n                  return R;\n                }\n                function rh(R, A3) {\n                  let F3 = A3.type === "color", W = R.stops && typeof R.stops[0][0] == "object", re = W || !(W || R.property !== void 0), fe = R.type || (Rc(A3) ? "exponential" : "interval");\n                  if (F3 || A3.type === "padding") {\n                    let Lt = F3 ? nr.parse : Qr.parse;\n                    (R = $e({}, R)).stops && (R.stops = R.stops.map(($t) => [$t[0], Lt($t[1])])), R.default = Lt(R.default ? R.default : A3.default);\n                  }\n                  if (R.colorSpace && (pe = R.colorSpace) !== "rgb" && pe !== "hcl" && pe !== "lab") throw new Error(`Unknown color space: "${R.colorSpace}"`);\n                  var pe;\n                  let ze, Ke, ct;\n                  if (fe === "exponential") ze = ih;\n                  else if (fe === "interval") ze = Mu;\n                  else if (fe === "categorical") {\n                    ze = Th, Ke = /* @__PURE__ */ Object.create(null);\n                    for (let Lt of R.stops) Ke[Lt[0]] = Lt[1];\n                    ct = typeof R.stops[0][0];\n                  } else {\n                    if (fe !== "identity") throw new Error(`Unknown function type "${fe}"`);\n                    ze = js;\n                  }\n                  if (W) {\n                    let Lt = {}, $t = [];\n                    for (let Pr = 0; Pr < R.stops.length; Pr++) {\n                      let zr = R.stops[Pr], ui = zr[0].zoom;\n                      Lt[ui] === void 0 && (Lt[ui] = { zoom: ui, type: R.type, property: R.property, default: R.default, stops: [] }, $t.push(ui)), Lt[ui].stops.push([zr[0].value, zr[1]]);\n                    }\n                    let fr = [];\n                    for (let Pr of $t) fr.push([Lt[Pr].zoom, rh(Lt[Pr], A3)]);\n                    let mr = { name: "linear" };\n                    return { kind: "composite", interpolationType: mr, interpolationFactor: ko.interpolationFactor.bind(void 0, mr), zoomStops: fr.map((Pr) => Pr[0]), evaluate: ({ zoom: Pr }, zr) => ih({ stops: fr, base: R.base }, A3, Pr).evaluate(Pr, zr) };\n                  }\n                  if (re) {\n                    let Lt = fe === "exponential" ? { name: "exponential", base: R.base !== void 0 ? R.base : 1 } : null;\n                    return { kind: "camera", interpolationType: Lt, interpolationFactor: ko.interpolationFactor.bind(void 0, Lt), zoomStops: R.stops.map(($t) => $t[0]), evaluate: ({ zoom: $t }) => ze(R, A3, $t, Ke, ct) };\n                  }\n                  return { kind: "source", evaluate(Lt, $t) {\n                    let fr = $t && $t.properties ? $t.properties[R.property] : void 0;\n                    return fr === void 0 ? sf(R.default, A3.default) : ze(R, A3, fr, Ke, ct);\n                  } };\n                }\n                function sf(R, A3, F3) {\n                  return R !== void 0 ? R : A3 !== void 0 ? A3 : F3 !== void 0 ? F3 : void 0;\n                }\n                function Th(R, A3, F3, W, re) {\n                  return sf(typeof F3 === re ? W[F3] : void 0, R.default, A3.default);\n                }\n                function Mu(R, A3, F3) {\n                  if (gs(F3) !== "number") return sf(R.default, A3.default);\n                  let W = R.stops.length;\n                  if (W === 1 || F3 <= R.stops[0][0]) return R.stops[0][1];\n                  if (F3 >= R.stops[W - 1][0]) return R.stops[W - 1][1];\n                  let re = Li(R.stops.map((fe) => fe[0]), F3);\n                  return R.stops[re][1];\n                }\n                function ih(R, A3, F3) {\n                  let W = R.base !== void 0 ? R.base : 1;\n                  if (gs(F3) !== "number") return sf(R.default, A3.default);\n                  let re = R.stops.length;\n                  if (re === 1 || F3 <= R.stops[0][0]) return R.stops[0][1];\n                  if (F3 >= R.stops[re - 1][0]) return R.stops[re - 1][1];\n                  let fe = Li(R.stops.map((Lt) => Lt[0]), F3), pe = (function(Lt, $t, fr, mr) {\n                    let Pr = mr - fr, zr = Lt - fr;\n                    return Pr === 0 ? 0 : $t === 1 ? zr / Pr : (Math.pow($t, zr) - 1) / (Math.pow($t, Pr) - 1);\n                  })(F3, W, R.stops[fe][0], R.stops[fe + 1][0]), ze = R.stops[fe][1], Ke = R.stops[fe + 1][1], ct = Lo[A3.type] || Gh;\n                  return typeof ze.evaluate == "function" ? { evaluate(...Lt) {\n                    let $t = ze.evaluate.apply(void 0, Lt), fr = Ke.evaluate.apply(void 0, Lt);\n                    if ($t !== void 0 && fr !== void 0) return ct($t, fr, pe, R.colorSpace);\n                  } } : ct(ze, Ke, pe, R.colorSpace);\n                }\n                function js(R, A3, F3) {\n                  switch (A3.type) {\n                    case "color":\n                      F3 = nr.parse(F3);\n                      break;\n                    case "formatted":\n                      F3 = ri.fromString(F3.toString());\n                      break;\n                    case "resolvedImage":\n                      F3 = tn.fromString(F3.toString());\n                      break;\n                    case "padding":\n                      F3 = Qr.parse(F3);\n                      break;\n                    default:\n                      gs(F3) === A3.type || A3.type === "enum" && A3.values[F3] || (F3 = void 0);\n                  }\n                  return sf(F3, R.default, A3.default);\n                }\n                Bl.register(yf, { error: [{ kind: "error" }, [It], (R, [A3]) => {\n                  throw new ma(A3.evaluate(R));\n                }], typeof: [It, [Tr], (R, [A3]) => Je(Sn(A3.evaluate(R)))], "to-rgba": [Ge(_t, 4), [er], (R, [A3]) => {\n                  let [F3, W, re, fe] = A3.evaluate(R).rgb;\n                  return [255 * F3, 255 * W, 255 * re, fe];\n                }], rgb: [er, [_t, _t, _t], wh], rgba: [er, [_t, _t, _t, _t], wh], has: { type: mt, overloads: [[[It], (R, [A3]) => Qf(A3.evaluate(R), R.properties())], [[It, lr], (R, [A3, F3]) => Qf(A3.evaluate(R), F3.evaluate(R))]] }, get: { type: Tr, overloads: [[[It], (R, [A3]) => _f(A3.evaluate(R), R.properties())], [[It, lr], (R, [A3, F3]) => _f(A3.evaluate(R), F3.evaluate(R))]] }, "feature-state": [Tr, [It], (R, [A3]) => _f(A3.evaluate(R), R.featureState || {})], properties: [lr, [], (R) => R.properties()], "geometry-type": [It, [], (R) => R.geometryType()], id: [Tr, [], (R) => R.id()], zoom: [_t, [], (R) => R.globals.zoom], "heatmap-density": [_t, [], (R) => R.globals.heatmapDensity || 0], "line-progress": [_t, [], (R) => R.globals.lineProgress || 0], accumulated: [Tr, [], (R) => R.globals.accumulated === void 0 ? null : R.globals.accumulated], "+": [_t, Yc(_t), (R, A3) => {\n                  let F3 = 0;\n                  for (let W of A3) F3 += W.evaluate(R);\n                  return F3;\n                }], "*": [_t, Yc(_t), (R, A3) => {\n                  let F3 = 1;\n                  for (let W of A3) F3 *= W.evaluate(R);\n                  return F3;\n                }], "-": { type: _t, overloads: [[[_t, _t], (R, [A3, F3]) => A3.evaluate(R) - F3.evaluate(R)], [[_t], (R, [A3]) => -A3.evaluate(R)]] }, "/": [_t, [_t, _t], (R, [A3, F3]) => A3.evaluate(R) / F3.evaluate(R)], "%": [_t, [_t, _t], (R, [A3, F3]) => A3.evaluate(R) % F3.evaluate(R)], ln2: [_t, [], () => Math.LN2], pi: [_t, [], () => Math.PI], e: [_t, [], () => Math.E], "^": [_t, [_t, _t], (R, [A3, F3]) => Math.pow(A3.evaluate(R), F3.evaluate(R))], sqrt: [_t, [_t], (R, [A3]) => Math.sqrt(A3.evaluate(R))], log10: [_t, [_t], (R, [A3]) => Math.log(A3.evaluate(R)) / Math.LN10], ln: [_t, [_t], (R, [A3]) => Math.log(A3.evaluate(R))], log2: [_t, [_t], (R, [A3]) => Math.log(A3.evaluate(R)) / Math.LN2], sin: [_t, [_t], (R, [A3]) => Math.sin(A3.evaluate(R))], cos: [_t, [_t], (R, [A3]) => Math.cos(A3.evaluate(R))], tan: [_t, [_t], (R, [A3]) => Math.tan(A3.evaluate(R))], asin: [_t, [_t], (R, [A3]) => Math.asin(A3.evaluate(R))], acos: [_t, [_t], (R, [A3]) => Math.acos(A3.evaluate(R))], atan: [_t, [_t], (R, [A3]) => Math.atan(A3.evaluate(R))], min: [_t, Yc(_t), (R, A3) => Math.min(...A3.map((F3) => F3.evaluate(R)))], max: [_t, Yc(_t), (R, A3) => Math.max(...A3.map((F3) => F3.evaluate(R)))], abs: [_t, [_t], (R, [A3]) => Math.abs(A3.evaluate(R))], round: [_t, [_t], (R, [A3]) => {\n                  let F3 = A3.evaluate(R);\n                  return F3 < 0 ? -Math.round(-F3) : Math.round(F3);\n                }], floor: [_t, [_t], (R, [A3]) => Math.floor(A3.evaluate(R))], ceil: [_t, [_t], (R, [A3]) => Math.ceil(A3.evaluate(R))], "filter-==": [mt, [It, Tr], (R, [A3, F3]) => R.properties()[A3.value] === F3.value], "filter-id-==": [mt, [Tr], (R, [A3]) => R.id() === A3.value], "filter-type-==": [mt, [It], (R, [A3]) => R.geometryType() === A3.value], "filter-<": [mt, [It, Tr], (R, [A3, F3]) => {\n                  let W = R.properties()[A3.value], re = F3.value;\n                  return typeof W == typeof re && W < re;\n                }], "filter-id-<": [mt, [Tr], (R, [A3]) => {\n                  let F3 = R.id(), W = A3.value;\n                  return typeof F3 == typeof W && F3 < W;\n                }], "filter->": [mt, [It, Tr], (R, [A3, F3]) => {\n                  let W = R.properties()[A3.value], re = F3.value;\n                  return typeof W == typeof re && W > re;\n                }], "filter-id->": [mt, [Tr], (R, [A3]) => {\n                  let F3 = R.id(), W = A3.value;\n                  return typeof F3 == typeof W && F3 > W;\n                }], "filter-<=": [mt, [It, Tr], (R, [A3, F3]) => {\n                  let W = R.properties()[A3.value], re = F3.value;\n                  return typeof W == typeof re && W <= re;\n                }], "filter-id-<=": [mt, [Tr], (R, [A3]) => {\n                  let F3 = R.id(), W = A3.value;\n                  return typeof F3 == typeof W && F3 <= W;\n                }], "filter->=": [mt, [It, Tr], (R, [A3, F3]) => {\n                  let W = R.properties()[A3.value], re = F3.value;\n                  return typeof W == typeof re && W >= re;\n                }], "filter-id->=": [mt, [Tr], (R, [A3]) => {\n                  let F3 = R.id(), W = A3.value;\n                  return typeof F3 == typeof W && F3 >= W;\n                }], "filter-has": [mt, [Tr], (R, [A3]) => A3.value in R.properties()], "filter-has-id": [mt, [], (R) => R.id() !== null && R.id() !== void 0], "filter-type-in": [mt, [Ge(It)], (R, [A3]) => A3.value.indexOf(R.geometryType()) >= 0], "filter-id-in": [mt, [Ge(Tr)], (R, [A3]) => A3.value.indexOf(R.id()) >= 0], "filter-in-small": [mt, [It, Ge(Tr)], (R, [A3, F3]) => F3.value.indexOf(R.properties()[A3.value]) >= 0], "filter-in-large": [mt, [It, Ge(Tr)], (R, [A3, F3]) => (function(W, re, fe, pe) {\n                  for (; fe <= pe; ) {\n                    let ze = fe + pe >> 1;\n                    if (re[ze] === W) return true;\n                    re[ze] > W ? pe = ze - 1 : fe = ze + 1;\n                  }\n                  return false;\n                })(R.properties()[A3.value], F3.value, 0, F3.value.length - 1)], all: { type: mt, overloads: [[[mt, mt], (R, [A3, F3]) => A3.evaluate(R) && F3.evaluate(R)], [Yc(mt), (R, A3) => {\n                  for (let F3 of A3) if (!F3.evaluate(R)) return false;\n                  return true;\n                }]] }, any: { type: mt, overloads: [[[mt, mt], (R, [A3, F3]) => A3.evaluate(R) || F3.evaluate(R)], [Yc(mt), (R, A3) => {\n                  for (let F3 of A3) if (F3.evaluate(R)) return true;\n                  return false;\n                }]] }, "!": [mt, [mt], (R, [A3]) => !A3.evaluate(R)], "is-supported-script": [mt, [It], (R, [A3]) => {\n                  let F3 = R.globals && R.globals.isSupportedScript;\n                  return !F3 || F3(A3.evaluate(R));\n                }], upcase: [It, [It], (R, [A3]) => A3.evaluate(R).toUpperCase()], downcase: [It, [It], (R, [A3]) => A3.evaluate(R).toLowerCase()], concat: [It, Yc(Tr), (R, A3) => A3.map((F3) => Ba(F3.evaluate(R))).join("")], "resolved-locale": [It, [Lr], (R, [A3]) => A3.evaluate(R).resolvedLocale()] });\n                class Eu {\n                  constructor(A3, F3) {\n                    var W;\n                    this.expression = A3, this._warningHistory = {}, this._evaluator = new Ha(), this._defaultValue = F3 ? (W = F3).type === "color" && jf(W.default) ? new nr(0, 0, 0, 0) : W.type === "color" ? nr.parse(W.default) || null : W.type === "padding" ? Qr.parse(W.default) || null : W.type === "variableAnchorOffsetCollection" ? $i.parse(W.default) || null : W.default === void 0 ? null : W.default : null, this._enumValues = F3 && F3.type === "enum" ? F3.values : null;\n                  }\n                  evaluateWithoutErrorHandling(A3, F3, W, re, fe, pe) {\n                    return this._evaluator.globals = A3, this._evaluator.feature = F3, this._evaluator.featureState = W, this._evaluator.canonical = re, this._evaluator.availableImages = fe || null, this._evaluator.formattedSection = pe, this.expression.evaluate(this._evaluator);\n                  }\n                  evaluate(A3, F3, W, re, fe, pe) {\n                    this._evaluator.globals = A3, this._evaluator.feature = F3 || null, this._evaluator.featureState = W || null, this._evaluator.canonical = re, this._evaluator.availableImages = fe || null, this._evaluator.formattedSection = pe || null;\n                    try {\n                      let ze = this.expression.evaluate(this._evaluator);\n                      if (ze == null || typeof ze == "number" && ze != ze) return this._defaultValue;\n                      if (this._enumValues && !(ze in this._enumValues)) throw new ma(`Expected value to be one of ${Object.keys(this._enumValues).map((Ke) => JSON.stringify(Ke)).join(", ")}, but found ${JSON.stringify(ze)} instead.`);\n                      return ze;\n                    } catch (ze) {\n                      return this._warningHistory[ze.message] || (this._warningHistory[ze.message] = true, typeof console != "undefined" && console.warn(ze.message)), this._defaultValue;\n                    }\n                  }\n                }\n                function Dc(R) {\n                  return Array.isArray(R) && R.length > 0 && typeof R[0] == "string" && R[0] in yf;\n                }\n                function ks(R, A3) {\n                  let F3 = new vo(yf, eh, [], A3 ? (function(re) {\n                    let fe = { color: er, string: It, number: _t, enum: It, boolean: mt, formatted: ti, padding: Br, resolvedImage: Vr, variableAnchorOffsetCollection: dt };\n                    return re.type === "array" ? Ge(fe[re.value] || Tr, re.length) : fe[re.type];\n                  })(A3) : void 0), W = F3.parse(R, void 0, void 0, void 0, A3 && A3.type === "string" ? { typeAnnotation: "coerce" } : void 0);\n                  return W ? cc(new Eu(W, A3)) : of(F3.errors);\n                }\n                class bc {\n                  constructor(A3, F3) {\n                    this.kind = A3, this._styleExpression = F3, this.isStateDependent = A3 !== "constant" && !ju(F3.expression);\n                  }\n                  evaluateWithoutErrorHandling(A3, F3, W, re, fe, pe) {\n                    return this._styleExpression.evaluateWithoutErrorHandling(A3, F3, W, re, fe, pe);\n                  }\n                  evaluate(A3, F3, W, re, fe, pe) {\n                    return this._styleExpression.evaluate(A3, F3, W, re, fe, pe);\n                  }\n                }\n                class hu {\n                  constructor(A3, F3, W, re) {\n                    this.kind = A3, this.zoomStops = W, this._styleExpression = F3, this.isStateDependent = A3 !== "camera" && !ju(F3.expression), this.interpolationType = re;\n                  }\n                  evaluateWithoutErrorHandling(A3, F3, W, re, fe, pe) {\n                    return this._styleExpression.evaluateWithoutErrorHandling(A3, F3, W, re, fe, pe);\n                  }\n                  evaluate(A3, F3, W, re, fe, pe) {\n                    return this._styleExpression.evaluate(A3, F3, W, re, fe, pe);\n                  }\n                  interpolationFactor(A3, F3, W) {\n                    return this.interpolationType ? ko.interpolationFactor(this.interpolationType, A3, F3, W) : 0;\n                  }\n                }\n                function _u(R, A3) {\n                  let F3 = ks(R, A3);\n                  if (F3.result === "error") return F3;\n                  let W = F3.value.expression, re = th(W);\n                  if (!re && !Nl(A3)) return of([new St("", "data expressions not supported")]);\n                  let fe = Hf(W, ["zoom"]);\n                  if (!fe && !Kc(A3)) return of([new St("", "zoom expressions not supported")]);\n                  let pe = nh(W);\n                  return pe || fe ? pe instanceof St ? of([pe]) : pe instanceof ko && !Rc(A3) ? of([new St("", \'"interpolate" expressions cannot be used with this property\')]) : cc(pe ? new hu(re ? "camera" : "composite", F3.value, pe.labels, pe instanceof ko ? pe.interpolation : void 0) : new bc(re ? "constant" : "source", F3.value)) : of([new St("", \'"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.\')]);\n                }\n                class nl {\n                  constructor(A3, F3) {\n                    this._parameters = A3, this._specification = F3, $e(this, rh(this._parameters, this._specification));\n                  }\n                  static deserialize(A3) {\n                    return new nl(A3._parameters, A3._specification);\n                  }\n                  static serialize(A3) {\n                    return { _parameters: A3._parameters, _specification: A3._specification };\n                  }\n                }\n                function nh(R) {\n                  let A3 = null;\n                  if (R instanceof jn) A3 = nh(R.result);\n                  else if (R instanceof Fs) {\n                    for (let F3 of R.args) if (A3 = nh(F3), A3) break;\n                  } else (R instanceof _n || R instanceof ko) && R.input instanceof Bl && R.input.name === "zoom" && (A3 = R);\n                  return A3 instanceof St || R.eachChild((F3) => {\n                    let W = nh(F3);\n                    W instanceof St ? A3 = W : !A3 && W ? A3 = new St("", \'"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.\') : A3 && W && A3 !== W && (A3 = new St("", \'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.\'));\n                  }), A3;\n                }\n                function Ah(R) {\n                  if (R === true || R === false) return true;\n                  if (!Array.isArray(R) || R.length === 0) return false;\n                  switch (R[0]) {\n                    case "has":\n                      return R.length >= 2 && R[1] !== "$id" && R[1] !== "$type";\n                    case "in":\n                      return R.length >= 3 && (typeof R[1] != "string" || Array.isArray(R[2]));\n                    case "!in":\n                    case "!has":\n                    case "none":\n                      return false;\n                    case "==":\n                    case "!=":\n                    case ">":\n                    case ">=":\n                    case "<":\n                    case "<=":\n                      return R.length !== 3 || Array.isArray(R[1]) || Array.isArray(R[2]);\n                    case "any":\n                    case "all":\n                      for (let A3 of R.slice(1)) if (!Ah(A3) && typeof A3 != "boolean") return false;\n                      return true;\n                    default:\n                      return true;\n                  }\n                }\n                let zu = { type: "boolean", default: false, transition: false, "property-type": "data-driven", expression: { interpolated: false, parameters: ["zoom", "feature"] } };\n                function Fc(R) {\n                  if (R == null) return { filter: () => true, needGeometry: false };\n                  Ah(R) || (R = xf(R));\n                  let A3 = ks(R, zu);\n                  if (A3.result === "error") throw new Error(A3.value.map((F3) => `${F3.key}: ${F3.message}`).join(", "));\n                  return { filter: (F3, W, re) => A3.value.evaluate(F3, W, {}, re), needGeometry: bd(R) };\n                }\n                function wc(R, A3) {\n                  return R < A3 ? -1 : R > A3 ? 1 : 0;\n                }\n                function bd(R) {\n                  if (!Array.isArray(R)) return false;\n                  if (R[0] === "within" || R[0] === "distance") return true;\n                  for (let A3 = 1; A3 < R.length; A3++) if (bd(R[A3])) return true;\n                  return false;\n                }\n                function xf(R) {\n                  if (!R) return true;\n                  let A3 = R[0];\n                  return R.length <= 1 ? A3 !== "any" : A3 === "==" ? Pf(R[1], R[2], "==") : A3 === "!=" ? jl(Pf(R[1], R[2], "==")) : A3 === "<" || A3 === ">" || A3 === "<=" || A3 === ">=" ? Pf(R[1], R[2], A3) : A3 === "any" ? (F3 = R.slice(1), ["any"].concat(F3.map(xf))) : A3 === "all" ? ["all"].concat(R.slice(1).map(xf)) : A3 === "none" ? ["all"].concat(R.slice(1).map(xf).map(jl)) : A3 === "in" ? Ou(R[1], R.slice(2)) : A3 === "!in" ? jl(Ou(R[1], R.slice(2))) : A3 === "has" ? bf(R[1]) : A3 !== "!has" || jl(bf(R[1]));\n                  var F3;\n                }\n                function Pf(R, A3, F3) {\n                  switch (R) {\n                    case "$type":\n                      return [`filter-type-${F3}`, A3];\n                    case "$id":\n                      return [`filter-id-${F3}`, A3];\n                    default:\n                      return [`filter-${F3}`, R, A3];\n                  }\n                }\n                function Ou(R, A3) {\n                  if (A3.length === 0) return false;\n                  switch (R) {\n                    case "$type":\n                      return ["filter-type-in", ["literal", A3]];\n                    case "$id":\n                      return ["filter-id-in", ["literal", A3]];\n                    default:\n                      return A3.length > 200 && !A3.some((F3) => typeof F3 != typeof A3[0]) ? ["filter-in-large", R, ["literal", A3.sort(wc)]] : ["filter-in-small", R, ["literal", A3]];\n                  }\n                }\n                function bf(R) {\n                  switch (R) {\n                    case "$type":\n                      return true;\n                    case "$id":\n                      return ["filter-has-id"];\n                    default:\n                      return ["filter-has", R];\n                  }\n                }\n                function jl(R) {\n                  return ["!", R];\n                }\n                function lf(R) {\n                  let A3 = typeof R;\n                  if (A3 === "number" || A3 === "boolean" || A3 === "string" || R == null) return JSON.stringify(R);\n                  if (Array.isArray(R)) {\n                    let re = "[";\n                    for (let fe of R) re += `${lf(fe)},`;\n                    return `${re}]`;\n                  }\n                  let F3 = Object.keys(R).sort(), W = "{";\n                  for (let re = 0; re < F3.length; re++) W += `${JSON.stringify(F3[re])}:${lf(R[F3[re]])},`;\n                  return `${W}}`;\n                }\n                function Hh(R) {\n                  let A3 = "";\n                  for (let F3 of Ze) A3 += `/${lf(R[F3])}`;\n                  return A3;\n                }\n                function If(R) {\n                  let A3 = R.value;\n                  return A3 ? [new cr(R.key, A3, "constants have been deprecated as of v8")] : [];\n                }\n                function Cs(R) {\n                  return R instanceof Number || R instanceof String || R instanceof Boolean ? R.valueOf() : R;\n                }\n                function du(R) {\n                  if (Array.isArray(R)) return R.map(du);\n                  if (R instanceof Object && !(R instanceof Number || R instanceof String || R instanceof Boolean)) {\n                    let A3 = {};\n                    for (let F3 in R) A3[F3] = du(R[F3]);\n                    return A3;\n                  }\n                  return Cs(R);\n                }\n                function ku(R) {\n                  let A3 = R.key, F3 = R.value, W = R.valueSpec || {}, re = R.objectElementValidators || {}, fe = R.style, pe = R.styleSpec, ze = R.validateSpec, Ke = [], ct = gs(F3);\n                  if (ct !== "object") return [new cr(A3, F3, `object expected, ${ct} found`)];\n                  for (let Lt in F3) {\n                    let $t = Lt.split(".")[0], fr = W[$t] || W["*"], mr;\n                    if (re[$t]) mr = re[$t];\n                    else if (W[$t]) mr = ze;\n                    else if (re["*"]) mr = re["*"];\n                    else {\n                      if (!W["*"]) {\n                        Ke.push(new cr(A3, F3[Lt], `unknown property "${Lt}"`));\n                        continue;\n                      }\n                      mr = ze;\n                    }\n                    Ke = Ke.concat(mr({ key: (A3 && `${A3}.`) + Lt, value: F3[Lt], valueSpec: fr, style: fe, styleSpec: pe, object: F3, objectKey: Lt, validateSpec: ze }, F3));\n                  }\n                  for (let Lt in W) re[Lt] || W[Lt].required && W[Lt].default === void 0 && F3[Lt] === void 0 && Ke.push(new cr(A3, F3, `missing required property "${Lt}"`));\n                  return Ke;\n                }\n                function Wf(R) {\n                  let A3 = R.value, F3 = R.valueSpec, W = R.style, re = R.styleSpec, fe = R.key, pe = R.arrayElementValidator || R.validateSpec;\n                  if (gs(A3) !== "array") return [new cr(fe, A3, `array expected, ${gs(A3)} found`)];\n                  if (F3.length && A3.length !== F3.length) return [new cr(fe, A3, `array length ${F3.length} expected, length ${A3.length} found`)];\n                  if (F3["min-length"] && A3.length < F3["min-length"]) return [new cr(fe, A3, `array length at least ${F3["min-length"]} expected, length ${A3.length} found`)];\n                  let ze = { type: F3.value, values: F3.values };\n                  re.$version < 7 && (ze.function = F3.function), gs(F3.value) === "object" && (ze = F3.value);\n                  let Ke = [];\n                  for (let ct = 0; ct < A3.length; ct++) Ke = Ke.concat(pe({ array: A3, arrayIndex: ct, value: A3[ct], valueSpec: ze, validateSpec: R.validateSpec, style: W, styleSpec: re, key: `${fe}[${ct}]` }));\n                  return Ke;\n                }\n                function Us(R) {\n                  let A3 = R.key, F3 = R.value, W = R.valueSpec, re = gs(F3);\n                  return re === "number" && F3 != F3 && (re = "NaN"), re !== "number" ? [new cr(A3, F3, `number expected, ${re} found`)] : "minimum" in W && F3 < W.minimum ? [new cr(A3, F3, `${F3} is less than the minimum value ${W.minimum}`)] : "maximum" in W && F3 > W.maximum ? [new cr(A3, F3, `${F3} is greater than the maximum value ${W.maximum}`)] : [];\n                }\n                function wf(R) {\n                  let A3 = R.valueSpec, F3 = Cs(R.value.type), W, re, fe, pe = {}, ze = F3 !== "categorical" && R.value.property === void 0, Ke = !ze, ct = gs(R.value.stops) === "array" && gs(R.value.stops[0]) === "array" && gs(R.value.stops[0][0]) === "object", Lt = ku({ key: R.key, value: R.value, valueSpec: R.styleSpec.function, validateSpec: R.validateSpec, style: R.style, styleSpec: R.styleSpec, objectElementValidators: { stops: function(mr) {\n                    if (F3 === "identity") return [new cr(mr.key, mr.value, \'identity function may not have a "stops" property\')];\n                    let Pr = [], zr = mr.value;\n                    return Pr = Pr.concat(Wf({ key: mr.key, value: zr, valueSpec: mr.valueSpec, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec, arrayElementValidator: $t })), gs(zr) === "array" && zr.length === 0 && Pr.push(new cr(mr.key, zr, "array must have at least one stop")), Pr;\n                  }, default: function(mr) {\n                    return mr.validateSpec({ key: mr.key, value: mr.value, valueSpec: A3, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec });\n                  } } });\n                  return F3 === "identity" && ze && Lt.push(new cr(R.key, R.value, \'missing required property "property"\')), F3 === "identity" || R.value.stops || Lt.push(new cr(R.key, R.value, \'missing required property "stops"\')), F3 === "exponential" && R.valueSpec.expression && !Rc(R.valueSpec) && Lt.push(new cr(R.key, R.value, "exponential functions not supported")), R.styleSpec.$version >= 8 && (Ke && !Nl(R.valueSpec) ? Lt.push(new cr(R.key, R.value, "property functions not supported")) : ze && !Kc(R.valueSpec) && Lt.push(new cr(R.key, R.value, "zoom functions not supported"))), F3 !== "categorical" && !ct || R.value.property !== void 0 || Lt.push(new cr(R.key, R.value, \'"property" property is required\')), Lt;\n                  function $t(mr) {\n                    let Pr = [], zr = mr.value, ui = mr.key;\n                    if (gs(zr) !== "array") return [new cr(ui, zr, `array expected, ${gs(zr)} found`)];\n                    if (zr.length !== 2) return [new cr(ui, zr, `array length 2 expected, length ${zr.length} found`)];\n                    if (ct) {\n                      if (gs(zr[0]) !== "object") return [new cr(ui, zr, `object expected, ${gs(zr[0])} found`)];\n                      if (zr[0].zoom === void 0) return [new cr(ui, zr, "object stop key must have zoom")];\n                      if (zr[0].value === void 0) return [new cr(ui, zr, "object stop key must have value")];\n                      if (fe && fe > Cs(zr[0].zoom)) return [new cr(ui, zr[0].zoom, "stop zoom values must appear in ascending order")];\n                      Cs(zr[0].zoom) !== fe && (fe = Cs(zr[0].zoom), re = void 0, pe = {}), Pr = Pr.concat(ku({ key: `${ui}[0]`, value: zr[0], valueSpec: { zoom: {} }, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec, objectElementValidators: { zoom: Us, value: fr } }));\n                    } else Pr = Pr.concat(fr({ key: `${ui}[0]`, value: zr[0], valueSpec: {}, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec }, zr));\n                    return Dc(du(zr[1])) ? Pr.concat([new cr(`${ui}[1]`, zr[1], "expressions are not allowed in function stops.")]) : Pr.concat(mr.validateSpec({ key: `${ui}[1]`, value: zr[1], valueSpec: A3, validateSpec: mr.validateSpec, style: mr.style, styleSpec: mr.styleSpec }));\n                  }\n                  function fr(mr, Pr) {\n                    let zr = gs(mr.value), ui = Cs(mr.value), yi = mr.value !== null ? mr.value : Pr;\n                    if (W) {\n                      if (zr !== W) return [new cr(mr.key, yi, `${zr} stop domain type must match previous stop domain type ${W}`)];\n                    } else W = zr;\n                    if (zr !== "number" && zr !== "string" && zr !== "boolean") return [new cr(mr.key, yi, "stop domain value must be a number, string, or boolean")];\n                    if (zr !== "number" && F3 !== "categorical") {\n                      let vn = `number expected, ${zr} found`;\n                      return Nl(A3) && F3 === void 0 && (vn += \'\\nIf you intended to use a categorical function, specify `"type": "categorical"`.\'), [new cr(mr.key, yi, vn)];\n                    }\n                    return F3 !== "categorical" || zr !== "number" || isFinite(ui) && Math.floor(ui) === ui ? F3 !== "categorical" && zr === "number" && re !== void 0 && ui < re ? [new cr(mr.key, yi, "stop domain values must appear in ascending order")] : (re = ui, F3 === "categorical" && ui in pe ? [new cr(mr.key, yi, "stop domain values must be unique")] : (pe[ui] = true, [])) : [new cr(mr.key, yi, `integer expected, found ${ui}`)];\n                  }\n                }\n                function zc(R) {\n                  let A3 = (R.expressionContext === "property" ? _u : ks)(du(R.value), R.valueSpec);\n                  if (A3.result === "error") return A3.value.map((W) => new cr(`${R.key}${W.key}`, R.value, W.message));\n                  let F3 = A3.value.expression || A3.value._styleExpression.expression;\n                  if (R.expressionContext === "property" && R.propertyKey === "text-font" && !F3.outputDefined()) return [new cr(R.key, R.value, `Invalid data expression for "${R.propertyKey}". Output values must be contained as literals within the expression.`)];\n                  if (R.expressionContext === "property" && R.propertyType === "layout" && !ju(F3)) return [new cr(R.key, R.value, \'"feature-state" data expressions are not supported with layout properties.\')];\n                  if (R.expressionContext === "filter" && !ju(F3)) return [new cr(R.key, R.value, \'"feature-state" data expressions are not supported with filters.\')];\n                  if (R.expressionContext && R.expressionContext.indexOf("cluster") === 0) {\n                    if (!Hf(F3, ["zoom", "feature-state"])) return [new cr(R.key, R.value, \'"zoom" and "feature-state" expressions are not supported with cluster properties.\')];\n                    if (R.expressionContext === "cluster-initial" && !th(F3)) return [new cr(R.key, R.value, "Feature data expressions are not supported with initial expression part of cluster properties.")];\n                  }\n                  return [];\n                }\n                function Wu(R) {\n                  let A3 = R.key, F3 = R.value, W = R.valueSpec, re = [];\n                  return Array.isArray(W.values) ? W.values.indexOf(Cs(F3)) === -1 && re.push(new cr(A3, F3, `expected one of [${W.values.join(", ")}], ${JSON.stringify(F3)} found`)) : Object.keys(W.values).indexOf(Cs(F3)) === -1 && re.push(new cr(A3, F3, `expected one of [${Object.keys(W.values).join(", ")}], ${JSON.stringify(F3)} found`)), re;\n                }\n                function Rf(R) {\n                  return Ah(du(R.value)) ? zc($e({}, R, { expressionContext: "filter", valueSpec: { value: "boolean" } })) : Xu(R);\n                }\n                function Xu(R) {\n                  let A3 = R.value, F3 = R.key;\n                  if (gs(A3) !== "array") return [new cr(F3, A3, `array expected, ${gs(A3)} found`)];\n                  let W = R.styleSpec, re, fe = [];\n                  if (A3.length < 1) return [new cr(F3, A3, "filter array must have at least 1 element")];\n                  switch (fe = fe.concat(Wu({ key: `${F3}[0]`, value: A3[0], valueSpec: W.filter_operator, style: R.style, styleSpec: R.styleSpec })), Cs(A3[0])) {\n                    case "<":\n                    case "<=":\n                    case ">":\n                    case ">=":\n                      A3.length >= 2 && Cs(A3[1]) === "$type" && fe.push(new cr(F3, A3, `"$type" cannot be use with operator "${A3[0]}"`));\n                    case "==":\n                    case "!=":\n                      A3.length !== 3 && fe.push(new cr(F3, A3, `filter array for operator "${A3[0]}" must have 3 elements`));\n                    case "in":\n                    case "!in":\n                      A3.length >= 2 && (re = gs(A3[1]), re !== "string" && fe.push(new cr(`${F3}[1]`, A3[1], `string expected, ${re} found`)));\n                      for (let pe = 2; pe < A3.length; pe++) re = gs(A3[pe]), Cs(A3[1]) === "$type" ? fe = fe.concat(Wu({ key: `${F3}[${pe}]`, value: A3[pe], valueSpec: W.geometry_type, style: R.style, styleSpec: R.styleSpec })) : re !== "string" && re !== "number" && re !== "boolean" && fe.push(new cr(`${F3}[${pe}]`, A3[pe], `string, number, or boolean expected, ${re} found`));\n                      break;\n                    case "any":\n                    case "all":\n                    case "none":\n                      for (let pe = 1; pe < A3.length; pe++) fe = fe.concat(Xu({ key: `${F3}[${pe}]`, value: A3[pe], style: R.style, styleSpec: R.styleSpec }));\n                      break;\n                    case "has":\n                    case "!has":\n                      re = gs(A3[1]), A3.length !== 2 ? fe.push(new cr(F3, A3, `filter array for "${A3[0]}" operator must have 2 elements`)) : re !== "string" && fe.push(new cr(`${F3}[1]`, A3[1], `string expected, ${re} found`));\n                  }\n                  return fe;\n                }\n                function uf(R, A3) {\n                  let F3 = R.key, W = R.validateSpec, re = R.style, fe = R.styleSpec, pe = R.value, ze = R.objectKey, Ke = fe[`${A3}_${R.layerType}`];\n                  if (!Ke) return [];\n                  let ct = ze.match(/^(.*)-transition$/);\n                  if (A3 === "paint" && ct && Ke[ct[1]] && Ke[ct[1]].transition) return W({ key: F3, value: pe, valueSpec: fe.transition, style: re, styleSpec: fe });\n                  let Lt = R.valueSpec || Ke[ze];\n                  if (!Lt) return [new cr(F3, pe, `unknown property "${ze}"`)];\n                  let $t;\n                  if (gs(pe) === "string" && Nl(Lt) && !Lt.tokens && ($t = /^{([^}]+)}$/.exec(pe))) return [new cr(F3, pe, `"${ze}" does not support interpolation syntax\nUse an identity property function instead: \\`{ "type": "identity", "property": ${JSON.stringify($t[1])} }\\`.`)];\n                  let fr = [];\n                  return R.layerType === "symbol" && (ze === "text-field" && re && !re.glyphs && fr.push(new cr(F3, pe, \'use of "text-field" requires a style "glyphs" property\')), ze === "text-font" && jf(du(pe)) && Cs(pe.type) === "identity" && fr.push(new cr(F3, pe, \'"text-font" does not support identity functions\'))), fr.concat(W({ key: R.key, value: pe, valueSpec: Lt, style: re, styleSpec: fe, expressionContext: "property", propertyType: A3, propertyKey: ze }));\n                }\n                function Xf(R) {\n                  return uf(R, "paint");\n                }\n                function Wl(R) {\n                  return uf(R, "layout");\n                }\n                function ah(R) {\n                  let A3 = [], F3 = R.value, W = R.key, re = R.style, fe = R.styleSpec;\n                  F3.type || F3.ref || A3.push(new cr(W, F3, \'either "type" or "ref" is required\'));\n                  let pe = Cs(F3.type), ze = Cs(F3.ref);\n                  if (F3.id) {\n                    let Ke = Cs(F3.id);\n                    for (let ct = 0; ct < R.arrayIndex; ct++) {\n                      let Lt = re.layers[ct];\n                      Cs(Lt.id) === Ke && A3.push(new cr(W, F3.id, `duplicate layer id "${F3.id}", previously used at line ${Lt.id.__line__}`));\n                    }\n                  }\n                  if ("ref" in F3) {\n                    let Ke;\n                    ["type", "source", "source-layer", "filter", "layout"].forEach((ct) => {\n                      ct in F3 && A3.push(new cr(W, F3[ct], `"${ct}" is prohibited for ref layers`));\n                    }), re.layers.forEach((ct) => {\n                      Cs(ct.id) === ze && (Ke = ct);\n                    }), Ke ? Ke.ref ? A3.push(new cr(W, F3.ref, "ref cannot reference another ref layer")) : pe = Cs(Ke.type) : A3.push(new cr(W, F3.ref, `ref layer "${ze}" not found`));\n                  } else if (pe !== "background") if (F3.source) {\n                    let Ke = re.sources && re.sources[F3.source], ct = Ke && Cs(Ke.type);\n                    Ke ? ct === "vector" && pe === "raster" ? A3.push(new cr(W, F3.source, `layer "${F3.id}" requires a raster source`)) : ct !== "raster-dem" && pe === "hillshade" ? A3.push(new cr(W, F3.source, `layer "${F3.id}" requires a raster-dem source`)) : ct === "raster" && pe !== "raster" ? A3.push(new cr(W, F3.source, `layer "${F3.id}" requires a vector source`)) : ct !== "vector" || F3["source-layer"] ? ct === "raster-dem" && pe !== "hillshade" ? A3.push(new cr(W, F3.source, "raster-dem source can only be used with layer type \'hillshade\'.")) : pe !== "line" || !F3.paint || !F3.paint["line-gradient"] || ct === "geojson" && Ke.lineMetrics || A3.push(new cr(W, F3, `layer "${F3.id}" specifies a line-gradient, which requires a GeoJSON source with \\`lineMetrics\\` enabled.`)) : A3.push(new cr(W, F3, `layer "${F3.id}" must specify a "source-layer"`)) : A3.push(new cr(W, F3.source, `source "${F3.source}" not found`));\n                  } else A3.push(new cr(W, F3, \'missing required property "source"\'));\n                  return A3 = A3.concat(ku({ key: W, value: F3, valueSpec: fe.layer, style: R.style, styleSpec: R.styleSpec, validateSpec: R.validateSpec, objectElementValidators: { "*": () => [], type: () => R.validateSpec({ key: `${W}.type`, value: F3.type, valueSpec: fe.layer.type, style: R.style, styleSpec: R.styleSpec, validateSpec: R.validateSpec, object: F3, objectKey: "type" }), filter: Rf, layout: (Ke) => ku({ layer: F3, key: Ke.key, value: Ke.value, style: Ke.style, styleSpec: Ke.styleSpec, validateSpec: Ke.validateSpec, objectElementValidators: { "*": (ct) => Wl($e({ layerType: pe }, ct)) } }), paint: (Ke) => ku({ layer: F3, key: Ke.key, value: Ke.value, style: Ke.style, styleSpec: Ke.styleSpec, validateSpec: Ke.validateSpec, objectElementValidators: { "*": (ct) => Xf($e({ layerType: pe }, ct)) } }) } })), A3;\n                }\n                function Zu(R) {\n                  let A3 = R.value, F3 = R.key, W = gs(A3);\n                  return W !== "string" ? [new cr(F3, A3, `string expected, ${W} found`)] : [];\n                }\n                let Oc = { promoteId: function({ key: R, value: A3 }) {\n                  if (gs(A3) === "string") return Zu({ key: R, value: A3 });\n                  {\n                    let F3 = [];\n                    for (let W in A3) F3.push(...Zu({ key: `${R}.${W}`, value: A3[W] }));\n                    return F3;\n                  }\n                } };\n                function Tc(R) {\n                  let A3 = R.value, F3 = R.key, W = R.styleSpec, re = R.style, fe = R.validateSpec;\n                  if (!A3.type) return [new cr(F3, A3, \'"type" is required\')];\n                  let pe = Cs(A3.type), ze;\n                  switch (pe) {\n                    case "vector":\n                    case "raster":\n                      return ze = ku({ key: F3, value: A3, valueSpec: W[`source_${pe.replace("-", "_")}`], style: R.style, styleSpec: W, objectElementValidators: Oc, validateSpec: fe }), ze;\n                    case "raster-dem":\n                      return ze = (function(Ke) {\n                        var ct;\n                        let Lt = (ct = Ke.sourceName) !== null && ct !== void 0 ? ct : "", $t = Ke.value, fr = Ke.styleSpec, mr = fr.source_raster_dem, Pr = Ke.style, zr = [], ui = gs($t);\n                        if ($t === void 0) return zr;\n                        if (ui !== "object") return zr.push(new cr("source_raster_dem", $t, `object expected, ${ui} found`)), zr;\n                        let yi = Cs($t.encoding) === "custom", vn = ["redFactor", "greenFactor", "blueFactor", "baseShift"], zi = Ke.value.encoding ? `"${Ke.value.encoding}"` : "Default";\n                        for (let un in $t) !yi && vn.includes(un) ? zr.push(new cr(un, $t[un], `In "${Lt}": "${un}" is only valid when "encoding" is set to "custom". ${zi} encoding found`)) : mr[un] ? zr = zr.concat(Ke.validateSpec({ key: un, value: $t[un], valueSpec: mr[un], validateSpec: Ke.validateSpec, style: Pr, styleSpec: fr })) : zr.push(new cr(un, $t[un], `unknown property "${un}"`));\n                        return zr;\n                      })({ sourceName: F3, value: A3, style: R.style, styleSpec: W, validateSpec: fe }), ze;\n                    case "geojson":\n                      if (ze = ku({ key: F3, value: A3, valueSpec: W.source_geojson, style: re, styleSpec: W, validateSpec: fe, objectElementValidators: Oc }), A3.cluster) for (let Ke in A3.clusterProperties) {\n                        let [ct, Lt] = A3.clusterProperties[Ke], $t = typeof ct == "string" ? [ct, ["accumulated"], ["get", Ke]] : ct;\n                        ze.push(...zc({ key: `${F3}.${Ke}.map`, value: Lt, validateSpec: fe, expressionContext: "cluster-map" })), ze.push(...zc({ key: `${F3}.${Ke}.reduce`, value: $t, validateSpec: fe, expressionContext: "cluster-reduce" }));\n                      }\n                      return ze;\n                    case "video":\n                      return ku({ key: F3, value: A3, valueSpec: W.source_video, style: re, validateSpec: fe, styleSpec: W });\n                    case "image":\n                      return ku({ key: F3, value: A3, valueSpec: W.source_image, style: re, validateSpec: fe, styleSpec: W });\n                    case "canvas":\n                      return [new cr(F3, null, "Please use runtime APIs to add canvas sources, rather than including them in stylesheets.", "source.canvas")];\n                    default:\n                      return Wu({ key: `${F3}.type`, value: A3.type, valueSpec: { values: ["vector", "raster", "raster-dem", "geojson", "video", "image"] }, style: re, validateSpec: fe, styleSpec: W });\n                  }\n                }\n                function wl(R) {\n                  let A3 = R.value, F3 = R.styleSpec, W = F3.light, re = R.style, fe = [], pe = gs(A3);\n                  if (A3 === void 0) return fe;\n                  if (pe !== "object") return fe = fe.concat([new cr("light", A3, `object expected, ${pe} found`)]), fe;\n                  for (let ze in A3) {\n                    let Ke = ze.match(/^(.*)-transition$/);\n                    fe = fe.concat(Ke && W[Ke[1]] && W[Ke[1]].transition ? R.validateSpec({ key: ze, value: A3[ze], valueSpec: F3.transition, validateSpec: R.validateSpec, style: re, styleSpec: F3 }) : W[ze] ? R.validateSpec({ key: ze, value: A3[ze], valueSpec: W[ze], validateSpec: R.validateSpec, style: re, styleSpec: F3 }) : [new cr(ze, A3[ze], `unknown property "${ze}"`)]);\n                  }\n                  return fe;\n                }\n                function vu(R) {\n                  let A3 = R.value, F3 = R.styleSpec, W = F3.sky, re = R.style, fe = gs(A3);\n                  if (A3 === void 0) return [];\n                  if (fe !== "object") return [new cr("sky", A3, `object expected, ${fe} found`)];\n                  let pe = [];\n                  for (let ze in A3) pe = pe.concat(W[ze] ? R.validateSpec({ key: ze, value: A3[ze], valueSpec: W[ze], style: re, styleSpec: F3 }) : [new cr(ze, A3[ze], `unknown property "${ze}"`)]);\n                  return pe;\n                }\n                function qc(R) {\n                  let A3 = R.value, F3 = R.styleSpec, W = F3.terrain, re = R.style, fe = [], pe = gs(A3);\n                  if (A3 === void 0) return fe;\n                  if (pe !== "object") return fe = fe.concat([new cr("terrain", A3, `object expected, ${pe} found`)]), fe;\n                  for (let ze in A3) fe = fe.concat(W[ze] ? R.validateSpec({ key: ze, value: A3[ze], valueSpec: W[ze], validateSpec: R.validateSpec, style: re, styleSpec: F3 }) : [new cr(ze, A3[ze], `unknown property "${ze}"`)]);\n                  return fe;\n                }\n                function cf(R) {\n                  let A3 = [], F3 = R.value, W = R.key;\n                  if (Array.isArray(F3)) {\n                    let re = [], fe = [];\n                    for (let pe in F3) F3[pe].id && re.includes(F3[pe].id) && A3.push(new cr(W, F3, `all the sprites\' ids must be unique, but ${F3[pe].id} is duplicated`)), re.push(F3[pe].id), F3[pe].url && fe.includes(F3[pe].url) && A3.push(new cr(W, F3, `all the sprites\' URLs must be unique, but ${F3[pe].url} is duplicated`)), fe.push(F3[pe].url), A3 = A3.concat(ku({ key: `${W}[${pe}]`, value: F3[pe], valueSpec: { id: { type: "string", required: true }, url: { type: "string", required: true } }, validateSpec: R.validateSpec }));\n                    return A3;\n                  }\n                  return Zu({ key: W, value: F3 });\n                }\n                let fc = { "*": () => [], array: Wf, boolean: function(R) {\n                  let A3 = R.value, F3 = R.key, W = gs(A3);\n                  return W !== "boolean" ? [new cr(F3, A3, `boolean expected, ${W} found`)] : [];\n                }, number: Us, color: function(R) {\n                  let A3 = R.key, F3 = R.value, W = gs(F3);\n                  return W !== "string" ? [new cr(A3, F3, `color expected, ${W} found`)] : nr.parse(String(F3)) ? [] : [new cr(A3, F3, `color expected, "${F3}" found`)];\n                }, constants: If, enum: Wu, filter: Rf, function: wf, layer: ah, object: ku, source: Tc, light: wl, sky: vu, terrain: qc, projection: function(R) {\n                  let A3 = R.value, F3 = R.styleSpec, W = F3.projection, re = R.style, fe = gs(A3);\n                  if (A3 === void 0) return [];\n                  if (fe !== "object") return [new cr("projection", A3, `object expected, ${fe} found`)];\n                  let pe = [];\n                  for (let ze in A3) pe = pe.concat(W[ze] ? R.validateSpec({ key: ze, value: A3[ze], valueSpec: W[ze], style: re, styleSpec: F3 }) : [new cr(ze, A3[ze], `unknown property "${ze}"`)]);\n                  return pe;\n                }, string: Zu, formatted: function(R) {\n                  return Zu(R).length === 0 ? [] : zc(R);\n                }, resolvedImage: function(R) {\n                  return Zu(R).length === 0 ? [] : zc(R);\n                }, padding: function(R) {\n                  let A3 = R.key, F3 = R.value;\n                  if (gs(F3) === "array") {\n                    if (F3.length < 1 || F3.length > 4) return [new cr(A3, F3, `padding requires 1 to 4 values; ${F3.length} values found`)];\n                    let W = { type: "number" }, re = [];\n                    for (let fe = 0; fe < F3.length; fe++) re = re.concat(R.validateSpec({ key: `${A3}[${fe}]`, value: F3[fe], validateSpec: R.validateSpec, valueSpec: W }));\n                    return re;\n                  }\n                  return Us({ key: A3, value: F3, valueSpec: {} });\n                }, variableAnchorOffsetCollection: function(R) {\n                  let A3 = R.key, F3 = R.value, W = gs(F3), re = R.styleSpec;\n                  if (W !== "array" || F3.length < 1 || F3.length % 2 != 0) return [new cr(A3, F3, "variableAnchorOffsetCollection requires a non-empty array of even length")];\n                  let fe = [];\n                  for (let pe = 0; pe < F3.length; pe += 2) fe = fe.concat(Wu({ key: `${A3}[${pe}]`, value: F3[pe], valueSpec: re.layout_symbol["text-anchor"] })), fe = fe.concat(Wf({ key: `${A3}[${pe + 1}]`, value: F3[pe + 1], valueSpec: { length: 2, value: "number" }, validateSpec: R.validateSpec, style: R.style, styleSpec: re }));\n                  return fe;\n                }, sprite: cf };\n                function Bc(R) {\n                  let A3 = R.value, F3 = R.valueSpec, W = R.styleSpec;\n                  return R.validateSpec = Bc, F3.expression && jf(Cs(A3)) ? wf(R) : F3.expression && Dc(du(A3)) ? zc(R) : F3.type && fc[F3.type] ? fc[F3.type](R) : ku($e({}, R, { valueSpec: F3.type ? W[F3.type] : F3 }));\n                }\n                function At(R) {\n                  let A3 = R.value, F3 = R.key, W = Zu(R);\n                  return W.length || (A3.indexOf("{fontstack}") === -1 && W.push(new cr(F3, A3, \'"glyphs" url must include a "{fontstack}" token\')), A3.indexOf("{range}") === -1 && W.push(new cr(F3, A3, \'"glyphs" url must include a "{range}" token\'))), W;\n                }\n                function Wt(R, A3 = ce) {\n                  let F3 = [];\n                  return F3 = F3.concat(Bc({ key: "", value: R, valueSpec: A3.$root, styleSpec: A3, style: R, validateSpec: Bc, objectElementValidators: { glyphs: At, "*": () => [] } })), R.constants && (F3 = F3.concat(If({ key: "constants", value: R.constants, style: R, styleSpec: A3, validateSpec: Bc }))), Ar(F3);\n                }\n                function Cr(R) {\n                  return function(A3) {\n                    return R(q1(mg({}, A3), { validateSpec: Bc }));\n                  };\n                }\n                function Ar(R) {\n                  return [].concat(R).sort((A3, F3) => A3.line - F3.line);\n                }\n                function Kr(R) {\n                  return function(...A3) {\n                    return Ar(R.apply(this, A3));\n                  };\n                }\n                Wt.source = Kr(Cr(Tc)), Wt.sprite = Kr(Cr(cf)), Wt.glyphs = Kr(Cr(At)), Wt.light = Kr(Cr(wl)), Wt.sky = Kr(Cr(vu)), Wt.terrain = Kr(Cr(qc)), Wt.layer = Kr(Cr(ah)), Wt.filter = Kr(Cr(Rf)), Wt.paintProperty = Kr(Cr(Xf)), Wt.layoutProperty = Kr(Cr(Wl));\n                let ki = Wt, Xi = ki.light, dn = ki.sky, wn = ki.paintProperty, Nn = ki.layoutProperty;\n                function Yi(R, A3) {\n                  let F3 = false;\n                  if (A3 && A3.length) for (let W of A3) R.fire(new ge(new Error(W.message))), F3 = true;\n                  return F3;\n                }\n                class Qi {\n                  constructor(A3, F3, W) {\n                    let re = this.cells = [];\n                    if (A3 instanceof ArrayBuffer) {\n                      this.arrayBuffer = A3;\n                      let pe = new Int32Array(this.arrayBuffer);\n                      A3 = pe[0], this.d = (F3 = pe[1]) + 2 * (W = pe[2]);\n                      for (let Ke = 0; Ke < this.d * this.d; Ke++) {\n                        let ct = pe[3 + Ke], Lt = pe[3 + Ke + 1];\n                        re.push(ct === Lt ? null : pe.subarray(ct, Lt));\n                      }\n                      let ze = pe[3 + re.length + 1];\n                      this.keys = pe.subarray(pe[3 + re.length], ze), this.bboxes = pe.subarray(ze), this.insert = this._insertReadonly;\n                    } else {\n                      this.d = F3 + 2 * W;\n                      for (let pe = 0; pe < this.d * this.d; pe++) re.push([]);\n                      this.keys = [], this.bboxes = [];\n                    }\n                    this.n = F3, this.extent = A3, this.padding = W, this.scale = F3 / A3, this.uid = 0;\n                    let fe = W / F3 * A3;\n                    this.min = -fe, this.max = A3 + fe;\n                  }\n                  insert(A3, F3, W, re, fe) {\n                    this._forEachCell(F3, W, re, fe, this._insertCell, this.uid++, void 0, void 0), this.keys.push(A3), this.bboxes.push(F3), this.bboxes.push(W), this.bboxes.push(re), this.bboxes.push(fe);\n                  }\n                  _insertReadonly() {\n                    throw new Error("Cannot insert into a GridIndex created from an ArrayBuffer.");\n                  }\n                  _insertCell(A3, F3, W, re, fe, pe) {\n                    this.cells[fe].push(pe);\n                  }\n                  query(A3, F3, W, re, fe) {\n                    let pe = this.min, ze = this.max;\n                    if (A3 <= pe && F3 <= pe && ze <= W && ze <= re && !fe) return Array.prototype.slice.call(this.keys);\n                    {\n                      let Ke = [];\n                      return this._forEachCell(A3, F3, W, re, this._queryCell, Ke, {}, fe), Ke;\n                    }\n                  }\n                  _queryCell(A3, F3, W, re, fe, pe, ze, Ke) {\n                    let ct = this.cells[fe];\n                    if (ct !== null) {\n                      let Lt = this.keys, $t = this.bboxes;\n                      for (let fr = 0; fr < ct.length; fr++) {\n                        let mr = ct[fr];\n                        if (ze[mr] === void 0) {\n                          let Pr = 4 * mr;\n                          (Ke ? Ke($t[Pr + 0], $t[Pr + 1], $t[Pr + 2], $t[Pr + 3]) : A3 <= $t[Pr + 2] && F3 <= $t[Pr + 3] && W >= $t[Pr + 0] && re >= $t[Pr + 1]) ? (ze[mr] = true, pe.push(Lt[mr])) : ze[mr] = false;\n                        }\n                      }\n                    }\n                  }\n                  _forEachCell(A3, F3, W, re, fe, pe, ze, Ke) {\n                    let ct = this._convertToCellCoord(A3), Lt = this._convertToCellCoord(F3), $t = this._convertToCellCoord(W), fr = this._convertToCellCoord(re);\n                    for (let mr = ct; mr <= $t; mr++) for (let Pr = Lt; Pr <= fr; Pr++) {\n                      let zr = this.d * Pr + mr;\n                      if ((!Ke || Ke(this._convertFromCellCoord(mr), this._convertFromCellCoord(Pr), this._convertFromCellCoord(mr + 1), this._convertFromCellCoord(Pr + 1))) && fe.call(this, A3, F3, W, re, zr, pe, ze, Ke)) return;\n                    }\n                  }\n                  _convertFromCellCoord(A3) {\n                    return (A3 - this.padding) / this.scale;\n                  }\n                  _convertToCellCoord(A3) {\n                    return Math.max(0, Math.min(this.d - 1, Math.floor(A3 * this.scale) + this.padding));\n                  }\n                  toArrayBuffer() {\n                    if (this.arrayBuffer) return this.arrayBuffer;\n                    let A3 = this.cells, F3 = 3 + this.cells.length + 1 + 1, W = 0;\n                    for (let pe = 0; pe < this.cells.length; pe++) W += this.cells[pe].length;\n                    let re = new Int32Array(F3 + W + this.keys.length + this.bboxes.length);\n                    re[0] = this.extent, re[1] = this.n, re[2] = this.padding;\n                    let fe = F3;\n                    for (let pe = 0; pe < A3.length; pe++) {\n                      let ze = A3[pe];\n                      re[3 + pe] = fe, re.set(ze, fe), fe += ze.length;\n                    }\n                    return re[3 + A3.length] = fe, re.set(this.keys, fe), fe += this.keys.length, re[3 + A3.length + 1] = fe, re.set(this.bboxes, fe), fe += this.bboxes.length, re.buffer;\n                  }\n                  static serialize(A3, F3) {\n                    let W = A3.toArrayBuffer();\n                    return F3 && F3.push(W), { buffer: W };\n                  }\n                  static deserialize(A3) {\n                    return new Qi(A3.buffer);\n                  }\n                }\n                let on = {};\n                function Fi(R, A3, F3 = {}) {\n                  if (on[R]) throw new Error(`${R} is already registered.`);\n                  Object.defineProperty(A3, "_classRegistryKey", { value: R, writeable: false }), on[R] = { klass: A3, omit: F3.omit || [], shallow: F3.shallow || [] };\n                }\n                Fi("Object", Object), Fi("TransferableGridIndex", Qi), Fi("Color", nr), Fi("Error", Error), Fi("AJAXError", me), Fi("ResolvedImage", tn), Fi("StylePropertyFunction", nl), Fi("StyleExpression", Eu, { omit: ["_evaluator"] }), Fi("ZoomDependentExpression", hu), Fi("ZoomConstantExpression", bc), Fi("CompoundExpression", Bl, { omit: ["_evaluate"] });\n                for (let R in yf) yf[R]._classRegistryKey || Fi(`Expression_${R}`, yf[R]);\n                function $n(R) {\n                  return R && typeof ArrayBuffer != "undefined" && (R instanceof ArrayBuffer || R.constructor && R.constructor.name === "ArrayBuffer");\n                }\n                function Ca(R) {\n                  return R.$name || R.constructor._classRegistryKey;\n                }\n                function Ra(R) {\n                  return !(function(A3) {\n                    if (A3 === null || typeof A3 != "object") return false;\n                    let F3 = Ca(A3);\n                    return !(!F3 || F3 === "Object");\n                  })(R) && (R == null || typeof R == "boolean" || typeof R == "number" || typeof R == "string" || R instanceof Boolean || R instanceof Number || R instanceof String || R instanceof Date || R instanceof RegExp || R instanceof Blob || R instanceof Error || $n(R) || G2(R) || ArrayBuffer.isView(R) || R instanceof ImageData);\n                }\n                function La(R, A3) {\n                  if (Ra(R)) return ($n(R) || G2(R)) && A3 && A3.push(R), ArrayBuffer.isView(R) && A3 && A3.push(R.buffer), R instanceof ImageData && A3 && A3.push(R.data.buffer), R;\n                  if (Array.isArray(R)) {\n                    let fe = [];\n                    for (let pe of R) fe.push(La(pe, A3));\n                    return fe;\n                  }\n                  if (typeof R != "object") throw new Error("can\'t serialize object of type " + typeof R);\n                  let F3 = Ca(R);\n                  if (!F3) throw new Error(`can\'t serialize object of unregistered class ${R.constructor.name}`);\n                  if (!on[F3]) throw new Error(`${F3} is not registered.`);\n                  let { klass: W } = on[F3], re = W.serialize ? W.serialize(R, A3) : {};\n                  if (W.serialize) {\n                    if (A3 && re === A3[A3.length - 1]) throw new Error("statically serialized object won\'t survive transfer of $name property");\n                  } else {\n                    for (let fe in R) {\n                      if (!R.hasOwnProperty(fe) || on[F3].omit.indexOf(fe) >= 0) continue;\n                      let pe = R[fe];\n                      re[fe] = on[F3].shallow.indexOf(fe) >= 0 ? pe : La(pe, A3);\n                    }\n                    R instanceof Error && (re.message = R.message);\n                  }\n                  if (re.$name) throw new Error("$name property is reserved for worker serialization logic.");\n                  return F3 !== "Object" && (re.$name = F3), re;\n                }\n                function Na(R) {\n                  if (Ra(R)) return R;\n                  if (Array.isArray(R)) return R.map(Na);\n                  if (typeof R != "object") throw new Error("can\'t deserialize object of type " + typeof R);\n                  let A3 = Ca(R) || "Object";\n                  if (!on[A3]) throw new Error(`can\'t deserialize unregistered class ${A3}`);\n                  let { klass: F3 } = on[A3];\n                  if (!F3) throw new Error(`can\'t deserialize unregistered class ${A3}`);\n                  if (F3.deserialize) return F3.deserialize(R);\n                  let W = Object.create(F3.prototype);\n                  for (let re of Object.keys(R)) {\n                    if (re === "$name") continue;\n                    let fe = R[re];\n                    W[re] = on[A3].shallow.indexOf(re) >= 0 ? fe : Na(fe);\n                  }\n                  return W;\n                }\n                class Yn {\n                  constructor() {\n                    this.first = true;\n                  }\n                  update(A3, F3) {\n                    let W = Math.floor(A3);\n                    return this.first ? (this.first = false, this.lastIntegerZoom = W, this.lastIntegerZoomTime = 0, this.lastZoom = A3, this.lastFloorZoom = W, true) : (this.lastFloorZoom > W ? (this.lastIntegerZoom = W + 1, this.lastIntegerZoomTime = F3) : this.lastFloorZoom < W && (this.lastIntegerZoom = W, this.lastIntegerZoomTime = F3), A3 !== this.lastZoom && (this.lastZoom = A3, this.lastFloorZoom = W, true));\n                  }\n                }\n                let Dn = { "Latin-1 Supplement": (R) => R >= 128 && R <= 255, "Hangul Jamo": (R) => R >= 4352 && R <= 4607, Khmer: (R) => R >= 6016 && R <= 6143, "General Punctuation": (R) => R >= 8192 && R <= 8303, "Letterlike Symbols": (R) => R >= 8448 && R <= 8527, "Number Forms": (R) => R >= 8528 && R <= 8591, "Miscellaneous Technical": (R) => R >= 8960 && R <= 9215, "Control Pictures": (R) => R >= 9216 && R <= 9279, "Optical Character Recognition": (R) => R >= 9280 && R <= 9311, "Enclosed Alphanumerics": (R) => R >= 9312 && R <= 9471, "Geometric Shapes": (R) => R >= 9632 && R <= 9727, "Miscellaneous Symbols": (R) => R >= 9728 && R <= 9983, "Miscellaneous Symbols and Arrows": (R) => R >= 11008 && R <= 11263, "Ideographic Description Characters": (R) => R >= 12272 && R <= 12287, "CJK Symbols and Punctuation": (R) => R >= 12288 && R <= 12351, Katakana: (R) => R >= 12448 && R <= 12543, Kanbun: (R) => R >= 12688 && R <= 12703, "CJK Strokes": (R) => R >= 12736 && R <= 12783, "Enclosed CJK Letters and Months": (R) => R >= 12800 && R <= 13055, "CJK Compatibility": (R) => R >= 13056 && R <= 13311, "Yijing Hexagram Symbols": (R) => R >= 19904 && R <= 19967, "Private Use Area": (R) => R >= 57344 && R <= 63743, "Vertical Forms": (R) => R >= 65040 && R <= 65055, "CJK Compatibility Forms": (R) => R >= 65072 && R <= 65103, "Small Form Variants": (R) => R >= 65104 && R <= 65135, "Halfwidth and Fullwidth Forms": (R) => R >= 65280 && R <= 65519 };\n                function Ka(R) {\n                  for (let A3 of R) if (Ho(A3.charCodeAt(0))) return true;\n                  return false;\n                }\n                function bo(R) {\n                  for (let A3 of R) if (!as(A3.charCodeAt(0))) return false;\n                  return true;\n                }\n                function Xo(R) {\n                  let A3 = R.map((F3) => {\n                    try {\n                      return new RegExp(`\\\\p{sc=${F3}}`, "u").source;\n                    } catch (W) {\n                      return null;\n                    }\n                  }).filter((F3) => F3);\n                  return new RegExp(A3.join("|"), "u");\n                }\n                let Ss = Xo(["Arab", "Dupl", "Mong", "Ougr", "Syrc"]);\n                function as(R) {\n                  return !Ss.test(String.fromCodePoint(R));\n                }\n                let ws = Xo(["Bopo", "Hani", "Hira", "Kana", "Kits", "Nshu", "Tang", "Yiii"]);\n                function Ho(R) {\n                  return !(R !== 746 && R !== 747 && (R < 4352 || !(Dn["CJK Compatibility Forms"](R) && !(R >= 65097 && R <= 65103) || Dn["CJK Compatibility"](R) || Dn["CJK Strokes"](R) || !(!Dn["CJK Symbols and Punctuation"](R) || R >= 12296 && R <= 12305 || R >= 12308 && R <= 12319 || R === 12336) || Dn["Enclosed CJK Letters and Months"](R) || Dn["Ideographic Description Characters"](R) || Dn.Kanbun(R) || Dn.Katakana(R) && R !== 12540 || !(!Dn["Halfwidth and Fullwidth Forms"](R) || R === 65288 || R === 65289 || R === 65293 || R >= 65306 && R <= 65310 || R === 65339 || R === 65341 || R === 65343 || R >= 65371 && R <= 65503 || R === 65507 || R >= 65512 && R <= 65519) || !(!Dn["Small Form Variants"](R) || R >= 65112 && R <= 65118 || R >= 65123 && R <= 65126) || Dn["Vertical Forms"](R) || Dn["Yijing Hexagram Symbols"](R) || new RegExp("\\\\p{sc=Cans}", "u").test(String.fromCodePoint(R)) || new RegExp("\\\\p{sc=Hang}", "u").test(String.fromCodePoint(R)) || ws.test(String.fromCodePoint(R)))));\n                }\n                function ml(R) {\n                  return !(Ho(R) || (function(A3) {\n                    return !!(Dn["Latin-1 Supplement"](A3) && (A3 === 167 || A3 === 169 || A3 === 174 || A3 === 177 || A3 === 188 || A3 === 189 || A3 === 190 || A3 === 215 || A3 === 247) || Dn["General Punctuation"](A3) && (A3 === 8214 || A3 === 8224 || A3 === 8225 || A3 === 8240 || A3 === 8241 || A3 === 8251 || A3 === 8252 || A3 === 8258 || A3 === 8263 || A3 === 8264 || A3 === 8265 || A3 === 8273) || Dn["Letterlike Symbols"](A3) || Dn["Number Forms"](A3) || Dn["Miscellaneous Technical"](A3) && (A3 >= 8960 && A3 <= 8967 || A3 >= 8972 && A3 <= 8991 || A3 >= 8996 && A3 <= 9e3 || A3 === 9003 || A3 >= 9085 && A3 <= 9114 || A3 >= 9150 && A3 <= 9165 || A3 === 9167 || A3 >= 9169 && A3 <= 9179 || A3 >= 9186 && A3 <= 9215) || Dn["Control Pictures"](A3) && A3 !== 9251 || Dn["Optical Character Recognition"](A3) || Dn["Enclosed Alphanumerics"](A3) || Dn["Geometric Shapes"](A3) || Dn["Miscellaneous Symbols"](A3) && !(A3 >= 9754 && A3 <= 9759) || Dn["Miscellaneous Symbols and Arrows"](A3) && (A3 >= 11026 && A3 <= 11055 || A3 >= 11088 && A3 <= 11097 || A3 >= 11192 && A3 <= 11243) || Dn["CJK Symbols and Punctuation"](A3) || Dn.Katakana(A3) || Dn["Private Use Area"](A3) || Dn["CJK Compatibility Forms"](A3) || Dn["Small Form Variants"](A3) || Dn["Halfwidth and Fullwidth Forms"](A3) || A3 === 8734 || A3 === 8756 || A3 === 8757 || A3 >= 9984 && A3 <= 10087 || A3 >= 10102 && A3 <= 10131 || A3 === 65532 || A3 === 65533);\n                  })(R));\n                }\n                let Ws = Xo(["Adlm", "Arab", "Armi", "Avst", "Chrs", "Cprt", "Egyp", "Elym", "Gara", "Hatr", "Hebr", "Hung", "Khar", "Lydi", "Mand", "Mani", "Mend", "Merc", "Mero", "Narb", "Nbat", "Nkoo", "Orkh", "Palm", "Phli", "Phlp", "Phnx", "Prti", "Rohg", "Samr", "Sarb", "Sogo", "Syrc", "Thaa", "Todr", "Yezi"]);\n                function Ls(R) {\n                  return Ws.test(String.fromCodePoint(R));\n                }\n                function va(R, A3) {\n                  return !(!A3 && Ls(R) || R >= 2304 && R <= 3583 || R >= 3840 && R <= 4255 || Dn.Khmer(R));\n                }\n                function no(R) {\n                  for (let A3 of R) if (Ls(A3.charCodeAt(0))) return true;\n                  return false;\n                }\n                let ys = new class {\n                  constructor() {\n                    this.applyArabicShaping = null, this.processBidirectionalText = null, this.processStyledBidirectionalText = null, this.pluginStatus = "unavailable", this.pluginURL = null;\n                  }\n                  setState(R) {\n                    this.pluginStatus = R.pluginStatus, this.pluginURL = R.pluginURL;\n                  }\n                  getState() {\n                    return { pluginStatus: this.pluginStatus, pluginURL: this.pluginURL };\n                  }\n                  setMethods(R) {\n                    this.applyArabicShaping = R.applyArabicShaping, this.processBidirectionalText = R.processBidirectionalText, this.processStyledBidirectionalText = R.processStyledBidirectionalText;\n                  }\n                  isParsed() {\n                    return this.applyArabicShaping != null && this.processBidirectionalText != null && this.processStyledBidirectionalText != null;\n                  }\n                  getPluginURL() {\n                    return this.pluginURL;\n                  }\n                  getRTLTextPluginStatus() {\n                    return this.pluginStatus;\n                  }\n                }();\n                class rs {\n                  constructor(A3, F3) {\n                    this.zoom = A3, F3 ? (this.now = F3.now, this.fadeDuration = F3.fadeDuration, this.zoomHistory = F3.zoomHistory, this.transition = F3.transition) : (this.now = 0, this.fadeDuration = 0, this.zoomHistory = new Yn(), this.transition = {});\n                  }\n                  isSupportedScript(A3) {\n                    return (function(F3, W) {\n                      for (let re of F3) if (!va(re.charCodeAt(0), W)) return false;\n                      return true;\n                    })(A3, ys.getRTLTextPluginStatus() === "loaded");\n                  }\n                  crossFadingFactor() {\n                    return this.fadeDuration === 0 ? 1 : Math.min((this.now - this.zoomHistory.lastIntegerZoomTime) / this.fadeDuration, 1);\n                  }\n                  getCrossfadeParameters() {\n                    let A3 = this.zoom, F3 = A3 - Math.floor(A3), W = this.crossFadingFactor();\n                    return A3 > this.zoomHistory.lastIntegerZoom ? { fromScale: 2, toScale: 1, t: F3 + (1 - F3) * W } : { fromScale: 0.5, toScale: 1, t: 1 - (1 - W) * F3 };\n                  }\n                }\n                class $l {\n                  constructor(A3, F3) {\n                    this.property = A3, this.value = F3, this.expression = (function(W, re) {\n                      if (jf(W)) return new nl(W, re);\n                      if (Dc(W)) {\n                        let fe = _u(W, re);\n                        if (fe.result === "error") throw new Error(fe.value.map((pe) => `${pe.key}: ${pe.message}`).join(", "));\n                        return fe.value;\n                      }\n                      {\n                        let fe = W;\n                        return re.type === "color" && typeof W == "string" ? fe = nr.parse(W) : re.type !== "padding" || typeof W != "number" && !Array.isArray(W) ? re.type === "variableAnchorOffsetCollection" && Array.isArray(W) && (fe = $i.parse(W)) : fe = Qr.parse(W), { kind: "constant", evaluate: () => fe };\n                      }\n                    })(F3 === void 0 ? A3.specification.default : F3, A3.specification);\n                  }\n                  isDataDriven() {\n                    return this.expression.kind === "source" || this.expression.kind === "composite";\n                  }\n                  possiblyEvaluate(A3, F3, W) {\n                    return this.property.possiblyEvaluate(this, A3, F3, W);\n                  }\n                }\n                class Cu {\n                  constructor(A3) {\n                    this.property = A3, this.value = new $l(A3, void 0);\n                  }\n                  transitioned(A3, F3) {\n                    return new Nc(this.property, this.value, F3, L3({}, A3.transition, this.transition), A3.now);\n                  }\n                  untransitioned() {\n                    return new Nc(this.property, this.value, null, {}, 0);\n                  }\n                }\n                class Yu {\n                  constructor(A3) {\n                    this._properties = A3, this._values = Object.create(A3.defaultTransitionablePropertyValues);\n                  }\n                  getValue(A3) {\n                    return g3(this._values[A3].value.value);\n                  }\n                  setValue(A3, F3) {\n                    Object.prototype.hasOwnProperty.call(this._values, A3) || (this._values[A3] = new Cu(this._values[A3].property)), this._values[A3].value = new $l(this._values[A3].property, F3 === null ? void 0 : g3(F3));\n                  }\n                  getTransition(A3) {\n                    return g3(this._values[A3].transition);\n                  }\n                  setTransition(A3, F3) {\n                    Object.prototype.hasOwnProperty.call(this._values, A3) || (this._values[A3] = new Cu(this._values[A3].property)), this._values[A3].transition = g3(F3) || void 0;\n                  }\n                  serialize() {\n                    let A3 = {};\n                    for (let F3 of Object.keys(this._values)) {\n                      let W = this.getValue(F3);\n                      W !== void 0 && (A3[F3] = W);\n                      let re = this.getTransition(F3);\n                      re !== void 0 && (A3[`${F3}-transition`] = re);\n                    }\n                    return A3;\n                  }\n                  transitioned(A3, F3) {\n                    let W = new pu(this._properties);\n                    for (let re of Object.keys(this._values)) W._values[re] = this._values[re].transitioned(A3, F3._values[re]);\n                    return W;\n                  }\n                  untransitioned() {\n                    let A3 = new pu(this._properties);\n                    for (let F3 of Object.keys(this._values)) A3._values[F3] = this._values[F3].untransitioned();\n                    return A3;\n                  }\n                }\n                class Nc {\n                  constructor(A3, F3, W, re, fe) {\n                    this.property = A3, this.value = F3, this.begin = fe + re.delay || 0, this.end = this.begin + re.duration || 0, A3.specification.transition && (re.delay || re.duration) && (this.prior = W);\n                  }\n                  possiblyEvaluate(A3, F3, W) {\n                    let re = A3.now || 0, fe = this.value.possiblyEvaluate(A3, F3, W), pe = this.prior;\n                    if (pe) {\n                      if (re > this.end) return this.prior = null, fe;\n                      if (this.value.isDataDriven()) return this.prior = null, fe;\n                      if (re < this.begin) return pe.possiblyEvaluate(A3, F3, W);\n                      {\n                        let ze = (re - this.begin) / (this.end - this.begin);\n                        return this.property.interpolate(pe.possiblyEvaluate(A3, F3, W), fe, (function(Ke) {\n                          if (Ke <= 0) return 0;\n                          if (Ke >= 1) return 1;\n                          let ct = Ke * Ke, Lt = ct * Ke;\n                          return 4 * (Ke < 0.5 ? Lt : 3 * (Ke - ct) + Lt - 0.75);\n                        })(ze));\n                      }\n                    }\n                    return fe;\n                  }\n                }\n                class pu {\n                  constructor(A3) {\n                    this._properties = A3, this._values = Object.create(A3.defaultTransitioningPropertyValues);\n                  }\n                  possiblyEvaluate(A3, F3, W) {\n                    let re = new Ac(this._properties);\n                    for (let fe of Object.keys(this._values)) re._values[fe] = this._values[fe].possiblyEvaluate(A3, F3, W);\n                    return re;\n                  }\n                  hasTransition() {\n                    for (let A3 of Object.keys(this._values)) if (this._values[A3].prior) return true;\n                    return false;\n                  }\n                }\n                class Uc {\n                  constructor(A3) {\n                    this._properties = A3, this._values = Object.create(A3.defaultPropertyValues);\n                  }\n                  hasValue(A3) {\n                    return this._values[A3].value !== void 0;\n                  }\n                  getValue(A3) {\n                    return g3(this._values[A3].value);\n                  }\n                  setValue(A3, F3) {\n                    this._values[A3] = new $l(this._values[A3].property, F3 === null ? void 0 : g3(F3));\n                  }\n                  serialize() {\n                    let A3 = {};\n                    for (let F3 of Object.keys(this._values)) {\n                      let W = this.getValue(F3);\n                      W !== void 0 && (A3[F3] = W);\n                    }\n                    return A3;\n                  }\n                  possiblyEvaluate(A3, F3, W) {\n                    let re = new Ac(this._properties);\n                    for (let fe of Object.keys(this._values)) re._values[fe] = this._values[fe].possiblyEvaluate(A3, F3, W);\n                    return re;\n                  }\n                }\n                class xu {\n                  constructor(A3, F3, W) {\n                    this.property = A3, this.value = F3, this.parameters = W;\n                  }\n                  isConstant() {\n                    return this.value.kind === "constant";\n                  }\n                  constantOr(A3) {\n                    return this.value.kind === "constant" ? this.value.value : A3;\n                  }\n                  evaluate(A3, F3, W, re) {\n                    return this.property.evaluate(this.value, this.parameters, A3, F3, W, re);\n                  }\n                }\n                class Ac {\n                  constructor(A3) {\n                    this._properties = A3, this._values = Object.create(A3.defaultPossiblyEvaluatedValues);\n                  }\n                  get(A3) {\n                    return this._values[A3];\n                  }\n                }\n                class Ua {\n                  constructor(A3) {\n                    this.specification = A3;\n                  }\n                  possiblyEvaluate(A3, F3) {\n                    if (A3.isDataDriven()) throw new Error("Value should not be data driven");\n                    return A3.expression.evaluate(F3);\n                  }\n                  interpolate(A3, F3, W) {\n                    let re = Lo[this.specification.type];\n                    return re ? re(A3, F3, W) : A3;\n                  }\n                }\n                class oo {\n                  constructor(A3, F3) {\n                    this.specification = A3, this.overrides = F3;\n                  }\n                  possiblyEvaluate(A3, F3, W, re) {\n                    return new xu(this, A3.expression.kind === "constant" || A3.expression.kind === "camera" ? { kind: "constant", value: A3.expression.evaluate(F3, null, {}, W, re) } : A3.expression, F3);\n                  }\n                  interpolate(A3, F3, W) {\n                    if (A3.value.kind !== "constant" || F3.value.kind !== "constant") return A3;\n                    if (A3.value.value === void 0 || F3.value.value === void 0) return new xu(this, { kind: "constant", value: void 0 }, A3.parameters);\n                    let re = Lo[this.specification.type];\n                    if (re) {\n                      let fe = re(A3.value.value, F3.value.value, W);\n                      return new xu(this, { kind: "constant", value: fe }, A3.parameters);\n                    }\n                    return A3;\n                  }\n                  evaluate(A3, F3, W, re, fe, pe) {\n                    return A3.kind === "constant" ? A3.value : A3.evaluate(F3, W, re, fe, pe);\n                  }\n                }\n                class Vc extends oo {\n                  possiblyEvaluate(A3, F3, W, re) {\n                    if (A3.value === void 0) return new xu(this, { kind: "constant", value: void 0 }, F3);\n                    if (A3.expression.kind === "constant") {\n                      let fe = A3.expression.evaluate(F3, null, {}, W, re), pe = A3.property.specification.type === "resolvedImage" && typeof fe != "string" ? fe.name : fe, ze = this._calculate(pe, pe, pe, F3);\n                      return new xu(this, { kind: "constant", value: ze }, F3);\n                    }\n                    if (A3.expression.kind === "camera") {\n                      let fe = this._calculate(A3.expression.evaluate({ zoom: F3.zoom - 1 }), A3.expression.evaluate({ zoom: F3.zoom }), A3.expression.evaluate({ zoom: F3.zoom + 1 }), F3);\n                      return new xu(this, { kind: "constant", value: fe }, F3);\n                    }\n                    return new xu(this, A3.expression, F3);\n                  }\n                  evaluate(A3, F3, W, re, fe, pe) {\n                    if (A3.kind === "source") {\n                      let ze = A3.evaluate(F3, W, re, fe, pe);\n                      return this._calculate(ze, ze, ze, F3);\n                    }\n                    return A3.kind === "composite" ? this._calculate(A3.evaluate({ zoom: Math.floor(F3.zoom) - 1 }, W, re), A3.evaluate({ zoom: Math.floor(F3.zoom) }, W, re), A3.evaluate({ zoom: Math.floor(F3.zoom) + 1 }, W, re), F3) : A3.value;\n                  }\n                  _calculate(A3, F3, W, re) {\n                    return re.zoom > re.zoomHistory.lastIntegerZoom ? { from: A3, to: F3 } : { from: W, to: F3 };\n                  }\n                  interpolate(A3) {\n                    return A3;\n                  }\n                }\n                class hc {\n                  constructor(A3) {\n                    this.specification = A3;\n                  }\n                  possiblyEvaluate(A3, F3, W, re) {\n                    if (A3.value !== void 0) {\n                      if (A3.expression.kind === "constant") {\n                        let fe = A3.expression.evaluate(F3, null, {}, W, re);\n                        return this._calculate(fe, fe, fe, F3);\n                      }\n                      return this._calculate(A3.expression.evaluate(new rs(Math.floor(F3.zoom - 1), F3)), A3.expression.evaluate(new rs(Math.floor(F3.zoom), F3)), A3.expression.evaluate(new rs(Math.floor(F3.zoom + 1), F3)), F3);\n                    }\n                  }\n                  _calculate(A3, F3, W, re) {\n                    return re.zoom > re.zoomHistory.lastIntegerZoom ? { from: A3, to: F3 } : { from: W, to: F3 };\n                  }\n                  interpolate(A3) {\n                    return A3;\n                  }\n                }\n                class Ku {\n                  constructor(A3) {\n                    this.specification = A3;\n                  }\n                  possiblyEvaluate(A3, F3, W, re) {\n                    return !!A3.expression.evaluate(F3, null, {}, W, re);\n                  }\n                  interpolate() {\n                    return false;\n                  }\n                }\n                class ue {\n                  constructor(A3) {\n                    this.properties = A3, this.defaultPropertyValues = {}, this.defaultTransitionablePropertyValues = {}, this.defaultTransitioningPropertyValues = {}, this.defaultPossiblyEvaluatedValues = {}, this.overridableProperties = [];\n                    for (let F3 in A3) {\n                      let W = A3[F3];\n                      W.specification.overridable && this.overridableProperties.push(F3);\n                      let re = this.defaultPropertyValues[F3] = new $l(W, void 0), fe = this.defaultTransitionablePropertyValues[F3] = new Cu(W);\n                      this.defaultTransitioningPropertyValues[F3] = fe.untransitioned(), this.defaultPossiblyEvaluatedValues[F3] = re.possiblyEvaluate({});\n                    }\n                  }\n                }\n                Fi("DataDrivenProperty", oo), Fi("DataConstantProperty", Ua), Fi("CrossFadedDataDrivenProperty", Vc), Fi("CrossFadedProperty", hc), Fi("ColorRampProperty", Ku);\n                let w4 = "-transition";\n                class B4 extends Re {\n                  constructor(A3, F3) {\n                    if (super(), this.id = A3.id, this.type = A3.type, this._featureFilter = { filter: () => true, needGeometry: false }, A3.type !== "custom" && (this.metadata = A3.metadata, this.minzoom = A3.minzoom, this.maxzoom = A3.maxzoom, A3.type !== "background" && (this.source = A3.source, this.sourceLayer = A3["source-layer"], this.filter = A3.filter), F3.layout && (this._unevaluatedLayout = new Uc(F3.layout)), F3.paint)) {\n                      this._transitionablePaint = new Yu(F3.paint);\n                      for (let W in A3.paint) this.setPaintProperty(W, A3.paint[W], { validate: false });\n                      for (let W in A3.layout) this.setLayoutProperty(W, A3.layout[W], { validate: false });\n                      this._transitioningPaint = this._transitionablePaint.untransitioned(), this.paint = new Ac(F3.paint);\n                    }\n                  }\n                  getCrossfadeParameters() {\n                    return this._crossfadeParameters;\n                  }\n                  getLayoutProperty(A3) {\n                    return A3 === "visibility" ? this.visibility : this._unevaluatedLayout.getValue(A3);\n                  }\n                  setLayoutProperty(A3, F3, W = {}) {\n                    F3 != null && this._validate(Nn, `layers.${this.id}.layout.${A3}`, A3, F3, W) || (A3 !== "visibility" ? this._unevaluatedLayout.setValue(A3, F3) : this.visibility = F3);\n                  }\n                  getPaintProperty(A3) {\n                    return A3.endsWith(w4) ? this._transitionablePaint.getTransition(A3.slice(0, -11)) : this._transitionablePaint.getValue(A3);\n                  }\n                  setPaintProperty(A3, F3, W = {}) {\n                    if (F3 != null && this._validate(wn, `layers.${this.id}.paint.${A3}`, A3, F3, W)) return false;\n                    if (A3.endsWith(w4)) return this._transitionablePaint.setTransition(A3.slice(0, -11), F3 || void 0), false;\n                    {\n                      let re = this._transitionablePaint._values[A3], fe = re.property.specification["property-type"] === "cross-faded-data-driven", pe = re.value.isDataDriven(), ze = re.value;\n                      this._transitionablePaint.setValue(A3, F3), this._handleSpecialPaintPropertyUpdate(A3);\n                      let Ke = this._transitionablePaint._values[A3].value;\n                      return Ke.isDataDriven() || pe || fe || this._handleOverridablePaintPropertyUpdate(A3, ze, Ke);\n                    }\n                  }\n                  _handleSpecialPaintPropertyUpdate(A3) {\n                  }\n                  _handleOverridablePaintPropertyUpdate(A3, F3, W) {\n                    return false;\n                  }\n                  isHidden(A3) {\n                    return !!(this.minzoom && A3 < this.minzoom) || !!(this.maxzoom && A3 >= this.maxzoom) || this.visibility === "none";\n                  }\n                  updateTransitions(A3) {\n                    this._transitioningPaint = this._transitionablePaint.transitioned(A3, this._transitioningPaint);\n                  }\n                  hasTransition() {\n                    return this._transitioningPaint.hasTransition();\n                  }\n                  recalculate(A3, F3) {\n                    A3.getCrossfadeParameters && (this._crossfadeParameters = A3.getCrossfadeParameters()), this._unevaluatedLayout && (this.layout = this._unevaluatedLayout.possiblyEvaluate(A3, void 0, F3)), this.paint = this._transitioningPaint.possiblyEvaluate(A3, void 0, F3);\n                  }\n                  serialize() {\n                    let A3 = { id: this.id, type: this.type, source: this.source, "source-layer": this.sourceLayer, metadata: this.metadata, minzoom: this.minzoom, maxzoom: this.maxzoom, filter: this.filter, layout: this._unevaluatedLayout && this._unevaluatedLayout.serialize(), paint: this._transitionablePaint && this._transitionablePaint.serialize() };\n                    return this.visibility && (A3.layout = A3.layout || {}, A3.layout.visibility = this.visibility), M4(A3, (F3, W) => !(F3 === void 0 || W === "layout" && !Object.keys(F3).length || W === "paint" && !Object.keys(F3).length));\n                  }\n                  _validate(A3, F3, W, re, fe = {}) {\n                    return (!fe || fe.validate !== false) && Yi(this, A3.call(ki, { key: F3, layerType: this.type, objectKey: W, value: re, styleSpec: ce, style: { glyphs: true, sprite: true } }));\n                  }\n                  is3D() {\n                    return false;\n                  }\n                  isTileClipped() {\n                    return false;\n                  }\n                  hasOffscreenPass() {\n                    return false;\n                  }\n                  resize() {\n                  }\n                  isStateDependent() {\n                    for (let A3 in this.paint._values) {\n                      let F3 = this.paint.get(A3);\n                      if (F3 instanceof xu && Nl(F3.property.specification) && (F3.value.kind === "source" || F3.value.kind === "composite") && F3.value.isStateDependent) return true;\n                    }\n                    return false;\n                  }\n                }\n                let Q = { Int8: Int8Array, Uint8: Uint8Array, Int16: Int16Array, Uint16: Uint16Array, Int32: Int32Array, Uint32: Uint32Array, Float32: Float32Array };\n                class ee {\n                  constructor(A3, F3) {\n                    this._structArray = A3, this._pos1 = F3 * this.size, this._pos2 = this._pos1 / 2, this._pos4 = this._pos1 / 4, this._pos8 = this._pos1 / 8;\n                  }\n                }\n                class le {\n                  constructor() {\n                    this.isTransferred = false, this.capacity = -1, this.resize(0);\n                  }\n                  static serialize(A3, F3) {\n                    return A3._trim(), F3 && (A3.isTransferred = true, F3.push(A3.arrayBuffer)), { length: A3.length, arrayBuffer: A3.arrayBuffer };\n                  }\n                  static deserialize(A3) {\n                    let F3 = Object.create(this.prototype);\n                    return F3.arrayBuffer = A3.arrayBuffer, F3.length = A3.length, F3.capacity = A3.arrayBuffer.byteLength / F3.bytesPerElement, F3._refreshViews(), F3;\n                  }\n                  _trim() {\n                    this.length !== this.capacity && (this.capacity = this.length, this.arrayBuffer = this.arrayBuffer.slice(0, this.length * this.bytesPerElement), this._refreshViews());\n                  }\n                  clear() {\n                    this.length = 0;\n                  }\n                  resize(A3) {\n                    this.reserve(A3), this.length = A3;\n                  }\n                  reserve(A3) {\n                    if (A3 > this.capacity) {\n                      this.capacity = Math.max(A3, Math.floor(5 * this.capacity), 128), this.arrayBuffer = new ArrayBuffer(this.capacity * this.bytesPerElement);\n                      let F3 = this.uint8;\n                      this._refreshViews(), F3 && this.uint8.set(F3);\n                    }\n                  }\n                  _refreshViews() {\n                    throw new Error("_refreshViews() must be implemented by each concrete StructArray layout");\n                  }\n                }\n                function qe(R, A3 = 1) {\n                  let F3 = 0, W = 0;\n                  return { members: R.map((re) => {\n                    let fe = Q[re.type].BYTES_PER_ELEMENT, pe = F3 = Xe(F3, Math.max(A3, fe)), ze = re.components || 1;\n                    return W = Math.max(W, fe), F3 += fe * ze, { name: re.name, type: re.type, components: ze, offset: pe };\n                  }), size: Xe(F3, Math.max(W, A3)), alignment: A3 };\n                }\n                function Xe(R, A3) {\n                  return Math.ceil(R / A3) * A3;\n                }\n                class ot extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3) {\n                    let W = this.length;\n                    return this.resize(W + 1), this.emplace(W, A3, F3);\n                  }\n                  emplace(A3, F3, W) {\n                    let re = 2 * A3;\n                    return this.int16[re + 0] = F3, this.int16[re + 1] = W, A3;\n                  }\n                }\n                ot.prototype.bytesPerElement = 4, Fi("StructArrayLayout2i4", ot);\n                class Tt extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W) {\n                    let re = this.length;\n                    return this.resize(re + 1), this.emplace(re, A3, F3, W);\n                  }\n                  emplace(A3, F3, W, re) {\n                    let fe = 3 * A3;\n                    return this.int16[fe + 0] = F3, this.int16[fe + 1] = W, this.int16[fe + 2] = re, A3;\n                  }\n                }\n                Tt.prototype.bytesPerElement = 6, Fi("StructArrayLayout3i6", Tt);\n                class Yt extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re) {\n                    let fe = this.length;\n                    return this.resize(fe + 1), this.emplace(fe, A3, F3, W, re);\n                  }\n                  emplace(A3, F3, W, re, fe) {\n                    let pe = 4 * A3;\n                    return this.int16[pe + 0] = F3, this.int16[pe + 1] = W, this.int16[pe + 2] = re, this.int16[pe + 3] = fe, A3;\n                  }\n                }\n                Yt.prototype.bytesPerElement = 8, Fi("StructArrayLayout4i8", Yt);\n                class Kt extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe) {\n                    let ze = this.length;\n                    return this.resize(ze + 1), this.emplace(ze, A3, F3, W, re, fe, pe);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = 6 * A3;\n                    return this.int16[Ke + 0] = F3, this.int16[Ke + 1] = W, this.int16[Ke + 2] = re, this.int16[Ke + 3] = fe, this.int16[Ke + 4] = pe, this.int16[Ke + 5] = ze, A3;\n                  }\n                }\n                Kt.prototype.bytesPerElement = 12, Fi("StructArrayLayout2i4i12", Kt);\n                class xr extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe) {\n                    let ze = this.length;\n                    return this.resize(ze + 1), this.emplace(ze, A3, F3, W, re, fe, pe);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = 4 * A3, ct = 8 * A3;\n                    return this.int16[Ke + 0] = F3, this.int16[Ke + 1] = W, this.uint8[ct + 4] = re, this.uint8[ct + 5] = fe, this.uint8[ct + 6] = pe, this.uint8[ct + 7] = ze, A3;\n                  }\n                }\n                xr.prototype.bytesPerElement = 8, Fi("StructArrayLayout2i4ub8", xr);\n                class Ir extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3) {\n                    let W = this.length;\n                    return this.resize(W + 1), this.emplace(W, A3, F3);\n                  }\n                  emplace(A3, F3, W) {\n                    let re = 2 * A3;\n                    return this.float32[re + 0] = F3, this.float32[re + 1] = W, A3;\n                  }\n                }\n                Ir.prototype.bytesPerElement = 8, Fi("StructArrayLayout2f8", Ir);\n                class ve extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt) {\n                    let $t = this.length;\n                    return this.resize($t + 1), this.emplace($t, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t) {\n                    let fr = 10 * A3;\n                    return this.uint16[fr + 0] = F3, this.uint16[fr + 1] = W, this.uint16[fr + 2] = re, this.uint16[fr + 3] = fe, this.uint16[fr + 4] = pe, this.uint16[fr + 5] = ze, this.uint16[fr + 6] = Ke, this.uint16[fr + 7] = ct, this.uint16[fr + 8] = Lt, this.uint16[fr + 9] = $t, A3;\n                  }\n                }\n                ve.prototype.bytesPerElement = 20, Fi("StructArrayLayout10ui20", ve);\n                class be extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr) {\n                    let mr = this.length;\n                    return this.resize(mr + 1), this.emplace(mr, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr) {\n                    let Pr = 12 * A3;\n                    return this.int16[Pr + 0] = F3, this.int16[Pr + 1] = W, this.int16[Pr + 2] = re, this.int16[Pr + 3] = fe, this.uint16[Pr + 4] = pe, this.uint16[Pr + 5] = ze, this.uint16[Pr + 6] = Ke, this.uint16[Pr + 7] = ct, this.int16[Pr + 8] = Lt, this.int16[Pr + 9] = $t, this.int16[Pr + 10] = fr, this.int16[Pr + 11] = mr, A3;\n                  }\n                }\n                be.prototype.bytesPerElement = 24, Fi("StructArrayLayout4i4ui4i24", be);\n                class De extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W) {\n                    let re = this.length;\n                    return this.resize(re + 1), this.emplace(re, A3, F3, W);\n                  }\n                  emplace(A3, F3, W, re) {\n                    let fe = 3 * A3;\n                    return this.float32[fe + 0] = F3, this.float32[fe + 1] = W, this.float32[fe + 2] = re, A3;\n                  }\n                }\n                De.prototype.bytesPerElement = 12, Fi("StructArrayLayout3f12", De);\n                class Be extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3) {\n                    let F3 = this.length;\n                    return this.resize(F3 + 1), this.emplace(F3, A3);\n                  }\n                  emplace(A3, F3) {\n                    return this.uint32[1 * A3 + 0] = F3, A3;\n                  }\n                }\n                Be.prototype.bytesPerElement = 4, Fi("StructArrayLayout1ul4", Be);\n                class et extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe, ze, Ke, ct) {\n                    let Lt = this.length;\n                    return this.resize(Lt + 1), this.emplace(Lt, A3, F3, W, re, fe, pe, ze, Ke, ct);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt) {\n                    let $t = 10 * A3, fr = 5 * A3;\n                    return this.int16[$t + 0] = F3, this.int16[$t + 1] = W, this.int16[$t + 2] = re, this.int16[$t + 3] = fe, this.int16[$t + 4] = pe, this.int16[$t + 5] = ze, this.uint32[fr + 3] = Ke, this.uint16[$t + 8] = ct, this.uint16[$t + 9] = Lt, A3;\n                  }\n                }\n                et.prototype.bytesPerElement = 20, Fi("StructArrayLayout6i1ul2ui20", et);\n                class We extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe) {\n                    let ze = this.length;\n                    return this.resize(ze + 1), this.emplace(ze, A3, F3, W, re, fe, pe);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = 6 * A3;\n                    return this.int16[Ke + 0] = F3, this.int16[Ke + 1] = W, this.int16[Ke + 2] = re, this.int16[Ke + 3] = fe, this.int16[Ke + 4] = pe, this.int16[Ke + 5] = ze, A3;\n                  }\n                }\n                We.prototype.bytesPerElement = 12, Fi("StructArrayLayout2i2i2i12", We);\n                class it extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe) {\n                    let pe = this.length;\n                    return this.resize(pe + 1), this.emplace(pe, A3, F3, W, re, fe);\n                  }\n                  emplace(A3, F3, W, re, fe, pe) {\n                    let ze = 4 * A3, Ke = 8 * A3;\n                    return this.float32[ze + 0] = F3, this.float32[ze + 1] = W, this.float32[ze + 2] = re, this.int16[Ke + 6] = fe, this.int16[Ke + 7] = pe, A3;\n                  }\n                }\n                it.prototype.bytesPerElement = 16, Fi("StructArrayLayout2f1f2i16", it);\n                class Ft extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe) {\n                    let ze = this.length;\n                    return this.resize(ze + 1), this.emplace(ze, A3, F3, W, re, fe, pe);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = 16 * A3, ct = 4 * A3, Lt = 8 * A3;\n                    return this.uint8[Ke + 0] = F3, this.uint8[Ke + 1] = W, this.float32[ct + 1] = re, this.float32[ct + 2] = fe, this.int16[Lt + 6] = pe, this.int16[Lt + 7] = ze, A3;\n                  }\n                }\n                Ft.prototype.bytesPerElement = 16, Fi("StructArrayLayout2ub2f2i16", Ft);\n                class Ht extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W) {\n                    let re = this.length;\n                    return this.resize(re + 1), this.emplace(re, A3, F3, W);\n                  }\n                  emplace(A3, F3, W, re) {\n                    let fe = 3 * A3;\n                    return this.uint16[fe + 0] = F3, this.uint16[fe + 1] = W, this.uint16[fe + 2] = re, A3;\n                  }\n                }\n                Ht.prototype.bytesPerElement = 6, Fi("StructArrayLayout3ui6", Ht);\n                class tr extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi) {\n                    let vn = this.length;\n                    return this.resize(vn + 1), this.emplace(vn, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi, vn) {\n                    let zi = 24 * A3, un = 12 * A3, Tn = 48 * A3;\n                    return this.int16[zi + 0] = F3, this.int16[zi + 1] = W, this.uint16[zi + 2] = re, this.uint16[zi + 3] = fe, this.uint32[un + 2] = pe, this.uint32[un + 3] = ze, this.uint32[un + 4] = Ke, this.uint16[zi + 10] = ct, this.uint16[zi + 11] = Lt, this.uint16[zi + 12] = $t, this.float32[un + 7] = fr, this.float32[un + 8] = mr, this.uint8[Tn + 36] = Pr, this.uint8[Tn + 37] = zr, this.uint8[Tn + 38] = ui, this.uint32[un + 10] = yi, this.int16[zi + 22] = vn, A3;\n                  }\n                }\n                tr.prototype.bytesPerElement = 48, Fi("StructArrayLayout2i2ui3ul3ui2f3ub1ul1i48", tr);\n                class dr extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.int16 = new Int16Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo) {\n                    let lo = this.length;\n                    return this.resize(lo + 1), this.emplace(lo, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo);\n                  }\n                  emplace(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr, ui, yi, vn, zi, un, Tn, pa, ro, Vo, Xa, sa, Mo, fo, lo) {\n                    let Xn = 32 * A3, Ro = 16 * A3;\n                    return this.int16[Xn + 0] = F3, this.int16[Xn + 1] = W, this.int16[Xn + 2] = re, this.int16[Xn + 3] = fe, this.int16[Xn + 4] = pe, this.int16[Xn + 5] = ze, this.int16[Xn + 6] = Ke, this.int16[Xn + 7] = ct, this.uint16[Xn + 8] = Lt, this.uint16[Xn + 9] = $t, this.uint16[Xn + 10] = fr, this.uint16[Xn + 11] = mr, this.uint16[Xn + 12] = Pr, this.uint16[Xn + 13] = zr, this.uint16[Xn + 14] = ui, this.uint16[Xn + 15] = yi, this.uint16[Xn + 16] = vn, this.uint16[Xn + 17] = zi, this.uint16[Xn + 18] = un, this.uint16[Xn + 19] = Tn, this.uint16[Xn + 20] = pa, this.uint16[Xn + 21] = ro, this.uint16[Xn + 22] = Vo, this.uint32[Ro + 12] = Xa, this.float32[Ro + 13] = sa, this.float32[Ro + 14] = Mo, this.uint16[Xn + 30] = fo, this.uint16[Xn + 31] = lo, A3;\n                  }\n                }\n                dr.prototype.bytesPerElement = 64, Fi("StructArrayLayout8i15ui1ul2f2ui64", dr);\n                class Sr extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3) {\n                    let F3 = this.length;\n                    return this.resize(F3 + 1), this.emplace(F3, A3);\n                  }\n                  emplace(A3, F3) {\n                    return this.float32[1 * A3 + 0] = F3, A3;\n                  }\n                }\n                Sr.prototype.bytesPerElement = 4, Fi("StructArrayLayout1f4", Sr);\n                class Or extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W) {\n                    let re = this.length;\n                    return this.resize(re + 1), this.emplace(re, A3, F3, W);\n                  }\n                  emplace(A3, F3, W, re) {\n                    let fe = 3 * A3;\n                    return this.uint16[6 * A3 + 0] = F3, this.float32[fe + 1] = W, this.float32[fe + 2] = re, A3;\n                  }\n                }\n                Or.prototype.bytesPerElement = 12, Fi("StructArrayLayout1ui2f12", Or);\n                class Wr extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint32 = new Uint32Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W) {\n                    let re = this.length;\n                    return this.resize(re + 1), this.emplace(re, A3, F3, W);\n                  }\n                  emplace(A3, F3, W, re) {\n                    let fe = 4 * A3;\n                    return this.uint32[2 * A3 + 0] = F3, this.uint16[fe + 2] = W, this.uint16[fe + 3] = re, A3;\n                  }\n                }\n                Wr.prototype.bytesPerElement = 8, Fi("StructArrayLayout1ul2ui8", Wr);\n                class ni extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3) {\n                    let W = this.length;\n                    return this.resize(W + 1), this.emplace(W, A3, F3);\n                  }\n                  emplace(A3, F3, W) {\n                    let re = 2 * A3;\n                    return this.uint16[re + 0] = F3, this.uint16[re + 1] = W, A3;\n                  }\n                }\n                ni.prototype.bytesPerElement = 4, Fi("StructArrayLayout2ui4", ni);\n                class Pi extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.uint16 = new Uint16Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3) {\n                    let F3 = this.length;\n                    return this.resize(F3 + 1), this.emplace(F3, A3);\n                  }\n                  emplace(A3, F3) {\n                    return this.uint16[1 * A3 + 0] = F3, A3;\n                  }\n                }\n                Pi.prototype.bytesPerElement = 2, Fi("StructArrayLayout1ui2", Pi);\n                class cn extends le {\n                  _refreshViews() {\n                    this.uint8 = new Uint8Array(this.arrayBuffer), this.float32 = new Float32Array(this.arrayBuffer);\n                  }\n                  emplaceBack(A3, F3, W, re) {\n                    let fe = this.length;\n                    return this.resize(fe + 1), this.emplace(fe, A3, F3, W, re);\n                  }\n                  emplace(A3, F3, W, re, fe) {\n                    let pe = 4 * A3;\n                    return this.float32[pe + 0] = F3, this.float32[pe + 1] = W, this.float32[pe + 2] = re, this.float32[pe + 3] = fe, A3;\n                  }\n                }\n                cn.prototype.bytesPerElement = 16, Fi("StructArrayLayout4f16", cn);\n                class ln extends ee {\n                  get anchorPointX() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }\n                  get anchorPointY() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }\n                  get x1() {\n                    return this._structArray.int16[this._pos2 + 2];\n                  }\n                  get y1() {\n                    return this._structArray.int16[this._pos2 + 3];\n                  }\n                  get x2() {\n                    return this._structArray.int16[this._pos2 + 4];\n                  }\n                  get y2() {\n                    return this._structArray.int16[this._pos2 + 5];\n                  }\n                  get featureIndex() {\n                    return this._structArray.uint32[this._pos4 + 3];\n                  }\n                  get sourceLayerIndex() {\n                    return this._structArray.uint16[this._pos2 + 8];\n                  }\n                  get bucketIndex() {\n                    return this._structArray.uint16[this._pos2 + 9];\n                  }\n                  get anchorPoint() {\n                    return new u4(this.anchorPointX, this.anchorPointY);\n                  }\n                }\n                ln.prototype.size = 20;\n                class Cn extends et {\n                  get(A3) {\n                    return new ln(this, A3);\n                  }\n                }\n                Fi("CollisionBoxArray", Cn);\n                class Kn extends ee {\n                  get anchorX() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }\n                  get anchorY() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }\n                  get glyphStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 2];\n                  }\n                  get numGlyphs() {\n                    return this._structArray.uint16[this._pos2 + 3];\n                  }\n                  get vertexStartIndex() {\n                    return this._structArray.uint32[this._pos4 + 2];\n                  }\n                  get lineStartIndex() {\n                    return this._structArray.uint32[this._pos4 + 3];\n                  }\n                  get lineLength() {\n                    return this._structArray.uint32[this._pos4 + 4];\n                  }\n                  get segment() {\n                    return this._structArray.uint16[this._pos2 + 10];\n                  }\n                  get lowerSize() {\n                    return this._structArray.uint16[this._pos2 + 11];\n                  }\n                  get upperSize() {\n                    return this._structArray.uint16[this._pos2 + 12];\n                  }\n                  get lineOffsetX() {\n                    return this._structArray.float32[this._pos4 + 7];\n                  }\n                  get lineOffsetY() {\n                    return this._structArray.float32[this._pos4 + 8];\n                  }\n                  get writingMode() {\n                    return this._structArray.uint8[this._pos1 + 36];\n                  }\n                  get placedOrientation() {\n                    return this._structArray.uint8[this._pos1 + 37];\n                  }\n                  set placedOrientation(A3) {\n                    this._structArray.uint8[this._pos1 + 37] = A3;\n                  }\n                  get hidden() {\n                    return this._structArray.uint8[this._pos1 + 38];\n                  }\n                  set hidden(A3) {\n                    this._structArray.uint8[this._pos1 + 38] = A3;\n                  }\n                  get crossTileID() {\n                    return this._structArray.uint32[this._pos4 + 10];\n                  }\n                  set crossTileID(A3) {\n                    this._structArray.uint32[this._pos4 + 10] = A3;\n                  }\n                  get associatedIconIndex() {\n                    return this._structArray.int16[this._pos2 + 22];\n                  }\n                }\n                Kn.prototype.size = 48;\n                class Ta extends tr {\n                  get(A3) {\n                    return new Kn(this, A3);\n                  }\n                }\n                Fi("PlacedSymbolArray", Ta);\n                class fa extends ee {\n                  get anchorX() {\n                    return this._structArray.int16[this._pos2 + 0];\n                  }\n                  get anchorY() {\n                    return this._structArray.int16[this._pos2 + 1];\n                  }\n                  get rightJustifiedTextSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 2];\n                  }\n                  get centerJustifiedTextSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 3];\n                  }\n                  get leftJustifiedTextSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 4];\n                  }\n                  get verticalPlacedTextSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 5];\n                  }\n                  get placedIconSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 6];\n                  }\n                  get verticalPlacedIconSymbolIndex() {\n                    return this._structArray.int16[this._pos2 + 7];\n                  }\n                  get key() {\n                    return this._structArray.uint16[this._pos2 + 8];\n                  }\n                  get textBoxStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 9];\n                  }\n                  get textBoxEndIndex() {\n                    return this._structArray.uint16[this._pos2 + 10];\n                  }\n                  get verticalTextBoxStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 11];\n                  }\n                  get verticalTextBoxEndIndex() {\n                    return this._structArray.uint16[this._pos2 + 12];\n                  }\n                  get iconBoxStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 13];\n                  }\n                  get iconBoxEndIndex() {\n                    return this._structArray.uint16[this._pos2 + 14];\n                  }\n                  get verticalIconBoxStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 15];\n                  }\n                  get verticalIconBoxEndIndex() {\n                    return this._structArray.uint16[this._pos2 + 16];\n                  }\n                  get featureIndex() {\n                    return this._structArray.uint16[this._pos2 + 17];\n                  }\n                  get numHorizontalGlyphVertices() {\n                    return this._structArray.uint16[this._pos2 + 18];\n                  }\n                  get numVerticalGlyphVertices() {\n                    return this._structArray.uint16[this._pos2 + 19];\n                  }\n                  get numIconVertices() {\n                    return this._structArray.uint16[this._pos2 + 20];\n                  }\n                  get numVerticalIconVertices() {\n                    return this._structArray.uint16[this._pos2 + 21];\n                  }\n                  get useRuntimeCollisionCircles() {\n                    return this._structArray.uint16[this._pos2 + 22];\n                  }\n                  get crossTileID() {\n                    return this._structArray.uint32[this._pos4 + 12];\n                  }\n                  set crossTileID(A3) {\n                    this._structArray.uint32[this._pos4 + 12] = A3;\n                  }\n                  get textBoxScale() {\n                    return this._structArray.float32[this._pos4 + 13];\n                  }\n                  get collisionCircleDiameter() {\n                    return this._structArray.float32[this._pos4 + 14];\n                  }\n                  get textAnchorOffsetStartIndex() {\n                    return this._structArray.uint16[this._pos2 + 30];\n                  }\n                  get textAnchorOffsetEndIndex() {\n                    return this._structArray.uint16[this._pos2 + 31];\n                  }\n                }\n                fa.prototype.size = 64;\n                class $a extends dr {\n                  get(A3) {\n                    return new fa(this, A3);\n                  }\n                }\n                Fi("SymbolInstanceArray", $a);\n                class Co extends Sr {\n                  getoffsetX(A3) {\n                    return this.float32[1 * A3 + 0];\n                  }\n                }\n                Fi("GlyphOffsetArray", Co);\n                class Qa extends Tt {\n                  getx(A3) {\n                    return this.int16[3 * A3 + 0];\n                  }\n                  gety(A3) {\n                    return this.int16[3 * A3 + 1];\n                  }\n                  gettileUnitDistanceFromAnchor(A3) {\n                    return this.int16[3 * A3 + 2];\n                  }\n                }\n                Fi("SymbolLineVertexArray", Qa);\n                class mo extends ee {\n                  get textAnchor() {\n                    return this._structArray.uint16[this._pos2 + 0];\n                  }\n                  get textOffset0() {\n                    return this._structArray.float32[this._pos4 + 1];\n                  }\n                  get textOffset1() {\n                    return this._structArray.float32[this._pos4 + 2];\n                  }\n                }\n                mo.prototype.size = 12;\n                class Bo extends Or {\n                  get(A3) {\n                    return new mo(this, A3);\n                  }\n                }\n                Fi("TextAnchorOffsetArray", Bo);\n                class Ps extends ee {\n                  get featureIndex() {\n                    return this._structArray.uint32[this._pos4 + 0];\n                  }\n                  get sourceLayerIndex() {\n                    return this._structArray.uint16[this._pos2 + 2];\n                  }\n                  get bucketIndex() {\n                    return this._structArray.uint16[this._pos2 + 3];\n                  }\n                }\n                Ps.prototype.size = 8;\n                class Ts extends Wr {\n                  get(A3) {\n                    return new Ps(this, A3);\n                  }\n                }\n                Fi("FeatureIndexArray", Ts);\n                class wo extends ot {\n                }\n                class To extends ot {\n                }\n                class hl extends ot {\n                }\n                class Ul extends Kt {\n                }\n                class Lu extends xr {\n                }\n                class au extends Ir {\n                }\n                class Js extends ve {\n                }\n                class Ql extends be {\n                }\n                class dc extends De {\n                }\n                class Tl extends Be {\n                }\n                class Al extends We {\n                }\n                class X extends Ft {\n                }\n                class se extends Ht {\n                }\n                class Te extends ni {\n                }\n                let Ne = qe([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: He } = Ne;\n                class Ye {\n                  constructor(A3 = []) {\n                    this.segments = A3;\n                  }\n                  prepareSegment(A3, F3, W, re) {\n                    let fe = this.segments[this.segments.length - 1];\n                    return A3 > Ye.MAX_VERTEX_ARRAY_LENGTH && T3(`Max vertices per segment is ${Ye.MAX_VERTEX_ARRAY_LENGTH}: bucket requested ${A3}`), (!fe || fe.vertexLength + A3 > Ye.MAX_VERTEX_ARRAY_LENGTH || fe.sortKey !== re) && (fe = { vertexOffset: F3.length, primitiveOffset: W.length, vertexLength: 0, primitiveLength: 0 }, re !== void 0 && (fe.sortKey = re), this.segments.push(fe)), fe;\n                  }\n                  get() {\n                    return this.segments;\n                  }\n                  destroy() {\n                    for (let A3 of this.segments) for (let F3 in A3.vaos) A3.vaos[F3].destroy();\n                  }\n                  static simpleSegment(A3, F3, W, re) {\n                    return new Ye([{ vertexOffset: A3, primitiveOffset: F3, vertexLength: W, primitiveLength: re, vaos: {}, sortKey: 0 }]);\n                  }\n                }\n                function kt(R, A3) {\n                  return 256 * (R = E3(Math.floor(R), 0, 255)) + E3(Math.floor(A3), 0, 255);\n                }\n                Ye.MAX_VERTEX_ARRAY_LENGTH = Math.pow(2, 16) - 1, Fi("SegmentVector", Ye);\n                let nt = qe([{ name: "a_pattern_from", components: 4, type: "Uint16" }, { name: "a_pattern_to", components: 4, type: "Uint16" }, { name: "a_pixel_ratio_from", components: 1, type: "Uint16" }, { name: "a_pixel_ratio_to", components: 1, type: "Uint16" }]);\n                var jt = { exports: {} }, gr = { exports: {} };\n                gr.exports = function(R, A3) {\n                  var F3, W, re, fe, pe, ze, Ke, ct;\n                  for (W = R.length - (F3 = 3 & R.length), re = A3, pe = 3432918353, ze = 461845907, ct = 0; ct < W; ) Ke = 255 & R.charCodeAt(ct) | (255 & R.charCodeAt(++ct)) << 8 | (255 & R.charCodeAt(++ct)) << 16 | (255 & R.charCodeAt(++ct)) << 24, ++ct, re = 27492 + (65535 & (fe = 5 * (65535 & (re = (re ^= Ke = (65535 & (Ke = (Ke = (65535 & Ke) * pe + (((Ke >>> 16) * pe & 65535) << 16) & 4294967295) << 15 | Ke >>> 17)) * ze + (((Ke >>> 16) * ze & 65535) << 16) & 4294967295) << 13 | re >>> 19)) + ((5 * (re >>> 16) & 65535) << 16) & 4294967295)) + ((58964 + (fe >>> 16) & 65535) << 16);\n                  switch (Ke = 0, F3) {\n                    case 3:\n                      Ke ^= (255 & R.charCodeAt(ct + 2)) << 16;\n                    case 2:\n                      Ke ^= (255 & R.charCodeAt(ct + 1)) << 8;\n                    case 1:\n                      re ^= Ke = (65535 & (Ke = (Ke = (65535 & (Ke ^= 255 & R.charCodeAt(ct))) * pe + (((Ke >>> 16) * pe & 65535) << 16) & 4294967295) << 15 | Ke >>> 17)) * ze + (((Ke >>> 16) * ze & 65535) << 16) & 4294967295;\n                  }\n                  return re ^= R.length, re = 2246822507 * (65535 & (re ^= re >>> 16)) + ((2246822507 * (re >>> 16) & 65535) << 16) & 4294967295, re = 3266489909 * (65535 & (re ^= re >>> 13)) + ((3266489909 * (re >>> 16) & 65535) << 16) & 4294967295, (re ^= re >>> 16) >>> 0;\n                };\n                var yr = gr.exports, Hr = { exports: {} };\n                Hr.exports = function(R, A3) {\n                  for (var F3, W = R.length, re = A3 ^ W, fe = 0; W >= 4; ) F3 = 1540483477 * (65535 & (F3 = 255 & R.charCodeAt(fe) | (255 & R.charCodeAt(++fe)) << 8 | (255 & R.charCodeAt(++fe)) << 16 | (255 & R.charCodeAt(++fe)) << 24)) + ((1540483477 * (F3 >>> 16) & 65535) << 16), re = 1540483477 * (65535 & re) + ((1540483477 * (re >>> 16) & 65535) << 16) ^ (F3 = 1540483477 * (65535 & (F3 ^= F3 >>> 24)) + ((1540483477 * (F3 >>> 16) & 65535) << 16)), W -= 4, ++fe;\n                  switch (W) {\n                    case 3:\n                      re ^= (255 & R.charCodeAt(fe + 2)) << 16;\n                    case 2:\n                      re ^= (255 & R.charCodeAt(fe + 1)) << 8;\n                    case 1:\n                      re = 1540483477 * (65535 & (re ^= 255 & R.charCodeAt(fe))) + ((1540483477 * (re >>> 16) & 65535) << 16);\n                  }\n                  return re = 1540483477 * (65535 & (re ^= re >>> 13)) + ((1540483477 * (re >>> 16) & 65535) << 16), (re ^= re >>> 15) >>> 0;\n                };\n                var qr = yr, _i = Hr.exports;\n                jt.exports = qr, jt.exports.murmur3 = qr, jt.exports.murmur2 = _i;\n                var bi = o4(jt.exports);\n                class Zr {\n                  constructor() {\n                    this.ids = [], this.positions = [], this.indexed = false;\n                  }\n                  add(A3, F3, W, re) {\n                    this.ids.push(ai(A3)), this.positions.push(F3, W, re);\n                  }\n                  getPositions(A3) {\n                    if (!this.indexed) throw new Error("Trying to get index, but feature positions are not indexed");\n                    let F3 = ai(A3), W = 0, re = this.ids.length - 1;\n                    for (; W < re; ) {\n                      let pe = W + re >> 1;\n                      this.ids[pe] >= F3 ? re = pe : W = pe + 1;\n                    }\n                    let fe = [];\n                    for (; this.ids[W] === F3; ) fe.push({ index: this.positions[3 * W], start: this.positions[3 * W + 1], end: this.positions[3 * W + 2] }), W++;\n                    return fe;\n                  }\n                  static serialize(A3, F3) {\n                    let W = new Float64Array(A3.ids), re = new Uint32Array(A3.positions);\n                    return gi(W, re, 0, W.length - 1), F3 && F3.push(W.buffer, re.buffer), { ids: W, positions: re };\n                  }\n                  static deserialize(A3) {\n                    let F3 = new Zr();\n                    return F3.ids = A3.ids, F3.positions = A3.positions, F3.indexed = true, F3;\n                  }\n                }\n                function ai(R) {\n                  let A3 = +R;\n                  return !isNaN(A3) && A3 <= Number.MAX_SAFE_INTEGER ? A3 : bi(String(R));\n                }\n                function gi(R, A3, F3, W) {\n                  for (; F3 < W; ) {\n                    let re = R[F3 + W >> 1], fe = F3 - 1, pe = W + 1;\n                    for (; ; ) {\n                      do\n                        fe++;\n                      while (R[fe] < re);\n                      do\n                        pe--;\n                      while (R[pe] > re);\n                      if (fe >= pe) break;\n                      Ii(R, fe, pe), Ii(A3, 3 * fe, 3 * pe), Ii(A3, 3 * fe + 1, 3 * pe + 1), Ii(A3, 3 * fe + 2, 3 * pe + 2);\n                    }\n                    pe - F3 < W - pe ? (gi(R, A3, F3, pe), F3 = pe + 1) : (gi(R, A3, pe + 1, W), W = pe);\n                  }\n                }\n                function Ii(R, A3, F3) {\n                  let W = R[A3];\n                  R[A3] = R[F3], R[F3] = W;\n                }\n                Fi("FeaturePositionMap", Zr);\n                class Si {\n                  constructor(A3, F3) {\n                    this.gl = A3.gl, this.location = F3;\n                  }\n                }\n                class ei extends Si {\n                  constructor(A3, F3) {\n                    super(A3, F3), this.current = 0;\n                  }\n                  set(A3) {\n                    this.current !== A3 && (this.current = A3, this.gl.uniform1f(this.location, A3));\n                  }\n                }\n                class Ln extends Si {\n                  constructor(A3, F3) {\n                    super(A3, F3), this.current = [0, 0, 0, 0];\n                  }\n                  set(A3) {\n                    A3[0] === this.current[0] && A3[1] === this.current[1] && A3[2] === this.current[2] && A3[3] === this.current[3] || (this.current = A3, this.gl.uniform4f(this.location, A3[0], A3[1], A3[2], A3[3]));\n                  }\n                }\n                class En extends Si {\n                  constructor(A3, F3) {\n                    super(A3, F3), this.current = nr.transparent;\n                  }\n                  set(A3) {\n                    A3.r === this.current.r && A3.g === this.current.g && A3.b === this.current.b && A3.a === this.current.a || (this.current = A3, this.gl.uniform4f(this.location, A3.r, A3.g, A3.b, A3.a));\n                  }\n                }\n                let Un = new Float32Array(16);\n                function ia(R) {\n                  return [kt(255 * R.r, 255 * R.g), kt(255 * R.b, 255 * R.a)];\n                }\n                class Ea {\n                  constructor(A3, F3, W) {\n                    this.value = A3, this.uniformNames = F3.map((re) => `u_${re}`), this.type = W;\n                  }\n                  setUniform(A3, F3, W) {\n                    A3.set(W.constantOr(this.value));\n                  }\n                  getBinding(A3, F3, W) {\n                    return this.type === "color" ? new En(A3, F3) : new ei(A3, F3);\n                  }\n                }\n                class Ia {\n                  constructor(A3, F3) {\n                    this.uniformNames = F3.map((W) => `u_${W}`), this.patternFrom = null, this.patternTo = null, this.pixelRatioFrom = 1, this.pixelRatioTo = 1;\n                  }\n                  setConstantPatternPositions(A3, F3) {\n                    this.pixelRatioFrom = F3.pixelRatio, this.pixelRatioTo = A3.pixelRatio, this.patternFrom = F3.tlbr, this.patternTo = A3.tlbr;\n                  }\n                  setUniform(A3, F3, W, re) {\n                    let fe = re === "u_pattern_to" ? this.patternTo : re === "u_pattern_from" ? this.patternFrom : re === "u_pixel_ratio_to" ? this.pixelRatioTo : re === "u_pixel_ratio_from" ? this.pixelRatioFrom : null;\n                    fe && A3.set(fe);\n                  }\n                  getBinding(A3, F3, W) {\n                    return W.substr(0, 9) === "u_pattern" ? new Ln(A3, F3) : new ei(A3, F3);\n                  }\n                }\n                class yo {\n                  constructor(A3, F3, W, re) {\n                    this.expression = A3, this.type = W, this.maxValue = 0, this.paintVertexAttributes = F3.map((fe) => ({ name: `a_${fe}`, type: "Float32", components: W === "color" ? 2 : 1, offset: 0 })), this.paintVertexArray = new re();\n                  }\n                  populatePaintArray(A3, F3, W, re, fe) {\n                    let pe = this.paintVertexArray.length, ze = this.expression.evaluate(new rs(0), F3, {}, re, [], fe);\n                    this.paintVertexArray.resize(A3), this._setPaintValue(pe, A3, ze);\n                  }\n                  updatePaintArray(A3, F3, W, re) {\n                    let fe = this.expression.evaluate({ zoom: 0 }, W, re);\n                    this._setPaintValue(A3, F3, fe);\n                  }\n                  _setPaintValue(A3, F3, W) {\n                    if (this.type === "color") {\n                      let re = ia(W);\n                      for (let fe = A3; fe < F3; fe++) this.paintVertexArray.emplace(fe, re[0], re[1]);\n                    } else {\n                      for (let re = A3; re < F3; re++) this.paintVertexArray.emplace(re, W);\n                      this.maxValue = Math.max(this.maxValue, Math.abs(W));\n                    }\n                  }\n                  upload(A3) {\n                    this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = A3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));\n                  }\n                  destroy() {\n                    this.paintVertexBuffer && this.paintVertexBuffer.destroy();\n                  }\n                }\n                class Da {\n                  constructor(A3, F3, W, re, fe, pe) {\n                    this.expression = A3, this.uniformNames = F3.map((ze) => `u_${ze}_t`), this.type = W, this.useIntegerZoom = re, this.zoom = fe, this.maxValue = 0, this.paintVertexAttributes = F3.map((ze) => ({ name: `a_${ze}`, type: "Float32", components: W === "color" ? 4 : 2, offset: 0 })), this.paintVertexArray = new pe();\n                  }\n                  populatePaintArray(A3, F3, W, re, fe) {\n                    let pe = this.expression.evaluate(new rs(this.zoom), F3, {}, re, [], fe), ze = this.expression.evaluate(new rs(this.zoom + 1), F3, {}, re, [], fe), Ke = this.paintVertexArray.length;\n                    this.paintVertexArray.resize(A3), this._setPaintValue(Ke, A3, pe, ze);\n                  }\n                  updatePaintArray(A3, F3, W, re) {\n                    let fe = this.expression.evaluate({ zoom: this.zoom }, W, re), pe = this.expression.evaluate({ zoom: this.zoom + 1 }, W, re);\n                    this._setPaintValue(A3, F3, fe, pe);\n                  }\n                  _setPaintValue(A3, F3, W, re) {\n                    if (this.type === "color") {\n                      let fe = ia(W), pe = ia(re);\n                      for (let ze = A3; ze < F3; ze++) this.paintVertexArray.emplace(ze, fe[0], fe[1], pe[0], pe[1]);\n                    } else {\n                      for (let fe = A3; fe < F3; fe++) this.paintVertexArray.emplace(fe, W, re);\n                      this.maxValue = Math.max(this.maxValue, Math.abs(W), Math.abs(re));\n                    }\n                  }\n                  upload(A3) {\n                    this.paintVertexArray && this.paintVertexArray.arrayBuffer && (this.paintVertexBuffer && this.paintVertexBuffer.buffer ? this.paintVertexBuffer.updateData(this.paintVertexArray) : this.paintVertexBuffer = A3.createVertexBuffer(this.paintVertexArray, this.paintVertexAttributes, this.expression.isStateDependent));\n                  }\n                  destroy() {\n                    this.paintVertexBuffer && this.paintVertexBuffer.destroy();\n                  }\n                  setUniform(A3, F3) {\n                    let W = this.useIntegerZoom ? Math.floor(F3.zoom) : F3.zoom, re = E3(this.expression.interpolationFactor(W, this.zoom, this.zoom + 1), 0, 1);\n                    A3.set(re);\n                  }\n                  getBinding(A3, F3, W) {\n                    return new ei(A3, F3);\n                  }\n                }\n                class go {\n                  constructor(A3, F3, W, re, fe, pe) {\n                    this.expression = A3, this.type = F3, this.useIntegerZoom = W, this.zoom = re, this.layerId = pe, this.zoomInPaintVertexArray = new fe(), this.zoomOutPaintVertexArray = new fe();\n                  }\n                  populatePaintArray(A3, F3, W) {\n                    let re = this.zoomInPaintVertexArray.length;\n                    this.zoomInPaintVertexArray.resize(A3), this.zoomOutPaintVertexArray.resize(A3), this._setPaintValues(re, A3, F3.patterns && F3.patterns[this.layerId], W);\n                  }\n                  updatePaintArray(A3, F3, W, re, fe) {\n                    this._setPaintValues(A3, F3, W.patterns && W.patterns[this.layerId], fe);\n                  }\n                  _setPaintValues(A3, F3, W, re) {\n                    if (!re || !W) return;\n                    let { min: fe, mid: pe, max: ze } = W, Ke = re[fe], ct = re[pe], Lt = re[ze];\n                    if (Ke && ct && Lt) for (let $t = A3; $t < F3; $t++) this.zoomInPaintVertexArray.emplace($t, ct.tl[0], ct.tl[1], ct.br[0], ct.br[1], Ke.tl[0], Ke.tl[1], Ke.br[0], Ke.br[1], ct.pixelRatio, Ke.pixelRatio), this.zoomOutPaintVertexArray.emplace($t, ct.tl[0], ct.tl[1], ct.br[0], ct.br[1], Lt.tl[0], Lt.tl[1], Lt.br[0], Lt.br[1], ct.pixelRatio, Lt.pixelRatio);\n                  }\n                  upload(A3) {\n                    this.zoomInPaintVertexArray && this.zoomInPaintVertexArray.arrayBuffer && this.zoomOutPaintVertexArray && this.zoomOutPaintVertexArray.arrayBuffer && (this.zoomInPaintVertexBuffer = A3.createVertexBuffer(this.zoomInPaintVertexArray, nt.members, this.expression.isStateDependent), this.zoomOutPaintVertexBuffer = A3.createVertexBuffer(this.zoomOutPaintVertexArray, nt.members, this.expression.isStateDependent));\n                  }\n                  destroy() {\n                    this.zoomOutPaintVertexBuffer && this.zoomOutPaintVertexBuffer.destroy(), this.zoomInPaintVertexBuffer && this.zoomInPaintVertexBuffer.destroy();\n                  }\n                }\n                class Is {\n                  constructor(A3, F3, W) {\n                    this.binders = {}, this._buffers = [];\n                    let re = [];\n                    for (let fe in A3.paint._values) {\n                      if (!W(fe)) continue;\n                      let pe = A3.paint.get(fe);\n                      if (!(pe instanceof xu && Nl(pe.property.specification))) continue;\n                      let ze = Xs(fe, A3.type), Ke = pe.value, ct = pe.property.specification.type, Lt = pe.property.useIntegerZoom, $t = pe.property.specification["property-type"], fr = $t === "cross-faded" || $t === "cross-faded-data-driven";\n                      if (Ke.kind === "constant") this.binders[fe] = fr ? new Ia(Ke.value, ze) : new Ea(Ke.value, ze, ct), re.push(`/u_${fe}`);\n                      else if (Ke.kind === "source" || fr) {\n                        let mr = Gn(fe, ct, "source");\n                        this.binders[fe] = fr ? new go(Ke, ct, Lt, F3, mr, A3.id) : new yo(Ke, ze, ct, mr), re.push(`/a_${fe}`);\n                      } else {\n                        let mr = Gn(fe, ct, "composite");\n                        this.binders[fe] = new Da(Ke, ze, ct, Lt, F3, mr), re.push(`/z_${fe}`);\n                      }\n                    }\n                    this.cacheKey = re.sort().join("");\n                  }\n                  getMaxValue(A3) {\n                    let F3 = this.binders[A3];\n                    return F3 instanceof yo || F3 instanceof Da ? F3.maxValue : 0;\n                  }\n                  populatePaintArrays(A3, F3, W, re, fe) {\n                    for (let pe in this.binders) {\n                      let ze = this.binders[pe];\n                      (ze instanceof yo || ze instanceof Da || ze instanceof go) && ze.populatePaintArray(A3, F3, W, re, fe);\n                    }\n                  }\n                  setConstantPatternPositions(A3, F3) {\n                    for (let W in this.binders) {\n                      let re = this.binders[W];\n                      re instanceof Ia && re.setConstantPatternPositions(A3, F3);\n                    }\n                  }\n                  updatePaintArrays(A3, F3, W, re, fe) {\n                    let pe = false;\n                    for (let ze in A3) {\n                      let Ke = F3.getPositions(ze);\n                      for (let ct of Ke) {\n                        let Lt = W.feature(ct.index);\n                        for (let $t in this.binders) {\n                          let fr = this.binders[$t];\n                          if ((fr instanceof yo || fr instanceof Da || fr instanceof go) && fr.expression.isStateDependent === true) {\n                            let mr = re.paint.get($t);\n                            fr.expression = mr.value, fr.updatePaintArray(ct.start, ct.end, Lt, A3[ze], fe), pe = true;\n                          }\n                        }\n                      }\n                    }\n                    return pe;\n                  }\n                  defines() {\n                    let A3 = [];\n                    for (let F3 in this.binders) {\n                      let W = this.binders[F3];\n                      (W instanceof Ea || W instanceof Ia) && A3.push(...W.uniformNames.map((re) => `#define HAS_UNIFORM_${re}`));\n                    }\n                    return A3;\n                  }\n                  getBinderAttributes() {\n                    let A3 = [];\n                    for (let F3 in this.binders) {\n                      let W = this.binders[F3];\n                      if (W instanceof yo || W instanceof Da) for (let re = 0; re < W.paintVertexAttributes.length; re++) A3.push(W.paintVertexAttributes[re].name);\n                      else if (W instanceof go) for (let re = 0; re < nt.members.length; re++) A3.push(nt.members[re].name);\n                    }\n                    return A3;\n                  }\n                  getBinderUniforms() {\n                    let A3 = [];\n                    for (let F3 in this.binders) {\n                      let W = this.binders[F3];\n                      if (W instanceof Ea || W instanceof Ia || W instanceof Da) for (let re of W.uniformNames) A3.push(re);\n                    }\n                    return A3;\n                  }\n                  getPaintVertexBuffers() {\n                    return this._buffers;\n                  }\n                  getUniforms(A3, F3) {\n                    let W = [];\n                    for (let re in this.binders) {\n                      let fe = this.binders[re];\n                      if (fe instanceof Ea || fe instanceof Ia || fe instanceof Da) {\n                        for (let pe of fe.uniformNames) if (F3[pe]) {\n                          let ze = fe.getBinding(A3, F3[pe], pe);\n                          W.push({ name: pe, property: re, binding: ze });\n                        }\n                      }\n                    }\n                    return W;\n                  }\n                  setUniforms(A3, F3, W, re) {\n                    for (let { name: fe, property: pe, binding: ze } of F3) this.binders[pe].setUniform(ze, re, W.get(pe), fe);\n                  }\n                  updatePaintBuffers(A3) {\n                    this._buffers = [];\n                    for (let F3 in this.binders) {\n                      let W = this.binders[F3];\n                      if (A3 && W instanceof go) {\n                        let re = A3.fromScale === 2 ? W.zoomInPaintVertexBuffer : W.zoomOutPaintVertexBuffer;\n                        re && this._buffers.push(re);\n                      } else (W instanceof yo || W instanceof Da) && W.paintVertexBuffer && this._buffers.push(W.paintVertexBuffer);\n                    }\n                  }\n                  upload(A3) {\n                    for (let F3 in this.binders) {\n                      let W = this.binders[F3];\n                      (W instanceof yo || W instanceof Da || W instanceof go) && W.upload(A3);\n                    }\n                    this.updatePaintBuffers();\n                  }\n                  destroy() {\n                    for (let A3 in this.binders) {\n                      let F3 = this.binders[A3];\n                      (F3 instanceof yo || F3 instanceof Da || F3 instanceof go) && F3.destroy();\n                    }\n                  }\n                }\n                class Ms {\n                  constructor(A3, F3, W = () => true) {\n                    this.programConfigurations = {};\n                    for (let re of A3) this.programConfigurations[re.id] = new Is(re, F3, W);\n                    this.needsUpload = false, this._featureMap = new Zr(), this._bufferOffset = 0;\n                  }\n                  populatePaintArrays(A3, F3, W, re, fe, pe) {\n                    for (let ze in this.programConfigurations) this.programConfigurations[ze].populatePaintArrays(A3, F3, re, fe, pe);\n                    F3.id !== void 0 && this._featureMap.add(F3.id, W, this._bufferOffset, A3), this._bufferOffset = A3, this.needsUpload = true;\n                  }\n                  updatePaintArrays(A3, F3, W, re) {\n                    for (let fe of W) this.needsUpload = this.programConfigurations[fe.id].updatePaintArrays(A3, this._featureMap, F3, fe, re) || this.needsUpload;\n                  }\n                  get(A3) {\n                    return this.programConfigurations[A3];\n                  }\n                  upload(A3) {\n                    if (this.needsUpload) {\n                      for (let F3 in this.programConfigurations) this.programConfigurations[F3].upload(A3);\n                      this.needsUpload = false;\n                    }\n                  }\n                  destroy() {\n                    for (let A3 in this.programConfigurations) this.programConfigurations[A3].destroy();\n                  }\n                }\n                function Xs(R, A3) {\n                  return { "text-opacity": ["opacity"], "icon-opacity": ["opacity"], "text-color": ["fill_color"], "icon-color": ["fill_color"], "text-halo-color": ["halo_color"], "icon-halo-color": ["halo_color"], "text-halo-blur": ["halo_blur"], "icon-halo-blur": ["halo_blur"], "text-halo-width": ["halo_width"], "icon-halo-width": ["halo_width"], "line-gap-width": ["gapwidth"], "line-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"], "fill-extrusion-pattern": ["pattern_to", "pattern_from", "pixel_ratio_to", "pixel_ratio_from"] }[R] || [R.replace(`${A3}-`, "").replace(/-/g, "_")];\n                }\n                function Gn(R, A3, F3) {\n                  let W = { color: { source: Ir, composite: cn }, number: { source: Sr, composite: Ir } }, re = (function(fe) {\n                    return { "line-pattern": { source: Js, composite: Js }, "fill-pattern": { source: Js, composite: Js }, "fill-extrusion-pattern": { source: Js, composite: Js } }[fe];\n                  })(R);\n                  return re && re[F3] || W[A3][F3];\n                }\n                Fi("ConstantBinder", Ea), Fi("CrossFadedConstantBinder", Ia), Fi("SourceExpressionBinder", yo), Fi("CrossFadedCompositeBinder", go), Fi("CompositeExpressionBinder", Da), Fi("ProgramConfiguration", Is, { omit: ["_buffers"] }), Fi("ProgramConfigurationSet", Ms);\n                let ja = 8192, Fo = Math.pow(2, 14) - 1, Uo = -Fo - 1;\n                function $s(R) {\n                  let A3 = ja / R.extent, F3 = R.loadGeometry();\n                  for (let W = 0; W < F3.length; W++) {\n                    let re = F3[W];\n                    for (let fe = 0; fe < re.length; fe++) {\n                      let pe = re[fe], ze = Math.round(pe.x * A3), Ke = Math.round(pe.y * A3);\n                      pe.x = E3(ze, Uo, Fo), pe.y = E3(Ke, Uo, Fo), (ze < pe.x || ze > pe.x + 1 || Ke < pe.y || Ke > pe.y + 1) && T3("Geometry exceeds allowed extent, reduce your vector tile buffer size");\n                    }\n                  }\n                  return F3;\n                }\n                function Sl(R, A3) {\n                  return { type: R.type, id: R.id, properties: R.properties, geometry: A3 ? $s(R) : [] };\n                }\n                function bu(R, A3, F3, W, re) {\n                  R.emplaceBack(2 * A3 + (W + 1) / 2, 2 * F3 + (re + 1) / 2);\n                }\n                class dl {\n                  constructor(A3) {\n                    this.zoom = A3.zoom, this.overscaling = A3.overscaling, this.layers = A3.layers, this.layerIds = this.layers.map((F3) => F3.id), this.index = A3.index, this.hasPattern = false, this.layoutVertexArray = new To(), this.indexArray = new se(), this.segments = new Ye(), this.programConfigurations = new Ms(A3.layers, A3.zoom), this.stateDependentLayerIds = this.layers.filter((F3) => F3.isStateDependent()).map((F3) => F3.id);\n                  }\n                  populate(A3, F3, W) {\n                    let re = this.layers[0], fe = [], pe = null, ze = false;\n                    re.type === "circle" && (pe = re.layout.get("circle-sort-key"), ze = !pe.isConstant());\n                    for (let { feature: Ke, id: ct, index: Lt, sourceLayerIndex: $t } of A3) {\n                      let fr = this.layers[0]._featureFilter.needGeometry, mr = Sl(Ke, fr);\n                      if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), mr, W)) continue;\n                      let Pr = ze ? pe.evaluate(mr, {}, W) : void 0, zr = { id: ct, properties: Ke.properties, type: Ke.type, sourceLayerIndex: $t, index: Lt, geometry: fr ? mr.geometry : $s(Ke), patterns: {}, sortKey: Pr };\n                      fe.push(zr);\n                    }\n                    ze && fe.sort((Ke, ct) => Ke.sortKey - ct.sortKey);\n                    for (let Ke of fe) {\n                      let { geometry: ct, index: Lt, sourceLayerIndex: $t } = Ke, fr = A3[Lt].feature;\n                      this.addFeature(Ke, ct, Lt, W), F3.featureIndex.insert(fr, ct, Lt, $t, this.index);\n                    }\n                  }\n                  update(A3, F3, W) {\n                    this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(A3, F3, this.stateDependentLayers, W);\n                  }\n                  isEmpty() {\n                    return this.layoutVertexArray.length === 0;\n                  }\n                  uploadPending() {\n                    return !this.uploaded || this.programConfigurations.needsUpload;\n                  }\n                  upload(A3) {\n                    this.uploaded || (this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, He), this.indexBuffer = A3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(A3), this.uploaded = true;\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());\n                  }\n                  addFeature(A3, F3, W, re) {\n                    for (let fe of F3) for (let pe of fe) {\n                      let ze = pe.x, Ke = pe.y;\n                      if (ze < 0 || ze >= ja || Ke < 0 || Ke >= ja) continue;\n                      let ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray, A3.sortKey), Lt = ct.vertexLength;\n                      bu(this.layoutVertexArray, ze, Ke, -1, -1), bu(this.layoutVertexArray, ze, Ke, 1, -1), bu(this.layoutVertexArray, ze, Ke, 1, 1), bu(this.layoutVertexArray, ze, Ke, -1, 1), this.indexArray.emplaceBack(Lt, Lt + 1, Lt + 2), this.indexArray.emplaceBack(Lt, Lt + 3, Lt + 2), ct.vertexLength += 4, ct.primitiveLength += 2;\n                    }\n                    this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, A3, W, {}, re);\n                  }\n                }\n                function Sc(R, A3) {\n                  for (let F3 = 0; F3 < R.length; F3++) if (Ui(A3, R[F3])) return true;\n                  for (let F3 = 0; F3 < A3.length; F3++) if (Ui(R, A3[F3])) return true;\n                  return !!Rr(R, A3);\n                }\n                function Me(R, A3, F3) {\n                  return !!Ui(R, A3) || !!Nr(A3, R, F3);\n                }\n                function bt(R, A3) {\n                  if (R.length === 1) return mi(A3, R[0]);\n                  for (let F3 = 0; F3 < A3.length; F3++) {\n                    let W = A3[F3];\n                    for (let re = 0; re < W.length; re++) if (Ui(R, W[re])) return true;\n                  }\n                  for (let F3 = 0; F3 < R.length; F3++) if (mi(A3, R[F3])) return true;\n                  for (let F3 = 0; F3 < A3.length; F3++) if (Rr(R, A3[F3])) return true;\n                  return false;\n                }\n                function zt(R, A3, F3) {\n                  if (R.length > 1) {\n                    if (Rr(R, A3)) return true;\n                    for (let W = 0; W < A3.length; W++) if (Nr(A3[W], R, F3)) return true;\n                  }\n                  for (let W = 0; W < R.length; W++) if (Nr(R[W], A3, F3)) return true;\n                  return false;\n                }\n                function Rr(R, A3) {\n                  if (R.length === 0 || A3.length === 0) return false;\n                  for (let F3 = 0; F3 < R.length - 1; F3++) {\n                    let W = R[F3], re = R[F3 + 1];\n                    for (let fe = 0; fe < A3.length - 1; fe++) if (jr(W, re, A3[fe], A3[fe + 1])) return true;\n                  }\n                  return false;\n                }\n                function jr(R, A3, F3, W) {\n                  return z3(R, F3, W) !== z3(A3, F3, W) && z3(R, A3, F3) !== z3(R, A3, W);\n                }\n                function Nr(R, A3, F3) {\n                  let W = F3 * F3;\n                  if (A3.length === 1) return R.distSqr(A3[0]) < W;\n                  for (let re = 1; re < A3.length; re++) if (Gr(R, A3[re - 1], A3[re]) < W) return true;\n                  return false;\n                }\n                function Gr(R, A3, F3) {\n                  let W = A3.distSqr(F3);\n                  if (W === 0) return R.distSqr(A3);\n                  let re = ((R.x - A3.x) * (F3.x - A3.x) + (R.y - A3.y) * (F3.y - A3.y)) / W;\n                  return R.distSqr(re < 0 ? A3 : re > 1 ? F3 : F3.sub(A3)._mult(re)._add(A3));\n                }\n                function mi(R, A3) {\n                  let F3, W, re, fe = false;\n                  for (let pe = 0; pe < R.length; pe++) {\n                    F3 = R[pe];\n                    for (let ze = 0, Ke = F3.length - 1; ze < F3.length; Ke = ze++) W = F3[ze], re = F3[Ke], W.y > A3.y != re.y > A3.y && A3.x < (re.x - W.x) * (A3.y - W.y) / (re.y - W.y) + W.x && (fe = !fe);\n                  }\n                  return fe;\n                }\n                function Ui(R, A3) {\n                  let F3 = false;\n                  for (let W = 0, re = R.length - 1; W < R.length; re = W++) {\n                    let fe = R[W], pe = R[re];\n                    fe.y > A3.y != pe.y > A3.y && A3.x < (pe.x - fe.x) * (A3.y - fe.y) / (pe.y - fe.y) + fe.x && (F3 = !F3);\n                  }\n                  return F3;\n                }\n                function qi(R, A3, F3) {\n                  let W = F3[0], re = F3[2];\n                  if (R.x < W.x && A3.x < W.x || R.x > re.x && A3.x > re.x || R.y < W.y && A3.y < W.y || R.y > re.y && A3.y > re.y) return false;\n                  let fe = z3(R, A3, F3[0]);\n                  return fe !== z3(R, A3, F3[1]) || fe !== z3(R, A3, F3[2]) || fe !== z3(R, A3, F3[3]);\n                }\n                function Ei(R, A3, F3) {\n                  let W = A3.paint.get(R).value;\n                  return W.kind === "constant" ? W.value : F3.programConfigurations.get(A3.id).getMaxValue(R);\n                }\n                function Hn(R) {\n                  return Math.sqrt(R[0] * R[0] + R[1] * R[1]);\n                }\n                function en(R, A3, F3, W, re) {\n                  if (!A3[0] && !A3[1]) return R;\n                  let fe = u4.convert(A3)._mult(re);\n                  F3 === "viewport" && fe._rotate(-W);\n                  let pe = [];\n                  for (let ze = 0; ze < R.length; ze++) pe.push(R[ze].sub(fe));\n                  return pe;\n                }\n                let Wi, si;\n                Fi("CircleBucket", dl, { omit: ["layers"] });\n                var Mr = { get paint() {\n                  return si = si || new ue({ "circle-radius": new oo(ce.paint_circle["circle-radius"]), "circle-color": new oo(ce.paint_circle["circle-color"]), "circle-blur": new oo(ce.paint_circle["circle-blur"]), "circle-opacity": new oo(ce.paint_circle["circle-opacity"]), "circle-translate": new Ua(ce.paint_circle["circle-translate"]), "circle-translate-anchor": new Ua(ce.paint_circle["circle-translate-anchor"]), "circle-pitch-scale": new Ua(ce.paint_circle["circle-pitch-scale"]), "circle-pitch-alignment": new Ua(ce.paint_circle["circle-pitch-alignment"]), "circle-stroke-width": new oo(ce.paint_circle["circle-stroke-width"]), "circle-stroke-color": new oo(ce.paint_circle["circle-stroke-color"]), "circle-stroke-opacity": new oo(ce.paint_circle["circle-stroke-opacity"]) });\n                }, get layout() {\n                  return Wi = Wi || new ue({ "circle-sort-key": new oo(ce.layout_circle["circle-sort-key"]) });\n                } }, Yr = 1e-6, xi = typeof Float32Array != "undefined" ? Float32Array : Array;\n                function Ri(R) {\n                  return R[0] = 1, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = 1, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = 1, R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0, R[15] = 1, R;\n                }\n                function ci(R, A3, F3) {\n                  var W = A3[0], re = A3[1], fe = A3[2], pe = A3[3], ze = A3[4], Ke = A3[5], ct = A3[6], Lt = A3[7], $t = A3[8], fr = A3[9], mr = A3[10], Pr = A3[11], zr = A3[12], ui = A3[13], yi = A3[14], vn = A3[15], zi = F3[0], un = F3[1], Tn = F3[2], pa = F3[3];\n                  return R[0] = zi * W + un * ze + Tn * $t + pa * zr, R[1] = zi * re + un * Ke + Tn * fr + pa * ui, R[2] = zi * fe + un * ct + Tn * mr + pa * yi, R[3] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[4] = (zi = F3[4]) * W + (un = F3[5]) * ze + (Tn = F3[6]) * $t + (pa = F3[7]) * zr, R[5] = zi * re + un * Ke + Tn * fr + pa * ui, R[6] = zi * fe + un * ct + Tn * mr + pa * yi, R[7] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[8] = (zi = F3[8]) * W + (un = F3[9]) * ze + (Tn = F3[10]) * $t + (pa = F3[11]) * zr, R[9] = zi * re + un * Ke + Tn * fr + pa * ui, R[10] = zi * fe + un * ct + Tn * mr + pa * yi, R[11] = zi * pe + un * Lt + Tn * Pr + pa * vn, R[12] = (zi = F3[12]) * W + (un = F3[13]) * ze + (Tn = F3[14]) * $t + (pa = F3[15]) * zr, R[13] = zi * re + un * Ke + Tn * fr + pa * ui, R[14] = zi * fe + un * ct + Tn * mr + pa * yi, R[15] = zi * pe + un * Lt + Tn * Pr + pa * vn, R;\n                }\n                Math.hypot || (Math.hypot = function() {\n                  for (var R = 0, A3 = arguments.length; A3--; ) R += arguments[A3] * arguments[A3];\n                  return Math.sqrt(R);\n                });\n                var an, Zi = ci;\n                function Bn(R, A3, F3) {\n                  var W = A3[0], re = A3[1], fe = A3[2], pe = A3[3];\n                  return R[0] = F3[0] * W + F3[4] * re + F3[8] * fe + F3[12] * pe, R[1] = F3[1] * W + F3[5] * re + F3[9] * fe + F3[13] * pe, R[2] = F3[2] * W + F3[6] * re + F3[10] * fe + F3[14] * pe, R[3] = F3[3] * W + F3[7] * re + F3[11] * fe + F3[15] * pe, R;\n                }\n                an = new xi(4), xi != Float32Array && (an[0] = 0, an[1] = 0, an[2] = 0, an[3] = 0);\n                class hi extends B4 {\n                  constructor(A3) {\n                    super(A3, Mr);\n                  }\n                  createBucket(A3) {\n                    return new dl(A3);\n                  }\n                  queryRadius(A3) {\n                    let F3 = A3;\n                    return Ei("circle-radius", this, F3) + Ei("circle-stroke-width", this, F3) + Hn(this.paint.get("circle-translate"));\n                  }\n                  queryIntersectsFeature(A3, F3, W, re, fe, pe, ze, Ke) {\n                    let ct = en(A3, this.paint.get("circle-translate"), this.paint.get("circle-translate-anchor"), pe.angle, ze), Lt = this.paint.get("circle-radius").evaluate(F3, W) + this.paint.get("circle-stroke-width").evaluate(F3, W), $t = this.paint.get("circle-pitch-alignment") === "map", fr = $t ? ct : (function(Pr, zr) {\n                      return Pr.map((ui) => li(ui, zr));\n                    })(ct, Ke), mr = $t ? Lt * ze : Lt;\n                    for (let Pr of re) for (let zr of Pr) {\n                      let ui = $t ? zr : li(zr, Ke), yi = mr, vn = Bn([], [zr.x, zr.y, 0, 1], Ke);\n                      if (this.paint.get("circle-pitch-scale") === "viewport" && this.paint.get("circle-pitch-alignment") === "map" ? yi *= vn[3] / pe.cameraToCenterDistance : this.paint.get("circle-pitch-scale") === "map" && this.paint.get("circle-pitch-alignment") === "viewport" && (yi *= pe.cameraToCenterDistance / vn[3]), Me(fr, ui, yi)) return true;\n                    }\n                    return false;\n                  }\n                }\n                function li(R, A3) {\n                  let F3 = Bn([], [R.x, R.y, 0, 1], A3);\n                  return new u4(F3[0] / F3[3], F3[1] / F3[3]);\n                }\n                class mn extends dl {\n                }\n                let Ji;\n                Fi("HeatmapBucket", mn, { omit: ["layers"] });\n                var Vi = { get paint() {\n                  return Ji = Ji || new ue({ "heatmap-radius": new oo(ce.paint_heatmap["heatmap-radius"]), "heatmap-weight": new oo(ce.paint_heatmap["heatmap-weight"]), "heatmap-intensity": new Ua(ce.paint_heatmap["heatmap-intensity"]), "heatmap-color": new Ku(ce.paint_heatmap["heatmap-color"]), "heatmap-opacity": new Ua(ce.paint_heatmap["heatmap-opacity"]) });\n                } };\n                function Ni(R, { width: A3, height: F3 }, W, re) {\n                  if (re) {\n                    if (re instanceof Uint8ClampedArray) re = new Uint8Array(re.buffer);\n                    else if (re.length !== A3 * F3 * W) throw new RangeError(`mismatched image size. expected: ${re.length} but got: ${A3 * F3 * W}`);\n                  } else re = new Uint8Array(A3 * F3 * W);\n                  return R.width = A3, R.height = F3, R.data = re, R;\n                }\n                function pn(R, { width: A3, height: F3 }, W) {\n                  if (A3 === R.width && F3 === R.height) return;\n                  let re = Ni({}, { width: A3, height: F3 }, W);\n                  Vn(R, re, { x: 0, y: 0 }, { x: 0, y: 0 }, { width: Math.min(R.width, A3), height: Math.min(R.height, F3) }, W), R.width = A3, R.height = F3, R.data = re.data;\n                }\n                function Vn(R, A3, F3, W, re, fe) {\n                  if (re.width === 0 || re.height === 0) return A3;\n                  if (re.width > R.width || re.height > R.height || F3.x > R.width - re.width || F3.y > R.height - re.height) throw new RangeError("out of range source coordinates for image copy");\n                  if (re.width > A3.width || re.height > A3.height || W.x > A3.width - re.width || W.y > A3.height - re.height) throw new RangeError("out of range destination coordinates for image copy");\n                  let pe = R.data, ze = A3.data;\n                  if (pe === ze) throw new Error("srcData equals dstData, so image is already copied");\n                  for (let Ke = 0; Ke < re.height; Ke++) {\n                    let ct = ((F3.y + Ke) * R.width + F3.x) * fe, Lt = ((W.y + Ke) * A3.width + W.x) * fe;\n                    for (let $t = 0; $t < re.width * fe; $t++) ze[Lt + $t] = pe[ct + $t];\n                  }\n                  return A3;\n                }\n                class na {\n                  constructor(A3, F3) {\n                    Ni(this, A3, 1, F3);\n                  }\n                  resize(A3) {\n                    pn(this, A3, 1);\n                  }\n                  clone() {\n                    return new na({ width: this.width, height: this.height }, new Uint8Array(this.data));\n                  }\n                  static copy(A3, F3, W, re, fe) {\n                    Vn(A3, F3, W, re, fe, 1);\n                  }\n                }\n                class Ki {\n                  constructor(A3, F3) {\n                    Ni(this, A3, 4, F3);\n                  }\n                  resize(A3) {\n                    pn(this, A3, 4);\n                  }\n                  replace(A3, F3) {\n                    F3 ? this.data.set(A3) : this.data = A3 instanceof Uint8ClampedArray ? new Uint8Array(A3.buffer) : A3;\n                  }\n                  clone() {\n                    return new Ki({ width: this.width, height: this.height }, new Uint8Array(this.data));\n                  }\n                  static copy(A3, F3, W, re, fe) {\n                    Vn(A3, F3, W, re, fe, 4);\n                  }\n                }\n                function kn(R) {\n                  let A3 = {}, F3 = R.resolution || 256, W = R.clips ? R.clips.length : 1, re = R.image || new Ki({ width: F3, height: W });\n                  if (Math.log(F3) / Math.LN2 % 1 != 0) throw new Error(`width is not a power of 2 - ${F3}`);\n                  let fe = (pe, ze, Ke) => {\n                    A3[R.evaluationKey] = Ke;\n                    let ct = R.expression.evaluate(A3);\n                    re.data[pe + ze + 0] = Math.floor(255 * ct.r / ct.a), re.data[pe + ze + 1] = Math.floor(255 * ct.g / ct.a), re.data[pe + ze + 2] = Math.floor(255 * ct.b / ct.a), re.data[pe + ze + 3] = Math.floor(255 * ct.a);\n                  };\n                  if (R.clips) for (let pe = 0, ze = 0; pe < W; ++pe, ze += 4 * F3) for (let Ke = 0, ct = 0; Ke < F3; Ke++, ct += 4) {\n                    let Lt = Ke / (F3 - 1), { start: $t, end: fr } = R.clips[pe];\n                    fe(ze, ct, $t * (1 - Lt) + fr * Lt);\n                  }\n                  else for (let pe = 0, ze = 0; pe < F3; pe++, ze += 4) fe(0, ze, pe / (F3 - 1));\n                  return re;\n                }\n                Fi("AlphaImage", na), Fi("RGBAImage", Ki);\n                let ta = "big-fb";\n                class oa extends B4 {\n                  createBucket(A3) {\n                    return new mn(A3);\n                  }\n                  constructor(A3) {\n                    super(A3, Vi), this.heatmapFbos = /* @__PURE__ */ new Map(), this._updateColorRamp();\n                  }\n                  _handleSpecialPaintPropertyUpdate(A3) {\n                    A3 === "heatmap-color" && this._updateColorRamp();\n                  }\n                  _updateColorRamp() {\n                    this.colorRamp = kn({ expression: this._transitionablePaint._values["heatmap-color"].value.expression, evaluationKey: "heatmapDensity", image: this.colorRamp }), this.colorRampTexture = null;\n                  }\n                  resize() {\n                    this.heatmapFbos.has(ta) && this.heatmapFbos.delete(ta);\n                  }\n                  queryRadius() {\n                    return 0;\n                  }\n                  queryIntersectsFeature() {\n                    return false;\n                  }\n                  hasOffscreenPass() {\n                    return this.paint.get("heatmap-opacity") !== 0 && this.visibility !== "none";\n                  }\n                }\n                let ba;\n                var is = { get paint() {\n                  return ba = ba || new ue({ "hillshade-illumination-direction": new Ua(ce.paint_hillshade["hillshade-illumination-direction"]), "hillshade-illumination-anchor": new Ua(ce.paint_hillshade["hillshade-illumination-anchor"]), "hillshade-exaggeration": new Ua(ce.paint_hillshade["hillshade-exaggeration"]), "hillshade-shadow-color": new Ua(ce.paint_hillshade["hillshade-shadow-color"]), "hillshade-highlight-color": new Ua(ce.paint_hillshade["hillshade-highlight-color"]), "hillshade-accent-color": new Ua(ce.paint_hillshade["hillshade-accent-color"]) });\n                } };\n                class Zs extends B4 {\n                  constructor(A3) {\n                    super(A3, is);\n                  }\n                  hasOffscreenPass() {\n                    return this.paint.get("hillshade-exaggeration") !== 0 && this.visibility !== "none";\n                  }\n                }\n                let Va = qe([{ name: "a_pos", components: 2, type: "Int16" }], 4), { members: Ml } = Va;\n                function zo(R, A3, F3 = 2) {\n                  let W = A3 && A3.length, re = W ? A3[0] * F3 : R.length, fe = Qs(R, 0, re, F3, true), pe = [];\n                  if (!fe || fe.next === fe.prev) return pe;\n                  let ze, Ke, ct;\n                  if (W && (fe = (function(Lt, $t, fr, mr) {\n                    let Pr = [];\n                    for (let zr = 0, ui = $t.length; zr < ui; zr++) {\n                      let yi = Qs(Lt, $t[zr] * mr, zr < ui - 1 ? $t[zr + 1] * mr : Lt.length, mr, false);\n                      yi === yi.next && (yi.steiner = true), Pr.push(J(yi));\n                    }\n                    Pr.sort(ol);\n                    for (let zr = 0; zr < Pr.length; zr++) fr = io(Pr[zr], fr);\n                    return fr;\n                  })(R, A3, fe, F3)), R.length > 80 * F3) {\n                    ze = 1 / 0, Ke = 1 / 0;\n                    let Lt = -1 / 0, $t = -1 / 0;\n                    for (let fr = F3; fr < re; fr += F3) {\n                      let mr = R[fr], Pr = R[fr + 1];\n                      mr < ze && (ze = mr), Pr < Ke && (Ke = Pr), mr > Lt && (Lt = mr), Pr > $t && ($t = Pr);\n                    }\n                    ct = Math.max(Lt - ze, $t - Ke), ct = ct !== 0 ? 32767 / ct : 0;\n                  }\n                  return Vl(fe, pe, F3, ze, Ke, ct, 0), pe;\n                }\n                function Qs(R, A3, F3, W, re) {\n                  let fe;\n                  if (re === (function(pe, ze, Ke, ct) {\n                    let Lt = 0;\n                    for (let $t = ze, fr = Ke - ct; $t < Ke; $t += ct) Lt += (pe[fr] - pe[$t]) * (pe[$t + 1] + pe[fr + 1]), fr = $t;\n                    return Lt;\n                  })(R, A3, F3, W) > 0) for (let pe = A3; pe < F3; pe += W) fe = qt(pe / W | 0, R[pe], R[pe + 1], fe);\n                  else for (let pe = F3 - W; pe >= A3; pe -= W) fe = qt(pe / W | 0, R[pe], R[pe + 1], fe);\n                  return fe && ne(fe, fe.next) && (Ve(fe), fe = fe.next), fe;\n                }\n                function al(R, A3) {\n                  if (!R) return R;\n                  A3 || (A3 = R);\n                  let F3, W = R;\n                  do\n                    if (F3 = false, W.steiner || !ne(W, W.next) && de(W.prev, W, W.next) !== 0) W = W.next;\n                    else {\n                      if (Ve(W), W = A3 = W.prev, W === W.next) break;\n                      F3 = true;\n                    }\n                  while (F3 || W !== A3);\n                  return A3;\n                }\n                function Vl(R, A3, F3, W, re, fe, pe) {\n                  if (!R) return;\n                  !pe && fe && (function(Ke, ct, Lt, $t) {\n                    let fr = Ke;\n                    do\n                      fr.z === 0 && (fr.z = D3(fr.x, fr.y, ct, Lt, $t)), fr.prevZ = fr.prev, fr.nextZ = fr.next, fr = fr.next;\n                    while (fr !== Ke);\n                    fr.prevZ.nextZ = null, fr.prevZ = null, (function(mr) {\n                      let Pr, zr = 1;\n                      do {\n                        let ui, yi = mr;\n                        mr = null;\n                        let vn = null;\n                        for (Pr = 0; yi; ) {\n                          Pr++;\n                          let zi = yi, un = 0;\n                          for (let pa = 0; pa < zr && (un++, zi = zi.nextZ, zi); pa++) ;\n                          let Tn = zr;\n                          for (; un > 0 || Tn > 0 && zi; ) un !== 0 && (Tn === 0 || !zi || yi.z <= zi.z) ? (ui = yi, yi = yi.nextZ, un--) : (ui = zi, zi = zi.nextZ, Tn--), vn ? vn.nextZ = ui : mr = ui, ui.prevZ = vn, vn = ui;\n                          yi = zi;\n                        }\n                        vn.nextZ = null, zr *= 2;\n                      } while (Pr > 1);\n                    })(fr);\n                  })(R, W, re, fe);\n                  let ze = R;\n                  for (; R.prev !== R.next; ) {\n                    let Ke = R.prev, ct = R.next;\n                    if (fe ? Vs(R, W, re, fe) : ss(R)) A3.push(Ke.i, R.i, ct.i), Ve(R), R = ct.next, ze = ct.next;\n                    else if ((R = ct) === ze) {\n                      pe ? pe === 1 ? Vl(R = Ys(al(R), A3), A3, F3, W, re, fe, 2) : pe === 2 && wa(R, A3, F3, W, re, fe) : Vl(al(R), A3, F3, W, re, fe, 1);\n                      break;\n                    }\n                  }\n                }\n                function ss(R) {\n                  let A3 = R.prev, F3 = R, W = R.next;\n                  if (de(A3, F3, W) >= 0) return false;\n                  let re = A3.x, fe = F3.x, pe = W.x, ze = A3.y, Ke = F3.y, ct = W.y, Lt = re < fe ? re < pe ? re : pe : fe < pe ? fe : pe, $t = ze < Ke ? ze < ct ? ze : ct : Ke < ct ? Ke : ct, fr = re > fe ? re > pe ? re : pe : fe > pe ? fe : pe, mr = ze > Ke ? ze > ct ? ze : ct : Ke > ct ? Ke : ct, Pr = W.next;\n                  for (; Pr !== A3; ) {\n                    if (Pr.x >= Lt && Pr.x <= fr && Pr.y >= $t && Pr.y <= mr && q2(re, ze, fe, Ke, pe, ct, Pr.x, Pr.y) && de(Pr.prev, Pr, Pr.next) >= 0) return false;\n                    Pr = Pr.next;\n                  }\n                  return true;\n                }\n                function Vs(R, A3, F3, W) {\n                  let re = R.prev, fe = R, pe = R.next;\n                  if (de(re, fe, pe) >= 0) return false;\n                  let ze = re.x, Ke = fe.x, ct = pe.x, Lt = re.y, $t = fe.y, fr = pe.y, mr = ze < Ke ? ze < ct ? ze : ct : Ke < ct ? Ke : ct, Pr = Lt < $t ? Lt < fr ? Lt : fr : $t < fr ? $t : fr, zr = ze > Ke ? ze > ct ? ze : ct : Ke > ct ? Ke : ct, ui = Lt > $t ? Lt > fr ? Lt : fr : $t > fr ? $t : fr, yi = D3(mr, Pr, A3, F3, W), vn = D3(zr, ui, A3, F3, W), zi = R.prevZ, un = R.nextZ;\n                  for (; zi && zi.z >= yi && un && un.z <= vn; ) {\n                    if (zi.x >= mr && zi.x <= zr && zi.y >= Pr && zi.y <= ui && zi !== re && zi !== pe && q2(ze, Lt, Ke, $t, ct, fr, zi.x, zi.y) && de(zi.prev, zi, zi.next) >= 0 || (zi = zi.prevZ, un.x >= mr && un.x <= zr && un.y >= Pr && un.y <= ui && un !== re && un !== pe && q2(ze, Lt, Ke, $t, ct, fr, un.x, un.y) && de(un.prev, un, un.next) >= 0)) return false;\n                    un = un.nextZ;\n                  }\n                  for (; zi && zi.z >= yi; ) {\n                    if (zi.x >= mr && zi.x <= zr && zi.y >= Pr && zi.y <= ui && zi !== re && zi !== pe && q2(ze, Lt, Ke, $t, ct, fr, zi.x, zi.y) && de(zi.prev, zi, zi.next) >= 0) return false;\n                    zi = zi.prevZ;\n                  }\n                  for (; un && un.z <= vn; ) {\n                    if (un.x >= mr && un.x <= zr && un.y >= Pr && un.y <= ui && un !== re && un !== pe && q2(ze, Lt, Ke, $t, ct, fr, un.x, un.y) && de(un.prev, un, un.next) >= 0) return false;\n                    un = un.nextZ;\n                  }\n                  return true;\n                }\n                function Ys(R, A3) {\n                  let F3 = R;\n                  do {\n                    let W = F3.prev, re = F3.next.next;\n                    !ne(W, re) && we(W, F3, F3.next, re) && Xt(W, re) && Xt(re, W) && (A3.push(W.i, F3.i, re.i), Ve(F3), Ve(F3.next), F3 = R = re), F3 = F3.next;\n                  } while (F3 !== R);\n                  return al(F3);\n                }\n                function wa(R, A3, F3, W, re, fe) {\n                  let pe = R;\n                  do {\n                    let ze = pe.next.next;\n                    for (; ze !== pe.prev; ) {\n                      if (pe.i !== ze.i && K(pe, ze)) {\n                        let Ke = hr(pe, ze);\n                        return pe = al(pe, pe.next), Ke = al(Ke, Ke.next), Vl(pe, A3, F3, W, re, fe, 0), void Vl(Ke, A3, F3, W, re, fe, 0);\n                      }\n                      ze = ze.next;\n                    }\n                    pe = pe.next;\n                  } while (pe !== R);\n                }\n                function ol(R, A3) {\n                  return R.x - A3.x;\n                }\n                function io(R, A3) {\n                  let F3 = (function(re, fe) {\n                    let pe = fe, ze = re.x, Ke = re.y, ct, Lt = -1 / 0;\n                    do {\n                      if (Ke <= pe.y && Ke >= pe.next.y && pe.next.y !== pe.y) {\n                        let zr = pe.x + (Ke - pe.y) * (pe.next.x - pe.x) / (pe.next.y - pe.y);\n                        if (zr <= ze && zr > Lt && (Lt = zr, ct = pe.x < pe.next.x ? pe : pe.next, zr === ze)) return ct;\n                      }\n                      pe = pe.next;\n                    } while (pe !== fe);\n                    if (!ct) return null;\n                    let $t = ct, fr = ct.x, mr = ct.y, Pr = 1 / 0;\n                    pe = ct;\n                    do {\n                      if (ze >= pe.x && pe.x >= fr && ze !== pe.x && q2(Ke < mr ? ze : Lt, Ke, fr, mr, Ke < mr ? Lt : ze, Ke, pe.x, pe.y)) {\n                        let zr = Math.abs(Ke - pe.y) / (ze - pe.x);\n                        Xt(pe, re) && (zr < Pr || zr === Pr && (pe.x > ct.x || pe.x === ct.x && Y(ct, pe))) && (ct = pe, Pr = zr);\n                      }\n                      pe = pe.next;\n                    } while (pe !== $t);\n                    return ct;\n                  })(R, A3);\n                  if (!F3) return A3;\n                  let W = hr(F3, R);\n                  return al(W, W.next), al(F3, F3.next);\n                }\n                function Y(R, A3) {\n                  return de(R.prev, R, A3.prev) < 0 && de(A3.next, R, R.next) < 0;\n                }\n                function D3(R, A3, F3, W, re) {\n                  return (R = 1431655765 & ((R = 858993459 & ((R = 252645135 & ((R = 16711935 & ((R = (R - F3) * re | 0) | R << 8)) | R << 4)) | R << 2)) | R << 1)) | (A3 = 1431655765 & ((A3 = 858993459 & ((A3 = 252645135 & ((A3 = 16711935 & ((A3 = (A3 - W) * re | 0) | A3 << 8)) | A3 << 4)) | A3 << 2)) | A3 << 1)) << 1;\n                }\n                function J(R) {\n                  let A3 = R, F3 = R;\n                  do\n                    (A3.x < F3.x || A3.x === F3.x && A3.y < F3.y) && (F3 = A3), A3 = A3.next;\n                  while (A3 !== R);\n                  return F3;\n                }\n                function q2(R, A3, F3, W, re, fe, pe, ze) {\n                  return (re - pe) * (A3 - ze) >= (R - pe) * (fe - ze) && (R - pe) * (W - ze) >= (F3 - pe) * (A3 - ze) && (F3 - pe) * (fe - ze) >= (re - pe) * (W - ze);\n                }\n                function K(R, A3) {\n                  return R.next.i !== A3.i && R.prev.i !== A3.i && !(function(F3, W) {\n                    let re = F3;\n                    do {\n                      if (re.i !== F3.i && re.next.i !== F3.i && re.i !== W.i && re.next.i !== W.i && we(re, re.next, F3, W)) return true;\n                      re = re.next;\n                    } while (re !== F3);\n                    return false;\n                  })(R, A3) && (Xt(R, A3) && Xt(A3, R) && (function(F3, W) {\n                    let re = F3, fe = false, pe = (F3.x + W.x) / 2, ze = (F3.y + W.y) / 2;\n                    do\n                      re.y > ze != re.next.y > ze && re.next.y !== re.y && pe < (re.next.x - re.x) * (ze - re.y) / (re.next.y - re.y) + re.x && (fe = !fe), re = re.next;\n                    while (re !== F3);\n                    return fe;\n                  })(R, A3) && (de(R.prev, R, A3.prev) || de(R, A3.prev, A3)) || ne(R, A3) && de(R.prev, R, R.next) > 0 && de(A3.prev, A3, A3.next) > 0);\n                }\n                function de(R, A3, F3) {\n                  return (A3.y - R.y) * (F3.x - A3.x) - (A3.x - R.x) * (F3.y - A3.y);\n                }\n                function ne(R, A3) {\n                  return R.x === A3.x && R.y === A3.y;\n                }\n                function we(R, A3, F3, W) {\n                  let re = ft(de(R, A3, F3)), fe = ft(de(R, A3, W)), pe = ft(de(F3, W, R)), ze = ft(de(F3, W, A3));\n                  return re !== fe && pe !== ze || !(re !== 0 || !Ue(R, F3, A3)) || !(fe !== 0 || !Ue(R, W, A3)) || !(pe !== 0 || !Ue(F3, R, W)) || !(ze !== 0 || !Ue(F3, A3, W));\n                }\n                function Ue(R, A3, F3) {\n                  return A3.x <= Math.max(R.x, F3.x) && A3.x >= Math.min(R.x, F3.x) && A3.y <= Math.max(R.y, F3.y) && A3.y >= Math.min(R.y, F3.y);\n                }\n                function ft(R) {\n                  return R > 0 ? 1 : R < 0 ? -1 : 0;\n                }\n                function Xt(R, A3) {\n                  return de(R.prev, R, R.next) < 0 ? de(R, A3, R.next) >= 0 && de(R, R.prev, A3) >= 0 : de(R, A3, R.prev) < 0 || de(R, R.next, A3) < 0;\n                }\n                function hr(R, A3) {\n                  let F3 = Qe(R.i, R.x, R.y), W = Qe(A3.i, A3.x, A3.y), re = R.next, fe = A3.prev;\n                  return R.next = A3, A3.prev = R, F3.next = re, re.prev = F3, W.next = F3, F3.prev = W, fe.next = W, W.prev = fe, W;\n                }\n                function qt(R, A3, F3, W) {\n                  let re = Qe(R, A3, F3);\n                  return W ? (re.next = W.next, re.prev = W, W.next.prev = re, W.next = re) : (re.prev = re, re.next = re), re;\n                }\n                function Ve(R) {\n                  R.next.prev = R.prev, R.prev.next = R.next, R.prevZ && (R.prevZ.nextZ = R.nextZ), R.nextZ && (R.nextZ.prevZ = R.prevZ);\n                }\n                function Qe(R, A3, F3) {\n                  return { i: R, x: A3, y: F3, prev: null, next: null, z: 0, prevZ: null, nextZ: null, steiner: false };\n                }\n                function at(R, A3, F3) {\n                  let W = F3.patternDependencies, re = false;\n                  for (let fe of A3) {\n                    let pe = fe.paint.get(`${R}-pattern`);\n                    pe.isConstant() || (re = true);\n                    let ze = pe.constantOr(null);\n                    ze && (re = true, W[ze.to] = true, W[ze.from] = true);\n                  }\n                  return re;\n                }\n                function Ct(R, A3, F3, W, re) {\n                  let fe = re.patternDependencies;\n                  for (let pe of A3) {\n                    let ze = pe.paint.get(`${R}-pattern`).value;\n                    if (ze.kind !== "constant") {\n                      let Ke = ze.evaluate({ zoom: W - 1 }, F3, {}, re.availableImages), ct = ze.evaluate({ zoom: W }, F3, {}, re.availableImages), Lt = ze.evaluate({ zoom: W + 1 }, F3, {}, re.availableImages);\n                      Ke = Ke && Ke.name ? Ke.name : Ke, ct = ct && ct.name ? ct.name : ct, Lt = Lt && Lt.name ? Lt.name : Lt, fe[Ke] = true, fe[ct] = true, fe[Lt] = true, F3.patterns[pe.id] = { min: Ke, mid: ct, max: Lt };\n                    }\n                  }\n                  return F3;\n                }\n                class Ot {\n                  constructor(A3) {\n                    this.zoom = A3.zoom, this.overscaling = A3.overscaling, this.layers = A3.layers, this.layerIds = this.layers.map((F3) => F3.id), this.index = A3.index, this.hasPattern = false, this.patternFeatures = [], this.layoutVertexArray = new hl(), this.indexArray = new se(), this.indexArray2 = new Te(), this.programConfigurations = new Ms(A3.layers, A3.zoom), this.segments = new Ye(), this.segments2 = new Ye(), this.stateDependentLayerIds = this.layers.filter((F3) => F3.isStateDependent()).map((F3) => F3.id);\n                  }\n                  populate(A3, F3, W) {\n                    this.hasPattern = at("fill", this.layers, F3);\n                    let re = this.layers[0].layout.get("fill-sort-key"), fe = !re.isConstant(), pe = [];\n                    for (let { feature: ze, id: Ke, index: ct, sourceLayerIndex: Lt } of A3) {\n                      let $t = this.layers[0]._featureFilter.needGeometry, fr = Sl(ze, $t);\n                      if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), fr, W)) continue;\n                      let mr = fe ? re.evaluate(fr, {}, W, F3.availableImages) : void 0, Pr = { id: Ke, properties: ze.properties, type: ze.type, sourceLayerIndex: Lt, index: ct, geometry: $t ? fr.geometry : $s(ze), patterns: {}, sortKey: mr };\n                      pe.push(Pr);\n                    }\n                    fe && pe.sort((ze, Ke) => ze.sortKey - Ke.sortKey);\n                    for (let ze of pe) {\n                      let { geometry: Ke, index: ct, sourceLayerIndex: Lt } = ze;\n                      if (this.hasPattern) {\n                        let $t = Ct("fill", this.layers, ze, this.zoom, F3);\n                        this.patternFeatures.push($t);\n                      } else this.addFeature(ze, Ke, ct, W, {});\n                      F3.featureIndex.insert(A3[ct].feature, Ke, ct, Lt, this.index);\n                    }\n                  }\n                  update(A3, F3, W) {\n                    this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(A3, F3, this.stateDependentLayers, W);\n                  }\n                  addFeatures(A3, F3, W) {\n                    for (let re of this.patternFeatures) this.addFeature(re, re.geometry, re.index, F3, W);\n                  }\n                  isEmpty() {\n                    return this.layoutVertexArray.length === 0;\n                  }\n                  uploadPending() {\n                    return !this.uploaded || this.programConfigurations.needsUpload;\n                  }\n                  upload(A3) {\n                    this.uploaded || (this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, Ml), this.indexBuffer = A3.createIndexBuffer(this.indexArray), this.indexBuffer2 = A3.createIndexBuffer(this.indexArray2)), this.programConfigurations.upload(A3), this.uploaded = true;\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.indexBuffer2.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.segments2.destroy());\n                  }\n                  addFeature(A3, F3, W, re, fe) {\n                    for (let pe of Cf(F3, 500)) {\n                      let ze = 0;\n                      for (let mr of pe) ze += mr.length;\n                      let Ke = this.segments.prepareSegment(ze, this.layoutVertexArray, this.indexArray), ct = Ke.vertexLength, Lt = [], $t = [];\n                      for (let mr of pe) {\n                        if (mr.length === 0) continue;\n                        mr !== pe[0] && $t.push(Lt.length / 2);\n                        let Pr = this.segments2.prepareSegment(mr.length, this.layoutVertexArray, this.indexArray2), zr = Pr.vertexLength;\n                        this.layoutVertexArray.emplaceBack(mr[0].x, mr[0].y), this.indexArray2.emplaceBack(zr + mr.length - 1, zr), Lt.push(mr[0].x), Lt.push(mr[0].y);\n                        for (let ui = 1; ui < mr.length; ui++) this.layoutVertexArray.emplaceBack(mr[ui].x, mr[ui].y), this.indexArray2.emplaceBack(zr + ui - 1, zr + ui), Lt.push(mr[ui].x), Lt.push(mr[ui].y);\n                        Pr.vertexLength += mr.length, Pr.primitiveLength += mr.length;\n                      }\n                      let fr = zo(Lt, $t);\n                      for (let mr = 0; mr < fr.length; mr += 3) this.indexArray.emplaceBack(ct + fr[mr], ct + fr[mr + 1], ct + fr[mr + 2]);\n                      Ke.vertexLength += ze, Ke.primitiveLength += fr.length / 3;\n                    }\n                    this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, A3, W, fe, re);\n                  }\n                }\n                let Rt, Bt;\n                Fi("FillBucket", Ot, { omit: ["layers", "patternFeatures"] });\n                var Dt = { get paint() {\n                  return Bt = Bt || new ue({ "fill-antialias": new Ua(ce.paint_fill["fill-antialias"]), "fill-opacity": new oo(ce.paint_fill["fill-opacity"]), "fill-color": new oo(ce.paint_fill["fill-color"]), "fill-outline-color": new oo(ce.paint_fill["fill-outline-color"]), "fill-translate": new Ua(ce.paint_fill["fill-translate"]), "fill-translate-anchor": new Ua(ce.paint_fill["fill-translate-anchor"]), "fill-pattern": new Vc(ce.paint_fill["fill-pattern"]) });\n                }, get layout() {\n                  return Rt = Rt || new ue({ "fill-sort-key": new oo(ce.layout_fill["fill-sort-key"]) });\n                } };\n                class yt extends B4 {\n                  constructor(A3) {\n                    super(A3, Dt);\n                  }\n                  recalculate(A3, F3) {\n                    super.recalculate(A3, F3);\n                    let W = this.paint._values["fill-outline-color"];\n                    W.value.kind === "constant" && W.value.value === void 0 && (this.paint._values["fill-outline-color"] = this.paint._values["fill-color"]);\n                  }\n                  createBucket(A3) {\n                    return new Ot(A3);\n                  }\n                  queryRadius() {\n                    return Hn(this.paint.get("fill-translate"));\n                  }\n                  queryIntersectsFeature(A3, F3, W, re, fe, pe, ze) {\n                    return bt(en(A3, this.paint.get("fill-translate"), this.paint.get("fill-translate-anchor"), pe.angle, ze), re);\n                  }\n                  isTileClipped() {\n                    return true;\n                  }\n                }\n                let Pt = qe([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_normal_ed", components: 4, type: "Int16" }], 4), ht = qe([{ name: "a_centroid", components: 2, type: "Int16" }], 4), { members: ur } = Pt;\n                var br = {}, Ur = s3, Di = fi;\n                function fi(R, A3, F3, W, re) {\n                  this.properties = {}, this.extent = F3, this.type = 0, this._pbf = R, this._geometry = -1, this._keys = W, this._values = re, R.readFields(Ti, this, A3);\n                }\n                function Ti(R, A3, F3) {\n                  R == 1 ? A3.id = F3.readVarint() : R == 2 ? (function(W, re) {\n                    for (var fe = W.readVarint() + W.pos; W.pos < fe; ) {\n                      var pe = re._keys[W.readVarint()], ze = re._values[W.readVarint()];\n                      re.properties[pe] = ze;\n                    }\n                  })(F3, A3) : R == 3 ? A3.type = F3.readVarint() : R == 4 && (A3._geometry = F3.pos);\n                }\n                function gn(R) {\n                  for (var A3, F3, W = 0, re = 0, fe = R.length, pe = fe - 1; re < fe; pe = re++) W += ((F3 = R[pe]).x - (A3 = R[re]).x) * (A3.y + F3.y);\n                  return W;\n                }\n                fi.types = ["Unknown", "Point", "LineString", "Polygon"], fi.prototype.loadGeometry = function() {\n                  var R = this._pbf;\n                  R.pos = this._geometry;\n                  for (var A3, F3 = R.readVarint() + R.pos, W = 1, re = 0, fe = 0, pe = 0, ze = []; R.pos < F3; ) {\n                    if (re <= 0) {\n                      var Ke = R.readVarint();\n                      W = 7 & Ke, re = Ke >> 3;\n                    }\n                    if (re--, W === 1 || W === 2) fe += R.readSVarint(), pe += R.readSVarint(), W === 1 && (A3 && ze.push(A3), A3 = []), A3.push(new Ur(fe, pe));\n                    else {\n                      if (W !== 7) throw new Error("unknown command " + W);\n                      A3 && A3.push(A3[0].clone());\n                    }\n                  }\n                  return A3 && ze.push(A3), ze;\n                }, fi.prototype.bbox = function() {\n                  var R = this._pbf;\n                  R.pos = this._geometry;\n                  for (var A3 = R.readVarint() + R.pos, F3 = 1, W = 0, re = 0, fe = 0, pe = 1 / 0, ze = -1 / 0, Ke = 1 / 0, ct = -1 / 0; R.pos < A3; ) {\n                    if (W <= 0) {\n                      var Lt = R.readVarint();\n                      F3 = 7 & Lt, W = Lt >> 3;\n                    }\n                    if (W--, F3 === 1 || F3 === 2) (re += R.readSVarint()) < pe && (pe = re), re > ze && (ze = re), (fe += R.readSVarint()) < Ke && (Ke = fe), fe > ct && (ct = fe);\n                    else if (F3 !== 7) throw new Error("unknown command " + F3);\n                  }\n                  return [pe, Ke, ze, ct];\n                }, fi.prototype.toGeoJSON = function(R, A3, F3) {\n                  var W, re, fe = this.extent * Math.pow(2, F3), pe = this.extent * R, ze = this.extent * A3, Ke = this.loadGeometry(), ct = fi.types[this.type];\n                  function Lt(mr) {\n                    for (var Pr = 0; Pr < mr.length; Pr++) {\n                      var zr = mr[Pr];\n                      mr[Pr] = [360 * (zr.x + pe) / fe - 180, 360 / Math.PI * Math.atan(Math.exp((180 - 360 * (zr.y + ze) / fe) * Math.PI / 180)) - 90];\n                    }\n                  }\n                  switch (this.type) {\n                    case 1:\n                      var $t = [];\n                      for (W = 0; W < Ke.length; W++) $t[W] = Ke[W][0];\n                      Lt(Ke = $t);\n                      break;\n                    case 2:\n                      for (W = 0; W < Ke.length; W++) Lt(Ke[W]);\n                      break;\n                    case 3:\n                      for (Ke = (function(mr) {\n                        var Pr = mr.length;\n                        if (Pr <= 1) return [mr];\n                        for (var zr, ui, yi = [], vn = 0; vn < Pr; vn++) {\n                          var zi = gn(mr[vn]);\n                          zi !== 0 && (ui === void 0 && (ui = zi < 0), ui === zi < 0 ? (zr && yi.push(zr), zr = [mr[vn]]) : zr.push(mr[vn]));\n                        }\n                        return zr && yi.push(zr), yi;\n                      })(Ke), W = 0; W < Ke.length; W++) for (re = 0; re < Ke[W].length; re++) Lt(Ke[W][re]);\n                  }\n                  Ke.length === 1 ? Ke = Ke[0] : ct = "Multi" + ct;\n                  var fr = { type: "Feature", geometry: { type: ct, coordinates: Ke }, properties: this.properties };\n                  return "id" in this && (fr.id = this.id), fr;\n                };\n                var rn = Di, Ci = Bi;\n                function Bi(R, A3) {\n                  this.version = 1, this.name = null, this.extent = 4096, this.length = 0, this._pbf = R, this._keys = [], this._values = [], this._features = [], R.readFields(Gi, this, A3), this.length = this._features.length;\n                }\n                function Gi(R, A3, F3) {\n                  R === 15 ? A3.version = F3.readVarint() : R === 1 ? A3.name = F3.readString() : R === 5 ? A3.extent = F3.readVarint() : R === 2 ? A3._features.push(F3.pos) : R === 3 ? A3._keys.push(F3.readString()) : R === 4 && A3._values.push((function(W) {\n                    for (var re = null, fe = W.readVarint() + W.pos; W.pos < fe; ) {\n                      var pe = W.readVarint() >> 3;\n                      re = pe === 1 ? W.readString() : pe === 2 ? W.readFloat() : pe === 3 ? W.readDouble() : pe === 4 ? W.readVarint64() : pe === 5 ? W.readVarint() : pe === 6 ? W.readSVarint() : pe === 7 ? W.readBoolean() : null;\n                    }\n                    return re;\n                  })(F3));\n                }\n                Bi.prototype.feature = function(R) {\n                  if (R < 0 || R >= this._features.length) throw new Error("feature index out of bounds");\n                  this._pbf.pos = this._features[R];\n                  var A3 = this._pbf.readVarint() + this._pbf.pos;\n                  return new rn(this._pbf, A3, this.extent, this._keys, this._values);\n                };\n                var sn = Ci;\n                function zn(R, A3, F3) {\n                  if (R === 3) {\n                    var W = new sn(F3, F3.readVarint() + F3.pos);\n                    W.length && (A3[W.name] = W);\n                  }\n                }\n                br.VectorTile = function(R, A3) {\n                  this.layers = R.readFields(zn, {}, A3);\n                }, br.VectorTileFeature = Di, br.VectorTileLayer = Ci;\n                let Ja = br.VectorTileFeature.types, co = Math.pow(2, 13);\n                function ts(R, A3, F3, W, re, fe, pe, ze) {\n                  R.emplaceBack(A3, F3, 2 * Math.floor(W * co) + pe, re * co * 2, fe * co * 2, Math.round(ze));\n                }\n                class so {\n                  constructor(A3) {\n                    this.zoom = A3.zoom, this.overscaling = A3.overscaling, this.layers = A3.layers, this.layerIds = this.layers.map((F3) => F3.id), this.index = A3.index, this.hasPattern = false, this.layoutVertexArray = new Ul(), this.centroidVertexArray = new wo(), this.indexArray = new se(), this.programConfigurations = new Ms(A3.layers, A3.zoom), this.segments = new Ye(), this.stateDependentLayerIds = this.layers.filter((F3) => F3.isStateDependent()).map((F3) => F3.id);\n                  }\n                  populate(A3, F3, W) {\n                    this.features = [], this.hasPattern = at("fill-extrusion", this.layers, F3);\n                    for (let { feature: re, id: fe, index: pe, sourceLayerIndex: ze } of A3) {\n                      let Ke = this.layers[0]._featureFilter.needGeometry, ct = Sl(re, Ke);\n                      if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), ct, W)) continue;\n                      let Lt = { id: fe, sourceLayerIndex: ze, index: pe, geometry: Ke ? ct.geometry : $s(re), properties: re.properties, type: re.type, patterns: {} };\n                      this.hasPattern ? this.features.push(Ct("fill-extrusion", this.layers, Lt, this.zoom, F3)) : this.addFeature(Lt, Lt.geometry, pe, W, {}), F3.featureIndex.insert(re, Lt.geometry, pe, ze, this.index, true);\n                    }\n                  }\n                  addFeatures(A3, F3, W) {\n                    for (let re of this.features) {\n                      let { geometry: fe } = re;\n                      this.addFeature(re, fe, re.index, F3, W);\n                    }\n                  }\n                  update(A3, F3, W) {\n                    this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(A3, F3, this.stateDependentLayers, W);\n                  }\n                  isEmpty() {\n                    return this.layoutVertexArray.length === 0 && this.centroidVertexArray.length === 0;\n                  }\n                  uploadPending() {\n                    return !this.uploaded || this.programConfigurations.needsUpload;\n                  }\n                  upload(A3) {\n                    this.uploaded || (this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, ur), this.centroidVertexBuffer = A3.createVertexBuffer(this.centroidVertexArray, ht.members, true), this.indexBuffer = A3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(A3), this.uploaded = true;\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.centroidVertexBuffer.destroy());\n                  }\n                  addFeature(A3, F3, W, re, fe) {\n                    for (let pe of Cf(F3, 500)) {\n                      let ze = { x: 0, y: 0, vertexCount: 0 }, Ke = 0;\n                      for (let Pr of pe) Ke += Pr.length;\n                      let ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray);\n                      for (let Pr of pe) {\n                        if (Pr.length === 0 || ms(Pr)) continue;\n                        let zr = 0;\n                        for (let ui = 0; ui < Pr.length; ui++) {\n                          let yi = Pr[ui];\n                          if (ui >= 1) {\n                            let vn = Pr[ui - 1];\n                            if (!Zo(yi, vn)) {\n                              ct.vertexLength + 4 > Ye.MAX_VERTEX_ARRAY_LENGTH && (ct = this.segments.prepareSegment(4, this.layoutVertexArray, this.indexArray));\n                              let zi = yi.sub(vn)._perp()._unit(), un = vn.dist(yi);\n                              zr + un > 32768 && (zr = 0), ts(this.layoutVertexArray, yi.x, yi.y, zi.x, zi.y, 0, 0, zr), ts(this.layoutVertexArray, yi.x, yi.y, zi.x, zi.y, 0, 1, zr), ze.x += 2 * yi.x, ze.y += 2 * yi.y, ze.vertexCount += 2, zr += un, ts(this.layoutVertexArray, vn.x, vn.y, zi.x, zi.y, 0, 0, zr), ts(this.layoutVertexArray, vn.x, vn.y, zi.x, zi.y, 0, 1, zr), ze.x += 2 * vn.x, ze.y += 2 * vn.y, ze.vertexCount += 2;\n                              let Tn = ct.vertexLength;\n                              this.indexArray.emplaceBack(Tn, Tn + 2, Tn + 1), this.indexArray.emplaceBack(Tn + 1, Tn + 2, Tn + 3), ct.vertexLength += 4, ct.primitiveLength += 2;\n                            }\n                          }\n                        }\n                      }\n                      if (ct.vertexLength + Ke > Ye.MAX_VERTEX_ARRAY_LENGTH && (ct = this.segments.prepareSegment(Ke, this.layoutVertexArray, this.indexArray)), Ja[A3.type] !== "Polygon") continue;\n                      let Lt = [], $t = [], fr = ct.vertexLength;\n                      for (let Pr of pe) if (Pr.length !== 0) {\n                        Pr !== pe[0] && $t.push(Lt.length / 2);\n                        for (let zr = 0; zr < Pr.length; zr++) {\n                          let ui = Pr[zr];\n                          ts(this.layoutVertexArray, ui.x, ui.y, 0, 0, 1, 1, 0), ze.x += ui.x, ze.y += ui.y, ze.vertexCount += 1, Lt.push(ui.x), Lt.push(ui.y);\n                        }\n                      }\n                      let mr = zo(Lt, $t);\n                      for (let Pr = 0; Pr < mr.length; Pr += 3) this.indexArray.emplaceBack(fr + mr[Pr], fr + mr[Pr + 2], fr + mr[Pr + 1]);\n                      ct.primitiveLength += mr.length / 3, ct.vertexLength += Ke;\n                      for (let Pr = 0; Pr < ze.vertexCount; Pr++) {\n                        let zr = Math.floor(ze.x / ze.vertexCount), ui = Math.floor(ze.y / ze.vertexCount);\n                        this.centroidVertexArray.emplaceBack(zr, ui);\n                      }\n                    }\n                    this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, A3, W, fe, re);\n                  }\n                }\n                function Zo(R, A3) {\n                  return R.x === A3.x && (R.x < 0 || R.x > ja) || R.y === A3.y && (R.y < 0 || R.y > ja);\n                }\n                function ms(R) {\n                  return R.every((A3) => A3.x < 0) || R.every((A3) => A3.x > ja) || R.every((A3) => A3.y < 0) || R.every((A3) => A3.y > ja);\n                }\n                let ou;\n                Fi("FillExtrusionBucket", so, { omit: ["layers", "features"] });\n                var Cv = { get paint() {\n                  return ou = ou || new ue({ "fill-extrusion-opacity": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-opacity"]), "fill-extrusion-color": new oo(ce["paint_fill-extrusion"]["fill-extrusion-color"]), "fill-extrusion-translate": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-translate"]), "fill-extrusion-translate-anchor": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]), "fill-extrusion-pattern": new Vc(ce["paint_fill-extrusion"]["fill-extrusion-pattern"]), "fill-extrusion-height": new oo(ce["paint_fill-extrusion"]["fill-extrusion-height"]), "fill-extrusion-base": new oo(ce["paint_fill-extrusion"]["fill-extrusion-base"]), "fill-extrusion-vertical-gradient": new Ua(ce["paint_fill-extrusion"]["fill-extrusion-vertical-gradient"]) });\n                } };\n                class Lv extends B4 {\n                  constructor(A3) {\n                    super(A3, Cv);\n                  }\n                  createBucket(A3) {\n                    return new so(A3);\n                  }\n                  queryRadius() {\n                    return Hn(this.paint.get("fill-extrusion-translate"));\n                  }\n                  is3D() {\n                    return true;\n                  }\n                  queryIntersectsFeature(A3, F3, W, re, fe, pe, ze, Ke) {\n                    let ct = en(A3, this.paint.get("fill-extrusion-translate"), this.paint.get("fill-extrusion-translate-anchor"), pe.angle, ze), Lt = this.paint.get("fill-extrusion-height").evaluate(F3, W), $t = this.paint.get("fill-extrusion-base").evaluate(F3, W), fr = (function(Pr, zr, ui, yi) {\n                      let vn = [];\n                      for (let zi of Pr) {\n                        let un = [zi.x, zi.y, 0, 1];\n                        Bn(un, un, zr), vn.push(new u4(un[0] / un[3], un[1] / un[3]));\n                      }\n                      return vn;\n                    })(ct, Ke), mr = (function(Pr, zr, ui, yi) {\n                      let vn = [], zi = [], un = yi[8] * zr, Tn = yi[9] * zr, pa = yi[10] * zr, ro = yi[11] * zr, Vo = yi[8] * ui, Xa = yi[9] * ui, sa = yi[10] * ui, Mo = yi[11] * ui;\n                      for (let fo of Pr) {\n                        let lo = [], Xn = [];\n                        for (let Ro of fo) {\n                          let uo = Ro.x, $o = Ro.y, Ju = yi[0] * uo + yi[4] * $o + yi[12], qu = yi[1] * uo + yi[5] * $o + yi[13], Mh = yi[2] * uo + yi[6] * $o + yi[14], Qv = yi[3] * uo + yi[7] * $o + yi[15], ld = Mh + pa, Eh = Qv + ro, Gd = Ju + Vo, Hd = qu + Xa, jd = Mh + sa, Af = Qv + Mo, kh = new u4((Ju + un) / Eh, (qu + Tn) / Eh);\n                          kh.z = ld / Eh, lo.push(kh);\n                          let Ed = new u4(Gd / Af, Hd / Af);\n                          Ed.z = jd / Af, Xn.push(Ed);\n                        }\n                        vn.push(lo), zi.push(Xn);\n                      }\n                      return [vn, zi];\n                    })(re, $t, Lt, Ke);\n                    return (function(Pr, zr, ui) {\n                      let yi = 1 / 0;\n                      bt(ui, zr) && (yi = Kv(ui, zr[0]));\n                      for (let vn = 0; vn < zr.length; vn++) {\n                        let zi = zr[vn], un = Pr[vn];\n                        for (let Tn = 0; Tn < zi.length - 1; Tn++) {\n                          let pa = zi[Tn], ro = [pa, zi[Tn + 1], un[Tn + 1], un[Tn], pa];\n                          Sc(ui, ro) && (yi = Math.min(yi, Kv(ui, ro)));\n                        }\n                      }\n                      return yi !== 1 / 0 && yi;\n                    })(mr[0], mr[1], fr);\n                  }\n                }\n                function wd(R, A3) {\n                  return R.x * A3.x + R.y * A3.y;\n                }\n                function Kv(R, A3) {\n                  if (R.length === 1) {\n                    let F3 = 0, W = A3[F3++], re;\n                    for (; !re || W.equals(re); ) if (re = A3[F3++], !re) return 1 / 0;\n                    for (; F3 < A3.length; F3++) {\n                      let fe = A3[F3], pe = R[0], ze = re.sub(W), Ke = fe.sub(W), ct = pe.sub(W), Lt = wd(ze, ze), $t = wd(ze, Ke), fr = wd(Ke, Ke), mr = wd(ct, ze), Pr = wd(ct, Ke), zr = Lt * fr - $t * $t, ui = (fr * mr - $t * Pr) / zr, yi = (Lt * Pr - $t * mr) / zr, vn = W.z * (1 - ui - yi) + re.z * ui + fe.z * yi;\n                      if (isFinite(vn)) return vn;\n                    }\n                    return 1 / 0;\n                  }\n                  {\n                    let F3 = 1 / 0;\n                    for (let W of A3) F3 = Math.min(F3, W.z);\n                    return F3;\n                  }\n                }\n                let cg = qe([{ name: "a_pos_normal", components: 2, type: "Int16" }, { name: "a_data", components: 4, type: "Uint8" }], 4), { members: pp } = cg, Td = qe([{ name: "a_uv_x", components: 1, type: "Float32" }, { name: "a_split_index", components: 1, type: "Float32" }]), { members: gp } = Td, Vd = br.VectorTileFeature.types, Ad = Math.cos(Math.PI / 180 * 37.5), Pv = Math.pow(2, 14) / 0.5;\n                class Jv {\n                  constructor(A3) {\n                    this.zoom = A3.zoom, this.overscaling = A3.overscaling, this.layers = A3.layers, this.layerIds = this.layers.map((F3) => F3.id), this.index = A3.index, this.hasPattern = false, this.patternFeatures = [], this.lineClipsArray = [], this.gradients = {}, this.layers.forEach((F3) => {\n                      this.gradients[F3.id] = {};\n                    }), this.layoutVertexArray = new Lu(), this.layoutVertexArray2 = new au(), this.indexArray = new se(), this.programConfigurations = new Ms(A3.layers, A3.zoom), this.segments = new Ye(), this.maxLineLength = 0, this.stateDependentLayerIds = this.layers.filter((F3) => F3.isStateDependent()).map((F3) => F3.id);\n                  }\n                  populate(A3, F3, W) {\n                    this.hasPattern = at("line", this.layers, F3);\n                    let re = this.layers[0].layout.get("line-sort-key"), fe = !re.isConstant(), pe = [];\n                    for (let { feature: ze, id: Ke, index: ct, sourceLayerIndex: Lt } of A3) {\n                      let $t = this.layers[0]._featureFilter.needGeometry, fr = Sl(ze, $t);\n                      if (!this.layers[0]._featureFilter.filter(new rs(this.zoom), fr, W)) continue;\n                      let mr = fe ? re.evaluate(fr, {}, W) : void 0, Pr = { id: Ke, properties: ze.properties, type: ze.type, sourceLayerIndex: Lt, index: ct, geometry: $t ? fr.geometry : $s(ze), patterns: {}, sortKey: mr };\n                      pe.push(Pr);\n                    }\n                    fe && pe.sort((ze, Ke) => ze.sortKey - Ke.sortKey);\n                    for (let ze of pe) {\n                      let { geometry: Ke, index: ct, sourceLayerIndex: Lt } = ze;\n                      if (this.hasPattern) {\n                        let $t = Ct("line", this.layers, ze, this.zoom, F3);\n                        this.patternFeatures.push($t);\n                      } else this.addFeature(ze, Ke, ct, W, {});\n                      F3.featureIndex.insert(A3[ct].feature, Ke, ct, Lt, this.index);\n                    }\n                  }\n                  update(A3, F3, W) {\n                    this.stateDependentLayers.length && this.programConfigurations.updatePaintArrays(A3, F3, this.stateDependentLayers, W);\n                  }\n                  addFeatures(A3, F3, W) {\n                    for (let re of this.patternFeatures) this.addFeature(re, re.geometry, re.index, F3, W);\n                  }\n                  isEmpty() {\n                    return this.layoutVertexArray.length === 0;\n                  }\n                  uploadPending() {\n                    return !this.uploaded || this.programConfigurations.needsUpload;\n                  }\n                  upload(A3) {\n                    this.uploaded || (this.layoutVertexArray2.length !== 0 && (this.layoutVertexBuffer2 = A3.createVertexBuffer(this.layoutVertexArray2, gp)), this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, pp), this.indexBuffer = A3.createIndexBuffer(this.indexArray)), this.programConfigurations.upload(A3), this.uploaded = true;\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy());\n                  }\n                  lineFeatureClips(A3) {\n                    if (A3.properties && Object.prototype.hasOwnProperty.call(A3.properties, "mapbox_clip_start") && Object.prototype.hasOwnProperty.call(A3.properties, "mapbox_clip_end")) return { start: +A3.properties.mapbox_clip_start, end: +A3.properties.mapbox_clip_end };\n                  }\n                  addFeature(A3, F3, W, re, fe) {\n                    let pe = this.layers[0].layout, ze = pe.get("line-join").evaluate(A3, {}), Ke = pe.get("line-cap"), ct = pe.get("line-miter-limit"), Lt = pe.get("line-round-limit");\n                    this.lineClips = this.lineFeatureClips(A3);\n                    for (let $t of F3) this.addLine($t, A3, ze, Ke, ct, Lt);\n                    this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length, A3, W, fe, re);\n                  }\n                  addLine(A3, F3, W, re, fe, pe) {\n                    if (this.distance = 0, this.scaledDistance = 0, this.totalDistance = 0, this.lineClips) {\n                      this.lineClipsArray.push(this.lineClips);\n                      for (let yi = 0; yi < A3.length - 1; yi++) this.totalDistance += A3[yi].dist(A3[yi + 1]);\n                      this.updateScaledDistance(), this.maxLineLength = Math.max(this.maxLineLength, this.totalDistance);\n                    }\n                    let ze = Vd[F3.type] === "Polygon", Ke = A3.length;\n                    for (; Ke >= 2 && A3[Ke - 1].equals(A3[Ke - 2]); ) Ke--;\n                    let ct = 0;\n                    for (; ct < Ke - 1 && A3[ct].equals(A3[ct + 1]); ) ct++;\n                    if (Ke < (ze ? 3 : 2)) return;\n                    W === "bevel" && (fe = 1.05);\n                    let Lt = this.overscaling <= 16 ? 15 * ja / (512 * this.overscaling) : 0, $t = this.segments.prepareSegment(10 * Ke, this.layoutVertexArray, this.indexArray), fr, mr, Pr, zr, ui;\n                    this.e1 = this.e2 = -1, ze && (fr = A3[Ke - 2], ui = A3[ct].sub(fr)._unit()._perp());\n                    for (let yi = ct; yi < Ke; yi++) {\n                      if (Pr = yi === Ke - 1 ? ze ? A3[ct + 1] : void 0 : A3[yi + 1], Pr && A3[yi].equals(Pr)) continue;\n                      ui && (zr = ui), fr && (mr = fr), fr = A3[yi], ui = Pr ? Pr.sub(fr)._unit()._perp() : zr, zr = zr || ui;\n                      let vn = zr.add(ui);\n                      vn.x === 0 && vn.y === 0 || vn._unit();\n                      let zi = zr.x * ui.x + zr.y * ui.y, un = vn.x * ui.x + vn.y * ui.y, Tn = un !== 0 ? 1 / un : 1 / 0, pa = 2 * Math.sqrt(2 - 2 * un), ro = un < Ad && mr && Pr, Vo = zr.x * ui.y - zr.y * ui.x > 0;\n                      if (ro && yi > ct) {\n                        let Mo = fr.dist(mr);\n                        if (Mo > 2 * Lt) {\n                          let fo = fr.sub(fr.sub(mr)._mult(Lt / Mo)._round());\n                          this.updateDistance(mr, fo), this.addCurrentVertex(fo, zr, 0, 0, $t), mr = fo;\n                        }\n                      }\n                      let Xa = mr && Pr, sa = Xa ? W : ze ? "butt" : re;\n                      if (Xa && sa === "round" && (Tn < pe ? sa = "miter" : Tn <= 2 && (sa = "fakeround")), sa === "miter" && Tn > fe && (sa = "bevel"), sa === "bevel" && (Tn > 2 && (sa = "flipbevel"), Tn < fe && (sa = "miter")), mr && this.updateDistance(mr, fr), sa === "miter") vn._mult(Tn), this.addCurrentVertex(fr, vn, 0, 0, $t);\n                      else if (sa === "flipbevel") {\n                        if (Tn > 100) vn = ui.mult(-1);\n                        else {\n                          let Mo = Tn * zr.add(ui).mag() / zr.sub(ui).mag();\n                          vn._perp()._mult(Mo * (Vo ? -1 : 1));\n                        }\n                        this.addCurrentVertex(fr, vn, 0, 0, $t), this.addCurrentVertex(fr, vn.mult(-1), 0, 0, $t);\n                      } else if (sa === "bevel" || sa === "fakeround") {\n                        let Mo = -Math.sqrt(Tn * Tn - 1), fo = Vo ? Mo : 0, lo = Vo ? 0 : Mo;\n                        if (mr && this.addCurrentVertex(fr, zr, fo, lo, $t), sa === "fakeround") {\n                          let Xn = Math.round(180 * pa / Math.PI / 20);\n                          for (let Ro = 1; Ro < Xn; Ro++) {\n                            let uo = Ro / Xn;\n                            if (uo !== 0.5) {\n                              let Ju = uo - 0.5;\n                              uo += uo * Ju * (uo - 1) * ((1.0904 + zi * (zi * (3.55645 - 1.43519 * zi) - 3.2452)) * Ju * Ju + (0.848013 + zi * (0.215638 * zi - 1.06021)));\n                            }\n                            let $o = ui.sub(zr)._mult(uo)._add(zr)._unit()._mult(Vo ? -1 : 1);\n                            this.addHalfVertex(fr, $o.x, $o.y, false, Vo, 0, $t);\n                          }\n                        }\n                        Pr && this.addCurrentVertex(fr, ui, -fo, -lo, $t);\n                      } else if (sa === "butt") this.addCurrentVertex(fr, vn, 0, 0, $t);\n                      else if (sa === "square") {\n                        let Mo = mr ? 1 : -1;\n                        this.addCurrentVertex(fr, vn, Mo, Mo, $t);\n                      } else sa === "round" && (mr && (this.addCurrentVertex(fr, zr, 0, 0, $t), this.addCurrentVertex(fr, zr, 1, 1, $t, true)), Pr && (this.addCurrentVertex(fr, ui, -1, -1, $t, true), this.addCurrentVertex(fr, ui, 0, 0, $t)));\n                      if (ro && yi < Ke - 1) {\n                        let Mo = fr.dist(Pr);\n                        if (Mo > 2 * Lt) {\n                          let fo = fr.add(Pr.sub(fr)._mult(Lt / Mo)._round());\n                          this.updateDistance(fr, fo), this.addCurrentVertex(fo, ui, 0, 0, $t), fr = fo;\n                        }\n                      }\n                    }\n                  }\n                  addCurrentVertex(A3, F3, W, re, fe, pe = false) {\n                    let ze = F3.y * re - F3.x, Ke = -F3.y - F3.x * re;\n                    this.addHalfVertex(A3, F3.x + F3.y * W, F3.y - F3.x * W, pe, false, W, fe), this.addHalfVertex(A3, ze, Ke, pe, true, -re, fe), this.distance > Pv / 2 && this.totalDistance === 0 && (this.distance = 0, this.updateScaledDistance(), this.addCurrentVertex(A3, F3, W, re, fe, pe));\n                  }\n                  addHalfVertex({ x: A3, y: F3 }, W, re, fe, pe, ze, Ke) {\n                    let ct = 0.5 * (this.lineClips ? this.scaledDistance * (Pv - 1) : this.scaledDistance);\n                    this.layoutVertexArray.emplaceBack((A3 << 1) + (fe ? 1 : 0), (F3 << 1) + (pe ? 1 : 0), Math.round(63 * W) + 128, Math.round(63 * re) + 128, 1 + (ze === 0 ? 0 : ze < 0 ? -1 : 1) | (63 & ct) << 2, ct >> 6), this.lineClips && this.layoutVertexArray2.emplaceBack((this.scaledDistance - this.lineClips.start) / (this.lineClips.end - this.lineClips.start), this.lineClipsArray.length);\n                    let Lt = Ke.vertexLength++;\n                    this.e1 >= 0 && this.e2 >= 0 && (this.indexArray.emplaceBack(this.e1, this.e2, Lt), Ke.primitiveLength++), pe ? this.e2 = Lt : this.e1 = Lt;\n                  }\n                  updateScaledDistance() {\n                    this.scaledDistance = this.lineClips ? this.lineClips.start + (this.lineClips.end - this.lineClips.start) * this.distance / this.totalDistance : this.distance;\n                  }\n                  updateDistance(A3, F3) {\n                    this.distance += A3.dist(F3), this.updateScaledDistance();\n                  }\n                }\n                let Iv, ay;\n                Fi("LineBucket", Jv, { omit: ["layers", "patternFeatures"] });\n                var fg = { get paint() {\n                  return ay = ay || new ue({ "line-opacity": new oo(ce.paint_line["line-opacity"]), "line-color": new oo(ce.paint_line["line-color"]), "line-translate": new Ua(ce.paint_line["line-translate"]), "line-translate-anchor": new Ua(ce.paint_line["line-translate-anchor"]), "line-width": new oo(ce.paint_line["line-width"]), "line-gap-width": new oo(ce.paint_line["line-gap-width"]), "line-offset": new oo(ce.paint_line["line-offset"]), "line-blur": new oo(ce.paint_line["line-blur"]), "line-dasharray": new hc(ce.paint_line["line-dasharray"]), "line-pattern": new Vc(ce.paint_line["line-pattern"]), "line-gradient": new Ku(ce.paint_line["line-gradient"]) });\n                }, get layout() {\n                  return Iv = Iv || new ue({ "line-cap": new Ua(ce.layout_line["line-cap"]), "line-join": new oo(ce.layout_line["line-join"]), "line-miter-limit": new Ua(ce.layout_line["line-miter-limit"]), "line-round-limit": new Ua(ce.layout_line["line-round-limit"]), "line-sort-key": new oo(ce.layout_line["line-sort-key"]) });\n                } };\n                class oh extends oo {\n                  possiblyEvaluate(A3, F3) {\n                    return F3 = new rs(Math.floor(F3.zoom), { now: F3.now, fadeDuration: F3.fadeDuration, zoomHistory: F3.zoomHistory, transition: F3.transition }), super.possiblyEvaluate(A3, F3);\n                  }\n                  evaluate(A3, F3, W, re) {\n                    return F3 = L3({}, F3, { zoom: Math.floor(F3.zoom) }), super.evaluate(A3, F3, W, re);\n                  }\n                }\n                let hg;\n                class oy extends B4 {\n                  constructor(A3) {\n                    super(A3, fg), this.gradientVersion = 0, hg || (hg = new oh(fg.paint.properties["line-width"].specification), hg.useIntegerZoom = true);\n                  }\n                  _handleSpecialPaintPropertyUpdate(A3) {\n                    if (A3 === "line-gradient") {\n                      let F3 = this.gradientExpression();\n                      this.stepInterpolant = !!(function(W) {\n                        return W._styleExpression !== void 0;\n                      })(F3) && F3._styleExpression.expression instanceof _n, this.gradientVersion = (this.gradientVersion + 1) % Number.MAX_SAFE_INTEGER;\n                    }\n                  }\n                  gradientExpression() {\n                    return this._transitionablePaint._values["line-gradient"].value.expression;\n                  }\n                  recalculate(A3, F3) {\n                    super.recalculate(A3, F3), this.paint._values["line-floorwidth"] = hg.possiblyEvaluate(this._transitioningPaint._values["line-width"].value, A3);\n                  }\n                  createBucket(A3) {\n                    return new Jv(A3);\n                  }\n                  queryRadius(A3) {\n                    let F3 = A3, W = jh(Ei("line-width", this, F3), Ei("line-gap-width", this, F3)), re = Ei("line-offset", this, F3);\n                    return W / 2 + Math.abs(re) + Hn(this.paint.get("line-translate"));\n                  }\n                  queryIntersectsFeature(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = en(A3, this.paint.get("line-translate"), this.paint.get("line-translate-anchor"), pe.angle, ze), ct = ze / 2 * jh(this.paint.get("line-width").evaluate(F3, W), this.paint.get("line-gap-width").evaluate(F3, W)), Lt = this.paint.get("line-offset").evaluate(F3, W);\n                    return Lt && (re = (function($t, fr) {\n                      let mr = [];\n                      for (let Pr = 0; Pr < $t.length; Pr++) {\n                        let zr = $t[Pr], ui = [];\n                        for (let yi = 0; yi < zr.length; yi++) {\n                          let vn = zr[yi - 1], zi = zr[yi], un = zr[yi + 1], Tn = yi === 0 ? new u4(0, 0) : zi.sub(vn)._unit()._perp(), pa = yi === zr.length - 1 ? new u4(0, 0) : un.sub(zi)._unit()._perp(), ro = Tn._add(pa)._unit(), Vo = ro.x * pa.x + ro.y * pa.y;\n                          Vo !== 0 && ro._mult(1 / Vo), ui.push(ro._mult(fr)._add(zi));\n                        }\n                        mr.push(ui);\n                      }\n                      return mr;\n                    })(re, Lt * ze)), (function($t, fr, mr) {\n                      for (let Pr = 0; Pr < fr.length; Pr++) {\n                        let zr = fr[Pr];\n                        if ($t.length >= 3) {\n                          for (let ui = 0; ui < zr.length; ui++) if (Ui($t, zr[ui])) return true;\n                        }\n                        if (zt($t, zr, mr)) return true;\n                      }\n                      return false;\n                    })(Ke, re, ct);\n                  }\n                  isTileClipped() {\n                    return true;\n                  }\n                }\n                function jh(R, A3) {\n                  return A3 > 0 ? A3 + 2 * R : R;\n                }\n                let im = qe([{ name: "a_pos_offset", components: 4, type: "Int16" }, { name: "a_data", components: 4, type: "Uint16" }, { name: "a_pixeloffset", components: 4, type: "Int16" }], 4), b1 = qe([{ name: "a_projected_pos", components: 3, type: "Float32" }], 4);\n                qe([{ name: "a_fade_opacity", components: 1, type: "Uint32" }], 4);\n                let w1 = qe([{ name: "a_placed", components: 2, type: "Uint8" }, { name: "a_shift", components: 2, type: "Float32" }, { name: "a_box_real", components: 2, type: "Int16" }]);\n                qe([{ type: "Int16", name: "anchorPointX" }, { type: "Int16", name: "anchorPointY" }, { type: "Int16", name: "x1" }, { type: "Int16", name: "y1" }, { type: "Int16", name: "x2" }, { type: "Int16", name: "y2" }, { type: "Uint32", name: "featureIndex" }, { type: "Uint16", name: "sourceLayerIndex" }, { type: "Uint16", name: "bucketIndex" }]);\n                let sy = qe([{ name: "a_pos", components: 2, type: "Int16" }, { name: "a_anchor_pos", components: 2, type: "Int16" }, { name: "a_extrude", components: 2, type: "Int16" }], 4), nm = qe([{ name: "a_pos", components: 2, type: "Float32" }, { name: "a_radius", components: 1, type: "Float32" }, { name: "a_flags", components: 2, type: "Int16" }], 4);\n                function am(R, A3, F3) {\n                  return R.sections.forEach((W) => {\n                    W.text = (function(re, fe, pe) {\n                      let ze = fe.layout.get("text-transform").evaluate(pe, {});\n                      return ze === "uppercase" ? re = re.toLocaleUpperCase() : ze === "lowercase" && (re = re.toLocaleLowerCase()), ys.applyArabicShaping && (re = ys.applyArabicShaping(re)), re;\n                    })(W.text, A3, F3);\n                  }), R;\n                }\n                qe([{ name: "triangle", components: 3, type: "Uint16" }]), qe([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Uint16", name: "glyphStartIndex" }, { type: "Uint16", name: "numGlyphs" }, { type: "Uint32", name: "vertexStartIndex" }, { type: "Uint32", name: "lineStartIndex" }, { type: "Uint32", name: "lineLength" }, { type: "Uint16", name: "segment" }, { type: "Uint16", name: "lowerSize" }, { type: "Uint16", name: "upperSize" }, { type: "Float32", name: "lineOffsetX" }, { type: "Float32", name: "lineOffsetY" }, { type: "Uint8", name: "writingMode" }, { type: "Uint8", name: "placedOrientation" }, { type: "Uint8", name: "hidden" }, { type: "Uint32", name: "crossTileID" }, { type: "Int16", name: "associatedIconIndex" }]), qe([{ type: "Int16", name: "anchorX" }, { type: "Int16", name: "anchorY" }, { type: "Int16", name: "rightJustifiedTextSymbolIndex" }, { type: "Int16", name: "centerJustifiedTextSymbolIndex" }, { type: "Int16", name: "leftJustifiedTextSymbolIndex" }, { type: "Int16", name: "verticalPlacedTextSymbolIndex" }, { type: "Int16", name: "placedIconSymbolIndex" }, { type: "Int16", name: "verticalPlacedIconSymbolIndex" }, { type: "Uint16", name: "key" }, { type: "Uint16", name: "textBoxStartIndex" }, { type: "Uint16", name: "textBoxEndIndex" }, { type: "Uint16", name: "verticalTextBoxStartIndex" }, { type: "Uint16", name: "verticalTextBoxEndIndex" }, { type: "Uint16", name: "iconBoxStartIndex" }, { type: "Uint16", name: "iconBoxEndIndex" }, { type: "Uint16", name: "verticalIconBoxStartIndex" }, { type: "Uint16", name: "verticalIconBoxEndIndex" }, { type: "Uint16", name: "featureIndex" }, { type: "Uint16", name: "numHorizontalGlyphVertices" }, { type: "Uint16", name: "numVerticalGlyphVertices" }, { type: "Uint16", name: "numIconVertices" }, { type: "Uint16", name: "numVerticalIconVertices" }, { type: "Uint16", name: "useRuntimeCollisionCircles" }, { type: "Uint32", name: "crossTileID" }, { type: "Float32", name: "textBoxScale" }, { type: "Float32", name: "collisionCircleDiameter" }, { type: "Uint16", name: "textAnchorOffsetStartIndex" }, { type: "Uint16", name: "textAnchorOffsetEndIndex" }]), qe([{ type: "Float32", name: "offsetX" }]), qe([{ type: "Int16", name: "x" }, { type: "Int16", name: "y" }, { type: "Int16", name: "tileUnitDistanceFromAnchor" }]), qe([{ type: "Uint16", name: "textAnchor" }, { type: "Float32", components: 2, name: "textOffset" }]);\n                let vc = { "!": "\\uFE15", "#": "\\uFF03", $: "\\uFF04", "%": "\\uFF05", "&": "\\uFF06", "(": "\\uFE35", ")": "\\uFE36", "*": "\\uFF0A", "+": "\\uFF0B", ",": "\\uFE10", "-": "\\uFE32", ".": "\\u30FB", "/": "\\uFF0F", ":": "\\uFE13", ";": "\\uFE14", "<": "\\uFE3F", "=": "\\uFF1D", ">": "\\uFE40", "?": "\\uFE16", "@": "\\uFF20", "[": "\\uFE47", "\\\\": "\\uFF3C", "]": "\\uFE48", "^": "\\uFF3E", _: "\\uFE33", "`": "\\uFF40", "{": "\\uFE37", "|": "\\u2015", "}": "\\uFE38", "~": "\\uFF5E", "\\xA2": "\\uFFE0", "\\xA3": "\\uFFE1", "\\xA5": "\\uFFE5", "\\xA6": "\\uFFE4", "\\xAC": "\\uFFE2", "\\xAF": "\\uFFE3", "\\u2013": "\\uFE32", "\\u2014": "\\uFE31", "\\u2018": "\\uFE43", "\\u2019": "\\uFE44", "\\u201C": "\\uFE41", "\\u201D": "\\uFE42", "\\u2026": "\\uFE19", "\\u2027": "\\u30FB", "\\u20A9": "\\uFFE6", "\\u3001": "\\uFE11", "\\u3002": "\\uFE12", "\\u3008": "\\uFE3F", "\\u3009": "\\uFE40", "\\u300A": "\\uFE3D", "\\u300B": "\\uFE3E", "\\u300C": "\\uFE41", "\\u300D": "\\uFE42", "\\u300E": "\\uFE43", "\\u300F": "\\uFE44", "\\u3010": "\\uFE3B", "\\u3011": "\\uFE3C", "\\u3014": "\\uFE39", "\\u3015": "\\uFE3A", "\\u3016": "\\uFE17", "\\u3017": "\\uFE18", "\\uFF01": "\\uFE15", "\\uFF08": "\\uFE35", "\\uFF09": "\\uFE36", "\\uFF0C": "\\uFE10", "\\uFF0D": "\\uFE32", "\\uFF0E": "\\u30FB", "\\uFF1A": "\\uFE13", "\\uFF1B": "\\uFE14", "\\uFF1C": "\\uFE3F", "\\uFF1E": "\\uFE40", "\\uFF1F": "\\uFE16", "\\uFF3B": "\\uFE47", "\\uFF3D": "\\uFE48", "\\uFF3F": "\\uFE33", "\\uFF5B": "\\uFE37", "\\uFF5C": "\\u2015", "\\uFF5D": "\\uFE38", "\\uFF5F": "\\uFE35", "\\uFF60": "\\uFE36", "\\uFF61": "\\uFE12", "\\uFF62": "\\uFE41", "\\uFF63": "\\uFE42" };\n                var eu = 24, Sd = wu, ly = function(R, A3, F3, W, re) {\n                  var fe, pe, ze = 8 * re - W - 1, Ke = (1 << ze) - 1, ct = Ke >> 1, Lt = -7, $t = F3 ? re - 1 : 0, fr = F3 ? -1 : 1, mr = R[A3 + $t];\n                  for ($t += fr, fe = mr & (1 << -Lt) - 1, mr >>= -Lt, Lt += ze; Lt > 0; fe = 256 * fe + R[A3 + $t], $t += fr, Lt -= 8) ;\n                  for (pe = fe & (1 << -Lt) - 1, fe >>= -Lt, Lt += W; Lt > 0; pe = 256 * pe + R[A3 + $t], $t += fr, Lt -= 8) ;\n                  if (fe === 0) fe = 1 - ct;\n                  else {\n                    if (fe === Ke) return pe ? NaN : 1 / 0 * (mr ? -1 : 1);\n                    pe += Math.pow(2, W), fe -= ct;\n                  }\n                  return (mr ? -1 : 1) * pe * Math.pow(2, fe - W);\n                }, T1 = function(R, A3, F3, W, re, fe) {\n                  var pe, ze, Ke, ct = 8 * fe - re - 1, Lt = (1 << ct) - 1, $t = Lt >> 1, fr = re === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, mr = W ? 0 : fe - 1, Pr = W ? 1 : -1, zr = A3 < 0 || A3 === 0 && 1 / A3 < 0 ? 1 : 0;\n                  for (A3 = Math.abs(A3), isNaN(A3) || A3 === 1 / 0 ? (ze = isNaN(A3) ? 1 : 0, pe = Lt) : (pe = Math.floor(Math.log(A3) / Math.LN2), A3 * (Ke = Math.pow(2, -pe)) < 1 && (pe--, Ke *= 2), (A3 += pe + $t >= 1 ? fr / Ke : fr * Math.pow(2, 1 - $t)) * Ke >= 2 && (pe++, Ke /= 2), pe + $t >= Lt ? (ze = 0, pe = Lt) : pe + $t >= 1 ? (ze = (A3 * Ke - 1) * Math.pow(2, re), pe += $t) : (ze = A3 * Math.pow(2, $t - 1) * Math.pow(2, re), pe = 0)); re >= 8; R[F3 + mr] = 255 & ze, mr += Pr, ze /= 256, re -= 8) ;\n                  for (pe = pe << re | ze, ct += re; ct > 0; R[F3 + mr] = 255 & pe, mr += Pr, pe /= 256, ct -= 8) ;\n                  R[F3 + mr - Pr] |= 128 * zr;\n                };\n                function wu(R) {\n                  this.buf = ArrayBuffer.isView && ArrayBuffer.isView(R) ? R : new Uint8Array(R || 0), this.pos = 0, this.type = 0, this.length = this.buf.length;\n                }\n                wu.Varint = 0, wu.Fixed64 = 1, wu.Bytes = 2, wu.Fixed32 = 5;\n                var Nx = 4294967296, om = 1 / Nx, kw = typeof TextDecoder == "undefined" ? null : new TextDecoder("utf-8");\n                function Rv(R) {\n                  return R.type === wu.Bytes ? R.readVarint() + R.pos : R.pos + 1;\n                }\n                function sm(R, A3, F3) {\n                  return F3 ? 4294967296 * A3 + (R >>> 0) : 4294967296 * (A3 >>> 0) + (R >>> 0);\n                }\n                function Cw(R, A3, F3) {\n                  var W = A3 <= 16383 ? 1 : A3 <= 2097151 ? 2 : A3 <= 268435455 ? 3 : Math.floor(Math.log(A3) / (7 * Math.LN2));\n                  F3.realloc(W);\n                  for (var re = F3.pos - 1; re >= R; re--) F3.buf[re + W] = F3.buf[re];\n                }\n                function Ux(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeVarint(R[F3]);\n                }\n                function q9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeSVarint(R[F3]);\n                }\n                function B9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeFloat(R[F3]);\n                }\n                function N9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeDouble(R[F3]);\n                }\n                function U9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeBoolean(R[F3]);\n                }\n                function LQ(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeFixed32(R[F3]);\n                }\n                function V9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeSFixed32(R[F3]);\n                }\n                function G9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeFixed64(R[F3]);\n                }\n                function H9(R, A3) {\n                  for (var F3 = 0; F3 < R.length; F3++) A3.writeSFixed64(R[F3]);\n                }\n                function uy(R, A3) {\n                  return (R[A3] | R[A3 + 1] << 8 | R[A3 + 2] << 16) + 16777216 * R[A3 + 3];\n                }\n                function Vx(R, A3, F3) {\n                  R[F3] = A3, R[F3 + 1] = A3 >>> 8, R[F3 + 2] = A3 >>> 16, R[F3 + 3] = A3 >>> 24;\n                }\n                function mC(R, A3) {\n                  return (R[A3] | R[A3 + 1] << 8 | R[A3 + 2] << 16) + (R[A3 + 3] << 24);\n                }\n                wu.prototype = { destroy: function() {\n                  this.buf = null;\n                }, readFields: function(R, A3, F3) {\n                  for (F3 = F3 || this.length; this.pos < F3; ) {\n                    var W = this.readVarint(), re = W >> 3, fe = this.pos;\n                    this.type = 7 & W, R(re, A3, this), this.pos === fe && this.skip(W);\n                  }\n                  return A3;\n                }, readMessage: function(R, A3) {\n                  return this.readFields(R, A3, this.readVarint() + this.pos);\n                }, readFixed32: function() {\n                  var R = uy(this.buf, this.pos);\n                  return this.pos += 4, R;\n                }, readSFixed32: function() {\n                  var R = mC(this.buf, this.pos);\n                  return this.pos += 4, R;\n                }, readFixed64: function() {\n                  var R = uy(this.buf, this.pos) + uy(this.buf, this.pos + 4) * Nx;\n                  return this.pos += 8, R;\n                }, readSFixed64: function() {\n                  var R = uy(this.buf, this.pos) + mC(this.buf, this.pos + 4) * Nx;\n                  return this.pos += 8, R;\n                }, readFloat: function() {\n                  var R = ly(this.buf, this.pos, true, 23, 4);\n                  return this.pos += 4, R;\n                }, readDouble: function() {\n                  var R = ly(this.buf, this.pos, true, 52, 8);\n                  return this.pos += 8, R;\n                }, readVarint: function(R) {\n                  var A3, F3, W = this.buf;\n                  return A3 = 127 & (F3 = W[this.pos++]), F3 < 128 ? A3 : (A3 |= (127 & (F3 = W[this.pos++])) << 7, F3 < 128 ? A3 : (A3 |= (127 & (F3 = W[this.pos++])) << 14, F3 < 128 ? A3 : (A3 |= (127 & (F3 = W[this.pos++])) << 21, F3 < 128 ? A3 : (function(re, fe, pe) {\n                    var ze, Ke, ct = pe.buf;\n                    if (ze = (112 & (Ke = ct[pe.pos++])) >> 4, Ke < 128 || (ze |= (127 & (Ke = ct[pe.pos++])) << 3, Ke < 128) || (ze |= (127 & (Ke = ct[pe.pos++])) << 10, Ke < 128) || (ze |= (127 & (Ke = ct[pe.pos++])) << 17, Ke < 128) || (ze |= (127 & (Ke = ct[pe.pos++])) << 24, Ke < 128) || (ze |= (1 & (Ke = ct[pe.pos++])) << 31, Ke < 128)) return sm(re, ze, fe);\n                    throw new Error("Expected varint not more than 10 bytes");\n                  })(A3 |= (15 & (F3 = W[this.pos])) << 28, R, this))));\n                }, readVarint64: function() {\n                  return this.readVarint(true);\n                }, readSVarint: function() {\n                  var R = this.readVarint();\n                  return R % 2 == 1 ? (R + 1) / -2 : R / 2;\n                }, readBoolean: function() {\n                  return !!this.readVarint();\n                }, readString: function() {\n                  var R = this.readVarint() + this.pos, A3 = this.pos;\n                  return this.pos = R, R - A3 >= 12 && kw ? (function(F3, W, re) {\n                    return kw.decode(F3.subarray(W, re));\n                  })(this.buf, A3, R) : (function(F3, W, re) {\n                    for (var fe = "", pe = W; pe < re; ) {\n                      var ze, Ke, ct, Lt = F3[pe], $t = null, fr = Lt > 239 ? 4 : Lt > 223 ? 3 : Lt > 191 ? 2 : 1;\n                      if (pe + fr > re) break;\n                      fr === 1 ? Lt < 128 && ($t = Lt) : fr === 2 ? (192 & (ze = F3[pe + 1])) == 128 && ($t = (31 & Lt) << 6 | 63 & ze) <= 127 && ($t = null) : fr === 3 ? (Ke = F3[pe + 2], (192 & (ze = F3[pe + 1])) == 128 && (192 & Ke) == 128 && (($t = (15 & Lt) << 12 | (63 & ze) << 6 | 63 & Ke) <= 2047 || $t >= 55296 && $t <= 57343) && ($t = null)) : fr === 4 && (Ke = F3[pe + 2], ct = F3[pe + 3], (192 & (ze = F3[pe + 1])) == 128 && (192 & Ke) == 128 && (192 & ct) == 128 && (($t = (15 & Lt) << 18 | (63 & ze) << 12 | (63 & Ke) << 6 | 63 & ct) <= 65535 || $t >= 1114112) && ($t = null)), $t === null ? ($t = 65533, fr = 1) : $t > 65535 && ($t -= 65536, fe += String.fromCharCode($t >>> 10 & 1023 | 55296), $t = 56320 | 1023 & $t), fe += String.fromCharCode($t), pe += fr;\n                    }\n                    return fe;\n                  })(this.buf, A3, R);\n                }, readBytes: function() {\n                  var R = this.readVarint() + this.pos, A3 = this.buf.subarray(this.pos, R);\n                  return this.pos = R, A3;\n                }, readPackedVarint: function(R, A3) {\n                  if (this.type !== wu.Bytes) return R.push(this.readVarint(A3));\n                  var F3 = Rv(this);\n                  for (R = R || []; this.pos < F3; ) R.push(this.readVarint(A3));\n                  return R;\n                }, readPackedSVarint: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readSVarint());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readSVarint());\n                  return R;\n                }, readPackedBoolean: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readBoolean());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readBoolean());\n                  return R;\n                }, readPackedFloat: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readFloat());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readFloat());\n                  return R;\n                }, readPackedDouble: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readDouble());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readDouble());\n                  return R;\n                }, readPackedFixed32: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readFixed32());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readFixed32());\n                  return R;\n                }, readPackedSFixed32: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readSFixed32());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readSFixed32());\n                  return R;\n                }, readPackedFixed64: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readFixed64());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readFixed64());\n                  return R;\n                }, readPackedSFixed64: function(R) {\n                  if (this.type !== wu.Bytes) return R.push(this.readSFixed64());\n                  var A3 = Rv(this);\n                  for (R = R || []; this.pos < A3; ) R.push(this.readSFixed64());\n                  return R;\n                }, skip: function(R) {\n                  var A3 = 7 & R;\n                  if (A3 === wu.Varint) for (; this.buf[this.pos++] > 127; ) ;\n                  else if (A3 === wu.Bytes) this.pos = this.readVarint() + this.pos;\n                  else if (A3 === wu.Fixed32) this.pos += 4;\n                  else {\n                    if (A3 !== wu.Fixed64) throw new Error("Unimplemented type: " + A3);\n                    this.pos += 8;\n                  }\n                }, writeTag: function(R, A3) {\n                  this.writeVarint(R << 3 | A3);\n                }, realloc: function(R) {\n                  for (var A3 = this.length || 16; A3 < this.pos + R; ) A3 *= 2;\n                  if (A3 !== this.length) {\n                    var F3 = new Uint8Array(A3);\n                    F3.set(this.buf), this.buf = F3, this.length = A3;\n                  }\n                }, finish: function() {\n                  return this.length = this.pos, this.pos = 0, this.buf.subarray(0, this.length);\n                }, writeFixed32: function(R) {\n                  this.realloc(4), Vx(this.buf, R, this.pos), this.pos += 4;\n                }, writeSFixed32: function(R) {\n                  this.realloc(4), Vx(this.buf, R, this.pos), this.pos += 4;\n                }, writeFixed64: function(R) {\n                  this.realloc(8), Vx(this.buf, -1 & R, this.pos), Vx(this.buf, Math.floor(R * om), this.pos + 4), this.pos += 8;\n                }, writeSFixed64: function(R) {\n                  this.realloc(8), Vx(this.buf, -1 & R, this.pos), Vx(this.buf, Math.floor(R * om), this.pos + 4), this.pos += 8;\n                }, writeVarint: function(R) {\n                  (R = +R || 0) > 268435455 || R < 0 ? (function(A3, F3) {\n                    var W, re;\n                    if (A3 >= 0 ? (W = A3 % 4294967296 | 0, re = A3 / 4294967296 | 0) : (re = ~(-A3 / 4294967296), 4294967295 ^ (W = ~(-A3 % 4294967296)) ? W = W + 1 | 0 : (W = 0, re = re + 1 | 0)), A3 >= 18446744073709552e3 || A3 < -18446744073709552e3) throw new Error("Given varint doesn\'t fit into 10 bytes");\n                    F3.realloc(10), (function(fe, pe, ze) {\n                      ze.buf[ze.pos++] = 127 & fe | 128, fe >>>= 7, ze.buf[ze.pos++] = 127 & fe | 128, fe >>>= 7, ze.buf[ze.pos++] = 127 & fe | 128, fe >>>= 7, ze.buf[ze.pos++] = 127 & fe | 128, ze.buf[ze.pos] = 127 & (fe >>>= 7);\n                    })(W, 0, F3), (function(fe, pe) {\n                      var ze = (7 & fe) << 4;\n                      pe.buf[pe.pos++] |= ze | ((fe >>>= 3) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe | ((fe >>>= 7) ? 128 : 0), fe && (pe.buf[pe.pos++] = 127 & fe)))));\n                    })(re, F3);\n                  })(R, this) : (this.realloc(4), this.buf[this.pos++] = 127 & R | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = 127 & (R >>>= 7) | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = 127 & (R >>>= 7) | (R > 127 ? 128 : 0), R <= 127 || (this.buf[this.pos++] = R >>> 7 & 127))));\n                }, writeSVarint: function(R) {\n                  this.writeVarint(R < 0 ? 2 * -R - 1 : 2 * R);\n                }, writeBoolean: function(R) {\n                  this.writeVarint(!!R);\n                }, writeString: function(R) {\n                  R = String(R), this.realloc(4 * R.length), this.pos++;\n                  var A3 = this.pos;\n                  this.pos = (function(W, re, fe) {\n                    for (var pe, ze, Ke = 0; Ke < re.length; Ke++) {\n                      if ((pe = re.charCodeAt(Ke)) > 55295 && pe < 57344) {\n                        if (!ze) {\n                          pe > 56319 || Ke + 1 === re.length ? (W[fe++] = 239, W[fe++] = 191, W[fe++] = 189) : ze = pe;\n                          continue;\n                        }\n                        if (pe < 56320) {\n                          W[fe++] = 239, W[fe++] = 191, W[fe++] = 189, ze = pe;\n                          continue;\n                        }\n                        pe = ze - 55296 << 10 | pe - 56320 | 65536, ze = null;\n                      } else ze && (W[fe++] = 239, W[fe++] = 191, W[fe++] = 189, ze = null);\n                      pe < 128 ? W[fe++] = pe : (pe < 2048 ? W[fe++] = pe >> 6 | 192 : (pe < 65536 ? W[fe++] = pe >> 12 | 224 : (W[fe++] = pe >> 18 | 240, W[fe++] = pe >> 12 & 63 | 128), W[fe++] = pe >> 6 & 63 | 128), W[fe++] = 63 & pe | 128);\n                    }\n                    return fe;\n                  })(this.buf, R, this.pos);\n                  var F3 = this.pos - A3;\n                  F3 >= 128 && Cw(A3, F3, this), this.pos = A3 - 1, this.writeVarint(F3), this.pos += F3;\n                }, writeFloat: function(R) {\n                  this.realloc(4), T1(this.buf, R, this.pos, true, 23, 4), this.pos += 4;\n                }, writeDouble: function(R) {\n                  this.realloc(8), T1(this.buf, R, this.pos, true, 52, 8), this.pos += 8;\n                }, writeBytes: function(R) {\n                  var A3 = R.length;\n                  this.writeVarint(A3), this.realloc(A3);\n                  for (var F3 = 0; F3 < A3; F3++) this.buf[this.pos++] = R[F3];\n                }, writeRawMessage: function(R, A3) {\n                  this.pos++;\n                  var F3 = this.pos;\n                  R(A3, this);\n                  var W = this.pos - F3;\n                  W >= 128 && Cw(F3, W, this), this.pos = F3 - 1, this.writeVarint(W), this.pos += W;\n                }, writeMessage: function(R, A3, F3) {\n                  this.writeTag(R, wu.Bytes), this.writeRawMessage(A3, F3);\n                }, writePackedVarint: function(R, A3) {\n                  A3.length && this.writeMessage(R, Ux, A3);\n                }, writePackedSVarint: function(R, A3) {\n                  A3.length && this.writeMessage(R, q9, A3);\n                }, writePackedBoolean: function(R, A3) {\n                  A3.length && this.writeMessage(R, U9, A3);\n                }, writePackedFloat: function(R, A3) {\n                  A3.length && this.writeMessage(R, B9, A3);\n                }, writePackedDouble: function(R, A3) {\n                  A3.length && this.writeMessage(R, N9, A3);\n                }, writePackedFixed32: function(R, A3) {\n                  A3.length && this.writeMessage(R, LQ, A3);\n                }, writePackedSFixed32: function(R, A3) {\n                  A3.length && this.writeMessage(R, V9, A3);\n                }, writePackedFixed64: function(R, A3) {\n                  A3.length && this.writeMessage(R, G9, A3);\n                }, writePackedSFixed64: function(R, A3) {\n                  A3.length && this.writeMessage(R, H9, A3);\n                }, writeBytesField: function(R, A3) {\n                  this.writeTag(R, wu.Bytes), this.writeBytes(A3);\n                }, writeFixed32Field: function(R, A3) {\n                  this.writeTag(R, wu.Fixed32), this.writeFixed32(A3);\n                }, writeSFixed32Field: function(R, A3) {\n                  this.writeTag(R, wu.Fixed32), this.writeSFixed32(A3);\n                }, writeFixed64Field: function(R, A3) {\n                  this.writeTag(R, wu.Fixed64), this.writeFixed64(A3);\n                }, writeSFixed64Field: function(R, A3) {\n                  this.writeTag(R, wu.Fixed64), this.writeSFixed64(A3);\n                }, writeVarintField: function(R, A3) {\n                  this.writeTag(R, wu.Varint), this.writeVarint(A3);\n                }, writeSVarintField: function(R, A3) {\n                  this.writeTag(R, wu.Varint), this.writeSVarint(A3);\n                }, writeStringField: function(R, A3) {\n                  this.writeTag(R, wu.Bytes), this.writeString(A3);\n                }, writeFloatField: function(R, A3) {\n                  this.writeTag(R, wu.Fixed32), this.writeFloat(A3);\n                }, writeDoubleField: function(R, A3) {\n                  this.writeTag(R, wu.Fixed64), this.writeDouble(A3);\n                }, writeBooleanField: function(R, A3) {\n                  this.writeVarintField(R, !!A3);\n                } };\n                var nS = o4(Sd);\n                let aS = 3;\n                function PQ(R, A3, F3) {\n                  R === 1 && F3.readMessage(j9, A3);\n                }\n                function j9(R, A3, F3) {\n                  if (R === 3) {\n                    let { id: W, bitmap: re, width: fe, height: pe, left: ze, top: Ke, advance: ct } = F3.readMessage(yC, {});\n                    A3.push({ id: W, bitmap: new na({ width: fe + 2 * aS, height: pe + 2 * aS }, re), metrics: { width: fe, height: pe, left: ze, top: Ke, advance: ct } });\n                  }\n                }\n                function yC(R, A3, F3) {\n                  R === 1 ? A3.id = F3.readVarint() : R === 2 ? A3.bitmap = F3.readBytes() : R === 3 ? A3.width = F3.readVarint() : R === 4 ? A3.height = F3.readVarint() : R === 5 ? A3.left = F3.readSVarint() : R === 6 ? A3.top = F3.readSVarint() : R === 7 && (A3.advance = F3.readVarint());\n                }\n                let _C = aS;\n                function oS(R) {\n                  let A3 = 0, F3 = 0;\n                  for (let pe of R) A3 += pe.w * pe.h, F3 = Math.max(F3, pe.w);\n                  R.sort((pe, ze) => ze.h - pe.h);\n                  let W = [{ x: 0, y: 0, w: Math.max(Math.ceil(Math.sqrt(A3 / 0.95)), F3), h: 1 / 0 }], re = 0, fe = 0;\n                  for (let pe of R) for (let ze = W.length - 1; ze >= 0; ze--) {\n                    let Ke = W[ze];\n                    if (!(pe.w > Ke.w || pe.h > Ke.h)) {\n                      if (pe.x = Ke.x, pe.y = Ke.y, fe = Math.max(fe, pe.y + pe.h), re = Math.max(re, pe.x + pe.w), pe.w === Ke.w && pe.h === Ke.h) {\n                        let ct = W.pop();\n                        ze < W.length && (W[ze] = ct);\n                      } else pe.h === Ke.h ? (Ke.x += pe.w, Ke.w -= pe.w) : pe.w === Ke.w ? (Ke.y += pe.h, Ke.h -= pe.h) : (W.push({ x: Ke.x + pe.w, y: Ke.y, w: Ke.w - pe.w, h: pe.h }), Ke.y += pe.h, Ke.h -= pe.h);\n                      break;\n                    }\n                  }\n                  return { w: re, h: fe, fill: A3 / (re * fe) || 0 };\n                }\n                let Md = 1;\n                class Lw {\n                  constructor(A3, { pixelRatio: F3, version: W, stretchX: re, stretchY: fe, content: pe, textFitWidth: ze, textFitHeight: Ke }) {\n                    this.paddedRect = A3, this.pixelRatio = F3, this.stretchX = re, this.stretchY = fe, this.content = pe, this.version = W, this.textFitWidth = ze, this.textFitHeight = Ke;\n                  }\n                  get tl() {\n                    return [this.paddedRect.x + Md, this.paddedRect.y + Md];\n                  }\n                  get br() {\n                    return [this.paddedRect.x + this.paddedRect.w - Md, this.paddedRect.y + this.paddedRect.h - Md];\n                  }\n                  get tlbr() {\n                    return this.tl.concat(this.br);\n                  }\n                  get displaySize() {\n                    return [(this.paddedRect.w - 2 * Md) / this.pixelRatio, (this.paddedRect.h - 2 * Md) / this.pixelRatio];\n                  }\n                }\n                class Pw {\n                  constructor(A3, F3) {\n                    let W = {}, re = {};\n                    this.haveRenderCallbacks = [];\n                    let fe = [];\n                    this.addImages(A3, W, fe), this.addImages(F3, re, fe);\n                    let { w: pe, h: ze } = oS(fe), Ke = new Ki({ width: pe || 1, height: ze || 1 });\n                    for (let ct in A3) {\n                      let Lt = A3[ct], $t = W[ct].paddedRect;\n                      Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: $t.x + Md, y: $t.y + Md }, Lt.data);\n                    }\n                    for (let ct in F3) {\n                      let Lt = F3[ct], $t = re[ct].paddedRect, fr = $t.x + Md, mr = $t.y + Md, Pr = Lt.data.width, zr = Lt.data.height;\n                      Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: fr, y: mr }, Lt.data), Ki.copy(Lt.data, Ke, { x: 0, y: zr - 1 }, { x: fr, y: mr - 1 }, { width: Pr, height: 1 }), Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: fr, y: mr + zr }, { width: Pr, height: 1 }), Ki.copy(Lt.data, Ke, { x: Pr - 1, y: 0 }, { x: fr - 1, y: mr }, { width: 1, height: zr }), Ki.copy(Lt.data, Ke, { x: 0, y: 0 }, { x: fr + Pr, y: mr }, { width: 1, height: zr });\n                    }\n                    this.image = Ke, this.iconPositions = W, this.patternPositions = re;\n                  }\n                  addImages(A3, F3, W) {\n                    for (let re in A3) {\n                      let fe = A3[re], pe = { x: 0, y: 0, w: fe.data.width + 2 * Md, h: fe.data.height + 2 * Md };\n                      W.push(pe), F3[re] = new Lw(pe, fe), fe.hasRenderCallback && this.haveRenderCallbacks.push(re);\n                    }\n                  }\n                  patchUpdatedImages(A3, F3) {\n                    A3.dispatchRenderCallbacks(this.haveRenderCallbacks);\n                    for (let W in A3.updatedImages) this.patchUpdatedImage(this.iconPositions[W], A3.getImage(W), F3), this.patchUpdatedImage(this.patternPositions[W], A3.getImage(W), F3);\n                  }\n                  patchUpdatedImage(A3, F3, W) {\n                    if (!A3 || !F3 || A3.version === F3.version) return;\n                    A3.version = F3.version;\n                    let [re, fe] = A3.tl;\n                    W.update(F3.data, void 0, { x: re, y: fe });\n                  }\n                }\n                var Dv;\n                Fi("ImagePosition", Lw), Fi("ImageAtlas", Pw), i3.ah = void 0, (Dv = i3.ah || (i3.ah = {}))[Dv.none = 0] = "none", Dv[Dv.horizontal = 1] = "horizontal", Dv[Dv.vertical = 2] = "vertical", Dv[Dv.horizontalOnly = 3] = "horizontalOnly";\n                let Sh = -17;\n                class Gx {\n                  constructor() {\n                    this.scale = 1, this.fontStack = "", this.imageName = null;\n                  }\n                  static forText(A3, F3) {\n                    let W = new Gx();\n                    return W.scale = A3 || 1, W.fontStack = F3, W;\n                  }\n                  static forImage(A3) {\n                    let F3 = new Gx();\n                    return F3.imageName = A3, F3;\n                  }\n                }\n                class A1 {\n                  constructor() {\n                    this.text = "", this.sectionIndex = [], this.sections = [], this.imageSectionID = null;\n                  }\n                  static fromFeature(A3, F3) {\n                    let W = new A1();\n                    for (let re = 0; re < A3.sections.length; re++) {\n                      let fe = A3.sections[re];\n                      fe.image ? W.addImageSection(fe) : W.addTextSection(fe, F3);\n                    }\n                    return W;\n                  }\n                  length() {\n                    return this.text.length;\n                  }\n                  getSection(A3) {\n                    return this.sections[this.sectionIndex[A3]];\n                  }\n                  getSectionIndex(A3) {\n                    return this.sectionIndex[A3];\n                  }\n                  getCharCode(A3) {\n                    return this.text.charCodeAt(A3);\n                  }\n                  verticalizePunctuation() {\n                    this.text = (function(A3) {\n                      let F3 = "";\n                      for (let W = 0; W < A3.length; W++) {\n                        let re = A3.charCodeAt(W + 1) || null, fe = A3.charCodeAt(W - 1) || null;\n                        F3 += re && ml(re) && !vc[A3[W + 1]] || fe && ml(fe) && !vc[A3[W - 1]] || !vc[A3[W]] ? A3[W] : vc[A3[W]];\n                      }\n                      return F3;\n                    })(this.text);\n                  }\n                  trim() {\n                    let A3 = 0;\n                    for (let W = 0; W < this.text.length && Iw[this.text.charCodeAt(W)]; W++) A3++;\n                    let F3 = this.text.length;\n                    for (let W = this.text.length - 1; W >= 0 && W >= A3 && Iw[this.text.charCodeAt(W)]; W--) F3--;\n                    this.text = this.text.substring(A3, F3), this.sectionIndex = this.sectionIndex.slice(A3, F3);\n                  }\n                  substring(A3, F3) {\n                    let W = new A1();\n                    return W.text = this.text.substring(A3, F3), W.sectionIndex = this.sectionIndex.slice(A3, F3), W.sections = this.sections, W;\n                  }\n                  toString() {\n                    return this.text;\n                  }\n                  getMaxScale() {\n                    return this.sectionIndex.reduce((A3, F3) => Math.max(A3, this.sections[F3].scale), 0);\n                  }\n                  addTextSection(A3, F3) {\n                    this.text += A3.text, this.sections.push(Gx.forText(A3.scale, A3.fontStack || F3));\n                    let W = this.sections.length - 1;\n                    for (let re = 0; re < A3.text.length; ++re) this.sectionIndex.push(W);\n                  }\n                  addImageSection(A3) {\n                    let F3 = A3.image ? A3.image.name : "";\n                    if (F3.length === 0) return void T3("Can\'t add FormattedSection with an empty image.");\n                    let W = this.getNextImageSectionCharCode();\n                    W ? (this.text += String.fromCharCode(W), this.sections.push(Gx.forImage(F3)), this.sectionIndex.push(this.sections.length - 1)) : T3("Reached maximum number of images 6401");\n                  }\n                  getNextImageSectionCharCode() {\n                    return this.imageSectionID ? this.imageSectionID >= 63743 ? null : ++this.imageSectionID : (this.imageSectionID = 57344, this.imageSectionID);\n                  }\n                }\n                function Hx(R, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr) {\n                  let zr = A1.fromFeature(R, re), ui;\n                  $t === i3.ah.vertical && zr.verticalizePunctuation();\n                  let { processBidirectionalText: yi, processStyledBidirectionalText: vn } = ys;\n                  if (yi && zr.sections.length === 1) {\n                    ui = [];\n                    let Tn = yi(zr.toString(), S1(zr, ct, fe, A3, W, mr));\n                    for (let pa of Tn) {\n                      let ro = new A1();\n                      ro.text = pa, ro.sections = zr.sections;\n                      for (let Vo = 0; Vo < pa.length; Vo++) ro.sectionIndex.push(0);\n                      ui.push(ro);\n                    }\n                  } else if (vn) {\n                    ui = [];\n                    let Tn = vn(zr.text, zr.sectionIndex, S1(zr, ct, fe, A3, W, mr));\n                    for (let pa of Tn) {\n                      let ro = new A1();\n                      ro.text = pa[0], ro.sectionIndex = pa[1], ro.sections = zr.sections, ui.push(ro);\n                    }\n                  } else ui = (function(Tn, pa) {\n                    let ro = [], Vo = Tn.text, Xa = 0;\n                    for (let sa of pa) ro.push(Tn.substring(Xa, sa)), Xa = sa;\n                    return Xa < Vo.length && ro.push(Tn.substring(Xa, Vo.length)), ro;\n                  })(zr, S1(zr, ct, fe, A3, W, mr));\n                  let zi = [], un = { positionedLines: zi, text: zr.toString(), top: Lt[1], bottom: Lt[1], left: Lt[0], right: Lt[0], writingMode: $t, iconsInText: false, verticalizable: false };\n                  return (function(Tn, pa, ro, Vo, Xa, sa, Mo, fo, lo, Xn, Ro, uo) {\n                    let $o = 0, Ju = Sh, qu = 0, Mh = 0, Qv = fo === "right" ? 1 : fo === "left" ? 0 : 0.5, ld = 0;\n                    for (let Af of Xa) {\n                      Af.trim();\n                      let kh = Af.getMaxScale(), Ed = (kh - 1) * eu, ud = { positionedGlyphs: [], lineOffset: 0 };\n                      Tn.positionedLines[ld] = ud;\n                      let Wh = ud.positionedGlyphs, Df = 0;\n                      if (!Af.length()) {\n                        Ju += sa, ++ld;\n                        continue;\n                      }\n                      for (let lv = 0; lv < Af.length(); lv++) {\n                        let tu = Af.getSection(lv), pc = Af.getSectionIndex(lv), $u = Af.getCharCode(lv), zv = 0, ff = null, P1 = null, v0 = null, Gp = eu, ep = !(lo === i3.ah.horizontal || !Ro && !Ho($u) || Ro && (Iw[$u] || (Eh = $u, new RegExp("\\\\p{sc=Arab}", "u").test(String.fromCodePoint(Eh)))));\n                        if (tu.imageName) {\n                          let Gc = Vo[tu.imageName];\n                          if (!Gc) continue;\n                          v0 = tu.imageName, Tn.iconsInText = Tn.iconsInText || true, P1 = Gc.paddedRect;\n                          let Zf = Gc.displaySize;\n                          tu.scale = tu.scale * eu / uo, ff = { width: Zf[0], height: Zf[1], left: Md, top: -_C, advance: ep ? Zf[1] : Zf[0] }, zv = Ed + (eu - Zf[1] * tu.scale), Gp = ff.advance;\n                          let tp = ep ? Zf[0] * tu.scale - eu * kh : Zf[1] * tu.scale - eu * kh;\n                          tp > 0 && tp > Df && (Df = tp);\n                        } else {\n                          let Gc = ro[tu.fontStack], Zf = Gc && Gc[$u];\n                          if (Zf && Zf.rect) P1 = Zf.rect, ff = Zf.metrics;\n                          else {\n                            let tp = pa[tu.fontStack], gg = tp && tp[$u];\n                            if (!gg) continue;\n                            ff = gg.metrics;\n                          }\n                          zv = (kh - tu.scale) * eu;\n                        }\n                        ep ? (Tn.verticalizable = true, Wh.push({ glyph: $u, imageName: v0, x: $o, y: Ju + zv, vertical: ep, scale: tu.scale, fontStack: tu.fontStack, sectionIndex: pc, metrics: ff, rect: P1 }), $o += Gp * tu.scale + Xn) : (Wh.push({ glyph: $u, imageName: v0, x: $o, y: Ju + zv, vertical: ep, scale: tu.scale, fontStack: tu.fontStack, sectionIndex: pc, metrics: ff, rect: P1 }), $o += ff.advance * tu.scale + Xn);\n                      }\n                      Wh.length !== 0 && (qu = Math.max($o - Xn, qu), lm(Wh, 0, Wh.length - 1, Qv, Df)), $o = 0;\n                      let Fv = sa * kh + Df;\n                      ud.lineOffset = Math.max(Df, Ed), Ju += Fv, Mh = Math.max(Fv, Mh), ++ld;\n                    }\n                    var Eh;\n                    let Gd = Ju - Sh, { horizontalAlign: Hd, verticalAlign: jd } = Dw(Mo);\n                    (function(Af, kh, Ed, ud, Wh, Df, Fv, lv, tu) {\n                      let pc = (kh - Ed) * Wh, $u = 0;\n                      $u = Df !== Fv ? -lv * ud - Sh : (-ud * tu + 0.5) * Fv;\n                      for (let zv of Af) for (let ff of zv.positionedGlyphs) ff.x += pc, ff.y += $u;\n                    })(Tn.positionedLines, Qv, Hd, jd, qu, Mh, sa, Gd, Xa.length), Tn.top += -jd * Gd, Tn.bottom = Tn.top + Gd, Tn.left += -Hd * qu, Tn.right = Tn.left + qu;\n                  })(un, A3, F3, W, ui, pe, ze, Ke, $t, ct, fr, Pr), !(function(Tn) {\n                    for (let pa of Tn) if (pa.positionedGlyphs.length !== 0) return false;\n                    return true;\n                  })(zi) && un;\n                }\n                let Iw = { 9: true, 10: true, 11: true, 12: true, 13: true, 32: true }, W9 = { 10: true, 32: true, 38: true, 41: true, 43: true, 45: true, 47: true, 173: true, 183: true, 8203: true, 8208: true, 8211: true, 8231: true }, X9 = { 40: true };\n                function xC(R, A3, F3, W, re, fe) {\n                  if (A3.imageName) {\n                    let pe = W[A3.imageName];\n                    return pe ? pe.displaySize[0] * A3.scale * eu / fe + re : 0;\n                  }\n                  {\n                    let pe = F3[A3.fontStack], ze = pe && pe[R];\n                    return ze ? ze.metrics.advance * A3.scale + re : 0;\n                  }\n                }\n                function bC(R, A3, F3, W) {\n                  let re = Math.pow(R - A3, 2);\n                  return W ? R < A3 ? re / 2 : 2 * re : re + Math.abs(F3) * F3;\n                }\n                function Z9(R, A3, F3) {\n                  let W = 0;\n                  return R === 10 && (W -= 1e4), F3 && (W += 150), R !== 40 && R !== 65288 || (W += 50), A3 !== 41 && A3 !== 65289 || (W += 50), W;\n                }\n                function Rw(R, A3, F3, W, re, fe) {\n                  let pe = null, ze = bC(A3, F3, re, fe);\n                  for (let Ke of W) {\n                    let ct = bC(A3 - Ke.x, F3, re, fe) + Ke.badness;\n                    ct <= ze && (pe = Ke, ze = ct);\n                  }\n                  return { index: R, x: A3, priorBreak: pe, badness: ze };\n                }\n                function wC(R) {\n                  return R ? wC(R.priorBreak).concat(R.index) : [];\n                }\n                function S1(R, A3, F3, W, re, fe) {\n                  if (!R) return [];\n                  let pe = [], ze = (function($t, fr, mr, Pr, zr, ui) {\n                    let yi = 0;\n                    for (let vn = 0; vn < $t.length(); vn++) {\n                      let zi = $t.getSection(vn);\n                      yi += xC($t.getCharCode(vn), zi, Pr, zr, fr, ui);\n                    }\n                    return yi / Math.max(1, Math.ceil(yi / mr));\n                  })(R, A3, F3, W, re, fe), Ke = R.text.indexOf("\\u200B") >= 0, ct = 0;\n                  for (let $t = 0; $t < R.length(); $t++) {\n                    let fr = R.getSection($t), mr = R.getCharCode($t);\n                    if (Iw[mr] || (ct += xC(mr, fr, W, re, A3, fe)), $t < R.length() - 1) {\n                      let Pr = !((Lt = mr) < 11904) && (!!Dn["CJK Compatibility Forms"](Lt) || !!Dn["CJK Compatibility"](Lt) || !!Dn["CJK Strokes"](Lt) || !!Dn["CJK Symbols and Punctuation"](Lt) || !!Dn["Enclosed CJK Letters and Months"](Lt) || !!Dn["Halfwidth and Fullwidth Forms"](Lt) || !!Dn["Ideographic Description Characters"](Lt) || !!Dn["Vertical Forms"](Lt) || ws.test(String.fromCodePoint(Lt)));\n                      (W9[mr] || Pr || fr.imageName || $t !== R.length() - 2 && X9[R.getCharCode($t + 1)]) && pe.push(Rw($t + 1, ct, ze, pe, Z9(mr, R.getCharCode($t + 1), Pr && Ke), false));\n                    }\n                  }\n                  var Lt;\n                  return wC(Rw(R.length(), ct, ze, pe, 0, true));\n                }\n                function Dw(R) {\n                  let A3 = 0.5, F3 = 0.5;\n                  switch (R) {\n                    case "right":\n                    case "top-right":\n                    case "bottom-right":\n                      A3 = 1;\n                      break;\n                    case "left":\n                    case "top-left":\n                    case "bottom-left":\n                      A3 = 0;\n                  }\n                  switch (R) {\n                    case "bottom":\n                    case "bottom-right":\n                    case "bottom-left":\n                      F3 = 1;\n                      break;\n                    case "top":\n                    case "top-right":\n                    case "top-left":\n                      F3 = 0;\n                  }\n                  return { horizontalAlign: A3, verticalAlign: F3 };\n                }\n                function lm(R, A3, F3, W, re) {\n                  if (!W && !re) return;\n                  let fe = R[F3], pe = (R[F3].x + fe.metrics.advance * fe.scale) * W;\n                  for (let ze = A3; ze <= F3; ze++) R[ze].x -= pe, R[ze].y += re;\n                }\n                function jx(R, A3, F3) {\n                  let { horizontalAlign: W, verticalAlign: re } = Dw(F3), fe = A3[0] - R.displaySize[0] * W, pe = A3[1] - R.displaySize[1] * re;\n                  return { image: R, top: pe, bottom: pe + R.displaySize[1], left: fe, right: fe + R.displaySize[0] };\n                }\n                function TC(R) {\n                  var A3, F3;\n                  let W = R.left, re = R.top, fe = R.right - W, pe = R.bottom - re, ze = (A3 = R.image.textFitWidth) !== null && A3 !== void 0 ? A3 : "stretchOrShrink", Ke = (F3 = R.image.textFitHeight) !== null && F3 !== void 0 ? F3 : "stretchOrShrink", ct = (R.image.content[2] - R.image.content[0]) / (R.image.content[3] - R.image.content[1]);\n                  if (Ke === "proportional") {\n                    if (ze === "stretchOnly" && fe / pe < ct || ze === "proportional") {\n                      let Lt = Math.ceil(pe * ct);\n                      W *= Lt / fe, fe = Lt;\n                    }\n                  } else if (ze === "proportional" && Ke === "stretchOnly" && ct !== 0 && fe / pe > ct) {\n                    let Lt = Math.ceil(fe / ct);\n                    re *= Lt / pe, pe = Lt;\n                  }\n                  return { x1: W, y1: re, x2: W + fe, y2: re + pe };\n                }\n                function AC(R, A3, F3, W, re, fe) {\n                  let pe = R.image, ze;\n                  if (pe.content) {\n                    let ui = pe.content, yi = pe.pixelRatio || 1;\n                    ze = [ui[0] / yi, ui[1] / yi, pe.displaySize[0] - ui[2] / yi, pe.displaySize[1] - ui[3] / yi];\n                  }\n                  let Ke = A3.left * fe, ct = A3.right * fe, Lt, $t, fr, mr;\n                  F3 === "width" || F3 === "both" ? (mr = re[0] + Ke - W[3], $t = re[0] + ct + W[1]) : (mr = re[0] + (Ke + ct - pe.displaySize[0]) / 2, $t = mr + pe.displaySize[0]);\n                  let Pr = A3.top * fe, zr = A3.bottom * fe;\n                  return F3 === "height" || F3 === "both" ? (Lt = re[1] + Pr - W[0], fr = re[1] + zr + W[2]) : (Lt = re[1] + (Pr + zr - pe.displaySize[1]) / 2, fr = Lt + pe.displaySize[1]), { image: pe, top: Lt, right: $t, bottom: fr, left: mr, collisionPadding: ze };\n                }\n                let Wx = 255, d0 = 128, um = Wx * d0;\n                function SC(R, A3) {\n                  let { expression: F3 } = A3;\n                  if (F3.kind === "constant") return { kind: "constant", layoutSize: F3.evaluate(new rs(R + 1)) };\n                  if (F3.kind === "source") return { kind: "source" };\n                  {\n                    let { zoomStops: W, interpolationType: re } = F3, fe = 0;\n                    for (; fe < W.length && W[fe] <= R; ) fe++;\n                    fe = Math.max(0, fe - 1);\n                    let pe = fe;\n                    for (; pe < W.length && W[pe] < R + 1; ) pe++;\n                    pe = Math.min(W.length - 1, pe);\n                    let ze = W[fe], Ke = W[pe];\n                    return F3.kind === "composite" ? { kind: "composite", minZoom: ze, maxZoom: Ke, interpolationType: re } : { kind: "camera", minZoom: ze, maxZoom: Ke, minSize: F3.evaluate(new rs(ze)), maxSize: F3.evaluate(new rs(Ke)), interpolationType: re };\n                  }\n                }\n                function sS(R, A3, F3) {\n                  let W = "never", re = R.get(A3);\n                  return re ? W = re : R.get(F3) && (W = "always"), W;\n                }\n                let Y9 = br.VectorTileFeature.types, K9 = [{ name: "a_fade_opacity", components: 1, type: "Uint8", offset: 0 }];\n                function Fw(R, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr) {\n                  let mr = ze ? Math.min(um, Math.round(ze[0])) : 0, Pr = ze ? Math.min(um, Math.round(ze[1])) : 0;\n                  R.emplaceBack(A3, F3, Math.round(32 * W), Math.round(32 * re), fe, pe, (mr << 1) + (Ke ? 1 : 0), Pr, 16 * ct, 16 * Lt, 256 * $t, 256 * fr);\n                }\n                function lS(R, A3, F3) {\n                  R.emplaceBack(A3.x, A3.y, F3), R.emplaceBack(A3.x, A3.y, F3), R.emplaceBack(A3.x, A3.y, F3), R.emplaceBack(A3.x, A3.y, F3);\n                }\n                function uS(R) {\n                  for (let A3 of R.sections) if (no(A3.text)) return true;\n                  return false;\n                }\n                class cS {\n                  constructor(A3) {\n                    this.layoutVertexArray = new Ql(), this.indexArray = new se(), this.programConfigurations = A3, this.segments = new Ye(), this.dynamicLayoutVertexArray = new dc(), this.opacityVertexArray = new Tl(), this.hasVisibleVertices = false, this.placedSymbolArray = new Ta();\n                  }\n                  isEmpty() {\n                    return this.layoutVertexArray.length === 0 && this.indexArray.length === 0 && this.dynamicLayoutVertexArray.length === 0 && this.opacityVertexArray.length === 0;\n                  }\n                  upload(A3, F3, W, re) {\n                    this.isEmpty() || (W && (this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, im.members), this.indexBuffer = A3.createIndexBuffer(this.indexArray, F3), this.dynamicLayoutVertexBuffer = A3.createVertexBuffer(this.dynamicLayoutVertexArray, b1.members, true), this.opacityVertexBuffer = A3.createVertexBuffer(this.opacityVertexArray, K9, true), this.opacityVertexBuffer.itemSize = 1), (W || re) && this.programConfigurations.upload(A3));\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.programConfigurations.destroy(), this.segments.destroy(), this.dynamicLayoutVertexBuffer.destroy(), this.opacityVertexBuffer.destroy());\n                  }\n                }\n                Fi("SymbolBuffers", cS);\n                class cm {\n                  constructor(A3, F3, W) {\n                    this.layoutVertexArray = new A3(), this.layoutAttributes = F3, this.indexArray = new W(), this.segments = new Ye(), this.collisionVertexArray = new X();\n                  }\n                  upload(A3) {\n                    this.layoutVertexBuffer = A3.createVertexBuffer(this.layoutVertexArray, this.layoutAttributes), this.indexBuffer = A3.createIndexBuffer(this.indexArray), this.collisionVertexBuffer = A3.createVertexBuffer(this.collisionVertexArray, w1.members, true);\n                  }\n                  destroy() {\n                    this.layoutVertexBuffer && (this.layoutVertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.collisionVertexBuffer.destroy());\n                  }\n                }\n                Fi("CollisionBuffers", cm);\n                class M1 {\n                  constructor(A3) {\n                    this.collisionBoxArray = A3.collisionBoxArray, this.zoom = A3.zoom, this.overscaling = A3.overscaling, this.layers = A3.layers, this.layerIds = this.layers.map((pe) => pe.id), this.index = A3.index, this.pixelRatio = A3.pixelRatio, this.sourceLayerIndex = A3.sourceLayerIndex, this.hasPattern = false, this.hasRTLText = false, this.sortKeyRanges = [], this.collisionCircleArray = [], this.placementInvProjMatrix = Ri([]), this.placementViewportMatrix = Ri([]);\n                    let F3 = this.layers[0]._unevaluatedLayout._values;\n                    this.textSizeData = SC(this.zoom, F3["text-size"]), this.iconSizeData = SC(this.zoom, F3["icon-size"]);\n                    let W = this.layers[0].layout, re = W.get("symbol-sort-key"), fe = W.get("symbol-z-order");\n                    this.canOverlap = sS(W, "text-overlap", "text-allow-overlap") !== "never" || sS(W, "icon-overlap", "icon-allow-overlap") !== "never" || W.get("text-ignore-placement") || W.get("icon-ignore-placement"), this.sortFeaturesByKey = fe !== "viewport-y" && !re.isConstant(), this.sortFeaturesByY = (fe === "viewport-y" || fe === "auto" && !this.sortFeaturesByKey) && this.canOverlap, W.get("symbol-placement") === "point" && (this.writingModes = W.get("text-writing-mode").map((pe) => i3.ah[pe])), this.stateDependentLayerIds = this.layers.filter((pe) => pe.isStateDependent()).map((pe) => pe.id), this.sourceID = A3.sourceID;\n                  }\n                  createArrays() {\n                    this.text = new cS(new Ms(this.layers, this.zoom, (A3) => /^text/.test(A3))), this.icon = new cS(new Ms(this.layers, this.zoom, (A3) => /^icon/.test(A3))), this.glyphOffsetArray = new Co(), this.lineVertexArray = new Qa(), this.symbolInstances = new $a(), this.textAnchorOffsets = new Bo();\n                  }\n                  calculateGlyphDependencies(A3, F3, W, re, fe) {\n                    for (let pe = 0; pe < A3.length; pe++) if (F3[A3.charCodeAt(pe)] = true, (W || re) && fe) {\n                      let ze = vc[A3.charAt(pe)];\n                      ze && (F3[ze.charCodeAt(0)] = true);\n                    }\n                  }\n                  populate(A3, F3, W) {\n                    let re = this.layers[0], fe = re.layout, pe = fe.get("text-font"), ze = fe.get("text-field"), Ke = fe.get("icon-image"), ct = (ze.value.kind !== "constant" || ze.value.value instanceof ri && !ze.value.value.isEmpty() || ze.value.value.toString().length > 0) && (pe.value.kind !== "constant" || pe.value.value.length > 0), Lt = Ke.value.kind !== "constant" || !!Ke.value.value || Object.keys(Ke.parameters).length > 0, $t = fe.get("symbol-sort-key");\n                    if (this.features = [], !ct && !Lt) return;\n                    let fr = F3.iconDependencies, mr = F3.glyphDependencies, Pr = F3.availableImages, zr = new rs(this.zoom);\n                    for (let { feature: ui, id: yi, index: vn, sourceLayerIndex: zi } of A3) {\n                      let un = re._featureFilter.needGeometry, Tn = Sl(ui, un);\n                      if (!re._featureFilter.filter(zr, Tn, W)) continue;\n                      let pa, ro;\n                      if (un || (Tn.geometry = $s(ui)), ct) {\n                        let Xa = re.getValueAndResolveTokens("text-field", Tn, W, Pr), sa = ri.factory(Xa), Mo = this.hasRTLText = this.hasRTLText || uS(sa);\n                        (!Mo || ys.getRTLTextPluginStatus() === "unavailable" || Mo && ys.isParsed()) && (pa = am(sa, re, Tn));\n                      }\n                      if (Lt) {\n                        let Xa = re.getValueAndResolveTokens("icon-image", Tn, W, Pr);\n                        ro = Xa instanceof tn ? Xa : tn.fromString(Xa);\n                      }\n                      if (!pa && !ro) continue;\n                      let Vo = this.sortFeaturesByKey ? $t.evaluate(Tn, {}, W) : void 0;\n                      if (this.features.push({ id: yi, text: pa, icon: ro, index: vn, sourceLayerIndex: zi, geometry: Tn.geometry, properties: ui.properties, type: Y9[ui.type], sortKey: Vo }), ro && (fr[ro.name] = true), pa) {\n                        let Xa = pe.evaluate(Tn, {}, W).join(","), sa = fe.get("text-rotation-alignment") !== "viewport" && fe.get("symbol-placement") !== "point";\n                        this.allowVerticalPlacement = this.writingModes && this.writingModes.indexOf(i3.ah.vertical) >= 0;\n                        for (let Mo of pa.sections) if (Mo.image) fr[Mo.image.name] = true;\n                        else {\n                          let fo = Ka(pa.toString()), lo = Mo.fontStack || Xa, Xn = mr[lo] = mr[lo] || {};\n                          this.calculateGlyphDependencies(Mo.text, Xn, sa, this.allowVerticalPlacement, fo);\n                        }\n                      }\n                    }\n                    fe.get("symbol-placement") === "line" && (this.features = (function(ui) {\n                      let yi = {}, vn = {}, zi = [], un = 0;\n                      function Tn(Xa) {\n                        zi.push(ui[Xa]), un++;\n                      }\n                      function pa(Xa, sa, Mo) {\n                        let fo = vn[Xa];\n                        return delete vn[Xa], vn[sa] = fo, zi[fo].geometry[0].pop(), zi[fo].geometry[0] = zi[fo].geometry[0].concat(Mo[0]), fo;\n                      }\n                      function ro(Xa, sa, Mo) {\n                        let fo = yi[sa];\n                        return delete yi[sa], yi[Xa] = fo, zi[fo].geometry[0].shift(), zi[fo].geometry[0] = Mo[0].concat(zi[fo].geometry[0]), fo;\n                      }\n                      function Vo(Xa, sa, Mo) {\n                        let fo = Mo ? sa[0][sa[0].length - 1] : sa[0][0];\n                        return `${Xa}:${fo.x}:${fo.y}`;\n                      }\n                      for (let Xa = 0; Xa < ui.length; Xa++) {\n                        let sa = ui[Xa], Mo = sa.geometry, fo = sa.text ? sa.text.toString() : null;\n                        if (!fo) {\n                          Tn(Xa);\n                          continue;\n                        }\n                        let lo = Vo(fo, Mo), Xn = Vo(fo, Mo, true);\n                        if (lo in vn && Xn in yi && vn[lo] !== yi[Xn]) {\n                          let Ro = ro(lo, Xn, Mo), uo = pa(lo, Xn, zi[Ro].geometry);\n                          delete yi[lo], delete vn[Xn], vn[Vo(fo, zi[uo].geometry, true)] = uo, zi[Ro].geometry = null;\n                        } else lo in vn ? pa(lo, Xn, Mo) : Xn in yi ? ro(lo, Xn, Mo) : (Tn(Xa), yi[lo] = un - 1, vn[Xn] = un - 1);\n                      }\n                      return zi.filter((Xa) => Xa.geometry);\n                    })(this.features)), this.sortFeaturesByKey && this.features.sort((ui, yi) => ui.sortKey - yi.sortKey);\n                  }\n                  update(A3, F3, W) {\n                    this.stateDependentLayers.length && (this.text.programConfigurations.updatePaintArrays(A3, F3, this.layers, W), this.icon.programConfigurations.updatePaintArrays(A3, F3, this.layers, W));\n                  }\n                  isEmpty() {\n                    return this.symbolInstances.length === 0 && !this.hasRTLText;\n                  }\n                  uploadPending() {\n                    return !this.uploaded || this.text.programConfigurations.needsUpload || this.icon.programConfigurations.needsUpload;\n                  }\n                  upload(A3) {\n                    !this.uploaded && this.hasDebugData() && (this.textCollisionBox.upload(A3), this.iconCollisionBox.upload(A3)), this.text.upload(A3, this.sortFeaturesByY, !this.uploaded, this.text.programConfigurations.needsUpload), this.icon.upload(A3, this.sortFeaturesByY, !this.uploaded, this.icon.programConfigurations.needsUpload), this.uploaded = true;\n                  }\n                  destroyDebugData() {\n                    this.textCollisionBox.destroy(), this.iconCollisionBox.destroy();\n                  }\n                  destroy() {\n                    this.text.destroy(), this.icon.destroy(), this.hasDebugData() && this.destroyDebugData();\n                  }\n                  addToLineVertexArray(A3, F3) {\n                    let W = this.lineVertexArray.length;\n                    if (A3.segment !== void 0) {\n                      let re = A3.dist(F3[A3.segment + 1]), fe = A3.dist(F3[A3.segment]), pe = {};\n                      for (let ze = A3.segment + 1; ze < F3.length; ze++) pe[ze] = { x: F3[ze].x, y: F3[ze].y, tileUnitDistanceFromAnchor: re }, ze < F3.length - 1 && (re += F3[ze + 1].dist(F3[ze]));\n                      for (let ze = A3.segment || 0; ze >= 0; ze--) pe[ze] = { x: F3[ze].x, y: F3[ze].y, tileUnitDistanceFromAnchor: fe }, ze > 0 && (fe += F3[ze - 1].dist(F3[ze]));\n                      for (let ze = 0; ze < F3.length; ze++) {\n                        let Ke = pe[ze];\n                        this.lineVertexArray.emplaceBack(Ke.x, Ke.y, Ke.tileUnitDistanceFromAnchor);\n                      }\n                    }\n                    return { lineStartIndex: W, lineLength: this.lineVertexArray.length - W };\n                  }\n                  addSymbols(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr) {\n                    let mr = A3.indexArray, Pr = A3.layoutVertexArray, zr = A3.segments.prepareSegment(4 * F3.length, Pr, mr, this.canOverlap ? pe.sortKey : void 0), ui = this.glyphOffsetArray.length, yi = zr.vertexLength, vn = this.allowVerticalPlacement && ze === i3.ah.vertical ? Math.PI / 2 : 0, zi = pe.text && pe.text.sections;\n                    for (let un = 0; un < F3.length; un++) {\n                      let { tl: Tn, tr: pa, bl: ro, br: Vo, tex: Xa, pixelOffsetTL: sa, pixelOffsetBR: Mo, minFontScaleX: fo, minFontScaleY: lo, glyphOffset: Xn, isSDF: Ro, sectionIndex: uo } = F3[un], $o = zr.vertexLength, Ju = Xn[1];\n                      Fw(Pr, Ke.x, Ke.y, Tn.x, Ju + Tn.y, Xa.x, Xa.y, W, Ro, sa.x, sa.y, fo, lo), Fw(Pr, Ke.x, Ke.y, pa.x, Ju + pa.y, Xa.x + Xa.w, Xa.y, W, Ro, Mo.x, sa.y, fo, lo), Fw(Pr, Ke.x, Ke.y, ro.x, Ju + ro.y, Xa.x, Xa.y + Xa.h, W, Ro, sa.x, Mo.y, fo, lo), Fw(Pr, Ke.x, Ke.y, Vo.x, Ju + Vo.y, Xa.x + Xa.w, Xa.y + Xa.h, W, Ro, Mo.x, Mo.y, fo, lo), lS(A3.dynamicLayoutVertexArray, Ke, vn), mr.emplaceBack($o, $o + 1, $o + 2), mr.emplaceBack($o + 1, $o + 2, $o + 3), zr.vertexLength += 4, zr.primitiveLength += 2, this.glyphOffsetArray.emplaceBack(Xn[0]), un !== F3.length - 1 && uo === F3[un + 1].sectionIndex || A3.programConfigurations.populatePaintArrays(Pr.length, pe, pe.index, {}, fr, zi && zi[uo]);\n                    }\n                    A3.placedSymbolArray.emplaceBack(Ke.x, Ke.y, ui, this.glyphOffsetArray.length - ui, yi, ct, Lt, Ke.segment, W ? W[0] : 0, W ? W[1] : 0, re[0], re[1], ze, 0, false, 0, $t);\n                  }\n                  _addCollisionDebugVertex(A3, F3, W, re, fe, pe) {\n                    return F3.emplaceBack(0, 0), A3.emplaceBack(W.x, W.y, re, fe, Math.round(pe.x), Math.round(pe.y));\n                  }\n                  addCollisionDebugVertices(A3, F3, W, re, fe, pe, ze) {\n                    let Ke = fe.segments.prepareSegment(4, fe.layoutVertexArray, fe.indexArray), ct = Ke.vertexLength, Lt = fe.layoutVertexArray, $t = fe.collisionVertexArray, fr = ze.anchorX, mr = ze.anchorY;\n                    this._addCollisionDebugVertex(Lt, $t, pe, fr, mr, new u4(A3, F3)), this._addCollisionDebugVertex(Lt, $t, pe, fr, mr, new u4(W, F3)), this._addCollisionDebugVertex(Lt, $t, pe, fr, mr, new u4(W, re)), this._addCollisionDebugVertex(Lt, $t, pe, fr, mr, new u4(A3, re)), Ke.vertexLength += 4;\n                    let Pr = fe.indexArray;\n                    Pr.emplaceBack(ct, ct + 1), Pr.emplaceBack(ct + 1, ct + 2), Pr.emplaceBack(ct + 2, ct + 3), Pr.emplaceBack(ct + 3, ct), Ke.primitiveLength += 4;\n                  }\n                  addDebugCollisionBoxes(A3, F3, W, re) {\n                    for (let fe = A3; fe < F3; fe++) {\n                      let pe = this.collisionBoxArray.get(fe);\n                      this.addCollisionDebugVertices(pe.x1, pe.y1, pe.x2, pe.y2, re ? this.textCollisionBox : this.iconCollisionBox, pe.anchorPoint, W);\n                    }\n                  }\n                  generateCollisionDebugBuffers() {\n                    this.hasDebugData() && this.destroyDebugData(), this.textCollisionBox = new cm(Al, sy.members, Te), this.iconCollisionBox = new cm(Al, sy.members, Te);\n                    for (let A3 = 0; A3 < this.symbolInstances.length; A3++) {\n                      let F3 = this.symbolInstances.get(A3);\n                      this.addDebugCollisionBoxes(F3.textBoxStartIndex, F3.textBoxEndIndex, F3, true), this.addDebugCollisionBoxes(F3.verticalTextBoxStartIndex, F3.verticalTextBoxEndIndex, F3, true), this.addDebugCollisionBoxes(F3.iconBoxStartIndex, F3.iconBoxEndIndex, F3, false), this.addDebugCollisionBoxes(F3.verticalIconBoxStartIndex, F3.verticalIconBoxEndIndex, F3, false);\n                    }\n                  }\n                  _deserializeCollisionBoxesForSymbol(A3, F3, W, re, fe, pe, ze, Ke, ct) {\n                    let Lt = {};\n                    for (let $t = F3; $t < W; $t++) {\n                      let fr = A3.get($t);\n                      Lt.textBox = { x1: fr.x1, y1: fr.y1, x2: fr.x2, y2: fr.y2, anchorPointX: fr.anchorPointX, anchorPointY: fr.anchorPointY }, Lt.textFeatureIndex = fr.featureIndex;\n                      break;\n                    }\n                    for (let $t = re; $t < fe; $t++) {\n                      let fr = A3.get($t);\n                      Lt.verticalTextBox = { x1: fr.x1, y1: fr.y1, x2: fr.x2, y2: fr.y2, anchorPointX: fr.anchorPointX, anchorPointY: fr.anchorPointY }, Lt.verticalTextFeatureIndex = fr.featureIndex;\n                      break;\n                    }\n                    for (let $t = pe; $t < ze; $t++) {\n                      let fr = A3.get($t);\n                      Lt.iconBox = { x1: fr.x1, y1: fr.y1, x2: fr.x2, y2: fr.y2, anchorPointX: fr.anchorPointX, anchorPointY: fr.anchorPointY }, Lt.iconFeatureIndex = fr.featureIndex;\n                      break;\n                    }\n                    for (let $t = Ke; $t < ct; $t++) {\n                      let fr = A3.get($t);\n                      Lt.verticalIconBox = { x1: fr.x1, y1: fr.y1, x2: fr.x2, y2: fr.y2, anchorPointX: fr.anchorPointX, anchorPointY: fr.anchorPointY }, Lt.verticalIconFeatureIndex = fr.featureIndex;\n                      break;\n                    }\n                    return Lt;\n                  }\n                  deserializeCollisionBoxes(A3) {\n                    this.collisionArrays = [];\n                    for (let F3 = 0; F3 < this.symbolInstances.length; F3++) {\n                      let W = this.symbolInstances.get(F3);\n                      this.collisionArrays.push(this._deserializeCollisionBoxesForSymbol(A3, W.textBoxStartIndex, W.textBoxEndIndex, W.verticalTextBoxStartIndex, W.verticalTextBoxEndIndex, W.iconBoxStartIndex, W.iconBoxEndIndex, W.verticalIconBoxStartIndex, W.verticalIconBoxEndIndex));\n                    }\n                  }\n                  hasTextData() {\n                    return this.text.segments.get().length > 0;\n                  }\n                  hasIconData() {\n                    return this.icon.segments.get().length > 0;\n                  }\n                  hasDebugData() {\n                    return this.textCollisionBox && this.iconCollisionBox;\n                  }\n                  hasTextCollisionBoxData() {\n                    return this.hasDebugData() && this.textCollisionBox.segments.get().length > 0;\n                  }\n                  hasIconCollisionBoxData() {\n                    return this.hasDebugData() && this.iconCollisionBox.segments.get().length > 0;\n                  }\n                  addIndicesForPlacedSymbol(A3, F3) {\n                    let W = A3.placedSymbolArray.get(F3), re = W.vertexStartIndex + 4 * W.numGlyphs;\n                    for (let fe = W.vertexStartIndex; fe < re; fe += 4) A3.indexArray.emplaceBack(fe, fe + 1, fe + 2), A3.indexArray.emplaceBack(fe + 1, fe + 2, fe + 3);\n                  }\n                  getSortedSymbolIndexes(A3) {\n                    if (this.sortedAngle === A3 && this.symbolInstanceIndexes !== void 0) return this.symbolInstanceIndexes;\n                    let F3 = Math.sin(A3), W = Math.cos(A3), re = [], fe = [], pe = [];\n                    for (let ze = 0; ze < this.symbolInstances.length; ++ze) {\n                      pe.push(ze);\n                      let Ke = this.symbolInstances.get(ze);\n                      re.push(0 | Math.round(F3 * Ke.anchorX + W * Ke.anchorY)), fe.push(Ke.featureIndex);\n                    }\n                    return pe.sort((ze, Ke) => re[ze] - re[Ke] || fe[Ke] - fe[ze]), pe;\n                  }\n                  addToSortKeyRanges(A3, F3) {\n                    let W = this.sortKeyRanges[this.sortKeyRanges.length - 1];\n                    W && W.sortKey === F3 ? W.symbolInstanceEnd = A3 + 1 : this.sortKeyRanges.push({ sortKey: F3, symbolInstanceStart: A3, symbolInstanceEnd: A3 + 1 });\n                  }\n                  sortFeatures(A3) {\n                    if (this.sortFeaturesByY && this.sortedAngle !== A3 && !(this.text.segments.get().length > 1 || this.icon.segments.get().length > 1)) {\n                      this.symbolInstanceIndexes = this.getSortedSymbolIndexes(A3), this.sortedAngle = A3, this.text.indexArray.clear(), this.icon.indexArray.clear(), this.featureSortOrder = [];\n                      for (let F3 of this.symbolInstanceIndexes) {\n                        let W = this.symbolInstances.get(F3);\n                        this.featureSortOrder.push(W.featureIndex), [W.rightJustifiedTextSymbolIndex, W.centerJustifiedTextSymbolIndex, W.leftJustifiedTextSymbolIndex].forEach((re, fe, pe) => {\n                          re >= 0 && pe.indexOf(re) === fe && this.addIndicesForPlacedSymbol(this.text, re);\n                        }), W.verticalPlacedTextSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.text, W.verticalPlacedTextSymbolIndex), W.placedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, W.placedIconSymbolIndex), W.verticalPlacedIconSymbolIndex >= 0 && this.addIndicesForPlacedSymbol(this.icon, W.verticalPlacedIconSymbolIndex);\n                      }\n                      this.text.indexBuffer && this.text.indexBuffer.updateData(this.text.indexArray), this.icon.indexBuffer && this.icon.indexBuffer.updateData(this.icon.indexArray);\n                    }\n                  }\n                }\n                let Tf, Xx;\n                Fi("SymbolBucket", M1, { omit: ["layers", "collisionBoxArray", "features", "compareText"] }), M1.MAX_GLYPHS = 65535, M1.addDynamicAttributes = lS;\n                var zw = { get paint() {\n                  return Xx = Xx || new ue({ "icon-opacity": new oo(ce.paint_symbol["icon-opacity"]), "icon-color": new oo(ce.paint_symbol["icon-color"]), "icon-halo-color": new oo(ce.paint_symbol["icon-halo-color"]), "icon-halo-width": new oo(ce.paint_symbol["icon-halo-width"]), "icon-halo-blur": new oo(ce.paint_symbol["icon-halo-blur"]), "icon-translate": new Ua(ce.paint_symbol["icon-translate"]), "icon-translate-anchor": new Ua(ce.paint_symbol["icon-translate-anchor"]), "text-opacity": new oo(ce.paint_symbol["text-opacity"]), "text-color": new oo(ce.paint_symbol["text-color"], { runtimeType: er, getOverride: (R) => R.textColor, hasOverride: (R) => !!R.textColor }), "text-halo-color": new oo(ce.paint_symbol["text-halo-color"]), "text-halo-width": new oo(ce.paint_symbol["text-halo-width"]), "text-halo-blur": new oo(ce.paint_symbol["text-halo-blur"]), "text-translate": new Ua(ce.paint_symbol["text-translate"]), "text-translate-anchor": new Ua(ce.paint_symbol["text-translate-anchor"]) });\n                }, get layout() {\n                  return Tf = Tf || new ue({ "symbol-placement": new Ua(ce.layout_symbol["symbol-placement"]), "symbol-spacing": new Ua(ce.layout_symbol["symbol-spacing"]), "symbol-avoid-edges": new Ua(ce.layout_symbol["symbol-avoid-edges"]), "symbol-sort-key": new oo(ce.layout_symbol["symbol-sort-key"]), "symbol-z-order": new Ua(ce.layout_symbol["symbol-z-order"]), "icon-allow-overlap": new Ua(ce.layout_symbol["icon-allow-overlap"]), "icon-overlap": new Ua(ce.layout_symbol["icon-overlap"]), "icon-ignore-placement": new Ua(ce.layout_symbol["icon-ignore-placement"]), "icon-optional": new Ua(ce.layout_symbol["icon-optional"]), "icon-rotation-alignment": new Ua(ce.layout_symbol["icon-rotation-alignment"]), "icon-size": new oo(ce.layout_symbol["icon-size"]), "icon-text-fit": new Ua(ce.layout_symbol["icon-text-fit"]), "icon-text-fit-padding": new Ua(ce.layout_symbol["icon-text-fit-padding"]), "icon-image": new oo(ce.layout_symbol["icon-image"]), "icon-rotate": new oo(ce.layout_symbol["icon-rotate"]), "icon-padding": new oo(ce.layout_symbol["icon-padding"]), "icon-keep-upright": new Ua(ce.layout_symbol["icon-keep-upright"]), "icon-offset": new oo(ce.layout_symbol["icon-offset"]), "icon-anchor": new oo(ce.layout_symbol["icon-anchor"]), "icon-pitch-alignment": new Ua(ce.layout_symbol["icon-pitch-alignment"]), "text-pitch-alignment": new Ua(ce.layout_symbol["text-pitch-alignment"]), "text-rotation-alignment": new Ua(ce.layout_symbol["text-rotation-alignment"]), "text-field": new oo(ce.layout_symbol["text-field"]), "text-font": new oo(ce.layout_symbol["text-font"]), "text-size": new oo(ce.layout_symbol["text-size"]), "text-max-width": new oo(ce.layout_symbol["text-max-width"]), "text-line-height": new Ua(ce.layout_symbol["text-line-height"]), "text-letter-spacing": new oo(ce.layout_symbol["text-letter-spacing"]), "text-justify": new oo(ce.layout_symbol["text-justify"]), "text-radial-offset": new oo(ce.layout_symbol["text-radial-offset"]), "text-variable-anchor": new Ua(ce.layout_symbol["text-variable-anchor"]), "text-variable-anchor-offset": new oo(ce.layout_symbol["text-variable-anchor-offset"]), "text-anchor": new oo(ce.layout_symbol["text-anchor"]), "text-max-angle": new Ua(ce.layout_symbol["text-max-angle"]), "text-writing-mode": new Ua(ce.layout_symbol["text-writing-mode"]), "text-rotate": new oo(ce.layout_symbol["text-rotate"]), "text-padding": new Ua(ce.layout_symbol["text-padding"]), "text-keep-upright": new Ua(ce.layout_symbol["text-keep-upright"]), "text-transform": new oo(ce.layout_symbol["text-transform"]), "text-offset": new oo(ce.layout_symbol["text-offset"]), "text-allow-overlap": new Ua(ce.layout_symbol["text-allow-overlap"]), "text-overlap": new Ua(ce.layout_symbol["text-overlap"]), "text-ignore-placement": new Ua(ce.layout_symbol["text-ignore-placement"]), "text-optional": new Ua(ce.layout_symbol["text-optional"]) });\n                } };\n                class Zx {\n                  constructor(A3) {\n                    if (A3.property.overrides === void 0) throw new Error("overrides must be provided to instantiate FormatSectionOverride class");\n                    this.type = A3.property.overrides ? A3.property.overrides.runtimeType : Vt, this.defaultValue = A3;\n                  }\n                  evaluate(A3) {\n                    if (A3.formattedSection) {\n                      let F3 = this.defaultValue.property.overrides;\n                      if (F3 && F3.hasOverride(A3.formattedSection)) return F3.getOverride(A3.formattedSection);\n                    }\n                    return A3.feature && A3.featureState ? this.defaultValue.evaluate(A3.feature, A3.featureState) : this.defaultValue.property.specification.default;\n                  }\n                  eachChild(A3) {\n                    this.defaultValue.isConstant() || A3(this.defaultValue.value._styleExpression.expression);\n                  }\n                  outputDefined() {\n                    return false;\n                  }\n                  serialize() {\n                    return null;\n                  }\n                }\n                Fi("FormatSectionOverride", Zx, { omit: ["defaultValue"] });\n                class cy extends B4 {\n                  constructor(A3) {\n                    super(A3, zw);\n                  }\n                  recalculate(A3, F3) {\n                    if (super.recalculate(A3, F3), this.layout.get("icon-rotation-alignment") === "auto" && (this.layout._values["icon-rotation-alignment"] = this.layout.get("symbol-placement") !== "point" ? "map" : "viewport"), this.layout.get("text-rotation-alignment") === "auto" && (this.layout._values["text-rotation-alignment"] = this.layout.get("symbol-placement") !== "point" ? "map" : "viewport"), this.layout.get("text-pitch-alignment") === "auto" && (this.layout._values["text-pitch-alignment"] = this.layout.get("text-rotation-alignment") === "map" ? "map" : "viewport"), this.layout.get("icon-pitch-alignment") === "auto" && (this.layout._values["icon-pitch-alignment"] = this.layout.get("icon-rotation-alignment")), this.layout.get("symbol-placement") === "point") {\n                      let W = this.layout.get("text-writing-mode");\n                      if (W) {\n                        let re = [];\n                        for (let fe of W) re.indexOf(fe) < 0 && re.push(fe);\n                        this.layout._values["text-writing-mode"] = re;\n                      } else this.layout._values["text-writing-mode"] = ["horizontal"];\n                    }\n                    this._setPaintOverrides();\n                  }\n                  getValueAndResolveTokens(A3, F3, W, re) {\n                    let fe = this.layout.get(A3).evaluate(F3, {}, W, re), pe = this._unevaluatedLayout._values[A3];\n                    return pe.isDataDriven() || Dc(pe.value) || !fe ? fe : (function(ze, Ke) {\n                      return Ke.replace(/{([^{}]+)}/g, (ct, Lt) => ze && Lt in ze ? String(ze[Lt]) : "");\n                    })(F3.properties, fe);\n                  }\n                  createBucket(A3) {\n                    return new M1(A3);\n                  }\n                  queryRadius() {\n                    return 0;\n                  }\n                  queryIntersectsFeature() {\n                    throw new Error("Should take a different path in FeatureIndex");\n                  }\n                  _setPaintOverrides() {\n                    for (let A3 of zw.paint.overridableProperties) {\n                      if (!cy.hasPaintOverride(this.layout, A3)) continue;\n                      let F3 = this.paint.get(A3), W = new Zx(F3), re = new Eu(W, F3.property.specification), fe = null;\n                      fe = F3.value.kind === "constant" || F3.value.kind === "source" ? new bc("source", re) : new hu("composite", re, F3.value.zoomStops), this.paint._values[A3] = new xu(F3.property, fe, F3.parameters);\n                    }\n                  }\n                  _handleOverridablePaintPropertyUpdate(A3, F3, W) {\n                    return !(!this.layout || F3.isDataDriven() || W.isDataDriven()) && cy.hasPaintOverride(this.layout, A3);\n                  }\n                  static hasPaintOverride(A3, F3) {\n                    let W = A3.get("text-field"), re = zw.paint.properties[F3], fe = false, pe = (ze) => {\n                      for (let Ke of ze) if (re.overrides && re.overrides.hasOverride(Ke)) return void (fe = true);\n                    };\n                    if (W.value.kind === "constant" && W.value.value instanceof ri) pe(W.value.value.sections);\n                    else if (W.value.kind === "source") {\n                      let ze = (ct) => {\n                        fe || (ct instanceof ua && Sn(ct.value) === ti ? pe(ct.value.sections) : ct instanceof Zl ? pe(ct.sections) : ct.eachChild(ze));\n                      }, Ke = W.value;\n                      Ke._styleExpression && ze(Ke._styleExpression.expression);\n                    }\n                    return fe;\n                  }\n                }\n                let MC;\n                var Yx = { get paint() {\n                  return MC = MC || new ue({ "background-color": new Ua(ce.paint_background["background-color"]), "background-pattern": new hc(ce.paint_background["background-pattern"]), "background-opacity": new Ua(ce.paint_background["background-opacity"]) });\n                } };\n                class J9 extends B4 {\n                  constructor(A3) {\n                    super(A3, Yx);\n                  }\n                }\n                let fS;\n                var EC = { get paint() {\n                  return fS = fS || new ue({ "raster-opacity": new Ua(ce.paint_raster["raster-opacity"]), "raster-hue-rotate": new Ua(ce.paint_raster["raster-hue-rotate"]), "raster-brightness-min": new Ua(ce.paint_raster["raster-brightness-min"]), "raster-brightness-max": new Ua(ce.paint_raster["raster-brightness-max"]), "raster-saturation": new Ua(ce.paint_raster["raster-saturation"]), "raster-contrast": new Ua(ce.paint_raster["raster-contrast"]), "raster-resampling": new Ua(ce.paint_raster["raster-resampling"]), "raster-fade-duration": new Ua(ce.paint_raster["raster-fade-duration"]) });\n                } };\n                class Kx extends B4 {\n                  constructor(A3) {\n                    super(A3, EC);\n                  }\n                }\n                class hS extends B4 {\n                  constructor(A3) {\n                    super(A3, {}), this.onAdd = (F3) => {\n                      this.implementation.onAdd && this.implementation.onAdd(F3, F3.painter.context.gl);\n                    }, this.onRemove = (F3) => {\n                      this.implementation.onRemove && this.implementation.onRemove(F3, F3.painter.context.gl);\n                    }, this.implementation = A3;\n                  }\n                  is3D() {\n                    return this.implementation.renderingMode === "3d";\n                  }\n                  hasOffscreenPass() {\n                    return this.implementation.prerender !== void 0;\n                  }\n                  recalculate() {\n                  }\n                  updateTransitions() {\n                  }\n                  hasTransition() {\n                    return false;\n                  }\n                  serialize() {\n                    throw new Error("Custom layers cannot be serialized");\n                  }\n                }\n                class dS {\n                  constructor(A3) {\n                    this._methodToThrottle = A3, this._triggered = false, typeof MessageChannel != "undefined" && (this._channel = new MessageChannel(), this._channel.port2.onmessage = () => {\n                      this._triggered = false, this._methodToThrottle();\n                    });\n                  }\n                  trigger() {\n                    this._triggered || (this._triggered = true, this._channel ? this._channel.port1.postMessage(true) : setTimeout(() => {\n                      this._triggered = false, this._methodToThrottle();\n                    }, 0));\n                  }\n                  remove() {\n                    delete this._channel, this._methodToThrottle = () => {\n                    };\n                  }\n                }\n                let vS = 63710088e-1;\n                class dg {\n                  constructor(A3, F3) {\n                    if (isNaN(A3) || isNaN(F3)) throw new Error(`Invalid LngLat object: (${A3}, ${F3})`);\n                    if (this.lng = +A3, this.lat = +F3, this.lat > 90 || this.lat < -90) throw new Error("Invalid LngLat latitude value: must be between -90 and 90");\n                  }\n                  wrap() {\n                    return new dg(S2(this.lng, -180, 180), this.lat);\n                  }\n                  toArray() {\n                    return [this.lng, this.lat];\n                  }\n                  toString() {\n                    return `LngLat(${this.lng}, ${this.lat})`;\n                  }\n                  distanceTo(A3) {\n                    let F3 = Math.PI / 180, W = this.lat * F3, re = A3.lat * F3, fe = Math.sin(W) * Math.sin(re) + Math.cos(W) * Math.cos(re) * Math.cos((A3.lng - this.lng) * F3);\n                    return vS * Math.acos(Math.min(fe, 1));\n                  }\n                  static convert(A3) {\n                    if (A3 instanceof dg) return A3;\n                    if (Array.isArray(A3) && (A3.length === 2 || A3.length === 3)) return new dg(Number(A3[0]), Number(A3[1]));\n                    if (!Array.isArray(A3) && typeof A3 == "object" && A3 !== null) return new dg(Number("lng" in A3 ? A3.lng : A3.lon), Number(A3.lat));\n                    throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: <lng>, lat: <lat>}, an object {lon: <lng>, lat: <lat>}, or an array of [<lng>, <lat>]");\n                  }\n                }\n                let E1 = 2 * Math.PI * vS;\n                function kC(R) {\n                  return E1 * Math.cos(R * Math.PI / 180);\n                }\n                function Ow(R) {\n                  return (180 + R) / 360;\n                }\n                function CC(R) {\n                  return (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + R * Math.PI / 360))) / 360;\n                }\n                function qw(R, A3) {\n                  return R / kC(A3);\n                }\n                function Jx(R) {\n                  return 360 / Math.PI * Math.atan(Math.exp((180 - 360 * R) * Math.PI / 180)) - 90;\n                }\n                class $x {\n                  constructor(A3, F3, W = 0) {\n                    this.x = +A3, this.y = +F3, this.z = +W;\n                  }\n                  static fromLngLat(A3, F3 = 0) {\n                    let W = dg.convert(A3);\n                    return new $x(Ow(W.lng), CC(W.lat), qw(F3, W.lat));\n                  }\n                  toLngLat() {\n                    return new dg(360 * this.x - 180, Jx(this.y));\n                  }\n                  toAltitude() {\n                    return this.z * kC(Jx(this.y));\n                  }\n                  meterInMercatorCoordinateUnits() {\n                    return 1 / E1 * (A3 = Jx(this.y), 1 / Math.cos(A3 * Math.PI / 180));\n                    var A3;\n                  }\n                }\n                function mp(R, A3, F3) {\n                  var W = 2 * Math.PI * 6378137 / 256 / Math.pow(2, F3);\n                  return [R * W - 2 * Math.PI * 6378137 / 2, A3 * W - 2 * Math.PI * 6378137 / 2];\n                }\n                class pS {\n                  constructor(A3, F3, W) {\n                    if (!(function(re, fe, pe) {\n                      return !(re < 0 || re > 25 || pe < 0 || pe >= Math.pow(2, re) || fe < 0 || fe >= Math.pow(2, re));\n                    })(A3, F3, W)) throw new Error(`x=${F3}, y=${W}, z=${A3} outside of bounds. 0<=x<${Math.pow(2, A3)}, 0<=y<${Math.pow(2, A3)} 0<=z<=25 `);\n                    this.z = A3, this.x = F3, this.y = W, this.key = Qx(0, A3, A3, F3, W);\n                  }\n                  equals(A3) {\n                    return this.z === A3.z && this.x === A3.x && this.y === A3.y;\n                  }\n                  url(A3, F3, W) {\n                    let re = (pe = this.y, ze = this.z, Ke = mp(256 * (fe = this.x), 256 * (pe = Math.pow(2, ze) - pe - 1), ze), ct = mp(256 * (fe + 1), 256 * (pe + 1), ze), Ke[0] + "," + Ke[1] + "," + ct[0] + "," + ct[1]);\n                    var fe, pe, ze, Ke, ct;\n                    let Lt = (function($t, fr, mr) {\n                      let Pr, zr = "";\n                      for (let ui = $t; ui > 0; ui--) Pr = 1 << ui - 1, zr += (fr & Pr ? 1 : 0) + (mr & Pr ? 2 : 0);\n                      return zr;\n                    })(this.z, this.x, this.y);\n                    return A3[(this.x + this.y) % A3.length].replace(/{prefix}/g, (this.x % 16).toString(16) + (this.y % 16).toString(16)).replace(/{z}/g, String(this.z)).replace(/{x}/g, String(this.x)).replace(/{y}/g, String(W === "tms" ? Math.pow(2, this.z) - this.y - 1 : this.y)).replace(/{ratio}/g, F3 > 1 ? "@2x" : "").replace(/{quadkey}/g, Lt).replace(/{bbox-epsg-3857}/g, re);\n                  }\n                  isChildOf(A3) {\n                    let F3 = this.z - A3.z;\n                    return F3 > 0 && A3.x === this.x >> F3 && A3.y === this.y >> F3;\n                  }\n                  getTilePoint(A3) {\n                    let F3 = Math.pow(2, this.z);\n                    return new u4((A3.x * F3 - this.x) * ja, (A3.y * F3 - this.y) * ja);\n                  }\n                  toString() {\n                    return `${this.z}/${this.x}/${this.y}`;\n                  }\n                }\n                class LC {\n                  constructor(A3, F3) {\n                    this.wrap = A3, this.canonical = F3, this.key = Qx(A3, F3.z, F3.z, F3.x, F3.y);\n                  }\n                }\n                class $v {\n                  constructor(A3, F3, W, re, fe) {\n                    if (A3 < W) throw new Error(`overscaledZ should be >= z; overscaledZ = ${A3}; z = ${W}`);\n                    this.overscaledZ = A3, this.wrap = F3, this.canonical = new pS(W, +re, +fe), this.key = Qx(F3, A3, W, re, fe);\n                  }\n                  clone() {\n                    return new $v(this.overscaledZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);\n                  }\n                  equals(A3) {\n                    return this.overscaledZ === A3.overscaledZ && this.wrap === A3.wrap && this.canonical.equals(A3.canonical);\n                  }\n                  scaledTo(A3) {\n                    if (A3 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${A3}; overscaledZ = ${this.overscaledZ}`);\n                    let F3 = this.canonical.z - A3;\n                    return A3 > this.canonical.z ? new $v(A3, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y) : new $v(A3, this.wrap, A3, this.canonical.x >> F3, this.canonical.y >> F3);\n                  }\n                  calculateScaledKey(A3, F3) {\n                    if (A3 > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${A3}; overscaledZ = ${this.overscaledZ}`);\n                    let W = this.canonical.z - A3;\n                    return A3 > this.canonical.z ? Qx(this.wrap * +F3, A3, this.canonical.z, this.canonical.x, this.canonical.y) : Qx(this.wrap * +F3, A3, A3, this.canonical.x >> W, this.canonical.y >> W);\n                  }\n                  isChildOf(A3) {\n                    if (A3.wrap !== this.wrap) return false;\n                    let F3 = this.canonical.z - A3.canonical.z;\n                    return A3.overscaledZ === 0 || A3.overscaledZ < this.overscaledZ && A3.canonical.x === this.canonical.x >> F3 && A3.canonical.y === this.canonical.y >> F3;\n                  }\n                  children(A3) {\n                    if (this.overscaledZ >= A3) return [new $v(this.overscaledZ + 1, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y)];\n                    let F3 = this.canonical.z + 1, W = 2 * this.canonical.x, re = 2 * this.canonical.y;\n                    return [new $v(F3, this.wrap, F3, W, re), new $v(F3, this.wrap, F3, W + 1, re), new $v(F3, this.wrap, F3, W, re + 1), new $v(F3, this.wrap, F3, W + 1, re + 1)];\n                  }\n                  isLessThan(A3) {\n                    return this.wrap < A3.wrap || !(this.wrap > A3.wrap) && (this.overscaledZ < A3.overscaledZ || !(this.overscaledZ > A3.overscaledZ) && (this.canonical.x < A3.canonical.x || !(this.canonical.x > A3.canonical.x) && this.canonical.y < A3.canonical.y));\n                  }\n                  wrapped() {\n                    return new $v(this.overscaledZ, 0, this.canonical.z, this.canonical.x, this.canonical.y);\n                  }\n                  unwrapTo(A3) {\n                    return new $v(this.overscaledZ, A3, this.canonical.z, this.canonical.x, this.canonical.y);\n                  }\n                  overscaleFactor() {\n                    return Math.pow(2, this.overscaledZ - this.canonical.z);\n                  }\n                  toUnwrapped() {\n                    return new LC(this.wrap, this.canonical);\n                  }\n                  toString() {\n                    return `${this.overscaledZ}/${this.canonical.x}/${this.canonical.y}`;\n                  }\n                  getTilePoint(A3) {\n                    return this.canonical.getTilePoint(new $x(A3.x - this.wrap, A3.y));\n                  }\n                }\n                function Qx(R, A3, F3, W, re) {\n                  (R *= 2) < 0 && (R = -1 * R - 1);\n                  let fe = 1 << F3;\n                  return (fe * fe * R + fe * re + W).toString(36) + F3.toString(36) + A3.toString(36);\n                }\n                Fi("CanonicalTileID", pS), Fi("OverscaledTileID", $v, { omit: ["posMatrix"] });\n                class PC {\n                  constructor(A3, F3, W, re = 1, fe = 1, pe = 1, ze = 0) {\n                    if (this.uid = A3, F3.height !== F3.width) throw new RangeError("DEM tiles must be square");\n                    if (W && !["mapbox", "terrarium", "custom"].includes(W)) return void T3(`"${W}" is not a valid encoding type. Valid types include "mapbox", "terrarium" and "custom".`);\n                    this.stride = F3.height;\n                    let Ke = this.dim = F3.height - 2;\n                    switch (this.data = new Uint32Array(F3.data.buffer), W) {\n                      case "terrarium":\n                        this.redFactor = 256, this.greenFactor = 1, this.blueFactor = 1 / 256, this.baseShift = 32768;\n                        break;\n                      case "custom":\n                        this.redFactor = re, this.greenFactor = fe, this.blueFactor = pe, this.baseShift = ze;\n                        break;\n                      default:\n                        this.redFactor = 6553.6, this.greenFactor = 25.6, this.blueFactor = 0.1, this.baseShift = 1e4;\n                    }\n                    for (let ct = 0; ct < Ke; ct++) this.data[this._idx(-1, ct)] = this.data[this._idx(0, ct)], this.data[this._idx(Ke, ct)] = this.data[this._idx(Ke - 1, ct)], this.data[this._idx(ct, -1)] = this.data[this._idx(ct, 0)], this.data[this._idx(ct, Ke)] = this.data[this._idx(ct, Ke - 1)];\n                    this.data[this._idx(-1, -1)] = this.data[this._idx(0, 0)], this.data[this._idx(Ke, -1)] = this.data[this._idx(Ke - 1, 0)], this.data[this._idx(-1, Ke)] = this.data[this._idx(0, Ke - 1)], this.data[this._idx(Ke, Ke)] = this.data[this._idx(Ke - 1, Ke - 1)], this.min = Number.MAX_SAFE_INTEGER, this.max = Number.MIN_SAFE_INTEGER;\n                    for (let ct = 0; ct < Ke; ct++) for (let Lt = 0; Lt < Ke; Lt++) {\n                      let $t = this.get(ct, Lt);\n                      $t > this.max && (this.max = $t), $t < this.min && (this.min = $t);\n                    }\n                  }\n                  get(A3, F3) {\n                    let W = new Uint8Array(this.data.buffer), re = 4 * this._idx(A3, F3);\n                    return this.unpack(W[re], W[re + 1], W[re + 2]);\n                  }\n                  getUnpackVector() {\n                    return [this.redFactor, this.greenFactor, this.blueFactor, this.baseShift];\n                  }\n                  _idx(A3, F3) {\n                    if (A3 < -1 || A3 >= this.dim + 1 || F3 < -1 || F3 >= this.dim + 1) throw new RangeError("out of range source coordinates for DEM data");\n                    return (F3 + 1) * this.stride + (A3 + 1);\n                  }\n                  unpack(A3, F3, W) {\n                    return A3 * this.redFactor + F3 * this.greenFactor + W * this.blueFactor - this.baseShift;\n                  }\n                  getPixels() {\n                    return new Ki({ width: this.stride, height: this.stride }, new Uint8Array(this.data.buffer));\n                  }\n                  backfillBorder(A3, F3, W) {\n                    if (this.dim !== A3.dim) throw new Error("dem dimension mismatch");\n                    let re = F3 * this.dim, fe = F3 * this.dim + this.dim, pe = W * this.dim, ze = W * this.dim + this.dim;\n                    switch (F3) {\n                      case -1:\n                        re = fe - 1;\n                        break;\n                      case 1:\n                        fe = re + 1;\n                    }\n                    switch (W) {\n                      case -1:\n                        pe = ze - 1;\n                        break;\n                      case 1:\n                        ze = pe + 1;\n                    }\n                    let Ke = -F3 * this.dim, ct = -W * this.dim;\n                    for (let Lt = pe; Lt < ze; Lt++) for (let $t = re; $t < fe; $t++) this.data[this._idx($t, Lt)] = A3.data[this._idx($t + Ke, Lt + ct)];\n                  }\n                }\n                Fi("DEMData", PC);\n                class IC {\n                  constructor(A3) {\n                    this._stringToNumber = {}, this._numberToString = [];\n                    for (let F3 = 0; F3 < A3.length; F3++) {\n                      let W = A3[F3];\n                      this._stringToNumber[W] = F3, this._numberToString[F3] = W;\n                    }\n                  }\n                  encode(A3) {\n                    return this._stringToNumber[A3];\n                  }\n                  decode(A3) {\n                    if (A3 >= this._numberToString.length) throw new Error(`Out of bounds. Index requested n=${A3} can\'t be >= this._numberToString.length ${this._numberToString.length}`);\n                    return this._numberToString[A3];\n                  }\n                }\n                class gS {\n                  constructor(A3, F3, W, re, fe) {\n                    this.type = "Feature", this._vectorTileFeature = A3, A3._z = F3, A3._x = W, A3._y = re, this.properties = A3.properties, this.id = fe;\n                  }\n                  get geometry() {\n                    return this._geometry === void 0 && (this._geometry = this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x, this._vectorTileFeature._y, this._vectorTileFeature._z).geometry), this._geometry;\n                  }\n                  set geometry(A3) {\n                    this._geometry = A3;\n                  }\n                  toJSON() {\n                    let A3 = { geometry: this.geometry };\n                    for (let F3 in this) F3 !== "_geometry" && F3 !== "_vectorTileFeature" && (A3[F3] = this[F3]);\n                    return A3;\n                  }\n                }\n                class fy {\n                  constructor(A3, F3) {\n                    this.tileID = A3, this.x = A3.canonical.x, this.y = A3.canonical.y, this.z = A3.canonical.z, this.grid = new Qi(ja, 16, 0), this.grid3D = new Qi(ja, 16, 0), this.featureIndexArray = new Ts(), this.promoteId = F3;\n                  }\n                  insert(A3, F3, W, re, fe, pe) {\n                    let ze = this.featureIndexArray.length;\n                    this.featureIndexArray.emplaceBack(W, re, fe);\n                    let Ke = pe ? this.grid3D : this.grid;\n                    for (let ct = 0; ct < F3.length; ct++) {\n                      let Lt = F3[ct], $t = [1 / 0, 1 / 0, -1 / 0, -1 / 0];\n                      for (let fr = 0; fr < Lt.length; fr++) {\n                        let mr = Lt[fr];\n                        $t[0] = Math.min($t[0], mr.x), $t[1] = Math.min($t[1], mr.y), $t[2] = Math.max($t[2], mr.x), $t[3] = Math.max($t[3], mr.y);\n                      }\n                      $t[0] < ja && $t[1] < ja && $t[2] >= 0 && $t[3] >= 0 && Ke.insert(ze, $t[0], $t[1], $t[2], $t[3]);\n                    }\n                  }\n                  loadVTLayers() {\n                    return this.vtLayers || (this.vtLayers = new br.VectorTile(new nS(this.rawTileData)).layers, this.sourceLayerCoder = new IC(this.vtLayers ? Object.keys(this.vtLayers).sort() : ["_geojsonTileLayer"])), this.vtLayers;\n                  }\n                  query(A3, F3, W, re) {\n                    this.loadVTLayers();\n                    let fe = A3.params || {}, pe = ja / A3.tileSize / A3.scale, ze = Fc(fe.filter), Ke = A3.queryGeometry, ct = A3.queryPadding * pe, Lt = DC(Ke), $t = this.grid.query(Lt.minX - ct, Lt.minY - ct, Lt.maxX + ct, Lt.maxY + ct), fr = DC(A3.cameraQueryGeometry), mr = this.grid3D.query(fr.minX - ct, fr.minY - ct, fr.maxX + ct, fr.maxY + ct, (ui, yi, vn, zi) => (function(un, Tn, pa, ro, Vo) {\n                      for (let sa of un) if (Tn <= sa.x && pa <= sa.y && ro >= sa.x && Vo >= sa.y) return true;\n                      let Xa = [new u4(Tn, pa), new u4(Tn, Vo), new u4(ro, Vo), new u4(ro, pa)];\n                      if (un.length > 2) {\n                        for (let sa of Xa) if (Ui(un, sa)) return true;\n                      }\n                      for (let sa = 0; sa < un.length - 1; sa++) if (qi(un[sa], un[sa + 1], Xa)) return true;\n                      return false;\n                    })(A3.cameraQueryGeometry, ui - ct, yi - ct, vn + ct, zi + ct));\n                    for (let ui of mr) $t.push(ui);\n                    $t.sort($9);\n                    let Pr = {}, zr;\n                    for (let ui = 0; ui < $t.length; ui++) {\n                      let yi = $t[ui];\n                      if (yi === zr) continue;\n                      zr = yi;\n                      let vn = this.featureIndexArray.get(yi), zi = null;\n                      this.loadMatchingFeature(Pr, vn.bucketIndex, vn.sourceLayerIndex, vn.featureIndex, ze, fe.layers, fe.availableImages, F3, W, re, (un, Tn, pa) => (zi || (zi = $s(un)), Tn.queryIntersectsFeature(Ke, un, pa, zi, this.z, A3.transform, pe, A3.pixelPosMatrix)));\n                    }\n                    return Pr;\n                  }\n                  loadMatchingFeature(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t) {\n                    let fr = this.bucketLayerIDs[F3];\n                    if (pe && !(function(ui, yi) {\n                      for (let vn = 0; vn < ui.length; vn++) if (yi.indexOf(ui[vn]) >= 0) return true;\n                      return false;\n                    })(pe, fr)) return;\n                    let mr = this.sourceLayerCoder.decode(W), Pr = this.vtLayers[mr].feature(re);\n                    if (fe.needGeometry) {\n                      let ui = Sl(Pr, true);\n                      if (!fe.filter(new rs(this.tileID.overscaledZ), ui, this.tileID.canonical)) return;\n                    } else if (!fe.filter(new rs(this.tileID.overscaledZ), Pr)) return;\n                    let zr = this.getId(Pr, mr);\n                    for (let ui = 0; ui < fr.length; ui++) {\n                      let yi = fr[ui];\n                      if (pe && pe.indexOf(yi) < 0) continue;\n                      let vn = Ke[yi];\n                      if (!vn) continue;\n                      let zi = {};\n                      zr && Lt && (zi = Lt.getState(vn.sourceLayer || "_geojsonTileLayer", zr));\n                      let un = L3({}, ct[yi]);\n                      un.paint = RC(un.paint, vn.paint, Pr, zi, ze), un.layout = RC(un.layout, vn.layout, Pr, zi, ze);\n                      let Tn = !$t || $t(Pr, vn, zi);\n                      if (!Tn) continue;\n                      let pa = new gS(Pr, this.z, this.x, this.y, zr);\n                      pa.layer = un;\n                      let ro = A3[yi];\n                      ro === void 0 && (ro = A3[yi] = []), ro.push({ featureIndex: re, feature: pa, intersectionZ: Tn });\n                    }\n                  }\n                  lookupSymbolFeatures(A3, F3, W, re, fe, pe, ze, Ke) {\n                    let ct = {};\n                    this.loadVTLayers();\n                    let Lt = Fc(fe);\n                    for (let $t of A3) this.loadMatchingFeature(ct, W, re, $t, Lt, pe, ze, Ke, F3);\n                    return ct;\n                  }\n                  hasLayer(A3) {\n                    for (let F3 of this.bucketLayerIDs) for (let W of F3) if (A3 === W) return true;\n                    return false;\n                  }\n                  getId(A3, F3) {\n                    let W = A3.id;\n                    return this.promoteId && (W = A3.properties[typeof this.promoteId == "string" ? this.promoteId : this.promoteId[F3]], typeof W == "boolean" && (W = Number(W))), W;\n                  }\n                }\n                function RC(R, A3, F3, W, re) {\n                  return C3(R, (fe, pe) => {\n                    let ze = A3 instanceof Ac ? A3.get(pe) : null;\n                    return ze && ze.evaluate ? ze.evaluate(F3, W, re) : ze;\n                  });\n                }\n                function DC(R) {\n                  let A3 = 1 / 0, F3 = 1 / 0, W = -1 / 0, re = -1 / 0;\n                  for (let fe of R) A3 = Math.min(A3, fe.x), F3 = Math.min(F3, fe.y), W = Math.max(W, fe.x), re = Math.max(re, fe.y);\n                  return { minX: A3, minY: F3, maxX: W, maxY: re };\n                }\n                function $9(R, A3) {\n                  return A3 - R;\n                }\n                function FC(R, A3, F3, W, re) {\n                  let fe = [];\n                  for (let pe = 0; pe < R.length; pe++) {\n                    let ze = R[pe], Ke;\n                    for (let ct = 0; ct < ze.length - 1; ct++) {\n                      let Lt = ze[ct], $t = ze[ct + 1];\n                      Lt.x < A3 && $t.x < A3 || (Lt.x < A3 ? Lt = new u4(A3, Lt.y + (A3 - Lt.x) / ($t.x - Lt.x) * ($t.y - Lt.y))._round() : $t.x < A3 && ($t = new u4(A3, Lt.y + (A3 - Lt.x) / ($t.x - Lt.x) * ($t.y - Lt.y))._round()), Lt.y < F3 && $t.y < F3 || (Lt.y < F3 ? Lt = new u4(Lt.x + (F3 - Lt.y) / ($t.y - Lt.y) * ($t.x - Lt.x), F3)._round() : $t.y < F3 && ($t = new u4(Lt.x + (F3 - Lt.y) / ($t.y - Lt.y) * ($t.x - Lt.x), F3)._round()), Lt.x >= W && $t.x >= W || (Lt.x >= W ? Lt = new u4(W, Lt.y + (W - Lt.x) / ($t.x - Lt.x) * ($t.y - Lt.y))._round() : $t.x >= W && ($t = new u4(W, Lt.y + (W - Lt.x) / ($t.x - Lt.x) * ($t.y - Lt.y))._round()), Lt.y >= re && $t.y >= re || (Lt.y >= re ? Lt = new u4(Lt.x + (re - Lt.y) / ($t.y - Lt.y) * ($t.x - Lt.x), re)._round() : $t.y >= re && ($t = new u4(Lt.x + (re - Lt.y) / ($t.y - Lt.y) * ($t.x - Lt.x), re)._round()), Ke && Lt.equals(Ke[Ke.length - 1]) || (Ke = [Lt], fe.push(Ke)), Ke.push($t)))));\n                    }\n                  }\n                  return fe;\n                }\n                Fi("FeatureIndex", fy, { omit: ["rawTileData", "sourceLayerCoder"] });\n                class vg extends u4 {\n                  constructor(A3, F3, W, re) {\n                    super(A3, F3), this.angle = W, re !== void 0 && (this.segment = re);\n                  }\n                  clone() {\n                    return new vg(this.x, this.y, this.angle, this.segment);\n                  }\n                }\n                function mS(R, A3, F3, W, re) {\n                  if (A3.segment === void 0 || F3 === 0) return true;\n                  let fe = A3, pe = A3.segment + 1, ze = 0;\n                  for (; ze > -F3 / 2; ) {\n                    if (pe--, pe < 0) return false;\n                    ze -= R[pe].dist(fe), fe = R[pe];\n                  }\n                  ze += R[pe].dist(R[pe + 1]), pe++;\n                  let Ke = [], ct = 0;\n                  for (; ze < F3 / 2; ) {\n                    let Lt = R[pe], $t = R[pe + 1];\n                    if (!$t) return false;\n                    let fr = R[pe - 1].angleTo(Lt) - Lt.angleTo($t);\n                    for (fr = Math.abs((fr + 3 * Math.PI) % (2 * Math.PI) - Math.PI), Ke.push({ distance: ze, angleDelta: fr }), ct += fr; ze - Ke[0].distance > W; ) ct -= Ke.shift().angleDelta;\n                    if (ct > re) return false;\n                    pe++, ze += Lt.dist($t);\n                  }\n                  return true;\n                }\n                function zC(R) {\n                  let A3 = 0;\n                  for (let F3 = 0; F3 < R.length - 1; F3++) A3 += R[F3].dist(R[F3 + 1]);\n                  return A3;\n                }\n                function OC(R, A3, F3) {\n                  return R ? 0.6 * A3 * F3 : 0;\n                }\n                function qC(R, A3) {\n                  return Math.max(R ? R.right - R.left : 0, A3 ? A3.right - A3.left : 0);\n                }\n                function Q9(R, A3, F3, W, re, fe) {\n                  let pe = OC(F3, re, fe), ze = qC(F3, W) * fe, Ke = 0, ct = zC(R) / 2;\n                  for (let Lt = 0; Lt < R.length - 1; Lt++) {\n                    let $t = R[Lt], fr = R[Lt + 1], mr = $t.dist(fr);\n                    if (Ke + mr > ct) {\n                      let Pr = (ct - Ke) / mr, zr = Lo.number($t.x, fr.x, Pr), ui = Lo.number($t.y, fr.y, Pr), yi = new vg(zr, ui, fr.angleTo($t), Lt);\n                      return yi._round(), !pe || mS(R, yi, ze, pe, A3) ? yi : void 0;\n                    }\n                    Ke += mr;\n                  }\n                }\n                function eO(R, A3, F3, W, re, fe, pe, ze, Ke) {\n                  let ct = OC(W, fe, pe), Lt = qC(W, re), $t = Lt * pe, fr = R[0].x === 0 || R[0].x === Ke || R[0].y === 0 || R[0].y === Ke;\n                  return A3 - $t < A3 / 4 && (A3 = $t + A3 / 4), BC(R, fr ? A3 / 2 * ze % A3 : (Lt / 2 + 2 * fe) * pe * ze % A3, A3, ct, F3, $t, fr, false, Ke);\n                }\n                function BC(R, A3, F3, W, re, fe, pe, ze, Ke) {\n                  let ct = fe / 2, Lt = zC(R), $t = 0, fr = A3 - F3, mr = [];\n                  for (let Pr = 0; Pr < R.length - 1; Pr++) {\n                    let zr = R[Pr], ui = R[Pr + 1], yi = zr.dist(ui), vn = ui.angleTo(zr);\n                    for (; fr + F3 < $t + yi; ) {\n                      fr += F3;\n                      let zi = (fr - $t) / yi, un = Lo.number(zr.x, ui.x, zi), Tn = Lo.number(zr.y, ui.y, zi);\n                      if (un >= 0 && un < Ke && Tn >= 0 && Tn < Ke && fr - ct >= 0 && fr + ct <= Lt) {\n                        let pa = new vg(un, Tn, vn, Pr);\n                        pa._round(), W && !mS(R, pa, fe, W, re) || mr.push(pa);\n                      }\n                    }\n                    $t += yi;\n                  }\n                  return ze || mr.length || pe || (mr = BC(R, $t / 2, F3, W, re, fe, pe, true, Ke)), mr;\n                }\n                Fi("Anchor", vg);\n                let k1 = Md;\n                function NC(R, A3, F3, W) {\n                  let re = [], fe = R.image, pe = fe.pixelRatio, ze = fe.paddedRect.w - 2 * k1, Ke = fe.paddedRect.h - 2 * k1, ct = { x1: R.left, y1: R.top, x2: R.right, y2: R.bottom }, Lt = fe.stretchX || [[0, ze]], $t = fe.stretchY || [[0, Ke]], fr = (Xn, Ro) => Xn + Ro[1] - Ro[0], mr = Lt.reduce(fr, 0), Pr = $t.reduce(fr, 0), zr = ze - mr, ui = Ke - Pr, yi = 0, vn = mr, zi = 0, un = Pr, Tn = 0, pa = zr, ro = 0, Vo = ui;\n                  if (fe.content && W) {\n                    let Xn = fe.content, Ro = Xn[2] - Xn[0], uo = Xn[3] - Xn[1];\n                    (fe.textFitWidth || fe.textFitHeight) && (ct = TC(R)), yi = pg(Lt, 0, Xn[0]), zi = pg($t, 0, Xn[1]), vn = pg(Lt, Xn[0], Xn[2]), un = pg($t, Xn[1], Xn[3]), Tn = Xn[0] - yi, ro = Xn[1] - zi, pa = Ro - vn, Vo = uo - un;\n                  }\n                  let Xa = ct.x1, sa = ct.y1, Mo = ct.x2 - Xa, fo = ct.y2 - sa, lo = (Xn, Ro, uo, $o) => {\n                    let Ju = Bw(Xn.stretch - yi, vn, Mo, Xa), qu = C1(Xn.fixed - Tn, pa, Xn.stretch, mr), Mh = Bw(Ro.stretch - zi, un, fo, sa), Qv = C1(Ro.fixed - ro, Vo, Ro.stretch, Pr), ld = Bw(uo.stretch - yi, vn, Mo, Xa), Eh = C1(uo.fixed - Tn, pa, uo.stretch, mr), Gd = Bw($o.stretch - zi, un, fo, sa), Hd = C1($o.fixed - ro, Vo, $o.stretch, Pr), jd = new u4(Ju, Mh), Af = new u4(ld, Mh), kh = new u4(ld, Gd), Ed = new u4(Ju, Gd), ud = new u4(qu / pe, Qv / pe), Wh = new u4(Eh / pe, Hd / pe), Df = A3 * Math.PI / 180;\n                    if (Df) {\n                      let tu = Math.sin(Df), pc = Math.cos(Df), $u = [pc, -tu, tu, pc];\n                      jd._matMult($u), Af._matMult($u), Ed._matMult($u), kh._matMult($u);\n                    }\n                    let Fv = Xn.stretch + Xn.fixed, lv = Ro.stretch + Ro.fixed;\n                    return { tl: jd, tr: Af, bl: Ed, br: kh, tex: { x: fe.paddedRect.x + k1 + Fv, y: fe.paddedRect.y + k1 + lv, w: uo.stretch + uo.fixed - Fv, h: $o.stretch + $o.fixed - lv }, writingMode: void 0, glyphOffset: [0, 0], sectionIndex: 0, pixelOffsetTL: ud, pixelOffsetBR: Wh, minFontScaleX: pa / pe / Mo, minFontScaleY: Vo / pe / fo, isSDF: F3 };\n                  };\n                  if (W && (fe.stretchX || fe.stretchY)) {\n                    let Xn = UC(Lt, zr, mr), Ro = UC($t, ui, Pr);\n                    for (let uo = 0; uo < Xn.length - 1; uo++) {\n                      let $o = Xn[uo], Ju = Xn[uo + 1];\n                      for (let qu = 0; qu < Ro.length - 1; qu++) re.push(lo($o, Ro[qu], Ju, Ro[qu + 1]));\n                    }\n                  } else re.push(lo({ fixed: 0, stretch: -1 }, { fixed: 0, stretch: -1 }, { fixed: 0, stretch: ze + 1 }, { fixed: 0, stretch: Ke + 1 }));\n                  return re;\n                }\n                function pg(R, A3, F3) {\n                  let W = 0;\n                  for (let re of R) W += Math.max(A3, Math.min(F3, re[1])) - Math.max(A3, Math.min(F3, re[0]));\n                  return W;\n                }\n                function UC(R, A3, F3) {\n                  let W = [{ fixed: -k1, stretch: 0 }];\n                  for (let [re, fe] of R) {\n                    let pe = W[W.length - 1];\n                    W.push({ fixed: re - pe.stretch, stretch: pe.stretch }), W.push({ fixed: re - pe.stretch, stretch: pe.stretch + (fe - re) });\n                  }\n                  return W.push({ fixed: A3 + k1, stretch: F3 }), W;\n                }\n                function Bw(R, A3, F3, W) {\n                  return R / A3 * F3 + W;\n                }\n                function C1(R, A3, F3, W) {\n                  return R - A3 * F3 / W;\n                }\n                class fm {\n                  constructor(A3, F3, W, re, fe, pe, ze, Ke, ct, Lt) {\n                    var $t;\n                    if (this.boxStartIndex = A3.length, ct) {\n                      let fr = pe.top, mr = pe.bottom, Pr = pe.collisionPadding;\n                      Pr && (fr -= Pr[1], mr += Pr[3]);\n                      let zr = mr - fr;\n                      zr > 0 && (zr = Math.max(10, zr), this.circleDiameter = zr);\n                    } else {\n                      let fr = !(($t = pe.image) === null || $t === void 0) && $t.content && (pe.image.textFitWidth || pe.image.textFitHeight) ? TC(pe) : { x1: pe.left, y1: pe.top, x2: pe.right, y2: pe.bottom };\n                      fr.y1 = fr.y1 * ze - Ke[0], fr.y2 = fr.y2 * ze + Ke[2], fr.x1 = fr.x1 * ze - Ke[3], fr.x2 = fr.x2 * ze + Ke[1];\n                      let mr = pe.collisionPadding;\n                      if (mr && (fr.x1 -= mr[0] * ze, fr.y1 -= mr[1] * ze, fr.x2 += mr[2] * ze, fr.y2 += mr[3] * ze), Lt) {\n                        let Pr = new u4(fr.x1, fr.y1), zr = new u4(fr.x2, fr.y1), ui = new u4(fr.x1, fr.y2), yi = new u4(fr.x2, fr.y2), vn = Lt * Math.PI / 180;\n                        Pr._rotate(vn), zr._rotate(vn), ui._rotate(vn), yi._rotate(vn), fr.x1 = Math.min(Pr.x, zr.x, ui.x, yi.x), fr.x2 = Math.max(Pr.x, zr.x, ui.x, yi.x), fr.y1 = Math.min(Pr.y, zr.y, ui.y, yi.y), fr.y2 = Math.max(Pr.y, zr.y, ui.y, yi.y);\n                      }\n                      A3.emplaceBack(F3.x, F3.y, fr.x1, fr.y1, fr.x2, fr.y2, W, re, fe);\n                    }\n                    this.boxEndIndex = A3.length;\n                  }\n                }\n                class Vp {\n                  constructor(A3 = [], F3 = (W, re) => W < re ? -1 : W > re ? 1 : 0) {\n                    if (this.data = A3, this.length = this.data.length, this.compare = F3, this.length > 0) for (let W = (this.length >> 1) - 1; W >= 0; W--) this._down(W);\n                  }\n                  push(A3) {\n                    this.data.push(A3), this._up(this.length++);\n                  }\n                  pop() {\n                    if (this.length === 0) return;\n                    let A3 = this.data[0], F3 = this.data.pop();\n                    return --this.length > 0 && (this.data[0] = F3, this._down(0)), A3;\n                  }\n                  peek() {\n                    return this.data[0];\n                  }\n                  _up(A3) {\n                    let { data: F3, compare: W } = this, re = F3[A3];\n                    for (; A3 > 0; ) {\n                      let fe = A3 - 1 >> 1, pe = F3[fe];\n                      if (W(re, pe) >= 0) break;\n                      F3[A3] = pe, A3 = fe;\n                    }\n                    F3[A3] = re;\n                  }\n                  _down(A3) {\n                    let { data: F3, compare: W } = this, re = this.length >> 1, fe = F3[A3];\n                    for (; A3 < re; ) {\n                      let pe = 1 + (A3 << 1), ze = pe + 1;\n                      if (ze < this.length && W(F3[ze], F3[pe]) < 0 && (pe = ze), W(F3[pe], fe) >= 0) break;\n                      F3[A3] = F3[pe], A3 = pe;\n                    }\n                    F3[A3] = fe;\n                  }\n                }\n                function tO(R, A3 = 1, F3 = false) {\n                  let W = 1 / 0, re = 1 / 0, fe = -1 / 0, pe = -1 / 0, ze = R[0];\n                  for (let mr = 0; mr < ze.length; mr++) {\n                    let Pr = ze[mr];\n                    (!mr || Pr.x < W) && (W = Pr.x), (!mr || Pr.y < re) && (re = Pr.y), (!mr || Pr.x > fe) && (fe = Pr.x), (!mr || Pr.y > pe) && (pe = Pr.y);\n                  }\n                  let Ke = Math.min(fe - W, pe - re), ct = Ke / 2, Lt = new Vp([], rO);\n                  if (Ke === 0) return new u4(W, re);\n                  for (let mr = W; mr < fe; mr += Ke) for (let Pr = re; Pr < pe; Pr += Ke) Lt.push(new L1(mr + ct, Pr + ct, ct, R));\n                  let $t = (function(mr) {\n                    let Pr = 0, zr = 0, ui = 0, yi = mr[0];\n                    for (let vn = 0, zi = yi.length, un = zi - 1; vn < zi; un = vn++) {\n                      let Tn = yi[vn], pa = yi[un], ro = Tn.x * pa.y - pa.x * Tn.y;\n                      zr += (Tn.x + pa.x) * ro, ui += (Tn.y + pa.y) * ro, Pr += 3 * ro;\n                    }\n                    return new L1(zr / Pr, ui / Pr, 0, mr);\n                  })(R), fr = Lt.length;\n                  for (; Lt.length; ) {\n                    let mr = Lt.pop();\n                    (mr.d > $t.d || !$t.d) && ($t = mr, F3 && console.log("found best %d after %d probes", Math.round(1e4 * mr.d) / 1e4, fr)), mr.max - $t.d <= A3 || (ct = mr.h / 2, Lt.push(new L1(mr.p.x - ct, mr.p.y - ct, ct, R)), Lt.push(new L1(mr.p.x + ct, mr.p.y - ct, ct, R)), Lt.push(new L1(mr.p.x - ct, mr.p.y + ct, ct, R)), Lt.push(new L1(mr.p.x + ct, mr.p.y + ct, ct, R)), fr += 4);\n                  }\n                  return F3 && (console.log(`num probes: ${fr}`), console.log(`best distance: ${$t.d}`)), $t.p;\n                }\n                function rO(R, A3) {\n                  return A3.max - R.max;\n                }\n                function L1(R, A3, F3, W) {\n                  this.p = new u4(R, A3), this.h = F3, this.d = (function(re, fe) {\n                    let pe = false, ze = 1 / 0;\n                    for (let Ke = 0; Ke < fe.length; Ke++) {\n                      let ct = fe[Ke];\n                      for (let Lt = 0, $t = ct.length, fr = $t - 1; Lt < $t; fr = Lt++) {\n                        let mr = ct[Lt], Pr = ct[fr];\n                        mr.y > re.y != Pr.y > re.y && re.x < (Pr.x - mr.x) * (re.y - mr.y) / (Pr.y - mr.y) + mr.x && (pe = !pe), ze = Math.min(ze, Gr(re, mr, Pr));\n                      }\n                    }\n                    return (pe ? 1 : -1) * Math.sqrt(ze);\n                  })(this.p, W), this.max = this.d + this.h * Math.SQRT2;\n                }\n                var sd;\n                i3.aq = void 0, (sd = i3.aq || (i3.aq = {}))[sd.center = 1] = "center", sd[sd.left = 2] = "left", sd[sd.right = 3] = "right", sd[sd.top = 4] = "top", sd[sd.bottom = 5] = "bottom", sd[sd["top-left"] = 6] = "top-left", sd[sd["top-right"] = 7] = "top-right", sd[sd["bottom-left"] = 8] = "bottom-left", sd[sd["bottom-right"] = 9] = "bottom-right";\n                let hm = 7, hy = Number.POSITIVE_INFINITY;\n                function yS(R, A3) {\n                  return A3[1] !== hy ? (function(F3, W, re) {\n                    let fe = 0, pe = 0;\n                    switch (W = Math.abs(W), re = Math.abs(re), F3) {\n                      case "top-right":\n                      case "top-left":\n                      case "top":\n                        pe = re - hm;\n                        break;\n                      case "bottom-right":\n                      case "bottom-left":\n                      case "bottom":\n                        pe = -re + hm;\n                    }\n                    switch (F3) {\n                      case "top-right":\n                      case "bottom-right":\n                      case "right":\n                        fe = -W;\n                        break;\n                      case "top-left":\n                      case "bottom-left":\n                      case "left":\n                        fe = W;\n                    }\n                    return [fe, pe];\n                  })(R, A3[0], A3[1]) : (function(F3, W) {\n                    let re = 0, fe = 0;\n                    W < 0 && (W = 0);\n                    let pe = W / Math.SQRT2;\n                    switch (F3) {\n                      case "top-right":\n                      case "top-left":\n                        fe = pe - hm;\n                        break;\n                      case "bottom-right":\n                      case "bottom-left":\n                        fe = -pe + hm;\n                        break;\n                      case "bottom":\n                        fe = -W + hm;\n                        break;\n                      case "top":\n                        fe = W - hm;\n                    }\n                    switch (F3) {\n                      case "top-right":\n                      case "bottom-right":\n                        re = -pe;\n                        break;\n                      case "top-left":\n                      case "bottom-left":\n                        re = pe;\n                        break;\n                      case "left":\n                        re = W;\n                        break;\n                      case "right":\n                        re = -W;\n                    }\n                    return [re, fe];\n                  })(R, A3[0]);\n                }\n                function VC(R, A3, F3) {\n                  var W;\n                  let re = R.layout, fe = (W = re.get("text-variable-anchor-offset")) === null || W === void 0 ? void 0 : W.evaluate(A3, {}, F3);\n                  if (fe) {\n                    let ze = fe.values, Ke = [];\n                    for (let ct = 0; ct < ze.length; ct += 2) {\n                      let Lt = Ke[ct] = ze[ct], $t = ze[ct + 1].map((fr) => fr * eu);\n                      Lt.startsWith("top") ? $t[1] -= hm : Lt.startsWith("bottom") && ($t[1] += hm), Ke[ct + 1] = $t;\n                    }\n                    return new $i(Ke);\n                  }\n                  let pe = re.get("text-variable-anchor");\n                  if (pe) {\n                    let ze;\n                    ze = R._unevaluatedLayout.getValue("text-radial-offset") !== void 0 ? [re.get("text-radial-offset").evaluate(A3, {}, F3) * eu, hy] : re.get("text-offset").evaluate(A3, {}, F3).map((ct) => ct * eu);\n                    let Ke = [];\n                    for (let ct of pe) Ke.push(ct, yS(ct, ze));\n                    return new $i(Ke);\n                  }\n                  return null;\n                }\n                function _S(R) {\n                  switch (R) {\n                    case "right":\n                    case "top-right":\n                    case "bottom-right":\n                      return "right";\n                    case "left":\n                    case "top-left":\n                    case "bottom-left":\n                      return "left";\n                  }\n                  return "center";\n                }\n                function iO(R, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt) {\n                  let $t = fe.textMaxSize.evaluate(A3, {});\n                  $t === void 0 && ($t = pe);\n                  let fr = R.layers[0].layout, mr = fr.get("icon-offset").evaluate(A3, {}, Lt), Pr = HC(F3.horizontal), zr = pe / 24, ui = R.tilePixelRatio * zr, yi = R.tilePixelRatio * $t / 24, vn = R.tilePixelRatio * ze, zi = R.tilePixelRatio * fr.get("symbol-spacing"), un = fr.get("text-padding") * R.tilePixelRatio, Tn = (function(Xn, Ro, uo, $o = 1) {\n                    let Ju = Xn.get("icon-padding").evaluate(Ro, {}, uo), qu = Ju && Ju.values;\n                    return [qu[0] * $o, qu[1] * $o, qu[2] * $o, qu[3] * $o];\n                  })(fr, A3, Lt, R.tilePixelRatio), pa = fr.get("text-max-angle") / 180 * Math.PI, ro = fr.get("text-rotation-alignment") !== "viewport" && fr.get("symbol-placement") !== "point", Vo = fr.get("icon-rotation-alignment") === "map" && fr.get("symbol-placement") !== "point", Xa = fr.get("symbol-placement"), sa = zi / 2, Mo = fr.get("icon-text-fit"), fo;\n                  W && Mo !== "none" && (R.allowVerticalPlacement && F3.vertical && (fo = AC(W, F3.vertical, Mo, fr.get("icon-text-fit-padding"), mr, zr)), Pr && (W = AC(W, Pr, Mo, fr.get("icon-text-fit-padding"), mr, zr)));\n                  let lo = (Xn, Ro) => {\n                    Ro.x < 0 || Ro.x >= ja || Ro.y < 0 || Ro.y >= ja || (function(uo, $o, Ju, qu, Mh, Qv, ld, Eh, Gd, Hd, jd, Af, kh, Ed, ud, Wh, Df, Fv, lv, tu, pc, $u, zv, ff, P1) {\n                      let v0 = uo.addToLineVertexArray($o, Ju), Gp, ep, Gc, Zf, tp = 0, gg = 0, uv = 0, I1 = 0, AS = -1, Gw = -1, p0 = {}, dy = bi("");\n                      if (uo.allowVerticalPlacement && qu.vertical) {\n                        let kd = Eh.layout.get("text-rotate").evaluate(pc, {}, ff) + 90;\n                        Gc = new fm(Gd, $o, Hd, jd, Af, qu.vertical, kh, Ed, ud, kd), ld && (Zf = new fm(Gd, $o, Hd, jd, Af, ld, Df, Fv, ud, kd));\n                      }\n                      if (Mh) {\n                        let kd = Eh.layout.get("icon-rotate").evaluate(pc, {}), rp = Eh.layout.get("icon-text-fit") !== "none", dm = NC(Mh, kd, zv, rp), Wd = ld ? NC(ld, kd, zv, rp) : void 0;\n                        ep = new fm(Gd, $o, Hd, jd, Af, Mh, Df, Fv, false, kd), tp = 4 * dm.length;\n                        let Cd = uo.iconSizeData, _p = null;\n                        Cd.kind === "source" ? (_p = [d0 * Eh.layout.get("icon-size").evaluate(pc, {})], _p[0] > um && T3(`${uo.layerIds[0]}: Value for "icon-size" is >= ${Wx}. Reduce your "icon-size".`)) : Cd.kind === "composite" && (_p = [d0 * $u.compositeIconSizes[0].evaluate(pc, {}, ff), d0 * $u.compositeIconSizes[1].evaluate(pc, {}, ff)], (_p[0] > um || _p[1] > um) && T3(`${uo.layerIds[0]}: Value for "icon-size" is >= ${Wx}. Reduce your "icon-size".`)), uo.addSymbols(uo.icon, dm, _p, tu, lv, pc, i3.ah.none, $o, v0.lineStartIndex, v0.lineLength, -1, ff), AS = uo.icon.placedSymbolArray.length - 1, Wd && (gg = 4 * Wd.length, uo.addSymbols(uo.icon, Wd, _p, tu, lv, pc, i3.ah.vertical, $o, v0.lineStartIndex, v0.lineLength, -1, ff), Gw = uo.icon.placedSymbolArray.length - 1);\n                      }\n                      let Xh = Object.keys(qu.horizontal);\n                      for (let kd of Xh) {\n                        let rp = qu.horizontal[kd];\n                        if (!Gp) {\n                          dy = bi(rp.text);\n                          let Wd = Eh.layout.get("text-rotate").evaluate(pc, {}, ff);\n                          Gp = new fm(Gd, $o, Hd, jd, Af, rp, kh, Ed, ud, Wd);\n                        }\n                        let dm = rp.positionedLines.length === 1;\n                        if (uv += GC(uo, $o, rp, Qv, Eh, ud, pc, Wh, v0, qu.vertical ? i3.ah.horizontal : i3.ah.horizontalOnly, dm ? Xh : [kd], p0, AS, $u, ff), dm) break;\n                      }\n                      qu.vertical && (I1 += GC(uo, $o, qu.vertical, Qv, Eh, ud, pc, Wh, v0, i3.ah.vertical, ["vertical"], p0, Gw, $u, ff));\n                      let oO = Gp ? Gp.boxStartIndex : uo.collisionBoxArray.length, Hw = Gp ? Gp.boxEndIndex : uo.collisionBoxArray.length, g0 = Gc ? Gc.boxStartIndex : uo.collisionBoxArray.length, cv = Gc ? Gc.boxEndIndex : uo.collisionBoxArray.length, ZC = ep ? ep.boxStartIndex : uo.collisionBoxArray.length, sO = ep ? ep.boxEndIndex : uo.collisionBoxArray.length, YC = Zf ? Zf.boxStartIndex : uo.collisionBoxArray.length, lO = Zf ? Zf.boxEndIndex : uo.collisionBoxArray.length, yp = -1, rb = (kd, rp) => kd && kd.circleDiameter ? Math.max(kd.circleDiameter, rp) : rp;\n                      yp = rb(Gp, yp), yp = rb(Gc, yp), yp = rb(ep, yp), yp = rb(Zf, yp);\n                      let jw = yp > -1 ? 1 : 0;\n                      jw && (yp *= P1 / eu), uo.glyphOffsetArray.length >= M1.MAX_GLYPHS && T3("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"), pc.sortKey !== void 0 && uo.addToSortKeyRanges(uo.symbolInstances.length, pc.sortKey);\n                      let SS = VC(Eh, pc, ff), [uO, cO] = (function(kd, rp) {\n                        let dm = kd.length, Wd = rp == null ? void 0 : rp.values;\n                        if ((Wd == null ? void 0 : Wd.length) > 0) for (let Cd = 0; Cd < Wd.length; Cd += 2) {\n                          let _p = Wd[Cd + 1];\n                          kd.emplaceBack(i3.aq[Wd[Cd]], _p[0], _p[1]);\n                        }\n                        return [dm, kd.length];\n                      })(uo.textAnchorOffsets, SS);\n                      uo.symbolInstances.emplaceBack($o.x, $o.y, p0.right >= 0 ? p0.right : -1, p0.center >= 0 ? p0.center : -1, p0.left >= 0 ? p0.left : -1, p0.vertical || -1, AS, Gw, dy, oO, Hw, g0, cv, ZC, sO, YC, lO, Hd, uv, I1, tp, gg, jw, 0, kh, yp, uO, cO);\n                    })(R, Ro, Xn, F3, W, re, fo, R.layers[0], R.collisionBoxArray, A3.index, A3.sourceLayerIndex, R.index, ui, [un, un, un, un], ro, Ke, vn, Tn, Vo, mr, A3, fe, ct, Lt, pe);\n                  };\n                  if (Xa === "line") for (let Xn of FC(A3.geometry, 0, 0, ja, ja)) {\n                    let Ro = eO(Xn, zi, pa, F3.vertical || Pr, W, 24, yi, R.overscaling, ja);\n                    for (let uo of Ro) Pr && nO(R, Pr.text, sa, uo) || lo(Xn, uo);\n                  }\n                  else if (Xa === "line-center") {\n                    for (let Xn of A3.geometry) if (Xn.length > 1) {\n                      let Ro = Q9(Xn, pa, F3.vertical || Pr, W, 24, yi);\n                      Ro && lo(Xn, Ro);\n                    }\n                  } else if (A3.type === "Polygon") for (let Xn of Cf(A3.geometry, 0)) {\n                    let Ro = tO(Xn, 16);\n                    lo(Xn[0], new vg(Ro.x, Ro.y, 0));\n                  }\n                  else if (A3.type === "LineString") for (let Xn of A3.geometry) lo(Xn, new vg(Xn[0].x, Xn[0].y, 0));\n                  else if (A3.type === "Point") for (let Xn of A3.geometry) for (let Ro of Xn) lo([Ro], new vg(Ro.x, Ro.y, 0));\n                }\n                function GC(R, A3, F3, W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr) {\n                  let zr = (function(vn, zi, un, Tn, pa, ro, Vo, Xa) {\n                    let sa = Tn.layout.get("text-rotate").evaluate(ro, {}) * Math.PI / 180, Mo = [];\n                    for (let fo of zi.positionedLines) for (let lo of fo.positionedGlyphs) {\n                      if (!lo.rect) continue;\n                      let Xn = lo.rect || {}, Ro = _C + 1, uo = true, $o = 1, Ju = 0, qu = (pa || Xa) && lo.vertical, Mh = lo.metrics.advance * lo.scale / 2;\n                      if (Xa && zi.verticalizable && (Ju = fo.lineOffset / 2 - (lo.imageName ? -(eu - lo.metrics.width * lo.scale) / 2 : (lo.scale - 1) * eu)), lo.imageName) {\n                        let tu = Vo[lo.imageName];\n                        uo = tu.sdf, $o = tu.pixelRatio, Ro = Md / $o;\n                      }\n                      let Qv = pa ? [lo.x + Mh, lo.y] : [0, 0], ld = pa ? [0, 0] : [lo.x + Mh + un[0], lo.y + un[1] - Ju], Eh = [0, 0];\n                      qu && (Eh = ld, ld = [0, 0]);\n                      let Gd = lo.metrics.isDoubleResolution ? 2 : 1, Hd = (lo.metrics.left - Ro) * lo.scale - Mh + ld[0], jd = (-lo.metrics.top - Ro) * lo.scale + ld[1], Af = Hd + Xn.w / Gd * lo.scale / $o, kh = jd + Xn.h / Gd * lo.scale / $o, Ed = new u4(Hd, jd), ud = new u4(Af, jd), Wh = new u4(Hd, kh), Df = new u4(Af, kh);\n                      if (qu) {\n                        let tu = new u4(-Mh, Mh - Sh), pc = -Math.PI / 2, $u = eu / 2 - Mh, zv = new u4(5 - Sh - $u, -(lo.imageName ? $u : 0)), ff = new u4(...Eh);\n                        Ed._rotateAround(pc, tu)._add(zv)._add(ff), ud._rotateAround(pc, tu)._add(zv)._add(ff), Wh._rotateAround(pc, tu)._add(zv)._add(ff), Df._rotateAround(pc, tu)._add(zv)._add(ff);\n                      }\n                      if (sa) {\n                        let tu = Math.sin(sa), pc = Math.cos(sa), $u = [pc, -tu, tu, pc];\n                        Ed._matMult($u), ud._matMult($u), Wh._matMult($u), Df._matMult($u);\n                      }\n                      let Fv = new u4(0, 0), lv = new u4(0, 0);\n                      Mo.push({ tl: Ed, tr: ud, bl: Wh, br: Df, tex: Xn, writingMode: zi.writingMode, glyphOffset: Qv, sectionIndex: lo.sectionIndex, isSDF: uo, pixelOffsetTL: Fv, pixelOffsetBR: lv, minFontScaleX: 0, minFontScaleY: 0 });\n                    }\n                    return Mo;\n                  })(0, F3, ze, re, fe, pe, W, R.allowVerticalPlacement), ui = R.textSizeData, yi = null;\n                  ui.kind === "source" ? (yi = [d0 * re.layout.get("text-size").evaluate(pe, {})], yi[0] > um && T3(`${R.layerIds[0]}: Value for "text-size" is >= ${Wx}. Reduce your "text-size".`)) : ui.kind === "composite" && (yi = [d0 * mr.compositeTextSizes[0].evaluate(pe, {}, Pr), d0 * mr.compositeTextSizes[1].evaluate(pe, {}, Pr)], (yi[0] > um || yi[1] > um) && T3(`${R.layerIds[0]}: Value for "text-size" is >= ${Wx}. Reduce your "text-size".`)), R.addSymbols(R.text, zr, yi, ze, fe, pe, ct, A3, Ke.lineStartIndex, Ke.lineLength, fr, Pr);\n                  for (let vn of Lt) $t[vn] = R.text.placedSymbolArray.length - 1;\n                  return 4 * zr.length;\n                }\n                function HC(R) {\n                  for (let A3 in R) return R[A3];\n                  return null;\n                }\n                function nO(R, A3, F3, W) {\n                  let re = R.compareText;\n                  if (A3 in re) {\n                    let fe = re[A3];\n                    for (let pe = fe.length - 1; pe >= 0; pe--) if (W.dist(fe[pe]) < F3) return true;\n                  } else re[A3] = [];\n                  return re[A3].push(W), false;\n                }\n                let jC = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];\n                class xS {\n                  static from(A3) {\n                    if (!(A3 instanceof ArrayBuffer)) throw new Error("Data must be an instance of ArrayBuffer.");\n                    let [F3, W] = new Uint8Array(A3, 0, 2);\n                    if (F3 !== 219) throw new Error("Data does not appear to be in a KDBush format.");\n                    let re = W >> 4;\n                    if (re !== 1) throw new Error(`Got v${re} data when expected v1.`);\n                    let fe = jC[15 & W];\n                    if (!fe) throw new Error("Unrecognized array type.");\n                    let [pe] = new Uint16Array(A3, 2, 1), [ze] = new Uint32Array(A3, 4, 1);\n                    return new xS(ze, pe, fe, A3);\n                  }\n                  constructor(A3, F3 = 64, W = Float64Array, re) {\n                    if (isNaN(A3) || A3 < 0) throw new Error(`Unpexpected numItems value: ${A3}.`);\n                    this.numItems = +A3, this.nodeSize = Math.min(Math.max(+F3, 2), 65535), this.ArrayType = W, this.IndexArrayType = A3 < 65536 ? Uint16Array : Uint32Array;\n                    let fe = jC.indexOf(this.ArrayType), pe = 2 * A3 * this.ArrayType.BYTES_PER_ELEMENT, ze = A3 * this.IndexArrayType.BYTES_PER_ELEMENT, Ke = (8 - ze % 8) % 8;\n                    if (fe < 0) throw new Error(`Unexpected typed array class: ${W}.`);\n                    re && re instanceof ArrayBuffer ? (this.data = re, this.ids = new this.IndexArrayType(this.data, 8, A3), this.coords = new this.ArrayType(this.data, 8 + ze + Ke, 2 * A3), this._pos = 2 * A3, this._finished = true) : (this.data = new ArrayBuffer(8 + pe + ze + Ke), this.ids = new this.IndexArrayType(this.data, 8, A3), this.coords = new this.ArrayType(this.data, 8 + ze + Ke, 2 * A3), this._pos = 0, this._finished = false, new Uint8Array(this.data, 0, 2).set([219, 16 + fe]), new Uint16Array(this.data, 2, 1)[0] = F3, new Uint32Array(this.data, 4, 1)[0] = A3);\n                  }\n                  add(A3, F3) {\n                    let W = this._pos >> 1;\n                    return this.ids[W] = W, this.coords[this._pos++] = A3, this.coords[this._pos++] = F3, W;\n                  }\n                  finish() {\n                    let A3 = this._pos >> 1;\n                    if (A3 !== this.numItems) throw new Error(`Added ${A3} items when expected ${this.numItems}.`);\n                    return Nw(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0), this._finished = true, this;\n                  }\n                  range(A3, F3, W, re) {\n                    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");\n                    let { ids: fe, coords: pe, nodeSize: ze } = this, Ke = [0, fe.length - 1, 0], ct = [];\n                    for (; Ke.length; ) {\n                      let Lt = Ke.pop() || 0, $t = Ke.pop() || 0, fr = Ke.pop() || 0;\n                      if ($t - fr <= ze) {\n                        for (let ui = fr; ui <= $t; ui++) {\n                          let yi = pe[2 * ui], vn = pe[2 * ui + 1];\n                          yi >= A3 && yi <= W && vn >= F3 && vn <= re && ct.push(fe[ui]);\n                        }\n                        continue;\n                      }\n                      let mr = fr + $t >> 1, Pr = pe[2 * mr], zr = pe[2 * mr + 1];\n                      Pr >= A3 && Pr <= W && zr >= F3 && zr <= re && ct.push(fe[mr]), (Lt === 0 ? A3 <= Pr : F3 <= zr) && (Ke.push(fr), Ke.push(mr - 1), Ke.push(1 - Lt)), (Lt === 0 ? W >= Pr : re >= zr) && (Ke.push(mr + 1), Ke.push($t), Ke.push(1 - Lt));\n                    }\n                    return ct;\n                  }\n                  within(A3, F3, W) {\n                    if (!this._finished) throw new Error("Data not yet indexed - call index.finish().");\n                    let { ids: re, coords: fe, nodeSize: pe } = this, ze = [0, re.length - 1, 0], Ke = [], ct = W * W;\n                    for (; ze.length; ) {\n                      let Lt = ze.pop() || 0, $t = ze.pop() || 0, fr = ze.pop() || 0;\n                      if ($t - fr <= pe) {\n                        for (let ui = fr; ui <= $t; ui++) XC(fe[2 * ui], fe[2 * ui + 1], A3, F3) <= ct && Ke.push(re[ui]);\n                        continue;\n                      }\n                      let mr = fr + $t >> 1, Pr = fe[2 * mr], zr = fe[2 * mr + 1];\n                      XC(Pr, zr, A3, F3) <= ct && Ke.push(re[mr]), (Lt === 0 ? A3 - W <= Pr : F3 - W <= zr) && (ze.push(fr), ze.push(mr - 1), ze.push(1 - Lt)), (Lt === 0 ? A3 + W >= Pr : F3 + W >= zr) && (ze.push(mr + 1), ze.push($t), ze.push(1 - Lt));\n                    }\n                    return Ke;\n                  }\n                }\n                function Nw(R, A3, F3, W, re, fe) {\n                  if (re - W <= F3) return;\n                  let pe = W + re >> 1;\n                  WC(R, A3, pe, W, re, fe), Nw(R, A3, F3, W, pe - 1, 1 - fe), Nw(R, A3, F3, pe + 1, re, 1 - fe);\n                }\n                function WC(R, A3, F3, W, re, fe) {\n                  for (; re > W; ) {\n                    if (re - W > 600) {\n                      let ct = re - W + 1, Lt = F3 - W + 1, $t = Math.log(ct), fr = 0.5 * Math.exp(2 * $t / 3), mr = 0.5 * Math.sqrt($t * fr * (ct - fr) / ct) * (Lt - ct / 2 < 0 ? -1 : 1);\n                      WC(R, A3, F3, Math.max(W, Math.floor(F3 - Lt * fr / ct + mr)), Math.min(re, Math.floor(F3 + (ct - Lt) * fr / ct + mr)), fe);\n                    }\n                    let pe = A3[2 * F3 + fe], ze = W, Ke = re;\n                    for (eb(R, A3, W, F3), A3[2 * re + fe] > pe && eb(R, A3, W, re); ze < Ke; ) {\n                      for (eb(R, A3, ze, Ke), ze++, Ke--; A3[2 * ze + fe] < pe; ) ze++;\n                      for (; A3[2 * Ke + fe] > pe; ) Ke--;\n                    }\n                    A3[2 * W + fe] === pe ? eb(R, A3, W, Ke) : (Ke++, eb(R, A3, Ke, re)), Ke <= F3 && (W = Ke + 1), F3 <= Ke && (re = Ke - 1);\n                  }\n                }\n                function eb(R, A3, F3, W) {\n                  bS(R, F3, W), bS(A3, 2 * F3, 2 * W), bS(A3, 2 * F3 + 1, 2 * W + 1);\n                }\n                function bS(R, A3, F3) {\n                  let W = R[A3];\n                  R[A3] = R[F3], R[F3] = W;\n                }\n                function XC(R, A3, F3, W) {\n                  let re = R - F3, fe = A3 - W;\n                  return re * re + fe * fe;\n                }\n                var Uw;\n                i3.bg = void 0, (Uw = i3.bg || (i3.bg = {})).create = "create", Uw.load = "load", Uw.fullLoad = "fullLoad";\n                let tb = null, sh = [], wS = 1e3 / 60, TS = "loadTime", Vw = "fullLoadTime", aO = { mark(R) {\n                  performance.mark(R);\n                }, frame(R) {\n                  let A3 = R;\n                  tb != null && sh.push(A3 - tb), tb = A3;\n                }, clearMetrics() {\n                  tb = null, sh = [], performance.clearMeasures(TS), performance.clearMeasures(Vw);\n                  for (let R in i3.bg) performance.clearMarks(i3.bg[R]);\n                }, getPerformanceMetrics() {\n                  performance.measure(TS, i3.bg.create, i3.bg.load), performance.measure(Vw, i3.bg.create, i3.bg.fullLoad);\n                  let R = performance.getEntriesByName(TS)[0].duration, A3 = performance.getEntriesByName(Vw)[0].duration, F3 = sh.length, W = 1 / (sh.reduce((fe, pe) => fe + pe, 0) / F3 / 1e3), re = sh.filter((fe) => fe > wS).reduce((fe, pe) => fe + (pe - wS) / wS, 0);\n                  return { loadTime: R, fullLoadTime: A3, fps: W, percentDroppedFrames: re / (F3 + re) * 100, totalFrames: F3 };\n                } };\n                i3.$ = class extends Yt {\n                }, i3.A = xi, i3.B = dn, i3.C = function(R) {\n                  if (V2 == null) {\n                    let A3 = R.navigator ? R.navigator.userAgent : null;\n                    V2 = !!R.safari || !(!A3 || !(/\\b(iPad|iPhone|iPod)\\b/.test(A3) || A3.match("Safari") && !A3.match("Chrome")));\n                  }\n                  return V2;\n                }, i3.D = Ua, i3.E = Re, i3.F = class {\n                  constructor(R, A3) {\n                    this.target = R, this.mapId = A3, this.resolveRejects = {}, this.tasks = {}, this.taskQueue = [], this.abortControllers = {}, this.messageHandlers = {}, this.invoker = new dS(() => this.process()), this.subscription = (function(F3, W, re, fe) {\n                      return F3.addEventListener(W, re, false), { unsubscribe: () => {\n                        F3.removeEventListener(W, re, false);\n                      } };\n                    })(this.target, "message", (F3) => this.receive(F3)), this.globalScope = O3(self) ? R : window;\n                  }\n                  registerMessageHandler(R, A3) {\n                    this.messageHandlers[R] = A3;\n                  }\n                  sendAsync(R, A3) {\n                    return new Promise((F3, W) => {\n                      let re = Math.round(1e18 * Math.random()).toString(36).substring(0, 10);\n                      this.resolveRejects[re] = { resolve: F3, reject: W }, A3 && A3.signal.addEventListener("abort", () => {\n                        delete this.resolveRejects[re];\n                        let ze = { id: re, type: "<cancel>", origin: location.origin, targetMapId: R.targetMapId, sourceMapId: this.mapId };\n                        this.target.postMessage(ze);\n                      }, { once: true });\n                      let fe = [], pe = Object.assign(Object.assign({}, R), { id: re, sourceMapId: this.mapId, origin: location.origin, data: La(R.data, fe) });\n                      this.target.postMessage(pe, { transfer: fe });\n                    });\n                  }\n                  receive(R) {\n                    let A3 = R.data, F3 = A3.id;\n                    if (!(A3.origin !== "file://" && location.origin !== "file://" && A3.origin !== "resource://android" && location.origin !== "resource://android" && A3.origin !== location.origin || A3.targetMapId && this.mapId !== A3.targetMapId)) {\n                      if (A3.type === "<cancel>") {\n                        delete this.tasks[F3];\n                        let W = this.abortControllers[F3];\n                        return delete this.abortControllers[F3], void (W && W.abort());\n                      }\n                      if (O3(self) || A3.mustQueue) return this.tasks[F3] = A3, this.taskQueue.push(F3), void this.invoker.trigger();\n                      this.processTask(F3, A3);\n                    }\n                  }\n                  process() {\n                    if (this.taskQueue.length === 0) return;\n                    let R = this.taskQueue.shift(), A3 = this.tasks[R];\n                    delete this.tasks[R], this.taskQueue.length > 0 && this.invoker.trigger(), A3 && this.processTask(R, A3);\n                  }\n                  processTask(R, A3) {\n                    return a4(this, void 0, void 0, function* () {\n                      if (A3.type === "<response>") {\n                        let re = this.resolveRejects[R];\n                        return delete this.resolveRejects[R], re ? void (A3.error ? re.reject(Na(A3.error)) : re.resolve(Na(A3.data))) : void 0;\n                      }\n                      if (!this.messageHandlers[A3.type]) return void this.completeTask(R, new Error(`Could not find a registered handler for ${A3.type}, map ID: ${this.mapId}, available handlers: ${Object.keys(this.messageHandlers).join(", ")}`));\n                      let F3 = Na(A3.data), W = new AbortController();\n                      this.abortControllers[R] = W;\n                      try {\n                        let re = yield this.messageHandlers[A3.type](A3.sourceMapId, F3, W);\n                        this.completeTask(R, null, re);\n                      } catch (re) {\n                        this.completeTask(R, re);\n                      }\n                    });\n                  }\n                  completeTask(R, A3, F3) {\n                    let W = [];\n                    delete this.abortControllers[R];\n                    let re = { id: R, type: "<response>", sourceMapId: this.mapId, origin: location.origin, error: A3 ? La(A3) : null, data: La(F3, W) };\n                    this.target.postMessage(re, { transfer: W });\n                  }\n                  remove() {\n                    this.invoker.remove(), this.subscription.unsubscribe();\n                  }\n                }, i3.G = Ce, i3.H = function() {\n                  var R = new xi(16);\n                  return xi != Float32Array && (R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0), R[0] = 1, R[5] = 1, R[10] = 1, R[15] = 1, R;\n                }, i3.I = Lw, i3.J = function(R, A3, F3) {\n                  var W, re, fe, pe, ze, Ke, ct, Lt, $t, fr, mr, Pr, zr = F3[0], ui = F3[1], yi = F3[2];\n                  return A3 === R ? (R[12] = A3[0] * zr + A3[4] * ui + A3[8] * yi + A3[12], R[13] = A3[1] * zr + A3[5] * ui + A3[9] * yi + A3[13], R[14] = A3[2] * zr + A3[6] * ui + A3[10] * yi + A3[14], R[15] = A3[3] * zr + A3[7] * ui + A3[11] * yi + A3[15]) : (re = A3[1], fe = A3[2], pe = A3[3], ze = A3[4], Ke = A3[5], ct = A3[6], Lt = A3[7], $t = A3[8], fr = A3[9], mr = A3[10], Pr = A3[11], R[0] = W = A3[0], R[1] = re, R[2] = fe, R[3] = pe, R[4] = ze, R[5] = Ke, R[6] = ct, R[7] = Lt, R[8] = $t, R[9] = fr, R[10] = mr, R[11] = Pr, R[12] = W * zr + ze * ui + $t * yi + A3[12], R[13] = re * zr + Ke * ui + fr * yi + A3[13], R[14] = fe * zr + ct * ui + mr * yi + A3[14], R[15] = pe * zr + Lt * ui + Pr * yi + A3[15]), R;\n                }, i3.K = function(R, A3, F3) {\n                  var W = F3[0], re = F3[1], fe = F3[2];\n                  return R[0] = A3[0] * W, R[1] = A3[1] * W, R[2] = A3[2] * W, R[3] = A3[3] * W, R[4] = A3[4] * re, R[5] = A3[5] * re, R[6] = A3[6] * re, R[7] = A3[7] * re, R[8] = A3[8] * fe, R[9] = A3[9] * fe, R[10] = A3[10] * fe, R[11] = A3[11] * fe, R[12] = A3[12], R[13] = A3[13], R[14] = A3[14], R[15] = A3[15], R;\n                }, i3.L = ci, i3.M = function(R, A3) {\n                  let F3 = {};\n                  for (let W = 0; W < A3.length; W++) {\n                    let re = A3[W];\n                    re in R && (F3[re] = R[re]);\n                  }\n                  return F3;\n                }, i3.N = dg, i3.O = Ow, i3.P = u4, i3.Q = CC, i3.R = Ki, i3.S = $v, i3.T = Yu, i3.U = _2, i3.V = b, i3.W = j3, i3.X = ja, i3.Y = qe, i3.Z = $x, i3._ = a4, i3.a = _e, i3.a$ = function(R, A3) {\n                  var F3 = R[0], W = R[1], re = R[2], fe = R[3], pe = R[4], ze = R[5], Ke = R[6], ct = R[7], Lt = R[8], $t = R[9], fr = R[10], mr = R[11], Pr = R[12], zr = R[13], ui = R[14], yi = R[15], vn = A3[0], zi = A3[1], un = A3[2], Tn = A3[3], pa = A3[4], ro = A3[5], Vo = A3[6], Xa = A3[7], sa = A3[8], Mo = A3[9], fo = A3[10], lo = A3[11], Xn = A3[12], Ro = A3[13], uo = A3[14], $o = A3[15];\n                  return Math.abs(F3 - vn) <= Yr * Math.max(1, Math.abs(F3), Math.abs(vn)) && Math.abs(W - zi) <= Yr * Math.max(1, Math.abs(W), Math.abs(zi)) && Math.abs(re - un) <= Yr * Math.max(1, Math.abs(re), Math.abs(un)) && Math.abs(fe - Tn) <= Yr * Math.max(1, Math.abs(fe), Math.abs(Tn)) && Math.abs(pe - pa) <= Yr * Math.max(1, Math.abs(pe), Math.abs(pa)) && Math.abs(ze - ro) <= Yr * Math.max(1, Math.abs(ze), Math.abs(ro)) && Math.abs(Ke - Vo) <= Yr * Math.max(1, Math.abs(Ke), Math.abs(Vo)) && Math.abs(ct - Xa) <= Yr * Math.max(1, Math.abs(ct), Math.abs(Xa)) && Math.abs(Lt - sa) <= Yr * Math.max(1, Math.abs(Lt), Math.abs(sa)) && Math.abs($t - Mo) <= Yr * Math.max(1, Math.abs($t), Math.abs(Mo)) && Math.abs(fr - fo) <= Yr * Math.max(1, Math.abs(fr), Math.abs(fo)) && Math.abs(mr - lo) <= Yr * Math.max(1, Math.abs(mr), Math.abs(lo)) && Math.abs(Pr - Xn) <= Yr * Math.max(1, Math.abs(Pr), Math.abs(Xn)) && Math.abs(zr - Ro) <= Yr * Math.max(1, Math.abs(zr), Math.abs(Ro)) && Math.abs(ui - uo) <= Yr * Math.max(1, Math.abs(ui), Math.abs(uo)) && Math.abs(yi - $o) <= Yr * Math.max(1, Math.abs(yi), Math.abs($o));\n                }, i3.a0 = Ye, i3.a1 = pS, i3.a2 = cr, i3.a3 = (R) => {\n                  let A3 = window.document.createElement("video");\n                  return A3.muted = true, new Promise((F3) => {\n                    A3.onloadstart = () => {\n                      F3(A3);\n                    };\n                    for (let W of R) {\n                      let re = window.document.createElement("source");\n                      Le(W) || (A3.crossOrigin = "Anonymous"), re.src = W, A3.appendChild(re);\n                    }\n                  });\n                }, i3.a4 = function() {\n                  return x2++;\n                }, i3.a5 = Cn, i3.a6 = M1, i3.a7 = Fc, i3.a8 = Sl, i3.a9 = gS, i3.aA = function(R) {\n                  if (R.type === "custom") return new hS(R);\n                  switch (R.type) {\n                    case "background":\n                      return new J9(R);\n                    case "circle":\n                      return new hi(R);\n                    case "fill":\n                      return new yt(R);\n                    case "fill-extrusion":\n                      return new Lv(R);\n                    case "heatmap":\n                      return new oa(R);\n                    case "hillshade":\n                      return new Zs(R);\n                    case "line":\n                      return new oy(R);\n                    case "raster":\n                      return new Kx(R);\n                    case "symbol":\n                      return new cy(R);\n                  }\n                }, i3.aB = g3, i3.aC = function(R, A3) {\n                  if (!R) return [{ command: "setStyle", args: [A3] }];\n                  let F3 = [];\n                  try {\n                    if (!pt(R.version, A3.version)) return [{ command: "setStyle", args: [A3] }];\n                    pt(R.center, A3.center) || F3.push({ command: "setCenter", args: [A3.center] }), pt(R.zoom, A3.zoom) || F3.push({ command: "setZoom", args: [A3.zoom] }), pt(R.bearing, A3.bearing) || F3.push({ command: "setBearing", args: [A3.bearing] }), pt(R.pitch, A3.pitch) || F3.push({ command: "setPitch", args: [A3.pitch] }), pt(R.sprite, A3.sprite) || F3.push({ command: "setSprite", args: [A3.sprite] }), pt(R.glyphs, A3.glyphs) || F3.push({ command: "setGlyphs", args: [A3.glyphs] }), pt(R.transition, A3.transition) || F3.push({ command: "setTransition", args: [A3.transition] }), pt(R.light, A3.light) || F3.push({ command: "setLight", args: [A3.light] }), pt(R.terrain, A3.terrain) || F3.push({ command: "setTerrain", args: [A3.terrain] }), pt(R.sky, A3.sky) || F3.push({ command: "setSky", args: [A3.sky] }), pt(R.projection, A3.projection) || F3.push({ command: "setProjection", args: [A3.projection] });\n                    let W = {}, re = [];\n                    (function(pe, ze, Ke, ct) {\n                      let Lt;\n                      for (Lt in ze = ze || {}, pe = pe || {}) Object.prototype.hasOwnProperty.call(pe, Lt) && (Object.prototype.hasOwnProperty.call(ze, Lt) || lt(Lt, Ke, ct));\n                      for (Lt in ze) Object.prototype.hasOwnProperty.call(ze, Lt) && (Object.prototype.hasOwnProperty.call(pe, Lt) ? pt(pe[Lt], ze[Lt]) || (pe[Lt].type === "geojson" && ze[Lt].type === "geojson" && Nt(pe, ze, Lt) ? Zt(Ke, { command: "setGeoJSONSourceData", args: [Lt, ze[Lt].data] }) : Gt(Lt, ze, Ke, ct)) : st(Lt, ze, Ke));\n                    })(R.sources, A3.sources, re, W);\n                    let fe = [];\n                    R.layers && R.layers.forEach((pe) => {\n                      "source" in pe && W[pe.source] ? F3.push({ command: "removeLayer", args: [pe.id] }) : fe.push(pe);\n                    }), F3 = F3.concat(re), (function(pe, ze, Ke) {\n                      ze = ze || [];\n                      let ct = (pe = pe || []).map(sr), Lt = ze.map(sr), $t = pe.reduce(wr, {}), fr = ze.reduce(wr, {}), mr = ct.slice(), Pr = /* @__PURE__ */ Object.create(null), zr, ui, yi, vn, zi;\n                      for (let un = 0, Tn = 0; un < ct.length; un++) zr = ct[un], Object.prototype.hasOwnProperty.call(fr, zr) ? Tn++ : (Zt(Ke, { command: "removeLayer", args: [zr] }), mr.splice(mr.indexOf(zr, Tn), 1));\n                      for (let un = 0, Tn = 0; un < Lt.length; un++) zr = Lt[Lt.length - 1 - un], mr[mr.length - 1 - un] !== zr && (Object.prototype.hasOwnProperty.call($t, zr) ? (Zt(Ke, { command: "removeLayer", args: [zr] }), mr.splice(mr.lastIndexOf(zr, mr.length - Tn), 1)) : Tn++, vn = mr[mr.length - un], Zt(Ke, { command: "addLayer", args: [fr[zr], vn] }), mr.splice(mr.length - un, 0, zr), Pr[zr] = true);\n                      for (let un = 0; un < Lt.length; un++) if (zr = Lt[un], ui = $t[zr], yi = fr[zr], !Pr[zr] && !pt(ui, yi)) if (pt(ui.source, yi.source) && pt(ui["source-layer"], yi["source-layer"]) && pt(ui.type, yi.type)) {\n                        for (zi in Jt(ui.layout, yi.layout, Ke, zr, null, "setLayoutProperty"), Jt(ui.paint, yi.paint, Ke, zr, null, "setPaintProperty"), pt(ui.filter, yi.filter) || Zt(Ke, { command: "setFilter", args: [zr, yi.filter] }), pt(ui.minzoom, yi.minzoom) && pt(ui.maxzoom, yi.maxzoom) || Zt(Ke, { command: "setLayerZoomRange", args: [zr, yi.minzoom, yi.maxzoom] }), ui) Object.prototype.hasOwnProperty.call(ui, zi) && zi !== "layout" && zi !== "paint" && zi !== "filter" && zi !== "metadata" && zi !== "minzoom" && zi !== "maxzoom" && (zi.indexOf("paint.") === 0 ? Jt(ui[zi], yi[zi], Ke, zr, zi.slice(6), "setPaintProperty") : pt(ui[zi], yi[zi]) || Zt(Ke, { command: "setLayerProperty", args: [zr, zi, yi[zi]] }));\n                        for (zi in yi) Object.prototype.hasOwnProperty.call(yi, zi) && !Object.prototype.hasOwnProperty.call(ui, zi) && zi !== "layout" && zi !== "paint" && zi !== "filter" && zi !== "metadata" && zi !== "minzoom" && zi !== "maxzoom" && (zi.indexOf("paint.") === 0 ? Jt(ui[zi], yi[zi], Ke, zr, zi.slice(6), "setPaintProperty") : pt(ui[zi], yi[zi]) || Zt(Ke, { command: "setLayerProperty", args: [zr, zi, yi[zi]] }));\n                      } else Zt(Ke, { command: "removeLayer", args: [zr] }), vn = mr[mr.lastIndexOf(zr) + 1], Zt(Ke, { command: "addLayer", args: [yi, vn] });\n                    })(fe, A3.layers, F3);\n                  } catch (W) {\n                    console.warn("Unable to compute style diff:", W), F3 = [{ command: "setStyle", args: [A3] }];\n                  }\n                  return F3;\n                }, i3.aD = function(R) {\n                  let A3 = [], F3 = R.id;\n                  return F3 === void 0 && A3.push({ message: `layers.${F3}: missing required property "id"` }), R.render === void 0 && A3.push({ message: `layers.${F3}: missing required method "render"` }), R.renderingMode && R.renderingMode !== "2d" && R.renderingMode !== "3d" && A3.push({ message: `layers.${F3}: property "renderingMode" must be either "2d" or "3d"` }), A3;\n                }, i3.aE = function R(A3, F3) {\n                  if (Array.isArray(A3)) {\n                    if (!Array.isArray(F3) || A3.length !== F3.length) return false;\n                    for (let W = 0; W < A3.length; W++) if (!R(A3[W], F3[W])) return false;\n                    return true;\n                  }\n                  if (typeof A3 == "object" && A3 !== null && F3 !== null) {\n                    if (typeof F3 != "object" || Object.keys(A3).length !== Object.keys(F3).length) return false;\n                    for (let W in A3) if (!R(A3[W], F3[W])) return false;\n                    return true;\n                  }\n                  return A3 === F3;\n                }, i3.aF = C3, i3.aG = M4, i3.aH = class extends Si {\n                  constructor(R, A3) {\n                    super(R, A3), this.current = 0;\n                  }\n                  set(R) {\n                    this.current !== R && (this.current = R, this.gl.uniform1i(this.location, R));\n                  }\n                }, i3.aI = ei, i3.aJ = class extends Si {\n                  constructor(R, A3) {\n                    super(R, A3), this.current = Un;\n                  }\n                  set(R) {\n                    if (R[12] !== this.current[12] || R[0] !== this.current[0]) return this.current = R, void this.gl.uniformMatrix4fv(this.location, false, R);\n                    for (let A3 = 1; A3 < 16; A3++) if (R[A3] !== this.current[A3]) {\n                      this.current = R, this.gl.uniformMatrix4fv(this.location, false, R);\n                      break;\n                    }\n                  }\n                }, i3.aK = Ln, i3.aL = En, i3.aM = nr, i3.aN = class extends Si {\n                  constructor(R, A3) {\n                    super(R, A3), this.current = [0, 0, 0];\n                  }\n                  set(R) {\n                    R[0] === this.current[0] && R[1] === this.current[1] && R[2] === this.current[2] || (this.current = R, this.gl.uniform3f(this.location, R[0], R[1], R[2]));\n                  }\n                }, i3.aO = class extends Si {\n                  constructor(R, A3) {\n                    super(R, A3), this.current = [0, 0];\n                  }\n                  set(R) {\n                    R[0] === this.current[0] && R[1] === this.current[1] || (this.current = R, this.gl.uniform2f(this.location, R[0], R[1]));\n                  }\n                }, i3.aP = function(R, A3, F3, W, re, fe, pe) {\n                  var ze = 1 / (A3 - F3), Ke = 1 / (W - re), ct = 1 / (fe - pe);\n                  return R[0] = -2 * ze, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = -2 * Ke, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = 2 * ct, R[11] = 0, R[12] = (A3 + F3) * ze, R[13] = (re + W) * Ke, R[14] = (pe + fe) * ct, R[15] = 1, R;\n                }, i3.aQ = Zi, i3.aR = class extends it {\n                }, i3.aS = nm, i3.aT = class extends Ht {\n                }, i3.aU = ta, i3.aV = function(R) {\n                  return R <= 1 ? 1 : Math.pow(2, Math.ceil(Math.log(R) / Math.LN2));\n                }, i3.aW = kn, i3.aX = wo, i3.aY = se, i3.aZ = class extends Pi {\n                }, i3.a_ = function(R, A3) {\n                  return R[0] === A3[0] && R[1] === A3[1] && R[2] === A3[2] && R[3] === A3[3] && R[4] === A3[4] && R[5] === A3[5] && R[6] === A3[6] && R[7] === A3[7] && R[8] === A3[8] && R[9] === A3[9] && R[10] === A3[10] && R[11] === A3[11] && R[12] === A3[12] && R[13] === A3[13] && R[14] === A3[14] && R[15] === A3[15];\n                }, i3.aa = function(R) {\n                  let A3 = {};\n                  if (R.replace(/(?:^|(?:\\s*\\,\\s*))([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)(?:\\=(?:([^\\x00-\\x20\\(\\)<>@\\,;\\:\\\\"\\/\\[\\]\\?\\=\\{\\}\\x7F]+)|(?:\\"((?:[^"\\\\]|\\\\.)*)\\")))?/g, (F3, W, re, fe) => {\n                    let pe = re || fe;\n                    return A3[W] = !pe || pe.toLowerCase(), "";\n                  }), A3["max-age"]) {\n                    let F3 = parseInt(A3["max-age"], 10);\n                    isNaN(F3) ? delete A3["max-age"] : A3["max-age"] = F3;\n                  }\n                  return A3;\n                }, i3.ab = function(R, A3) {\n                  let F3 = [];\n                  for (let W in R) W in A3 || F3.push(W);\n                  return F3;\n                }, i3.ac = E3, i3.ad = function(R, A3, F3) {\n                  var W = Math.sin(F3), re = Math.cos(F3), fe = A3[0], pe = A3[1], ze = A3[2], Ke = A3[3], ct = A3[4], Lt = A3[5], $t = A3[6], fr = A3[7];\n                  return A3 !== R && (R[8] = A3[8], R[9] = A3[9], R[10] = A3[10], R[11] = A3[11], R[12] = A3[12], R[13] = A3[13], R[14] = A3[14], R[15] = A3[15]), R[0] = fe * re + ct * W, R[1] = pe * re + Lt * W, R[2] = ze * re + $t * W, R[3] = Ke * re + fr * W, R[4] = ct * re - fe * W, R[5] = Lt * re - pe * W, R[6] = $t * re - ze * W, R[7] = fr * re - Ke * W, R;\n                }, i3.ae = function(R) {\n                  var A3 = new xi(16);\n                  return A3[0] = R[0], A3[1] = R[1], A3[2] = R[2], A3[3] = R[3], A3[4] = R[4], A3[5] = R[5], A3[6] = R[6], A3[7] = R[7], A3[8] = R[8], A3[9] = R[9], A3[10] = R[10], A3[11] = R[11], A3[12] = R[12], A3[13] = R[13], A3[14] = R[14], A3[15] = R[15], A3;\n                }, i3.af = Bn, i3.ag = function(R, A3) {\n                  let F3 = 0, W = 0;\n                  if (R.kind === "constant") W = R.layoutSize;\n                  else if (R.kind !== "source") {\n                    let { interpolationType: re, minZoom: fe, maxZoom: pe } = R, ze = re ? E3(ko.interpolationFactor(re, A3, fe, pe), 0, 1) : 0;\n                    R.kind === "camera" ? W = Lo.number(R.minSize, R.maxSize, ze) : F3 = ze;\n                  }\n                  return { uSizeT: F3, uSize: W };\n                }, i3.ai = function(R, { uSize: A3, uSizeT: F3 }, { lowerSize: W, upperSize: re }) {\n                  return R.kind === "source" ? W / d0 : R.kind === "composite" ? Lo.number(W / d0, re / d0, F3) : A3;\n                }, i3.aj = lS, i3.ak = function(R, A3, F3, W) {\n                  let re = A3.y - R.y, fe = A3.x - R.x, pe = W.y - F3.y, ze = W.x - F3.x, Ke = pe * fe - ze * re;\n                  if (Ke === 0) return null;\n                  let ct = (ze * (R.y - F3.y) - pe * (R.x - F3.x)) / Ke;\n                  return new u4(R.x + ct * fe, R.y + ct * re);\n                }, i3.al = FC, i3.am = Sc, i3.an = Ri, i3.ao = function(R) {\n                  let A3 = 1 / 0, F3 = 1 / 0, W = -1 / 0, re = -1 / 0;\n                  for (let fe of R) A3 = Math.min(A3, fe.x), F3 = Math.min(F3, fe.y), W = Math.max(W, fe.x), re = Math.max(re, fe.y);\n                  return [A3, F3, W, re];\n                }, i3.ap = eu, i3.ar = sS, i3.as = function(R, A3) {\n                  var F3 = A3[0], W = A3[1], re = A3[2], fe = A3[3], pe = A3[4], ze = A3[5], Ke = A3[6], ct = A3[7], Lt = A3[8], $t = A3[9], fr = A3[10], mr = A3[11], Pr = A3[12], zr = A3[13], ui = A3[14], yi = A3[15], vn = F3 * ze - W * pe, zi = F3 * Ke - re * pe, un = F3 * ct - fe * pe, Tn = W * Ke - re * ze, pa = W * ct - fe * ze, ro = re * ct - fe * Ke, Vo = Lt * zr - $t * Pr, Xa = Lt * ui - fr * Pr, sa = Lt * yi - mr * Pr, Mo = $t * ui - fr * zr, fo = $t * yi - mr * zr, lo = fr * yi - mr * ui, Xn = vn * lo - zi * fo + un * Mo + Tn * sa - pa * Xa + ro * Vo;\n                  return Xn ? (R[0] = (ze * lo - Ke * fo + ct * Mo) * (Xn = 1 / Xn), R[1] = (re * fo - W * lo - fe * Mo) * Xn, R[2] = (zr * ro - ui * pa + yi * Tn) * Xn, R[3] = (fr * pa - $t * ro - mr * Tn) * Xn, R[4] = (Ke * sa - pe * lo - ct * Xa) * Xn, R[5] = (F3 * lo - re * sa + fe * Xa) * Xn, R[6] = (ui * un - Pr * ro - yi * zi) * Xn, R[7] = (Lt * ro - fr * un + mr * zi) * Xn, R[8] = (pe * fo - ze * sa + ct * Vo) * Xn, R[9] = (W * sa - F3 * fo - fe * Vo) * Xn, R[10] = (Pr * pa - zr * un + yi * vn) * Xn, R[11] = ($t * un - Lt * pa - mr * vn) * Xn, R[12] = (ze * Xa - pe * Mo - Ke * Vo) * Xn, R[13] = (F3 * Mo - W * Xa + re * Vo) * Xn, R[14] = (zr * zi - Pr * Tn - ui * vn) * Xn, R[15] = (Lt * Tn - $t * zi + fr * vn) * Xn, R) : null;\n                }, i3.at = _S, i3.au = Dw, i3.av = xS, i3.aw = function() {\n                  let R = {}, A3 = ce.$version;\n                  for (let F3 in ce.$root) {\n                    let W = ce.$root[F3];\n                    if (W.required) {\n                      let re = null;\n                      re = F3 === "version" ? A3 : W.type === "array" ? [] : {}, re != null && (R[F3] = re);\n                    }\n                  }\n                  return R;\n                }, i3.ax = Yn, i3.ay = ie, i3.az = function(R) {\n                  R = R.slice();\n                  let A3 = /* @__PURE__ */ Object.create(null);\n                  for (let F3 = 0; F3 < R.length; F3++) A3[R[F3].id] = R[F3];\n                  for (let F3 = 0; F3 < R.length; F3++) "ref" in R[F3] && (R[F3] = ut(R[F3], A3[R[F3].ref]));\n                  return R;\n                }, i3.b = G2, i3.b0 = function(R, A3) {\n                  return R[0] = A3[0], R[1] = A3[1], R[2] = A3[2], R[3] = A3[3], R[4] = A3[4], R[5] = A3[5], R[6] = A3[6], R[7] = A3[7], R[8] = A3[8], R[9] = A3[9], R[10] = A3[10], R[11] = A3[11], R[12] = A3[12], R[13] = A3[13], R[14] = A3[14], R[15] = A3[15], R;\n                }, i3.b1 = function(R, A3, F3) {\n                  return R[0] = A3[0] * F3[0], R[1] = A3[1] * F3[1], R[2] = A3[2] * F3[2], R[3] = A3[3] * F3[3], R;\n                }, i3.b2 = function(R, A3) {\n                  return R[0] * A3[0] + R[1] * A3[1] + R[2] * A3[2] + R[3] * A3[3];\n                }, i3.b3 = S2, i3.b4 = LC, i3.b5 = qw, i3.b6 = function(R, A3, F3, W, re) {\n                  var fe, pe = 1 / Math.tan(A3 / 2);\n                  return R[0] = pe / F3, R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = pe, R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[11] = -1, R[12] = 0, R[13] = 0, R[15] = 0, re != null && re !== 1 / 0 ? (R[10] = (re + W) * (fe = 1 / (W - re)), R[14] = 2 * re * W * fe) : (R[10] = -1, R[14] = -2 * W), R;\n                }, i3.b7 = function(R, A3, F3) {\n                  var W = Math.sin(F3), re = Math.cos(F3), fe = A3[4], pe = A3[5], ze = A3[6], Ke = A3[7], ct = A3[8], Lt = A3[9], $t = A3[10], fr = A3[11];\n                  return A3 !== R && (R[0] = A3[0], R[1] = A3[1], R[2] = A3[2], R[3] = A3[3], R[12] = A3[12], R[13] = A3[13], R[14] = A3[14], R[15] = A3[15]), R[4] = fe * re + ct * W, R[5] = pe * re + Lt * W, R[6] = ze * re + $t * W, R[7] = Ke * re + fr * W, R[8] = ct * re - fe * W, R[9] = Lt * re - pe * W, R[10] = $t * re - ze * W, R[11] = fr * re - Ke * W, R;\n                }, i3.b8 = p3, i3.b9 = k4, i3.bA = Sd, i3.bB = function(R) {\n                  return R.message === te;\n                }, i3.bC = ks, i3.bD = ys, i3.ba = function(R) {\n                  return R * Math.PI / 180;\n                }, i3.bb = function(R, A3) {\n                  let { x: F3, y: W } = $x.fromLngLat(A3);\n                  return !(R < 0 || R > 25 || W < 0 || W >= 1 || F3 < 0 || F3 >= 1);\n                }, i3.bc = function(R, A3) {\n                  return R[0] = A3[0], R[1] = 0, R[2] = 0, R[3] = 0, R[4] = 0, R[5] = A3[1], R[6] = 0, R[7] = 0, R[8] = 0, R[9] = 0, R[10] = A3[2], R[11] = 0, R[12] = 0, R[13] = 0, R[14] = 0, R[15] = 1, R;\n                }, i3.bd = class extends Tt {\n                }, i3.be = vS, i3.bf = aO, i3.bh = me, i3.bi = function(R, A3) {\n                  _e.REGISTERED_PROTOCOLS[R] = A3;\n                }, i3.bj = function(R) {\n                  delete _e.REGISTERED_PROTOCOLS[R];\n                }, i3.bk = function(R, A3) {\n                  let F3 = {};\n                  for (let re = 0; re < R.length; re++) {\n                    let fe = A3 && A3[R[re].id] || Hh(R[re]);\n                    A3 && (A3[R[re].id] = fe);\n                    let pe = F3[fe];\n                    pe || (pe = F3[fe] = []), pe.push(R[re]);\n                  }\n                  let W = [];\n                  for (let re in F3) W.push(F3[re]);\n                  return W;\n                }, i3.bl = Fi, i3.bm = IC, i3.bn = fy, i3.bo = Pw, i3.bp = function(R) {\n                  R.bucket.createArrays(), R.bucket.tilePixelRatio = ja / (512 * R.bucket.overscaling), R.bucket.compareText = {}, R.bucket.iconsNeedLinear = false;\n                  let A3 = R.bucket.layers[0], F3 = A3.layout, W = A3._unevaluatedLayout._values, re = { layoutIconSize: W["icon-size"].possiblyEvaluate(new rs(R.bucket.zoom + 1), R.canonical), layoutTextSize: W["text-size"].possiblyEvaluate(new rs(R.bucket.zoom + 1), R.canonical), textMaxSize: W["text-size"].possiblyEvaluate(new rs(18)) };\n                  if (R.bucket.textSizeData.kind === "composite") {\n                    let { minZoom: ct, maxZoom: Lt } = R.bucket.textSizeData;\n                    re.compositeTextSizes = [W["text-size"].possiblyEvaluate(new rs(ct), R.canonical), W["text-size"].possiblyEvaluate(new rs(Lt), R.canonical)];\n                  }\n                  if (R.bucket.iconSizeData.kind === "composite") {\n                    let { minZoom: ct, maxZoom: Lt } = R.bucket.iconSizeData;\n                    re.compositeIconSizes = [W["icon-size"].possiblyEvaluate(new rs(ct), R.canonical), W["icon-size"].possiblyEvaluate(new rs(Lt), R.canonical)];\n                  }\n                  let fe = F3.get("text-line-height") * eu, pe = F3.get("text-rotation-alignment") !== "viewport" && F3.get("symbol-placement") !== "point", ze = F3.get("text-keep-upright"), Ke = F3.get("text-size");\n                  for (let ct of R.bucket.features) {\n                    let Lt = F3.get("text-font").evaluate(ct, {}, R.canonical).join(","), $t = Ke.evaluate(ct, {}, R.canonical), fr = re.layoutTextSize.evaluate(ct, {}, R.canonical), mr = re.layoutIconSize.evaluate(ct, {}, R.canonical), Pr = { horizontal: {}, vertical: void 0 }, zr = ct.text, ui, yi = [0, 0];\n                    if (zr) {\n                      let un = zr.toString(), Tn = F3.get("text-letter-spacing").evaluate(ct, {}, R.canonical) * eu, pa = bo(un) ? Tn : 0, ro = F3.get("text-anchor").evaluate(ct, {}, R.canonical), Vo = VC(A3, ct, R.canonical);\n                      if (!Vo) {\n                        let fo = F3.get("text-radial-offset").evaluate(ct, {}, R.canonical);\n                        yi = fo ? yS(ro, [fo * eu, hy]) : F3.get("text-offset").evaluate(ct, {}, R.canonical).map((lo) => lo * eu);\n                      }\n                      let Xa = pe ? "center" : F3.get("text-justify").evaluate(ct, {}, R.canonical), sa = F3.get("symbol-placement") === "point" ? F3.get("text-max-width").evaluate(ct, {}, R.canonical) * eu : 1 / 0, Mo = () => {\n                        R.bucket.allowVerticalPlacement && Ka(un) && (Pr.vertical = Hx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, "left", pa, yi, i3.ah.vertical, true, fr, $t));\n                      };\n                      if (!pe && Vo) {\n                        let fo = /* @__PURE__ */ new Set();\n                        if (Xa === "auto") for (let Xn = 0; Xn < Vo.values.length; Xn += 2) fo.add(_S(Vo.values[Xn]));\n                        else fo.add(Xa);\n                        let lo = false;\n                        for (let Xn of fo) if (!Pr.horizontal[Xn]) if (lo) Pr.horizontal[Xn] = Pr.horizontal[0];\n                        else {\n                          let Ro = Hx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, "center", Xn, pa, yi, i3.ah.horizontal, false, fr, $t);\n                          Ro && (Pr.horizontal[Xn] = Ro, lo = Ro.positionedLines.length === 1);\n                        }\n                        Mo();\n                      } else {\n                        Xa === "auto" && (Xa = _S(ro));\n                        let fo = Hx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, Xa, pa, yi, i3.ah.horizontal, false, fr, $t);\n                        fo && (Pr.horizontal[Xa] = fo), Mo(), Ka(un) && pe && ze && (Pr.vertical = Hx(zr, R.glyphMap, R.glyphPositions, R.imagePositions, Lt, sa, fe, ro, Xa, pa, yi, i3.ah.vertical, false, fr, $t));\n                      }\n                    }\n                    let vn = false;\n                    if (ct.icon && ct.icon.name) {\n                      let un = R.imageMap[ct.icon.name];\n                      un && (ui = jx(R.imagePositions[ct.icon.name], F3.get("icon-offset").evaluate(ct, {}, R.canonical), F3.get("icon-anchor").evaluate(ct, {}, R.canonical)), vn = !!un.sdf, R.bucket.sdfIcons === void 0 ? R.bucket.sdfIcons = vn : R.bucket.sdfIcons !== vn && T3("Style sheet warning: Cannot mix SDF and non-SDF icons in one buffer"), (un.pixelRatio !== R.bucket.pixelRatio || F3.get("icon-rotate").constantOr(1) !== 0) && (R.bucket.iconsNeedLinear = true));\n                    }\n                    let zi = HC(Pr.horizontal) || Pr.vertical;\n                    R.bucket.iconsInText = !!zi && zi.iconsInText, (zi || ui) && iO(R.bucket, ct, Pr, ui, R.imageMap, re, fr, mr, yi, vn, R.canonical);\n                  }\n                  R.showCollisionBoxes && R.bucket.generateCollisionDebugBuffers();\n                }, i3.bq = Jv, i3.br = Ot, i3.bs = so, i3.bt = br, i3.bu = nS, i3.bv = class {\n                  constructor(R) {\n                    this._marks = { start: [R.url, "start"].join("#"), end: [R.url, "end"].join("#"), measure: R.url.toString() }, performance.mark(this._marks.start);\n                  }\n                  finish() {\n                    performance.mark(this._marks.end);\n                    let R = performance.getEntriesByName(this._marks.measure);\n                    return R.length === 0 && (performance.measure(this._marks.measure, this._marks.start, this._marks.end), R = performance.getEntriesByName(this._marks.measure), performance.clearMarks(this._marks.start), performance.clearMarks(this._marks.end), performance.clearMeasures(this._marks.measure)), R;\n                  }\n                }, i3.bw = function(R, A3, F3, W, re) {\n                  return a4(this, void 0, void 0, function* () {\n                    if (b()) try {\n                      return yield j3(R, A3, F3, W, re);\n                    } catch (fe) {\n                    }\n                    return (function(fe, pe, ze, Ke, ct) {\n                      let Lt = fe.width, $t = fe.height;\n                      N2 && H || (N2 = new OffscreenCanvas(Lt, $t), H = N2.getContext("2d", { willReadFrequently: true })), N2.width = Lt, N2.height = $t, H.drawImage(fe, 0, 0, Lt, $t);\n                      let fr = H.getImageData(pe, ze, Ke, ct);\n                      return H.clearRect(0, 0, Lt, $t), fr.data;\n                    })(R, A3, F3, W, re);\n                  });\n                }, i3.bx = PC, i3.by = o4, i3.bz = s3, i3.c = oe, i3.d = (R) => a4(void 0, void 0, void 0, function* () {\n                  if (R.byteLength === 0) return createImageBitmap(new ImageData(1, 1));\n                  let A3 = new Blob([new Uint8Array(R)], { type: "image/png" });\n                  try {\n                    return createImageBitmap(A3);\n                  } catch (F3) {\n                    throw new Error(`Could not load image because of ${F3.message}. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported.`);\n                  }\n                }), i3.e = L3, i3.f = (R) => new Promise((A3, F3) => {\n                  let W = new Image();\n                  W.onload = () => {\n                    A3(W), URL.revokeObjectURL(W.src), W.onload = null, window.requestAnimationFrame(() => {\n                      W.src = Z;\n                    });\n                  }, W.onerror = () => F3(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));\n                  let re = new Blob([new Uint8Array(R)], { type: "image/png" });\n                  W.src = R.byteLength ? URL.createObjectURL(re) : Z;\n                }), i3.g = Ee, i3.h = (R, A3) => Se(L3(R, { type: "json" }), A3), i3.i = O3, i3.j = ge, i3.k = Pe, i3.l = (R, A3) => Se(L3(R, { type: "arrayBuffer" }), A3), i3.m = Se, i3.n = function(R) {\n                  return new nS(R).readFields(PQ, []);\n                }, i3.o = na, i3.p = oS, i3.q = ue, i3.r = Xi, i3.s = Le, i3.t = Yi, i3.u = ki, i3.v = ce, i3.w = T3, i3.x = function([R, A3, F3]) {\n                  return A3 += 90, A3 *= Math.PI / 180, F3 *= Math.PI / 180, { x: R * Math.cos(A3) * Math.sin(F3), y: R * Math.sin(A3) * Math.sin(F3), z: R * Math.cos(F3) };\n                }, i3.y = Lo, i3.z = rs;\n              }), r4("worker", ["./shared"], function(i3) {\n                "use strict";\n                class a4 {\n                  constructor(Ge) {\n                    this.keyCache = {}, Ge && this.replace(Ge);\n                  }\n                  replace(Ge) {\n                    this._layerConfigs = {}, this._layers = {}, this.update(Ge, []);\n                  }\n                  update(Ge, Je) {\n                    for (let tt of Ge) {\n                      this._layerConfigs[tt.id] = tt;\n                      let xt = this._layers[tt.id] = i3.aA(tt);\n                      xt._featureFilter = i3.a7(xt.filter), this.keyCache[tt.id] && delete this.keyCache[tt.id];\n                    }\n                    for (let tt of Je) delete this.keyCache[tt], delete this._layerConfigs[tt], delete this._layers[tt];\n                    this.familiesBySource = {};\n                    let je = i3.bk(Object.values(this._layerConfigs), this.keyCache);\n                    for (let tt of je) {\n                      let xt = tt.map((ar) => this._layers[ar.id]), Ie = xt[0];\n                      if (Ie.visibility === "none") continue;\n                      let xe = Ie.source || "", ke = this.familiesBySource[xe];\n                      ke || (ke = this.familiesBySource[xe] = {});\n                      let vt = Ie.sourceLayer || "_geojsonTileLayer", ir = ke[vt];\n                      ir || (ir = ke[vt] = []), ir.push(xt);\n                    }\n                  }\n                }\n                class o4 {\n                  constructor(Ge) {\n                    let Je = {}, je = [];\n                    for (let xe in Ge) {\n                      let ke = Ge[xe], vt = Je[xe] = {};\n                      for (let ir in ke) {\n                        let ar = ke[+ir];\n                        if (!ar || ar.bitmap.width === 0 || ar.bitmap.height === 0) continue;\n                        let vr = { x: 0, y: 0, w: ar.bitmap.width + 2, h: ar.bitmap.height + 2 };\n                        je.push(vr), vt[ir] = { rect: vr, metrics: ar.metrics };\n                      }\n                    }\n                    let { w: tt, h: xt } = i3.p(je), Ie = new i3.o({ width: tt || 1, height: xt || 1 });\n                    for (let xe in Ge) {\n                      let ke = Ge[xe];\n                      for (let vt in ke) {\n                        let ir = ke[+vt];\n                        if (!ir || ir.bitmap.width === 0 || ir.bitmap.height === 0) continue;\n                        let ar = Je[xe][vt].rect;\n                        i3.o.copy(ir.bitmap, Ie, { x: 0, y: 0 }, { x: ar.x + 1, y: ar.y + 1 }, ir.bitmap);\n                      }\n                    }\n                    this.image = Ie, this.positions = Je;\n                  }\n                }\n                i3.bl("GlyphAtlas", o4);\n                class s3 {\n                  constructor(Ge) {\n                    this.tileID = new i3.S(Ge.tileID.overscaledZ, Ge.tileID.wrap, Ge.tileID.canonical.z, Ge.tileID.canonical.x, Ge.tileID.canonical.y), this.uid = Ge.uid, this.zoom = Ge.zoom, this.pixelRatio = Ge.pixelRatio, this.tileSize = Ge.tileSize, this.source = Ge.source, this.overscaling = this.tileID.overscaleFactor(), this.showCollisionBoxes = Ge.showCollisionBoxes, this.collectResourceTiming = !!Ge.collectResourceTiming, this.returnDependencies = !!Ge.returnDependencies, this.promoteId = Ge.promoteId, this.inFlightDependencies = [];\n                  }\n                  parse(Ge, Je, je, tt) {\n                    return i3._(this, void 0, void 0, function* () {\n                      this.status = "parsing", this.data = Ge, this.collisionBoxArray = new i3.a5();\n                      let xt = new i3.bm(Object.keys(Ge.layers).sort()), Ie = new i3.bn(this.tileID, this.promoteId);\n                      Ie.bucketLayerIDs = [];\n                      let xe = {}, ke = { featureIndex: Ie, iconDependencies: {}, patternDependencies: {}, glyphDependencies: {}, availableImages: je }, vt = Je.familiesBySource[this.source];\n                      for (let qn in vt) {\n                        let Fn = Ge.layers[qn];\n                        if (!Fn) continue;\n                        Fn.version === 1 && i3.w(`Vector tile source "${this.source}" layer "${qn}" does not use vector tile spec v2 and therefore may have some rendering errors.`);\n                        let ra = xt.encode(qn), la = [];\n                        for (let Ut = 0; Ut < Fn.length; Ut++) {\n                          let wt = Fn.feature(Ut), rr = Ie.getId(wt, qn);\n                          la.push({ feature: wt, id: rr, index: Ut, sourceLayerIndex: ra });\n                        }\n                        for (let Ut of vt[qn]) {\n                          let wt = Ut[0];\n                          wt.source !== this.source && i3.w(`layer.source = ${wt.source} does not equal this.source = ${this.source}`), wt.minzoom && this.zoom < Math.floor(wt.minzoom) || wt.maxzoom && this.zoom >= wt.maxzoom || wt.visibility !== "none" && (l3(Ut, this.zoom, je), (xe[wt.id] = wt.createBucket({ index: Ie.bucketLayerIDs.length, layers: Ut, zoom: this.zoom, pixelRatio: this.pixelRatio, overscaling: this.overscaling, collisionBoxArray: this.collisionBoxArray, sourceLayerIndex: ra, sourceID: this.source })).populate(la, ke, this.tileID.canonical), Ie.bucketLayerIDs.push(Ut.map((rr) => rr.id)));\n                        }\n                      }\n                      let ir = i3.aF(ke.glyphDependencies, (qn) => Object.keys(qn).map(Number));\n                      this.inFlightDependencies.forEach((qn) => qn == null ? void 0 : qn.abort()), this.inFlightDependencies = [];\n                      let ar = Promise.resolve({});\n                      if (Object.keys(ir).length) {\n                        let qn = new AbortController();\n                        this.inFlightDependencies.push(qn), ar = tt.sendAsync({ type: "GG", data: { stacks: ir, source: this.source, tileID: this.tileID, type: "glyphs" } }, qn);\n                      }\n                      let vr = Object.keys(ke.iconDependencies), ii = Promise.resolve({});\n                      if (vr.length) {\n                        let qn = new AbortController();\n                        this.inFlightDependencies.push(qn), ii = tt.sendAsync({ type: "GI", data: { icons: vr, source: this.source, tileID: this.tileID, type: "icons" } }, qn);\n                      }\n                      let pi = Object.keys(ke.patternDependencies), $r = Promise.resolve({});\n                      if (pi.length) {\n                        let qn = new AbortController();\n                        this.inFlightDependencies.push(qn), $r = tt.sendAsync({ type: "GI", data: { icons: pi, source: this.source, tileID: this.tileID, type: "patterns" } }, qn);\n                      }\n                      let [di, ji, In] = yield Promise.all([ar, ii, $r]), wi = new o4(di), On = new i3.bo(ji, In);\n                      for (let qn in xe) {\n                        let Fn = xe[qn];\n                        Fn instanceof i3.a6 ? (l3(Fn.layers, this.zoom, je), i3.bp({ bucket: Fn, glyphMap: di, glyphPositions: wi.positions, imageMap: ji, imagePositions: On.iconPositions, showCollisionBoxes: this.showCollisionBoxes, canonical: this.tileID.canonical })) : Fn.hasPattern && (Fn instanceof i3.bq || Fn instanceof i3.br || Fn instanceof i3.bs) && (l3(Fn.layers, this.zoom, je), Fn.addFeatures(ke, this.tileID.canonical, On.patternPositions));\n                      }\n                      return this.status = "done", { buckets: Object.values(xe).filter((qn) => !qn.isEmpty()), featureIndex: Ie, collisionBoxArray: this.collisionBoxArray, glyphAtlasImage: wi.image, imageAtlas: On, glyphMap: this.returnDependencies ? di : null, iconMap: this.returnDependencies ? ji : null, glyphPositions: this.returnDependencies ? wi.positions : null };\n                    });\n                  }\n                }\n                function l3(dt, Ge, Je) {\n                  let je = new i3.z(Ge);\n                  for (let tt of dt) tt.recalculate(je, Je);\n                }\n                class u4 {\n                  constructor(Ge, Je, je) {\n                    this.actor = Ge, this.layerIndex = Je, this.availableImages = je, this.fetching = {}, this.loading = {}, this.loaded = {};\n                  }\n                  loadVectorTile(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let je = yield i3.l(Ge.request, Je);\n                      try {\n                        return { vectorTile: new i3.bt.VectorTile(new i3.bu(je.data)), rawData: je.data, cacheControl: je.cacheControl, expires: je.expires };\n                      } catch (tt) {\n                        let xt = new Uint8Array(je.data), Ie = `Unable to parse the tile at ${Ge.request.url}, `;\n                        throw Ie += xt[0] === 31 && xt[1] === 139 ? "please make sure the data is not gzipped and that you have configured the relevant header in the server" : `got error: ${tt.message}`, new Error(Ie);\n                      }\n                    });\n                  }\n                  loadTile(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let Je = Ge.uid, je = !!(Ge && Ge.request && Ge.request.collectResourceTiming) && new i3.bv(Ge.request), tt = new s3(Ge);\n                      this.loading[Je] = tt;\n                      let xt = new AbortController();\n                      tt.abort = xt;\n                      try {\n                        let Ie = yield this.loadVectorTile(Ge, xt);\n                        if (delete this.loading[Je], !Ie) return null;\n                        let xe = Ie.rawData, ke = {};\n                        Ie.expires && (ke.expires = Ie.expires), Ie.cacheControl && (ke.cacheControl = Ie.cacheControl);\n                        let vt = {};\n                        if (je) {\n                          let ar = je.finish();\n                          ar && (vt.resourceTiming = JSON.parse(JSON.stringify(ar)));\n                        }\n                        tt.vectorTile = Ie.vectorTile;\n                        let ir = tt.parse(Ie.vectorTile, this.layerIndex, this.availableImages, this.actor);\n                        this.loaded[Je] = tt, this.fetching[Je] = { rawTileData: xe, cacheControl: ke, resourceTiming: vt };\n                        try {\n                          let ar = yield ir;\n                          return i3.e({ rawTileData: xe.slice(0) }, ar, ke, vt);\n                        } finally {\n                          delete this.fetching[Je];\n                        }\n                      } catch (Ie) {\n                        throw delete this.loading[Je], tt.status = "done", this.loaded[Je] = tt, Ie;\n                      }\n                    });\n                  }\n                  reloadTile(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let Je = Ge.uid;\n                      if (!this.loaded || !this.loaded[Je]) throw new Error("Should not be trying to reload a tile that was never loaded or has been removed");\n                      let je = this.loaded[Je];\n                      if (je.showCollisionBoxes = Ge.showCollisionBoxes, je.status === "parsing") {\n                        let tt = yield je.parse(je.vectorTile, this.layerIndex, this.availableImages, this.actor), xt;\n                        if (this.fetching[Je]) {\n                          let { rawTileData: Ie, cacheControl: xe, resourceTiming: ke } = this.fetching[Je];\n                          delete this.fetching[Je], xt = i3.e({ rawTileData: Ie.slice(0) }, tt, xe, ke);\n                        } else xt = tt;\n                        return xt;\n                      }\n                      if (je.status === "done" && je.vectorTile) return je.parse(je.vectorTile, this.layerIndex, this.availableImages, this.actor);\n                    });\n                  }\n                  abortTile(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let Je = this.loading, je = Ge.uid;\n                      Je && Je[je] && Je[je].abort && (Je[je].abort.abort(), delete Je[je]);\n                    });\n                  }\n                  removeTile(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      this.loaded && this.loaded[Ge.uid] && delete this.loaded[Ge.uid];\n                    });\n                  }\n                }\n                class c5 {\n                  constructor() {\n                    this.loaded = {};\n                  }\n                  loadTile(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let { uid: Je, encoding: je, rawImageData: tt, redFactor: xt, greenFactor: Ie, blueFactor: xe, baseShift: ke } = Ge, vt = tt.width + 2, ir = tt.height + 2, ar = i3.b(tt) ? new i3.R({ width: vt, height: ir }, yield i3.bw(tt, -1, -1, vt, ir)) : tt, vr = new i3.bx(Je, ar, je, xt, Ie, xe, ke);\n                      return this.loaded = this.loaded || {}, this.loaded[Je] = vr, vr;\n                    });\n                  }\n                  removeTile(Ge) {\n                    let Je = this.loaded, je = Ge.uid;\n                    Je && Je[je] && delete Je[je];\n                  }\n                }\n                function f4(dt, Ge) {\n                  if (dt.length !== 0) {\n                    h3(dt[0], Ge);\n                    for (var Je = 1; Je < dt.length; Je++) h3(dt[Je], !Ge);\n                  }\n                }\n                function h3(dt, Ge) {\n                  for (var Je = 0, je = 0, tt = 0, xt = dt.length, Ie = xt - 1; tt < xt; Ie = tt++) {\n                    var xe = (dt[tt][0] - dt[Ie][0]) * (dt[Ie][1] + dt[tt][1]), ke = Je + xe;\n                    je += Math.abs(Je) >= Math.abs(xe) ? Je - ke + xe : xe - ke + Je, Je = ke;\n                  }\n                  Je + je >= 0 != !!Ge && dt.reverse();\n                }\n                var d3 = i3.by(function dt(Ge, Je) {\n                  var je, tt = Ge && Ge.type;\n                  if (tt === "FeatureCollection") for (je = 0; je < Ge.features.length; je++) dt(Ge.features[je], Je);\n                  else if (tt === "GeometryCollection") for (je = 0; je < Ge.geometries.length; je++) dt(Ge.geometries[je], Je);\n                  else if (tt === "Feature") dt(Ge.geometry, Je);\n                  else if (tt === "Polygon") f4(Ge.coordinates, Je);\n                  else if (tt === "MultiPolygon") for (je = 0; je < Ge.coordinates.length; je++) f4(Ge.coordinates[je], Je);\n                  return Ge;\n                });\n                let v3 = i3.bt.VectorTileFeature.prototype.toGeoJSON;\n                var _2 = { exports: {} }, b = i3.bz, p3 = i3.bt.VectorTileFeature, k4 = E3;\n                function E3(dt, Ge) {\n                  this.options = Ge || {}, this.features = dt, this.length = dt.length;\n                }\n                function S2(dt, Ge) {\n                  this.id = typeof dt.id == "number" ? dt.id : void 0, this.type = dt.type, this.rawGeometry = dt.type === 1 ? [dt.geometry] : dt.geometry, this.properties = dt.tags, this.extent = Ge || 4096;\n                }\n                E3.prototype.feature = function(dt) {\n                  return new S2(this.features[dt], this.options.extent);\n                }, S2.prototype.loadGeometry = function() {\n                  var dt = this.rawGeometry;\n                  this.geometry = [];\n                  for (var Ge = 0; Ge < dt.length; Ge++) {\n                    for (var Je = dt[Ge], je = [], tt = 0; tt < Je.length; tt++) je.push(new b(Je[tt][0], Je[tt][1]));\n                    this.geometry.push(je);\n                  }\n                  return this.geometry;\n                }, S2.prototype.bbox = function() {\n                  this.geometry || this.loadGeometry();\n                  for (var dt = this.geometry, Ge = 1 / 0, Je = -1 / 0, je = 1 / 0, tt = -1 / 0, xt = 0; xt < dt.length; xt++) for (var Ie = dt[xt], xe = 0; xe < Ie.length; xe++) {\n                    var ke = Ie[xe];\n                    Ge = Math.min(Ge, ke.x), Je = Math.max(Je, ke.x), je = Math.min(je, ke.y), tt = Math.max(tt, ke.y);\n                  }\n                  return [Ge, je, Je, tt];\n                }, S2.prototype.toGeoJSON = p3.prototype.toGeoJSON;\n                var L3 = i3.bA, x2 = k4;\n                function C3(dt) {\n                  var Ge = new L3();\n                  return (function(Je, je) {\n                    for (var tt in Je.layers) je.writeMessage(3, M4, Je.layers[tt]);\n                  })(dt, Ge), Ge.finish();\n                }\n                function M4(dt, Ge) {\n                  var Je;\n                  Ge.writeVarintField(15, dt.version || 1), Ge.writeStringField(1, dt.name || ""), Ge.writeVarintField(5, dt.extent || 4096);\n                  var je = { keys: [], values: [], keycache: {}, valuecache: {} };\n                  for (Je = 0; Je < dt.length; Je++) je.feature = dt.feature(Je), Ge.writeMessage(2, g3, je);\n                  var tt = je.keys;\n                  for (Je = 0; Je < tt.length; Je++) Ge.writeStringField(3, tt[Je]);\n                  var xt = je.values;\n                  for (Je = 0; Je < xt.length; Je++) Ge.writeMessage(4, V2, xt[Je]);\n                }\n                function g3(dt, Ge) {\n                  var Je = dt.feature;\n                  Je.id !== void 0 && Ge.writeVarintField(1, Je.id), Ge.writeMessage(2, P3, dt), Ge.writeVarintField(3, Je.type), Ge.writeMessage(4, O3, Je);\n                }\n                function P3(dt, Ge) {\n                  var Je = dt.feature, je = dt.keys, tt = dt.values, xt = dt.keycache, Ie = dt.valuecache;\n                  for (var xe in Je.properties) {\n                    var ke = Je.properties[xe], vt = xt[xe];\n                    if (ke !== null) {\n                      vt === void 0 && (je.push(xe), xt[xe] = vt = je.length - 1), Ge.writeVarint(vt);\n                      var ir = typeof ke;\n                      ir !== "string" && ir !== "boolean" && ir !== "number" && (ke = JSON.stringify(ke));\n                      var ar = ir + ":" + ke, vr = Ie[ar];\n                      vr === void 0 && (tt.push(ke), Ie[ar] = vr = tt.length - 1), Ge.writeVarint(vr);\n                    }\n                  }\n                }\n                function T3(dt, Ge) {\n                  return (Ge << 3) + (7 & dt);\n                }\n                function z3(dt) {\n                  return dt << 1 ^ dt >> 31;\n                }\n                function O3(dt, Ge) {\n                  for (var Je = dt.loadGeometry(), je = dt.type, tt = 0, xt = 0, Ie = Je.length, xe = 0; xe < Ie; xe++) {\n                    var ke = Je[xe], vt = 1;\n                    je === 1 && (vt = ke.length), Ge.writeVarint(T3(1, vt));\n                    for (var ir = je === 3 ? ke.length - 1 : ke.length, ar = 0; ar < ir; ar++) {\n                      ar === 1 && je !== 1 && Ge.writeVarint(T3(2, ir - 1));\n                      var vr = ke[ar].x - tt, ii = ke[ar].y - xt;\n                      Ge.writeVarint(z3(vr)), Ge.writeVarint(z3(ii)), tt += vr, xt += ii;\n                    }\n                    je === 3 && Ge.writeVarint(T3(7, 1));\n                  }\n                }\n                function V2(dt, Ge) {\n                  var Je = typeof dt;\n                  Je === "string" ? Ge.writeStringField(1, dt) : Je === "boolean" ? Ge.writeBooleanField(7, dt) : Je === "number" && (dt % 1 != 0 ? Ge.writeDoubleField(3, dt) : dt < 0 ? Ge.writeSVarintField(6, dt) : Ge.writeVarintField(5, dt));\n                }\n                _2.exports = C3, _2.exports.fromVectorTileJs = C3, _2.exports.fromGeojsonVt = function(dt, Ge) {\n                  Ge = Ge || {};\n                  var Je = {};\n                  for (var je in dt) Je[je] = new x2(dt[je].features, Ge), Je[je].name = je, Je[je].version = Ge.version, Je[je].extent = Ge.extent;\n                  return C3({ layers: Je });\n                }, _2.exports.GeoJSONWrapper = x2;\n                var G2 = i3.by(_2.exports);\n                let Z = { minZoom: 0, maxZoom: 16, minPoints: 2, radius: 40, extent: 512, nodeSize: 64, log: false, generateId: false, reduce: null, map: (dt) => dt }, j3 = Math.fround || (N2 = new Float32Array(1), (dt) => (N2[0] = +dt, N2[0]));\n                var N2;\n                let H = 3, te = 5, oe = 6;\n                class _e {\n                  constructor(Ge) {\n                    this.options = Object.assign(Object.create(Z), Ge), this.trees = new Array(this.options.maxZoom + 1), this.stride = this.options.reduce ? 7 : 6, this.clusterProps = [];\n                  }\n                  load(Ge) {\n                    let { log: Je, minZoom: je, maxZoom: tt } = this.options;\n                    Je && console.time("total time");\n                    let xt = `prepare ${Ge.length} points`;\n                    Je && console.time(xt), this.points = Ge;\n                    let Ie = [];\n                    for (let ke = 0; ke < Ge.length; ke++) {\n                      let vt = Ge[ke];\n                      if (!vt.geometry) continue;\n                      let [ir, ar] = vt.geometry.coordinates, vr = j3(me(ir)), ii = j3(ie(ar));\n                      Ie.push(vr, ii, 1 / 0, ke, -1, 1), this.options.reduce && Ie.push(0);\n                    }\n                    let xe = this.trees[tt + 1] = this._createTree(Ie);\n                    Je && console.timeEnd(xt);\n                    for (let ke = tt; ke >= je; ke--) {\n                      let vt = +Date.now();\n                      xe = this.trees[ke] = this._createTree(this._cluster(xe, ke)), Je && console.log("z%d: %d clusters in %dms", ke, xe.numItems, +Date.now() - vt);\n                    }\n                    return Je && console.timeEnd("total time"), this;\n                  }\n                  getClusters(Ge, Je) {\n                    let je = ((Ge[0] + 180) % 360 + 360) % 360 - 180, tt = Math.max(-90, Math.min(90, Ge[1])), xt = Ge[2] === 180 ? 180 : ((Ge[2] + 180) % 360 + 360) % 360 - 180, Ie = Math.max(-90, Math.min(90, Ge[3]));\n                    if (Ge[2] - Ge[0] >= 360) je = -180, xt = 180;\n                    else if (je > xt) {\n                      let ar = this.getClusters([je, tt, 180, Ie], Je), vr = this.getClusters([-180, tt, xt, Ie], Je);\n                      return ar.concat(vr);\n                    }\n                    let xe = this.trees[this._limitZoom(Je)], ke = xe.range(me(je), ie(Ie), me(xt), ie(tt)), vt = xe.data, ir = [];\n                    for (let ar of ke) {\n                      let vr = this.stride * ar;\n                      ir.push(vt[vr + te] > 1 ? Ee(vt, vr, this.clusterProps) : this.points[vt[vr + H]]);\n                    }\n                    return ir;\n                  }\n                  getChildren(Ge) {\n                    let Je = this._getOriginId(Ge), je = this._getOriginZoom(Ge), tt = "No cluster with the specified id.", xt = this.trees[je];\n                    if (!xt) throw new Error(tt);\n                    let Ie = xt.data;\n                    if (Je * this.stride >= Ie.length) throw new Error(tt);\n                    let xe = this.options.radius / (this.options.extent * Math.pow(2, je - 1)), ke = xt.within(Ie[Je * this.stride], Ie[Je * this.stride + 1], xe), vt = [];\n                    for (let ir of ke) {\n                      let ar = ir * this.stride;\n                      Ie[ar + 4] === Ge && vt.push(Ie[ar + te] > 1 ? Ee(Ie, ar, this.clusterProps) : this.points[Ie[ar + H]]);\n                    }\n                    if (vt.length === 0) throw new Error(tt);\n                    return vt;\n                  }\n                  getLeaves(Ge, Je, je) {\n                    let tt = [];\n                    return this._appendLeaves(tt, Ge, Je = Je || 10, je = je || 0, 0), tt;\n                  }\n                  getTile(Ge, Je, je) {\n                    let tt = this.trees[this._limitZoom(Ge)], xt = Math.pow(2, Ge), { extent: Ie, radius: xe } = this.options, ke = xe / Ie, vt = (je - ke) / xt, ir = (je + 1 + ke) / xt, ar = { features: [] };\n                    return this._addTileFeatures(tt.range((Je - ke) / xt, vt, (Je + 1 + ke) / xt, ir), tt.data, Je, je, xt, ar), Je === 0 && this._addTileFeatures(tt.range(1 - ke / xt, vt, 1, ir), tt.data, xt, je, xt, ar), Je === xt - 1 && this._addTileFeatures(tt.range(0, vt, ke / xt, ir), tt.data, -1, je, xt, ar), ar.features.length ? ar : null;\n                  }\n                  getClusterExpansionZoom(Ge) {\n                    let Je = this._getOriginZoom(Ge) - 1;\n                    for (; Je <= this.options.maxZoom; ) {\n                      let je = this.getChildren(Ge);\n                      if (Je++, je.length !== 1) break;\n                      Ge = je[0].properties.cluster_id;\n                    }\n                    return Je;\n                  }\n                  _appendLeaves(Ge, Je, je, tt, xt) {\n                    let Ie = this.getChildren(Je);\n                    for (let xe of Ie) {\n                      let ke = xe.properties;\n                      if (ke && ke.cluster ? xt + ke.point_count <= tt ? xt += ke.point_count : xt = this._appendLeaves(Ge, ke.cluster_id, je, tt, xt) : xt < tt ? xt++ : Ge.push(xe), Ge.length === je) break;\n                    }\n                    return xt;\n                  }\n                  _createTree(Ge) {\n                    let Je = new i3.av(Ge.length / this.stride | 0, this.options.nodeSize, Float32Array);\n                    for (let je = 0; je < Ge.length; je += this.stride) Je.add(Ge[je], Ge[je + 1]);\n                    return Je.finish(), Je.data = Ge, Je;\n                  }\n                  _addTileFeatures(Ge, Je, je, tt, xt, Ie) {\n                    for (let xe of Ge) {\n                      let ke = xe * this.stride, vt = Je[ke + te] > 1, ir, ar, vr;\n                      if (vt) ir = Ce(Je, ke, this.clusterProps), ar = Je[ke], vr = Je[ke + 1];\n                      else {\n                        let $r = this.points[Je[ke + H]];\n                        ir = $r.properties;\n                        let [di, ji] = $r.geometry.coordinates;\n                        ar = me(di), vr = ie(ji);\n                      }\n                      let ii = { type: 1, geometry: [[Math.round(this.options.extent * (ar * xt - je)), Math.round(this.options.extent * (vr * xt - tt))]], tags: ir }, pi;\n                      pi = vt || this.options.generateId ? Je[ke + H] : this.points[Je[ke + H]].id, pi !== void 0 && (ii.id = pi), Ie.features.push(ii);\n                    }\n                  }\n                  _limitZoom(Ge) {\n                    return Math.max(this.options.minZoom, Math.min(Math.floor(+Ge), this.options.maxZoom + 1));\n                  }\n                  _cluster(Ge, Je) {\n                    let { radius: je, extent: tt, reduce: xt, minPoints: Ie } = this.options, xe = je / (tt * Math.pow(2, Je)), ke = Ge.data, vt = [], ir = this.stride;\n                    for (let ar = 0; ar < ke.length; ar += ir) {\n                      if (ke[ar + 2] <= Je) continue;\n                      ke[ar + 2] = Je;\n                      let vr = ke[ar], ii = ke[ar + 1], pi = Ge.within(ke[ar], ke[ar + 1], xe), $r = ke[ar + te], di = $r;\n                      for (let ji of pi) {\n                        let In = ji * ir;\n                        ke[In + 2] > Je && (di += ke[In + te]);\n                      }\n                      if (di > $r && di >= Ie) {\n                        let ji, In = vr * $r, wi = ii * $r, On = -1, qn = ((ar / ir | 0) << 5) + (Je + 1) + this.points.length;\n                        for (let Fn of pi) {\n                          let ra = Fn * ir;\n                          if (ke[ra + 2] <= Je) continue;\n                          ke[ra + 2] = Je;\n                          let la = ke[ra + te];\n                          In += ke[ra] * la, wi += ke[ra + 1] * la, ke[ra + 4] = qn, xt && (ji || (ji = this._map(ke, ar, true), On = this.clusterProps.length, this.clusterProps.push(ji)), xt(ji, this._map(ke, ra)));\n                        }\n                        ke[ar + 4] = qn, vt.push(In / di, wi / di, 1 / 0, qn, -1, di), xt && vt.push(On);\n                      } else {\n                        for (let ji = 0; ji < ir; ji++) vt.push(ke[ar + ji]);\n                        if (di > 1) for (let ji of pi) {\n                          let In = ji * ir;\n                          if (!(ke[In + 2] <= Je)) {\n                            ke[In + 2] = Je;\n                            for (let wi = 0; wi < ir; wi++) vt.push(ke[In + wi]);\n                          }\n                        }\n                      }\n                    }\n                    return vt;\n                  }\n                  _getOriginId(Ge) {\n                    return Ge - this.points.length >> 5;\n                  }\n                  _getOriginZoom(Ge) {\n                    return (Ge - this.points.length) % 32;\n                  }\n                  _map(Ge, Je, je) {\n                    if (Ge[Je + te] > 1) {\n                      let Ie = this.clusterProps[Ge[Je + oe]];\n                      return je ? Object.assign({}, Ie) : Ie;\n                    }\n                    let tt = this.points[Ge[Je + H]].properties, xt = this.options.map(tt);\n                    return je && xt === tt ? Object.assign({}, xt) : xt;\n                  }\n                }\n                function Ee(dt, Ge, Je) {\n                  return { type: "Feature", id: dt[Ge + H], properties: Ce(dt, Ge, Je), geometry: { type: "Point", coordinates: [(je = dt[Ge], 360 * (je - 0.5)), Se(dt[Ge + 1])] } };\n                  var je;\n                }\n                function Ce(dt, Ge, Je) {\n                  let je = dt[Ge + te], tt = je >= 1e4 ? `${Math.round(je / 1e3)}k` : je >= 1e3 ? Math.round(je / 100) / 10 + "k" : je, xt = dt[Ge + oe], Ie = xt === -1 ? {} : Object.assign({}, Je[xt]);\n                  return Object.assign(Ie, { cluster: true, cluster_id: dt[Ge + H], point_count: je, point_count_abbreviated: tt });\n                }\n                function me(dt) {\n                  return dt / 360 + 0.5;\n                }\n                function ie(dt) {\n                  let Ge = Math.sin(dt * Math.PI / 180), Je = 0.5 - 0.25 * Math.log((1 + Ge) / (1 - Ge)) / Math.PI;\n                  return Je < 0 ? 0 : Je > 1 ? 1 : Je;\n                }\n                function Se(dt) {\n                  let Ge = (180 - 360 * dt) * Math.PI / 180;\n                  return 360 * Math.atan(Math.exp(Ge)) / Math.PI - 90;\n                }\n                function Le(dt, Ge, Je, je) {\n                  let tt = je, xt = Ge + (Je - Ge >> 1), Ie, xe = Je - Ge, ke = dt[Ge], vt = dt[Ge + 1], ir = dt[Je], ar = dt[Je + 1];\n                  for (let vr = Ge + 3; vr < Je; vr += 3) {\n                    let ii = Ae(dt[vr], dt[vr + 1], ke, vt, ir, ar);\n                    if (ii > tt) Ie = vr, tt = ii;\n                    else if (ii === tt) {\n                      let pi = Math.abs(vr - xt);\n                      pi < xe && (Ie = vr, xe = pi);\n                    }\n                  }\n                  tt > je && (Ie - Ge > 3 && Le(dt, Ge, Ie, je), dt[Ie + 2] = tt, Je - Ie > 3 && Le(dt, Ie, Je, je));\n                }\n                function Ae(dt, Ge, Je, je, tt, xt) {\n                  let Ie = tt - Je, xe = xt - je;\n                  if (Ie !== 0 || xe !== 0) {\n                    let ke = ((dt - Je) * Ie + (Ge - je) * xe) / (Ie * Ie + xe * xe);\n                    ke > 1 ? (Je = tt, je = xt) : ke > 0 && (Je += Ie * ke, je += xe * ke);\n                  }\n                  return Ie = dt - Je, xe = Ge - je, Ie * Ie + xe * xe;\n                }\n                function Fe(dt, Ge, Je, je) {\n                  let tt = { id: dt == null ? null : dt, type: Ge, geometry: Je, tags: je, minX: 1 / 0, minY: 1 / 0, maxX: -1 / 0, maxY: -1 / 0 };\n                  if (Ge === "Point" || Ge === "MultiPoint" || Ge === "LineString") Pe(tt, Je);\n                  else if (Ge === "Polygon") Pe(tt, Je[0]);\n                  else if (Ge === "MultiLineString") for (let xt of Je) Pe(tt, xt);\n                  else if (Ge === "MultiPolygon") for (let xt of Je) Pe(tt, xt[0]);\n                  return tt;\n                }\n                function Pe(dt, Ge) {\n                  for (let Je = 0; Je < Ge.length; Je += 3) dt.minX = Math.min(dt.minX, Ge[Je]), dt.minY = Math.min(dt.minY, Ge[Je + 1]), dt.maxX = Math.max(dt.maxX, Ge[Je]), dt.maxY = Math.max(dt.maxY, Ge[Je + 1]);\n                }\n                function ge(dt, Ge, Je, je) {\n                  if (!Ge.geometry) return;\n                  let tt = Ge.geometry.coordinates;\n                  if (tt && tt.length === 0) return;\n                  let xt = Ge.geometry.type, Ie = Math.pow(Je.tolerance / ((1 << Je.maxZoom) * Je.extent), 2), xe = [], ke = Ge.id;\n                  if (Je.promoteId ? ke = Ge.properties[Je.promoteId] : Je.generateId && (ke = je || 0), xt === "Point") Re(tt, xe);\n                  else if (xt === "MultiPoint") for (let vt of tt) Re(vt, xe);\n                  else if (xt === "LineString") ce(tt, xe, Ie, false);\n                  else if (xt === "MultiLineString") {\n                    if (Je.lineMetrics) {\n                      for (let vt of tt) xe = [], ce(vt, xe, Ie, false), dt.push(Fe(ke, "LineString", xe, Ge.properties));\n                      return;\n                    }\n                    Ze(tt, xe, Ie, false);\n                  } else if (xt === "Polygon") Ze(tt, xe, Ie, true);\n                  else {\n                    if (xt !== "MultiPolygon") {\n                      if (xt === "GeometryCollection") {\n                        for (let vt of Ge.geometry.geometries) ge(dt, { id: ke, geometry: vt, properties: Ge.properties }, Je, je);\n                        return;\n                      }\n                      throw new Error("Input data is not a valid GeoJSON object.");\n                    }\n                    for (let vt of tt) {\n                      let ir = [];\n                      Ze(vt, ir, Ie, true), xe.push(ir);\n                    }\n                  }\n                  dt.push(Fe(ke, xt, xe, Ge.properties));\n                }\n                function Re(dt, Ge) {\n                  Ge.push(ut(dt[0]), pt(dt[1]), 0);\n                }\n                function ce(dt, Ge, Je, je) {\n                  let tt, xt, Ie = 0;\n                  for (let ke = 0; ke < dt.length; ke++) {\n                    let vt = ut(dt[ke][0]), ir = pt(dt[ke][1]);\n                    Ge.push(vt, ir, 0), ke > 0 && (Ie += je ? (tt * ir - vt * xt) / 2 : Math.sqrt(Math.pow(vt - tt, 2) + Math.pow(ir - xt, 2))), tt = vt, xt = ir;\n                  }\n                  let xe = Ge.length - 3;\n                  Ge[2] = 1, Le(Ge, 0, xe, Je), Ge[xe + 2] = 1, Ge.size = Math.abs(Ie), Ge.start = 0, Ge.end = Ge.size;\n                }\n                function Ze(dt, Ge, Je, je) {\n                  for (let tt = 0; tt < dt.length; tt++) {\n                    let xt = [];\n                    ce(dt[tt], xt, Je, je), Ge.push(xt);\n                  }\n                }\n                function ut(dt) {\n                  return dt / 360 + 0.5;\n                }\n                function pt(dt) {\n                  let Ge = Math.sin(dt * Math.PI / 180), Je = 0.5 - 0.25 * Math.log((1 + Ge) / (1 - Ge)) / Math.PI;\n                  return Je < 0 ? 0 : Je > 1 ? 1 : Je;\n                }\n                function Zt(dt, Ge, Je, je, tt, xt, Ie, xe) {\n                  if (je /= Ge, xt >= (Je /= Ge) && Ie < je) return dt;\n                  if (Ie < Je || xt >= je) return null;\n                  let ke = [];\n                  for (let vt of dt) {\n                    let ir = vt.geometry, ar = vt.type, vr = tt === 0 ? vt.minX : vt.minY, ii = tt === 0 ? vt.maxX : vt.maxY;\n                    if (vr >= Je && ii < je) {\n                      ke.push(vt);\n                      continue;\n                    }\n                    if (ii < Je || vr >= je) continue;\n                    let pi = [];\n                    if (ar === "Point" || ar === "MultiPoint") st(ir, pi, Je, je, tt);\n                    else if (ar === "LineString") lt(ir, pi, Je, je, tt, false, xe.lineMetrics);\n                    else if (ar === "MultiLineString") Nt(ir, pi, Je, je, tt, false);\n                    else if (ar === "Polygon") Nt(ir, pi, Je, je, tt, true);\n                    else if (ar === "MultiPolygon") for (let $r of ir) {\n                      let di = [];\n                      Nt($r, di, Je, je, tt, true), di.length && pi.push(di);\n                    }\n                    if (pi.length) {\n                      if (xe.lineMetrics && ar === "LineString") {\n                        for (let $r of pi) ke.push(Fe(vt.id, ar, $r, vt.tags));\n                        continue;\n                      }\n                      ar !== "LineString" && ar !== "MultiLineString" || (pi.length === 1 ? (ar = "LineString", pi = pi[0]) : ar = "MultiLineString"), ar !== "Point" && ar !== "MultiPoint" || (ar = pi.length === 3 ? "Point" : "MultiPoint"), ke.push(Fe(vt.id, ar, pi, vt.tags));\n                    }\n                  }\n                  return ke.length ? ke : null;\n                }\n                function st(dt, Ge, Je, je, tt) {\n                  for (let xt = 0; xt < dt.length; xt += 3) {\n                    let Ie = dt[xt + tt];\n                    Ie >= Je && Ie <= je && Jt(Ge, dt[xt], dt[xt + 1], dt[xt + 2]);\n                  }\n                }\n                function lt(dt, Ge, Je, je, tt, xt, Ie) {\n                  let xe = Gt(dt), ke = tt === 0 ? sr : wr, vt, ir, ar = dt.start;\n                  for (let di = 0; di < dt.length - 3; di += 3) {\n                    let ji = dt[di], In = dt[di + 1], wi = dt[di + 2], On = dt[di + 3], qn = dt[di + 4], Fn = tt === 0 ? ji : In, ra = tt === 0 ? On : qn, la = false;\n                    Ie && (vt = Math.sqrt(Math.pow(ji - On, 2) + Math.pow(In - qn, 2))), Fn < Je ? ra > Je && (ir = ke(xe, ji, In, On, qn, Je), Ie && (xe.start = ar + vt * ir)) : Fn > je ? ra < je && (ir = ke(xe, ji, In, On, qn, je), Ie && (xe.start = ar + vt * ir)) : Jt(xe, ji, In, wi), ra < Je && Fn >= Je && (ir = ke(xe, ji, In, On, qn, Je), la = true), ra > je && Fn <= je && (ir = ke(xe, ji, In, On, qn, je), la = true), !xt && la && (Ie && (xe.end = ar + vt * ir), Ge.push(xe), xe = Gt(dt)), Ie && (ar += vt);\n                  }\n                  let vr = dt.length - 3, ii = dt[vr], pi = dt[vr + 1], $r = tt === 0 ? ii : pi;\n                  $r >= Je && $r <= je && Jt(xe, ii, pi, dt[vr + 2]), vr = xe.length - 3, xt && vr >= 3 && (xe[vr] !== xe[0] || xe[vr + 1] !== xe[1]) && Jt(xe, xe[0], xe[1], xe[2]), xe.length && Ge.push(xe);\n                }\n                function Gt(dt) {\n                  let Ge = [];\n                  return Ge.size = dt.size, Ge.start = dt.start, Ge.end = dt.end, Ge;\n                }\n                function Nt(dt, Ge, Je, je, tt, xt) {\n                  for (let Ie of dt) lt(Ie, Ge, Je, je, tt, xt, false);\n                }\n                function Jt(dt, Ge, Je, je) {\n                  dt.push(Ge, Je, je);\n                }\n                function sr(dt, Ge, Je, je, tt, xt) {\n                  let Ie = (xt - Ge) / (je - Ge);\n                  return Jt(dt, xt, Je + (tt - Je) * Ie, 1), Ie;\n                }\n                function wr(dt, Ge, Je, je, tt, xt) {\n                  let Ie = (xt - Je) / (tt - Je);\n                  return Jt(dt, Ge + (je - Ge) * Ie, xt, 1), Ie;\n                }\n                function cr(dt, Ge) {\n                  let Je = [];\n                  for (let je = 0; je < dt.length; je++) {\n                    let tt = dt[je], xt = tt.type, Ie;\n                    if (xt === "Point" || xt === "MultiPoint" || xt === "LineString") Ie = $e(tt.geometry, Ge);\n                    else if (xt === "MultiLineString" || xt === "Polygon") {\n                      Ie = [];\n                      for (let xe of tt.geometry) Ie.push($e(xe, Ge));\n                    } else if (xt === "MultiPolygon") {\n                      Ie = [];\n                      for (let xe of tt.geometry) {\n                        let ke = [];\n                        for (let vt of xe) ke.push($e(vt, Ge));\n                        Ie.push(ke);\n                      }\n                    }\n                    Je.push(Fe(tt.id, xt, Ie, tt.tags));\n                  }\n                  return Je;\n                }\n                function $e(dt, Ge) {\n                  let Je = [];\n                  Je.size = dt.size, dt.start !== void 0 && (Je.start = dt.start, Je.end = dt.end);\n                  for (let je = 0; je < dt.length; je += 3) Je.push(dt[je] + Ge, dt[je + 1], dt[je + 2]);\n                  return Je;\n                }\n                function St(dt, Ge) {\n                  if (dt.transformed) return dt;\n                  let Je = 1 << dt.z, je = dt.x, tt = dt.y;\n                  for (let xt of dt.features) {\n                    let Ie = xt.geometry, xe = xt.type;\n                    if (xt.geometry = [], xe === 1) for (let ke = 0; ke < Ie.length; ke += 2) xt.geometry.push(Qt(Ie[ke], Ie[ke + 1], Ge, Je, je, tt));\n                    else for (let ke = 0; ke < Ie.length; ke++) {\n                      let vt = [];\n                      for (let ir = 0; ir < Ie[ke].length; ir += 2) vt.push(Qt(Ie[ke][ir], Ie[ke][ir + 1], Ge, Je, je, tt));\n                      xt.geometry.push(vt);\n                    }\n                  }\n                  return dt.transformed = true, dt;\n                }\n                function Qt(dt, Ge, Je, je, tt, xt) {\n                  return [Math.round(Je * (dt * je - tt)), Math.round(Je * (Ge * je - xt))];\n                }\n                function Vt(dt, Ge, Je, je, tt) {\n                  let xt = Ge === tt.maxZoom ? 0 : tt.tolerance / ((1 << Ge) * tt.extent), Ie = { features: [], numPoints: 0, numSimplified: 0, numFeatures: dt.length, source: null, x: Je, y: je, z: Ge, transformed: false, minX: 2, minY: 1, maxX: -1, maxY: 0 };\n                  for (let xe of dt) _t(Ie, xe, xt, tt);\n                  return Ie;\n                }\n                function _t(dt, Ge, Je, je) {\n                  let tt = Ge.geometry, xt = Ge.type, Ie = [];\n                  if (dt.minX = Math.min(dt.minX, Ge.minX), dt.minY = Math.min(dt.minY, Ge.minY), dt.maxX = Math.max(dt.maxX, Ge.maxX), dt.maxY = Math.max(dt.maxY, Ge.maxY), xt === "Point" || xt === "MultiPoint") for (let xe = 0; xe < tt.length; xe += 3) Ie.push(tt[xe], tt[xe + 1]), dt.numPoints++, dt.numSimplified++;\n                  else if (xt === "LineString") It(Ie, tt, dt, Je, false, false);\n                  else if (xt === "MultiLineString" || xt === "Polygon") for (let xe = 0; xe < tt.length; xe++) It(Ie, tt[xe], dt, Je, xt === "Polygon", xe === 0);\n                  else if (xt === "MultiPolygon") for (let xe = 0; xe < tt.length; xe++) {\n                    let ke = tt[xe];\n                    for (let vt = 0; vt < ke.length; vt++) It(Ie, ke[vt], dt, Je, true, vt === 0);\n                  }\n                  if (Ie.length) {\n                    let xe = Ge.tags || null;\n                    if (xt === "LineString" && je.lineMetrics) {\n                      xe = {};\n                      for (let vt in Ge.tags) xe[vt] = Ge.tags[vt];\n                      xe.mapbox_clip_start = tt.start / tt.size, xe.mapbox_clip_end = tt.end / tt.size;\n                    }\n                    let ke = { geometry: Ie, type: xt === "Polygon" || xt === "MultiPolygon" ? 3 : xt === "LineString" || xt === "MultiLineString" ? 2 : 1, tags: xe };\n                    Ge.id !== null && (ke.id = Ge.id), dt.features.push(ke);\n                  }\n                }\n                function It(dt, Ge, Je, je, tt, xt) {\n                  let Ie = je * je;\n                  if (je > 0 && Ge.size < (tt ? Ie : je)) return void (Je.numPoints += Ge.length / 3);\n                  let xe = [];\n                  for (let ke = 0; ke < Ge.length; ke += 3) (je === 0 || Ge[ke + 2] > Ie) && (Je.numSimplified++, xe.push(Ge[ke], Ge[ke + 1])), Je.numPoints++;\n                  tt && (function(ke, vt) {\n                    let ir = 0;\n                    for (let ar = 0, vr = ke.length, ii = vr - 2; ar < vr; ii = ar, ar += 2) ir += (ke[ar] - ke[ii]) * (ke[ar + 1] + ke[ii + 1]);\n                    if (ir > 0 === vt) for (let ar = 0, vr = ke.length; ar < vr / 2; ar += 2) {\n                      let ii = ke[ar], pi = ke[ar + 1];\n                      ke[ar] = ke[vr - 2 - ar], ke[ar + 1] = ke[vr - 1 - ar], ke[vr - 2 - ar] = ii, ke[vr - 1 - ar] = pi;\n                    }\n                  })(xe, xt), dt.push(xe);\n                }\n                let mt = { maxZoom: 14, indexMaxZoom: 5, indexMaxPoints: 1e5, tolerance: 3, extent: 4096, buffer: 64, lineMetrics: false, promoteId: null, generateId: false, debug: 0 };\n                class er {\n                  constructor(Ge, Je) {\n                    let je = (Je = this.options = (function(xt, Ie) {\n                      for (let xe in Ie) xt[xe] = Ie[xe];\n                      return xt;\n                    })(Object.create(mt), Je)).debug;\n                    if (je && console.time("preprocess data"), Je.maxZoom < 0 || Je.maxZoom > 24) throw new Error("maxZoom should be in the 0-24 range");\n                    if (Je.promoteId && Je.generateId) throw new Error("promoteId and generateId cannot be used together.");\n                    let tt = (function(xt, Ie) {\n                      let xe = [];\n                      if (xt.type === "FeatureCollection") for (let ke = 0; ke < xt.features.length; ke++) ge(xe, xt.features[ke], Ie, ke);\n                      else ge(xe, xt.type === "Feature" ? xt : { geometry: xt }, Ie);\n                      return xe;\n                    })(Ge, Je);\n                    this.tiles = {}, this.tileCoords = [], je && (console.timeEnd("preprocess data"), console.log("index: maxZoom: %d, maxPoints: %d", Je.indexMaxZoom, Je.indexMaxPoints), console.time("generate tiles"), this.stats = {}, this.total = 0), tt = (function(xt, Ie) {\n                      let xe = Ie.buffer / Ie.extent, ke = xt, vt = Zt(xt, 1, -1 - xe, xe, 0, -1, 2, Ie), ir = Zt(xt, 1, 1 - xe, 2 + xe, 0, -1, 2, Ie);\n                      return (vt || ir) && (ke = Zt(xt, 1, -xe, 1 + xe, 0, -1, 2, Ie) || [], vt && (ke = cr(vt, 1).concat(ke)), ir && (ke = ke.concat(cr(ir, -1)))), ke;\n                    })(tt, Je), tt.length && this.splitTile(tt, 0, 0, 0), je && (tt.length && console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints), console.timeEnd("generate tiles"), console.log("tiles generated:", this.total, JSON.stringify(this.stats)));\n                  }\n                  splitTile(Ge, Je, je, tt, xt, Ie, xe) {\n                    let ke = [Ge, Je, je, tt], vt = this.options, ir = vt.debug;\n                    for (; ke.length; ) {\n                      tt = ke.pop(), je = ke.pop(), Je = ke.pop(), Ge = ke.pop();\n                      let ar = 1 << Je, vr = lr(Je, je, tt), ii = this.tiles[vr];\n                      if (!ii && (ir > 1 && console.time("creation"), ii = this.tiles[vr] = Vt(Ge, Je, je, tt, vt), this.tileCoords.push({ z: Je, x: je, y: tt }), ir)) {\n                        ir > 1 && (console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", Je, je, tt, ii.numFeatures, ii.numPoints, ii.numSimplified), console.timeEnd("creation"));\n                        let la = `z${Je}`;\n                        this.stats[la] = (this.stats[la] || 0) + 1, this.total++;\n                      }\n                      if (ii.source = Ge, xt == null) {\n                        if (Je === vt.indexMaxZoom || ii.numPoints <= vt.indexMaxPoints) continue;\n                      } else {\n                        if (Je === vt.maxZoom || Je === xt) continue;\n                        if (xt != null) {\n                          let la = xt - Je;\n                          if (je !== Ie >> la || tt !== xe >> la) continue;\n                        }\n                      }\n                      if (ii.source = null, Ge.length === 0) continue;\n                      ir > 1 && console.time("clipping");\n                      let pi = 0.5 * vt.buffer / vt.extent, $r = 0.5 - pi, di = 0.5 + pi, ji = 1 + pi, In = null, wi = null, On = null, qn = null, Fn = Zt(Ge, ar, je - pi, je + di, 0, ii.minX, ii.maxX, vt), ra = Zt(Ge, ar, je + $r, je + ji, 0, ii.minX, ii.maxX, vt);\n                      Ge = null, Fn && (In = Zt(Fn, ar, tt - pi, tt + di, 1, ii.minY, ii.maxY, vt), wi = Zt(Fn, ar, tt + $r, tt + ji, 1, ii.minY, ii.maxY, vt), Fn = null), ra && (On = Zt(ra, ar, tt - pi, tt + di, 1, ii.minY, ii.maxY, vt), qn = Zt(ra, ar, tt + $r, tt + ji, 1, ii.minY, ii.maxY, vt), ra = null), ir > 1 && console.timeEnd("clipping"), ke.push(In || [], Je + 1, 2 * je, 2 * tt), ke.push(wi || [], Je + 1, 2 * je, 2 * tt + 1), ke.push(On || [], Je + 1, 2 * je + 1, 2 * tt), ke.push(qn || [], Je + 1, 2 * je + 1, 2 * tt + 1);\n                    }\n                  }\n                  getTile(Ge, Je, je) {\n                    Ge = +Ge, Je = +Je, je = +je;\n                    let tt = this.options, { extent: xt, debug: Ie } = tt;\n                    if (Ge < 0 || Ge > 24) return null;\n                    let xe = 1 << Ge, ke = lr(Ge, Je = Je + xe & xe - 1, je);\n                    if (this.tiles[ke]) return St(this.tiles[ke], xt);\n                    Ie > 1 && console.log("drilling down to z%d-%d-%d", Ge, Je, je);\n                    let vt, ir = Ge, ar = Je, vr = je;\n                    for (; !vt && ir > 0; ) ir--, ar >>= 1, vr >>= 1, vt = this.tiles[lr(ir, ar, vr)];\n                    return vt && vt.source ? (Ie > 1 && (console.log("found parent tile z%d-%d-%d", ir, ar, vr), console.time("drilling down")), this.splitTile(vt.source, ir, ar, vr, Ge, Je, je), Ie > 1 && console.timeEnd("drilling down"), this.tiles[ke] ? St(this.tiles[ke], xt) : null) : null;\n                  }\n                }\n                function lr(dt, Ge, Je) {\n                  return 32 * ((1 << dt) * Je + Ge) + dt;\n                }\n                function Tr(dt, Ge) {\n                  return Ge ? dt.properties[Ge] : dt.id;\n                }\n                function Lr(dt, Ge) {\n                  if (dt == null) return true;\n                  if (dt.type === "Feature") return Tr(dt, Ge) != null;\n                  if (dt.type === "FeatureCollection") {\n                    let Je = /* @__PURE__ */ new Set();\n                    for (let je of dt.features) {\n                      let tt = Tr(je, Ge);\n                      if (tt == null || Je.has(tt)) return false;\n                      Je.add(tt);\n                    }\n                    return true;\n                  }\n                  return false;\n                }\n                function ti(dt, Ge) {\n                  let Je = /* @__PURE__ */ new Map();\n                  if (dt != null) if (dt.type === "Feature") Je.set(Tr(dt, Ge), dt);\n                  else for (let je of dt.features) Je.set(Tr(je, Ge), je);\n                  return Je;\n                }\n                class Br extends u4 {\n                  constructor() {\n                    super(...arguments), this._dataUpdateable = /* @__PURE__ */ new Map();\n                  }\n                  loadVectorTile(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let je = Ge.tileID.canonical;\n                      if (!this._geoJSONIndex) throw new Error("Unable to parse the data into a cluster or geojson");\n                      let tt = this._geoJSONIndex.getTile(je.z, je.x, je.y);\n                      if (!tt) return null;\n                      let xt = new class {\n                        constructor(xe) {\n                          this.layers = { _geojsonTileLayer: this }, this.name = "_geojsonTileLayer", this.extent = i3.X, this.length = xe.length, this._features = xe;\n                        }\n                        feature(xe) {\n                          return new class {\n                            constructor(ke) {\n                              this._feature = ke, this.extent = i3.X, this.type = ke.type, this.properties = ke.tags, "id" in ke && !isNaN(ke.id) && (this.id = parseInt(ke.id, 10));\n                            }\n                            loadGeometry() {\n                              if (this._feature.type === 1) {\n                                let ke = [];\n                                for (let vt of this._feature.geometry) ke.push([new i3.P(vt[0], vt[1])]);\n                                return ke;\n                              }\n                              {\n                                let ke = [];\n                                for (let vt of this._feature.geometry) {\n                                  let ir = [];\n                                  for (let ar of vt) ir.push(new i3.P(ar[0], ar[1]));\n                                  ke.push(ir);\n                                }\n                                return ke;\n                              }\n                            }\n                            toGeoJSON(ke, vt, ir) {\n                              return v3.call(this, ke, vt, ir);\n                            }\n                          }(this._features[xe]);\n                        }\n                      }(tt.features), Ie = G2(xt);\n                      return Ie.byteOffset === 0 && Ie.byteLength === Ie.buffer.byteLength || (Ie = new Uint8Array(Ie)), { vectorTile: xt, rawData: Ie.buffer };\n                    });\n                  }\n                  loadData(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      var Je;\n                      (Je = this._pendingRequest) === null || Je === void 0 || Je.abort();\n                      let je = !!(Ge && Ge.request && Ge.request.collectResourceTiming) && new i3.bv(Ge.request);\n                      this._pendingRequest = new AbortController();\n                      try {\n                        this._pendingData = this.loadAndProcessGeoJSON(Ge, this._pendingRequest), this._geoJSONIndex = Ge.cluster ? new _e((function({ superclusterOptions: Ie, clusterProperties: xe }) {\n                          if (!xe || !Ie) return Ie;\n                          let ke = {}, vt = {}, ir = { accumulated: null, zoom: 0 }, ar = { properties: null }, vr = Object.keys(xe);\n                          for (let ii of vr) {\n                            let [pi, $r] = xe[ii], di = i3.bC($r), ji = i3.bC(typeof pi == "string" ? [pi, ["accumulated"], ["get", ii]] : pi);\n                            ke[ii] = di.value, vt[ii] = ji.value;\n                          }\n                          return Ie.map = (ii) => {\n                            ar.properties = ii;\n                            let pi = {};\n                            for (let $r of vr) pi[$r] = ke[$r].evaluate(ir, ar);\n                            return pi;\n                          }, Ie.reduce = (ii, pi) => {\n                            ar.properties = pi;\n                            for (let $r of vr) ir.accumulated = ii[$r], ii[$r] = vt[$r].evaluate(ir, ar);\n                          }, Ie;\n                        })(Ge)).load((yield this._pendingData).features) : (tt = yield this._pendingData, new er(tt, Ge.geojsonVtOptions)), this.loaded = {};\n                        let xt = {};\n                        if (je) {\n                          let Ie = je.finish();\n                          Ie && (xt.resourceTiming = {}, xt.resourceTiming[Ge.source] = JSON.parse(JSON.stringify(Ie)));\n                        }\n                        return xt;\n                      } catch (xt) {\n                        if (delete this._pendingRequest, i3.bB(xt)) return { abandoned: true };\n                        throw xt;\n                      }\n                      var tt;\n                    });\n                  }\n                  getData() {\n                    return i3._(this, void 0, void 0, function* () {\n                      return this._pendingData;\n                    });\n                  }\n                  reloadTile(Ge) {\n                    let Je = this.loaded;\n                    return Je && Je[Ge.uid] ? super.reloadTile(Ge) : this.loadTile(Ge);\n                  }\n                  loadAndProcessGeoJSON(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let je = yield this.loadGeoJSON(Ge, Je);\n                      if (delete this._pendingRequest, typeof je != "object") throw new Error(`Input data given to \'${Ge.source}\' is not a valid GeoJSON object.`);\n                      if (d3(je, true), Ge.filter) {\n                        let tt = i3.bC(Ge.filter, { type: "boolean", "property-type": "data-driven", overridable: false, transition: false });\n                        if (tt.result === "error") throw new Error(tt.value.map((Ie) => `${Ie.key}: ${Ie.message}`).join(", "));\n                        je = { type: "FeatureCollection", features: je.features.filter((Ie) => tt.value.evaluate({ zoom: 0 }, Ie)) };\n                      }\n                      return je;\n                    });\n                  }\n                  loadGeoJSON(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      let { promoteId: je } = Ge;\n                      if (Ge.request) {\n                        let tt = yield i3.h(Ge.request, Je);\n                        return this._dataUpdateable = Lr(tt.data, je) ? ti(tt.data, je) : void 0, tt.data;\n                      }\n                      if (typeof Ge.data == "string") try {\n                        let tt = JSON.parse(Ge.data);\n                        return this._dataUpdateable = Lr(tt, je) ? ti(tt, je) : void 0, tt;\n                      } catch (tt) {\n                        throw new Error(`Input data given to \'${Ge.source}\' is not a valid GeoJSON object.`);\n                      }\n                      if (!Ge.dataDiff) throw new Error(`Input data given to \'${Ge.source}\' is not a valid GeoJSON object.`);\n                      if (!this._dataUpdateable) throw new Error(`Cannot update existing geojson data in ${Ge.source}`);\n                      return (function(tt, xt, Ie) {\n                        var xe, ke, vt, ir;\n                        if (xt.removeAll && tt.clear(), xt.remove) for (let ar of xt.remove) tt.delete(ar);\n                        if (xt.add) for (let ar of xt.add) {\n                          let vr = Tr(ar, Ie);\n                          vr != null && tt.set(vr, ar);\n                        }\n                        if (xt.update) for (let ar of xt.update) {\n                          let vr = tt.get(ar.id);\n                          if (vr == null) continue;\n                          let ii = !ar.removeAllProperties && (((xe = ar.removeProperties) === null || xe === void 0 ? void 0 : xe.length) > 0 || ((ke = ar.addOrUpdateProperties) === null || ke === void 0 ? void 0 : ke.length) > 0);\n                          if ((ar.newGeometry || ar.removeAllProperties || ii) && (vr = Object.assign({}, vr), tt.set(ar.id, vr), ii && (vr.properties = Object.assign({}, vr.properties))), ar.newGeometry && (vr.geometry = ar.newGeometry), ar.removeAllProperties) vr.properties = {};\n                          else if (((vt = ar.removeProperties) === null || vt === void 0 ? void 0 : vt.length) > 0) for (let pi of ar.removeProperties) Object.prototype.hasOwnProperty.call(vr.properties, pi) && delete vr.properties[pi];\n                          if (((ir = ar.addOrUpdateProperties) === null || ir === void 0 ? void 0 : ir.length) > 0) for (let { key: pi, value: $r } of ar.addOrUpdateProperties) vr.properties[pi] = $r;\n                        }\n                      })(this._dataUpdateable, Ge.dataDiff, je), { type: "FeatureCollection", features: Array.from(this._dataUpdateable.values()) };\n                    });\n                  }\n                  removeSource(Ge) {\n                    return i3._(this, void 0, void 0, function* () {\n                      this._pendingRequest && this._pendingRequest.abort();\n                    });\n                  }\n                  getClusterExpansionZoom(Ge) {\n                    return this._geoJSONIndex.getClusterExpansionZoom(Ge.clusterId);\n                  }\n                  getClusterChildren(Ge) {\n                    return this._geoJSONIndex.getChildren(Ge.clusterId);\n                  }\n                  getClusterLeaves(Ge) {\n                    return this._geoJSONIndex.getLeaves(Ge.clusterId, Ge.limit, Ge.offset);\n                  }\n                }\n                class Vr {\n                  constructor(Ge) {\n                    this.self = Ge, this.actor = new i3.F(Ge), this.layerIndexes = {}, this.availableImages = {}, this.workerSources = {}, this.demWorkerSources = {}, this.externalWorkerSourceTypes = {}, this.self.registerWorkerSource = (Je, je) => {\n                      if (this.externalWorkerSourceTypes[Je]) throw new Error(`Worker source with name "${Je}" already registered.`);\n                      this.externalWorkerSourceTypes[Je] = je;\n                    }, this.self.addProtocol = i3.bi, this.self.removeProtocol = i3.bj, this.self.registerRTLTextPlugin = (Je) => {\n                      if (i3.bD.isParsed()) throw new Error("RTL text plugin already registered.");\n                      i3.bD.setMethods(Je);\n                    }, this.actor.registerMessageHandler("LDT", (Je, je) => this._getDEMWorkerSource(Je, je.source).loadTile(je)), this.actor.registerMessageHandler("RDT", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      this._getDEMWorkerSource(Je, je.source).removeTile(je);\n                    })), this.actor.registerMessageHandler("GCEZ", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      return this._getWorkerSource(Je, je.type, je.source).getClusterExpansionZoom(je);\n                    })), this.actor.registerMessageHandler("GCC", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      return this._getWorkerSource(Je, je.type, je.source).getClusterChildren(je);\n                    })), this.actor.registerMessageHandler("GCL", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      return this._getWorkerSource(Je, je.type, je.source).getClusterLeaves(je);\n                    })), this.actor.registerMessageHandler("LD", (Je, je) => this._getWorkerSource(Je, je.type, je.source).loadData(je)), this.actor.registerMessageHandler("GD", (Je, je) => this._getWorkerSource(Je, je.type, je.source).getData()), this.actor.registerMessageHandler("LT", (Je, je) => this._getWorkerSource(Je, je.type, je.source).loadTile(je)), this.actor.registerMessageHandler("RT", (Je, je) => this._getWorkerSource(Je, je.type, je.source).reloadTile(je)), this.actor.registerMessageHandler("AT", (Je, je) => this._getWorkerSource(Je, je.type, je.source).abortTile(je)), this.actor.registerMessageHandler("RMT", (Je, je) => this._getWorkerSource(Je, je.type, je.source).removeTile(je)), this.actor.registerMessageHandler("RS", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      if (!this.workerSources[Je] || !this.workerSources[Je][je.type] || !this.workerSources[Je][je.type][je.source]) return;\n                      let tt = this.workerSources[Je][je.type][je.source];\n                      delete this.workerSources[Je][je.type][je.source], tt.removeSource !== void 0 && tt.removeSource(je);\n                    })), this.actor.registerMessageHandler("RM", (Je) => i3._(this, void 0, void 0, function* () {\n                      delete this.layerIndexes[Je], delete this.availableImages[Je], delete this.workerSources[Je], delete this.demWorkerSources[Je];\n                    })), this.actor.registerMessageHandler("SR", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      this.referrer = je;\n                    })), this.actor.registerMessageHandler("SRPS", (Je, je) => this._syncRTLPluginState(Je, je)), this.actor.registerMessageHandler("IS", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      this.self.importScripts(je);\n                    })), this.actor.registerMessageHandler("SI", (Je, je) => this._setImages(Je, je)), this.actor.registerMessageHandler("UL", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      this._getLayerIndex(Je).update(je.layers, je.removedIds);\n                    })), this.actor.registerMessageHandler("SL", (Je, je) => i3._(this, void 0, void 0, function* () {\n                      this._getLayerIndex(Je).replace(je);\n                    }));\n                  }\n                  _setImages(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      this.availableImages[Ge] = Je;\n                      for (let je in this.workerSources[Ge]) {\n                        let tt = this.workerSources[Ge][je];\n                        for (let xt in tt) tt[xt].availableImages = Je;\n                      }\n                    });\n                  }\n                  _syncRTLPluginState(Ge, Je) {\n                    return i3._(this, void 0, void 0, function* () {\n                      if (i3.bD.isParsed()) return i3.bD.getState();\n                      if (Je.pluginStatus !== "loading") return i3.bD.setState(Je), Je;\n                      let je = Je.pluginURL;\n                      if (this.self.importScripts(je), i3.bD.isParsed()) {\n                        let tt = { pluginStatus: "loaded", pluginURL: je };\n                        return i3.bD.setState(tt), tt;\n                      }\n                      throw i3.bD.setState({ pluginStatus: "error", pluginURL: "" }), new Error(`RTL Text Plugin failed to import scripts from ${je}`);\n                    });\n                  }\n                  _getAvailableImages(Ge) {\n                    let Je = this.availableImages[Ge];\n                    return Je || (Je = []), Je;\n                  }\n                  _getLayerIndex(Ge) {\n                    let Je = this.layerIndexes[Ge];\n                    return Je || (Je = this.layerIndexes[Ge] = new a4()), Je;\n                  }\n                  _getWorkerSource(Ge, Je, je) {\n                    if (this.workerSources[Ge] || (this.workerSources[Ge] = {}), this.workerSources[Ge][Je] || (this.workerSources[Ge][Je] = {}), !this.workerSources[Ge][Je][je]) {\n                      let tt = { sendAsync: (xt, Ie) => (xt.targetMapId = Ge, this.actor.sendAsync(xt, Ie)) };\n                      switch (Je) {\n                        case "vector":\n                          this.workerSources[Ge][Je][je] = new u4(tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));\n                          break;\n                        case "geojson":\n                          this.workerSources[Ge][Je][je] = new Br(tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));\n                          break;\n                        default:\n                          this.workerSources[Ge][Je][je] = new this.externalWorkerSourceTypes[Je](tt, this._getLayerIndex(Ge), this._getAvailableImages(Ge));\n                      }\n                    }\n                    return this.workerSources[Ge][Je][je];\n                  }\n                  _getDEMWorkerSource(Ge, Je) {\n                    return this.demWorkerSources[Ge] || (this.demWorkerSources[Ge] = {}), this.demWorkerSources[Ge][Je] || (this.demWorkerSources[Ge][Je] = new c5()), this.demWorkerSources[Ge][Je];\n                  }\n                }\n                return i3.i(self) && (self.worker = new Vr(self)), Vr;\n              }), r4("index", ["exports", "./shared"], function(i3, a4) {\n                "use strict";\n                var o4 = "4.7.1";\n                let s3, l3, u4 = { now: typeof performance != "undefined" && performance && performance.now ? performance.now.bind(performance) : Date.now.bind(Date), frameAsync: (ue) => new Promise((w4, B4) => {\n                  let Q = requestAnimationFrame(w4);\n                  ue.signal.addEventListener("abort", () => {\n                    cancelAnimationFrame(Q), B4(a4.c());\n                  });\n                }), getImageData(ue, w4 = 0) {\n                  return this.getImageCanvasContext(ue).getImageData(-w4, -w4, ue.width + 2 * w4, ue.height + 2 * w4);\n                }, getImageCanvasContext(ue) {\n                  let w4 = window.document.createElement("canvas"), B4 = w4.getContext("2d", { willReadFrequently: true });\n                  if (!B4) throw new Error("failed to create canvas 2d context");\n                  return w4.width = ue.width, w4.height = ue.height, B4.drawImage(ue, 0, 0, ue.width, ue.height), B4;\n                }, resolveURL: (ue) => (s3 || (s3 = document.createElement("a")), s3.href = ue, s3.href), hardwareConcurrency: typeof navigator != "undefined" && navigator.hardwareConcurrency || 4, get prefersReducedMotion() {\n                  return !!matchMedia && (l3 == null && (l3 = matchMedia("(prefers-reduced-motion: reduce)")), l3.matches);\n                } };\n                class c5 {\n                  static testProp(w4) {\n                    if (!c5.docStyle) return w4[0];\n                    for (let B4 = 0; B4 < w4.length; B4++) if (w4[B4] in c5.docStyle) return w4[B4];\n                    return w4[0];\n                  }\n                  static create(w4, B4, Q) {\n                    let ee = window.document.createElement(w4);\n                    return B4 !== void 0 && (ee.className = B4), Q && Q.appendChild(ee), ee;\n                  }\n                  static createNS(w4, B4) {\n                    return window.document.createElementNS(w4, B4);\n                  }\n                  static disableDrag() {\n                    c5.docStyle && c5.selectProp && (c5.userSelect = c5.docStyle[c5.selectProp], c5.docStyle[c5.selectProp] = "none");\n                  }\n                  static enableDrag() {\n                    c5.docStyle && c5.selectProp && (c5.docStyle[c5.selectProp] = c5.userSelect);\n                  }\n                  static setTransform(w4, B4) {\n                    w4.style[c5.transformProp] = B4;\n                  }\n                  static addEventListener(w4, B4, Q, ee = {}) {\n                    w4.addEventListener(B4, Q, "passive" in ee ? ee : ee.capture);\n                  }\n                  static removeEventListener(w4, B4, Q, ee = {}) {\n                    w4.removeEventListener(B4, Q, "passive" in ee ? ee : ee.capture);\n                  }\n                  static suppressClickInternal(w4) {\n                    w4.preventDefault(), w4.stopPropagation(), window.removeEventListener("click", c5.suppressClickInternal, true);\n                  }\n                  static suppressClick() {\n                    window.addEventListener("click", c5.suppressClickInternal, true), window.setTimeout(() => {\n                      window.removeEventListener("click", c5.suppressClickInternal, true);\n                    }, 0);\n                  }\n                  static getScale(w4) {\n                    let B4 = w4.getBoundingClientRect();\n                    return { x: B4.width / w4.offsetWidth || 1, y: B4.height / w4.offsetHeight || 1, boundingClientRect: B4 };\n                  }\n                  static getPoint(w4, B4, Q) {\n                    let ee = B4.boundingClientRect;\n                    return new a4.P((Q.clientX - ee.left) / B4.x - w4.clientLeft, (Q.clientY - ee.top) / B4.y - w4.clientTop);\n                  }\n                  static mousePos(w4, B4) {\n                    let Q = c5.getScale(w4);\n                    return c5.getPoint(w4, Q, B4);\n                  }\n                  static touchPos(w4, B4) {\n                    let Q = [], ee = c5.getScale(w4);\n                    for (let le = 0; le < B4.length; le++) Q.push(c5.getPoint(w4, ee, B4[le]));\n                    return Q;\n                  }\n                  static mouseButton(w4) {\n                    return w4.button;\n                  }\n                  static remove(w4) {\n                    w4.parentNode && w4.parentNode.removeChild(w4);\n                  }\n                }\n                c5.docStyle = typeof window != "undefined" && window.document && window.document.documentElement.style, c5.selectProp = c5.testProp(["userSelect", "MozUserSelect", "WebkitUserSelect", "msUserSelect"]), c5.transformProp = c5.testProp(["transform", "WebkitTransform"]);\n                let f4 = { supported: false, testSupport: function(ue) {\n                  !v3 && d3 && (_2 ? b(ue) : h3 = ue);\n                } }, h3, d3, v3 = false, _2 = false;\n                function b(ue) {\n                  let w4 = ue.createTexture();\n                  ue.bindTexture(ue.TEXTURE_2D, w4);\n                  try {\n                    if (ue.texImage2D(ue.TEXTURE_2D, 0, ue.RGBA, ue.RGBA, ue.UNSIGNED_BYTE, d3), ue.isContextLost()) return;\n                    f4.supported = true;\n                  } catch (B4) {\n                  }\n                  ue.deleteTexture(w4), v3 = true;\n                }\n                var p3;\n                typeof document != "undefined" && (d3 = document.createElement("img"), d3.onload = () => {\n                  h3 && b(h3), h3 = null, _2 = true;\n                }, d3.onerror = () => {\n                  v3 = true, h3 = null;\n                }, d3.src = "data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA="), (function(ue) {\n                  let w4, B4, Q, ee;\n                  ue.resetRequestQueue = () => {\n                    w4 = [], B4 = 0, Q = 0, ee = {};\n                  }, ue.addThrottleControl = (ot) => {\n                    let Tt = Q++;\n                    return ee[Tt] = ot, Tt;\n                  }, ue.removeThrottleControl = (ot) => {\n                    delete ee[ot], qe();\n                  }, ue.getImage = (ot, Tt, Yt = true) => new Promise((Kt, xr) => {\n                    f4.supported && (ot.headers || (ot.headers = {}), ot.headers.accept = "image/webp,*/*"), a4.e(ot, { type: "image" }), w4.push({ abortController: Tt, requestParameters: ot, supportImageRefresh: Yt, state: "queued", onError: (Ir) => {\n                      xr(Ir);\n                    }, onSuccess: (Ir) => {\n                      Kt(Ir);\n                    } }), qe();\n                  });\n                  let le = (ot) => a4._(this, void 0, void 0, function* () {\n                    ot.state = "running";\n                    let { requestParameters: Tt, supportImageRefresh: Yt, onError: Kt, onSuccess: xr, abortController: Ir } = ot, ve = Yt === false && !a4.i(self) && !a4.g(Tt.url) && (!Tt.headers || Object.keys(Tt.headers).reduce((Be, et) => Be && et === "accept", true));\n                    B4++;\n                    let be = ve ? Xe(Tt, Ir) : a4.m(Tt, Ir);\n                    try {\n                      let Be = yield be;\n                      delete ot.abortController, ot.state = "completed", Be.data instanceof HTMLImageElement || a4.b(Be.data) ? xr(Be) : Be.data && xr({ data: yield (De = Be.data, typeof createImageBitmap == "function" ? a4.d(De) : a4.f(De)), cacheControl: Be.cacheControl, expires: Be.expires });\n                    } catch (Be) {\n                      delete ot.abortController, Kt(Be);\n                    } finally {\n                      B4--, qe();\n                    }\n                    var De;\n                  }), qe = () => {\n                    let ot = (() => {\n                      for (let Tt of Object.keys(ee)) if (ee[Tt]()) return true;\n                      return false;\n                    })() ? a4.a.MAX_PARALLEL_IMAGE_REQUESTS_PER_FRAME : a4.a.MAX_PARALLEL_IMAGE_REQUESTS;\n                    for (let Tt = B4; Tt < ot && w4.length > 0; Tt++) {\n                      let Yt = w4.shift();\n                      Yt.abortController.signal.aborted ? Tt-- : le(Yt);\n                    }\n                  }, Xe = (ot, Tt) => new Promise((Yt, Kt) => {\n                    let xr = new Image(), Ir = ot.url, ve = ot.credentials;\n                    ve && ve === "include" ? xr.crossOrigin = "use-credentials" : (ve && ve === "same-origin" || !a4.s(Ir)) && (xr.crossOrigin = "anonymous"), Tt.signal.addEventListener("abort", () => {\n                      xr.src = "", Kt(a4.c());\n                    }), xr.fetchPriority = "high", xr.onload = () => {\n                      xr.onerror = xr.onload = null, Yt({ data: xr });\n                    }, xr.onerror = () => {\n                      xr.onerror = xr.onload = null, Tt.signal.aborted || Kt(new Error("Could not load image. Please make sure to use a supported image type such as PNG or JPEG. Note that SVGs are not supported."));\n                    }, xr.src = Ir;\n                  });\n                })(p3 || (p3 = {})), p3.resetRequestQueue();\n                class k4 {\n                  constructor(w4) {\n                    this._transformRequestFn = w4;\n                  }\n                  transformRequest(w4, B4) {\n                    return this._transformRequestFn && this._transformRequestFn(w4, B4) || { url: w4 };\n                  }\n                  setTransformRequest(w4) {\n                    this._transformRequestFn = w4;\n                  }\n                }\n                function E3(ue) {\n                  var w4 = new a4.A(3);\n                  return w4[0] = ue[0], w4[1] = ue[1], w4[2] = ue[2], w4;\n                }\n                var S2, L3 = function(ue, w4, B4) {\n                  return ue[0] = w4[0] - B4[0], ue[1] = w4[1] - B4[1], ue[2] = w4[2] - B4[2], ue;\n                };\n                S2 = new a4.A(3), a4.A != Float32Array && (S2[0] = 0, S2[1] = 0, S2[2] = 0);\n                var x2 = function(ue) {\n                  var w4 = ue[0], B4 = ue[1];\n                  return w4 * w4 + B4 * B4;\n                };\n                function C3(ue) {\n                  let w4 = [];\n                  if (typeof ue == "string") w4.push({ id: "default", url: ue });\n                  else if (ue && ue.length > 0) {\n                    let B4 = [];\n                    for (let { id: Q, url: ee } of ue) {\n                      let le = `${Q}${ee}`;\n                      B4.indexOf(le) === -1 && (B4.push(le), w4.push({ id: Q, url: ee }));\n                    }\n                  }\n                  return w4;\n                }\n                function M4(ue, w4, B4) {\n                  let Q = ue.split("?");\n                  return Q[0] += `${w4}${B4}`, Q.join("?");\n                }\n                (function() {\n                  var ue = new a4.A(2);\n                  a4.A != Float32Array && (ue[0] = 0, ue[1] = 0);\n                })();\n                class g3 {\n                  constructor(w4, B4, Q, ee) {\n                    this.context = w4, this.format = Q, this.texture = w4.gl.createTexture(), this.update(B4, ee);\n                  }\n                  update(w4, B4, Q) {\n                    let { width: ee, height: le } = w4, qe = !(this.size && this.size[0] === ee && this.size[1] === le || Q), { context: Xe } = this, { gl: ot } = Xe;\n                    if (this.useMipmap = !!(B4 && B4.useMipmap), ot.bindTexture(ot.TEXTURE_2D, this.texture), Xe.pixelStoreUnpackFlipY.set(false), Xe.pixelStoreUnpack.set(1), Xe.pixelStoreUnpackPremultiplyAlpha.set(this.format === ot.RGBA && (!B4 || B4.premultiply !== false)), qe) this.size = [ee, le], w4 instanceof HTMLImageElement || w4 instanceof HTMLCanvasElement || w4 instanceof HTMLVideoElement || w4 instanceof ImageData || a4.b(w4) ? ot.texImage2D(ot.TEXTURE_2D, 0, this.format, this.format, ot.UNSIGNED_BYTE, w4) : ot.texImage2D(ot.TEXTURE_2D, 0, this.format, ee, le, 0, this.format, ot.UNSIGNED_BYTE, w4.data);\n                    else {\n                      let { x: Tt, y: Yt } = Q || { x: 0, y: 0 };\n                      w4 instanceof HTMLImageElement || w4 instanceof HTMLCanvasElement || w4 instanceof HTMLVideoElement || w4 instanceof ImageData || a4.b(w4) ? ot.texSubImage2D(ot.TEXTURE_2D, 0, Tt, Yt, ot.RGBA, ot.UNSIGNED_BYTE, w4) : ot.texSubImage2D(ot.TEXTURE_2D, 0, Tt, Yt, ee, le, ot.RGBA, ot.UNSIGNED_BYTE, w4.data);\n                    }\n                    this.useMipmap && this.isSizePowerOfTwo() && ot.generateMipmap(ot.TEXTURE_2D);\n                  }\n                  bind(w4, B4, Q) {\n                    let { context: ee } = this, { gl: le } = ee;\n                    le.bindTexture(le.TEXTURE_2D, this.texture), Q !== le.LINEAR_MIPMAP_NEAREST || this.isSizePowerOfTwo() || (Q = le.LINEAR), w4 !== this.filter && (le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MAG_FILTER, w4), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MIN_FILTER, Q || w4), this.filter = w4), B4 !== this.wrap && (le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_S, B4), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_T, B4), this.wrap = B4);\n                  }\n                  isSizePowerOfTwo() {\n                    return this.size[0] === this.size[1] && Math.log(this.size[0]) / Math.LN2 % 1 == 0;\n                  }\n                  destroy() {\n                    let { gl: w4 } = this.context;\n                    w4.deleteTexture(this.texture), this.texture = null;\n                  }\n                }\n                function P3(ue) {\n                  let { userImage: w4 } = ue;\n                  return !!(w4 && w4.render && w4.render()) && (ue.data.replace(new Uint8Array(w4.data.buffer)), true);\n                }\n                class T3 extends a4.E {\n                  constructor() {\n                    super(), this.images = {}, this.updatedImages = {}, this.callbackDispatchedThisFrame = {}, this.loaded = false, this.requestors = [], this.patterns = {}, this.atlasImage = new a4.R({ width: 1, height: 1 }), this.dirty = true;\n                  }\n                  isLoaded() {\n                    return this.loaded;\n                  }\n                  setLoaded(w4) {\n                    if (this.loaded !== w4 && (this.loaded = w4, w4)) {\n                      for (let { ids: B4, promiseResolve: Q } of this.requestors) Q(this._getImagesForIds(B4));\n                      this.requestors = [];\n                    }\n                  }\n                  getImage(w4) {\n                    let B4 = this.images[w4];\n                    if (B4 && !B4.data && B4.spriteData) {\n                      let Q = B4.spriteData;\n                      B4.data = new a4.R({ width: Q.width, height: Q.height }, Q.context.getImageData(Q.x, Q.y, Q.width, Q.height).data), B4.spriteData = null;\n                    }\n                    return B4;\n                  }\n                  addImage(w4, B4) {\n                    if (this.images[w4]) throw new Error(`Image id ${w4} already exist, use updateImage instead`);\n                    this._validate(w4, B4) && (this.images[w4] = B4);\n                  }\n                  _validate(w4, B4) {\n                    let Q = true, ee = B4.data || B4.spriteData;\n                    return this._validateStretch(B4.stretchX, ee && ee.width) || (this.fire(new a4.j(new Error(`Image "${w4}" has invalid "stretchX" value`))), Q = false), this._validateStretch(B4.stretchY, ee && ee.height) || (this.fire(new a4.j(new Error(`Image "${w4}" has invalid "stretchY" value`))), Q = false), this._validateContent(B4.content, B4) || (this.fire(new a4.j(new Error(`Image "${w4}" has invalid "content" value`))), Q = false), Q;\n                  }\n                  _validateStretch(w4, B4) {\n                    if (!w4) return true;\n                    let Q = 0;\n                    for (let ee of w4) {\n                      if (ee[0] < Q || ee[1] < ee[0] || B4 < ee[1]) return false;\n                      Q = ee[1];\n                    }\n                    return true;\n                  }\n                  _validateContent(w4, B4) {\n                    if (!w4) return true;\n                    if (w4.length !== 4) return false;\n                    let Q = B4.spriteData, ee = Q && Q.width || B4.data.width, le = Q && Q.height || B4.data.height;\n                    return !(w4[0] < 0 || ee < w4[0] || w4[1] < 0 || le < w4[1] || w4[2] < 0 || ee < w4[2] || w4[3] < 0 || le < w4[3] || w4[2] < w4[0] || w4[3] < w4[1]);\n                  }\n                  updateImage(w4, B4, Q = true) {\n                    let ee = this.getImage(w4);\n                    if (Q && (ee.data.width !== B4.data.width || ee.data.height !== B4.data.height)) throw new Error(`size mismatch between old image (${ee.data.width}x${ee.data.height}) and new image (${B4.data.width}x${B4.data.height}).`);\n                    B4.version = ee.version + 1, this.images[w4] = B4, this.updatedImages[w4] = true;\n                  }\n                  removeImage(w4) {\n                    let B4 = this.images[w4];\n                    delete this.images[w4], delete this.patterns[w4], B4.userImage && B4.userImage.onRemove && B4.userImage.onRemove();\n                  }\n                  listImages() {\n                    return Object.keys(this.images);\n                  }\n                  getImages(w4) {\n                    return new Promise((B4, Q) => {\n                      let ee = true;\n                      if (!this.isLoaded()) for (let le of w4) this.images[le] || (ee = false);\n                      this.isLoaded() || ee ? B4(this._getImagesForIds(w4)) : this.requestors.push({ ids: w4, promiseResolve: B4 });\n                    });\n                  }\n                  _getImagesForIds(w4) {\n                    let B4 = {};\n                    for (let Q of w4) {\n                      let ee = this.getImage(Q);\n                      ee || (this.fire(new a4.k("styleimagemissing", { id: Q })), ee = this.getImage(Q)), ee ? B4[Q] = { data: ee.data.clone(), pixelRatio: ee.pixelRatio, sdf: ee.sdf, version: ee.version, stretchX: ee.stretchX, stretchY: ee.stretchY, content: ee.content, textFitWidth: ee.textFitWidth, textFitHeight: ee.textFitHeight, hasRenderCallback: !!(ee.userImage && ee.userImage.render) } : a4.w(`Image "${Q}" could not be loaded. Please make sure you have added the image with map.addImage() or a "sprite" property in your style. You can provide missing images by listening for the "styleimagemissing" map event.`);\n                    }\n                    return B4;\n                  }\n                  getPixelSize() {\n                    let { width: w4, height: B4 } = this.atlasImage;\n                    return { width: w4, height: B4 };\n                  }\n                  getPattern(w4) {\n                    let B4 = this.patterns[w4], Q = this.getImage(w4);\n                    if (!Q) return null;\n                    if (B4 && B4.position.version === Q.version) return B4.position;\n                    if (B4) B4.position.version = Q.version;\n                    else {\n                      let ee = { w: Q.data.width + 2, h: Q.data.height + 2, x: 0, y: 0 }, le = new a4.I(ee, Q);\n                      this.patterns[w4] = { bin: ee, position: le };\n                    }\n                    return this._updatePatternAtlas(), this.patterns[w4].position;\n                  }\n                  bind(w4) {\n                    let B4 = w4.gl;\n                    this.atlasTexture ? this.dirty && (this.atlasTexture.update(this.atlasImage), this.dirty = false) : this.atlasTexture = new g3(w4, this.atlasImage, B4.RGBA), this.atlasTexture.bind(B4.LINEAR, B4.CLAMP_TO_EDGE);\n                  }\n                  _updatePatternAtlas() {\n                    let w4 = [];\n                    for (let le in this.patterns) w4.push(this.patterns[le].bin);\n                    let { w: B4, h: Q } = a4.p(w4), ee = this.atlasImage;\n                    ee.resize({ width: B4 || 1, height: Q || 1 });\n                    for (let le in this.patterns) {\n                      let { bin: qe } = this.patterns[le], Xe = qe.x + 1, ot = qe.y + 1, Tt = this.getImage(le).data, Yt = Tt.width, Kt = Tt.height;\n                      a4.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Xe, y: ot }, { width: Yt, height: Kt }), a4.R.copy(Tt, ee, { x: 0, y: Kt - 1 }, { x: Xe, y: ot - 1 }, { width: Yt, height: 1 }), a4.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Xe, y: ot + Kt }, { width: Yt, height: 1 }), a4.R.copy(Tt, ee, { x: Yt - 1, y: 0 }, { x: Xe - 1, y: ot }, { width: 1, height: Kt }), a4.R.copy(Tt, ee, { x: 0, y: 0 }, { x: Xe + Yt, y: ot }, { width: 1, height: Kt });\n                    }\n                    this.dirty = true;\n                  }\n                  beginFrame() {\n                    this.callbackDispatchedThisFrame = {};\n                  }\n                  dispatchRenderCallbacks(w4) {\n                    for (let B4 of w4) {\n                      if (this.callbackDispatchedThisFrame[B4]) continue;\n                      this.callbackDispatchedThisFrame[B4] = true;\n                      let Q = this.getImage(B4);\n                      Q || a4.w(`Image with ID: "${B4}" was not found`), P3(Q) && this.updateImage(B4, Q);\n                    }\n                  }\n                }\n                let z3 = 1e20;\n                function O3(ue, w4, B4, Q, ee, le, qe, Xe, ot) {\n                  for (let Tt = w4; Tt < w4 + Q; Tt++) V2(ue, B4 * le + Tt, le, ee, qe, Xe, ot);\n                  for (let Tt = B4; Tt < B4 + ee; Tt++) V2(ue, Tt * le + w4, 1, Q, qe, Xe, ot);\n                }\n                function V2(ue, w4, B4, Q, ee, le, qe) {\n                  le[0] = 0, qe[0] = -z3, qe[1] = z3, ee[0] = ue[w4];\n                  for (let Xe = 1, ot = 0, Tt = 0; Xe < Q; Xe++) {\n                    ee[Xe] = ue[w4 + Xe * B4];\n                    let Yt = Xe * Xe;\n                    do {\n                      let Kt = le[ot];\n                      Tt = (ee[Xe] - ee[Kt] + Yt - Kt * Kt) / (Xe - Kt) / 2;\n                    } while (Tt <= qe[ot] && --ot > -1);\n                    ot++, le[ot] = Xe, qe[ot] = Tt, qe[ot + 1] = z3;\n                  }\n                  for (let Xe = 0, ot = 0; Xe < Q; Xe++) {\n                    for (; qe[ot + 1] < Xe; ) ot++;\n                    let Tt = le[ot], Yt = Xe - Tt;\n                    ue[w4 + Xe * B4] = ee[Tt] + Yt * Yt;\n                  }\n                }\n                class G2 {\n                  constructor(w4, B4) {\n                    this.requestManager = w4, this.localIdeographFontFamily = B4, this.entries = {};\n                  }\n                  setURL(w4) {\n                    this.url = w4;\n                  }\n                  getGlyphs(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = [];\n                      for (let le in w4) for (let qe of w4[le]) B4.push(this._getAndCacheGlyphsPromise(le, qe));\n                      let Q = yield Promise.all(B4), ee = {};\n                      for (let { stack: le, id: qe, glyph: Xe } of Q) ee[le] || (ee[le] = {}), ee[le][qe] = Xe && { id: Xe.id, bitmap: Xe.bitmap.clone(), metrics: Xe.metrics };\n                      return ee;\n                    });\n                  }\n                  _getAndCacheGlyphsPromise(w4, B4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let Q = this.entries[w4];\n                      Q || (Q = this.entries[w4] = { glyphs: {}, requests: {}, ranges: {} });\n                      let ee = Q.glyphs[B4];\n                      if (ee !== void 0) return { stack: w4, id: B4, glyph: ee };\n                      if (ee = this._tinySDF(Q, w4, B4), ee) return Q.glyphs[B4] = ee, { stack: w4, id: B4, glyph: ee };\n                      let le = Math.floor(B4 / 256);\n                      if (256 * le > 65535) throw new Error("glyphs > 65535 not supported");\n                      if (Q.ranges[le]) return { stack: w4, id: B4, glyph: ee };\n                      if (!this.url) throw new Error("glyphsUrl is not set");\n                      if (!Q.requests[le]) {\n                        let Xe = G2.loadGlyphRange(w4, le, this.url, this.requestManager);\n                        Q.requests[le] = Xe;\n                      }\n                      let qe = yield Q.requests[le];\n                      for (let Xe in qe) this._doesCharSupportLocalGlyph(+Xe) || (Q.glyphs[+Xe] = qe[+Xe]);\n                      return Q.ranges[le] = true, { stack: w4, id: B4, glyph: qe[B4] || null };\n                    });\n                  }\n                  _doesCharSupportLocalGlyph(w4) {\n                    return !!this.localIdeographFontFamily && new RegExp("\\\\p{Ideo}|\\\\p{sc=Hang}|\\\\p{sc=Hira}|\\\\p{sc=Kana}", "u").test(String.fromCodePoint(w4));\n                  }\n                  _tinySDF(w4, B4, Q) {\n                    let ee = this.localIdeographFontFamily;\n                    if (!ee || !this._doesCharSupportLocalGlyph(Q)) return;\n                    let le = w4.tinySDF;\n                    if (!le) {\n                      let Xe = "400";\n                      /bold/i.test(B4) ? Xe = "900" : /medium/i.test(B4) ? Xe = "500" : /light/i.test(B4) && (Xe = "200"), le = w4.tinySDF = new G2.TinySDF({ fontSize: 48, buffer: 6, radius: 16, cutoff: 0.25, fontFamily: ee, fontWeight: Xe });\n                    }\n                    let qe = le.draw(String.fromCharCode(Q));\n                    return { id: Q, bitmap: new a4.o({ width: qe.width || 60, height: qe.height || 60 }, qe.data), metrics: { width: qe.glyphWidth / 2 || 24, height: qe.glyphHeight / 2 || 24, left: qe.glyphLeft / 2 + 0.5 || 0, top: qe.glyphTop / 2 - 27.5 || -8, advance: qe.glyphAdvance / 2 || 24, isDoubleResolution: true } };\n                  }\n                }\n                G2.loadGlyphRange = function(ue, w4, B4, Q) {\n                  return a4._(this, void 0, void 0, function* () {\n                    let ee = 256 * w4, le = ee + 255, qe = Q.transformRequest(B4.replace("{fontstack}", ue).replace("{range}", `${ee}-${le}`), "Glyphs"), Xe = yield a4.l(qe, new AbortController());\n                    if (!Xe || !Xe.data) throw new Error(`Could not load glyph range. range: ${w4}, ${ee}-${le}`);\n                    let ot = {};\n                    for (let Tt of a4.n(Xe.data)) ot[Tt.id] = Tt;\n                    return ot;\n                  });\n                }, G2.TinySDF = class {\n                  constructor({ fontSize: ue = 24, buffer: w4 = 3, radius: B4 = 8, cutoff: Q = 0.25, fontFamily: ee = "sans-serif", fontWeight: le = "normal", fontStyle: qe = "normal" } = {}) {\n                    this.buffer = w4, this.cutoff = Q, this.radius = B4;\n                    let Xe = this.size = ue + 4 * w4, ot = this._createCanvas(Xe), Tt = this.ctx = ot.getContext("2d", { willReadFrequently: true });\n                    Tt.font = `${qe} ${le} ${ue}px ${ee}`, Tt.textBaseline = "alphabetic", Tt.textAlign = "left", Tt.fillStyle = "black", this.gridOuter = new Float64Array(Xe * Xe), this.gridInner = new Float64Array(Xe * Xe), this.f = new Float64Array(Xe), this.z = new Float64Array(Xe + 1), this.v = new Uint16Array(Xe);\n                  }\n                  _createCanvas(ue) {\n                    let w4 = document.createElement("canvas");\n                    return w4.width = w4.height = ue, w4;\n                  }\n                  draw(ue) {\n                    let { width: w4, actualBoundingBoxAscent: B4, actualBoundingBoxDescent: Q, actualBoundingBoxLeft: ee, actualBoundingBoxRight: le } = this.ctx.measureText(ue), qe = Math.ceil(B4), Xe = Math.max(0, Math.min(this.size - this.buffer, Math.ceil(le - ee))), ot = Math.min(this.size - this.buffer, qe + Math.ceil(Q)), Tt = Xe + 2 * this.buffer, Yt = ot + 2 * this.buffer, Kt = Math.max(Tt * Yt, 0), xr = new Uint8ClampedArray(Kt), Ir = { data: xr, width: Tt, height: Yt, glyphWidth: Xe, glyphHeight: ot, glyphTop: qe, glyphLeft: 0, glyphAdvance: w4 };\n                    if (Xe === 0 || ot === 0) return Ir;\n                    let { ctx: ve, buffer: be, gridInner: De, gridOuter: Be } = this;\n                    ve.clearRect(be, be, Xe, ot), ve.fillText(ue, be, be + qe);\n                    let et = ve.getImageData(be, be, Xe, ot);\n                    Be.fill(z3, 0, Kt), De.fill(0, 0, Kt);\n                    for (let We = 0; We < ot; We++) for (let it = 0; it < Xe; it++) {\n                      let Ft = et.data[4 * (We * Xe + it) + 3] / 255;\n                      if (Ft === 0) continue;\n                      let Ht = (We + be) * Tt + it + be;\n                      if (Ft === 1) Be[Ht] = 0, De[Ht] = z3;\n                      else {\n                        let tr = 0.5 - Ft;\n                        Be[Ht] = tr > 0 ? tr * tr : 0, De[Ht] = tr < 0 ? tr * tr : 0;\n                      }\n                    }\n                    O3(Be, 0, 0, Tt, Yt, Tt, this.f, this.v, this.z), O3(De, be, be, Xe, ot, Tt, this.f, this.v, this.z);\n                    for (let We = 0; We < Kt; We++) {\n                      let it = Math.sqrt(Be[We]) - Math.sqrt(De[We]);\n                      xr[We] = Math.round(255 - 255 * (it / this.radius + this.cutoff));\n                    }\n                    return Ir;\n                  }\n                };\n                class Z {\n                  constructor() {\n                    this.specification = a4.v.light.position;\n                  }\n                  possiblyEvaluate(w4, B4) {\n                    return a4.x(w4.expression.evaluate(B4));\n                  }\n                  interpolate(w4, B4, Q) {\n                    return { x: a4.y.number(w4.x, B4.x, Q), y: a4.y.number(w4.y, B4.y, Q), z: a4.y.number(w4.z, B4.z, Q) };\n                  }\n                }\n                let j3;\n                class N2 extends a4.E {\n                  constructor(w4) {\n                    super(), j3 = j3 || new a4.q({ anchor: new a4.D(a4.v.light.anchor), position: new Z(), color: new a4.D(a4.v.light.color), intensity: new a4.D(a4.v.light.intensity) }), this._transitionable = new a4.T(j3), this.setLight(w4), this._transitioning = this._transitionable.untransitioned();\n                  }\n                  getLight() {\n                    return this._transitionable.serialize();\n                  }\n                  setLight(w4, B4 = {}) {\n                    if (!this._validate(a4.r, w4, B4)) for (let Q in w4) {\n                      let ee = w4[Q];\n                      Q.endsWith("-transition") ? this._transitionable.setTransition(Q.slice(0, -11), ee) : this._transitionable.setValue(Q, ee);\n                    }\n                  }\n                  updateTransitions(w4) {\n                    this._transitioning = this._transitionable.transitioned(w4, this._transitioning);\n                  }\n                  hasTransition() {\n                    return this._transitioning.hasTransition();\n                  }\n                  recalculate(w4) {\n                    this.properties = this._transitioning.possiblyEvaluate(w4);\n                  }\n                  _validate(w4, B4, Q) {\n                    return (!Q || Q.validate !== false) && a4.t(this, w4.call(a4.u, { value: B4, style: { glyphs: true, sprite: true }, styleSpec: a4.v }));\n                  }\n                }\n                let H = new a4.q({ "sky-color": new a4.D(a4.v.sky["sky-color"]), "horizon-color": new a4.D(a4.v.sky["horizon-color"]), "fog-color": new a4.D(a4.v.sky["fog-color"]), "fog-ground-blend": new a4.D(a4.v.sky["fog-ground-blend"]), "horizon-fog-blend": new a4.D(a4.v.sky["horizon-fog-blend"]), "sky-horizon-blend": new a4.D(a4.v.sky["sky-horizon-blend"]), "atmosphere-blend": new a4.D(a4.v.sky["atmosphere-blend"]) });\n                class te extends a4.E {\n                  constructor(w4) {\n                    super(), this._transitionable = new a4.T(H), this.setSky(w4), this._transitioning = this._transitionable.untransitioned(), this.recalculate(new a4.z(0));\n                  }\n                  setSky(w4, B4 = {}) {\n                    if (!this._validate(a4.B, w4, B4)) {\n                      w4 || (w4 = { "sky-color": "transparent", "horizon-color": "transparent", "fog-color": "transparent", "fog-ground-blend": 1, "atmosphere-blend": 0 });\n                      for (let Q in w4) {\n                        let ee = w4[Q];\n                        Q.endsWith("-transition") ? this._transitionable.setTransition(Q.slice(0, -11), ee) : this._transitionable.setValue(Q, ee);\n                      }\n                    }\n                  }\n                  getSky() {\n                    return this._transitionable.serialize();\n                  }\n                  updateTransitions(w4) {\n                    this._transitioning = this._transitionable.transitioned(w4, this._transitioning);\n                  }\n                  hasTransition() {\n                    return this._transitioning.hasTransition();\n                  }\n                  recalculate(w4) {\n                    this.properties = this._transitioning.possiblyEvaluate(w4);\n                  }\n                  _validate(w4, B4, Q = {}) {\n                    return (Q == null ? void 0 : Q.validate) !== false && a4.t(this, w4.call(a4.u, a4.e({ value: B4, style: { glyphs: true, sprite: true }, styleSpec: a4.v })));\n                  }\n                  calculateFogBlendOpacity(w4) {\n                    return w4 < 60 ? 0 : w4 < 70 ? (w4 - 60) / 10 : 1;\n                  }\n                }\n                class oe {\n                  constructor(w4, B4) {\n                    this.width = w4, this.height = B4, this.nextRow = 0, this.data = new Uint8Array(this.width * this.height), this.dashEntry = {};\n                  }\n                  getDash(w4, B4) {\n                    let Q = w4.join(",") + String(B4);\n                    return this.dashEntry[Q] || (this.dashEntry[Q] = this.addDash(w4, B4)), this.dashEntry[Q];\n                  }\n                  getDashRanges(w4, B4, Q) {\n                    let ee = [], le = w4.length % 2 == 1 ? -w4[w4.length - 1] * Q : 0, qe = w4[0] * Q, Xe = true;\n                    ee.push({ left: le, right: qe, isDash: Xe, zeroLength: w4[0] === 0 });\n                    let ot = w4[0];\n                    for (let Tt = 1; Tt < w4.length; Tt++) {\n                      Xe = !Xe;\n                      let Yt = w4[Tt];\n                      le = ot * Q, ot += Yt, qe = ot * Q, ee.push({ left: le, right: qe, isDash: Xe, zeroLength: Yt === 0 });\n                    }\n                    return ee;\n                  }\n                  addRoundDash(w4, B4, Q) {\n                    let ee = B4 / 2;\n                    for (let le = -Q; le <= Q; le++) {\n                      let qe = this.width * (this.nextRow + Q + le), Xe = 0, ot = w4[Xe];\n                      for (let Tt = 0; Tt < this.width; Tt++) {\n                        Tt / ot.right > 1 && (ot = w4[++Xe]);\n                        let Yt = Math.abs(Tt - ot.left), Kt = Math.abs(Tt - ot.right), xr = Math.min(Yt, Kt), Ir, ve = le / Q * (ee + 1);\n                        if (ot.isDash) {\n                          let be = ee - Math.abs(ve);\n                          Ir = Math.sqrt(xr * xr + be * be);\n                        } else Ir = ee - Math.sqrt(xr * xr + ve * ve);\n                        this.data[qe + Tt] = Math.max(0, Math.min(255, Ir + 128));\n                      }\n                    }\n                  }\n                  addRegularDash(w4) {\n                    for (let Xe = w4.length - 1; Xe >= 0; --Xe) {\n                      let ot = w4[Xe], Tt = w4[Xe + 1];\n                      ot.zeroLength ? w4.splice(Xe, 1) : Tt && Tt.isDash === ot.isDash && (Tt.left = ot.left, w4.splice(Xe, 1));\n                    }\n                    let B4 = w4[0], Q = w4[w4.length - 1];\n                    B4.isDash === Q.isDash && (B4.left = Q.left - this.width, Q.right = B4.right + this.width);\n                    let ee = this.width * this.nextRow, le = 0, qe = w4[le];\n                    for (let Xe = 0; Xe < this.width; Xe++) {\n                      Xe / qe.right > 1 && (qe = w4[++le]);\n                      let ot = Math.abs(Xe - qe.left), Tt = Math.abs(Xe - qe.right), Yt = Math.min(ot, Tt);\n                      this.data[ee + Xe] = Math.max(0, Math.min(255, (qe.isDash ? Yt : -Yt) + 128));\n                    }\n                  }\n                  addDash(w4, B4) {\n                    let Q = B4 ? 7 : 0, ee = 2 * Q + 1;\n                    if (this.nextRow + ee > this.height) return a4.w("LineAtlas out of space"), null;\n                    let le = 0;\n                    for (let Xe = 0; Xe < w4.length; Xe++) le += w4[Xe];\n                    if (le !== 0) {\n                      let Xe = this.width / le, ot = this.getDashRanges(w4, this.width, Xe);\n                      B4 ? this.addRoundDash(ot, Xe, Q) : this.addRegularDash(ot);\n                    }\n                    let qe = { y: (this.nextRow + Q + 0.5) / this.height, height: 2 * Q / this.height, width: le };\n                    return this.nextRow += ee, this.dirty = true, qe;\n                  }\n                  bind(w4) {\n                    let B4 = w4.gl;\n                    this.texture ? (B4.bindTexture(B4.TEXTURE_2D, this.texture), this.dirty && (this.dirty = false, B4.texSubImage2D(B4.TEXTURE_2D, 0, 0, 0, this.width, this.height, B4.ALPHA, B4.UNSIGNED_BYTE, this.data))) : (this.texture = B4.createTexture(), B4.bindTexture(B4.TEXTURE_2D, this.texture), B4.texParameteri(B4.TEXTURE_2D, B4.TEXTURE_WRAP_S, B4.REPEAT), B4.texParameteri(B4.TEXTURE_2D, B4.TEXTURE_WRAP_T, B4.REPEAT), B4.texParameteri(B4.TEXTURE_2D, B4.TEXTURE_MIN_FILTER, B4.LINEAR), B4.texParameteri(B4.TEXTURE_2D, B4.TEXTURE_MAG_FILTER, B4.LINEAR), B4.texImage2D(B4.TEXTURE_2D, 0, B4.ALPHA, this.width, this.height, 0, B4.ALPHA, B4.UNSIGNED_BYTE, this.data));\n                  }\n                }\n                let _e = "maplibre_preloaded_worker_pool";\n                class Ee {\n                  constructor() {\n                    this.active = {};\n                  }\n                  acquire(w4) {\n                    if (!this.workers) for (this.workers = []; this.workers.length < Ee.workerCount; ) this.workers.push(new Worker(a4.a.WORKER_URL));\n                    return this.active[w4] = true, this.workers.slice();\n                  }\n                  release(w4) {\n                    delete this.active[w4], this.numActive() === 0 && (this.workers.forEach((B4) => {\n                      B4.terminate();\n                    }), this.workers = null);\n                  }\n                  isPreloaded() {\n                    return !!this.active[_e];\n                  }\n                  numActive() {\n                    return Object.keys(this.active).length;\n                  }\n                }\n                let Ce = Math.floor(u4.hardwareConcurrency / 2), me, ie;\n                function Se() {\n                  return me || (me = new Ee()), me;\n                }\n                Ee.workerCount = a4.C(globalThis) ? Math.max(Math.min(Ce, 3), 1) : 1;\n                class Le {\n                  constructor(w4, B4) {\n                    this.workerPool = w4, this.actors = [], this.currentActor = 0, this.id = B4;\n                    let Q = this.workerPool.acquire(B4);\n                    for (let ee = 0; ee < Q.length; ee++) {\n                      let le = new a4.F(Q[ee], B4);\n                      le.name = `Worker ${ee}`, this.actors.push(le);\n                    }\n                    if (!this.actors.length) throw new Error("No actors found");\n                  }\n                  broadcast(w4, B4) {\n                    let Q = [];\n                    for (let ee of this.actors) Q.push(ee.sendAsync({ type: w4, data: B4 }));\n                    return Promise.all(Q);\n                  }\n                  getActor() {\n                    return this.currentActor = (this.currentActor + 1) % this.actors.length, this.actors[this.currentActor];\n                  }\n                  remove(w4 = true) {\n                    this.actors.forEach((B4) => {\n                      B4.remove();\n                    }), this.actors = [], w4 && this.workerPool.release(this.id);\n                  }\n                  registerMessageHandler(w4, B4) {\n                    for (let Q of this.actors) Q.registerMessageHandler(w4, B4);\n                  }\n                }\n                function Ae() {\n                  return ie || (ie = new Le(Se(), a4.G), ie.registerMessageHandler("GR", (ue, w4, B4) => a4.m(w4, B4))), ie;\n                }\n                function Fe(ue, w4) {\n                  let B4 = a4.H();\n                  return a4.J(B4, B4, [1, 1, 0]), a4.K(B4, B4, [0.5 * ue.width, 0.5 * ue.height, 1]), a4.L(B4, B4, ue.calculatePosMatrix(w4.toUnwrapped()));\n                }\n                function Pe(ue, w4, B4, Q, ee, le) {\n                  let qe = (function(Kt, xr, Ir) {\n                    if (Kt) for (let ve of Kt) {\n                      let be = xr[ve];\n                      if (be && be.source === Ir && be.type === "fill-extrusion") return true;\n                    }\n                    else for (let ve in xr) {\n                      let be = xr[ve];\n                      if (be.source === Ir && be.type === "fill-extrusion") return true;\n                    }\n                    return false;\n                  })(ee && ee.layers, w4, ue.id), Xe = le.maxPitchScaleFactor(), ot = ue.tilesIn(Q, Xe, qe);\n                  ot.sort(ge);\n                  let Tt = [];\n                  for (let Kt of ot) Tt.push({ wrappedTileID: Kt.tileID.wrapped().key, queryResults: Kt.tile.queryRenderedFeatures(w4, B4, ue._state, Kt.queryGeometry, Kt.cameraQueryGeometry, Kt.scale, ee, le, Xe, Fe(ue.transform, Kt.tileID)) });\n                  let Yt = (function(Kt) {\n                    let xr = {}, Ir = {};\n                    for (let ve of Kt) {\n                      let be = ve.queryResults, De = ve.wrappedTileID, Be = Ir[De] = Ir[De] || {};\n                      for (let et in be) {\n                        let We = be[et], it = Be[et] = Be[et] || {}, Ft = xr[et] = xr[et] || [];\n                        for (let Ht of We) it[Ht.featureIndex] || (it[Ht.featureIndex] = true, Ft.push(Ht));\n                      }\n                    }\n                    return xr;\n                  })(Tt);\n                  for (let Kt in Yt) Yt[Kt].forEach((xr) => {\n                    let Ir = xr.feature, ve = ue.getFeatureState(Ir.layer["source-layer"], Ir.id);\n                    Ir.source = Ir.layer.source, Ir.layer["source-layer"] && (Ir.sourceLayer = Ir.layer["source-layer"]), Ir.state = ve;\n                  });\n                  return Yt;\n                }\n                function ge(ue, w4) {\n                  let B4 = ue.tileID, Q = w4.tileID;\n                  return B4.overscaledZ - Q.overscaledZ || B4.canonical.y - Q.canonical.y || B4.wrap - Q.wrap || B4.canonical.x - Q.canonical.x;\n                }\n                function Re(ue, w4, B4) {\n                  return a4._(this, void 0, void 0, function* () {\n                    let Q = ue;\n                    if (ue.url ? Q = (yield a4.h(w4.transformRequest(ue.url, "Source"), B4)).data : yield u4.frameAsync(B4), !Q) return null;\n                    let ee = a4.M(a4.e(Q, ue), ["tiles", "minzoom", "maxzoom", "attribution", "bounds", "scheme", "tileSize", "encoding"]);\n                    return "vector_layers" in Q && Q.vector_layers && (ee.vectorLayerIds = Q.vector_layers.map((le) => le.id)), ee;\n                  });\n                }\n                class ce {\n                  constructor(w4, B4) {\n                    w4 && (B4 ? this.setSouthWest(w4).setNorthEast(B4) : Array.isArray(w4) && (w4.length === 4 ? this.setSouthWest([w4[0], w4[1]]).setNorthEast([w4[2], w4[3]]) : this.setSouthWest(w4[0]).setNorthEast(w4[1])));\n                  }\n                  setNorthEast(w4) {\n                    return this._ne = w4 instanceof a4.N ? new a4.N(w4.lng, w4.lat) : a4.N.convert(w4), this;\n                  }\n                  setSouthWest(w4) {\n                    return this._sw = w4 instanceof a4.N ? new a4.N(w4.lng, w4.lat) : a4.N.convert(w4), this;\n                  }\n                  extend(w4) {\n                    let B4 = this._sw, Q = this._ne, ee, le;\n                    if (w4 instanceof a4.N) ee = w4, le = w4;\n                    else {\n                      if (!(w4 instanceof ce)) return Array.isArray(w4) ? w4.length === 4 || w4.every(Array.isArray) ? this.extend(ce.convert(w4)) : this.extend(a4.N.convert(w4)) : w4 && ("lng" in w4 || "lon" in w4) && "lat" in w4 ? this.extend(a4.N.convert(w4)) : this;\n                      if (ee = w4._sw, le = w4._ne, !ee || !le) return this;\n                    }\n                    return B4 || Q ? (B4.lng = Math.min(ee.lng, B4.lng), B4.lat = Math.min(ee.lat, B4.lat), Q.lng = Math.max(le.lng, Q.lng), Q.lat = Math.max(le.lat, Q.lat)) : (this._sw = new a4.N(ee.lng, ee.lat), this._ne = new a4.N(le.lng, le.lat)), this;\n                  }\n                  getCenter() {\n                    return new a4.N((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);\n                  }\n                  getSouthWest() {\n                    return this._sw;\n                  }\n                  getNorthEast() {\n                    return this._ne;\n                  }\n                  getNorthWest() {\n                    return new a4.N(this.getWest(), this.getNorth());\n                  }\n                  getSouthEast() {\n                    return new a4.N(this.getEast(), this.getSouth());\n                  }\n                  getWest() {\n                    return this._sw.lng;\n                  }\n                  getSouth() {\n                    return this._sw.lat;\n                  }\n                  getEast() {\n                    return this._ne.lng;\n                  }\n                  getNorth() {\n                    return this._ne.lat;\n                  }\n                  toArray() {\n                    return [this._sw.toArray(), this._ne.toArray()];\n                  }\n                  toString() {\n                    return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;\n                  }\n                  isEmpty() {\n                    return !(this._sw && this._ne);\n                  }\n                  contains(w4) {\n                    let { lng: B4, lat: Q } = a4.N.convert(w4), ee = this._sw.lng <= B4 && B4 <= this._ne.lng;\n                    return this._sw.lng > this._ne.lng && (ee = this._sw.lng >= B4 && B4 >= this._ne.lng), this._sw.lat <= Q && Q <= this._ne.lat && ee;\n                  }\n                  static convert(w4) {\n                    return w4 instanceof ce ? w4 : w4 && new ce(w4);\n                  }\n                  static fromLngLat(w4, B4 = 0) {\n                    let Q = 360 * B4 / 40075017, ee = Q / Math.cos(Math.PI / 180 * w4.lat);\n                    return new ce(new a4.N(w4.lng - ee, w4.lat - Q), new a4.N(w4.lng + ee, w4.lat + Q));\n                  }\n                  adjustAntiMeridian() {\n                    let w4 = new a4.N(this._sw.lng, this._sw.lat), B4 = new a4.N(this._ne.lng, this._ne.lat);\n                    return new ce(w4, w4.lng > B4.lng ? new a4.N(B4.lng + 360, B4.lat) : B4);\n                  }\n                }\n                class Ze {\n                  constructor(w4, B4, Q) {\n                    this.bounds = ce.convert(this.validateBounds(w4)), this.minzoom = B4 || 0, this.maxzoom = Q || 24;\n                  }\n                  validateBounds(w4) {\n                    return Array.isArray(w4) && w4.length === 4 ? [Math.max(-180, w4[0]), Math.max(-90, w4[1]), Math.min(180, w4[2]), Math.min(90, w4[3])] : [-180, -90, 180, 90];\n                  }\n                  contains(w4) {\n                    let B4 = Math.pow(2, w4.z), Q = Math.floor(a4.O(this.bounds.getWest()) * B4), ee = Math.floor(a4.Q(this.bounds.getNorth()) * B4), le = Math.ceil(a4.O(this.bounds.getEast()) * B4), qe = Math.ceil(a4.Q(this.bounds.getSouth()) * B4);\n                    return w4.x >= Q && w4.x < le && w4.y >= ee && w4.y < qe;\n                  }\n                }\n                class ut extends a4.E {\n                  constructor(w4, B4, Q, ee) {\n                    if (super(), this.id = w4, this.dispatcher = Q, this.type = "vector", this.minzoom = 0, this.maxzoom = 22, this.scheme = "xyz", this.tileSize = 512, this.reparseOverscaled = true, this.isTileClipped = true, this._loaded = false, a4.e(this, a4.M(B4, ["url", "scheme", "tileSize", "promoteId"])), this._options = a4.e({ type: "vector" }, B4), this._collectResourceTiming = B4.collectResourceTiming, this.tileSize !== 512) throw new Error("vector tile sources must have a tileSize of 512");\n                    this.setEventedParent(ee);\n                  }\n                  load() {\n                    return a4._(this, void 0, void 0, function* () {\n                      this._loaded = false, this.fire(new a4.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();\n                      try {\n                        let w4 = yield Re(this._options, this.map._requestManager, this._tileJSONRequest);\n                        this._tileJSONRequest = null, this._loaded = true, this.map.style.sourceCaches[this.id].clearTiles(), w4 && (a4.e(this, w4), w4.bounds && (this.tileBounds = new Ze(w4.bounds, this.minzoom, this.maxzoom)), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "content" })));\n                      } catch (w4) {\n                        this._tileJSONRequest = null, this.fire(new a4.j(w4));\n                      }\n                    });\n                  }\n                  loaded() {\n                    return this._loaded;\n                  }\n                  hasTile(w4) {\n                    return !this.tileBounds || this.tileBounds.contains(w4.canonical);\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this.load();\n                  }\n                  setSourceProperty(w4) {\n                    this._tileJSONRequest && this._tileJSONRequest.abort(), w4(), this.load();\n                  }\n                  setTiles(w4) {\n                    return this.setSourceProperty(() => {\n                      this._options.tiles = w4;\n                    }), this;\n                  }\n                  setUrl(w4) {\n                    return this.setSourceProperty(() => {\n                      this.url = w4, this._options.url = w4;\n                    }), this;\n                  }\n                  onRemove() {\n                    this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);\n                  }\n                  serialize() {\n                    return a4.e({}, this._options);\n                  }\n                  loadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = w4.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), Q = { request: this.map._requestManager.transformRequest(B4, "Tile"), uid: w4.uid, tileID: w4.tileID, zoom: w4.tileID.overscaledZ, tileSize: this.tileSize * w4.tileID.overscaleFactor(), type: this.type, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };\n                      Q.request.collectResourceTiming = this._collectResourceTiming;\n                      let ee = "RT";\n                      if (w4.actor && w4.state !== "expired") {\n                        if (w4.state === "loading") return new Promise((le, qe) => {\n                          w4.reloadPromise = { resolve: le, reject: qe };\n                        });\n                      } else w4.actor = this.dispatcher.getActor(), ee = "LT";\n                      w4.abortController = new AbortController();\n                      try {\n                        let le = yield w4.actor.sendAsync({ type: ee, data: Q }, w4.abortController);\n                        if (delete w4.abortController, w4.aborted) return;\n                        this._afterTileLoadWorkerResponse(w4, le);\n                      } catch (le) {\n                        if (delete w4.abortController, w4.aborted) return;\n                        if (le && le.status !== 404) throw le;\n                        this._afterTileLoadWorkerResponse(w4, null);\n                      }\n                    });\n                  }\n                  _afterTileLoadWorkerResponse(w4, B4) {\n                    if (B4 && B4.resourceTiming && (w4.resourceTiming = B4.resourceTiming), B4 && this.map._refreshExpiredTiles && w4.setExpiryData(B4), w4.loadVectorData(B4, this.map.painter), w4.reloadPromise) {\n                      let Q = w4.reloadPromise;\n                      w4.reloadPromise = null, this.loadTile(w4).then(Q.resolve).catch(Q.reject);\n                    }\n                  }\n                  abortTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.abortController && (w4.abortController.abort(), delete w4.abortController), w4.actor && (yield w4.actor.sendAsync({ type: "AT", data: { uid: w4.uid, type: this.type, source: this.id } }));\n                    });\n                  }\n                  unloadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.unloadVectorData(), w4.actor && (yield w4.actor.sendAsync({ type: "RMT", data: { uid: w4.uid, type: this.type, source: this.id } }));\n                    });\n                  }\n                  hasTransition() {\n                    return false;\n                  }\n                }\n                class pt extends a4.E {\n                  constructor(w4, B4, Q, ee) {\n                    super(), this.id = w4, this.dispatcher = Q, this.setEventedParent(ee), this.type = "raster", this.minzoom = 0, this.maxzoom = 22, this.roundZoom = true, this.scheme = "xyz", this.tileSize = 512, this._loaded = false, this._options = a4.e({ type: "raster" }, B4), a4.e(this, a4.M(B4, ["url", "scheme", "tileSize"]));\n                  }\n                  load() {\n                    return a4._(this, void 0, void 0, function* () {\n                      this._loaded = false, this.fire(new a4.k("dataloading", { dataType: "source" })), this._tileJSONRequest = new AbortController();\n                      try {\n                        let w4 = yield Re(this._options, this.map._requestManager, this._tileJSONRequest);\n                        this._tileJSONRequest = null, this._loaded = true, w4 && (a4.e(this, w4), w4.bounds && (this.tileBounds = new Ze(w4.bounds, this.minzoom, this.maxzoom)), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "metadata" })), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "content" })));\n                      } catch (w4) {\n                        this._tileJSONRequest = null, this.fire(new a4.j(w4));\n                      }\n                    });\n                  }\n                  loaded() {\n                    return this._loaded;\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this.load();\n                  }\n                  onRemove() {\n                    this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null);\n                  }\n                  setSourceProperty(w4) {\n                    this._tileJSONRequest && (this._tileJSONRequest.abort(), this._tileJSONRequest = null), w4(), this.load();\n                  }\n                  setTiles(w4) {\n                    return this.setSourceProperty(() => {\n                      this._options.tiles = w4;\n                    }), this;\n                  }\n                  setUrl(w4) {\n                    return this.setSourceProperty(() => {\n                      this.url = w4, this._options.url = w4;\n                    }), this;\n                  }\n                  serialize() {\n                    return a4.e({}, this._options);\n                  }\n                  hasTile(w4) {\n                    return !this.tileBounds || this.tileBounds.contains(w4.canonical);\n                  }\n                  loadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = w4.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme);\n                      w4.abortController = new AbortController();\n                      try {\n                        let Q = yield p3.getImage(this.map._requestManager.transformRequest(B4, "Tile"), w4.abortController, this.map._refreshExpiredTiles);\n                        if (delete w4.abortController, w4.aborted) return void (w4.state = "unloaded");\n                        if (Q && Q.data) {\n                          this.map._refreshExpiredTiles && Q.cacheControl && Q.expires && w4.setExpiryData({ cacheControl: Q.cacheControl, expires: Q.expires });\n                          let ee = this.map.painter.context, le = ee.gl, qe = Q.data;\n                          w4.texture = this.map.painter.getTileTexture(qe.width), w4.texture ? w4.texture.update(qe, { useMipmap: true }) : (w4.texture = new g3(ee, qe, le.RGBA, { useMipmap: true }), w4.texture.bind(le.LINEAR, le.CLAMP_TO_EDGE, le.LINEAR_MIPMAP_NEAREST)), w4.state = "loaded";\n                        }\n                      } catch (Q) {\n                        if (delete w4.abortController, w4.aborted) w4.state = "unloaded";\n                        else if (Q) throw w4.state = "errored", Q;\n                      }\n                    });\n                  }\n                  abortTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.abortController && (w4.abortController.abort(), delete w4.abortController);\n                    });\n                  }\n                  unloadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.texture && this.map.painter.saveTileTexture(w4.texture);\n                    });\n                  }\n                  hasTransition() {\n                    return false;\n                  }\n                }\n                class Zt extends pt {\n                  constructor(w4, B4, Q, ee) {\n                    super(w4, B4, Q, ee), this.type = "raster-dem", this.maxzoom = 22, this._options = a4.e({ type: "raster-dem" }, B4), this.encoding = B4.encoding || "mapbox", this.redFactor = B4.redFactor, this.greenFactor = B4.greenFactor, this.blueFactor = B4.blueFactor, this.baseShift = B4.baseShift;\n                  }\n                  loadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = w4.tileID.canonical.url(this.tiles, this.map.getPixelRatio(), this.scheme), Q = this.map._requestManager.transformRequest(B4, "Tile");\n                      w4.neighboringTiles = this._getNeighboringTiles(w4.tileID), w4.abortController = new AbortController();\n                      try {\n                        let ee = yield p3.getImage(Q, w4.abortController, this.map._refreshExpiredTiles);\n                        if (delete w4.abortController, w4.aborted) return void (w4.state = "unloaded");\n                        if (ee && ee.data) {\n                          let le = ee.data;\n                          this.map._refreshExpiredTiles && ee.cacheControl && ee.expires && w4.setExpiryData({ cacheControl: ee.cacheControl, expires: ee.expires });\n                          let qe = a4.b(le) && a4.U() ? le : yield this.readImageNow(le), Xe = { type: this.type, uid: w4.uid, source: this.id, rawImageData: qe, encoding: this.encoding, redFactor: this.redFactor, greenFactor: this.greenFactor, blueFactor: this.blueFactor, baseShift: this.baseShift };\n                          if (!w4.actor || w4.state === "expired") {\n                            w4.actor = this.dispatcher.getActor();\n                            let ot = yield w4.actor.sendAsync({ type: "LDT", data: Xe });\n                            w4.dem = ot, w4.needsHillshadePrepare = true, w4.needsTerrainPrepare = true, w4.state = "loaded";\n                          }\n                        }\n                      } catch (ee) {\n                        if (delete w4.abortController, w4.aborted) w4.state = "unloaded";\n                        else if (ee) throw w4.state = "errored", ee;\n                      }\n                    });\n                  }\n                  readImageNow(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      if (typeof VideoFrame != "undefined" && a4.V()) {\n                        let B4 = w4.width + 2, Q = w4.height + 2;\n                        try {\n                          return new a4.R({ width: B4, height: Q }, yield a4.W(w4, -1, -1, B4, Q));\n                        } catch (ee) {\n                        }\n                      }\n                      return u4.getImageData(w4, 1);\n                    });\n                  }\n                  _getNeighboringTiles(w4) {\n                    let B4 = w4.canonical, Q = Math.pow(2, B4.z), ee = (B4.x - 1 + Q) % Q, le = B4.x === 0 ? w4.wrap - 1 : w4.wrap, qe = (B4.x + 1 + Q) % Q, Xe = B4.x + 1 === Q ? w4.wrap + 1 : w4.wrap, ot = {};\n                    return ot[new a4.S(w4.overscaledZ, le, B4.z, ee, B4.y).key] = { backfilled: false }, ot[new a4.S(w4.overscaledZ, Xe, B4.z, qe, B4.y).key] = { backfilled: false }, B4.y > 0 && (ot[new a4.S(w4.overscaledZ, le, B4.z, ee, B4.y - 1).key] = { backfilled: false }, ot[new a4.S(w4.overscaledZ, w4.wrap, B4.z, B4.x, B4.y - 1).key] = { backfilled: false }, ot[new a4.S(w4.overscaledZ, Xe, B4.z, qe, B4.y - 1).key] = { backfilled: false }), B4.y + 1 < Q && (ot[new a4.S(w4.overscaledZ, le, B4.z, ee, B4.y + 1).key] = { backfilled: false }, ot[new a4.S(w4.overscaledZ, w4.wrap, B4.z, B4.x, B4.y + 1).key] = { backfilled: false }, ot[new a4.S(w4.overscaledZ, Xe, B4.z, qe, B4.y + 1).key] = { backfilled: false }), ot;\n                  }\n                  unloadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.demTexture && this.map.painter.saveTileTexture(w4.demTexture), w4.fbo && (w4.fbo.destroy(), delete w4.fbo), w4.dem && delete w4.dem, delete w4.neighboringTiles, w4.state = "unloaded", w4.actor && (yield w4.actor.sendAsync({ type: "RDT", data: { type: this.type, uid: w4.uid, source: this.id } }));\n                    });\n                  }\n                }\n                class st extends a4.E {\n                  constructor(w4, B4, Q, ee) {\n                    super(), this.id = w4, this.type = "geojson", this.minzoom = 0, this.maxzoom = 18, this.tileSize = 512, this.isTileClipped = true, this.reparseOverscaled = true, this._removed = false, this._pendingLoads = 0, this.actor = Q.getActor(), this.setEventedParent(ee), this._data = B4.data, this._options = a4.e({}, B4), this._collectResourceTiming = B4.collectResourceTiming, B4.maxzoom !== void 0 && (this.maxzoom = B4.maxzoom), B4.type && (this.type = B4.type), B4.attribution && (this.attribution = B4.attribution), this.promoteId = B4.promoteId;\n                    let le = a4.X / this.tileSize;\n                    B4.clusterMaxZoom !== void 0 && this.maxzoom <= B4.clusterMaxZoom && a4.w(`The maxzoom value "${this.maxzoom}" is expected to be greater than the clusterMaxZoom value "${B4.clusterMaxZoom}".`), this.workerOptions = a4.e({ source: this.id, cluster: B4.cluster || false, geojsonVtOptions: { buffer: (B4.buffer !== void 0 ? B4.buffer : 128) * le, tolerance: (B4.tolerance !== void 0 ? B4.tolerance : 0.375) * le, extent: a4.X, maxZoom: this.maxzoom, lineMetrics: B4.lineMetrics || false, generateId: B4.generateId || false }, superclusterOptions: { maxZoom: B4.clusterMaxZoom !== void 0 ? B4.clusterMaxZoom : this.maxzoom - 1, minPoints: Math.max(2, B4.clusterMinPoints || 2), extent: a4.X, radius: (B4.clusterRadius || 50) * le, log: false, generateId: B4.generateId || false }, clusterProperties: B4.clusterProperties, filter: B4.filter }, B4.workerOptions), typeof this.promoteId == "string" && (this.workerOptions.promoteId = this.promoteId);\n                  }\n                  load() {\n                    return a4._(this, void 0, void 0, function* () {\n                      yield this._updateWorkerData();\n                    });\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this.load();\n                  }\n                  setData(w4) {\n                    return this._data = w4, this._updateWorkerData(), this;\n                  }\n                  updateData(w4) {\n                    return this._updateWorkerData(w4), this;\n                  }\n                  getData() {\n                    return a4._(this, void 0, void 0, function* () {\n                      let w4 = a4.e({ type: this.type }, this.workerOptions);\n                      return this.actor.sendAsync({ type: "GD", data: w4 });\n                    });\n                  }\n                  setClusterOptions(w4) {\n                    return this.workerOptions.cluster = w4.cluster, w4 && (w4.clusterRadius !== void 0 && (this.workerOptions.superclusterOptions.radius = w4.clusterRadius), w4.clusterMaxZoom !== void 0 && (this.workerOptions.superclusterOptions.maxZoom = w4.clusterMaxZoom)), this._updateWorkerData(), this;\n                  }\n                  getClusterExpansionZoom(w4) {\n                    return this.actor.sendAsync({ type: "GCEZ", data: { type: this.type, clusterId: w4, source: this.id } });\n                  }\n                  getClusterChildren(w4) {\n                    return this.actor.sendAsync({ type: "GCC", data: { type: this.type, clusterId: w4, source: this.id } });\n                  }\n                  getClusterLeaves(w4, B4, Q) {\n                    return this.actor.sendAsync({ type: "GCL", data: { type: this.type, source: this.id, clusterId: w4, limit: B4, offset: Q } });\n                  }\n                  _updateWorkerData(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = a4.e({ type: this.type }, this.workerOptions);\n                      w4 ? B4.dataDiff = w4 : typeof this._data == "string" ? (B4.request = this.map._requestManager.transformRequest(u4.resolveURL(this._data), "Source"), B4.request.collectResourceTiming = this._collectResourceTiming) : B4.data = JSON.stringify(this._data), this._pendingLoads++, this.fire(new a4.k("dataloading", { dataType: "source" }));\n                      try {\n                        let Q = yield this.actor.sendAsync({ type: "LD", data: B4 });\n                        if (this._pendingLoads--, this._removed || Q.abandoned) return void this.fire(new a4.k("dataabort", { dataType: "source" }));\n                        let ee = null;\n                        Q.resourceTiming && Q.resourceTiming[this.id] && (ee = Q.resourceTiming[this.id].slice(0));\n                        let le = { dataType: "source" };\n                        this._collectResourceTiming && ee && ee.length > 0 && a4.e(le, { resourceTiming: ee }), this.fire(new a4.k("data", Object.assign(Object.assign({}, le), { sourceDataType: "metadata" }))), this.fire(new a4.k("data", Object.assign(Object.assign({}, le), { sourceDataType: "content" })));\n                      } catch (Q) {\n                        if (this._pendingLoads--, this._removed) return void this.fire(new a4.k("dataabort", { dataType: "source" }));\n                        this.fire(new a4.j(Q));\n                      }\n                    });\n                  }\n                  loaded() {\n                    return this._pendingLoads === 0;\n                  }\n                  loadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let B4 = w4.actor ? "RT" : "LT";\n                      w4.actor = this.actor;\n                      let Q = { type: this.type, uid: w4.uid, tileID: w4.tileID, zoom: w4.tileID.overscaledZ, maxZoom: this.maxzoom, tileSize: this.tileSize, source: this.id, pixelRatio: this.map.getPixelRatio(), showCollisionBoxes: this.map.showCollisionBoxes, promoteId: this.promoteId };\n                      w4.abortController = new AbortController();\n                      let ee = yield this.actor.sendAsync({ type: B4, data: Q }, w4.abortController);\n                      delete w4.abortController, w4.unloadVectorData(), w4.aborted || w4.loadVectorData(ee, this.map.painter, B4 === "RT");\n                    });\n                  }\n                  abortTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.abortController && (w4.abortController.abort(), delete w4.abortController), w4.aborted = true;\n                    });\n                  }\n                  unloadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      w4.unloadVectorData(), yield this.actor.sendAsync({ type: "RMT", data: { uid: w4.uid, type: this.type, source: this.id } });\n                    });\n                  }\n                  onRemove() {\n                    this._removed = true, this.actor.sendAsync({ type: "RS", data: { type: this.type, source: this.id } });\n                  }\n                  serialize() {\n                    return a4.e({}, this._options, { type: this.type, data: this._data });\n                  }\n                  hasTransition() {\n                    return false;\n                  }\n                }\n                var lt = a4.Y([{ name: "a_pos", type: "Int16", components: 2 }, { name: "a_texture_pos", type: "Int16", components: 2 }]);\n                class Gt extends a4.E {\n                  constructor(w4, B4, Q, ee) {\n                    super(), this.id = w4, this.dispatcher = Q, this.coordinates = B4.coordinates, this.type = "image", this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.tiles = {}, this._loaded = false, this.setEventedParent(ee), this.options = B4;\n                  }\n                  load(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      this._loaded = false, this.fire(new a4.k("dataloading", { dataType: "source" })), this.url = this.options.url, this._request = new AbortController();\n                      try {\n                        let B4 = yield p3.getImage(this.map._requestManager.transformRequest(this.url, "Image"), this._request);\n                        this._request = null, this._loaded = true, B4 && B4.data && (this.image = B4.data, w4 && (this.coordinates = w4), this._finishLoading());\n                      } catch (B4) {\n                        this._request = null, this._loaded = true, this.fire(new a4.j(B4));\n                      }\n                    });\n                  }\n                  loaded() {\n                    return this._loaded;\n                  }\n                  updateImage(w4) {\n                    return w4.url ? (this._request && (this._request.abort(), this._request = null), this.options.url = w4.url, this.load(w4.coordinates).finally(() => {\n                      this.texture = null;\n                    }), this) : this;\n                  }\n                  _finishLoading() {\n                    this.map && (this.setCoordinates(this.coordinates), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "metadata" })));\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this.load();\n                  }\n                  onRemove() {\n                    this._request && (this._request.abort(), this._request = null);\n                  }\n                  setCoordinates(w4) {\n                    this.coordinates = w4;\n                    let B4 = w4.map(a4.Z.fromLngLat);\n                    this.tileID = (function(ee) {\n                      let le = 1 / 0, qe = 1 / 0, Xe = -1 / 0, ot = -1 / 0;\n                      for (let xr of ee) le = Math.min(le, xr.x), qe = Math.min(qe, xr.y), Xe = Math.max(Xe, xr.x), ot = Math.max(ot, xr.y);\n                      let Tt = Math.max(Xe - le, ot - qe), Yt = Math.max(0, Math.floor(-Math.log(Tt) / Math.LN2)), Kt = Math.pow(2, Yt);\n                      return new a4.a1(Yt, Math.floor((le + Xe) / 2 * Kt), Math.floor((qe + ot) / 2 * Kt));\n                    })(B4), this.minzoom = this.maxzoom = this.tileID.z;\n                    let Q = B4.map((ee) => this.tileID.getTilePoint(ee)._round());\n                    return this._boundsArray = new a4.$(), this._boundsArray.emplaceBack(Q[0].x, Q[0].y, 0, 0), this._boundsArray.emplaceBack(Q[1].x, Q[1].y, a4.X, 0), this._boundsArray.emplaceBack(Q[3].x, Q[3].y, 0, a4.X), this._boundsArray.emplaceBack(Q[2].x, Q[2].y, a4.X, a4.X), this.boundsBuffer && (this.boundsBuffer.destroy(), delete this.boundsBuffer), this.fire(new a4.k("data", { dataType: "source", sourceDataType: "content" })), this;\n                  }\n                  prepare() {\n                    if (Object.keys(this.tiles).length === 0 || !this.image) return;\n                    let w4 = this.map.painter.context, B4 = w4.gl;\n                    this.boundsBuffer || (this.boundsBuffer = w4.createVertexBuffer(this._boundsArray, lt.members)), this.boundsSegments || (this.boundsSegments = a4.a0.simpleSegment(0, 0, 4, 2)), this.texture || (this.texture = new g3(w4, this.image, B4.RGBA), this.texture.bind(B4.LINEAR, B4.CLAMP_TO_EDGE));\n                    let Q = false;\n                    for (let ee in this.tiles) {\n                      let le = this.tiles[ee];\n                      le.state !== "loaded" && (le.state = "loaded", le.texture = this.texture, Q = true);\n                    }\n                    Q && this.fire(new a4.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));\n                  }\n                  loadTile(w4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      this.tileID && this.tileID.equals(w4.tileID.canonical) ? (this.tiles[String(w4.tileID.wrap)] = w4, w4.buckets = {}) : w4.state = "errored";\n                    });\n                  }\n                  serialize() {\n                    return { type: "image", url: this.options.url, coordinates: this.coordinates };\n                  }\n                  hasTransition() {\n                    return false;\n                  }\n                }\n                class Nt extends Gt {\n                  constructor(w4, B4, Q, ee) {\n                    super(w4, B4, Q, ee), this.roundZoom = true, this.type = "video", this.options = B4;\n                  }\n                  load() {\n                    return a4._(this, void 0, void 0, function* () {\n                      this._loaded = false;\n                      let w4 = this.options;\n                      this.urls = [];\n                      for (let B4 of w4.urls) this.urls.push(this.map._requestManager.transformRequest(B4, "Source").url);\n                      try {\n                        let B4 = yield a4.a3(this.urls);\n                        if (this._loaded = true, !B4) return;\n                        this.video = B4, this.video.loop = true, this.video.addEventListener("playing", () => {\n                          this.map.triggerRepaint();\n                        }), this.map && this.video.play(), this._finishLoading();\n                      } catch (B4) {\n                        this.fire(new a4.j(B4));\n                      }\n                    });\n                  }\n                  pause() {\n                    this.video && this.video.pause();\n                  }\n                  play() {\n                    this.video && this.video.play();\n                  }\n                  seek(w4) {\n                    if (this.video) {\n                      let B4 = this.video.seekable;\n                      w4 < B4.start(0) || w4 > B4.end(0) ? this.fire(new a4.j(new a4.a2(`sources.${this.id}`, null, `Playback for this video can be set only between the ${B4.start(0)} and ${B4.end(0)}-second mark.`))) : this.video.currentTime = w4;\n                    }\n                  }\n                  getVideo() {\n                    return this.video;\n                  }\n                  onAdd(w4) {\n                    this.map || (this.map = w4, this.load(), this.video && (this.video.play(), this.setCoordinates(this.coordinates)));\n                  }\n                  prepare() {\n                    if (Object.keys(this.tiles).length === 0 || this.video.readyState < 2) return;\n                    let w4 = this.map.painter.context, B4 = w4.gl;\n                    this.boundsBuffer || (this.boundsBuffer = w4.createVertexBuffer(this._boundsArray, lt.members)), this.boundsSegments || (this.boundsSegments = a4.a0.simpleSegment(0, 0, 4, 2)), this.texture ? this.video.paused || (this.texture.bind(B4.LINEAR, B4.CLAMP_TO_EDGE), B4.texSubImage2D(B4.TEXTURE_2D, 0, 0, 0, B4.RGBA, B4.UNSIGNED_BYTE, this.video)) : (this.texture = new g3(w4, this.video, B4.RGBA), this.texture.bind(B4.LINEAR, B4.CLAMP_TO_EDGE));\n                    let Q = false;\n                    for (let ee in this.tiles) {\n                      let le = this.tiles[ee];\n                      le.state !== "loaded" && (le.state = "loaded", le.texture = this.texture, Q = true);\n                    }\n                    Q && this.fire(new a4.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));\n                  }\n                  serialize() {\n                    return { type: "video", urls: this.urls, coordinates: this.coordinates };\n                  }\n                  hasTransition() {\n                    return this.video && !this.video.paused;\n                  }\n                }\n                class Jt extends Gt {\n                  constructor(w4, B4, Q, ee) {\n                    super(w4, B4, Q, ee), B4.coordinates ? Array.isArray(B4.coordinates) && B4.coordinates.length === 4 && !B4.coordinates.some((le) => !Array.isArray(le) || le.length !== 2 || le.some((qe) => typeof qe != "number")) || this.fire(new a4.j(new a4.a2(`sources.${w4}`, null, \'"coordinates" property must be an array of 4 longitude/latitude array pairs\'))) : this.fire(new a4.j(new a4.a2(`sources.${w4}`, null, \'missing required property "coordinates"\'))), B4.animate && typeof B4.animate != "boolean" && this.fire(new a4.j(new a4.a2(`sources.${w4}`, null, \'optional "animate" property must be a boolean value\'))), B4.canvas ? typeof B4.canvas == "string" || B4.canvas instanceof HTMLCanvasElement || this.fire(new a4.j(new a4.a2(`sources.${w4}`, null, \'"canvas" must be either a string representing the ID of the canvas element from which to read, or an HTMLCanvasElement instance\'))) : this.fire(new a4.j(new a4.a2(`sources.${w4}`, null, \'missing required property "canvas"\'))), this.options = B4, this.animate = B4.animate === void 0 || B4.animate;\n                  }\n                  load() {\n                    return a4._(this, void 0, void 0, function* () {\n                      this._loaded = true, this.canvas || (this.canvas = this.options.canvas instanceof HTMLCanvasElement ? this.options.canvas : document.getElementById(this.options.canvas)), this.width = this.canvas.width, this.height = this.canvas.height, this._hasInvalidDimensions() ? this.fire(new a4.j(new Error("Canvas dimensions cannot be less than or equal to zero."))) : (this.play = function() {\n                        this._playing = true, this.map.triggerRepaint();\n                      }, this.pause = function() {\n                        this._playing && (this.prepare(), this._playing = false);\n                      }, this._finishLoading());\n                    });\n                  }\n                  getCanvas() {\n                    return this.canvas;\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this.load(), this.canvas && this.animate && this.play();\n                  }\n                  onRemove() {\n                    this.pause();\n                  }\n                  prepare() {\n                    let w4 = false;\n                    if (this.canvas.width !== this.width && (this.width = this.canvas.width, w4 = true), this.canvas.height !== this.height && (this.height = this.canvas.height, w4 = true), this._hasInvalidDimensions() || Object.keys(this.tiles).length === 0) return;\n                    let B4 = this.map.painter.context, Q = B4.gl;\n                    this.boundsBuffer || (this.boundsBuffer = B4.createVertexBuffer(this._boundsArray, lt.members)), this.boundsSegments || (this.boundsSegments = a4.a0.simpleSegment(0, 0, 4, 2)), this.texture ? (w4 || this._playing) && this.texture.update(this.canvas, { premultiply: true }) : this.texture = new g3(B4, this.canvas, Q.RGBA, { premultiply: true });\n                    let ee = false;\n                    for (let le in this.tiles) {\n                      let qe = this.tiles[le];\n                      qe.state !== "loaded" && (qe.state = "loaded", qe.texture = this.texture, ee = true);\n                    }\n                    ee && this.fire(new a4.k("data", { dataType: "source", sourceDataType: "idle", sourceId: this.id }));\n                  }\n                  serialize() {\n                    return { type: "canvas", coordinates: this.coordinates };\n                  }\n                  hasTransition() {\n                    return this._playing;\n                  }\n                  _hasInvalidDimensions() {\n                    for (let w4 of [this.canvas.width, this.canvas.height]) if (isNaN(w4) || w4 <= 0) return true;\n                    return false;\n                  }\n                }\n                let sr = {}, wr = (ue) => {\n                  switch (ue) {\n                    case "geojson":\n                      return st;\n                    case "image":\n                      return Gt;\n                    case "raster":\n                      return pt;\n                    case "raster-dem":\n                      return Zt;\n                    case "vector":\n                      return ut;\n                    case "video":\n                      return Nt;\n                    case "canvas":\n                      return Jt;\n                  }\n                  return sr[ue];\n                }, cr = "RTLPluginLoaded";\n                class $e extends a4.E {\n                  constructor() {\n                    super(...arguments), this.status = "unavailable", this.url = null, this.dispatcher = Ae();\n                  }\n                  _syncState(w4) {\n                    return this.status = w4, this.dispatcher.broadcast("SRPS", { pluginStatus: w4, pluginURL: this.url }).catch((B4) => {\n                      throw this.status = "error", B4;\n                    });\n                  }\n                  getRTLTextPluginStatus() {\n                    return this.status;\n                  }\n                  clearRTLTextPlugin() {\n                    this.status = "unavailable", this.url = null;\n                  }\n                  setRTLTextPlugin(w4) {\n                    return a4._(this, arguments, void 0, function* (B4, Q = false) {\n                      if (this.url) throw new Error("setRTLTextPlugin cannot be called multiple times.");\n                      if (this.url = u4.resolveURL(B4), !this.url) throw new Error(`requested url ${B4} is invalid`);\n                      if (this.status === "unavailable") {\n                        if (!Q) return this._requestImport();\n                        this.status = "deferred", this._syncState(this.status);\n                      } else if (this.status === "requested") return this._requestImport();\n                    });\n                  }\n                  _requestImport() {\n                    return a4._(this, void 0, void 0, function* () {\n                      yield this._syncState("loading"), this.status = "loaded", this.fire(new a4.k(cr));\n                    });\n                  }\n                  lazyLoad() {\n                    this.status === "unavailable" ? this.status = "requested" : this.status === "deferred" && this._requestImport();\n                  }\n                }\n                let St = null;\n                function Qt() {\n                  return St || (St = new $e()), St;\n                }\n                class Vt {\n                  constructor(w4, B4) {\n                    this.timeAdded = 0, this.fadeEndTime = 0, this.tileID = w4, this.uid = a4.a4(), this.uses = 0, this.tileSize = B4, this.buckets = {}, this.expirationTime = null, this.queryPadding = 0, this.hasSymbolBuckets = false, this.hasRTLText = false, this.dependencies = {}, this.rtt = [], this.rttCoords = {}, this.expiredRequestCount = 0, this.state = "loading";\n                  }\n                  registerFadeDuration(w4) {\n                    let B4 = w4 + this.timeAdded;\n                    B4 < this.fadeEndTime || (this.fadeEndTime = B4);\n                  }\n                  wasRequested() {\n                    return this.state === "errored" || this.state === "loaded" || this.state === "reloading";\n                  }\n                  clearTextures(w4) {\n                    this.demTexture && w4.saveTileTexture(this.demTexture), this.demTexture = null;\n                  }\n                  loadVectorData(w4, B4, Q) {\n                    if (this.hasData() && this.unloadVectorData(), this.state = "loaded", w4) {\n                      w4.featureIndex && (this.latestFeatureIndex = w4.featureIndex, w4.rawTileData ? (this.latestRawTileData = w4.rawTileData, this.latestFeatureIndex.rawTileData = w4.rawTileData) : this.latestRawTileData && (this.latestFeatureIndex.rawTileData = this.latestRawTileData)), this.collisionBoxArray = w4.collisionBoxArray, this.buckets = (function(ee, le) {\n                        let qe = {};\n                        if (!le) return qe;\n                        for (let Xe of ee) {\n                          let ot = Xe.layerIds.map((Tt) => le.getLayer(Tt)).filter(Boolean);\n                          if (ot.length !== 0) {\n                            Xe.layers = ot, Xe.stateDependentLayerIds && (Xe.stateDependentLayers = Xe.stateDependentLayerIds.map((Tt) => ot.filter((Yt) => Yt.id === Tt)[0]));\n                            for (let Tt of ot) qe[Tt.id] = Xe;\n                          }\n                        }\n                        return qe;\n                      })(w4.buckets, B4.style), this.hasSymbolBuckets = false;\n                      for (let ee in this.buckets) {\n                        let le = this.buckets[ee];\n                        if (le instanceof a4.a6) {\n                          if (this.hasSymbolBuckets = true, !Q) break;\n                          le.justReloaded = true;\n                        }\n                      }\n                      if (this.hasRTLText = false, this.hasSymbolBuckets) for (let ee in this.buckets) {\n                        let le = this.buckets[ee];\n                        if (le instanceof a4.a6 && le.hasRTLText) {\n                          this.hasRTLText = true, Qt().lazyLoad();\n                          break;\n                        }\n                      }\n                      this.queryPadding = 0;\n                      for (let ee in this.buckets) {\n                        let le = this.buckets[ee];\n                        this.queryPadding = Math.max(this.queryPadding, B4.style.getLayer(ee).queryRadius(le));\n                      }\n                      w4.imageAtlas && (this.imageAtlas = w4.imageAtlas), w4.glyphAtlasImage && (this.glyphAtlasImage = w4.glyphAtlasImage);\n                    } else this.collisionBoxArray = new a4.a5();\n                  }\n                  unloadVectorData() {\n                    for (let w4 in this.buckets) this.buckets[w4].destroy();\n                    this.buckets = {}, this.imageAtlasTexture && this.imageAtlasTexture.destroy(), this.imageAtlas && (this.imageAtlas = null), this.glyphAtlasTexture && this.glyphAtlasTexture.destroy(), this.latestFeatureIndex = null, this.state = "unloaded";\n                  }\n                  getBucket(w4) {\n                    return this.buckets[w4.id];\n                  }\n                  upload(w4) {\n                    for (let Q in this.buckets) {\n                      let ee = this.buckets[Q];\n                      ee.uploadPending() && ee.upload(w4);\n                    }\n                    let B4 = w4.gl;\n                    this.imageAtlas && !this.imageAtlas.uploaded && (this.imageAtlasTexture = new g3(w4, this.imageAtlas.image, B4.RGBA), this.imageAtlas.uploaded = true), this.glyphAtlasImage && (this.glyphAtlasTexture = new g3(w4, this.glyphAtlasImage, B4.ALPHA), this.glyphAtlasImage = null);\n                  }\n                  prepare(w4) {\n                    this.imageAtlas && this.imageAtlas.patchUpdatedImages(w4, this.imageAtlasTexture);\n                  }\n                  queryRenderedFeatures(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt) {\n                    return this.latestFeatureIndex && this.latestFeatureIndex.rawTileData ? this.latestFeatureIndex.query({ queryGeometry: ee, cameraQueryGeometry: le, scale: qe, tileSize: this.tileSize, pixelPosMatrix: Yt, transform: ot, params: Xe, queryPadding: this.queryPadding * Tt }, w4, B4, Q) : {};\n                  }\n                  querySourceFeatures(w4, B4) {\n                    let Q = this.latestFeatureIndex;\n                    if (!Q || !Q.rawTileData) return;\n                    let ee = Q.loadVTLayers(), le = B4 && B4.sourceLayer ? B4.sourceLayer : "", qe = ee._geojsonTileLayer || ee[le];\n                    if (!qe) return;\n                    let Xe = a4.a7(B4 && B4.filter), { z: ot, x: Tt, y: Yt } = this.tileID.canonical, Kt = { z: ot, x: Tt, y: Yt };\n                    for (let xr = 0; xr < qe.length; xr++) {\n                      let Ir = qe.feature(xr);\n                      if (Xe.needGeometry) {\n                        let De = a4.a8(Ir, true);\n                        if (!Xe.filter(new a4.z(this.tileID.overscaledZ), De, this.tileID.canonical)) continue;\n                      } else if (!Xe.filter(new a4.z(this.tileID.overscaledZ), Ir)) continue;\n                      let ve = Q.getId(Ir, le), be = new a4.a9(Ir, ot, Tt, Yt, ve);\n                      be.tile = Kt, w4.push(be);\n                    }\n                  }\n                  hasData() {\n                    return this.state === "loaded" || this.state === "reloading" || this.state === "expired";\n                  }\n                  patternsLoaded() {\n                    return this.imageAtlas && !!Object.keys(this.imageAtlas.patternPositions).length;\n                  }\n                  setExpiryData(w4) {\n                    let B4 = this.expirationTime;\n                    if (w4.cacheControl) {\n                      let Q = a4.aa(w4.cacheControl);\n                      Q["max-age"] && (this.expirationTime = Date.now() + 1e3 * Q["max-age"]);\n                    } else w4.expires && (this.expirationTime = new Date(w4.expires).getTime());\n                    if (this.expirationTime) {\n                      let Q = Date.now(), ee = false;\n                      if (this.expirationTime > Q) ee = false;\n                      else if (B4) if (this.expirationTime < B4) ee = true;\n                      else {\n                        let le = this.expirationTime - B4;\n                        le ? this.expirationTime = Q + Math.max(le, 3e4) : ee = true;\n                      }\n                      else ee = true;\n                      ee ? (this.expiredRequestCount++, this.state = "expired") : this.expiredRequestCount = 0;\n                    }\n                  }\n                  getExpiryTimeout() {\n                    if (this.expirationTime) return this.expiredRequestCount ? 1e3 * (1 << Math.min(this.expiredRequestCount - 1, 31)) : Math.min(this.expirationTime - (/* @__PURE__ */ new Date()).getTime(), Math.pow(2, 31) - 1);\n                  }\n                  setFeatureState(w4, B4) {\n                    if (!this.latestFeatureIndex || !this.latestFeatureIndex.rawTileData || Object.keys(w4).length === 0) return;\n                    let Q = this.latestFeatureIndex.loadVTLayers();\n                    for (let ee in this.buckets) {\n                      if (!B4.style.hasLayer(ee)) continue;\n                      let le = this.buckets[ee], qe = le.layers[0].sourceLayer || "_geojsonTileLayer", Xe = Q[qe], ot = w4[qe];\n                      if (!Xe || !ot || Object.keys(ot).length === 0) continue;\n                      le.update(ot, Xe, this.imageAtlas && this.imageAtlas.patternPositions || {});\n                      let Tt = B4 && B4.style && B4.style.getLayer(ee);\n                      Tt && (this.queryPadding = Math.max(this.queryPadding, Tt.queryRadius(le)));\n                    }\n                  }\n                  holdingForFade() {\n                    return this.symbolFadeHoldUntil !== void 0;\n                  }\n                  symbolFadeFinished() {\n                    return !this.symbolFadeHoldUntil || this.symbolFadeHoldUntil < u4.now();\n                  }\n                  clearFadeHold() {\n                    this.symbolFadeHoldUntil = void 0;\n                  }\n                  setHoldDuration(w4) {\n                    this.symbolFadeHoldUntil = u4.now() + w4;\n                  }\n                  setDependencies(w4, B4) {\n                    let Q = {};\n                    for (let ee of B4) Q[ee] = true;\n                    this.dependencies[w4] = Q;\n                  }\n                  hasDependency(w4, B4) {\n                    for (let Q of w4) {\n                      let ee = this.dependencies[Q];\n                      if (ee) {\n                        for (let le of B4) if (ee[le]) return true;\n                      }\n                    }\n                    return false;\n                  }\n                }\n                class _t {\n                  constructor(w4, B4) {\n                    this.max = w4, this.onRemove = B4, this.reset();\n                  }\n                  reset() {\n                    for (let w4 in this.data) for (let B4 of this.data[w4]) B4.timeout && clearTimeout(B4.timeout), this.onRemove(B4.value);\n                    return this.data = {}, this.order = [], this;\n                  }\n                  add(w4, B4, Q) {\n                    let ee = w4.wrapped().key;\n                    this.data[ee] === void 0 && (this.data[ee] = []);\n                    let le = { value: B4, timeout: void 0 };\n                    if (Q !== void 0 && (le.timeout = setTimeout(() => {\n                      this.remove(w4, le);\n                    }, Q)), this.data[ee].push(le), this.order.push(ee), this.order.length > this.max) {\n                      let qe = this._getAndRemoveByKey(this.order[0]);\n                      qe && this.onRemove(qe);\n                    }\n                    return this;\n                  }\n                  has(w4) {\n                    return w4.wrapped().key in this.data;\n                  }\n                  getAndRemove(w4) {\n                    return this.has(w4) ? this._getAndRemoveByKey(w4.wrapped().key) : null;\n                  }\n                  _getAndRemoveByKey(w4) {\n                    let B4 = this.data[w4].shift();\n                    return B4.timeout && clearTimeout(B4.timeout), this.data[w4].length === 0 && delete this.data[w4], this.order.splice(this.order.indexOf(w4), 1), B4.value;\n                  }\n                  getByKey(w4) {\n                    let B4 = this.data[w4];\n                    return B4 ? B4[0].value : null;\n                  }\n                  get(w4) {\n                    return this.has(w4) ? this.data[w4.wrapped().key][0].value : null;\n                  }\n                  remove(w4, B4) {\n                    if (!this.has(w4)) return this;\n                    let Q = w4.wrapped().key, ee = B4 === void 0 ? 0 : this.data[Q].indexOf(B4), le = this.data[Q][ee];\n                    return this.data[Q].splice(ee, 1), le.timeout && clearTimeout(le.timeout), this.data[Q].length === 0 && delete this.data[Q], this.onRemove(le.value), this.order.splice(this.order.indexOf(Q), 1), this;\n                  }\n                  setMaxSize(w4) {\n                    for (this.max = w4; this.order.length > this.max; ) {\n                      let B4 = this._getAndRemoveByKey(this.order[0]);\n                      B4 && this.onRemove(B4);\n                    }\n                    return this;\n                  }\n                  filter(w4) {\n                    let B4 = [];\n                    for (let Q in this.data) for (let ee of this.data[Q]) w4(ee.value) || B4.push(ee);\n                    for (let Q of B4) this.remove(Q.value.tileID, Q);\n                  }\n                }\n                class It {\n                  constructor() {\n                    this.state = {}, this.stateChanges = {}, this.deletedStates = {};\n                  }\n                  updateState(w4, B4, Q) {\n                    let ee = String(B4);\n                    if (this.stateChanges[w4] = this.stateChanges[w4] || {}, this.stateChanges[w4][ee] = this.stateChanges[w4][ee] || {}, a4.e(this.stateChanges[w4][ee], Q), this.deletedStates[w4] === null) {\n                      this.deletedStates[w4] = {};\n                      for (let le in this.state[w4]) le !== ee && (this.deletedStates[w4][le] = null);\n                    } else if (this.deletedStates[w4] && this.deletedStates[w4][ee] === null) {\n                      this.deletedStates[w4][ee] = {};\n                      for (let le in this.state[w4][ee]) Q[le] || (this.deletedStates[w4][ee][le] = null);\n                    } else for (let le in Q) this.deletedStates[w4] && this.deletedStates[w4][ee] && this.deletedStates[w4][ee][le] === null && delete this.deletedStates[w4][ee][le];\n                  }\n                  removeFeatureState(w4, B4, Q) {\n                    if (this.deletedStates[w4] === null) return;\n                    let ee = String(B4);\n                    if (this.deletedStates[w4] = this.deletedStates[w4] || {}, Q && B4 !== void 0) this.deletedStates[w4][ee] !== null && (this.deletedStates[w4][ee] = this.deletedStates[w4][ee] || {}, this.deletedStates[w4][ee][Q] = null);\n                    else if (B4 !== void 0) if (this.stateChanges[w4] && this.stateChanges[w4][ee]) for (Q in this.deletedStates[w4][ee] = {}, this.stateChanges[w4][ee]) this.deletedStates[w4][ee][Q] = null;\n                    else this.deletedStates[w4][ee] = null;\n                    else this.deletedStates[w4] = null;\n                  }\n                  getState(w4, B4) {\n                    let Q = String(B4), ee = a4.e({}, (this.state[w4] || {})[Q], (this.stateChanges[w4] || {})[Q]);\n                    if (this.deletedStates[w4] === null) return {};\n                    if (this.deletedStates[w4]) {\n                      let le = this.deletedStates[w4][B4];\n                      if (le === null) return {};\n                      for (let qe in le) delete ee[qe];\n                    }\n                    return ee;\n                  }\n                  initializeTileState(w4, B4) {\n                    w4.setFeatureState(this.state, B4);\n                  }\n                  coalesceChanges(w4, B4) {\n                    let Q = {};\n                    for (let ee in this.stateChanges) {\n                      this.state[ee] = this.state[ee] || {};\n                      let le = {};\n                      for (let qe in this.stateChanges[ee]) this.state[ee][qe] || (this.state[ee][qe] = {}), a4.e(this.state[ee][qe], this.stateChanges[ee][qe]), le[qe] = this.state[ee][qe];\n                      Q[ee] = le;\n                    }\n                    for (let ee in this.deletedStates) {\n                      this.state[ee] = this.state[ee] || {};\n                      let le = {};\n                      if (this.deletedStates[ee] === null) for (let qe in this.state[ee]) le[qe] = {}, this.state[ee][qe] = {};\n                      else for (let qe in this.deletedStates[ee]) {\n                        if (this.deletedStates[ee][qe] === null) this.state[ee][qe] = {};\n                        else for (let Xe of Object.keys(this.deletedStates[ee][qe])) delete this.state[ee][qe][Xe];\n                        le[qe] = this.state[ee][qe];\n                      }\n                      Q[ee] = Q[ee] || {}, a4.e(Q[ee], le);\n                    }\n                    if (this.stateChanges = {}, this.deletedStates = {}, Object.keys(Q).length !== 0) for (let ee in w4) w4[ee].setFeatureState(Q, B4);\n                  }\n                }\n                class mt extends a4.E {\n                  constructor(w4, B4, Q) {\n                    super(), this.id = w4, this.dispatcher = Q, this.on("data", (ee) => this._dataHandler(ee)), this.on("dataloading", () => {\n                      this._sourceErrored = false;\n                    }), this.on("error", () => {\n                      this._sourceErrored = this._source.loaded();\n                    }), this._source = ((ee, le, qe, Xe) => {\n                      let ot = new (wr(le.type))(ee, le, qe, Xe);\n                      if (ot.id !== ee) throw new Error(`Expected Source id to be ${ee} instead of ${ot.id}`);\n                      return ot;\n                    })(w4, B4, Q, this), this._tiles = {}, this._cache = new _t(0, (ee) => this._unloadTile(ee)), this._timers = {}, this._cacheTimers = {}, this._maxTileCacheSize = null, this._maxTileCacheZoomLevels = null, this._loadedParentTiles = {}, this._coveredTiles = {}, this._state = new It(), this._didEmitContent = false, this._updated = false;\n                  }\n                  onAdd(w4) {\n                    this.map = w4, this._maxTileCacheSize = w4 ? w4._maxTileCacheSize : null, this._maxTileCacheZoomLevels = w4 ? w4._maxTileCacheZoomLevels : null, this._source && this._source.onAdd && this._source.onAdd(w4);\n                  }\n                  onRemove(w4) {\n                    this.clearTiles(), this._source && this._source.onRemove && this._source.onRemove(w4);\n                  }\n                  loaded() {\n                    if (this._sourceErrored) return true;\n                    if (!this._sourceLoaded || !this._source.loaded()) return false;\n                    if (!(this.used === void 0 && this.usedForTerrain === void 0 || this.used || this.usedForTerrain)) return true;\n                    if (!this._updated) return false;\n                    for (let w4 in this._tiles) {\n                      let B4 = this._tiles[w4];\n                      if (B4.state !== "loaded" && B4.state !== "errored") return false;\n                    }\n                    return true;\n                  }\n                  getSource() {\n                    return this._source;\n                  }\n                  pause() {\n                    this._paused = true;\n                  }\n                  resume() {\n                    if (!this._paused) return;\n                    let w4 = this._shouldReloadOnResume;\n                    this._paused = false, this._shouldReloadOnResume = false, w4 && this.reload(), this.transform && this.update(this.transform, this.terrain);\n                  }\n                  _loadTile(w4, B4, Q) {\n                    return a4._(this, void 0, void 0, function* () {\n                      try {\n                        yield this._source.loadTile(w4), this._tileLoaded(w4, B4, Q);\n                      } catch (ee) {\n                        w4.state = "errored", ee.status !== 404 ? this._source.fire(new a4.j(ee, { tile: w4 })) : this.update(this.transform, this.terrain);\n                      }\n                    });\n                  }\n                  _unloadTile(w4) {\n                    this._source.unloadTile && this._source.unloadTile(w4);\n                  }\n                  _abortTile(w4) {\n                    this._source.abortTile && this._source.abortTile(w4), this._source.fire(new a4.k("dataabort", { tile: w4, coord: w4.tileID, dataType: "source" }));\n                  }\n                  serialize() {\n                    return this._source.serialize();\n                  }\n                  prepare(w4) {\n                    this._source.prepare && this._source.prepare(), this._state.coalesceChanges(this._tiles, this.map ? this.map.painter : null);\n                    for (let B4 in this._tiles) {\n                      let Q = this._tiles[B4];\n                      Q.upload(w4), Q.prepare(this.map.style.imageManager);\n                    }\n                  }\n                  getIds() {\n                    return Object.values(this._tiles).map((w4) => w4.tileID).sort(er).map((w4) => w4.key);\n                  }\n                  getRenderableIds(w4) {\n                    let B4 = [];\n                    for (let Q in this._tiles) this._isIdRenderable(Q, w4) && B4.push(this._tiles[Q]);\n                    return w4 ? B4.sort((Q, ee) => {\n                      let le = Q.tileID, qe = ee.tileID, Xe = new a4.P(le.canonical.x, le.canonical.y)._rotate(this.transform.angle), ot = new a4.P(qe.canonical.x, qe.canonical.y)._rotate(this.transform.angle);\n                      return le.overscaledZ - qe.overscaledZ || ot.y - Xe.y || ot.x - Xe.x;\n                    }).map((Q) => Q.tileID.key) : B4.map((Q) => Q.tileID).sort(er).map((Q) => Q.key);\n                  }\n                  hasRenderableParent(w4) {\n                    let B4 = this.findLoadedParent(w4, 0);\n                    return !!B4 && this._isIdRenderable(B4.tileID.key);\n                  }\n                  _isIdRenderable(w4, B4) {\n                    return this._tiles[w4] && this._tiles[w4].hasData() && !this._coveredTiles[w4] && (B4 || !this._tiles[w4].holdingForFade());\n                  }\n                  reload() {\n                    if (this._paused) this._shouldReloadOnResume = true;\n                    else {\n                      this._cache.reset();\n                      for (let w4 in this._tiles) this._tiles[w4].state !== "errored" && this._reloadTile(w4, "reloading");\n                    }\n                  }\n                  _reloadTile(w4, B4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let Q = this._tiles[w4];\n                      Q && (Q.state !== "loading" && (Q.state = B4), yield this._loadTile(Q, w4, B4));\n                    });\n                  }\n                  _tileLoaded(w4, B4, Q) {\n                    w4.timeAdded = u4.now(), Q === "expired" && (w4.refreshedUponExpiration = true), this._setTileReloadTimer(B4, w4), this.getSource().type === "raster-dem" && w4.dem && this._backfillDEM(w4), this._state.initializeTileState(w4, this.map ? this.map.painter : null), w4.aborted || this._source.fire(new a4.k("data", { dataType: "source", tile: w4, coord: w4.tileID }));\n                  }\n                  _backfillDEM(w4) {\n                    let B4 = this.getRenderableIds();\n                    for (let ee = 0; ee < B4.length; ee++) {\n                      let le = B4[ee];\n                      if (w4.neighboringTiles && w4.neighboringTiles[le]) {\n                        let qe = this.getTileByID(le);\n                        Q(w4, qe), Q(qe, w4);\n                      }\n                    }\n                    function Q(ee, le) {\n                      ee.needsHillshadePrepare = true, ee.needsTerrainPrepare = true;\n                      let qe = le.tileID.canonical.x - ee.tileID.canonical.x, Xe = le.tileID.canonical.y - ee.tileID.canonical.y, ot = Math.pow(2, ee.tileID.canonical.z), Tt = le.tileID.key;\n                      qe === 0 && Xe === 0 || Math.abs(Xe) > 1 || (Math.abs(qe) > 1 && (Math.abs(qe + ot) === 1 ? qe += ot : Math.abs(qe - ot) === 1 && (qe -= ot)), le.dem && ee.dem && (ee.dem.backfillBorder(le.dem, qe, Xe), ee.neighboringTiles && ee.neighboringTiles[Tt] && (ee.neighboringTiles[Tt].backfilled = true)));\n                    }\n                  }\n                  getTile(w4) {\n                    return this.getTileByID(w4.key);\n                  }\n                  getTileByID(w4) {\n                    return this._tiles[w4];\n                  }\n                  _retainLoadedChildren(w4, B4, Q, ee) {\n                    for (let le in this._tiles) {\n                      let qe = this._tiles[le];\n                      if (ee[le] || !qe.hasData() || qe.tileID.overscaledZ <= B4 || qe.tileID.overscaledZ > Q) continue;\n                      let Xe = qe.tileID;\n                      for (; qe && qe.tileID.overscaledZ > B4 + 1; ) {\n                        let Tt = qe.tileID.scaledTo(qe.tileID.overscaledZ - 1);\n                        qe = this._tiles[Tt.key], qe && qe.hasData() && (Xe = Tt);\n                      }\n                      let ot = Xe;\n                      for (; ot.overscaledZ > B4; ) if (ot = ot.scaledTo(ot.overscaledZ - 1), w4[ot.key]) {\n                        ee[Xe.key] = Xe;\n                        break;\n                      }\n                    }\n                  }\n                  findLoadedParent(w4, B4) {\n                    if (w4.key in this._loadedParentTiles) {\n                      let Q = this._loadedParentTiles[w4.key];\n                      return Q && Q.tileID.overscaledZ >= B4 ? Q : null;\n                    }\n                    for (let Q = w4.overscaledZ - 1; Q >= B4; Q--) {\n                      let ee = w4.scaledTo(Q), le = this._getLoadedTile(ee);\n                      if (le) return le;\n                    }\n                  }\n                  findLoadedSibling(w4) {\n                    return this._getLoadedTile(w4);\n                  }\n                  _getLoadedTile(w4) {\n                    let B4 = this._tiles[w4.key];\n                    return B4 && B4.hasData() ? B4 : this._cache.getByKey(w4.wrapped().key);\n                  }\n                  updateCacheSize(w4) {\n                    let B4 = Math.ceil(w4.width / this._source.tileSize) + 1, Q = Math.ceil(w4.height / this._source.tileSize) + 1, ee = Math.floor(B4 * Q * (this._maxTileCacheZoomLevels === null ? a4.a.MAX_TILE_CACHE_ZOOM_LEVELS : this._maxTileCacheZoomLevels)), le = typeof this._maxTileCacheSize == "number" ? Math.min(this._maxTileCacheSize, ee) : ee;\n                    this._cache.setMaxSize(le);\n                  }\n                  handleWrapJump(w4) {\n                    let B4 = Math.round((w4 - (this._prevLng === void 0 ? w4 : this._prevLng)) / 360);\n                    if (this._prevLng = w4, B4) {\n                      let Q = {};\n                      for (let ee in this._tiles) {\n                        let le = this._tiles[ee];\n                        le.tileID = le.tileID.unwrapTo(le.tileID.wrap + B4), Q[le.tileID.key] = le;\n                      }\n                      this._tiles = Q;\n                      for (let ee in this._timers) clearTimeout(this._timers[ee]), delete this._timers[ee];\n                      for (let ee in this._tiles) this._setTileReloadTimer(ee, this._tiles[ee]);\n                    }\n                  }\n                  _updateCoveredAndRetainedTiles(w4, B4, Q, ee, le, qe) {\n                    let Xe = {}, ot = {}, Tt = Object.keys(w4), Yt = u4.now();\n                    for (let Kt of Tt) {\n                      let xr = w4[Kt], Ir = this._tiles[Kt];\n                      if (!Ir || Ir.fadeEndTime !== 0 && Ir.fadeEndTime <= Yt) continue;\n                      let ve = this.findLoadedParent(xr, B4), be = this.findLoadedSibling(xr), De = ve || be || null;\n                      De && (this._addTile(De.tileID), Xe[De.tileID.key] = De.tileID), ot[Kt] = xr;\n                    }\n                    this._retainLoadedChildren(ot, ee, Q, w4);\n                    for (let Kt in Xe) w4[Kt] || (this._coveredTiles[Kt] = true, w4[Kt] = Xe[Kt]);\n                    if (qe) {\n                      let Kt = {}, xr = {};\n                      for (let Ir of le) this._tiles[Ir.key].hasData() ? Kt[Ir.key] = Ir : xr[Ir.key] = Ir;\n                      for (let Ir in xr) {\n                        let ve = xr[Ir].children(this._source.maxzoom);\n                        this._tiles[ve[0].key] && this._tiles[ve[1].key] && this._tiles[ve[2].key] && this._tiles[ve[3].key] && (Kt[ve[0].key] = w4[ve[0].key] = ve[0], Kt[ve[1].key] = w4[ve[1].key] = ve[1], Kt[ve[2].key] = w4[ve[2].key] = ve[2], Kt[ve[3].key] = w4[ve[3].key] = ve[3], delete xr[Ir]);\n                      }\n                      for (let Ir in xr) {\n                        let ve = xr[Ir], be = this.findLoadedParent(ve, this._source.minzoom), De = this.findLoadedSibling(ve), Be = be || De || null;\n                        if (Be) {\n                          Kt[Be.tileID.key] = w4[Be.tileID.key] = Be.tileID;\n                          for (let et in Kt) Kt[et].isChildOf(Be.tileID) && delete Kt[et];\n                        }\n                      }\n                      for (let Ir in this._tiles) Kt[Ir] || (this._coveredTiles[Ir] = true);\n                    }\n                  }\n                  update(w4, B4) {\n                    if (!this._sourceLoaded || this._paused) return;\n                    let Q;\n                    this.transform = w4, this.terrain = B4, this.updateCacheSize(w4), this.handleWrapJump(this.transform.center.lng), this._coveredTiles = {}, this.used || this.usedForTerrain ? this._source.tileID ? Q = w4.getVisibleUnwrappedCoordinates(this._source.tileID).map((Yt) => new a4.S(Yt.canonical.z, Yt.wrap, Yt.canonical.z, Yt.canonical.x, Yt.canonical.y)) : (Q = w4.coveringTiles({ tileSize: this.usedForTerrain ? this.tileSize : this._source.tileSize, minzoom: this._source.minzoom, maxzoom: this._source.maxzoom, roundZoom: !this.usedForTerrain && this._source.roundZoom, reparseOverscaled: this._source.reparseOverscaled, terrain: B4 }), this._source.hasTile && (Q = Q.filter((Yt) => this._source.hasTile(Yt)))) : Q = [];\n                    let ee = w4.coveringZoomLevel(this._source), le = Math.max(ee - mt.maxOverzooming, this._source.minzoom), qe = Math.max(ee + mt.maxUnderzooming, this._source.minzoom);\n                    if (this.usedForTerrain) {\n                      let Yt = {};\n                      for (let Kt of Q) if (Kt.canonical.z > this._source.minzoom) {\n                        let xr = Kt.scaledTo(Kt.canonical.z - 1);\n                        Yt[xr.key] = xr;\n                        let Ir = Kt.scaledTo(Math.max(this._source.minzoom, Math.min(Kt.canonical.z, 5)));\n                        Yt[Ir.key] = Ir;\n                      }\n                      Q = Q.concat(Object.values(Yt));\n                    }\n                    let Xe = Q.length === 0 && !this._updated && this._didEmitContent;\n                    this._updated = true, Xe && this.fire(new a4.k("data", { sourceDataType: "idle", dataType: "source", sourceId: this.id }));\n                    let ot = this._updateRetainedTiles(Q, ee);\n                    lr(this._source.type) && this._updateCoveredAndRetainedTiles(ot, le, qe, ee, Q, B4);\n                    for (let Yt in ot) this._tiles[Yt].clearFadeHold();\n                    let Tt = a4.ab(this._tiles, ot);\n                    for (let Yt of Tt) {\n                      let Kt = this._tiles[Yt];\n                      Kt.hasSymbolBuckets && !Kt.holdingForFade() ? Kt.setHoldDuration(this.map._fadeDuration) : Kt.hasSymbolBuckets && !Kt.symbolFadeFinished() || this._removeTile(Yt);\n                    }\n                    this._updateLoadedParentTileCache(), this._updateLoadedSiblingTileCache();\n                  }\n                  releaseSymbolFadeTiles() {\n                    for (let w4 in this._tiles) this._tiles[w4].holdingForFade() && this._removeTile(w4);\n                  }\n                  _updateRetainedTiles(w4, B4) {\n                    var Q;\n                    let ee = {}, le = {}, qe = Math.max(B4 - mt.maxOverzooming, this._source.minzoom), Xe = Math.max(B4 + mt.maxUnderzooming, this._source.minzoom), ot = {};\n                    for (let Tt of w4) {\n                      let Yt = this._addTile(Tt);\n                      ee[Tt.key] = Tt, Yt.hasData() || B4 < this._source.maxzoom && (ot[Tt.key] = Tt);\n                    }\n                    this._retainLoadedChildren(ot, B4, Xe, ee);\n                    for (let Tt of w4) {\n                      let Yt = this._tiles[Tt.key];\n                      if (Yt.hasData()) continue;\n                      if (B4 + 1 > this._source.maxzoom) {\n                        let xr = Tt.children(this._source.maxzoom)[0], Ir = this.getTile(xr);\n                        if (Ir && Ir.hasData()) {\n                          ee[xr.key] = xr;\n                          continue;\n                        }\n                      } else {\n                        let xr = Tt.children(this._source.maxzoom);\n                        if (ee[xr[0].key] && ee[xr[1].key] && ee[xr[2].key] && ee[xr[3].key]) continue;\n                      }\n                      let Kt = Yt.wasRequested();\n                      for (let xr = Tt.overscaledZ - 1; xr >= qe; --xr) {\n                        let Ir = Tt.scaledTo(xr);\n                        if (le[Ir.key]) break;\n                        if (le[Ir.key] = true, Yt = this.getTile(Ir), !Yt && Kt && (Yt = this._addTile(Ir)), Yt) {\n                          let ve = Yt.hasData();\n                          if ((ve || !(!((Q = this.map) === null || Q === void 0) && Q.cancelPendingTileRequestsWhileZooming) || Kt) && (ee[Ir.key] = Ir), Kt = Yt.wasRequested(), ve) break;\n                        }\n                      }\n                    }\n                    return ee;\n                  }\n                  _updateLoadedParentTileCache() {\n                    this._loadedParentTiles = {};\n                    for (let w4 in this._tiles) {\n                      let B4 = [], Q, ee = this._tiles[w4].tileID;\n                      for (; ee.overscaledZ > 0; ) {\n                        if (ee.key in this._loadedParentTiles) {\n                          Q = this._loadedParentTiles[ee.key];\n                          break;\n                        }\n                        B4.push(ee.key);\n                        let le = ee.scaledTo(ee.overscaledZ - 1);\n                        if (Q = this._getLoadedTile(le), Q) break;\n                        ee = le;\n                      }\n                      for (let le of B4) this._loadedParentTiles[le] = Q;\n                    }\n                  }\n                  _updateLoadedSiblingTileCache() {\n                    this._loadedSiblingTiles = {};\n                    for (let w4 in this._tiles) {\n                      let B4 = this._tiles[w4].tileID, Q = this._getLoadedTile(B4);\n                      this._loadedSiblingTiles[B4.key] = Q;\n                    }\n                  }\n                  _addTile(w4) {\n                    let B4 = this._tiles[w4.key];\n                    if (B4) return B4;\n                    B4 = this._cache.getAndRemove(w4), B4 && (this._setTileReloadTimer(w4.key, B4), B4.tileID = w4, this._state.initializeTileState(B4, this.map ? this.map.painter : null), this._cacheTimers[w4.key] && (clearTimeout(this._cacheTimers[w4.key]), delete this._cacheTimers[w4.key], this._setTileReloadTimer(w4.key, B4)));\n                    let Q = B4;\n                    return B4 || (B4 = new Vt(w4, this._source.tileSize * w4.overscaleFactor()), this._loadTile(B4, w4.key, B4.state)), B4.uses++, this._tiles[w4.key] = B4, Q || this._source.fire(new a4.k("dataloading", { tile: B4, coord: B4.tileID, dataType: "source" })), B4;\n                  }\n                  _setTileReloadTimer(w4, B4) {\n                    w4 in this._timers && (clearTimeout(this._timers[w4]), delete this._timers[w4]);\n                    let Q = B4.getExpiryTimeout();\n                    Q && (this._timers[w4] = setTimeout(() => {\n                      this._reloadTile(w4, "expired"), delete this._timers[w4];\n                    }, Q));\n                  }\n                  _removeTile(w4) {\n                    let B4 = this._tiles[w4];\n                    B4 && (B4.uses--, delete this._tiles[w4], this._timers[w4] && (clearTimeout(this._timers[w4]), delete this._timers[w4]), B4.uses > 0 || (B4.hasData() && B4.state !== "reloading" ? this._cache.add(B4.tileID, B4, B4.getExpiryTimeout()) : (B4.aborted = true, this._abortTile(B4), this._unloadTile(B4))));\n                  }\n                  _dataHandler(w4) {\n                    let B4 = w4.sourceDataType;\n                    w4.dataType === "source" && B4 === "metadata" && (this._sourceLoaded = true), this._sourceLoaded && !this._paused && w4.dataType === "source" && B4 === "content" && (this.reload(), this.transform && this.update(this.transform, this.terrain), this._didEmitContent = true);\n                  }\n                  clearTiles() {\n                    this._shouldReloadOnResume = false, this._paused = false;\n                    for (let w4 in this._tiles) this._removeTile(w4);\n                    this._cache.reset();\n                  }\n                  tilesIn(w4, B4, Q) {\n                    let ee = [], le = this.transform;\n                    if (!le) return ee;\n                    let qe = Q ? le.getCameraQueryGeometry(w4) : w4, Xe = w4.map((ve) => le.pointCoordinate(ve, this.terrain)), ot = qe.map((ve) => le.pointCoordinate(ve, this.terrain)), Tt = this.getIds(), Yt = 1 / 0, Kt = 1 / 0, xr = -1 / 0, Ir = -1 / 0;\n                    for (let ve of ot) Yt = Math.min(Yt, ve.x), Kt = Math.min(Kt, ve.y), xr = Math.max(xr, ve.x), Ir = Math.max(Ir, ve.y);\n                    for (let ve = 0; ve < Tt.length; ve++) {\n                      let be = this._tiles[Tt[ve]];\n                      if (be.holdingForFade()) continue;\n                      let De = be.tileID, Be = Math.pow(2, le.zoom - be.tileID.overscaledZ), et = B4 * be.queryPadding * a4.X / be.tileSize / Be, We = [De.getTilePoint(new a4.Z(Yt, Kt)), De.getTilePoint(new a4.Z(xr, Ir))];\n                      if (We[0].x - et < a4.X && We[0].y - et < a4.X && We[1].x + et >= 0 && We[1].y + et >= 0) {\n                        let it = Xe.map((Ht) => De.getTilePoint(Ht)), Ft = ot.map((Ht) => De.getTilePoint(Ht));\n                        ee.push({ tile: be, tileID: De, queryGeometry: it, cameraQueryGeometry: Ft, scale: Be });\n                      }\n                    }\n                    return ee;\n                  }\n                  getVisibleCoordinates(w4) {\n                    let B4 = this.getRenderableIds(w4).map((Q) => this._tiles[Q].tileID);\n                    for (let Q of B4) Q.posMatrix = this.transform.calculatePosMatrix(Q.toUnwrapped());\n                    return B4;\n                  }\n                  hasTransition() {\n                    if (this._source.hasTransition()) return true;\n                    if (lr(this._source.type)) {\n                      let w4 = u4.now();\n                      for (let B4 in this._tiles) if (this._tiles[B4].fadeEndTime >= w4) return true;\n                    }\n                    return false;\n                  }\n                  setFeatureState(w4, B4, Q) {\n                    this._state.updateState(w4 = w4 || "_geojsonTileLayer", B4, Q);\n                  }\n                  removeFeatureState(w4, B4, Q) {\n                    this._state.removeFeatureState(w4 = w4 || "_geojsonTileLayer", B4, Q);\n                  }\n                  getFeatureState(w4, B4) {\n                    return this._state.getState(w4 = w4 || "_geojsonTileLayer", B4);\n                  }\n                  setDependencies(w4, B4, Q) {\n                    let ee = this._tiles[w4];\n                    ee && ee.setDependencies(B4, Q);\n                  }\n                  reloadTilesForDependencies(w4, B4) {\n                    for (let Q in this._tiles) this._tiles[Q].hasDependency(w4, B4) && this._reloadTile(Q, "reloading");\n                    this._cache.filter((Q) => !Q.hasDependency(w4, B4));\n                  }\n                }\n                function er(ue, w4) {\n                  let B4 = Math.abs(2 * ue.wrap) - +(ue.wrap < 0), Q = Math.abs(2 * w4.wrap) - +(w4.wrap < 0);\n                  return ue.overscaledZ - w4.overscaledZ || Q - B4 || w4.canonical.y - ue.canonical.y || w4.canonical.x - ue.canonical.x;\n                }\n                function lr(ue) {\n                  return ue === "raster" || ue === "image" || ue === "video";\n                }\n                mt.maxOverzooming = 10, mt.maxUnderzooming = 3;\n                class Tr {\n                  constructor(w4, B4) {\n                    this.reset(w4, B4);\n                  }\n                  reset(w4, B4) {\n                    this.points = w4 || [], this._distances = [0];\n                    for (let Q = 1; Q < this.points.length; Q++) this._distances[Q] = this._distances[Q - 1] + this.points[Q].dist(this.points[Q - 1]);\n                    this.length = this._distances[this._distances.length - 1], this.padding = Math.min(B4 || 0, 0.5 * this.length), this.paddedLength = this.length - 2 * this.padding;\n                  }\n                  lerp(w4) {\n                    if (this.points.length === 1) return this.points[0];\n                    w4 = a4.ac(w4, 0, 1);\n                    let B4 = 1, Q = this._distances[B4], ee = w4 * this.paddedLength + this.padding;\n                    for (; Q < ee && B4 < this._distances.length; ) Q = this._distances[++B4];\n                    let le = B4 - 1, qe = this._distances[le], Xe = Q - qe, ot = Xe > 0 ? (ee - qe) / Xe : 0;\n                    return this.points[le].mult(1 - ot).add(this.points[B4].mult(ot));\n                  }\n                }\n                function Lr(ue, w4) {\n                  let B4 = true;\n                  return ue === "always" || ue !== "never" && w4 !== "never" || (B4 = false), B4;\n                }\n                class ti {\n                  constructor(w4, B4, Q) {\n                    let ee = this.boxCells = [], le = this.circleCells = [];\n                    this.xCellCount = Math.ceil(w4 / Q), this.yCellCount = Math.ceil(B4 / Q);\n                    for (let qe = 0; qe < this.xCellCount * this.yCellCount; qe++) ee.push([]), le.push([]);\n                    this.circleKeys = [], this.boxKeys = [], this.bboxes = [], this.circles = [], this.width = w4, this.height = B4, this.xScale = this.xCellCount / w4, this.yScale = this.yCellCount / B4, this.boxUid = 0, this.circleUid = 0;\n                  }\n                  keysLength() {\n                    return this.boxKeys.length + this.circleKeys.length;\n                  }\n                  insert(w4, B4, Q, ee, le) {\n                    this._forEachCell(B4, Q, ee, le, this._insertBoxCell, this.boxUid++), this.boxKeys.push(w4), this.bboxes.push(B4), this.bboxes.push(Q), this.bboxes.push(ee), this.bboxes.push(le);\n                  }\n                  insertCircle(w4, B4, Q, ee) {\n                    this._forEachCell(B4 - ee, Q - ee, B4 + ee, Q + ee, this._insertCircleCell, this.circleUid++), this.circleKeys.push(w4), this.circles.push(B4), this.circles.push(Q), this.circles.push(ee);\n                  }\n                  _insertBoxCell(w4, B4, Q, ee, le, qe) {\n                    this.boxCells[le].push(qe);\n                  }\n                  _insertCircleCell(w4, B4, Q, ee, le, qe) {\n                    this.circleCells[le].push(qe);\n                  }\n                  _query(w4, B4, Q, ee, le, qe, Xe) {\n                    if (Q < 0 || w4 > this.width || ee < 0 || B4 > this.height) return [];\n                    let ot = [];\n                    if (w4 <= 0 && B4 <= 0 && this.width <= Q && this.height <= ee) {\n                      if (le) return [{ key: null, x1: w4, y1: B4, x2: Q, y2: ee }];\n                      for (let Tt = 0; Tt < this.boxKeys.length; Tt++) ot.push({ key: this.boxKeys[Tt], x1: this.bboxes[4 * Tt], y1: this.bboxes[4 * Tt + 1], x2: this.bboxes[4 * Tt + 2], y2: this.bboxes[4 * Tt + 3] });\n                      for (let Tt = 0; Tt < this.circleKeys.length; Tt++) {\n                        let Yt = this.circles[3 * Tt], Kt = this.circles[3 * Tt + 1], xr = this.circles[3 * Tt + 2];\n                        ot.push({ key: this.circleKeys[Tt], x1: Yt - xr, y1: Kt - xr, x2: Yt + xr, y2: Kt + xr });\n                      }\n                    } else this._forEachCell(w4, B4, Q, ee, this._queryCell, ot, { hitTest: le, overlapMode: qe, seenUids: { box: {}, circle: {} } }, Xe);\n                    return ot;\n                  }\n                  query(w4, B4, Q, ee) {\n                    return this._query(w4, B4, Q, ee, false, null);\n                  }\n                  hitTest(w4, B4, Q, ee, le, qe) {\n                    return this._query(w4, B4, Q, ee, true, le, qe).length > 0;\n                  }\n                  hitTestCircle(w4, B4, Q, ee, le) {\n                    let qe = w4 - Q, Xe = w4 + Q, ot = B4 - Q, Tt = B4 + Q;\n                    if (Xe < 0 || qe > this.width || Tt < 0 || ot > this.height) return false;\n                    let Yt = [];\n                    return this._forEachCell(qe, ot, Xe, Tt, this._queryCellCircle, Yt, { hitTest: true, overlapMode: ee, circle: { x: w4, y: B4, radius: Q }, seenUids: { box: {}, circle: {} } }, le), Yt.length > 0;\n                  }\n                  _queryCell(w4, B4, Q, ee, le, qe, Xe, ot) {\n                    let { seenUids: Tt, hitTest: Yt, overlapMode: Kt } = Xe, xr = this.boxCells[le];\n                    if (xr !== null) {\n                      let ve = this.bboxes;\n                      for (let be of xr) if (!Tt.box[be]) {\n                        Tt.box[be] = true;\n                        let De = 4 * be, Be = this.boxKeys[be];\n                        if (w4 <= ve[De + 2] && B4 <= ve[De + 3] && Q >= ve[De + 0] && ee >= ve[De + 1] && (!ot || ot(Be)) && (!Yt || !Lr(Kt, Be.overlapMode)) && (qe.push({ key: Be, x1: ve[De], y1: ve[De + 1], x2: ve[De + 2], y2: ve[De + 3] }), Yt)) return true;\n                      }\n                    }\n                    let Ir = this.circleCells[le];\n                    if (Ir !== null) {\n                      let ve = this.circles;\n                      for (let be of Ir) if (!Tt.circle[be]) {\n                        Tt.circle[be] = true;\n                        let De = 3 * be, Be = this.circleKeys[be];\n                        if (this._circleAndRectCollide(ve[De], ve[De + 1], ve[De + 2], w4, B4, Q, ee) && (!ot || ot(Be)) && (!Yt || !Lr(Kt, Be.overlapMode))) {\n                          let et = ve[De], We = ve[De + 1], it = ve[De + 2];\n                          if (qe.push({ key: Be, x1: et - it, y1: We - it, x2: et + it, y2: We + it }), Yt) return true;\n                        }\n                      }\n                    }\n                    return false;\n                  }\n                  _queryCellCircle(w4, B4, Q, ee, le, qe, Xe, ot) {\n                    let { circle: Tt, seenUids: Yt, overlapMode: Kt } = Xe, xr = this.boxCells[le];\n                    if (xr !== null) {\n                      let ve = this.bboxes;\n                      for (let be of xr) if (!Yt.box[be]) {\n                        Yt.box[be] = true;\n                        let De = 4 * be, Be = this.boxKeys[be];\n                        if (this._circleAndRectCollide(Tt.x, Tt.y, Tt.radius, ve[De + 0], ve[De + 1], ve[De + 2], ve[De + 3]) && (!ot || ot(Be)) && !Lr(Kt, Be.overlapMode)) return qe.push(true), true;\n                      }\n                    }\n                    let Ir = this.circleCells[le];\n                    if (Ir !== null) {\n                      let ve = this.circles;\n                      for (let be of Ir) if (!Yt.circle[be]) {\n                        Yt.circle[be] = true;\n                        let De = 3 * be, Be = this.circleKeys[be];\n                        if (this._circlesCollide(ve[De], ve[De + 1], ve[De + 2], Tt.x, Tt.y, Tt.radius) && (!ot || ot(Be)) && !Lr(Kt, Be.overlapMode)) return qe.push(true), true;\n                      }\n                    }\n                  }\n                  _forEachCell(w4, B4, Q, ee, le, qe, Xe, ot) {\n                    let Tt = this._convertToXCellCoord(w4), Yt = this._convertToYCellCoord(B4), Kt = this._convertToXCellCoord(Q), xr = this._convertToYCellCoord(ee);\n                    for (let Ir = Tt; Ir <= Kt; Ir++) for (let ve = Yt; ve <= xr; ve++) if (le.call(this, w4, B4, Q, ee, this.xCellCount * ve + Ir, qe, Xe, ot)) return;\n                  }\n                  _convertToXCellCoord(w4) {\n                    return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(w4 * this.xScale)));\n                  }\n                  _convertToYCellCoord(w4) {\n                    return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(w4 * this.yScale)));\n                  }\n                  _circlesCollide(w4, B4, Q, ee, le, qe) {\n                    let Xe = ee - w4, ot = le - B4, Tt = Q + qe;\n                    return Tt * Tt > Xe * Xe + ot * ot;\n                  }\n                  _circleAndRectCollide(w4, B4, Q, ee, le, qe, Xe) {\n                    let ot = (qe - ee) / 2, Tt = Math.abs(w4 - (ee + ot));\n                    if (Tt > ot + Q) return false;\n                    let Yt = (Xe - le) / 2, Kt = Math.abs(B4 - (le + Yt));\n                    if (Kt > Yt + Q) return false;\n                    if (Tt <= ot || Kt <= Yt) return true;\n                    let xr = Tt - ot, Ir = Kt - Yt;\n                    return xr * xr + Ir * Ir <= Q * Q;\n                  }\n                }\n                function Br(ue, w4, B4, Q, ee) {\n                  let le = a4.H();\n                  return w4 ? (a4.K(le, le, [1 / ee, 1 / ee, 1]), B4 || a4.ad(le, le, Q.angle)) : a4.L(le, Q.labelPlaneMatrix, ue), le;\n                }\n                function Vr(ue, w4, B4, Q, ee) {\n                  if (w4) {\n                    let le = a4.ae(ue);\n                    return a4.K(le, le, [ee, ee, 1]), B4 || a4.ad(le, le, -Q.angle), le;\n                  }\n                  return Q.glCoordMatrix;\n                }\n                function dt(ue, w4, B4, Q) {\n                  let ee;\n                  Q ? (ee = [ue, w4, Q(ue, w4), 1], a4.af(ee, ee, B4)) : (ee = [ue, w4, 0, 1], $r(ee, ee, B4));\n                  let le = ee[3];\n                  return { point: new a4.P(ee[0] / le, ee[1] / le), signedDistanceFromCamera: le, isOccluded: false };\n                }\n                function Ge(ue, w4) {\n                  return 0.5 + ue / w4 * 0.5;\n                }\n                function Je(ue, w4) {\n                  return ue.x >= -w4[0] && ue.x <= w4[0] && ue.y >= -w4[1] && ue.y <= w4[1];\n                }\n                function je(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir, ve) {\n                  let be = Q ? ue.textSizeData : ue.iconSizeData, De = a4.ag(be, B4.transform.zoom), Be = [256 / B4.width * 2 + 1, 256 / B4.height * 2 + 1], et = Q ? ue.text.dynamicLayoutVertexArray : ue.icon.dynamicLayoutVertexArray;\n                  et.clear();\n                  let We = ue.lineVertexArray, it = Q ? ue.text.placedSymbolArray : ue.icon.placedSymbolArray, Ft = B4.transform.width / B4.transform.height, Ht = false;\n                  for (let tr = 0; tr < it.length; tr++) {\n                    let dr = it.get(tr);\n                    if (dr.hidden || dr.writingMode === a4.ah.vertical && !Ht) {\n                      pi(dr.numGlyphs, et);\n                      continue;\n                    }\n                    Ht = false;\n                    let Sr = dt(dr.anchorX, dr.anchorY, w4, ve);\n                    if (!Je(Sr.point, Be)) {\n                      pi(dr.numGlyphs, et);\n                      continue;\n                    }\n                    let Or = Ge(B4.transform.cameraToCenterDistance, Sr.signedDistanceFromCamera), Wr = a4.ai(be, De, dr), ni = qe ? Wr / Or : Wr * Or, Pi = { getElevation: ve, labelPlaneMatrix: ee, lineVertexArray: We, pitchWithMap: qe, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: Tt, tileAnchorPoint: new a4.P(dr.anchorX, dr.anchorY), unwrappedTileID: Yt, width: Kt, height: xr, translation: Ir }, cn = Ie(Pi, dr, ni, false, Xe, w4, le, ue.glyphOffsetArray, et, Ft, ot);\n                    Ht = cn.useVertical, (cn.notEnoughRoom || Ht || cn.needsFlipping && Ie(Pi, dr, ni, true, Xe, w4, le, ue.glyphOffsetArray, et, Ft, ot).notEnoughRoom) && pi(dr.numGlyphs, et);\n                  }\n                  Q ? ue.text.dynamicLayoutVertexBuffer.updateData(et) : ue.icon.dynamicLayoutVertexBuffer.updateData(et);\n                }\n                function tt(ue, w4, B4, Q, ee, le, qe, Xe) {\n                  let ot = le.glyphStartIndex + le.numGlyphs, Tt = le.lineStartIndex, Yt = le.lineStartIndex + le.lineLength, Kt = w4.getoffsetX(le.glyphStartIndex), xr = w4.getoffsetX(ot - 1), Ir = vr(ue * Kt, B4, Q, ee, le.segment, Tt, Yt, Xe, qe);\n                  if (!Ir) return null;\n                  let ve = vr(ue * xr, B4, Q, ee, le.segment, Tt, Yt, Xe, qe);\n                  return ve ? Xe.projectionCache.anyProjectionOccluded ? null : { first: Ir, last: ve } : null;\n                }\n                function xt(ue, w4, B4, Q) {\n                  return ue === a4.ah.horizontal && Math.abs(B4.y - w4.y) > Math.abs(B4.x - w4.x) * Q ? { useVertical: true } : (ue === a4.ah.vertical ? w4.y < B4.y : w4.x > B4.x) ? { needsFlipping: true } : null;\n                }\n                function Ie(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt) {\n                  let Kt = B4 / 24, xr = w4.lineOffsetX * Kt, Ir = w4.lineOffsetY * Kt, ve;\n                  if (w4.numGlyphs > 1) {\n                    let be = w4.glyphStartIndex + w4.numGlyphs, De = w4.lineStartIndex, Be = w4.lineStartIndex + w4.lineLength, et = tt(Kt, Xe, xr, Ir, Q, w4, Yt, ue);\n                    if (!et) return { notEnoughRoom: true };\n                    let We = dt(et.first.point.x, et.first.point.y, qe, ue.getElevation).point, it = dt(et.last.point.x, et.last.point.y, qe, ue.getElevation).point;\n                    if (ee && !Q) {\n                      let Ft = xt(w4.writingMode, We, it, Tt);\n                      if (Ft) return Ft;\n                    }\n                    ve = [et.first];\n                    for (let Ft = w4.glyphStartIndex + 1; Ft < be - 1; Ft++) ve.push(vr(Kt * Xe.getoffsetX(Ft), xr, Ir, Q, w4.segment, De, Be, ue, Yt));\n                    ve.push(et.last);\n                  } else {\n                    if (ee && !Q) {\n                      let De = dt(ue.tileAnchorPoint.x, ue.tileAnchorPoint.y, le, ue.getElevation).point, Be = w4.lineStartIndex + w4.segment + 1, et = new a4.P(ue.lineVertexArray.getx(Be), ue.lineVertexArray.gety(Be)), We = dt(et.x, et.y, le, ue.getElevation), it = We.signedDistanceFromCamera > 0 ? We.point : (function(Ht, tr, dr, Sr, Or, Wr) {\n                        return xe(Ht, tr, dr, 1, Or, Wr);\n                      })(ue.tileAnchorPoint, et, De, 0, le, ue), Ft = xt(w4.writingMode, De, it, Tt);\n                      if (Ft) return Ft;\n                    }\n                    let be = vr(Kt * Xe.getoffsetX(w4.glyphStartIndex), xr, Ir, Q, w4.segment, w4.lineStartIndex, w4.lineStartIndex + w4.lineLength, ue, Yt);\n                    if (!be || ue.projectionCache.anyProjectionOccluded) return { notEnoughRoom: true };\n                    ve = [be];\n                  }\n                  for (let be of ve) a4.aj(ot, be.point, be.angle);\n                  return {};\n                }\n                function xe(ue, w4, B4, Q, ee, le) {\n                  let qe = ue.add(ue.sub(w4)._unit()), Xe = ee !== void 0 ? dt(qe.x, qe.y, ee, le.getElevation).point : vt(qe.x, qe.y, le).point, ot = B4.sub(Xe);\n                  return B4.add(ot._mult(Q / ot.mag()));\n                }\n                function ke(ue, w4, B4) {\n                  let Q = w4.projectionCache;\n                  if (Q.projections[ue]) return Q.projections[ue];\n                  let ee = new a4.P(w4.lineVertexArray.getx(ue), w4.lineVertexArray.gety(ue)), le = vt(ee.x, ee.y, w4);\n                  if (le.signedDistanceFromCamera > 0) return Q.projections[ue] = le.point, Q.anyProjectionOccluded = Q.anyProjectionOccluded || le.isOccluded, le.point;\n                  let qe = ue - B4.direction;\n                  return (function(Xe, ot, Tt, Yt, Kt) {\n                    return xe(Xe, ot, Tt, Yt, void 0, Kt);\n                  })(B4.distanceFromAnchor === 0 ? w4.tileAnchorPoint : new a4.P(w4.lineVertexArray.getx(qe), w4.lineVertexArray.gety(qe)), ee, B4.previousVertex, B4.absOffsetX - B4.distanceFromAnchor + 1, w4);\n                }\n                function vt(ue, w4, B4) {\n                  let Q = ue + B4.translation[0], ee = w4 + B4.translation[1], le;\n                  return !B4.pitchWithMap && B4.projection.useSpecialProjectionForSymbols ? (le = B4.projection.projectTileCoordinates(Q, ee, B4.unwrappedTileID, B4.getElevation), le.point.x = (0.5 * le.point.x + 0.5) * B4.width, le.point.y = (0.5 * -le.point.y + 0.5) * B4.height) : (le = dt(Q, ee, B4.labelPlaneMatrix, B4.getElevation), le.isOccluded = false), le;\n                }\n                function ir(ue, w4, B4) {\n                  return ue._unit()._perp()._mult(w4 * B4);\n                }\n                function ar(ue, w4, B4, Q, ee, le, qe, Xe, ot) {\n                  if (Xe.projectionCache.offsets[ue]) return Xe.projectionCache.offsets[ue];\n                  let Tt = B4.add(w4);\n                  if (ue + ot.direction < Q || ue + ot.direction >= ee) return Xe.projectionCache.offsets[ue] = Tt, Tt;\n                  let Yt = ke(ue + ot.direction, Xe, ot), Kt = ir(Yt.sub(B4), qe, ot.direction), xr = B4.add(Kt), Ir = Yt.add(Kt);\n                  return Xe.projectionCache.offsets[ue] = a4.ak(le, Tt, xr, Ir) || Tt, Xe.projectionCache.offsets[ue];\n                }\n                function vr(ue, w4, B4, Q, ee, le, qe, Xe, ot) {\n                  let Tt = Q ? ue - w4 : ue + w4, Yt = Tt > 0 ? 1 : -1, Kt = 0;\n                  Q && (Yt *= -1, Kt = Math.PI), Yt < 0 && (Kt += Math.PI);\n                  let xr, Ir = Yt > 0 ? le + ee : le + ee + 1;\n                  Xe.projectionCache.cachedAnchorPoint ? xr = Xe.projectionCache.cachedAnchorPoint : (xr = vt(Xe.tileAnchorPoint.x, Xe.tileAnchorPoint.y, Xe).point, Xe.projectionCache.cachedAnchorPoint = xr);\n                  let ve, be, De = xr, Be = xr, et = 0, We = 0, it = Math.abs(Tt), Ft = [], Ht;\n                  for (; et + We <= it; ) {\n                    if (Ir += Yt, Ir < le || Ir >= qe) return null;\n                    et += We, Be = De, be = ve;\n                    let Sr = { absOffsetX: it, direction: Yt, distanceFromAnchor: et, previousVertex: Be };\n                    if (De = ke(Ir, Xe, Sr), B4 === 0) Ft.push(Be), Ht = De.sub(Be);\n                    else {\n                      let Or, Wr = De.sub(Be);\n                      Or = Wr.mag() === 0 ? ir(ke(Ir + Yt, Xe, Sr).sub(De), B4, Yt) : ir(Wr, B4, Yt), be || (be = Be.add(Or)), ve = ar(Ir, Or, De, le, qe, be, B4, Xe, Sr), Ft.push(be), Ht = ve.sub(be);\n                    }\n                    We = Ht.mag();\n                  }\n                  let tr = Ht._mult((it - et) / We)._add(be || Be), dr = Kt + Math.atan2(De.y - Be.y, De.x - Be.x);\n                  return Ft.push(tr), { point: tr, angle: ot ? dr : 0, path: Ft };\n                }\n                let ii = new Float32Array([-1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0, -1 / 0, -1 / 0, 0]);\n                function pi(ue, w4) {\n                  for (let B4 = 0; B4 < ue; B4++) {\n                    let Q = w4.length;\n                    w4.resize(Q + 4), w4.float32.set(ii, 3 * Q);\n                  }\n                }\n                function $r(ue, w4, B4) {\n                  let Q = w4[0], ee = w4[1];\n                  return ue[0] = B4[0] * Q + B4[4] * ee + B4[12], ue[1] = B4[1] * Q + B4[5] * ee + B4[13], ue[3] = B4[3] * Q + B4[7] * ee + B4[15], ue;\n                }\n                let di = 100;\n                class ji {\n                  constructor(w4, B4, Q = new ti(w4.width + 200, w4.height + 200, 25), ee = new ti(w4.width + 200, w4.height + 200, 25)) {\n                    this.transform = w4, this.mapProjection = B4, this.grid = Q, this.ignoredGrid = ee, this.pitchFactor = Math.cos(w4._pitch) * w4.cameraToCenterDistance, this.screenRightBoundary = w4.width + di, this.screenBottomBoundary = w4.height + di, this.gridRightBoundary = w4.width + 200, this.gridBottomBoundary = w4.height + 200, this.perspectiveRatioCutoff = 0.6;\n                  }\n                  placeCollisionBox(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt) {\n                    let xr = w4.anchorPointX + ot[0], Ir = w4.anchorPointY + ot[1], ve = this.projectAndGetPerspectiveRatio(ee, xr, Ir, le, Yt), be = Q * ve.perspectiveRatio, De;\n                    if (qe || Xe) De = this._projectCollisionBox(w4, be, ee, le, qe, Xe, ot, ve, Yt, Kt);\n                    else {\n                      let Ft = ve.point.x + (Kt ? Kt.x * be : 0), Ht = ve.point.y + (Kt ? Kt.y * be : 0);\n                      De = { allPointsOccluded: false, box: [Ft + w4.x1 * be, Ht + w4.y1 * be, Ft + w4.x2 * be, Ht + w4.y2 * be] };\n                    }\n                    let [Be, et, We, it] = De.box;\n                    return this.mapProjection.useSpecialProjectionForSymbols && (qe ? De.allPointsOccluded : this.mapProjection.isOccluded(xr, Ir, le)) || ve.perspectiveRatio < this.perspectiveRatioCutoff || !this.isInsideGrid(Be, et, We, it) || B4 !== "always" && this.grid.hitTest(Be, et, We, it, B4, Tt) ? { box: [Be, et, We, it], placeable: false, offscreen: false } : { box: [Be, et, We, it], placeable: true, offscreen: this.isOffscreen(Be, et, We, it) };\n                  }\n                  placeCollisionCircles(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir, ve, be, De) {\n                    let Be = [], et = new a4.P(B4.anchorX, B4.anchorY), We = this.getPerspectiveRatio(qe, et.x, et.y, Xe, De), it = (Kt ? le / We : le * We) / a4.ap, Ft = { getElevation: De, labelPlaneMatrix: ot, lineVertexArray: Q, pitchWithMap: Kt, projectionCache: { projections: {}, offsets: {}, cachedAnchorPoint: void 0, anyProjectionOccluded: false }, projection: this.mapProjection, tileAnchorPoint: et, unwrappedTileID: Xe, width: this.transform.width, height: this.transform.height, translation: be }, Ht = tt(it, ee, B4.lineOffsetX * it, B4.lineOffsetY * it, false, B4, false, Ft), tr = false, dr = false, Sr = true;\n                    if (Ht) {\n                      let Or = 0.5 * Ir * We + ve, Wr = new a4.P(-100, -100), ni = new a4.P(this.screenRightBoundary, this.screenBottomBoundary), Pi = new Tr(), cn = Ht.first, ln = Ht.last, Cn = [];\n                      for (let fa = cn.path.length - 1; fa >= 1; fa--) Cn.push(cn.path[fa]);\n                      for (let fa = 1; fa < ln.path.length; fa++) Cn.push(ln.path[fa]);\n                      let Kn = 2.5 * Or;\n                      if (Tt) {\n                        let fa = this.projectPathToScreenSpace(Cn, Ft, Tt);\n                        Cn = fa.some(($a) => $a.signedDistanceFromCamera <= 0) ? [] : fa.map(($a) => $a.point);\n                      }\n                      let Ta = [];\n                      if (Cn.length > 0) {\n                        let fa = Cn[0].clone(), $a = Cn[0].clone();\n                        for (let Co = 1; Co < Cn.length; Co++) fa.x = Math.min(fa.x, Cn[Co].x), fa.y = Math.min(fa.y, Cn[Co].y), $a.x = Math.max($a.x, Cn[Co].x), $a.y = Math.max($a.y, Cn[Co].y);\n                        Ta = fa.x >= Wr.x && $a.x <= ni.x && fa.y >= Wr.y && $a.y <= ni.y ? [Cn] : $a.x < Wr.x || fa.x > ni.x || $a.y < Wr.y || fa.y > ni.y ? [] : a4.al([Cn], Wr.x, Wr.y, ni.x, ni.y);\n                      }\n                      for (let fa of Ta) {\n                        Pi.reset(fa, 0.25 * Or);\n                        let $a = 0;\n                        $a = Pi.length <= 0.5 * Or ? 1 : Math.ceil(Pi.paddedLength / Kn) + 1;\n                        for (let Co = 0; Co < $a; Co++) {\n                          let Qa = Co / Math.max($a - 1, 1), mo = Pi.lerp(Qa), Bo = mo.x + di, Ps = mo.y + di;\n                          Be.push(Bo, Ps, Or, 0);\n                          let Ts = Bo - Or, wo = Ps - Or, To = Bo + Or, hl = Ps + Or;\n                          if (Sr = Sr && this.isOffscreen(Ts, wo, To, hl), dr = dr || this.isInsideGrid(Ts, wo, To, hl), w4 !== "always" && this.grid.hitTestCircle(Bo, Ps, Or, w4, xr) && (tr = true, !Yt)) return { circles: [], offscreen: false, collisionDetected: tr };\n                        }\n                      }\n                    }\n                    return { circles: !Yt && tr || !dr || We < this.perspectiveRatioCutoff ? [] : Be, offscreen: Sr, collisionDetected: tr };\n                  }\n                  projectPathToScreenSpace(w4, B4, Q) {\n                    return w4.map((ee) => dt(ee.x, ee.y, Q, B4.getElevation));\n                  }\n                  queryRenderedSymbols(w4) {\n                    if (w4.length === 0 || this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0) return {};\n                    let B4 = [], Q = 1 / 0, ee = 1 / 0, le = -1 / 0, qe = -1 / 0;\n                    for (let Yt of w4) {\n                      let Kt = new a4.P(Yt.x + di, Yt.y + di);\n                      Q = Math.min(Q, Kt.x), ee = Math.min(ee, Kt.y), le = Math.max(le, Kt.x), qe = Math.max(qe, Kt.y), B4.push(Kt);\n                    }\n                    let Xe = this.grid.query(Q, ee, le, qe).concat(this.ignoredGrid.query(Q, ee, le, qe)), ot = {}, Tt = {};\n                    for (let Yt of Xe) {\n                      let Kt = Yt.key;\n                      if (ot[Kt.bucketInstanceId] === void 0 && (ot[Kt.bucketInstanceId] = {}), ot[Kt.bucketInstanceId][Kt.featureIndex]) continue;\n                      let xr = [new a4.P(Yt.x1, Yt.y1), new a4.P(Yt.x2, Yt.y1), new a4.P(Yt.x2, Yt.y2), new a4.P(Yt.x1, Yt.y2)];\n                      a4.am(B4, xr) && (ot[Kt.bucketInstanceId][Kt.featureIndex] = true, Tt[Kt.bucketInstanceId] === void 0 && (Tt[Kt.bucketInstanceId] = []), Tt[Kt.bucketInstanceId].push(Kt.featureIndex));\n                    }\n                    return Tt;\n                  }\n                  insertCollisionBox(w4, B4, Q, ee, le, qe) {\n                    (Q ? this.ignoredGrid : this.grid).insert({ bucketInstanceId: ee, featureIndex: le, collisionGroupID: qe, overlapMode: B4 }, w4[0], w4[1], w4[2], w4[3]);\n                  }\n                  insertCollisionCircles(w4, B4, Q, ee, le, qe) {\n                    let Xe = Q ? this.ignoredGrid : this.grid, ot = { bucketInstanceId: ee, featureIndex: le, collisionGroupID: qe, overlapMode: B4 };\n                    for (let Tt = 0; Tt < w4.length; Tt += 4) Xe.insertCircle(ot, w4[Tt], w4[Tt + 1], w4[Tt + 2]);\n                  }\n                  projectAndGetPerspectiveRatio(w4, B4, Q, ee, le) {\n                    let qe;\n                    le ? (qe = [B4, Q, le(B4, Q), 1], a4.af(qe, qe, w4)) : (qe = [B4, Q, 0, 1], $r(qe, qe, w4));\n                    let Xe = qe[3];\n                    return { point: new a4.P((qe[0] / Xe + 1) / 2 * this.transform.width + di, (-qe[1] / Xe + 1) / 2 * this.transform.height + di), perspectiveRatio: 0.5 + this.transform.cameraToCenterDistance / Xe * 0.5, isOccluded: false, signedDistanceFromCamera: Xe };\n                  }\n                  getPerspectiveRatio(w4, B4, Q, ee, le) {\n                    let qe = this.mapProjection.useSpecialProjectionForSymbols ? this.mapProjection.projectTileCoordinates(B4, Q, ee, le) : dt(B4, Q, w4, le);\n                    return 0.5 + this.transform.cameraToCenterDistance / qe.signedDistanceFromCamera * 0.5;\n                  }\n                  isOffscreen(w4, B4, Q, ee) {\n                    return Q < di || w4 >= this.screenRightBoundary || ee < di || B4 > this.screenBottomBoundary;\n                  }\n                  isInsideGrid(w4, B4, Q, ee) {\n                    return Q >= 0 && w4 < this.gridRightBoundary && ee >= 0 && B4 < this.gridBottomBoundary;\n                  }\n                  getViewportMatrix() {\n                    let w4 = a4.an([]);\n                    return a4.J(w4, w4, [-100, -100, 0]), w4;\n                  }\n                  _projectCollisionBox(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt) {\n                    let Kt = new a4.P(1, 0), xr = new a4.P(0, 1), Ir = new a4.P(w4.anchorPointX + Xe[0], w4.anchorPointY + Xe[1]);\n                    if (qe && !le) {\n                      let Sr = this.projectAndGetPerspectiveRatio(Q, Ir.x + 1, Ir.y, ee, Tt).point.sub(ot.point).unit(), Or = Math.atan(Sr.y / Sr.x) + (Sr.x < 0 ? Math.PI : 0), Wr = Math.sin(Or), ni = Math.cos(Or);\n                      Kt = new a4.P(ni, Wr), xr = new a4.P(-Wr, ni);\n                    } else if (!qe && le) {\n                      let Sr = -this.transform.angle, Or = Math.sin(Sr), Wr = Math.cos(Sr);\n                      Kt = new a4.P(Wr, Or), xr = new a4.P(-Or, Wr);\n                    }\n                    let ve = ot.point, be = B4;\n                    if (le) {\n                      ve = Ir;\n                      let Sr = this.transform.zoom - Math.floor(this.transform.zoom);\n                      be = Math.pow(2, -Sr), be *= this.mapProjection.getPitchedTextCorrection(this.transform, Ir, ee), Yt || (be *= a4.ac(0.5 + ot.signedDistanceFromCamera / this.transform.cameraToCenterDistance * 0.5, 0, 4));\n                    }\n                    Yt && (ve = ve.add(Kt.mult(Yt.x * be)).add(xr.mult(Yt.y * be)));\n                    let De = w4.x1 * be, Be = w4.x2 * be, et = (De + Be) / 2, We = w4.y1 * be, it = w4.y2 * be, Ft = (We + it) / 2, Ht = [{ offsetX: De, offsetY: We }, { offsetX: et, offsetY: We }, { offsetX: Be, offsetY: We }, { offsetX: Be, offsetY: Ft }, { offsetX: Be, offsetY: it }, { offsetX: et, offsetY: it }, { offsetX: De, offsetY: it }, { offsetX: De, offsetY: Ft }], tr = [];\n                    for (let { offsetX: Sr, offsetY: Or } of Ht) tr.push(new a4.P(ve.x + Kt.x * Sr + xr.x * Or, ve.y + Kt.y * Sr + xr.y * Or));\n                    let dr = false;\n                    if (le) {\n                      let Sr = tr.map((Or) => this.projectAndGetPerspectiveRatio(Q, Or.x, Or.y, ee, Tt));\n                      dr = Sr.some((Or) => !Or.isOccluded), tr = Sr.map((Or) => Or.point);\n                    } else dr = true;\n                    return { box: a4.ao(tr), allPointsOccluded: !dr };\n                  }\n                }\n                function In(ue, w4, B4) {\n                  return w4 * (a4.X / (ue.tileSize * Math.pow(2, B4 - ue.tileID.overscaledZ)));\n                }\n                class wi {\n                  constructor(w4, B4, Q, ee) {\n                    this.opacity = w4 ? Math.max(0, Math.min(1, w4.opacity + (w4.placed ? B4 : -B4))) : ee && Q ? 1 : 0, this.placed = Q;\n                  }\n                  isHidden() {\n                    return this.opacity === 0 && !this.placed;\n                  }\n                }\n                class On {\n                  constructor(w4, B4, Q, ee, le) {\n                    this.text = new wi(w4 ? w4.text : null, B4, Q, le), this.icon = new wi(w4 ? w4.icon : null, B4, ee, le);\n                  }\n                  isHidden() {\n                    return this.text.isHidden() && this.icon.isHidden();\n                  }\n                }\n                class qn {\n                  constructor(w4, B4, Q) {\n                    this.text = w4, this.icon = B4, this.skipFade = Q;\n                  }\n                }\n                class Fn {\n                  constructor() {\n                    this.invProjMatrix = a4.H(), this.viewportMatrix = a4.H(), this.circles = [];\n                  }\n                }\n                class ra {\n                  constructor(w4, B4, Q, ee, le) {\n                    this.bucketInstanceId = w4, this.featureIndex = B4, this.sourceLayerIndex = Q, this.bucketIndex = ee, this.tileID = le;\n                  }\n                }\n                class la {\n                  constructor(w4) {\n                    this.crossSourceCollisions = w4, this.maxGroupID = 0, this.collisionGroups = {};\n                  }\n                  get(w4) {\n                    if (this.crossSourceCollisions) return { ID: 0, predicate: null };\n                    if (!this.collisionGroups[w4]) {\n                      let B4 = ++this.maxGroupID;\n                      this.collisionGroups[w4] = { ID: B4, predicate: (Q) => Q.collisionGroupID === B4 };\n                    }\n                    return this.collisionGroups[w4];\n                  }\n                }\n                function Ut(ue, w4, B4, Q, ee) {\n                  let { horizontalAlign: le, verticalAlign: qe } = a4.au(ue);\n                  return new a4.P(-(le - 0.5) * w4 + Q[0] * ee, -(qe - 0.5) * B4 + Q[1] * ee);\n                }\n                class wt {\n                  constructor(w4, B4, Q, ee, le, qe) {\n                    this.transform = w4.clone(), this.terrain = Q, this.collisionIndex = new ji(this.transform, B4), this.placements = {}, this.opacities = {}, this.variableOffsets = {}, this.stale = false, this.commitTime = 0, this.fadeDuration = ee, this.retainedQueryData = {}, this.collisionGroups = new la(le), this.collisionCircleArrays = {}, this.collisionBoxArrays = /* @__PURE__ */ new Map(), this.prevPlacement = qe, qe && (qe.prevPlacement = void 0), this.placedOrientations = {};\n                  }\n                  _getTerrainElevationFunc(w4) {\n                    let B4 = this.terrain;\n                    return B4 ? (Q, ee) => B4.getElevation(w4, Q, ee) : null;\n                  }\n                  getBucketParts(w4, B4, Q, ee) {\n                    let le = Q.getBucket(B4), qe = Q.latestFeatureIndex;\n                    if (!le || !qe || B4.id !== le.layerIds[0]) return;\n                    let Xe = Q.collisionBoxArray, ot = le.layers[0].layout, Tt = le.layers[0].paint, Yt = Math.pow(2, this.transform.zoom - Q.tileID.overscaledZ), Kt = Q.tileSize / a4.X, xr = Q.tileID.toUnwrapped(), Ir = this.transform.calculatePosMatrix(xr), ve = ot.get("text-pitch-alignment") === "map", be = ot.get("text-rotation-alignment") === "map", De = In(Q, 1, this.transform.zoom), Be = this.collisionIndex.mapProjection.translatePosition(this.transform, Q, Tt.get("text-translate"), Tt.get("text-translate-anchor")), et = this.collisionIndex.mapProjection.translatePosition(this.transform, Q, Tt.get("icon-translate"), Tt.get("icon-translate-anchor")), We = Br(Ir, ve, be, this.transform, De), it = null;\n                    if (ve) {\n                      let Ht = Vr(Ir, ve, be, this.transform, De);\n                      it = a4.L([], this.transform.labelPlaneMatrix, Ht);\n                    }\n                    this.retainedQueryData[le.bucketInstanceId] = new ra(le.bucketInstanceId, qe, le.sourceLayerIndex, le.index, Q.tileID);\n                    let Ft = { bucket: le, layout: ot, translationText: Be, translationIcon: et, posMatrix: Ir, unwrappedTileID: xr, textLabelPlaneMatrix: We, labelToScreenMatrix: it, scale: Yt, textPixelRatio: Kt, holdingForFade: Q.holdingForFade(), collisionBoxArray: Xe, partiallyEvaluatedTextSize: a4.ag(le.textSizeData, this.transform.zoom), collisionGroup: this.collisionGroups.get(le.sourceID) };\n                    if (ee) for (let Ht of le.sortKeyRanges) {\n                      let { sortKey: tr, symbolInstanceStart: dr, symbolInstanceEnd: Sr } = Ht;\n                      w4.push({ sortKey: tr, symbolInstanceStart: dr, symbolInstanceEnd: Sr, parameters: Ft });\n                    }\n                    else w4.push({ symbolInstanceStart: 0, symbolInstanceEnd: le.symbolInstances.length, parameters: Ft });\n                  }\n                  attemptAnchorPlacement(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir, ve, be, De, Be, et, We) {\n                    let it = a4.aq[w4.textAnchor], Ft = [w4.textOffset0, w4.textOffset1], Ht = Ut(it, Q, ee, Ft, le), tr = this.collisionIndex.placeCollisionBox(B4, xr, ot, Tt, Yt, Xe, qe, De, Kt.predicate, We, Ht);\n                    if ((!et || this.collisionIndex.placeCollisionBox(et, xr, ot, Tt, Yt, Xe, qe, Be, Kt.predicate, We, Ht).placeable) && tr.placeable) {\n                      let dr;\n                      if (this.prevPlacement && this.prevPlacement.variableOffsets[Ir.crossTileID] && this.prevPlacement.placements[Ir.crossTileID] && this.prevPlacement.placements[Ir.crossTileID].text && (dr = this.prevPlacement.variableOffsets[Ir.crossTileID].anchor), Ir.crossTileID === 0) throw new Error("symbolInstance.crossTileID can\'t be 0");\n                      return this.variableOffsets[Ir.crossTileID] = { textOffset: Ft, width: Q, height: ee, anchor: it, textBoxScale: le, prevAnchor: dr }, this.markUsedJustification(ve, it, Ir, be), ve.allowVerticalPlacement && (this.markUsedOrientation(ve, be, Ir), this.placedOrientations[Ir.crossTileID] = be), { shift: Ht, placedGlyphBoxes: tr };\n                    }\n                  }\n                  placeLayerBucketPart(w4, B4, Q) {\n                    let { bucket: ee, layout: le, translationText: qe, translationIcon: Xe, posMatrix: ot, unwrappedTileID: Tt, textLabelPlaneMatrix: Yt, labelToScreenMatrix: Kt, textPixelRatio: xr, holdingForFade: Ir, collisionBoxArray: ve, partiallyEvaluatedTextSize: be, collisionGroup: De } = w4.parameters, Be = le.get("text-optional"), et = le.get("icon-optional"), We = a4.ar(le, "text-overlap", "text-allow-overlap"), it = We === "always", Ft = a4.ar(le, "icon-overlap", "icon-allow-overlap"), Ht = Ft === "always", tr = le.get("text-rotation-alignment") === "map", dr = le.get("text-pitch-alignment") === "map", Sr = le.get("icon-text-fit") !== "none", Or = le.get("symbol-z-order") === "viewport-y", Wr = it && (Ht || !ee.hasIconData() || et), ni = Ht && (it || !ee.hasTextData() || Be);\n                    !ee.collisionArrays && ve && ee.deserializeCollisionBoxes(ve);\n                    let Pi = this._getTerrainElevationFunc(this.retainedQueryData[ee.bucketInstanceId].tileID), cn = (ln, Cn, Kn) => {\n                      var Ta, fa;\n                      if (B4[ln.crossTileID]) return;\n                      if (Ir) return void (this.placements[ln.crossTileID] = new qn(false, false, false));\n                      let $a = false, Co = false, Qa = true, mo = null, Bo = { box: null, placeable: false, offscreen: null }, Ps = { box: null, placeable: false, offscreen: null }, Ts = null, wo = null, To = null, hl = 0, Ul = 0, Lu = 0;\n                      Cn.textFeatureIndex ? hl = Cn.textFeatureIndex : ln.useRuntimeCollisionCircles && (hl = ln.featureIndex), Cn.verticalTextFeatureIndex && (Ul = Cn.verticalTextFeatureIndex);\n                      let au = Cn.textBox;\n                      if (au) {\n                        let Tl = (Te) => {\n                          let Ne = a4.ah.horizontal;\n                          if (ee.allowVerticalPlacement && !Te && this.prevPlacement) {\n                            let He = this.prevPlacement.placedOrientations[ln.crossTileID];\n                            He && (this.placedOrientations[ln.crossTileID] = He, Ne = He, this.markUsedOrientation(ee, Ne, ln));\n                          }\n                          return Ne;\n                        }, Al = (Te, Ne) => {\n                          if (ee.allowVerticalPlacement && ln.numVerticalGlyphVertices > 0 && Cn.verticalTextBox) {\n                            for (let He of ee.writingModes) if (He === a4.ah.vertical ? (Bo = Ne(), Ps = Bo) : Bo = Te(), Bo && Bo.placeable) break;\n                          } else Bo = Te();\n                        }, X = ln.textAnchorOffsetStartIndex, se = ln.textAnchorOffsetEndIndex;\n                        if (se === X) {\n                          let Te = (Ne, He) => {\n                            let Ye = this.collisionIndex.placeCollisionBox(Ne, We, xr, ot, Tt, dr, tr, qe, De.predicate, Pi);\n                            return Ye && Ye.placeable && (this.markUsedOrientation(ee, He, ln), this.placedOrientations[ln.crossTileID] = He), Ye;\n                          };\n                          Al(() => Te(au, a4.ah.horizontal), () => {\n                            let Ne = Cn.verticalTextBox;\n                            return ee.allowVerticalPlacement && ln.numVerticalGlyphVertices > 0 && Ne ? Te(Ne, a4.ah.vertical) : { box: null, offscreen: null };\n                          }), Tl(Bo && Bo.placeable);\n                        } else {\n                          let Te = a4.aq[(fa = (Ta = this.prevPlacement) === null || Ta === void 0 ? void 0 : Ta.variableOffsets[ln.crossTileID]) === null || fa === void 0 ? void 0 : fa.anchor], Ne = (Ye, kt, nt) => {\n                            let jt = Ye.x2 - Ye.x1, gr = Ye.y2 - Ye.y1, yr = ln.textBoxScale, Hr = Sr && Ft === "never" ? kt : null, qr = null, _i = We === "never" ? 1 : 2, bi = "never";\n                            Te && _i++;\n                            for (let Zr = 0; Zr < _i; Zr++) {\n                              for (let ai = X; ai < se; ai++) {\n                                let gi = ee.textAnchorOffsets.get(ai);\n                                if (Te && gi.textAnchor !== Te) continue;\n                                let Ii = this.attemptAnchorPlacement(gi, Ye, jt, gr, yr, tr, dr, xr, ot, Tt, De, bi, ln, ee, nt, qe, Xe, Hr, Pi);\n                                if (Ii && (qr = Ii.placedGlyphBoxes, qr && qr.placeable)) return $a = true, mo = Ii.shift, qr;\n                              }\n                              Te ? Te = null : bi = We;\n                            }\n                            return Q && !qr && (qr = { box: this.collisionIndex.placeCollisionBox(au, "always", xr, ot, Tt, dr, tr, qe, De.predicate, Pi, new a4.P(0, 0)).box, offscreen: false, placeable: false }), qr;\n                          };\n                          Al(() => Ne(au, Cn.iconBox, a4.ah.horizontal), () => {\n                            let Ye = Cn.verticalTextBox;\n                            return ee.allowVerticalPlacement && (!Bo || !Bo.placeable) && ln.numVerticalGlyphVertices > 0 && Ye ? Ne(Ye, Cn.verticalIconBox, a4.ah.vertical) : { box: null, occluded: true, offscreen: null };\n                          }), Bo && ($a = Bo.placeable, Qa = Bo.offscreen);\n                          let He = Tl(Bo && Bo.placeable);\n                          if (!$a && this.prevPlacement) {\n                            let Ye = this.prevPlacement.variableOffsets[ln.crossTileID];\n                            Ye && (this.variableOffsets[ln.crossTileID] = Ye, this.markUsedJustification(ee, Ye.anchor, ln, He));\n                          }\n                        }\n                      }\n                      if (Ts = Bo, $a = Ts && Ts.placeable, Qa = Ts && Ts.offscreen, ln.useRuntimeCollisionCircles) {\n                        let Tl = ee.text.placedSymbolArray.get(ln.centerJustifiedTextSymbolIndex), Al = a4.ai(ee.textSizeData, be, Tl), X = le.get("text-padding");\n                        wo = this.collisionIndex.placeCollisionCircles(We, Tl, ee.lineVertexArray, ee.glyphOffsetArray, Al, ot, Tt, Yt, Kt, Q, dr, De.predicate, ln.collisionCircleDiameter, X, qe, Pi), wo.circles.length && wo.collisionDetected && !Q && a4.w("Collisions detected, but collision boxes are not shown"), $a = it || wo.circles.length > 0 && !wo.collisionDetected, Qa = Qa && wo.offscreen;\n                      }\n                      if (Cn.iconFeatureIndex && (Lu = Cn.iconFeatureIndex), Cn.iconBox) {\n                        let Tl = (Al) => this.collisionIndex.placeCollisionBox(Al, Ft, xr, ot, Tt, dr, tr, Xe, De.predicate, Pi, Sr && mo ? mo : void 0);\n                        Ps && Ps.placeable && Cn.verticalIconBox ? (To = Tl(Cn.verticalIconBox), Co = To.placeable) : (To = Tl(Cn.iconBox), Co = To.placeable), Qa = Qa && To.offscreen;\n                      }\n                      let Js = Be || ln.numHorizontalGlyphVertices === 0 && ln.numVerticalGlyphVertices === 0, Ql = et || ln.numIconVertices === 0;\n                      Js || Ql ? Ql ? Js || (Co = Co && $a) : $a = Co && $a : Co = $a = Co && $a;\n                      let dc = Co && To.placeable;\n                      if ($a && Ts.placeable && this.collisionIndex.insertCollisionBox(Ts.box, We, le.get("text-ignore-placement"), ee.bucketInstanceId, Ps && Ps.placeable && Ul ? Ul : hl, De.ID), dc && this.collisionIndex.insertCollisionBox(To.box, Ft, le.get("icon-ignore-placement"), ee.bucketInstanceId, Lu, De.ID), wo && $a && this.collisionIndex.insertCollisionCircles(wo.circles, We, le.get("text-ignore-placement"), ee.bucketInstanceId, hl, De.ID), Q && this.storeCollisionData(ee.bucketInstanceId, Kn, Cn, Ts, To, wo), ln.crossTileID === 0) throw new Error("symbolInstance.crossTileID can\'t be 0");\n                      if (ee.bucketInstanceId === 0) throw new Error("bucket.bucketInstanceId can\'t be 0");\n                      this.placements[ln.crossTileID] = new qn($a || Wr, Co || ni, Qa || ee.justReloaded), B4[ln.crossTileID] = true;\n                    };\n                    if (Or) {\n                      if (w4.symbolInstanceStart !== 0) throw new Error("bucket.bucketInstanceId should be 0");\n                      let ln = ee.getSortedSymbolIndexes(this.transform.angle);\n                      for (let Cn = ln.length - 1; Cn >= 0; --Cn) {\n                        let Kn = ln[Cn];\n                        cn(ee.symbolInstances.get(Kn), ee.collisionArrays[Kn], Kn);\n                      }\n                    } else for (let ln = w4.symbolInstanceStart; ln < w4.symbolInstanceEnd; ln++) cn(ee.symbolInstances.get(ln), ee.collisionArrays[ln], ln);\n                    if (Q && ee.bucketInstanceId in this.collisionCircleArrays) {\n                      let ln = this.collisionCircleArrays[ee.bucketInstanceId];\n                      a4.as(ln.invProjMatrix, ot), ln.viewportMatrix = this.collisionIndex.getViewportMatrix();\n                    }\n                    ee.justReloaded = false;\n                  }\n                  storeCollisionData(w4, B4, Q, ee, le, qe) {\n                    if (Q.textBox || Q.iconBox) {\n                      let Xe, ot;\n                      this.collisionBoxArrays.has(w4) ? Xe = this.collisionBoxArrays.get(w4) : (Xe = /* @__PURE__ */ new Map(), this.collisionBoxArrays.set(w4, Xe)), Xe.has(B4) ? ot = Xe.get(B4) : (ot = { text: null, icon: null }, Xe.set(B4, ot)), Q.textBox && (ot.text = ee.box), Q.iconBox && (ot.icon = le.box);\n                    }\n                    if (qe) {\n                      let Xe = this.collisionCircleArrays[w4];\n                      Xe === void 0 && (Xe = this.collisionCircleArrays[w4] = new Fn());\n                      for (let ot = 0; ot < qe.circles.length; ot += 4) Xe.circles.push(qe.circles[ot + 0]), Xe.circles.push(qe.circles[ot + 1]), Xe.circles.push(qe.circles[ot + 2]), Xe.circles.push(qe.collisionDetected ? 1 : 0);\n                    }\n                  }\n                  markUsedJustification(w4, B4, Q, ee) {\n                    let le;\n                    le = ee === a4.ah.vertical ? Q.verticalPlacedTextSymbolIndex : { left: Q.leftJustifiedTextSymbolIndex, center: Q.centerJustifiedTextSymbolIndex, right: Q.rightJustifiedTextSymbolIndex }[a4.at(B4)];\n                    let qe = [Q.leftJustifiedTextSymbolIndex, Q.centerJustifiedTextSymbolIndex, Q.rightJustifiedTextSymbolIndex, Q.verticalPlacedTextSymbolIndex];\n                    for (let Xe of qe) Xe >= 0 && (w4.text.placedSymbolArray.get(Xe).crossTileID = le >= 0 && Xe !== le ? 0 : Q.crossTileID);\n                  }\n                  markUsedOrientation(w4, B4, Q) {\n                    let ee = B4 === a4.ah.horizontal || B4 === a4.ah.horizontalOnly ? B4 : 0, le = B4 === a4.ah.vertical ? B4 : 0, qe = [Q.leftJustifiedTextSymbolIndex, Q.centerJustifiedTextSymbolIndex, Q.rightJustifiedTextSymbolIndex];\n                    for (let Xe of qe) w4.text.placedSymbolArray.get(Xe).placedOrientation = ee;\n                    Q.verticalPlacedTextSymbolIndex && (w4.text.placedSymbolArray.get(Q.verticalPlacedTextSymbolIndex).placedOrientation = le);\n                  }\n                  commit(w4) {\n                    this.commitTime = w4, this.zoomAtLastRecencyCheck = this.transform.zoom;\n                    let B4 = this.prevPlacement, Q = false;\n                    this.prevZoomAdjustment = B4 ? B4.zoomAdjustment(this.transform.zoom) : 0;\n                    let ee = B4 ? B4.symbolFadeChange(w4) : 1, le = B4 ? B4.opacities : {}, qe = B4 ? B4.variableOffsets : {}, Xe = B4 ? B4.placedOrientations : {};\n                    for (let ot in this.placements) {\n                      let Tt = this.placements[ot], Yt = le[ot];\n                      Yt ? (this.opacities[ot] = new On(Yt, ee, Tt.text, Tt.icon), Q = Q || Tt.text !== Yt.text.placed || Tt.icon !== Yt.icon.placed) : (this.opacities[ot] = new On(null, ee, Tt.text, Tt.icon, Tt.skipFade), Q = Q || Tt.text || Tt.icon);\n                    }\n                    for (let ot in le) {\n                      let Tt = le[ot];\n                      if (!this.opacities[ot]) {\n                        let Yt = new On(Tt, ee, false, false);\n                        Yt.isHidden() || (this.opacities[ot] = Yt, Q = Q || Tt.text.placed || Tt.icon.placed);\n                      }\n                    }\n                    for (let ot in qe) this.variableOffsets[ot] || !this.opacities[ot] || this.opacities[ot].isHidden() || (this.variableOffsets[ot] = qe[ot]);\n                    for (let ot in Xe) this.placedOrientations[ot] || !this.opacities[ot] || this.opacities[ot].isHidden() || (this.placedOrientations[ot] = Xe[ot]);\n                    if (B4 && B4.lastPlacementChangeTime === void 0) throw new Error("Last placement time for previous placement is not defined");\n                    Q ? this.lastPlacementChangeTime = w4 : typeof this.lastPlacementChangeTime != "number" && (this.lastPlacementChangeTime = B4 ? B4.lastPlacementChangeTime : w4);\n                  }\n                  updateLayerOpacities(w4, B4) {\n                    let Q = {};\n                    for (let ee of B4) {\n                      let le = ee.getBucket(w4);\n                      le && ee.latestFeatureIndex && w4.id === le.layerIds[0] && this.updateBucketOpacities(le, ee.tileID, Q, ee.collisionBoxArray);\n                    }\n                  }\n                  updateBucketOpacities(w4, B4, Q, ee) {\n                    w4.hasTextData() && (w4.text.opacityVertexArray.clear(), w4.text.hasVisibleVertices = false), w4.hasIconData() && (w4.icon.opacityVertexArray.clear(), w4.icon.hasVisibleVertices = false), w4.hasIconCollisionBoxData() && w4.iconCollisionBox.collisionVertexArray.clear(), w4.hasTextCollisionBoxData() && w4.textCollisionBox.collisionVertexArray.clear();\n                    let le = w4.layers[0], qe = le.layout, Xe = new On(null, 0, false, false, true), ot = qe.get("text-allow-overlap"), Tt = qe.get("icon-allow-overlap"), Yt = le._unevaluatedLayout.hasValue("text-variable-anchor") || le._unevaluatedLayout.hasValue("text-variable-anchor-offset"), Kt = qe.get("text-rotation-alignment") === "map", xr = qe.get("text-pitch-alignment") === "map", Ir = qe.get("icon-text-fit") !== "none", ve = new On(null, 0, ot && (Tt || !w4.hasIconData() || qe.get("icon-optional")), Tt && (ot || !w4.hasTextData() || qe.get("text-optional")), true);\n                    !w4.collisionArrays && ee && (w4.hasIconCollisionBoxData() || w4.hasTextCollisionBoxData()) && w4.deserializeCollisionBoxes(ee);\n                    let be = (Be, et, We) => {\n                      for (let it = 0; it < et / 4; it++) Be.opacityVertexArray.emplaceBack(We);\n                      Be.hasVisibleVertices = Be.hasVisibleVertices || We !== fn;\n                    }, De = this.collisionBoxArrays.get(w4.bucketInstanceId);\n                    for (let Be = 0; Be < w4.symbolInstances.length; Be++) {\n                      let et = w4.symbolInstances.get(Be), { numHorizontalGlyphVertices: We, numVerticalGlyphVertices: it, crossTileID: Ft } = et, Ht = this.opacities[Ft];\n                      Q[Ft] ? Ht = Xe : Ht || (Ht = ve, this.opacities[Ft] = Ht), Q[Ft] = true;\n                      let tr = et.numIconVertices > 0, dr = this.placedOrientations[et.crossTileID], Sr = dr === a4.ah.vertical, Or = dr === a4.ah.horizontal || dr === a4.ah.horizontalOnly;\n                      if (We > 0 || it > 0) {\n                        let ni = tn(Ht.text);\n                        be(w4.text, We, Sr ? fn : ni), be(w4.text, it, Or ? fn : ni);\n                        let Pi = Ht.text.isHidden();\n                        [et.rightJustifiedTextSymbolIndex, et.centerJustifiedTextSymbolIndex, et.leftJustifiedTextSymbolIndex].forEach((Cn) => {\n                          Cn >= 0 && (w4.text.placedSymbolArray.get(Cn).hidden = Pi || Sr ? 1 : 0);\n                        }), et.verticalPlacedTextSymbolIndex >= 0 && (w4.text.placedSymbolArray.get(et.verticalPlacedTextSymbolIndex).hidden = Pi || Or ? 1 : 0);\n                        let cn = this.variableOffsets[et.crossTileID];\n                        cn && this.markUsedJustification(w4, cn.anchor, et, dr);\n                        let ln = this.placedOrientations[et.crossTileID];\n                        ln && (this.markUsedJustification(w4, "left", et, ln), this.markUsedOrientation(w4, ln, et));\n                      }\n                      if (tr) {\n                        let ni = tn(Ht.icon), Pi = !(Ir && et.verticalPlacedIconSymbolIndex && Sr);\n                        et.placedIconSymbolIndex >= 0 && (be(w4.icon, et.numIconVertices, Pi ? ni : fn), w4.icon.placedSymbolArray.get(et.placedIconSymbolIndex).hidden = Ht.icon.isHidden()), et.verticalPlacedIconSymbolIndex >= 0 && (be(w4.icon, et.numVerticalIconVertices, Pi ? fn : ni), w4.icon.placedSymbolArray.get(et.verticalPlacedIconSymbolIndex).hidden = Ht.icon.isHidden());\n                      }\n                      let Wr = De && De.has(Be) ? De.get(Be) : { text: null, icon: null };\n                      if (w4.hasIconCollisionBoxData() || w4.hasTextCollisionBoxData()) {\n                        let ni = w4.collisionArrays[Be];\n                        if (ni) {\n                          let Pi = new a4.P(0, 0);\n                          if (ni.textBox || ni.verticalTextBox) {\n                            let cn = true;\n                            if (Yt) {\n                              let ln = this.variableOffsets[Ft];\n                              ln ? (Pi = Ut(ln.anchor, ln.width, ln.height, ln.textOffset, ln.textBoxScale), Kt && Pi._rotate(xr ? this.transform.angle : -this.transform.angle)) : cn = false;\n                            }\n                            if (ni.textBox || ni.verticalTextBox) {\n                              let ln;\n                              ni.textBox && (ln = Sr), ni.verticalTextBox && (ln = Or), rr(w4.textCollisionBox.collisionVertexArray, Ht.text.placed, !cn || ln, Wr.text, Pi.x, Pi.y);\n                            }\n                          }\n                          if (ni.iconBox || ni.verticalIconBox) {\n                            let cn = !!(!Or && ni.verticalIconBox), ln;\n                            ni.iconBox && (ln = cn), ni.verticalIconBox && (ln = !cn), rr(w4.iconCollisionBox.collisionVertexArray, Ht.icon.placed, ln, Wr.icon, Ir ? Pi.x : 0, Ir ? Pi.y : 0);\n                          }\n                        }\n                      }\n                    }\n                    if (w4.sortFeatures(this.transform.angle), this.retainedQueryData[w4.bucketInstanceId] && (this.retainedQueryData[w4.bucketInstanceId].featureSortOrder = w4.featureSortOrder), w4.hasTextData() && w4.text.opacityVertexBuffer && w4.text.opacityVertexBuffer.updateData(w4.text.opacityVertexArray), w4.hasIconData() && w4.icon.opacityVertexBuffer && w4.icon.opacityVertexBuffer.updateData(w4.icon.opacityVertexArray), w4.hasIconCollisionBoxData() && w4.iconCollisionBox.collisionVertexBuffer && w4.iconCollisionBox.collisionVertexBuffer.updateData(w4.iconCollisionBox.collisionVertexArray), w4.hasTextCollisionBoxData() && w4.textCollisionBox.collisionVertexBuffer && w4.textCollisionBox.collisionVertexBuffer.updateData(w4.textCollisionBox.collisionVertexArray), w4.text.opacityVertexArray.length !== w4.text.layoutVertexArray.length / 4) throw new Error(`bucket.text.opacityVertexArray.length (= ${w4.text.opacityVertexArray.length}) !== bucket.text.layoutVertexArray.length (= ${w4.text.layoutVertexArray.length}) / 4`);\n                    if (w4.icon.opacityVertexArray.length !== w4.icon.layoutVertexArray.length / 4) throw new Error(`bucket.icon.opacityVertexArray.length (= ${w4.icon.opacityVertexArray.length}) !== bucket.icon.layoutVertexArray.length (= ${w4.icon.layoutVertexArray.length}) / 4`);\n                    if (w4.bucketInstanceId in this.collisionCircleArrays) {\n                      let Be = this.collisionCircleArrays[w4.bucketInstanceId];\n                      w4.placementInvProjMatrix = Be.invProjMatrix, w4.placementViewportMatrix = Be.viewportMatrix, w4.collisionCircleArray = Be.circles, delete this.collisionCircleArrays[w4.bucketInstanceId];\n                    }\n                  }\n                  symbolFadeChange(w4) {\n                    return this.fadeDuration === 0 ? 1 : (w4 - this.commitTime) / this.fadeDuration + this.prevZoomAdjustment;\n                  }\n                  zoomAdjustment(w4) {\n                    return Math.max(0, (this.transform.zoom - w4) / 1.5);\n                  }\n                  hasTransitions(w4) {\n                    return this.stale || w4 - this.lastPlacementChangeTime < this.fadeDuration;\n                  }\n                  stillRecent(w4, B4) {\n                    let Q = this.zoomAtLastRecencyCheck === B4 ? 1 - this.zoomAdjustment(B4) : 1;\n                    return this.zoomAtLastRecencyCheck = B4, this.commitTime + this.fadeDuration * Q > w4;\n                  }\n                  setStale() {\n                    this.stale = true;\n                  }\n                }\n                function rr(ue, w4, B4, Q, ee, le) {\n                  Q && Q.length !== 0 || (Q = [0, 0, 0, 0]);\n                  let qe = Q[0] - di, Xe = Q[1] - di, ot = Q[2] - di, Tt = Q[3] - di;\n                  ue.emplaceBack(w4 ? 1 : 0, B4 ? 1 : 0, ee || 0, le || 0, qe, Xe), ue.emplaceBack(w4 ? 1 : 0, B4 ? 1 : 0, ee || 0, le || 0, ot, Xe), ue.emplaceBack(w4 ? 1 : 0, B4 ? 1 : 0, ee || 0, le || 0, ot, Tt), ue.emplaceBack(w4 ? 1 : 0, B4 ? 1 : 0, ee || 0, le || 0, qe, Tt);\n                }\n                let nr = Math.pow(2, 25), Er = Math.pow(2, 24), Xr = Math.pow(2, 17), ri = Math.pow(2, 16), Qr = Math.pow(2, 9), Oi = Math.pow(2, 8), $i = Math.pow(2, 1);\n                function tn(ue) {\n                  if (ue.opacity === 0 && !ue.placed) return 0;\n                  if (ue.opacity === 1 && ue.placed) return 4294967295;\n                  let w4 = ue.placed ? 1 : 0, B4 = Math.floor(127 * ue.opacity);\n                  return B4 * nr + w4 * Er + B4 * Xr + w4 * ri + B4 * Qr + w4 * Oi + B4 * $i + w4;\n                }\n                let fn = 0;\n                function yn() {\n                  return { isOccluded: (ue, w4, B4) => false, getPitchedTextCorrection: (ue, w4, B4) => 1, get useSpecialProjectionForSymbols() {\n                    return false;\n                  }, projectTileCoordinates(ue, w4, B4, Q) {\n                    throw new Error("Not implemented.");\n                  }, translatePosition: (ue, w4, B4, Q) => (function(ee, le, qe, Xe, ot = false) {\n                    if (!qe[0] && !qe[1]) return [0, 0];\n                    let Tt = ot ? Xe === "map" ? ee.angle : 0 : Xe === "viewport" ? -ee.angle : 0;\n                    if (Tt) {\n                      let Yt = Math.sin(Tt), Kt = Math.cos(Tt);\n                      qe = [qe[0] * Kt - qe[1] * Yt, qe[0] * Yt + qe[1] * Kt];\n                    }\n                    return [ot ? qe[0] : In(le, qe[0], ee.zoom), ot ? qe[1] : In(le, qe[1], ee.zoom)];\n                  })(ue, w4, B4, Q), getCircleRadiusCorrection: (ue) => 1 };\n                }\n                class Sn {\n                  constructor(w4) {\n                    this._sortAcrossTiles = w4.layout.get("symbol-z-order") !== "viewport-y" && !w4.layout.get("symbol-sort-key").isConstant(), this._currentTileIndex = 0, this._currentPartIndex = 0, this._seenCrossTileIDs = {}, this._bucketParts = [];\n                  }\n                  continuePlacement(w4, B4, Q, ee, le) {\n                    let qe = this._bucketParts;\n                    for (; this._currentTileIndex < w4.length; ) if (B4.getBucketParts(qe, ee, w4[this._currentTileIndex], this._sortAcrossTiles), this._currentTileIndex++, le()) return true;\n                    for (this._sortAcrossTiles && (this._sortAcrossTiles = false, qe.sort((Xe, ot) => Xe.sortKey - ot.sortKey)); this._currentPartIndex < qe.length; ) if (B4.placeLayerBucketPart(qe[this._currentPartIndex], this._seenCrossTileIDs, Q), this._currentPartIndex++, le()) return true;\n                    return false;\n                  }\n                }\n                class Ba {\n                  constructor(w4, B4, Q, ee, le, qe, Xe, ot) {\n                    this.placement = new wt(w4, yn(), B4, qe, Xe, ot), this._currentPlacementIndex = Q.length - 1, this._forceFullPlacement = ee, this._showCollisionBoxes = le, this._done = false;\n                  }\n                  isDone() {\n                    return this._done;\n                  }\n                  continuePlacement(w4, B4, Q) {\n                    let ee = u4.now(), le = () => !this._forceFullPlacement && u4.now() - ee > 2;\n                    for (; this._currentPlacementIndex >= 0; ) {\n                      let qe = B4[w4[this._currentPlacementIndex]], Xe = this.placement.collisionIndex.transform.zoom;\n                      if (qe.type === "symbol" && (!qe.minzoom || qe.minzoom <= Xe) && (!qe.maxzoom || qe.maxzoom > Xe)) {\n                        if (this._inProgressLayer || (this._inProgressLayer = new Sn(qe)), this._inProgressLayer.continuePlacement(Q[qe.source], this.placement, this._showCollisionBoxes, qe, le)) return;\n                        delete this._inProgressLayer;\n                      }\n                      this._currentPlacementIndex--;\n                    }\n                    this._done = true;\n                  }\n                  commit(w4) {\n                    return this.placement.commit(w4), this.placement;\n                  }\n                }\n                let ua = 512 / a4.X / 2;\n                class ma {\n                  constructor(w4, B4, Q) {\n                    this.tileID = w4, this.bucketInstanceId = Q, this._symbolsByKey = {};\n                    let ee = /* @__PURE__ */ new Map();\n                    for (let le = 0; le < B4.length; le++) {\n                      let qe = B4.get(le), Xe = qe.key, ot = ee.get(Xe);\n                      ot ? ot.push(qe) : ee.set(Xe, [qe]);\n                    }\n                    for (let [le, qe] of ee) {\n                      let Xe = { positions: qe.map((ot) => ({ x: Math.floor(ot.anchorX * ua), y: Math.floor(ot.anchorY * ua) })), crossTileIDs: qe.map((ot) => ot.crossTileID) };\n                      if (Xe.positions.length > 128) {\n                        let ot = new a4.av(Xe.positions.length, 16, Uint16Array);\n                        for (let { x: Tt, y: Yt } of Xe.positions) ot.add(Tt, Yt);\n                        ot.finish(), delete Xe.positions, Xe.index = ot;\n                      }\n                      this._symbolsByKey[le] = Xe;\n                    }\n                  }\n                  getScaledCoordinates(w4, B4) {\n                    let { x: Q, y: ee, z: le } = this.tileID.canonical, { x: qe, y: Xe, z: ot } = B4.canonical, Tt = ua / Math.pow(2, ot - le), Yt = (Xe * a4.X + w4.anchorY) * Tt, Kt = ee * a4.X * ua;\n                    return { x: Math.floor((qe * a4.X + w4.anchorX) * Tt - Q * a4.X * ua), y: Math.floor(Yt - Kt) };\n                  }\n                  findMatches(w4, B4, Q) {\n                    let ee = this.tileID.canonical.z < B4.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - B4.canonical.z);\n                    for (let le = 0; le < w4.length; le++) {\n                      let qe = w4.get(le);\n                      if (qe.crossTileID) continue;\n                      let Xe = this._symbolsByKey[qe.key];\n                      if (!Xe) continue;\n                      let ot = this.getScaledCoordinates(qe, B4);\n                      if (Xe.index) {\n                        let Tt = Xe.index.range(ot.x - ee, ot.y - ee, ot.x + ee, ot.y + ee).sort();\n                        for (let Yt of Tt) {\n                          let Kt = Xe.crossTileIDs[Yt];\n                          if (!Q[Kt]) {\n                            Q[Kt] = true, qe.crossTileID = Kt;\n                            break;\n                          }\n                        }\n                      } else if (Xe.positions) for (let Tt = 0; Tt < Xe.positions.length; Tt++) {\n                        let Yt = Xe.positions[Tt], Kt = Xe.crossTileIDs[Tt];\n                        if (Math.abs(Yt.x - ot.x) <= ee && Math.abs(Yt.y - ot.y) <= ee && !Q[Kt]) {\n                          Q[Kt] = true, qe.crossTileID = Kt;\n                          break;\n                        }\n                      }\n                    }\n                  }\n                  getCrossTileIDsLists() {\n                    return Object.values(this._symbolsByKey).map(({ crossTileIDs: w4 }) => w4);\n                  }\n                }\n                class Wa {\n                  constructor() {\n                    this.maxCrossTileID = 0;\n                  }\n                  generate() {\n                    return ++this.maxCrossTileID;\n                  }\n                }\n                class Fa {\n                  constructor() {\n                    this.indexes = {}, this.usedCrossTileIDs = {}, this.lng = 0;\n                  }\n                  handleWrapJump(w4) {\n                    let B4 = Math.round((w4 - this.lng) / 360);\n                    if (B4 !== 0) for (let Q in this.indexes) {\n                      let ee = this.indexes[Q], le = {};\n                      for (let qe in ee) {\n                        let Xe = ee[qe];\n                        Xe.tileID = Xe.tileID.unwrapTo(Xe.tileID.wrap + B4), le[Xe.tileID.key] = Xe;\n                      }\n                      this.indexes[Q] = le;\n                    }\n                    this.lng = w4;\n                  }\n                  addBucket(w4, B4, Q) {\n                    if (this.indexes[w4.overscaledZ] && this.indexes[w4.overscaledZ][w4.key]) {\n                      if (this.indexes[w4.overscaledZ][w4.key].bucketInstanceId === B4.bucketInstanceId) return false;\n                      this.removeBucketCrossTileIDs(w4.overscaledZ, this.indexes[w4.overscaledZ][w4.key]);\n                    }\n                    for (let le = 0; le < B4.symbolInstances.length; le++) B4.symbolInstances.get(le).crossTileID = 0;\n                    this.usedCrossTileIDs[w4.overscaledZ] || (this.usedCrossTileIDs[w4.overscaledZ] = {});\n                    let ee = this.usedCrossTileIDs[w4.overscaledZ];\n                    for (let le in this.indexes) {\n                      let qe = this.indexes[le];\n                      if (Number(le) > w4.overscaledZ) for (let Xe in qe) {\n                        let ot = qe[Xe];\n                        ot.tileID.isChildOf(w4) && ot.findMatches(B4.symbolInstances, w4, ee);\n                      }\n                      else {\n                        let Xe = qe[w4.scaledTo(Number(le)).key];\n                        Xe && Xe.findMatches(B4.symbolInstances, w4, ee);\n                      }\n                    }\n                    for (let le = 0; le < B4.symbolInstances.length; le++) {\n                      let qe = B4.symbolInstances.get(le);\n                      qe.crossTileID || (qe.crossTileID = Q.generate(), ee[qe.crossTileID] = true);\n                    }\n                    return this.indexes[w4.overscaledZ] === void 0 && (this.indexes[w4.overscaledZ] = {}), this.indexes[w4.overscaledZ][w4.key] = new ma(w4, B4.symbolInstances, B4.bucketInstanceId), true;\n                  }\n                  removeBucketCrossTileIDs(w4, B4) {\n                    for (let Q of B4.getCrossTileIDsLists()) for (let ee of Q) delete this.usedCrossTileIDs[w4][ee];\n                  }\n                  removeStaleBuckets(w4) {\n                    let B4 = false;\n                    for (let Q in this.indexes) {\n                      let ee = this.indexes[Q];\n                      for (let le in ee) w4[ee[le].bucketInstanceId] || (this.removeBucketCrossTileIDs(Q, ee[le]), delete ee[le], B4 = true);\n                    }\n                    return B4;\n                  }\n                }\n                class Wo {\n                  constructor() {\n                    this.layerIndexes = {}, this.crossTileIDs = new Wa(), this.maxBucketInstanceId = 0, this.bucketsInCurrentPlacement = {};\n                  }\n                  addLayer(w4, B4, Q) {\n                    let ee = this.layerIndexes[w4.id];\n                    ee === void 0 && (ee = this.layerIndexes[w4.id] = new Fa());\n                    let le = false, qe = {};\n                    ee.handleWrapJump(Q);\n                    for (let Xe of B4) {\n                      let ot = Xe.getBucket(w4);\n                      ot && w4.id === ot.layerIds[0] && (ot.bucketInstanceId || (ot.bucketInstanceId = ++this.maxBucketInstanceId), ee.addBucket(Xe.tileID, ot, this.crossTileIDs) && (le = true), qe[ot.bucketInstanceId] = true);\n                    }\n                    return ee.removeStaleBuckets(qe) && (le = true), le;\n                  }\n                  pruneUnusedLayers(w4) {\n                    let B4 = {};\n                    w4.forEach((Q) => {\n                      B4[Q] = true;\n                    });\n                    for (let Q in this.layerIndexes) B4[Q] || delete this.layerIndexes[Q];\n                  }\n                }\n                let da = (ue, w4) => a4.t(ue, w4 && w4.filter((B4) => B4.identifier !== "source.canvas")), Wn = a4.aw();\n                class Ha extends a4.E {\n                  constructor(w4, B4 = {}) {\n                    super(), this._rtlPluginLoaded = () => {\n                      for (let Q in this.sourceCaches) {\n                        let ee = this.sourceCaches[Q].getSource().type;\n                        ee !== "vector" && ee !== "geojson" || this.sourceCaches[Q].reload();\n                      }\n                    }, this.map = w4, this.dispatcher = new Le(Se(), w4._getMapId()), this.dispatcher.registerMessageHandler("GG", (Q, ee) => this.getGlyphs(Q, ee)), this.dispatcher.registerMessageHandler("GI", (Q, ee) => this.getImages(Q, ee)), this.imageManager = new T3(), this.imageManager.setEventedParent(this), this.glyphManager = new G2(w4._requestManager, B4.localIdeographFontFamily), this.lineAtlas = new oe(256, 512), this.crossTileSymbolIndex = new Wo(), this._spritesImagesIds = {}, this._layers = {}, this._order = [], this.sourceCaches = {}, this.zoomHistory = new a4.ax(), this._loaded = false, this._availableImages = [], this._resetUpdates(), this.dispatcher.broadcast("SR", a4.ay()), Qt().on(cr, this._rtlPluginLoaded), this.on("data", (Q) => {\n                      if (Q.dataType !== "source" || Q.sourceDataType !== "metadata") return;\n                      let ee = this.sourceCaches[Q.sourceId];\n                      if (!ee) return;\n                      let le = ee.getSource();\n                      if (le && le.vectorLayerIds) for (let qe in this._layers) {\n                        let Xe = this._layers[qe];\n                        Xe.source === le.id && this._validateLayer(Xe);\n                      }\n                    });\n                  }\n                  loadURL(w4, B4 = {}, Q) {\n                    this.fire(new a4.k("dataloading", { dataType: "style" })), B4.validate = typeof B4.validate != "boolean" || B4.validate;\n                    let ee = this.map._requestManager.transformRequest(w4, "Style");\n                    this._loadStyleRequest = new AbortController();\n                    let le = this._loadStyleRequest;\n                    a4.h(ee, this._loadStyleRequest).then((qe) => {\n                      this._loadStyleRequest = null, this._load(qe.data, B4, Q);\n                    }).catch((qe) => {\n                      this._loadStyleRequest = null, qe && !le.signal.aborted && this.fire(new a4.j(qe));\n                    });\n                  }\n                  loadJSON(w4, B4 = {}, Q) {\n                    this.fire(new a4.k("dataloading", { dataType: "style" })), this._frameRequest = new AbortController(), u4.frameAsync(this._frameRequest).then(() => {\n                      this._frameRequest = null, B4.validate = B4.validate !== false, this._load(w4, B4, Q);\n                    }).catch(() => {\n                    });\n                  }\n                  loadEmpty() {\n                    this.fire(new a4.k("dataloading", { dataType: "style" })), this._load(Wn, { validate: false });\n                  }\n                  _load(w4, B4, Q) {\n                    var ee;\n                    let le = B4.transformStyle ? B4.transformStyle(Q, w4) : w4;\n                    if (!B4.validate || !da(this, a4.u(le))) {\n                      this._loaded = true, this.stylesheet = le;\n                      for (let qe in le.sources) this.addSource(qe, le.sources[qe], { validate: false });\n                      le.sprite ? this._loadSprite(le.sprite) : this.imageManager.setLoaded(true), this.glyphManager.setURL(le.glyphs), this._createLayers(), this.light = new N2(this.stylesheet.light), this.sky = new te(this.stylesheet.sky), this.map.setTerrain((ee = this.stylesheet.terrain) !== null && ee !== void 0 ? ee : null), this.fire(new a4.k("data", { dataType: "style" })), this.fire(new a4.k("style.load"));\n                    }\n                  }\n                  _createLayers() {\n                    let w4 = a4.az(this.stylesheet.layers);\n                    this.dispatcher.broadcast("SL", w4), this._order = w4.map((B4) => B4.id), this._layers = {}, this._serializedLayers = null;\n                    for (let B4 of w4) {\n                      let Q = a4.aA(B4);\n                      Q.setEventedParent(this, { layer: { id: B4.id } }), this._layers[B4.id] = Q;\n                    }\n                  }\n                  _loadSprite(w4, B4 = false, Q = void 0) {\n                    let ee;\n                    this.imageManager.setLoaded(false), this._spriteRequest = new AbortController(), (function(le, qe, Xe, ot) {\n                      return a4._(this, void 0, void 0, function* () {\n                        let Tt = C3(le), Yt = Xe > 1 ? "@2x" : "", Kt = {}, xr = {};\n                        for (let { id: Ir, url: ve } of Tt) {\n                          let be = qe.transformRequest(M4(ve, Yt, ".json"), "SpriteJSON");\n                          Kt[Ir] = a4.h(be, ot);\n                          let De = qe.transformRequest(M4(ve, Yt, ".png"), "SpriteImage");\n                          xr[Ir] = p3.getImage(De, ot);\n                        }\n                        return yield Promise.all([...Object.values(Kt), ...Object.values(xr)]), (function(Ir, ve) {\n                          return a4._(this, void 0, void 0, function* () {\n                            let be = {};\n                            for (let De in Ir) {\n                              be[De] = {};\n                              let Be = u4.getImageCanvasContext((yield ve[De]).data), et = (yield Ir[De]).data;\n                              for (let We in et) {\n                                let { width: it, height: Ft, x: Ht, y: tr, sdf: dr, pixelRatio: Sr, stretchX: Or, stretchY: Wr, content: ni, textFitWidth: Pi, textFitHeight: cn } = et[We];\n                                be[De][We] = { data: null, pixelRatio: Sr, sdf: dr, stretchX: Or, stretchY: Wr, content: ni, textFitWidth: Pi, textFitHeight: cn, spriteData: { width: it, height: Ft, x: Ht, y: tr, context: Be } };\n                              }\n                            }\n                            return be;\n                          });\n                        })(Kt, xr);\n                      });\n                    })(w4, this.map._requestManager, this.map.getPixelRatio(), this._spriteRequest).then((le) => {\n                      if (this._spriteRequest = null, le) for (let qe in le) {\n                        this._spritesImagesIds[qe] = [];\n                        let Xe = this._spritesImagesIds[qe] ? this._spritesImagesIds[qe].filter((ot) => !(ot in le)) : [];\n                        for (let ot of Xe) this.imageManager.removeImage(ot), this._changedImages[ot] = true;\n                        for (let ot in le[qe]) {\n                          let Tt = qe === "default" ? ot : `${qe}:${ot}`;\n                          this._spritesImagesIds[qe].push(Tt), Tt in this.imageManager.images ? this.imageManager.updateImage(Tt, le[qe][ot], false) : this.imageManager.addImage(Tt, le[qe][ot]), B4 && (this._changedImages[Tt] = true);\n                        }\n                      }\n                    }).catch((le) => {\n                      this._spriteRequest = null, ee = le, this.fire(new a4.j(ee));\n                    }).finally(() => {\n                      this.imageManager.setLoaded(true), this._availableImages = this.imageManager.listImages(), B4 && (this._changed = true), this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a4.k("data", { dataType: "style" })), Q && Q(ee);\n                    });\n                  }\n                  _unloadSprite() {\n                    for (let w4 of Object.values(this._spritesImagesIds).flat()) this.imageManager.removeImage(w4), this._changedImages[w4] = true;\n                    this._spritesImagesIds = {}, this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a4.k("data", { dataType: "style" }));\n                  }\n                  _validateLayer(w4) {\n                    let B4 = this.sourceCaches[w4.source];\n                    if (!B4) return;\n                    let Q = w4.sourceLayer;\n                    if (!Q) return;\n                    let ee = B4.getSource();\n                    (ee.type === "geojson" || ee.vectorLayerIds && ee.vectorLayerIds.indexOf(Q) === -1) && this.fire(new a4.j(new Error(`Source layer "${Q}" does not exist on source "${ee.id}" as specified by style layer "${w4.id}".`)));\n                  }\n                  loaded() {\n                    if (!this._loaded || Object.keys(this._updatedSources).length) return false;\n                    for (let w4 in this.sourceCaches) if (!this.sourceCaches[w4].loaded()) return false;\n                    return !!this.imageManager.isLoaded();\n                  }\n                  _serializeByIds(w4, B4 = false) {\n                    let Q = this._serializedAllLayers();\n                    if (!w4 || w4.length === 0) return Object.values(B4 ? a4.aB(Q) : Q);\n                    let ee = [];\n                    for (let le of w4) if (Q[le]) {\n                      let qe = B4 ? a4.aB(Q[le]) : Q[le];\n                      ee.push(qe);\n                    }\n                    return ee;\n                  }\n                  _serializedAllLayers() {\n                    let w4 = this._serializedLayers;\n                    if (w4) return w4;\n                    w4 = this._serializedLayers = {};\n                    let B4 = Object.keys(this._layers);\n                    for (let Q of B4) {\n                      let ee = this._layers[Q];\n                      ee.type !== "custom" && (w4[Q] = ee.serialize());\n                    }\n                    return w4;\n                  }\n                  hasTransitions() {\n                    if (this.light && this.light.hasTransition() || this.sky && this.sky.hasTransition()) return true;\n                    for (let w4 in this.sourceCaches) if (this.sourceCaches[w4].hasTransition()) return true;\n                    for (let w4 in this._layers) if (this._layers[w4].hasTransition()) return true;\n                    return false;\n                  }\n                  _checkLoaded() {\n                    if (!this._loaded) throw new Error("Style is not done loading.");\n                  }\n                  update(w4) {\n                    if (!this._loaded) return;\n                    let B4 = this._changed;\n                    if (B4) {\n                      let ee = Object.keys(this._updatedLayers), le = Object.keys(this._removedLayers);\n                      (ee.length || le.length) && this._updateWorkerLayers(ee, le);\n                      for (let qe in this._updatedSources) {\n                        let Xe = this._updatedSources[qe];\n                        if (Xe === "reload") this._reloadSource(qe);\n                        else {\n                          if (Xe !== "clear") throw new Error(`Invalid action ${Xe}`);\n                          this._clearSource(qe);\n                        }\n                      }\n                      this._updateTilesForChangedImages(), this._updateTilesForChangedGlyphs();\n                      for (let qe in this._updatedPaintProps) this._layers[qe].updateTransitions(w4);\n                      this.light.updateTransitions(w4), this.sky.updateTransitions(w4), this._resetUpdates();\n                    }\n                    let Q = {};\n                    for (let ee in this.sourceCaches) {\n                      let le = this.sourceCaches[ee];\n                      Q[ee] = le.used, le.used = false;\n                    }\n                    for (let ee of this._order) {\n                      let le = this._layers[ee];\n                      le.recalculate(w4, this._availableImages), !le.isHidden(w4.zoom) && le.source && (this.sourceCaches[le.source].used = true);\n                    }\n                    for (let ee in Q) {\n                      let le = this.sourceCaches[ee];\n                      !!Q[ee] != !!le.used && le.fire(new a4.k("data", { sourceDataType: "visibility", dataType: "source", sourceId: ee }));\n                    }\n                    this.light.recalculate(w4), this.sky.recalculate(w4), this.z = w4.zoom, B4 && this.fire(new a4.k("data", { dataType: "style" }));\n                  }\n                  _updateTilesForChangedImages() {\n                    let w4 = Object.keys(this._changedImages);\n                    if (w4.length) {\n                      for (let B4 in this.sourceCaches) this.sourceCaches[B4].reloadTilesForDependencies(["icons", "patterns"], w4);\n                      this._changedImages = {};\n                    }\n                  }\n                  _updateTilesForChangedGlyphs() {\n                    if (this._glyphsDidChange) {\n                      for (let w4 in this.sourceCaches) this.sourceCaches[w4].reloadTilesForDependencies(["glyphs"], [""]);\n                      this._glyphsDidChange = false;\n                    }\n                  }\n                  _updateWorkerLayers(w4, B4) {\n                    this.dispatcher.broadcast("UL", { layers: this._serializeByIds(w4, false), removedIds: B4 });\n                  }\n                  _resetUpdates() {\n                    this._changed = false, this._updatedLayers = {}, this._removedLayers = {}, this._updatedSources = {}, this._updatedPaintProps = {}, this._changedImages = {}, this._glyphsDidChange = false;\n                  }\n                  setState(w4, B4 = {}) {\n                    var Q;\n                    this._checkLoaded();\n                    let ee = this.serialize();\n                    if (w4 = B4.transformStyle ? B4.transformStyle(ee, w4) : w4, ((Q = B4.validate) === null || Q === void 0 || Q) && da(this, a4.u(w4))) return false;\n                    (w4 = a4.aB(w4)).layers = a4.az(w4.layers);\n                    let le = a4.aC(ee, w4), qe = this._getOperationsToPerform(le);\n                    if (qe.unimplemented.length > 0) throw new Error(`Unimplemented: ${qe.unimplemented.join(", ")}.`);\n                    if (qe.operations.length === 0) return false;\n                    for (let Xe of qe.operations) Xe();\n                    return this.stylesheet = w4, this._serializedLayers = null, true;\n                  }\n                  _getOperationsToPerform(w4) {\n                    let B4 = [], Q = [];\n                    for (let ee of w4) switch (ee.command) {\n                      case "setCenter":\n                      case "setZoom":\n                      case "setBearing":\n                      case "setPitch":\n                        continue;\n                      case "addLayer":\n                        B4.push(() => this.addLayer.apply(this, ee.args));\n                        break;\n                      case "removeLayer":\n                        B4.push(() => this.removeLayer.apply(this, ee.args));\n                        break;\n                      case "setPaintProperty":\n                        B4.push(() => this.setPaintProperty.apply(this, ee.args));\n                        break;\n                      case "setLayoutProperty":\n                        B4.push(() => this.setLayoutProperty.apply(this, ee.args));\n                        break;\n                      case "setFilter":\n                        B4.push(() => this.setFilter.apply(this, ee.args));\n                        break;\n                      case "addSource":\n                        B4.push(() => this.addSource.apply(this, ee.args));\n                        break;\n                      case "removeSource":\n                        B4.push(() => this.removeSource.apply(this, ee.args));\n                        break;\n                      case "setLayerZoomRange":\n                        B4.push(() => this.setLayerZoomRange.apply(this, ee.args));\n                        break;\n                      case "setLight":\n                        B4.push(() => this.setLight.apply(this, ee.args));\n                        break;\n                      case "setGeoJSONSourceData":\n                        B4.push(() => this.setGeoJSONSourceData.apply(this, ee.args));\n                        break;\n                      case "setGlyphs":\n                        B4.push(() => this.setGlyphs.apply(this, ee.args));\n                        break;\n                      case "setSprite":\n                        B4.push(() => this.setSprite.apply(this, ee.args));\n                        break;\n                      case "setSky":\n                        B4.push(() => this.setSky.apply(this, ee.args));\n                        break;\n                      case "setTerrain":\n                        B4.push(() => this.map.setTerrain.apply(this, ee.args));\n                        break;\n                      case "setTransition":\n                        B4.push(() => {\n                        });\n                        break;\n                      default:\n                        Q.push(ee.command);\n                    }\n                    return { operations: B4, unimplemented: Q };\n                  }\n                  addImage(w4, B4) {\n                    if (this.getImage(w4)) return this.fire(new a4.j(new Error(`An image named "${w4}" already exists.`)));\n                    this.imageManager.addImage(w4, B4), this._afterImageUpdated(w4);\n                  }\n                  updateImage(w4, B4) {\n                    this.imageManager.updateImage(w4, B4);\n                  }\n                  getImage(w4) {\n                    return this.imageManager.getImage(w4);\n                  }\n                  removeImage(w4) {\n                    if (!this.getImage(w4)) return this.fire(new a4.j(new Error(`An image named "${w4}" does not exist.`)));\n                    this.imageManager.removeImage(w4), this._afterImageUpdated(w4);\n                  }\n                  _afterImageUpdated(w4) {\n                    this._availableImages = this.imageManager.listImages(), this._changedImages[w4] = true, this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a4.k("data", { dataType: "style" }));\n                  }\n                  listImages() {\n                    return this._checkLoaded(), this.imageManager.listImages();\n                  }\n                  addSource(w4, B4, Q = {}) {\n                    if (this._checkLoaded(), this.sourceCaches[w4] !== void 0) throw new Error(`Source "${w4}" already exists.`);\n                    if (!B4.type) throw new Error(`The type property must be defined, but only the following properties were given: ${Object.keys(B4).join(", ")}.`);\n                    if (["vector", "raster", "geojson", "video", "image"].indexOf(B4.type) >= 0 && this._validate(a4.u.source, `sources.${w4}`, B4, null, Q)) return;\n                    this.map && this.map._collectResourceTiming && (B4.collectResourceTiming = true);\n                    let ee = this.sourceCaches[w4] = new mt(w4, B4, this.dispatcher);\n                    ee.style = this, ee.setEventedParent(this, () => ({ isSourceLoaded: ee.loaded(), source: ee.serialize(), sourceId: w4 })), ee.onAdd(this.map), this._changed = true;\n                  }\n                  removeSource(w4) {\n                    if (this._checkLoaded(), this.sourceCaches[w4] === void 0) throw new Error("There is no source with this ID");\n                    for (let Q in this._layers) if (this._layers[Q].source === w4) return this.fire(new a4.j(new Error(`Source "${w4}" cannot be removed while layer "${Q}" is using it.`)));\n                    let B4 = this.sourceCaches[w4];\n                    delete this.sourceCaches[w4], delete this._updatedSources[w4], B4.fire(new a4.k("data", { sourceDataType: "metadata", dataType: "source", sourceId: w4 })), B4.setEventedParent(null), B4.onRemove(this.map), this._changed = true;\n                  }\n                  setGeoJSONSourceData(w4, B4) {\n                    if (this._checkLoaded(), this.sourceCaches[w4] === void 0) throw new Error(`There is no source with this ID=${w4}`);\n                    let Q = this.sourceCaches[w4].getSource();\n                    if (Q.type !== "geojson") throw new Error(`geojsonSource.type is ${Q.type}, which is !== \'geojson`);\n                    Q.setData(B4), this._changed = true;\n                  }\n                  getSource(w4) {\n                    return this.sourceCaches[w4] && this.sourceCaches[w4].getSource();\n                  }\n                  addLayer(w4, B4, Q = {}) {\n                    this._checkLoaded();\n                    let ee = w4.id;\n                    if (this.getLayer(ee)) return void this.fire(new a4.j(new Error(`Layer "${ee}" already exists on this map.`)));\n                    let le;\n                    if (w4.type === "custom") {\n                      if (da(this, a4.aD(w4))) return;\n                      le = a4.aA(w4);\n                    } else {\n                      if ("source" in w4 && typeof w4.source == "object" && (this.addSource(ee, w4.source), w4 = a4.aB(w4), w4 = a4.e(w4, { source: ee })), this._validate(a4.u.layer, `layers.${ee}`, w4, { arrayIndex: -1 }, Q)) return;\n                      le = a4.aA(w4), this._validateLayer(le), le.setEventedParent(this, { layer: { id: ee } });\n                    }\n                    let qe = B4 ? this._order.indexOf(B4) : this._order.length;\n                    if (B4 && qe === -1) this.fire(new a4.j(new Error(`Cannot add layer "${ee}" before non-existing layer "${B4}".`)));\n                    else {\n                      if (this._order.splice(qe, 0, ee), this._layerOrderChanged = true, this._layers[ee] = le, this._removedLayers[ee] && le.source && le.type !== "custom") {\n                        let Xe = this._removedLayers[ee];\n                        delete this._removedLayers[ee], Xe.type !== le.type ? this._updatedSources[le.source] = "clear" : (this._updatedSources[le.source] = "reload", this.sourceCaches[le.source].pause());\n                      }\n                      this._updateLayer(le), le.onAdd && le.onAdd(this.map);\n                    }\n                  }\n                  moveLayer(w4, B4) {\n                    if (this._checkLoaded(), this._changed = true, !this._layers[w4]) return void this.fire(new a4.j(new Error(`The layer \'${w4}\' does not exist in the map\'s style and cannot be moved.`)));\n                    if (w4 === B4) return;\n                    let Q = this._order.indexOf(w4);\n                    this._order.splice(Q, 1);\n                    let ee = B4 ? this._order.indexOf(B4) : this._order.length;\n                    B4 && ee === -1 ? this.fire(new a4.j(new Error(`Cannot move layer "${w4}" before non-existing layer "${B4}".`))) : (this._order.splice(ee, 0, w4), this._layerOrderChanged = true);\n                  }\n                  removeLayer(w4) {\n                    this._checkLoaded();\n                    let B4 = this._layers[w4];\n                    if (!B4) return void this.fire(new a4.j(new Error(`Cannot remove non-existing layer "${w4}".`)));\n                    B4.setEventedParent(null);\n                    let Q = this._order.indexOf(w4);\n                    this._order.splice(Q, 1), this._layerOrderChanged = true, this._changed = true, this._removedLayers[w4] = B4, delete this._layers[w4], this._serializedLayers && delete this._serializedLayers[w4], delete this._updatedLayers[w4], delete this._updatedPaintProps[w4], B4.onRemove && B4.onRemove(this.map);\n                  }\n                  getLayer(w4) {\n                    return this._layers[w4];\n                  }\n                  getLayersOrder() {\n                    return [...this._order];\n                  }\n                  hasLayer(w4) {\n                    return w4 in this._layers;\n                  }\n                  setLayerZoomRange(w4, B4, Q) {\n                    this._checkLoaded();\n                    let ee = this.getLayer(w4);\n                    ee ? ee.minzoom === B4 && ee.maxzoom === Q || (B4 != null && (ee.minzoom = B4), Q != null && (ee.maxzoom = Q), this._updateLayer(ee)) : this.fire(new a4.j(new Error(`Cannot set the zoom range of non-existing layer "${w4}".`)));\n                  }\n                  setFilter(w4, B4, Q = {}) {\n                    this._checkLoaded();\n                    let ee = this.getLayer(w4);\n                    if (ee) {\n                      if (!a4.aE(ee.filter, B4)) return B4 == null ? (ee.filter = void 0, void this._updateLayer(ee)) : void (this._validate(a4.u.filter, `layers.${ee.id}.filter`, B4, null, Q) || (ee.filter = a4.aB(B4), this._updateLayer(ee)));\n                    } else this.fire(new a4.j(new Error(`Cannot filter non-existing layer "${w4}".`)));\n                  }\n                  getFilter(w4) {\n                    return a4.aB(this.getLayer(w4).filter);\n                  }\n                  setLayoutProperty(w4, B4, Q, ee = {}) {\n                    this._checkLoaded();\n                    let le = this.getLayer(w4);\n                    le ? a4.aE(le.getLayoutProperty(B4), Q) || (le.setLayoutProperty(B4, Q, ee), this._updateLayer(le)) : this.fire(new a4.j(new Error(`Cannot style non-existing layer "${w4}".`)));\n                  }\n                  getLayoutProperty(w4, B4) {\n                    let Q = this.getLayer(w4);\n                    if (Q) return Q.getLayoutProperty(B4);\n                    this.fire(new a4.j(new Error(`Cannot get style of non-existing layer "${w4}".`)));\n                  }\n                  setPaintProperty(w4, B4, Q, ee = {}) {\n                    this._checkLoaded();\n                    let le = this.getLayer(w4);\n                    le ? a4.aE(le.getPaintProperty(B4), Q) || (le.setPaintProperty(B4, Q, ee) && this._updateLayer(le), this._changed = true, this._updatedPaintProps[w4] = true, this._serializedLayers = null) : this.fire(new a4.j(new Error(`Cannot style non-existing layer "${w4}".`)));\n                  }\n                  getPaintProperty(w4, B4) {\n                    return this.getLayer(w4).getPaintProperty(B4);\n                  }\n                  setFeatureState(w4, B4) {\n                    this._checkLoaded();\n                    let Q = w4.source, ee = w4.sourceLayer, le = this.sourceCaches[Q];\n                    if (le === void 0) return void this.fire(new a4.j(new Error(`The source \'${Q}\' does not exist in the map\'s style.`)));\n                    let qe = le.getSource().type;\n                    qe === "geojson" && ee ? this.fire(new a4.j(new Error("GeoJSON sources cannot have a sourceLayer parameter."))) : qe !== "vector" || ee ? (w4.id === void 0 && this.fire(new a4.j(new Error("The feature id parameter must be provided."))), le.setFeatureState(ee, w4.id, B4)) : this.fire(new a4.j(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                  }\n                  removeFeatureState(w4, B4) {\n                    this._checkLoaded();\n                    let Q = w4.source, ee = this.sourceCaches[Q];\n                    if (ee === void 0) return void this.fire(new a4.j(new Error(`The source \'${Q}\' does not exist in the map\'s style.`)));\n                    let le = ee.getSource().type, qe = le === "vector" ? w4.sourceLayer : void 0;\n                    le !== "vector" || qe ? B4 && typeof w4.id != "string" && typeof w4.id != "number" ? this.fire(new a4.j(new Error("A feature id is required to remove its specific state property."))) : ee.removeFeatureState(qe, w4.id, B4) : this.fire(new a4.j(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                  }\n                  getFeatureState(w4) {\n                    this._checkLoaded();\n                    let B4 = w4.source, Q = w4.sourceLayer, ee = this.sourceCaches[B4];\n                    if (ee !== void 0) return ee.getSource().type !== "vector" || Q ? (w4.id === void 0 && this.fire(new a4.j(new Error("The feature id parameter must be provided."))), ee.getFeatureState(Q, w4.id)) : void this.fire(new a4.j(new Error("The sourceLayer parameter must be provided for vector source types.")));\n                    this.fire(new a4.j(new Error(`The source \'${B4}\' does not exist in the map\'s style.`)));\n                  }\n                  getTransition() {\n                    return a4.e({ duration: 300, delay: 0 }, this.stylesheet && this.stylesheet.transition);\n                  }\n                  serialize() {\n                    if (!this._loaded) return;\n                    let w4 = a4.aF(this.sourceCaches, (le) => le.serialize()), B4 = this._serializeByIds(this._order, true), Q = this.map.getTerrain() || void 0, ee = this.stylesheet;\n                    return a4.aG({ version: ee.version, name: ee.name, metadata: ee.metadata, light: ee.light, sky: ee.sky, center: ee.center, zoom: ee.zoom, bearing: ee.bearing, pitch: ee.pitch, sprite: ee.sprite, glyphs: ee.glyphs, transition: ee.transition, sources: w4, layers: B4, terrain: Q }, (le) => le !== void 0);\n                  }\n                  _updateLayer(w4) {\n                    this._updatedLayers[w4.id] = true, w4.source && !this._updatedSources[w4.source] && this.sourceCaches[w4.source].getSource().type !== "raster" && (this._updatedSources[w4.source] = "reload", this.sourceCaches[w4.source].pause()), this._serializedLayers = null, this._changed = true;\n                  }\n                  _flattenAndSortRenderedFeatures(w4) {\n                    let B4 = (qe) => this._layers[qe].type === "fill-extrusion", Q = {}, ee = [];\n                    for (let qe = this._order.length - 1; qe >= 0; qe--) {\n                      let Xe = this._order[qe];\n                      if (B4(Xe)) {\n                        Q[Xe] = qe;\n                        for (let ot of w4) {\n                          let Tt = ot[Xe];\n                          if (Tt) for (let Yt of Tt) ee.push(Yt);\n                        }\n                      }\n                    }\n                    ee.sort((qe, Xe) => Xe.intersectionZ - qe.intersectionZ);\n                    let le = [];\n                    for (let qe = this._order.length - 1; qe >= 0; qe--) {\n                      let Xe = this._order[qe];\n                      if (B4(Xe)) for (let ot = ee.length - 1; ot >= 0; ot--) {\n                        let Tt = ee[ot].feature;\n                        if (Q[Tt.layer.id] < qe) break;\n                        le.push(Tt), ee.pop();\n                      }\n                      else for (let ot of w4) {\n                        let Tt = ot[Xe];\n                        if (Tt) for (let Yt of Tt) le.push(Yt.feature);\n                      }\n                    }\n                    return le;\n                  }\n                  queryRenderedFeatures(w4, B4, Q) {\n                    B4 && B4.filter && this._validate(a4.u.filter, "queryRenderedFeatures.filter", B4.filter, null, B4);\n                    let ee = {};\n                    if (B4 && B4.layers) {\n                      if (!Array.isArray(B4.layers)) return this.fire(new a4.j(new Error("parameters.layers must be an Array."))), [];\n                      for (let Xe of B4.layers) {\n                        let ot = this._layers[Xe];\n                        if (!ot) return this.fire(new a4.j(new Error(`The layer \'${Xe}\' does not exist in the map\'s style and cannot be queried for features.`))), [];\n                        ee[ot.source] = true;\n                      }\n                    }\n                    let le = [];\n                    B4.availableImages = this._availableImages;\n                    let qe = this._serializedAllLayers();\n                    for (let Xe in this.sourceCaches) B4.layers && !ee[Xe] || le.push(Pe(this.sourceCaches[Xe], this._layers, qe, w4, B4, Q));\n                    return this.placement && le.push((function(Xe, ot, Tt, Yt, Kt, xr, Ir) {\n                      let ve = {}, be = xr.queryRenderedSymbols(Yt), De = [];\n                      for (let Be of Object.keys(be).map(Number)) De.push(Ir[Be]);\n                      De.sort(ge);\n                      for (let Be of De) {\n                        let et = Be.featureIndex.lookupSymbolFeatures(be[Be.bucketInstanceId], ot, Be.bucketIndex, Be.sourceLayerIndex, Kt.filter, Kt.layers, Kt.availableImages, Xe);\n                        for (let We in et) {\n                          let it = ve[We] = ve[We] || [], Ft = et[We];\n                          Ft.sort((Ht, tr) => {\n                            let dr = Be.featureSortOrder;\n                            if (dr) {\n                              let Sr = dr.indexOf(Ht.featureIndex);\n                              return dr.indexOf(tr.featureIndex) - Sr;\n                            }\n                            return tr.featureIndex - Ht.featureIndex;\n                          });\n                          for (let Ht of Ft) it.push(Ht);\n                        }\n                      }\n                      for (let Be in ve) ve[Be].forEach((et) => {\n                        let We = et.feature, it = Tt[Xe[Be].source].getFeatureState(We.layer["source-layer"], We.id);\n                        We.source = We.layer.source, We.layer["source-layer"] && (We.sourceLayer = We.layer["source-layer"]), We.state = it;\n                      });\n                      return ve;\n                    })(this._layers, qe, this.sourceCaches, w4, B4, this.placement.collisionIndex, this.placement.retainedQueryData)), this._flattenAndSortRenderedFeatures(le);\n                  }\n                  querySourceFeatures(w4, B4) {\n                    B4 && B4.filter && this._validate(a4.u.filter, "querySourceFeatures.filter", B4.filter, null, B4);\n                    let Q = this.sourceCaches[w4];\n                    return Q ? (function(ee, le) {\n                      let qe = ee.getRenderableIds().map((Tt) => ee.getTileByID(Tt)), Xe = [], ot = {};\n                      for (let Tt = 0; Tt < qe.length; Tt++) {\n                        let Yt = qe[Tt], Kt = Yt.tileID.canonical.key;\n                        ot[Kt] || (ot[Kt] = true, Yt.querySourceFeatures(Xe, le));\n                      }\n                      return Xe;\n                    })(Q, B4) : [];\n                  }\n                  getLight() {\n                    return this.light.getLight();\n                  }\n                  setLight(w4, B4 = {}) {\n                    this._checkLoaded();\n                    let Q = this.light.getLight(), ee = false;\n                    for (let qe in w4) if (!a4.aE(w4[qe], Q[qe])) {\n                      ee = true;\n                      break;\n                    }\n                    if (!ee) return;\n                    let le = { now: u4.now(), transition: a4.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };\n                    this.light.setLight(w4, B4), this.light.updateTransitions(le);\n                  }\n                  getSky() {\n                    var w4;\n                    return (w4 = this.stylesheet) === null || w4 === void 0 ? void 0 : w4.sky;\n                  }\n                  setSky(w4, B4 = {}) {\n                    let Q = this.getSky(), ee = false;\n                    if (!w4 && !Q) return;\n                    if (w4 && !Q) ee = true;\n                    else if (!w4 && Q) ee = true;\n                    else for (let qe in w4) if (!a4.aE(w4[qe], Q[qe])) {\n                      ee = true;\n                      break;\n                    }\n                    if (!ee) return;\n                    let le = { now: u4.now(), transition: a4.e({ duration: 300, delay: 0 }, this.stylesheet.transition) };\n                    this.stylesheet.sky = w4, this.sky.setSky(w4, B4), this.sky.updateTransitions(le);\n                  }\n                  _validate(w4, B4, Q, ee, le = {}) {\n                    return (!le || le.validate !== false) && da(this, w4.call(a4.u, a4.e({ key: B4, style: this.serialize(), value: Q, styleSpec: a4.v }, ee)));\n                  }\n                  _remove(w4 = true) {\n                    this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._loadStyleRequest && (this._loadStyleRequest.abort(), this._loadStyleRequest = null), this._spriteRequest && (this._spriteRequest.abort(), this._spriteRequest = null), Qt().off(cr, this._rtlPluginLoaded);\n                    for (let B4 in this._layers) this._layers[B4].setEventedParent(null);\n                    for (let B4 in this.sourceCaches) {\n                      let Q = this.sourceCaches[B4];\n                      Q.setEventedParent(null), Q.onRemove(this.map);\n                    }\n                    this.imageManager.setEventedParent(null), this.setEventedParent(null), w4 && this.dispatcher.broadcast("RM", void 0), this.dispatcher.remove(w4);\n                  }\n                  _clearSource(w4) {\n                    this.sourceCaches[w4].clearTiles();\n                  }\n                  _reloadSource(w4) {\n                    this.sourceCaches[w4].resume(), this.sourceCaches[w4].reload();\n                  }\n                  _updateSources(w4) {\n                    for (let B4 in this.sourceCaches) this.sourceCaches[B4].update(w4, this.map.terrain);\n                  }\n                  _generateCollisionBoxes() {\n                    for (let w4 in this.sourceCaches) this._reloadSource(w4);\n                  }\n                  _updatePlacement(w4, B4, Q, ee, le = false) {\n                    let qe = false, Xe = false, ot = {};\n                    for (let Tt of this._order) {\n                      let Yt = this._layers[Tt];\n                      if (Yt.type !== "symbol") continue;\n                      if (!ot[Yt.source]) {\n                        let xr = this.sourceCaches[Yt.source];\n                        ot[Yt.source] = xr.getRenderableIds(true).map((Ir) => xr.getTileByID(Ir)).sort((Ir, ve) => ve.tileID.overscaledZ - Ir.tileID.overscaledZ || (Ir.tileID.isLessThan(ve.tileID) ? -1 : 1));\n                      }\n                      let Kt = this.crossTileSymbolIndex.addLayer(Yt, ot[Yt.source], w4.center.lng);\n                      qe = qe || Kt;\n                    }\n                    if (this.crossTileSymbolIndex.pruneUnusedLayers(this._order), ((le = le || this._layerOrderChanged || Q === 0) || !this.pauseablePlacement || this.pauseablePlacement.isDone() && !this.placement.stillRecent(u4.now(), w4.zoom)) && (this.pauseablePlacement = new Ba(w4, this.map.terrain, this._order, le, B4, Q, ee, this.placement), this._layerOrderChanged = false), this.pauseablePlacement.isDone() ? this.placement.setStale() : (this.pauseablePlacement.continuePlacement(this._order, this._layers, ot), this.pauseablePlacement.isDone() && (this.placement = this.pauseablePlacement.commit(u4.now()), Xe = true), qe && this.pauseablePlacement.placement.setStale()), Xe || qe) for (let Tt of this._order) {\n                      let Yt = this._layers[Tt];\n                      Yt.type === "symbol" && this.placement.updateLayerOpacities(Yt, ot[Yt.source]);\n                    }\n                    return !this.pauseablePlacement.isDone() || this.placement.hasTransitions(u4.now());\n                  }\n                  _releaseSymbolFadeTiles() {\n                    for (let w4 in this.sourceCaches) this.sourceCaches[w4].releaseSymbolFadeTiles();\n                  }\n                  getImages(w4, B4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let Q = yield this.imageManager.getImages(B4.icons);\n                      this._updateTilesForChangedImages();\n                      let ee = this.sourceCaches[B4.source];\n                      return ee && ee.setDependencies(B4.tileID.key, B4.type, B4.icons), Q;\n                    });\n                  }\n                  getGlyphs(w4, B4) {\n                    return a4._(this, void 0, void 0, function* () {\n                      let Q = yield this.glyphManager.getGlyphs(B4.stacks), ee = this.sourceCaches[B4.source];\n                      return ee && ee.setDependencies(B4.tileID.key, B4.type, [""]), Q;\n                    });\n                  }\n                  getGlyphsUrl() {\n                    return this.stylesheet.glyphs || null;\n                  }\n                  setGlyphs(w4, B4 = {}) {\n                    this._checkLoaded(), w4 && this._validate(a4.u.glyphs, "glyphs", w4, null, B4) || (this._glyphsDidChange = true, this.stylesheet.glyphs = w4, this.glyphManager.entries = {}, this.glyphManager.setURL(w4));\n                  }\n                  addSprite(w4, B4, Q = {}, ee) {\n                    this._checkLoaded();\n                    let le = [{ id: w4, url: B4 }], qe = [...C3(this.stylesheet.sprite), ...le];\n                    this._validate(a4.u.sprite, "sprite", qe, null, Q) || (this.stylesheet.sprite = qe, this._loadSprite(le, true, ee));\n                  }\n                  removeSprite(w4) {\n                    this._checkLoaded();\n                    let B4 = C3(this.stylesheet.sprite);\n                    if (B4.find((Q) => Q.id === w4)) {\n                      if (this._spritesImagesIds[w4]) for (let Q of this._spritesImagesIds[w4]) this.imageManager.removeImage(Q), this._changedImages[Q] = true;\n                      B4.splice(B4.findIndex((Q) => Q.id === w4), 1), this.stylesheet.sprite = B4.length > 0 ? B4 : void 0, delete this._spritesImagesIds[w4], this._availableImages = this.imageManager.listImages(), this._changed = true, this.dispatcher.broadcast("SI", this._availableImages), this.fire(new a4.k("data", { dataType: "style" }));\n                    } else this.fire(new a4.j(new Error(`Sprite "${w4}" doesn\'t exists on this map.`)));\n                  }\n                  getSprite() {\n                    return C3(this.stylesheet.sprite);\n                  }\n                  setSprite(w4, B4 = {}, Q) {\n                    this._checkLoaded(), w4 && this._validate(a4.u.sprite, "sprite", w4, null, B4) || (this.stylesheet.sprite = w4, w4 ? this._loadSprite(w4, true, Q) : (this._unloadSprite(), Q && Q(null)));\n                  }\n                }\n                var vo = a4.Y([{ name: "a_pos", type: "Int16", components: 2 }]);\n                let jn = { prelude: Mt(`#ifdef GL_ES\nprecision mediump float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\n`, `#ifdef GL_ES\nprecision highp float;\n#else\n#if !defined(lowp)\n#define lowp\n#endif\n#if !defined(mediump)\n#define mediump\n#endif\n#if !defined(highp)\n#define highp\n#endif\n#endif\nvec2 unpack_float(const float packedValue) {int packedIntValue=int(packedValue);int v0=packedIntValue/256;return vec2(v0,packedIntValue-v0*256);}vec2 unpack_opacity(const float packedOpacity) {int intOpacity=int(packedOpacity)/2;return vec2(float(intOpacity)/127.0,mod(packedOpacity,2.0));}vec4 decode_color(const vec2 encodedColor) {return vec4(unpack_float(encodedColor[0])/255.0,unpack_float(encodedColor[1])/255.0\n);}float unpack_mix_vec2(const vec2 packedValue,const float t) {return mix(packedValue[0],packedValue[1],t);}vec4 unpack_mix_color(const vec4 packedColors,const float t) {vec4 minColor=decode_color(vec2(packedColors[0],packedColors[1]));vec4 maxColor=decode_color(vec2(packedColors[2],packedColors[3]));return mix(minColor,maxColor,t);}vec2 get_pattern_pos(const vec2 pixel_coord_upper,const vec2 pixel_coord_lower,const vec2 pattern_size,const float tile_units_to_pixels,const vec2 pos) {vec2 offset=mod(mod(mod(pixel_coord_upper,pattern_size)*256.0,pattern_size)*256.0+pixel_coord_lower,pattern_size);return (tile_units_to_pixels*pos+offset)/pattern_size;}\n#ifdef TERRAIN3D\nuniform sampler2D u_terrain;uniform float u_terrain_dim;uniform mat4 u_terrain_matrix;uniform vec4 u_terrain_unpack;uniform float u_terrain_exaggeration;uniform highp sampler2D u_depth;\n#endif\nconst highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitShifts=vec4(1.)/bitSh;highp float unpack(highp vec4 color) {return dot(color,bitShifts);}highp float depthOpacity(vec3 frag) {\n#ifdef TERRAIN3D\nhighp float d=unpack(texture2D(u_depth,frag.xy*0.5+0.5))+0.0001-frag.z;return 1.0-max(0.0,min(1.0,-d*500.0));\n#else\nreturn 1.0;\n#endif\n}float calculate_visibility(vec4 pos) {\n#ifdef TERRAIN3D\nvec3 frag=pos.xyz/pos.w;highp float d=depthOpacity(frag);if (d > 0.95) return 1.0;return (d+depthOpacity(frag+vec3(0.0,0.01,0.0)))/2.0;\n#else\nreturn 1.0;\n#endif\n}float ele(vec2 pos) {\n#ifdef TERRAIN3D\nvec4 rgb=(texture2D(u_terrain,pos)*255.0)*u_terrain_unpack;return rgb.r+rgb.g+rgb.b-u_terrain_unpack.a;\n#else\nreturn 0.0;\n#endif\n}float get_elevation(vec2 pos) {\n#ifdef TERRAIN3D\nvec2 coord=(u_terrain_matrix*vec4(pos,0.0,1.0)).xy*u_terrain_dim+1.0;vec2 f=fract(coord);vec2 c=(floor(coord)+0.5)/(u_terrain_dim+2.0);float d=1.0/(u_terrain_dim+2.0);float tl=ele(c);float tr=ele(c+vec2(d,0.0));float bl=ele(c+vec2(0.0,d));float br=ele(c+vec2(d,d));float elevation=mix(mix(tl,tr,f.x),mix(bl,br,f.x),f.y);return elevation*u_terrain_exaggeration;\n#else\nreturn 0.0;\n#endif\n}`), background: Mt(`uniform vec4 u_color;uniform float u_opacity;void main() {gl_FragColor=u_color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), backgroundPattern: Mt(`uniform vec2 u_pattern_tl_a;uniform vec2 u_pattern_br_a;uniform vec2 u_pattern_tl_b;uniform vec2 u_pattern_br_b;uniform vec2 u_texsize;uniform float u_mix;uniform float u_opacity;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(u_pattern_tl_a/u_texsize,u_pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(u_pattern_tl_b/u_texsize,u_pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_mix)*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, "uniform mat4 u_matrix;uniform vec2 u_pattern_size_a;uniform vec2 u_pattern_size_b;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_scale_a;uniform float u_scale_b;uniform float u_tile_units_to_pixels;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_a*u_pattern_size_a,u_tile_units_to_pixels,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,u_scale_b*u_pattern_size_b,u_tile_units_to_pixels,a_pos);}"), circle: Mt(`varying vec3 v_data;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=v_data.xy;float extrude_length=length(extrude);float antialiased_blur=v_data.z;float opacity_t=smoothstep(0.0,antialiased_blur,extrude_length-1.0);float color_t=stroke_width < 0.01 ? 0.0 : smoothstep(antialiased_blur,0.0,extrude_length-radius/(radius+stroke_width));gl_FragColor=v_visibility*opacity_t*mix(color*opacity,stroke_color*stroke_opacity,color_t);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform bool u_scale_with_map;uniform bool u_pitch_with_map;uniform vec2 u_extrude_scale;uniform lowp float u_device_pixel_ratio;uniform highp float u_camera_to_center_distance;attribute vec2 a_pos;varying vec3 v_data;varying float v_visibility;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define mediump float radius\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define highp vec4 stroke_color\n#pragma mapbox: define mediump float stroke_width\n#pragma mapbox: define lowp float stroke_opacity\nvoid main(void) {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize mediump float radius\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize highp vec4 stroke_color\n#pragma mapbox: initialize mediump float stroke_width\n#pragma mapbox: initialize lowp float stroke_opacity\nvec2 extrude=vec2(mod(a_pos,2.0)*2.0-1.0);vec2 circle_center=floor(a_pos*0.5);float ele=get_elevation(circle_center);v_visibility=calculate_visibility(u_matrix*vec4(circle_center,ele,1.0));if (u_pitch_with_map) {vec2 corner_position=circle_center;if (u_scale_with_map) {corner_position+=extrude*(radius+stroke_width)*u_extrude_scale;} else {vec4 projected_center=u_matrix*vec4(circle_center,0,1);corner_position+=extrude*(radius+stroke_width)*u_extrude_scale*(projected_center.w/u_camera_to_center_distance);}gl_Position=u_matrix*vec4(corner_position,ele,1);} else {gl_Position=u_matrix*vec4(circle_center,ele,1);if (u_scale_with_map) {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*u_camera_to_center_distance;} else {gl_Position.xy+=extrude*(radius+stroke_width)*u_extrude_scale*gl_Position.w;}}float antialiasblur=-max(1.0/u_device_pixel_ratio/(radius+stroke_width),blur);v_data=vec3(extrude.x,extrude.y,antialiasblur);}`), clippingMask: Mt("void main() {gl_FragColor=vec4(1.0);}", "attribute vec2 a_pos;uniform mat4 u_matrix;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);}"), heatmap: Mt(`uniform highp float u_intensity;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#define GAUSS_COEF 0.3989422804014327\nvoid main() {\n#pragma mapbox: initialize highp float weight\nfloat d=-0.5*3.0*3.0*dot(v_extrude,v_extrude);float val=weight*u_intensity*GAUSS_COEF*exp(d);gl_FragColor=vec4(val,1.0,1.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform float u_extrude_scale;uniform float u_opacity;uniform float u_intensity;attribute vec2 a_pos;varying vec2 v_extrude;\n#pragma mapbox: define highp float weight\n#pragma mapbox: define mediump float radius\nconst highp float ZERO=1.0/255.0/16.0;\n#define GAUSS_COEF 0.3989422804014327\nvoid main(void) {\n#pragma mapbox: initialize highp float weight\n#pragma mapbox: initialize mediump float radius\nvec2 unscaled_extrude=vec2(mod(a_pos,2.0)*2.0-1.0);float S=sqrt(-2.0*log(ZERO/weight/u_intensity/GAUSS_COEF))/3.0;v_extrude=S*unscaled_extrude;vec2 extrude=v_extrude*radius*u_extrude_scale;vec4 pos=vec4(floor(a_pos*0.5)+extrude,get_elevation(floor(a_pos*0.5)),1);gl_Position=u_matrix*pos;}`), heatmapTexture: Mt(`uniform sampler2D u_image;uniform sampler2D u_color_ramp;uniform float u_opacity;varying vec2 v_pos;void main() {float t=texture2D(u_image,v_pos).r;vec4 color=texture2D(u_color_ramp,vec2(t,0.5));gl_FragColor=color*u_opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(0.0);\n#endif\n}`, "uniform mat4 u_matrix;uniform vec2 u_world;attribute vec2 a_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos*u_world,0,1);v_pos.x=a_pos.x;v_pos.y=1.0-a_pos.y;}"), collisionBox: Mt("varying float v_placed;varying float v_notUsed;void main() {float alpha=0.5;gl_FragColor=vec4(1.0,0.0,0.0,1.0)*alpha;if (v_placed > 0.5) {gl_FragColor=vec4(0.0,0.0,1.0,0.5)*alpha;}if (v_notUsed > 0.5) {gl_FragColor*=.1;}}", "attribute vec2 a_anchor_pos;attribute vec2 a_placed;attribute vec2 a_box_real;uniform mat4 u_matrix;uniform vec2 u_pixel_extrude_scale;varying float v_placed;varying float v_notUsed;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}void main() {gl_Position=projectTileWithElevation(a_anchor_pos,get_elevation(a_anchor_pos));gl_Position.xy=((a_box_real+0.5)*u_pixel_extrude_scale*2.0-1.0)*vec2(1.0,-1.0)*gl_Position.w;if (gl_Position.z/gl_Position.w < 1.1) {gl_Position.z=0.5;}v_placed=a_placed.x;v_notUsed=a_placed.y;}"), collisionCircle: Mt("varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;void main() {float alpha=0.5*min(v_perspective_ratio,1.0);float stroke_radius=0.9*max(v_perspective_ratio,1.0);float distance_to_center=length(v_extrude);float distance_to_edge=abs(distance_to_center-v_radius);float opacity_t=smoothstep(-stroke_radius,0.0,-distance_to_edge);vec4 color=mix(vec4(0.0,0.0,1.0,0.5),vec4(1.0,0.0,0.0,1.0),v_collision);gl_FragColor=color*alpha*opacity_t;}", "attribute vec2 a_pos;attribute float a_radius;attribute vec2 a_flags;uniform mat4 u_matrix;uniform mat4 u_inv_matrix;uniform vec2 u_viewport_size;uniform float u_camera_to_center_distance;varying float v_radius;varying vec2 v_extrude;varying float v_perspective_ratio;varying float v_collision;vec3 toTilePosition(vec2 screenPos) {vec4 rayStart=u_inv_matrix*vec4(screenPos,-1.0,1.0);vec4 rayEnd  =u_inv_matrix*vec4(screenPos, 1.0,1.0);rayStart.xyz/=rayStart.w;rayEnd.xyz  /=rayEnd.w;highp float t=(0.0-rayStart.z)/(rayEnd.z-rayStart.z);return mix(rayStart.xyz,rayEnd.xyz,t);}void main() {vec2 quadCenterPos=a_pos;float radius=a_radius;float collision=a_flags.x;float vertexIdx=a_flags.y;vec2 quadVertexOffset=vec2(mix(-1.0,1.0,float(vertexIdx >=2.0)),mix(-1.0,1.0,float(vertexIdx >=1.0 && vertexIdx <=2.0)));vec2 quadVertexExtent=quadVertexOffset*radius;vec3 tilePos=toTilePosition(quadCenterPos);vec4 clipPos=u_matrix*vec4(tilePos,1.0);highp float camera_to_anchor_distance=clipPos.w;highp float collision_perspective_ratio=clamp(0.5+0.5*(u_camera_to_center_distance/camera_to_anchor_distance),0.0,4.0);float padding_factor=1.2;v_radius=radius;v_extrude=quadVertexExtent*padding_factor;v_perspective_ratio=collision_perspective_ratio;v_collision=collision;gl_Position=vec4(clipPos.xyz/clipPos.w,1.0)+vec4(quadVertexExtent*padding_factor/u_viewport_size*2.0,0.0,0.0);}"), debug: Mt("uniform highp vec4 u_color;uniform sampler2D u_overlay;varying vec2 v_uv;void main() {vec4 overlay_color=texture2D(u_overlay,v_uv);gl_FragColor=mix(u_color,overlay_color,overlay_color.a);}", "attribute vec2 a_pos;varying vec2 v_uv;uniform mat4 u_matrix;uniform float u_overlay_scale;void main() {v_uv=a_pos/8192.0;gl_Position=u_matrix*vec4(a_pos*u_overlay_scale,get_elevation(a_pos),1);}"), fill: Mt(`#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_FragColor=color*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `attribute vec2 a_pos;uniform mat4 u_matrix;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);}`), fillOutline: Mt(`varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=outline_color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `attribute vec2 a_pos;uniform mat4 u_matrix;uniform vec2 u_world;varying vec2 v_pos;\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 outline_color\n#pragma mapbox: initialize lowp float opacity\ngl_Position=u_matrix*vec4(a_pos,0,1);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`), fillOutlinePattern: Mt(`uniform vec2 u_texsize;uniform sampler2D u_image;uniform float u_fade;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);float dist=length(v_pos-gl_FragCoord.xy);float alpha=1.0-smoothstep(0.0,1.0,dist);gl_FragColor=mix(color1,color2,u_fade)*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform vec2 u_world;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec2 v_pos;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;gl_Position=u_matrix*vec4(a_pos,0,1);vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,a_pos);v_pos=(gl_Position.xy/gl_Position.w+1.0)/2.0*u_world;}`), fillPattern: Mt(`#ifdef GL_ES\nprecision highp float;\n#endif\nuniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);gl_FragColor=mix(color1,color2,u_fade)*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform vec3 u_scale;attribute vec2 a_pos;varying vec2 v_pos_a;varying vec2 v_pos_b;\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;gl_Position=u_matrix*vec4(a_pos,0,1);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileZoomRatio,a_pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileZoomRatio,a_pos);}`), fillExtrusion: Mt(`varying vec4 v_color;void main() {gl_FragColor=v_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;uniform float u_vertical_gradient;uniform lowp float u_opacity;attribute vec2 a_pos;attribute vec4 a_normal_ed;\n#ifdef TERRAIN3D\nattribute vec2 a_centroid;\n#endif\nvarying vec4 v_color;\n#pragma mapbox: define highp float base\n#pragma mapbox: define highp float height\n#pragma mapbox: define highp vec4 color\nvoid main() {\n#pragma mapbox: initialize highp float base\n#pragma mapbox: initialize highp float height\n#pragma mapbox: initialize highp vec4 color\nvec3 normal=a_normal_ed.xyz;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);gl_Position=u_matrix*vec4(a_pos,t > 0.0 ? height : base,1);float colorvalue=color.r*0.2126+color.g*0.7152+color.b*0.0722;v_color=vec4(0.0,0.0,0.0,1.0);vec4 ambientlight=vec4(0.03,0.03,0.03,1.0);color+=ambientlight;float directional=clamp(dot(normal/16384.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((1.0-colorvalue+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_color.r+=clamp(color.r*directional*u_lightcolor.r,mix(0.0,0.3,1.0-u_lightcolor.r),1.0);v_color.g+=clamp(color.g*directional*u_lightcolor.g,mix(0.0,0.3,1.0-u_lightcolor.g),1.0);v_color.b+=clamp(color.b*directional*u_lightcolor.b,mix(0.0,0.3,1.0-u_lightcolor.b),1.0);v_color*=u_opacity;}`), fillExtrusionPattern: Mt(`uniform vec2 u_texsize;uniform float u_fade;uniform sampler2D u_image;varying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;vec2 imagecoord=mod(v_pos_a,1.0);vec2 pos=mix(pattern_tl_a/u_texsize,pattern_br_a/u_texsize,imagecoord);vec4 color1=texture2D(u_image,pos);vec2 imagecoord_b=mod(v_pos_b,1.0);vec2 pos2=mix(pattern_tl_b/u_texsize,pattern_br_b/u_texsize,imagecoord_b);vec4 color2=texture2D(u_image,pos2);vec4 mixedColor=mix(color1,color2,u_fade);gl_FragColor=mixedColor*v_lighting;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `uniform mat4 u_matrix;uniform vec2 u_pixel_coord_upper;uniform vec2 u_pixel_coord_lower;uniform float u_height_factor;uniform vec3 u_scale;uniform float u_vertical_gradient;uniform lowp float u_opacity;uniform vec3 u_lightcolor;uniform lowp vec3 u_lightpos;uniform lowp float u_lightintensity;attribute vec2 a_pos;attribute vec4 a_normal_ed;\n#ifdef TERRAIN3D\nattribute vec2 a_centroid;\n#endif\nvarying vec2 v_pos_a;varying vec2 v_pos_b;varying vec4 v_lighting;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float base\n#pragma mapbox: initialize lowp float height\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec3 normal=a_normal_ed.xyz;float edgedistance=a_normal_ed.w;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;\n#ifdef TERRAIN3D\nfloat height_terrain3d_offset=get_elevation(a_centroid);float base_terrain3d_offset=height_terrain3d_offset-(base > 0.0 ? 0.0 : 10.0);\n#else\nfloat height_terrain3d_offset=0.0;float base_terrain3d_offset=0.0;\n#endif\nbase=max(0.0,base)+base_terrain3d_offset;height=max(0.0,height)+height_terrain3d_offset;float t=mod(normal.x,2.0);float z=t > 0.0 ? height : base;gl_Position=u_matrix*vec4(a_pos,z,1);vec2 pos=normal.x==1.0 && normal.y==0.0 && normal.z==16384.0\n? a_pos\n: vec2(edgedistance,z*u_height_factor);v_pos_a=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,fromScale*display_size_a,tileRatio,pos);v_pos_b=get_pattern_pos(u_pixel_coord_upper,u_pixel_coord_lower,toScale*display_size_b,tileRatio,pos);v_lighting=vec4(0.0,0.0,0.0,1.0);float directional=clamp(dot(normal/16383.0,u_lightpos),0.0,1.0);directional=mix((1.0-u_lightintensity),max((0.5+u_lightintensity),1.0),directional);if (normal.y !=0.0) {directional*=((1.0-u_vertical_gradient)+(u_vertical_gradient*clamp((t+base)*pow(height/150.0,0.5),mix(0.7,0.98,1.0-u_lightintensity),1.0)));}v_lighting.rgb+=clamp(directional*u_lightcolor,mix(vec3(0.0),vec3(0.3),1.0-u_lightcolor),vec3(1.0));v_lighting*=u_opacity;}`), hillshadePrepare: Mt(`#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_dimension;uniform float u_zoom;uniform vec4 u_unpack;float getElevation(vec2 coord,float bias) {vec4 data=texture2D(u_image,coord)*255.0;data.a=-1.0;return dot(data,u_unpack)/4.0;}void main() {vec2 epsilon=1.0/u_dimension;float a=getElevation(v_pos+vec2(-epsilon.x,-epsilon.y),0.0);float b=getElevation(v_pos+vec2(0,-epsilon.y),0.0);float c=getElevation(v_pos+vec2(epsilon.x,-epsilon.y),0.0);float d=getElevation(v_pos+vec2(-epsilon.x,0),0.0);float e=getElevation(v_pos,0.0);float f=getElevation(v_pos+vec2(epsilon.x,0),0.0);float g=getElevation(v_pos+vec2(-epsilon.x,epsilon.y),0.0);float h=getElevation(v_pos+vec2(0,epsilon.y),0.0);float i=getElevation(v_pos+vec2(epsilon.x,epsilon.y),0.0);float exaggerationFactor=u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;float exaggeration=u_zoom < 15.0 ? (u_zoom-15.0)*exaggerationFactor : 0.0;vec2 deriv=vec2((c+f+f+i)-(a+d+d+g),(g+h+h+i)-(a+b+b+c))/pow(2.0,exaggeration+(19.2562-u_zoom));gl_FragColor=clamp(vec4(deriv.x/2.0+0.5,deriv.y/2.0+0.5,1.0,1.0),0.0,1.0);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, "uniform mat4 u_matrix;uniform vec2 u_dimension;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);highp vec2 epsilon=1.0/u_dimension;float scale=(u_dimension.x-2.0)/u_dimension.x;v_pos=(a_texture_pos/8192.0)*scale+epsilon;}"), hillshade: Mt(`uniform sampler2D u_image;varying vec2 v_pos;uniform vec2 u_latrange;uniform vec2 u_light;uniform vec4 u_shadow;uniform vec4 u_highlight;uniform vec4 u_accent;\n#define PI 3.141592653589793\nvoid main() {vec4 pixel=texture2D(u_image,v_pos);vec2 deriv=((pixel.rg*2.0)-1.0);float scaleFactor=cos(radians((u_latrange[0]-u_latrange[1])*(1.0-v_pos.y)+u_latrange[1]));float slope=atan(1.25*length(deriv)/scaleFactor);float aspect=deriv.x !=0.0 ? atan(deriv.y,-deriv.x) : PI/2.0*(deriv.y > 0.0 ? 1.0 :-1.0);float intensity=u_light.x;float azimuth=u_light.y+PI;float base=1.875-intensity*1.75;float maxValue=0.5*PI;float scaledSlope=intensity !=0.5 ? ((pow(base,slope)-1.0)/(pow(base,maxValue)-1.0))*maxValue : slope;float accent=cos(scaledSlope);vec4 accent_color=(1.0-accent)*u_accent*clamp(intensity*2.0,0.0,1.0);float shade=abs(mod((aspect+azimuth)/PI+0.5,2.0)-1.0);vec4 shade_color=mix(u_shadow,u_highlight,shade)*sin(scaledSlope)*clamp(intensity*2.0,0.0,1.0);gl_FragColor=accent_color*(1.0-shade_color.a)+shade_color;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, "uniform mat4 u_matrix;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos=a_texture_pos/8192.0;}"), line: Mt(`uniform lowp float u_device_pixel_ratio;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform vec2 u_units_to_pixels;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp float v_linesofar;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;v_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*2.0;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}`), lineGradient: Mt(`uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;varying vec2 v_width2;varying vec2 v_normal;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);vec4 color=texture2D(u_image,v_uv);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `\n#define scale 0.015873016\nattribute vec2 a_pos_normal;attribute vec4 a_data;attribute float a_uv_x;attribute float a_split_index;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_units_to_pixels;uniform float u_image_height;varying vec2 v_normal;varying vec2 v_width2;varying float v_gamma_scale;varying highp vec2 v_uv;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;highp float texel_height=1.0/u_image_height;highp float half_texel_height=0.5*texel_height;v_uv=vec2(a_uv_x,a_split_index*texel_height-half_texel_height);vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_width2=vec2(outset,inset);}`), linePattern: Mt(`#ifdef GL_ES\nprecision highp float;\n#endif\nuniform lowp float u_device_pixel_ratio;uniform vec2 u_texsize;uniform float u_fade;uniform mediump vec3 u_scale;uniform sampler2D u_image;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\nvec2 pattern_tl_a=pattern_from.xy;vec2 pattern_br_a=pattern_from.zw;vec2 pattern_tl_b=pattern_to.xy;vec2 pattern_br_b=pattern_to.zw;float tileZoomRatio=u_scale.x;float fromScale=u_scale.y;float toScale=u_scale.z;vec2 display_size_a=(pattern_br_a-pattern_tl_a)/pixel_ratio_from;vec2 display_size_b=(pattern_br_b-pattern_tl_b)/pixel_ratio_to;vec2 pattern_size_a=vec2(display_size_a.x*fromScale/tileZoomRatio,display_size_a.y);vec2 pattern_size_b=vec2(display_size_b.x*toScale/tileZoomRatio,display_size_b.y);float aspect_a=display_size_a.y/v_width;float aspect_b=display_size_b.y/v_width;float dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float x_a=mod(v_linesofar/pattern_size_a.x*aspect_a,1.0);float x_b=mod(v_linesofar/pattern_size_b.x*aspect_b,1.0);float y=0.5*v_normal.y+0.5;vec2 texel_size=1.0/u_texsize;vec2 pos_a=mix(pattern_tl_a*texel_size-texel_size,pattern_br_a*texel_size+texel_size,vec2(x_a,y));vec2 pos_b=mix(pattern_tl_b*texel_size-texel_size,pattern_br_b*texel_size+texel_size,vec2(x_b,y));vec4 color=mix(texture2D(u_image,pos_a),texture2D(u_image,pos_b),u_fade);gl_FragColor=color*alpha*opacity;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform vec2 u_units_to_pixels;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;varying vec2 v_normal;varying vec2 v_width2;varying float v_linesofar;varying float v_gamma_scale;varying float v_width;\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n#pragma mapbox: define lowp vec4 pattern_from\n#pragma mapbox: define lowp vec4 pattern_to\n#pragma mapbox: define lowp float pixel_ratio_from\n#pragma mapbox: define lowp float pixel_ratio_to\nvoid main() {\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\n#pragma mapbox: initialize mediump vec4 pattern_from\n#pragma mapbox: initialize mediump vec4 pattern_to\n#pragma mapbox: initialize lowp float pixel_ratio_from\n#pragma mapbox: initialize lowp float pixel_ratio_to\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_linesofar=a_linesofar;v_width2=vec2(outset,inset);v_width=floorwidth;}`), lineSDF: Mt(`uniform lowp float u_device_pixel_ratio;uniform sampler2D u_image;uniform float u_sdfgamma;uniform float u_mix;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat dist=length(v_normal)*v_width2.s;float blur2=(blur+1.0/u_device_pixel_ratio)*v_gamma_scale;float alpha=clamp(min(dist-(v_width2.t-blur2),v_width2.s-dist)/blur2,0.0,1.0);float sdfdist_a=texture2D(u_image,v_tex_a).a;float sdfdist_b=texture2D(u_image,v_tex_b).a;float sdfdist=mix(sdfdist_a,sdfdist_b,u_mix);alpha*=smoothstep(0.5-u_sdfgamma/floorwidth,0.5+u_sdfgamma/floorwidth,sdfdist);gl_FragColor=color*(alpha*opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `\n#define scale 0.015873016\n#define LINE_DISTANCE_SCALE 2.0\nattribute vec2 a_pos_normal;attribute vec4 a_data;uniform mat4 u_matrix;uniform mediump float u_ratio;uniform lowp float u_device_pixel_ratio;uniform vec2 u_patternscale_a;uniform float u_tex_y_a;uniform vec2 u_patternscale_b;uniform float u_tex_y_b;uniform vec2 u_units_to_pixels;varying vec2 v_normal;varying vec2 v_width2;varying vec2 v_tex_a;varying vec2 v_tex_b;varying float v_gamma_scale;\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\nvoid main() {\n#pragma mapbox: initialize highp vec4 color\n#pragma mapbox: initialize lowp float blur\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize mediump float gapwidth\n#pragma mapbox: initialize lowp float offset\n#pragma mapbox: initialize mediump float width\n#pragma mapbox: initialize lowp float floorwidth\nfloat ANTIALIASING=1.0/u_device_pixel_ratio/2.0;vec2 a_extrude=a_data.xy-128.0;float a_direction=mod(a_data.z,4.0)-1.0;float a_linesofar=(floor(a_data.z/4.0)+a_data.w*64.0)*LINE_DISTANCE_SCALE;vec2 pos=floor(a_pos_normal*0.5);mediump vec2 normal=a_pos_normal-2.0*pos;normal.y=normal.y*2.0-1.0;v_normal=normal;gapwidth=gapwidth/2.0;float halfwidth=width/2.0;offset=-1.0*offset;float inset=gapwidth+(gapwidth > 0.0 ? ANTIALIASING : 0.0);float outset=gapwidth+halfwidth*(gapwidth > 0.0 ? 2.0 : 1.0)+(halfwidth==0.0 ? 0.0 : ANTIALIASING);mediump vec2 dist=outset*a_extrude*scale;mediump float u=0.5*a_direction;mediump float t=1.0-abs(u);mediump vec2 offset2=offset*a_extrude*scale*normal.y*mat2(t,-u,u,t);vec4 projected_extrude=u_matrix*vec4(dist/u_ratio,0.0,0.0);gl_Position=u_matrix*vec4(pos+offset2/u_ratio,0.0,1.0)+projected_extrude;\n#ifdef TERRAIN3D\nv_gamma_scale=1.0;\n#else\nfloat extrude_length_without_perspective=length(dist);float extrude_length_with_perspective=length(projected_extrude.xy/gl_Position.w*u_units_to_pixels);v_gamma_scale=extrude_length_without_perspective/extrude_length_with_perspective;\n#endif\nv_tex_a=vec2(a_linesofar*u_patternscale_a.x/floorwidth,normal.y*u_patternscale_a.y+u_tex_y_a);v_tex_b=vec2(a_linesofar*u_patternscale_b.x/floorwidth,normal.y*u_patternscale_b.y+u_tex_y_b);v_width2=vec2(outset,inset);}`), raster: Mt(`uniform float u_fade_t;uniform float u_opacity;uniform sampler2D u_image0;uniform sampler2D u_image1;varying vec2 v_pos0;varying vec2 v_pos1;uniform float u_brightness_low;uniform float u_brightness_high;uniform float u_saturation_factor;uniform float u_contrast_factor;uniform vec3 u_spin_weights;void main() {vec4 color0=texture2D(u_image0,v_pos0);vec4 color1=texture2D(u_image1,v_pos1);if (color0.a > 0.0) {color0.rgb=color0.rgb/color0.a;}if (color1.a > 0.0) {color1.rgb=color1.rgb/color1.a;}vec4 color=mix(color0,color1,u_fade_t);color.a*=u_opacity;vec3 rgb=color.rgb;rgb=vec3(dot(rgb,u_spin_weights.xyz),dot(rgb,u_spin_weights.zxy),dot(rgb,u_spin_weights.yzx));float average=(color.r+color.g+color.b)/3.0;rgb+=(average-rgb)*u_saturation_factor;rgb=(rgb-0.5)*u_contrast_factor+0.5;vec3 u_high_vec=vec3(u_brightness_low,u_brightness_low,u_brightness_low);vec3 u_low_vec=vec3(u_brightness_high,u_brightness_high,u_brightness_high);gl_FragColor=vec4(mix(u_high_vec,u_low_vec,rgb)*color.a,color.a);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, "uniform mat4 u_matrix;uniform vec2 u_tl_parent;uniform float u_scale_parent;uniform float u_buffer_scale;attribute vec2 a_pos;attribute vec2 a_texture_pos;varying vec2 v_pos0;varying vec2 v_pos1;void main() {gl_Position=u_matrix*vec4(a_pos,0,1);v_pos0=(((a_texture_pos/8192.0)-0.5)/u_buffer_scale )+0.5;v_pos1=(v_pos0*u_scale_parent)+u_tl_parent;}"), symbolIcon: Mt(`uniform sampler2D u_texture;varying vec2 v_tex;varying float v_fade_opacity;\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nlowp float alpha=opacity*v_fade_opacity;gl_FragColor=texture2D(u_texture,v_tex)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform highp float u_camera_to_center_distance;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform float u_fade_change;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform vec2 u_texsize;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_tex;varying float v_fade_opacity;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define lowp float opacity\nvoid main() {\n#pragma mapbox: initialize lowp float opacity\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;vec2 a_minFontScale=a_pixeloffset.zw/256.0;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*max(a_minFontScale,fontScale)+a_pxoffset/16.0)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}gl_Position=finalPos;v_tex=a_tex/u_texsize;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float visibility=calculate_visibility(projectedPoint);v_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));}`), symbolSDF: Mt(`#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec4 a_pixeloffset;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec2 v_data0;varying vec3 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);vec2 a_pxoffset=a_pixeloffset.xy;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=u_is_text ? size/24.0 : size;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale+a_pxoffset)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0=a_tex/u_texsize;v_data1=vec3(gamma_scale,size,interpolated_fade_opacity);}`), symbolTextAndIcon: Mt(`#define SDF_PX 8.0\n#define SDF 1.0\n#define ICON 0.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform sampler2D u_texture_icon;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;varying vec4 v_data0;varying vec4 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat fade_opacity=v_data1[2];if (v_data1.w==ICON) {vec2 tex_icon=v_data0.zw;lowp float alpha=opacity*fade_opacity;gl_FragColor=texture2D(u_texture_icon,tex_icon)*alpha;\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\nreturn;}vec2 tex=v_data0.xy;float EDGE_GAMMA=0.105/u_device_pixel_ratio;float gamma_scale=v_data1.x;float size=v_data1.y;float fontScale=size/24.0;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}`, `attribute vec4 a_pos_offset;attribute vec4 a_data;attribute vec3 a_projected_pos;attribute float a_fade_opacity;uniform bool u_is_size_zoom_constant;uniform bool u_is_size_feature_constant;uniform highp float u_size_t;uniform highp float u_size;uniform mat4 u_matrix;uniform mat4 u_label_plane_matrix;uniform mat4 u_coord_matrix;uniform bool u_is_text;uniform bool u_pitch_with_map;uniform highp float u_pitch;uniform bool u_rotate_symbol;uniform highp float u_aspect_ratio;uniform highp float u_camera_to_center_distance;uniform float u_fade_change;uniform vec2 u_texsize;uniform vec2 u_texsize_icon;uniform bool u_is_along_line;uniform bool u_is_variable_anchor;uniform vec2 u_translation;uniform float u_pitched_scale;varying vec4 v_data0;varying vec4 v_data1;vec4 projectTileWithElevation(vec2 posInTile,float elevation) {return u_matrix*vec4(posInTile,elevation,1.0);}\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nvec2 a_pos=a_pos_offset.xy;vec2 a_offset=a_pos_offset.zw;vec2 a_tex=a_data.xy;vec2 a_size=a_data.zw;float a_size_min=floor(a_size[0]*0.5);float is_sdf=a_size[0]-2.0*a_size_min;float ele=get_elevation(a_pos);highp float segment_angle=-a_projected_pos[2];float size;if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {size=mix(a_size_min,a_size[1],u_size_t)/128.0;} else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {size=a_size_min/128.0;} else {size=u_size;}vec2 translated_a_pos=a_pos+u_translation;vec4 projectedPoint=projectTileWithElevation(translated_a_pos,ele);highp float camera_to_anchor_distance=projectedPoint.w;highp float distance_ratio=u_pitch_with_map ?\ncamera_to_anchor_distance/u_camera_to_center_distance :\nu_camera_to_center_distance/camera_to_anchor_distance;highp float perspective_ratio=clamp(0.5+0.5*distance_ratio,0.0,4.0);size*=perspective_ratio;float fontScale=size/24.0;highp float symbol_rotation=0.0;if (u_rotate_symbol) {vec4 offsetProjectedPoint=projectTileWithElevation(translated_a_pos+vec2(1,0),ele);vec2 a=projectedPoint.xy/projectedPoint.w;vec2 b=offsetProjectedPoint.xy/offsetProjectedPoint.w;symbol_rotation=atan((b.y-a.y)/u_aspect_ratio,b.x-a.x);}highp float angle_sin=sin(segment_angle+symbol_rotation);highp float angle_cos=cos(segment_angle+symbol_rotation);mat2 rotation_matrix=mat2(angle_cos,-1.0*angle_sin,angle_sin,angle_cos);vec4 projected_pos;if (u_is_along_line || u_is_variable_anchor) {projected_pos=vec4(a_projected_pos.xy,ele,1.0);} else if (u_pitch_with_map) {projected_pos=u_label_plane_matrix*vec4(a_projected_pos.xy+u_translation,ele,1.0);} else {projected_pos=u_label_plane_matrix*projectTileWithElevation(a_projected_pos.xy+u_translation,ele);}float z=float(u_pitch_with_map)*projected_pos.z/projected_pos.w;float projectionScaling=1.0;vec4 finalPos=u_coord_matrix*vec4(projected_pos.xy/projected_pos.w+rotation_matrix*(a_offset/32.0*fontScale)*projectionScaling,z,1.0);if(u_pitch_with_map) {finalPos=projectTileWithElevation(finalPos.xy,finalPos.z);}float gamma_scale=finalPos.w;gl_Position=finalPos;vec2 fade_opacity=unpack_opacity(a_fade_opacity);float visibility=calculate_visibility(projectedPoint);float fade_change=fade_opacity[1] > 0.5 ? u_fade_change :-u_fade_change;float interpolated_fade_opacity=max(0.0,min(visibility,fade_opacity[0]+fade_change));v_data0.xy=a_tex/u_texsize;v_data0.zw=a_tex/u_texsize_icon;v_data1=vec4(gamma_scale,size,interpolated_fade_opacity,is_sdf);}`), terrain: Mt("uniform sampler2D u_texture;uniform vec4 u_fog_color;uniform vec4 u_horizon_color;uniform float u_fog_ground_blend;uniform float u_fog_ground_blend_opacity;uniform float u_horizon_fog_blend;varying vec2 v_texture_pos;varying float v_fog_depth;const float gamma=2.2;vec4 gammaToLinear(vec4 color) {return pow(color,vec4(gamma));}vec4 linearToGamma(vec4 color) {return pow(color,vec4(1.0/gamma));}void main() {vec4 surface_color=texture2D(u_texture,v_texture_pos);if (v_fog_depth > u_fog_ground_blend) {vec4 surface_color_linear=gammaToLinear(surface_color);float blend_color=smoothstep(0.0,1.0,max((v_fog_depth-u_horizon_fog_blend)/(1.0-u_horizon_fog_blend),0.0));vec4 fog_horizon_color_linear=mix(gammaToLinear(u_fog_color),gammaToLinear(u_horizon_color),blend_color);float factor_fog=max(v_fog_depth-u_fog_ground_blend,0.0)/(1.0-u_fog_ground_blend);gl_FragColor=linearToGamma(mix(surface_color_linear,fog_horizon_color_linear,pow(factor_fog,2.0)*u_fog_ground_blend_opacity));} else {gl_FragColor=surface_color;}}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform mat4 u_fog_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;varying float v_fog_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);vec4 pos=u_fog_matrix*vec4(a_pos3d.xy,ele,1.0);v_fog_depth=pos.z/pos.w*0.5+0.5;}"), terrainDepth: Mt("varying float v_depth;const highp vec4 bitSh=vec4(256.*256.*256.,256.*256.,256.,1.);const highp vec4 bitMsk=vec4(0.,vec3(1./256.0));highp vec4 pack(highp float value) {highp vec4 comp=fract(value*bitSh);comp-=comp.xxyz*bitMsk;return comp;}void main() {gl_FragColor=pack(v_depth);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying float v_depth;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);v_depth=gl_Position.z/gl_Position.w;}"), terrainCoords: Mt("precision mediump float;uniform sampler2D u_texture;uniform float u_terrain_coords_id;varying vec2 v_texture_pos;void main() {vec4 rgba=texture2D(u_texture,v_texture_pos);gl_FragColor=vec4(rgba.r,rgba.g,rgba.b,u_terrain_coords_id);}", "attribute vec3 a_pos3d;uniform mat4 u_matrix;uniform float u_ele_delta;varying vec2 v_texture_pos;void main() {float ele=get_elevation(a_pos3d.xy);float ele_delta=a_pos3d.z==1.0 ? u_ele_delta : 0.0;v_texture_pos=a_pos3d.xy/8192.0;gl_Position=u_matrix*vec4(a_pos3d.xy,ele-ele_delta,1.0);}"), sky: Mt("uniform vec4 u_sky_color;uniform vec4 u_horizon_color;uniform float u_horizon;uniform float u_sky_horizon_blend;void main() {float y=gl_FragCoord.y;if (y > u_horizon) {float blend=y-u_horizon;if (blend < u_sky_horizon_blend) {gl_FragColor=mix(u_sky_color,u_horizon_color,pow(1.0-blend/u_sky_horizon_blend,2.0));} else {gl_FragColor=u_sky_color;}}}", "attribute vec2 a_pos;void main() {gl_Position=vec4(a_pos,1.0,1.0);}") };\n                function Mt(ue, w4) {\n                  let B4 = /#pragma mapbox: ([\\w]+) ([\\w]+) ([\\w]+) ([\\w]+)/g, Q = w4.match(/attribute ([\\w]+) ([\\w]+)/g), ee = ue.match(/uniform ([\\w]+) ([\\w]+)([\\s]*)([\\w]*)/g), le = w4.match(/uniform ([\\w]+) ([\\w]+)([\\s]*)([\\w]*)/g), qe = le ? le.concat(ee) : ee, Xe = {};\n                  return { fragmentSource: ue = ue.replace(B4, (ot, Tt, Yt, Kt, xr) => (Xe[xr] = true, Tt === "define" ? `\n#ifndef HAS_UNIFORM_u_${xr}\nvarying ${Yt} ${Kt} ${xr};\n#else\nuniform ${Yt} ${Kt} u_${xr};\n#endif\n` : `\n#ifdef HAS_UNIFORM_u_${xr}\n    ${Yt} ${Kt} ${xr} = u_${xr};\n#endif\n`)), vertexSource: w4 = w4.replace(B4, (ot, Tt, Yt, Kt, xr) => {\n                    let Ir = Kt === "float" ? "vec2" : "vec4", ve = xr.match(/color/) ? "color" : Ir;\n                    return Xe[xr] ? Tt === "define" ? `\n#ifndef HAS_UNIFORM_u_${xr}\nuniform lowp float u_${xr}_t;\nattribute ${Yt} ${Ir} a_${xr};\nvarying ${Yt} ${Kt} ${xr};\n#else\nuniform ${Yt} ${Kt} u_${xr};\n#endif\n` : ve === "vec4" ? `\n#ifndef HAS_UNIFORM_u_${xr}\n    ${xr} = a_${xr};\n#else\n    ${Yt} ${Kt} ${xr} = u_${xr};\n#endif\n` : `\n#ifndef HAS_UNIFORM_u_${xr}\n    ${xr} = unpack_mix_${ve}(a_${xr}, u_${xr}_t);\n#else\n    ${Yt} ${Kt} ${xr} = u_${xr};\n#endif\n` : Tt === "define" ? `\n#ifndef HAS_UNIFORM_u_${xr}\nuniform lowp float u_${xr}_t;\nattribute ${Yt} ${Ir} a_${xr};\n#else\nuniform ${Yt} ${Kt} u_${xr};\n#endif\n` : ve === "vec4" ? `\n#ifndef HAS_UNIFORM_u_${xr}\n    ${Yt} ${Kt} ${xr} = a_${xr};\n#else\n    ${Yt} ${Kt} ${xr} = u_${xr};\n#endif\n` : `\n#ifndef HAS_UNIFORM_u_${xr}\n    ${Yt} ${Kt} ${xr} = unpack_mix_${ve}(a_${xr}, u_${xr}_t);\n#else\n    ${Yt} ${Kt} ${xr} = u_${xr};\n#endif\n`;\n                  }), staticAttributes: Q, staticUniforms: qe };\n                }\n                class kr {\n                  constructor() {\n                    this.boundProgram = null, this.boundLayoutVertexBuffer = null, this.boundPaintVertexBuffers = [], this.boundIndexBuffer = null, this.boundVertexOffset = null, this.boundDynamicVertexBuffer = null, this.vao = null;\n                  }\n                  bind(w4, B4, Q, ee, le, qe, Xe, ot, Tt) {\n                    this.context = w4;\n                    let Yt = this.boundPaintVertexBuffers.length !== ee.length;\n                    for (let Kt = 0; !Yt && Kt < ee.length; Kt++) this.boundPaintVertexBuffers[Kt] !== ee[Kt] && (Yt = true);\n                    !this.vao || this.boundProgram !== B4 || this.boundLayoutVertexBuffer !== Q || Yt || this.boundIndexBuffer !== le || this.boundVertexOffset !== qe || this.boundDynamicVertexBuffer !== Xe || this.boundDynamicVertexBuffer2 !== ot || this.boundDynamicVertexBuffer3 !== Tt ? this.freshBind(B4, Q, ee, le, qe, Xe, ot, Tt) : (w4.bindVertexArray.set(this.vao), Xe && Xe.bind(), le && le.dynamicDraw && le.bind(), ot && ot.bind(), Tt && Tt.bind());\n                  }\n                  freshBind(w4, B4, Q, ee, le, qe, Xe, ot) {\n                    let Tt = w4.numAttributes, Yt = this.context, Kt = Yt.gl;\n                    this.vao && this.destroy(), this.vao = Yt.createVertexArray(), Yt.bindVertexArray.set(this.vao), this.boundProgram = w4, this.boundLayoutVertexBuffer = B4, this.boundPaintVertexBuffers = Q, this.boundIndexBuffer = ee, this.boundVertexOffset = le, this.boundDynamicVertexBuffer = qe, this.boundDynamicVertexBuffer2 = Xe, this.boundDynamicVertexBuffer3 = ot, B4.enableAttributes(Kt, w4);\n                    for (let xr of Q) xr.enableAttributes(Kt, w4);\n                    qe && qe.enableAttributes(Kt, w4), Xe && Xe.enableAttributes(Kt, w4), ot && ot.enableAttributes(Kt, w4), B4.bind(), B4.setVertexAttribPointers(Kt, w4, le);\n                    for (let xr of Q) xr.bind(), xr.setVertexAttribPointers(Kt, w4, le);\n                    qe && (qe.bind(), qe.setVertexAttribPointers(Kt, w4, le)), ee && ee.bind(), Xe && (Xe.bind(), Xe.setVertexAttribPointers(Kt, w4, le)), ot && (ot.bind(), ot.setVertexAttribPointers(Kt, w4, le)), Yt.currentNumAttributes = Tt;\n                  }\n                  destroy() {\n                    this.vao && (this.context.deleteVertexArray(this.vao), this.vao = null);\n                  }\n                }\n                let Jr = (ue, w4, B4, Q, ee) => ({ u_matrix: ue, u_texture: 0, u_ele_delta: w4, u_fog_matrix: B4, u_fog_color: Q ? Q.properties.get("fog-color") : a4.aM.white, u_fog_ground_blend: Q ? Q.properties.get("fog-ground-blend") : 1, u_fog_ground_blend_opacity: Q ? Q.calculateFogBlendOpacity(ee) : 0, u_horizon_color: Q ? Q.properties.get("horizon-color") : a4.aM.white, u_horizon_fog_blend: Q ? Q.properties.get("horizon-fog-blend") : 1 });\n                function vi(ue) {\n                  let w4 = [];\n                  for (let B4 = 0; B4 < ue.length; B4++) {\n                    if (ue[B4] === null) continue;\n                    let Q = ue[B4].split(" ");\n                    w4.push(Q.pop());\n                  }\n                  return w4;\n                }\n                class hn {\n                  constructor(w4, B4, Q, ee, le, qe) {\n                    let Xe = w4.gl;\n                    this.program = Xe.createProgram();\n                    let ot = vi(B4.staticAttributes), Tt = Q ? Q.getBinderAttributes() : [], Yt = ot.concat(Tt), Kt = jn.prelude.staticUniforms ? vi(jn.prelude.staticUniforms) : [], xr = B4.staticUniforms ? vi(B4.staticUniforms) : [], Ir = Q ? Q.getBinderUniforms() : [], ve = Kt.concat(xr).concat(Ir), be = [];\n                    for (let Ht of ve) be.indexOf(Ht) < 0 && be.push(Ht);\n                    let De = Q ? Q.defines() : [];\n                    le && De.push("#define OVERDRAW_INSPECTOR;"), qe && De.push("#define TERRAIN3D;");\n                    let Be = De.concat(jn.prelude.fragmentSource, B4.fragmentSource).join(`\n`), et = De.concat(jn.prelude.vertexSource, B4.vertexSource).join(`\n`), We = Xe.createShader(Xe.FRAGMENT_SHADER);\n                    if (Xe.isContextLost()) return void (this.failedToCreate = true);\n                    if (Xe.shaderSource(We, Be), Xe.compileShader(We), !Xe.getShaderParameter(We, Xe.COMPILE_STATUS)) throw new Error(`Could not compile fragment shader: ${Xe.getShaderInfoLog(We)}`);\n                    Xe.attachShader(this.program, We);\n                    let it = Xe.createShader(Xe.VERTEX_SHADER);\n                    if (Xe.isContextLost()) return void (this.failedToCreate = true);\n                    if (Xe.shaderSource(it, et), Xe.compileShader(it), !Xe.getShaderParameter(it, Xe.COMPILE_STATUS)) throw new Error(`Could not compile vertex shader: ${Xe.getShaderInfoLog(it)}`);\n                    Xe.attachShader(this.program, it), this.attributes = {};\n                    let Ft = {};\n                    this.numAttributes = Yt.length;\n                    for (let Ht = 0; Ht < this.numAttributes; Ht++) Yt[Ht] && (Xe.bindAttribLocation(this.program, Ht, Yt[Ht]), this.attributes[Yt[Ht]] = Ht);\n                    if (Xe.linkProgram(this.program), !Xe.getProgramParameter(this.program, Xe.LINK_STATUS)) throw new Error(`Program failed to link: ${Xe.getProgramInfoLog(this.program)}`);\n                    Xe.deleteShader(it), Xe.deleteShader(We);\n                    for (let Ht = 0; Ht < be.length; Ht++) {\n                      let tr = be[Ht];\n                      if (tr && !Ft[tr]) {\n                        let dr = Xe.getUniformLocation(this.program, tr);\n                        dr && (Ft[tr] = dr);\n                      }\n                    }\n                    this.fixedUniforms = ee(w4, Ft), this.terrainUniforms = ((Ht, tr) => ({ u_depth: new a4.aH(Ht, tr.u_depth), u_terrain: new a4.aH(Ht, tr.u_terrain), u_terrain_dim: new a4.aI(Ht, tr.u_terrain_dim), u_terrain_matrix: new a4.aJ(Ht, tr.u_terrain_matrix), u_terrain_unpack: new a4.aK(Ht, tr.u_terrain_unpack), u_terrain_exaggeration: new a4.aI(Ht, tr.u_terrain_exaggeration) }))(w4, Ft), this.binderUniforms = Q ? Q.getUniforms(w4, Ft) : [];\n                  }\n                  draw(w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir, ve, be, De, Be, et) {\n                    let We = w4.gl;\n                    if (this.failedToCreate) return;\n                    if (w4.program.set(this.program), w4.setDepthMode(Q), w4.setStencilMode(ee), w4.setColorMode(le), w4.setCullFace(qe), ot) {\n                      w4.activeTexture.set(We.TEXTURE2), We.bindTexture(We.TEXTURE_2D, ot.depthTexture), w4.activeTexture.set(We.TEXTURE3), We.bindTexture(We.TEXTURE_2D, ot.texture);\n                      for (let Ft in this.terrainUniforms) this.terrainUniforms[Ft].set(ot[Ft]);\n                    }\n                    for (let Ft in this.fixedUniforms) this.fixedUniforms[Ft].set(Xe[Ft]);\n                    be && be.setUniforms(w4, this.binderUniforms, Ir, { zoom: ve });\n                    let it = 0;\n                    switch (B4) {\n                      case We.LINES:\n                        it = 2;\n                        break;\n                      case We.TRIANGLES:\n                        it = 3;\n                        break;\n                      case We.LINE_STRIP:\n                        it = 1;\n                    }\n                    for (let Ft of xr.get()) {\n                      let Ht = Ft.vaos || (Ft.vaos = {});\n                      (Ht[Tt] || (Ht[Tt] = new kr())).bind(w4, this, Yt, be ? be.getPaintVertexBuffers() : [], Kt, Ft.vertexOffset, De, Be, et), We.drawElements(B4, Ft.primitiveLength * it, We.UNSIGNED_SHORT, Ft.primitiveOffset * it * 2);\n                    }\n                  }\n                }\n                function An(ue, w4, B4) {\n                  let Q = 1 / In(B4, 1, w4.transform.tileZoom), ee = Math.pow(2, B4.tileID.overscaledZ), le = B4.tileSize * Math.pow(2, w4.transform.tileZoom) / ee, qe = le * (B4.tileID.canonical.x + B4.tileID.wrap * ee), Xe = le * B4.tileID.canonical.y;\n                  return { u_image: 0, u_texsize: B4.imageAtlasTexture.size, u_scale: [Q, ue.fromScale, ue.toScale], u_fade: ue.t, u_pixel_coord_upper: [qe >> 16, Xe >> 16], u_pixel_coord_lower: [65535 & qe, 65535 & Xe] };\n                }\n                let Mn = (ue, w4, B4, Q) => {\n                  let ee = w4.style.light, le = ee.properties.get("position"), qe = [le.x, le.y, le.z], Xe = (function() {\n                    var Tt = new a4.A(9);\n                    return a4.A != Float32Array && (Tt[1] = 0, Tt[2] = 0, Tt[3] = 0, Tt[5] = 0, Tt[6] = 0, Tt[7] = 0), Tt[0] = 1, Tt[4] = 1, Tt[8] = 1, Tt;\n                  })();\n                  ee.properties.get("anchor") === "viewport" && (function(Tt, Yt) {\n                    var Kt = Math.sin(Yt), xr = Math.cos(Yt);\n                    Tt[0] = xr, Tt[1] = Kt, Tt[2] = 0, Tt[3] = -Kt, Tt[4] = xr, Tt[5] = 0, Tt[6] = 0, Tt[7] = 0, Tt[8] = 1;\n                  })(Xe, -w4.transform.angle), (function(Tt, Yt, Kt) {\n                    var xr = Yt[0], Ir = Yt[1], ve = Yt[2];\n                    Tt[0] = xr * Kt[0] + Ir * Kt[3] + ve * Kt[6], Tt[1] = xr * Kt[1] + Ir * Kt[4] + ve * Kt[7], Tt[2] = xr * Kt[2] + Ir * Kt[5] + ve * Kt[8];\n                  })(qe, qe, Xe);\n                  let ot = ee.properties.get("color");\n                  return { u_matrix: ue, u_lightpos: qe, u_lightintensity: ee.properties.get("intensity"), u_lightcolor: [ot.r, ot.g, ot.b], u_vertical_gradient: +B4, u_opacity: Q };\n                }, Li = (ue, w4, B4, Q, ee, le, qe) => a4.e(Mn(ue, w4, B4, Q), An(le, w4, qe), { u_height_factor: -Math.pow(2, ee.overscaledZ) / qe.tileSize / 8 }), _n = (ue) => ({ u_matrix: ue }), ya = (ue, w4, B4, Q) => a4.e(_n(ue), An(B4, w4, Q)), Jn = (ue, w4) => ({ u_matrix: ue, u_world: w4 }), Ma = (ue, w4, B4, Q, ee) => a4.e(ya(ue, w4, B4, Q), { u_world: ee }), _o = (ue, w4, B4, Q) => {\n                  let ee = ue.transform, le, qe;\n                  if (Q.paint.get("circle-pitch-alignment") === "map") {\n                    let Xe = In(B4, 1, ee.zoom);\n                    le = true, qe = [Xe, Xe];\n                  } else le = false, qe = ee.pixelsToGLUnits;\n                  return { u_camera_to_center_distance: ee.cameraToCenterDistance, u_scale_with_map: +(Q.paint.get("circle-pitch-scale") === "map"), u_matrix: ue.translatePosMatrix(w4.posMatrix, B4, Q.paint.get("circle-translate"), Q.paint.get("circle-translate-anchor")), u_pitch_with_map: +le, u_device_pixel_ratio: ue.pixelRatio, u_extrude_scale: qe };\n                }, No = (ue, w4, B4) => ({ u_matrix: ue, u_inv_matrix: w4, u_camera_to_center_distance: B4.cameraToCenterDistance, u_viewport_size: [B4.width, B4.height] }), po = (ue, w4, B4 = 1) => ({ u_matrix: ue, u_color: w4, u_overlay: 0, u_overlay_scale: B4 }), Lo = (ue) => ({ u_matrix: ue }), ko = (ue, w4, B4, Q) => ({ u_matrix: ue, u_extrude_scale: In(w4, 1, B4), u_intensity: Q }), Ds = (ue, w4, B4, Q) => {\n                  let ee = a4.H();\n                  a4.aP(ee, 0, ue.width, ue.height, 0, 0, 1);\n                  let le = ue.context.gl;\n                  return { u_matrix: ee, u_world: [le.drawingBufferWidth, le.drawingBufferHeight], u_image: B4, u_color_ramp: Q, u_opacity: w4.paint.get("heatmap-opacity") };\n                };\n                function Fs(ue, w4) {\n                  let B4 = Math.pow(2, w4.canonical.z), Q = w4.canonical.y;\n                  return [new a4.Z(0, Q / B4).toLngLat().lat, new a4.Z(0, (Q + 1) / B4).toLngLat().lat];\n                }\n                let ll = (ue, w4, B4, Q) => {\n                  let ee = ue.transform;\n                  return { u_matrix: As(ue, w4, B4, Q), u_ratio: 1 / In(w4, 1, ee.zoom), u_device_pixel_ratio: ue.pixelRatio, u_units_to_pixels: [1 / ee.pixelsToGLUnits[0], 1 / ee.pixelsToGLUnits[1]] };\n                }, ul = (ue, w4, B4, Q, ee) => a4.e(ll(ue, w4, B4, ee), { u_image: 0, u_image_height: Q }), zl = (ue, w4, B4, Q, ee) => {\n                  let le = ue.transform, qe = il(w4, le);\n                  return { u_matrix: As(ue, w4, B4, ee), u_texsize: w4.imageAtlasTexture.size, u_ratio: 1 / In(w4, 1, le.zoom), u_device_pixel_ratio: ue.pixelRatio, u_image: 0, u_scale: [qe, Q.fromScale, Q.toScale], u_fade: Q.t, u_units_to_pixels: [1 / le.pixelsToGLUnits[0], 1 / le.pixelsToGLUnits[1]] };\n                }, us = (ue, w4, B4, Q, ee, le) => {\n                  let qe = ue.lineAtlas, Xe = il(w4, ue.transform), ot = B4.layout.get("line-cap") === "round", Tt = qe.getDash(Q.from, ot), Yt = qe.getDash(Q.to, ot), Kt = Tt.width * ee.fromScale, xr = Yt.width * ee.toScale;\n                  return a4.e(ll(ue, w4, B4, le), { u_patternscale_a: [Xe / Kt, -Tt.height / 2], u_patternscale_b: [Xe / xr, -Yt.height / 2], u_sdfgamma: qe.width / (256 * Math.min(Kt, xr) * ue.pixelRatio) / 2, u_image: 0, u_tex_y_a: Tt.y, u_tex_y_b: Yt.y, u_mix: ee.t });\n                };\n                function il(ue, w4) {\n                  return 1 / In(ue, 1, w4.tileZoom);\n                }\n                function As(ue, w4, B4, Q) {\n                  return ue.translatePosMatrix(Q ? Q.posMatrix : w4.tileID.posMatrix, w4, B4.paint.get("line-translate"), B4.paint.get("line-translate-anchor"));\n                }\n                let cl = (ue, w4, B4, Q, ee) => {\n                  return { u_matrix: ue, u_tl_parent: w4, u_scale_parent: B4, u_buffer_scale: 1, u_fade_t: Q.mix, u_opacity: Q.opacity * ee.paint.get("raster-opacity"), u_image0: 0, u_image1: 1, u_brightness_low: ee.paint.get("raster-brightness-min"), u_brightness_high: ee.paint.get("raster-brightness-max"), u_saturation_factor: (qe = ee.paint.get("raster-saturation"), qe > 0 ? 1 - 1 / (1.001 - qe) : -qe), u_contrast_factor: (le = ee.paint.get("raster-contrast"), le > 0 ? 1 / (1 - le) : 1 + le), u_spin_weights: Ks(ee.paint.get("raster-hue-rotate")) };\n                  var le, qe;\n                };\n                function Ks(ue) {\n                  ue *= Math.PI / 180;\n                  let w4 = Math.sin(ue), B4 = Math.cos(ue);\n                  return [(2 * B4 + 1) / 3, (-Math.sqrt(3) * w4 - B4 + 1) / 3, (Math.sqrt(3) * w4 - B4 + 1) / 3];\n                }\n                let zs = (ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir) => {\n                  let ve = qe.transform;\n                  return { u_is_size_zoom_constant: +(ue === "constant" || ue === "source"), u_is_size_feature_constant: +(ue === "constant" || ue === "camera"), u_size_t: w4 ? w4.uSizeT : 0, u_size: w4 ? w4.uSize : 0, u_camera_to_center_distance: ve.cameraToCenterDistance, u_pitch: ve.pitch / 360 * 2 * Math.PI, u_rotate_symbol: +B4, u_aspect_ratio: ve.width / ve.height, u_fade_change: qe.options.fadeDuration ? qe.symbolFadeChange : 1, u_matrix: Xe, u_label_plane_matrix: ot, u_coord_matrix: Tt, u_is_text: +Kt, u_pitch_with_map: +Q, u_is_along_line: ee, u_is_variable_anchor: le, u_texsize: xr, u_texture: 0, u_translation: Yt, u_pitched_scale: Ir };\n                }, Io = (ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir, ve) => {\n                  let be = qe.transform;\n                  return a4.e(zs(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, ve), { u_gamma_scale: Q ? Math.cos(be._pitch) * be.cameraToCenterDistance : 1, u_device_pixel_ratio: qe.pixelRatio, u_is_halo: +Ir });\n                }, ls = (ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir) => a4.e(Io(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, true, Kt, true, Ir), { u_texsize_icon: xr, u_texture_icon: 1 }), Zl = (ue, w4, B4) => ({ u_matrix: ue, u_opacity: w4, u_color: B4 }), Su = (ue, w4, B4, Q, ee, le) => a4.e((function(qe, Xe, ot, Tt) {\n                  let Yt = ot.imageManager.getPattern(qe.from.toString()), Kt = ot.imageManager.getPattern(qe.to.toString()), { width: xr, height: Ir } = ot.imageManager.getPixelSize(), ve = Math.pow(2, Tt.tileID.overscaledZ), be = Tt.tileSize * Math.pow(2, ot.transform.tileZoom) / ve, De = be * (Tt.tileID.canonical.x + Tt.tileID.wrap * ve), Be = be * Tt.tileID.canonical.y;\n                  return { u_image: 0, u_pattern_tl_a: Yt.tl, u_pattern_br_a: Yt.br, u_pattern_tl_b: Kt.tl, u_pattern_br_b: Kt.br, u_texsize: [xr, Ir], u_mix: Xe.t, u_pattern_size_a: Yt.displaySize, u_pattern_size_b: Kt.displaySize, u_scale_a: Xe.fromScale, u_scale_b: Xe.toScale, u_tile_units_to_pixels: 1 / In(Tt, 1, ot.transform.tileZoom), u_pixel_coord_upper: [De >> 16, Be >> 16], u_pixel_coord_lower: [65535 & De, 65535 & Be] };\n                })(Q, le, B4, ee), { u_matrix: ue, u_opacity: w4 }), nc = { fillExtrusion: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_lightpos: new a4.aN(ue, w4.u_lightpos), u_lightintensity: new a4.aI(ue, w4.u_lightintensity), u_lightcolor: new a4.aN(ue, w4.u_lightcolor), u_vertical_gradient: new a4.aI(ue, w4.u_vertical_gradient), u_opacity: new a4.aI(ue, w4.u_opacity) }), fillExtrusionPattern: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_lightpos: new a4.aN(ue, w4.u_lightpos), u_lightintensity: new a4.aI(ue, w4.u_lightintensity), u_lightcolor: new a4.aN(ue, w4.u_lightcolor), u_vertical_gradient: new a4.aI(ue, w4.u_vertical_gradient), u_height_factor: new a4.aI(ue, w4.u_height_factor), u_image: new a4.aH(ue, w4.u_image), u_texsize: new a4.aO(ue, w4.u_texsize), u_pixel_coord_upper: new a4.aO(ue, w4.u_pixel_coord_upper), u_pixel_coord_lower: new a4.aO(ue, w4.u_pixel_coord_lower), u_scale: new a4.aN(ue, w4.u_scale), u_fade: new a4.aI(ue, w4.u_fade), u_opacity: new a4.aI(ue, w4.u_opacity) }), fill: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix) }), fillPattern: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_image: new a4.aH(ue, w4.u_image), u_texsize: new a4.aO(ue, w4.u_texsize), u_pixel_coord_upper: new a4.aO(ue, w4.u_pixel_coord_upper), u_pixel_coord_lower: new a4.aO(ue, w4.u_pixel_coord_lower), u_scale: new a4.aN(ue, w4.u_scale), u_fade: new a4.aI(ue, w4.u_fade) }), fillOutline: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_world: new a4.aO(ue, w4.u_world) }), fillOutlinePattern: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_world: new a4.aO(ue, w4.u_world), u_image: new a4.aH(ue, w4.u_image), u_texsize: new a4.aO(ue, w4.u_texsize), u_pixel_coord_upper: new a4.aO(ue, w4.u_pixel_coord_upper), u_pixel_coord_lower: new a4.aO(ue, w4.u_pixel_coord_lower), u_scale: new a4.aN(ue, w4.u_scale), u_fade: new a4.aI(ue, w4.u_fade) }), circle: (ue, w4) => ({ u_camera_to_center_distance: new a4.aI(ue, w4.u_camera_to_center_distance), u_scale_with_map: new a4.aH(ue, w4.u_scale_with_map), u_pitch_with_map: new a4.aH(ue, w4.u_pitch_with_map), u_extrude_scale: new a4.aO(ue, w4.u_extrude_scale), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_matrix: new a4.aJ(ue, w4.u_matrix) }), collisionBox: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_pixel_extrude_scale: new a4.aO(ue, w4.u_pixel_extrude_scale) }), collisionCircle: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_inv_matrix: new a4.aJ(ue, w4.u_inv_matrix), u_camera_to_center_distance: new a4.aI(ue, w4.u_camera_to_center_distance), u_viewport_size: new a4.aO(ue, w4.u_viewport_size) }), debug: (ue, w4) => ({ u_color: new a4.aL(ue, w4.u_color), u_matrix: new a4.aJ(ue, w4.u_matrix), u_overlay: new a4.aH(ue, w4.u_overlay), u_overlay_scale: new a4.aI(ue, w4.u_overlay_scale) }), clippingMask: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix) }), heatmap: (ue, w4) => ({ u_extrude_scale: new a4.aI(ue, w4.u_extrude_scale), u_intensity: new a4.aI(ue, w4.u_intensity), u_matrix: new a4.aJ(ue, w4.u_matrix) }), heatmapTexture: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_world: new a4.aO(ue, w4.u_world), u_image: new a4.aH(ue, w4.u_image), u_color_ramp: new a4.aH(ue, w4.u_color_ramp), u_opacity: new a4.aI(ue, w4.u_opacity) }), hillshade: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_image: new a4.aH(ue, w4.u_image), u_latrange: new a4.aO(ue, w4.u_latrange), u_light: new a4.aO(ue, w4.u_light), u_shadow: new a4.aL(ue, w4.u_shadow), u_highlight: new a4.aL(ue, w4.u_highlight), u_accent: new a4.aL(ue, w4.u_accent) }), hillshadePrepare: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_image: new a4.aH(ue, w4.u_image), u_dimension: new a4.aO(ue, w4.u_dimension), u_zoom: new a4.aI(ue, w4.u_zoom), u_unpack: new a4.aK(ue, w4.u_unpack) }), line: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_ratio: new a4.aI(ue, w4.u_ratio), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_units_to_pixels: new a4.aO(ue, w4.u_units_to_pixels) }), lineGradient: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_ratio: new a4.aI(ue, w4.u_ratio), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_units_to_pixels: new a4.aO(ue, w4.u_units_to_pixels), u_image: new a4.aH(ue, w4.u_image), u_image_height: new a4.aI(ue, w4.u_image_height) }), linePattern: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_texsize: new a4.aO(ue, w4.u_texsize), u_ratio: new a4.aI(ue, w4.u_ratio), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_image: new a4.aH(ue, w4.u_image), u_units_to_pixels: new a4.aO(ue, w4.u_units_to_pixels), u_scale: new a4.aN(ue, w4.u_scale), u_fade: new a4.aI(ue, w4.u_fade) }), lineSDF: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_ratio: new a4.aI(ue, w4.u_ratio), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_units_to_pixels: new a4.aO(ue, w4.u_units_to_pixels), u_patternscale_a: new a4.aO(ue, w4.u_patternscale_a), u_patternscale_b: new a4.aO(ue, w4.u_patternscale_b), u_sdfgamma: new a4.aI(ue, w4.u_sdfgamma), u_image: new a4.aH(ue, w4.u_image), u_tex_y_a: new a4.aI(ue, w4.u_tex_y_a), u_tex_y_b: new a4.aI(ue, w4.u_tex_y_b), u_mix: new a4.aI(ue, w4.u_mix) }), raster: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_tl_parent: new a4.aO(ue, w4.u_tl_parent), u_scale_parent: new a4.aI(ue, w4.u_scale_parent), u_buffer_scale: new a4.aI(ue, w4.u_buffer_scale), u_fade_t: new a4.aI(ue, w4.u_fade_t), u_opacity: new a4.aI(ue, w4.u_opacity), u_image0: new a4.aH(ue, w4.u_image0), u_image1: new a4.aH(ue, w4.u_image1), u_brightness_low: new a4.aI(ue, w4.u_brightness_low), u_brightness_high: new a4.aI(ue, w4.u_brightness_high), u_saturation_factor: new a4.aI(ue, w4.u_saturation_factor), u_contrast_factor: new a4.aI(ue, w4.u_contrast_factor), u_spin_weights: new a4.aN(ue, w4.u_spin_weights) }), symbolIcon: (ue, w4) => ({ u_is_size_zoom_constant: new a4.aH(ue, w4.u_is_size_zoom_constant), u_is_size_feature_constant: new a4.aH(ue, w4.u_is_size_feature_constant), u_size_t: new a4.aI(ue, w4.u_size_t), u_size: new a4.aI(ue, w4.u_size), u_camera_to_center_distance: new a4.aI(ue, w4.u_camera_to_center_distance), u_pitch: new a4.aI(ue, w4.u_pitch), u_rotate_symbol: new a4.aH(ue, w4.u_rotate_symbol), u_aspect_ratio: new a4.aI(ue, w4.u_aspect_ratio), u_fade_change: new a4.aI(ue, w4.u_fade_change), u_matrix: new a4.aJ(ue, w4.u_matrix), u_label_plane_matrix: new a4.aJ(ue, w4.u_label_plane_matrix), u_coord_matrix: new a4.aJ(ue, w4.u_coord_matrix), u_is_text: new a4.aH(ue, w4.u_is_text), u_pitch_with_map: new a4.aH(ue, w4.u_pitch_with_map), u_is_along_line: new a4.aH(ue, w4.u_is_along_line), u_is_variable_anchor: new a4.aH(ue, w4.u_is_variable_anchor), u_texsize: new a4.aO(ue, w4.u_texsize), u_texture: new a4.aH(ue, w4.u_texture), u_translation: new a4.aO(ue, w4.u_translation), u_pitched_scale: new a4.aI(ue, w4.u_pitched_scale) }), symbolSDF: (ue, w4) => ({ u_is_size_zoom_constant: new a4.aH(ue, w4.u_is_size_zoom_constant), u_is_size_feature_constant: new a4.aH(ue, w4.u_is_size_feature_constant), u_size_t: new a4.aI(ue, w4.u_size_t), u_size: new a4.aI(ue, w4.u_size), u_camera_to_center_distance: new a4.aI(ue, w4.u_camera_to_center_distance), u_pitch: new a4.aI(ue, w4.u_pitch), u_rotate_symbol: new a4.aH(ue, w4.u_rotate_symbol), u_aspect_ratio: new a4.aI(ue, w4.u_aspect_ratio), u_fade_change: new a4.aI(ue, w4.u_fade_change), u_matrix: new a4.aJ(ue, w4.u_matrix), u_label_plane_matrix: new a4.aJ(ue, w4.u_label_plane_matrix), u_coord_matrix: new a4.aJ(ue, w4.u_coord_matrix), u_is_text: new a4.aH(ue, w4.u_is_text), u_pitch_with_map: new a4.aH(ue, w4.u_pitch_with_map), u_is_along_line: new a4.aH(ue, w4.u_is_along_line), u_is_variable_anchor: new a4.aH(ue, w4.u_is_variable_anchor), u_texsize: new a4.aO(ue, w4.u_texsize), u_texture: new a4.aH(ue, w4.u_texture), u_gamma_scale: new a4.aI(ue, w4.u_gamma_scale), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_is_halo: new a4.aH(ue, w4.u_is_halo), u_translation: new a4.aO(ue, w4.u_translation), u_pitched_scale: new a4.aI(ue, w4.u_pitched_scale) }), symbolTextAndIcon: (ue, w4) => ({ u_is_size_zoom_constant: new a4.aH(ue, w4.u_is_size_zoom_constant), u_is_size_feature_constant: new a4.aH(ue, w4.u_is_size_feature_constant), u_size_t: new a4.aI(ue, w4.u_size_t), u_size: new a4.aI(ue, w4.u_size), u_camera_to_center_distance: new a4.aI(ue, w4.u_camera_to_center_distance), u_pitch: new a4.aI(ue, w4.u_pitch), u_rotate_symbol: new a4.aH(ue, w4.u_rotate_symbol), u_aspect_ratio: new a4.aI(ue, w4.u_aspect_ratio), u_fade_change: new a4.aI(ue, w4.u_fade_change), u_matrix: new a4.aJ(ue, w4.u_matrix), u_label_plane_matrix: new a4.aJ(ue, w4.u_label_plane_matrix), u_coord_matrix: new a4.aJ(ue, w4.u_coord_matrix), u_is_text: new a4.aH(ue, w4.u_is_text), u_pitch_with_map: new a4.aH(ue, w4.u_pitch_with_map), u_is_along_line: new a4.aH(ue, w4.u_is_along_line), u_is_variable_anchor: new a4.aH(ue, w4.u_is_variable_anchor), u_texsize: new a4.aO(ue, w4.u_texsize), u_texsize_icon: new a4.aO(ue, w4.u_texsize_icon), u_texture: new a4.aH(ue, w4.u_texture), u_texture_icon: new a4.aH(ue, w4.u_texture_icon), u_gamma_scale: new a4.aI(ue, w4.u_gamma_scale), u_device_pixel_ratio: new a4.aI(ue, w4.u_device_pixel_ratio), u_is_halo: new a4.aH(ue, w4.u_is_halo), u_translation: new a4.aO(ue, w4.u_translation), u_pitched_scale: new a4.aI(ue, w4.u_pitched_scale) }), background: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_opacity: new a4.aI(ue, w4.u_opacity), u_color: new a4.aL(ue, w4.u_color) }), backgroundPattern: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_opacity: new a4.aI(ue, w4.u_opacity), u_image: new a4.aH(ue, w4.u_image), u_pattern_tl_a: new a4.aO(ue, w4.u_pattern_tl_a), u_pattern_br_a: new a4.aO(ue, w4.u_pattern_br_a), u_pattern_tl_b: new a4.aO(ue, w4.u_pattern_tl_b), u_pattern_br_b: new a4.aO(ue, w4.u_pattern_br_b), u_texsize: new a4.aO(ue, w4.u_texsize), u_mix: new a4.aI(ue, w4.u_mix), u_pattern_size_a: new a4.aO(ue, w4.u_pattern_size_a), u_pattern_size_b: new a4.aO(ue, w4.u_pattern_size_b), u_scale_a: new a4.aI(ue, w4.u_scale_a), u_scale_b: new a4.aI(ue, w4.u_scale_b), u_pixel_coord_upper: new a4.aO(ue, w4.u_pixel_coord_upper), u_pixel_coord_lower: new a4.aO(ue, w4.u_pixel_coord_lower), u_tile_units_to_pixels: new a4.aI(ue, w4.u_tile_units_to_pixels) }), terrain: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_texture: new a4.aH(ue, w4.u_texture), u_ele_delta: new a4.aI(ue, w4.u_ele_delta), u_fog_matrix: new a4.aJ(ue, w4.u_fog_matrix), u_fog_color: new a4.aL(ue, w4.u_fog_color), u_fog_ground_blend: new a4.aI(ue, w4.u_fog_ground_blend), u_fog_ground_blend_opacity: new a4.aI(ue, w4.u_fog_ground_blend_opacity), u_horizon_color: new a4.aL(ue, w4.u_horizon_color), u_horizon_fog_blend: new a4.aI(ue, w4.u_horizon_fog_blend) }), terrainDepth: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_ele_delta: new a4.aI(ue, w4.u_ele_delta) }), terrainCoords: (ue, w4) => ({ u_matrix: new a4.aJ(ue, w4.u_matrix), u_texture: new a4.aH(ue, w4.u_texture), u_terrain_coords_id: new a4.aI(ue, w4.u_terrain_coords_id), u_ele_delta: new a4.aI(ue, w4.u_ele_delta) }), sky: (ue, w4) => ({ u_sky_color: new a4.aL(ue, w4.u_sky_color), u_horizon_color: new a4.aL(ue, w4.u_horizon_color), u_horizon: new a4.aI(ue, w4.u_horizon), u_sky_horizon_blend: new a4.aI(ue, w4.u_sky_horizon_blend) }) };\n                class bs {\n                  constructor(w4, B4, Q) {\n                    this.context = w4;\n                    let ee = w4.gl;\n                    this.buffer = ee.createBuffer(), this.dynamicDraw = !!Q, this.context.unbindVAO(), w4.bindElementBuffer.set(this.buffer), ee.bufferData(ee.ELEMENT_ARRAY_BUFFER, B4.arrayBuffer, this.dynamicDraw ? ee.DYNAMIC_DRAW : ee.STATIC_DRAW), this.dynamicDraw || delete B4.arrayBuffer;\n                  }\n                  bind() {\n                    this.context.bindElementBuffer.set(this.buffer);\n                  }\n                  updateData(w4) {\n                    let B4 = this.context.gl;\n                    if (!this.dynamicDraw) throw new Error("Attempted to update data while not in dynamic mode.");\n                    this.context.unbindVAO(), this.bind(), B4.bufferSubData(B4.ELEMENT_ARRAY_BUFFER, 0, w4.arrayBuffer);\n                  }\n                  destroy() {\n                    this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);\n                  }\n                }\n                let Rn = { Int8: "BYTE", Uint8: "UNSIGNED_BYTE", Int16: "SHORT", Uint16: "UNSIGNED_SHORT", Int32: "INT", Uint32: "UNSIGNED_INT", Float32: "FLOAT" };\n                class _a {\n                  constructor(w4, B4, Q, ee) {\n                    this.length = B4.length, this.attributes = Q, this.itemSize = B4.bytesPerElement, this.dynamicDraw = ee, this.context = w4;\n                    let le = w4.gl;\n                    this.buffer = le.createBuffer(), w4.bindVertexBuffer.set(this.buffer), le.bufferData(le.ARRAY_BUFFER, B4.arrayBuffer, this.dynamicDraw ? le.DYNAMIC_DRAW : le.STATIC_DRAW), this.dynamicDraw || delete B4.arrayBuffer;\n                  }\n                  bind() {\n                    this.context.bindVertexBuffer.set(this.buffer);\n                  }\n                  updateData(w4) {\n                    if (w4.length !== this.length) throw new Error(`Length of new data is ${w4.length}, which doesn\'t match current length of ${this.length}`);\n                    let B4 = this.context.gl;\n                    this.bind(), B4.bufferSubData(B4.ARRAY_BUFFER, 0, w4.arrayBuffer);\n                  }\n                  enableAttributes(w4, B4) {\n                    for (let Q = 0; Q < this.attributes.length; Q++) {\n                      let ee = B4.attributes[this.attributes[Q].name];\n                      ee !== void 0 && w4.enableVertexAttribArray(ee);\n                    }\n                  }\n                  setVertexAttribPointers(w4, B4, Q) {\n                    for (let ee = 0; ee < this.attributes.length; ee++) {\n                      let le = this.attributes[ee], qe = B4.attributes[le.name];\n                      qe !== void 0 && w4.vertexAttribPointer(qe, le.components, w4[Rn[le.type]], false, this.itemSize, le.offset + this.itemSize * (Q || 0));\n                    }\n                  }\n                  destroy() {\n                    this.buffer && (this.context.gl.deleteBuffer(this.buffer), delete this.buffer);\n                  }\n                }\n                let Vu = /* @__PURE__ */ new WeakMap();\n                function Ol(ue) {\n                  var w4;\n                  if (Vu.has(ue)) return Vu.get(ue);\n                  {\n                    let B4 = (w4 = ue.getParameter(ue.VERSION)) === null || w4 === void 0 ? void 0 : w4.startsWith("WebGL 2.0");\n                    return Vu.set(ue, B4), B4;\n                  }\n                }\n                class xo {\n                  constructor(w4) {\n                    this.gl = w4.gl, this.default = this.getDefault(), this.current = this.default, this.dirty = false;\n                  }\n                  get() {\n                    return this.current;\n                  }\n                  set(w4) {\n                  }\n                  getDefault() {\n                    return this.default;\n                  }\n                  setDefault() {\n                    this.set(this.default);\n                  }\n                }\n                class Yl extends xo {\n                  getDefault() {\n                    return a4.aM.transparent;\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4.r !== B4.r || w4.g !== B4.g || w4.b !== B4.b || w4.a !== B4.a || this.dirty) && (this.gl.clearColor(w4.r, w4.g, w4.b, w4.a), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Ns extends xo {\n                  getDefault() {\n                    return 1;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.clearDepth(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Hl extends xo {\n                  getDefault() {\n                    return 0;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.clearStencil(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class ac extends xo {\n                  getDefault() {\n                    return [true, true, true, true];\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4[0] !== B4[0] || w4[1] !== B4[1] || w4[2] !== B4[2] || w4[3] !== B4[3] || this.dirty) && (this.gl.colorMask(w4[0], w4[1], w4[2], w4[3]), this.current = w4, this.dirty = false);\n                  }\n                }\n                class aa extends xo {\n                  getDefault() {\n                    return true;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.depthMask(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Oo extends xo {\n                  getDefault() {\n                    return 255;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.stencilMask(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class qo extends xo {\n                  getDefault() {\n                    return { func: this.gl.ALWAYS, ref: 0, mask: 255 };\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4.func !== B4.func || w4.ref !== B4.ref || w4.mask !== B4.mask || this.dirty) && (this.gl.stencilFunc(w4.func, w4.ref, w4.mask), this.current = w4, this.dirty = false);\n                  }\n                }\n                class ql extends xo {\n                  getDefault() {\n                    let w4 = this.gl;\n                    return [w4.KEEP, w4.KEEP, w4.KEEP];\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4[0] !== B4[0] || w4[1] !== B4[1] || w4[2] !== B4[2] || this.dirty) && (this.gl.stencilOp(w4[0], w4[1], w4[2]), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Pc extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    w4 ? B4.enable(B4.STENCIL_TEST) : B4.disable(B4.STENCIL_TEST), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Do extends xo {\n                  getDefault() {\n                    return [0, 1];\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4[0] !== B4[0] || w4[1] !== B4[1] || this.dirty) && (this.gl.depthRange(w4[0], w4[1]), this.current = w4, this.dirty = false);\n                  }\n                }\n                class rf extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    w4 ? B4.enable(B4.DEPTH_TEST) : B4.disable(B4.DEPTH_TEST), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Uf extends xo {\n                  getDefault() {\n                    return this.gl.LESS;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.depthFunc(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class pl extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    w4 ? B4.enable(B4.BLEND) : B4.disable(B4.BLEND), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Zc extends xo {\n                  getDefault() {\n                    let w4 = this.gl;\n                    return [w4.ONE, w4.ZERO];\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4[0] !== B4[0] || w4[1] !== B4[1] || this.dirty) && (this.gl.blendFunc(w4[0], w4[1]), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Kl extends xo {\n                  getDefault() {\n                    return a4.aM.transparent;\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4.r !== B4.r || w4.g !== B4.g || w4.b !== B4.b || w4.a !== B4.a || this.dirty) && (this.gl.blendColor(w4.r, w4.g, w4.b, w4.a), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Os extends xo {\n                  getDefault() {\n                    return this.gl.FUNC_ADD;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.blendEquation(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class yu extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    w4 ? B4.enable(B4.CULL_FACE) : B4.disable(B4.CULL_FACE), this.current = w4, this.dirty = false;\n                  }\n                }\n                class oc extends xo {\n                  getDefault() {\n                    return this.gl.BACK;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.cullFace(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Cf extends xo {\n                  getDefault() {\n                    return this.gl.CCW;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.frontFace(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class sc extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.useProgram(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Vh extends xo {\n                  getDefault() {\n                    return this.gl.TEXTURE0;\n                  }\n                  set(w4) {\n                    (w4 !== this.current || this.dirty) && (this.gl.activeTexture(w4), this.current = w4, this.dirty = false);\n                  }\n                }\n                class Lf extends xo {\n                  getDefault() {\n                    let w4 = this.gl;\n                    return [0, 0, w4.drawingBufferWidth, w4.drawingBufferHeight];\n                  }\n                  set(w4) {\n                    let B4 = this.current;\n                    (w4[0] !== B4[0] || w4[1] !== B4[1] || w4[2] !== B4[2] || w4[3] !== B4[3] || this.dirty) && (this.gl.viewport(w4[0], w4[1], w4[2], w4[3]), this.current = w4, this.dirty = false);\n                  }\n                }\n                class cs extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.bindFramebuffer(B4.FRAMEBUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class nf extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.bindRenderbuffer(B4.RENDERBUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Vf extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.bindTexture(B4.TEXTURE_2D, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Jl extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.bindBuffer(B4.ARRAY_BUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class fl extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    let B4 = this.gl;\n                    B4.bindBuffer(B4.ELEMENT_ARRAY_BUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class lc extends xo {\n                  getDefault() {\n                    return null;\n                  }\n                  set(w4) {\n                    var B4;\n                    if (w4 === this.current && !this.dirty) return;\n                    let Q = this.gl;\n                    Ol(Q) ? Q.bindVertexArray(w4) : (B4 = Q.getExtension("OES_vertex_array_object")) === null || B4 === void 0 || B4.bindVertexArrayOES(w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Fu extends xo {\n                  getDefault() {\n                    return 4;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.pixelStorei(B4.UNPACK_ALIGNMENT, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Es extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.pixelStorei(B4.UNPACK_PREMULTIPLY_ALPHA_WEBGL, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Hs extends xo {\n                  getDefault() {\n                    return false;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    let B4 = this.gl;\n                    B4.pixelStorei(B4.UNPACK_FLIP_Y_WEBGL, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Go extends xo {\n                  constructor(w4, B4) {\n                    super(w4), this.context = w4, this.parent = B4;\n                  }\n                  getDefault() {\n                    return null;\n                  }\n                }\n                class ps extends Go {\n                  setDirty() {\n                    this.dirty = true;\n                  }\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    this.context.bindFramebuffer.set(this.parent);\n                    let B4 = this.gl;\n                    B4.framebufferTexture2D(B4.FRAMEBUFFER, B4.COLOR_ATTACHMENT0, B4.TEXTURE_2D, w4, 0), this.current = w4, this.dirty = false;\n                  }\n                }\n                class uc extends Go {\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    this.context.bindFramebuffer.set(this.parent);\n                    let B4 = this.gl;\n                    B4.framebufferRenderbuffer(B4.FRAMEBUFFER, B4.DEPTH_ATTACHMENT, B4.RENDERBUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class xl extends Go {\n                  set(w4) {\n                    if (w4 === this.current && !this.dirty) return;\n                    this.context.bindFramebuffer.set(this.parent);\n                    let B4 = this.gl;\n                    B4.framebufferRenderbuffer(B4.FRAMEBUFFER, B4.DEPTH_STENCIL_ATTACHMENT, B4.RENDERBUFFER, w4), this.current = w4, this.dirty = false;\n                  }\n                }\n                class Gu {\n                  constructor(w4, B4, Q, ee, le) {\n                    this.context = w4, this.width = B4, this.height = Q;\n                    let qe = w4.gl, Xe = this.framebuffer = qe.createFramebuffer();\n                    if (this.colorAttachment = new ps(w4, Xe), ee) this.depthAttachment = le ? new xl(w4, Xe) : new uc(w4, Xe);\n                    else if (le) throw new Error("Stencil cannot be set without depth");\n                    if (qe.checkFramebufferStatus(qe.FRAMEBUFFER) !== qe.FRAMEBUFFER_COMPLETE) throw new Error("Framebuffer is not complete");\n                  }\n                  destroy() {\n                    let w4 = this.context.gl, B4 = this.colorAttachment.get();\n                    if (B4 && w4.deleteTexture(B4), this.depthAttachment) {\n                      let Q = this.depthAttachment.get();\n                      Q && w4.deleteRenderbuffer(Q);\n                    }\n                    w4.deleteFramebuffer(this.framebuffer);\n                  }\n                }\n                class qs {\n                  constructor(w4, B4, Q) {\n                    this.blendFunction = w4, this.blendColor = B4, this.mask = Q;\n                  }\n                }\n                qs.Replace = [1, 0], qs.disabled = new qs(qs.Replace, a4.aM.transparent, [false, false, false, false]), qs.unblended = new qs(qs.Replace, a4.aM.transparent, [true, true, true, true]), qs.alphaBlended = new qs([1, 771], a4.aM.transparent, [true, true, true, true]);\n                class ad {\n                  constructor(w4) {\n                    var B4, Q;\n                    if (this.gl = w4, this.clearColor = new Yl(this), this.clearDepth = new Ns(this), this.clearStencil = new Hl(this), this.colorMask = new ac(this), this.depthMask = new aa(this), this.stencilMask = new Oo(this), this.stencilFunc = new qo(this), this.stencilOp = new ql(this), this.stencilTest = new Pc(this), this.depthRange = new Do(this), this.depthTest = new rf(this), this.depthFunc = new Uf(this), this.blend = new pl(this), this.blendFunc = new Zc(this), this.blendColor = new Kl(this), this.blendEquation = new Os(this), this.cullFace = new yu(this), this.cullFaceSide = new oc(this), this.frontFace = new Cf(this), this.program = new sc(this), this.activeTexture = new Vh(this), this.viewport = new Lf(this), this.bindFramebuffer = new cs(this), this.bindRenderbuffer = new nf(this), this.bindTexture = new Vf(this), this.bindVertexBuffer = new Jl(this), this.bindElementBuffer = new fl(this), this.bindVertexArray = new lc(this), this.pixelStoreUnpack = new Fu(this), this.pixelStoreUnpackPremultiplyAlpha = new Es(this), this.pixelStoreUnpackFlipY = new Hs(this), this.extTextureFilterAnisotropic = w4.getExtension("EXT_texture_filter_anisotropic") || w4.getExtension("MOZ_EXT_texture_filter_anisotropic") || w4.getExtension("WEBKIT_EXT_texture_filter_anisotropic"), this.extTextureFilterAnisotropic && (this.extTextureFilterAnisotropicMax = w4.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)), this.maxTextureSize = w4.getParameter(w4.MAX_TEXTURE_SIZE), Ol(w4)) {\n                      this.HALF_FLOAT = w4.HALF_FLOAT;\n                      let ee = w4.getExtension("EXT_color_buffer_half_float");\n                      this.RGBA16F = (B4 = w4.RGBA16F) !== null && B4 !== void 0 ? B4 : ee == null ? void 0 : ee.RGBA16F_EXT, this.RGB16F = (Q = w4.RGB16F) !== null && Q !== void 0 ? Q : ee == null ? void 0 : ee.RGB16F_EXT, w4.getExtension("EXT_color_buffer_float");\n                    } else {\n                      w4.getExtension("EXT_color_buffer_half_float"), w4.getExtension("OES_texture_half_float_linear");\n                      let ee = w4.getExtension("OES_texture_half_float");\n                      this.HALF_FLOAT = ee == null ? void 0 : ee.HALF_FLOAT_OES;\n                    }\n                  }\n                  setDefault() {\n                    this.unbindVAO(), this.clearColor.setDefault(), this.clearDepth.setDefault(), this.clearStencil.setDefault(), this.colorMask.setDefault(), this.depthMask.setDefault(), this.stencilMask.setDefault(), this.stencilFunc.setDefault(), this.stencilOp.setDefault(), this.stencilTest.setDefault(), this.depthRange.setDefault(), this.depthTest.setDefault(), this.depthFunc.setDefault(), this.blend.setDefault(), this.blendFunc.setDefault(), this.blendColor.setDefault(), this.blendEquation.setDefault(), this.cullFace.setDefault(), this.cullFaceSide.setDefault(), this.frontFace.setDefault(), this.program.setDefault(), this.activeTexture.setDefault(), this.bindFramebuffer.setDefault(), this.pixelStoreUnpack.setDefault(), this.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.pixelStoreUnpackFlipY.setDefault();\n                  }\n                  setDirty() {\n                    this.clearColor.dirty = true, this.clearDepth.dirty = true, this.clearStencil.dirty = true, this.colorMask.dirty = true, this.depthMask.dirty = true, this.stencilMask.dirty = true, this.stencilFunc.dirty = true, this.stencilOp.dirty = true, this.stencilTest.dirty = true, this.depthRange.dirty = true, this.depthTest.dirty = true, this.depthFunc.dirty = true, this.blend.dirty = true, this.blendFunc.dirty = true, this.blendColor.dirty = true, this.blendEquation.dirty = true, this.cullFace.dirty = true, this.cullFaceSide.dirty = true, this.frontFace.dirty = true, this.program.dirty = true, this.activeTexture.dirty = true, this.viewport.dirty = true, this.bindFramebuffer.dirty = true, this.bindRenderbuffer.dirty = true, this.bindTexture.dirty = true, this.bindVertexBuffer.dirty = true, this.bindElementBuffer.dirty = true, this.bindVertexArray.dirty = true, this.pixelStoreUnpack.dirty = true, this.pixelStoreUnpackPremultiplyAlpha.dirty = true, this.pixelStoreUnpackFlipY.dirty = true;\n                  }\n                  createIndexBuffer(w4, B4) {\n                    return new bs(this, w4, B4);\n                  }\n                  createVertexBuffer(w4, B4, Q) {\n                    return new _a(this, w4, B4, Q);\n                  }\n                  createRenderbuffer(w4, B4, Q) {\n                    let ee = this.gl, le = ee.createRenderbuffer();\n                    return this.bindRenderbuffer.set(le), ee.renderbufferStorage(ee.RENDERBUFFER, w4, B4, Q), this.bindRenderbuffer.set(null), le;\n                  }\n                  createFramebuffer(w4, B4, Q, ee) {\n                    return new Gu(this, w4, B4, Q, ee);\n                  }\n                  clear({ color: w4, depth: B4, stencil: Q }) {\n                    let ee = this.gl, le = 0;\n                    w4 && (le |= ee.COLOR_BUFFER_BIT, this.clearColor.set(w4), this.colorMask.set([true, true, true, true])), B4 !== void 0 && (le |= ee.DEPTH_BUFFER_BIT, this.depthRange.set([0, 1]), this.clearDepth.set(B4), this.depthMask.set(true)), Q !== void 0 && (le |= ee.STENCIL_BUFFER_BIT, this.clearStencil.set(Q), this.stencilMask.set(255)), ee.clear(le);\n                  }\n                  setCullFace(w4) {\n                    w4.enable === false ? this.cullFace.set(false) : (this.cullFace.set(true), this.cullFaceSide.set(w4.mode), this.frontFace.set(w4.frontFace));\n                  }\n                  setDepthMode(w4) {\n                    w4.func !== this.gl.ALWAYS || w4.mask ? (this.depthTest.set(true), this.depthFunc.set(w4.func), this.depthMask.set(w4.mask), this.depthRange.set(w4.range)) : this.depthTest.set(false);\n                  }\n                  setStencilMode(w4) {\n                    w4.test.func !== this.gl.ALWAYS || w4.mask ? (this.stencilTest.set(true), this.stencilMask.set(w4.mask), this.stencilOp.set([w4.fail, w4.depthFail, w4.pass]), this.stencilFunc.set({ func: w4.test.func, ref: w4.ref, mask: w4.test.mask })) : this.stencilTest.set(false);\n                  }\n                  setColorMode(w4) {\n                    a4.aE(w4.blendFunction, qs.Replace) ? this.blend.set(false) : (this.blend.set(true), this.blendFunc.set(w4.blendFunction), this.blendColor.set(w4.blendColor)), this.colorMask.set(w4.mask);\n                  }\n                  createVertexArray() {\n                    var w4;\n                    return Ol(this.gl) ? this.gl.createVertexArray() : (w4 = this.gl.getExtension("OES_vertex_array_object")) === null || w4 === void 0 ? void 0 : w4.createVertexArrayOES();\n                  }\n                  deleteVertexArray(w4) {\n                    var B4;\n                    return Ol(this.gl) ? this.gl.deleteVertexArray(w4) : (B4 = this.gl.getExtension("OES_vertex_array_object")) === null || B4 === void 0 ? void 0 : B4.deleteVertexArrayOES(w4);\n                  }\n                  unbindVAO() {\n                    this.bindVertexArray.set(null);\n                  }\n                }\n                class Po {\n                  constructor(w4, B4, Q) {\n                    this.func = w4, this.mask = B4, this.range = Q;\n                  }\n                }\n                Po.ReadOnly = false, Po.ReadWrite = true, Po.disabled = new Po(519, Po.ReadOnly, [0, 1]);\n                let od = 7680;\n                class Yo {\n                  constructor(w4, B4, Q, ee, le, qe) {\n                    this.test = w4, this.ref = B4, this.mask = Q, this.fail = ee, this.depthFail = le, this.pass = qe;\n                  }\n                }\n                Yo.disabled = new Yo({ func: 519, mask: 0 }, 0, 0, od, od, od);\n                class Pa {\n                  constructor(w4, B4, Q) {\n                    this.enable = w4, this.mode = B4, this.frontFace = Q;\n                  }\n                }\n                let af;\n                function Hu(ue, w4, B4, Q, ee) {\n                  let le = ue.context, qe = le.gl, Xe = ue.useProgram("collisionBox"), ot = [], Tt = 0, Yt = 0;\n                  for (let Be = 0; Be < Q.length; Be++) {\n                    let et = Q[Be], We = w4.getTile(et).getBucket(B4);\n                    if (!We) continue;\n                    let it = ee ? We.textCollisionBox : We.iconCollisionBox, Ft = We.collisionCircleArray;\n                    if (Ft.length > 0) {\n                      let Ht = a4.H();\n                      a4.aQ(Ht, We.placementInvProjMatrix, ue.transform.glCoordMatrix), a4.aQ(Ht, Ht, We.placementViewportMatrix), ot.push({ circleArray: Ft, circleOffset: Yt, transform: et.posMatrix, invTransform: Ht, coord: et }), Tt += Ft.length / 4, Yt = Tt;\n                    }\n                    it && Xe.draw(le, qe.LINES, Po.disabled, Yo.disabled, ue.colorModeForRenderPass(), Pa.disabled, { u_matrix: et.posMatrix, u_pixel_extrude_scale: [1 / (Kt = ue.transform).width, 1 / Kt.height] }, ue.style.map.terrain && ue.style.map.terrain.getTerrainData(et), B4.id, it.layoutVertexBuffer, it.indexBuffer, it.segments, null, ue.transform.zoom, null, null, it.collisionVertexBuffer);\n                  }\n                  var Kt;\n                  if (!ee || !ot.length) return;\n                  let xr = ue.useProgram("collisionCircle"), Ir = new a4.aR();\n                  Ir.resize(4 * Tt), Ir._trim();\n                  let ve = 0;\n                  for (let Be of ot) for (let et = 0; et < Be.circleArray.length / 4; et++) {\n                    let We = 4 * et, it = Be.circleArray[We + 0], Ft = Be.circleArray[We + 1], Ht = Be.circleArray[We + 2], tr = Be.circleArray[We + 3];\n                    Ir.emplace(ve++, it, Ft, Ht, tr, 0), Ir.emplace(ve++, it, Ft, Ht, tr, 1), Ir.emplace(ve++, it, Ft, Ht, tr, 2), Ir.emplace(ve++, it, Ft, Ht, tr, 3);\n                  }\n                  (!af || af.length < 2 * Tt) && (af = (function(Be) {\n                    let et = 2 * Be, We = new a4.aT();\n                    We.resize(et), We._trim();\n                    for (let it = 0; it < et; it++) {\n                      let Ft = 6 * it;\n                      We.uint16[Ft + 0] = 4 * it + 0, We.uint16[Ft + 1] = 4 * it + 1, We.uint16[Ft + 2] = 4 * it + 2, We.uint16[Ft + 3] = 4 * it + 2, We.uint16[Ft + 4] = 4 * it + 3, We.uint16[Ft + 5] = 4 * it + 0;\n                    }\n                    return We;\n                  })(Tt));\n                  let be = le.createIndexBuffer(af, true), De = le.createVertexBuffer(Ir, a4.aS.members, true);\n                  for (let Be of ot) {\n                    let et = No(Be.transform, Be.invTransform, ue.transform);\n                    xr.draw(le, qe.TRIANGLES, Po.disabled, Yo.disabled, ue.colorModeForRenderPass(), Pa.disabled, et, ue.style.map.terrain && ue.style.map.terrain.getTerrainData(Be.coord), B4.id, De, be, a4.a0.simpleSegment(0, 2 * Be.circleOffset, Be.circleArray.length, Be.circleArray.length / 2), null, ue.transform.zoom, null, null, null);\n                  }\n                  De.destroy(), be.destroy();\n                }\n                Pa.disabled = new Pa(false, 1029, 2305), Pa.backCCW = new Pa(true, 1029, 2305);\n                let bl = a4.an(new Float32Array(16));\n                function Gf(ue, w4, B4, Q, ee, le) {\n                  let { horizontalAlign: qe, verticalAlign: Xe } = a4.au(ue);\n                  return new a4.P((-(qe - 0.5) * w4 / ee + Q[0]) * le, (-(Xe - 0.5) * B4 / ee + Q[1]) * le);\n                }\n                function Ic(ue, w4, B4, Q, ee, le) {\n                  let qe = w4.tileAnchorPoint.add(new a4.P(w4.translation[0], w4.translation[1]));\n                  if (w4.pitchWithMap) {\n                    let Xe = Q.mult(le);\n                    B4 || (Xe = Xe.rotate(-ee));\n                    let ot = qe.add(Xe);\n                    return dt(ot.x, ot.y, w4.labelPlaneMatrix, w4.getElevation).point;\n                  }\n                  if (B4) {\n                    let Xe = vt(w4.tileAnchorPoint.x + 1, w4.tileAnchorPoint.y, w4).point.sub(ue), ot = Math.atan(Xe.y / Xe.x) + (Xe.x < 0 ? Math.PI : 0);\n                    return ue.add(Q.rotate(ot));\n                  }\n                  return ue.add(Q);\n                }\n                function yf(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt, xr, Ir) {\n                  let ve = ue.text.placedSymbolArray, be = ue.text.dynamicLayoutVertexArray, De = ue.icon.dynamicLayoutVertexArray, Be = {};\n                  be.clear();\n                  for (let et = 0; et < ve.length; et++) {\n                    let We = ve.get(et), it = We.hidden || !We.crossTileID || ue.allowVerticalPlacement && !We.placedOrientation ? null : Q[We.crossTileID];\n                    if (it) {\n                      let Ft = new a4.P(We.anchorX, We.anchorY), Ht = { getElevation: Ir, width: ee.width, height: ee.height, labelPlaneMatrix: le, lineVertexArray: null, pitchWithMap: B4, projection: Yt, projectionCache: null, tileAnchorPoint: Ft, translation: Kt, unwrappedTileID: xr }, tr = B4 ? dt(Ft.x, Ft.y, qe, Ir) : vt(Ft.x, Ft.y, Ht), dr = Ge(ee.cameraToCenterDistance, tr.signedDistanceFromCamera), Sr = a4.ai(ue.textSizeData, ot, We) * dr / a4.ap;\n                      B4 && (Sr *= ue.tilePixelRatio / Xe);\n                      let { width: Or, height: Wr, anchor: ni, textOffset: Pi, textBoxScale: cn } = it, ln = Gf(ni, Or, Wr, Pi, cn, Sr), Cn = Yt.getPitchedTextCorrection(ee, Ft.add(new a4.P(Kt[0], Kt[1])), xr), Kn = Ic(tr.point, Ht, w4, ln, ee.angle, Cn), Ta = ue.allowVerticalPlacement && We.placedOrientation === a4.ah.vertical ? Math.PI / 2 : 0;\n                      for (let fa = 0; fa < We.numGlyphs; fa++) a4.aj(be, Kn, Ta);\n                      Tt && We.associatedIconIndex >= 0 && (Be[We.associatedIconIndex] = { shiftedAnchor: Kn, angle: Ta });\n                    } else pi(We.numGlyphs, be);\n                  }\n                  if (Tt) {\n                    De.clear();\n                    let et = ue.icon.placedSymbolArray;\n                    for (let We = 0; We < et.length; We++) {\n                      let it = et.get(We);\n                      if (it.hidden) pi(it.numGlyphs, De);\n                      else {\n                        let Ft = Be[We];\n                        if (Ft) for (let Ht = 0; Ht < it.numGlyphs; Ht++) a4.aj(De, Ft.shiftedAnchor, Ft.angle);\n                        else pi(it.numGlyphs, De);\n                      }\n                    }\n                    ue.icon.dynamicLayoutVertexBuffer.updateData(De);\n                  }\n                  ue.text.dynamicLayoutVertexBuffer.updateData(be);\n                }\n                function Bl(ue, w4, B4) {\n                  return B4.iconsInText && w4 ? "symbolTextAndIcon" : ue ? "symbolSDF" : "symbolIcon";\n                }\n                function wh(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt, Yt, Kt) {\n                  let xr = ue.context, Ir = xr.gl, ve = ue.transform, be = yn(), De = Xe === "map", Be = ot === "map", et = Xe !== "viewport" && B4.layout.get("symbol-placement") !== "point", We = De && !Be && !et, it = !Be && et, Ft = !B4.layout.get("symbol-sort-key").isConstant(), Ht = false, tr = ue.depthModeForSublayer(0, Po.ReadOnly), dr = B4._unevaluatedLayout.hasValue("text-variable-anchor") || B4._unevaluatedLayout.hasValue("text-variable-anchor-offset"), Sr = [], Or = be.getCircleRadiusCorrection(ve);\n                  for (let Wr of Q) {\n                    let ni = w4.getTile(Wr), Pi = ni.getBucket(B4);\n                    if (!Pi) continue;\n                    let cn = ee ? Pi.text : Pi.icon;\n                    if (!cn || !cn.segments.get().length || !cn.hasVisibleVertices) continue;\n                    let ln = cn.programConfigurations.get(B4.id), Cn = ee || Pi.sdfIcons, Kn = ee ? Pi.textSizeData : Pi.iconSizeData, Ta = Be || ve.pitch !== 0, fa = ue.useProgram(Bl(Cn, ee, Pi), ln), $a = a4.ag(Kn, ve.zoom), Co = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(Wr), Qa, mo, Bo, Ps, Ts = [0, 0], wo = null;\n                    if (ee) mo = ni.glyphAtlasTexture, Bo = Ir.LINEAR, Qa = ni.glyphAtlasTexture.size, Pi.iconsInText && (Ts = ni.imageAtlasTexture.size, wo = ni.imageAtlasTexture, Ps = Ta || ue.options.rotating || ue.options.zooming || Kn.kind === "composite" || Kn.kind === "camera" ? Ir.LINEAR : Ir.NEAREST);\n                    else {\n                      let Ye = B4.layout.get("icon-size").constantOr(0) !== 1 || Pi.iconsNeedLinear;\n                      mo = ni.imageAtlasTexture, Bo = Cn || ue.options.rotating || ue.options.zooming || Ye || Ta ? Ir.LINEAR : Ir.NEAREST, Qa = ni.imageAtlasTexture.size;\n                    }\n                    let To = In(ni, 1, ue.transform.zoom), hl = it ? Wr.posMatrix : bl, Ul = Br(hl, Be, De, ue.transform, To), Lu = Vr(hl, Be, De, ue.transform, To), au = Vr(Wr.posMatrix, Be, De, ue.transform, To), Js = be.translatePosition(ue.transform, ni, le, qe), Ql = dr && Pi.hasTextData(), dc = B4.layout.get("icon-text-fit") !== "none" && Ql && Pi.hasIconData();\n                    if (et) {\n                      let Ye = ue.style.map.terrain ? (nt, jt) => ue.style.map.terrain.getElevation(Wr, nt, jt) : null, kt = B4.layout.get("text-rotation-alignment") === "map";\n                      je(Pi, Wr.posMatrix, ue, ee, Ul, au, Be, Tt, kt, be, Wr.toUnwrapped(), ve.width, ve.height, Js, Ye);\n                    }\n                    let Tl = Wr.posMatrix, Al = ee && dr || dc, X = et || Al ? bl : Ul, se = Lu, Te = Cn && B4.paint.get(ee ? "text-halo-width" : "icon-halo-width").constantOr(1) !== 0, Ne;\n                    Ne = Cn ? Pi.iconsInText ? ls(Kn.kind, $a, We, Be, et, Al, ue, Tl, X, se, Js, Qa, Ts, Or) : Io(Kn.kind, $a, We, Be, et, Al, ue, Tl, X, se, Js, ee, Qa, true, Or) : zs(Kn.kind, $a, We, Be, et, Al, ue, Tl, X, se, Js, ee, Qa, Or);\n                    let He = { program: fa, buffers: cn, uniformValues: Ne, atlasTexture: mo, atlasTextureIcon: wo, atlasInterpolation: Bo, atlasInterpolationIcon: Ps, isSDF: Cn, hasHalo: Te };\n                    if (Ft && Pi.canOverlap) {\n                      Ht = true;\n                      let Ye = cn.segments.get();\n                      for (let kt of Ye) Sr.push({ segments: new a4.a0([kt]), sortKey: kt.sortKey, state: He, terrainData: Co });\n                    } else Sr.push({ segments: cn.segments, sortKey: 0, state: He, terrainData: Co });\n                  }\n                  Ht && Sr.sort((Wr, ni) => Wr.sortKey - ni.sortKey);\n                  for (let Wr of Sr) {\n                    let ni = Wr.state;\n                    if (xr.activeTexture.set(Ir.TEXTURE0), ni.atlasTexture.bind(ni.atlasInterpolation, Ir.CLAMP_TO_EDGE), ni.atlasTextureIcon && (xr.activeTexture.set(Ir.TEXTURE1), ni.atlasTextureIcon && ni.atlasTextureIcon.bind(ni.atlasInterpolationIcon, Ir.CLAMP_TO_EDGE)), ni.isSDF) {\n                      let Pi = ni.uniformValues;\n                      ni.hasHalo && (Pi.u_is_halo = 1, Qf(ni.buffers, Wr.segments, B4, ue, ni.program, tr, Yt, Kt, Pi, Wr.terrainData)), Pi.u_is_halo = 0;\n                    }\n                    Qf(ni.buffers, Wr.segments, B4, ue, ni.program, tr, Yt, Kt, ni.uniformValues, Wr.terrainData);\n                  }\n                }\n                function Qf(ue, w4, B4, Q, ee, le, qe, Xe, ot, Tt) {\n                  let Yt = Q.context;\n                  ee.draw(Yt, Yt.gl.TRIANGLES, le, qe, Xe, Pa.disabled, ot, Tt, B4.id, ue.layoutVertexBuffer, ue.indexBuffer, w4, B4.paint, Q.transform.zoom, ue.programConfigurations.get(B4.id), ue.dynamicLayoutVertexBuffer, ue.opacityVertexBuffer);\n                }\n                function _f(ue, w4, B4, Q) {\n                  let ee = ue.context, le = ee.gl, qe = Yo.disabled, Xe = new qs([le.ONE, le.ONE], a4.aM.transparent, [true, true, true, true]), ot = w4.getBucket(B4);\n                  if (!ot) return;\n                  let Tt = Q.key, Yt = B4.heatmapFbos.get(Tt);\n                  Yt || (Yt = eh(ee, w4.tileSize, w4.tileSize), B4.heatmapFbos.set(Tt, Yt)), ee.bindFramebuffer.set(Yt.framebuffer), ee.viewport.set([0, 0, w4.tileSize, w4.tileSize]), ee.clear({ color: a4.aM.transparent });\n                  let Kt = ot.programConfigurations.get(B4.id), xr = ue.useProgram("heatmap", Kt), Ir = ue.style.map.terrain.getTerrainData(Q);\n                  xr.draw(ee, le.TRIANGLES, Po.disabled, qe, Xe, Pa.disabled, ko(Q.posMatrix, w4, ue.transform.zoom, B4.paint.get("heatmap-intensity")), Ir, B4.id, ot.layoutVertexBuffer, ot.indexBuffer, ot.segments, B4.paint, ue.transform.zoom, Kt);\n                }\n                function Yc(ue, w4, B4) {\n                  let Q = ue.context, ee = Q.gl;\n                  Q.setColorMode(ue.colorModeForRenderPass());\n                  let le = th(Q, w4), qe = B4.key, Xe = w4.heatmapFbos.get(qe);\n                  Xe && (Q.activeTexture.set(ee.TEXTURE0), ee.bindTexture(ee.TEXTURE_2D, Xe.colorAttachment.get()), Q.activeTexture.set(ee.TEXTURE1), le.bind(ee.LINEAR, ee.CLAMP_TO_EDGE), ue.useProgram("heatmapTexture").draw(Q, ee.TRIANGLES, Po.disabled, Yo.disabled, ue.colorModeForRenderPass(), Pa.disabled, Ds(ue, w4, 0, 1), null, w4.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments, w4.paint, ue.transform.zoom), Xe.destroy(), w4.heatmapFbos.delete(qe));\n                }\n                function eh(ue, w4, B4) {\n                  var Q, ee;\n                  let le = ue.gl, qe = le.createTexture();\n                  le.bindTexture(le.TEXTURE_2D, qe), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_S, le.CLAMP_TO_EDGE), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_WRAP_T, le.CLAMP_TO_EDGE), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MIN_FILTER, le.LINEAR), le.texParameteri(le.TEXTURE_2D, le.TEXTURE_MAG_FILTER, le.LINEAR);\n                  let Xe = (Q = ue.HALF_FLOAT) !== null && Q !== void 0 ? Q : le.UNSIGNED_BYTE, ot = (ee = ue.RGBA16F) !== null && ee !== void 0 ? ee : le.RGBA;\n                  le.texImage2D(le.TEXTURE_2D, 0, ot, w4, B4, 0, le.RGBA, Xe, null);\n                  let Tt = ue.createFramebuffer(w4, B4, false, false);\n                  return Tt.colorAttachment.set(qe), Tt;\n                }\n                function th(ue, w4) {\n                  return w4.colorRampTexture || (w4.colorRampTexture = new g3(ue, w4.colorRamp, ue.gl.RGBA)), w4.colorRampTexture;\n                }\n                function ju(ue, w4, B4, Q, ee) {\n                  if (!B4 || !Q || !Q.imageAtlas) return;\n                  let le = Q.imageAtlas.patternPositions, qe = le[B4.to.toString()], Xe = le[B4.from.toString()];\n                  if (!qe && Xe && (qe = Xe), !Xe && qe && (Xe = qe), !qe || !Xe) {\n                    let ot = ee.getPaintProperty(w4);\n                    qe = le[ot], Xe = le[ot];\n                  }\n                  qe && Xe && ue.setConstantPatternPositions(qe, Xe);\n                }\n                function Hf(ue, w4, B4, Q, ee, le, qe) {\n                  let Xe = ue.context.gl, ot = "fill-pattern", Tt = B4.paint.get(ot), Yt = Tt && Tt.constantOr(1), Kt = B4.getCrossfadeParameters(), xr, Ir, ve, be, De;\n                  qe ? (Ir = Yt && !B4.getPaintProperty("fill-outline-color") ? "fillOutlinePattern" : "fillOutline", xr = Xe.LINES) : (Ir = Yt ? "fillPattern" : "fill", xr = Xe.TRIANGLES);\n                  let Be = Tt.constantOr(null);\n                  for (let et of Q) {\n                    let We = w4.getTile(et);\n                    if (Yt && !We.patternsLoaded()) continue;\n                    let it = We.getBucket(B4);\n                    if (!it) continue;\n                    let Ft = it.programConfigurations.get(B4.id), Ht = ue.useProgram(Ir, Ft), tr = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(et);\n                    Yt && (ue.context.activeTexture.set(Xe.TEXTURE0), We.imageAtlasTexture.bind(Xe.LINEAR, Xe.CLAMP_TO_EDGE), Ft.updatePaintBuffers(Kt)), ju(Ft, ot, Be, We, B4);\n                    let dr = tr ? et : null, Sr = ue.translatePosMatrix(dr ? dr.posMatrix : et.posMatrix, We, B4.paint.get("fill-translate"), B4.paint.get("fill-translate-anchor"));\n                    if (qe) {\n                      be = it.indexBuffer2, De = it.segments2;\n                      let Or = [Xe.drawingBufferWidth, Xe.drawingBufferHeight];\n                      ve = Ir === "fillOutlinePattern" && Yt ? Ma(Sr, ue, Kt, We, Or) : Jn(Sr, Or);\n                    } else be = it.indexBuffer, De = it.segments, ve = Yt ? ya(Sr, ue, Kt, We) : _n(Sr);\n                    Ht.draw(ue.context, xr, ee, ue.stencilModeForClipping(et), le, Pa.disabled, ve, tr, B4.id, it.layoutVertexBuffer, be, De, B4.paint, ue.transform.zoom, Ft);\n                  }\n                }\n                function cc(ue, w4, B4, Q, ee, le, qe) {\n                  let Xe = ue.context, ot = Xe.gl, Tt = "fill-extrusion-pattern", Yt = B4.paint.get(Tt), Kt = Yt.constantOr(1), xr = B4.getCrossfadeParameters(), Ir = B4.paint.get("fill-extrusion-opacity"), ve = Yt.constantOr(null);\n                  for (let be of Q) {\n                    let De = w4.getTile(be), Be = De.getBucket(B4);\n                    if (!Be) continue;\n                    let et = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(be), We = Be.programConfigurations.get(B4.id), it = ue.useProgram(Kt ? "fillExtrusionPattern" : "fillExtrusion", We);\n                    Kt && (ue.context.activeTexture.set(ot.TEXTURE0), De.imageAtlasTexture.bind(ot.LINEAR, ot.CLAMP_TO_EDGE), We.updatePaintBuffers(xr)), ju(We, Tt, ve, De, B4);\n                    let Ft = ue.translatePosMatrix(be.posMatrix, De, B4.paint.get("fill-extrusion-translate"), B4.paint.get("fill-extrusion-translate-anchor")), Ht = B4.paint.get("fill-extrusion-vertical-gradient"), tr = Kt ? Li(Ft, ue, Ht, Ir, be, xr, De) : Mn(Ft, ue, Ht, Ir);\n                    it.draw(Xe, Xe.gl.TRIANGLES, ee, le, qe, Pa.backCCW, tr, et, B4.id, Be.layoutVertexBuffer, Be.indexBuffer, Be.segments, B4.paint, ue.transform.zoom, We, ue.style.map.terrain && Be.centroidVertexBuffer);\n                  }\n                }\n                function of(ue, w4, B4, Q, ee, le, qe) {\n                  let Xe = ue.context, ot = Xe.gl, Tt = B4.fbo;\n                  if (!Tt) return;\n                  let Yt = ue.useProgram("hillshade"), Kt = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(w4);\n                  Xe.activeTexture.set(ot.TEXTURE0), ot.bindTexture(ot.TEXTURE_2D, Tt.colorAttachment.get()), Yt.draw(Xe, ot.TRIANGLES, ee, le, qe, Pa.disabled, ((xr, Ir, ve, be) => {\n                    let De = ve.paint.get("hillshade-shadow-color"), Be = ve.paint.get("hillshade-highlight-color"), et = ve.paint.get("hillshade-accent-color"), We = ve.paint.get("hillshade-illumination-direction") * (Math.PI / 180);\n                    ve.paint.get("hillshade-illumination-anchor") === "viewport" && (We -= xr.transform.angle);\n                    let it = !xr.options.moving;\n                    return { u_matrix: be ? be.posMatrix : xr.transform.calculatePosMatrix(Ir.tileID.toUnwrapped(), it), u_image: 0, u_latrange: Fs(0, Ir.tileID), u_light: [ve.paint.get("hillshade-exaggeration"), We], u_shadow: De, u_highlight: Be, u_accent: et };\n                  })(ue, B4, Q, Kt ? w4 : null), Kt, Q.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments);\n                }\n                function Nl(ue, w4, B4, Q, ee, le) {\n                  let qe = ue.context, Xe = qe.gl, ot = w4.dem;\n                  if (ot && ot.data) {\n                    let Tt = ot.dim, Yt = ot.stride, Kt = ot.getPixels();\n                    if (qe.activeTexture.set(Xe.TEXTURE1), qe.pixelStoreUnpackPremultiplyAlpha.set(false), w4.demTexture = w4.demTexture || ue.getTileTexture(Yt), w4.demTexture) {\n                      let Ir = w4.demTexture;\n                      Ir.update(Kt, { premultiply: false }), Ir.bind(Xe.NEAREST, Xe.CLAMP_TO_EDGE);\n                    } else w4.demTexture = new g3(qe, Kt, Xe.RGBA, { premultiply: false }), w4.demTexture.bind(Xe.NEAREST, Xe.CLAMP_TO_EDGE);\n                    qe.activeTexture.set(Xe.TEXTURE0);\n                    let xr = w4.fbo;\n                    if (!xr) {\n                      let Ir = new g3(qe, { width: Tt, height: Tt, data: null }, Xe.RGBA);\n                      Ir.bind(Xe.LINEAR, Xe.CLAMP_TO_EDGE), xr = w4.fbo = qe.createFramebuffer(Tt, Tt, true, false), xr.colorAttachment.set(Ir.texture);\n                    }\n                    qe.bindFramebuffer.set(xr.framebuffer), qe.viewport.set([0, 0, Tt, Tt]), ue.useProgram("hillshadePrepare").draw(qe, Xe.TRIANGLES, Q, ee, le, Pa.disabled, ((Ir, ve) => {\n                      let be = ve.stride, De = a4.H();\n                      return a4.aP(De, 0, a4.X, -a4.X, 0, 0, 1), a4.J(De, De, [0, -a4.X, 0]), { u_matrix: De, u_image: 1, u_dimension: [be, be], u_zoom: Ir.overscaledZ, u_unpack: ve.getUnpackVector() };\n                    })(w4.tileID, ot), null, B4.id, ue.rasterBoundsBuffer, ue.quadTriangleIndexBuffer, ue.rasterBoundsSegments), w4.needsHillshadePrepare = false;\n                  }\n                }\n                function Kc(ue, w4, B4, Q, ee, le) {\n                  let qe = Q.paint.get("raster-fade-duration");\n                  if (!le && qe > 0) {\n                    let Xe = u4.now(), ot = (Xe - ue.timeAdded) / qe, Tt = w4 ? (Xe - w4.timeAdded) / qe : -1, Yt = B4.getSource(), Kt = ee.coveringZoomLevel({ tileSize: Yt.tileSize, roundZoom: Yt.roundZoom }), xr = !w4 || Math.abs(w4.tileID.overscaledZ - Kt) > Math.abs(ue.tileID.overscaledZ - Kt), Ir = xr && ue.refreshedUponExpiration ? 1 : a4.ac(xr ? ot : 1 - Tt, 0, 1);\n                    return ue.refreshedUponExpiration && ot >= 1 && (ue.refreshedUponExpiration = false), w4 ? { opacity: 1, mix: 1 - Ir } : { opacity: Ir, mix: 0 };\n                  }\n                  return { opacity: 1, mix: 0 };\n                }\n                let Rc = new a4.aM(1, 0, 0, 1), gs = new a4.aM(0, 1, 0, 1), jf = new a4.aM(0, 0, 1, 1), Gh = new a4.aM(1, 0, 1, 1), rh = new a4.aM(0, 1, 1, 1);\n                function sf(ue, w4, B4, Q) {\n                  Mu(ue, 0, w4 + B4 / 2, ue.transform.width, B4, Q);\n                }\n                function Th(ue, w4, B4, Q) {\n                  Mu(ue, w4 - B4 / 2, 0, B4, ue.transform.height, Q);\n                }\n                function Mu(ue, w4, B4, Q, ee, le) {\n                  let qe = ue.context, Xe = qe.gl;\n                  Xe.enable(Xe.SCISSOR_TEST), Xe.scissor(w4 * ue.pixelRatio, B4 * ue.pixelRatio, Q * ue.pixelRatio, ee * ue.pixelRatio), qe.clear({ color: le }), Xe.disable(Xe.SCISSOR_TEST);\n                }\n                function ih(ue, w4, B4) {\n                  let Q = ue.context, ee = Q.gl, le = B4.posMatrix, qe = ue.useProgram("debug"), Xe = Po.disabled, ot = Yo.disabled, Tt = ue.colorModeForRenderPass(), Yt = "$debug", Kt = ue.style.map.terrain && ue.style.map.terrain.getTerrainData(B4);\n                  Q.activeTexture.set(ee.TEXTURE0);\n                  let xr = w4.getTileByID(B4.key).latestRawTileData, Ir = Math.floor((xr && xr.byteLength || 0) / 1024), ve = w4.getTile(B4).tileSize, be = 512 / Math.min(ve, 512) * (B4.overscaledZ / ue.transform.zoom) * 0.5, De = B4.canonical.toString();\n                  B4.overscaledZ !== B4.canonical.z && (De += ` => ${B4.overscaledZ}`), (function(Be, et) {\n                    Be.initDebugOverlayCanvas();\n                    let We = Be.debugOverlayCanvas, it = Be.context.gl, Ft = Be.debugOverlayCanvas.getContext("2d");\n                    Ft.clearRect(0, 0, We.width, We.height), Ft.shadowColor = "white", Ft.shadowBlur = 2, Ft.lineWidth = 1.5, Ft.strokeStyle = "white", Ft.textBaseline = "top", Ft.font = "bold 36px Open Sans, sans-serif", Ft.fillText(et, 5, 5), Ft.strokeText(et, 5, 5), Be.debugOverlayTexture.update(We), Be.debugOverlayTexture.bind(it.LINEAR, it.CLAMP_TO_EDGE);\n                  })(ue, `${De} ${Ir}kB`), qe.draw(Q, ee.TRIANGLES, Xe, ot, qs.alphaBlended, Pa.disabled, po(le, a4.aM.transparent, be), null, Yt, ue.debugBuffer, ue.quadTriangleIndexBuffer, ue.debugSegments), qe.draw(Q, ee.LINE_STRIP, Xe, ot, Tt, Pa.disabled, po(le, a4.aM.red), Kt, Yt, ue.debugBuffer, ue.tileBorderIndexBuffer, ue.debugSegments);\n                }\n                function js(ue, w4, B4) {\n                  let Q = ue.context, ee = Q.gl, le = ue.colorModeForRenderPass(), qe = new Po(ee.LEQUAL, Po.ReadWrite, ue.depthRangeFor3D), Xe = ue.useProgram("terrain"), ot = w4.getTerrainMesh();\n                  Q.bindFramebuffer.set(null), Q.viewport.set([0, 0, ue.width, ue.height]);\n                  for (let Tt of B4) {\n                    let Yt = ue.renderToTexture.getTexture(Tt), Kt = w4.getTerrainData(Tt.tileID);\n                    Q.activeTexture.set(ee.TEXTURE0), ee.bindTexture(ee.TEXTURE_2D, Yt.texture);\n                    let xr = ue.transform.calculatePosMatrix(Tt.tileID.toUnwrapped()), Ir = w4.getMeshFrameDelta(ue.transform.zoom), ve = ue.transform.calculateFogMatrix(Tt.tileID.toUnwrapped()), be = Jr(xr, Ir, ve, ue.style.sky, ue.transform.pitch);\n                    Xe.draw(Q, ee.TRIANGLES, qe, Yo.disabled, le, Pa.backCCW, be, Kt, "terrain", ot.vertexBuffer, ot.indexBuffer, ot.segments);\n                  }\n                }\n                class Eu {\n                  constructor(w4, B4, Q) {\n                    this.vertexBuffer = w4, this.indexBuffer = B4, this.segments = Q;\n                  }\n                  destroy() {\n                    this.vertexBuffer.destroy(), this.indexBuffer.destroy(), this.segments.destroy(), this.vertexBuffer = null, this.indexBuffer = null, this.segments = null;\n                  }\n                }\n                class Dc {\n                  constructor(w4, B4) {\n                    this.context = new ad(w4), this.transform = B4, this._tileTextures = {}, this.terrainFacilitator = { dirty: true, matrix: a4.an(new Float64Array(16)), renderTime: 0 }, this.setup(), this.numSublayers = mt.maxUnderzooming + mt.maxOverzooming + 1, this.depthEpsilon = 1 / Math.pow(2, 16), this.crossTileSymbolIndex = new Wo();\n                  }\n                  resize(w4, B4, Q) {\n                    if (this.width = Math.floor(w4 * Q), this.height = Math.floor(B4 * Q), this.pixelRatio = Q, this.context.viewport.set([0, 0, this.width, this.height]), this.style) for (let ee of this.style._order) this.style._layers[ee].resize();\n                  }\n                  setup() {\n                    let w4 = this.context, B4 = new a4.aX();\n                    B4.emplaceBack(0, 0), B4.emplaceBack(a4.X, 0), B4.emplaceBack(0, a4.X), B4.emplaceBack(a4.X, a4.X), this.tileExtentBuffer = w4.createVertexBuffer(B4, vo.members), this.tileExtentSegments = a4.a0.simpleSegment(0, 0, 4, 2);\n                    let Q = new a4.aX();\n                    Q.emplaceBack(0, 0), Q.emplaceBack(a4.X, 0), Q.emplaceBack(0, a4.X), Q.emplaceBack(a4.X, a4.X), this.debugBuffer = w4.createVertexBuffer(Q, vo.members), this.debugSegments = a4.a0.simpleSegment(0, 0, 4, 5);\n                    let ee = new a4.$();\n                    ee.emplaceBack(0, 0, 0, 0), ee.emplaceBack(a4.X, 0, a4.X, 0), ee.emplaceBack(0, a4.X, 0, a4.X), ee.emplaceBack(a4.X, a4.X, a4.X, a4.X), this.rasterBoundsBuffer = w4.createVertexBuffer(ee, lt.members), this.rasterBoundsSegments = a4.a0.simpleSegment(0, 0, 4, 2);\n                    let le = new a4.aX();\n                    le.emplaceBack(0, 0), le.emplaceBack(1, 0), le.emplaceBack(0, 1), le.emplaceBack(1, 1), this.viewportBuffer = w4.createVertexBuffer(le, vo.members), this.viewportSegments = a4.a0.simpleSegment(0, 0, 4, 2);\n                    let qe = new a4.aZ();\n                    qe.emplaceBack(0), qe.emplaceBack(1), qe.emplaceBack(3), qe.emplaceBack(2), qe.emplaceBack(0), this.tileBorderIndexBuffer = w4.createIndexBuffer(qe);\n                    let Xe = new a4.aY();\n                    Xe.emplaceBack(0, 1, 2), Xe.emplaceBack(2, 1, 3), this.quadTriangleIndexBuffer = w4.createIndexBuffer(Xe);\n                    let ot = this.context.gl;\n                    this.stencilClearMode = new Yo({ func: ot.ALWAYS, mask: 0 }, 0, 255, ot.ZERO, ot.ZERO, ot.ZERO);\n                  }\n                  clearStencil() {\n                    let w4 = this.context, B4 = w4.gl;\n                    this.nextStencilID = 1, this.currentStencilSource = void 0;\n                    let Q = a4.H();\n                    a4.aP(Q, 0, this.width, this.height, 0, 0, 1), a4.K(Q, Q, [B4.drawingBufferWidth, B4.drawingBufferHeight, 0]), this.useProgram("clippingMask").draw(w4, B4.TRIANGLES, Po.disabled, this.stencilClearMode, qs.disabled, Pa.disabled, Lo(Q), null, "$clipping", this.viewportBuffer, this.quadTriangleIndexBuffer, this.viewportSegments);\n                  }\n                  _renderTileClippingMasks(w4, B4) {\n                    if (this.currentStencilSource === w4.source || !w4.isTileClipped() || !B4 || !B4.length) return;\n                    this.currentStencilSource = w4.source;\n                    let Q = this.context, ee = Q.gl;\n                    this.nextStencilID + B4.length > 256 && this.clearStencil(), Q.setColorMode(qs.disabled), Q.setDepthMode(Po.disabled);\n                    let le = this.useProgram("clippingMask");\n                    this._tileClippingMaskIDs = {};\n                    for (let qe of B4) {\n                      let Xe = this._tileClippingMaskIDs[qe.key] = this.nextStencilID++, ot = this.style.map.terrain && this.style.map.terrain.getTerrainData(qe);\n                      le.draw(Q, ee.TRIANGLES, Po.disabled, new Yo({ func: ee.ALWAYS, mask: 0 }, Xe, 255, ee.KEEP, ee.KEEP, ee.REPLACE), qs.disabled, Pa.disabled, Lo(qe.posMatrix), ot, "$clipping", this.tileExtentBuffer, this.quadTriangleIndexBuffer, this.tileExtentSegments);\n                    }\n                  }\n                  stencilModeFor3D() {\n                    this.currentStencilSource = void 0, this.nextStencilID + 1 > 256 && this.clearStencil();\n                    let w4 = this.nextStencilID++, B4 = this.context.gl;\n                    return new Yo({ func: B4.NOTEQUAL, mask: 255 }, w4, 255, B4.KEEP, B4.KEEP, B4.REPLACE);\n                  }\n                  stencilModeForClipping(w4) {\n                    let B4 = this.context.gl;\n                    return new Yo({ func: B4.EQUAL, mask: 255 }, this._tileClippingMaskIDs[w4.key], 0, B4.KEEP, B4.KEEP, B4.REPLACE);\n                  }\n                  stencilConfigForOverlap(w4) {\n                    let B4 = this.context.gl, Q = w4.sort((qe, Xe) => Xe.overscaledZ - qe.overscaledZ), ee = Q[Q.length - 1].overscaledZ, le = Q[0].overscaledZ - ee + 1;\n                    if (le > 1) {\n                      this.currentStencilSource = void 0, this.nextStencilID + le > 256 && this.clearStencil();\n                      let qe = {};\n                      for (let Xe = 0; Xe < le; Xe++) qe[Xe + ee] = new Yo({ func: B4.GEQUAL, mask: 255 }, Xe + this.nextStencilID, 255, B4.KEEP, B4.KEEP, B4.REPLACE);\n                      return this.nextStencilID += le, [qe, Q];\n                    }\n                    return [{ [ee]: Yo.disabled }, Q];\n                  }\n                  colorModeForRenderPass() {\n                    let w4 = this.context.gl;\n                    return this._showOverdrawInspector ? new qs([w4.CONSTANT_COLOR, w4.ONE], new a4.aM(0.125, 0.125, 0.125, 0), [true, true, true, true]) : this.renderPass === "opaque" ? qs.unblended : qs.alphaBlended;\n                  }\n                  depthModeForSublayer(w4, B4, Q) {\n                    if (!this.opaquePassEnabledForLayer()) return Po.disabled;\n                    let ee = 1 - ((1 + this.currentLayer) * this.numSublayers + w4) * this.depthEpsilon;\n                    return new Po(Q || this.context.gl.LEQUAL, B4, [ee, ee]);\n                  }\n                  opaquePassEnabledForLayer() {\n                    return this.currentLayer < this.opaquePassCutoff;\n                  }\n                  render(w4, B4) {\n                    this.style = w4, this.options = B4, this.lineAtlas = w4.lineAtlas, this.imageManager = w4.imageManager, this.glyphManager = w4.glyphManager, this.symbolFadeChange = w4.placement.symbolFadeChange(u4.now()), this.imageManager.beginFrame();\n                    let Q = this.style._order, ee = this.style.sourceCaches, le = {}, qe = {}, Xe = {};\n                    for (let ot in ee) {\n                      let Tt = ee[ot];\n                      Tt.used && Tt.prepare(this.context), le[ot] = Tt.getVisibleCoordinates(), qe[ot] = le[ot].slice().reverse(), Xe[ot] = Tt.getVisibleCoordinates(true).reverse();\n                    }\n                    this.opaquePassCutoff = 1 / 0;\n                    for (let ot = 0; ot < Q.length; ot++) if (this.style._layers[Q[ot]].is3D()) {\n                      this.opaquePassCutoff = ot;\n                      break;\n                    }\n                    this.maybeDrawDepthAndCoords(false), this.renderToTexture && (this.renderToTexture.prepareForRender(this.style, this.transform.zoom), this.opaquePassCutoff = 0), this.renderPass = "offscreen";\n                    for (let ot of Q) {\n                      let Tt = this.style._layers[ot];\n                      if (!Tt.hasOffscreenPass() || Tt.isHidden(this.transform.zoom)) continue;\n                      let Yt = qe[Tt.source];\n                      (Tt.type === "custom" || Yt.length) && this.renderLayer(this, ee[Tt.source], Tt, Yt);\n                    }\n                    if (this.context.bindFramebuffer.set(null), this.context.clear({ color: B4.showOverdrawInspector ? a4.aM.black : a4.aM.transparent, depth: 1 }), this.clearStencil(), this.style.sky && (function(ot, Tt) {\n                      let Yt = ot.context, Kt = Yt.gl, xr = ((Be, et, We) => ({ u_sky_color: Be.properties.get("sky-color"), u_horizon_color: Be.properties.get("horizon-color"), u_horizon: (et.height / 2 + et.getHorizon()) * We, u_sky_horizon_blend: Be.properties.get("sky-horizon-blend") * et.height / 2 * We }))(Tt, ot.style.map.transform, ot.pixelRatio), Ir = new Po(Kt.LEQUAL, Po.ReadWrite, [0, 1]), ve = Yo.disabled, be = ot.colorModeForRenderPass(), De = ot.useProgram("sky");\n                      if (!Tt.mesh) {\n                        let Be = new a4.aX();\n                        Be.emplaceBack(-1, -1), Be.emplaceBack(1, -1), Be.emplaceBack(1, 1), Be.emplaceBack(-1, 1);\n                        let et = new a4.aY();\n                        et.emplaceBack(0, 1, 2), et.emplaceBack(0, 2, 3), Tt.mesh = new Eu(Yt.createVertexBuffer(Be, vo.members), Yt.createIndexBuffer(et), a4.a0.simpleSegment(0, 0, Be.length, et.length));\n                      }\n                      De.draw(Yt, Kt.TRIANGLES, Ir, ve, be, Pa.disabled, xr, void 0, "sky", Tt.mesh.vertexBuffer, Tt.mesh.indexBuffer, Tt.mesh.segments);\n                    })(this, this.style.sky), this._showOverdrawInspector = B4.showOverdrawInspector, this.depthRangeFor3D = [0, 1 - (w4._order.length + 2) * this.numSublayers * this.depthEpsilon], !this.renderToTexture) for (this.renderPass = "opaque", this.currentLayer = Q.length - 1; this.currentLayer >= 0; this.currentLayer--) {\n                      let ot = this.style._layers[Q[this.currentLayer]], Tt = ee[ot.source], Yt = le[ot.source];\n                      this._renderTileClippingMasks(ot, Yt), this.renderLayer(this, Tt, ot, Yt);\n                    }\n                    for (this.renderPass = "translucent", this.currentLayer = 0; this.currentLayer < Q.length; this.currentLayer++) {\n                      let ot = this.style._layers[Q[this.currentLayer]], Tt = ee[ot.source];\n                      if (this.renderToTexture && this.renderToTexture.renderLayer(ot)) continue;\n                      let Yt = (ot.type === "symbol" ? Xe : qe)[ot.source];\n                      this._renderTileClippingMasks(ot, le[ot.source]), this.renderLayer(this, Tt, ot, Yt);\n                    }\n                    if (this.options.showTileBoundaries) {\n                      let ot = (function(Tt, Yt) {\n                        let Kt = null, xr = Object.values(Tt._layers).flatMap((De) => De.source && !De.isHidden(Yt) ? [Tt.sourceCaches[De.source]] : []), Ir = xr.filter((De) => De.getSource().type === "vector"), ve = xr.filter((De) => De.getSource().type !== "vector"), be = (De) => {\n                          (!Kt || Kt.getSource().maxzoom < De.getSource().maxzoom) && (Kt = De);\n                        };\n                        return Ir.forEach((De) => be(De)), Kt || ve.forEach((De) => be(De)), Kt;\n                      })(this.style, this.transform.zoom);\n                      ot && (function(Tt, Yt, Kt) {\n                        for (let xr = 0; xr < Kt.length; xr++) ih(Tt, Yt, Kt[xr]);\n                      })(this, ot, ot.getVisibleCoordinates());\n                    }\n                    this.options.showPadding && (function(ot) {\n                      let Tt = ot.transform.padding;\n                      sf(ot, ot.transform.height - (Tt.top || 0), 3, Rc), sf(ot, Tt.bottom || 0, 3, gs), Th(ot, Tt.left || 0, 3, jf), Th(ot, ot.transform.width - (Tt.right || 0), 3, Gh);\n                      let Yt = ot.transform.centerPoint;\n                      (function(Kt, xr, Ir, ve) {\n                        Mu(Kt, xr - 1, Ir - 10, 2, 20, ve), Mu(Kt, xr - 10, Ir - 1, 20, 2, ve);\n                      })(ot, Yt.x, ot.transform.height - Yt.y, rh);\n                    })(this), this.context.setDefault();\n                  }\n                  maybeDrawDepthAndCoords(w4) {\n                    if (!this.style || !this.style.map || !this.style.map.terrain) return;\n                    let B4 = this.terrainFacilitator.matrix, Q = this.transform.modelViewProjectionMatrix, ee = this.terrainFacilitator.dirty;\n                    ee || (ee = w4 ? !a4.a_(B4, Q) : !a4.a$(B4, Q)), ee || (ee = this.style.map.terrain.sourceCache.tilesAfterTime(this.terrainFacilitator.renderTime).length > 0), ee && (a4.b0(B4, Q), this.terrainFacilitator.renderTime = Date.now(), this.terrainFacilitator.dirty = false, (function(le, qe) {\n                      let Xe = le.context, ot = Xe.gl, Tt = qs.unblended, Yt = new Po(ot.LEQUAL, Po.ReadWrite, [0, 1]), Kt = qe.getTerrainMesh(), xr = qe.sourceCache.getRenderableTiles(), Ir = le.useProgram("terrainDepth");\n                      Xe.bindFramebuffer.set(qe.getFramebuffer("depth").framebuffer), Xe.viewport.set([0, 0, le.width / devicePixelRatio, le.height / devicePixelRatio]), Xe.clear({ color: a4.aM.transparent, depth: 1 });\n                      for (let ve of xr) {\n                        let be = qe.getTerrainData(ve.tileID), De = { u_matrix: le.transform.calculatePosMatrix(ve.tileID.toUnwrapped()), u_ele_delta: qe.getMeshFrameDelta(le.transform.zoom) };\n                        Ir.draw(Xe, ot.TRIANGLES, Yt, Yo.disabled, Tt, Pa.backCCW, De, be, "terrain", Kt.vertexBuffer, Kt.indexBuffer, Kt.segments);\n                      }\n                      Xe.bindFramebuffer.set(null), Xe.viewport.set([0, 0, le.width, le.height]);\n                    })(this, this.style.map.terrain), (function(le, qe) {\n                      let Xe = le.context, ot = Xe.gl, Tt = qs.unblended, Yt = new Po(ot.LEQUAL, Po.ReadWrite, [0, 1]), Kt = qe.getTerrainMesh(), xr = qe.getCoordsTexture(), Ir = qe.sourceCache.getRenderableTiles(), ve = le.useProgram("terrainCoords");\n                      Xe.bindFramebuffer.set(qe.getFramebuffer("coords").framebuffer), Xe.viewport.set([0, 0, le.width / devicePixelRatio, le.height / devicePixelRatio]), Xe.clear({ color: a4.aM.transparent, depth: 1 }), qe.coordsIndex = [];\n                      for (let be of Ir) {\n                        let De = qe.getTerrainData(be.tileID);\n                        Xe.activeTexture.set(ot.TEXTURE0), ot.bindTexture(ot.TEXTURE_2D, xr.texture);\n                        let Be = { u_matrix: le.transform.calculatePosMatrix(be.tileID.toUnwrapped()), u_terrain_coords_id: (255 - qe.coordsIndex.length) / 255, u_texture: 0, u_ele_delta: qe.getMeshFrameDelta(le.transform.zoom) };\n                        ve.draw(Xe, ot.TRIANGLES, Yt, Yo.disabled, Tt, Pa.backCCW, Be, De, "terrain", Kt.vertexBuffer, Kt.indexBuffer, Kt.segments), qe.coordsIndex.push(be.tileID.key);\n                      }\n                      Xe.bindFramebuffer.set(null), Xe.viewport.set([0, 0, le.width, le.height]);\n                    })(this, this.style.map.terrain));\n                  }\n                  renderLayer(w4, B4, Q, ee) {\n                    if (!Q.isHidden(this.transform.zoom) && (Q.type === "background" || Q.type === "custom" || (ee || []).length)) switch (this.id = Q.id, Q.type) {\n                      case "symbol":\n                        (function(le, qe, Xe, ot, Tt) {\n                          if (le.renderPass !== "translucent") return;\n                          let Yt = Yo.disabled, Kt = le.colorModeForRenderPass();\n                          (Xe._unevaluatedLayout.hasValue("text-variable-anchor") || Xe._unevaluatedLayout.hasValue("text-variable-anchor-offset")) && (function(xr, Ir, ve, be, De, Be, et, We, it) {\n                            let Ft = Ir.transform, Ht = yn(), tr = De === "map", dr = Be === "map";\n                            for (let Sr of xr) {\n                              let Or = be.getTile(Sr), Wr = Or.getBucket(ve);\n                              if (!Wr || !Wr.text || !Wr.text.segments.get().length) continue;\n                              let ni = a4.ag(Wr.textSizeData, Ft.zoom), Pi = In(Or, 1, Ir.transform.zoom), cn = Br(Sr.posMatrix, dr, tr, Ir.transform, Pi), ln = ve.layout.get("icon-text-fit") !== "none" && Wr.hasIconData();\n                              if (ni) {\n                                let Cn = Math.pow(2, Ft.zoom - Or.tileID.overscaledZ), Kn = Ir.style.map.terrain ? (fa, $a) => Ir.style.map.terrain.getElevation(Sr, fa, $a) : null, Ta = Ht.translatePosition(Ft, Or, et, We);\n                                yf(Wr, tr, dr, it, Ft, cn, Sr.posMatrix, Cn, ni, ln, Ht, Ta, Sr.toUnwrapped(), Kn);\n                              }\n                            }\n                          })(ot, le, Xe, qe, Xe.layout.get("text-rotation-alignment"), Xe.layout.get("text-pitch-alignment"), Xe.paint.get("text-translate"), Xe.paint.get("text-translate-anchor"), Tt), Xe.paint.get("icon-opacity").constantOr(1) !== 0 && wh(le, qe, Xe, ot, false, Xe.paint.get("icon-translate"), Xe.paint.get("icon-translate-anchor"), Xe.layout.get("icon-rotation-alignment"), Xe.layout.get("icon-pitch-alignment"), Xe.layout.get("icon-keep-upright"), Yt, Kt), Xe.paint.get("text-opacity").constantOr(1) !== 0 && wh(le, qe, Xe, ot, true, Xe.paint.get("text-translate"), Xe.paint.get("text-translate-anchor"), Xe.layout.get("text-rotation-alignment"), Xe.layout.get("text-pitch-alignment"), Xe.layout.get("text-keep-upright"), Yt, Kt), qe.map.showCollisionBoxes && (Hu(le, qe, Xe, ot, true), Hu(le, qe, Xe, ot, false));\n                        })(w4, B4, Q, ee, this.style.placement.variableOffsets);\n                        break;\n                      case "circle":\n                        (function(le, qe, Xe, ot) {\n                          if (le.renderPass !== "translucent") return;\n                          let Tt = Xe.paint.get("circle-opacity"), Yt = Xe.paint.get("circle-stroke-width"), Kt = Xe.paint.get("circle-stroke-opacity"), xr = !Xe.layout.get("circle-sort-key").isConstant();\n                          if (Tt.constantOr(1) === 0 && (Yt.constantOr(1) === 0 || Kt.constantOr(1) === 0)) return;\n                          let Ir = le.context, ve = Ir.gl, be = le.depthModeForSublayer(0, Po.ReadOnly), De = Yo.disabled, Be = le.colorModeForRenderPass(), et = [];\n                          for (let We = 0; We < ot.length; We++) {\n                            let it = ot[We], Ft = qe.getTile(it), Ht = Ft.getBucket(Xe);\n                            if (!Ht) continue;\n                            let tr = Ht.programConfigurations.get(Xe.id), dr = le.useProgram("circle", tr), Sr = Ht.layoutVertexBuffer, Or = Ht.indexBuffer, Wr = le.style.map.terrain && le.style.map.terrain.getTerrainData(it), ni = { programConfiguration: tr, program: dr, layoutVertexBuffer: Sr, indexBuffer: Or, uniformValues: _o(le, it, Ft, Xe), terrainData: Wr };\n                            if (xr) {\n                              let Pi = Ht.segments.get();\n                              for (let cn of Pi) et.push({ segments: new a4.a0([cn]), sortKey: cn.sortKey, state: ni });\n                            } else et.push({ segments: Ht.segments, sortKey: 0, state: ni });\n                          }\n                          xr && et.sort((We, it) => We.sortKey - it.sortKey);\n                          for (let We of et) {\n                            let { programConfiguration: it, program: Ft, layoutVertexBuffer: Ht, indexBuffer: tr, uniformValues: dr, terrainData: Sr } = We.state;\n                            Ft.draw(Ir, ve.TRIANGLES, be, De, Be, Pa.disabled, dr, Sr, Xe.id, Ht, tr, We.segments, Xe.paint, le.transform.zoom, it);\n                          }\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "heatmap":\n                        (function(le, qe, Xe, ot) {\n                          if (Xe.paint.get("heatmap-opacity") === 0) return;\n                          let Tt = le.context;\n                          if (le.style.map.terrain) {\n                            for (let Yt of ot) {\n                              let Kt = qe.getTile(Yt);\n                              qe.hasRenderableParent(Yt) || (le.renderPass === "offscreen" ? _f(le, Kt, Xe, Yt) : le.renderPass === "translucent" && Yc(le, Xe, Yt));\n                            }\n                            Tt.viewport.set([0, 0, le.width, le.height]);\n                          } else le.renderPass === "offscreen" ? (function(Yt, Kt, xr, Ir) {\n                            let ve = Yt.context, be = ve.gl, De = Yo.disabled, Be = new qs([be.ONE, be.ONE], a4.aM.transparent, [true, true, true, true]);\n                            (function(et, We, it) {\n                              let Ft = et.gl;\n                              et.activeTexture.set(Ft.TEXTURE1), et.viewport.set([0, 0, We.width / 4, We.height / 4]);\n                              let Ht = it.heatmapFbos.get(a4.aU);\n                              Ht ? (Ft.bindTexture(Ft.TEXTURE_2D, Ht.colorAttachment.get()), et.bindFramebuffer.set(Ht.framebuffer)) : (Ht = eh(et, We.width / 4, We.height / 4), it.heatmapFbos.set(a4.aU, Ht));\n                            })(ve, Yt, xr), ve.clear({ color: a4.aM.transparent });\n                            for (let et = 0; et < Ir.length; et++) {\n                              let We = Ir[et];\n                              if (Kt.hasRenderableParent(We)) continue;\n                              let it = Kt.getTile(We), Ft = it.getBucket(xr);\n                              if (!Ft) continue;\n                              let Ht = Ft.programConfigurations.get(xr.id), tr = Yt.useProgram("heatmap", Ht), { zoom: dr } = Yt.transform;\n                              tr.draw(ve, be.TRIANGLES, Po.disabled, De, Be, Pa.disabled, ko(We.posMatrix, it, dr, xr.paint.get("heatmap-intensity")), null, xr.id, Ft.layoutVertexBuffer, Ft.indexBuffer, Ft.segments, xr.paint, Yt.transform.zoom, Ht);\n                            }\n                            ve.viewport.set([0, 0, Yt.width, Yt.height]);\n                          })(le, qe, Xe, ot) : le.renderPass === "translucent" && (function(Yt, Kt) {\n                            let xr = Yt.context, Ir = xr.gl;\n                            xr.setColorMode(Yt.colorModeForRenderPass());\n                            let ve = Kt.heatmapFbos.get(a4.aU);\n                            ve && (xr.activeTexture.set(Ir.TEXTURE0), Ir.bindTexture(Ir.TEXTURE_2D, ve.colorAttachment.get()), xr.activeTexture.set(Ir.TEXTURE1), th(xr, Kt).bind(Ir.LINEAR, Ir.CLAMP_TO_EDGE), Yt.useProgram("heatmapTexture").draw(xr, Ir.TRIANGLES, Po.disabled, Yo.disabled, Yt.colorModeForRenderPass(), Pa.disabled, Ds(Yt, Kt, 0, 1), null, Kt.id, Yt.viewportBuffer, Yt.quadTriangleIndexBuffer, Yt.viewportSegments, Kt.paint, Yt.transform.zoom));\n                          })(le, Xe);\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "line":\n                        (function(le, qe, Xe, ot) {\n                          if (le.renderPass !== "translucent") return;\n                          let Tt = Xe.paint.get("line-opacity"), Yt = Xe.paint.get("line-width");\n                          if (Tt.constantOr(1) === 0 || Yt.constantOr(1) === 0) return;\n                          let Kt = le.depthModeForSublayer(0, Po.ReadOnly), xr = le.colorModeForRenderPass(), Ir = Xe.paint.get("line-dasharray"), ve = Xe.paint.get("line-pattern"), be = ve.constantOr(1), De = Xe.paint.get("line-gradient"), Be = Xe.getCrossfadeParameters(), et = be ? "linePattern" : Ir ? "lineSDF" : De ? "lineGradient" : "line", We = le.context, it = We.gl, Ft = true;\n                          for (let Ht of ot) {\n                            let tr = qe.getTile(Ht);\n                            if (be && !tr.patternsLoaded()) continue;\n                            let dr = tr.getBucket(Xe);\n                            if (!dr) continue;\n                            let Sr = dr.programConfigurations.get(Xe.id), Or = le.context.program.get(), Wr = le.useProgram(et, Sr), ni = Ft || Wr.program !== Or, Pi = le.style.map.terrain && le.style.map.terrain.getTerrainData(Ht), cn = ve.constantOr(null);\n                            if (cn && tr.imageAtlas) {\n                              let Kn = tr.imageAtlas, Ta = Kn.patternPositions[cn.to.toString()], fa = Kn.patternPositions[cn.from.toString()];\n                              Ta && fa && Sr.setConstantPatternPositions(Ta, fa);\n                            }\n                            let ln = Pi ? Ht : null, Cn = be ? zl(le, tr, Xe, Be, ln) : Ir ? us(le, tr, Xe, Ir, Be, ln) : De ? ul(le, tr, Xe, dr.lineClipsArray.length, ln) : ll(le, tr, Xe, ln);\n                            if (be) We.activeTexture.set(it.TEXTURE0), tr.imageAtlasTexture.bind(it.LINEAR, it.CLAMP_TO_EDGE), Sr.updatePaintBuffers(Be);\n                            else if (Ir && (ni || le.lineAtlas.dirty)) We.activeTexture.set(it.TEXTURE0), le.lineAtlas.bind(We);\n                            else if (De) {\n                              let Kn = dr.gradients[Xe.id], Ta = Kn.texture;\n                              if (Xe.gradientVersion !== Kn.version) {\n                                let fa = 256;\n                                if (Xe.stepInterpolant) {\n                                  let $a = qe.getSource().maxzoom, Co = Ht.canonical.z === $a ? Math.ceil(1 << le.transform.maxZoom - Ht.canonical.z) : 1;\n                                  fa = a4.ac(a4.aV(dr.maxLineLength / a4.X * 1024 * Co), 256, We.maxTextureSize);\n                                }\n                                Kn.gradient = a4.aW({ expression: Xe.gradientExpression(), evaluationKey: "lineProgress", resolution: fa, image: Kn.gradient || void 0, clips: dr.lineClipsArray }), Kn.texture ? Kn.texture.update(Kn.gradient) : Kn.texture = new g3(We, Kn.gradient, it.RGBA), Kn.version = Xe.gradientVersion, Ta = Kn.texture;\n                              }\n                              We.activeTexture.set(it.TEXTURE0), Ta.bind(Xe.stepInterpolant ? it.NEAREST : it.LINEAR, it.CLAMP_TO_EDGE);\n                            }\n                            Wr.draw(We, it.TRIANGLES, Kt, le.stencilModeForClipping(Ht), xr, Pa.disabled, Cn, Pi, Xe.id, dr.layoutVertexBuffer, dr.indexBuffer, dr.segments, Xe.paint, le.transform.zoom, Sr, dr.layoutVertexBuffer2), Ft = false;\n                          }\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "fill":\n                        (function(le, qe, Xe, ot) {\n                          let Tt = Xe.paint.get("fill-color"), Yt = Xe.paint.get("fill-opacity");\n                          if (Yt.constantOr(1) === 0) return;\n                          let Kt = le.colorModeForRenderPass(), xr = Xe.paint.get("fill-pattern"), Ir = le.opaquePassEnabledForLayer() && !xr.constantOr(1) && Tt.constantOr(a4.aM.transparent).a === 1 && Yt.constantOr(0) === 1 ? "opaque" : "translucent";\n                          if (le.renderPass === Ir) {\n                            let ve = le.depthModeForSublayer(1, le.renderPass === "opaque" ? Po.ReadWrite : Po.ReadOnly);\n                            Hf(le, qe, Xe, ot, ve, Kt, false);\n                          }\n                          if (le.renderPass === "translucent" && Xe.paint.get("fill-antialias")) {\n                            let ve = le.depthModeForSublayer(Xe.getPaintProperty("fill-outline-color") ? 2 : 0, Po.ReadOnly);\n                            Hf(le, qe, Xe, ot, ve, Kt, true);\n                          }\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "fill-extrusion":\n                        (function(le, qe, Xe, ot) {\n                          let Tt = Xe.paint.get("fill-extrusion-opacity");\n                          if (Tt !== 0 && le.renderPass === "translucent") {\n                            let Yt = new Po(le.context.gl.LEQUAL, Po.ReadWrite, le.depthRangeFor3D);\n                            if (Tt !== 1 || Xe.paint.get("fill-extrusion-pattern").constantOr(1)) cc(le, qe, Xe, ot, Yt, Yo.disabled, qs.disabled), cc(le, qe, Xe, ot, Yt, le.stencilModeFor3D(), le.colorModeForRenderPass());\n                            else {\n                              let Kt = le.colorModeForRenderPass();\n                              cc(le, qe, Xe, ot, Yt, Yo.disabled, Kt);\n                            }\n                          }\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "hillshade":\n                        (function(le, qe, Xe, ot) {\n                          if (le.renderPass !== "offscreen" && le.renderPass !== "translucent") return;\n                          let Tt = le.context, Yt = le.depthModeForSublayer(0, Po.ReadOnly), Kt = le.colorModeForRenderPass(), [xr, Ir] = le.renderPass === "translucent" ? le.stencilConfigForOverlap(ot) : [{}, ot];\n                          for (let ve of Ir) {\n                            let be = qe.getTile(ve);\n                            be.needsHillshadePrepare !== void 0 && be.needsHillshadePrepare && le.renderPass === "offscreen" ? Nl(le, be, Xe, Yt, Yo.disabled, Kt) : le.renderPass === "translucent" && of(le, ve, be, Xe, Yt, xr[ve.overscaledZ], Kt);\n                          }\n                          Tt.viewport.set([0, 0, le.width, le.height]);\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "raster":\n                        (function(le, qe, Xe, ot) {\n                          if (le.renderPass !== "translucent" || Xe.paint.get("raster-opacity") === 0 || !ot.length) return;\n                          let Tt = le.context, Yt = Tt.gl, Kt = qe.getSource(), xr = le.useProgram("raster"), Ir = le.colorModeForRenderPass(), [ve, be] = Kt instanceof Gt ? [{}, ot] : le.stencilConfigForOverlap(ot), De = be[be.length - 1].overscaledZ, Be = !le.options.moving;\n                          for (let et of be) {\n                            let We = le.depthModeForSublayer(et.overscaledZ - De, Xe.paint.get("raster-opacity") === 1 ? Po.ReadWrite : Po.ReadOnly, Yt.LESS), it = qe.getTile(et);\n                            it.registerFadeDuration(Xe.paint.get("raster-fade-duration"));\n                            let Ft = qe.findLoadedParent(et, 0), Ht = qe.findLoadedSibling(et), tr = Kc(it, Ft || Ht || null, qe, Xe, le.transform, le.style.map.terrain), dr, Sr, Or = Xe.paint.get("raster-resampling") === "nearest" ? Yt.NEAREST : Yt.LINEAR;\n                            Tt.activeTexture.set(Yt.TEXTURE0), it.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), Tt.activeTexture.set(Yt.TEXTURE1), Ft ? (Ft.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), dr = Math.pow(2, Ft.tileID.overscaledZ - it.tileID.overscaledZ), Sr = [it.tileID.canonical.x * dr % 1, it.tileID.canonical.y * dr % 1]) : it.texture.bind(Or, Yt.CLAMP_TO_EDGE, Yt.LINEAR_MIPMAP_NEAREST), it.texture.useMipmap && Tt.extTextureFilterAnisotropic && le.transform.pitch > 20 && Yt.texParameterf(Yt.TEXTURE_2D, Tt.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT, Tt.extTextureFilterAnisotropicMax);\n                            let Wr = le.style.map.terrain && le.style.map.terrain.getTerrainData(et), ni = Wr ? et : null, Pi = ni ? ni.posMatrix : le.transform.calculatePosMatrix(et.toUnwrapped(), Be), cn = cl(Pi, Sr || [0, 0], dr || 1, tr, Xe);\n                            Kt instanceof Gt ? xr.draw(Tt, Yt.TRIANGLES, We, Yo.disabled, Ir, Pa.disabled, cn, Wr, Xe.id, Kt.boundsBuffer, le.quadTriangleIndexBuffer, Kt.boundsSegments) : xr.draw(Tt, Yt.TRIANGLES, We, ve[et.overscaledZ], Ir, Pa.disabled, cn, Wr, Xe.id, le.rasterBoundsBuffer, le.quadTriangleIndexBuffer, le.rasterBoundsSegments);\n                          }\n                        })(w4, B4, Q, ee);\n                        break;\n                      case "background":\n                        (function(le, qe, Xe, ot) {\n                          let Tt = Xe.paint.get("background-color"), Yt = Xe.paint.get("background-opacity");\n                          if (Yt === 0) return;\n                          let Kt = le.context, xr = Kt.gl, Ir = le.transform, ve = Ir.tileSize, be = Xe.paint.get("background-pattern");\n                          if (le.isPatternMissing(be)) return;\n                          let De = !be && Tt.a === 1 && Yt === 1 && le.opaquePassEnabledForLayer() ? "opaque" : "translucent";\n                          if (le.renderPass !== De) return;\n                          let Be = Yo.disabled, et = le.depthModeForSublayer(0, De === "opaque" ? Po.ReadWrite : Po.ReadOnly), We = le.colorModeForRenderPass(), it = le.useProgram(be ? "backgroundPattern" : "background"), Ft = ot || Ir.coveringTiles({ tileSize: ve, terrain: le.style.map.terrain });\n                          be && (Kt.activeTexture.set(xr.TEXTURE0), le.imageManager.bind(le.context));\n                          let Ht = Xe.getCrossfadeParameters();\n                          for (let tr of Ft) {\n                            let dr = ot ? tr.posMatrix : le.transform.calculatePosMatrix(tr.toUnwrapped()), Sr = be ? Su(dr, Yt, le, be, { tileID: tr, tileSize: ve }, Ht) : Zl(dr, Yt, Tt), Or = le.style.map.terrain && le.style.map.terrain.getTerrainData(tr);\n                            it.draw(Kt, xr.TRIANGLES, et, Be, We, Pa.disabled, Sr, Or, Xe.id, le.tileExtentBuffer, le.quadTriangleIndexBuffer, le.tileExtentSegments);\n                          }\n                        })(w4, 0, Q, ee);\n                        break;\n                      case "custom":\n                        (function(le, qe, Xe) {\n                          let ot = le.context, Tt = Xe.implementation;\n                          if (le.renderPass === "offscreen") {\n                            let Yt = Tt.prerender;\n                            Yt && (le.setCustomLayerDefaults(), ot.setColorMode(le.colorModeForRenderPass()), Yt.call(Tt, ot.gl, le.transform.customLayerMatrix()), ot.setDirty(), le.setBaseState());\n                          } else if (le.renderPass === "translucent") {\n                            le.setCustomLayerDefaults(), ot.setColorMode(le.colorModeForRenderPass()), ot.setStencilMode(Yo.disabled);\n                            let Yt = Tt.renderingMode === "3d" ? new Po(le.context.gl.LEQUAL, Po.ReadWrite, le.depthRangeFor3D) : le.depthModeForSublayer(0, Po.ReadOnly);\n                            ot.setDepthMode(Yt), Tt.render(ot.gl, le.transform.customLayerMatrix(), { farZ: le.transform.farZ, nearZ: le.transform.nearZ, fov: le.transform._fov, modelViewProjectionMatrix: le.transform.modelViewProjectionMatrix, projectionMatrix: le.transform.projectionMatrix }), ot.setDirty(), le.setBaseState(), ot.bindFramebuffer.set(null);\n                          }\n                        })(w4, 0, Q);\n                    }\n                  }\n                  translatePosMatrix(w4, B4, Q, ee, le) {\n                    if (!Q[0] && !Q[1]) return w4;\n                    let qe = le ? ee === "map" ? this.transform.angle : 0 : ee === "viewport" ? -this.transform.angle : 0;\n                    if (qe) {\n                      let Tt = Math.sin(qe), Yt = Math.cos(qe);\n                      Q = [Q[0] * Yt - Q[1] * Tt, Q[0] * Tt + Q[1] * Yt];\n                    }\n                    let Xe = [le ? Q[0] : In(B4, Q[0], this.transform.zoom), le ? Q[1] : In(B4, Q[1], this.transform.zoom), 0], ot = new Float32Array(16);\n                    return a4.J(ot, w4, Xe), ot;\n                  }\n                  saveTileTexture(w4) {\n                    let B4 = this._tileTextures[w4.size[0]];\n                    B4 ? B4.push(w4) : this._tileTextures[w4.size[0]] = [w4];\n                  }\n                  getTileTexture(w4) {\n                    let B4 = this._tileTextures[w4];\n                    return B4 && B4.length > 0 ? B4.pop() : null;\n                  }\n                  isPatternMissing(w4) {\n                    if (!w4) return false;\n                    if (!w4.from || !w4.to) return true;\n                    let B4 = this.imageManager.getPattern(w4.from.toString()), Q = this.imageManager.getPattern(w4.to.toString());\n                    return !B4 || !Q;\n                  }\n                  useProgram(w4, B4) {\n                    this.cache = this.cache || {};\n                    let Q = w4 + (B4 ? B4.cacheKey : "") + (this._showOverdrawInspector ? "/overdraw" : "") + (this.style.map.terrain ? "/terrain" : "");\n                    return this.cache[Q] || (this.cache[Q] = new hn(this.context, jn[w4], B4, nc[w4], this._showOverdrawInspector, this.style.map.terrain)), this.cache[Q];\n                  }\n                  setCustomLayerDefaults() {\n                    this.context.unbindVAO(), this.context.cullFace.setDefault(), this.context.activeTexture.setDefault(), this.context.pixelStoreUnpack.setDefault(), this.context.pixelStoreUnpackPremultiplyAlpha.setDefault(), this.context.pixelStoreUnpackFlipY.setDefault();\n                  }\n                  setBaseState() {\n                    let w4 = this.context.gl;\n                    this.context.cullFace.set(false), this.context.viewport.set([0, 0, this.width, this.height]), this.context.blendEquation.set(w4.FUNC_ADD);\n                  }\n                  initDebugOverlayCanvas() {\n                    this.debugOverlayCanvas == null && (this.debugOverlayCanvas = document.createElement("canvas"), this.debugOverlayCanvas.width = 512, this.debugOverlayCanvas.height = 512, this.debugOverlayTexture = new g3(this.context, this.debugOverlayCanvas, this.context.gl.RGBA));\n                  }\n                  destroy() {\n                    this.debugOverlayTexture && this.debugOverlayTexture.destroy();\n                  }\n                  overLimit() {\n                    let { drawingBufferWidth: w4, drawingBufferHeight: B4 } = this.context.gl;\n                    return this.width !== w4 || this.height !== B4;\n                  }\n                }\n                class ks {\n                  constructor(w4, B4) {\n                    this.points = w4, this.planes = B4;\n                  }\n                  static fromInvProjectionMatrix(w4, B4, Q) {\n                    let ee = Math.pow(2, Q), le = [[-1, 1, -1, 1], [1, 1, -1, 1], [1, -1, -1, 1], [-1, -1, -1, 1], [-1, 1, 1, 1], [1, 1, 1, 1], [1, -1, 1, 1], [-1, -1, 1, 1]].map((Xe) => {\n                      let ot = 1 / (Xe = a4.af([], Xe, w4))[3] / B4 * ee;\n                      return a4.b1(Xe, Xe, [ot, ot, 1 / Xe[3], ot]);\n                    }), qe = [[0, 1, 2], [6, 5, 4], [0, 3, 7], [2, 1, 5], [3, 2, 6], [0, 4, 5]].map((Xe) => {\n                      let ot = (function(xr, Ir) {\n                        var ve = Ir[0], be = Ir[1], De = Ir[2], Be = ve * ve + be * be + De * De;\n                        return Be > 0 && (Be = 1 / Math.sqrt(Be)), xr[0] = Ir[0] * Be, xr[1] = Ir[1] * Be, xr[2] = Ir[2] * Be, xr;\n                      })([], (function(xr, Ir, ve) {\n                        var be = Ir[0], De = Ir[1], Be = Ir[2], et = ve[0], We = ve[1], it = ve[2];\n                        return xr[0] = De * it - Be * We, xr[1] = Be * et - be * it, xr[2] = be * We - De * et, xr;\n                      })([], L3([], le[Xe[0]], le[Xe[1]]), L3([], le[Xe[2]], le[Xe[1]]))), Tt = -((Yt = ot)[0] * (Kt = le[Xe[1]])[0] + Yt[1] * Kt[1] + Yt[2] * Kt[2]);\n                      var Yt, Kt;\n                      return ot.concat(Tt);\n                    });\n                    return new ks(le, qe);\n                  }\n                }\n                class bc {\n                  constructor(w4, B4) {\n                    this.min = w4, this.max = B4, this.center = (function(Q, ee, le) {\n                      return Q[0] = 0.5 * ee[0], Q[1] = 0.5 * ee[1], Q[2] = 0.5 * ee[2], Q;\n                    })([], (function(Q, ee, le) {\n                      return Q[0] = ee[0] + le[0], Q[1] = ee[1] + le[1], Q[2] = ee[2] + le[2], Q;\n                    })([], this.min, this.max));\n                  }\n                  quadrant(w4) {\n                    let B4 = [w4 % 2 == 0, w4 < 2], Q = E3(this.min), ee = E3(this.max);\n                    for (let le = 0; le < B4.length; le++) Q[le] = B4[le] ? this.min[le] : this.center[le], ee[le] = B4[le] ? this.center[le] : this.max[le];\n                    return ee[2] = this.max[2], new bc(Q, ee);\n                  }\n                  distanceX(w4) {\n                    return Math.max(Math.min(this.max[0], w4[0]), this.min[0]) - w4[0];\n                  }\n                  distanceY(w4) {\n                    return Math.max(Math.min(this.max[1], w4[1]), this.min[1]) - w4[1];\n                  }\n                  intersects(w4) {\n                    let B4 = [[this.min[0], this.min[1], this.min[2], 1], [this.max[0], this.min[1], this.min[2], 1], [this.max[0], this.max[1], this.min[2], 1], [this.min[0], this.max[1], this.min[2], 1], [this.min[0], this.min[1], this.max[2], 1], [this.max[0], this.min[1], this.max[2], 1], [this.max[0], this.max[1], this.max[2], 1], [this.min[0], this.max[1], this.max[2], 1]], Q = true;\n                    for (let ee = 0; ee < w4.planes.length; ee++) {\n                      let le = w4.planes[ee], qe = 0;\n                      for (let Xe = 0; Xe < B4.length; Xe++) a4.b2(le, B4[Xe]) >= 0 && qe++;\n                      if (qe === 0) return 0;\n                      qe !== B4.length && (Q = false);\n                    }\n                    if (Q) return 2;\n                    for (let ee = 0; ee < 3; ee++) {\n                      let le = Number.MAX_VALUE, qe = -Number.MAX_VALUE;\n                      for (let Xe = 0; Xe < w4.points.length; Xe++) {\n                        let ot = w4.points[Xe][ee] - this.min[ee];\n                        le = Math.min(le, ot), qe = Math.max(qe, ot);\n                      }\n                      if (qe < 0 || le > this.max[ee] - this.min[ee]) return 0;\n                    }\n                    return 1;\n                  }\n                }\n                class hu {\n                  constructor(w4 = 0, B4 = 0, Q = 0, ee = 0) {\n                    if (isNaN(w4) || w4 < 0 || isNaN(B4) || B4 < 0 || isNaN(Q) || Q < 0 || isNaN(ee) || ee < 0) throw new Error("Invalid value for edge-insets, top, bottom, left and right must all be numbers");\n                    this.top = w4, this.bottom = B4, this.left = Q, this.right = ee;\n                  }\n                  interpolate(w4, B4, Q) {\n                    return B4.top != null && w4.top != null && (this.top = a4.y.number(w4.top, B4.top, Q)), B4.bottom != null && w4.bottom != null && (this.bottom = a4.y.number(w4.bottom, B4.bottom, Q)), B4.left != null && w4.left != null && (this.left = a4.y.number(w4.left, B4.left, Q)), B4.right != null && w4.right != null && (this.right = a4.y.number(w4.right, B4.right, Q)), this;\n                  }\n                  getCenter(w4, B4) {\n                    let Q = a4.ac((this.left + w4 - this.right) / 2, 0, w4), ee = a4.ac((this.top + B4 - this.bottom) / 2, 0, B4);\n                    return new a4.P(Q, ee);\n                  }\n                  equals(w4) {\n                    return this.top === w4.top && this.bottom === w4.bottom && this.left === w4.left && this.right === w4.right;\n                  }\n                  clone() {\n                    return new hu(this.top, this.bottom, this.left, this.right);\n                  }\n                  toJSON() {\n                    return { top: this.top, bottom: this.bottom, left: this.left, right: this.right };\n                  }\n                }\n                let _u = 85.051129;\n                class nl {\n                  constructor(w4, B4, Q, ee, le) {\n                    this.tileSize = 512, this._renderWorldCopies = le === void 0 || !!le, this._minZoom = w4 || 0, this._maxZoom = B4 || 22, this._minPitch = Q == null ? 0 : Q, this._maxPitch = ee == null ? 60 : ee, this.setMaxBounds(), this.width = 0, this.height = 0, this._center = new a4.N(0, 0), this._elevation = 0, this.zoom = 0, this.angle = 0, this._fov = 0.6435011087932844, this._pitch = 0, this._unmodified = true, this._edgeInsets = new hu(), this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {}, this.minElevationForCurrentTile = 0;\n                  }\n                  clone() {\n                    let w4 = new nl(this._minZoom, this._maxZoom, this._minPitch, this.maxPitch, this._renderWorldCopies);\n                    return w4.apply(this), w4;\n                  }\n                  apply(w4) {\n                    this.tileSize = w4.tileSize, this.latRange = w4.latRange, this.lngRange = w4.lngRange, this.width = w4.width, this.height = w4.height, this._center = w4._center, this._elevation = w4._elevation, this.minElevationForCurrentTile = w4.minElevationForCurrentTile, this.zoom = w4.zoom, this.angle = w4.angle, this._fov = w4._fov, this._pitch = w4._pitch, this._unmodified = w4._unmodified, this._edgeInsets = w4._edgeInsets.clone(), this._calcMatrices();\n                  }\n                  get minZoom() {\n                    return this._minZoom;\n                  }\n                  set minZoom(w4) {\n                    this._minZoom !== w4 && (this._minZoom = w4, this.zoom = Math.max(this.zoom, w4));\n                  }\n                  get maxZoom() {\n                    return this._maxZoom;\n                  }\n                  set maxZoom(w4) {\n                    this._maxZoom !== w4 && (this._maxZoom = w4, this.zoom = Math.min(this.zoom, w4));\n                  }\n                  get minPitch() {\n                    return this._minPitch;\n                  }\n                  set minPitch(w4) {\n                    this._minPitch !== w4 && (this._minPitch = w4, this.pitch = Math.max(this.pitch, w4));\n                  }\n                  get maxPitch() {\n                    return this._maxPitch;\n                  }\n                  set maxPitch(w4) {\n                    this._maxPitch !== w4 && (this._maxPitch = w4, this.pitch = Math.min(this.pitch, w4));\n                  }\n                  get renderWorldCopies() {\n                    return this._renderWorldCopies;\n                  }\n                  set renderWorldCopies(w4) {\n                    w4 === void 0 ? w4 = true : w4 === null && (w4 = false), this._renderWorldCopies = w4;\n                  }\n                  get worldSize() {\n                    return this.tileSize * this.scale;\n                  }\n                  get centerOffset() {\n                    return this.centerPoint._sub(this.size._div(2));\n                  }\n                  get size() {\n                    return new a4.P(this.width, this.height);\n                  }\n                  get bearing() {\n                    return -this.angle / Math.PI * 180;\n                  }\n                  set bearing(w4) {\n                    let B4 = -a4.b3(w4, -180, 180) * Math.PI / 180;\n                    this.angle !== B4 && (this._unmodified = false, this.angle = B4, this._calcMatrices(), this.rotationMatrix = (function() {\n                      var Q = new a4.A(4);\n                      return a4.A != Float32Array && (Q[1] = 0, Q[2] = 0), Q[0] = 1, Q[3] = 1, Q;\n                    })(), (function(Q, ee, le) {\n                      var qe = ee[0], Xe = ee[1], ot = ee[2], Tt = ee[3], Yt = Math.sin(le), Kt = Math.cos(le);\n                      Q[0] = qe * Kt + ot * Yt, Q[1] = Xe * Kt + Tt * Yt, Q[2] = qe * -Yt + ot * Kt, Q[3] = Xe * -Yt + Tt * Kt;\n                    })(this.rotationMatrix, this.rotationMatrix, this.angle));\n                  }\n                  get pitch() {\n                    return this._pitch / Math.PI * 180;\n                  }\n                  set pitch(w4) {\n                    let B4 = a4.ac(w4, this.minPitch, this.maxPitch) / 180 * Math.PI;\n                    this._pitch !== B4 && (this._unmodified = false, this._pitch = B4, this._calcMatrices());\n                  }\n                  get fov() {\n                    return this._fov / Math.PI * 180;\n                  }\n                  set fov(w4) {\n                    w4 = Math.max(0.01, Math.min(60, w4)), this._fov !== w4 && (this._unmodified = false, this._fov = w4 / 180 * Math.PI, this._calcMatrices());\n                  }\n                  get zoom() {\n                    return this._zoom;\n                  }\n                  set zoom(w4) {\n                    let B4 = Math.min(Math.max(w4, this.minZoom), this.maxZoom);\n                    this._zoom !== B4 && (this._unmodified = false, this._zoom = B4, this.tileZoom = Math.max(0, Math.floor(B4)), this.scale = this.zoomScale(B4), this._constrain(), this._calcMatrices());\n                  }\n                  get center() {\n                    return this._center;\n                  }\n                  set center(w4) {\n                    w4.lat === this._center.lat && w4.lng === this._center.lng || (this._unmodified = false, this._center = w4, this._constrain(), this._calcMatrices());\n                  }\n                  get elevation() {\n                    return this._elevation;\n                  }\n                  set elevation(w4) {\n                    w4 !== this._elevation && (this._elevation = w4, this._constrain(), this._calcMatrices());\n                  }\n                  get padding() {\n                    return this._edgeInsets.toJSON();\n                  }\n                  set padding(w4) {\n                    this._edgeInsets.equals(w4) || (this._unmodified = false, this._edgeInsets.interpolate(this._edgeInsets, w4, 1), this._calcMatrices());\n                  }\n                  get centerPoint() {\n                    return this._edgeInsets.getCenter(this.width, this.height);\n                  }\n                  isPaddingEqual(w4) {\n                    return this._edgeInsets.equals(w4);\n                  }\n                  interpolatePadding(w4, B4, Q) {\n                    this._unmodified = false, this._edgeInsets.interpolate(w4, B4, Q), this._constrain(), this._calcMatrices();\n                  }\n                  coveringZoomLevel(w4) {\n                    let B4 = (w4.roundZoom ? Math.round : Math.floor)(this.zoom + this.scaleZoom(this.tileSize / w4.tileSize));\n                    return Math.max(0, B4);\n                  }\n                  getVisibleUnwrappedCoordinates(w4) {\n                    let B4 = [new a4.b4(0, w4)];\n                    if (this._renderWorldCopies) {\n                      let Q = this.pointCoordinate(new a4.P(0, 0)), ee = this.pointCoordinate(new a4.P(this.width, 0)), le = this.pointCoordinate(new a4.P(this.width, this.height)), qe = this.pointCoordinate(new a4.P(0, this.height)), Xe = Math.floor(Math.min(Q.x, ee.x, le.x, qe.x)), ot = Math.floor(Math.max(Q.x, ee.x, le.x, qe.x)), Tt = 1;\n                      for (let Yt = Xe - Tt; Yt <= ot + Tt; Yt++) Yt !== 0 && B4.push(new a4.b4(Yt, w4));\n                    }\n                    return B4;\n                  }\n                  coveringTiles(w4) {\n                    var B4, Q;\n                    let ee = this.coveringZoomLevel(w4), le = ee;\n                    if (w4.minzoom !== void 0 && ee < w4.minzoom) return [];\n                    w4.maxzoom !== void 0 && ee > w4.maxzoom && (ee = w4.maxzoom);\n                    let qe = this.pointCoordinate(this.getCameraPoint()), Xe = a4.Z.fromLngLat(this.center), ot = Math.pow(2, ee), Tt = [ot * qe.x, ot * qe.y, 0], Yt = [ot * Xe.x, ot * Xe.y, 0], Kt = ks.fromInvProjectionMatrix(this.invModelViewProjectionMatrix, this.worldSize, ee), xr = w4.minzoom || 0;\n                    !w4.terrain && this.pitch <= 60 && this._edgeInsets.top < 0.1 && (xr = ee);\n                    let Ir = w4.terrain ? 2 / Math.min(this.tileSize, w4.tileSize) * this.tileSize : 3, ve = (We) => ({ aabb: new bc([We * ot, 0, 0], [(We + 1) * ot, ot, 0]), zoom: 0, x: 0, y: 0, wrap: We, fullyVisible: false }), be = [], De = [], Be = ee, et = w4.reparseOverscaled ? le : ee;\n                    if (this._renderWorldCopies) for (let We = 1; We <= 3; We++) be.push(ve(-We)), be.push(ve(We));\n                    for (be.push(ve(0)); be.length > 0; ) {\n                      let We = be.pop(), it = We.x, Ft = We.y, Ht = We.fullyVisible;\n                      if (!Ht) {\n                        let Wr = We.aabb.intersects(Kt);\n                        if (Wr === 0) continue;\n                        Ht = Wr === 2;\n                      }\n                      let tr = w4.terrain ? Tt : Yt, dr = We.aabb.distanceX(tr), Sr = We.aabb.distanceY(tr), Or = Math.max(Math.abs(dr), Math.abs(Sr));\n                      if (We.zoom === Be || Or > Ir + (1 << Be - We.zoom) - 2 && We.zoom >= xr) {\n                        let Wr = Be - We.zoom, ni = Tt[0] - 0.5 - (it << Wr), Pi = Tt[1] - 0.5 - (Ft << Wr);\n                        De.push({ tileID: new a4.S(We.zoom === Be ? et : We.zoom, We.wrap, We.zoom, it, Ft), distanceSq: x2([Yt[0] - 0.5 - it, Yt[1] - 0.5 - Ft]), tileDistanceToCamera: Math.sqrt(ni * ni + Pi * Pi) });\n                      } else for (let Wr = 0; Wr < 4; Wr++) {\n                        let ni = (it << 1) + Wr % 2, Pi = (Ft << 1) + (Wr >> 1), cn = We.zoom + 1, ln = We.aabb.quadrant(Wr);\n                        if (w4.terrain) {\n                          let Cn = new a4.S(cn, We.wrap, cn, ni, Pi), Kn = w4.terrain.getMinMaxElevation(Cn), Ta = (B4 = Kn.minElevation) !== null && B4 !== void 0 ? B4 : this.elevation, fa = (Q = Kn.maxElevation) !== null && Q !== void 0 ? Q : this.elevation;\n                          ln = new bc([ln.min[0], ln.min[1], Ta], [ln.max[0], ln.max[1], fa]);\n                        }\n                        be.push({ aabb: ln, zoom: cn, x: ni, y: Pi, wrap: We.wrap, fullyVisible: Ht });\n                      }\n                    }\n                    return De.sort((We, it) => We.distanceSq - it.distanceSq).map((We) => We.tileID);\n                  }\n                  resize(w4, B4) {\n                    this.width = w4, this.height = B4, this.pixelsToGLUnits = [2 / w4, -2 / B4], this._constrain(), this._calcMatrices();\n                  }\n                  get unmodified() {\n                    return this._unmodified;\n                  }\n                  zoomScale(w4) {\n                    return Math.pow(2, w4);\n                  }\n                  scaleZoom(w4) {\n                    return Math.log(w4) / Math.LN2;\n                  }\n                  project(w4) {\n                    let B4 = a4.ac(w4.lat, -85.051129, _u);\n                    return new a4.P(a4.O(w4.lng) * this.worldSize, a4.Q(B4) * this.worldSize);\n                  }\n                  unproject(w4) {\n                    return new a4.Z(w4.x / this.worldSize, w4.y / this.worldSize).toLngLat();\n                  }\n                  get point() {\n                    return this.project(this.center);\n                  }\n                  getCameraPosition() {\n                    return { lngLat: this.pointLocation(this.getCameraPoint()), altitude: Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter + this.elevation };\n                  }\n                  recalculateZoom(w4) {\n                    let B4 = this.elevation, Q = Math.cos(this._pitch) * this.cameraToCenterDistance / this._pixelPerMeter, ee = this.pointLocation(this.centerPoint, w4), le = w4.getElevationForLngLatZoom(ee, this.tileZoom);\n                    if (!(this.elevation - le)) return;\n                    let qe = Q + B4 - le, Xe = Math.cos(this._pitch) * this.cameraToCenterDistance / qe / a4.b5(1, ee.lat), ot = this.scaleZoom(Xe / this.tileSize);\n                    this._elevation = le, this._center = ee, this.zoom = ot;\n                  }\n                  setLocationAtPoint(w4, B4) {\n                    let Q = this.pointCoordinate(B4), ee = this.pointCoordinate(this.centerPoint), le = this.locationCoordinate(w4), qe = new a4.Z(le.x - (Q.x - ee.x), le.y - (Q.y - ee.y));\n                    this.center = this.coordinateLocation(qe), this._renderWorldCopies && (this.center = this.center.wrap());\n                  }\n                  locationPoint(w4, B4) {\n                    return B4 ? this.coordinatePoint(this.locationCoordinate(w4), B4.getElevationForLngLatZoom(w4, this.tileZoom), this.pixelMatrix3D) : this.coordinatePoint(this.locationCoordinate(w4));\n                  }\n                  pointLocation(w4, B4) {\n                    return this.coordinateLocation(this.pointCoordinate(w4, B4));\n                  }\n                  locationCoordinate(w4) {\n                    return a4.Z.fromLngLat(w4);\n                  }\n                  coordinateLocation(w4) {\n                    return w4 && w4.toLngLat();\n                  }\n                  pointCoordinate(w4, B4) {\n                    if (B4) {\n                      let xr = B4.pointCoordinate(w4);\n                      if (xr != null) return xr;\n                    }\n                    let Q = [w4.x, w4.y, 0, 1], ee = [w4.x, w4.y, 1, 1];\n                    a4.af(Q, Q, this.pixelMatrixInverse), a4.af(ee, ee, this.pixelMatrixInverse);\n                    let le = Q[3], qe = ee[3], Xe = Q[1] / le, ot = ee[1] / qe, Tt = Q[2] / le, Yt = ee[2] / qe, Kt = Tt === Yt ? 0 : (0 - Tt) / (Yt - Tt);\n                    return new a4.Z(a4.y.number(Q[0] / le, ee[0] / qe, Kt) / this.worldSize, a4.y.number(Xe, ot, Kt) / this.worldSize);\n                  }\n                  coordinatePoint(w4, B4 = 0, Q = this.pixelMatrix) {\n                    let ee = [w4.x * this.worldSize, w4.y * this.worldSize, B4, 1];\n                    return a4.af(ee, ee, Q), new a4.P(ee[0] / ee[3], ee[1] / ee[3]);\n                  }\n                  getBounds() {\n                    let w4 = Math.max(0, this.height / 2 - this.getHorizon());\n                    return new ce().extend(this.pointLocation(new a4.P(0, w4))).extend(this.pointLocation(new a4.P(this.width, w4))).extend(this.pointLocation(new a4.P(this.width, this.height))).extend(this.pointLocation(new a4.P(0, this.height)));\n                  }\n                  getMaxBounds() {\n                    return this.latRange && this.latRange.length === 2 && this.lngRange && this.lngRange.length === 2 ? new ce([this.lngRange[0], this.latRange[0]], [this.lngRange[1], this.latRange[1]]) : null;\n                  }\n                  getHorizon() {\n                    return Math.tan(Math.PI / 2 - this._pitch) * this.cameraToCenterDistance * 0.85;\n                  }\n                  setMaxBounds(w4) {\n                    w4 ? (this.lngRange = [w4.getWest(), w4.getEast()], this.latRange = [w4.getSouth(), w4.getNorth()], this._constrain()) : (this.lngRange = null, this.latRange = [-85.051129, _u]);\n                  }\n                  calculateTileMatrix(w4) {\n                    let B4 = w4.canonical, Q = this.worldSize / this.zoomScale(B4.z), ee = B4.x + Math.pow(2, B4.z) * w4.wrap, le = a4.an(new Float64Array(16));\n                    return a4.J(le, le, [ee * Q, B4.y * Q, 0]), a4.K(le, le, [Q / a4.X, Q / a4.X, 1]), le;\n                  }\n                  calculatePosMatrix(w4, B4 = false) {\n                    let Q = w4.key, ee = B4 ? this._alignedPosMatrixCache : this._posMatrixCache;\n                    if (ee[Q]) return ee[Q];\n                    let le = this.calculateTileMatrix(w4);\n                    return a4.L(le, B4 ? this.alignedModelViewProjectionMatrix : this.modelViewProjectionMatrix, le), ee[Q] = new Float32Array(le), ee[Q];\n                  }\n                  calculateFogMatrix(w4) {\n                    let B4 = w4.key, Q = this._fogMatrixCache;\n                    if (Q[B4]) return Q[B4];\n                    let ee = this.calculateTileMatrix(w4);\n                    return a4.L(ee, this.fogMatrix, ee), Q[B4] = new Float32Array(ee), Q[B4];\n                  }\n                  customLayerMatrix() {\n                    return this.mercatorMatrix.slice();\n                  }\n                  getConstrained(w4, B4) {\n                    B4 = a4.ac(+B4, this.minZoom, this.maxZoom);\n                    let Q = { center: new a4.N(w4.lng, w4.lat), zoom: B4 }, ee = this.lngRange;\n                    if (!this._renderWorldCopies && ee === null) {\n                      let We = 179.9999999999;\n                      ee = [-We, We];\n                    }\n                    let le = this.tileSize * this.zoomScale(Q.zoom), qe = 0, Xe = le, ot = 0, Tt = le, Yt = 0, Kt = 0, { x: xr, y: Ir } = this.size;\n                    if (this.latRange) {\n                      let We = this.latRange;\n                      qe = a4.Q(We[1]) * le, Xe = a4.Q(We[0]) * le, Xe - qe < Ir && (Yt = Ir / (Xe - qe));\n                    }\n                    ee && (ot = a4.b3(a4.O(ee[0]) * le, 0, le), Tt = a4.b3(a4.O(ee[1]) * le, 0, le), Tt < ot && (Tt += le), Tt - ot < xr && (Kt = xr / (Tt - ot)));\n                    let { x: ve, y: be } = this.project.call({ worldSize: le }, w4), De, Be, et = Math.max(Kt || 0, Yt || 0);\n                    if (et) {\n                      let We = new a4.P(Kt ? (Tt + ot) / 2 : ve, Yt ? (Xe + qe) / 2 : be);\n                      return Q.center = this.unproject.call({ worldSize: le }, We).wrap(), Q.zoom += this.scaleZoom(et), Q;\n                    }\n                    if (this.latRange) {\n                      let We = Ir / 2;\n                      be - We < qe && (Be = qe + We), be + We > Xe && (Be = Xe - We);\n                    }\n                    if (ee) {\n                      let We = (ot + Tt) / 2, it = ve;\n                      this._renderWorldCopies && (it = a4.b3(ve, We - le / 2, We + le / 2));\n                      let Ft = xr / 2;\n                      it - Ft < ot && (De = ot + Ft), it + Ft > Tt && (De = Tt - Ft);\n                    }\n                    if (De !== void 0 || Be !== void 0) {\n                      let We = new a4.P(De != null ? De : ve, Be != null ? Be : be);\n                      Q.center = this.unproject.call({ worldSize: le }, We).wrap();\n                    }\n                    return Q;\n                  }\n                  _constrain() {\n                    if (!this.center || !this.width || !this.height || this._constraining) return;\n                    this._constraining = true;\n                    let w4 = this._unmodified, { center: B4, zoom: Q } = this.getConstrained(this.center, this.zoom);\n                    this.center = B4, this.zoom = Q, this._unmodified = w4, this._constraining = false;\n                  }\n                  _calcMatrices() {\n                    if (!this.height) return;\n                    let w4 = this.centerOffset, B4 = this.point.x, Q = this.point.y;\n                    this.cameraToCenterDistance = 0.5 / Math.tan(this._fov / 2) * this.height, this._pixelPerMeter = a4.b5(1, this.center.lat) * this.worldSize;\n                    let ee = a4.an(new Float64Array(16));\n                    a4.K(ee, ee, [this.width / 2, -this.height / 2, 1]), a4.J(ee, ee, [1, -1, 0]), this.labelPlaneMatrix = ee, ee = a4.an(new Float64Array(16)), a4.K(ee, ee, [1, -1, 1]), a4.J(ee, ee, [-1, -1, 0]), a4.K(ee, ee, [2 / this.width, 2 / this.height, 1]), this.glCoordMatrix = ee;\n                    let le = this.cameraToCenterDistance + this._elevation * this._pixelPerMeter / Math.cos(this._pitch), qe = Math.min(this.elevation, this.minElevationForCurrentTile), Xe = le - qe * this._pixelPerMeter / Math.cos(this._pitch), ot = qe < 0 ? Xe : le, Tt = Math.PI / 2 + this._pitch, Yt = this._fov * (0.5 + w4.y / this.height), Kt = Math.sin(Yt) * ot / Math.sin(a4.ac(Math.PI - Tt - Yt, 0.01, Math.PI - 0.01)), xr = this.getHorizon(), Ir = 2 * Math.atan(xr / this.cameraToCenterDistance) * (0.5 + w4.y / (2 * xr)), ve = Math.sin(Ir) * ot / Math.sin(a4.ac(Math.PI - Tt - Ir, 0.01, Math.PI - 0.01)), be = Math.min(Kt, ve);\n                    this.farZ = 1.01 * (Math.cos(Math.PI / 2 - this._pitch) * be + ot), this.nearZ = this.height / 50, ee = new Float64Array(16), a4.b6(ee, this._fov, this.width / this.height, this.nearZ, this.farZ), ee[8] = 2 * -w4.x / this.width, ee[9] = 2 * w4.y / this.height, this.projectionMatrix = a4.ae(ee), a4.K(ee, ee, [1, -1, 1]), a4.J(ee, ee, [0, 0, -this.cameraToCenterDistance]), a4.b7(ee, ee, this._pitch), a4.ad(ee, ee, this.angle), a4.J(ee, ee, [-B4, -Q, 0]), this.mercatorMatrix = a4.K([], ee, [this.worldSize, this.worldSize, this.worldSize]), a4.K(ee, ee, [1, 1, this._pixelPerMeter]), this.pixelMatrix = a4.L(new Float64Array(16), this.labelPlaneMatrix, ee), a4.J(ee, ee, [0, 0, -this.elevation]), this.modelViewProjectionMatrix = ee, this.invModelViewProjectionMatrix = a4.as([], ee), this.fogMatrix = new Float64Array(16), a4.b6(this.fogMatrix, this._fov, this.width / this.height, le, this.farZ), this.fogMatrix[8] = 2 * -w4.x / this.width, this.fogMatrix[9] = 2 * w4.y / this.height, a4.K(this.fogMatrix, this.fogMatrix, [1, -1, 1]), a4.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.cameraToCenterDistance]), a4.b7(this.fogMatrix, this.fogMatrix, this._pitch), a4.ad(this.fogMatrix, this.fogMatrix, this.angle), a4.J(this.fogMatrix, this.fogMatrix, [-B4, -Q, 0]), a4.K(this.fogMatrix, this.fogMatrix, [1, 1, this._pixelPerMeter]), a4.J(this.fogMatrix, this.fogMatrix, [0, 0, -this.elevation]), this.pixelMatrix3D = a4.L(new Float64Array(16), this.labelPlaneMatrix, ee);\n                    let De = this.width % 2 / 2, Be = this.height % 2 / 2, et = Math.cos(this.angle), We = Math.sin(this.angle), it = B4 - Math.round(B4) + et * De + We * Be, Ft = Q - Math.round(Q) + et * Be + We * De, Ht = new Float64Array(ee);\n                    if (a4.J(Ht, Ht, [it > 0.5 ? it - 1 : it, Ft > 0.5 ? Ft - 1 : Ft, 0]), this.alignedModelViewProjectionMatrix = Ht, ee = a4.as(new Float64Array(16), this.pixelMatrix), !ee) throw new Error("failed to invert matrix");\n                    this.pixelMatrixInverse = ee, this._posMatrixCache = {}, this._alignedPosMatrixCache = {}, this._fogMatrixCache = {};\n                  }\n                  maxPitchScaleFactor() {\n                    if (!this.pixelMatrixInverse) return 1;\n                    let w4 = this.pointCoordinate(new a4.P(0, 0)), B4 = [w4.x * this.worldSize, w4.y * this.worldSize, 0, 1];\n                    return a4.af(B4, B4, this.pixelMatrix)[3] / this.cameraToCenterDistance;\n                  }\n                  getCameraPoint() {\n                    let w4 = Math.tan(this._pitch) * (this.cameraToCenterDistance || 1);\n                    return this.centerPoint.add(new a4.P(0, w4));\n                  }\n                  getCameraQueryGeometry(w4) {\n                    let B4 = this.getCameraPoint();\n                    if (w4.length === 1) return [w4[0], B4];\n                    {\n                      let Q = B4.x, ee = B4.y, le = B4.x, qe = B4.y;\n                      for (let Xe of w4) Q = Math.min(Q, Xe.x), ee = Math.min(ee, Xe.y), le = Math.max(le, Xe.x), qe = Math.max(qe, Xe.y);\n                      return [new a4.P(Q, ee), new a4.P(le, ee), new a4.P(le, qe), new a4.P(Q, qe), new a4.P(Q, ee)];\n                    }\n                  }\n                  lngLatToCameraDepth(w4, B4) {\n                    let Q = this.locationCoordinate(w4), ee = [Q.x * this.worldSize, Q.y * this.worldSize, B4, 1];\n                    return a4.af(ee, ee, this.modelViewProjectionMatrix), ee[2] / ee[3];\n                  }\n                }\n                function nh(ue, w4) {\n                  let B4, Q = false, ee = null, le = null, qe = () => {\n                    ee = null, Q && (ue.apply(le, B4), ee = setTimeout(qe, w4), Q = false);\n                  };\n                  return (...Xe) => (Q = true, le = this, B4 = Xe, ee || qe(), ee);\n                }\n                class Ah {\n                  constructor(w4) {\n                    this._getCurrentHash = () => {\n                      let B4 = window.location.hash.replace("#", "");\n                      if (this._hashName) {\n                        let Q;\n                        return B4.split("&").map((ee) => ee.split("=")).forEach((ee) => {\n                          ee[0] === this._hashName && (Q = ee);\n                        }), (Q && Q[1] || "").split("/");\n                      }\n                      return B4.split("/");\n                    }, this._onHashChange = () => {\n                      let B4 = this._getCurrentHash();\n                      if (B4.length >= 3 && !B4.some((Q) => isNaN(Q))) {\n                        let Q = this._map.dragRotate.isEnabled() && this._map.touchZoomRotate.isEnabled() ? +(B4[3] || 0) : this._map.getBearing();\n                        return this._map.jumpTo({ center: [+B4[2], +B4[1]], zoom: +B4[0], bearing: Q, pitch: +(B4[4] || 0) }), true;\n                      }\n                      return false;\n                    }, this._updateHashUnthrottled = () => {\n                      let B4 = window.location.href.replace(/(#.*)?$/, this.getHashString());\n                      window.history.replaceState(window.history.state, null, B4);\n                    }, this._removeHash = () => {\n                      let B4 = this._getCurrentHash();\n                      if (B4.length === 0) return;\n                      let Q = B4.join("/"), ee = Q;\n                      ee.split("&").length > 0 && (ee = ee.split("&")[0]), this._hashName && (ee = `${this._hashName}=${Q}`);\n                      let le = window.location.hash.replace(ee, "");\n                      le.startsWith("#&") ? le = le.slice(0, 1) + le.slice(2) : le === "#" && (le = "");\n                      let qe = window.location.href.replace(/(#.+)?$/, le);\n                      qe = qe.replace("&&", "&"), window.history.replaceState(window.history.state, null, qe);\n                    }, this._updateHash = nh(this._updateHashUnthrottled, 300), this._hashName = w4 && encodeURIComponent(w4);\n                  }\n                  addTo(w4) {\n                    return this._map = w4, addEventListener("hashchange", this._onHashChange, false), this._map.on("moveend", this._updateHash), this;\n                  }\n                  remove() {\n                    return removeEventListener("hashchange", this._onHashChange, false), this._map.off("moveend", this._updateHash), clearTimeout(this._updateHash()), this._removeHash(), delete this._map, this;\n                  }\n                  getHashString(w4) {\n                    let B4 = this._map.getCenter(), Q = Math.round(100 * this._map.getZoom()) / 100, ee = Math.ceil((Q * Math.LN2 + Math.log(512 / 360 / 0.5)) / Math.LN10), le = Math.pow(10, ee), qe = Math.round(B4.lng * le) / le, Xe = Math.round(B4.lat * le) / le, ot = this._map.getBearing(), Tt = this._map.getPitch(), Yt = "";\n                    if (Yt += w4 ? `/${qe}/${Xe}/${Q}` : `${Q}/${Xe}/${qe}`, (ot || Tt) && (Yt += "/" + Math.round(10 * ot) / 10), Tt && (Yt += `/${Math.round(Tt)}`), this._hashName) {\n                      let Kt = this._hashName, xr = false, Ir = window.location.hash.slice(1).split("&").map((ve) => {\n                        let be = ve.split("=")[0];\n                        return be === Kt ? (xr = true, `${be}=${Yt}`) : ve;\n                      }).filter((ve) => ve);\n                      return xr || Ir.push(`${Kt}=${Yt}`), `#${Ir.join("&")}`;\n                    }\n                    return `#${Yt}`;\n                  }\n                }\n                let zu = { linearity: 0.3, easing: a4.b8(0, 0, 0.3, 1) }, Fc = a4.e({ deceleration: 2500, maxSpeed: 1400 }, zu), wc = a4.e({ deceleration: 20, maxSpeed: 1400 }, zu), bd = a4.e({ deceleration: 1e3, maxSpeed: 360 }, zu), xf = a4.e({ deceleration: 1e3, maxSpeed: 90 }, zu);\n                class Pf {\n                  constructor(w4) {\n                    this._map = w4, this.clear();\n                  }\n                  clear() {\n                    this._inertiaBuffer = [];\n                  }\n                  record(w4) {\n                    this._drainInertiaBuffer(), this._inertiaBuffer.push({ time: u4.now(), settings: w4 });\n                  }\n                  _drainInertiaBuffer() {\n                    let w4 = this._inertiaBuffer, B4 = u4.now();\n                    for (; w4.length > 0 && B4 - w4[0].time > 160; ) w4.shift();\n                  }\n                  _onMoveEnd(w4) {\n                    if (this._drainInertiaBuffer(), this._inertiaBuffer.length < 2) return;\n                    let B4 = { zoom: 0, bearing: 0, pitch: 0, pan: new a4.P(0, 0), pinchAround: void 0, around: void 0 };\n                    for (let { settings: le } of this._inertiaBuffer) B4.zoom += le.zoomDelta || 0, B4.bearing += le.bearingDelta || 0, B4.pitch += le.pitchDelta || 0, le.panDelta && B4.pan._add(le.panDelta), le.around && (B4.around = le.around), le.pinchAround && (B4.pinchAround = le.pinchAround);\n                    let Q = this._inertiaBuffer[this._inertiaBuffer.length - 1].time - this._inertiaBuffer[0].time, ee = {};\n                    if (B4.pan.mag()) {\n                      let le = bf(B4.pan.mag(), Q, a4.e({}, Fc, w4 || {}));\n                      ee.offset = B4.pan.mult(le.amount / B4.pan.mag()), ee.center = this._map.transform.center, Ou(ee, le);\n                    }\n                    if (B4.zoom) {\n                      let le = bf(B4.zoom, Q, wc);\n                      ee.zoom = this._map.transform.zoom + le.amount, Ou(ee, le);\n                    }\n                    if (B4.bearing) {\n                      let le = bf(B4.bearing, Q, bd);\n                      ee.bearing = this._map.transform.bearing + a4.ac(le.amount, -179, 179), Ou(ee, le);\n                    }\n                    if (B4.pitch) {\n                      let le = bf(B4.pitch, Q, xf);\n                      ee.pitch = this._map.transform.pitch + le.amount, Ou(ee, le);\n                    }\n                    if (ee.zoom || ee.bearing) {\n                      let le = B4.pinchAround === void 0 ? B4.around : B4.pinchAround;\n                      ee.around = le ? this._map.unproject(le) : this._map.getCenter();\n                    }\n                    return this.clear(), a4.e(ee, { noMoveStart: true });\n                  }\n                }\n                function Ou(ue, w4) {\n                  (!ue.duration || ue.duration < w4.duration) && (ue.duration = w4.duration, ue.easing = w4.easing);\n                }\n                function bf(ue, w4, B4) {\n                  let { maxSpeed: Q, linearity: ee, deceleration: le } = B4, qe = a4.ac(ue * ee / (w4 / 1e3), -Q, Q), Xe = Math.abs(qe) / (le * ee);\n                  return { easing: B4.easing, duration: 1e3 * Xe, amount: qe * (Xe / 2) };\n                }\n                class jl extends a4.k {\n                  preventDefault() {\n                    this._defaultPrevented = true;\n                  }\n                  get defaultPrevented() {\n                    return this._defaultPrevented;\n                  }\n                  constructor(w4, B4, Q, ee = {}) {\n                    let le = c5.mousePos(B4.getCanvas(), Q), qe = B4.unproject(le);\n                    super(w4, a4.e({ point: le, lngLat: qe, originalEvent: Q }, ee)), this._defaultPrevented = false, this.target = B4;\n                  }\n                }\n                class lf extends a4.k {\n                  preventDefault() {\n                    this._defaultPrevented = true;\n                  }\n                  get defaultPrevented() {\n                    return this._defaultPrevented;\n                  }\n                  constructor(w4, B4, Q) {\n                    let ee = w4 === "touchend" ? Q.changedTouches : Q.touches, le = c5.touchPos(B4.getCanvasContainer(), ee), qe = le.map((ot) => B4.unproject(ot)), Xe = le.reduce((ot, Tt, Yt, Kt) => ot.add(Tt.div(Kt.length)), new a4.P(0, 0));\n                    super(w4, { points: le, point: Xe, lngLats: qe, lngLat: B4.unproject(Xe), originalEvent: Q }), this._defaultPrevented = false;\n                  }\n                }\n                class Hh extends a4.k {\n                  preventDefault() {\n                    this._defaultPrevented = true;\n                  }\n                  get defaultPrevented() {\n                    return this._defaultPrevented;\n                  }\n                  constructor(w4, B4, Q) {\n                    super(w4, { originalEvent: Q }), this._defaultPrevented = false;\n                  }\n                }\n                class If {\n                  constructor(w4, B4) {\n                    this._map = w4, this._clickTolerance = B4.clickTolerance;\n                  }\n                  reset() {\n                    delete this._mousedownPos;\n                  }\n                  wheel(w4) {\n                    return this._firePreventable(new Hh(w4.type, this._map, w4));\n                  }\n                  mousedown(w4, B4) {\n                    return this._mousedownPos = B4, this._firePreventable(new jl(w4.type, this._map, w4));\n                  }\n                  mouseup(w4) {\n                    this._map.fire(new jl(w4.type, this._map, w4));\n                  }\n                  click(w4, B4) {\n                    this._mousedownPos && this._mousedownPos.dist(B4) >= this._clickTolerance || this._map.fire(new jl(w4.type, this._map, w4));\n                  }\n                  dblclick(w4) {\n                    return this._firePreventable(new jl(w4.type, this._map, w4));\n                  }\n                  mouseover(w4) {\n                    this._map.fire(new jl(w4.type, this._map, w4));\n                  }\n                  mouseout(w4) {\n                    this._map.fire(new jl(w4.type, this._map, w4));\n                  }\n                  touchstart(w4) {\n                    return this._firePreventable(new lf(w4.type, this._map, w4));\n                  }\n                  touchmove(w4) {\n                    this._map.fire(new lf(w4.type, this._map, w4));\n                  }\n                  touchend(w4) {\n                    this._map.fire(new lf(w4.type, this._map, w4));\n                  }\n                  touchcancel(w4) {\n                    this._map.fire(new lf(w4.type, this._map, w4));\n                  }\n                  _firePreventable(w4) {\n                    if (this._map.fire(w4), w4.defaultPrevented) return {};\n                  }\n                  isEnabled() {\n                    return true;\n                  }\n                  isActive() {\n                    return false;\n                  }\n                  enable() {\n                  }\n                  disable() {\n                  }\n                }\n                class Cs {\n                  constructor(w4) {\n                    this._map = w4;\n                  }\n                  reset() {\n                    this._delayContextMenu = false, this._ignoreContextMenu = true, delete this._contextMenuEvent;\n                  }\n                  mousemove(w4) {\n                    this._map.fire(new jl(w4.type, this._map, w4));\n                  }\n                  mousedown() {\n                    this._delayContextMenu = true, this._ignoreContextMenu = false;\n                  }\n                  mouseup() {\n                    this._delayContextMenu = false, this._contextMenuEvent && (this._map.fire(new jl("contextmenu", this._map, this._contextMenuEvent)), delete this._contextMenuEvent);\n                  }\n                  contextmenu(w4) {\n                    this._delayContextMenu ? this._contextMenuEvent = w4 : this._ignoreContextMenu || this._map.fire(new jl(w4.type, this._map, w4)), this._map.listens("contextmenu") && w4.preventDefault();\n                  }\n                  isEnabled() {\n                    return true;\n                  }\n                  isActive() {\n                    return false;\n                  }\n                  enable() {\n                  }\n                  disable() {\n                  }\n                }\n                class du {\n                  constructor(w4) {\n                    this._map = w4;\n                  }\n                  get transform() {\n                    return this._map._requestedCameraState || this._map.transform;\n                  }\n                  get center() {\n                    return { lng: this.transform.center.lng, lat: this.transform.center.lat };\n                  }\n                  get zoom() {\n                    return this.transform.zoom;\n                  }\n                  get pitch() {\n                    return this.transform.pitch;\n                  }\n                  get bearing() {\n                    return this.transform.bearing;\n                  }\n                  unproject(w4) {\n                    return this.transform.pointLocation(a4.P.convert(w4), this._map.terrain);\n                  }\n                }\n                class ku {\n                  constructor(w4, B4) {\n                    this._map = w4, this._tr = new du(w4), this._el = w4.getCanvasContainer(), this._container = w4.getContainer(), this._clickTolerance = B4.clickTolerance || 1;\n                  }\n                  isEnabled() {\n                    return !!this._enabled;\n                  }\n                  isActive() {\n                    return !!this._active;\n                  }\n                  enable() {\n                    this.isEnabled() || (this._enabled = true);\n                  }\n                  disable() {\n                    this.isEnabled() && (this._enabled = false);\n                  }\n                  mousedown(w4, B4) {\n                    this.isEnabled() && w4.shiftKey && w4.button === 0 && (c5.disableDrag(), this._startPos = this._lastPos = B4, this._active = true);\n                  }\n                  mousemoveWindow(w4, B4) {\n                    if (!this._active) return;\n                    let Q = B4;\n                    if (this._lastPos.equals(Q) || !this._box && Q.dist(this._startPos) < this._clickTolerance) return;\n                    let ee = this._startPos;\n                    this._lastPos = Q, this._box || (this._box = c5.create("div", "maplibregl-boxzoom", this._container), this._container.classList.add("maplibregl-crosshair"), this._fireEvent("boxzoomstart", w4));\n                    let le = Math.min(ee.x, Q.x), qe = Math.max(ee.x, Q.x), Xe = Math.min(ee.y, Q.y), ot = Math.max(ee.y, Q.y);\n                    c5.setTransform(this._box, `translate(${le}px,${Xe}px)`), this._box.style.width = qe - le + "px", this._box.style.height = ot - Xe + "px";\n                  }\n                  mouseupWindow(w4, B4) {\n                    if (!this._active || w4.button !== 0) return;\n                    let Q = this._startPos, ee = B4;\n                    if (this.reset(), c5.suppressClick(), Q.x !== ee.x || Q.y !== ee.y) return this._map.fire(new a4.k("boxzoomend", { originalEvent: w4 })), { cameraAnimation: (le) => le.fitScreenCoordinates(Q, ee, this._tr.bearing, { linear: true }) };\n                    this._fireEvent("boxzoomcancel", w4);\n                  }\n                  keydown(w4) {\n                    this._active && w4.keyCode === 27 && (this.reset(), this._fireEvent("boxzoomcancel", w4));\n                  }\n                  reset() {\n                    this._active = false, this._container.classList.remove("maplibregl-crosshair"), this._box && (c5.remove(this._box), this._box = null), c5.enableDrag(), delete this._startPos, delete this._lastPos;\n                  }\n                  _fireEvent(w4, B4) {\n                    return this._map.fire(new a4.k(w4, { originalEvent: B4 }));\n                  }\n                }\n                function Wf(ue, w4) {\n                  if (ue.length !== w4.length) throw new Error(`The number of touches and points are not equal - touches ${ue.length}, points ${w4.length}`);\n                  let B4 = {};\n                  for (let Q = 0; Q < ue.length; Q++) B4[ue[Q].identifier] = w4[Q];\n                  return B4;\n                }\n                class Us {\n                  constructor(w4) {\n                    this.reset(), this.numTouches = w4.numTouches;\n                  }\n                  reset() {\n                    delete this.centroid, delete this.startTime, delete this.touches, this.aborted = false;\n                  }\n                  touchstart(w4, B4, Q) {\n                    (this.centroid || Q.length > this.numTouches) && (this.aborted = true), this.aborted || (this.startTime === void 0 && (this.startTime = w4.timeStamp), Q.length === this.numTouches && (this.centroid = (function(ee) {\n                      let le = new a4.P(0, 0);\n                      for (let qe of ee) le._add(qe);\n                      return le.div(ee.length);\n                    })(B4), this.touches = Wf(Q, B4)));\n                  }\n                  touchmove(w4, B4, Q) {\n                    if (this.aborted || !this.centroid) return;\n                    let ee = Wf(Q, B4);\n                    for (let le in this.touches) {\n                      let qe = ee[le];\n                      (!qe || qe.dist(this.touches[le]) > 30) && (this.aborted = true);\n                    }\n                  }\n                  touchend(w4, B4, Q) {\n                    if ((!this.centroid || w4.timeStamp - this.startTime > 500) && (this.aborted = true), Q.length === 0) {\n                      let ee = !this.aborted && this.centroid;\n                      if (this.reset(), ee) return ee;\n                    }\n                  }\n                }\n                class wf {\n                  constructor(w4) {\n                    this.singleTap = new Us(w4), this.numTaps = w4.numTaps, this.reset();\n                  }\n                  reset() {\n                    this.lastTime = 1 / 0, delete this.lastTap, this.count = 0, this.singleTap.reset();\n                  }\n                  touchstart(w4, B4, Q) {\n                    this.singleTap.touchstart(w4, B4, Q);\n                  }\n                  touchmove(w4, B4, Q) {\n                    this.singleTap.touchmove(w4, B4, Q);\n                  }\n                  touchend(w4, B4, Q) {\n                    let ee = this.singleTap.touchend(w4, B4, Q);\n                    if (ee) {\n                      let le = w4.timeStamp - this.lastTime < 500, qe = !this.lastTap || this.lastTap.dist(ee) < 30;\n                      if (le && qe || this.reset(), this.count++, this.lastTime = w4.timeStamp, this.lastTap = ee, this.count === this.numTaps) return this.reset(), ee;\n                    }\n                  }\n                }\n                class zc {\n                  constructor(w4) {\n                    this._tr = new du(w4), this._zoomIn = new wf({ numTouches: 1, numTaps: 2 }), this._zoomOut = new wf({ numTouches: 2, numTaps: 1 }), this.reset();\n                  }\n                  reset() {\n                    this._active = false, this._zoomIn.reset(), this._zoomOut.reset();\n                  }\n                  touchstart(w4, B4, Q) {\n                    this._zoomIn.touchstart(w4, B4, Q), this._zoomOut.touchstart(w4, B4, Q);\n                  }\n                  touchmove(w4, B4, Q) {\n                    this._zoomIn.touchmove(w4, B4, Q), this._zoomOut.touchmove(w4, B4, Q);\n                  }\n                  touchend(w4, B4, Q) {\n                    let ee = this._zoomIn.touchend(w4, B4, Q), le = this._zoomOut.touchend(w4, B4, Q), qe = this._tr;\n                    return ee ? (this._active = true, w4.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (Xe) => Xe.easeTo({ duration: 300, zoom: qe.zoom + 1, around: qe.unproject(ee) }, { originalEvent: w4 }) }) : le ? (this._active = true, w4.preventDefault(), setTimeout(() => this.reset(), 0), { cameraAnimation: (Xe) => Xe.easeTo({ duration: 300, zoom: qe.zoom - 1, around: qe.unproject(le) }, { originalEvent: w4 }) }) : void 0;\n                  }\n                  touchcancel() {\n                    this.reset();\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                }\n                class Wu {\n                  constructor(w4) {\n                    this._enabled = !!w4.enable, this._moveStateManager = w4.moveStateManager, this._clickTolerance = w4.clickTolerance || 1, this._moveFunction = w4.move, this._activateOnStart = !!w4.activateOnStart, w4.assignEvents(this), this.reset();\n                  }\n                  reset(w4) {\n                    this._active = false, this._moved = false, delete this._lastPoint, this._moveStateManager.endMove(w4);\n                  }\n                  _move(...w4) {\n                    let B4 = this._moveFunction(...w4);\n                    if (B4.bearingDelta || B4.pitchDelta || B4.around || B4.panDelta) return this._active = true, B4;\n                  }\n                  dragStart(w4, B4) {\n                    this.isEnabled() && !this._lastPoint && this._moveStateManager.isValidStartEvent(w4) && (this._moveStateManager.startMove(w4), this._lastPoint = B4.length ? B4[0] : B4, this._activateOnStart && this._lastPoint && (this._active = true));\n                  }\n                  dragMove(w4, B4) {\n                    if (!this.isEnabled()) return;\n                    let Q = this._lastPoint;\n                    if (!Q) return;\n                    if (w4.preventDefault(), !this._moveStateManager.isValidMoveEvent(w4)) return void this.reset(w4);\n                    let ee = B4.length ? B4[0] : B4;\n                    return !this._moved && ee.dist(Q) < this._clickTolerance ? void 0 : (this._moved = true, this._lastPoint = ee, this._move(Q, ee));\n                  }\n                  dragEnd(w4) {\n                    this.isEnabled() && this._lastPoint && this._moveStateManager.isValidEndEvent(w4) && (this._moved && c5.suppressClick(), this.reset(w4));\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                  getClickTolerance() {\n                    return this._clickTolerance;\n                  }\n                }\n                let Rf = { 0: 1, 2: 2 };\n                class Xu {\n                  constructor(w4) {\n                    this._correctEvent = w4.checkCorrectEvent;\n                  }\n                  startMove(w4) {\n                    let B4 = c5.mouseButton(w4);\n                    this._eventButton = B4;\n                  }\n                  endMove(w4) {\n                    delete this._eventButton;\n                  }\n                  isValidStartEvent(w4) {\n                    return this._correctEvent(w4);\n                  }\n                  isValidMoveEvent(w4) {\n                    return !(function(B4, Q) {\n                      let ee = Rf[Q];\n                      return B4.buttons === void 0 || (B4.buttons & ee) !== ee;\n                    })(w4, this._eventButton);\n                  }\n                  isValidEndEvent(w4) {\n                    return c5.mouseButton(w4) === this._eventButton;\n                  }\n                }\n                class uf {\n                  constructor() {\n                    this._firstTouch = void 0;\n                  }\n                  _isOneFingerTouch(w4) {\n                    return w4.targetTouches.length === 1;\n                  }\n                  _isSameTouchEvent(w4) {\n                    return w4.targetTouches[0].identifier === this._firstTouch;\n                  }\n                  startMove(w4) {\n                    this._firstTouch = w4.targetTouches[0].identifier;\n                  }\n                  endMove(w4) {\n                    delete this._firstTouch;\n                  }\n                  isValidStartEvent(w4) {\n                    return this._isOneFingerTouch(w4);\n                  }\n                  isValidMoveEvent(w4) {\n                    return this._isOneFingerTouch(w4) && this._isSameTouchEvent(w4);\n                  }\n                  isValidEndEvent(w4) {\n                    return this._isOneFingerTouch(w4) && this._isSameTouchEvent(w4);\n                  }\n                }\n                let Xf = (ue) => {\n                  ue.mousedown = ue.dragStart, ue.mousemoveWindow = ue.dragMove, ue.mouseup = ue.dragEnd, ue.contextmenu = (w4) => {\n                    w4.preventDefault();\n                  };\n                }, Wl = ({ enable: ue, clickTolerance: w4, bearingDegreesPerPixelMoved: B4 = 0.8 }) => {\n                  let Q = new Xu({ checkCorrectEvent: (ee) => c5.mouseButton(ee) === 0 && ee.ctrlKey || c5.mouseButton(ee) === 2 });\n                  return new Wu({ clickTolerance: w4, move: (ee, le) => ({ bearingDelta: (le.x - ee.x) * B4 }), moveStateManager: Q, enable: ue, assignEvents: Xf });\n                }, ah = ({ enable: ue, clickTolerance: w4, pitchDegreesPerPixelMoved: B4 = -0.5 }) => {\n                  let Q = new Xu({ checkCorrectEvent: (ee) => c5.mouseButton(ee) === 0 && ee.ctrlKey || c5.mouseButton(ee) === 2 });\n                  return new Wu({ clickTolerance: w4, move: (ee, le) => ({ pitchDelta: (le.y - ee.y) * B4 }), moveStateManager: Q, enable: ue, assignEvents: Xf });\n                };\n                class Zu {\n                  constructor(w4, B4) {\n                    this._clickTolerance = w4.clickTolerance || 1, this._map = B4, this.reset();\n                  }\n                  reset() {\n                    this._active = false, this._touches = {}, this._sum = new a4.P(0, 0);\n                  }\n                  _shouldBePrevented(w4) {\n                    return w4 < (this._map.cooperativeGestures.isEnabled() ? 2 : 1);\n                  }\n                  touchstart(w4, B4, Q) {\n                    return this._calculateTransform(w4, B4, Q);\n                  }\n                  touchmove(w4, B4, Q) {\n                    if (this._active) {\n                      if (!this._shouldBePrevented(Q.length)) return w4.preventDefault(), this._calculateTransform(w4, B4, Q);\n                      this._map.cooperativeGestures.notifyGestureBlocked("touch_pan", w4);\n                    }\n                  }\n                  touchend(w4, B4, Q) {\n                    this._calculateTransform(w4, B4, Q), this._active && this._shouldBePrevented(Q.length) && this.reset();\n                  }\n                  touchcancel() {\n                    this.reset();\n                  }\n                  _calculateTransform(w4, B4, Q) {\n                    Q.length > 0 && (this._active = true);\n                    let ee = Wf(Q, B4), le = new a4.P(0, 0), qe = new a4.P(0, 0), Xe = 0;\n                    for (let Tt in ee) {\n                      let Yt = ee[Tt], Kt = this._touches[Tt];\n                      Kt && (le._add(Yt), qe._add(Yt.sub(Kt)), Xe++, ee[Tt] = Yt);\n                    }\n                    if (this._touches = ee, this._shouldBePrevented(Xe) || !qe.mag()) return;\n                    let ot = qe.div(Xe);\n                    return this._sum._add(ot), this._sum.mag() < this._clickTolerance ? void 0 : { around: le.div(Xe), panDelta: ot };\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                }\n                class Oc {\n                  constructor() {\n                    this.reset();\n                  }\n                  reset() {\n                    this._active = false, delete this._firstTwoTouches;\n                  }\n                  touchstart(w4, B4, Q) {\n                    this._firstTwoTouches || Q.length < 2 || (this._firstTwoTouches = [Q[0].identifier, Q[1].identifier], this._start([B4[0], B4[1]]));\n                  }\n                  touchmove(w4, B4, Q) {\n                    if (!this._firstTwoTouches) return;\n                    w4.preventDefault();\n                    let [ee, le] = this._firstTwoTouches, qe = Tc(Q, B4, ee), Xe = Tc(Q, B4, le);\n                    if (!qe || !Xe) return;\n                    let ot = this._aroundCenter ? null : qe.add(Xe).div(2);\n                    return this._move([qe, Xe], ot, w4);\n                  }\n                  touchend(w4, B4, Q) {\n                    if (!this._firstTwoTouches) return;\n                    let [ee, le] = this._firstTwoTouches, qe = Tc(Q, B4, ee), Xe = Tc(Q, B4, le);\n                    qe && Xe || (this._active && c5.suppressClick(), this.reset());\n                  }\n                  touchcancel() {\n                    this.reset();\n                  }\n                  enable(w4) {\n                    this._enabled = true, this._aroundCenter = !!w4 && w4.around === "center";\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return !!this._enabled;\n                  }\n                  isActive() {\n                    return !!this._active;\n                  }\n                }\n                function Tc(ue, w4, B4) {\n                  for (let Q = 0; Q < ue.length; Q++) if (ue[Q].identifier === B4) return w4[Q];\n                }\n                function wl(ue, w4) {\n                  return Math.log(ue / w4) / Math.LN2;\n                }\n                class vu extends Oc {\n                  reset() {\n                    super.reset(), delete this._distance, delete this._startDistance;\n                  }\n                  _start(w4) {\n                    this._startDistance = this._distance = w4[0].dist(w4[1]);\n                  }\n                  _move(w4, B4) {\n                    let Q = this._distance;\n                    if (this._distance = w4[0].dist(w4[1]), this._active || !(Math.abs(wl(this._distance, this._startDistance)) < 0.1)) return this._active = true, { zoomDelta: wl(this._distance, Q), pinchAround: B4 };\n                  }\n                }\n                function qc(ue, w4) {\n                  return 180 * ue.angleWith(w4) / Math.PI;\n                }\n                class cf extends Oc {\n                  reset() {\n                    super.reset(), delete this._minDiameter, delete this._startVector, delete this._vector;\n                  }\n                  _start(w4) {\n                    this._startVector = this._vector = w4[0].sub(w4[1]), this._minDiameter = w4[0].dist(w4[1]);\n                  }\n                  _move(w4, B4, Q) {\n                    let ee = this._vector;\n                    if (this._vector = w4[0].sub(w4[1]), this._active || !this._isBelowThreshold(this._vector)) return this._active = true, { bearingDelta: qc(this._vector, ee), pinchAround: B4 };\n                  }\n                  _isBelowThreshold(w4) {\n                    this._minDiameter = Math.min(this._minDiameter, w4.mag());\n                    let B4 = 25 / (Math.PI * this._minDiameter) * 360, Q = qc(w4, this._startVector);\n                    return Math.abs(Q) < B4;\n                  }\n                }\n                function fc(ue) {\n                  return Math.abs(ue.y) > Math.abs(ue.x);\n                }\n                class Bc extends Oc {\n                  constructor(w4) {\n                    super(), this._currentTouchCount = 0, this._map = w4;\n                  }\n                  reset() {\n                    super.reset(), this._valid = void 0, delete this._firstMove, delete this._lastPoints;\n                  }\n                  touchstart(w4, B4, Q) {\n                    super.touchstart(w4, B4, Q), this._currentTouchCount = Q.length;\n                  }\n                  _start(w4) {\n                    this._lastPoints = w4, fc(w4[0].sub(w4[1])) && (this._valid = false);\n                  }\n                  _move(w4, B4, Q) {\n                    if (this._map.cooperativeGestures.isEnabled() && this._currentTouchCount < 3) return;\n                    let ee = w4[0].sub(this._lastPoints[0]), le = w4[1].sub(this._lastPoints[1]);\n                    return this._valid = this.gestureBeginsVertically(ee, le, Q.timeStamp), this._valid ? (this._lastPoints = w4, this._active = true, { pitchDelta: (ee.y + le.y) / 2 * -0.5 }) : void 0;\n                  }\n                  gestureBeginsVertically(w4, B4, Q) {\n                    if (this._valid !== void 0) return this._valid;\n                    let ee = w4.mag() >= 2, le = B4.mag() >= 2;\n                    if (!ee && !le) return;\n                    if (!ee || !le) return this._firstMove === void 0 && (this._firstMove = Q), Q - this._firstMove < 100 && void 0;\n                    let qe = w4.y > 0 == B4.y > 0;\n                    return fc(w4) && fc(B4) && qe;\n                  }\n                }\n                let At = { panStep: 100, bearingStep: 15, pitchStep: 10 };\n                class Wt {\n                  constructor(w4) {\n                    this._tr = new du(w4);\n                    let B4 = At;\n                    this._panStep = B4.panStep, this._bearingStep = B4.bearingStep, this._pitchStep = B4.pitchStep, this._rotationDisabled = false;\n                  }\n                  reset() {\n                    this._active = false;\n                  }\n                  keydown(w4) {\n                    if (w4.altKey || w4.ctrlKey || w4.metaKey) return;\n                    let B4 = 0, Q = 0, ee = 0, le = 0, qe = 0;\n                    switch (w4.keyCode) {\n                      case 61:\n                      case 107:\n                      case 171:\n                      case 187:\n                        B4 = 1;\n                        break;\n                      case 189:\n                      case 109:\n                      case 173:\n                        B4 = -1;\n                        break;\n                      case 37:\n                        w4.shiftKey ? Q = -1 : (w4.preventDefault(), le = -1);\n                        break;\n                      case 39:\n                        w4.shiftKey ? Q = 1 : (w4.preventDefault(), le = 1);\n                        break;\n                      case 38:\n                        w4.shiftKey ? ee = 1 : (w4.preventDefault(), qe = -1);\n                        break;\n                      case 40:\n                        w4.shiftKey ? ee = -1 : (w4.preventDefault(), qe = 1);\n                        break;\n                      default:\n                        return;\n                    }\n                    return this._rotationDisabled && (Q = 0, ee = 0), { cameraAnimation: (Xe) => {\n                      let ot = this._tr;\n                      Xe.easeTo({ duration: 300, easeId: "keyboardHandler", easing: Cr, zoom: B4 ? Math.round(ot.zoom) + B4 * (w4.shiftKey ? 2 : 1) : ot.zoom, bearing: ot.bearing + Q * this._bearingStep, pitch: ot.pitch + ee * this._pitchStep, offset: [-le * this._panStep, -qe * this._panStep], center: ot.center }, { originalEvent: w4 });\n                    } };\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                  disableRotation() {\n                    this._rotationDisabled = true;\n                  }\n                  enableRotation() {\n                    this._rotationDisabled = false;\n                  }\n                }\n                function Cr(ue) {\n                  return ue * (2 - ue);\n                }\n                let Ar = 4.000244140625;\n                class Kr {\n                  constructor(w4, B4) {\n                    this._onTimeout = (Q) => {\n                      this._type = "wheel", this._delta -= this._lastValue, this._active || this._start(Q);\n                    }, this._map = w4, this._tr = new du(w4), this._triggerRenderFrame = B4, this._delta = 0, this._defaultZoomRate = 0.01, this._wheelZoomRate = 0.0022222222222222222;\n                  }\n                  setZoomRate(w4) {\n                    this._defaultZoomRate = w4;\n                  }\n                  setWheelZoomRate(w4) {\n                    this._wheelZoomRate = w4;\n                  }\n                  isEnabled() {\n                    return !!this._enabled;\n                  }\n                  isActive() {\n                    return !!this._active || this._finishTimeout !== void 0;\n                  }\n                  isZooming() {\n                    return !!this._zooming;\n                  }\n                  enable(w4) {\n                    this.isEnabled() || (this._enabled = true, this._aroundCenter = !!w4 && w4.around === "center");\n                  }\n                  disable() {\n                    this.isEnabled() && (this._enabled = false);\n                  }\n                  _shouldBePrevented(w4) {\n                    return !!this._map.cooperativeGestures.isEnabled() && !(w4.ctrlKey || this._map.cooperativeGestures.isBypassed(w4));\n                  }\n                  wheel(w4) {\n                    if (!this.isEnabled()) return;\n                    if (this._shouldBePrevented(w4)) return void this._map.cooperativeGestures.notifyGestureBlocked("wheel_zoom", w4);\n                    let B4 = w4.deltaMode === WheelEvent.DOM_DELTA_LINE ? 40 * w4.deltaY : w4.deltaY, Q = u4.now(), ee = Q - (this._lastWheelEventTime || 0);\n                    this._lastWheelEventTime = Q, B4 !== 0 && B4 % Ar == 0 ? this._type = "wheel" : B4 !== 0 && Math.abs(B4) < 4 ? this._type = "trackpad" : ee > 400 ? (this._type = null, this._lastValue = B4, this._timeout = setTimeout(this._onTimeout, 40, w4)) : this._type || (this._type = Math.abs(ee * B4) < 200 ? "trackpad" : "wheel", this._timeout && (clearTimeout(this._timeout), this._timeout = null, B4 += this._lastValue)), w4.shiftKey && B4 && (B4 /= 4), this._type && (this._lastWheelEvent = w4, this._delta -= B4, this._active || this._start(w4)), w4.preventDefault();\n                  }\n                  _start(w4) {\n                    if (!this._delta) return;\n                    this._frameId && (this._frameId = null), this._active = true, this.isZooming() || (this._zooming = true), this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);\n                    let B4 = c5.mousePos(this._map.getCanvas(), w4), Q = this._tr;\n                    this._around = B4.y > Q.transform.height / 2 - Q.transform.getHorizon() ? a4.N.convert(this._aroundCenter ? Q.center : Q.unproject(B4)) : a4.N.convert(Q.center), this._aroundPoint = Q.transform.locationPoint(this._around), this._frameId || (this._frameId = true, this._triggerRenderFrame());\n                  }\n                  renderFrame() {\n                    if (!this._frameId || (this._frameId = null, !this.isActive())) return;\n                    let w4 = this._tr.transform;\n                    if (this._delta !== 0) {\n                      let ot = this._type === "wheel" && Math.abs(this._delta) > Ar ? this._wheelZoomRate : this._defaultZoomRate, Tt = 2 / (1 + Math.exp(-Math.abs(this._delta * ot)));\n                      this._delta < 0 && Tt !== 0 && (Tt = 1 / Tt);\n                      let Yt = typeof this._targetZoom == "number" ? w4.zoomScale(this._targetZoom) : w4.scale;\n                      this._targetZoom = Math.min(w4.maxZoom, Math.max(w4.minZoom, w4.scaleZoom(Yt * Tt))), this._type === "wheel" && (this._startZoom = w4.zoom, this._easing = this._smoothOutEasing(200)), this._delta = 0;\n                    }\n                    let B4 = typeof this._targetZoom == "number" ? this._targetZoom : w4.zoom, Q = this._startZoom, ee = this._easing, le, qe = false, Xe = u4.now() - this._lastWheelEventTime;\n                    if (this._type === "wheel" && Q && ee && Xe) {\n                      let ot = Math.min(Xe / 200, 1), Tt = ee(ot);\n                      le = a4.y.number(Q, B4, Tt), ot < 1 ? this._frameId || (this._frameId = true) : qe = true;\n                    } else le = B4, qe = true;\n                    return this._active = true, qe && (this._active = false, this._finishTimeout = setTimeout(() => {\n                      this._zooming = false, this._triggerRenderFrame(), delete this._targetZoom, delete this._finishTimeout;\n                    }, 200)), { noInertia: true, needsRenderFrame: !qe, zoomDelta: le - w4.zoom, around: this._aroundPoint, originalEvent: this._lastWheelEvent };\n                  }\n                  _smoothOutEasing(w4) {\n                    let B4 = a4.b9;\n                    if (this._prevEase) {\n                      let Q = this._prevEase, ee = (u4.now() - Q.start) / Q.duration, le = Q.easing(ee + 0.01) - Q.easing(ee), qe = 0.27 / Math.sqrt(le * le + 1e-4) * 0.01, Xe = Math.sqrt(0.0729 - qe * qe);\n                      B4 = a4.b8(qe, Xe, 0.25, 1);\n                    }\n                    return this._prevEase = { start: u4.now(), duration: w4, easing: B4 }, B4;\n                  }\n                  reset() {\n                    this._active = false, this._zooming = false, delete this._targetZoom, this._finishTimeout && (clearTimeout(this._finishTimeout), delete this._finishTimeout);\n                  }\n                }\n                class ki {\n                  constructor(w4, B4) {\n                    this._clickZoom = w4, this._tapZoom = B4;\n                  }\n                  enable() {\n                    this._clickZoom.enable(), this._tapZoom.enable();\n                  }\n                  disable() {\n                    this._clickZoom.disable(), this._tapZoom.disable();\n                  }\n                  isEnabled() {\n                    return this._clickZoom.isEnabled() && this._tapZoom.isEnabled();\n                  }\n                  isActive() {\n                    return this._clickZoom.isActive() || this._tapZoom.isActive();\n                  }\n                }\n                class Xi {\n                  constructor(w4) {\n                    this._tr = new du(w4), this.reset();\n                  }\n                  reset() {\n                    this._active = false;\n                  }\n                  dblclick(w4, B4) {\n                    return w4.preventDefault(), { cameraAnimation: (Q) => {\n                      Q.easeTo({ duration: 300, zoom: this._tr.zoom + (w4.shiftKey ? -1 : 1), around: this._tr.unproject(B4) }, { originalEvent: w4 });\n                    } };\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                }\n                class dn {\n                  constructor() {\n                    this._tap = new wf({ numTouches: 1, numTaps: 1 }), this.reset();\n                  }\n                  reset() {\n                    this._active = false, delete this._swipePoint, delete this._swipeTouch, delete this._tapTime, delete this._tapPoint, this._tap.reset();\n                  }\n                  touchstart(w4, B4, Q) {\n                    if (!this._swipePoint) if (this._tapTime) {\n                      let ee = B4[0], le = w4.timeStamp - this._tapTime < 500, qe = this._tapPoint.dist(ee) < 30;\n                      le && qe ? Q.length > 0 && (this._swipePoint = ee, this._swipeTouch = Q[0].identifier) : this.reset();\n                    } else this._tap.touchstart(w4, B4, Q);\n                  }\n                  touchmove(w4, B4, Q) {\n                    if (this._tapTime) {\n                      if (this._swipePoint) {\n                        if (Q[0].identifier !== this._swipeTouch) return;\n                        let ee = B4[0], le = ee.y - this._swipePoint.y;\n                        return this._swipePoint = ee, w4.preventDefault(), this._active = true, { zoomDelta: le / 128 };\n                      }\n                    } else this._tap.touchmove(w4, B4, Q);\n                  }\n                  touchend(w4, B4, Q) {\n                    if (this._tapTime) this._swipePoint && Q.length === 0 && this.reset();\n                    else {\n                      let ee = this._tap.touchend(w4, B4, Q);\n                      ee && (this._tapTime = w4.timeStamp, this._tapPoint = ee);\n                    }\n                  }\n                  touchcancel() {\n                    this.reset();\n                  }\n                  enable() {\n                    this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this.reset();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isActive() {\n                    return this._active;\n                  }\n                }\n                class wn {\n                  constructor(w4, B4, Q) {\n                    this._el = w4, this._mousePan = B4, this._touchPan = Q;\n                  }\n                  enable(w4) {\n                    this._inertiaOptions = w4 || {}, this._mousePan.enable(), this._touchPan.enable(), this._el.classList.add("maplibregl-touch-drag-pan");\n                  }\n                  disable() {\n                    this._mousePan.disable(), this._touchPan.disable(), this._el.classList.remove("maplibregl-touch-drag-pan");\n                  }\n                  isEnabled() {\n                    return this._mousePan.isEnabled() && this._touchPan.isEnabled();\n                  }\n                  isActive() {\n                    return this._mousePan.isActive() || this._touchPan.isActive();\n                  }\n                }\n                class Nn {\n                  constructor(w4, B4, Q) {\n                    this._pitchWithRotate = w4.pitchWithRotate, this._mouseRotate = B4, this._mousePitch = Q;\n                  }\n                  enable() {\n                    this._mouseRotate.enable(), this._pitchWithRotate && this._mousePitch.enable();\n                  }\n                  disable() {\n                    this._mouseRotate.disable(), this._mousePitch.disable();\n                  }\n                  isEnabled() {\n                    return this._mouseRotate.isEnabled() && (!this._pitchWithRotate || this._mousePitch.isEnabled());\n                  }\n                  isActive() {\n                    return this._mouseRotate.isActive() || this._mousePitch.isActive();\n                  }\n                }\n                class Yi {\n                  constructor(w4, B4, Q, ee) {\n                    this._el = w4, this._touchZoom = B4, this._touchRotate = Q, this._tapDragZoom = ee, this._rotationDisabled = false, this._enabled = true;\n                  }\n                  enable(w4) {\n                    this._touchZoom.enable(w4), this._rotationDisabled || this._touchRotate.enable(w4), this._tapDragZoom.enable(), this._el.classList.add("maplibregl-touch-zoom-rotate");\n                  }\n                  disable() {\n                    this._touchZoom.disable(), this._touchRotate.disable(), this._tapDragZoom.disable(), this._el.classList.remove("maplibregl-touch-zoom-rotate");\n                  }\n                  isEnabled() {\n                    return this._touchZoom.isEnabled() && (this._rotationDisabled || this._touchRotate.isEnabled()) && this._tapDragZoom.isEnabled();\n                  }\n                  isActive() {\n                    return this._touchZoom.isActive() || this._touchRotate.isActive() || this._tapDragZoom.isActive();\n                  }\n                  disableRotation() {\n                    this._rotationDisabled = true, this._touchRotate.disable();\n                  }\n                  enableRotation() {\n                    this._rotationDisabled = false, this._touchZoom.isEnabled() && this._touchRotate.enable();\n                  }\n                }\n                class Qi {\n                  constructor(w4, B4) {\n                    this._bypassKey = navigator.userAgent.indexOf("Mac") !== -1 ? "metaKey" : "ctrlKey", this._map = w4, this._options = B4, this._enabled = false;\n                  }\n                  isActive() {\n                    return false;\n                  }\n                  reset() {\n                  }\n                  _setupUI() {\n                    if (this._container) return;\n                    let w4 = this._map.getCanvasContainer();\n                    w4.classList.add("maplibregl-cooperative-gestures"), this._container = c5.create("div", "maplibregl-cooperative-gesture-screen", w4);\n                    let B4 = this._map._getUIString("CooperativeGesturesHandler.WindowsHelpText");\n                    this._bypassKey === "metaKey" && (B4 = this._map._getUIString("CooperativeGesturesHandler.MacHelpText"));\n                    let Q = this._map._getUIString("CooperativeGesturesHandler.MobileHelpText"), ee = document.createElement("div");\n                    ee.className = "maplibregl-desktop-message", ee.textContent = B4, this._container.appendChild(ee);\n                    let le = document.createElement("div");\n                    le.className = "maplibregl-mobile-message", le.textContent = Q, this._container.appendChild(le), this._container.setAttribute("aria-hidden", "true");\n                  }\n                  _destroyUI() {\n                    this._container && (c5.remove(this._container), this._map.getCanvasContainer().classList.remove("maplibregl-cooperative-gestures")), delete this._container;\n                  }\n                  enable() {\n                    this._setupUI(), this._enabled = true;\n                  }\n                  disable() {\n                    this._enabled = false, this._destroyUI();\n                  }\n                  isEnabled() {\n                    return this._enabled;\n                  }\n                  isBypassed(w4) {\n                    return w4[this._bypassKey];\n                  }\n                  notifyGestureBlocked(w4, B4) {\n                    this._enabled && (this._map.fire(new a4.k("cooperativegestureprevented", { gestureType: w4, originalEvent: B4 })), this._container.classList.add("maplibregl-show"), setTimeout(() => {\n                      this._container.classList.remove("maplibregl-show");\n                    }, 100));\n                  }\n                }\n                let on = (ue) => ue.zoom || ue.drag || ue.pitch || ue.rotate;\n                class Fi extends a4.k {\n                }\n                function $n(ue) {\n                  return ue.panDelta && ue.panDelta.mag() || ue.zoomDelta || ue.bearingDelta || ue.pitchDelta;\n                }\n                class Ca {\n                  constructor(w4, B4) {\n                    this.handleWindowEvent = (ee) => {\n                      this.handleEvent(ee, `${ee.type}Window`);\n                    }, this.handleEvent = (ee, le) => {\n                      if (ee.type === "blur") return void this.stop(true);\n                      this._updatingCamera = true;\n                      let qe = ee.type === "renderFrame" ? void 0 : ee, Xe = { needsRenderFrame: false }, ot = {}, Tt = {}, Yt = ee.touches, Kt = Yt ? this._getMapTouches(Yt) : void 0, xr = Kt ? c5.touchPos(this._map.getCanvas(), Kt) : c5.mousePos(this._map.getCanvas(), ee);\n                      for (let { handlerName: be, handler: De, allowed: Be } of this._handlers) {\n                        if (!De.isEnabled()) continue;\n                        let et;\n                        this._blockedByActive(Tt, Be, be) ? De.reset() : De[le || ee.type] && (et = De[le || ee.type](ee, xr, Kt), this.mergeHandlerResult(Xe, ot, et, be, qe), et && et.needsRenderFrame && this._triggerRenderFrame()), (et || De.isActive()) && (Tt[be] = De);\n                      }\n                      let Ir = {};\n                      for (let be in this._previousActiveHandlers) Tt[be] || (Ir[be] = qe);\n                      this._previousActiveHandlers = Tt, (Object.keys(Ir).length || $n(Xe)) && (this._changes.push([Xe, ot, Ir]), this._triggerRenderFrame()), (Object.keys(Tt).length || $n(Xe)) && this._map._stop(true), this._updatingCamera = false;\n                      let { cameraAnimation: ve } = Xe;\n                      ve && (this._inertia.clear(), this._fireEvents({}, {}, true), this._changes = [], ve(this._map));\n                    }, this._map = w4, this._el = this._map.getCanvasContainer(), this._handlers = [], this._handlersById = {}, this._changes = [], this._inertia = new Pf(w4), this._bearingSnap = B4.bearingSnap, this._previousActiveHandlers = {}, this._eventsInProgress = {}, this._addDefaultHandlers(B4);\n                    let Q = this._el;\n                    this._listeners = [[Q, "touchstart", { passive: true }], [Q, "touchmove", { passive: false }], [Q, "touchend", void 0], [Q, "touchcancel", void 0], [Q, "mousedown", void 0], [Q, "mousemove", void 0], [Q, "mouseup", void 0], [document, "mousemove", { capture: true }], [document, "mouseup", void 0], [Q, "mouseover", void 0], [Q, "mouseout", void 0], [Q, "dblclick", void 0], [Q, "click", void 0], [Q, "keydown", { capture: false }], [Q, "keyup", void 0], [Q, "wheel", { passive: false }], [Q, "contextmenu", void 0], [window, "blur", void 0]];\n                    for (let [ee, le, qe] of this._listeners) c5.addEventListener(ee, le, ee === document ? this.handleWindowEvent : this.handleEvent, qe);\n                  }\n                  destroy() {\n                    for (let [w4, B4, Q] of this._listeners) c5.removeEventListener(w4, B4, w4 === document ? this.handleWindowEvent : this.handleEvent, Q);\n                  }\n                  _addDefaultHandlers(w4) {\n                    let B4 = this._map, Q = B4.getCanvasContainer();\n                    this._add("mapEvent", new If(B4, w4));\n                    let ee = B4.boxZoom = new ku(B4, w4);\n                    this._add("boxZoom", ee), w4.interactive && w4.boxZoom && ee.enable();\n                    let le = B4.cooperativeGestures = new Qi(B4, w4.cooperativeGestures);\n                    this._add("cooperativeGestures", le), w4.cooperativeGestures && le.enable();\n                    let qe = new zc(B4), Xe = new Xi(B4);\n                    B4.doubleClickZoom = new ki(Xe, qe), this._add("tapZoom", qe), this._add("clickZoom", Xe), w4.interactive && w4.doubleClickZoom && B4.doubleClickZoom.enable();\n                    let ot = new dn();\n                    this._add("tapDragZoom", ot);\n                    let Tt = B4.touchPitch = new Bc(B4);\n                    this._add("touchPitch", Tt), w4.interactive && w4.touchPitch && B4.touchPitch.enable(w4.touchPitch);\n                    let Yt = Wl(w4), Kt = ah(w4);\n                    B4.dragRotate = new Nn(w4, Yt, Kt), this._add("mouseRotate", Yt, ["mousePitch"]), this._add("mousePitch", Kt, ["mouseRotate"]), w4.interactive && w4.dragRotate && B4.dragRotate.enable();\n                    let xr = (({ enable: et, clickTolerance: We }) => {\n                      let it = new Xu({ checkCorrectEvent: (Ft) => c5.mouseButton(Ft) === 0 && !Ft.ctrlKey });\n                      return new Wu({ clickTolerance: We, move: (Ft, Ht) => ({ around: Ht, panDelta: Ht.sub(Ft) }), activateOnStart: true, moveStateManager: it, enable: et, assignEvents: Xf });\n                    })(w4), Ir = new Zu(w4, B4);\n                    B4.dragPan = new wn(Q, xr, Ir), this._add("mousePan", xr), this._add("touchPan", Ir, ["touchZoom", "touchRotate"]), w4.interactive && w4.dragPan && B4.dragPan.enable(w4.dragPan);\n                    let ve = new cf(), be = new vu();\n                    B4.touchZoomRotate = new Yi(Q, be, ve, ot), this._add("touchRotate", ve, ["touchPan", "touchZoom"]), this._add("touchZoom", be, ["touchPan", "touchRotate"]), w4.interactive && w4.touchZoomRotate && B4.touchZoomRotate.enable(w4.touchZoomRotate);\n                    let De = B4.scrollZoom = new Kr(B4, () => this._triggerRenderFrame());\n                    this._add("scrollZoom", De, ["mousePan"]), w4.interactive && w4.scrollZoom && B4.scrollZoom.enable(w4.scrollZoom);\n                    let Be = B4.keyboard = new Wt(B4);\n                    this._add("keyboard", Be), w4.interactive && w4.keyboard && B4.keyboard.enable(), this._add("blockableMapEvent", new Cs(B4));\n                  }\n                  _add(w4, B4, Q) {\n                    this._handlers.push({ handlerName: w4, handler: B4, allowed: Q }), this._handlersById[w4] = B4;\n                  }\n                  stop(w4) {\n                    if (!this._updatingCamera) {\n                      for (let { handler: B4 } of this._handlers) B4.reset();\n                      this._inertia.clear(), this._fireEvents({}, {}, w4), this._changes = [];\n                    }\n                  }\n                  isActive() {\n                    for (let { handler: w4 } of this._handlers) if (w4.isActive()) return true;\n                    return false;\n                  }\n                  isZooming() {\n                    return !!this._eventsInProgress.zoom || this._map.scrollZoom.isZooming();\n                  }\n                  isRotating() {\n                    return !!this._eventsInProgress.rotate;\n                  }\n                  isMoving() {\n                    return !!on(this._eventsInProgress) || this.isZooming();\n                  }\n                  _blockedByActive(w4, B4, Q) {\n                    for (let ee in w4) if (ee !== Q && (!B4 || B4.indexOf(ee) < 0)) return true;\n                    return false;\n                  }\n                  _getMapTouches(w4) {\n                    let B4 = [];\n                    for (let Q of w4) this._el.contains(Q.target) && B4.push(Q);\n                    return B4;\n                  }\n                  mergeHandlerResult(w4, B4, Q, ee, le) {\n                    if (!Q) return;\n                    a4.e(w4, Q);\n                    let qe = { handlerName: ee, originalEvent: Q.originalEvent || le };\n                    Q.zoomDelta !== void 0 && (B4.zoom = qe), Q.panDelta !== void 0 && (B4.drag = qe), Q.pitchDelta !== void 0 && (B4.pitch = qe), Q.bearingDelta !== void 0 && (B4.rotate = qe);\n                  }\n                  _applyChanges() {\n                    let w4 = {}, B4 = {}, Q = {};\n                    for (let [ee, le, qe] of this._changes) ee.panDelta && (w4.panDelta = (w4.panDelta || new a4.P(0, 0))._add(ee.panDelta)), ee.zoomDelta && (w4.zoomDelta = (w4.zoomDelta || 0) + ee.zoomDelta), ee.bearingDelta && (w4.bearingDelta = (w4.bearingDelta || 0) + ee.bearingDelta), ee.pitchDelta && (w4.pitchDelta = (w4.pitchDelta || 0) + ee.pitchDelta), ee.around !== void 0 && (w4.around = ee.around), ee.pinchAround !== void 0 && (w4.pinchAround = ee.pinchAround), ee.noInertia && (w4.noInertia = ee.noInertia), a4.e(B4, le), a4.e(Q, qe);\n                    this._updateMapTransform(w4, B4, Q), this._changes = [];\n                  }\n                  _updateMapTransform(w4, B4, Q) {\n                    let ee = this._map, le = ee._getTransformForUpdate(), qe = ee.terrain;\n                    if (!($n(w4) || qe && this._terrainMovement)) return this._fireEvents(B4, Q, true);\n                    let { panDelta: Xe, zoomDelta: ot, bearingDelta: Tt, pitchDelta: Yt, around: Kt, pinchAround: xr } = w4;\n                    xr !== void 0 && (Kt = xr), ee._stop(true), Kt = Kt || ee.transform.centerPoint;\n                    let Ir = le.pointLocation(Xe ? Kt.sub(Xe) : Kt);\n                    Tt && (le.bearing += Tt), Yt && (le.pitch += Yt), ot && (le.zoom += ot), qe ? this._terrainMovement || !B4.drag && !B4.zoom ? B4.drag && this._terrainMovement ? le.center = le.pointLocation(le.centerPoint.sub(Xe)) : le.setLocationAtPoint(Ir, Kt) : (this._terrainMovement = true, this._map._elevationFreeze = true, le.setLocationAtPoint(Ir, Kt)) : le.setLocationAtPoint(Ir, Kt), ee._applyUpdatedTransform(le), this._map._update(), w4.noInertia || this._inertia.record(w4), this._fireEvents(B4, Q, true);\n                  }\n                  _fireEvents(w4, B4, Q) {\n                    let ee = on(this._eventsInProgress), le = on(w4), qe = {};\n                    for (let Kt in w4) {\n                      let { originalEvent: xr } = w4[Kt];\n                      this._eventsInProgress[Kt] || (qe[`${Kt}start`] = xr), this._eventsInProgress[Kt] = w4[Kt];\n                    }\n                    !ee && le && this._fireEvent("movestart", le.originalEvent);\n                    for (let Kt in qe) this._fireEvent(Kt, qe[Kt]);\n                    le && this._fireEvent("move", le.originalEvent);\n                    for (let Kt in w4) {\n                      let { originalEvent: xr } = w4[Kt];\n                      this._fireEvent(Kt, xr);\n                    }\n                    let Xe = {}, ot;\n                    for (let Kt in this._eventsInProgress) {\n                      let { handlerName: xr, originalEvent: Ir } = this._eventsInProgress[Kt];\n                      this._handlersById[xr].isActive() || (delete this._eventsInProgress[Kt], ot = B4[xr] || Ir, Xe[`${Kt}end`] = ot);\n                    }\n                    for (let Kt in Xe) this._fireEvent(Kt, Xe[Kt]);\n                    let Tt = on(this._eventsInProgress), Yt = (ee || le) && !Tt;\n                    if (Yt && this._terrainMovement) {\n                      this._map._elevationFreeze = false, this._terrainMovement = false;\n                      let Kt = this._map._getTransformForUpdate();\n                      Kt.recalculateZoom(this._map.terrain), this._map._applyUpdatedTransform(Kt);\n                    }\n                    if (Q && Yt) {\n                      this._updatingCamera = true;\n                      let Kt = this._inertia._onMoveEnd(this._map.dragPan._inertiaOptions), xr = (Ir) => Ir !== 0 && -this._bearingSnap < Ir && Ir < this._bearingSnap;\n                      !Kt || !Kt.essential && u4.prefersReducedMotion ? (this._map.fire(new a4.k("moveend", { originalEvent: ot })), xr(this._map.getBearing()) && this._map.resetNorth()) : (xr(Kt.bearing || this._map.getBearing()) && (Kt.bearing = 0), Kt.freezeElevation = true, this._map.easeTo(Kt, { originalEvent: ot })), this._updatingCamera = false;\n                    }\n                  }\n                  _fireEvent(w4, B4) {\n                    this._map.fire(new a4.k(w4, B4 ? { originalEvent: B4 } : {}));\n                  }\n                  _requestFrame() {\n                    return this._map.triggerRepaint(), this._map._renderTaskQueue.add((w4) => {\n                      delete this._frameId, this.handleEvent(new Fi("renderFrame", { timeStamp: w4 })), this._applyChanges();\n                    });\n                  }\n                  _triggerRenderFrame() {\n                    this._frameId === void 0 && (this._frameId = this._requestFrame());\n                  }\n                }\n                class Ra extends a4.E {\n                  constructor(w4, B4) {\n                    super(), this._renderFrameCallback = () => {\n                      let Q = Math.min((u4.now() - this._easeStart) / this._easeOptions.duration, 1);\n                      this._onEaseFrame(this._easeOptions.easing(Q)), Q < 1 && this._easeFrameId ? this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback) : this.stop();\n                    }, this._moving = false, this._zooming = false, this.transform = w4, this._bearingSnap = B4.bearingSnap, this.on("moveend", () => {\n                      delete this._requestedCameraState;\n                    });\n                  }\n                  getCenter() {\n                    return new a4.N(this.transform.center.lng, this.transform.center.lat);\n                  }\n                  setCenter(w4, B4) {\n                    return this.jumpTo({ center: w4 }, B4);\n                  }\n                  panBy(w4, B4, Q) {\n                    return w4 = a4.P.convert(w4).mult(-1), this.panTo(this.transform.center, a4.e({ offset: w4 }, B4), Q);\n                  }\n                  panTo(w4, B4, Q) {\n                    return this.easeTo(a4.e({ center: w4 }, B4), Q);\n                  }\n                  getZoom() {\n                    return this.transform.zoom;\n                  }\n                  setZoom(w4, B4) {\n                    return this.jumpTo({ zoom: w4 }, B4), this;\n                  }\n                  zoomTo(w4, B4, Q) {\n                    return this.easeTo(a4.e({ zoom: w4 }, B4), Q);\n                  }\n                  zoomIn(w4, B4) {\n                    return this.zoomTo(this.getZoom() + 1, w4, B4), this;\n                  }\n                  zoomOut(w4, B4) {\n                    return this.zoomTo(this.getZoom() - 1, w4, B4), this;\n                  }\n                  getBearing() {\n                    return this.transform.bearing;\n                  }\n                  setBearing(w4, B4) {\n                    return this.jumpTo({ bearing: w4 }, B4), this;\n                  }\n                  getPadding() {\n                    return this.transform.padding;\n                  }\n                  setPadding(w4, B4) {\n                    return this.jumpTo({ padding: w4 }, B4), this;\n                  }\n                  rotateTo(w4, B4, Q) {\n                    return this.easeTo(a4.e({ bearing: w4 }, B4), Q);\n                  }\n                  resetNorth(w4, B4) {\n                    return this.rotateTo(0, a4.e({ duration: 1e3 }, w4), B4), this;\n                  }\n                  resetNorthPitch(w4, B4) {\n                    return this.easeTo(a4.e({ bearing: 0, pitch: 0, duration: 1e3 }, w4), B4), this;\n                  }\n                  snapToNorth(w4, B4) {\n                    return Math.abs(this.getBearing()) < this._bearingSnap ? this.resetNorth(w4, B4) : this;\n                  }\n                  getPitch() {\n                    return this.transform.pitch;\n                  }\n                  setPitch(w4, B4) {\n                    return this.jumpTo({ pitch: w4 }, B4), this;\n                  }\n                  cameraForBounds(w4, B4) {\n                    w4 = ce.convert(w4).adjustAntiMeridian();\n                    let Q = B4 && B4.bearing || 0;\n                    return this._cameraForBoxAndBearing(w4.getNorthWest(), w4.getSouthEast(), Q, B4);\n                  }\n                  _cameraForBoxAndBearing(w4, B4, Q, ee) {\n                    let le = { top: 0, bottom: 0, right: 0, left: 0 };\n                    if (typeof (ee = a4.e({ padding: le, offset: [0, 0], maxZoom: this.transform.maxZoom }, ee)).padding == "number") {\n                      let Wr = ee.padding;\n                      ee.padding = { top: Wr, bottom: Wr, right: Wr, left: Wr };\n                    }\n                    ee.padding = a4.e(le, ee.padding);\n                    let qe = this.transform, Xe = qe.padding, ot = new ce(w4, B4), Tt = qe.project(ot.getNorthWest()), Yt = qe.project(ot.getNorthEast()), Kt = qe.project(ot.getSouthEast()), xr = qe.project(ot.getSouthWest()), Ir = a4.ba(-Q), ve = Tt.rotate(Ir), be = Yt.rotate(Ir), De = Kt.rotate(Ir), Be = xr.rotate(Ir), et = new a4.P(Math.max(ve.x, be.x, Be.x, De.x), Math.max(ve.y, be.y, Be.y, De.y)), We = new a4.P(Math.min(ve.x, be.x, Be.x, De.x), Math.min(ve.y, be.y, Be.y, De.y)), it = et.sub(We), Ft = (qe.width - (Xe.left + Xe.right + ee.padding.left + ee.padding.right)) / it.x, Ht = (qe.height - (Xe.top + Xe.bottom + ee.padding.top + ee.padding.bottom)) / it.y;\n                    if (Ht < 0 || Ft < 0) return void a4.w("Map cannot fit within canvas with the given bounds, padding, and/or offset.");\n                    let tr = Math.min(qe.scaleZoom(qe.scale * Math.min(Ft, Ht)), ee.maxZoom), dr = a4.P.convert(ee.offset), Sr = new a4.P((ee.padding.left - ee.padding.right) / 2, (ee.padding.top - ee.padding.bottom) / 2).rotate(a4.ba(Q)), Or = dr.add(Sr).mult(qe.scale / qe.zoomScale(tr));\n                    return { center: qe.unproject(Tt.add(Kt).div(2).sub(Or)), zoom: tr, bearing: Q };\n                  }\n                  fitBounds(w4, B4, Q) {\n                    return this._fitInternal(this.cameraForBounds(w4, B4), B4, Q);\n                  }\n                  fitScreenCoordinates(w4, B4, Q, ee, le) {\n                    return this._fitInternal(this._cameraForBoxAndBearing(this.transform.pointLocation(a4.P.convert(w4)), this.transform.pointLocation(a4.P.convert(B4)), Q, ee), ee, le);\n                  }\n                  _fitInternal(w4, B4, Q) {\n                    return w4 ? (delete (B4 = a4.e(w4, B4)).padding, B4.linear ? this.easeTo(B4, Q) : this.flyTo(B4, Q)) : this;\n                  }\n                  jumpTo(w4, B4) {\n                    this.stop();\n                    let Q = this._getTransformForUpdate(), ee = false, le = false, qe = false;\n                    return "zoom" in w4 && Q.zoom !== +w4.zoom && (ee = true, Q.zoom = +w4.zoom), w4.center !== void 0 && (Q.center = a4.N.convert(w4.center)), "bearing" in w4 && Q.bearing !== +w4.bearing && (le = true, Q.bearing = +w4.bearing), "pitch" in w4 && Q.pitch !== +w4.pitch && (qe = true, Q.pitch = +w4.pitch), w4.padding == null || Q.isPaddingEqual(w4.padding) || (Q.padding = w4.padding), this._applyUpdatedTransform(Q), this.fire(new a4.k("movestart", B4)).fire(new a4.k("move", B4)), ee && this.fire(new a4.k("zoomstart", B4)).fire(new a4.k("zoom", B4)).fire(new a4.k("zoomend", B4)), le && this.fire(new a4.k("rotatestart", B4)).fire(new a4.k("rotate", B4)).fire(new a4.k("rotateend", B4)), qe && this.fire(new a4.k("pitchstart", B4)).fire(new a4.k("pitch", B4)).fire(new a4.k("pitchend", B4)), this.fire(new a4.k("moveend", B4));\n                  }\n                  calculateCameraOptionsFromTo(w4, B4, Q, ee = 0) {\n                    let le = a4.Z.fromLngLat(w4, B4), qe = a4.Z.fromLngLat(Q, ee), Xe = qe.x - le.x, ot = qe.y - le.y, Tt = qe.z - le.z, Yt = Math.hypot(Xe, ot, Tt);\n                    if (Yt === 0) throw new Error("Can\'t calculate camera options with same From and To");\n                    let Kt = Math.hypot(Xe, ot), xr = this.transform.scaleZoom(this.transform.cameraToCenterDistance / Yt / this.transform.tileSize), Ir = 180 * Math.atan2(Xe, -ot) / Math.PI, ve = 180 * Math.acos(Kt / Yt) / Math.PI;\n                    return ve = Tt < 0 ? 90 - ve : 90 + ve, { center: qe.toLngLat(), zoom: xr, pitch: ve, bearing: Ir };\n                  }\n                  easeTo(w4, B4) {\n                    var Q;\n                    this._stop(false, w4.easeId), ((w4 = a4.e({ offset: [0, 0], duration: 500, easing: a4.b9 }, w4)).animate === false || !w4.essential && u4.prefersReducedMotion) && (w4.duration = 0);\n                    let ee = this._getTransformForUpdate(), le = ee.zoom, qe = ee.bearing, Xe = ee.pitch, ot = ee.padding, Tt = "bearing" in w4 ? this._normalizeBearing(w4.bearing, qe) : qe, Yt = "pitch" in w4 ? +w4.pitch : Xe, Kt = "padding" in w4 ? w4.padding : ee.padding, xr = a4.P.convert(w4.offset), Ir = ee.centerPoint.add(xr), ve = ee.pointLocation(Ir), { center: be, zoom: De } = ee.getConstrained(a4.N.convert(w4.center || ve), (Q = w4.zoom) !== null && Q !== void 0 ? Q : le);\n                    this._normalizeCenter(be, ee);\n                    let Be = ee.project(ve), et = ee.project(be).sub(Be), We = ee.zoomScale(De - le), it, Ft;\n                    w4.around && (it = a4.N.convert(w4.around), Ft = ee.locationPoint(it));\n                    let Ht = { moving: this._moving, zooming: this._zooming, rotating: this._rotating, pitching: this._pitching };\n                    return this._zooming = this._zooming || De !== le, this._rotating = this._rotating || qe !== Tt, this._pitching = this._pitching || Yt !== Xe, this._padding = !ee.isPaddingEqual(Kt), this._easeId = w4.easeId, this._prepareEase(B4, w4.noMoveStart, Ht), this.terrain && this._prepareElevation(be), this._ease((tr) => {\n                      if (this._zooming && (ee.zoom = a4.y.number(le, De, tr)), this._rotating && (ee.bearing = a4.y.number(qe, Tt, tr)), this._pitching && (ee.pitch = a4.y.number(Xe, Yt, tr)), this._padding && (ee.interpolatePadding(ot, Kt, tr), Ir = ee.centerPoint.add(xr)), this.terrain && !w4.freezeElevation && this._updateElevation(tr), it) ee.setLocationAtPoint(it, Ft);\n                      else {\n                        let dr = ee.zoomScale(ee.zoom - le), Sr = De > le ? Math.min(2, We) : Math.max(0.5, We), Or = Math.pow(Sr, 1 - tr), Wr = ee.unproject(Be.add(et.mult(tr * Or)).mult(dr));\n                        ee.setLocationAtPoint(ee.renderWorldCopies ? Wr.wrap() : Wr, Ir);\n                      }\n                      this._applyUpdatedTransform(ee), this._fireMoveEvents(B4);\n                    }, (tr) => {\n                      this.terrain && w4.freezeElevation && this._finalizeElevation(), this._afterEase(B4, tr);\n                    }, w4), this;\n                  }\n                  _prepareEase(w4, B4, Q = {}) {\n                    this._moving = true, B4 || Q.moving || this.fire(new a4.k("movestart", w4)), this._zooming && !Q.zooming && this.fire(new a4.k("zoomstart", w4)), this._rotating && !Q.rotating && this.fire(new a4.k("rotatestart", w4)), this._pitching && !Q.pitching && this.fire(new a4.k("pitchstart", w4));\n                  }\n                  _prepareElevation(w4) {\n                    this._elevationCenter = w4, this._elevationStart = this.transform.elevation, this._elevationTarget = this.terrain.getElevationForLngLatZoom(w4, this.transform.tileZoom), this._elevationFreeze = true;\n                  }\n                  _updateElevation(w4) {\n                    this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);\n                    let B4 = this.terrain.getElevationForLngLatZoom(this._elevationCenter, this.transform.tileZoom);\n                    if (w4 < 1 && B4 !== this._elevationTarget) {\n                      let Q = this._elevationTarget - this._elevationStart;\n                      this._elevationStart += w4 * (Q - (B4 - (Q * w4 + this._elevationStart)) / (1 - w4)), this._elevationTarget = B4;\n                    }\n                    this.transform.elevation = a4.y.number(this._elevationStart, this._elevationTarget, w4);\n                  }\n                  _finalizeElevation() {\n                    this._elevationFreeze = false, this.transform.recalculateZoom(this.terrain);\n                  }\n                  _getTransformForUpdate() {\n                    return this.transformCameraUpdate || this.terrain ? (this._requestedCameraState || (this._requestedCameraState = this.transform.clone()), this._requestedCameraState) : this.transform;\n                  }\n                  _elevateCameraIfInsideTerrain(w4) {\n                    let B4 = w4.getCameraPosition(), Q = this.terrain.getElevationForLngLatZoom(B4.lngLat, w4.zoom);\n                    if (B4.altitude < Q) {\n                      let ee = this.calculateCameraOptionsFromTo(B4.lngLat, Q, w4.center, w4.elevation);\n                      return { pitch: ee.pitch, zoom: ee.zoom };\n                    }\n                    return {};\n                  }\n                  _applyUpdatedTransform(w4) {\n                    let B4 = [];\n                    if (this.terrain && B4.push((ee) => this._elevateCameraIfInsideTerrain(ee)), this.transformCameraUpdate && B4.push((ee) => this.transformCameraUpdate(ee)), !B4.length) return;\n                    let Q = w4.clone();\n                    for (let ee of B4) {\n                      let le = Q.clone(), { center: qe, zoom: Xe, pitch: ot, bearing: Tt, elevation: Yt } = ee(le);\n                      qe && (le.center = qe), Xe !== void 0 && (le.zoom = Xe), ot !== void 0 && (le.pitch = ot), Tt !== void 0 && (le.bearing = Tt), Yt !== void 0 && (le.elevation = Yt), Q.apply(le);\n                    }\n                    this.transform.apply(Q);\n                  }\n                  _fireMoveEvents(w4) {\n                    this.fire(new a4.k("move", w4)), this._zooming && this.fire(new a4.k("zoom", w4)), this._rotating && this.fire(new a4.k("rotate", w4)), this._pitching && this.fire(new a4.k("pitch", w4));\n                  }\n                  _afterEase(w4, B4) {\n                    if (this._easeId && B4 && this._easeId === B4) return;\n                    delete this._easeId;\n                    let Q = this._zooming, ee = this._rotating, le = this._pitching;\n                    this._moving = false, this._zooming = false, this._rotating = false, this._pitching = false, this._padding = false, Q && this.fire(new a4.k("zoomend", w4)), ee && this.fire(new a4.k("rotateend", w4)), le && this.fire(new a4.k("pitchend", w4)), this.fire(new a4.k("moveend", w4));\n                  }\n                  flyTo(w4, B4) {\n                    var Q;\n                    if (!w4.essential && u4.prefersReducedMotion) {\n                      let Cn = a4.M(w4, ["center", "zoom", "bearing", "pitch", "around"]);\n                      return this.jumpTo(Cn, B4);\n                    }\n                    this.stop(), w4 = a4.e({ offset: [0, 0], speed: 1.2, curve: 1.42, easing: a4.b9 }, w4);\n                    let ee = this._getTransformForUpdate(), le = ee.zoom, qe = ee.bearing, Xe = ee.pitch, ot = ee.padding, Tt = "bearing" in w4 ? this._normalizeBearing(w4.bearing, qe) : qe, Yt = "pitch" in w4 ? +w4.pitch : Xe, Kt = "padding" in w4 ? w4.padding : ee.padding, xr = a4.P.convert(w4.offset), Ir = ee.centerPoint.add(xr), ve = ee.pointLocation(Ir), { center: be, zoom: De } = ee.getConstrained(a4.N.convert(w4.center || ve), (Q = w4.zoom) !== null && Q !== void 0 ? Q : le);\n                    this._normalizeCenter(be, ee);\n                    let Be = ee.zoomScale(De - le), et = ee.project(ve), We = ee.project(be).sub(et), it = w4.curve, Ft = Math.max(ee.width, ee.height), Ht = Ft / Be, tr = We.mag();\n                    if ("minZoom" in w4) {\n                      let Cn = a4.ac(Math.min(w4.minZoom, le, De), ee.minZoom, ee.maxZoom), Kn = Ft / ee.zoomScale(Cn - le);\n                      it = Math.sqrt(Kn / tr * 2);\n                    }\n                    let dr = it * it;\n                    function Sr(Cn) {\n                      let Kn = (Ht * Ht - Ft * Ft + (Cn ? -1 : 1) * dr * dr * tr * tr) / (2 * (Cn ? Ht : Ft) * dr * tr);\n                      return Math.log(Math.sqrt(Kn * Kn + 1) - Kn);\n                    }\n                    function Or(Cn) {\n                      return (Math.exp(Cn) - Math.exp(-Cn)) / 2;\n                    }\n                    function Wr(Cn) {\n                      return (Math.exp(Cn) + Math.exp(-Cn)) / 2;\n                    }\n                    let ni = Sr(false), Pi = function(Cn) {\n                      return Wr(ni) / Wr(ni + it * Cn);\n                    }, cn = function(Cn) {\n                      return Ft * ((Wr(ni) * (Or(Kn = ni + it * Cn) / Wr(Kn)) - Or(ni)) / dr) / tr;\n                      var Kn;\n                    }, ln = (Sr(true) - ni) / it;\n                    if (Math.abs(tr) < 1e-6 || !isFinite(ln)) {\n                      if (Math.abs(Ft - Ht) < 1e-6) return this.easeTo(w4, B4);\n                      let Cn = Ht < Ft ? -1 : 1;\n                      ln = Math.abs(Math.log(Ht / Ft)) / it, cn = () => 0, Pi = (Kn) => Math.exp(Cn * it * Kn);\n                    }\n                    return w4.duration = "duration" in w4 ? +w4.duration : 1e3 * ln / ("screenSpeed" in w4 ? +w4.screenSpeed / it : +w4.speed), w4.maxDuration && w4.duration > w4.maxDuration && (w4.duration = 0), this._zooming = true, this._rotating = qe !== Tt, this._pitching = Yt !== Xe, this._padding = !ee.isPaddingEqual(Kt), this._prepareEase(B4, false), this.terrain && this._prepareElevation(be), this._ease((Cn) => {\n                      let Kn = Cn * ln, Ta = 1 / Pi(Kn);\n                      ee.zoom = Cn === 1 ? De : le + ee.scaleZoom(Ta), this._rotating && (ee.bearing = a4.y.number(qe, Tt, Cn)), this._pitching && (ee.pitch = a4.y.number(Xe, Yt, Cn)), this._padding && (ee.interpolatePadding(ot, Kt, Cn), Ir = ee.centerPoint.add(xr)), this.terrain && !w4.freezeElevation && this._updateElevation(Cn);\n                      let fa = Cn === 1 ? be : ee.unproject(et.add(We.mult(cn(Kn))).mult(Ta));\n                      ee.setLocationAtPoint(ee.renderWorldCopies ? fa.wrap() : fa, Ir), this._applyUpdatedTransform(ee), this._fireMoveEvents(B4);\n                    }, () => {\n                      this.terrain && w4.freezeElevation && this._finalizeElevation(), this._afterEase(B4);\n                    }, w4), this;\n                  }\n                  isEasing() {\n                    return !!this._easeFrameId;\n                  }\n                  stop() {\n                    return this._stop();\n                  }\n                  _stop(w4, B4) {\n                    var Q;\n                    if (this._easeFrameId && (this._cancelRenderFrame(this._easeFrameId), delete this._easeFrameId, delete this._onEaseFrame), this._onEaseEnd) {\n                      let ee = this._onEaseEnd;\n                      delete this._onEaseEnd, ee.call(this, B4);\n                    }\n                    return w4 || (Q = this.handlers) === null || Q === void 0 || Q.stop(false), this;\n                  }\n                  _ease(w4, B4, Q) {\n                    Q.animate === false || Q.duration === 0 ? (w4(1), B4()) : (this._easeStart = u4.now(), this._easeOptions = Q, this._onEaseFrame = w4, this._onEaseEnd = B4, this._easeFrameId = this._requestRenderFrame(this._renderFrameCallback));\n                  }\n                  _normalizeBearing(w4, B4) {\n                    w4 = a4.b3(w4, -180, 180);\n                    let Q = Math.abs(w4 - B4);\n                    return Math.abs(w4 - 360 - B4) < Q && (w4 -= 360), Math.abs(w4 + 360 - B4) < Q && (w4 += 360), w4;\n                  }\n                  _normalizeCenter(w4, B4) {\n                    if (!B4.renderWorldCopies || B4.lngRange) return;\n                    let Q = w4.lng - B4.center.lng;\n                    w4.lng += Q > 180 ? -360 : Q < -180 ? 360 : 0;\n                  }\n                  queryTerrainElevation(w4) {\n                    return this.terrain ? this.terrain.getElevationForLngLatZoom(a4.N.convert(w4), this.transform.tileZoom) - this.transform.elevation : null;\n                  }\n                }\n                let La = { compact: true, customAttribution: \'<a href="https://maplibre.org/" target="_blank">MapLibre</a>\' };\n                class Na {\n                  constructor(w4 = La) {\n                    this._toggleAttribution = () => {\n                      this._container.classList.contains("maplibregl-compact") && (this._container.classList.contains("maplibregl-compact-show") ? (this._container.setAttribute("open", ""), this._container.classList.remove("maplibregl-compact-show")) : (this._container.classList.add("maplibregl-compact-show"), this._container.removeAttribute("open")));\n                    }, this._updateData = (B4) => {\n                      !B4 || B4.sourceDataType !== "metadata" && B4.sourceDataType !== "visibility" && B4.dataType !== "style" && B4.type !== "terrain" || this._updateAttributions();\n                    }, this._updateCompact = () => {\n                      this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? this._compact === false ? this._container.setAttribute("open", "") : this._container.classList.contains("maplibregl-compact") || this._container.classList.contains("maplibregl-attrib-empty") || (this._container.setAttribute("open", ""), this._container.classList.add("maplibregl-compact", "maplibregl-compact-show")) : (this._container.setAttribute("open", ""), this._container.classList.contains("maplibregl-compact") && this._container.classList.remove("maplibregl-compact", "maplibregl-compact-show"));\n                    }, this._updateCompactMinimize = () => {\n                      this._container.classList.contains("maplibregl-compact") && this._container.classList.contains("maplibregl-compact-show") && this._container.classList.remove("maplibregl-compact-show");\n                    }, this.options = w4;\n                  }\n                  getDefaultPosition() {\n                    return "bottom-right";\n                  }\n                  onAdd(w4) {\n                    return this._map = w4, this._compact = this.options.compact, this._container = c5.create("details", "maplibregl-ctrl maplibregl-ctrl-attrib"), this._compactButton = c5.create("summary", "maplibregl-ctrl-attrib-button", this._container), this._compactButton.addEventListener("click", this._toggleAttribution), this._setElementTitle(this._compactButton, "ToggleAttribution"), this._innerContainer = c5.create("div", "maplibregl-ctrl-attrib-inner", this._container), this._updateAttributions(), this._updateCompact(), this._map.on("styledata", this._updateData), this._map.on("sourcedata", this._updateData), this._map.on("terrain", this._updateData), this._map.on("resize", this._updateCompact), this._map.on("drag", this._updateCompactMinimize), this._container;\n                  }\n                  onRemove() {\n                    c5.remove(this._container), this._map.off("styledata", this._updateData), this._map.off("sourcedata", this._updateData), this._map.off("terrain", this._updateData), this._map.off("resize", this._updateCompact), this._map.off("drag", this._updateCompactMinimize), this._map = void 0, this._compact = void 0, this._attribHTML = void 0;\n                  }\n                  _setElementTitle(w4, B4) {\n                    let Q = this._map._getUIString(`AttributionControl.${B4}`);\n                    w4.title = Q, w4.setAttribute("aria-label", Q);\n                  }\n                  _updateAttributions() {\n                    if (!this._map.style) return;\n                    let w4 = [];\n                    if (this.options.customAttribution && (Array.isArray(this.options.customAttribution) ? w4 = w4.concat(this.options.customAttribution.map((ee) => typeof ee != "string" ? "" : ee)) : typeof this.options.customAttribution == "string" && w4.push(this.options.customAttribution)), this._map.style.stylesheet) {\n                      let ee = this._map.style.stylesheet;\n                      this.styleOwner = ee.owner, this.styleId = ee.id;\n                    }\n                    let B4 = this._map.style.sourceCaches;\n                    for (let ee in B4) {\n                      let le = B4[ee];\n                      if (le.used || le.usedForTerrain) {\n                        let qe = le.getSource();\n                        qe.attribution && w4.indexOf(qe.attribution) < 0 && w4.push(qe.attribution);\n                      }\n                    }\n                    w4 = w4.filter((ee) => String(ee).trim()), w4.sort((ee, le) => ee.length - le.length), w4 = w4.filter((ee, le) => {\n                      for (let qe = le + 1; qe < w4.length; qe++) if (w4[qe].indexOf(ee) >= 0) return false;\n                      return true;\n                    });\n                    let Q = w4.join(" | ");\n                    Q !== this._attribHTML && (this._attribHTML = Q, w4.length ? (this._innerContainer.innerHTML = Q, this._container.classList.remove("maplibregl-attrib-empty")) : this._container.classList.add("maplibregl-attrib-empty"), this._updateCompact(), this._editLink = null);\n                  }\n                }\n                class Yn {\n                  constructor(w4 = {}) {\n                    this._updateCompact = () => {\n                      let B4 = this._container.children;\n                      if (B4.length) {\n                        let Q = B4[0];\n                        this._map.getCanvasContainer().offsetWidth <= 640 || this._compact ? this._compact !== false && Q.classList.add("maplibregl-compact") : Q.classList.remove("maplibregl-compact");\n                      }\n                    }, this.options = w4;\n                  }\n                  getDefaultPosition() {\n                    return "bottom-left";\n                  }\n                  onAdd(w4) {\n                    this._map = w4, this._compact = this.options && this.options.compact, this._container = c5.create("div", "maplibregl-ctrl");\n                    let B4 = c5.create("a", "maplibregl-ctrl-logo");\n                    return B4.target = "_blank", B4.rel = "noopener nofollow", B4.href = "https://maplibre.org/", B4.setAttribute("aria-label", this._map._getUIString("LogoControl.Title")), B4.setAttribute("rel", "noopener nofollow"), this._container.appendChild(B4), this._container.style.display = "block", this._map.on("resize", this._updateCompact), this._updateCompact(), this._container;\n                  }\n                  onRemove() {\n                    c5.remove(this._container), this._map.off("resize", this._updateCompact), this._map = void 0, this._compact = void 0;\n                  }\n                }\n                class Dn {\n                  constructor() {\n                    this._queue = [], this._id = 0, this._cleared = false, this._currentlyRunning = false;\n                  }\n                  add(w4) {\n                    let B4 = ++this._id;\n                    return this._queue.push({ callback: w4, id: B4, cancelled: false }), B4;\n                  }\n                  remove(w4) {\n                    let B4 = this._currentlyRunning, Q = B4 ? this._queue.concat(B4) : this._queue;\n                    for (let ee of Q) if (ee.id === w4) return void (ee.cancelled = true);\n                  }\n                  run(w4 = 0) {\n                    if (this._currentlyRunning) throw new Error("Attempting to run(), but is already running.");\n                    let B4 = this._currentlyRunning = this._queue;\n                    this._queue = [];\n                    for (let Q of B4) if (!Q.cancelled && (Q.callback(w4), this._cleared)) break;\n                    this._cleared = false, this._currentlyRunning = false;\n                  }\n                  clear() {\n                    this._currentlyRunning && (this._cleared = true), this._queue = [];\n                  }\n                }\n                var Ka = a4.Y([{ name: "a_pos3d", type: "Int16", components: 3 }]);\n                class bo extends a4.E {\n                  constructor(w4) {\n                    super(), this.sourceCache = w4, this._tiles = {}, this._renderableTilesKeys = [], this._sourceTileCache = {}, this.minzoom = 0, this.maxzoom = 22, this.tileSize = 512, this.deltaZoom = 1, w4.usedForTerrain = true, w4.tileSize = this.tileSize * 2 ** this.deltaZoom;\n                  }\n                  destruct() {\n                    this.sourceCache.usedForTerrain = false, this.sourceCache.tileSize = null;\n                  }\n                  update(w4, B4) {\n                    this.sourceCache.update(w4, B4), this._renderableTilesKeys = [];\n                    let Q = {};\n                    for (let ee of w4.coveringTiles({ tileSize: this.tileSize, minzoom: this.minzoom, maxzoom: this.maxzoom, reparseOverscaled: false, terrain: B4 })) Q[ee.key] = true, this._renderableTilesKeys.push(ee.key), this._tiles[ee.key] || (ee.posMatrix = new Float64Array(16), a4.aP(ee.posMatrix, 0, a4.X, 0, a4.X, 0, 1), this._tiles[ee.key] = new Vt(ee, this.tileSize));\n                    for (let ee in this._tiles) Q[ee] || delete this._tiles[ee];\n                  }\n                  freeRtt(w4) {\n                    for (let B4 in this._tiles) {\n                      let Q = this._tiles[B4];\n                      (!w4 || Q.tileID.equals(w4) || Q.tileID.isChildOf(w4) || w4.isChildOf(Q.tileID)) && (Q.rtt = []);\n                    }\n                  }\n                  getRenderableTiles() {\n                    return this._renderableTilesKeys.map((w4) => this.getTileByID(w4));\n                  }\n                  getTileByID(w4) {\n                    return this._tiles[w4];\n                  }\n                  getTerrainCoords(w4) {\n                    let B4 = {};\n                    for (let Q of this._renderableTilesKeys) {\n                      let ee = this._tiles[Q].tileID;\n                      if (ee.canonical.equals(w4.canonical)) {\n                        let le = w4.clone();\n                        le.posMatrix = new Float64Array(16), a4.aP(le.posMatrix, 0, a4.X, 0, a4.X, 0, 1), B4[Q] = le;\n                      } else if (ee.canonical.isChildOf(w4.canonical)) {\n                        let le = w4.clone();\n                        le.posMatrix = new Float64Array(16);\n                        let qe = ee.canonical.z - w4.canonical.z, Xe = ee.canonical.x - (ee.canonical.x >> qe << qe), ot = ee.canonical.y - (ee.canonical.y >> qe << qe), Tt = a4.X >> qe;\n                        a4.aP(le.posMatrix, 0, Tt, 0, Tt, 0, 1), a4.J(le.posMatrix, le.posMatrix, [-Xe * Tt, -ot * Tt, 0]), B4[Q] = le;\n                      } else if (w4.canonical.isChildOf(ee.canonical)) {\n                        let le = w4.clone();\n                        le.posMatrix = new Float64Array(16);\n                        let qe = w4.canonical.z - ee.canonical.z, Xe = w4.canonical.x - (w4.canonical.x >> qe << qe), ot = w4.canonical.y - (w4.canonical.y >> qe << qe), Tt = a4.X >> qe;\n                        a4.aP(le.posMatrix, 0, a4.X, 0, a4.X, 0, 1), a4.J(le.posMatrix, le.posMatrix, [Xe * Tt, ot * Tt, 0]), a4.K(le.posMatrix, le.posMatrix, [1 / 2 ** qe, 1 / 2 ** qe, 0]), B4[Q] = le;\n                      }\n                    }\n                    return B4;\n                  }\n                  getSourceTile(w4, B4) {\n                    let Q = this.sourceCache._source, ee = w4.overscaledZ - this.deltaZoom;\n                    if (ee > Q.maxzoom && (ee = Q.maxzoom), ee < Q.minzoom) return null;\n                    this._sourceTileCache[w4.key] || (this._sourceTileCache[w4.key] = w4.scaledTo(ee).key);\n                    let le = this.sourceCache.getTileByID(this._sourceTileCache[w4.key]);\n                    if ((!le || !le.dem) && B4) for (; ee >= Q.minzoom && (!le || !le.dem); ) le = this.sourceCache.getTileByID(w4.scaledTo(ee--).key);\n                    return le;\n                  }\n                  tilesAfterTime(w4 = Date.now()) {\n                    return Object.values(this._tiles).filter((B4) => B4.timeAdded >= w4);\n                  }\n                }\n                class Xo {\n                  constructor(w4, B4, Q) {\n                    this.painter = w4, this.sourceCache = new bo(B4), this.options = Q, this.exaggeration = typeof Q.exaggeration == "number" ? Q.exaggeration : 1, this.qualityFactor = 2, this.meshSize = 128, this._demMatrixCache = {}, this.coordsIndex = [], this._coordsTextureSize = 1024;\n                  }\n                  getDEMElevation(w4, B4, Q, ee = a4.X) {\n                    var le;\n                    if (!(B4 >= 0 && B4 < ee && Q >= 0 && Q < ee)) return 0;\n                    let qe = this.getTerrainData(w4), Xe = (le = qe.tile) === null || le === void 0 ? void 0 : le.dem;\n                    if (!Xe) return 0;\n                    let ot = (function(ve, be, De) {\n                      var Be = be[0], et = be[1];\n                      return ve[0] = De[0] * Be + De[4] * et + De[12], ve[1] = De[1] * Be + De[5] * et + De[13], ve;\n                    })([], [B4 / ee * a4.X, Q / ee * a4.X], qe.u_terrain_matrix), Tt = [ot[0] * Xe.dim, ot[1] * Xe.dim], Yt = Math.floor(Tt[0]), Kt = Math.floor(Tt[1]), xr = Tt[0] - Yt, Ir = Tt[1] - Kt;\n                    return Xe.get(Yt, Kt) * (1 - xr) * (1 - Ir) + Xe.get(Yt + 1, Kt) * xr * (1 - Ir) + Xe.get(Yt, Kt + 1) * (1 - xr) * Ir + Xe.get(Yt + 1, Kt + 1) * xr * Ir;\n                  }\n                  getElevationForLngLatZoom(w4, B4) {\n                    if (!a4.bb(B4, w4.wrap())) return 0;\n                    let { tileID: Q, mercatorX: ee, mercatorY: le } = this._getOverscaledTileIDFromLngLatZoom(w4, B4);\n                    return this.getElevation(Q, ee % a4.X, le % a4.X, a4.X);\n                  }\n                  getElevation(w4, B4, Q, ee = a4.X) {\n                    return this.getDEMElevation(w4, B4, Q, ee) * this.exaggeration;\n                  }\n                  getTerrainData(w4) {\n                    if (!this._emptyDemTexture) {\n                      let ee = this.painter.context, le = new a4.R({ width: 1, height: 1 }, new Uint8Array(4));\n                      this._emptyDepthTexture = new g3(ee, le, ee.gl.RGBA, { premultiply: false }), this._emptyDemUnpack = [0, 0, 0, 0], this._emptyDemTexture = new g3(ee, new a4.R({ width: 1, height: 1 }), ee.gl.RGBA, { premultiply: false }), this._emptyDemTexture.bind(ee.gl.NEAREST, ee.gl.CLAMP_TO_EDGE), this._emptyDemMatrix = a4.an([]);\n                    }\n                    let B4 = this.sourceCache.getSourceTile(w4, true);\n                    if (B4 && B4.dem && (!B4.demTexture || B4.needsTerrainPrepare)) {\n                      let ee = this.painter.context;\n                      B4.demTexture = this.painter.getTileTexture(B4.dem.stride), B4.demTexture ? B4.demTexture.update(B4.dem.getPixels(), { premultiply: false }) : B4.demTexture = new g3(ee, B4.dem.getPixels(), ee.gl.RGBA, { premultiply: false }), B4.demTexture.bind(ee.gl.NEAREST, ee.gl.CLAMP_TO_EDGE), B4.needsTerrainPrepare = false;\n                    }\n                    let Q = B4 && B4 + B4.tileID.key + w4.key;\n                    if (Q && !this._demMatrixCache[Q]) {\n                      let ee = this.sourceCache.sourceCache._source.maxzoom, le = w4.canonical.z - B4.tileID.canonical.z;\n                      w4.overscaledZ > w4.canonical.z && (w4.canonical.z >= ee ? le = w4.canonical.z - ee : a4.w("cannot calculate elevation if elevation maxzoom > source.maxzoom"));\n                      let qe = w4.canonical.x - (w4.canonical.x >> le << le), Xe = w4.canonical.y - (w4.canonical.y >> le << le), ot = a4.bc(new Float64Array(16), [1 / (a4.X << le), 1 / (a4.X << le), 0]);\n                      a4.J(ot, ot, [qe * a4.X, Xe * a4.X, 0]), this._demMatrixCache[w4.key] = { matrix: ot, coord: w4 };\n                    }\n                    return { u_depth: 2, u_terrain: 3, u_terrain_dim: B4 && B4.dem && B4.dem.dim || 1, u_terrain_matrix: Q ? this._demMatrixCache[w4.key].matrix : this._emptyDemMatrix, u_terrain_unpack: B4 && B4.dem && B4.dem.getUnpackVector() || this._emptyDemUnpack, u_terrain_exaggeration: this.exaggeration, texture: (B4 && B4.demTexture || this._emptyDemTexture).texture, depthTexture: (this._fboDepthTexture || this._emptyDepthTexture).texture, tile: B4 };\n                  }\n                  getFramebuffer(w4) {\n                    let B4 = this.painter, Q = B4.width / devicePixelRatio, ee = B4.height / devicePixelRatio;\n                    return !this._fbo || this._fbo.width === Q && this._fbo.height === ee || (this._fbo.destroy(), this._fboCoordsTexture.destroy(), this._fboDepthTexture.destroy(), delete this._fbo, delete this._fboDepthTexture, delete this._fboCoordsTexture), this._fboCoordsTexture || (this._fboCoordsTexture = new g3(B4.context, { width: Q, height: ee, data: null }, B4.context.gl.RGBA, { premultiply: false }), this._fboCoordsTexture.bind(B4.context.gl.NEAREST, B4.context.gl.CLAMP_TO_EDGE)), this._fboDepthTexture || (this._fboDepthTexture = new g3(B4.context, { width: Q, height: ee, data: null }, B4.context.gl.RGBA, { premultiply: false }), this._fboDepthTexture.bind(B4.context.gl.NEAREST, B4.context.gl.CLAMP_TO_EDGE)), this._fbo || (this._fbo = B4.context.createFramebuffer(Q, ee, true, false), this._fbo.depthAttachment.set(B4.context.createRenderbuffer(B4.context.gl.DEPTH_COMPONENT16, Q, ee))), this._fbo.colorAttachment.set(w4 === "coords" ? this._fboCoordsTexture.texture : this._fboDepthTexture.texture), this._fbo;\n                  }\n                  getCoordsTexture() {\n                    let w4 = this.painter.context;\n                    if (this._coordsTexture) return this._coordsTexture;\n                    let B4 = new Uint8Array(this._coordsTextureSize * this._coordsTextureSize * 4);\n                    for (let le = 0, qe = 0; le < this._coordsTextureSize; le++) for (let Xe = 0; Xe < this._coordsTextureSize; Xe++, qe += 4) B4[qe + 0] = 255 & Xe, B4[qe + 1] = 255 & le, B4[qe + 2] = Xe >> 8 << 4 | le >> 8, B4[qe + 3] = 0;\n                    let Q = new a4.R({ width: this._coordsTextureSize, height: this._coordsTextureSize }, new Uint8Array(B4.buffer)), ee = new g3(w4, Q, w4.gl.RGBA, { premultiply: false });\n                    return ee.bind(w4.gl.NEAREST, w4.gl.CLAMP_TO_EDGE), this._coordsTexture = ee, ee;\n                  }\n                  pointCoordinate(w4) {\n                    this.painter.maybeDrawDepthAndCoords(true);\n                    let B4 = new Uint8Array(4), Q = this.painter.context, ee = Q.gl, le = Math.round(w4.x * this.painter.pixelRatio / devicePixelRatio), qe = Math.round(w4.y * this.painter.pixelRatio / devicePixelRatio), Xe = Math.round(this.painter.height / devicePixelRatio);\n                    Q.bindFramebuffer.set(this.getFramebuffer("coords").framebuffer), ee.readPixels(le, Xe - qe - 1, 1, 1, ee.RGBA, ee.UNSIGNED_BYTE, B4), Q.bindFramebuffer.set(null);\n                    let ot = B4[0] + (B4[2] >> 4 << 8), Tt = B4[1] + ((15 & B4[2]) << 8), Yt = this.coordsIndex[255 - B4[3]], Kt = Yt && this.sourceCache.getTileByID(Yt);\n                    if (!Kt) return null;\n                    let xr = this._coordsTextureSize, Ir = (1 << Kt.tileID.canonical.z) * xr;\n                    return new a4.Z((Kt.tileID.canonical.x * xr + ot) / Ir + Kt.tileID.wrap, (Kt.tileID.canonical.y * xr + Tt) / Ir, this.getElevation(Kt.tileID, ot, Tt, xr));\n                  }\n                  depthAtPoint(w4) {\n                    let B4 = new Uint8Array(4), Q = this.painter.context, ee = Q.gl;\n                    return Q.bindFramebuffer.set(this.getFramebuffer("depth").framebuffer), ee.readPixels(w4.x, this.painter.height / devicePixelRatio - w4.y - 1, 1, 1, ee.RGBA, ee.UNSIGNED_BYTE, B4), Q.bindFramebuffer.set(null), (B4[0] / 16777216 + B4[1] / 65536 + B4[2] / 256 + B4[3]) / 256;\n                  }\n                  getTerrainMesh() {\n                    if (this._mesh) return this._mesh;\n                    let w4 = this.painter.context, B4 = new a4.bd(), Q = new a4.aY(), ee = this.meshSize, le = a4.X / ee, qe = ee * ee;\n                    for (let Kt = 0; Kt <= ee; Kt++) for (let xr = 0; xr <= ee; xr++) B4.emplaceBack(xr * le, Kt * le, 0);\n                    for (let Kt = 0; Kt < qe; Kt += ee + 1) for (let xr = 0; xr < ee; xr++) Q.emplaceBack(xr + Kt, ee + xr + Kt + 1, ee + xr + Kt + 2), Q.emplaceBack(xr + Kt, ee + xr + Kt + 2, xr + Kt + 1);\n                    let Xe = B4.length, ot = Xe + 2 * (ee + 1);\n                    for (let Kt of [0, 1]) for (let xr = 0; xr <= ee; xr++) for (let Ir of [0, 1]) B4.emplaceBack(xr * le, Kt * a4.X, Ir);\n                    for (let Kt = 0; Kt < 2 * ee; Kt += 2) Q.emplaceBack(ot + Kt, ot + Kt + 1, ot + Kt + 3), Q.emplaceBack(ot + Kt, ot + Kt + 3, ot + Kt + 2), Q.emplaceBack(Xe + Kt, Xe + Kt + 3, Xe + Kt + 1), Q.emplaceBack(Xe + Kt, Xe + Kt + 2, Xe + Kt + 3);\n                    let Tt = B4.length, Yt = Tt + 2 * (ee + 1);\n                    for (let Kt of [0, 1]) for (let xr = 0; xr <= ee; xr++) for (let Ir of [0, 1]) B4.emplaceBack(Kt * a4.X, xr * le, Ir);\n                    for (let Kt = 0; Kt < 2 * ee; Kt += 2) Q.emplaceBack(Tt + Kt, Tt + Kt + 1, Tt + Kt + 3), Q.emplaceBack(Tt + Kt, Tt + Kt + 3, Tt + Kt + 2), Q.emplaceBack(Yt + Kt, Yt + Kt + 3, Yt + Kt + 1), Q.emplaceBack(Yt + Kt, Yt + Kt + 2, Yt + Kt + 3);\n                    return this._mesh = new Eu(w4.createVertexBuffer(B4, Ka.members), w4.createIndexBuffer(Q), a4.a0.simpleSegment(0, 0, B4.length, Q.length)), this._mesh;\n                  }\n                  getMeshFrameDelta(w4) {\n                    return 2 * Math.PI * a4.be / Math.pow(2, w4) / 5;\n                  }\n                  getMinTileElevationForLngLatZoom(w4, B4) {\n                    var Q;\n                    let { tileID: ee } = this._getOverscaledTileIDFromLngLatZoom(w4, B4);\n                    return (Q = this.getMinMaxElevation(ee).minElevation) !== null && Q !== void 0 ? Q : 0;\n                  }\n                  getMinMaxElevation(w4) {\n                    let B4 = this.getTerrainData(w4).tile, Q = { minElevation: null, maxElevation: null };\n                    return B4 && B4.dem && (Q.minElevation = B4.dem.min * this.exaggeration, Q.maxElevation = B4.dem.max * this.exaggeration), Q;\n                  }\n                  _getOverscaledTileIDFromLngLatZoom(w4, B4) {\n                    let Q = a4.Z.fromLngLat(w4.wrap()), ee = (1 << B4) * a4.X, le = Q.x * ee, qe = Q.y * ee, Xe = Math.floor(le / a4.X), ot = Math.floor(qe / a4.X);\n                    return { tileID: new a4.S(B4, 0, B4, Xe, ot), mercatorX: le, mercatorY: qe };\n                  }\n                }\n                class Ss {\n                  constructor(w4, B4, Q) {\n                    this._context = w4, this._size = B4, this._tileSize = Q, this._objects = [], this._recentlyUsed = [], this._stamp = 0;\n                  }\n                  destruct() {\n                    for (let w4 of this._objects) w4.texture.destroy(), w4.fbo.destroy();\n                  }\n                  _createObject(w4) {\n                    let B4 = this._context.createFramebuffer(this._tileSize, this._tileSize, true, true), Q = new g3(this._context, { width: this._tileSize, height: this._tileSize, data: null }, this._context.gl.RGBA);\n                    return Q.bind(this._context.gl.LINEAR, this._context.gl.CLAMP_TO_EDGE), B4.depthAttachment.set(this._context.createRenderbuffer(this._context.gl.DEPTH_STENCIL, this._tileSize, this._tileSize)), B4.colorAttachment.set(Q.texture), { id: w4, fbo: B4, texture: Q, stamp: -1, inUse: false };\n                  }\n                  getObjectForId(w4) {\n                    return this._objects[w4];\n                  }\n                  useObject(w4) {\n                    w4.inUse = true, this._recentlyUsed = this._recentlyUsed.filter((B4) => w4.id !== B4), this._recentlyUsed.push(w4.id);\n                  }\n                  stampObject(w4) {\n                    w4.stamp = ++this._stamp;\n                  }\n                  getOrCreateFreeObject() {\n                    for (let B4 of this._recentlyUsed) if (!this._objects[B4].inUse) return this._objects[B4];\n                    if (this._objects.length >= this._size) throw new Error("No free RenderPool available, call freeAllObjects() required!");\n                    let w4 = this._createObject(this._objects.length);\n                    return this._objects.push(w4), w4;\n                  }\n                  freeObject(w4) {\n                    w4.inUse = false;\n                  }\n                  freeAllObjects() {\n                    for (let w4 of this._objects) this.freeObject(w4);\n                  }\n                  isFull() {\n                    return !(this._objects.length < this._size) && this._objects.some((w4) => !w4.inUse) === false;\n                  }\n                }\n                let as = { background: true, fill: true, line: true, raster: true, hillshade: true };\n                class ws {\n                  constructor(w4, B4) {\n                    this.painter = w4, this.terrain = B4, this.pool = new Ss(w4.context, 30, B4.sourceCache.tileSize * B4.qualityFactor);\n                  }\n                  destruct() {\n                    this.pool.destruct();\n                  }\n                  getTexture(w4) {\n                    return this.pool.getObjectForId(w4.rtt[this._stacks.length - 1].id).texture;\n                  }\n                  prepareForRender(w4, B4) {\n                    this._stacks = [], this._prevType = null, this._rttTiles = [], this._renderableTiles = this.terrain.sourceCache.getRenderableTiles(), this._renderableLayerIds = w4._order.filter((Q) => !w4._layers[Q].isHidden(B4)), this._coordsDescendingInv = {};\n                    for (let Q in w4.sourceCaches) {\n                      this._coordsDescendingInv[Q] = {};\n                      let ee = w4.sourceCaches[Q].getVisibleCoordinates();\n                      for (let le of ee) {\n                        let qe = this.terrain.sourceCache.getTerrainCoords(le);\n                        for (let Xe in qe) this._coordsDescendingInv[Q][Xe] || (this._coordsDescendingInv[Q][Xe] = []), this._coordsDescendingInv[Q][Xe].push(qe[Xe]);\n                      }\n                    }\n                    this._coordsDescendingInvStr = {};\n                    for (let Q of w4._order) {\n                      let ee = w4._layers[Q], le = ee.source;\n                      if (as[ee.type] && !this._coordsDescendingInvStr[le]) {\n                        this._coordsDescendingInvStr[le] = {};\n                        for (let qe in this._coordsDescendingInv[le]) this._coordsDescendingInvStr[le][qe] = this._coordsDescendingInv[le][qe].map((Xe) => Xe.key).sort().join();\n                      }\n                    }\n                    for (let Q of this._renderableTiles) for (let ee in this._coordsDescendingInvStr) {\n                      let le = this._coordsDescendingInvStr[ee][Q.tileID.key];\n                      le && le !== Q.rttCoords[ee] && (Q.rtt = []);\n                    }\n                  }\n                  renderLayer(w4) {\n                    if (w4.isHidden(this.painter.transform.zoom)) return false;\n                    let B4 = w4.type, Q = this.painter, ee = this._renderableLayerIds[this._renderableLayerIds.length - 1] === w4.id;\n                    if (as[B4] && (this._prevType && as[this._prevType] || this._stacks.push([]), this._prevType = B4, this._stacks[this._stacks.length - 1].push(w4.id), !ee)) return true;\n                    if (as[this._prevType] || as[B4] && ee) {\n                      this._prevType = B4;\n                      let le = this._stacks.length - 1, qe = this._stacks[le] || [];\n                      for (let Xe of this._renderableTiles) {\n                        if (this.pool.isFull() && (js(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects()), this._rttTiles.push(Xe), Xe.rtt[le]) {\n                          let Tt = this.pool.getObjectForId(Xe.rtt[le].id);\n                          if (Tt.stamp === Xe.rtt[le].stamp) {\n                            this.pool.useObject(Tt);\n                            continue;\n                          }\n                        }\n                        let ot = this.pool.getOrCreateFreeObject();\n                        this.pool.useObject(ot), this.pool.stampObject(ot), Xe.rtt[le] = { id: ot.id, stamp: ot.stamp }, Q.context.bindFramebuffer.set(ot.fbo.framebuffer), Q.context.clear({ color: a4.aM.transparent, stencil: 0 }), Q.currentStencilSource = void 0;\n                        for (let Tt = 0; Tt < qe.length; Tt++) {\n                          let Yt = Q.style._layers[qe[Tt]], Kt = Yt.source ? this._coordsDescendingInv[Yt.source][Xe.tileID.key] : [Xe.tileID];\n                          Q.context.viewport.set([0, 0, ot.fbo.width, ot.fbo.height]), Q._renderTileClippingMasks(Yt, Kt), Q.renderLayer(Q, Q.style.sourceCaches[Yt.source], Yt, Kt), Yt.source && (Xe.rttCoords[Yt.source] = this._coordsDescendingInvStr[Yt.source][Xe.tileID.key]);\n                        }\n                      }\n                      return js(this.painter, this.terrain, this._rttTiles), this._rttTiles = [], this.pool.freeAllObjects(), as[B4];\n                    }\n                    return false;\n                  }\n                }\n                let Ho = { "AttributionControl.ToggleAttribution": "Toggle attribution", "AttributionControl.MapFeedback": "Map feedback", "FullscreenControl.Enter": "Enter fullscreen", "FullscreenControl.Exit": "Exit fullscreen", "GeolocateControl.FindMyLocation": "Find my location", "GeolocateControl.LocationNotAvailable": "Location not available", "LogoControl.Title": "MapLibre logo", "Map.Title": "Map", "Marker.Title": "Map marker", "NavigationControl.ResetBearing": "Reset bearing to north", "NavigationControl.ZoomIn": "Zoom in", "NavigationControl.ZoomOut": "Zoom out", "Popup.Close": "Close popup", "ScaleControl.Feet": "ft", "ScaleControl.Meters": "m", "ScaleControl.Kilometers": "km", "ScaleControl.Miles": "mi", "ScaleControl.NauticalMiles": "nm", "TerrainControl.Enable": "Enable terrain", "TerrainControl.Disable": "Disable terrain", "CooperativeGesturesHandler.WindowsHelpText": "Use Ctrl + scroll to zoom the map", "CooperativeGesturesHandler.MacHelpText": "Use \\u2318 + scroll to zoom the map", "CooperativeGesturesHandler.MobileHelpText": "Use two fingers to move the map" }, ml = o4, Ws = { hash: false, interactive: true, bearingSnap: 7, attributionControl: La, maplibreLogo: false, failIfMajorPerformanceCaveat: false, preserveDrawingBuffer: false, refreshExpiredTiles: true, scrollZoom: true, minZoom: -2, maxZoom: 22, minPitch: 0, maxPitch: 60, boxZoom: true, dragRotate: true, dragPan: true, keyboard: true, doubleClickZoom: true, touchZoomRotate: true, touchPitch: true, cooperativeGestures: false, trackResize: true, center: [0, 0], zoom: 0, bearing: 0, pitch: 0, renderWorldCopies: true, maxTileCacheSize: null, maxTileCacheZoomLevels: a4.a.MAX_TILE_CACHE_ZOOM_LEVELS, transformRequest: null, transformCameraUpdate: null, fadeDuration: 300, crossSourceCollisions: true, clickTolerance: 3, localIdeographFontFamily: "sans-serif", pitchWithRotate: true, validateStyle: true, maxCanvasSize: [4096, 4096], cancelPendingTileRequestsWhileZooming: true }, Ls = (ue) => {\n                  ue.touchstart = ue.dragStart, ue.touchmoveWindow = ue.dragMove, ue.touchend = ue.dragEnd;\n                }, va = { showCompass: true, showZoom: true, visualizePitch: false };\n                class no {\n                  constructor(w4, B4, Q = false) {\n                    this.mousedown = (qe) => {\n                      this.startMouse(a4.e({}, qe, { ctrlKey: true, preventDefault: () => qe.preventDefault() }), c5.mousePos(this.element, qe)), c5.addEventListener(window, "mousemove", this.mousemove), c5.addEventListener(window, "mouseup", this.mouseup);\n                    }, this.mousemove = (qe) => {\n                      this.moveMouse(qe, c5.mousePos(this.element, qe));\n                    }, this.mouseup = (qe) => {\n                      this.mouseRotate.dragEnd(qe), this.mousePitch && this.mousePitch.dragEnd(qe), this.offTemp();\n                    }, this.touchstart = (qe) => {\n                      qe.targetTouches.length !== 1 ? this.reset() : (this._startPos = this._lastPos = c5.touchPos(this.element, qe.targetTouches)[0], this.startTouch(qe, this._startPos), c5.addEventListener(window, "touchmove", this.touchmove, { passive: false }), c5.addEventListener(window, "touchend", this.touchend));\n                    }, this.touchmove = (qe) => {\n                      qe.targetTouches.length !== 1 ? this.reset() : (this._lastPos = c5.touchPos(this.element, qe.targetTouches)[0], this.moveTouch(qe, this._lastPos));\n                    }, this.touchend = (qe) => {\n                      qe.targetTouches.length === 0 && this._startPos && this._lastPos && this._startPos.dist(this._lastPos) < this._clickTolerance && this.element.click(), delete this._startPos, delete this._lastPos, this.offTemp();\n                    }, this.reset = () => {\n                      this.mouseRotate.reset(), this.mousePitch && this.mousePitch.reset(), this.touchRotate.reset(), this.touchPitch && this.touchPitch.reset(), delete this._startPos, delete this._lastPos, this.offTemp();\n                    }, this._clickTolerance = 10;\n                    let ee = w4.dragRotate._mouseRotate.getClickTolerance(), le = w4.dragRotate._mousePitch.getClickTolerance();\n                    this.element = B4, this.mouseRotate = Wl({ clickTolerance: ee, enable: true }), this.touchRotate = (({ enable: qe, clickTolerance: Xe, bearingDegreesPerPixelMoved: ot = 0.8 }) => {\n                      let Tt = new uf();\n                      return new Wu({ clickTolerance: Xe, move: (Yt, Kt) => ({ bearingDelta: (Kt.x - Yt.x) * ot }), moveStateManager: Tt, enable: qe, assignEvents: Ls });\n                    })({ clickTolerance: ee, enable: true }), this.map = w4, Q && (this.mousePitch = ah({ clickTolerance: le, enable: true }), this.touchPitch = (({ enable: qe, clickTolerance: Xe, pitchDegreesPerPixelMoved: ot = -0.5 }) => {\n                      let Tt = new uf();\n                      return new Wu({ clickTolerance: Xe, move: (Yt, Kt) => ({ pitchDelta: (Kt.y - Yt.y) * ot }), moveStateManager: Tt, enable: qe, assignEvents: Ls });\n                    })({ clickTolerance: le, enable: true })), c5.addEventListener(B4, "mousedown", this.mousedown), c5.addEventListener(B4, "touchstart", this.touchstart, { passive: false }), c5.addEventListener(B4, "touchcancel", this.reset);\n                  }\n                  startMouse(w4, B4) {\n                    this.mouseRotate.dragStart(w4, B4), this.mousePitch && this.mousePitch.dragStart(w4, B4), c5.disableDrag();\n                  }\n                  startTouch(w4, B4) {\n                    this.touchRotate.dragStart(w4, B4), this.touchPitch && this.touchPitch.dragStart(w4, B4), c5.disableDrag();\n                  }\n                  moveMouse(w4, B4) {\n                    let Q = this.map, { bearingDelta: ee } = this.mouseRotate.dragMove(w4, B4) || {};\n                    if (ee && Q.setBearing(Q.getBearing() + ee), this.mousePitch) {\n                      let { pitchDelta: le } = this.mousePitch.dragMove(w4, B4) || {};\n                      le && Q.setPitch(Q.getPitch() + le);\n                    }\n                  }\n                  moveTouch(w4, B4) {\n                    let Q = this.map, { bearingDelta: ee } = this.touchRotate.dragMove(w4, B4) || {};\n                    if (ee && Q.setBearing(Q.getBearing() + ee), this.touchPitch) {\n                      let { pitchDelta: le } = this.touchPitch.dragMove(w4, B4) || {};\n                      le && Q.setPitch(Q.getPitch() + le);\n                    }\n                  }\n                  off() {\n                    let w4 = this.element;\n                    c5.removeEventListener(w4, "mousedown", this.mousedown), c5.removeEventListener(w4, "touchstart", this.touchstart, { passive: false }), c5.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), c5.removeEventListener(window, "touchend", this.touchend), c5.removeEventListener(w4, "touchcancel", this.reset), this.offTemp();\n                  }\n                  offTemp() {\n                    c5.enableDrag(), c5.removeEventListener(window, "mousemove", this.mousemove), c5.removeEventListener(window, "mouseup", this.mouseup), c5.removeEventListener(window, "touchmove", this.touchmove, { passive: false }), c5.removeEventListener(window, "touchend", this.touchend);\n                  }\n                }\n                let ys;\n                function rs(ue, w4, B4) {\n                  let Q = new a4.N(ue.lng, ue.lat);\n                  if (ue = new a4.N(ue.lng, ue.lat), w4) {\n                    let ee = new a4.N(ue.lng - 360, ue.lat), le = new a4.N(ue.lng + 360, ue.lat), qe = B4.locationPoint(ue).distSqr(w4);\n                    B4.locationPoint(ee).distSqr(w4) < qe ? ue = ee : B4.locationPoint(le).distSqr(w4) < qe && (ue = le);\n                  }\n                  for (; Math.abs(ue.lng - B4.center.lng) > 180; ) {\n                    let ee = B4.locationPoint(ue);\n                    if (ee.x >= 0 && ee.y >= 0 && ee.x <= B4.width && ee.y <= B4.height) break;\n                    ue.lng > B4.center.lng ? ue.lng -= 360 : ue.lng += 360;\n                  }\n                  return ue.lng !== Q.lng && B4.locationPoint(ue).y > B4.height / 2 - B4.getHorizon() ? ue : Q;\n                }\n                let $l = { center: "translate(-50%,-50%)", top: "translate(-50%,0)", "top-left": "translate(0,0)", "top-right": "translate(-100%,0)", bottom: "translate(-50%,-100%)", "bottom-left": "translate(0,-100%)", "bottom-right": "translate(-100%,-100%)", left: "translate(0,-50%)", right: "translate(-100%,-50%)" };\n                function Cu(ue, w4, B4) {\n                  let Q = ue.classList;\n                  for (let ee in $l) Q.remove(`maplibregl-${B4}-anchor-${ee}`);\n                  Q.add(`maplibregl-${B4}-anchor-${w4}`);\n                }\n                class Yu extends a4.E {\n                  constructor(w4) {\n                    if (super(), this._onKeyPress = (B4) => {\n                      let Q = B4.code, ee = B4.charCode || B4.keyCode;\n                      Q !== "Space" && Q !== "Enter" && ee !== 32 && ee !== 13 || this.togglePopup();\n                    }, this._onMapClick = (B4) => {\n                      let Q = B4.originalEvent.target, ee = this._element;\n                      this._popup && (Q === ee || ee.contains(Q)) && this.togglePopup();\n                    }, this._update = (B4) => {\n                      var Q;\n                      if (!this._map) return;\n                      let ee = this._map.loaded() && !this._map.isMoving();\n                      ((B4 == null ? void 0 : B4.type) === "terrain" || (B4 == null ? void 0 : B4.type) === "render" && !ee) && this._map.once("render", this._update), this._lngLat = this._map.transform.renderWorldCopies ? rs(this._lngLat, this._flatPos, this._map.transform) : (Q = this._lngLat) === null || Q === void 0 ? void 0 : Q.wrap(), this._flatPos = this._pos = this._map.project(this._lngLat)._add(this._offset), this._map.terrain && (this._flatPos = this._map.transform.locationPoint(this._lngLat)._add(this._offset));\n                      let le = "";\n                      this._rotationAlignment === "viewport" || this._rotationAlignment === "auto" ? le = `rotateZ(${this._rotation}deg)` : this._rotationAlignment === "map" && (le = `rotateZ(${this._rotation - this._map.getBearing()}deg)`);\n                      let qe = "";\n                      this._pitchAlignment === "viewport" || this._pitchAlignment === "auto" ? qe = "rotateX(0deg)" : this._pitchAlignment === "map" && (qe = `rotateX(${this._map.getPitch()}deg)`), this._subpixelPositioning || B4 && B4.type !== "moveend" || (this._pos = this._pos.round()), c5.setTransform(this._element, `${$l[this._anchor]} translate(${this._pos.x}px, ${this._pos.y}px) ${qe} ${le}`), u4.frameAsync(new AbortController()).then(() => {\n                        this._updateOpacity(B4 && B4.type === "moveend");\n                      }).catch(() => {\n                      });\n                    }, this._onMove = (B4) => {\n                      if (!this._isDragging) {\n                        let Q = this._clickTolerance || this._map._clickTolerance;\n                        this._isDragging = B4.point.dist(this._pointerdownPos) >= Q;\n                      }\n                      this._isDragging && (this._pos = B4.point.sub(this._positionDelta), this._lngLat = this._map.unproject(this._pos), this.setLngLat(this._lngLat), this._element.style.pointerEvents = "none", this._state === "pending" && (this._state = "active", this.fire(new a4.k("dragstart"))), this.fire(new a4.k("drag")));\n                    }, this._onUp = () => {\n                      this._element.style.pointerEvents = "auto", this._positionDelta = null, this._pointerdownPos = null, this._isDragging = false, this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), this._state === "active" && this.fire(new a4.k("dragend")), this._state = "inactive";\n                    }, this._addDragHandler = (B4) => {\n                      this._element.contains(B4.originalEvent.target) && (B4.preventDefault(), this._positionDelta = B4.point.sub(this._pos).add(this._offset), this._pointerdownPos = B4.point, this._state = "pending", this._map.on("mousemove", this._onMove), this._map.on("touchmove", this._onMove), this._map.once("mouseup", this._onUp), this._map.once("touchend", this._onUp));\n                    }, this._anchor = w4 && w4.anchor || "center", this._color = w4 && w4.color || "#3FB1CE", this._scale = w4 && w4.scale || 1, this._draggable = w4 && w4.draggable || false, this._clickTolerance = w4 && w4.clickTolerance || 0, this._subpixelPositioning = w4 && w4.subpixelPositioning || false, this._isDragging = false, this._state = "inactive", this._rotation = w4 && w4.rotation || 0, this._rotationAlignment = w4 && w4.rotationAlignment || "auto", this._pitchAlignment = w4 && w4.pitchAlignment && w4.pitchAlignment !== "auto" ? w4.pitchAlignment : this._rotationAlignment, this.setOpacity(), this.setOpacity(w4 == null ? void 0 : w4.opacity, w4 == null ? void 0 : w4.opacityWhenCovered), w4 && w4.element) this._element = w4.element, this._offset = a4.P.convert(w4 && w4.offset || [0, 0]);\n                    else {\n                      this._defaultMarker = true, this._element = c5.create("div");\n                      let B4 = c5.createNS("http://www.w3.org/2000/svg", "svg"), Q = 41, ee = 27;\n                      B4.setAttributeNS(null, "display", "block"), B4.setAttributeNS(null, "height", `${Q}px`), B4.setAttributeNS(null, "width", `${ee}px`), B4.setAttributeNS(null, "viewBox", `0 0 ${ee} ${Q}`);\n                      let le = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      le.setAttributeNS(null, "stroke", "none"), le.setAttributeNS(null, "stroke-width", "1"), le.setAttributeNS(null, "fill", "none"), le.setAttributeNS(null, "fill-rule", "evenodd");\n                      let qe = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      qe.setAttributeNS(null, "fill-rule", "nonzero");\n                      let Xe = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      Xe.setAttributeNS(null, "transform", "translate(3.0, 29.0)"), Xe.setAttributeNS(null, "fill", "#000000");\n                      let ot = [{ rx: "10.5", ry: "5.25002273" }, { rx: "10.5", ry: "5.25002273" }, { rx: "9.5", ry: "4.77275007" }, { rx: "8.5", ry: "4.29549936" }, { rx: "7.5", ry: "3.81822308" }, { rx: "6.5", ry: "3.34094679" }, { rx: "5.5", ry: "2.86367051" }, { rx: "4.5", ry: "2.38636864" }];\n                      for (let Be of ot) {\n                        let et = c5.createNS("http://www.w3.org/2000/svg", "ellipse");\n                        et.setAttributeNS(null, "opacity", "0.04"), et.setAttributeNS(null, "cx", "10.5"), et.setAttributeNS(null, "cy", "5.80029008"), et.setAttributeNS(null, "rx", Be.rx), et.setAttributeNS(null, "ry", Be.ry), Xe.appendChild(et);\n                      }\n                      let Tt = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      Tt.setAttributeNS(null, "fill", this._color);\n                      let Yt = c5.createNS("http://www.w3.org/2000/svg", "path");\n                      Yt.setAttributeNS(null, "d", "M27,13.5 C27,19.074644 20.250001,27.000002 14.75,34.500002 C14.016665,35.500004 12.983335,35.500004 12.25,34.500002 C6.7499993,27.000002 0,19.222562 0,13.5 C0,6.0441559 6.0441559,0 13.5,0 C20.955844,0 27,6.0441559 27,13.5 Z"), Tt.appendChild(Yt);\n                      let Kt = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      Kt.setAttributeNS(null, "opacity", "0.25"), Kt.setAttributeNS(null, "fill", "#000000");\n                      let xr = c5.createNS("http://www.w3.org/2000/svg", "path");\n                      xr.setAttributeNS(null, "d", "M13.5,0 C6.0441559,0 0,6.0441559 0,13.5 C0,19.222562 6.7499993,27 12.25,34.5 C13,35.522727 14.016664,35.500004 14.75,34.5 C20.250001,27 27,19.074644 27,13.5 C27,6.0441559 20.955844,0 13.5,0 Z M13.5,1 C20.415404,1 26,6.584596 26,13.5 C26,15.898657 24.495584,19.181431 22.220703,22.738281 C19.945823,26.295132 16.705119,30.142167 13.943359,33.908203 C13.743445,34.180814 13.612715,34.322738 13.5,34.441406 C13.387285,34.322738 13.256555,34.180814 13.056641,33.908203 C10.284481,30.127985 7.4148684,26.314159 5.015625,22.773438 C2.6163816,19.232715 1,15.953538 1,13.5 C1,6.584596 6.584596,1 13.5,1 Z"), Kt.appendChild(xr);\n                      let Ir = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      Ir.setAttributeNS(null, "transform", "translate(6.0, 7.0)"), Ir.setAttributeNS(null, "fill", "#FFFFFF");\n                      let ve = c5.createNS("http://www.w3.org/2000/svg", "g");\n                      ve.setAttributeNS(null, "transform", "translate(8.0, 8.0)");\n                      let be = c5.createNS("http://www.w3.org/2000/svg", "circle");\n                      be.setAttributeNS(null, "fill", "#000000"), be.setAttributeNS(null, "opacity", "0.25"), be.setAttributeNS(null, "cx", "5.5"), be.setAttributeNS(null, "cy", "5.5"), be.setAttributeNS(null, "r", "5.4999962");\n                      let De = c5.createNS("http://www.w3.org/2000/svg", "circle");\n                      De.setAttributeNS(null, "fill", "#FFFFFF"), De.setAttributeNS(null, "cx", "5.5"), De.setAttributeNS(null, "cy", "5.5"), De.setAttributeNS(null, "r", "5.4999962"), ve.appendChild(be), ve.appendChild(De), qe.appendChild(Xe), qe.appendChild(Tt), qe.appendChild(Kt), qe.appendChild(Ir), qe.appendChild(ve), B4.appendChild(qe), B4.setAttributeNS(null, "height", Q * this._scale + "px"), B4.setAttributeNS(null, "width", ee * this._scale + "px"), this._element.appendChild(B4), this._offset = a4.P.convert(w4 && w4.offset || [0, -14]);\n                    }\n                    if (this._element.classList.add("maplibregl-marker"), this._element.addEventListener("dragstart", (B4) => {\n                      B4.preventDefault();\n                    }), this._element.addEventListener("mousedown", (B4) => {\n                      B4.preventDefault();\n                    }), Cu(this._element, this._anchor, "marker"), w4 && w4.className) for (let B4 of w4.className.split(" ")) this._element.classList.add(B4);\n                    this._popup = null;\n                  }\n                  addTo(w4) {\n                    return this.remove(), this._map = w4, this._element.setAttribute("aria-label", w4._getUIString("Marker.Title")), w4.getCanvasContainer().appendChild(this._element), w4.on("move", this._update), w4.on("moveend", this._update), w4.on("terrain", this._update), this.setDraggable(this._draggable), this._update(), this._map.on("click", this._onMapClick), this;\n                  }\n                  remove() {\n                    return this._opacityTimeout && (clearTimeout(this._opacityTimeout), delete this._opacityTimeout), this._map && (this._map.off("click", this._onMapClick), this._map.off("move", this._update), this._map.off("moveend", this._update), this._map.off("terrain", this._update), this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler), this._map.off("mouseup", this._onUp), this._map.off("touchend", this._onUp), this._map.off("mousemove", this._onMove), this._map.off("touchmove", this._onMove), delete this._map), c5.remove(this._element), this._popup && this._popup.remove(), this;\n                  }\n                  getLngLat() {\n                    return this._lngLat;\n                  }\n                  setLngLat(w4) {\n                    return this._lngLat = a4.N.convert(w4), this._pos = null, this._popup && this._popup.setLngLat(this._lngLat), this._update(), this;\n                  }\n                  getElement() {\n                    return this._element;\n                  }\n                  setPopup(w4) {\n                    if (this._popup && (this._popup.remove(), this._popup = null, this._element.removeEventListener("keypress", this._onKeyPress), this._originalTabIndex || this._element.removeAttribute("tabindex")), w4) {\n                      if (!("offset" in w4.options)) {\n                        let ee = Math.abs(13.5) / Math.SQRT2;\n                        w4.options.offset = this._defaultMarker ? { top: [0, 0], "top-left": [0, 0], "top-right": [0, 0], bottom: [0, -38.1], "bottom-left": [ee, -1 * (38.1 - 13.5 + ee)], "bottom-right": [-ee, -1 * (38.1 - 13.5 + ee)], left: [13.5, -1 * (38.1 - 13.5)], right: [-13.5, -1 * (38.1 - 13.5)] } : this._offset;\n                      }\n                      this._popup = w4, this._originalTabIndex = this._element.getAttribute("tabindex"), this._originalTabIndex || this._element.setAttribute("tabindex", "0"), this._element.addEventListener("keypress", this._onKeyPress);\n                    }\n                    return this;\n                  }\n                  setSubpixelPositioning(w4) {\n                    return this._subpixelPositioning = w4, this;\n                  }\n                  getPopup() {\n                    return this._popup;\n                  }\n                  togglePopup() {\n                    let w4 = this._popup;\n                    return this._element.style.opacity === this._opacityWhenCovered ? this : w4 ? (w4.isOpen() ? w4.remove() : (w4.setLngLat(this._lngLat), w4.addTo(this._map)), this) : this;\n                  }\n                  _updateOpacity(w4 = false) {\n                    var B4, Q;\n                    if (!(!((B4 = this._map) === null || B4 === void 0) && B4.terrain)) return void (this._element.style.opacity !== this._opacity && (this._element.style.opacity = this._opacity));\n                    if (w4) this._opacityTimeout = null;\n                    else {\n                      if (this._opacityTimeout) return;\n                      this._opacityTimeout = setTimeout(() => {\n                        this._opacityTimeout = null;\n                      }, 100);\n                    }\n                    let ee = this._map, le = ee.terrain.depthAtPoint(this._pos), qe = ee.terrain.getElevationForLngLatZoom(this._lngLat, ee.transform.tileZoom);\n                    if (ee.transform.lngLatToCameraDepth(this._lngLat, qe) - le < 6e-3) return void (this._element.style.opacity = this._opacity);\n                    let Xe = -this._offset.y / ee.transform._pixelPerMeter, ot = Math.sin(ee.getPitch() * Math.PI / 180) * Xe, Tt = ee.terrain.depthAtPoint(new a4.P(this._pos.x, this._pos.y - this._offset.y)), Yt = ee.transform.lngLatToCameraDepth(this._lngLat, qe + ot) - Tt > 6e-3;\n                    !((Q = this._popup) === null || Q === void 0) && Q.isOpen() && Yt && this._popup.remove(), this._element.style.opacity = Yt ? this._opacityWhenCovered : this._opacity;\n                  }\n                  getOffset() {\n                    return this._offset;\n                  }\n                  setOffset(w4) {\n                    return this._offset = a4.P.convert(w4), this._update(), this;\n                  }\n                  addClassName(w4) {\n                    this._element.classList.add(w4);\n                  }\n                  removeClassName(w4) {\n                    this._element.classList.remove(w4);\n                  }\n                  toggleClassName(w4) {\n                    return this._element.classList.toggle(w4);\n                  }\n                  setDraggable(w4) {\n                    return this._draggable = !!w4, this._map && (w4 ? (this._map.on("mousedown", this._addDragHandler), this._map.on("touchstart", this._addDragHandler)) : (this._map.off("mousedown", this._addDragHandler), this._map.off("touchstart", this._addDragHandler))), this;\n                  }\n                  isDraggable() {\n                    return this._draggable;\n                  }\n                  setRotation(w4) {\n                    return this._rotation = w4 || 0, this._update(), this;\n                  }\n                  getRotation() {\n                    return this._rotation;\n                  }\n                  setRotationAlignment(w4) {\n                    return this._rotationAlignment = w4 || "auto", this._update(), this;\n                  }\n                  getRotationAlignment() {\n                    return this._rotationAlignment;\n                  }\n                  setPitchAlignment(w4) {\n                    return this._pitchAlignment = w4 && w4 !== "auto" ? w4 : this._rotationAlignment, this._update(), this;\n                  }\n                  getPitchAlignment() {\n                    return this._pitchAlignment;\n                  }\n                  setOpacity(w4, B4) {\n                    return w4 === void 0 && B4 === void 0 && (this._opacity = "1", this._opacityWhenCovered = "0.2"), w4 !== void 0 && (this._opacity = w4), B4 !== void 0 && (this._opacityWhenCovered = B4), this._map && this._updateOpacity(true), this;\n                  }\n                }\n                let Nc = { positionOptions: { enableHighAccuracy: false, maximumAge: 0, timeout: 6e3 }, fitBoundsOptions: { maxZoom: 15 }, trackUserLocation: false, showAccuracyCircle: true, showUserLocation: true }, pu = 0, Uc = false, xu = { maxWidth: 100, unit: "metric" };\n                function Ac(ue, w4, B4) {\n                  let Q = B4 && B4.maxWidth || 100, ee = ue._container.clientHeight / 2, le = ue.unproject([0, ee]), qe = ue.unproject([Q, ee]), Xe = le.distanceTo(qe);\n                  if (B4 && B4.unit === "imperial") {\n                    let ot = 3.2808 * Xe;\n                    ot > 5280 ? Ua(w4, Q, ot / 5280, ue._getUIString("ScaleControl.Miles")) : Ua(w4, Q, ot, ue._getUIString("ScaleControl.Feet"));\n                  } else B4 && B4.unit === "nautical" ? Ua(w4, Q, Xe / 1852, ue._getUIString("ScaleControl.NauticalMiles")) : Xe >= 1e3 ? Ua(w4, Q, Xe / 1e3, ue._getUIString("ScaleControl.Kilometers")) : Ua(w4, Q, Xe, ue._getUIString("ScaleControl.Meters"));\n                }\n                function Ua(ue, w4, B4, Q) {\n                  let ee = (function(le) {\n                    let qe = Math.pow(10, `${Math.floor(le)}`.length - 1), Xe = le / qe;\n                    return Xe = Xe >= 10 ? 10 : Xe >= 5 ? 5 : Xe >= 3 ? 3 : Xe >= 2 ? 2 : Xe >= 1 ? 1 : (function(ot) {\n                      let Tt = Math.pow(10, Math.ceil(-Math.log(ot) / Math.LN10));\n                      return Math.round(ot * Tt) / Tt;\n                    })(Xe), qe * Xe;\n                  })(B4);\n                  ue.style.width = w4 * (ee / B4) + "px", ue.innerHTML = `${ee}&nbsp;${Q}`;\n                }\n                let oo = { closeButton: true, closeOnClick: true, focusAfterOpen: true, className: "", maxWidth: "240px", subpixelPositioning: false }, Vc = ["a[href]", "[tabindex]:not([tabindex=\'-1\'])", "[contenteditable]:not([contenteditable=\'false\'])", "button:not([disabled])", "input:not([disabled])", "select:not([disabled])", "textarea:not([disabled])"].join(", ");\n                function hc(ue) {\n                  if (ue) {\n                    if (typeof ue == "number") {\n                      let w4 = Math.round(Math.abs(ue) / Math.SQRT2);\n                      return { center: new a4.P(0, 0), top: new a4.P(0, ue), "top-left": new a4.P(w4, w4), "top-right": new a4.P(-w4, w4), bottom: new a4.P(0, -ue), "bottom-left": new a4.P(w4, -w4), "bottom-right": new a4.P(-w4, -w4), left: new a4.P(ue, 0), right: new a4.P(-ue, 0) };\n                    }\n                    if (ue instanceof a4.P || Array.isArray(ue)) {\n                      let w4 = a4.P.convert(ue);\n                      return { center: w4, top: w4, "top-left": w4, "top-right": w4, bottom: w4, "bottom-left": w4, "bottom-right": w4, left: w4, right: w4 };\n                    }\n                    return { center: a4.P.convert(ue.center || [0, 0]), top: a4.P.convert(ue.top || [0, 0]), "top-left": a4.P.convert(ue["top-left"] || [0, 0]), "top-right": a4.P.convert(ue["top-right"] || [0, 0]), bottom: a4.P.convert(ue.bottom || [0, 0]), "bottom-left": a4.P.convert(ue["bottom-left"] || [0, 0]), "bottom-right": a4.P.convert(ue["bottom-right"] || [0, 0]), left: a4.P.convert(ue.left || [0, 0]), right: a4.P.convert(ue.right || [0, 0]) };\n                  }\n                  return hc(new a4.P(0, 0));\n                }\n                let Ku = o4;\n                i3.AJAXError = a4.bh, i3.Evented = a4.E, i3.LngLat = a4.N, i3.MercatorCoordinate = a4.Z, i3.Point = a4.P, i3.addProtocol = a4.bi, i3.config = a4.a, i3.removeProtocol = a4.bj, i3.AttributionControl = Na, i3.BoxZoomHandler = ku, i3.CanvasSource = Jt, i3.CooperativeGesturesHandler = Qi, i3.DoubleClickZoomHandler = ki, i3.DragPanHandler = wn, i3.DragRotateHandler = Nn, i3.EdgeInsets = hu, i3.FullscreenControl = class extends a4.E {\n                  constructor(ue = {}) {\n                    super(), this._onFullscreenChange = () => {\n                      var w4;\n                      let B4 = window.document.fullscreenElement || window.document.mozFullScreenElement || window.document.webkitFullscreenElement || window.document.msFullscreenElement;\n                      for (; !((w4 = B4 == null ? void 0 : B4.shadowRoot) === null || w4 === void 0) && w4.fullscreenElement; ) B4 = B4.shadowRoot.fullscreenElement;\n                      B4 === this._container !== this._fullscreen && this._handleFullscreenChange();\n                    }, this._onClickFullscreen = () => {\n                      this._isFullscreen() ? this._exitFullscreen() : this._requestFullscreen();\n                    }, this._fullscreen = false, ue && ue.container && (ue.container instanceof HTMLElement ? this._container = ue.container : a4.w("Full screen control \'container\' must be a DOM element.")), "onfullscreenchange" in document ? this._fullscreenchange = "fullscreenchange" : "onmozfullscreenchange" in document ? this._fullscreenchange = "mozfullscreenchange" : "onwebkitfullscreenchange" in document ? this._fullscreenchange = "webkitfullscreenchange" : "onmsfullscreenchange" in document && (this._fullscreenchange = "MSFullscreenChange");\n                  }\n                  onAdd(ue) {\n                    return this._map = ue, this._container || (this._container = this._map.getContainer()), this._controlContainer = c5.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), this._controlContainer;\n                  }\n                  onRemove() {\n                    c5.remove(this._controlContainer), this._map = null, window.document.removeEventListener(this._fullscreenchange, this._onFullscreenChange);\n                  }\n                  _setupUI() {\n                    let ue = this._fullscreenButton = c5.create("button", "maplibregl-ctrl-fullscreen", this._controlContainer);\n                    c5.create("span", "maplibregl-ctrl-icon", ue).setAttribute("aria-hidden", "true"), ue.type = "button", this._updateTitle(), this._fullscreenButton.addEventListener("click", this._onClickFullscreen), window.document.addEventListener(this._fullscreenchange, this._onFullscreenChange);\n                  }\n                  _updateTitle() {\n                    let ue = this._getTitle();\n                    this._fullscreenButton.setAttribute("aria-label", ue), this._fullscreenButton.title = ue;\n                  }\n                  _getTitle() {\n                    return this._map._getUIString(this._isFullscreen() ? "FullscreenControl.Exit" : "FullscreenControl.Enter");\n                  }\n                  _isFullscreen() {\n                    return this._fullscreen;\n                  }\n                  _handleFullscreenChange() {\n                    this._fullscreen = !this._fullscreen, this._fullscreenButton.classList.toggle("maplibregl-ctrl-shrink"), this._fullscreenButton.classList.toggle("maplibregl-ctrl-fullscreen"), this._updateTitle(), this._fullscreen ? (this.fire(new a4.k("fullscreenstart")), this._prevCooperativeGesturesEnabled = this._map.cooperativeGestures.isEnabled(), this._map.cooperativeGestures.disable()) : (this.fire(new a4.k("fullscreenend")), this._prevCooperativeGesturesEnabled && this._map.cooperativeGestures.enable());\n                  }\n                  _exitFullscreen() {\n                    window.document.exitFullscreen ? window.document.exitFullscreen() : window.document.mozCancelFullScreen ? window.document.mozCancelFullScreen() : window.document.msExitFullscreen ? window.document.msExitFullscreen() : window.document.webkitCancelFullScreen ? window.document.webkitCancelFullScreen() : this._togglePseudoFullScreen();\n                  }\n                  _requestFullscreen() {\n                    this._container.requestFullscreen ? this._container.requestFullscreen() : this._container.mozRequestFullScreen ? this._container.mozRequestFullScreen() : this._container.msRequestFullscreen ? this._container.msRequestFullscreen() : this._container.webkitRequestFullscreen ? this._container.webkitRequestFullscreen() : this._togglePseudoFullScreen();\n                  }\n                  _togglePseudoFullScreen() {\n                    this._container.classList.toggle("maplibregl-pseudo-fullscreen"), this._handleFullscreenChange(), this._map.resize();\n                  }\n                }, i3.GeoJSONSource = st, i3.GeolocateControl = class extends a4.E {\n                  constructor(ue) {\n                    super(), this._onSuccess = (w4) => {\n                      if (this._map) {\n                        if (this._isOutOfMapMaxBounds(w4)) return this._setErrorState(), this.fire(new a4.k("outofmaxbounds", w4)), this._updateMarker(), void this._finish();\n                        if (this.options.trackUserLocation) switch (this._lastKnownPosition = w4, this._watchState) {\n                          case "WAITING_ACTIVE":\n                          case "ACTIVE_LOCK":\n                          case "ACTIVE_ERROR":\n                            this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");\n                            break;\n                          case "BACKGROUND":\n                          case "BACKGROUND_ERROR":\n                            this._watchState = "BACKGROUND", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background");\n                            break;\n                          default:\n                            throw new Error(`Unexpected watchState ${this._watchState}`);\n                        }\n                        this.options.showUserLocation && this._watchState !== "OFF" && this._updateMarker(w4), this.options.trackUserLocation && this._watchState !== "ACTIVE_LOCK" || this._updateCamera(w4), this.options.showUserLocation && this._dotElement.classList.remove("maplibregl-user-location-dot-stale"), this.fire(new a4.k("geolocate", w4)), this._finish();\n                      }\n                    }, this._updateCamera = (w4) => {\n                      let B4 = new a4.N(w4.coords.longitude, w4.coords.latitude), Q = w4.coords.accuracy, ee = this._map.getBearing(), le = a4.e({ bearing: ee }, this.options.fitBoundsOptions), qe = ce.fromLngLat(B4, Q);\n                      this._map.fitBounds(qe, le, { geolocateSource: true });\n                    }, this._updateMarker = (w4) => {\n                      if (w4) {\n                        let B4 = new a4.N(w4.coords.longitude, w4.coords.latitude);\n                        this._accuracyCircleMarker.setLngLat(B4).addTo(this._map), this._userLocationDotMarker.setLngLat(B4).addTo(this._map), this._accuracy = w4.coords.accuracy, this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();\n                      } else this._userLocationDotMarker.remove(), this._accuracyCircleMarker.remove();\n                    }, this._onZoom = () => {\n                      this.options.showUserLocation && this.options.showAccuracyCircle && this._updateCircleRadius();\n                    }, this._onError = (w4) => {\n                      if (this._map) {\n                        if (this.options.trackUserLocation) if (w4.code === 1) {\n                          this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.disabled = true;\n                          let B4 = this._map._getUIString("GeolocateControl.LocationNotAvailable");\n                          this._geolocateButton.title = B4, this._geolocateButton.setAttribute("aria-label", B4), this._geolocationWatchID !== void 0 && this._clearWatch();\n                        } else {\n                          if (w4.code === 3 && Uc) return;\n                          this._setErrorState();\n                        }\n                        this._watchState !== "OFF" && this.options.showUserLocation && this._dotElement.classList.add("maplibregl-user-location-dot-stale"), this.fire(new a4.k("error", w4)), this._finish();\n                      }\n                    }, this._finish = () => {\n                      this._timeoutId && clearTimeout(this._timeoutId), this._timeoutId = void 0;\n                    }, this._setupUI = () => {\n                      this._map && (this._container.addEventListener("contextmenu", (w4) => w4.preventDefault()), this._geolocateButton = c5.create("button", "maplibregl-ctrl-geolocate", this._container), c5.create("span", "maplibregl-ctrl-icon", this._geolocateButton).setAttribute("aria-hidden", "true"), this._geolocateButton.type = "button", this._geolocateButton.disabled = true);\n                    }, this._finishSetupUI = (w4) => {\n                      if (this._map) {\n                        if (w4 === false) {\n                          a4.w("Geolocation support is not available so the GeolocateControl will be disabled.");\n                          let B4 = this._map._getUIString("GeolocateControl.LocationNotAvailable");\n                          this._geolocateButton.disabled = true, this._geolocateButton.title = B4, this._geolocateButton.setAttribute("aria-label", B4);\n                        } else {\n                          let B4 = this._map._getUIString("GeolocateControl.FindMyLocation");\n                          this._geolocateButton.disabled = false, this._geolocateButton.title = B4, this._geolocateButton.setAttribute("aria-label", B4);\n                        }\n                        this.options.trackUserLocation && (this._geolocateButton.setAttribute("aria-pressed", "false"), this._watchState = "OFF"), this.options.showUserLocation && (this._dotElement = c5.create("div", "maplibregl-user-location-dot"), this._userLocationDotMarker = new Yu({ element: this._dotElement }), this._circleElement = c5.create("div", "maplibregl-user-location-accuracy-circle"), this._accuracyCircleMarker = new Yu({ element: this._circleElement, pitchAlignment: "map" }), this.options.trackUserLocation && (this._watchState = "OFF"), this._map.on("zoom", this._onZoom)), this._geolocateButton.addEventListener("click", () => this.trigger()), this._setup = true, this.options.trackUserLocation && this._map.on("movestart", (B4) => {\n                          B4.geolocateSource || this._watchState !== "ACTIVE_LOCK" || B4.originalEvent && B4.originalEvent.type === "resize" || (this._watchState = "BACKGROUND", this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this.fire(new a4.k("trackuserlocationend")), this.fire(new a4.k("userlocationlostfocus")));\n                        });\n                      }\n                    }, this.options = a4.e({}, Nc, ue);\n                  }\n                  onAdd(ue) {\n                    return this._map = ue, this._container = c5.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._setupUI(), (function() {\n                      return a4._(this, arguments, void 0, function* (w4 = false) {\n                        if (ys !== void 0 && !w4) return ys;\n                        if (window.navigator.permissions === void 0) return ys = !!window.navigator.geolocation, ys;\n                        try {\n                          ys = (yield window.navigator.permissions.query({ name: "geolocation" })).state !== "denied";\n                        } catch (B4) {\n                          ys = !!window.navigator.geolocation;\n                        }\n                        return ys;\n                      });\n                    })().then((w4) => this._finishSetupUI(w4)), this._container;\n                  }\n                  onRemove() {\n                    this._geolocationWatchID !== void 0 && (window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0), this.options.showUserLocation && this._userLocationDotMarker && this._userLocationDotMarker.remove(), this.options.showAccuracyCircle && this._accuracyCircleMarker && this._accuracyCircleMarker.remove(), c5.remove(this._container), this._map.off("zoom", this._onZoom), this._map = void 0, pu = 0, Uc = false;\n                  }\n                  _isOutOfMapMaxBounds(ue) {\n                    let w4 = this._map.getMaxBounds(), B4 = ue.coords;\n                    return w4 && (B4.longitude < w4.getWest() || B4.longitude > w4.getEast() || B4.latitude < w4.getSouth() || B4.latitude > w4.getNorth());\n                  }\n                  _setErrorState() {\n                    switch (this._watchState) {\n                      case "WAITING_ACTIVE":\n                        this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error");\n                        break;\n                      case "ACTIVE_LOCK":\n                        this._watchState = "ACTIVE_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");\n                        break;\n                      case "BACKGROUND":\n                        this._watchState = "BACKGROUND_ERROR", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-background-error"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting");\n                        break;\n                      case "ACTIVE_ERROR":\n                        break;\n                      default:\n                        throw new Error(`Unexpected watchState ${this._watchState}`);\n                    }\n                  }\n                  _updateCircleRadius() {\n                    let ue = this._map.getBounds(), w4 = ue.getSouthEast(), B4 = ue.getNorthEast(), Q = w4.distanceTo(B4), ee = Math.ceil(this._accuracy / (Q / this._map._container.clientHeight) * 2);\n                    this._circleElement.style.width = `${ee}px`, this._circleElement.style.height = `${ee}px`;\n                  }\n                  trigger() {\n                    if (!this._setup) return a4.w("Geolocate control triggered before added to a map"), false;\n                    if (this.options.trackUserLocation) {\n                      switch (this._watchState) {\n                        case "OFF":\n                          this._watchState = "WAITING_ACTIVE", this.fire(new a4.k("trackuserlocationstart"));\n                          break;\n                        case "WAITING_ACTIVE":\n                        case "ACTIVE_LOCK":\n                        case "ACTIVE_ERROR":\n                        case "BACKGROUND_ERROR":\n                          pu--, Uc = false, this._watchState = "OFF", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-active-error"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background-error"), this.fire(new a4.k("trackuserlocationend"));\n                          break;\n                        case "BACKGROUND":\n                          this._watchState = "ACTIVE_LOCK", this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-background"), this._lastKnownPosition && this._updateCamera(this._lastKnownPosition), this.fire(new a4.k("trackuserlocationstart")), this.fire(new a4.k("userlocationfocus"));\n                          break;\n                        default:\n                          throw new Error(`Unexpected watchState ${this._watchState}`);\n                      }\n                      switch (this._watchState) {\n                        case "WAITING_ACTIVE":\n                          this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");\n                          break;\n                        case "ACTIVE_LOCK":\n                          this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-active");\n                          break;\n                        case "OFF":\n                          break;\n                        default:\n                          throw new Error(`Unexpected watchState ${this._watchState}`);\n                      }\n                      if (this._watchState === "OFF" && this._geolocationWatchID !== void 0) this._clearWatch();\n                      else if (this._geolocationWatchID === void 0) {\n                        let ue;\n                        this._geolocateButton.classList.add("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "true"), pu++, pu > 1 ? (ue = { maximumAge: 6e5, timeout: 0 }, Uc = true) : (ue = this.options.positionOptions, Uc = false), this._geolocationWatchID = window.navigator.geolocation.watchPosition(this._onSuccess, this._onError, ue);\n                      }\n                    } else window.navigator.geolocation.getCurrentPosition(this._onSuccess, this._onError, this.options.positionOptions), this._timeoutId = setTimeout(this._finish, 1e4);\n                    return true;\n                  }\n                  _clearWatch() {\n                    window.navigator.geolocation.clearWatch(this._geolocationWatchID), this._geolocationWatchID = void 0, this._geolocateButton.classList.remove("maplibregl-ctrl-geolocate-waiting"), this._geolocateButton.setAttribute("aria-pressed", "false"), this.options.showUserLocation && this._updateMarker(null);\n                  }\n                }, i3.Hash = Ah, i3.ImageSource = Gt, i3.KeyboardHandler = Wt, i3.LngLatBounds = ce, i3.LogoControl = Yn, i3.Map = class extends Ra {\n                  constructor(ue) {\n                    a4.bf.mark(a4.bg.create);\n                    let w4 = Object.assign(Object.assign({}, Ws), ue);\n                    if (w4.minZoom != null && w4.maxZoom != null && w4.minZoom > w4.maxZoom) throw new Error("maxZoom must be greater than or equal to minZoom");\n                    if (w4.minPitch != null && w4.maxPitch != null && w4.minPitch > w4.maxPitch) throw new Error("maxPitch must be greater than or equal to minPitch");\n                    if (w4.minPitch != null && w4.minPitch < 0) throw new Error("minPitch must be greater than or equal to 0");\n                    if (w4.maxPitch != null && w4.maxPitch > 85) throw new Error("maxPitch must be less than or equal to 85");\n                    if (super(new nl(w4.minZoom, w4.maxZoom, w4.minPitch, w4.maxPitch, w4.renderWorldCopies), { bearingSnap: w4.bearingSnap }), this._idleTriggered = false, this._crossFadingFactor = 1, this._renderTaskQueue = new Dn(), this._controls = [], this._mapId = a4.a4(), this._contextLost = (B4) => {\n                      B4.preventDefault(), this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this.fire(new a4.k("webglcontextlost", { originalEvent: B4 }));\n                    }, this._contextRestored = (B4) => {\n                      this._setupPainter(), this.resize(), this._update(), this.fire(new a4.k("webglcontextrestored", { originalEvent: B4 }));\n                    }, this._onMapScroll = (B4) => {\n                      if (B4.target === this._container) return this._container.scrollTop = 0, this._container.scrollLeft = 0, false;\n                    }, this._onWindowOnline = () => {\n                      this._update();\n                    }, this._interactive = w4.interactive, this._maxTileCacheSize = w4.maxTileCacheSize, this._maxTileCacheZoomLevels = w4.maxTileCacheZoomLevels, this._failIfMajorPerformanceCaveat = w4.failIfMajorPerformanceCaveat === true, this._preserveDrawingBuffer = w4.preserveDrawingBuffer === true, this._antialias = w4.antialias === true, this._trackResize = w4.trackResize === true, this._bearingSnap = w4.bearingSnap, this._refreshExpiredTiles = w4.refreshExpiredTiles === true, this._fadeDuration = w4.fadeDuration, this._crossSourceCollisions = w4.crossSourceCollisions === true, this._collectResourceTiming = w4.collectResourceTiming === true, this._locale = Object.assign(Object.assign({}, Ho), w4.locale), this._clickTolerance = w4.clickTolerance, this._overridePixelRatio = w4.pixelRatio, this._maxCanvasSize = w4.maxCanvasSize, this.transformCameraUpdate = w4.transformCameraUpdate, this.cancelPendingTileRequestsWhileZooming = w4.cancelPendingTileRequestsWhileZooming === true, this._imageQueueHandle = p3.addThrottleControl(() => this.isMoving()), this._requestManager = new k4(w4.transformRequest), typeof w4.container == "string") {\n                      if (this._container = document.getElementById(w4.container), !this._container) throw new Error(`Container \'${w4.container}\' not found.`);\n                    } else {\n                      if (!(w4.container instanceof HTMLElement)) throw new Error("Invalid type: \'container\' must be a String or HTMLElement.");\n                      this._container = w4.container;\n                    }\n                    if (w4.maxBounds && this.setMaxBounds(w4.maxBounds), this._setupContainer(), this._setupPainter(), this.on("move", () => this._update(false)).on("moveend", () => this._update(false)).on("zoom", () => this._update(true)).on("terrain", () => {\n                      this.painter.terrainFacilitator.dirty = true, this._update(true);\n                    }).once("idle", () => {\n                      this._idleTriggered = true;\n                    }), typeof window != "undefined") {\n                      addEventListener("online", this._onWindowOnline, false);\n                      let B4 = false, Q = nh((ee) => {\n                        this._trackResize && !this._removed && (this.resize(ee), this.redraw());\n                      }, 50);\n                      this._resizeObserver = new ResizeObserver((ee) => {\n                        B4 ? Q(ee) : B4 = true;\n                      }), this._resizeObserver.observe(this._container);\n                    }\n                    this.handlers = new Ca(this, w4), this._hash = w4.hash && new Ah(typeof w4.hash == "string" && w4.hash || void 0).addTo(this), this._hash && this._hash._onHashChange() || (this.jumpTo({ center: w4.center, zoom: w4.zoom, bearing: w4.bearing, pitch: w4.pitch }), w4.bounds && (this.resize(), this.fitBounds(w4.bounds, a4.e({}, w4.fitBoundsOptions, { duration: 0 })))), this.resize(), this._localIdeographFontFamily = w4.localIdeographFontFamily, this._validateStyle = w4.validateStyle, w4.style && this.setStyle(w4.style, { localIdeographFontFamily: w4.localIdeographFontFamily }), w4.attributionControl && this.addControl(new Na(typeof w4.attributionControl == "boolean" ? void 0 : w4.attributionControl)), w4.maplibreLogo && this.addControl(new Yn(), w4.logoPosition), this.on("style.load", () => {\n                      this.transform.unmodified && this.jumpTo(this.style.stylesheet);\n                    }), this.on("data", (B4) => {\n                      this._update(B4.dataType === "style"), this.fire(new a4.k(`${B4.dataType}data`, B4));\n                    }), this.on("dataloading", (B4) => {\n                      this.fire(new a4.k(`${B4.dataType}dataloading`, B4));\n                    }), this.on("dataabort", (B4) => {\n                      this.fire(new a4.k("sourcedataabort", B4));\n                    });\n                  }\n                  _getMapId() {\n                    return this._mapId;\n                  }\n                  addControl(ue, w4) {\n                    if (w4 === void 0 && (w4 = ue.getDefaultPosition ? ue.getDefaultPosition() : "top-right"), !ue || !ue.onAdd) return this.fire(new a4.j(new Error("Invalid argument to map.addControl(). Argument must be a control with onAdd and onRemove methods.")));\n                    let B4 = ue.onAdd(this);\n                    this._controls.push(ue);\n                    let Q = this._controlPositions[w4];\n                    return w4.indexOf("bottom") !== -1 ? Q.insertBefore(B4, Q.firstChild) : Q.appendChild(B4), this;\n                  }\n                  removeControl(ue) {\n                    if (!ue || !ue.onRemove) return this.fire(new a4.j(new Error("Invalid argument to map.removeControl(). Argument must be a control with onAdd and onRemove methods.")));\n                    let w4 = this._controls.indexOf(ue);\n                    return w4 > -1 && this._controls.splice(w4, 1), ue.onRemove(this), this;\n                  }\n                  hasControl(ue) {\n                    return this._controls.indexOf(ue) > -1;\n                  }\n                  calculateCameraOptionsFromTo(ue, w4, B4, Q) {\n                    return Q == null && this.terrain && (Q = this.terrain.getElevationForLngLatZoom(B4, this.transform.tileZoom)), super.calculateCameraOptionsFromTo(ue, w4, B4, Q);\n                  }\n                  resize(ue) {\n                    var w4;\n                    let B4 = this._containerDimensions(), Q = B4[0], ee = B4[1], le = this._getClampedPixelRatio(Q, ee);\n                    if (this._resizeCanvas(Q, ee, le), this.painter.resize(Q, ee, le), this.painter.overLimit()) {\n                      let Xe = this.painter.context.gl;\n                      this._maxCanvasSize = [Xe.drawingBufferWidth, Xe.drawingBufferHeight];\n                      let ot = this._getClampedPixelRatio(Q, ee);\n                      this._resizeCanvas(Q, ee, ot), this.painter.resize(Q, ee, ot);\n                    }\n                    this.transform.resize(Q, ee), (w4 = this._requestedCameraState) === null || w4 === void 0 || w4.resize(Q, ee);\n                    let qe = !this._moving;\n                    return qe && (this.stop(), this.fire(new a4.k("movestart", ue)).fire(new a4.k("move", ue))), this.fire(new a4.k("resize", ue)), qe && this.fire(new a4.k("moveend", ue)), this;\n                  }\n                  _getClampedPixelRatio(ue, w4) {\n                    let { 0: B4, 1: Q } = this._maxCanvasSize, ee = this.getPixelRatio(), le = ue * ee, qe = w4 * ee;\n                    return Math.min(le > B4 ? B4 / le : 1, qe > Q ? Q / qe : 1) * ee;\n                  }\n                  getPixelRatio() {\n                    var ue;\n                    return (ue = this._overridePixelRatio) !== null && ue !== void 0 ? ue : devicePixelRatio;\n                  }\n                  setPixelRatio(ue) {\n                    this._overridePixelRatio = ue, this.resize();\n                  }\n                  getBounds() {\n                    return this.transform.getBounds();\n                  }\n                  getMaxBounds() {\n                    return this.transform.getMaxBounds();\n                  }\n                  setMaxBounds(ue) {\n                    return this.transform.setMaxBounds(ce.convert(ue)), this._update();\n                  }\n                  setMinZoom(ue) {\n                    if ((ue = ue == null ? -2 : ue) >= -2 && ue <= this.transform.maxZoom) return this.transform.minZoom = ue, this._update(), this.getZoom() < ue && this.setZoom(ue), this;\n                    throw new Error("minZoom must be between -2 and the current maxZoom, inclusive");\n                  }\n                  getMinZoom() {\n                    return this.transform.minZoom;\n                  }\n                  setMaxZoom(ue) {\n                    if ((ue = ue == null ? 22 : ue) >= this.transform.minZoom) return this.transform.maxZoom = ue, this._update(), this.getZoom() > ue && this.setZoom(ue), this;\n                    throw new Error("maxZoom must be greater than the current minZoom");\n                  }\n                  getMaxZoom() {\n                    return this.transform.maxZoom;\n                  }\n                  setMinPitch(ue) {\n                    if ((ue = ue == null ? 0 : ue) < 0) throw new Error("minPitch must be greater than or equal to 0");\n                    if (ue >= 0 && ue <= this.transform.maxPitch) return this.transform.minPitch = ue, this._update(), this.getPitch() < ue && this.setPitch(ue), this;\n                    throw new Error("minPitch must be between 0 and the current maxPitch, inclusive");\n                  }\n                  getMinPitch() {\n                    return this.transform.minPitch;\n                  }\n                  setMaxPitch(ue) {\n                    if ((ue = ue == null ? 60 : ue) > 85) throw new Error("maxPitch must be less than or equal to 85");\n                    if (ue >= this.transform.minPitch) return this.transform.maxPitch = ue, this._update(), this.getPitch() > ue && this.setPitch(ue), this;\n                    throw new Error("maxPitch must be greater than the current minPitch");\n                  }\n                  getMaxPitch() {\n                    return this.transform.maxPitch;\n                  }\n                  getRenderWorldCopies() {\n                    return this.transform.renderWorldCopies;\n                  }\n                  setRenderWorldCopies(ue) {\n                    return this.transform.renderWorldCopies = ue, this._update();\n                  }\n                  project(ue) {\n                    return this.transform.locationPoint(a4.N.convert(ue), this.style && this.terrain);\n                  }\n                  unproject(ue) {\n                    return this.transform.pointLocation(a4.P.convert(ue), this.terrain);\n                  }\n                  isMoving() {\n                    var ue;\n                    return this._moving || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isMoving());\n                  }\n                  isZooming() {\n                    var ue;\n                    return this._zooming || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isZooming());\n                  }\n                  isRotating() {\n                    var ue;\n                    return this._rotating || ((ue = this.handlers) === null || ue === void 0 ? void 0 : ue.isRotating());\n                  }\n                  _createDelegatedListener(ue, w4, B4) {\n                    if (ue === "mouseenter" || ue === "mouseover") {\n                      let Q = false;\n                      return { layers: w4, listener: B4, delegates: { mousemove: (le) => {\n                        let qe = w4.filter((ot) => this.getLayer(ot)), Xe = qe.length !== 0 ? this.queryRenderedFeatures(le.point, { layers: qe }) : [];\n                        Xe.length ? Q || (Q = true, B4.call(this, new jl(ue, this, le.originalEvent, { features: Xe }))) : Q = false;\n                      }, mouseout: () => {\n                        Q = false;\n                      } } };\n                    }\n                    if (ue === "mouseleave" || ue === "mouseout") {\n                      let Q = false;\n                      return { layers: w4, listener: B4, delegates: { mousemove: (qe) => {\n                        let Xe = w4.filter((ot) => this.getLayer(ot));\n                        (Xe.length !== 0 ? this.queryRenderedFeatures(qe.point, { layers: Xe }) : []).length ? Q = true : Q && (Q = false, B4.call(this, new jl(ue, this, qe.originalEvent)));\n                      }, mouseout: (qe) => {\n                        Q && (Q = false, B4.call(this, new jl(ue, this, qe.originalEvent)));\n                      } } };\n                    }\n                    {\n                      let Q = (ee) => {\n                        let le = w4.filter((Xe) => this.getLayer(Xe)), qe = le.length !== 0 ? this.queryRenderedFeatures(ee.point, { layers: le }) : [];\n                        qe.length && (ee.features = qe, B4.call(this, ee), delete ee.features);\n                      };\n                      return { layers: w4, listener: B4, delegates: { [ue]: Q } };\n                    }\n                  }\n                  _saveDelegatedListener(ue, w4) {\n                    this._delegatedListeners = this._delegatedListeners || {}, this._delegatedListeners[ue] = this._delegatedListeners[ue] || [], this._delegatedListeners[ue].push(w4);\n                  }\n                  _removeDelegatedListener(ue, w4, B4) {\n                    if (!this._delegatedListeners || !this._delegatedListeners[ue]) return;\n                    let Q = this._delegatedListeners[ue];\n                    for (let ee = 0; ee < Q.length; ee++) {\n                      let le = Q[ee];\n                      if (le.listener === B4 && le.layers.length === w4.length && le.layers.every((qe) => w4.includes(qe))) {\n                        for (let qe in le.delegates) this.off(qe, le.delegates[qe]);\n                        return void Q.splice(ee, 1);\n                      }\n                    }\n                  }\n                  on(ue, w4, B4) {\n                    if (B4 === void 0) return super.on(ue, w4);\n                    let Q = this._createDelegatedListener(ue, typeof w4 == "string" ? [w4] : w4, B4);\n                    this._saveDelegatedListener(ue, Q);\n                    for (let ee in Q.delegates) this.on(ee, Q.delegates[ee]);\n                    return this;\n                  }\n                  once(ue, w4, B4) {\n                    if (B4 === void 0) return super.once(ue, w4);\n                    let Q = typeof w4 == "string" ? [w4] : w4, ee = this._createDelegatedListener(ue, Q, B4);\n                    for (let le in ee.delegates) {\n                      let qe = ee.delegates[le];\n                      ee.delegates[le] = (...Xe) => {\n                        this._removeDelegatedListener(ue, Q, B4), qe(...Xe);\n                      };\n                    }\n                    this._saveDelegatedListener(ue, ee);\n                    for (let le in ee.delegates) this.once(le, ee.delegates[le]);\n                    return this;\n                  }\n                  off(ue, w4, B4) {\n                    return B4 === void 0 ? super.off(ue, w4) : (this._removeDelegatedListener(ue, typeof w4 == "string" ? [w4] : w4, B4), this);\n                  }\n                  queryRenderedFeatures(ue, w4) {\n                    if (!this.style) return [];\n                    let B4, Q = ue instanceof a4.P || Array.isArray(ue), ee = Q ? ue : [[0, 0], [this.transform.width, this.transform.height]];\n                    if (w4 = w4 || (Q ? {} : ue) || {}, ee instanceof a4.P || typeof ee[0] == "number") B4 = [a4.P.convert(ee)];\n                    else {\n                      let le = a4.P.convert(ee[0]), qe = a4.P.convert(ee[1]);\n                      B4 = [le, new a4.P(qe.x, le.y), qe, new a4.P(le.x, qe.y), le];\n                    }\n                    return this.style.queryRenderedFeatures(B4, w4, this.transform);\n                  }\n                  querySourceFeatures(ue, w4) {\n                    return this.style.querySourceFeatures(ue, w4);\n                  }\n                  setStyle(ue, w4) {\n                    return (w4 = a4.e({}, { localIdeographFontFamily: this._localIdeographFontFamily, validate: this._validateStyle }, w4)).diff !== false && w4.localIdeographFontFamily === this._localIdeographFontFamily && this.style && ue ? (this._diffStyle(ue, w4), this) : (this._localIdeographFontFamily = w4.localIdeographFontFamily, this._updateStyle(ue, w4));\n                  }\n                  setTransformRequest(ue) {\n                    return this._requestManager.setTransformRequest(ue), this;\n                  }\n                  _getUIString(ue) {\n                    let w4 = this._locale[ue];\n                    if (w4 == null) throw new Error(`Missing UI string \'${ue}\'`);\n                    return w4;\n                  }\n                  _updateStyle(ue, w4) {\n                    if (w4.transformStyle && this.style && !this.style._loaded) return void this.style.once("style.load", () => this._updateStyle(ue, w4));\n                    let B4 = this.style && w4.transformStyle ? this.style.serialize() : void 0;\n                    return this.style && (this.style.setEventedParent(null), this.style._remove(!ue)), ue ? (this.style = new Ha(this, w4 || {}), this.style.setEventedParent(this, { style: this.style }), typeof ue == "string" ? this.style.loadURL(ue, w4, B4) : this.style.loadJSON(ue, w4, B4), this) : (delete this.style, this);\n                  }\n                  _lazyInitEmptyStyle() {\n                    this.style || (this.style = new Ha(this, {}), this.style.setEventedParent(this, { style: this.style }), this.style.loadEmpty());\n                  }\n                  _diffStyle(ue, w4) {\n                    if (typeof ue == "string") {\n                      let B4 = this._requestManager.transformRequest(ue, "Style");\n                      a4.h(B4, new AbortController()).then((Q) => {\n                        this._updateDiff(Q.data, w4);\n                      }).catch((Q) => {\n                        Q && this.fire(new a4.j(Q));\n                      });\n                    } else typeof ue == "object" && this._updateDiff(ue, w4);\n                  }\n                  _updateDiff(ue, w4) {\n                    try {\n                      this.style.setState(ue, w4) && this._update(true);\n                    } catch (B4) {\n                      a4.w(`Unable to perform style diff: ${B4.message || B4.error || B4}.  Rebuilding the style from scratch.`), this._updateStyle(ue, w4);\n                    }\n                  }\n                  getStyle() {\n                    if (this.style) return this.style.serialize();\n                  }\n                  isStyleLoaded() {\n                    return this.style ? this.style.loaded() : a4.w("There is no style added to the map.");\n                  }\n                  addSource(ue, w4) {\n                    return this._lazyInitEmptyStyle(), this.style.addSource(ue, w4), this._update(true);\n                  }\n                  isSourceLoaded(ue) {\n                    let w4 = this.style && this.style.sourceCaches[ue];\n                    if (w4 !== void 0) return w4.loaded();\n                    this.fire(new a4.j(new Error(`There is no source with ID \'${ue}\'`)));\n                  }\n                  setTerrain(ue) {\n                    if (this.style._checkLoaded(), this._terrainDataCallback && this.style.off("data", this._terrainDataCallback), ue) {\n                      let w4 = this.style.sourceCaches[ue.source];\n                      if (!w4) throw new Error(`cannot load terrain, because there exists no source with ID: ${ue.source}`);\n                      this.terrain === null && w4.reload();\n                      for (let B4 in this.style._layers) {\n                        let Q = this.style._layers[B4];\n                        Q.type === "hillshade" && Q.source === ue.source && a4.w("You are using the same source for a hillshade layer and for 3D terrain. Please consider using two separate sources to improve rendering quality.");\n                      }\n                      this.terrain = new Xo(this.painter, w4, ue), this.painter.renderToTexture = new ws(this.painter, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._terrainDataCallback = (B4) => {\n                        B4.dataType === "style" ? this.terrain.sourceCache.freeRtt() : B4.dataType === "source" && B4.tile && (B4.sourceId !== ue.source || this._elevationFreeze || (this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom)), this.terrain.sourceCache.freeRtt(B4.tile.tileID));\n                      }, this.style.on("data", this._terrainDataCallback);\n                    } else this.terrain && this.terrain.sourceCache.destruct(), this.terrain = null, this.painter.renderToTexture && this.painter.renderToTexture.destruct(), this.painter.renderToTexture = null, this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0;\n                    return this.fire(new a4.k("terrain", { terrain: ue })), this;\n                  }\n                  getTerrain() {\n                    var ue, w4;\n                    return (w4 = (ue = this.terrain) === null || ue === void 0 ? void 0 : ue.options) !== null && w4 !== void 0 ? w4 : null;\n                  }\n                  areTilesLoaded() {\n                    let ue = this.style && this.style.sourceCaches;\n                    for (let w4 in ue) {\n                      let B4 = ue[w4]._tiles;\n                      for (let Q in B4) {\n                        let ee = B4[Q];\n                        if (ee.state !== "loaded" && ee.state !== "errored") return false;\n                      }\n                    }\n                    return true;\n                  }\n                  removeSource(ue) {\n                    return this.style.removeSource(ue), this._update(true);\n                  }\n                  getSource(ue) {\n                    return this.style.getSource(ue);\n                  }\n                  addImage(ue, w4, B4 = {}) {\n                    let { pixelRatio: Q = 1, sdf: ee = false, stretchX: le, stretchY: qe, content: Xe, textFitWidth: ot, textFitHeight: Tt } = B4;\n                    if (this._lazyInitEmptyStyle(), !(w4 instanceof HTMLImageElement || a4.b(w4))) {\n                      if (w4.width === void 0 || w4.height === void 0) return this.fire(new a4.j(new Error("Invalid arguments to map.addImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));\n                      {\n                        let { width: Yt, height: Kt, data: xr } = w4, Ir = w4;\n                        return this.style.addImage(ue, { data: new a4.R({ width: Yt, height: Kt }, new Uint8Array(xr)), pixelRatio: Q, stretchX: le, stretchY: qe, content: Xe, textFitWidth: ot, textFitHeight: Tt, sdf: ee, version: 0, userImage: Ir }), Ir.onAdd && Ir.onAdd(this, ue), this;\n                      }\n                    }\n                    {\n                      let { width: Yt, height: Kt, data: xr } = u4.getImageData(w4);\n                      this.style.addImage(ue, { data: new a4.R({ width: Yt, height: Kt }, xr), pixelRatio: Q, stretchX: le, stretchY: qe, content: Xe, textFitWidth: ot, textFitHeight: Tt, sdf: ee, version: 0 });\n                    }\n                  }\n                  updateImage(ue, w4) {\n                    let B4 = this.style.getImage(ue);\n                    if (!B4) return this.fire(new a4.j(new Error("The map has no image with that id. If you are adding a new image use `map.addImage(...)` instead.")));\n                    let Q = w4 instanceof HTMLImageElement || a4.b(w4) ? u4.getImageData(w4) : w4, { width: ee, height: le, data: qe } = Q;\n                    if (ee === void 0 || le === void 0) return this.fire(new a4.j(new Error("Invalid arguments to map.updateImage(). The second argument must be an `HTMLImageElement`, `ImageData`, `ImageBitmap`, or object with `width`, `height`, and `data` properties with the same format as `ImageData`")));\n                    if (ee !== B4.data.width || le !== B4.data.height) return this.fire(new a4.j(new Error("The width and height of the updated image must be that same as the previous version of the image")));\n                    let Xe = !(w4 instanceof HTMLImageElement || a4.b(w4));\n                    return B4.data.replace(qe, Xe), this.style.updateImage(ue, B4), this;\n                  }\n                  getImage(ue) {\n                    return this.style.getImage(ue);\n                  }\n                  hasImage(ue) {\n                    return ue ? !!this.style.getImage(ue) : (this.fire(new a4.j(new Error("Missing required image id"))), false);\n                  }\n                  removeImage(ue) {\n                    this.style.removeImage(ue);\n                  }\n                  loadImage(ue) {\n                    return p3.getImage(this._requestManager.transformRequest(ue, "Image"), new AbortController());\n                  }\n                  listImages() {\n                    return this.style.listImages();\n                  }\n                  addLayer(ue, w4) {\n                    return this._lazyInitEmptyStyle(), this.style.addLayer(ue, w4), this._update(true);\n                  }\n                  moveLayer(ue, w4) {\n                    return this.style.moveLayer(ue, w4), this._update(true);\n                  }\n                  removeLayer(ue) {\n                    return this.style.removeLayer(ue), this._update(true);\n                  }\n                  getLayer(ue) {\n                    return this.style.getLayer(ue);\n                  }\n                  getLayersOrder() {\n                    return this.style.getLayersOrder();\n                  }\n                  setLayerZoomRange(ue, w4, B4) {\n                    return this.style.setLayerZoomRange(ue, w4, B4), this._update(true);\n                  }\n                  setFilter(ue, w4, B4 = {}) {\n                    return this.style.setFilter(ue, w4, B4), this._update(true);\n                  }\n                  getFilter(ue) {\n                    return this.style.getFilter(ue);\n                  }\n                  setPaintProperty(ue, w4, B4, Q = {}) {\n                    return this.style.setPaintProperty(ue, w4, B4, Q), this._update(true);\n                  }\n                  getPaintProperty(ue, w4) {\n                    return this.style.getPaintProperty(ue, w4);\n                  }\n                  setLayoutProperty(ue, w4, B4, Q = {}) {\n                    return this.style.setLayoutProperty(ue, w4, B4, Q), this._update(true);\n                  }\n                  getLayoutProperty(ue, w4) {\n                    return this.style.getLayoutProperty(ue, w4);\n                  }\n                  setGlyphs(ue, w4 = {}) {\n                    return this._lazyInitEmptyStyle(), this.style.setGlyphs(ue, w4), this._update(true);\n                  }\n                  getGlyphs() {\n                    return this.style.getGlyphsUrl();\n                  }\n                  addSprite(ue, w4, B4 = {}) {\n                    return this._lazyInitEmptyStyle(), this.style.addSprite(ue, w4, B4, (Q) => {\n                      Q || this._update(true);\n                    }), this;\n                  }\n                  removeSprite(ue) {\n                    return this._lazyInitEmptyStyle(), this.style.removeSprite(ue), this._update(true);\n                  }\n                  getSprite() {\n                    return this.style.getSprite();\n                  }\n                  setSprite(ue, w4 = {}) {\n                    return this._lazyInitEmptyStyle(), this.style.setSprite(ue, w4, (B4) => {\n                      B4 || this._update(true);\n                    }), this;\n                  }\n                  setLight(ue, w4 = {}) {\n                    return this._lazyInitEmptyStyle(), this.style.setLight(ue, w4), this._update(true);\n                  }\n                  getLight() {\n                    return this.style.getLight();\n                  }\n                  setSky(ue) {\n                    return this._lazyInitEmptyStyle(), this.style.setSky(ue), this._update(true);\n                  }\n                  getSky() {\n                    return this.style.getSky();\n                  }\n                  setFeatureState(ue, w4) {\n                    return this.style.setFeatureState(ue, w4), this._update();\n                  }\n                  removeFeatureState(ue, w4) {\n                    return this.style.removeFeatureState(ue, w4), this._update();\n                  }\n                  getFeatureState(ue) {\n                    return this.style.getFeatureState(ue);\n                  }\n                  getContainer() {\n                    return this._container;\n                  }\n                  getCanvasContainer() {\n                    return this._canvasContainer;\n                  }\n                  getCanvas() {\n                    return this._canvas;\n                  }\n                  _containerDimensions() {\n                    let ue = 0, w4 = 0;\n                    return this._container && (ue = this._container.clientWidth || 400, w4 = this._container.clientHeight || 300), [ue, w4];\n                  }\n                  _setupContainer() {\n                    let ue = this._container;\n                    ue.classList.add("maplibregl-map");\n                    let w4 = this._canvasContainer = c5.create("div", "maplibregl-canvas-container", ue);\n                    this._interactive && w4.classList.add("maplibregl-interactive"), this._canvas = c5.create("canvas", "maplibregl-canvas", w4), this._canvas.addEventListener("webglcontextlost", this._contextLost, false), this._canvas.addEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.setAttribute("tabindex", this._interactive ? "0" : "-1"), this._canvas.setAttribute("aria-label", this._getUIString("Map.Title")), this._canvas.setAttribute("role", "region");\n                    let B4 = this._containerDimensions(), Q = this._getClampedPixelRatio(B4[0], B4[1]);\n                    this._resizeCanvas(B4[0], B4[1], Q);\n                    let ee = this._controlContainer = c5.create("div", "maplibregl-control-container", ue), le = this._controlPositions = {};\n                    ["top-left", "top-right", "bottom-left", "bottom-right"].forEach((qe) => {\n                      le[qe] = c5.create("div", `maplibregl-ctrl-${qe} `, ee);\n                    }), this._container.addEventListener("scroll", this._onMapScroll, false);\n                  }\n                  _resizeCanvas(ue, w4, B4) {\n                    this._canvas.width = Math.floor(B4 * ue), this._canvas.height = Math.floor(B4 * w4), this._canvas.style.width = `${ue}px`, this._canvas.style.height = `${w4}px`;\n                  }\n                  _setupPainter() {\n                    let ue = { alpha: true, stencil: true, depth: true, failIfMajorPerformanceCaveat: this._failIfMajorPerformanceCaveat, preserveDrawingBuffer: this._preserveDrawingBuffer, antialias: this._antialias || false }, w4 = null;\n                    this._canvas.addEventListener("webglcontextcreationerror", (Q) => {\n                      w4 = { requestedAttributes: ue }, Q && (w4.statusMessage = Q.statusMessage, w4.type = Q.type);\n                    }, { once: true });\n                    let B4 = this._canvas.getContext("webgl2", ue) || this._canvas.getContext("webgl", ue);\n                    if (!B4) {\n                      let Q = "Failed to initialize WebGL";\n                      throw w4 ? (w4.message = Q, new Error(JSON.stringify(w4))) : new Error(Q);\n                    }\n                    this.painter = new Dc(B4, this.transform), f4.testSupport(B4);\n                  }\n                  loaded() {\n                    return !this._styleDirty && !this._sourcesDirty && !!this.style && this.style.loaded();\n                  }\n                  _update(ue) {\n                    return this.style && this.style._loaded ? (this._styleDirty = this._styleDirty || ue, this._sourcesDirty = true, this.triggerRepaint(), this) : this;\n                  }\n                  _requestRenderFrame(ue) {\n                    return this._update(), this._renderTaskQueue.add(ue);\n                  }\n                  _cancelRenderFrame(ue) {\n                    this._renderTaskQueue.remove(ue);\n                  }\n                  _render(ue) {\n                    let w4 = this._idleTriggered ? this._fadeDuration : 0;\n                    if (this.painter.context.setDirty(), this.painter.setBaseState(), this._renderTaskQueue.run(ue), this._removed) return;\n                    let B4 = false;\n                    if (this.style && this._styleDirty) {\n                      this._styleDirty = false;\n                      let ee = this.transform.zoom, le = u4.now();\n                      this.style.zoomHistory.update(ee, le);\n                      let qe = new a4.z(ee, { now: le, fadeDuration: w4, zoomHistory: this.style.zoomHistory, transition: this.style.getTransition() }), Xe = qe.crossFadingFactor();\n                      Xe === 1 && Xe === this._crossFadingFactor || (B4 = true, this._crossFadingFactor = Xe), this.style.update(qe);\n                    }\n                    this.style && this._sourcesDirty && (this._sourcesDirty = false, this.style._updateSources(this.transform)), this.terrain ? (this.terrain.sourceCache.update(this.transform, this.terrain), this.transform.minElevationForCurrentTile = this.terrain.getMinTileElevationForLngLatZoom(this.transform.center, this.transform.tileZoom), this._elevationFreeze || (this.transform.elevation = this.terrain.getElevationForLngLatZoom(this.transform.center, this.transform.tileZoom))) : (this.transform.minElevationForCurrentTile = 0, this.transform.elevation = 0), this._placementDirty = this.style && this.style._updatePlacement(this.painter.transform, this.showCollisionBoxes, w4, this._crossSourceCollisions), this.painter.render(this.style, { showTileBoundaries: this.showTileBoundaries, showOverdrawInspector: this._showOverdrawInspector, rotating: this.isRotating(), zooming: this.isZooming(), moving: this.isMoving(), fadeDuration: w4, showPadding: this.showPadding }), this.fire(new a4.k("render")), this.loaded() && !this._loaded && (this._loaded = true, a4.bf.mark(a4.bg.load), this.fire(new a4.k("load"))), this.style && (this.style.hasTransitions() || B4) && (this._styleDirty = true), this.style && !this._placementDirty && this.style._releaseSymbolFadeTiles();\n                    let Q = this._sourcesDirty || this._styleDirty || this._placementDirty;\n                    return Q || this._repaint ? this.triggerRepaint() : !this.isMoving() && this.loaded() && this.fire(new a4.k("idle")), !this._loaded || this._fullyLoaded || Q || (this._fullyLoaded = true, a4.bf.mark(a4.bg.fullLoad)), this;\n                  }\n                  redraw() {\n                    return this.style && (this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._render(0)), this;\n                  }\n                  remove() {\n                    var ue;\n                    this._hash && this._hash.remove();\n                    for (let B4 of this._controls) B4.onRemove(this);\n                    this._controls = [], this._frameRequest && (this._frameRequest.abort(), this._frameRequest = null), this._renderTaskQueue.clear(), this.painter.destroy(), this.handlers.destroy(), delete this.handlers, this.setStyle(null), typeof window != "undefined" && removeEventListener("online", this._onWindowOnline, false), p3.removeThrottleControl(this._imageQueueHandle), (ue = this._resizeObserver) === null || ue === void 0 || ue.disconnect();\n                    let w4 = this.painter.context.gl.getExtension("WEBGL_lose_context");\n                    w4 != null && w4.loseContext && w4.loseContext(), this._canvas.removeEventListener("webglcontextrestored", this._contextRestored, false), this._canvas.removeEventListener("webglcontextlost", this._contextLost, false), c5.remove(this._canvasContainer), c5.remove(this._controlContainer), this._container.classList.remove("maplibregl-map"), a4.bf.clearMetrics(), this._removed = true, this.fire(new a4.k("remove"));\n                  }\n                  triggerRepaint() {\n                    this.style && !this._frameRequest && (this._frameRequest = new AbortController(), u4.frameAsync(this._frameRequest).then((ue) => {\n                      a4.bf.frame(ue), this._frameRequest = null, this._render(ue);\n                    }).catch(() => {\n                    }));\n                  }\n                  get showTileBoundaries() {\n                    return !!this._showTileBoundaries;\n                  }\n                  set showTileBoundaries(ue) {\n                    this._showTileBoundaries !== ue && (this._showTileBoundaries = ue, this._update());\n                  }\n                  get showPadding() {\n                    return !!this._showPadding;\n                  }\n                  set showPadding(ue) {\n                    this._showPadding !== ue && (this._showPadding = ue, this._update());\n                  }\n                  get showCollisionBoxes() {\n                    return !!this._showCollisionBoxes;\n                  }\n                  set showCollisionBoxes(ue) {\n                    this._showCollisionBoxes !== ue && (this._showCollisionBoxes = ue, ue ? this.style._generateCollisionBoxes() : this._update());\n                  }\n                  get showOverdrawInspector() {\n                    return !!this._showOverdrawInspector;\n                  }\n                  set showOverdrawInspector(ue) {\n                    this._showOverdrawInspector !== ue && (this._showOverdrawInspector = ue, this._update());\n                  }\n                  get repaint() {\n                    return !!this._repaint;\n                  }\n                  set repaint(ue) {\n                    this._repaint !== ue && (this._repaint = ue, this.triggerRepaint());\n                  }\n                  get vertices() {\n                    return !!this._vertices;\n                  }\n                  set vertices(ue) {\n                    this._vertices = ue, this._update();\n                  }\n                  get version() {\n                    return ml;\n                  }\n                  getCameraTargetElevation() {\n                    return this.transform.elevation;\n                  }\n                }, i3.MapMouseEvent = jl, i3.MapTouchEvent = lf, i3.MapWheelEvent = Hh, i3.Marker = Yu, i3.NavigationControl = class {\n                  constructor(ue) {\n                    this._updateZoomButtons = () => {\n                      let w4 = this._map.getZoom(), B4 = w4 === this._map.getMaxZoom(), Q = w4 === this._map.getMinZoom();\n                      this._zoomInButton.disabled = B4, this._zoomOutButton.disabled = Q, this._zoomInButton.setAttribute("aria-disabled", B4.toString()), this._zoomOutButton.setAttribute("aria-disabled", Q.toString());\n                    }, this._rotateCompassArrow = () => {\n                      let w4 = this.options.visualizePitch ? `scale(${1 / Math.pow(Math.cos(this._map.transform.pitch * (Math.PI / 180)), 0.5)}) rotateX(${this._map.transform.pitch}deg) rotateZ(${this._map.transform.angle * (180 / Math.PI)}deg)` : `rotate(${this._map.transform.angle * (180 / Math.PI)}deg)`;\n                      this._compassIcon.style.transform = w4;\n                    }, this._setButtonTitle = (w4, B4) => {\n                      let Q = this._map._getUIString(`NavigationControl.${B4}`);\n                      w4.title = Q, w4.setAttribute("aria-label", Q);\n                    }, this.options = a4.e({}, va, ue), this._container = c5.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._container.addEventListener("contextmenu", (w4) => w4.preventDefault()), this.options.showZoom && (this._zoomInButton = this._createButton("maplibregl-ctrl-zoom-in", (w4) => this._map.zoomIn({}, { originalEvent: w4 })), c5.create("span", "maplibregl-ctrl-icon", this._zoomInButton).setAttribute("aria-hidden", "true"), this._zoomOutButton = this._createButton("maplibregl-ctrl-zoom-out", (w4) => this._map.zoomOut({}, { originalEvent: w4 })), c5.create("span", "maplibregl-ctrl-icon", this._zoomOutButton).setAttribute("aria-hidden", "true")), this.options.showCompass && (this._compass = this._createButton("maplibregl-ctrl-compass", (w4) => {\n                      this.options.visualizePitch ? this._map.resetNorthPitch({}, { originalEvent: w4 }) : this._map.resetNorth({}, { originalEvent: w4 });\n                    }), this._compassIcon = c5.create("span", "maplibregl-ctrl-icon", this._compass), this._compassIcon.setAttribute("aria-hidden", "true"));\n                  }\n                  onAdd(ue) {\n                    return this._map = ue, this.options.showZoom && (this._setButtonTitle(this._zoomInButton, "ZoomIn"), this._setButtonTitle(this._zoomOutButton, "ZoomOut"), this._map.on("zoom", this._updateZoomButtons), this._updateZoomButtons()), this.options.showCompass && (this._setButtonTitle(this._compass, "ResetBearing"), this.options.visualizePitch && this._map.on("pitch", this._rotateCompassArrow), this._map.on("rotate", this._rotateCompassArrow), this._rotateCompassArrow(), this._handler = new no(this._map, this._compass, this.options.visualizePitch)), this._container;\n                  }\n                  onRemove() {\n                    c5.remove(this._container), this.options.showZoom && this._map.off("zoom", this._updateZoomButtons), this.options.showCompass && (this.options.visualizePitch && this._map.off("pitch", this._rotateCompassArrow), this._map.off("rotate", this._rotateCompassArrow), this._handler.off(), delete this._handler), delete this._map;\n                  }\n                  _createButton(ue, w4) {\n                    let B4 = c5.create("button", ue, this._container);\n                    return B4.type = "button", B4.addEventListener("click", w4), B4;\n                  }\n                }, i3.Popup = class extends a4.E {\n                  constructor(ue) {\n                    super(), this.remove = () => (this._content && c5.remove(this._content), this._container && (c5.remove(this._container), delete this._container), this._map && (this._map.off("move", this._update), this._map.off("move", this._onClose), this._map.off("click", this._onClose), this._map.off("remove", this.remove), this._map.off("mousemove", this._onMouseMove), this._map.off("mouseup", this._onMouseUp), this._map.off("drag", this._onDrag), this._map._canvasContainer.classList.remove("maplibregl-track-pointer"), delete this._map, this.fire(new a4.k("close"))), this), this._onMouseUp = (w4) => {\n                      this._update(w4.point);\n                    }, this._onMouseMove = (w4) => {\n                      this._update(w4.point);\n                    }, this._onDrag = (w4) => {\n                      this._update(w4.point);\n                    }, this._update = (w4) => {\n                      var B4;\n                      if (!this._map || !this._lngLat && !this._trackPointer || !this._content) return;\n                      if (!this._container) {\n                        if (this._container = c5.create("div", "maplibregl-popup", this._map.getContainer()), this._tip = c5.create("div", "maplibregl-popup-tip", this._container), this._container.appendChild(this._content), this.options.className) for (let Xe of this.options.className.split(" ")) this._container.classList.add(Xe);\n                        this._closeButton && this._closeButton.setAttribute("aria-label", this._map._getUIString("Popup.Close")), this._trackPointer && this._container.classList.add("maplibregl-popup-track-pointer");\n                      }\n                      if (this.options.maxWidth && this._container.style.maxWidth !== this.options.maxWidth && (this._container.style.maxWidth = this.options.maxWidth), this._lngLat = this._map.transform.renderWorldCopies && !this._trackPointer ? rs(this._lngLat, this._flatPos, this._map.transform) : (B4 = this._lngLat) === null || B4 === void 0 ? void 0 : B4.wrap(), this._trackPointer && !w4) return;\n                      let Q = this._flatPos = this._pos = this._trackPointer && w4 ? w4 : this._map.project(this._lngLat);\n                      this._map.terrain && (this._flatPos = this._trackPointer && w4 ? w4 : this._map.transform.locationPoint(this._lngLat));\n                      let ee = this.options.anchor, le = hc(this.options.offset);\n                      if (!ee) {\n                        let Xe = this._container.offsetWidth, ot = this._container.offsetHeight, Tt;\n                        Tt = Q.y + le.bottom.y < ot ? ["top"] : Q.y > this._map.transform.height - ot ? ["bottom"] : [], Q.x < Xe / 2 ? Tt.push("left") : Q.x > this._map.transform.width - Xe / 2 && Tt.push("right"), ee = Tt.length === 0 ? "bottom" : Tt.join("-");\n                      }\n                      let qe = Q.add(le[ee]);\n                      this.options.subpixelPositioning || (qe = qe.round()), c5.setTransform(this._container, `${$l[ee]} translate(${qe.x}px,${qe.y}px)`), Cu(this._container, ee, "popup");\n                    }, this._onClose = () => {\n                      this.remove();\n                    }, this.options = a4.e(Object.create(oo), ue);\n                  }\n                  addTo(ue) {\n                    return this._map && this.remove(), this._map = ue, this.options.closeOnClick && this._map.on("click", this._onClose), this.options.closeOnMove && this._map.on("move", this._onClose), this._map.on("remove", this.remove), this._update(), this._focusFirstElement(), this._trackPointer ? (this._map.on("mousemove", this._onMouseMove), this._map.on("mouseup", this._onMouseUp), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")) : this._map.on("move", this._update), this.fire(new a4.k("open")), this;\n                  }\n                  isOpen() {\n                    return !!this._map;\n                  }\n                  getLngLat() {\n                    return this._lngLat;\n                  }\n                  setLngLat(ue) {\n                    return this._lngLat = a4.N.convert(ue), this._pos = null, this._flatPos = null, this._trackPointer = false, this._update(), this._map && (this._map.on("move", this._update), this._map.off("mousemove", this._onMouseMove), this._container && this._container.classList.remove("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.remove("maplibregl-track-pointer")), this;\n                  }\n                  trackPointer() {\n                    return this._trackPointer = true, this._pos = null, this._flatPos = null, this._update(), this._map && (this._map.off("move", this._update), this._map.on("mousemove", this._onMouseMove), this._map.on("drag", this._onDrag), this._container && this._container.classList.add("maplibregl-popup-track-pointer"), this._map._canvasContainer.classList.add("maplibregl-track-pointer")), this;\n                  }\n                  getElement() {\n                    return this._container;\n                  }\n                  setText(ue) {\n                    return this.setDOMContent(document.createTextNode(ue));\n                  }\n                  setHTML(ue) {\n                    let w4 = document.createDocumentFragment(), B4 = document.createElement("body"), Q;\n                    for (B4.innerHTML = ue; Q = B4.firstChild, Q; ) w4.appendChild(Q);\n                    return this.setDOMContent(w4);\n                  }\n                  getMaxWidth() {\n                    var ue;\n                    return (ue = this._container) === null || ue === void 0 ? void 0 : ue.style.maxWidth;\n                  }\n                  setMaxWidth(ue) {\n                    return this.options.maxWidth = ue, this._update(), this;\n                  }\n                  setDOMContent(ue) {\n                    if (this._content) for (; this._content.hasChildNodes(); ) this._content.firstChild && this._content.removeChild(this._content.firstChild);\n                    else this._content = c5.create("div", "maplibregl-popup-content", this._container);\n                    return this._content.appendChild(ue), this._createCloseButton(), this._update(), this._focusFirstElement(), this;\n                  }\n                  addClassName(ue) {\n                    return this._container && this._container.classList.add(ue), this;\n                  }\n                  removeClassName(ue) {\n                    return this._container && this._container.classList.remove(ue), this;\n                  }\n                  setOffset(ue) {\n                    return this.options.offset = ue, this._update(), this;\n                  }\n                  toggleClassName(ue) {\n                    if (this._container) return this._container.classList.toggle(ue);\n                  }\n                  setSubpixelPositioning(ue) {\n                    this.options.subpixelPositioning = ue;\n                  }\n                  _createCloseButton() {\n                    this.options.closeButton && (this._closeButton = c5.create("button", "maplibregl-popup-close-button", this._content), this._closeButton.type = "button", this._closeButton.innerHTML = "&#215;", this._closeButton.addEventListener("click", this._onClose));\n                  }\n                  _focusFirstElement() {\n                    if (!this.options.focusAfterOpen || !this._container) return;\n                    let ue = this._container.querySelector(Vc);\n                    ue && ue.focus();\n                  }\n                }, i3.RasterDEMTileSource = Zt, i3.RasterTileSource = pt, i3.ScaleControl = class {\n                  constructor(ue) {\n                    this._onMove = () => {\n                      Ac(this._map, this._container, this.options);\n                    }, this.setUnit = (w4) => {\n                      this.options.unit = w4, Ac(this._map, this._container, this.options);\n                    }, this.options = Object.assign(Object.assign({}, xu), ue);\n                  }\n                  getDefaultPosition() {\n                    return "bottom-left";\n                  }\n                  onAdd(ue) {\n                    return this._map = ue, this._container = c5.create("div", "maplibregl-ctrl maplibregl-ctrl-scale", ue.getContainer()), this._map.on("move", this._onMove), this._onMove(), this._container;\n                  }\n                  onRemove() {\n                    c5.remove(this._container), this._map.off("move", this._onMove), this._map = void 0;\n                  }\n                }, i3.ScrollZoomHandler = Kr, i3.Style = Ha, i3.TerrainControl = class {\n                  constructor(ue) {\n                    this._toggleTerrain = () => {\n                      this._map.getTerrain() ? this._map.setTerrain(null) : this._map.setTerrain(this.options), this._updateTerrainIcon();\n                    }, this._updateTerrainIcon = () => {\n                      this._terrainButton.classList.remove("maplibregl-ctrl-terrain"), this._terrainButton.classList.remove("maplibregl-ctrl-terrain-enabled"), this._map.terrain ? (this._terrainButton.classList.add("maplibregl-ctrl-terrain-enabled"), this._terrainButton.title = this._map._getUIString("TerrainControl.Disable")) : (this._terrainButton.classList.add("maplibregl-ctrl-terrain"), this._terrainButton.title = this._map._getUIString("TerrainControl.Enable"));\n                    }, this.options = ue;\n                  }\n                  onAdd(ue) {\n                    return this._map = ue, this._container = c5.create("div", "maplibregl-ctrl maplibregl-ctrl-group"), this._terrainButton = c5.create("button", "maplibregl-ctrl-terrain", this._container), c5.create("span", "maplibregl-ctrl-icon", this._terrainButton).setAttribute("aria-hidden", "true"), this._terrainButton.type = "button", this._terrainButton.addEventListener("click", this._toggleTerrain), this._updateTerrainIcon(), this._map.on("terrain", this._updateTerrainIcon), this._container;\n                  }\n                  onRemove() {\n                    c5.remove(this._container), this._map.off("terrain", this._updateTerrainIcon), this._map = void 0;\n                  }\n                }, i3.TwoFingersTouchPitchHandler = Bc, i3.TwoFingersTouchRotateHandler = cf, i3.TwoFingersTouchZoomHandler = vu, i3.TwoFingersTouchZoomRotateHandler = Yi, i3.VectorTileSource = ut, i3.VideoSource = Nt, i3.addSourceType = (ue, w4) => a4._(void 0, void 0, void 0, function* () {\n                  if (wr(ue)) throw new Error(`A source type called "${ue}" already exists.`);\n                  ((B4, Q) => {\n                    sr[B4] = Q;\n                  })(ue, w4);\n                }), i3.clearPrewarmedResources = function() {\n                  let ue = me;\n                  ue && (ue.isPreloaded() && ue.numActive() === 1 ? (ue.release(_e), me = null) : console.warn("Could not clear WebWorkers since there are active Map instances that still reference it. The pre-warmed WebWorker pool can only be cleared when all map instances have been removed with map.remove()"));\n                }, i3.getMaxParallelImageRequests = function() {\n                  return a4.a.MAX_PARALLEL_IMAGE_REQUESTS;\n                }, i3.getRTLTextPluginStatus = function() {\n                  return Qt().getRTLTextPluginStatus();\n                }, i3.getVersion = function() {\n                  return Ku;\n                }, i3.getWorkerCount = function() {\n                  return Ee.workerCount;\n                }, i3.getWorkerUrl = function() {\n                  return a4.a.WORKER_URL;\n                }, i3.importScriptInWorkers = function(ue) {\n                  return Ae().broadcast("IS", ue);\n                }, i3.prewarm = function() {\n                  Se().acquire(_e);\n                }, i3.setMaxParallelImageRequests = function(ue) {\n                  a4.a.MAX_PARALLEL_IMAGE_REQUESTS = ue;\n                }, i3.setRTLTextPlugin = function(ue, w4) {\n                  return Qt().setRTLTextPlugin(ue, w4);\n                }, i3.setWorkerCount = function(ue) {\n                  Ee.workerCount = ue;\n                }, i3.setWorkerUrl = function(ue) {\n                  a4.a.WORKER_URL = ue;\n                };\n              });\n              var n4 = e3;\n              return n4;\n            });\n          });\n          var fje = ye((Ebr, cje) => {\n            "use strict";\n            var aw = Dr(), AXt = ru().sanitizeHTML, SXt = SJ(), sje = wx();\n            function lje(e3, t3) {\n              this.subplot = e3, this.uid = e3.uid + "-" + t3, this.index = t3, this.idSource = "source-" + this.uid, this.idLayer = sje.layoutLayerPrefix + this.uid, this.sourceType = null, this.source = null, this.layerType = null, this.below = null, this.visible = false;\n            }\n            var ag = lje.prototype;\n            ag.update = function(t3) {\n              this.visible ? this.needsNewImage(t3) ? this.updateImage(t3) : this.needsNewSource(t3) ? (this.removeLayer(), this.updateSource(t3), this.updateLayer(t3)) : this.needsNewLayer(t3) ? this.updateLayer(t3) : this.updateStyle(t3) : (this.updateSource(t3), this.updateLayer(t3)), this.visible = c7(t3);\n            };\n            ag.needsNewImage = function(e3) {\n              var t3 = this.subplot.map;\n              return t3.getSource(this.idSource) && this.sourceType === "image" && e3.sourcetype === "image" && (this.source !== e3.source || JSON.stringify(this.coordinates) !== JSON.stringify(e3.coordinates));\n            };\n            ag.needsNewSource = function(e3) {\n              return this.sourceType !== e3.sourcetype || JSON.stringify(this.source) !== JSON.stringify(e3.source) || this.layerType !== e3.type;\n            };\n            ag.needsNewLayer = function(e3) {\n              return this.layerType !== e3.type || this.below !== this.subplot.belowLookup["layout-" + this.index];\n            };\n            ag.lookupBelow = function() {\n              return this.subplot.belowLookup["layout-" + this.index];\n            };\n            ag.updateImage = function(e3) {\n              var t3 = this.subplot.map;\n              t3.getSource(this.idSource).updateImage({ url: e3.source, coordinates: e3.coordinates });\n              var r4 = this.findFollowingMapLayerId(this.lookupBelow());\n              r4 !== null && this.subplot.map.moveLayer(this.idLayer, r4);\n            };\n            ag.updateSource = function(e3) {\n              var t3 = this.subplot.map;\n              if (t3.getSource(this.idSource) && t3.removeSource(this.idSource), this.sourceType = e3.sourcetype, this.source = e3.source, !!c7(e3)) {\n                var r4 = MXt(e3);\n                t3.addSource(this.idSource, r4);\n              }\n            };\n            ag.findFollowingMapLayerId = function(e3) {\n              if (e3 === "traces") for (var t3 = this.subplot.getMapLayers(), r4 = 0; r4 < t3.length; r4++) {\n                var n4 = t3[r4].id;\n                if (typeof n4 == "string" && n4.indexOf(sje.traceLayerPrefix) === 0) {\n                  e3 = n4;\n                  break;\n                }\n              }\n              return e3;\n            };\n            ag.updateLayer = function(e3) {\n              var t3 = this.subplot, r4 = uje(e3), n4 = this.lookupBelow(), i3 = this.findFollowingMapLayerId(n4);\n              this.removeLayer(), c7(e3) && t3.addLayer({ id: this.idLayer, source: this.idSource, "source-layer": e3.sourcelayer || "", type: e3.type, minzoom: e3.minzoom, maxzoom: e3.maxzoom, layout: r4.layout, paint: r4.paint }, i3), this.layerType = e3.type, this.below = n4;\n            };\n            ag.updateStyle = function(e3) {\n              if (c7(e3)) {\n                var t3 = uje(e3);\n                this.subplot.setOptions(this.idLayer, "setLayoutProperty", t3.layout), this.subplot.setOptions(this.idLayer, "setPaintProperty", t3.paint);\n              }\n            };\n            ag.removeLayer = function() {\n              var e3 = this.subplot.map;\n              e3.getLayer(this.idLayer) && e3.removeLayer(this.idLayer);\n            };\n            ag.dispose = function() {\n              var e3 = this.subplot.map;\n              e3.getLayer(this.idLayer) && e3.removeLayer(this.idLayer), e3.getSource(this.idSource) && e3.removeSource(this.idSource);\n            };\n            function c7(e3) {\n              if (!e3.visible) return false;\n              var t3 = e3.source;\n              if (Array.isArray(t3) && t3.length > 0) {\n                for (var r4 = 0; r4 < t3.length; r4++) if (typeof t3[r4] != "string" || t3[r4].length === 0) return false;\n                return true;\n              }\n              return aw.isPlainObject(t3) || typeof t3 == "string" && t3.length > 0;\n            }\n            function uje(e3) {\n              var t3 = {}, r4 = {};\n              switch (e3.type) {\n                case "circle":\n                  aw.extendFlat(r4, { "circle-radius": e3.circle.radius, "circle-color": e3.color, "circle-opacity": e3.opacity });\n                  break;\n                case "line":\n                  aw.extendFlat(r4, { "line-width": e3.line.width, "line-color": e3.color, "line-opacity": e3.opacity, "line-dasharray": e3.line.dash });\n                  break;\n                case "fill":\n                  aw.extendFlat(r4, { "fill-color": e3.color, "fill-outline-color": e3.fill.outlinecolor, "fill-opacity": e3.opacity });\n                  break;\n                case "symbol":\n                  var n4 = e3.symbol, i3 = SXt(n4.textposition, n4.iconsize);\n                  aw.extendFlat(t3, { "icon-image": n4.icon + "-15", "icon-size": n4.iconsize / 10, "text-field": n4.text, "text-size": n4.textfont.size, "text-anchor": i3.anchor, "text-offset": i3.offset, "symbol-placement": n4.placement }), aw.extendFlat(r4, { "icon-color": e3.color, "text-color": n4.textfont.color, "text-opacity": e3.opacity });\n                  break;\n                case "raster":\n                  aw.extendFlat(r4, { "raster-fade-duration": 0, "raster-opacity": e3.opacity });\n                  break;\n              }\n              return { layout: t3, paint: r4 };\n            }\n            function MXt(e3) {\n              var t3 = e3.sourcetype, r4 = e3.source, n4 = { type: t3 }, i3;\n              return t3 === "geojson" ? i3 = "data" : t3 === "vector" ? i3 = typeof r4 == "string" ? "url" : "tiles" : t3 === "raster" ? (i3 = "tiles", n4.tileSize = 256) : t3 === "image" && (i3 = "url", n4.coordinates = e3.coordinates), n4[i3] = r4, e3.sourceattribution && (n4.attribution = AXt(e3.sourceattribution)), n4;\n            }\n            cje.exports = function(t3, r4, n4) {\n              var i3 = new lje(t3, r4);\n              return i3.update(n4), i3;\n            };\n          });\n          var _je = ye((kbr, yje) => {\n            "use strict";\n            var PJ = oje(), IJ = Dr(), vje = ix(), hje = qa(), EXt = ho(), kXt = yv(), f7 = vf(), pje = Eg(), CXt = pje.drawMode, LXt = pje.selectMode, PXt = Of().prepSelect, IXt = Of().clearOutline, RXt = Of().clearSelectionsCache, DXt = Of().selectOnClick, ow = wx(), FXt = fje();\n            function gje(e3, t3) {\n              this.id = t3, this.gd = e3;\n              var r4 = e3._fullLayout, n4 = e3._context;\n              this.container = r4._glcontainer.node(), this.isStatic = n4.staticPlot, this.uid = r4._uid + "-" + this.id, this.div = null, this.xaxis = null, this.yaxis = null, this.createFramework(r4), this.map = null, this.styleObj = null, this.traceHash = {}, this.layerList = [], this.belowLookup = {}, this.dragging = false, this.wheeling = false;\n            }\n            var Uh = gje.prototype;\n            Uh.plot = function(e3, t3, r4) {\n              var n4 = this, i3;\n              n4.map ? i3 = new Promise(function(a4, o4) {\n                n4.updateMap(e3, t3, a4, o4);\n              }) : i3 = new Promise(function(a4, o4) {\n                n4.createMap(e3, t3, a4, o4);\n              }), r4.push(i3);\n            };\n            Uh.createMap = function(e3, t3, r4, n4) {\n              var i3 = this, a4 = t3[i3.id], o4 = i3.styleObj = mje(a4.style), s3 = a4.bounds, l3 = s3 ? [[s3.west, s3.south], [s3.east, s3.north]] : null, u4 = i3.map = new PJ.Map({ container: i3.div, style: o4.style, center: RJ(a4.center), zoom: a4.zoom, bearing: a4.bearing, pitch: a4.pitch, maxBounds: l3, interactive: !i3.isStatic, preserveDrawingBuffer: i3.isStatic, doubleClickZoom: false, boxZoom: false, attributionControl: false }).addControl(new PJ.AttributionControl({ compact: true })), c5 = {};\n              u4.on("styleimagemissing", function(h3) {\n                var d3 = h3.id;\n                if (!c5[d3] && d3.includes("-15")) {\n                  c5[d3] = true;\n                  var v3 = new Image(15, 15);\n                  v3.onload = function() {\n                    u4.addImage(d3, v3);\n                  }, v3.crossOrigin = "Anonymous", v3.src = "https://unpkg.com/maki@2.1.0/icons/" + d3 + ".svg";\n                }\n              }), u4.setTransformRequest(function(h3) {\n                return h3 = h3.replace("https://fonts.openmaptiles.org/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold"), h3 = h3.replace("https://tiles.basemaps.cartocdn.com/fonts/Open Sans Extrabold", "https://fonts.openmaptiles.org/Open Sans Extra Bold"), h3 = h3.replace("https://fonts.openmaptiles.org/Open Sans Regular,Arial Unicode MS Regular", "https://fonts.openmaptiles.org/Klokantech Noto Sans Regular"), { url: h3 };\n              }), u4._canvas.style.left = "0px", u4._canvas.style.top = "0px", i3.rejectOnError(n4), i3.isStatic || i3.initFx(e3, t3);\n              var f4 = [];\n              f4.push(new Promise(function(h3) {\n                u4.once("load", h3);\n              })), f4 = f4.concat(vje.fetchTraceGeoData(e3)), Promise.all(f4).then(function() {\n                i3.fillBelowLookup(e3, t3), i3.updateData(e3), i3.updateLayout(t3), i3.resolveOnRender(r4);\n              }).catch(n4);\n            };\n            Uh.updateMap = function(e3, t3, r4, n4) {\n              var i3 = this, a4 = i3.map, o4 = t3[this.id];\n              i3.rejectOnError(n4);\n              var s3 = [], l3 = mje(o4.style);\n              JSON.stringify(i3.styleObj) !== JSON.stringify(l3) && (i3.styleObj = l3, a4.setStyle(l3.style), i3.traceHash = {}, s3.push(new Promise(function(u4) {\n                a4.once("styledata", u4);\n              }))), s3 = s3.concat(vje.fetchTraceGeoData(e3)), Promise.all(s3).then(function() {\n                i3.fillBelowLookup(e3, t3), i3.updateData(e3), i3.updateLayout(t3), i3.resolveOnRender(r4);\n              }).catch(n4);\n            };\n            Uh.fillBelowLookup = function(e3, t3) {\n              var r4 = t3[this.id], n4 = r4.layers, i3, a4, o4 = this.belowLookup = {}, s3 = false;\n              for (i3 = 0; i3 < e3.length; i3++) {\n                var l3 = e3[i3][0].trace, u4 = l3._module;\n                typeof l3.below == "string" ? a4 = l3.below : u4.getBelow && (a4 = u4.getBelow(l3, this)), a4 === "" && (s3 = true), o4["trace-" + l3.uid] = a4 || "";\n              }\n              for (i3 = 0; i3 < n4.length; i3++) {\n                var c5 = n4[i3];\n                typeof c5.below == "string" ? a4 = c5.below : s3 ? a4 = "traces" : a4 = "", o4["layout-" + i3] = a4;\n              }\n              var f4 = {}, h3, d3;\n              for (h3 in o4) a4 = o4[h3], f4[a4] ? f4[a4].push(h3) : f4[a4] = [h3];\n              for (a4 in f4) {\n                var v3 = f4[a4];\n                if (v3.length > 1) for (i3 = 0; i3 < v3.length; i3++) h3 = v3[i3], h3.indexOf("trace-") === 0 ? (d3 = h3.split("trace-")[1], this.traceHash[d3] && (this.traceHash[d3].below = null)) : h3.indexOf("layout-") === 0 && (d3 = h3.split("layout-")[1], this.layerList[d3] && (this.layerList[d3].below = null));\n              }\n            };\n            var dje = { choroplethmap: 0, densitymap: 1, scattermap: 2 };\n            Uh.updateData = function(e3) {\n              var t3 = this.traceHash, r4, n4, i3, a4, o4 = e3.slice().sort(function(f4, h3) {\n                return dje[f4[0].trace.type] - dje[h3[0].trace.type];\n              });\n              for (i3 = 0; i3 < o4.length; i3++) {\n                var s3 = o4[i3];\n                n4 = s3[0].trace, r4 = t3[n4.uid];\n                var l3 = false;\n                r4 && (r4.type === n4.type ? (r4.update(s3), l3 = true) : r4.dispose()), !l3 && n4._module && (t3[n4.uid] = n4._module.plot(this, s3));\n              }\n              var u4 = Object.keys(t3);\n              e: for (i3 = 0; i3 < u4.length; i3++) {\n                var c5 = u4[i3];\n                for (a4 = 0; a4 < e3.length; a4++) if (n4 = e3[a4][0].trace, c5 === n4.uid) continue e;\n                r4 = t3[c5], r4.dispose(), delete t3[c5];\n              }\n            };\n            Uh.updateLayout = function(e3) {\n              var t3 = this.map, r4 = e3[this.id];\n              !this.dragging && !this.wheeling && (t3.setCenter(RJ(r4.center)), t3.setZoom(r4.zoom), t3.setBearing(r4.bearing), t3.setPitch(r4.pitch)), this.updateLayers(e3), this.updateFramework(e3), this.updateFx(e3), this.map.resize(), this.gd._context._scrollZoom.map ? t3.scrollZoom.enable() : t3.scrollZoom.disable();\n            };\n            Uh.resolveOnRender = function(e3) {\n              var t3 = this.map;\n              t3.on("render", function r4() {\n                t3.loaded() && (t3.off("render", r4), setTimeout(e3, 10));\n              });\n            };\n            Uh.rejectOnError = function(e3) {\n              var t3 = this.map;\n              function r4() {\n                e3(new Error(ow.mapOnErrorMsg));\n              }\n              t3.once("error", r4), t3.once("style.error", r4), t3.once("source.error", r4), t3.once("tile.error", r4), t3.once("layer.error", r4);\n            };\n            Uh.createFramework = function(e3) {\n              var t3 = this, r4 = t3.div = document.createElement("div");\n              r4.id = t3.uid, r4.style.position = "absolute", t3.container.appendChild(r4), t3.xaxis = { _id: "x", c2p: function(n4) {\n                return t3.project(n4).x;\n              } }, t3.yaxis = { _id: "y", c2p: function(n4) {\n                return t3.project(n4).y;\n              } }, t3.updateFramework(e3), t3.mockAxis = { type: "linear", showexponent: "all", exponentformat: "B" }, EXt.setConvert(t3.mockAxis, e3);\n            };\n            Uh.initFx = function(e3, t3) {\n              var r4 = this, n4 = r4.gd, i3 = r4.map;\n              i3.on("moveend", function(s3) {\n                if (r4.map) {\n                  var l3 = n4._fullLayout;\n                  if (s3.originalEvent || r4.wheeling) {\n                    var u4 = l3[r4.id];\n                    hje.call("_storeDirectGUIEdit", n4.layout, l3._preGUI, r4.getViewEdits(u4));\n                    var c5 = r4.getView();\n                    u4._input.center = u4.center = c5.center, u4._input.zoom = u4.zoom = c5.zoom, u4._input.bearing = u4.bearing = c5.bearing, u4._input.pitch = u4.pitch = c5.pitch, n4.emit("plotly_relayout", r4.getViewEditsWithDerived(c5));\n                  }\n                  s3.originalEvent && s3.originalEvent.type === "mouseup" ? r4.dragging = false : r4.wheeling && (r4.wheeling = false), l3 && l3._rehover && l3._rehover();\n                }\n              }), i3.on("wheel", function() {\n                r4.wheeling = true;\n              }), i3.on("mousemove", function(s3) {\n                var l3 = r4.div.getBoundingClientRect(), u4 = [s3.originalEvent.offsetX, s3.originalEvent.offsetY];\n                s3.target.getBoundingClientRect = function() {\n                  return l3;\n                }, r4.xaxis.p2c = function() {\n                  return i3.unproject(u4).lng;\n                }, r4.yaxis.p2c = function() {\n                  return i3.unproject(u4).lat;\n                }, n4._fullLayout._rehover = function() {\n                  n4._fullLayout._hoversubplot === r4.id && n4._fullLayout[r4.id] && f7.hover(n4, s3, r4.id);\n                }, f7.hover(n4, s3, r4.id), n4._fullLayout._hoversubplot = r4.id;\n              });\n              function a4() {\n                f7.loneUnhover(t3._hoverlayer);\n              }\n              i3.on("dragstart", function() {\n                r4.dragging = true, a4();\n              }), i3.on("zoomstart", a4), i3.on("mouseout", function() {\n                n4._fullLayout._hoversubplot = null;\n              });\n              function o4() {\n                var s3 = r4.getView();\n                n4.emit("plotly_relayouting", r4.getViewEditsWithDerived(s3));\n              }\n              i3.on("drag", o4), i3.on("zoom", o4), i3.on("dblclick", function() {\n                var s3 = n4._fullLayout[r4.id];\n                hje.call("_storeDirectGUIEdit", n4.layout, n4._fullLayout._preGUI, r4.getViewEdits(s3));\n                var l3 = r4.viewInitial;\n                i3.setCenter(RJ(l3.center)), i3.setZoom(l3.zoom), i3.setBearing(l3.bearing), i3.setPitch(l3.pitch);\n                var u4 = r4.getView();\n                s3._input.center = s3.center = u4.center, s3._input.zoom = s3.zoom = u4.zoom, s3._input.bearing = s3.bearing = u4.bearing, s3._input.pitch = s3.pitch = u4.pitch, n4.emit("plotly_doubleclick", null), n4.emit("plotly_relayout", r4.getViewEditsWithDerived(u4));\n              }), r4.clearOutline = function() {\n                RXt(r4.dragOptions), IXt(r4.dragOptions.gd);\n              }, r4.onClickInPanFn = function(s3) {\n                return function(l3) {\n                  var u4 = n4._fullLayout.clickmode;\n                  u4.indexOf("select") > -1 && DXt(l3.originalEvent, n4, [r4.xaxis], [r4.yaxis], r4.id, s3), u4.indexOf("event") > -1 && f7.click(n4, l3.originalEvent);\n                };\n              };\n            };\n            Uh.updateFx = function(e3) {\n              var t3 = this, r4 = t3.map, n4 = t3.gd;\n              if (t3.isStatic) return;\n              function i3(l3) {\n                var u4 = t3.map.unproject(l3);\n                return [u4.lng, u4.lat];\n              }\n              var a4 = e3.dragmode, o4;\n              o4 = function(l3, u4) {\n                if (u4.isRect) {\n                  var c5 = l3.range = {};\n                  c5[t3.id] = [i3([u4.xmin, u4.ymin]), i3([u4.xmax, u4.ymax])];\n                } else {\n                  var f4 = l3.lassoPoints = {};\n                  f4[t3.id] = u4.map(i3);\n                }\n              };\n              var s3 = t3.dragOptions;\n              t3.dragOptions = IJ.extendDeep(s3 || {}, { dragmode: e3.dragmode, element: t3.div, gd: n4, plotinfo: { id: t3.id, domain: e3[t3.id].domain, xaxis: t3.xaxis, yaxis: t3.yaxis, fillRangeItems: o4 }, xaxes: [t3.xaxis], yaxes: [t3.yaxis], subplot: t3.id }), r4.off("click", t3.onClickInPanHandler), LXt(a4) || CXt(a4) ? (r4.dragPan.disable(), r4.on("zoomstart", t3.clearOutline), t3.dragOptions.prepFn = function(l3, u4, c5) {\n                PXt(l3, u4, c5, t3.dragOptions, a4);\n              }, kXt.init(t3.dragOptions)) : (r4.dragPan.enable(), r4.off("zoomstart", t3.clearOutline), t3.div.onmousedown = null, t3.div.ontouchstart = null, t3.div.removeEventListener("touchstart", t3.div._ontouchstart), t3.onClickInPanHandler = t3.onClickInPanFn(t3.dragOptions), r4.on("click", t3.onClickInPanHandler));\n            };\n            Uh.updateFramework = function(e3) {\n              var t3 = e3[this.id].domain, r4 = e3._size, n4 = this.div.style;\n              n4.width = r4.w * (t3.x[1] - t3.x[0]) + "px", n4.height = r4.h * (t3.y[1] - t3.y[0]) + "px", n4.left = r4.l + t3.x[0] * r4.w + "px", n4.top = r4.t + (1 - t3.y[1]) * r4.h + "px", this.xaxis._offset = r4.l + t3.x[0] * r4.w, this.xaxis._length = r4.w * (t3.x[1] - t3.x[0]), this.yaxis._offset = r4.t + (1 - t3.y[1]) * r4.h, this.yaxis._length = r4.h * (t3.y[1] - t3.y[0]);\n            };\n            Uh.updateLayers = function(e3) {\n              var t3 = e3[this.id], r4 = t3.layers, n4 = this.layerList, i3;\n              if (r4.length !== n4.length) {\n                for (i3 = 0; i3 < n4.length; i3++) n4[i3].dispose();\n                for (n4 = this.layerList = [], i3 = 0; i3 < r4.length; i3++) n4.push(FXt(this, i3, r4[i3]));\n              } else for (i3 = 0; i3 < r4.length; i3++) n4[i3].update(r4[i3]);\n            };\n            Uh.destroy = function() {\n              this.map && (this.map.remove(), this.map = null, this.container.removeChild(this.div));\n            };\n            Uh.toImage = function() {\n              return this.map.stop(), this.map.getCanvas().toDataURL();\n            };\n            Uh.setOptions = function(e3, t3, r4) {\n              for (var n4 in r4) this.map[t3](e3, n4, r4[n4]);\n            };\n            Uh.getMapLayers = function() {\n              return this.map.getStyle().layers;\n            };\n            Uh.addLayer = function(e3, t3) {\n              var r4 = this.map;\n              if (typeof t3 == "string") {\n                if (t3 === "") {\n                  r4.addLayer(e3, t3);\n                  return;\n                }\n                for (var n4 = this.getMapLayers(), i3 = 0; i3 < n4.length; i3++) if (t3 === n4[i3].id) {\n                  r4.addLayer(e3, t3);\n                  return;\n                }\n                IJ.warn(["Trying to add layer with *below* value", t3, "referencing a layer that does not exist", "or that does not yet exist."].join(" "));\n              }\n              r4.addLayer(e3);\n            };\n            Uh.project = function(e3) {\n              return this.map.project(new PJ.LngLat(e3[0], e3[1]));\n            };\n            Uh.getView = function() {\n              var e3 = this.map, t3 = e3.getCenter(), r4 = t3.lng, n4 = t3.lat, i3 = { lon: r4, lat: n4 }, a4 = e3.getCanvas(), o4 = parseInt(a4.style.width), s3 = parseInt(a4.style.height);\n              return { center: i3, zoom: e3.getZoom(), bearing: e3.getBearing(), pitch: e3.getPitch(), _derived: { coordinates: [e3.unproject([0, 0]).toArray(), e3.unproject([o4, 0]).toArray(), e3.unproject([o4, s3]).toArray(), e3.unproject([0, s3]).toArray()] } };\n            };\n            Uh.getViewEdits = function(e3) {\n              for (var t3 = this.id, r4 = ["center", "zoom", "bearing", "pitch"], n4 = {}, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3];\n                n4[t3 + "." + a4] = e3[a4];\n              }\n              return n4;\n            };\n            Uh.getViewEditsWithDerived = function(e3) {\n              var t3 = this.id, r4 = this.getViewEdits(e3);\n              return r4[t3 + "._derived"] = e3._derived, r4;\n            };\n            function mje(e3) {\n              var t3 = {};\n              return IJ.isPlainObject(e3) ? (t3.id = e3.id, t3.style = e3) : typeof e3 == "string" ? (t3.id = e3, ow.stylesMap[e3] ? t3.style = ow.stylesMap[e3] : t3.style = e3) : (t3.id = ow.styleValueDflt, t3.style = zXt(ow.styleValueDflt)), t3.transition = { duration: 0, delay: 0 }, t3;\n            }\n            function zXt(e3) {\n              return ow.styleUrlPrefix + e3 + "-" + ow.styleUrlSuffix;\n            }\n            function RJ(e3) {\n              return [e3.lon, e3.lat];\n            }\n            yje.exports = gje;\n          });\n          var wje = ye((Cbr, bje) => {\n            "use strict";\n            var DJ = Dr(), OXt = k_(), qXt = Yd(), xje = jk();\n            bje.exports = function(t3, r4, n4) {\n              OXt(t3, r4, n4, { type: "map", attributes: xje, handleDefaults: BXt, partition: "y" });\n            };\n            function BXt(e3, t3, r4) {\n              r4("style"), r4("center.lon"), r4("center.lat"), r4("zoom"), r4("bearing"), r4("pitch");\n              var n4 = r4("bounds.west"), i3 = r4("bounds.east"), a4 = r4("bounds.south"), o4 = r4("bounds.north");\n              (n4 === void 0 || i3 === void 0 || a4 === void 0 || o4 === void 0) && delete t3.bounds, qXt(e3, t3, { name: "layers", handleItemDefaults: NXt }), t3._input = e3;\n            }\n            function NXt(e3, t3) {\n              function r4(l3, u4) {\n                return DJ.coerce(e3, t3, xje.layers, l3, u4);\n              }\n              var n4 = r4("visible");\n              if (n4) {\n                var i3 = r4("sourcetype"), a4 = i3 === "raster" || i3 === "image";\n                r4("source"), r4("sourceattribution"), i3 === "vector" && r4("sourcelayer"), i3 === "image" && r4("coordinates");\n                var o4;\n                a4 && (o4 = "raster");\n                var s3 = r4("type", o4);\n                a4 && s3 !== "raster" && (s3 = t3.type = "raster", DJ.log("Source types *raster* and *image* must drawn *raster* layer type.")), r4("below"), r4("color"), r4("opacity"), r4("minzoom"), r4("maxzoom"), s3 === "circle" && r4("circle.radius"), s3 === "line" && (r4("line.width"), r4("line.dash")), s3 === "fill" && r4("fill.outlinecolor"), s3 === "symbol" && (r4("symbol.icon"), r4("symbol.iconsize"), r4("symbol.text"), DJ.coerceFont(r4, "symbol.textfont", void 0, { noFontVariant: true, noFontShadow: true, noFontLineposition: true, noFontTextcase: true }), r4("symbol.textposition"), r4("symbol.placement"));\n              }\n            }\n          });\n          var d7 = ye((l0) => {\n            "use strict";\n            var h7 = Dr(), Tje = h7.strTranslate, UXt = h7.strScale, VXt = Id().getSubplotCalcData, GXt = Wp(), HXt = Oa(), Aje = So(), jXt = ru(), WXt = _je(), Tx = "map";\n            l0.name = Tx;\n            l0.attr = "subplot";\n            l0.idRoot = Tx;\n            l0.idRegex = l0.attrRegex = h7.counterRegex(Tx);\n            l0.attributes = { subplot: { valType: "subplotid", dflt: "map", editType: "calc" } };\n            l0.layoutAttributes = jk();\n            l0.supplyLayoutDefaults = wje();\n            l0.plot = function(t3) {\n              for (var r4 = t3._fullLayout, n4 = t3.calcdata, i3 = r4._subplots[Tx], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = VXt(n4, Tx, o4), l3 = r4[o4], u4 = l3._subplot;\n                u4 || (u4 = new WXt(t3, o4), r4[o4]._subplot = u4), u4.viewInitial || (u4.viewInitial = { center: h7.extendFlat({}, l3.center), zoom: l3.zoom, bearing: l3.bearing, pitch: l3.pitch }), u4.plot(s3, r4, t3._promises);\n              }\n            };\n            l0.clean = function(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[Tx] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4];\n                !t3[o4] && n4[o4]._subplot && n4[o4]._subplot.destroy();\n              }\n            };\n            l0.toSVG = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[Tx], n4 = t3._size, i3 = 0; i3 < r4.length; i3++) {\n                var a4 = t3[r4[i3]], o4 = a4.domain, s3 = a4._subplot, l3 = s3.toImage("png"), u4 = t3._glimages.append("svg:image");\n                u4.attr({ xmlns: GXt.svg, "xlink:href": l3, x: n4.l + n4.w * o4.x[0], y: n4.t + n4.h * (1 - o4.y[1]), width: n4.w * (o4.x[1] - o4.x[0]), height: n4.h * (o4.y[1] - o4.y[0]), preserveAspectRatio: "none" });\n                var c5 = HXt.select(a4._subplot.div), f4 = c5.select(".maplibregl-ctrl-attrib").text().replace("Improve this map", ""), h3 = t3._glimages.append("g"), d3 = h3.append("text");\n                d3.text(f4).classed("static-attribution", true).attr({ "font-size": 12, "font-family": "Arial", color: "rgba(0, 0, 0, 0.75)", "text-anchor": "end", "data-unformatted": f4 });\n                var v3 = Aje.bBox(d3.node()), _2 = n4.w * (o4.x[1] - o4.x[0]);\n                if (v3.width > _2 / 2) {\n                  var b = f4.split("|").join("<br>");\n                  d3.text(b).attr("data-unformatted", b).call(jXt.convertToTspans, e3), v3 = Aje.bBox(d3.node());\n                }\n                d3.attr("transform", Tje(-3, -v3.height + 8)), h3.insert("rect", ".static-attribution").attr({ x: -v3.width - 6, y: -v3.height - 3, width: v3.width + 6, height: v3.height + 3, fill: "rgba(255, 255, 255, 0.75)" });\n                var p3 = 1;\n                v3.width + 6 > _2 && (p3 = _2 / (v3.width + 6));\n                var k4 = [n4.l + n4.w * o4.x[1], n4.t + n4.h * (1 - o4.y[0])];\n                h3.attr("transform", Tje(k4[0], k4[1]) + UXt(p3));\n              }\n            };\n            l0.updateFx = function(e3) {\n              for (var t3 = e3._fullLayout, r4 = t3._subplots[Tx], n4 = 0; n4 < r4.length; n4++) {\n                var i3 = t3[r4[n4]]._subplot;\n                i3.updateFx(t3);\n              }\n            };\n          });\n          var Mje = ye((Pbr, Sje) => {\n            "use strict";\n            Sje.exports = { attributes: n7(), supplyDefaults: qHe(), colorbar: $d(), formatLabels: AJ(), calc: pF(), plot: $He(), hoverPoints: u7().hoverPoints, eventData: rje(), selectPoints: nje(), styleOnSelect: function(e3, t3) {\n              if (t3) {\n                var r4 = t3[0].trace;\n                r4._glTrace.update(t3);\n              }\n            }, moduleType: "trace", name: "scattermap", basePlotModule: d7(), categories: ["map", "gl", "symbols", "showLegend", "scatter-like"], meta: {} };\n          });\n          var kje = ye((Ibr, Eje) => {\n            "use strict";\n            Eje.exports = Mje();\n          });\n          var FJ = ye((Rbr, Cje) => {\n            "use strict";\n            var d1 = t5(), XXt = Tu(), { hovertemplateAttrs: ZXt, templatefallbackAttrs: YXt } = Ll(), KXt = Gl(), Ax = Ao().extendFlat;\n            Cje.exports = Ax({ locations: { valType: "data_array", editType: "calc" }, z: { valType: "data_array", editType: "calc" }, geojson: { valType: "any", editType: "calc" }, featureidkey: Ax({}, d1.featureidkey, {}), below: { valType: "string", editType: "plot" }, text: d1.text, hovertext: d1.hovertext, marker: { line: { color: Ax({}, d1.marker.line.color, { editType: "plot" }), width: Ax({}, d1.marker.line.width, { editType: "plot" }), editType: "calc" }, opacity: Ax({}, d1.marker.opacity, { editType: "plot" }), editType: "calc" }, selected: { marker: { opacity: Ax({}, d1.selected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, unselected: { marker: { opacity: Ax({}, d1.unselected.marker.opacity, { editType: "plot" }), editType: "plot" }, editType: "plot" }, hoverinfo: d1.hoverinfo, hovertemplate: ZXt({}, { keys: ["properties"] }), hovertemplatefallback: YXt(), showlegend: Ax({}, KXt.showlegend, { dflt: false }) }, XXt("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var Pje = ye((Dbr, Lje) => {\n            "use strict";\n            var Yk = Dr(), JXt = Qh(), $Xt = FJ();\n            Lje.exports = function(t3, r4, n4, i3) {\n              function a4(c5, f4) {\n                return Yk.coerce(t3, r4, $Xt, c5, f4);\n              }\n              var o4 = a4("locations"), s3 = a4("z"), l3 = a4("geojson");\n              if (!Yk.isArrayOrTypedArray(o4) || !o4.length || !Yk.isArrayOrTypedArray(s3) || !s3.length || !(typeof l3 == "string" && l3 !== "" || Yk.isPlainObject(l3))) {\n                r4.visible = false;\n                return;\n              }\n              a4("featureidkey"), r4._length = Math.min(o4.length, s3.length), a4("below"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback");\n              var u4 = a4("marker.line.width");\n              u4 && a4("marker.line.color"), a4("marker.opacity"), JXt(t3, r4, i3, a4, { prefix: "", cLetter: "z" }), Yk.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var zJ = ye((Fbr, Dje) => {\n            "use strict";\n            var QXt = Eo(), v1 = Dr(), eZt = tc(), tZt = So(), rZt = tx().makeBlank, Ije = ix();\n            function iZt(e3) {\n              var t3 = e3[0].trace, r4 = t3.visible === true && t3._length !== 0, n4 = { layout: { visibility: "none" }, paint: {} }, i3 = { layout: { visibility: "none" }, paint: {} }, a4 = t3._opts = { fill: n4, line: i3, geojson: rZt() };\n              if (!r4) return a4;\n              var o4 = Ije.extractTraceFeature(e3);\n              if (!o4) return a4;\n              var s3 = eZt.makeColorScaleFuncFromTrace(t3), l3 = t3.marker, u4 = l3.line || {}, c5;\n              v1.isArrayOrTypedArray(l3.opacity) && (c5 = function(k4) {\n                var E3 = k4.mo;\n                return QXt(E3) ? +v1.constrain(E3, 0, 1) : 0;\n              });\n              var f4;\n              v1.isArrayOrTypedArray(u4.color) && (f4 = function(k4) {\n                return k4.mlc;\n              });\n              var h3;\n              v1.isArrayOrTypedArray(u4.width) && (h3 = function(k4) {\n                return k4.mlw;\n              });\n              for (var d3 = 0; d3 < e3.length; d3++) {\n                var v3 = e3[d3], _2 = v3.fOut;\n                if (_2) {\n                  var b = _2.properties;\n                  b.fc = s3(v3.z), c5 && (b.mo = c5(v3)), f4 && (b.mlc = f4(v3)), h3 && (b.mlw = h3(v3)), v3.ct = b.ct, v3._polygons = Ije.feature2polygons(_2);\n                }\n              }\n              var p3 = c5 ? { type: "identity", property: "mo" } : l3.opacity;\n              return v1.extendFlat(n4.paint, { "fill-color": { type: "identity", property: "fc" }, "fill-opacity": p3 }), v1.extendFlat(i3.paint, { "line-color": f4 ? { type: "identity", property: "mlc" } : u4.color, "line-width": h3 ? { type: "identity", property: "mlw" } : u4.width, "line-opacity": p3 }), n4.layout.visibility = "visible", i3.layout.visibility = "visible", a4.geojson = { type: "FeatureCollection", features: o4 }, Rje(e3), a4;\n            }\n            function Rje(e3) {\n              var t3 = e3[0].trace, r4 = t3._opts, n4;\n              if (t3.selectedpoints) {\n                for (var i3 = tZt.makeSelectedPointStyleFns(t3), a4 = 0; a4 < e3.length; a4++) {\n                  var o4 = e3[a4];\n                  o4.fOut && (o4.fOut.properties.mo2 = i3.selectedOpacityFn(o4));\n                }\n                n4 = { type: "identity", property: "mo2" };\n              } else n4 = v1.isArrayOrTypedArray(t3.marker.opacity) ? { type: "identity", property: "mo" } : t3.marker.opacity;\n              return v1.extendFlat(r4.fill.paint, { "fill-opacity": n4 }), v1.extendFlat(r4.line.paint, { "line-opacity": n4 }), r4;\n            }\n            Dje.exports = { convert: iZt, convertOnSelect: Rje };\n          });\n          var Bje = ye((zbr, qje) => {\n            "use strict";\n            var zje = zJ().convert, nZt = zJ().convertOnSelect, Fje = wx().traceLayerPrefix;\n            function Oje(e3, t3) {\n              this.type = "choroplethmap", this.subplot = e3, this.uid = t3, this.sourceId = "source-" + t3, this.layerList = [["fill", Fje + t3 + "-fill"], ["line", Fje + t3 + "-line"]], this.below = null;\n            }\n            var L5 = Oje.prototype;\n            L5.update = function(e3) {\n              this._update(zje(e3)), e3[0].trace._glTrace = this;\n            };\n            L5.updateOnSelect = function(e3) {\n              this._update(nZt(e3));\n            };\n            L5._update = function(e3) {\n              var t3 = this.subplot, r4 = this.layerList, n4 = t3.belowLookup["trace-" + this.uid];\n              t3.map.getSource(this.sourceId).setData(e3.geojson), n4 !== this.below && (this._removeLayers(), this._addLayers(e3, n4), this.below = n4);\n              for (var i3 = 0; i3 < r4.length; i3++) {\n                var a4 = r4[i3], o4 = a4[0], s3 = a4[1], l3 = e3[o4];\n                t3.setOptions(s3, "setLayoutProperty", l3.layout), l3.layout.visibility === "visible" && t3.setOptions(s3, "setPaintProperty", l3.paint);\n              }\n            };\n            L5._addLayers = function(e3, t3) {\n              for (var r4 = this.subplot, n4 = this.layerList, i3 = this.sourceId, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = o4[0], l3 = e3[s3];\n                r4.addLayer({ type: s3, id: o4[1], source: i3, layout: l3.layout, paint: l3.paint }, t3);\n              }\n            };\n            L5._removeLayers = function() {\n              for (var e3 = this.subplot.map, t3 = this.layerList, r4 = t3.length - 1; r4 >= 0; r4--) e3.removeLayer(t3[r4][1]);\n            };\n            L5.dispose = function() {\n              var e3 = this.subplot.map;\n              this._removeLayers(), e3.removeSource(this.sourceId);\n            };\n            qje.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = new Oje(t3, n4.uid), a4 = i3.sourceId, o4 = zje(r4), s3 = i3.below = t3.belowLookup["trace-" + n4.uid];\n              return t3.map.addSource(a4, { type: "geojson", data: o4.geojson }), i3._addLayers(o4, s3), r4[0].trace._glTrace = i3, i3;\n            };\n          });\n          var Uje = ye((Obr, Nje) => {\n            "use strict";\n            Nje.exports = { attributes: FJ(), supplyDefaults: Pje(), colorbar: S_(), calc: zF(), plot: Bje(), hoverPoints: qF(), eventData: BF(), selectPoints: NF(), styleOnSelect: function(e3, t3) {\n              if (t3) {\n                var r4 = t3[0].trace;\n                r4._glTrace.updateOnSelect(t3);\n              }\n            }, getBelow: function(e3, t3) {\n              for (var r4 = t3.getMapLayers(), n4 = r4.length - 2; n4 >= 0; n4--) {\n                var i3 = r4[n4].id;\n                if (typeof i3 == "string" && i3.indexOf("water") === 0) {\n                  for (var a4 = n4 + 1; a4 < r4.length; a4++) if (i3 = r4[a4].id, typeof i3 == "string" && i3.indexOf("plotly-") === -1) return i3;\n                }\n              }\n            }, moduleType: "trace", name: "choroplethmap", basePlotModule: d7(), categories: ["map", "gl", "noOpacity", "showLegend"], meta: { hr_name: "choropleth_map" } };\n          });\n          var Gje = ye((qbr, Vje) => {\n            "use strict";\n            Vje.exports = Uje();\n          });\n          var qJ = ye((Bbr, jje) => {\n            "use strict";\n            var aZt = Tu(), { hovertemplateAttrs: oZt, templatefallbackAttrs: sZt } = Ll(), Hje = Gl(), v7 = n7(), OJ = Ao().extendFlat;\n            jje.exports = OJ({ lon: v7.lon, lat: v7.lat, z: { valType: "data_array", editType: "calc" }, radius: { valType: "number", editType: "plot", arrayOk: true, min: 1, dflt: 30 }, below: { valType: "string", editType: "plot" }, text: v7.text, hovertext: v7.hovertext, hoverinfo: OJ({}, Hje.hoverinfo, { flags: ["lon", "lat", "z", "text", "name"] }), hovertemplate: oZt(), hovertemplatefallback: sZt(), showlegend: OJ({}, Hje.showlegend, { dflt: false }) }, aZt("", { cLetter: "z", editTypeOverride: "calc" }));\n          });\n          var Xje = ye((Nbr, Wje) => {\n            "use strict";\n            var lZt = Dr(), uZt = Qh(), cZt = qJ();\n            Wje.exports = function(t3, r4, n4, i3) {\n              function a4(u4, c5) {\n                return lZt.coerce(t3, r4, cZt, u4, c5);\n              }\n              var o4 = a4("lon") || [], s3 = a4("lat") || [], l3 = Math.min(o4.length, s3.length);\n              if (!l3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = l3, a4("z"), a4("radius"), a4("below"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), uZt(t3, r4, i3, a4, { prefix: "", cLetter: "z" });\n            };\n          });\n          var Kje = ye((Ubr, Yje) => {\n            "use strict";\n            var BJ = Eo(), fZt = Dr().isArrayOrTypedArray, NJ = fs().BADNUM, hZt = gv(), Zje = Dr()._;\n            Yje.exports = function(t3, r4) {\n              for (var n4 = r4._length, i3 = new Array(n4), a4 = r4.z, o4 = fZt(a4) && a4.length, s3 = 0; s3 < n4; s3++) {\n                var l3 = i3[s3] = {}, u4 = r4.lon[s3], c5 = r4.lat[s3];\n                if (l3.lonlat = BJ(u4) && BJ(c5) ? [+u4, +c5] : [NJ, NJ], o4) {\n                  var f4 = a4[s3];\n                  l3.z = BJ(f4) ? f4 : NJ;\n                }\n              }\n              return hZt(t3, r4, { vals: o4 ? a4 : [0, 1], containerStr: "", cLetter: "z" }), n4 && (i3[0].t = { labels: { lat: Zje(t3, "lat:") + " ", lon: Zje(t3, "lon:") + " " } }), i3;\n            };\n          });\n          var tWe = ye((Vbr, eWe) => {\n            "use strict";\n            var dZt = Eo(), UJ = Dr(), Jje = ka(), $je = tc(), Qje = fs().BADNUM, vZt = tx().makeBlank;\n            eWe.exports = function(t3) {\n              var r4 = t3[0].trace, n4 = r4.visible === true && r4._length !== 0, i3 = { layout: { visibility: "none" }, paint: {} }, a4 = r4._opts = { heatmap: i3, geojson: vZt() };\n              if (!n4) return a4;\n              var o4 = [], s3, l3 = r4.z, u4 = r4.radius, c5 = UJ.isArrayOrTypedArray(l3) && l3.length, f4 = UJ.isArrayOrTypedArray(u4);\n              for (s3 = 0; s3 < t3.length; s3++) {\n                var h3 = t3[s3], d3 = h3.lonlat;\n                if (d3[0] !== Qje) {\n                  var v3 = {};\n                  if (c5) {\n                    var _2 = h3.z;\n                    v3.z = _2 !== Qje ? _2 : 0;\n                  }\n                  f4 && (v3.r = dZt(u4[s3]) && u4[s3] > 0 ? +u4[s3] : 0), o4.push({ type: "Feature", geometry: { type: "Point", coordinates: d3 }, properties: v3 });\n                }\n              }\n              var b = $je.extractOpts(r4), p3 = b.reversescale ? $je.flipScale(b.colorscale) : b.colorscale, k4 = p3[0][1], E3 = Jje.opacity(k4) < 1 ? k4 : Jje.addOpacity(k4, 0), S2 = ["interpolate", ["linear"], ["heatmap-density"], 0, E3];\n              for (s3 = 1; s3 < p3.length; s3++) S2.push(p3[s3][0], p3[s3][1]);\n              var L3 = ["interpolate", ["linear"], ["get", "z"], b.min, 0, b.max, 1];\n              return UJ.extendFlat(a4.heatmap.paint, { "heatmap-weight": c5 ? L3 : 1 / (b.max - b.min), "heatmap-color": S2, "heatmap-radius": f4 ? { type: "identity", property: "r" } : r4.radius, "heatmap-opacity": r4.opacity }), a4.geojson = { type: "FeatureCollection", features: o4 }, a4.heatmap.layout.visibility = "visible", a4;\n            };\n          });\n          var aWe = ye((Gbr, nWe) => {\n            "use strict";\n            var rWe = tWe(), pZt = wx().traceLayerPrefix;\n            function iWe(e3, t3) {\n              this.type = "densitymap", this.subplot = e3, this.uid = t3, this.sourceId = "source-" + t3, this.layerList = [["heatmap", pZt + t3 + "-heatmap"]], this.below = null;\n            }\n            var p7 = iWe.prototype;\n            p7.update = function(e3) {\n              var t3 = this.subplot, r4 = this.layerList, n4 = rWe(e3), i3 = t3.belowLookup["trace-" + this.uid];\n              t3.map.getSource(this.sourceId).setData(n4.geojson), i3 !== this.below && (this._removeLayers(), this._addLayers(n4, i3), this.below = i3);\n              for (var a4 = 0; a4 < r4.length; a4++) {\n                var o4 = r4[a4], s3 = o4[0], l3 = o4[1], u4 = n4[s3];\n                t3.setOptions(l3, "setLayoutProperty", u4.layout), u4.layout.visibility === "visible" && t3.setOptions(l3, "setPaintProperty", u4.paint);\n              }\n            };\n            p7._addLayers = function(e3, t3) {\n              for (var r4 = this.subplot, n4 = this.layerList, i3 = this.sourceId, a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = o4[0], l3 = e3[s3];\n                r4.addLayer({ type: s3, id: o4[1], source: i3, layout: l3.layout, paint: l3.paint }, t3);\n              }\n            };\n            p7._removeLayers = function() {\n              for (var e3 = this.subplot.map, t3 = this.layerList, r4 = t3.length - 1; r4 >= 0; r4--) e3.removeLayer(t3[r4][1]);\n            };\n            p7.dispose = function() {\n              var e3 = this.subplot.map;\n              this._removeLayers(), e3.removeSource(this.sourceId);\n            };\n            nWe.exports = function(t3, r4) {\n              var n4 = r4[0].trace, i3 = new iWe(t3, n4.uid), a4 = i3.sourceId, o4 = rWe(r4), s3 = i3.below = t3.belowLookup["trace-" + n4.uid];\n              return t3.map.addSource(a4, { type: "geojson", data: o4.geojson }), i3._addLayers(o4, s3), i3;\n            };\n          });\n          var sWe = ye((Hbr, oWe) => {\n            "use strict";\n            var gZt = ho(), mZt = u7().hoverPoints, yZt = u7().getExtraText;\n            oWe.exports = function(t3, r4, n4) {\n              var i3 = mZt(t3, r4, n4);\n              if (i3) {\n                var a4 = i3[0], o4 = a4.cd, s3 = o4[0].trace, l3 = o4[a4.index];\n                if (delete a4.color, "z" in l3) {\n                  var u4 = a4.subplot.mockAxis;\n                  a4.z = l3.z, a4.zLabel = gZt.tickText(u4, u4.c2l(l3.z), "hover").text;\n                }\n                return a4.extraText = yZt(s3, l3, o4[0].t.labels), [a4];\n              }\n            };\n          });\n          var uWe = ye((jbr, lWe) => {\n            "use strict";\n            lWe.exports = function(t3, r4) {\n              return t3.lon = r4.lon, t3.lat = r4.lat, t3.z = r4.z, t3;\n            };\n          });\n          var fWe = ye((Wbr, cWe) => {\n            "use strict";\n            cWe.exports = { attributes: qJ(), supplyDefaults: Xje(), colorbar: S_(), formatLabels: AJ(), calc: Kje(), plot: aWe(), hoverPoints: sWe(), eventData: uWe(), getBelow: function(e3, t3) {\n              for (var r4 = t3.getMapLayers(), n4 = 0; n4 < r4.length; n4++) {\n                var i3 = r4[n4], a4 = i3.id;\n                if (i3.type === "symbol" && typeof a4 == "string" && a4.indexOf("plotly-") === -1) return a4;\n              }\n            }, moduleType: "trace", name: "densitymap", basePlotModule: d7(), categories: ["map", "gl", "showLegend"], meta: { hr_name: "density_map" } };\n          });\n          var dWe = ye((Xbr, hWe) => {\n            "use strict";\n            hWe.exports = fWe();\n          });\n          var GJ = ye((Ybr, yWe) => {\n            "use strict";\n            var _Zt = ec(), xZt = Gl(), vWe = Lh(), VJ = a3(), bZt = Cc().attributes, { hovertemplateAttrs: pWe, templatefallbackAttrs: gWe } = Ll(), wZt = Tu(), TZt = vl().templatedArray, AZt = df().descriptionOnlyNumbers, mWe = Ao().extendFlat, SZt = mc().overrideAll, Zbr = yWe.exports = SZt({ hoverinfo: mWe({}, xZt.hoverinfo, { flags: [], arrayOk: false }), hoverlabel: VJ.hoverlabel, domain: bZt({ name: "sankey", trace: true }), orientation: { valType: "enumerated", values: ["v", "h"], dflt: "h" }, valueformat: { valType: "string", dflt: ".3s", description: AZt("value") }, valuesuffix: { valType: "string", dflt: "" }, arrangement: { valType: "enumerated", values: ["snap", "perpendicular", "freeform", "fixed"], dflt: "snap" }, textfont: _Zt({ autoShadowDflt: true }), customdata: void 0, node: { label: { valType: "data_array", dflt: [] }, groups: { valType: "info_array", impliedEdits: { x: [], y: [] }, dimensions: 2, freeLength: true, dflt: [], items: { valType: "number", editType: "calc" } }, x: { valType: "data_array", dflt: [] }, y: { valType: "data_array", dflt: [] }, color: { valType: "color", arrayOk: true }, customdata: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: vWe.defaultLine, arrayOk: true }, width: { valType: "number", min: 0, dflt: 0.5, arrayOk: true } }, pad: { valType: "number", arrayOk: false, min: 0, dflt: 20 }, thickness: { valType: "number", arrayOk: false, min: 1, dflt: 20 }, hoverinfo: { valType: "enumerated", values: ["all", "none", "skip"], dflt: "all" }, hoverlabel: VJ.hoverlabel, hovertemplate: pWe({}, { keys: ["value", "label"] }), hovertemplatefallback: gWe(), align: { valType: "enumerated", values: ["justify", "left", "right", "center"], dflt: "justify" } }, link: { arrowlen: { valType: "number", min: 0, dflt: 0 }, label: { valType: "data_array", dflt: [] }, color: { valType: "color", arrayOk: true }, hovercolor: { valType: "color", arrayOk: true }, customdata: { valType: "data_array", editType: "calc" }, line: { color: { valType: "color", dflt: vWe.defaultLine, arrayOk: true }, width: { valType: "number", min: 0, dflt: 0, arrayOk: true } }, source: { valType: "data_array", dflt: [] }, target: { valType: "data_array", dflt: [] }, value: { valType: "data_array", dflt: [] }, hoverinfo: { valType: "enumerated", values: ["all", "none", "skip"], dflt: "all" }, hoverlabel: VJ.hoverlabel, hovertemplate: pWe({}, { keys: ["value", "label"] }), hovertemplatefallback: gWe(), colorscales: TZt("concentrationscales", { editType: "calc", label: { valType: "string", editType: "calc", dflt: "" }, cmax: { valType: "number", editType: "calc", dflt: 1 }, cmin: { valType: "number", editType: "calc", dflt: 0 }, colorscale: mWe(wZt().colorscale, { dflt: [[0, "white"], [1, "black"]] }) }) } }, "calc", "nested");\n          });\n          var TWe = ye((Kbr, wWe) => {\n            "use strict";\n            var P5 = Dr(), g7 = GJ(), MZt = ka(), _We = cd(), EZt = Cc().defaults, xWe = hM(), bWe = vl(), kZt = Yd();\n            wWe.exports = function(t3, r4, n4, i3) {\n              function a4(S2, L3) {\n                return P5.coerce(t3, r4, g7, S2, L3);\n              }\n              var o4 = P5.extendDeep(i3.hoverlabel, t3.hoverlabel), s3 = t3.node, l3 = bWe.newContainer(r4, "node");\n              function u4(S2, L3) {\n                return P5.coerce(s3, l3, g7.node, S2, L3);\n              }\n              u4("label"), u4("groups"), u4("x"), u4("y"), u4("pad"), u4("thickness"), u4("line.color"), u4("line.width"), u4("hoverinfo", t3.hoverinfo), xWe(s3, l3, u4, o4), u4("hovertemplate"), u4("align");\n              var c5 = i3.colorway, f4 = function(S2) {\n                return c5[S2 % c5.length];\n              };\n              u4("color", l3.label.map(function(S2, L3) {\n                return MZt.addOpacity(f4(L3), 0.8);\n              })), u4("customdata");\n              var h3 = t3.link || {}, d3 = bWe.newContainer(r4, "link");\n              function v3(S2, L3) {\n                return P5.coerce(h3, d3, g7.link, S2, L3);\n              }\n              v3("label"), v3("arrowlen"), v3("source"), v3("target"), v3("value"), v3("line.color"), v3("line.width"), v3("hoverinfo", t3.hoverinfo), xWe(h3, d3, v3, o4), v3("hovertemplate");\n              var _2 = _We(i3.paper_bgcolor).getLuminance() < 0.333, b = _2 ? "rgba(255, 255, 255, 0.6)" : "rgba(0, 0, 0, 0.2)", p3 = v3("color", b);\n              function k4(S2) {\n                var L3 = _We(S2);\n                if (!L3.isValid()) return S2;\n                var x2 = L3.getAlpha();\n                return x2 <= 0.8 ? L3.setAlpha(x2 + 0.2) : L3 = _2 ? L3.brighten() : L3.darken(), L3.toRgbString();\n              }\n              v3("hovercolor", Array.isArray(p3) ? p3.map(k4) : k4(p3)), v3("customdata"), kZt(h3, d3, { name: "colorscales", handleItemDefaults: CZt }), EZt(r4, i3, a4), a4("orientation"), a4("valueformat"), a4("valuesuffix");\n              var E3;\n              l3.x.length && l3.y.length && (E3 = "freeform"), a4("arrangement", E3), P5.coerceFont(a4, "textfont", i3.font, { autoShadowDflt: true }), r4._length = null;\n            };\n            function CZt(e3, t3) {\n              function r4(n4, i3) {\n                return P5.coerce(e3, t3, g7.link.colorscales, n4, i3);\n              }\n              r4("label"), r4("cmin"), r4("cmax"), r4("colorscale");\n            }\n          });\n          var HJ = ye((Jbr, AWe) => {\n            "use strict";\n            AWe.exports = LZt;\n            function LZt(e3) {\n              for (var t3 = e3.length, r4 = new Array(t3), n4 = new Array(t3), i3 = new Array(t3), a4 = new Array(t3), o4 = new Array(t3), s3 = new Array(t3), l3 = 0; l3 < t3; ++l3) r4[l3] = -1, n4[l3] = 0, i3[l3] = false, a4[l3] = 0, o4[l3] = -1, s3[l3] = [];\n              var u4 = 0, c5 = [], f4 = [];\n              function h3(b) {\n                var p3 = [b], k4 = [b];\n                for (r4[b] = n4[b] = u4, i3[b] = true, u4 += 1; k4.length > 0; ) {\n                  b = k4[k4.length - 1];\n                  var E3 = e3[b];\n                  if (a4[b] < E3.length) {\n                    for (var S2 = a4[b]; S2 < E3.length; ++S2) {\n                      var L3 = E3[S2];\n                      if (r4[L3] < 0) {\n                        r4[L3] = n4[L3] = u4, i3[L3] = true, u4 += 1, p3.push(L3), k4.push(L3);\n                        break;\n                      } else i3[L3] && (n4[b] = Math.min(n4[b], n4[L3]) | 0);\n                      o4[L3] >= 0 && s3[b].push(o4[L3]);\n                    }\n                    a4[b] = S2;\n                  } else {\n                    if (n4[b] === r4[b]) {\n                      for (var x2 = [], C3 = [], M4 = 0, S2 = p3.length - 1; S2 >= 0; --S2) {\n                        var g3 = p3[S2];\n                        if (i3[g3] = false, x2.push(g3), C3.push(s3[g3]), M4 += s3[g3].length, o4[g3] = c5.length, g3 === b) {\n                          p3.length = S2;\n                          break;\n                        }\n                      }\n                      c5.push(x2);\n                      for (var P3 = new Array(M4), S2 = 0; S2 < C3.length; S2++) for (var T3 = 0; T3 < C3[S2].length; T3++) P3[--M4] = C3[S2][T3];\n                      f4.push(P3);\n                    }\n                    k4.pop();\n                  }\n                }\n              }\n              for (var l3 = 0; l3 < t3; ++l3) r4[l3] < 0 && h3(l3);\n              for (var d3, l3 = 0; l3 < f4.length; l3++) {\n                var v3 = f4[l3];\n                if (v3.length !== 0) {\n                  v3.sort(function(p3, k4) {\n                    return p3 - k4;\n                  }), d3 = [v3[0]];\n                  for (var _2 = 1; _2 < v3.length; _2++) v3[_2] !== v3[_2 - 1] && d3.push(v3[_2]);\n                  f4[l3] = d3;\n                }\n              }\n              return { components: c5, adjacencyList: f4 };\n            }\n          });\n          var kWe = ye(($br, EWe) => {\n            "use strict";\n            var PZt = HJ(), I5 = Dr(), IZt = Jm().wrap, Kk = I5.isArrayOrTypedArray, SWe = I5.isIndex, MWe = tc();\n            function RZt(e3) {\n              var t3 = e3.node, r4 = e3.link, n4 = [], i3 = Kk(r4.color), a4 = Kk(r4.hovercolor), o4 = Kk(r4.customdata), s3 = {}, l3 = {}, u4 = r4.colorscales.length, c5;\n              for (c5 = 0; c5 < u4; c5++) {\n                var f4 = r4.colorscales[c5], h3 = MWe.extractScale(f4, { cLetter: "c" }), d3 = MWe.makeColorScaleFunc(h3);\n                l3[f4.label] = d3;\n              }\n              var v3 = 0;\n              for (c5 = 0; c5 < r4.value.length; c5++) r4.source[c5] > v3 && (v3 = r4.source[c5]), r4.target[c5] > v3 && (v3 = r4.target[c5]);\n              var _2 = v3 + 1;\n              e3.node._count = _2;\n              var b, p3 = e3.node.groups, k4 = {};\n              for (c5 = 0; c5 < p3.length; c5++) {\n                var E3 = p3[c5];\n                for (b = 0; b < E3.length; b++) {\n                  var S2 = E3[b], L3 = _2 + c5;\n                  k4.hasOwnProperty(S2) ? I5.warn("Node " + S2 + " is already part of a group.") : k4[S2] = L3;\n                }\n              }\n              var x2 = { source: [], target: [] };\n              for (c5 = 0; c5 < r4.value.length; c5++) {\n                var C3 = r4.value[c5], M4 = r4.source[c5], g3 = r4.target[c5];\n                if (C3 > 0 && SWe(M4, _2) && SWe(g3, _2) && !(k4.hasOwnProperty(M4) && k4.hasOwnProperty(g3) && k4[M4] === k4[g3])) {\n                  k4.hasOwnProperty(g3) && (g3 = k4[g3]), k4.hasOwnProperty(M4) && (M4 = k4[M4]), M4 = +M4, g3 = +g3, s3[M4] = s3[g3] = true;\n                  var P3 = "";\n                  r4.label && r4.label[c5] && (P3 = r4.label[c5]);\n                  var T3 = null;\n                  P3 && l3.hasOwnProperty(P3) && (T3 = l3[P3]), n4.push({ pointNumber: c5, label: P3, color: i3 ? r4.color[c5] : r4.color, hovercolor: a4 ? r4.hovercolor[c5] : r4.hovercolor, customdata: o4 ? r4.customdata[c5] : r4.customdata, concentrationscale: T3, source: M4, target: g3, value: +C3 }), x2.source.push(M4), x2.target.push(g3);\n                }\n              }\n              var z3 = _2 + p3.length, O3 = Kk(t3.color), V2 = Kk(t3.customdata), G2 = [];\n              for (c5 = 0; c5 < z3; c5++) if (s3[c5]) {\n                var Z = t3.label[c5];\n                G2.push({ group: c5 > _2 - 1, childrenNodes: [], pointNumber: c5, label: Z, color: O3 ? t3.color[c5] : t3.color, customdata: V2 ? t3.customdata[c5] : t3.customdata });\n              }\n              var j3 = false;\n              return DZt(z3, x2.source, x2.target) && (j3 = true), { circular: j3, links: n4, nodes: G2, groups: p3, groupLookup: k4 };\n            }\n            function DZt(e3, t3, r4) {\n              for (var n4 = I5.init2dArray(e3, 0), i3 = 0; i3 < Math.min(t3.length, r4.length); i3++) if (I5.isIndex(t3[i3], e3) && I5.isIndex(r4[i3], e3)) {\n                if (t3[i3] === r4[i3]) return true;\n                n4[t3[i3]].push(r4[i3]);\n              }\n              var a4 = PZt(n4);\n              return a4.components.some(function(o4) {\n                return o4.length > 1;\n              });\n            }\n            EWe.exports = function(t3, r4) {\n              var n4 = RZt(r4);\n              return IZt({ circular: n4.circular, _nodes: n4.nodes, _links: n4.links, _groups: n4.groups, _groupLookup: n4.groupLookup });\n            };\n          });\n          var LWe = ye((m7, CWe) => {\n            (function(e3, t3) {\n              typeof m7 == "object" && typeof CWe != "undefined" ? t3(m7) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(m7, function(e3) {\n              "use strict";\n              function t3(C3) {\n                var M4 = +this._x.call(null, C3), g3 = +this._y.call(null, C3);\n                return r4(this.cover(M4, g3), M4, g3, C3);\n              }\n              function r4(C3, M4, g3, P3) {\n                if (isNaN(M4) || isNaN(g3)) return C3;\n                var T3, z3 = C3._root, O3 = { data: P3 }, V2 = C3._x0, G2 = C3._y0, Z = C3._x1, j3 = C3._y1, N2, H, te, oe, _e, Ee, Ce, me;\n                if (!z3) return C3._root = O3, C3;\n                for (; z3.length; ) if ((_e = M4 >= (N2 = (V2 + Z) / 2)) ? V2 = N2 : Z = N2, (Ee = g3 >= (H = (G2 + j3) / 2)) ? G2 = H : j3 = H, T3 = z3, !(z3 = z3[Ce = Ee << 1 | _e])) return T3[Ce] = O3, C3;\n                if (te = +C3._x.call(null, z3.data), oe = +C3._y.call(null, z3.data), M4 === te && g3 === oe) return O3.next = z3, T3 ? T3[Ce] = O3 : C3._root = O3, C3;\n                do\n                  T3 = T3 ? T3[Ce] = new Array(4) : C3._root = new Array(4), (_e = M4 >= (N2 = (V2 + Z) / 2)) ? V2 = N2 : Z = N2, (Ee = g3 >= (H = (G2 + j3) / 2)) ? G2 = H : j3 = H;\n                while ((Ce = Ee << 1 | _e) === (me = (oe >= H) << 1 | te >= N2));\n                return T3[me] = z3, T3[Ce] = O3, C3;\n              }\n              function n4(C3) {\n                var M4, g3, P3 = C3.length, T3, z3, O3 = new Array(P3), V2 = new Array(P3), G2 = 1 / 0, Z = 1 / 0, j3 = -1 / 0, N2 = -1 / 0;\n                for (g3 = 0; g3 < P3; ++g3) isNaN(T3 = +this._x.call(null, M4 = C3[g3])) || isNaN(z3 = +this._y.call(null, M4)) || (O3[g3] = T3, V2[g3] = z3, T3 < G2 && (G2 = T3), T3 > j3 && (j3 = T3), z3 < Z && (Z = z3), z3 > N2 && (N2 = z3));\n                if (G2 > j3 || Z > N2) return this;\n                for (this.cover(G2, Z).cover(j3, N2), g3 = 0; g3 < P3; ++g3) r4(this, O3[g3], V2[g3], C3[g3]);\n                return this;\n              }\n              function i3(C3, M4) {\n                if (isNaN(C3 = +C3) || isNaN(M4 = +M4)) return this;\n                var g3 = this._x0, P3 = this._y0, T3 = this._x1, z3 = this._y1;\n                if (isNaN(g3)) T3 = (g3 = Math.floor(C3)) + 1, z3 = (P3 = Math.floor(M4)) + 1;\n                else {\n                  for (var O3 = T3 - g3, V2 = this._root, G2, Z; g3 > C3 || C3 >= T3 || P3 > M4 || M4 >= z3; ) switch (Z = (M4 < P3) << 1 | C3 < g3, G2 = new Array(4), G2[Z] = V2, V2 = G2, O3 *= 2, Z) {\n                    case 0:\n                      T3 = g3 + O3, z3 = P3 + O3;\n                      break;\n                    case 1:\n                      g3 = T3 - O3, z3 = P3 + O3;\n                      break;\n                    case 2:\n                      T3 = g3 + O3, P3 = z3 - O3;\n                      break;\n                    case 3:\n                      g3 = T3 - O3, P3 = z3 - O3;\n                      break;\n                  }\n                  this._root && this._root.length && (this._root = V2);\n                }\n                return this._x0 = g3, this._y0 = P3, this._x1 = T3, this._y1 = z3, this;\n              }\n              function a4() {\n                var C3 = [];\n                return this.visit(function(M4) {\n                  if (!M4.length) do\n                    C3.push(M4.data);\n                  while (M4 = M4.next);\n                }), C3;\n              }\n              function o4(C3) {\n                return arguments.length ? this.cover(+C3[0][0], +C3[0][1]).cover(+C3[1][0], +C3[1][1]) : isNaN(this._x0) ? void 0 : [[this._x0, this._y0], [this._x1, this._y1]];\n              }\n              function s3(C3, M4, g3, P3, T3) {\n                this.node = C3, this.x0 = M4, this.y0 = g3, this.x1 = P3, this.y1 = T3;\n              }\n              function l3(C3, M4, g3) {\n                var P3, T3 = this._x0, z3 = this._y0, O3, V2, G2, Z, j3 = this._x1, N2 = this._y1, H = [], te = this._root, oe, _e;\n                for (te && H.push(new s3(te, T3, z3, j3, N2)), g3 == null ? g3 = 1 / 0 : (T3 = C3 - g3, z3 = M4 - g3, j3 = C3 + g3, N2 = M4 + g3, g3 *= g3); oe = H.pop(); ) if (!(!(te = oe.node) || (O3 = oe.x0) > j3 || (V2 = oe.y0) > N2 || (G2 = oe.x1) < T3 || (Z = oe.y1) < z3)) if (te.length) {\n                  var Ee = (O3 + G2) / 2, Ce = (V2 + Z) / 2;\n                  H.push(new s3(te[3], Ee, Ce, G2, Z), new s3(te[2], O3, Ce, Ee, Z), new s3(te[1], Ee, V2, G2, Ce), new s3(te[0], O3, V2, Ee, Ce)), (_e = (M4 >= Ce) << 1 | C3 >= Ee) && (oe = H[H.length - 1], H[H.length - 1] = H[H.length - 1 - _e], H[H.length - 1 - _e] = oe);\n                } else {\n                  var me = C3 - +this._x.call(null, te.data), ie = M4 - +this._y.call(null, te.data), Se = me * me + ie * ie;\n                  if (Se < g3) {\n                    var Le = Math.sqrt(g3 = Se);\n                    T3 = C3 - Le, z3 = M4 - Le, j3 = C3 + Le, N2 = M4 + Le, P3 = te.data;\n                  }\n                }\n                return P3;\n              }\n              function u4(C3) {\n                if (isNaN(j3 = +this._x.call(null, C3)) || isNaN(N2 = +this._y.call(null, C3))) return this;\n                var M4, g3 = this._root, P3, T3, z3, O3 = this._x0, V2 = this._y0, G2 = this._x1, Z = this._y1, j3, N2, H, te, oe, _e, Ee, Ce;\n                if (!g3) return this;\n                if (g3.length) for (; ; ) {\n                  if ((oe = j3 >= (H = (O3 + G2) / 2)) ? O3 = H : G2 = H, (_e = N2 >= (te = (V2 + Z) / 2)) ? V2 = te : Z = te, M4 = g3, !(g3 = g3[Ee = _e << 1 | oe])) return this;\n                  if (!g3.length) break;\n                  (M4[Ee + 1 & 3] || M4[Ee + 2 & 3] || M4[Ee + 3 & 3]) && (P3 = M4, Ce = Ee);\n                }\n                for (; g3.data !== C3; ) if (T3 = g3, !(g3 = g3.next)) return this;\n                return (z3 = g3.next) && delete g3.next, T3 ? (z3 ? T3.next = z3 : delete T3.next, this) : M4 ? (z3 ? M4[Ee] = z3 : delete M4[Ee], (g3 = M4[0] || M4[1] || M4[2] || M4[3]) && g3 === (M4[3] || M4[2] || M4[1] || M4[0]) && !g3.length && (P3 ? P3[Ce] = g3 : this._root = g3), this) : (this._root = z3, this);\n              }\n              function c5(C3) {\n                for (var M4 = 0, g3 = C3.length; M4 < g3; ++M4) this.remove(C3[M4]);\n                return this;\n              }\n              function f4() {\n                return this._root;\n              }\n              function h3() {\n                var C3 = 0;\n                return this.visit(function(M4) {\n                  if (!M4.length) do\n                    ++C3;\n                  while (M4 = M4.next);\n                }), C3;\n              }\n              function d3(C3) {\n                var M4 = [], g3, P3 = this._root, T3, z3, O3, V2, G2;\n                for (P3 && M4.push(new s3(P3, this._x0, this._y0, this._x1, this._y1)); g3 = M4.pop(); ) if (!C3(P3 = g3.node, z3 = g3.x0, O3 = g3.y0, V2 = g3.x1, G2 = g3.y1) && P3.length) {\n                  var Z = (z3 + V2) / 2, j3 = (O3 + G2) / 2;\n                  (T3 = P3[3]) && M4.push(new s3(T3, Z, j3, V2, G2)), (T3 = P3[2]) && M4.push(new s3(T3, z3, j3, Z, G2)), (T3 = P3[1]) && M4.push(new s3(T3, Z, O3, V2, j3)), (T3 = P3[0]) && M4.push(new s3(T3, z3, O3, Z, j3));\n                }\n                return this;\n              }\n              function v3(C3) {\n                var M4 = [], g3 = [], P3;\n                for (this._root && M4.push(new s3(this._root, this._x0, this._y0, this._x1, this._y1)); P3 = M4.pop(); ) {\n                  var T3 = P3.node;\n                  if (T3.length) {\n                    var z3, O3 = P3.x0, V2 = P3.y0, G2 = P3.x1, Z = P3.y1, j3 = (O3 + G2) / 2, N2 = (V2 + Z) / 2;\n                    (z3 = T3[0]) && M4.push(new s3(z3, O3, V2, j3, N2)), (z3 = T3[1]) && M4.push(new s3(z3, j3, V2, G2, N2)), (z3 = T3[2]) && M4.push(new s3(z3, O3, N2, j3, Z)), (z3 = T3[3]) && M4.push(new s3(z3, j3, N2, G2, Z));\n                  }\n                  g3.push(P3);\n                }\n                for (; P3 = g3.pop(); ) C3(P3.node, P3.x0, P3.y0, P3.x1, P3.y1);\n                return this;\n              }\n              function _2(C3) {\n                return C3[0];\n              }\n              function b(C3) {\n                return arguments.length ? (this._x = C3, this) : this._x;\n              }\n              function p3(C3) {\n                return C3[1];\n              }\n              function k4(C3) {\n                return arguments.length ? (this._y = C3, this) : this._y;\n              }\n              function E3(C3, M4, g3) {\n                var P3 = new S2(M4 == null ? _2 : M4, g3 == null ? p3 : g3, NaN, NaN, NaN, NaN);\n                return C3 == null ? P3 : P3.addAll(C3);\n              }\n              function S2(C3, M4, g3, P3, T3, z3) {\n                this._x = C3, this._y = M4, this._x0 = g3, this._y0 = P3, this._x1 = T3, this._y1 = z3, this._root = void 0;\n              }\n              function L3(C3) {\n                for (var M4 = { data: C3.data }, g3 = M4; C3 = C3.next; ) g3 = g3.next = { data: C3.data };\n                return M4;\n              }\n              var x2 = E3.prototype = S2.prototype;\n              x2.copy = function() {\n                var C3 = new S2(this._x, this._y, this._x0, this._y0, this._x1, this._y1), M4 = this._root, g3, P3;\n                if (!M4) return C3;\n                if (!M4.length) return C3._root = L3(M4), C3;\n                for (g3 = [{ source: M4, target: C3._root = new Array(4) }]; M4 = g3.pop(); ) for (var T3 = 0; T3 < 4; ++T3) (P3 = M4.source[T3]) && (P3.length ? g3.push({ source: P3, target: M4.target[T3] = new Array(4) }) : M4.target[T3] = L3(P3));\n                return C3;\n              }, x2.add = t3, x2.addAll = n4, x2.cover = i3, x2.data = a4, x2.extent = o4, x2.find = l3, x2.remove = u4, x2.removeAll = c5, x2.root = f4, x2.size = h3, x2.visit = d3, x2.visitAfter = v3, x2.x = b, x2.y = k4, e3.quadtree = E3, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var _7 = ye((y7, PWe) => {\n            (function(e3, t3) {\n              t3(typeof y7 == "object" && typeof PWe != "undefined" ? y7 : e3.d3 = e3.d3 || {});\n            })(y7, function(e3) {\n              "use strict";\n              var t3 = "$";\n              function r4() {\n              }\n              r4.prototype = n4.prototype = { constructor: r4, has: function(_2) {\n                return t3 + _2 in this;\n              }, get: function(_2) {\n                return this[t3 + _2];\n              }, set: function(_2, b) {\n                return this[t3 + _2] = b, this;\n              }, remove: function(_2) {\n                var b = t3 + _2;\n                return b in this && delete this[b];\n              }, clear: function() {\n                for (var _2 in this) _2[0] === t3 && delete this[_2];\n              }, keys: function() {\n                var _2 = [];\n                for (var b in this) b[0] === t3 && _2.push(b.slice(1));\n                return _2;\n              }, values: function() {\n                var _2 = [];\n                for (var b in this) b[0] === t3 && _2.push(this[b]);\n                return _2;\n              }, entries: function() {\n                var _2 = [];\n                for (var b in this) b[0] === t3 && _2.push({ key: b.slice(1), value: this[b] });\n                return _2;\n              }, size: function() {\n                var _2 = 0;\n                for (var b in this) b[0] === t3 && ++_2;\n                return _2;\n              }, empty: function() {\n                for (var _2 in this) if (_2[0] === t3) return false;\n                return true;\n              }, each: function(_2) {\n                for (var b in this) b[0] === t3 && _2(this[b], b.slice(1), this);\n              } };\n              function n4(_2, b) {\n                var p3 = new r4();\n                if (_2 instanceof r4) _2.each(function(x2, C3) {\n                  p3.set(C3, x2);\n                });\n                else if (Array.isArray(_2)) {\n                  var k4 = -1, E3 = _2.length, S2;\n                  if (b == null) for (; ++k4 < E3; ) p3.set(k4, _2[k4]);\n                  else for (; ++k4 < E3; ) p3.set(b(S2 = _2[k4], k4, _2), S2);\n                } else if (_2) for (var L3 in _2) p3.set(L3, _2[L3]);\n                return p3;\n              }\n              function i3() {\n                var _2 = [], b = [], p3, k4, E3;\n                function S2(x2, C3, M4, g3) {\n                  if (C3 >= _2.length) return p3 != null && x2.sort(p3), k4 != null ? k4(x2) : x2;\n                  for (var P3 = -1, T3 = x2.length, z3 = _2[C3++], O3, V2, G2 = n4(), Z, j3 = M4(); ++P3 < T3; ) (Z = G2.get(O3 = z3(V2 = x2[P3]) + "")) ? Z.push(V2) : G2.set(O3, [V2]);\n                  return G2.each(function(N2, H) {\n                    g3(j3, H, S2(N2, C3, M4, g3));\n                  }), j3;\n                }\n                function L3(x2, C3) {\n                  if (++C3 > _2.length) return x2;\n                  var M4, g3 = b[C3 - 1];\n                  return k4 != null && C3 >= _2.length ? M4 = x2.entries() : (M4 = [], x2.each(function(P3, T3) {\n                    M4.push({ key: T3, values: L3(P3, C3) });\n                  })), g3 != null ? M4.sort(function(P3, T3) {\n                    return g3(P3.key, T3.key);\n                  }) : M4;\n                }\n                return E3 = { object: function(x2) {\n                  return S2(x2, 0, a4, o4);\n                }, map: function(x2) {\n                  return S2(x2, 0, s3, l3);\n                }, entries: function(x2) {\n                  return L3(S2(x2, 0, s3, l3), 0);\n                }, key: function(x2) {\n                  return _2.push(x2), E3;\n                }, sortKeys: function(x2) {\n                  return b[_2.length - 1] = x2, E3;\n                }, sortValues: function(x2) {\n                  return p3 = x2, E3;\n                }, rollup: function(x2) {\n                  return k4 = x2, E3;\n                } };\n              }\n              function a4() {\n                return {};\n              }\n              function o4(_2, b, p3) {\n                _2[b] = p3;\n              }\n              function s3() {\n                return n4();\n              }\n              function l3(_2, b, p3) {\n                _2.set(b, p3);\n              }\n              function u4() {\n              }\n              var c5 = n4.prototype;\n              u4.prototype = f4.prototype = { constructor: u4, has: c5.has, add: function(_2) {\n                return _2 += "", this[t3 + _2] = _2, this;\n              }, remove: c5.remove, clear: c5.clear, values: c5.keys, size: c5.size, empty: c5.empty, each: c5.each };\n              function f4(_2, b) {\n                var p3 = new u4();\n                if (_2 instanceof u4) _2.each(function(S2) {\n                  p3.add(S2);\n                });\n                else if (_2) {\n                  var k4 = -1, E3 = _2.length;\n                  if (b == null) for (; ++k4 < E3; ) p3.add(_2[k4]);\n                  else for (; ++k4 < E3; ) p3.add(b(_2[k4], k4, _2));\n                }\n                return p3;\n              }\n              function h3(_2) {\n                var b = [];\n                for (var p3 in _2) b.push(p3);\n                return b;\n              }\n              function d3(_2) {\n                var b = [];\n                for (var p3 in _2) b.push(_2[p3]);\n                return b;\n              }\n              function v3(_2) {\n                var b = [];\n                for (var p3 in _2) b.push({ key: p3, value: _2[p3] });\n                return b;\n              }\n              e3.nest = i3, e3.set = f4, e3.map = n4, e3.keys = h3, e3.values = d3, e3.entries = v3, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var RWe = ye((x7, IWe) => {\n            (function(e3, t3) {\n              typeof x7 == "object" && typeof IWe != "undefined" ? t3(x7) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(x7, function(e3) {\n              "use strict";\n              var t3 = { value: function() {\n              } };\n              function r4() {\n                for (var s3 = 0, l3 = arguments.length, u4 = {}, c5; s3 < l3; ++s3) {\n                  if (!(c5 = arguments[s3] + "") || c5 in u4 || /[\\s.]/.test(c5)) throw new Error("illegal type: " + c5);\n                  u4[c5] = [];\n                }\n                return new n4(u4);\n              }\n              function n4(s3) {\n                this._ = s3;\n              }\n              function i3(s3, l3) {\n                return s3.trim().split(/^|\\s+/).map(function(u4) {\n                  var c5 = "", f4 = u4.indexOf(".");\n                  if (f4 >= 0 && (c5 = u4.slice(f4 + 1), u4 = u4.slice(0, f4)), u4 && !l3.hasOwnProperty(u4)) throw new Error("unknown type: " + u4);\n                  return { type: u4, name: c5 };\n                });\n              }\n              n4.prototype = r4.prototype = { constructor: n4, on: function(s3, l3) {\n                var u4 = this._, c5 = i3(s3 + "", u4), f4, h3 = -1, d3 = c5.length;\n                if (arguments.length < 2) {\n                  for (; ++h3 < d3; ) if ((f4 = (s3 = c5[h3]).type) && (f4 = a4(u4[f4], s3.name))) return f4;\n                  return;\n                }\n                if (l3 != null && typeof l3 != "function") throw new Error("invalid callback: " + l3);\n                for (; ++h3 < d3; ) if (f4 = (s3 = c5[h3]).type) u4[f4] = o4(u4[f4], s3.name, l3);\n                else if (l3 == null) for (f4 in u4) u4[f4] = o4(u4[f4], s3.name, null);\n                return this;\n              }, copy: function() {\n                var s3 = {}, l3 = this._;\n                for (var u4 in l3) s3[u4] = l3[u4].slice();\n                return new n4(s3);\n              }, call: function(s3, l3) {\n                if ((f4 = arguments.length - 2) > 0) for (var u4 = new Array(f4), c5 = 0, f4, h3; c5 < f4; ++c5) u4[c5] = arguments[c5 + 2];\n                if (!this._.hasOwnProperty(s3)) throw new Error("unknown type: " + s3);\n                for (h3 = this._[s3], c5 = 0, f4 = h3.length; c5 < f4; ++c5) h3[c5].value.apply(l3, u4);\n              }, apply: function(s3, l3, u4) {\n                if (!this._.hasOwnProperty(s3)) throw new Error("unknown type: " + s3);\n                for (var c5 = this._[s3], f4 = 0, h3 = c5.length; f4 < h3; ++f4) c5[f4].value.apply(l3, u4);\n              } };\n              function a4(s3, l3) {\n                for (var u4 = 0, c5 = s3.length, f4; u4 < c5; ++u4) if ((f4 = s3[u4]).name === l3) return f4.value;\n              }\n              function o4(s3, l3, u4) {\n                for (var c5 = 0, f4 = s3.length; c5 < f4; ++c5) if (s3[c5].name === l3) {\n                  s3[c5] = t3, s3 = s3.slice(0, c5).concat(s3.slice(c5 + 1));\n                  break;\n                }\n                return u4 != null && s3.push({ name: l3, value: u4 }), s3;\n              }\n              e3.dispatch = r4, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var FWe = ye((b7, DWe) => {\n            (function(e3, t3) {\n              typeof b7 == "object" && typeof DWe != "undefined" ? t3(b7) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(b7, function(e3) {\n              "use strict";\n              var t3 = 0, r4 = 0, n4 = 0, i3 = 1e3, a4, o4, s3 = 0, l3 = 0, u4 = 0, c5 = typeof performance == "object" && performance.now ? performance : Date, f4 = typeof window == "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(C3) {\n                setTimeout(C3, 17);\n              };\n              function h3() {\n                return l3 || (f4(d3), l3 = c5.now() + u4);\n              }\n              function d3() {\n                l3 = 0;\n              }\n              function v3() {\n                this._call = this._time = this._next = null;\n              }\n              v3.prototype = _2.prototype = { constructor: v3, restart: function(C3, M4, g3) {\n                if (typeof C3 != "function") throw new TypeError("callback is not a function");\n                g3 = (g3 == null ? h3() : +g3) + (M4 == null ? 0 : +M4), !this._next && o4 !== this && (o4 ? o4._next = this : a4 = this, o4 = this), this._call = C3, this._time = g3, S2();\n              }, stop: function() {\n                this._call && (this._call = null, this._time = 1 / 0, S2());\n              } };\n              function _2(C3, M4, g3) {\n                var P3 = new v3();\n                return P3.restart(C3, M4, g3), P3;\n              }\n              function b() {\n                h3(), ++t3;\n                for (var C3 = a4, M4; C3; ) (M4 = l3 - C3._time) >= 0 && C3._call.call(null, M4), C3 = C3._next;\n                --t3;\n              }\n              function p3() {\n                l3 = (s3 = c5.now()) + u4, t3 = r4 = 0;\n                try {\n                  b();\n                } finally {\n                  t3 = 0, E3(), l3 = 0;\n                }\n              }\n              function k4() {\n                var C3 = c5.now(), M4 = C3 - s3;\n                M4 > i3 && (u4 -= M4, s3 = C3);\n              }\n              function E3() {\n                for (var C3, M4 = a4, g3, P3 = 1 / 0; M4; ) M4._call ? (P3 > M4._time && (P3 = M4._time), C3 = M4, M4 = M4._next) : (g3 = M4._next, M4._next = null, M4 = C3 ? C3._next = g3 : a4 = g3);\n                o4 = C3, S2(P3);\n              }\n              function S2(C3) {\n                if (!t3) {\n                  r4 && (r4 = clearTimeout(r4));\n                  var M4 = C3 - l3;\n                  M4 > 24 ? (C3 < 1 / 0 && (r4 = setTimeout(p3, C3 - c5.now() - u4)), n4 && (n4 = clearInterval(n4))) : (n4 || (s3 = c5.now(), n4 = setInterval(k4, i3)), t3 = 1, f4(p3));\n                }\n              }\n              function L3(C3, M4, g3) {\n                var P3 = new v3();\n                return M4 = M4 == null ? 0 : +M4, P3.restart(function(T3) {\n                  P3.stop(), C3(T3 + M4);\n                }, M4, g3), P3;\n              }\n              function x2(C3, M4, g3) {\n                var P3 = new v3(), T3 = M4;\n                return M4 == null ? (P3.restart(C3, M4, g3), P3) : (M4 = +M4, g3 = g3 == null ? h3() : +g3, P3.restart(function z3(O3) {\n                  O3 += T3, P3.restart(z3, T3 += M4, g3), C3(O3);\n                }, M4, g3), P3);\n              }\n              e3.interval = x2, e3.now = h3, e3.timeout = L3, e3.timer = _2, e3.timerFlush = b, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var OWe = ye((w7, zWe) => {\n            (function(e3, t3) {\n              typeof w7 == "object" && typeof zWe != "undefined" ? t3(w7, LWe(), _7(), RWe(), FWe()) : t3(e3.d3 = e3.d3 || {}, e3.d3, e3.d3, e3.d3, e3.d3);\n            })(w7, function(e3, t3, r4, n4, i3) {\n              "use strict";\n              function a4(C3, M4) {\n                var g3;\n                C3 == null && (C3 = 0), M4 == null && (M4 = 0);\n                function P3() {\n                  var T3, z3 = g3.length, O3, V2 = 0, G2 = 0;\n                  for (T3 = 0; T3 < z3; ++T3) O3 = g3[T3], V2 += O3.x, G2 += O3.y;\n                  for (V2 = V2 / z3 - C3, G2 = G2 / z3 - M4, T3 = 0; T3 < z3; ++T3) O3 = g3[T3], O3.x -= V2, O3.y -= G2;\n                }\n                return P3.initialize = function(T3) {\n                  g3 = T3;\n                }, P3.x = function(T3) {\n                  return arguments.length ? (C3 = +T3, P3) : C3;\n                }, P3.y = function(T3) {\n                  return arguments.length ? (M4 = +T3, P3) : M4;\n                }, P3;\n              }\n              function o4(C3) {\n                return function() {\n                  return C3;\n                };\n              }\n              function s3() {\n                return (Math.random() - 0.5) * 1e-6;\n              }\n              function l3(C3) {\n                return C3.x + C3.vx;\n              }\n              function u4(C3) {\n                return C3.y + C3.vy;\n              }\n              function c5(C3) {\n                var M4, g3, P3 = 1, T3 = 1;\n                typeof C3 != "function" && (C3 = o4(C3 == null ? 1 : +C3));\n                function z3() {\n                  for (var G2, Z = M4.length, j3, N2, H, te, oe, _e, Ee = 0; Ee < T3; ++Ee) for (j3 = t3.quadtree(M4, l3, u4).visitAfter(O3), G2 = 0; G2 < Z; ++G2) N2 = M4[G2], oe = g3[N2.index], _e = oe * oe, H = N2.x + N2.vx, te = N2.y + N2.vy, j3.visit(Ce);\n                  function Ce(me, ie, Se, Le, Ae) {\n                    var Fe = me.data, Pe = me.r, ge = oe + Pe;\n                    if (Fe) {\n                      if (Fe.index > N2.index) {\n                        var Re = H - Fe.x - Fe.vx, ce = te - Fe.y - Fe.vy, Ze = Re * Re + ce * ce;\n                        Ze < ge * ge && (Re === 0 && (Re = s3(), Ze += Re * Re), ce === 0 && (ce = s3(), Ze += ce * ce), Ze = (ge - (Ze = Math.sqrt(Ze))) / Ze * P3, N2.vx += (Re *= Ze) * (ge = (Pe *= Pe) / (_e + Pe)), N2.vy += (ce *= Ze) * ge, Fe.vx -= Re * (ge = 1 - ge), Fe.vy -= ce * ge);\n                      }\n                      return;\n                    }\n                    return ie > H + ge || Le < H - ge || Se > te + ge || Ae < te - ge;\n                  }\n                }\n                function O3(G2) {\n                  if (G2.data) return G2.r = g3[G2.data.index];\n                  for (var Z = G2.r = 0; Z < 4; ++Z) G2[Z] && G2[Z].r > G2.r && (G2.r = G2[Z].r);\n                }\n                function V2() {\n                  if (M4) {\n                    var G2, Z = M4.length, j3;\n                    for (g3 = new Array(Z), G2 = 0; G2 < Z; ++G2) j3 = M4[G2], g3[j3.index] = +C3(j3, G2, M4);\n                  }\n                }\n                return z3.initialize = function(G2) {\n                  M4 = G2, V2();\n                }, z3.iterations = function(G2) {\n                  return arguments.length ? (T3 = +G2, z3) : T3;\n                }, z3.strength = function(G2) {\n                  return arguments.length ? (P3 = +G2, z3) : P3;\n                }, z3.radius = function(G2) {\n                  return arguments.length ? (C3 = typeof G2 == "function" ? G2 : o4(+G2), V2(), z3) : C3;\n                }, z3;\n              }\n              function f4(C3) {\n                return C3.index;\n              }\n              function h3(C3, M4) {\n                var g3 = C3.get(M4);\n                if (!g3) throw new Error("missing: " + M4);\n                return g3;\n              }\n              function d3(C3) {\n                var M4 = f4, g3 = j3, P3, T3 = o4(30), z3, O3, V2, G2, Z = 1;\n                C3 == null && (C3 = []);\n                function j3(_e) {\n                  return 1 / Math.min(V2[_e.source.index], V2[_e.target.index]);\n                }\n                function N2(_e) {\n                  for (var Ee = 0, Ce = C3.length; Ee < Z; ++Ee) for (var me = 0, ie, Se, Le, Ae, Fe, Pe, ge; me < Ce; ++me) ie = C3[me], Se = ie.source, Le = ie.target, Ae = Le.x + Le.vx - Se.x - Se.vx || s3(), Fe = Le.y + Le.vy - Se.y - Se.vy || s3(), Pe = Math.sqrt(Ae * Ae + Fe * Fe), Pe = (Pe - z3[me]) / Pe * _e * P3[me], Ae *= Pe, Fe *= Pe, Le.vx -= Ae * (ge = G2[me]), Le.vy -= Fe * ge, Se.vx += Ae * (ge = 1 - ge), Se.vy += Fe * ge;\n                }\n                function H() {\n                  if (O3) {\n                    var _e, Ee = O3.length, Ce = C3.length, me = r4.map(O3, M4), ie;\n                    for (_e = 0, V2 = new Array(Ee); _e < Ce; ++_e) ie = C3[_e], ie.index = _e, typeof ie.source != "object" && (ie.source = h3(me, ie.source)), typeof ie.target != "object" && (ie.target = h3(me, ie.target)), V2[ie.source.index] = (V2[ie.source.index] || 0) + 1, V2[ie.target.index] = (V2[ie.target.index] || 0) + 1;\n                    for (_e = 0, G2 = new Array(Ce); _e < Ce; ++_e) ie = C3[_e], G2[_e] = V2[ie.source.index] / (V2[ie.source.index] + V2[ie.target.index]);\n                    P3 = new Array(Ce), te(), z3 = new Array(Ce), oe();\n                  }\n                }\n                function te() {\n                  if (O3) for (var _e = 0, Ee = C3.length; _e < Ee; ++_e) P3[_e] = +g3(C3[_e], _e, C3);\n                }\n                function oe() {\n                  if (O3) for (var _e = 0, Ee = C3.length; _e < Ee; ++_e) z3[_e] = +T3(C3[_e], _e, C3);\n                }\n                return N2.initialize = function(_e) {\n                  O3 = _e, H();\n                }, N2.links = function(_e) {\n                  return arguments.length ? (C3 = _e, H(), N2) : C3;\n                }, N2.id = function(_e) {\n                  return arguments.length ? (M4 = _e, N2) : M4;\n                }, N2.iterations = function(_e) {\n                  return arguments.length ? (Z = +_e, N2) : Z;\n                }, N2.strength = function(_e) {\n                  return arguments.length ? (g3 = typeof _e == "function" ? _e : o4(+_e), te(), N2) : g3;\n                }, N2.distance = function(_e) {\n                  return arguments.length ? (T3 = typeof _e == "function" ? _e : o4(+_e), oe(), N2) : T3;\n                }, N2;\n              }\n              function v3(C3) {\n                return C3.x;\n              }\n              function _2(C3) {\n                return C3.y;\n              }\n              var b = 10, p3 = Math.PI * (3 - Math.sqrt(5));\n              function k4(C3) {\n                var M4, g3 = 1, P3 = 1e-3, T3 = 1 - Math.pow(P3, 1 / 300), z3 = 0, O3 = 0.6, V2 = r4.map(), G2 = i3.timer(j3), Z = n4.dispatch("tick", "end");\n                C3 == null && (C3 = []);\n                function j3() {\n                  N2(), Z.call("tick", M4), g3 < P3 && (G2.stop(), Z.call("end", M4));\n                }\n                function N2(oe) {\n                  var _e, Ee = C3.length, Ce;\n                  oe === void 0 && (oe = 1);\n                  for (var me = 0; me < oe; ++me) for (g3 += (z3 - g3) * T3, V2.each(function(ie) {\n                    ie(g3);\n                  }), _e = 0; _e < Ee; ++_e) Ce = C3[_e], Ce.fx == null ? Ce.x += Ce.vx *= O3 : (Ce.x = Ce.fx, Ce.vx = 0), Ce.fy == null ? Ce.y += Ce.vy *= O3 : (Ce.y = Ce.fy, Ce.vy = 0);\n                  return M4;\n                }\n                function H() {\n                  for (var oe = 0, _e = C3.length, Ee; oe < _e; ++oe) {\n                    if (Ee = C3[oe], Ee.index = oe, Ee.fx != null && (Ee.x = Ee.fx), Ee.fy != null && (Ee.y = Ee.fy), isNaN(Ee.x) || isNaN(Ee.y)) {\n                      var Ce = b * Math.sqrt(oe), me = oe * p3;\n                      Ee.x = Ce * Math.cos(me), Ee.y = Ce * Math.sin(me);\n                    }\n                    (isNaN(Ee.vx) || isNaN(Ee.vy)) && (Ee.vx = Ee.vy = 0);\n                  }\n                }\n                function te(oe) {\n                  return oe.initialize && oe.initialize(C3), oe;\n                }\n                return H(), M4 = { tick: N2, restart: function() {\n                  return G2.restart(j3), M4;\n                }, stop: function() {\n                  return G2.stop(), M4;\n                }, nodes: function(oe) {\n                  return arguments.length ? (C3 = oe, H(), V2.each(te), M4) : C3;\n                }, alpha: function(oe) {\n                  return arguments.length ? (g3 = +oe, M4) : g3;\n                }, alphaMin: function(oe) {\n                  return arguments.length ? (P3 = +oe, M4) : P3;\n                }, alphaDecay: function(oe) {\n                  return arguments.length ? (T3 = +oe, M4) : +T3;\n                }, alphaTarget: function(oe) {\n                  return arguments.length ? (z3 = +oe, M4) : z3;\n                }, velocityDecay: function(oe) {\n                  return arguments.length ? (O3 = 1 - oe, M4) : 1 - O3;\n                }, force: function(oe, _e) {\n                  return arguments.length > 1 ? (_e == null ? V2.remove(oe) : V2.set(oe, te(_e)), M4) : V2.get(oe);\n                }, find: function(oe, _e, Ee) {\n                  var Ce = 0, me = C3.length, ie, Se, Le, Ae, Fe;\n                  for (Ee == null ? Ee = 1 / 0 : Ee *= Ee, Ce = 0; Ce < me; ++Ce) Ae = C3[Ce], ie = oe - Ae.x, Se = _e - Ae.y, Le = ie * ie + Se * Se, Le < Ee && (Fe = Ae, Ee = Le);\n                  return Fe;\n                }, on: function(oe, _e) {\n                  return arguments.length > 1 ? (Z.on(oe, _e), M4) : Z.on(oe);\n                } };\n              }\n              function E3() {\n                var C3, M4, g3, P3 = o4(-30), T3, z3 = 1, O3 = 1 / 0, V2 = 0.81;\n                function G2(H) {\n                  var te, oe = C3.length, _e = t3.quadtree(C3, v3, _2).visitAfter(j3);\n                  for (g3 = H, te = 0; te < oe; ++te) M4 = C3[te], _e.visit(N2);\n                }\n                function Z() {\n                  if (C3) {\n                    var H, te = C3.length, oe;\n                    for (T3 = new Array(te), H = 0; H < te; ++H) oe = C3[H], T3[oe.index] = +P3(oe, H, C3);\n                  }\n                }\n                function j3(H) {\n                  var te = 0, oe, _e, Ee = 0, Ce, me, ie;\n                  if (H.length) {\n                    for (Ce = me = ie = 0; ie < 4; ++ie) (oe = H[ie]) && (_e = Math.abs(oe.value)) && (te += oe.value, Ee += _e, Ce += _e * oe.x, me += _e * oe.y);\n                    H.x = Ce / Ee, H.y = me / Ee;\n                  } else {\n                    oe = H, oe.x = oe.data.x, oe.y = oe.data.y;\n                    do\n                      te += T3[oe.data.index];\n                    while (oe = oe.next);\n                  }\n                  H.value = te;\n                }\n                function N2(H, te, oe, _e) {\n                  if (!H.value) return true;\n                  var Ee = H.x - M4.x, Ce = H.y - M4.y, me = _e - te, ie = Ee * Ee + Ce * Ce;\n                  if (me * me / V2 < ie) return ie < O3 && (Ee === 0 && (Ee = s3(), ie += Ee * Ee), Ce === 0 && (Ce = s3(), ie += Ce * Ce), ie < z3 && (ie = Math.sqrt(z3 * ie)), M4.vx += Ee * H.value * g3 / ie, M4.vy += Ce * H.value * g3 / ie), true;\n                  if (H.length || ie >= O3) return;\n                  (H.data !== M4 || H.next) && (Ee === 0 && (Ee = s3(), ie += Ee * Ee), Ce === 0 && (Ce = s3(), ie += Ce * Ce), ie < z3 && (ie = Math.sqrt(z3 * ie)));\n                  do\n                    H.data !== M4 && (me = T3[H.data.index] * g3 / ie, M4.vx += Ee * me, M4.vy += Ce * me);\n                  while (H = H.next);\n                }\n                return G2.initialize = function(H) {\n                  C3 = H, Z();\n                }, G2.strength = function(H) {\n                  return arguments.length ? (P3 = typeof H == "function" ? H : o4(+H), Z(), G2) : P3;\n                }, G2.distanceMin = function(H) {\n                  return arguments.length ? (z3 = H * H, G2) : Math.sqrt(z3);\n                }, G2.distanceMax = function(H) {\n                  return arguments.length ? (O3 = H * H, G2) : Math.sqrt(O3);\n                }, G2.theta = function(H) {\n                  return arguments.length ? (V2 = H * H, G2) : Math.sqrt(V2);\n                }, G2;\n              }\n              function S2(C3, M4, g3) {\n                var P3, T3 = o4(0.1), z3, O3;\n                typeof C3 != "function" && (C3 = o4(+C3)), M4 == null && (M4 = 0), g3 == null && (g3 = 0);\n                function V2(Z) {\n                  for (var j3 = 0, N2 = P3.length; j3 < N2; ++j3) {\n                    var H = P3[j3], te = H.x - M4 || 1e-6, oe = H.y - g3 || 1e-6, _e = Math.sqrt(te * te + oe * oe), Ee = (O3[j3] - _e) * z3[j3] * Z / _e;\n                    H.vx += te * Ee, H.vy += oe * Ee;\n                  }\n                }\n                function G2() {\n                  if (P3) {\n                    var Z, j3 = P3.length;\n                    for (z3 = new Array(j3), O3 = new Array(j3), Z = 0; Z < j3; ++Z) O3[Z] = +C3(P3[Z], Z, P3), z3[Z] = isNaN(O3[Z]) ? 0 : +T3(P3[Z], Z, P3);\n                  }\n                }\n                return V2.initialize = function(Z) {\n                  P3 = Z, G2();\n                }, V2.strength = function(Z) {\n                  return arguments.length ? (T3 = typeof Z == "function" ? Z : o4(+Z), G2(), V2) : T3;\n                }, V2.radius = function(Z) {\n                  return arguments.length ? (C3 = typeof Z == "function" ? Z : o4(+Z), G2(), V2) : C3;\n                }, V2.x = function(Z) {\n                  return arguments.length ? (M4 = +Z, V2) : M4;\n                }, V2.y = function(Z) {\n                  return arguments.length ? (g3 = +Z, V2) : g3;\n                }, V2;\n              }\n              function L3(C3) {\n                var M4 = o4(0.1), g3, P3, T3;\n                typeof C3 != "function" && (C3 = o4(C3 == null ? 0 : +C3));\n                function z3(V2) {\n                  for (var G2 = 0, Z = g3.length, j3; G2 < Z; ++G2) j3 = g3[G2], j3.vx += (T3[G2] - j3.x) * P3[G2] * V2;\n                }\n                function O3() {\n                  if (g3) {\n                    var V2, G2 = g3.length;\n                    for (P3 = new Array(G2), T3 = new Array(G2), V2 = 0; V2 < G2; ++V2) P3[V2] = isNaN(T3[V2] = +C3(g3[V2], V2, g3)) ? 0 : +M4(g3[V2], V2, g3);\n                  }\n                }\n                return z3.initialize = function(V2) {\n                  g3 = V2, O3();\n                }, z3.strength = function(V2) {\n                  return arguments.length ? (M4 = typeof V2 == "function" ? V2 : o4(+V2), O3(), z3) : M4;\n                }, z3.x = function(V2) {\n                  return arguments.length ? (C3 = typeof V2 == "function" ? V2 : o4(+V2), O3(), z3) : C3;\n                }, z3;\n              }\n              function x2(C3) {\n                var M4 = o4(0.1), g3, P3, T3;\n                typeof C3 != "function" && (C3 = o4(C3 == null ? 0 : +C3));\n                function z3(V2) {\n                  for (var G2 = 0, Z = g3.length, j3; G2 < Z; ++G2) j3 = g3[G2], j3.vy += (T3[G2] - j3.y) * P3[G2] * V2;\n                }\n                function O3() {\n                  if (g3) {\n                    var V2, G2 = g3.length;\n                    for (P3 = new Array(G2), T3 = new Array(G2), V2 = 0; V2 < G2; ++V2) P3[V2] = isNaN(T3[V2] = +C3(g3[V2], V2, g3)) ? 0 : +M4(g3[V2], V2, g3);\n                  }\n                }\n                return z3.initialize = function(V2) {\n                  g3 = V2, O3();\n                }, z3.strength = function(V2) {\n                  return arguments.length ? (M4 = typeof V2 == "function" ? V2 : o4(+V2), O3(), z3) : M4;\n                }, z3.y = function(V2) {\n                  return arguments.length ? (C3 = typeof V2 == "function" ? V2 : o4(+V2), O3(), z3) : C3;\n                }, z3;\n              }\n              e3.forceCenter = a4, e3.forceCollide = c5, e3.forceLink = d3, e3.forceManyBody = E3, e3.forceRadial = S2, e3.forceSimulation = k4, e3.forceX = L3, e3.forceY = x2, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var BWe = ye((T7, qWe) => {\n            (function(e3, t3) {\n              typeof T7 == "object" && typeof qWe != "undefined" ? t3(T7) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}));\n            })(T7, function(e3) {\n              "use strict";\n              var t3 = Math.PI, r4 = 2 * t3, n4 = 1e-6, i3 = r4 - n4;\n              function a4() {\n                this._x0 = this._y0 = this._x1 = this._y1 = null, this._ = "";\n              }\n              function o4() {\n                return new a4();\n              }\n              a4.prototype = o4.prototype = { constructor: a4, moveTo: function(s3, l3) {\n                this._ += "M" + (this._x0 = this._x1 = +s3) + "," + (this._y0 = this._y1 = +l3);\n              }, closePath: function() {\n                this._x1 !== null && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");\n              }, lineTo: function(s3, l3) {\n                this._ += "L" + (this._x1 = +s3) + "," + (this._y1 = +l3);\n              }, quadraticCurveTo: function(s3, l3, u4, c5) {\n                this._ += "Q" + +s3 + "," + +l3 + "," + (this._x1 = +u4) + "," + (this._y1 = +c5);\n              }, bezierCurveTo: function(s3, l3, u4, c5, f4, h3) {\n                this._ += "C" + +s3 + "," + +l3 + "," + +u4 + "," + +c5 + "," + (this._x1 = +f4) + "," + (this._y1 = +h3);\n              }, arcTo: function(s3, l3, u4, c5, f4) {\n                s3 = +s3, l3 = +l3, u4 = +u4, c5 = +c5, f4 = +f4;\n                var h3 = this._x1, d3 = this._y1, v3 = u4 - s3, _2 = c5 - l3, b = h3 - s3, p3 = d3 - l3, k4 = b * b + p3 * p3;\n                if (f4 < 0) throw new Error("negative radius: " + f4);\n                if (this._x1 === null) this._ += "M" + (this._x1 = s3) + "," + (this._y1 = l3);\n                else if (k4 > n4) if (!(Math.abs(p3 * v3 - _2 * b) > n4) || !f4) this._ += "L" + (this._x1 = s3) + "," + (this._y1 = l3);\n                else {\n                  var E3 = u4 - h3, S2 = c5 - d3, L3 = v3 * v3 + _2 * _2, x2 = E3 * E3 + S2 * S2, C3 = Math.sqrt(L3), M4 = Math.sqrt(k4), g3 = f4 * Math.tan((t3 - Math.acos((L3 + k4 - x2) / (2 * C3 * M4))) / 2), P3 = g3 / M4, T3 = g3 / C3;\n                  Math.abs(P3 - 1) > n4 && (this._ += "L" + (s3 + P3 * b) + "," + (l3 + P3 * p3)), this._ += "A" + f4 + "," + f4 + ",0,0," + +(p3 * E3 > b * S2) + "," + (this._x1 = s3 + T3 * v3) + "," + (this._y1 = l3 + T3 * _2);\n                }\n              }, arc: function(s3, l3, u4, c5, f4, h3) {\n                s3 = +s3, l3 = +l3, u4 = +u4, h3 = !!h3;\n                var d3 = u4 * Math.cos(c5), v3 = u4 * Math.sin(c5), _2 = s3 + d3, b = l3 + v3, p3 = 1 ^ h3, k4 = h3 ? c5 - f4 : f4 - c5;\n                if (u4 < 0) throw new Error("negative radius: " + u4);\n                this._x1 === null ? this._ += "M" + _2 + "," + b : (Math.abs(this._x1 - _2) > n4 || Math.abs(this._y1 - b) > n4) && (this._ += "L" + _2 + "," + b), u4 && (k4 < 0 && (k4 = k4 % r4 + r4), k4 > i3 ? this._ += "A" + u4 + "," + u4 + ",0,1," + p3 + "," + (s3 - d3) + "," + (l3 - v3) + "A" + u4 + "," + u4 + ",0,1," + p3 + "," + (this._x1 = _2) + "," + (this._y1 = b) : k4 > n4 && (this._ += "A" + u4 + "," + u4 + ",0," + +(k4 >= t3) + "," + p3 + "," + (this._x1 = s3 + u4 * Math.cos(f4)) + "," + (this._y1 = l3 + u4 * Math.sin(f4))));\n              }, rect: function(s3, l3, u4, c5) {\n                this._ += "M" + (this._x0 = this._x1 = +s3) + "," + (this._y0 = this._y1 = +l3) + "h" + +u4 + "v" + +c5 + "h" + -u4 + "Z";\n              }, toString: function() {\n                return this._;\n              } }, e3.path = o4, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var jJ = ye((A7, NWe) => {\n            (function(e3, t3) {\n              typeof A7 == "object" && typeof NWe != "undefined" ? t3(A7, BWe()) : (e3 = e3 || self, t3(e3.d3 = e3.d3 || {}, e3.d3));\n            })(A7, function(e3, t3) {\n              "use strict";\n              function r4(Mt) {\n                return function() {\n                  return Mt;\n                };\n              }\n              var n4 = Math.abs, i3 = Math.atan2, a4 = Math.cos, o4 = Math.max, s3 = Math.min, l3 = Math.sin, u4 = Math.sqrt, c5 = 1e-12, f4 = Math.PI, h3 = f4 / 2, d3 = 2 * f4;\n              function v3(Mt) {\n                return Mt > 1 ? 0 : Mt < -1 ? f4 : Math.acos(Mt);\n              }\n              function _2(Mt) {\n                return Mt >= 1 ? h3 : Mt <= -1 ? -h3 : Math.asin(Mt);\n              }\n              function b(Mt) {\n                return Mt.innerRadius;\n              }\n              function p3(Mt) {\n                return Mt.outerRadius;\n              }\n              function k4(Mt) {\n                return Mt.startAngle;\n              }\n              function E3(Mt) {\n                return Mt.endAngle;\n              }\n              function S2(Mt) {\n                return Mt && Mt.padAngle;\n              }\n              function L3(Mt, kr, Jr, vi, hn, An, Mn, Li) {\n                var _n = Jr - Mt, ya = vi - kr, Jn = Mn - hn, Ma = Li - An, _o = Ma * _n - Jn * ya;\n                if (!(_o * _o < c5)) return _o = (Jn * (kr - An) - Ma * (Mt - hn)) / _o, [Mt + _o * _n, kr + _o * ya];\n              }\n              function x2(Mt, kr, Jr, vi, hn, An, Mn) {\n                var Li = Mt - Jr, _n = kr - vi, ya = (Mn ? An : -An) / u4(Li * Li + _n * _n), Jn = ya * _n, Ma = -ya * Li, _o = Mt + Jn, No = kr + Ma, po = Jr + Jn, Lo = vi + Ma, ko = (_o + po) / 2, Ds = (No + Lo) / 2, Fs = po - _o, ll = Lo - No, ul = Fs * Fs + ll * ll, zl = hn - An, us = _o * Lo - po * No, il = (ll < 0 ? -1 : 1) * u4(o4(0, zl * zl * ul - us * us)), As = (us * ll - Fs * il) / ul, cl = (-us * Fs - ll * il) / ul, Ks = (us * ll + Fs * il) / ul, zs = (-us * Fs + ll * il) / ul, Io = As - ko, ls = cl - Ds, Zl = Ks - ko, Su = zs - Ds;\n                return Io * Io + ls * ls > Zl * Zl + Su * Su && (As = Ks, cl = zs), { cx: As, cy: cl, x01: -Jn, y01: -Ma, x11: As * (hn / zl - 1), y11: cl * (hn / zl - 1) };\n              }\n              function C3() {\n                var Mt = b, kr = p3, Jr = r4(0), vi = null, hn = k4, An = E3, Mn = S2, Li = null;\n                function _n() {\n                  var ya, Jn, Ma = +Mt.apply(this, arguments), _o = +kr.apply(this, arguments), No = hn.apply(this, arguments) - h3, po = An.apply(this, arguments) - h3, Lo = n4(po - No), ko = po > No;\n                  if (Li || (Li = ya = t3.path()), _o < Ma && (Jn = _o, _o = Ma, Ma = Jn), !(_o > c5)) Li.moveTo(0, 0);\n                  else if (Lo > d3 - c5) Li.moveTo(_o * a4(No), _o * l3(No)), Li.arc(0, 0, _o, No, po, !ko), Ma > c5 && (Li.moveTo(Ma * a4(po), Ma * l3(po)), Li.arc(0, 0, Ma, po, No, ko));\n                  else {\n                    var Ds = No, Fs = po, ll = No, ul = po, zl = Lo, us = Lo, il = Mn.apply(this, arguments) / 2, As = il > c5 && (vi ? +vi.apply(this, arguments) : u4(Ma * Ma + _o * _o)), cl = s3(n4(_o - Ma) / 2, +Jr.apply(this, arguments)), Ks = cl, zs = cl, Io, ls;\n                    if (As > c5) {\n                      var Zl = _2(As / Ma * l3(il)), Su = _2(As / _o * l3(il));\n                      (zl -= Zl * 2) > c5 ? (Zl *= ko ? 1 : -1, ll += Zl, ul -= Zl) : (zl = 0, ll = ul = (No + po) / 2), (us -= Su * 2) > c5 ? (Su *= ko ? 1 : -1, Ds += Su, Fs -= Su) : (us = 0, Ds = Fs = (No + po) / 2);\n                    }\n                    var nc = _o * a4(Ds), bs = _o * l3(Ds), Rn = Ma * a4(ul), _a = Ma * l3(ul);\n                    if (cl > c5) {\n                      var Vu = _o * a4(Fs), Ol = _o * l3(Fs), xo = Ma * a4(ll), Yl = Ma * l3(ll), Ns;\n                      if (Lo < f4 && (Ns = L3(nc, bs, xo, Yl, Vu, Ol, Rn, _a))) {\n                        var Hl = nc - Ns[0], ac = bs - Ns[1], aa = Vu - Ns[0], Oo = Ol - Ns[1], qo = 1 / l3(v3((Hl * aa + ac * Oo) / (u4(Hl * Hl + ac * ac) * u4(aa * aa + Oo * Oo))) / 2), ql = u4(Ns[0] * Ns[0] + Ns[1] * Ns[1]);\n                        Ks = s3(cl, (Ma - ql) / (qo - 1)), zs = s3(cl, (_o - ql) / (qo + 1));\n                      }\n                    }\n                    us > c5 ? zs > c5 ? (Io = x2(xo, Yl, nc, bs, _o, zs, ko), ls = x2(Vu, Ol, Rn, _a, _o, zs, ko), Li.moveTo(Io.cx + Io.x01, Io.cy + Io.y01), zs < cl ? Li.arc(Io.cx, Io.cy, zs, i3(Io.y01, Io.x01), i3(ls.y01, ls.x01), !ko) : (Li.arc(Io.cx, Io.cy, zs, i3(Io.y01, Io.x01), i3(Io.y11, Io.x11), !ko), Li.arc(0, 0, _o, i3(Io.cy + Io.y11, Io.cx + Io.x11), i3(ls.cy + ls.y11, ls.cx + ls.x11), !ko), Li.arc(ls.cx, ls.cy, zs, i3(ls.y11, ls.x11), i3(ls.y01, ls.x01), !ko))) : (Li.moveTo(nc, bs), Li.arc(0, 0, _o, Ds, Fs, !ko)) : Li.moveTo(nc, bs), !(Ma > c5) || !(zl > c5) ? Li.lineTo(Rn, _a) : Ks > c5 ? (Io = x2(Rn, _a, Vu, Ol, Ma, -Ks, ko), ls = x2(nc, bs, xo, Yl, Ma, -Ks, ko), Li.lineTo(Io.cx + Io.x01, Io.cy + Io.y01), Ks < cl ? Li.arc(Io.cx, Io.cy, Ks, i3(Io.y01, Io.x01), i3(ls.y01, ls.x01), !ko) : (Li.arc(Io.cx, Io.cy, Ks, i3(Io.y01, Io.x01), i3(Io.y11, Io.x11), !ko), Li.arc(0, 0, Ma, i3(Io.cy + Io.y11, Io.cx + Io.x11), i3(ls.cy + ls.y11, ls.cx + ls.x11), ko), Li.arc(ls.cx, ls.cy, Ks, i3(ls.y11, ls.x11), i3(ls.y01, ls.x01), !ko))) : Li.arc(0, 0, Ma, ul, ll, ko);\n                  }\n                  if (Li.closePath(), ya) return Li = null, ya + "" || null;\n                }\n                return _n.centroid = function() {\n                  var ya = (+Mt.apply(this, arguments) + +kr.apply(this, arguments)) / 2, Jn = (+hn.apply(this, arguments) + +An.apply(this, arguments)) / 2 - f4 / 2;\n                  return [a4(Jn) * ya, l3(Jn) * ya];\n                }, _n.innerRadius = function(ya) {\n                  return arguments.length ? (Mt = typeof ya == "function" ? ya : r4(+ya), _n) : Mt;\n                }, _n.outerRadius = function(ya) {\n                  return arguments.length ? (kr = typeof ya == "function" ? ya : r4(+ya), _n) : kr;\n                }, _n.cornerRadius = function(ya) {\n                  return arguments.length ? (Jr = typeof ya == "function" ? ya : r4(+ya), _n) : Jr;\n                }, _n.padRadius = function(ya) {\n                  return arguments.length ? (vi = ya == null ? null : typeof ya == "function" ? ya : r4(+ya), _n) : vi;\n                }, _n.startAngle = function(ya) {\n                  return arguments.length ? (hn = typeof ya == "function" ? ya : r4(+ya), _n) : hn;\n                }, _n.endAngle = function(ya) {\n                  return arguments.length ? (An = typeof ya == "function" ? ya : r4(+ya), _n) : An;\n                }, _n.padAngle = function(ya) {\n                  return arguments.length ? (Mn = typeof ya == "function" ? ya : r4(+ya), _n) : Mn;\n                }, _n.context = function(ya) {\n                  return arguments.length ? (Li = ya == null ? null : ya, _n) : Li;\n                }, _n;\n              }\n              function M4(Mt) {\n                this._context = Mt;\n              }\n              M4.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._point = 0;\n              }, lineEnd: function() {\n                (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                    break;\n                  case 1:\n                    this._point = 2;\n                  default:\n                    this._context.lineTo(Mt, kr);\n                    break;\n                }\n              } };\n              function g3(Mt) {\n                return new M4(Mt);\n              }\n              function P3(Mt) {\n                return Mt[0];\n              }\n              function T3(Mt) {\n                return Mt[1];\n              }\n              function z3() {\n                var Mt = P3, kr = T3, Jr = r4(true), vi = null, hn = g3, An = null;\n                function Mn(Li) {\n                  var _n, ya = Li.length, Jn, Ma = false, _o;\n                  for (vi == null && (An = hn(_o = t3.path())), _n = 0; _n <= ya; ++_n) !(_n < ya && Jr(Jn = Li[_n], _n, Li)) === Ma && ((Ma = !Ma) ? An.lineStart() : An.lineEnd()), Ma && An.point(+Mt(Jn, _n, Li), +kr(Jn, _n, Li));\n                  if (_o) return An = null, _o + "" || null;\n                }\n                return Mn.x = function(Li) {\n                  return arguments.length ? (Mt = typeof Li == "function" ? Li : r4(+Li), Mn) : Mt;\n                }, Mn.y = function(Li) {\n                  return arguments.length ? (kr = typeof Li == "function" ? Li : r4(+Li), Mn) : kr;\n                }, Mn.defined = function(Li) {\n                  return arguments.length ? (Jr = typeof Li == "function" ? Li : r4(!!Li), Mn) : Jr;\n                }, Mn.curve = function(Li) {\n                  return arguments.length ? (hn = Li, vi != null && (An = hn(vi)), Mn) : hn;\n                }, Mn.context = function(Li) {\n                  return arguments.length ? (Li == null ? vi = An = null : An = hn(vi = Li), Mn) : vi;\n                }, Mn;\n              }\n              function O3() {\n                var Mt = P3, kr = null, Jr = r4(0), vi = T3, hn = r4(true), An = null, Mn = g3, Li = null;\n                function _n(Jn) {\n                  var Ma, _o, No, po = Jn.length, Lo, ko = false, Ds, Fs = new Array(po), ll = new Array(po);\n                  for (An == null && (Li = Mn(Ds = t3.path())), Ma = 0; Ma <= po; ++Ma) {\n                    if (!(Ma < po && hn(Lo = Jn[Ma], Ma, Jn)) === ko) if (ko = !ko) _o = Ma, Li.areaStart(), Li.lineStart();\n                    else {\n                      for (Li.lineEnd(), Li.lineStart(), No = Ma - 1; No >= _o; --No) Li.point(Fs[No], ll[No]);\n                      Li.lineEnd(), Li.areaEnd();\n                    }\n                    ko && (Fs[Ma] = +Mt(Lo, Ma, Jn), ll[Ma] = +Jr(Lo, Ma, Jn), Li.point(kr ? +kr(Lo, Ma, Jn) : Fs[Ma], vi ? +vi(Lo, Ma, Jn) : ll[Ma]));\n                  }\n                  if (Ds) return Li = null, Ds + "" || null;\n                }\n                function ya() {\n                  return z3().defined(hn).curve(Mn).context(An);\n                }\n                return _n.x = function(Jn) {\n                  return arguments.length ? (Mt = typeof Jn == "function" ? Jn : r4(+Jn), kr = null, _n) : Mt;\n                }, _n.x0 = function(Jn) {\n                  return arguments.length ? (Mt = typeof Jn == "function" ? Jn : r4(+Jn), _n) : Mt;\n                }, _n.x1 = function(Jn) {\n                  return arguments.length ? (kr = Jn == null ? null : typeof Jn == "function" ? Jn : r4(+Jn), _n) : kr;\n                }, _n.y = function(Jn) {\n                  return arguments.length ? (Jr = typeof Jn == "function" ? Jn : r4(+Jn), vi = null, _n) : Jr;\n                }, _n.y0 = function(Jn) {\n                  return arguments.length ? (Jr = typeof Jn == "function" ? Jn : r4(+Jn), _n) : Jr;\n                }, _n.y1 = function(Jn) {\n                  return arguments.length ? (vi = Jn == null ? null : typeof Jn == "function" ? Jn : r4(+Jn), _n) : vi;\n                }, _n.lineX0 = _n.lineY0 = function() {\n                  return ya().x(Mt).y(Jr);\n                }, _n.lineY1 = function() {\n                  return ya().x(Mt).y(vi);\n                }, _n.lineX1 = function() {\n                  return ya().x(kr).y(Jr);\n                }, _n.defined = function(Jn) {\n                  return arguments.length ? (hn = typeof Jn == "function" ? Jn : r4(!!Jn), _n) : hn;\n                }, _n.curve = function(Jn) {\n                  return arguments.length ? (Mn = Jn, An != null && (Li = Mn(An)), _n) : Mn;\n                }, _n.context = function(Jn) {\n                  return arguments.length ? (Jn == null ? An = Li = null : Li = Mn(An = Jn), _n) : An;\n                }, _n;\n              }\n              function V2(Mt, kr) {\n                return kr < Mt ? -1 : kr > Mt ? 1 : kr >= Mt ? 0 : NaN;\n              }\n              function G2(Mt) {\n                return Mt;\n              }\n              function Z() {\n                var Mt = G2, kr = V2, Jr = null, vi = r4(0), hn = r4(d3), An = r4(0);\n                function Mn(Li) {\n                  var _n, ya = Li.length, Jn, Ma, _o = 0, No = new Array(ya), po = new Array(ya), Lo = +vi.apply(this, arguments), ko = Math.min(d3, Math.max(-d3, hn.apply(this, arguments) - Lo)), Ds, Fs = Math.min(Math.abs(ko) / ya, An.apply(this, arguments)), ll = Fs * (ko < 0 ? -1 : 1), ul;\n                  for (_n = 0; _n < ya; ++_n) (ul = po[No[_n] = _n] = +Mt(Li[_n], _n, Li)) > 0 && (_o += ul);\n                  for (kr != null ? No.sort(function(zl, us) {\n                    return kr(po[zl], po[us]);\n                  }) : Jr != null && No.sort(function(zl, us) {\n                    return Jr(Li[zl], Li[us]);\n                  }), _n = 0, Ma = _o ? (ko - ya * ll) / _o : 0; _n < ya; ++_n, Lo = Ds) Jn = No[_n], ul = po[Jn], Ds = Lo + (ul > 0 ? ul * Ma : 0) + ll, po[Jn] = { data: Li[Jn], index: _n, value: ul, startAngle: Lo, endAngle: Ds, padAngle: Fs };\n                  return po;\n                }\n                return Mn.value = function(Li) {\n                  return arguments.length ? (Mt = typeof Li == "function" ? Li : r4(+Li), Mn) : Mt;\n                }, Mn.sortValues = function(Li) {\n                  return arguments.length ? (kr = Li, Jr = null, Mn) : kr;\n                }, Mn.sort = function(Li) {\n                  return arguments.length ? (Jr = Li, kr = null, Mn) : Jr;\n                }, Mn.startAngle = function(Li) {\n                  return arguments.length ? (vi = typeof Li == "function" ? Li : r4(+Li), Mn) : vi;\n                }, Mn.endAngle = function(Li) {\n                  return arguments.length ? (hn = typeof Li == "function" ? Li : r4(+Li), Mn) : hn;\n                }, Mn.padAngle = function(Li) {\n                  return arguments.length ? (An = typeof Li == "function" ? Li : r4(+Li), Mn) : An;\n                }, Mn;\n              }\n              var j3 = H(g3);\n              function N2(Mt) {\n                this._curve = Mt;\n              }\n              N2.prototype = { areaStart: function() {\n                this._curve.areaStart();\n              }, areaEnd: function() {\n                this._curve.areaEnd();\n              }, lineStart: function() {\n                this._curve.lineStart();\n              }, lineEnd: function() {\n                this._curve.lineEnd();\n              }, point: function(Mt, kr) {\n                this._curve.point(kr * Math.sin(Mt), kr * -Math.cos(Mt));\n              } };\n              function H(Mt) {\n                function kr(Jr) {\n                  return new N2(Mt(Jr));\n                }\n                return kr._curve = Mt, kr;\n              }\n              function te(Mt) {\n                var kr = Mt.curve;\n                return Mt.angle = Mt.x, delete Mt.x, Mt.radius = Mt.y, delete Mt.y, Mt.curve = function(Jr) {\n                  return arguments.length ? kr(H(Jr)) : kr()._curve;\n                }, Mt;\n              }\n              function oe() {\n                return te(z3().curve(j3));\n              }\n              function _e() {\n                var Mt = O3().curve(j3), kr = Mt.curve, Jr = Mt.lineX0, vi = Mt.lineX1, hn = Mt.lineY0, An = Mt.lineY1;\n                return Mt.angle = Mt.x, delete Mt.x, Mt.startAngle = Mt.x0, delete Mt.x0, Mt.endAngle = Mt.x1, delete Mt.x1, Mt.radius = Mt.y, delete Mt.y, Mt.innerRadius = Mt.y0, delete Mt.y0, Mt.outerRadius = Mt.y1, delete Mt.y1, Mt.lineStartAngle = function() {\n                  return te(Jr());\n                }, delete Mt.lineX0, Mt.lineEndAngle = function() {\n                  return te(vi());\n                }, delete Mt.lineX1, Mt.lineInnerRadius = function() {\n                  return te(hn());\n                }, delete Mt.lineY0, Mt.lineOuterRadius = function() {\n                  return te(An());\n                }, delete Mt.lineY1, Mt.curve = function(Mn) {\n                  return arguments.length ? kr(H(Mn)) : kr()._curve;\n                }, Mt;\n              }\n              function Ee(Mt, kr) {\n                return [(kr = +kr) * Math.cos(Mt -= Math.PI / 2), kr * Math.sin(Mt)];\n              }\n              var Ce = Array.prototype.slice;\n              function me(Mt) {\n                return Mt.source;\n              }\n              function ie(Mt) {\n                return Mt.target;\n              }\n              function Se(Mt) {\n                var kr = me, Jr = ie, vi = P3, hn = T3, An = null;\n                function Mn() {\n                  var Li, _n = Ce.call(arguments), ya = kr.apply(this, _n), Jn = Jr.apply(this, _n);\n                  if (An || (An = Li = t3.path()), Mt(An, +vi.apply(this, (_n[0] = ya, _n)), +hn.apply(this, _n), +vi.apply(this, (_n[0] = Jn, _n)), +hn.apply(this, _n)), Li) return An = null, Li + "" || null;\n                }\n                return Mn.source = function(Li) {\n                  return arguments.length ? (kr = Li, Mn) : kr;\n                }, Mn.target = function(Li) {\n                  return arguments.length ? (Jr = Li, Mn) : Jr;\n                }, Mn.x = function(Li) {\n                  return arguments.length ? (vi = typeof Li == "function" ? Li : r4(+Li), Mn) : vi;\n                }, Mn.y = function(Li) {\n                  return arguments.length ? (hn = typeof Li == "function" ? Li : r4(+Li), Mn) : hn;\n                }, Mn.context = function(Li) {\n                  return arguments.length ? (An = Li == null ? null : Li, Mn) : An;\n                }, Mn;\n              }\n              function Le(Mt, kr, Jr, vi, hn) {\n                Mt.moveTo(kr, Jr), Mt.bezierCurveTo(kr = (kr + vi) / 2, Jr, kr, hn, vi, hn);\n              }\n              function Ae(Mt, kr, Jr, vi, hn) {\n                Mt.moveTo(kr, Jr), Mt.bezierCurveTo(kr, Jr = (Jr + hn) / 2, vi, Jr, vi, hn);\n              }\n              function Fe(Mt, kr, Jr, vi, hn) {\n                var An = Ee(kr, Jr), Mn = Ee(kr, Jr = (Jr + hn) / 2), Li = Ee(vi, Jr), _n = Ee(vi, hn);\n                Mt.moveTo(An[0], An[1]), Mt.bezierCurveTo(Mn[0], Mn[1], Li[0], Li[1], _n[0], _n[1]);\n              }\n              function Pe() {\n                return Se(Le);\n              }\n              function ge() {\n                return Se(Ae);\n              }\n              function Re() {\n                var Mt = Se(Fe);\n                return Mt.angle = Mt.x, delete Mt.x, Mt.radius = Mt.y, delete Mt.y, Mt;\n              }\n              var ce = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr / f4);\n                Mt.moveTo(Jr, 0), Mt.arc(0, 0, Jr, 0, d3);\n              } }, Ze = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr / 5) / 2;\n                Mt.moveTo(-3 * Jr, -Jr), Mt.lineTo(-Jr, -Jr), Mt.lineTo(-Jr, -3 * Jr), Mt.lineTo(Jr, -3 * Jr), Mt.lineTo(Jr, -Jr), Mt.lineTo(3 * Jr, -Jr), Mt.lineTo(3 * Jr, Jr), Mt.lineTo(Jr, Jr), Mt.lineTo(Jr, 3 * Jr), Mt.lineTo(-Jr, 3 * Jr), Mt.lineTo(-Jr, Jr), Mt.lineTo(-3 * Jr, Jr), Mt.closePath();\n              } }, ut = Math.sqrt(1 / 3), pt = ut * 2, Zt = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr / pt), vi = Jr * ut;\n                Mt.moveTo(0, -Jr), Mt.lineTo(vi, 0), Mt.lineTo(0, Jr), Mt.lineTo(-vi, 0), Mt.closePath();\n              } }, st = 0.8908130915292852, lt = Math.sin(f4 / 10) / Math.sin(7 * f4 / 10), Gt = Math.sin(d3 / 10) * lt, Nt = -Math.cos(d3 / 10) * lt, Jt = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr * st), vi = Gt * Jr, hn = Nt * Jr;\n                Mt.moveTo(0, -Jr), Mt.lineTo(vi, hn);\n                for (var An = 1; An < 5; ++An) {\n                  var Mn = d3 * An / 5, Li = Math.cos(Mn), _n = Math.sin(Mn);\n                  Mt.lineTo(_n * Jr, -Li * Jr), Mt.lineTo(Li * vi - _n * hn, _n * vi + Li * hn);\n                }\n                Mt.closePath();\n              } }, sr = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr), vi = -Jr / 2;\n                Mt.rect(vi, vi, Jr, Jr);\n              } }, wr = Math.sqrt(3), cr = { draw: function(Mt, kr) {\n                var Jr = -Math.sqrt(kr / (wr * 3));\n                Mt.moveTo(0, Jr * 2), Mt.lineTo(-wr * Jr, -Jr), Mt.lineTo(wr * Jr, -Jr), Mt.closePath();\n              } }, $e = -0.5, St = Math.sqrt(3) / 2, Qt = 1 / Math.sqrt(12), Vt = (Qt / 2 + 1) * 3, _t = { draw: function(Mt, kr) {\n                var Jr = Math.sqrt(kr / Vt), vi = Jr / 2, hn = Jr * Qt, An = vi, Mn = Jr * Qt + Jr, Li = -An, _n = Mn;\n                Mt.moveTo(vi, hn), Mt.lineTo(An, Mn), Mt.lineTo(Li, _n), Mt.lineTo($e * vi - St * hn, St * vi + $e * hn), Mt.lineTo($e * An - St * Mn, St * An + $e * Mn), Mt.lineTo($e * Li - St * _n, St * Li + $e * _n), Mt.lineTo($e * vi + St * hn, $e * hn - St * vi), Mt.lineTo($e * An + St * Mn, $e * Mn - St * An), Mt.lineTo($e * Li + St * _n, $e * _n - St * Li), Mt.closePath();\n              } }, It = [ce, Ze, Zt, sr, Jt, cr, _t];\n              function mt() {\n                var Mt = r4(ce), kr = r4(64), Jr = null;\n                function vi() {\n                  var hn;\n                  if (Jr || (Jr = hn = t3.path()), Mt.apply(this, arguments).draw(Jr, +kr.apply(this, arguments)), hn) return Jr = null, hn + "" || null;\n                }\n                return vi.type = function(hn) {\n                  return arguments.length ? (Mt = typeof hn == "function" ? hn : r4(hn), vi) : Mt;\n                }, vi.size = function(hn) {\n                  return arguments.length ? (kr = typeof hn == "function" ? hn : r4(+hn), vi) : kr;\n                }, vi.context = function(hn) {\n                  return arguments.length ? (Jr = hn == null ? null : hn, vi) : Jr;\n                }, vi;\n              }\n              function er() {\n              }\n              function lr(Mt, kr, Jr) {\n                Mt._context.bezierCurveTo((2 * Mt._x0 + Mt._x1) / 3, (2 * Mt._y0 + Mt._y1) / 3, (Mt._x0 + 2 * Mt._x1) / 3, (Mt._y0 + 2 * Mt._y1) / 3, (Mt._x0 + 4 * Mt._x1 + kr) / 6, (Mt._y0 + 4 * Mt._y1 + Jr) / 6);\n              }\n              function Tr(Mt) {\n                this._context = Mt;\n              }\n              Tr.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 3:\n                    lr(this, this._x1, this._y1);\n                  case 2:\n                    this._context.lineTo(this._x1, this._y1);\n                    break;\n                }\n                (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                    break;\n                  case 1:\n                    this._point = 2;\n                    break;\n                  case 2:\n                    this._point = 3, this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);\n                  default:\n                    lr(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;\n              } };\n              function Lr(Mt) {\n                return new Tr(Mt);\n              }\n              function ti(Mt) {\n                this._context = Mt;\n              }\n              ti.prototype = { areaStart: er, areaEnd: er, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 1: {\n                    this._context.moveTo(this._x2, this._y2), this._context.closePath();\n                    break;\n                  }\n                  case 2: {\n                    this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3), this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3), this._context.closePath();\n                    break;\n                  }\n                  case 3: {\n                    this.point(this._x2, this._y2), this.point(this._x3, this._y3), this.point(this._x4, this._y4);\n                    break;\n                  }\n                }\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._x2 = Mt, this._y2 = kr;\n                    break;\n                  case 1:\n                    this._point = 2, this._x3 = Mt, this._y3 = kr;\n                    break;\n                  case 2:\n                    this._point = 3, this._x4 = Mt, this._y4 = kr, this._context.moveTo((this._x0 + 4 * this._x1 + Mt) / 6, (this._y0 + 4 * this._y1 + kr) / 6);\n                    break;\n                  default:\n                    lr(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;\n              } };\n              function Br(Mt) {\n                return new ti(Mt);\n              }\n              function Vr(Mt) {\n                this._context = Mt;\n              }\n              Vr.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1;\n                    break;\n                  case 1:\n                    this._point = 2;\n                    break;\n                  case 2:\n                    this._point = 3;\n                    var Jr = (this._x0 + 4 * this._x1 + Mt) / 6, vi = (this._y0 + 4 * this._y1 + kr) / 6;\n                    this._line ? this._context.lineTo(Jr, vi) : this._context.moveTo(Jr, vi);\n                    break;\n                  case 3:\n                    this._point = 4;\n                  default:\n                    lr(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr;\n              } };\n              function dt(Mt) {\n                return new Vr(Mt);\n              }\n              function Ge(Mt, kr) {\n                this._basis = new Tr(Mt), this._beta = kr;\n              }\n              Ge.prototype = { lineStart: function() {\n                this._x = [], this._y = [], this._basis.lineStart();\n              }, lineEnd: function() {\n                var Mt = this._x, kr = this._y, Jr = Mt.length - 1;\n                if (Jr > 0) for (var vi = Mt[0], hn = kr[0], An = Mt[Jr] - vi, Mn = kr[Jr] - hn, Li = -1, _n; ++Li <= Jr; ) _n = Li / Jr, this._basis.point(this._beta * Mt[Li] + (1 - this._beta) * (vi + _n * An), this._beta * kr[Li] + (1 - this._beta) * (hn + _n * Mn));\n                this._x = this._y = null, this._basis.lineEnd();\n              }, point: function(Mt, kr) {\n                this._x.push(+Mt), this._y.push(+kr);\n              } };\n              var Je = (function Mt(kr) {\n                function Jr(vi) {\n                  return kr === 1 ? new Tr(vi) : new Ge(vi, kr);\n                }\n                return Jr.beta = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0.85);\n              function je(Mt, kr, Jr) {\n                Mt._context.bezierCurveTo(Mt._x1 + Mt._k * (Mt._x2 - Mt._x0), Mt._y1 + Mt._k * (Mt._y2 - Mt._y0), Mt._x2 + Mt._k * (Mt._x1 - kr), Mt._y2 + Mt._k * (Mt._y1 - Jr), Mt._x2, Mt._y2);\n              }\n              function tt(Mt, kr) {\n                this._context = Mt, this._k = (1 - kr) / 6;\n              }\n              tt.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 2:\n                    this._context.lineTo(this._x2, this._y2);\n                    break;\n                  case 3:\n                    je(this, this._x1, this._y1);\n                    break;\n                }\n                (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                    break;\n                  case 1:\n                    this._point = 2, this._x1 = Mt, this._y1 = kr;\n                    break;\n                  case 2:\n                    this._point = 3;\n                  default:\n                    je(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var xt = (function Mt(kr) {\n                function Jr(vi) {\n                  return new tt(vi, kr);\n                }\n                return Jr.tension = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0);\n              function Ie(Mt, kr) {\n                this._context = Mt, this._k = (1 - kr) / 6;\n              }\n              Ie.prototype = { areaStart: er, areaEnd: er, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 1: {\n                    this._context.moveTo(this._x3, this._y3), this._context.closePath();\n                    break;\n                  }\n                  case 2: {\n                    this._context.lineTo(this._x3, this._y3), this._context.closePath();\n                    break;\n                  }\n                  case 3: {\n                    this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);\n                    break;\n                  }\n                }\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._x3 = Mt, this._y3 = kr;\n                    break;\n                  case 1:\n                    this._point = 2, this._context.moveTo(this._x4 = Mt, this._y4 = kr);\n                    break;\n                  case 2:\n                    this._point = 3, this._x5 = Mt, this._y5 = kr;\n                    break;\n                  default:\n                    je(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var xe = (function Mt(kr) {\n                function Jr(vi) {\n                  return new Ie(vi, kr);\n                }\n                return Jr.tension = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0);\n              function ke(Mt, kr) {\n                this._context = Mt, this._k = (1 - kr) / 6;\n              }\n              ke.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1;\n                    break;\n                  case 1:\n                    this._point = 2;\n                    break;\n                  case 2:\n                    this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);\n                    break;\n                  case 3:\n                    this._point = 4;\n                  default:\n                    je(this, Mt, kr);\n                    break;\n                }\n                this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var vt = (function Mt(kr) {\n                function Jr(vi) {\n                  return new ke(vi, kr);\n                }\n                return Jr.tension = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0);\n              function ir(Mt, kr, Jr) {\n                var vi = Mt._x1, hn = Mt._y1, An = Mt._x2, Mn = Mt._y2;\n                if (Mt._l01_a > c5) {\n                  var Li = 2 * Mt._l01_2a + 3 * Mt._l01_a * Mt._l12_a + Mt._l12_2a, _n = 3 * Mt._l01_a * (Mt._l01_a + Mt._l12_a);\n                  vi = (vi * Li - Mt._x0 * Mt._l12_2a + Mt._x2 * Mt._l01_2a) / _n, hn = (hn * Li - Mt._y0 * Mt._l12_2a + Mt._y2 * Mt._l01_2a) / _n;\n                }\n                if (Mt._l23_a > c5) {\n                  var ya = 2 * Mt._l23_2a + 3 * Mt._l23_a * Mt._l12_a + Mt._l12_2a, Jn = 3 * Mt._l23_a * (Mt._l23_a + Mt._l12_a);\n                  An = (An * ya + Mt._x1 * Mt._l23_2a - kr * Mt._l12_2a) / Jn, Mn = (Mn * ya + Mt._y1 * Mt._l23_2a - Jr * Mt._l12_2a) / Jn;\n                }\n                Mt._context.bezierCurveTo(vi, hn, An, Mn, Mt._x2, Mt._y2);\n              }\n              function ar(Mt, kr) {\n                this._context = Mt, this._alpha = kr;\n              }\n              ar.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 2:\n                    this._context.lineTo(this._x2, this._y2);\n                    break;\n                  case 3:\n                    this.point(this._x2, this._y2);\n                    break;\n                }\n                (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                if (Mt = +Mt, kr = +kr, this._point) {\n                  var Jr = this._x2 - Mt, vi = this._y2 - kr;\n                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));\n                }\n                switch (this._point) {\n                  case 0:\n                    this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                    break;\n                  case 1:\n                    this._point = 2;\n                    break;\n                  case 2:\n                    this._point = 3;\n                  default:\n                    ir(this, Mt, kr);\n                    break;\n                }\n                this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var vr = (function Mt(kr) {\n                function Jr(vi) {\n                  return kr ? new ar(vi, kr) : new tt(vi, 0);\n                }\n                return Jr.alpha = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0.5);\n              function ii(Mt, kr) {\n                this._context = Mt, this._alpha = kr;\n              }\n              ii.prototype = { areaStart: er, areaEnd: er, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 1: {\n                    this._context.moveTo(this._x3, this._y3), this._context.closePath();\n                    break;\n                  }\n                  case 2: {\n                    this._context.lineTo(this._x3, this._y3), this._context.closePath();\n                    break;\n                  }\n                  case 3: {\n                    this.point(this._x3, this._y3), this.point(this._x4, this._y4), this.point(this._x5, this._y5);\n                    break;\n                  }\n                }\n              }, point: function(Mt, kr) {\n                if (Mt = +Mt, kr = +kr, this._point) {\n                  var Jr = this._x2 - Mt, vi = this._y2 - kr;\n                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));\n                }\n                switch (this._point) {\n                  case 0:\n                    this._point = 1, this._x3 = Mt, this._y3 = kr;\n                    break;\n                  case 1:\n                    this._point = 2, this._context.moveTo(this._x4 = Mt, this._y4 = kr);\n                    break;\n                  case 2:\n                    this._point = 3, this._x5 = Mt, this._y5 = kr;\n                    break;\n                  default:\n                    ir(this, Mt, kr);\n                    break;\n                }\n                this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var pi = (function Mt(kr) {\n                function Jr(vi) {\n                  return kr ? new ii(vi, kr) : new Ie(vi, 0);\n                }\n                return Jr.alpha = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0.5);\n              function $r(Mt, kr) {\n                this._context = Mt, this._alpha = kr;\n              }\n              $r.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._x2 = this._y0 = this._y1 = this._y2 = NaN, this._l01_a = this._l12_a = this._l23_a = this._l01_2a = this._l12_2a = this._l23_2a = this._point = 0;\n              }, lineEnd: function() {\n                (this._line || this._line !== 0 && this._point === 3) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                if (Mt = +Mt, kr = +kr, this._point) {\n                  var Jr = this._x2 - Mt, vi = this._y2 - kr;\n                  this._l23_a = Math.sqrt(this._l23_2a = Math.pow(Jr * Jr + vi * vi, this._alpha));\n                }\n                switch (this._point) {\n                  case 0:\n                    this._point = 1;\n                    break;\n                  case 1:\n                    this._point = 2;\n                    break;\n                  case 2:\n                    this._point = 3, this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2);\n                    break;\n                  case 3:\n                    this._point = 4;\n                  default:\n                    ir(this, Mt, kr);\n                    break;\n                }\n                this._l01_a = this._l12_a, this._l12_a = this._l23_a, this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a, this._x0 = this._x1, this._x1 = this._x2, this._x2 = Mt, this._y0 = this._y1, this._y1 = this._y2, this._y2 = kr;\n              } };\n              var di = (function Mt(kr) {\n                function Jr(vi) {\n                  return kr ? new $r(vi, kr) : new ke(vi, 0);\n                }\n                return Jr.alpha = function(vi) {\n                  return Mt(+vi);\n                }, Jr;\n              })(0.5);\n              function ji(Mt) {\n                this._context = Mt;\n              }\n              ji.prototype = { areaStart: er, areaEnd: er, lineStart: function() {\n                this._point = 0;\n              }, lineEnd: function() {\n                this._point && this._context.closePath();\n              }, point: function(Mt, kr) {\n                Mt = +Mt, kr = +kr, this._point ? this._context.lineTo(Mt, kr) : (this._point = 1, this._context.moveTo(Mt, kr));\n              } };\n              function In(Mt) {\n                return new ji(Mt);\n              }\n              function wi(Mt) {\n                return Mt < 0 ? -1 : 1;\n              }\n              function On(Mt, kr, Jr) {\n                var vi = Mt._x1 - Mt._x0, hn = kr - Mt._x1, An = (Mt._y1 - Mt._y0) / (vi || hn < 0 && -0), Mn = (Jr - Mt._y1) / (hn || vi < 0 && -0), Li = (An * hn + Mn * vi) / (vi + hn);\n                return (wi(An) + wi(Mn)) * Math.min(Math.abs(An), Math.abs(Mn), 0.5 * Math.abs(Li)) || 0;\n              }\n              function qn(Mt, kr) {\n                var Jr = Mt._x1 - Mt._x0;\n                return Jr ? (3 * (Mt._y1 - Mt._y0) / Jr - kr) / 2 : kr;\n              }\n              function Fn(Mt, kr, Jr) {\n                var vi = Mt._x0, hn = Mt._y0, An = Mt._x1, Mn = Mt._y1, Li = (An - vi) / 3;\n                Mt._context.bezierCurveTo(vi + Li, hn + Li * kr, An - Li, Mn - Li * Jr, An, Mn);\n              }\n              function ra(Mt) {\n                this._context = Mt;\n              }\n              ra.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x0 = this._x1 = this._y0 = this._y1 = this._t0 = NaN, this._point = 0;\n              }, lineEnd: function() {\n                switch (this._point) {\n                  case 2:\n                    this._context.lineTo(this._x1, this._y1);\n                    break;\n                  case 3:\n                    Fn(this, this._t0, qn(this, this._t0));\n                    break;\n                }\n                (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;\n              }, point: function(Mt, kr) {\n                var Jr = NaN;\n                if (Mt = +Mt, kr = +kr, !(Mt === this._x1 && kr === this._y1)) {\n                  switch (this._point) {\n                    case 0:\n                      this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                      break;\n                    case 1:\n                      this._point = 2;\n                      break;\n                    case 2:\n                      this._point = 3, Fn(this, qn(this, Jr = On(this, Mt, kr)), Jr);\n                      break;\n                    default:\n                      Fn(this, this._t0, Jr = On(this, Mt, kr));\n                      break;\n                  }\n                  this._x0 = this._x1, this._x1 = Mt, this._y0 = this._y1, this._y1 = kr, this._t0 = Jr;\n                }\n              } };\n              function la(Mt) {\n                this._context = new Ut(Mt);\n              }\n              (la.prototype = Object.create(ra.prototype)).point = function(Mt, kr) {\n                ra.prototype.point.call(this, kr, Mt);\n              };\n              function Ut(Mt) {\n                this._context = Mt;\n              }\n              Ut.prototype = { moveTo: function(Mt, kr) {\n                this._context.moveTo(kr, Mt);\n              }, closePath: function() {\n                this._context.closePath();\n              }, lineTo: function(Mt, kr) {\n                this._context.lineTo(kr, Mt);\n              }, bezierCurveTo: function(Mt, kr, Jr, vi, hn, An) {\n                this._context.bezierCurveTo(kr, Mt, vi, Jr, An, hn);\n              } };\n              function wt(Mt) {\n                return new ra(Mt);\n              }\n              function rr(Mt) {\n                return new la(Mt);\n              }\n              function nr(Mt) {\n                this._context = Mt;\n              }\n              nr.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x = [], this._y = [];\n              }, lineEnd: function() {\n                var Mt = this._x, kr = this._y, Jr = Mt.length;\n                if (Jr) if (this._line ? this._context.lineTo(Mt[0], kr[0]) : this._context.moveTo(Mt[0], kr[0]), Jr === 2) this._context.lineTo(Mt[1], kr[1]);\n                else for (var vi = Er(Mt), hn = Er(kr), An = 0, Mn = 1; Mn < Jr; ++An, ++Mn) this._context.bezierCurveTo(vi[0][An], hn[0][An], vi[1][An], hn[1][An], Mt[Mn], kr[Mn]);\n                (this._line || this._line !== 0 && Jr === 1) && this._context.closePath(), this._line = 1 - this._line, this._x = this._y = null;\n              }, point: function(Mt, kr) {\n                this._x.push(+Mt), this._y.push(+kr);\n              } };\n              function Er(Mt) {\n                var kr, Jr = Mt.length - 1, vi, hn = new Array(Jr), An = new Array(Jr), Mn = new Array(Jr);\n                for (hn[0] = 0, An[0] = 2, Mn[0] = Mt[0] + 2 * Mt[1], kr = 1; kr < Jr - 1; ++kr) hn[kr] = 1, An[kr] = 4, Mn[kr] = 4 * Mt[kr] + 2 * Mt[kr + 1];\n                for (hn[Jr - 1] = 2, An[Jr - 1] = 7, Mn[Jr - 1] = 8 * Mt[Jr - 1] + Mt[Jr], kr = 1; kr < Jr; ++kr) vi = hn[kr] / An[kr - 1], An[kr] -= vi, Mn[kr] -= vi * Mn[kr - 1];\n                for (hn[Jr - 1] = Mn[Jr - 1] / An[Jr - 1], kr = Jr - 2; kr >= 0; --kr) hn[kr] = (Mn[kr] - hn[kr + 1]) / An[kr];\n                for (An[Jr - 1] = (Mt[Jr] + hn[Jr - 1]) / 2, kr = 0; kr < Jr - 1; ++kr) An[kr] = 2 * Mt[kr + 1] - hn[kr + 1];\n                return [hn, An];\n              }\n              function Xr(Mt) {\n                return new nr(Mt);\n              }\n              function ri(Mt, kr) {\n                this._context = Mt, this._t = kr;\n              }\n              ri.prototype = { areaStart: function() {\n                this._line = 0;\n              }, areaEnd: function() {\n                this._line = NaN;\n              }, lineStart: function() {\n                this._x = this._y = NaN, this._point = 0;\n              }, lineEnd: function() {\n                0 < this._t && this._t < 1 && this._point === 2 && this._context.lineTo(this._x, this._y), (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line >= 0 && (this._t = 1 - this._t, this._line = 1 - this._line);\n              }, point: function(Mt, kr) {\n                switch (Mt = +Mt, kr = +kr, this._point) {\n                  case 0:\n                    this._point = 1, this._line ? this._context.lineTo(Mt, kr) : this._context.moveTo(Mt, kr);\n                    break;\n                  case 1:\n                    this._point = 2;\n                  default: {\n                    if (this._t <= 0) this._context.lineTo(this._x, kr), this._context.lineTo(Mt, kr);\n                    else {\n                      var Jr = this._x * (1 - this._t) + Mt * this._t;\n                      this._context.lineTo(Jr, this._y), this._context.lineTo(Jr, kr);\n                    }\n                    break;\n                  }\n                }\n                this._x = Mt, this._y = kr;\n              } };\n              function Qr(Mt) {\n                return new ri(Mt, 0.5);\n              }\n              function Oi(Mt) {\n                return new ri(Mt, 0);\n              }\n              function $i(Mt) {\n                return new ri(Mt, 1);\n              }\n              function tn(Mt, kr) {\n                if ((Mn = Mt.length) > 1) for (var Jr = 1, vi, hn, An = Mt[kr[0]], Mn, Li = An.length; Jr < Mn; ++Jr) for (hn = An, An = Mt[kr[Jr]], vi = 0; vi < Li; ++vi) An[vi][1] += An[vi][0] = isNaN(hn[vi][1]) ? hn[vi][0] : hn[vi][1];\n              }\n              function fn(Mt) {\n                for (var kr = Mt.length, Jr = new Array(kr); --kr >= 0; ) Jr[kr] = kr;\n                return Jr;\n              }\n              function yn(Mt, kr) {\n                return Mt[kr];\n              }\n              function Sn() {\n                var Mt = r4([]), kr = fn, Jr = tn, vi = yn;\n                function hn(An) {\n                  var Mn = Mt.apply(this, arguments), Li, _n = An.length, ya = Mn.length, Jn = new Array(ya), Ma;\n                  for (Li = 0; Li < ya; ++Li) {\n                    for (var _o = Mn[Li], No = Jn[Li] = new Array(_n), po = 0, Lo; po < _n; ++po) No[po] = Lo = [0, +vi(An[po], _o, po, An)], Lo.data = An[po];\n                    No.key = _o;\n                  }\n                  for (Li = 0, Ma = kr(Jn); Li < ya; ++Li) Jn[Ma[Li]].index = Li;\n                  return Jr(Jn, Ma), Jn;\n                }\n                return hn.keys = function(An) {\n                  return arguments.length ? (Mt = typeof An == "function" ? An : r4(Ce.call(An)), hn) : Mt;\n                }, hn.value = function(An) {\n                  return arguments.length ? (vi = typeof An == "function" ? An : r4(+An), hn) : vi;\n                }, hn.order = function(An) {\n                  return arguments.length ? (kr = An == null ? fn : typeof An == "function" ? An : r4(Ce.call(An)), hn) : kr;\n                }, hn.offset = function(An) {\n                  return arguments.length ? (Jr = An == null ? tn : An, hn) : Jr;\n                }, hn;\n              }\n              function Ba(Mt, kr) {\n                if ((vi = Mt.length) > 0) {\n                  for (var Jr, vi, hn = 0, An = Mt[0].length, Mn; hn < An; ++hn) {\n                    for (Mn = Jr = 0; Jr < vi; ++Jr) Mn += Mt[Jr][hn][1] || 0;\n                    if (Mn) for (Jr = 0; Jr < vi; ++Jr) Mt[Jr][hn][1] /= Mn;\n                  }\n                  tn(Mt, kr);\n                }\n              }\n              function ua(Mt, kr) {\n                if ((_n = Mt.length) > 0) for (var Jr, vi = 0, hn, An, Mn, Li, _n, ya = Mt[kr[0]].length; vi < ya; ++vi) for (Mn = Li = 0, Jr = 0; Jr < _n; ++Jr) (An = (hn = Mt[kr[Jr]][vi])[1] - hn[0]) > 0 ? (hn[0] = Mn, hn[1] = Mn += An) : An < 0 ? (hn[1] = Li, hn[0] = Li += An) : (hn[0] = 0, hn[1] = An);\n              }\n              function ma(Mt, kr) {\n                if ((hn = Mt.length) > 0) {\n                  for (var Jr = 0, vi = Mt[kr[0]], hn, An = vi.length; Jr < An; ++Jr) {\n                    for (var Mn = 0, Li = 0; Mn < hn; ++Mn) Li += Mt[Mn][Jr][1] || 0;\n                    vi[Jr][1] += vi[Jr][0] = -Li / 2;\n                  }\n                  tn(Mt, kr);\n                }\n              }\n              function Wa(Mt, kr) {\n                if (!(!((Mn = Mt.length) > 0) || !((An = (hn = Mt[kr[0]]).length) > 0))) {\n                  for (var Jr = 0, vi = 1, hn, An, Mn; vi < An; ++vi) {\n                    for (var Li = 0, _n = 0, ya = 0; Li < Mn; ++Li) {\n                      for (var Jn = Mt[kr[Li]], Ma = Jn[vi][1] || 0, _o = Jn[vi - 1][1] || 0, No = (Ma - _o) / 2, po = 0; po < Li; ++po) {\n                        var Lo = Mt[kr[po]], ko = Lo[vi][1] || 0, Ds = Lo[vi - 1][1] || 0;\n                        No += ko - Ds;\n                      }\n                      _n += Ma, ya += No * Ma;\n                    }\n                    hn[vi - 1][1] += hn[vi - 1][0] = Jr, _n && (Jr -= ya / _n);\n                  }\n                  hn[vi - 1][1] += hn[vi - 1][0] = Jr, tn(Mt, kr);\n                }\n              }\n              function Fa(Mt) {\n                var kr = Mt.map(Wo);\n                return fn(Mt).sort(function(Jr, vi) {\n                  return kr[Jr] - kr[vi];\n                });\n              }\n              function Wo(Mt) {\n                for (var kr = -1, Jr = 0, vi = Mt.length, hn, An = -1 / 0; ++kr < vi; ) (hn = +Mt[kr][1]) > An && (An = hn, Jr = kr);\n                return Jr;\n              }\n              function da(Mt) {\n                var kr = Mt.map(Wn);\n                return fn(Mt).sort(function(Jr, vi) {\n                  return kr[Jr] - kr[vi];\n                });\n              }\n              function Wn(Mt) {\n                for (var kr = 0, Jr = -1, vi = Mt.length, hn; ++Jr < vi; ) (hn = +Mt[Jr][1]) && (kr += hn);\n                return kr;\n              }\n              function Ha(Mt) {\n                return da(Mt).reverse();\n              }\n              function vo(Mt) {\n                var kr = Mt.length, Jr, vi, hn = Mt.map(Wn), An = Fa(Mt), Mn = 0, Li = 0, _n = [], ya = [];\n                for (Jr = 0; Jr < kr; ++Jr) vi = An[Jr], Mn < Li ? (Mn += hn[vi], _n.push(vi)) : (Li += hn[vi], ya.push(vi));\n                return ya.reverse().concat(_n);\n              }\n              function jn(Mt) {\n                return fn(Mt).reverse();\n              }\n              e3.arc = C3, e3.area = O3, e3.areaRadial = _e, e3.curveBasis = Lr, e3.curveBasisClosed = Br, e3.curveBasisOpen = dt, e3.curveBundle = Je, e3.curveCardinal = xt, e3.curveCardinalClosed = xe, e3.curveCardinalOpen = vt, e3.curveCatmullRom = vr, e3.curveCatmullRomClosed = pi, e3.curveCatmullRomOpen = di, e3.curveLinear = g3, e3.curveLinearClosed = In, e3.curveMonotoneX = wt, e3.curveMonotoneY = rr, e3.curveNatural = Xr, e3.curveStep = Qr, e3.curveStepAfter = $i, e3.curveStepBefore = Oi, e3.line = z3, e3.lineRadial = oe, e3.linkHorizontal = Pe, e3.linkRadial = Re, e3.linkVertical = ge, e3.pie = Z, e3.pointRadial = Ee, e3.radialArea = _e, e3.radialLine = oe, e3.stack = Sn, e3.stackOffsetDiverging = ua, e3.stackOffsetExpand = Ba, e3.stackOffsetNone = tn, e3.stackOffsetSilhouette = ma, e3.stackOffsetWiggle = Wa, e3.stackOrderAppearance = Fa, e3.stackOrderAscending = da, e3.stackOrderDescending = Ha, e3.stackOrderInsideOut = vo, e3.stackOrderNone = fn, e3.stackOrderReverse = jn, e3.symbol = mt, e3.symbolCircle = ce, e3.symbolCross = Ze, e3.symbolDiamond = Zt, e3.symbolSquare = sr, e3.symbolStar = Jt, e3.symbolTriangle = cr, e3.symbolWye = _t, e3.symbols = It, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var VWe = ye((S7, UWe) => {\n            (function(e3, t3) {\n              typeof S7 == "object" && typeof UWe != "undefined" ? t3(S7, nk(), _7(), jJ()) : t3(e3.d3 = e3.d3 || {}, e3.d3, e3.d3, e3.d3);\n            })(S7, function(e3, t3, r4, n4) {\n              "use strict";\n              function i3(g3) {\n                return g3.target.depth;\n              }\n              function a4(g3) {\n                return g3.depth;\n              }\n              function o4(g3, P3) {\n                return P3 - 1 - g3.height;\n              }\n              function s3(g3, P3) {\n                return g3.sourceLinks.length ? g3.depth : P3 - 1;\n              }\n              function l3(g3) {\n                return g3.targetLinks.length ? g3.depth : g3.sourceLinks.length ? t3.min(g3.sourceLinks, i3) - 1 : 0;\n              }\n              function u4(g3) {\n                return function() {\n                  return g3;\n                };\n              }\n              function c5(g3, P3) {\n                return h3(g3.source, P3.source) || g3.index - P3.index;\n              }\n              function f4(g3, P3) {\n                return h3(g3.target, P3.target) || g3.index - P3.index;\n              }\n              function h3(g3, P3) {\n                return g3.y0 - P3.y0;\n              }\n              function d3(g3) {\n                return g3.value;\n              }\n              function v3(g3) {\n                return (g3.y0 + g3.y1) / 2;\n              }\n              function _2(g3) {\n                return v3(g3.source) * g3.value;\n              }\n              function b(g3) {\n                return v3(g3.target) * g3.value;\n              }\n              function p3(g3) {\n                return g3.index;\n              }\n              function k4(g3) {\n                return g3.nodes;\n              }\n              function E3(g3) {\n                return g3.links;\n              }\n              function S2(g3, P3) {\n                var T3 = g3.get(P3);\n                if (!T3) throw new Error("missing: " + P3);\n                return T3;\n              }\n              var L3 = function() {\n                var g3 = 0, P3 = 0, T3 = 1, z3 = 1, O3 = 24, V2 = 8, G2 = p3, Z = s3, j3 = k4, N2 = E3, H = 32, te = 2 / 3;\n                function oe() {\n                  var Se = { nodes: j3.apply(null, arguments), links: N2.apply(null, arguments) };\n                  return _e(Se), Ee(Se), Ce(Se), me(Se, H), ie(Se), Se;\n                }\n                oe.update = function(Se) {\n                  return ie(Se), Se;\n                }, oe.nodeId = function(Se) {\n                  return arguments.length ? (G2 = typeof Se == "function" ? Se : u4(Se), oe) : G2;\n                }, oe.nodeAlign = function(Se) {\n                  return arguments.length ? (Z = typeof Se == "function" ? Se : u4(Se), oe) : Z;\n                }, oe.nodeWidth = function(Se) {\n                  return arguments.length ? (O3 = +Se, oe) : O3;\n                }, oe.nodePadding = function(Se) {\n                  return arguments.length ? (V2 = +Se, oe) : V2;\n                }, oe.nodes = function(Se) {\n                  return arguments.length ? (j3 = typeof Se == "function" ? Se : u4(Se), oe) : j3;\n                }, oe.links = function(Se) {\n                  return arguments.length ? (N2 = typeof Se == "function" ? Se : u4(Se), oe) : N2;\n                }, oe.size = function(Se) {\n                  return arguments.length ? (g3 = P3 = 0, T3 = +Se[0], z3 = +Se[1], oe) : [T3 - g3, z3 - P3];\n                }, oe.extent = function(Se) {\n                  return arguments.length ? (g3 = +Se[0][0], T3 = +Se[1][0], P3 = +Se[0][1], z3 = +Se[1][1], oe) : [[g3, P3], [T3, z3]];\n                }, oe.iterations = function(Se) {\n                  return arguments.length ? (H = +Se, oe) : H;\n                };\n                function _e(Se) {\n                  Se.nodes.forEach(function(Ae, Fe) {\n                    Ae.index = Fe, Ae.sourceLinks = [], Ae.targetLinks = [];\n                  });\n                  var Le = r4.map(Se.nodes, G2);\n                  Se.links.forEach(function(Ae, Fe) {\n                    Ae.index = Fe;\n                    var Pe = Ae.source, ge = Ae.target;\n                    typeof Pe != "object" && (Pe = Ae.source = S2(Le, Pe)), typeof ge != "object" && (ge = Ae.target = S2(Le, ge)), Pe.sourceLinks.push(Ae), ge.targetLinks.push(Ae);\n                  });\n                }\n                function Ee(Se) {\n                  Se.nodes.forEach(function(Le) {\n                    Le.value = Math.max(t3.sum(Le.sourceLinks, d3), t3.sum(Le.targetLinks, d3));\n                  });\n                }\n                function Ce(Se) {\n                  var Le, Ae, Fe;\n                  for (Le = Se.nodes, Ae = [], Fe = 0; Le.length; ++Fe, Le = Ae, Ae = []) Le.forEach(function(ge) {\n                    ge.depth = Fe, ge.sourceLinks.forEach(function(Re) {\n                      Ae.indexOf(Re.target) < 0 && Ae.push(Re.target);\n                    });\n                  });\n                  for (Le = Se.nodes, Ae = [], Fe = 0; Le.length; ++Fe, Le = Ae, Ae = []) Le.forEach(function(ge) {\n                    ge.height = Fe, ge.targetLinks.forEach(function(Re) {\n                      Ae.indexOf(Re.source) < 0 && Ae.push(Re.source);\n                    });\n                  });\n                  var Pe = (T3 - g3 - O3) / (Fe - 1);\n                  Se.nodes.forEach(function(ge) {\n                    ge.x1 = (ge.x0 = g3 + Math.max(0, Math.min(Fe - 1, Math.floor(Z.call(null, ge, Fe)))) * Pe) + O3;\n                  });\n                }\n                function me(Se) {\n                  var Le = r4.nest().key(function(Ze) {\n                    return Ze.x0;\n                  }).sortKeys(t3.ascending).entries(Se.nodes).map(function(Ze) {\n                    return Ze.values;\n                  });\n                  Pe(), ce();\n                  for (var Ae = 1, Fe = H; Fe > 0; --Fe) Re(Ae *= 0.99), ce(), ge(Ae), ce();\n                  function Pe() {\n                    var Ze = t3.max(Le, function(Zt) {\n                      return Zt.length;\n                    }), ut = te * (z3 - P3) / (Ze - 1);\n                    V2 > ut && (V2 = ut);\n                    var pt = t3.min(Le, function(Zt) {\n                      return (z3 - P3 - (Zt.length - 1) * V2) / t3.sum(Zt, d3);\n                    });\n                    Le.forEach(function(Zt) {\n                      Zt.forEach(function(st, lt) {\n                        st.y1 = (st.y0 = lt) + st.value * pt;\n                      });\n                    }), Se.links.forEach(function(Zt) {\n                      Zt.width = Zt.value * pt;\n                    });\n                  }\n                  function ge(Ze) {\n                    Le.forEach(function(ut) {\n                      ut.forEach(function(pt) {\n                        if (pt.targetLinks.length) {\n                          var Zt = (t3.sum(pt.targetLinks, _2) / t3.sum(pt.targetLinks, d3) - v3(pt)) * Ze;\n                          pt.y0 += Zt, pt.y1 += Zt;\n                        }\n                      });\n                    });\n                  }\n                  function Re(Ze) {\n                    Le.slice().reverse().forEach(function(ut) {\n                      ut.forEach(function(pt) {\n                        if (pt.sourceLinks.length) {\n                          var Zt = (t3.sum(pt.sourceLinks, b) / t3.sum(pt.sourceLinks, d3) - v3(pt)) * Ze;\n                          pt.y0 += Zt, pt.y1 += Zt;\n                        }\n                      });\n                    });\n                  }\n                  function ce() {\n                    Le.forEach(function(Ze) {\n                      var ut, pt, Zt = P3, st = Ze.length, lt;\n                      for (Ze.sort(h3), lt = 0; lt < st; ++lt) ut = Ze[lt], pt = Zt - ut.y0, pt > 0 && (ut.y0 += pt, ut.y1 += pt), Zt = ut.y1 + V2;\n                      if (pt = Zt - V2 - z3, pt > 0) for (Zt = ut.y0 -= pt, ut.y1 -= pt, lt = st - 2; lt >= 0; --lt) ut = Ze[lt], pt = ut.y1 + V2 - Zt, pt > 0 && (ut.y0 -= pt, ut.y1 -= pt), Zt = ut.y0;\n                    });\n                  }\n                }\n                function ie(Se) {\n                  Se.nodes.forEach(function(Le) {\n                    Le.sourceLinks.sort(f4), Le.targetLinks.sort(c5);\n                  }), Se.nodes.forEach(function(Le) {\n                    var Ae = Le.y0, Fe = Ae;\n                    Le.sourceLinks.forEach(function(Pe) {\n                      Pe.y0 = Ae + Pe.width / 2, Ae += Pe.width;\n                    }), Le.targetLinks.forEach(function(Pe) {\n                      Pe.y1 = Fe + Pe.width / 2, Fe += Pe.width;\n                    });\n                  });\n                }\n                return oe;\n              };\n              function x2(g3) {\n                return [g3.source.x1, g3.y0];\n              }\n              function C3(g3) {\n                return [g3.target.x0, g3.y1];\n              }\n              var M4 = function() {\n                return n4.linkHorizontal().source(x2).target(C3);\n              };\n              e3.sankey = L3, e3.sankeyCenter = l3, e3.sankeyLeft = a4, e3.sankeyRight = o4, e3.sankeyJustify = s3, e3.sankeyLinkHorizontal = M4, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var HWe = ye((Qbr, GWe) => {\n            var FZt = HJ();\n            GWe.exports = function(t3, r4) {\n              var n4 = [], i3 = [], a4 = [], o4 = {}, s3 = [], l3;\n              function u4(E3) {\n                a4[E3] = false, o4.hasOwnProperty(E3) && Object.keys(o4[E3]).forEach(function(S2) {\n                  delete o4[E3][S2], a4[S2] && u4(S2);\n                });\n              }\n              function c5(E3) {\n                var S2 = false;\n                i3.push(E3), a4[E3] = true;\n                var L3, x2;\n                for (L3 = 0; L3 < s3[E3].length; L3++) x2 = s3[E3][L3], x2 === l3 ? (f4(l3, i3), S2 = true) : a4[x2] || (S2 = c5(x2));\n                if (S2) u4(E3);\n                else for (L3 = 0; L3 < s3[E3].length; L3++) {\n                  x2 = s3[E3][L3];\n                  var C3 = o4[x2];\n                  C3 || (C3 = {}, o4[x2] = C3), C3[x2] = true;\n                }\n                return i3.pop(), S2;\n              }\n              function f4(E3, S2) {\n                var L3 = [].concat(S2).concat(E3);\n                r4 ? r4(c5) : n4.push(L3);\n              }\n              function h3(E3) {\n                for (var S2 = 0; S2 < t3.length; S2++) S2 < E3 && (t3[S2] = []), t3[S2] = t3[S2].filter(function(L3) {\n                  return L3 >= E3;\n                });\n              }\n              function d3(E3) {\n                h3(E3);\n                for (var S2 = t3, L3 = FZt(S2), x2 = L3.components.filter(function(O3) {\n                  return O3.length > 1;\n                }), C3 = 1 / 0, M4, g3 = 0; g3 < x2.length; g3++) for (var P3 = 0; P3 < x2[g3].length; P3++) x2[g3][P3] < C3 && (C3 = x2[g3][P3], M4 = g3);\n                var T3 = x2[M4];\n                if (!T3) return false;\n                var z3 = t3.map(function(O3, V2) {\n                  return T3.indexOf(V2) === -1 ? [] : O3.filter(function(G2) {\n                    return T3.indexOf(G2) !== -1;\n                  });\n                });\n                return { leastVertex: C3, adjList: z3 };\n              }\n              l3 = 0;\n              for (var v3 = t3.length; l3 < v3; ) {\n                var _2 = d3(l3);\n                if (l3 = _2.leastVertex, s3 = _2.adjList, s3) {\n                  for (var b = 0; b < s3.length; b++) for (var p3 = 0; p3 < s3[b].length; p3++) {\n                    var k4 = s3[b][p3];\n                    a4[+k4] = false, o4[k4] = {};\n                  }\n                  c5(l3), l3 = l3 + 1;\n                } else l3 = v3;\n              }\n              if (!r4) return n4;\n            };\n          });\n          var WWe = ye((M7, jWe) => {\n            (function(e3, t3) {\n              typeof M7 == "object" && typeof jWe != "undefined" ? t3(M7, nk(), _7(), jJ(), HWe()) : t3(e3.d3 = e3.d3 || {}, e3.d3, e3.d3, e3.d3, null);\n            })(M7, function(e3, t3, r4, n4, i3) {\n              "use strict";\n              i3 = i3 && i3.hasOwnProperty("default") ? i3.default : i3;\n              function a4(st) {\n                return st.target.depth;\n              }\n              function o4(st) {\n                return st.depth;\n              }\n              function s3(st, lt) {\n                return lt - 1 - st.height;\n              }\n              function l3(st, lt) {\n                return st.sourceLinks.length ? st.depth : lt - 1;\n              }\n              function u4(st) {\n                return st.targetLinks.length ? st.depth : st.sourceLinks.length ? t3.min(st.sourceLinks, a4) - 1 : 0;\n              }\n              function c5(st) {\n                return function() {\n                  return st;\n                };\n              }\n              var f4 = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(st) {\n                return typeof st;\n              } : function(st) {\n                return st && typeof Symbol == "function" && st.constructor === Symbol && st !== Symbol.prototype ? "symbol" : typeof st;\n              };\n              function h3(st, lt) {\n                return v3(st.source, lt.source) || st.index - lt.index;\n              }\n              function d3(st, lt) {\n                return v3(st.target, lt.target) || st.index - lt.index;\n              }\n              function v3(st, lt) {\n                return st.partOfCycle === lt.partOfCycle ? st.y0 - lt.y0 : st.circularLinkType === "top" || lt.circularLinkType === "bottom" ? -1 : 1;\n              }\n              function _2(st) {\n                return st.value;\n              }\n              function b(st) {\n                return (st.y0 + st.y1) / 2;\n              }\n              function p3(st) {\n                return b(st.source);\n              }\n              function k4(st) {\n                return b(st.target);\n              }\n              function E3(st) {\n                return st.index;\n              }\n              function S2(st) {\n                return st.nodes;\n              }\n              function L3(st) {\n                return st.links;\n              }\n              function x2(st, lt) {\n                var Gt = st.get(lt);\n                if (!Gt) throw new Error("missing: " + lt);\n                return Gt;\n              }\n              function C3(st, lt) {\n                return lt(st);\n              }\n              var M4 = 25, g3 = 10, P3 = 0.3;\n              function T3() {\n                var st = 0, lt = 0, Gt = 1, Nt = 1, Jt = 24, sr, wr = E3, cr = l3, $e = S2, St = L3, Qt = 32, Vt = 2, _t, It = null;\n                function mt() {\n                  var dt = { nodes: $e.apply(null, arguments), links: St.apply(null, arguments) };\n                  er(dt), z3(dt, wr, It), lr(dt), ti(dt), O3(dt, wr), Br(dt, Qt, wr), Vr(dt);\n                  for (var Ge = 4, Je = 0; Je < Ge; Je++) Re(dt, Nt, wr), ce(dt, Nt, wr), Fe(dt, lt, Nt, wr), Re(dt, Nt, wr), ce(dt, Nt, wr);\n                  return Zt(dt, lt, Nt), H(dt, Vt, Nt, wr), dt;\n                }\n                mt.nodeId = function(dt) {\n                  return arguments.length ? (wr = typeof dt == "function" ? dt : c5(dt), mt) : wr;\n                }, mt.nodeAlign = function(dt) {\n                  return arguments.length ? (cr = typeof dt == "function" ? dt : c5(dt), mt) : cr;\n                }, mt.nodeWidth = function(dt) {\n                  return arguments.length ? (Jt = +dt, mt) : Jt;\n                }, mt.nodePadding = function(dt) {\n                  return arguments.length ? (sr = +dt, mt) : sr;\n                }, mt.nodes = function(dt) {\n                  return arguments.length ? ($e = typeof dt == "function" ? dt : c5(dt), mt) : $e;\n                }, mt.links = function(dt) {\n                  return arguments.length ? (St = typeof dt == "function" ? dt : c5(dt), mt) : St;\n                }, mt.size = function(dt) {\n                  return arguments.length ? (st = lt = 0, Gt = +dt[0], Nt = +dt[1], mt) : [Gt - st, Nt - lt];\n                }, mt.extent = function(dt) {\n                  return arguments.length ? (st = +dt[0][0], Gt = +dt[1][0], lt = +dt[0][1], Nt = +dt[1][1], mt) : [[st, lt], [Gt, Nt]];\n                }, mt.iterations = function(dt) {\n                  return arguments.length ? (Qt = +dt, mt) : Qt;\n                }, mt.circularLinkGap = function(dt) {\n                  return arguments.length ? (Vt = +dt, mt) : Vt;\n                }, mt.nodePaddingRatio = function(dt) {\n                  return arguments.length ? (_t = +dt, mt) : _t;\n                }, mt.sortNodes = function(dt) {\n                  return arguments.length ? (It = dt, mt) : It;\n                }, mt.update = function(dt) {\n                  return O3(dt, wr), Vr(dt), dt.links.forEach(function(Ge) {\n                    Ge.circular && (Ge.circularLinkType = Ge.y0 + Ge.y1 < Nt ? "top" : "bottom", Ge.source.circularLinkType = Ge.circularLinkType, Ge.target.circularLinkType = Ge.circularLinkType);\n                  }), Re(dt, Nt, wr, false), ce(dt, Nt, wr), H(dt, Vt, Nt, wr), dt;\n                };\n                function er(dt) {\n                  dt.nodes.forEach(function(Je, je) {\n                    Je.index = je, Je.sourceLinks = [], Je.targetLinks = [];\n                  });\n                  var Ge = r4.map(dt.nodes, wr);\n                  return dt.links.forEach(function(Je, je) {\n                    Je.index = je;\n                    var tt = Je.source, xt = Je.target;\n                    (typeof tt == "undefined" ? "undefined" : f4(tt)) !== "object" && (tt = Je.source = x2(Ge, tt)), (typeof xt == "undefined" ? "undefined" : f4(xt)) !== "object" && (xt = Je.target = x2(Ge, xt)), tt.sourceLinks.push(Je), xt.targetLinks.push(Je);\n                  }), dt;\n                }\n                function lr(dt) {\n                  dt.nodes.forEach(function(Ge) {\n                    Ge.partOfCycle = false, Ge.value = Math.max(t3.sum(Ge.sourceLinks, _2), t3.sum(Ge.targetLinks, _2)), Ge.sourceLinks.forEach(function(Je) {\n                      Je.circular && (Ge.partOfCycle = true, Ge.circularLinkType = Je.circularLinkType);\n                    }), Ge.targetLinks.forEach(function(Je) {\n                      Je.circular && (Ge.partOfCycle = true, Ge.circularLinkType = Je.circularLinkType);\n                    });\n                  });\n                }\n                function Tr(dt) {\n                  var Ge = 0, Je = 0, je = 0, tt = 0, xt = t3.max(dt.nodes, function(Ie) {\n                    return Ie.column;\n                  });\n                  return dt.links.forEach(function(Ie) {\n                    Ie.circular && (Ie.circularLinkType == "top" ? Ge = Ge + Ie.width : Je = Je + Ie.width, Ie.target.column == 0 && (tt = tt + Ie.width), Ie.source.column == xt && (je = je + Ie.width));\n                  }), Ge = Ge > 0 ? Ge + M4 + g3 : Ge, Je = Je > 0 ? Je + M4 + g3 : Je, je = je > 0 ? je + M4 + g3 : je, tt = tt > 0 ? tt + M4 + g3 : tt, { top: Ge, bottom: Je, left: tt, right: je };\n                }\n                function Lr(dt, Ge) {\n                  var Je = t3.max(dt.nodes, function(vt) {\n                    return vt.column;\n                  }), je = Gt - st, tt = Nt - lt, xt = je + Ge.right + Ge.left, Ie = tt + Ge.top + Ge.bottom, xe = je / xt, ke = tt / Ie;\n                  return st = st * xe + Ge.left, Gt = Ge.right == 0 ? Gt : Gt * xe, lt = lt * ke + Ge.top, Nt = Nt * ke, dt.nodes.forEach(function(vt) {\n                    vt.x0 = st + vt.column * ((Gt - st - Jt) / Je), vt.x1 = vt.x0 + Jt;\n                  }), ke;\n                }\n                function ti(dt) {\n                  var Ge, Je, je;\n                  for (Ge = dt.nodes, Je = [], je = 0; Ge.length; ++je, Ge = Je, Je = []) Ge.forEach(function(tt) {\n                    tt.depth = je, tt.sourceLinks.forEach(function(xt) {\n                      Je.indexOf(xt.target) < 0 && !xt.circular && Je.push(xt.target);\n                    });\n                  });\n                  for (Ge = dt.nodes, Je = [], je = 0; Ge.length; ++je, Ge = Je, Je = []) Ge.forEach(function(tt) {\n                    tt.height = je, tt.targetLinks.forEach(function(xt) {\n                      Je.indexOf(xt.source) < 0 && !xt.circular && Je.push(xt.source);\n                    });\n                  });\n                  dt.nodes.forEach(function(tt) {\n                    tt.column = Math.floor(cr.call(null, tt, je));\n                  });\n                }\n                function Br(dt, Ge, Je) {\n                  var je = r4.nest().key(function(vt) {\n                    return vt.column;\n                  }).sortKeys(t3.ascending).entries(dt.nodes).map(function(vt) {\n                    return vt.values;\n                  });\n                  Ie(Je), ke();\n                  for (var tt = 1, xt = Ge; xt > 0; --xt) xe(tt *= 0.99, Je), ke();\n                  function Ie(vt) {\n                    if (_t) {\n                      var ir = 1 / 0;\n                      je.forEach(function(pi) {\n                        var $r = Nt * _t / (pi.length + 1);\n                        ir = $r < ir ? $r : ir;\n                      }), sr = ir;\n                    }\n                    var ar = t3.min(je, function(pi) {\n                      return (Nt - lt - (pi.length - 1) * sr) / t3.sum(pi, _2);\n                    });\n                    ar = ar * P3, dt.links.forEach(function(pi) {\n                      pi.width = pi.value * ar;\n                    });\n                    var vr = Tr(dt), ii = Lr(dt, vr);\n                    ar = ar * ii, dt.links.forEach(function(pi) {\n                      pi.width = pi.value * ar;\n                    }), je.forEach(function(pi) {\n                      var $r = pi.length;\n                      pi.forEach(function(di, ji) {\n                        di.depth == je.length - 1 && $r == 1 || di.depth == 0 && $r == 1 ? (di.y0 = Nt / 2 - di.value * ar, di.y1 = di.y0 + di.value * ar) : di.partOfCycle ? Z(di, vt) == 0 ? (di.y0 = Nt / 2 + ji, di.y1 = di.y0 + di.value * ar) : di.circularLinkType == "top" ? (di.y0 = lt + ji, di.y1 = di.y0 + di.value * ar) : (di.y0 = Nt - di.value * ar - ji, di.y1 = di.y0 + di.value * ar) : vr.top == 0 || vr.bottom == 0 ? (di.y0 = (Nt - lt) / $r * ji, di.y1 = di.y0 + di.value * ar) : (di.y0 = (Nt - lt) / 2 - $r / 2 + ji, di.y1 = di.y0 + di.value * ar);\n                      });\n                    });\n                  }\n                  function xe(vt, ir) {\n                    var ar = je.length;\n                    je.forEach(function(vr) {\n                      var ii = vr.length, pi = vr[0].depth;\n                      vr.forEach(function($r) {\n                        var di;\n                        if (($r.sourceLinks.length || $r.targetLinks.length) && !($r.partOfCycle && Z($r, ir) > 0)) if (pi == 0 && ii == 1) di = $r.y1 - $r.y0, $r.y0 = Nt / 2 - di / 2, $r.y1 = Nt / 2 + di / 2;\n                        else if (pi == ar - 1 && ii == 1) di = $r.y1 - $r.y0, $r.y0 = Nt / 2 - di / 2, $r.y1 = Nt / 2 + di / 2;\n                        else {\n                          var ji = 0, In = t3.mean($r.sourceLinks, k4), wi = t3.mean($r.targetLinks, p3);\n                          In && wi ? ji = (In + wi) / 2 : ji = In || wi;\n                          var On = (ji - b($r)) * vt;\n                          $r.y0 += On, $r.y1 += On;\n                        }\n                      });\n                    });\n                  }\n                  function ke() {\n                    je.forEach(function(vt) {\n                      var ir, ar, vr = lt, ii = vt.length, pi;\n                      for (vt.sort(v3), pi = 0; pi < ii; ++pi) ir = vt[pi], ar = vr - ir.y0, ar > 0 && (ir.y0 += ar, ir.y1 += ar), vr = ir.y1 + sr;\n                      if (ar = vr - sr - Nt, ar > 0) for (vr = ir.y0 -= ar, ir.y1 -= ar, pi = ii - 2; pi >= 0; --pi) ir = vt[pi], ar = ir.y1 + sr - vr, ar > 0 && (ir.y0 -= ar, ir.y1 -= ar), vr = ir.y0;\n                    });\n                  }\n                }\n                function Vr(dt) {\n                  dt.nodes.forEach(function(Ge) {\n                    Ge.sourceLinks.sort(d3), Ge.targetLinks.sort(h3);\n                  }), dt.nodes.forEach(function(Ge) {\n                    var Je = Ge.y0, je = Je, tt = Ge.y1, xt = tt;\n                    Ge.sourceLinks.forEach(function(Ie) {\n                      Ie.circular ? (Ie.y0 = tt - Ie.width / 2, tt = tt - Ie.width) : (Ie.y0 = Je + Ie.width / 2, Je += Ie.width);\n                    }), Ge.targetLinks.forEach(function(Ie) {\n                      Ie.circular ? (Ie.y1 = xt - Ie.width / 2, xt = xt - Ie.width) : (Ie.y1 = je + Ie.width / 2, je += Ie.width);\n                    });\n                  });\n                }\n                return mt;\n              }\n              function z3(st, lt, Gt) {\n                var Nt = 0;\n                if (Gt === null) {\n                  for (var Jt = [], sr = 0; sr < st.links.length; sr++) {\n                    var wr = st.links[sr], cr = wr.source.index, $e = wr.target.index;\n                    Jt[cr] || (Jt[cr] = []), Jt[$e] || (Jt[$e] = []), Jt[cr].indexOf($e) === -1 && Jt[cr].push($e);\n                  }\n                  var St = i3(Jt);\n                  St.sort(function(It, mt) {\n                    return It.length - mt.length;\n                  });\n                  var Qt = {};\n                  for (sr = 0; sr < St.length; sr++) {\n                    var Vt = St[sr], _t = Vt.slice(-2);\n                    Qt[_t[0]] || (Qt[_t[0]] = {}), Qt[_t[0]][_t[1]] = true;\n                  }\n                  st.links.forEach(function(It) {\n                    var mt = It.target.index, er = It.source.index;\n                    mt === er || Qt[er] && Qt[er][mt] ? (It.circular = true, It.circularLinkID = Nt, Nt = Nt + 1) : It.circular = false;\n                  });\n                } else st.links.forEach(function(It) {\n                  It.source[Gt] < It.target[Gt] ? It.circular = false : (It.circular = true, It.circularLinkID = Nt, Nt = Nt + 1);\n                });\n              }\n              function O3(st, lt) {\n                var Gt = 0, Nt = 0;\n                st.links.forEach(function(Jt) {\n                  Jt.circular && (Jt.source.circularLinkType || Jt.target.circularLinkType ? Jt.circularLinkType = Jt.source.circularLinkType ? Jt.source.circularLinkType : Jt.target.circularLinkType : Jt.circularLinkType = Gt < Nt ? "top" : "bottom", Jt.circularLinkType == "top" ? Gt = Gt + 1 : Nt = Nt + 1, st.nodes.forEach(function(sr) {\n                    (C3(sr, lt) == C3(Jt.source, lt) || C3(sr, lt) == C3(Jt.target, lt)) && (sr.circularLinkType = Jt.circularLinkType);\n                  }));\n                }), st.links.forEach(function(Jt) {\n                  Jt.circular && (Jt.source.circularLinkType == Jt.target.circularLinkType && (Jt.circularLinkType = Jt.source.circularLinkType), pt(Jt, lt) && (Jt.circularLinkType = Jt.source.circularLinkType));\n                });\n              }\n              function V2(st) {\n                var lt = Math.abs(st.y1 - st.y0), Gt = Math.abs(st.target.x0 - st.source.x1);\n                return Math.atan(Gt / lt);\n              }\n              function G2(st, lt) {\n                return st.source.column < lt.target.column ? false : !(st.target.column > lt.source.column);\n              }\n              function Z(st, lt) {\n                var Gt = 0;\n                st.sourceLinks.forEach(function(Jt) {\n                  Gt = Jt.circular && !pt(Jt, lt) ? Gt + 1 : Gt;\n                });\n                var Nt = 0;\n                return st.targetLinks.forEach(function(Jt) {\n                  Nt = Jt.circular && !pt(Jt, lt) ? Nt + 1 : Nt;\n                }), Gt + Nt;\n              }\n              function j3(st) {\n                var lt = st.source.sourceLinks, Gt = 0;\n                lt.forEach(function(sr) {\n                  Gt = sr.circular ? Gt + 1 : Gt;\n                });\n                var Nt = st.target.targetLinks, Jt = 0;\n                return Nt.forEach(function(sr) {\n                  Jt = sr.circular ? Jt + 1 : Jt;\n                }), !(Gt > 1 || Jt > 1);\n              }\n              function N2(st, lt, Gt) {\n                return st.sort(oe), st.forEach(function(Nt, Jt) {\n                  var sr = 0;\n                  if (pt(Nt, Gt) && j3(Nt)) Nt.circularPathData.verticalBuffer = sr + Nt.width / 2;\n                  else {\n                    var wr = 0;\n                    for (wr; wr < Jt; wr++) if (G2(st[Jt], st[wr])) {\n                      var cr = st[wr].circularPathData.verticalBuffer + st[wr].width / 2 + lt;\n                      sr = cr > sr ? cr : sr;\n                    }\n                    Nt.circularPathData.verticalBuffer = sr + Nt.width / 2;\n                  }\n                }), st;\n              }\n              function H(st, lt, Gt, Nt) {\n                var Jt = 5, sr = t3.min(st.links, function($e) {\n                  return $e.source.y0;\n                });\n                st.links.forEach(function($e) {\n                  $e.circular && ($e.circularPathData = {});\n                });\n                var wr = st.links.filter(function($e) {\n                  return $e.circularLinkType == "top";\n                });\n                N2(wr, lt, Nt);\n                var cr = st.links.filter(function($e) {\n                  return $e.circularLinkType == "bottom";\n                });\n                N2(cr, lt, Nt), st.links.forEach(function($e) {\n                  if ($e.circular) {\n                    if ($e.circularPathData.arcRadius = $e.width + g3, $e.circularPathData.leftNodeBuffer = Jt, $e.circularPathData.rightNodeBuffer = Jt, $e.circularPathData.sourceWidth = $e.source.x1 - $e.source.x0, $e.circularPathData.sourceX = $e.source.x0 + $e.circularPathData.sourceWidth, $e.circularPathData.targetX = $e.target.x0, $e.circularPathData.sourceY = $e.y0, $e.circularPathData.targetY = $e.y1, pt($e, Nt) && j3($e)) $e.circularPathData.leftSmallArcRadius = g3 + $e.width / 2, $e.circularPathData.leftLargeArcRadius = g3 + $e.width / 2, $e.circularPathData.rightSmallArcRadius = g3 + $e.width / 2, $e.circularPathData.rightLargeArcRadius = g3 + $e.width / 2, $e.circularLinkType == "bottom" ? ($e.circularPathData.verticalFullExtent = $e.source.y1 + M4 + $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.rightLargeArcRadius) : ($e.circularPathData.verticalFullExtent = $e.source.y0 - M4 - $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.rightLargeArcRadius);\n                    else {\n                      var St = $e.source.column, Qt = $e.circularLinkType, Vt = st.links.filter(function(mt) {\n                        return mt.source.column == St && mt.circularLinkType == Qt;\n                      });\n                      $e.circularLinkType == "bottom" ? Vt.sort(Ee) : Vt.sort(_e);\n                      var _t = 0;\n                      Vt.forEach(function(mt, er) {\n                        mt.circularLinkID == $e.circularLinkID && ($e.circularPathData.leftSmallArcRadius = g3 + $e.width / 2 + _t, $e.circularPathData.leftLargeArcRadius = g3 + $e.width / 2 + er * lt + _t), _t = _t + mt.width;\n                      }), St = $e.target.column, Vt = st.links.filter(function(mt) {\n                        return mt.target.column == St && mt.circularLinkType == Qt;\n                      }), $e.circularLinkType == "bottom" ? Vt.sort(me) : Vt.sort(Ce), _t = 0, Vt.forEach(function(mt, er) {\n                        mt.circularLinkID == $e.circularLinkID && ($e.circularPathData.rightSmallArcRadius = g3 + $e.width / 2 + _t, $e.circularPathData.rightLargeArcRadius = g3 + $e.width / 2 + er * lt + _t), _t = _t + mt.width;\n                      }), $e.circularLinkType == "bottom" ? ($e.circularPathData.verticalFullExtent = Math.max(Gt, $e.source.y1, $e.target.y1) + M4 + $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent - $e.circularPathData.rightLargeArcRadius) : ($e.circularPathData.verticalFullExtent = sr - M4 - $e.circularPathData.verticalBuffer, $e.circularPathData.verticalLeftInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.leftLargeArcRadius, $e.circularPathData.verticalRightInnerExtent = $e.circularPathData.verticalFullExtent + $e.circularPathData.rightLargeArcRadius);\n                    }\n                    $e.circularPathData.leftInnerExtent = $e.circularPathData.sourceX + $e.circularPathData.leftNodeBuffer, $e.circularPathData.rightInnerExtent = $e.circularPathData.targetX - $e.circularPathData.rightNodeBuffer, $e.circularPathData.leftFullExtent = $e.circularPathData.sourceX + $e.circularPathData.leftLargeArcRadius + $e.circularPathData.leftNodeBuffer, $e.circularPathData.rightFullExtent = $e.circularPathData.targetX - $e.circularPathData.rightLargeArcRadius - $e.circularPathData.rightNodeBuffer;\n                  }\n                  if ($e.circular) $e.path = te($e);\n                  else {\n                    var It = n4.linkHorizontal().source(function(mt) {\n                      var er = mt.source.x0 + (mt.source.x1 - mt.source.x0), lr = mt.y0;\n                      return [er, lr];\n                    }).target(function(mt) {\n                      var er = mt.target.x0, lr = mt.y1;\n                      return [er, lr];\n                    });\n                    $e.path = It($e);\n                  }\n                });\n              }\n              function te(st) {\n                var lt = "";\n                return st.circularLinkType == "top" ? lt = "M" + st.circularPathData.sourceX + " " + st.circularPathData.sourceY + " L" + st.circularPathData.leftInnerExtent + " " + st.circularPathData.sourceY + " A" + st.circularPathData.leftLargeArcRadius + " " + st.circularPathData.leftSmallArcRadius + " 0 0 0 " + st.circularPathData.leftFullExtent + " " + (st.circularPathData.sourceY - st.circularPathData.leftSmallArcRadius) + " L" + st.circularPathData.leftFullExtent + " " + st.circularPathData.verticalLeftInnerExtent + " A" + st.circularPathData.leftLargeArcRadius + " " + st.circularPathData.leftLargeArcRadius + " 0 0 0 " + st.circularPathData.leftInnerExtent + " " + st.circularPathData.verticalFullExtent + " L" + st.circularPathData.rightInnerExtent + " " + st.circularPathData.verticalFullExtent + " A" + st.circularPathData.rightLargeArcRadius + " " + st.circularPathData.rightLargeArcRadius + " 0 0 0 " + st.circularPathData.rightFullExtent + " " + st.circularPathData.verticalRightInnerExtent + " L" + st.circularPathData.rightFullExtent + " " + (st.circularPathData.targetY - st.circularPathData.rightSmallArcRadius) + " A" + st.circularPathData.rightLargeArcRadius + " " + st.circularPathData.rightSmallArcRadius + " 0 0 0 " + st.circularPathData.rightInnerExtent + " " + st.circularPathData.targetY + " L" + st.circularPathData.targetX + " " + st.circularPathData.targetY : lt = "M" + st.circularPathData.sourceX + " " + st.circularPathData.sourceY + " L" + st.circularPathData.leftInnerExtent + " " + st.circularPathData.sourceY + " A" + st.circularPathData.leftLargeArcRadius + " " + st.circularPathData.leftSmallArcRadius + " 0 0 1 " + st.circularPathData.leftFullExtent + " " + (st.circularPathData.sourceY + st.circularPathData.leftSmallArcRadius) + " L" + st.circularPathData.leftFullExtent + " " + st.circularPathData.verticalLeftInnerExtent + " A" + st.circularPathData.leftLargeArcRadius + " " + st.circularPathData.leftLargeArcRadius + " 0 0 1 " + st.circularPathData.leftInnerExtent + " " + st.circularPathData.verticalFullExtent + " L" + st.circularPathData.rightInnerExtent + " " + st.circularPathData.verticalFullExtent + " A" + st.circularPathData.rightLargeArcRadius + " " + st.circularPathData.rightLargeArcRadius + " 0 0 1 " + st.circularPathData.rightFullExtent + " " + st.circularPathData.verticalRightInnerExtent + " L" + st.circularPathData.rightFullExtent + " " + (st.circularPathData.targetY + st.circularPathData.rightSmallArcRadius) + " A" + st.circularPathData.rightLargeArcRadius + " " + st.circularPathData.rightSmallArcRadius + " 0 0 1 " + st.circularPathData.rightInnerExtent + " " + st.circularPathData.targetY + " L" + st.circularPathData.targetX + " " + st.circularPathData.targetY, lt;\n              }\n              function oe(st, lt) {\n                return ie(st) == ie(lt) ? st.circularLinkType == "bottom" ? Ee(st, lt) : _e(st, lt) : ie(lt) - ie(st);\n              }\n              function _e(st, lt) {\n                return st.y0 - lt.y0;\n              }\n              function Ee(st, lt) {\n                return lt.y0 - st.y0;\n              }\n              function Ce(st, lt) {\n                return st.y1 - lt.y1;\n              }\n              function me(st, lt) {\n                return lt.y1 - st.y1;\n              }\n              function ie(st) {\n                return st.target.column - st.source.column;\n              }\n              function Se(st) {\n                return st.target.x0 - st.source.x1;\n              }\n              function Le(st, lt) {\n                var Gt = V2(st), Nt = Se(lt) / Math.tan(Gt), Jt = ut(st) == "up" ? st.y1 + Nt : st.y1 - Nt;\n                return Jt;\n              }\n              function Ae(st, lt) {\n                var Gt = V2(st), Nt = Se(lt) / Math.tan(Gt), Jt = ut(st) == "up" ? st.y1 - Nt : st.y1 + Nt;\n                return Jt;\n              }\n              function Fe(st, lt, Gt, Nt) {\n                st.links.forEach(function(Jt) {\n                  if (!Jt.circular && Jt.target.column - Jt.source.column > 1) {\n                    var sr = Jt.source.column + 1, wr = Jt.target.column - 1, cr = 1, $e = wr - sr + 1;\n                    for (cr = 1; sr <= wr; sr++, cr++) st.nodes.forEach(function(St) {\n                      if (St.column == sr) {\n                        var Qt = cr / ($e + 1), Vt = Math.pow(1 - Qt, 3), _t = 3 * Qt * Math.pow(1 - Qt, 2), It = 3 * Math.pow(Qt, 2) * (1 - Qt), mt = Math.pow(Qt, 3), er = Vt * Jt.y0 + _t * Jt.y0 + It * Jt.y1 + mt * Jt.y1, lr = er - Jt.width / 2, Tr = er + Jt.width / 2, Lr;\n                        lr > St.y0 && lr < St.y1 ? (Lr = St.y1 - lr + 10, Lr = St.circularLinkType == "bottom" ? Lr : -Lr, St = ge(St, Lr, lt, Gt), st.nodes.forEach(function(ti) {\n                          C3(ti, Nt) == C3(St, Nt) || ti.column != St.column || Pe(St, ti) && ge(ti, Lr, lt, Gt);\n                        })) : Tr > St.y0 && Tr < St.y1 ? (Lr = Tr - St.y0 + 10, St = ge(St, Lr, lt, Gt), st.nodes.forEach(function(ti) {\n                          C3(ti, Nt) == C3(St, Nt) || ti.column != St.column || ti.y0 < St.y1 && ti.y1 > St.y1 && ge(ti, Lr, lt, Gt);\n                        })) : lr < St.y0 && Tr > St.y1 && (Lr = Tr - St.y0 + 10, St = ge(St, Lr, lt, Gt), st.nodes.forEach(function(ti) {\n                          C3(ti, Nt) == C3(St, Nt) || ti.column != St.column || ti.y0 < St.y1 && ti.y1 > St.y1 && ge(ti, Lr, lt, Gt);\n                        }));\n                      }\n                    });\n                  }\n                });\n              }\n              function Pe(st, lt) {\n                return st.y0 > lt.y0 && st.y0 < lt.y1 || st.y1 > lt.y0 && st.y1 < lt.y1 ? true : st.y0 < lt.y0 && st.y1 > lt.y1;\n              }\n              function ge(st, lt, Gt, Nt) {\n                return st.y0 + lt >= Gt && st.y1 + lt <= Nt && (st.y0 = st.y0 + lt, st.y1 = st.y1 + lt, st.targetLinks.forEach(function(Jt) {\n                  Jt.y1 = Jt.y1 + lt;\n                }), st.sourceLinks.forEach(function(Jt) {\n                  Jt.y0 = Jt.y0 + lt;\n                })), st;\n              }\n              function Re(st, lt, Gt, Nt) {\n                st.nodes.forEach(function(Jt) {\n                  Nt && Jt.y + (Jt.y1 - Jt.y0) > lt && (Jt.y = Jt.y - (Jt.y + (Jt.y1 - Jt.y0) - lt));\n                  var sr = st.links.filter(function($e) {\n                    return C3($e.source, Gt) == C3(Jt, Gt);\n                  }), wr = sr.length;\n                  wr > 1 && sr.sort(function($e, St) {\n                    if (!$e.circular && !St.circular) {\n                      if ($e.target.column == St.target.column) return $e.y1 - St.y1;\n                      if (Ze($e, St)) {\n                        if ($e.target.column > St.target.column) {\n                          var Qt = Ae(St, $e);\n                          return $e.y1 - Qt;\n                        }\n                        if (St.target.column > $e.target.column) {\n                          var Vt = Ae($e, St);\n                          return Vt - St.y1;\n                        }\n                      } else return $e.y1 - St.y1;\n                    }\n                    if ($e.circular && !St.circular) return $e.circularLinkType == "top" ? -1 : 1;\n                    if (St.circular && !$e.circular) return St.circularLinkType == "top" ? 1 : -1;\n                    if ($e.circular && St.circular) return $e.circularLinkType === St.circularLinkType && $e.circularLinkType == "top" ? $e.target.column === St.target.column ? $e.target.y1 - St.target.y1 : St.target.column - $e.target.column : $e.circularLinkType === St.circularLinkType && $e.circularLinkType == "bottom" ? $e.target.column === St.target.column ? St.target.y1 - $e.target.y1 : $e.target.column - St.target.column : $e.circularLinkType == "top" ? -1 : 1;\n                  });\n                  var cr = Jt.y0;\n                  sr.forEach(function($e) {\n                    $e.y0 = cr + $e.width / 2, cr = cr + $e.width;\n                  }), sr.forEach(function($e, St) {\n                    if ($e.circularLinkType == "bottom") {\n                      var Qt = St + 1, Vt = 0;\n                      for (Qt; Qt < wr; Qt++) Vt = Vt + sr[Qt].width;\n                      $e.y0 = Jt.y1 - Vt - $e.width / 2;\n                    }\n                  });\n                });\n              }\n              function ce(st, lt, Gt) {\n                st.nodes.forEach(function(Nt) {\n                  var Jt = st.links.filter(function(cr) {\n                    return C3(cr.target, Gt) == C3(Nt, Gt);\n                  }), sr = Jt.length;\n                  sr > 1 && Jt.sort(function(cr, $e) {\n                    if (!cr.circular && !$e.circular) {\n                      if (cr.source.column == $e.source.column) return cr.y0 - $e.y0;\n                      if (Ze(cr, $e)) {\n                        if ($e.source.column < cr.source.column) {\n                          var St = Le($e, cr);\n                          return cr.y0 - St;\n                        }\n                        if (cr.source.column < $e.source.column) {\n                          var Qt = Le(cr, $e);\n                          return Qt - $e.y0;\n                        }\n                      } else return cr.y0 - $e.y0;\n                    }\n                    if (cr.circular && !$e.circular) return cr.circularLinkType == "top" ? -1 : 1;\n                    if ($e.circular && !cr.circular) return $e.circularLinkType == "top" ? 1 : -1;\n                    if (cr.circular && $e.circular) return cr.circularLinkType === $e.circularLinkType && cr.circularLinkType == "top" ? cr.source.column === $e.source.column ? cr.source.y1 - $e.source.y1 : cr.source.column - $e.source.column : cr.circularLinkType === $e.circularLinkType && cr.circularLinkType == "bottom" ? cr.source.column === $e.source.column ? cr.source.y1 - $e.source.y1 : $e.source.column - cr.source.column : cr.circularLinkType == "top" ? -1 : 1;\n                  });\n                  var wr = Nt.y0;\n                  Jt.forEach(function(cr) {\n                    cr.y1 = wr + cr.width / 2, wr = wr + cr.width;\n                  }), Jt.forEach(function(cr, $e) {\n                    if (cr.circularLinkType == "bottom") {\n                      var St = $e + 1, Qt = 0;\n                      for (St; St < sr; St++) Qt = Qt + Jt[St].width;\n                      cr.y1 = Nt.y1 - Qt - cr.width / 2;\n                    }\n                  });\n                });\n              }\n              function Ze(st, lt) {\n                return ut(st) == ut(lt);\n              }\n              function ut(st) {\n                return st.y0 - st.y1 > 0 ? "up" : "down";\n              }\n              function pt(st, lt) {\n                return C3(st.source, lt) == C3(st.target, lt);\n              }\n              function Zt(st, lt, Gt) {\n                var Nt = st.nodes, Jt = st.links, sr = false, wr = false;\n                if (Jt.forEach(function(_t) {\n                  _t.circularLinkType == "top" ? sr = true : _t.circularLinkType == "bottom" && (wr = true);\n                }), sr == false || wr == false) {\n                  var cr = t3.min(Nt, function(_t) {\n                    return _t.y0;\n                  }), $e = t3.max(Nt, function(_t) {\n                    return _t.y1;\n                  }), St = $e - cr, Qt = Gt - lt, Vt = Qt / St;\n                  Nt.forEach(function(_t) {\n                    var It = (_t.y1 - _t.y0) * Vt;\n                    _t.y0 = (_t.y0 - cr) * Vt, _t.y1 = _t.y0 + It;\n                  }), Jt.forEach(function(_t) {\n                    _t.y0 = (_t.y0 - cr) * Vt, _t.y1 = (_t.y1 - cr) * Vt, _t.width = _t.width * Vt;\n                  });\n                }\n              }\n              e3.sankeyCircular = T3, e3.sankeyCenter = u4, e3.sankeyLeft = o4, e3.sankeyRight = s3, e3.sankeyJustify = l3, Object.defineProperty(e3, "__esModule", { value: true });\n            });\n          });\n          var WJ = ye((e2r, XWe) => {\n            "use strict";\n            XWe.exports = { nodeTextOffsetHorizontal: 4, nodeTextOffsetVertical: 3, nodePadAcross: 10, sankeyIterations: 50, forceIterations: 5, forceTicksPerFrame: 10, duration: 500, ease: "linear", cn: { sankey: "sankey", sankeyLinks: "sankey-links", sankeyLink: "sankey-link", sankeyNodeSet: "sankey-node-set", sankeyNode: "sankey-node", nodeRect: "node-rect", nodeLabel: "node-label" } };\n          });\n          var oXe = ye((t2r, aXe) => {\n            "use strict";\n            var ZWe = OWe(), zZt = (F2(), ob(D22)).interpolateNumber, R5 = Oa(), Jk = VWe(), OZt = WWe(), Nu = WJ(), D5 = cd(), sw = ka(), qZt = So(), p1 = Dr(), YJ = p1.strTranslate, BZt = p1.strRotate, KJ = Jm(), $k = KJ.keyFun, E7 = KJ.repeat, eXe = KJ.unwrap, YWe = ru(), NZt = qa(), tXe = $h(), UZt = tXe.CAP_SHIFT, VZt = tXe.LINE_SPACING, GZt = 3;\n            function HZt(e3, t3, r4) {\n              var n4 = eXe(t3), i3 = n4.trace, a4 = i3.domain, o4 = i3.orientation === "h", s3 = i3.node.pad, l3 = i3.node.thickness, u4 = { justify: Jk.sankeyJustify, left: Jk.sankeyLeft, right: Jk.sankeyRight, center: Jk.sankeyCenter }[i3.node.align], c5 = e3.width * (a4.x[1] - a4.x[0]), f4 = e3.height * (a4.y[1] - a4.y[0]), h3 = n4._nodes, d3 = n4._links, v3 = n4.circular, _2;\n              v3 ? _2 = OZt.sankeyCircular().circularLinkGap(0) : _2 = Jk.sankey(), _2.iterations(Nu.sankeyIterations).size(o4 ? [c5, f4] : [f4, c5]).nodeWidth(l3).nodePadding(s3).nodeId(function(V2) {\n                return V2.pointNumber;\n              }).nodeAlign(u4).nodes(h3).links(d3);\n              var b = _2();\n              _2.nodePadding() < s3 && p1.warn("node.pad was reduced to ", _2.nodePadding(), " to fit within the figure.");\n              var p3, k4, E3;\n              for (var S2 in n4._groupLookup) {\n                var L3 = parseInt(n4._groupLookup[S2]), x2;\n                for (p3 = 0; p3 < b.nodes.length; p3++) if (b.nodes[p3].pointNumber === L3) {\n                  x2 = b.nodes[p3];\n                  break;\n                }\n                if (x2) {\n                  var C3 = { pointNumber: parseInt(S2), x0: x2.x0, x1: x2.x1, y0: x2.y0, y1: x2.y1, partOfGroup: true, sourceLinks: [], targetLinks: [] };\n                  b.nodes.unshift(C3), x2.childrenNodes.unshift(C3);\n                }\n              }\n              function M4() {\n                for (p3 = 0; p3 < b.nodes.length; p3++) {\n                  var V2 = b.nodes[p3], G2 = {}, Z, j3;\n                  for (k4 = 0; k4 < V2.targetLinks.length; k4++) j3 = V2.targetLinks[k4], Z = j3.source.pointNumber + ":" + j3.target.pointNumber, G2.hasOwnProperty(Z) || (G2[Z] = []), G2[Z].push(j3);\n                  var N2 = Object.keys(G2);\n                  for (k4 = 0; k4 < N2.length; k4++) {\n                    Z = N2[k4];\n                    var H = G2[Z], te = 0, oe = {};\n                    for (E3 = 0; E3 < H.length; E3++) j3 = H[E3], oe[j3.label] || (oe[j3.label] = 0), oe[j3.label] += j3.value, te += j3.value;\n                    for (E3 = 0; E3 < H.length; E3++) j3 = H[E3], j3.flow = { value: te, labelConcentration: oe[j3.label] / te, concentration: j3.value / te, links: H }, j3.concentrationscale && (j3.color = D5(j3.concentrationscale(j3.flow.labelConcentration)));\n                  }\n                  var _e = 0;\n                  for (k4 = 0; k4 < V2.sourceLinks.length; k4++) _e += V2.sourceLinks[k4].value;\n                  for (k4 = 0; k4 < V2.sourceLinks.length; k4++) j3 = V2.sourceLinks[k4], j3.concentrationOut = j3.value / _e;\n                  var Ee = 0;\n                  for (k4 = 0; k4 < V2.targetLinks.length; k4++) Ee += V2.targetLinks[k4].value;\n                  for (k4 = 0; k4 < V2.targetLinks.length; k4++) j3 = V2.targetLinks[k4], j3.concenrationIn = j3.value / Ee;\n                }\n              }\n              M4();\n              function g3(V2) {\n                V2.forEach(function(G2) {\n                  var Z, j3, N2 = 0, H = G2.length, te;\n                  for (G2.sort(function(oe, _e) {\n                    return oe.y0 - _e.y0;\n                  }), te = 0; te < H; ++te) Z = G2[te], Z.y0 >= N2 || (j3 = N2 - Z.y0, j3 > 1e-6 && (Z.y0 += j3, Z.y1 += j3)), N2 = Z.y1 + s3;\n                });\n              }\n              function P3(V2) {\n                var G2 = V2.map(function(_e, Ee) {\n                  return { x0: _e.x0, index: Ee };\n                }).sort(function(_e, Ee) {\n                  return _e.x0 - Ee.x0;\n                }), Z = [], j3 = -1, N2, H = -1 / 0, te;\n                for (p3 = 0; p3 < G2.length; p3++) {\n                  var oe = V2[G2[p3].index];\n                  oe.x0 > H + l3 && (j3 += 1, N2 = oe.x0), H = oe.x0, Z[j3] || (Z[j3] = []), Z[j3].push(oe), te = N2 - oe.x0, oe.x0 += te, oe.x1 += te;\n                }\n                return Z;\n              }\n              if (i3.node.x.length && i3.node.y.length) {\n                for (p3 = 0; p3 < Math.min(i3.node.x.length, i3.node.y.length, b.nodes.length); p3++) if (i3.node.x[p3] && i3.node.y[p3]) {\n                  var T3 = [i3.node.x[p3] * c5, i3.node.y[p3] * f4];\n                  b.nodes[p3].x0 = T3[0] - l3 / 2, b.nodes[p3].x1 = T3[0] + l3 / 2;\n                  var z3 = b.nodes[p3].y1 - b.nodes[p3].y0;\n                  b.nodes[p3].y0 = T3[1] - z3 / 2, b.nodes[p3].y1 = T3[1] + z3 / 2;\n                }\n                if (i3.arrangement === "snap") {\n                  h3 = b.nodes;\n                  var O3 = P3(h3);\n                  g3(O3);\n                }\n                _2.update(b);\n              }\n              return { circular: v3, key: r4, trace: i3, guid: p1.randstr(), horizontal: o4, width: c5, height: f4, nodePad: i3.node.pad, nodeLineColor: i3.node.line.color, nodeLineWidth: i3.node.line.width, linkLineColor: i3.link.line.color, linkLineWidth: i3.link.line.width, linkArrowLength: i3.link.arrowlen, valueFormat: i3.valueformat, valueSuffix: i3.valuesuffix, textFont: i3.textfont, translateX: a4.x[0] * e3.width + e3.margin.l, translateY: e3.height - a4.y[1] * e3.height + e3.margin.t, dragParallel: o4 ? f4 : c5, dragPerpendicular: o4 ? c5 : f4, arrangement: i3.arrangement, sankey: _2, graph: b, forceLayouts: {}, interactionState: { dragInProgress: false, hovered: false } };\n            }\n            function jZt(e3, t3, r4) {\n              var n4 = D5(t3.color), i3 = D5(t3.hovercolor), a4 = t3.source.label + "|" + t3.target.label, o4 = a4 + "__" + r4;\n              return t3.trace = e3.trace, t3.curveNumber = e3.trace.index, { circular: e3.circular, key: o4, traceId: e3.key, pointNumber: t3.pointNumber, link: t3, tinyColorHue: sw.tinyRGB(n4), tinyColorAlpha: n4.getAlpha(), tinyColorHoverHue: sw.tinyRGB(i3), tinyColorHoverAlpha: i3.getAlpha(), linkPath: JJ, linkLineColor: e3.linkLineColor, linkLineWidth: e3.linkLineWidth, linkArrowLength: e3.linkArrowLength, valueFormat: e3.valueFormat, valueSuffix: e3.valueSuffix, sankey: e3.sankey, parent: e3, interactionState: e3.interactionState, flow: t3.flow };\n            }\n            function WZt(e3, t3) {\n              var r4 = "", n4 = e3.width / 2, i3 = e3.circularPathData, a4 = i3.sourceX + i3.verticalBuffer < i3.targetX, o4 = i3.rightFullExtent - i3.rightLargeArcRadius - t3 <= i3.leftFullExtent - n4, s3 = Math.abs(i3.rightFullExtent - i3.leftFullExtent - n4) < n4;\n              return e3.circularLinkType === "top" ? (r4 = "M " + (i3.targetX - t3) + " " + (i3.targetY + n4) + " L " + (i3.rightInnerExtent - t3) + " " + (i3.targetY + n4) + "A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightSmallArcRadius + n4) + " 0 0 1 " + (i3.rightFullExtent - n4 - t3) + " " + (i3.targetY - i3.rightSmallArcRadius) + "L " + (i3.rightFullExtent - n4 - t3) + " " + i3.verticalRightInnerExtent, a4 && o4 ? r4 += " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 1 " + (i3.rightFullExtent + n4 - t3 - (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalRightInnerExtent - (i3.rightLargeArcRadius + n4)) + " L " + (i3.rightFullExtent + n4 - (i3.rightLargeArcRadius - n4) - t3) + " " + (i3.verticalRightInnerExtent - (i3.rightLargeArcRadius + n4)) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftLargeArcRadius + n4) + " 0 0 1 " + (i3.leftFullExtent + n4) + " " + i3.verticalRightInnerExtent : a4 ? r4 += " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightLargeArcRadius - n4) + " 0 0 0 " + (i3.rightFullExtent - n4 - t3 - (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalRightInnerExtent - (i3.rightLargeArcRadius - n4)) + " L " + (i3.leftFullExtent + n4 + (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalRightInnerExtent - (i3.rightLargeArcRadius - n4)) + " A " + (i3.leftLargeArcRadius - n4) + " " + (i3.leftLargeArcRadius - n4) + " 0 0 0 " + (i3.leftFullExtent + n4) + " " + i3.verticalLeftInnerExtent : r4 += " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 1 " + (i3.rightInnerExtent - t3) + " " + (i3.verticalFullExtent - n4) + " L " + i3.leftInnerExtent + " " + (i3.verticalFullExtent - n4) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftLargeArcRadius + n4) + " 0 0 1 " + (i3.leftFullExtent + n4) + " " + i3.verticalLeftInnerExtent, r4 += " L " + (i3.leftFullExtent + n4) + " " + (i3.sourceY - i3.leftSmallArcRadius) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 1 " + i3.leftInnerExtent + " " + (i3.sourceY + n4) + " L " + i3.sourceX + " " + (i3.sourceY + n4) + " L " + i3.sourceX + " " + (i3.sourceY - n4) + " L " + i3.leftInnerExtent + " " + (i3.sourceY - n4) + " A " + (i3.leftLargeArcRadius - n4) + " " + (i3.leftSmallArcRadius - n4) + " 0 0 0 " + (i3.leftFullExtent - n4) + " " + (i3.sourceY - i3.leftSmallArcRadius) + " L " + (i3.leftFullExtent - n4) + " " + i3.verticalLeftInnerExtent, a4 && o4 ? r4 += " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 0 " + (i3.leftFullExtent - n4) + " " + (i3.verticalFullExtent + n4) + "L" + (i3.rightFullExtent + n4 - t3) + " " + (i3.verticalFullExtent + n4) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 0 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent : a4 ? r4 += " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 1 " + (i3.leftFullExtent + n4) + " " + (i3.verticalFullExtent - n4) + " L " + (i3.rightFullExtent - n4 - t3) + " " + (i3.verticalFullExtent - n4) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 1 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent : r4 += " A " + (i3.leftLargeArcRadius - n4) + " " + (i3.leftLargeArcRadius - n4) + " 0 0 0 " + i3.leftInnerExtent + " " + (i3.verticalFullExtent + n4) + " L " + (i3.rightInnerExtent - t3) + " " + (i3.verticalFullExtent + n4) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightLargeArcRadius - n4) + " 0 0 0 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent, r4 += " L " + (i3.rightFullExtent + n4 - t3) + " " + (i3.targetY - i3.rightSmallArcRadius) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 0 " + (i3.rightInnerExtent - t3) + " " + (i3.targetY - n4) + " L " + (i3.targetX - t3) + " " + (i3.targetY - n4) + (t3 > 0 ? " L " + i3.targetX + " " + i3.targetY : "") + "Z") : (r4 = "M " + (i3.targetX - t3) + " " + (i3.targetY - n4) + "  L " + (i3.rightInnerExtent - t3) + " " + (i3.targetY - n4) + " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightSmallArcRadius + n4) + " 0 0 0 " + (i3.rightFullExtent - n4 - t3) + " " + (i3.targetY + i3.rightSmallArcRadius) + " L " + (i3.rightFullExtent - n4 - t3) + " " + i3.verticalRightInnerExtent, a4 && o4 ? r4 += " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 0 " + (i3.rightInnerExtent - n4 - t3) + " " + (i3.verticalFullExtent + n4) + " L " + (i3.rightFullExtent + n4 - t3 - (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalFullExtent + n4) + " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 0 " + (i3.leftFullExtent + n4) + " " + i3.verticalLeftInnerExtent : a4 ? r4 += " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 1 " + (i3.rightFullExtent - t3 - n4 - (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalFullExtent - n4) + " L " + (i3.leftFullExtent + n4 + (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalFullExtent - n4) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 1 " + (i3.leftFullExtent + n4) + " " + i3.verticalLeftInnerExtent : r4 += " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 0 " + (i3.rightInnerExtent - t3) + " " + (i3.verticalFullExtent + n4) + " L " + i3.leftInnerExtent + " " + (i3.verticalFullExtent + n4) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftLargeArcRadius + n4) + " 0 0 0 " + (i3.leftFullExtent + n4) + " " + i3.verticalLeftInnerExtent, r4 += " L " + (i3.leftFullExtent + n4) + " " + (i3.sourceY + i3.leftSmallArcRadius) + " A " + (i3.leftLargeArcRadius + n4) + " " + (i3.leftSmallArcRadius + n4) + " 0 0 0 " + i3.leftInnerExtent + " " + (i3.sourceY - n4) + " L " + i3.sourceX + " " + (i3.sourceY - n4) + " L " + i3.sourceX + " " + (i3.sourceY + n4) + " L " + i3.leftInnerExtent + " " + (i3.sourceY + n4) + " A " + (i3.leftLargeArcRadius - n4) + " " + (i3.leftSmallArcRadius - n4) + " 0 0 1 " + (i3.leftFullExtent - n4) + " " + (i3.sourceY + i3.leftSmallArcRadius) + " L " + (i3.leftFullExtent - n4) + " " + i3.verticalLeftInnerExtent, a4 && o4 ? r4 += " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 1 " + (i3.leftFullExtent - n4 - (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalFullExtent - n4) + " L " + (i3.rightFullExtent + n4 - t3 + (i3.rightLargeArcRadius - n4)) + " " + (i3.verticalFullExtent - n4) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 1 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent : a4 ? r4 += " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 0 " + (i3.leftFullExtent + n4) + " " + (i3.verticalFullExtent + n4) + " L " + (i3.rightFullExtent - t3 - n4) + " " + (i3.verticalFullExtent + n4) + " A " + (i3.rightLargeArcRadius + n4) + " " + (i3.rightLargeArcRadius + n4) + " 0 0 0 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent : r4 += " A " + (i3.leftLargeArcRadius - n4) + " " + (i3.leftLargeArcRadius - n4) + " 0 0 1 " + i3.leftInnerExtent + " " + (i3.verticalFullExtent - n4) + " L " + (i3.rightInnerExtent - t3) + " " + (i3.verticalFullExtent - n4) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightLargeArcRadius - n4) + " 0 0 1 " + (i3.rightFullExtent + n4 - t3) + " " + i3.verticalRightInnerExtent, r4 += " L " + (i3.rightFullExtent + n4 - t3) + " " + (i3.targetY + i3.rightSmallArcRadius) + " A " + (i3.rightLargeArcRadius - n4) + " " + (i3.rightSmallArcRadius - n4) + " 0 0 1 " + (i3.rightInnerExtent - t3) + " " + (i3.targetY + n4) + " L " + (i3.targetX - t3) + " " + (i3.targetY + n4) + (t3 > 0 ? " L " + i3.targetX + " " + i3.targetY : "") + "Z"), r4;\n            }\n            function JJ() {\n              var e3 = 0.5;\n              function t3(r4) {\n                var n4 = r4.linkArrowLength;\n                if (r4.link.circular) return WZt(r4.link, n4);\n                var i3 = Math.abs((r4.link.target.x0 - r4.link.source.x1) / 2);\n                n4 > i3 && (n4 = i3);\n                var a4 = r4.link.source.x1, o4 = r4.link.target.x0 - n4, s3 = zZt(a4, o4), l3 = s3(e3), u4 = s3(1 - e3), c5 = r4.link.y0 - r4.link.width / 2, f4 = r4.link.y0 + r4.link.width / 2, h3 = r4.link.y1 - r4.link.width / 2, d3 = r4.link.y1 + r4.link.width / 2, v3 = "M" + a4 + "," + c5, _2 = "C" + l3 + "," + c5 + " " + u4 + "," + h3 + " " + o4 + "," + h3, b = "C" + u4 + "," + d3 + " " + l3 + "," + f4 + " " + a4 + "," + f4, p3 = n4 > 0 ? "L" + (o4 + n4) + "," + (h3 + r4.link.width / 2) : "";\n                return p3 += "L" + o4 + "," + d3, v3 + _2 + p3 + b + "Z";\n              }\n              return t3;\n            }\n            function XZt(e3, t3) {\n              var r4 = D5(t3.color), n4 = Nu.nodePadAcross, i3 = e3.nodePad / 2;\n              t3.dx = t3.x1 - t3.x0, t3.dy = t3.y1 - t3.y0;\n              var a4 = t3.dx, o4 = Math.max(0.5, t3.dy), s3 = "node_" + t3.pointNumber;\n              return t3.group && (s3 = p1.randstr()), t3.trace = e3.trace, t3.curveNumber = e3.trace.index, { index: t3.pointNumber, key: s3, partOfGroup: t3.partOfGroup || false, group: t3.group, traceId: e3.key, trace: e3.trace, node: t3, nodePad: e3.nodePad, nodeLineColor: e3.nodeLineColor, nodeLineWidth: e3.nodeLineWidth, textFont: e3.textFont, size: e3.horizontal ? e3.height : e3.width, visibleWidth: Math.ceil(a4), visibleHeight: o4, zoneX: -n4, zoneY: -i3, zoneWidth: a4 + 2 * n4, zoneHeight: o4 + 2 * i3, labelY: e3.horizontal ? t3.dy / 2 + 1 : t3.dx / 2 + 1, left: t3.originalLayer === 1, sizeAcross: e3.width, forceLayouts: e3.forceLayouts, horizontal: e3.horizontal, darkBackground: r4.getBrightness() <= 128, tinyColorHue: sw.tinyRGB(r4), tinyColorAlpha: r4.getAlpha(), valueFormat: e3.valueFormat, valueSuffix: e3.valueSuffix, sankey: e3.sankey, graph: e3.graph, arrangement: e3.arrangement, uniqueNodeLabelPathId: [e3.guid, e3.key, s3].join("_"), interactionState: e3.interactionState, figure: e3 };\n            }\n            function ZJ(e3) {\n              e3.attr("transform", function(t3) {\n                return YJ(t3.node.x0.toFixed(3), t3.node.y0.toFixed(3));\n              });\n            }\n            function ZZt(e3) {\n              e3.call(ZJ);\n            }\n            function rXe(e3, t3) {\n              e3.call(ZZt), t3.attr("d", JJ());\n            }\n            function KWe(e3) {\n              e3.attr("width", function(t3) {\n                return t3.node.x1 - t3.node.x0;\n              }).attr("height", function(t3) {\n                return t3.visibleHeight;\n              });\n            }\n            function XJ(e3) {\n              return e3.link.width > 1 || e3.linkLineWidth > 0;\n            }\n            function JWe(e3) {\n              var t3 = YJ(e3.translateX, e3.translateY);\n              return t3 + (e3.horizontal ? "matrix(1 0 0 1 0 0)" : "matrix(0 1 1 0 0 0)");\n            }\n            function $We(e3, t3, r4) {\n              e3.on(".basic", null).on("mouseover.basic", function(n4) {\n                !n4.interactionState.dragInProgress && !n4.partOfGroup && (r4.hover(this, n4, t3), n4.interactionState.hovered = [this, n4]);\n              }).on("mousemove.basic", function(n4) {\n                !n4.interactionState.dragInProgress && !n4.partOfGroup && (r4.follow(this, n4), n4.interactionState.hovered = [this, n4]);\n              }).on("mouseout.basic", function(n4) {\n                !n4.interactionState.dragInProgress && !n4.partOfGroup && (r4.unhover(this, n4, t3), n4.interactionState.hovered = false);\n              }).on("click.basic", function(n4) {\n                n4.interactionState.hovered && (r4.unhover(this, n4, t3), n4.interactionState.hovered = false), !n4.interactionState.dragInProgress && !n4.partOfGroup && r4.select(this, n4, t3);\n              });\n            }\n            function YZt(e3, t3, r4, n4) {\n              var i3 = R5.behavior.drag().origin(function(a4) {\n                return { x: a4.node.x0 + a4.visibleWidth / 2, y: a4.node.y0 + a4.visibleHeight / 2 };\n              }).on("dragstart", function(a4) {\n                if (a4.arrangement !== "fixed" && (p1.ensureSingle(n4._fullLayout._infolayer, "g", "dragcover", function(s3) {\n                  n4._fullLayout._dragCover = s3;\n                }), p1.raiseToTop(this), a4.interactionState.dragInProgress = a4.node, QWe(a4.node), a4.interactionState.hovered && (r4.nodeEvents.unhover.apply(0, a4.interactionState.hovered), a4.interactionState.hovered = false), a4.arrangement === "snap")) {\n                  var o4 = a4.traceId + "|" + a4.key;\n                  a4.forceLayouts[o4] ? a4.forceLayouts[o4].alpha(1) : KZt(e3, o4, a4, n4), JZt(e3, t3, a4, o4, n4);\n                }\n              }).on("drag", function(a4) {\n                if (a4.arrangement !== "fixed") {\n                  var o4 = R5.event.x, s3 = R5.event.y;\n                  a4.arrangement === "snap" ? (a4.node.x0 = o4 - a4.visibleWidth / 2, a4.node.x1 = o4 + a4.visibleWidth / 2, a4.node.y0 = s3 - a4.visibleHeight / 2, a4.node.y1 = s3 + a4.visibleHeight / 2) : (a4.arrangement === "freeform" && (a4.node.x0 = o4 - a4.visibleWidth / 2, a4.node.x1 = o4 + a4.visibleWidth / 2), s3 = Math.max(0, Math.min(a4.size - a4.visibleHeight / 2, s3)), a4.node.y0 = s3 - a4.visibleHeight / 2, a4.node.y1 = s3 + a4.visibleHeight / 2), QWe(a4.node), a4.arrangement !== "snap" && (a4.sankey.update(a4.graph), rXe(e3.filter(nXe(a4)), t3));\n                }\n              }).on("dragend", function(a4) {\n                if (a4.arrangement !== "fixed") {\n                  a4.interactionState.dragInProgress = false;\n                  for (var o4 = 0; o4 < a4.node.childrenNodes.length; o4++) a4.node.childrenNodes[o4].x = a4.node.x, a4.node.childrenNodes[o4].y = a4.node.y;\n                  a4.arrangement !== "snap" && iXe(a4, n4);\n                }\n              });\n              e3.on(".drag", null).call(i3);\n            }\n            function KZt(e3, t3, r4, n4) {\n              eYt(r4.graph.nodes);\n              var i3 = r4.graph.nodes.filter(function(a4) {\n                return a4.originalX === r4.node.originalX;\n              }).filter(function(a4) {\n                return !a4.partOfGroup;\n              });\n              r4.forceLayouts[t3] = ZWe.forceSimulation(i3).alphaDecay(0).force("collide", ZWe.forceCollide().radius(function(a4) {\n                return a4.dy / 2 + r4.nodePad / 2;\n              }).strength(1).iterations(Nu.forceIterations)).force("constrain", $Zt(e3, t3, i3, r4, n4)).stop();\n            }\n            function JZt(e3, t3, r4, n4, i3) {\n              window.requestAnimationFrame(function a4() {\n                var o4;\n                for (o4 = 0; o4 < Nu.forceTicksPerFrame; o4++) r4.forceLayouts[n4].tick();\n                var s3 = r4.graph.nodes;\n                if (tYt(s3), r4.sankey.update(r4.graph), rXe(e3.filter(nXe(r4)), t3), r4.forceLayouts[n4].alpha() > 0) window.requestAnimationFrame(a4);\n                else {\n                  var l3 = r4.node.originalX;\n                  r4.node.x0 = l3 - r4.visibleWidth / 2, r4.node.x1 = l3 + r4.visibleWidth / 2, iXe(r4, i3);\n                }\n              });\n            }\n            function $Zt(e3, t3, r4, n4) {\n              return function() {\n                for (var a4 = 0, o4 = 0; o4 < r4.length; o4++) {\n                  var s3 = r4[o4];\n                  s3 === n4.interactionState.dragInProgress ? (s3.x = s3.lastDraggedX, s3.y = s3.lastDraggedY) : (s3.vx = (s3.originalX - s3.x) / Nu.forceTicksPerFrame, s3.y = Math.min(n4.size - s3.dy / 2, Math.max(s3.dy / 2, s3.y))), a4 = Math.max(a4, Math.abs(s3.vx), Math.abs(s3.vy));\n                }\n                !n4.interactionState.dragInProgress && a4 < 0.1 && n4.forceLayouts[t3].alpha() > 0 && n4.forceLayouts[t3].alpha(0);\n              };\n            }\n            function iXe(e3, t3) {\n              for (var r4 = [], n4 = [], i3 = 0; i3 < e3.graph.nodes.length; i3++) {\n                var a4 = (e3.graph.nodes[i3].x0 + e3.graph.nodes[i3].x1) / 2, o4 = (e3.graph.nodes[i3].y0 + e3.graph.nodes[i3].y1) / 2;\n                r4.push(a4 / e3.figure.width), n4.push(o4 / e3.figure.height);\n              }\n              NZt.call("_guiRestyle", t3, { "node.x": [r4], "node.y": [n4] }, e3.trace.index).then(function() {\n                t3._fullLayout._dragCover && t3._fullLayout._dragCover.remove();\n              });\n            }\n            function QZt(e3) {\n              var t3 = [], r4;\n              for (r4 = 0; r4 < e3.length; r4++) e3[r4].originalX = (e3[r4].x0 + e3[r4].x1) / 2, e3[r4].originalY = (e3[r4].y0 + e3[r4].y1) / 2, t3.indexOf(e3[r4].originalX) === -1 && t3.push(e3[r4].originalX);\n              for (t3.sort(function(n4, i3) {\n                return n4 - i3;\n              }), r4 = 0; r4 < e3.length; r4++) e3[r4].originalLayerIndex = t3.indexOf(e3[r4].originalX), e3[r4].originalLayer = e3[r4].originalLayerIndex / (t3.length - 1);\n            }\n            function QWe(e3) {\n              e3.lastDraggedX = e3.x0 + e3.dx / 2, e3.lastDraggedY = e3.y0 + e3.dy / 2;\n            }\n            function nXe(e3) {\n              return function(t3) {\n                return t3.node.originalX === e3.node.originalX;\n              };\n            }\n            function eYt(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) e3[t3].y = (e3[t3].y0 + e3[t3].y1) / 2, e3[t3].x = (e3[t3].x0 + e3[t3].x1) / 2;\n            }\n            function tYt(e3) {\n              for (var t3 = 0; t3 < e3.length; t3++) e3[t3].y0 = e3[t3].y - e3[t3].dy / 2, e3[t3].y1 = e3[t3].y0 + e3[t3].dy, e3[t3].x0 = e3[t3].x - e3[t3].dx / 2, e3[t3].x1 = e3[t3].x0 + e3[t3].dx;\n            }\n            aXe.exports = function(e3, t3, r4, n4, i3) {\n              var a4 = e3._context.staticPlot, o4 = false;\n              p1.ensureSingle(e3._fullLayout._infolayer, "g", "first-render", function() {\n                o4 = true;\n              });\n              var s3 = e3._fullLayout._dragCover, l3 = r4.filter(function(b) {\n                return eXe(b).trace.visible;\n              }).map(HZt.bind(null, n4)), u4 = t3.selectAll("." + Nu.cn.sankey).data(l3, $k);\n              u4.exit().remove(), u4.enter().append("g").classed(Nu.cn.sankey, true).style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("shape-rendering", "geometricPrecision").style("pointer-events", a4 ? "none" : "auto").attr("transform", JWe), u4.each(function(b, p3) {\n                e3._fullData[p3]._sankey = b;\n                var k4 = "bgsankey-" + b.trace.uid + "-" + p3;\n                p1.ensureSingle(e3._fullLayout._draggers, "rect", k4), e3._fullData[p3]._bgRect = R5.select("." + k4), e3._fullData[p3]._bgRect.style("pointer-events", a4 ? "none" : "all").attr("width", b.width).attr("height", b.height).attr("x", b.translateX).attr("y", b.translateY).classed("bgsankey", true).style({ fill: "transparent", "stroke-width": 0 });\n              }), u4.transition().ease(Nu.ease).duration(Nu.duration).attr("transform", JWe);\n              var c5 = u4.selectAll("." + Nu.cn.sankeyLinks).data(E7, $k);\n              c5.enter().append("g").classed(Nu.cn.sankeyLinks, true).style("fill", "none");\n              var f4 = c5.selectAll("." + Nu.cn.sankeyLink).data(function(b) {\n                var p3 = b.graph.links;\n                return p3.filter(function(k4) {\n                  return k4.value;\n                }).map(jZt.bind(null, b));\n              }, $k);\n              f4.enter().append("path").classed(Nu.cn.sankeyLink, true).call($We, u4, i3.linkEvents), f4.style("stroke", function(b) {\n                return XJ(b) ? sw.tinyRGB(D5(b.linkLineColor)) : b.tinyColorHue;\n              }).style("stroke-opacity", function(b) {\n                return XJ(b) ? sw.opacity(b.linkLineColor) : b.tinyColorAlpha;\n              }).style("fill", function(b) {\n                return b.tinyColorHue;\n              }).style("fill-opacity", function(b) {\n                return b.tinyColorAlpha;\n              }).style("stroke-width", function(b) {\n                return XJ(b) ? b.linkLineWidth : 1;\n              }).attr("d", JJ()), f4.style("opacity", function() {\n                return e3._context.staticPlot || o4 || s3 ? 1 : 0;\n              }).transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 1), f4.exit().transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 0).remove();\n              var h3 = u4.selectAll("." + Nu.cn.sankeyNodeSet).data(E7, $k);\n              h3.enter().append("g").classed(Nu.cn.sankeyNodeSet, true), h3.style("cursor", function(b) {\n                switch (b.arrangement) {\n                  case "fixed":\n                    return "default";\n                  case "perpendicular":\n                    return "ns-resize";\n                  default:\n                    return "move";\n                }\n              });\n              var d3 = h3.selectAll("." + Nu.cn.sankeyNode).data(function(b) {\n                var p3 = b.graph.nodes;\n                return QZt(p3), p3.map(XZt.bind(null, b));\n              }, $k);\n              d3.enter().append("g").classed(Nu.cn.sankeyNode, true).call(ZJ).style("opacity", function(b) {\n                return (e3._context.staticPlot || o4) && !b.partOfGroup ? 1 : 0;\n              }), d3.call($We, u4, i3.nodeEvents).call(YZt, f4, i3, e3), d3.transition().ease(Nu.ease).duration(Nu.duration).call(ZJ).style("opacity", function(b) {\n                return b.partOfGroup ? 0 : 1;\n              }), d3.exit().transition().ease(Nu.ease).duration(Nu.duration).style("opacity", 0).remove();\n              var v3 = d3.selectAll("." + Nu.cn.nodeRect).data(E7);\n              v3.enter().append("rect").classed(Nu.cn.nodeRect, true).call(KWe), v3.style("stroke-width", function(b) {\n                return b.nodeLineWidth;\n              }).style("stroke", function(b) {\n                return sw.tinyRGB(D5(b.nodeLineColor));\n              }).style("stroke-opacity", function(b) {\n                return sw.opacity(b.nodeLineColor);\n              }).style("fill", function(b) {\n                return b.tinyColorHue;\n              }).style("fill-opacity", function(b) {\n                return b.tinyColorAlpha;\n              }), v3.transition().ease(Nu.ease).duration(Nu.duration).call(KWe);\n              var _2 = d3.selectAll("." + Nu.cn.nodeLabel).data(E7);\n              _2.enter().append("text").classed(Nu.cn.nodeLabel, true).style("cursor", "default"), _2.attr("data-notex", 1).text(function(b) {\n                return b.node.label;\n              }).each(function(b) {\n                var p3 = R5.select(this);\n                qZt.font(p3, b.textFont), YWe.convertToTspans(p3, e3);\n              }).attr("text-anchor", function(b) {\n                return b.horizontal && b.left ? "end" : "start";\n              }).attr("transform", function(b) {\n                var p3 = R5.select(this), k4 = YWe.lineCount(p3), E3 = b.textFont.size * ((k4 - 1) * VZt - UZt), S2 = b.nodeLineWidth / 2 + GZt, L3 = ((b.horizontal ? b.visibleHeight : b.visibleWidth) - E3) / 2;\n                b.horizontal && (b.left ? S2 = -S2 : S2 += b.visibleWidth);\n                var x2 = b.horizontal ? "" : "scale(-1,1)" + BZt(90);\n                return YJ(b.horizontal ? S2 : L3, b.horizontal ? L3 : S2) + x2;\n              }), _2.transition().ease(Nu.ease).duration(Nu.duration);\n            };\n          });\n          var e$ = ye((r2r, pXe) => {\n            "use strict";\n            var Zv = Oa(), QJ = Dr(), k7 = QJ.numberFormat, rYt = oXe(), F5 = vf(), iYt = ka(), Sx = WJ().cn, Qk = QJ._;\n            function sXe(e3) {\n              return e3 !== "";\n            }\n            function z5(e3, t3) {\n              return e3.filter(function(r4) {\n                return r4.key === t3.traceId;\n              });\n            }\n            function lXe(e3, t3) {\n              Zv.select(e3).select("path").style("fill-opacity", t3), Zv.select(e3).select("rect").style("fill-opacity", t3);\n            }\n            function uXe(e3) {\n              Zv.select(e3).select("text.name").style("fill", "black");\n            }\n            function cXe(e3) {\n              return function(t3) {\n                return e3.node.sourceLinks.indexOf(t3.link) !== -1 || e3.node.targetLinks.indexOf(t3.link) !== -1;\n              };\n            }\n            function fXe(e3) {\n              return function(t3) {\n                return t3.node.sourceLinks.indexOf(e3.link) !== -1 || t3.node.targetLinks.indexOf(e3.link) !== -1;\n              };\n            }\n            function hXe(e3, t3, r4) {\n              t3 && r4 && z5(r4, t3).selectAll("." + Sx.sankeyLink).filter(cXe(t3)).call(dXe.bind(0, t3, r4, false));\n            }\n            function $J(e3, t3, r4) {\n              t3 && r4 && z5(r4, t3).selectAll("." + Sx.sankeyLink).filter(cXe(t3)).call(vXe.bind(0, t3, r4, false));\n            }\n            function dXe(e3, t3, r4, n4) {\n              n4.style("fill", function(i3) {\n                if (!i3.link.concentrationscale) return i3.tinyColorHoverHue;\n              }).style("fill-opacity", function(i3) {\n                if (!i3.link.concentrationscale) return i3.tinyColorHoverAlpha;\n              }), n4.each(function(i3) {\n                var a4 = i3.link.label;\n                a4 !== "" && z5(t3, e3).selectAll("." + Sx.sankeyLink).filter(function(o4) {\n                  return o4.link.label === a4;\n                }).style("fill", function(o4) {\n                  if (!o4.link.concentrationscale) return o4.tinyColorHoverHue;\n                }).style("fill-opacity", function(o4) {\n                  if (!o4.link.concentrationscale) return o4.tinyColorHoverAlpha;\n                });\n              }), r4 && z5(t3, e3).selectAll("." + Sx.sankeyNode).filter(fXe(e3)).call(hXe);\n            }\n            function vXe(e3, t3, r4, n4) {\n              n4.style("fill", function(i3) {\n                return i3.tinyColorHue;\n              }).style("fill-opacity", function(i3) {\n                return i3.tinyColorAlpha;\n              }), n4.each(function(i3) {\n                var a4 = i3.link.label;\n                a4 !== "" && z5(t3, e3).selectAll("." + Sx.sankeyLink).filter(function(o4) {\n                  return o4.link.label === a4;\n                }).style("fill", function(o4) {\n                  return o4.tinyColorHue;\n                }).style("fill-opacity", function(o4) {\n                  return o4.tinyColorAlpha;\n                });\n              }), r4 && z5(t3, e3).selectAll(Sx.sankeyNode).filter(fXe(e3)).call($J);\n            }\n            function kf(e3, t3) {\n              var r4 = e3.hoverlabel || {}, n4 = QJ.nestedProperty(r4, t3).get();\n              return Array.isArray(n4) ? false : n4;\n            }\n            pXe.exports = function(t3, r4) {\n              for (var n4 = t3._fullLayout, i3 = n4._paper, a4 = n4._size, o4 = 0; o4 < t3._fullData.length; o4++) if (t3._fullData[o4].visible && t3._fullData[o4].type === Sx.sankey && !t3._fullData[o4]._viewInitial) {\n                var s3 = t3._fullData[o4].node;\n                t3._fullData[o4]._viewInitial = { node: { groups: s3.groups.slice(), x: s3.x.slice(), y: s3.y.slice() } };\n              }\n              var l3 = function(L3, x2) {\n                var C3 = x2.link;\n                C3.originalEvent = Zv.event, t3._hoverdata = [C3], F5.click(t3, { target: true });\n              }, u4 = function(L3, x2, C3) {\n                t3._fullLayout.hovermode !== false && (Zv.select(L3).call(dXe.bind(0, x2, C3, true)), x2.link.trace.link.hoverinfo !== "skip" && (x2.link.fullData = x2.link.trace, t3.emit("plotly_hover", { event: Zv.event, points: [x2.link] })));\n              }, c5 = Qk(t3, "source:") + " ", f4 = Qk(t3, "target:") + " ", h3 = Qk(t3, "concentration:") + " ", d3 = Qk(t3, "incoming flow count:") + " ", v3 = Qk(t3, "outgoing flow count:") + " ", _2 = function(L3, x2) {\n                if (t3._fullLayout.hovermode === false) return;\n                var C3 = x2.link.trace.link;\n                if (C3.hoverinfo === "none" || C3.hoverinfo === "skip") return;\n                var M4 = [];\n                function g3(Z) {\n                  var j3, N2;\n                  Z.circular ? (j3 = (Z.circularPathData.leftInnerExtent + Z.circularPathData.rightInnerExtent) / 2, N2 = Z.circularPathData.verticalFullExtent) : (j3 = (Z.source.x1 + Z.target.x0) / 2, N2 = (Z.y0 + Z.y1) / 2);\n                  var H = [j3, N2];\n                  return Z.trace.orientation === "v" && H.reverse(), H[0] += x2.parent.translateX, H[1] += x2.parent.translateY, H;\n                }\n                for (var P3 = 0, T3 = 0; T3 < x2.flow.links.length; T3++) {\n                  var z3 = x2.flow.links[T3];\n                  if (!(t3._fullLayout.hovermode === "closest" && x2.link.pointNumber !== z3.pointNumber)) {\n                    x2.link.pointNumber === z3.pointNumber && (P3 = T3), z3.fullData = z3.trace, C3 = x2.link.trace.link;\n                    var O3 = g3(z3), V2 = { valueLabel: k7(x2.valueFormat)(z3.value) + x2.valueSuffix };\n                    M4.push({ x: O3[0], y: O3[1], name: V2.valueLabel, text: [z3.label || "", c5 + z3.source.label, f4 + z3.target.label, z3.concentrationscale ? h3 + k7("%0.2f")(z3.flow.labelConcentration) : ""].filter(sXe).join("<br>"), color: kf(C3, "bgcolor") || iYt.addOpacity(z3.color, 1), borderColor: kf(C3, "bordercolor"), fontFamily: kf(C3, "font.family"), fontSize: kf(C3, "font.size"), fontColor: kf(C3, "font.color"), fontWeight: kf(C3, "font.weight"), fontStyle: kf(C3, "font.style"), fontVariant: kf(C3, "font.variant"), fontTextcase: kf(C3, "font.textcase"), fontLineposition: kf(C3, "font.lineposition"), fontShadow: kf(C3, "font.shadow"), nameLength: kf(C3, "namelength"), textAlign: kf(C3, "align"), idealAlign: Zv.event.x < O3[0] ? "right" : "left", hovertemplate: C3.hovertemplate, hovertemplateLabels: V2, eventData: [z3] });\n                  }\n                }\n                var G2 = F5.loneHover(M4, { container: n4._hoverlayer.node(), outerContainer: n4._paper.node(), gd: t3, anchorIndex: P3 });\n                G2.each(function() {\n                  var Z = this;\n                  x2.link.concentrationscale || lXe(Z, 0.65), uXe(Z);\n                });\n              }, b = function(L3, x2, C3) {\n                t3._fullLayout.hovermode !== false && (Zv.select(L3).call(vXe.bind(0, x2, C3, true)), x2.link.trace.link.hoverinfo !== "skip" && (x2.link.fullData = x2.link.trace, t3.emit("plotly_unhover", { event: Zv.event, points: [x2.link] })), F5.loneUnhover(n4._hoverlayer.node()));\n              }, p3 = function(L3, x2, C3) {\n                var M4 = x2.node;\n                M4.originalEvent = Zv.event, t3._hoverdata = [M4], Zv.select(L3).call($J, x2, C3), F5.click(t3, { target: true });\n              }, k4 = function(L3, x2, C3) {\n                t3._fullLayout.hovermode !== false && (Zv.select(L3).call(hXe, x2, C3), x2.node.trace.node.hoverinfo !== "skip" && (x2.node.fullData = x2.node.trace, t3.emit("plotly_hover", { event: Zv.event, points: [x2.node] })));\n              }, E3 = function(L3, x2) {\n                if (t3._fullLayout.hovermode !== false) {\n                  var C3 = x2.node.trace.node;\n                  if (!(C3.hoverinfo === "none" || C3.hoverinfo === "skip")) {\n                    var M4 = Zv.select(L3).select("." + Sx.nodeRect), g3 = t3._fullLayout._paperdiv.node().getBoundingClientRect(), P3 = M4.node().getBoundingClientRect(), T3 = P3.left - 2 - g3.left, z3 = P3.right + 2 - g3.left, O3 = P3.top + P3.height / 4 - g3.top, V2 = { valueLabel: k7(x2.valueFormat)(x2.node.value) + x2.valueSuffix };\n                    x2.node.fullData = x2.node.trace, t3._fullLayout._calcInverseTransform(t3);\n                    var G2 = t3._fullLayout._invScaleX, Z = t3._fullLayout._invScaleY, j3 = F5.loneHover({ x0: G2 * T3, x1: G2 * z3, y: Z * O3, name: k7(x2.valueFormat)(x2.node.value) + x2.valueSuffix, text: [x2.node.label, d3 + x2.node.targetLinks.length, v3 + x2.node.sourceLinks.length].filter(sXe).join("<br>"), color: kf(C3, "bgcolor") || x2.tinyColorHue, borderColor: kf(C3, "bordercolor"), fontFamily: kf(C3, "font.family"), fontSize: kf(C3, "font.size"), fontColor: kf(C3, "font.color"), fontWeight: kf(C3, "font.weight"), fontStyle: kf(C3, "font.style"), fontVariant: kf(C3, "font.variant"), fontTextcase: kf(C3, "font.textcase"), fontLineposition: kf(C3, "font.lineposition"), fontShadow: kf(C3, "font.shadow"), nameLength: kf(C3, "namelength"), textAlign: kf(C3, "align"), idealAlign: "left", hovertemplate: C3.hovertemplate, hovertemplateLabels: V2, eventData: [x2.node] }, { container: n4._hoverlayer.node(), outerContainer: n4._paper.node(), gd: t3 });\n                    lXe(j3, 0.85), uXe(j3);\n                  }\n                }\n              }, S2 = function(L3, x2, C3) {\n                t3._fullLayout.hovermode !== false && (Zv.select(L3).call($J, x2, C3), x2.node.trace.node.hoverinfo !== "skip" && (x2.node.fullData = x2.node.trace, t3.emit("plotly_unhover", { event: Zv.event, points: [x2.node] })), F5.loneUnhover(n4._hoverlayer.node()));\n              };\n              rYt(t3, i3, r4, { width: a4.w, height: a4.h, margin: { t: a4.t, r: a4.r, b: a4.b, l: a4.l } }, { linkEvents: { hover: u4, follow: _2, unhover: b, select: l3 }, nodeEvents: { hover: k4, follow: E3, unhover: S2, select: p3 } });\n            };\n          });\n          var gXe = ye((lw) => {\n            "use strict";\n            var nYt = mc().overrideAll, aYt = Id().getModuleCalcData, oYt = e$(), sYt = B1(), lYt = Sg(), uYt = yv(), cYt = Of().prepSelect, t$ = Dr(), fYt = qa(), C7 = "sankey";\n            lw.name = C7;\n            lw.baseLayoutAttrOverrides = nYt({ hoverlabel: sYt.hoverlabel }, "plot", "nested");\n            lw.plot = function(e3) {\n              var t3 = aYt(e3.calcdata, C7)[0];\n              oYt(e3, t3), lw.updateFx(e3);\n            };\n            lw.clean = function(e3, t3, r4, n4) {\n              var i3 = n4._has && n4._has(C7), a4 = t3._has && t3._has(C7);\n              i3 && !a4 && (n4._paperdiv.selectAll(".sankey").remove(), n4._paperdiv.selectAll(".bgsankey").remove());\n            };\n            lw.updateFx = function(e3) {\n              for (var t3 = 0; t3 < e3._fullData.length; t3++) hYt(e3, t3);\n            };\n            function hYt(e3, t3) {\n              var r4 = e3._fullData[t3], n4 = e3._fullLayout, i3 = n4.dragmode, a4 = n4.dragmode === "pan" ? "move" : "crosshair", o4 = r4._bgRect;\n              if (o4 && !(i3 === "pan" || i3 === "zoom")) {\n                lYt(o4, a4);\n                var s3 = { _id: "x", c2p: t$.identity, _offset: r4._sankey.translateX, _length: r4._sankey.width }, l3 = { _id: "y", c2p: t$.identity, _offset: r4._sankey.translateY, _length: r4._sankey.height }, u4 = { gd: e3, element: o4.node(), plotinfo: { id: t3, xaxis: s3, yaxis: l3, fillRangeItems: t$.noop }, subplot: t3, xaxes: [s3], yaxes: [l3], doneFnCompleted: function(c5) {\n                  var f4 = e3._fullData[t3], h3, d3 = f4.node.groups.slice(), v3 = [];\n                  function _2(E3) {\n                    for (var S2 = f4._sankey.graph.nodes, L3 = 0; L3 < S2.length; L3++) if (S2[L3].pointNumber === E3) return S2[L3];\n                  }\n                  for (var b = 0; b < c5.length; b++) {\n                    var p3 = _2(c5[b].pointNumber);\n                    if (p3) if (p3.group) {\n                      for (var k4 = 0; k4 < p3.childrenNodes.length; k4++) v3.push(p3.childrenNodes[k4].pointNumber);\n                      d3[p3.pointNumber - f4.node._count] = false;\n                    } else v3.push(p3.pointNumber);\n                  }\n                  h3 = d3.filter(Boolean).concat([v3]), fYt.call("_guiRestyle", e3, { "node.groups": [h3] }, t3);\n                } };\n                u4.prepFn = function(c5, f4, h3) {\n                  cYt(c5, f4, h3, u4, i3);\n                }, uYt.init(u4);\n              }\n            }\n          });\n          var yXe = ye((n2r, mXe) => {\n            "use strict";\n            mXe.exports = function(t3, r4) {\n              for (var n4 = t3.cd, i3 = [], a4 = n4[0].trace, o4 = a4._sankey.graph.nodes, s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3];\n                if (!l3.partOfGroup) {\n                  var u4 = [(l3.x0 + l3.x1) / 2, (l3.y0 + l3.y1) / 2];\n                  a4.orientation === "v" && u4.reverse(), r4 && r4.contains(u4, false, s3, t3) && i3.push({ pointNumber: l3.pointNumber });\n                }\n              }\n              return i3;\n            };\n          });\n          var xXe = ye((a2r, _Xe) => {\n            "use strict";\n            _Xe.exports = { attributes: GJ(), supplyDefaults: TWe(), calc: kWe(), plot: e$(), moduleType: "trace", name: "sankey", basePlotModule: gXe(), selectPoints: yXe(), categories: ["noOpacity"], meta: {} };\n          });\n          var wXe = ye((o2r, bXe) => {\n            "use strict";\n            bXe.exports = xXe();\n          });\n          var AXe = ye((O5) => {\n            "use strict";\n            var TXe = Mc();\n            O5.name = "indicator";\n            O5.plot = function(e3, t3, r4, n4) {\n              TXe.plotBasePlot(O5.name, e3, t3, r4, n4);\n            };\n            O5.clean = function(e3, t3, r4, n4) {\n              TXe.cleanBasePlot(O5.name, e3, t3, r4, n4);\n            };\n          });\n          var i$ = ye((l2r, LXe) => {\n            "use strict";\n            var Mx = Ao().extendFlat, MXe = Ao().extendDeep, dYt = mc().overrideAll, EXe = ec(), kXe = Lh(), vYt = Cc().attributes, Bf = Rd(), pYt = vl().templatedArray, L7 = XT(), SXe = df().descriptionOnlyNumbers, r$ = EXe({ editType: "plot", colorEditType: "plot" }), eC = { color: { valType: "color", editType: "plot" }, line: { color: { valType: "color", dflt: kXe.defaultLine, editType: "plot" }, width: { valType: "number", min: 0, dflt: 0, editType: "plot" }, editType: "calc" }, thickness: { valType: "number", min: 0, max: 1, dflt: 1, editType: "plot" }, editType: "calc" }, CXe = { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], editType: "plot" }, gYt = pYt("step", MXe({}, eC, { range: CXe }));\n            LXe.exports = { mode: { valType: "flaglist", editType: "calc", flags: ["number", "delta", "gauge"], dflt: "number" }, value: { valType: "number", editType: "calc", anim: true }, align: { valType: "enumerated", values: ["left", "center", "right"], editType: "plot" }, domain: vYt({ name: "indicator", trace: true, editType: "calc" }), title: { text: { valType: "string", editType: "plot" }, align: { valType: "enumerated", values: ["left", "center", "right"], editType: "plot" }, font: Mx({}, r$, {}), editType: "plot" }, number: { valueformat: { valType: "string", dflt: "", editType: "plot", description: SXe("value") }, font: Mx({}, r$, {}), prefix: { valType: "string", dflt: "", editType: "plot" }, suffix: { valType: "string", dflt: "", editType: "plot" }, editType: "plot" }, delta: { reference: { valType: "number", editType: "calc" }, position: { valType: "enumerated", values: ["top", "bottom", "left", "right"], dflt: "bottom", editType: "plot" }, relative: { valType: "boolean", editType: "plot", dflt: false }, valueformat: { valType: "string", editType: "plot", description: SXe("value") }, increasing: { symbol: { valType: "string", dflt: L7.INCREASING.SYMBOL, editType: "plot" }, color: { valType: "color", dflt: L7.INCREASING.COLOR, editType: "plot" }, editType: "plot" }, decreasing: { symbol: { valType: "string", dflt: L7.DECREASING.SYMBOL, editType: "plot" }, color: { valType: "color", dflt: L7.DECREASING.COLOR, editType: "plot" }, editType: "plot" }, font: Mx({}, r$, {}), prefix: { valType: "string", dflt: "", editType: "plot" }, suffix: { valType: "string", dflt: "", editType: "plot" }, editType: "calc" }, gauge: { shape: { valType: "enumerated", editType: "plot", dflt: "angular", values: ["angular", "bullet"] }, bar: MXe({}, eC, { color: { dflt: "green" } }), bgcolor: { valType: "color", editType: "plot" }, bordercolor: { valType: "color", dflt: kXe.defaultLine, editType: "plot" }, borderwidth: { valType: "number", min: 0, dflt: 1, editType: "plot" }, axis: dYt({ range: CXe, visible: Mx({}, Bf.visible, { dflt: true }), tickmode: Bf.minor.tickmode, nticks: Bf.nticks, tick0: Bf.tick0, dtick: Bf.dtick, tickvals: Bf.tickvals, ticktext: Bf.ticktext, ticks: Mx({}, Bf.ticks, { dflt: "outside" }), ticklen: Bf.ticklen, tickwidth: Bf.tickwidth, tickcolor: Bf.tickcolor, ticklabelstep: Bf.ticklabelstep, showticklabels: Bf.showticklabels, labelalias: Bf.labelalias, tickfont: EXe({}), tickangle: Bf.tickangle, tickformat: Bf.tickformat, tickformatstops: Bf.tickformatstops, tickprefix: Bf.tickprefix, showtickprefix: Bf.showtickprefix, ticksuffix: Bf.ticksuffix, showticksuffix: Bf.showticksuffix, separatethousands: Bf.separatethousands, exponentformat: Bf.exponentformat, minexponent: Bf.minexponent, showexponent: Bf.showexponent, editType: "plot" }, "plot"), steps: gYt, threshold: { line: { color: Mx({}, eC.line.color, {}), width: Mx({}, eC.line.width, { dflt: 1 }), editType: "plot" }, thickness: Mx({}, eC.thickness, { dflt: 0.85 }), value: { valType: "number", editType: "calc", dflt: false }, editType: "plot" }, editType: "plot" } };\n          });\n          var n$ = ye((u2r, PXe) => {\n            "use strict";\n            PXe.exports = { defaultNumberFontSize: 80, bulletNumberDomainSize: 0.25, bulletPadding: 0.025, innerRadius: 0.75, valueThickness: 0.5, titlePadding: 5, horizontalPadding: 10 };\n          });\n          var DXe = ye((c2r, RXe) => {\n            "use strict";\n            var ty = Dr(), I7 = i$(), mYt = Cc().defaults, IXe = vl(), yYt = Yd(), P7 = n$(), _Yt = bb(), xYt = M3(), bYt = e_(), wYt = t_();\n            function TYt(e3, t3, r4, n4) {\n              function i3(x2, C3) {\n                return ty.coerce(e3, t3, I7, x2, C3);\n              }\n              mYt(t3, n4, i3), i3("mode"), t3._hasNumber = t3.mode.indexOf("number") !== -1, t3._hasDelta = t3.mode.indexOf("delta") !== -1, t3._hasGauge = t3.mode.indexOf("gauge") !== -1;\n              var a4 = i3("value");\n              t3._range = [0, typeof a4 == "number" ? 1.5 * a4 : 1];\n              var o4 = new Array(2), s3;\n              if (t3._hasNumber) {\n                i3("number.valueformat");\n                var l3 = ty.extendFlat({}, n4.font);\n                l3.size = void 0, ty.coerceFont(i3, "number.font", l3), t3.number.font.size === void 0 && (t3.number.font.size = P7.defaultNumberFontSize, o4[0] = true), i3("number.prefix"), i3("number.suffix"), s3 = t3.number.font.size;\n              }\n              var u4;\n              if (t3._hasDelta) {\n                var c5 = ty.extendFlat({}, n4.font);\n                c5.size = void 0, ty.coerceFont(i3, "delta.font", c5), t3.delta.font.size === void 0 && (t3.delta.font.size = (t3._hasNumber ? 0.5 : 1) * (s3 || P7.defaultNumberFontSize), o4[1] = true), i3("delta.reference", t3.value), i3("delta.relative"), i3("delta.valueformat", t3.delta.relative ? "2%" : ""), i3("delta.increasing.symbol"), i3("delta.increasing.color"), i3("delta.decreasing.symbol"), i3("delta.decreasing.color"), i3("delta.position"), i3("delta.prefix"), i3("delta.suffix"), u4 = t3.delta.font.size;\n              }\n              t3._scaleNumbers = (!t3._hasNumber || o4[0]) && (!t3._hasDelta || o4[1]) || false;\n              var f4 = ty.extendFlat({}, n4.font);\n              f4.size = 0.25 * (s3 || u4 || P7.defaultNumberFontSize), ty.coerceFont(i3, "title.font", f4), i3("title.text");\n              var h3, d3, v3, _2;\n              function b(x2, C3) {\n                return ty.coerce(h3, d3, I7.gauge, x2, C3);\n              }\n              function p3(x2, C3) {\n                return ty.coerce(v3, _2, I7.gauge.axis, x2, C3);\n              }\n              if (t3._hasGauge) {\n                h3 = e3.gauge, h3 || (h3 = {}), d3 = IXe.newContainer(t3, "gauge"), b("shape");\n                var k4 = t3._isBullet = t3.gauge.shape === "bullet";\n                k4 || i3("title.align", "center");\n                var E3 = t3._isAngular = t3.gauge.shape === "angular";\n                E3 || i3("align", "center"), b("bgcolor", n4.paper_bgcolor), b("borderwidth"), b("bordercolor"), b("bar.color"), b("bar.line.color"), b("bar.line.width");\n                var S2 = P7.valueThickness * (t3.gauge.shape === "bullet" ? 0.5 : 1);\n                b("bar.thickness", S2), yYt(h3, d3, { name: "steps", handleItemDefaults: AYt }), b("threshold.value"), b("threshold.thickness"), b("threshold.line.width"), b("threshold.line.color"), v3 = {}, h3 && (v3 = h3.axis || {}), _2 = IXe.newContainer(d3, "axis"), p3("visible"), t3._range = p3("range", t3._range);\n                var L3 = { font: n4.font, noAutotickangles: true, outerTicks: true, noTicklabelshift: true, noTicklabelstandoff: true };\n                _Yt(v3, _2, p3, "linear"), wYt(v3, _2, p3, "linear", L3), bYt(v3, _2, p3, "linear", L3), xYt(v3, _2, p3, L3);\n              } else i3("title.align", "center"), i3("align", "center"), t3._isAngular = t3._isBullet = false;\n              t3._length = null;\n            }\n            function AYt(e3, t3) {\n              function r4(n4, i3) {\n                return ty.coerce(e3, t3, I7.gauge.steps, n4, i3);\n              }\n              r4("color"), r4("line.color"), r4("line.width"), r4("range"), r4("thickness");\n            }\n            RXe.exports = { supplyDefaults: TYt };\n          });\n          var zXe = ye((f2r, FXe) => {\n            "use strict";\n            function SYt(e3, t3) {\n              var r4 = [], n4 = t3.value;\n              typeof t3._lastValue != "number" && (t3._lastValue = t3.value);\n              var i3 = t3._lastValue, a4 = i3;\n              return t3._hasDelta && typeof t3.delta.reference == "number" && (a4 = t3.delta.reference), r4[0] = { y: n4, lastY: i3, delta: n4 - a4, relativeDelta: (n4 - a4) / a4 }, r4;\n            }\n            FXe.exports = { calc: SYt };\n          });\n          var VXe = ye((h2r, UXe) => {\n            "use strict";\n            var dw = Oa(), MYt = (F2(), ob(D22)).interpolate, OXe = (F2(), ob(D22)).interpolateNumber, Ex = Dr(), EYt = Ex.strScale, rC = Ex.strTranslate, kYt = Ex.rad2deg, CYt = $h().MID_SHIFT, hw = So(), uw = n$(), D7 = ru(), sv = ho(), LYt = i4(), PYt = uI(), IYt = Rd(), q5 = ka(), a$ = { left: "start", center: "middle", right: "end" }, cw = { left: 0, center: 0.5, right: 1 }, qXe = /[yzafpn\xB5mkMGTPEZY]/;\n            function iC(e3) {\n              return e3 && e3.duration > 0;\n            }\n            UXe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._fullLayout, o4;\n              iC(n4) && i3 && (o4 = i3()), Ex.makeTraceGroups(a4._indicatorlayer, r4, "trace").each(function(s3) {\n                var l3 = s3[0], u4 = l3.trace, c5 = dw.select(this), f4 = u4._hasGauge, h3 = u4._isAngular, d3 = u4._isBullet, v3 = u4.domain, _2 = { w: a4._size.w * (v3.x[1] - v3.x[0]), h: a4._size.h * (v3.y[1] - v3.y[0]), l: a4._size.l + a4._size.w * v3.x[0], r: a4._size.r + a4._size.w * (1 - v3.x[1]), t: a4._size.t + a4._size.h * (1 - v3.y[1]), b: a4._size.b + a4._size.h * v3.y[0] }, b = _2.l + _2.w / 2, p3 = _2.t + _2.h / 2, k4 = Math.min(_2.w / 2, _2.h), E3 = uw.innerRadius * k4, S2, L3, x2, C3 = u4.align || "center";\n                if (L3 = p3, !f4) S2 = _2.l + cw[C3] * _2.w, x2 = function(j3) {\n                  return BXe(j3, _2.w, _2.h);\n                };\n                else if (h3 && (S2 = b, L3 = p3 + k4 / 2, x2 = function(j3) {\n                  return OYt(j3, 0.9 * E3);\n                }), d3) {\n                  var M4 = uw.bulletPadding, g3 = 1 - uw.bulletNumberDomainSize + M4;\n                  S2 = _2.l + (g3 + (1 - g3) * cw[C3]) * _2.w, x2 = function(j3) {\n                    return BXe(j3, (uw.bulletNumberDomainSize - M4) * _2.w, _2.h);\n                  };\n                }\n                FYt(t3, c5, s3, { numbersX: S2, numbersY: L3, numbersScaler: x2, transitionOpts: n4, onComplete: o4 });\n                var P3, T3;\n                f4 && (P3 = { range: u4.gauge.axis.range, color: u4.gauge.bgcolor, line: { color: u4.gauge.bordercolor, width: 0 }, thickness: 1 }, T3 = { range: u4.gauge.axis.range, color: "rgba(0, 0, 0, 0)", line: { color: u4.gauge.bordercolor, width: u4.gauge.borderwidth }, thickness: 1 });\n                var z3 = c5.selectAll("g.angular").data(h3 ? s3 : []);\n                z3.exit().remove();\n                var O3 = c5.selectAll("g.angularaxis").data(h3 ? s3 : []);\n                O3.exit().remove(), h3 && DYt(t3, c5, s3, { radius: k4, innerRadius: E3, gauge: z3, layer: O3, size: _2, gaugeBg: P3, gaugeOutline: T3, transitionOpts: n4, onComplete: o4 });\n                var V2 = c5.selectAll("g.bullet").data(d3 ? s3 : []);\n                V2.exit().remove();\n                var G2 = c5.selectAll("g.bulletaxis").data(d3 ? s3 : []);\n                G2.exit().remove(), d3 && RYt(t3, c5, s3, { gauge: V2, layer: G2, size: _2, gaugeBg: P3, gaugeOutline: T3, transitionOpts: n4, onComplete: o4 });\n                var Z = c5.selectAll("text.title").data(s3);\n                Z.exit().remove(), Z.enter().append("text").classed("title", true), Z.attr("text-anchor", function() {\n                  return d3 ? a$.right : a$[u4.title.align];\n                }).text(u4.title.text).call(hw.font, u4.title.font).call(D7.convertToTspans, t3), Z.attr("transform", function() {\n                  var j3 = _2.l + _2.w * cw[u4.title.align], N2, H = uw.titlePadding, te = hw.bBox(Z.node());\n                  if (f4) {\n                    if (h3) if (u4.gauge.axis.visible) {\n                      var oe = hw.bBox(O3.node());\n                      N2 = oe.top - H - te.bottom;\n                    } else N2 = _2.t + _2.h / 2 - k4 / 2 - te.bottom - H;\n                    d3 && (N2 = L3 - (te.top + te.bottom) / 2, j3 = _2.l - uw.bulletPadding * _2.w);\n                  } else N2 = u4._numbersTop - H - te.bottom;\n                  return rC(j3, N2);\n                });\n              });\n            };\n            function RYt(e3, t3, r4, n4) {\n              var i3 = r4[0].trace, a4 = n4.gauge, o4 = n4.layer, s3 = n4.gaugeBg, l3 = n4.gaugeOutline, u4 = n4.size, c5 = i3.domain, f4 = n4.transitionOpts, h3 = n4.onComplete, d3, v3, _2, b, p3;\n              a4.enter().append("g").classed("bullet", true), a4.attr("transform", rC(u4.l, u4.t)), o4.enter().append("g").classed("bulletaxis", true).classed("crisp", true), o4.selectAll("g.xbulletaxistick,path,text").remove();\n              var k4 = u4.h, E3 = i3.gauge.bar.thickness * k4, S2 = c5.x[0], L3 = c5.x[0] + (c5.x[1] - c5.x[0]) * (i3._hasNumber || i3._hasDelta ? 1 - uw.bulletNumberDomainSize : 1);\n              d3 = tC(e3, i3.gauge.axis), d3._id = "xbulletaxis", d3.domain = [S2, L3], d3.setScale(), v3 = sv.calcTicks(d3), _2 = sv.makeTransTickFn(d3), b = sv.getTickSigns(d3)[2], p3 = u4.t + u4.h, d3.visible && (sv.drawTicks(e3, d3, { vals: d3.ticks === "inside" ? sv.clipEnds(d3, v3) : v3, layer: o4, path: sv.makeTickPath(d3, p3, b), transFn: _2 }), sv.drawLabels(e3, d3, { vals: v3, layer: o4, transFn: _2, labelFns: sv.makeLabelFns(d3, p3) }));\n              function x2(O3) {\n                O3.attr("width", function(V2) {\n                  return Math.max(0, d3.c2p(V2.range[1]) - d3.c2p(V2.range[0]));\n                }).attr("x", function(V2) {\n                  return d3.c2p(V2.range[0]);\n                }).attr("y", function(V2) {\n                  return 0.5 * (1 - V2.thickness) * k4;\n                }).attr("height", function(V2) {\n                  return V2.thickness * k4;\n                });\n              }\n              var C3 = [s3].concat(i3.gauge.steps), M4 = a4.selectAll("g.bg-bullet").data(C3);\n              M4.enter().append("g").classed("bg-bullet", true).append("rect"), M4.select("rect").call(x2).call(fw), M4.exit().remove();\n              var g3 = a4.selectAll("g.value-bullet").data([i3.gauge.bar]);\n              g3.enter().append("g").classed("value-bullet", true).append("rect"), g3.select("rect").attr("height", E3).attr("y", (k4 - E3) / 2).call(fw), iC(f4) ? g3.select("rect").transition().duration(f4.duration).ease(f4.easing).each("end", function() {\n                h3 && h3();\n              }).each("interrupt", function() {\n                h3 && h3();\n              }).attr("width", Math.max(0, d3.c2p(Math.min(i3.gauge.axis.range[1], r4[0].y)))) : g3.select("rect").attr("width", typeof r4[0].y == "number" ? Math.max(0, d3.c2p(Math.min(i3.gauge.axis.range[1], r4[0].y))) : 0), g3.exit().remove();\n              var P3 = r4.filter(function() {\n                return i3.gauge.threshold.value || i3.gauge.threshold.value === 0;\n              }), T3 = a4.selectAll("g.threshold-bullet").data(P3);\n              T3.enter().append("g").classed("threshold-bullet", true).append("line"), T3.select("line").attr("x1", d3.c2p(i3.gauge.threshold.value)).attr("x2", d3.c2p(i3.gauge.threshold.value)).attr("y1", (1 - i3.gauge.threshold.thickness) / 2 * k4).attr("y2", (1 - (1 - i3.gauge.threshold.thickness) / 2) * k4).call(q5.stroke, i3.gauge.threshold.line.color).style("stroke-width", i3.gauge.threshold.line.width), T3.exit().remove();\n              var z3 = a4.selectAll("g.gauge-outline").data([l3]);\n              z3.enter().append("g").classed("gauge-outline", true).append("rect"), z3.select("rect").call(x2).call(fw), z3.exit().remove();\n            }\n            function DYt(e3, t3, r4, n4) {\n              var i3 = r4[0].trace, a4 = n4.size, o4 = n4.radius, s3 = n4.innerRadius, l3 = n4.gaugeBg, u4 = n4.gaugeOutline, c5 = [a4.l + a4.w / 2, a4.t + a4.h / 2 + o4 / 2], f4 = n4.gauge, h3 = n4.layer, d3 = n4.transitionOpts, v3 = n4.onComplete, _2 = Math.PI / 2;\n              function b(_e) {\n                var Ee = i3.gauge.axis.range[0], Ce = i3.gauge.axis.range[1], me = (_e - Ee) / (Ce - Ee) * Math.PI - _2;\n                return me < -_2 ? -_2 : me > _2 ? _2 : me;\n              }\n              function p3(_e) {\n                return dw.svg.arc().innerRadius((s3 + o4) / 2 - _e / 2 * (o4 - s3)).outerRadius((s3 + o4) / 2 + _e / 2 * (o4 - s3)).startAngle(-_2);\n              }\n              function k4(_e) {\n                _e.attr("d", function(Ee) {\n                  return p3(Ee.thickness).startAngle(b(Ee.range[0])).endAngle(b(Ee.range[1]))();\n                });\n              }\n              var E3, S2, L3, x2;\n              f4.enter().append("g").classed("angular", true), f4.attr("transform", rC(c5[0], c5[1])), h3.enter().append("g").classed("angularaxis", true).classed("crisp", true), h3.selectAll("g.xangularaxistick,path,text").remove(), E3 = tC(e3, i3.gauge.axis), E3.type = "linear", E3.range = i3.gauge.axis.range, E3._id = "xangularaxis", E3.ticklabeloverflow = "allow", E3.setScale();\n              var C3 = function(_e) {\n                return (E3.range[0] - _e.x) / (E3.range[1] - E3.range[0]) * Math.PI + Math.PI;\n              }, M4 = {}, g3 = sv.makeLabelFns(E3, 0), P3 = g3.labelStandoff;\n              M4.xFn = function(_e) {\n                var Ee = C3(_e);\n                return Math.cos(Ee) * P3;\n              }, M4.yFn = function(_e) {\n                var Ee = C3(_e), Ce = Math.sin(Ee) > 0 ? 0.2 : 1;\n                return -Math.sin(Ee) * (P3 + _e.fontSize * Ce) + Math.abs(Math.cos(Ee)) * (_e.fontSize * CYt);\n              }, M4.anchorFn = function(_e) {\n                var Ee = C3(_e), Ce = Math.cos(Ee);\n                return Math.abs(Ce) < 0.1 ? "middle" : Ce > 0 ? "start" : "end";\n              }, M4.heightFn = function(_e, Ee, Ce) {\n                var me = C3(_e);\n                return -0.5 * (1 + Math.sin(me)) * Ce;\n              };\n              var T3 = function(_e) {\n                return rC(c5[0] + o4 * Math.cos(_e), c5[1] - o4 * Math.sin(_e));\n              };\n              L3 = function(_e) {\n                return T3(C3(_e));\n              };\n              var z3 = function(_e) {\n                var Ee = C3(_e);\n                return T3(Ee) + "rotate(" + -kYt(Ee) + ")";\n              };\n              if (S2 = sv.calcTicks(E3), x2 = sv.getTickSigns(E3)[2], E3.visible) {\n                x2 = E3.ticks === "inside" ? -1 : 1;\n                var O3 = (E3.linewidth || 1) / 2;\n                sv.drawTicks(e3, E3, { vals: S2, layer: h3, path: "M" + x2 * O3 + ",0h" + x2 * E3.ticklen, transFn: z3 }), sv.drawLabels(e3, E3, { vals: S2, layer: h3, transFn: L3, labelFns: M4 });\n              }\n              var V2 = [l3].concat(i3.gauge.steps), G2 = f4.selectAll("g.bg-arc").data(V2);\n              G2.enter().append("g").classed("bg-arc", true).append("path"), G2.select("path").call(k4).call(fw), G2.exit().remove();\n              var Z = p3(i3.gauge.bar.thickness), j3 = f4.selectAll("g.value-arc").data([i3.gauge.bar]);\n              j3.enter().append("g").classed("value-arc", true).append("path");\n              var N2 = j3.select("path");\n              iC(d3) ? (N2.transition().duration(d3.duration).ease(d3.easing).each("end", function() {\n                v3 && v3();\n              }).each("interrupt", function() {\n                v3 && v3();\n              }).attrTween("d", zYt(Z, b(r4[0].lastY), b(r4[0].y))), i3._lastValue = r4[0].y) : N2.attr("d", typeof r4[0].y == "number" ? Z.endAngle(b(r4[0].y)) : "M0,0Z"), N2.call(fw), j3.exit().remove(), V2 = [];\n              var H = i3.gauge.threshold.value;\n              (H || H === 0) && V2.push({ range: [H, H], color: i3.gauge.threshold.color, line: { color: i3.gauge.threshold.line.color, width: i3.gauge.threshold.line.width }, thickness: i3.gauge.threshold.thickness });\n              var te = f4.selectAll("g.threshold-arc").data(V2);\n              te.enter().append("g").classed("threshold-arc", true).append("path"), te.select("path").call(k4).call(fw), te.exit().remove();\n              var oe = f4.selectAll("g.gauge-outline").data([u4]);\n              oe.enter().append("g").classed("gauge-outline", true).append("path"), oe.select("path").call(k4).call(fw), oe.exit().remove();\n            }\n            function FYt(e3, t3, r4, n4) {\n              var i3 = r4[0].trace, a4 = n4.numbersX, o4 = n4.numbersY, s3 = i3.align || "center", l3 = a$[s3], u4 = n4.transitionOpts, c5 = n4.onComplete, f4 = Ex.ensureSingle(t3, "g", "numbers"), h3, d3, v3, _2 = [];\n              i3._hasNumber && _2.push("number"), i3._hasDelta && (_2.push("delta"), i3.delta.position === "left" && _2.reverse());\n              var b = f4.selectAll("text").data(_2);\n              b.enter().append("text"), b.attr("text-anchor", function() {\n                return l3;\n              }).attr("class", function(T3) {\n                return T3;\n              }).attr("x", null).attr("y", null).attr("dx", null).attr("dy", null), b.exit().remove();\n              function p3(T3, z3, O3, V2) {\n                if (T3.match("s") && O3 >= 0 != V2 >= 0 && !z3(O3).slice(-1).match(qXe) && !z3(V2).slice(-1).match(qXe)) {\n                  var G2 = T3.slice().replace("s", "f").replace(/\\d+/, function(j3) {\n                    return parseInt(j3) - 1;\n                  }), Z = tC(e3, { tickformat: G2 });\n                  return function(j3) {\n                    return Math.abs(j3) < 1 ? sv.tickText(Z, j3).text : z3(j3);\n                  };\n                } else return z3;\n              }\n              function k4() {\n                var T3 = tC(e3, { tickformat: i3.number.valueformat }, i3._range);\n                T3.setScale(), sv.prepTicks(T3);\n                var z3 = function(j3) {\n                  return sv.tickText(T3, j3).text;\n                }, O3 = i3.number.suffix, V2 = i3.number.prefix, G2 = f4.select("text.number");\n                function Z() {\n                  var j3 = typeof r4[0].y == "number" ? V2 + z3(r4[0].y) + O3 : "-";\n                  G2.text(j3).call(hw.font, i3.number.font).call(D7.convertToTspans, e3);\n                }\n                return iC(u4) ? G2.transition().duration(u4.duration).ease(u4.easing).each("end", function() {\n                  Z(), c5 && c5();\n                }).each("interrupt", function() {\n                  Z(), c5 && c5();\n                }).attrTween("text", function() {\n                  var j3 = dw.select(this), N2 = OXe(r4[0].lastY, r4[0].y);\n                  i3._lastValue = r4[0].y;\n                  var H = p3(i3.number.valueformat, z3, r4[0].lastY, r4[0].y);\n                  return function(te) {\n                    j3.text(V2 + H(N2(te)) + O3);\n                  };\n                }) : Z(), h3 = NXe(V2 + z3(r4[0].y) + O3, i3.number.font, l3, e3), G2;\n              }\n              function E3() {\n                var T3 = tC(e3, { tickformat: i3.delta.valueformat }, i3._range);\n                T3.setScale(), sv.prepTicks(T3);\n                var z3 = function(te) {\n                  return sv.tickText(T3, te).text;\n                }, O3 = i3.delta.suffix, V2 = i3.delta.prefix, G2 = function(te) {\n                  var oe = i3.delta.relative ? te.relativeDelta : te.delta;\n                  return oe;\n                }, Z = function(te, oe) {\n                  return te === 0 || typeof te != "number" || isNaN(te) ? "-" : (te > 0 ? i3.delta.increasing.symbol : i3.delta.decreasing.symbol) + V2 + oe(te) + O3;\n                }, j3 = function(te) {\n                  return te.delta >= 0 ? i3.delta.increasing.color : i3.delta.decreasing.color;\n                };\n                i3._deltaLastValue === void 0 && (i3._deltaLastValue = G2(r4[0]));\n                var N2 = f4.select("text.delta");\n                N2.call(hw.font, i3.delta.font).call(q5.fill, j3({ delta: i3._deltaLastValue }));\n                function H() {\n                  N2.text(Z(G2(r4[0]), z3)).call(q5.fill, j3(r4[0])).call(D7.convertToTspans, e3);\n                }\n                return iC(u4) ? N2.transition().duration(u4.duration).ease(u4.easing).tween("text", function() {\n                  var te = dw.select(this), oe = G2(r4[0]), _e = i3._deltaLastValue, Ee = p3(i3.delta.valueformat, z3, _e, oe), Ce = OXe(_e, oe);\n                  return i3._deltaLastValue = oe, function(me) {\n                    te.text(Z(Ce(me), Ee)), te.call(q5.fill, j3({ delta: Ce(me) }));\n                  };\n                }).each("end", function() {\n                  H(), c5 && c5();\n                }).each("interrupt", function() {\n                  H(), c5 && c5();\n                }) : H(), d3 = NXe(Z(G2(r4[0]), z3), i3.delta.font, l3, e3), N2;\n              }\n              var S2 = i3.mode + i3.align, L3;\n              if (i3._hasDelta && (L3 = E3(), S2 += i3.delta.position + i3.delta.font.size + i3.delta.font.family + i3.delta.valueformat, S2 += i3.delta.increasing.symbol + i3.delta.decreasing.symbol, v3 = d3), i3._hasNumber && (k4(), S2 += i3.number.font.size + i3.number.font.family + i3.number.valueformat + i3.number.suffix + i3.number.prefix, v3 = h3), i3._hasDelta && i3._hasNumber) {\n                var x2 = [(h3.left + h3.right) / 2, (h3.top + h3.bottom) / 2], C3 = [(d3.left + d3.right) / 2, (d3.top + d3.bottom) / 2], M4, g3, P3 = 0.75 * i3.delta.font.size;\n                i3.delta.position === "left" && (M4 = R7(i3, "deltaPos", 0, -1 * (h3.width * cw[i3.align] + d3.width * (1 - cw[i3.align]) + P3), S2, Math.min), g3 = x2[1] - C3[1], v3 = { width: h3.width + d3.width + P3, height: Math.max(h3.height, d3.height), left: d3.left + M4, right: h3.right, top: Math.min(h3.top, d3.top + g3), bottom: Math.max(h3.bottom, d3.bottom + g3) }), i3.delta.position === "right" && (M4 = R7(i3, "deltaPos", 0, h3.width * (1 - cw[i3.align]) + d3.width * cw[i3.align] + P3, S2, Math.max), g3 = x2[1] - C3[1], v3 = { width: h3.width + d3.width + P3, height: Math.max(h3.height, d3.height), left: h3.left, right: d3.right + M4, top: Math.min(h3.top, d3.top + g3), bottom: Math.max(h3.bottom, d3.bottom + g3) }), i3.delta.position === "bottom" && (M4 = null, g3 = d3.height, v3 = { width: Math.max(h3.width, d3.width), height: h3.height + d3.height, left: Math.min(h3.left, d3.left), right: Math.max(h3.right, d3.right), top: h3.bottom - h3.height, bottom: h3.bottom + d3.height }), i3.delta.position === "top" && (M4 = null, g3 = h3.top, v3 = { width: Math.max(h3.width, d3.width), height: h3.height + d3.height, left: Math.min(h3.left, d3.left), right: Math.max(h3.right, d3.right), top: h3.bottom - h3.height - d3.height, bottom: h3.bottom }), L3.attr({ dx: M4, dy: g3 });\n              }\n              (i3._hasNumber || i3._hasDelta) && f4.attr("transform", function() {\n                var T3 = n4.numbersScaler(v3);\n                S2 += T3[2];\n                var z3 = R7(i3, "numbersScale", 1, T3[0], S2, Math.min), O3;\n                i3._scaleNumbers || (z3 = 1), i3._isAngular ? O3 = o4 - z3 * v3.bottom : O3 = o4 - z3 * (v3.top + v3.bottom) / 2, i3._numbersTop = z3 * v3.top + O3;\n                var V2 = v3[s3];\n                s3 === "center" && (V2 = (v3.left + v3.right) / 2);\n                var G2 = a4 - z3 * V2;\n                return G2 = R7(i3, "numbersTranslate", 0, G2, S2, Math.max), rC(G2, O3) + EYt(z3);\n              });\n            }\n            function fw(e3) {\n              e3.each(function(t3) {\n                q5.stroke(dw.select(this), t3.line.color);\n              }).each(function(t3) {\n                q5.fill(dw.select(this), t3.color);\n              }).style("stroke-width", function(t3) {\n                return t3.line.width;\n              });\n            }\n            function zYt(e3, t3, r4) {\n              return function() {\n                var n4 = MYt(t3, r4);\n                return function(i3) {\n                  return e3.endAngle(n4(i3))();\n                };\n              };\n            }\n            function tC(e3, t3, r4) {\n              var n4 = e3._fullLayout, i3 = Ex.extendFlat({ type: "linear", ticks: "outside", range: r4, showline: true }, t3), a4 = { type: "linear", _id: "x" + t3._id }, o4 = { letter: "x", font: n4.font, noAutotickangles: true, noHover: true, noTickson: true };\n              function s3(l3, u4) {\n                return Ex.coerce(i3, a4, IYt, l3, u4);\n              }\n              return LYt(i3, a4, s3, o4, n4), PYt(i3, a4, s3, o4), a4;\n            }\n            function BXe(e3, t3, r4) {\n              var n4 = Math.min(t3 / e3.width, r4 / e3.height);\n              return [n4, e3, t3 + "x" + r4];\n            }\n            function OYt(e3, t3) {\n              var r4 = Math.sqrt(e3.width / 2 * (e3.width / 2) + e3.height * e3.height), n4 = t3 / r4;\n              return [n4, e3, t3];\n            }\n            function NXe(e3, t3, r4, n4) {\n              var i3 = document.createElementNS("http://www.w3.org/2000/svg", "text"), a4 = dw.select(i3);\n              return a4.text(e3).attr("x", 0).attr("y", 0).attr("text-anchor", r4).attr("data-unformatted", e3).call(D7.convertToTspans, n4).call(hw.font, t3), hw.bBox(a4.node());\n            }\n            function R7(e3, t3, r4, n4, i3, a4) {\n              var o4 = "_cache" + t3;\n              e3[o4] && e3[o4].key === i3 || (e3[o4] = { key: i3, value: r4 });\n              var s3 = Ex.aggNums(a4, null, [e3[o4].value, n4], 2);\n              return e3[o4].value = s3, s3;\n            }\n          });\n          var HXe = ye((d2r, GXe) => {\n            "use strict";\n            GXe.exports = { moduleType: "trace", name: "indicator", basePlotModule: AXe(), categories: ["svg", "noOpacity", "noHover"], animatable: true, attributes: i$(), supplyDefaults: DXe().supplyDefaults, calc: zXe().calc, plot: VXe(), meta: {} };\n          });\n          var WXe = ye((v2r, jXe) => {\n            "use strict";\n            jXe.exports = HXe();\n          });\n          var o$ = ye((g2r, KXe) => {\n            "use strict";\n            var XXe = Ub(), F7 = Ao().extendFlat, qYt = mc().overrideAll, ZXe = ec(), BYt = Cc().attributes, YXe = df().descriptionOnlyNumbers, p2r = KXe.exports = qYt({ domain: BYt({ name: "table", trace: true }), columnwidth: { valType: "number", arrayOk: true, dflt: null }, columnorder: { valType: "data_array" }, header: { values: { valType: "data_array", dflt: [] }, format: { valType: "data_array", dflt: [], description: YXe("cell value") }, prefix: { valType: "string", arrayOk: true, dflt: null }, suffix: { valType: "string", arrayOk: true, dflt: null }, height: { valType: "number", dflt: 28 }, align: F7({}, XXe.align, { arrayOk: true }), line: { width: { valType: "number", arrayOk: true, dflt: 1 }, color: { valType: "color", arrayOk: true, dflt: "grey" } }, fill: { color: { valType: "color", arrayOk: true, dflt: "white" } }, font: F7({}, ZXe({ arrayOk: true })) }, cells: { values: { valType: "data_array", dflt: [] }, format: { valType: "data_array", dflt: [], description: YXe("cell value") }, prefix: { valType: "string", arrayOk: true, dflt: null }, suffix: { valType: "string", arrayOk: true, dflt: null }, height: { valType: "number", dflt: 20 }, align: F7({}, XXe.align, { arrayOk: true }), line: { width: { valType: "number", arrayOk: true, dflt: 1 }, color: { valType: "color", arrayOk: true, dflt: "grey" } }, fill: { color: { valType: "color", arrayOk: true, dflt: "white" } }, font: F7({}, ZXe({ arrayOk: true })) } }, "calc", "from-root");\n          });\n          var $Xe = ye((m2r, JXe) => {\n            "use strict";\n            var s$ = Dr(), NYt = o$(), UYt = Cc().defaults;\n            function VYt(e3, t3) {\n              for (var r4 = e3.columnorder || [], n4 = e3.header.values.length, i3 = r4.slice(0, n4), a4 = i3.slice().sort(function(l3, u4) {\n                return l3 - u4;\n              }), o4 = i3.map(function(l3) {\n                return a4.indexOf(l3);\n              }), s3 = o4.length; s3 < n4; s3++) o4.push(s3);\n              t3("columnorder", o4);\n            }\n            JXe.exports = function(t3, r4, n4, i3) {\n              function a4(o4, s3) {\n                return s$.coerce(t3, r4, NYt, o4, s3);\n              }\n              UYt(r4, i3, a4), a4("columnwidth"), a4("header.values"), a4("header.format"), a4("header.align"), a4("header.prefix"), a4("header.suffix"), a4("header.height"), a4("header.line.width"), a4("header.line.color"), a4("header.fill.color"), s$.coerceFont(a4, "header.font", i3.font), VYt(r4, a4), a4("cells.values"), a4("cells.format"), a4("cells.align"), a4("cells.prefix"), a4("cells.suffix"), a4("cells.height"), a4("cells.line.width"), a4("cells.line.color"), a4("cells.fill.color"), s$.coerceFont(a4, "cells.font", i3.font), r4._length = null;\n            };\n          });\n          var eZe = ye((y2r, QXe) => {\n            "use strict";\n            var GYt = Jm().wrap;\n            QXe.exports = function() {\n              return GYt({});\n            };\n          });\n          var l$ = ye((_2r, tZe) => {\n            "use strict";\n            tZe.exports = { cellPad: 8, columnExtentOffset: 10, columnTitleOffset: 28, emptyHeaderHeight: 16, latexCheck: /^\\$.*\\$$/, goldenRatio: 1.618, lineBreaker: "<br>", maxDimensionCount: 60, overdrag: 45, releaseTransitionDuration: 120, releaseTransitionEase: "cubic-out", scrollbarCaptureWidth: 18, scrollbarHideDelay: 1e3, scrollbarHideDuration: 1e3, scrollbarOffset: 5, scrollbarWidth: 8, transitionDuration: 100, transitionEase: "cubic-out", uplift: 5, wrapSpacer: " ", wrapSplitCharacter: " ", cn: { table: "table", tableControlView: "table-control-view", scrollBackground: "scroll-background", yColumn: "y-column", columnBlock: "column-block", scrollAreaClip: "scroll-area-clip", scrollAreaClipRect: "scroll-area-clip-rect", columnBoundary: "column-boundary", columnBoundaryClippath: "column-boundary-clippath", columnBoundaryRect: "column-boundary-rect", columnCells: "column-cells", columnCell: "column-cell", cellRect: "cell-rect", cellText: "cell-text", cellTextHolder: "cell-text-holder", scrollbarKit: "scrollbar-kit", scrollbar: "scrollbar", scrollbarSlider: "scrollbar-slider", scrollbarGlyph: "scrollbar-glyph", scrollbarCaptureZone: "scrollbar-capture-zone" } };\n          });\n          var cZe = ye((x2r, uZe) => {\n            "use strict";\n            var rZe = l$(), c$ = Ao().extendFlat, HYt = Eo(), jYt = vv().isTypedArray, z7 = vv().isArrayOrTypedArray;\n            uZe.exports = function(t3, r4) {\n              var n4 = u$(r4.cells.values), i3 = function(g3) {\n                return g3.slice(r4.header.values.length, g3.length);\n              }, a4 = u$(r4.header.values);\n              a4.length && !a4[0].length && (a4[0] = [""], a4 = u$(a4));\n              var o4 = a4.concat(i3(n4).map(function() {\n                return lZe((a4[0] || [""]).length);\n              })), s3 = r4.domain, l3 = Math.floor(t3._fullLayout._size.w * (s3.x[1] - s3.x[0])), u4 = Math.floor(t3._fullLayout._size.h * (s3.y[1] - s3.y[0])), c5 = r4.header.values.length ? o4[0].map(function() {\n                return r4.header.height;\n              }) : [rZe.emptyHeaderHeight], f4 = n4.length ? n4[0].map(function() {\n                return r4.cells.height;\n              }) : [], h3 = c5.reduce(iZe, 0), d3 = u4 - h3, v3 = d3 + rZe.uplift, _2 = oZe(f4, v3), b = oZe(c5, h3), p3 = aZe(b, []), k4 = aZe(_2, p3), E3 = {}, S2 = r4._fullInput.columnorder;\n              z7(S2) && (S2 = Array.from(S2)), S2 = S2.concat(i3(n4.map(function(g3, P3) {\n                return P3;\n              })));\n              var L3 = o4.map(function(g3, P3) {\n                var T3 = z7(r4.columnwidth) ? r4.columnwidth[Math.min(P3, r4.columnwidth.length - 1)] : r4.columnwidth;\n                return HYt(T3) ? Number(T3) : 1;\n              }), x2 = L3.reduce(iZe, 0);\n              L3 = L3.map(function(g3) {\n                return g3 / x2 * l3;\n              });\n              var C3 = Math.max(f$(r4.header.line.width), f$(r4.cells.line.width)), M4 = { key: r4.uid + t3._context.staticPlot, translateX: s3.x[0] * t3._fullLayout._size.w, translateY: t3._fullLayout._size.h * (1 - s3.y[1]), size: t3._fullLayout._size, width: l3, maxLineWidth: C3, height: u4, columnOrder: S2, groupHeight: u4, rowBlocks: k4, headerRowBlocks: p3, scrollY: 0, cells: c$({}, r4.cells, { values: n4 }), headerCells: c$({}, r4.header, { values: o4 }), gdColumns: o4.map(function(g3) {\n                return g3[0];\n              }), gdColumnsOriginalOrder: o4.map(function(g3) {\n                return g3[0];\n              }), prevPages: [0, 0], scrollbarState: { scrollbarScrollInProgress: false }, columns: o4.map(function(g3, P3) {\n                var T3 = E3[g3];\n                E3[g3] = (T3 || 0) + 1;\n                var z3 = g3 + "__" + E3[g3];\n                return { key: z3, label: g3, specIndex: P3, xIndex: S2[P3], xScale: nZe, x: void 0, calcdata: void 0, columnWidth: L3[P3] };\n              }) };\n              return M4.columns.forEach(function(g3) {\n                g3.calcdata = M4, g3.x = nZe(g3);\n              }), M4;\n            };\n            function f$(e3) {\n              if (z7(e3)) {\n                for (var t3 = 0, r4 = 0; r4 < e3.length; r4++) t3 = Math.max(t3, f$(e3[r4]));\n                return t3;\n              }\n              return e3;\n            }\n            function iZe(e3, t3) {\n              return e3 + t3;\n            }\n            function u$(e3) {\n              var t3 = e3.slice(), r4 = 1 / 0, n4 = 0, i3;\n              for (i3 = 0; i3 < t3.length; i3++) jYt(t3[i3]) ? t3[i3] = Array.from(t3[i3]) : z7(t3[i3]) || (t3[i3] = [t3[i3]]), r4 = Math.min(r4, t3[i3].length), n4 = Math.max(n4, t3[i3].length);\n              if (r4 !== n4) for (i3 = 0; i3 < t3.length; i3++) {\n                var a4 = n4 - t3[i3].length;\n                a4 && (t3[i3] = t3[i3].concat(lZe(a4)));\n              }\n              return t3;\n            }\n            function lZe(e3) {\n              for (var t3 = new Array(e3), r4 = 0; r4 < e3; r4++) t3[r4] = "";\n              return t3;\n            }\n            function nZe(e3) {\n              return e3.calcdata.columns.reduce(function(t3, r4) {\n                return r4.xIndex < e3.xIndex ? t3 + r4.columnWidth : t3;\n              }, 0);\n            }\n            function aZe(e3, t3) {\n              var r4 = Object.keys(e3);\n              return r4.map(function(n4) {\n                return c$({}, e3[n4], { auxiliaryBlocks: t3 });\n              });\n            }\n            function oZe(e3, t3) {\n              for (var r4 = {}, n4, i3 = 0, a4 = 0, o4 = sZe(), s3 = 0, l3 = 0, u4 = 0; u4 < e3.length; u4++) n4 = e3[u4], o4.rows.push({ rowIndex: u4, rowHeight: n4 }), a4 += n4, (a4 >= t3 || u4 === e3.length - 1) && (r4[i3] = o4, o4.key = l3++, o4.firstRowIndex = s3, o4.lastRowIndex = u4, o4 = sZe(), i3 += a4, s3 = u4 + 1, a4 = 0);\n              return r4;\n            }\n            function sZe() {\n              return { firstRowIndex: null, lastRowIndex: null, rows: [] };\n            }\n          });\n          var fZe = ye((h$) => {\n            "use strict";\n            var O7 = Ao().extendFlat;\n            h$.splitToPanels = function(e3) {\n              var t3 = [0, 0], r4 = O7({}, e3, { key: "header", type: "header", page: 0, prevPages: t3, currentRepaint: [null, null], dragHandle: true, values: e3.calcdata.headerCells.values[e3.specIndex], rowBlocks: e3.calcdata.headerRowBlocks, calcdata: O7({}, e3.calcdata, { cells: e3.calcdata.headerCells }) }), n4 = O7({}, e3, { key: "cells1", type: "cells", page: 0, prevPages: t3, currentRepaint: [null, null], dragHandle: false, values: e3.calcdata.cells.values[e3.specIndex], rowBlocks: e3.calcdata.rowBlocks }), i3 = O7({}, e3, { key: "cells2", type: "cells", page: 1, prevPages: t3, currentRepaint: [null, null], dragHandle: false, values: e3.calcdata.cells.values[e3.specIndex], rowBlocks: e3.calcdata.rowBlocks });\n              return [n4, i3, r4];\n            };\n            h$.splitToCells = function(e3) {\n              var t3 = WYt(e3);\n              return (e3.values || []).slice(t3[0], t3[1]).map(function(r4, n4) {\n                var i3 = typeof r4 == "string" && r4.match(/[<$&> ]/) ? "_keybuster_" + Math.random() : "";\n                return { keyWithinBlock: n4 + i3, key: t3[0] + n4, column: e3, calcdata: e3.calcdata, page: e3.page, rowBlocks: e3.rowBlocks, value: r4 };\n              });\n            };\n            function WYt(e3) {\n              var t3 = e3.rowBlocks[e3.page], r4 = t3 ? t3.rows[0].rowIndex : 0, n4 = t3 ? r4 + t3.rows.length : 0;\n              return [r4, n4];\n            }\n          });\n          var w$ = ye((w2r, wZe) => {\n            "use strict";\n            var Ya = l$(), tf = Oa(), d$ = Dr(), XYt = d$.numberFormat, Uu = Jm(), v$ = So(), ZYt = ru(), YYt = Dr().raiseToTop, og = Dr().strTranslate, KYt = Dr().cancelTransition, JYt = cZe(), yZe = fZe(), hZe = ka();\n            wZe.exports = function(t3, r4) {\n              var n4 = !t3._context.staticPlot, i3 = t3._fullLayout._paper.selectAll("." + Ya.cn.table).data(r4.map(function(k4) {\n                var E3 = Uu.unwrap(k4), S2 = E3.trace;\n                return JYt(t3, S2);\n              }), Uu.keyFun);\n              i3.exit().remove(), i3.enter().append("g").classed(Ya.cn.table, true).attr("overflow", "visible").style("box-sizing", "content-box").style("position", "absolute").style("left", 0).style("overflow", "visible").style("shape-rendering", "crispEdges").style("pointer-events", "all"), i3.attr("width", function(k4) {\n                return k4.width + k4.size.l + k4.size.r;\n              }).attr("height", function(k4) {\n                return k4.height + k4.size.t + k4.size.b;\n              }).attr("transform", function(k4) {\n                return og(k4.translateX, k4.translateY);\n              });\n              var a4 = i3.selectAll("." + Ya.cn.tableControlView).data(Uu.repeat, Uu.keyFun), o4 = a4.enter().append("g").classed(Ya.cn.tableControlView, true).style("box-sizing", "content-box");\n              if (n4) {\n                var s3 = "onwheel" in document ? "wheel" : "mousewheel";\n                o4.on("mousemove", function(k4) {\n                  a4.filter(function(E3) {\n                    return k4 === E3;\n                  }).call(nC, t3);\n                }).on(s3, function(k4) {\n                  if (!k4.scrollbarState.wheeling) {\n                    k4.scrollbarState.wheeling = true;\n                    var E3 = k4.scrollY + tf.event.deltaY, S2 = B7(t3, a4, null, E3)(k4);\n                    S2 || (tf.event.stopPropagation(), tf.event.preventDefault()), k4.scrollbarState.wheeling = false;\n                  }\n                }).call(nC, t3, true);\n              }\n              a4.attr("transform", function(k4) {\n                return og(k4.size.l, k4.size.t);\n              });\n              var l3 = a4.selectAll("." + Ya.cn.scrollBackground).data(Uu.repeat, Uu.keyFun);\n              l3.enter().append("rect").classed(Ya.cn.scrollBackground, true).attr("fill", "none"), l3.attr("width", function(k4) {\n                return k4.width;\n              }).attr("height", function(k4) {\n                return k4.height;\n              }), a4.each(function(k4) {\n                v$.setClipUrl(tf.select(this), dZe(t3, k4), t3);\n              });\n              var u4 = a4.selectAll("." + Ya.cn.yColumn).data(function(k4) {\n                return k4.columns;\n              }, Uu.keyFun);\n              u4.enter().append("g").classed(Ya.cn.yColumn, true), u4.exit().remove(), u4.attr("transform", function(k4) {\n                return og(k4.x, 0);\n              }), n4 && u4.call(tf.behavior.drag().origin(function(k4) {\n                var E3 = tf.select(this);\n                return gZe(E3, k4, -Ya.uplift), YYt(this), k4.calcdata.columnDragInProgress = true, nC(a4.filter(function(S2) {\n                  return k4.calcdata.key === S2.key;\n                }), t3), k4;\n              }).on("drag", function(k4) {\n                var E3 = tf.select(this), S2 = function(C3) {\n                  return (k4 === C3 ? tf.event.x : C3.x) + C3.columnWidth / 2;\n                };\n                k4.x = Math.max(-Ya.overdrag, Math.min(k4.calcdata.width + Ya.overdrag - k4.columnWidth, tf.event.x));\n                var L3 = _Ze(u4).filter(function(C3) {\n                  return C3.calcdata.key === k4.calcdata.key;\n                }), x2 = L3.sort(function(C3, M4) {\n                  return S2(C3) - S2(M4);\n                });\n                x2.forEach(function(C3, M4) {\n                  C3.xIndex = M4, C3.x = k4 === C3 ? C3.x : C3.xScale(C3);\n                }), u4.filter(function(C3) {\n                  return k4 !== C3;\n                }).transition().ease(Ya.transitionEase).duration(Ya.transitionDuration).attr("transform", function(C3) {\n                  return og(C3.x, 0);\n                }), E3.call(KYt).attr("transform", og(k4.x, -Ya.uplift));\n              }).on("dragend", function(k4) {\n                var E3 = tf.select(this), S2 = k4.calcdata;\n                k4.x = k4.xScale(k4), k4.calcdata.columnDragInProgress = false, gZe(E3, k4, 0), sKt(t3, S2, S2.columns.map(function(L3) {\n                  return L3.xIndex;\n                }));\n              })), u4.each(function(k4) {\n                v$.setClipUrl(tf.select(this), vZe(t3, k4), t3);\n              });\n              var c5 = u4.selectAll("." + Ya.cn.columnBlock).data(yZe.splitToPanels, Uu.keyFun);\n              c5.enter().append("g").classed(Ya.cn.columnBlock, true).attr("id", function(k4) {\n                return k4.key;\n              }), c5.style("cursor", function(k4) {\n                return k4.dragHandle ? "ew-resize" : k4.calcdata.scrollbarState.barWiggleRoom ? "ns-resize" : "default";\n              });\n              var f4 = c5.filter(lKt), h3 = c5.filter(_$);\n              n4 && h3.call(tf.behavior.drag().origin(function(k4) {\n                return tf.event.stopPropagation(), k4;\n              }).on("drag", B7(t3, a4, -1)).on("dragend", function() {\n              })), p$(t3, a4, f4, c5), p$(t3, a4, h3, c5);\n              var d3 = a4.selectAll("." + Ya.cn.scrollAreaClip).data(Uu.repeat, Uu.keyFun);\n              d3.enter().append("clipPath").classed(Ya.cn.scrollAreaClip, true).attr("id", function(k4) {\n                return dZe(t3, k4);\n              });\n              var v3 = d3.selectAll("." + Ya.cn.scrollAreaClipRect).data(Uu.repeat, Uu.keyFun);\n              v3.enter().append("rect").classed(Ya.cn.scrollAreaClipRect, true).attr("x", -Ya.overdrag).attr("y", -Ya.uplift).attr("fill", "none"), v3.attr("width", function(k4) {\n                return k4.width + 2 * Ya.overdrag;\n              }).attr("height", function(k4) {\n                return k4.height + Ya.uplift;\n              });\n              var _2 = u4.selectAll("." + Ya.cn.columnBoundary).data(Uu.repeat, Uu.keyFun);\n              _2.enter().append("g").classed(Ya.cn.columnBoundary, true);\n              var b = u4.selectAll("." + Ya.cn.columnBoundaryClippath).data(Uu.repeat, Uu.keyFun);\n              b.enter().append("clipPath").classed(Ya.cn.columnBoundaryClippath, true), b.attr("id", function(k4) {\n                return vZe(t3, k4);\n              });\n              var p3 = b.selectAll("." + Ya.cn.columnBoundaryRect).data(Uu.repeat, Uu.keyFun);\n              p3.enter().append("rect").classed(Ya.cn.columnBoundaryRect, true).attr("fill", "none"), p3.attr("width", function(k4) {\n                return k4.columnWidth + 2 * q7(k4);\n              }).attr("height", function(k4) {\n                return k4.calcdata.height + 2 * q7(k4) + Ya.uplift;\n              }).attr("x", function(k4) {\n                return -q7(k4);\n              }).attr("y", function(k4) {\n                return -q7(k4);\n              }), x$(null, h3, a4);\n            };\n            function q7(e3) {\n              return Math.ceil(e3.calcdata.maxLineWidth / 2);\n            }\n            function dZe(e3, t3) {\n              return "clip" + e3._fullLayout._uid + "_scrollAreaBottomClip_" + t3.key;\n            }\n            function vZe(e3, t3) {\n              return "clip" + e3._fullLayout._uid + "_columnBoundaryClippath_" + t3.calcdata.key + "_" + t3.specIndex;\n            }\n            function _Ze(e3) {\n              return [].concat.apply([], e3.map(function(t3) {\n                return t3;\n              })).map(function(t3) {\n                return t3.__data__;\n              });\n            }\n            function nC(e3, t3, r4) {\n              function n4(u4) {\n                var c5 = u4.rowBlocks;\n                return m$(c5, c5.length - 1) + (c5.length ? N7(c5[c5.length - 1], 1 / 0) : 1);\n              }\n              var i3 = e3.selectAll("." + Ya.cn.scrollbarKit).data(Uu.repeat, Uu.keyFun);\n              i3.enter().append("g").classed(Ya.cn.scrollbarKit, true).style("shape-rendering", "geometricPrecision"), i3.each(function(u4) {\n                var c5 = u4.scrollbarState;\n                c5.totalHeight = n4(u4), c5.scrollableAreaHeight = u4.groupHeight - g$(u4), c5.currentlyVisibleHeight = Math.min(c5.totalHeight, c5.scrollableAreaHeight), c5.ratio = c5.currentlyVisibleHeight / c5.totalHeight, c5.barLength = Math.max(c5.ratio * c5.currentlyVisibleHeight, Ya.goldenRatio * Ya.scrollbarWidth), c5.barWiggleRoom = c5.currentlyVisibleHeight - c5.barLength, c5.wiggleRoom = Math.max(0, c5.totalHeight - c5.scrollableAreaHeight), c5.topY = c5.barWiggleRoom === 0 ? 0 : u4.scrollY / c5.wiggleRoom * c5.barWiggleRoom, c5.bottomY = c5.topY + c5.barLength, c5.dragMultiplier = c5.wiggleRoom / c5.barWiggleRoom;\n              }).attr("transform", function(u4) {\n                var c5 = u4.width + Ya.scrollbarWidth / 2 + Ya.scrollbarOffset;\n                return og(c5, g$(u4));\n              });\n              var a4 = i3.selectAll("." + Ya.cn.scrollbar).data(Uu.repeat, Uu.keyFun);\n              a4.enter().append("g").classed(Ya.cn.scrollbar, true);\n              var o4 = a4.selectAll("." + Ya.cn.scrollbarSlider).data(Uu.repeat, Uu.keyFun);\n              o4.enter().append("g").classed(Ya.cn.scrollbarSlider, true), o4.attr("transform", function(u4) {\n                return og(0, u4.scrollbarState.topY || 0);\n              });\n              var s3 = o4.selectAll("." + Ya.cn.scrollbarGlyph).data(Uu.repeat, Uu.keyFun);\n              s3.enter().append("line").classed(Ya.cn.scrollbarGlyph, true).attr("stroke", "black").attr("stroke-width", Ya.scrollbarWidth).attr("stroke-linecap", "round").attr("y1", Ya.scrollbarWidth / 2), s3.attr("y2", function(u4) {\n                return u4.scrollbarState.barLength - Ya.scrollbarWidth / 2;\n              }).attr("stroke-opacity", function(u4) {\n                return u4.columnDragInProgress || !u4.scrollbarState.barWiggleRoom || r4 ? 0 : 0.4;\n              }), s3.transition().delay(0).duration(0), s3.transition().delay(Ya.scrollbarHideDelay).duration(Ya.scrollbarHideDuration).attr("stroke-opacity", 0);\n              var l3 = a4.selectAll("." + Ya.cn.scrollbarCaptureZone).data(Uu.repeat, Uu.keyFun);\n              l3.enter().append("line").classed(Ya.cn.scrollbarCaptureZone, true).attr("stroke", "white").attr("stroke-opacity", 0.01).attr("stroke-width", Ya.scrollbarCaptureWidth).attr("stroke-linecap", "butt").attr("y1", 0).on("mousedown", function(u4) {\n                var c5 = tf.event.y, f4 = this.getBoundingClientRect(), h3 = u4.scrollbarState, d3 = c5 - f4.top, v3 = tf.scale.linear().domain([0, h3.scrollableAreaHeight]).range([0, h3.totalHeight]).clamp(true);\n                h3.topY <= d3 && d3 <= h3.bottomY || B7(t3, e3, null, v3(d3 - h3.barLength / 2))(u4);\n              }).call(tf.behavior.drag().origin(function(u4) {\n                return tf.event.stopPropagation(), u4.scrollbarState.scrollbarScrollInProgress = true, u4;\n              }).on("drag", B7(t3, e3)).on("dragend", function() {\n              })), l3.attr("y2", function(u4) {\n                return u4.scrollbarState.scrollableAreaHeight;\n              }), t3._context.staticPlot && (s3.remove(), l3.remove());\n            }\n            function p$(e3, t3, r4, n4) {\n              var i3 = $Yt(r4), a4 = QYt(i3);\n              iKt(a4);\n              var o4 = eKt(a4);\n              aKt(o4);\n              var s3 = rKt(a4), l3 = tKt(s3);\n              nKt(l3), xZe(l3, t3, n4, e3), b$(a4);\n            }\n            function $Yt(e3) {\n              var t3 = e3.selectAll("." + Ya.cn.columnCells).data(Uu.repeat, Uu.keyFun);\n              return t3.enter().append("g").classed(Ya.cn.columnCells, true), t3.exit().remove(), t3;\n            }\n            function QYt(e3) {\n              var t3 = e3.selectAll("." + Ya.cn.columnCell).data(yZe.splitToCells, function(r4) {\n                return r4.keyWithinBlock;\n              });\n              return t3.enter().append("g").classed(Ya.cn.columnCell, true), t3.exit().remove(), t3;\n            }\n            function eKt(e3) {\n              var t3 = e3.selectAll("." + Ya.cn.cellRect).data(Uu.repeat, function(r4) {\n                return r4.keyWithinBlock;\n              });\n              return t3.enter().append("rect").classed(Ya.cn.cellRect, true), t3;\n            }\n            function tKt(e3) {\n              var t3 = e3.selectAll("." + Ya.cn.cellText).data(Uu.repeat, function(r4) {\n                return r4.keyWithinBlock;\n              });\n              return t3.enter().append("text").classed(Ya.cn.cellText, true).style("cursor", function() {\n                return "auto";\n              }).on("mousedown", function() {\n                tf.event.stopPropagation();\n              }), t3;\n            }\n            function rKt(e3) {\n              var t3 = e3.selectAll("." + Ya.cn.cellTextHolder).data(Uu.repeat, function(r4) {\n                return r4.keyWithinBlock;\n              });\n              return t3.enter().append("g").classed(Ya.cn.cellTextHolder, true).style("shape-rendering", "geometricPrecision"), t3;\n            }\n            function iKt(e3) {\n              e3.each(function(t3, r4) {\n                var n4 = t3.calcdata.cells.font, i3 = t3.column.specIndex, a4 = { size: Yv(n4.size, i3, r4), color: Yv(n4.color, i3, r4), family: Yv(n4.family, i3, r4), weight: Yv(n4.weight, i3, r4), style: Yv(n4.style, i3, r4), variant: Yv(n4.variant, i3, r4), textcase: Yv(n4.textcase, i3, r4), lineposition: Yv(n4.lineposition, i3, r4), shadow: Yv(n4.shadow, i3, r4) };\n                t3.rowNumber = t3.key, t3.align = Yv(t3.calcdata.cells.align, i3, r4), t3.cellBorderWidth = Yv(t3.calcdata.cells.line.width, i3, r4), t3.font = a4;\n              });\n            }\n            function nKt(e3) {\n              e3.each(function(t3) {\n                v$.font(tf.select(this), t3.font);\n              });\n            }\n            function aKt(e3) {\n              e3.attr("width", function(t3) {\n                return t3.column.columnWidth;\n              }).attr("stroke-width", function(t3) {\n                return t3.cellBorderWidth;\n              }).each(function(t3) {\n                var r4 = tf.select(this);\n                hZe.stroke(r4, Yv(t3.calcdata.cells.line.color, t3.column.specIndex, t3.rowNumber)), hZe.fill(r4, Yv(t3.calcdata.cells.fill.color, t3.column.specIndex, t3.rowNumber));\n              });\n            }\n            function xZe(e3, t3, r4, n4) {\n              e3.text(function(i3) {\n                var a4 = i3.column.specIndex, o4 = i3.rowNumber, s3 = i3.value, l3 = typeof s3 == "string", u4 = l3 && s3.match(/<br>/i), c5 = !l3 || u4;\n                i3.mayHaveMarkup = l3 && s3.match(/[<&>]/);\n                var f4 = oKt(s3);\n                i3.latex = f4;\n                var h3 = f4 ? "" : Yv(i3.calcdata.cells.prefix, a4, o4) || "", d3 = f4 ? "" : Yv(i3.calcdata.cells.suffix, a4, o4) || "", v3 = f4 ? null : Yv(i3.calcdata.cells.format, a4, o4) || null, _2 = h3 + (v3 ? XYt(v3)(i3.value) : i3.value) + d3, b;\n                i3.wrappingNeeded = !i3.wrapped && !c5 && !f4 && (b = pZe(_2)), i3.cellHeightMayIncrease = u4 || f4 || i3.mayHaveMarkup || (b === void 0 ? pZe(_2) : b), i3.needsConvertToTspans = i3.mayHaveMarkup || i3.wrappingNeeded || i3.latex;\n                var p3;\n                if (i3.wrappingNeeded) {\n                  var k4 = Ya.wrapSplitCharacter === " " ? _2.replace(/<a href=/ig, "<a_href=") : _2, E3 = k4.split(Ya.wrapSplitCharacter), S2 = Ya.wrapSplitCharacter === " " ? E3.map(function(L3) {\n                    return L3.replace(/<a_href=/ig, "<a href=");\n                  }) : E3;\n                  i3.fragments = S2.map(function(L3) {\n                    return { text: L3, width: null };\n                  }), i3.fragments.push({ fragment: Ya.wrapSpacer, width: null }), p3 = S2.join(Ya.lineBreaker) + Ya.lineBreaker + Ya.wrapSpacer;\n                } else delete i3.fragments, p3 = _2;\n                return p3;\n              }).attr("dy", function(i3) {\n                return i3.needsConvertToTspans ? 0 : "0.75em";\n              }).each(function(i3) {\n                var a4 = this, o4 = tf.select(a4), s3 = i3.wrappingNeeded ? cKt : fKt;\n                i3.needsConvertToTspans ? ZYt.convertToTspans(o4, n4, s3(r4, a4, t3, n4, i3)) : tf.select(a4.parentNode).attr("transform", function(l3) {\n                  return og(bZe(l3), Ya.cellPad);\n                }).attr("text-anchor", function(l3) {\n                  return { left: "start", center: "middle", right: "end" }[l3.align];\n                });\n              });\n            }\n            function oKt(e3) {\n              return typeof e3 == "string" && e3.match(Ya.latexCheck);\n            }\n            function pZe(e3) {\n              return e3.indexOf(Ya.wrapSplitCharacter) !== -1;\n            }\n            function sKt(e3, t3, r4) {\n              var n4 = t3.gdColumnsOriginalOrder;\n              t3.gdColumns.sort(function(i3, a4) {\n                return r4[n4.indexOf(i3)] - r4[n4.indexOf(a4)];\n              }), t3.columnorder = r4, e3.emit("plotly_restyle");\n            }\n            function Yv(e3, t3, r4) {\n              if (d$.isArrayOrTypedArray(e3)) {\n                var n4 = e3[Math.min(t3, e3.length - 1)];\n                return d$.isArrayOrTypedArray(n4) ? n4[Math.min(r4, n4.length - 1)] : n4;\n              } else return e3;\n            }\n            function gZe(e3, t3, r4) {\n              e3.transition().ease(Ya.releaseTransitionEase).duration(Ya.releaseTransitionDuration).attr("transform", og(t3.x, r4));\n            }\n            function _$(e3) {\n              return e3.type === "cells";\n            }\n            function lKt(e3) {\n              return e3.type === "header";\n            }\n            function g$(e3) {\n              var t3 = e3.rowBlocks.length ? e3.rowBlocks[0].auxiliaryBlocks : [];\n              return t3.reduce(function(r4, n4) {\n                return r4 + N7(n4, 1 / 0);\n              }, 0);\n            }\n            function uKt(e3, t3, r4) {\n              for (var n4 = [], i3 = 0, a4 = 0; a4 < e3.length; a4++) {\n                for (var o4 = e3[a4], s3 = o4.rows, l3 = 0, u4 = 0; u4 < s3.length; u4++) l3 += s3[u4].rowHeight;\n                o4.allRowsHeight = l3;\n                var c5 = i3 + l3, f4 = t3, h3 = f4 + r4;\n                f4 < c5 && h3 > i3 && n4.push(a4), i3 += l3;\n              }\n              return n4;\n            }\n            function x$(e3, t3, r4) {\n              var n4 = _Ze(t3)[0];\n              if (n4 !== void 0) {\n                var i3 = n4.rowBlocks, a4 = n4.calcdata, o4 = m$(i3, i3.length), s3 = n4.calcdata.groupHeight - g$(n4), l3 = a4.scrollY = Math.max(0, Math.min(o4 - s3, a4.scrollY)), u4 = uKt(i3, l3, s3);\n                u4.length === 1 && (u4[0] === i3.length - 1 ? u4.unshift(u4[0] - 1) : u4.push(u4[0] + 1)), u4[0] % 2 && u4.reverse(), t3.each(function(c5, f4) {\n                  c5.page = u4[f4], c5.scrollY = l3;\n                }), t3.attr("transform", function(c5) {\n                  var f4 = m$(c5.rowBlocks, c5.page) - c5.scrollY;\n                  return og(0, f4);\n                }), e3 && (mZe(e3, r4, t3, u4, n4.prevPages, n4, 0), mZe(e3, r4, t3, u4, n4.prevPages, n4, 1), nC(r4, e3));\n              }\n            }\n            function B7(e3, t3, r4, n4) {\n              return function(a4) {\n                var o4 = a4.calcdata ? a4.calcdata : a4, s3 = t3.filter(function(f4) {\n                  return o4.key === f4.key;\n                }), l3 = r4 || o4.scrollbarState.dragMultiplier, u4 = o4.scrollY;\n                o4.scrollY = n4 === void 0 ? o4.scrollY + l3 * tf.event.dy : n4;\n                var c5 = s3.selectAll("." + Ya.cn.yColumn).selectAll("." + Ya.cn.columnBlock).filter(_$);\n                return x$(e3, c5, s3), o4.scrollY === u4;\n              };\n            }\n            function mZe(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = n4[o4] !== i3[o4];\n              s3 && (clearTimeout(a4.currentRepaint[o4]), a4.currentRepaint[o4] = setTimeout(function() {\n                var l3 = r4.filter(function(u4, c5) {\n                  return c5 === o4 && n4[c5] !== i3[c5];\n                });\n                p$(e3, t3, l3, r4), i3[o4] = n4[o4];\n              }));\n            }\n            function cKt(e3, t3, r4, n4) {\n              return function() {\n                var a4 = tf.select(t3.parentNode);\n                a4.each(function(o4) {\n                  var s3 = o4.fragments;\n                  a4.selectAll("tspan.line").each(function(_2, b) {\n                    s3[b].width = this.getComputedTextLength();\n                  });\n                  var l3 = s3[s3.length - 1].width, u4 = s3.slice(0, -1), c5 = [], f4, h3, d3 = 0, v3 = o4.column.columnWidth - 2 * Ya.cellPad;\n                  for (o4.value = ""; u4.length; ) f4 = u4.shift(), h3 = f4.width + l3, d3 + h3 > v3 && (o4.value += c5.join(Ya.wrapSpacer) + Ya.lineBreaker, c5 = [], d3 = 0), c5.push(f4.text), d3 += h3;\n                  d3 && (o4.value += c5.join(Ya.wrapSpacer)), o4.wrapped = true;\n                }), a4.selectAll("tspan.line").remove(), xZe(a4.select("." + Ya.cn.cellText), r4, e3, n4), tf.select(t3.parentNode.parentNode).call(b$);\n              };\n            }\n            function fKt(e3, t3, r4, n4, i3) {\n              return function() {\n                if (!i3.settledY) {\n                  var o4 = tf.select(t3.parentNode), s3 = y$(i3), l3 = i3.key - s3.firstRowIndex, u4 = s3.rows[l3].rowHeight, c5 = i3.cellHeightMayIncrease ? t3.parentNode.getBoundingClientRect().height + 2 * Ya.cellPad : u4, f4 = Math.max(c5, u4), h3 = f4 - s3.rows[l3].rowHeight;\n                  h3 && (s3.rows[l3].rowHeight = f4, e3.selectAll("." + Ya.cn.columnCell).call(b$), x$(null, e3.filter(_$), 0), nC(r4, n4, true)), o4.attr("transform", function() {\n                    var d3 = this, v3 = d3.parentNode, _2 = v3.getBoundingClientRect(), b = tf.select(d3.parentNode).select("." + Ya.cn.cellRect).node().getBoundingClientRect(), p3 = d3.transform.baseVal.consolidate(), k4 = b.top - _2.top + (p3 ? p3.matrix.f : Ya.cellPad);\n                    return og(bZe(i3, tf.select(d3.parentNode).select("." + Ya.cn.cellTextHolder).node().getBoundingClientRect().width), k4);\n                  }), i3.settledY = true;\n                }\n              };\n            }\n            function bZe(e3, t3) {\n              switch (e3.align) {\n                case "left":\n                  return Ya.cellPad;\n                case "right":\n                  return e3.column.columnWidth - (t3 || 0) - Ya.cellPad;\n                case "center":\n                  return (e3.column.columnWidth - (t3 || 0)) / 2;\n                default:\n                  return Ya.cellPad;\n              }\n            }\n            function b$(e3) {\n              e3.attr("transform", function(t3) {\n                var r4 = t3.rowBlocks[0].auxiliaryBlocks.reduce(function(o4, s3) {\n                  return o4 + N7(s3, 1 / 0);\n                }, 0), n4 = y$(t3), i3 = N7(n4, t3.key), a4 = i3 + r4;\n                return og(0, a4);\n              }).selectAll("." + Ya.cn.cellRect).attr("height", function(t3) {\n                return dKt(y$(t3), t3.key).rowHeight;\n              });\n            }\n            function m$(e3, t3) {\n              for (var r4 = 0, n4 = t3 - 1; n4 >= 0; n4--) r4 += hKt(e3[n4]);\n              return r4;\n            }\n            function N7(e3, t3) {\n              for (var r4 = 0, n4 = 0; n4 < e3.rows.length && e3.rows[n4].rowIndex < t3; n4++) r4 += e3.rows[n4].rowHeight;\n              return r4;\n            }\n            function hKt(e3) {\n              var t3 = e3.allRowsHeight;\n              if (t3 !== void 0) return t3;\n              for (var r4 = 0, n4 = 0; n4 < e3.rows.length; n4++) r4 += e3.rows[n4].rowHeight;\n              return e3.allRowsHeight = r4, r4;\n            }\n            function y$(e3) {\n              return e3.rowBlocks[e3.page];\n            }\n            function dKt(e3, t3) {\n              return e3.rows[t3 - e3.firstRowIndex];\n            }\n          });\n          var TZe = ye((V7) => {\n            "use strict";\n            var vKt = Id().getModuleCalcData, pKt = w$(), U7 = "table";\n            V7.name = U7;\n            V7.plot = function(e3) {\n              var t3 = vKt(e3.calcdata, U7)[0];\n              t3.length && pKt(e3, t3);\n            };\n            V7.clean = function(e3, t3, r4, n4) {\n              var i3 = n4._has && n4._has(U7), a4 = t3._has && t3._has(U7);\n              i3 && !a4 && n4._paperdiv.selectAll(".table").remove();\n            };\n          });\n          var SZe = ye((A2r, AZe) => {\n            "use strict";\n            AZe.exports = { attributes: o$(), supplyDefaults: $Xe(), calc: eZe(), plot: w$(), moduleType: "trace", name: "table", basePlotModule: TZe(), categories: ["noOpacity"], meta: {} };\n          });\n          var EZe = ye((S2r, MZe) => {\n            "use strict";\n            MZe.exports = SZe();\n          });\n          var IZe = ye((M2r, PZe) => {\n            "use strict";\n            var kZe = ec(), CZe = Lh(), T$ = Rd(), gKt = df().descriptionWithDates, mKt = mc().overrideAll, LZe = Pd().dash, A$ = Ao().extendFlat;\n            PZe.exports = { color: { valType: "color", editType: "calc" }, smoothing: { valType: "number", dflt: 1, min: 0, max: 1.3, editType: "calc" }, title: { text: { valType: "string", dflt: "", editType: "calc" }, font: kZe({ editType: "calc" }), offset: { valType: "number", dflt: 10, editType: "calc" }, editType: "calc" }, type: { valType: "enumerated", values: ["-", "linear", "date", "category"], dflt: "-", editType: "calc" }, autotypenumbers: T$.autotypenumbers, autorange: { valType: "enumerated", values: [true, false, "reversed"], dflt: true, editType: "calc" }, rangemode: { valType: "enumerated", values: ["normal", "tozero", "nonnegative"], dflt: "normal", editType: "calc" }, range: { valType: "info_array", editType: "calc", items: [{ valType: "any", editType: "calc" }, { valType: "any", editType: "calc" }] }, fixedrange: { valType: "boolean", dflt: false, editType: "calc" }, cheatertype: { valType: "enumerated", values: ["index", "value"], dflt: "value", editType: "calc" }, tickmode: { valType: "enumerated", values: ["linear", "array"], dflt: "array", editType: "calc" }, nticks: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, tickvals: { valType: "data_array", editType: "calc" }, ticktext: { valType: "data_array", editType: "calc" }, showticklabels: { valType: "enumerated", values: ["start", "end", "both", "none"], dflt: "start", editType: "calc" }, labelalias: A$({}, T$.labelalias, { editType: "calc" }), tickfont: kZe({ editType: "calc" }), tickangle: { valType: "angle", dflt: "auto", editType: "calc" }, tickprefix: { valType: "string", dflt: "", editType: "calc" }, showtickprefix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, ticksuffix: { valType: "string", dflt: "", editType: "calc" }, showticksuffix: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, showexponent: { valType: "enumerated", values: ["all", "first", "last", "none"], dflt: "all", editType: "calc" }, exponentformat: { valType: "enumerated", values: ["none", "e", "E", "power", "SI", "B", "SI extended"], dflt: "B", editType: "calc" }, minexponent: { valType: "number", dflt: 3, min: 0, editType: "calc" }, separatethousands: { valType: "boolean", dflt: false, editType: "calc" }, tickformat: { valType: "string", dflt: "", editType: "calc", description: gKt("tick label") }, tickformatstops: mKt(T$.tickformatstops, "calc", "from-root"), categoryorder: { valType: "enumerated", values: ["trace", "category ascending", "category descending", "array"], dflt: "trace", editType: "calc" }, categoryarray: { valType: "data_array", editType: "calc" }, labelpadding: { valType: "integer", dflt: 10, editType: "calc" }, labelprefix: { valType: "string", editType: "calc" }, labelsuffix: { valType: "string", dflt: "", editType: "calc" }, showline: { valType: "boolean", dflt: false, editType: "calc" }, linecolor: { valType: "color", dflt: CZe.defaultLine, editType: "calc" }, linewidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, gridcolor: { valType: "color", editType: "calc" }, gridwidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, griddash: A$({}, LZe, { editType: "calc" }), showgrid: { valType: "boolean", dflt: true, editType: "calc" }, minorgridcount: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, minorgridwidth: { valType: "number", min: 0, dflt: 1, editType: "calc" }, minorgriddash: A$({}, LZe, { editType: "calc" }), minorgridcolor: { valType: "color", dflt: CZe.lightLine, editType: "calc" }, startline: { valType: "boolean", editType: "calc" }, startlinecolor: { valType: "color", editType: "calc" }, startlinewidth: { valType: "number", dflt: 1, editType: "calc" }, endline: { valType: "boolean", editType: "calc" }, endlinewidth: { valType: "number", dflt: 1, editType: "calc" }, endlinecolor: { valType: "color", editType: "calc" }, tick0: { valType: "number", min: 0, dflt: 0, editType: "calc" }, dtick: { valType: "number", min: 0, dflt: 1, editType: "calc" }, arraytick0: { valType: "integer", min: 0, dflt: 0, editType: "calc" }, arraydtick: { valType: "integer", min: 1, dflt: 1, editType: "calc" }, editType: "calc" };\n          });\n          var H7 = ye((E2r, FZe) => {\n            "use strict";\n            var yKt = ec(), RZe = IZe(), DZe = Lh(), G7 = yKt({ editType: "calc" }), _Kt = pf().zorder;\n            G7.family.dflt = \'"Open Sans", verdana, arial, sans-serif\';\n            G7.size.dflt = 12;\n            G7.color.dflt = DZe.defaultLine;\n            FZe.exports = { carpet: { valType: "string", editType: "calc" }, x: { valType: "data_array", editType: "calc+clearAxisTypes" }, y: { valType: "data_array", editType: "calc+clearAxisTypes" }, a: { valType: "data_array", editType: "calc" }, a0: { valType: "number", dflt: 0, editType: "calc" }, da: { valType: "number", dflt: 1, editType: "calc" }, b: { valType: "data_array", editType: "calc" }, b0: { valType: "number", dflt: 0, editType: "calc" }, db: { valType: "number", dflt: 1, editType: "calc" }, cheaterslope: { valType: "number", dflt: 1, editType: "calc" }, aaxis: RZe, baxis: RZe, font: G7, color: { valType: "color", dflt: DZe.defaultLine, editType: "plot" }, zorder: _Kt };\n          });\n          var qZe = ye((k2r, OZe) => {\n            "use strict";\n            var zZe = Dr().isArray1D;\n            OZe.exports = function(t3, r4, n4) {\n              var i3 = n4("x"), a4 = i3 && i3.length, o4 = n4("y"), s3 = o4 && o4.length;\n              if (!a4 && !s3) return false;\n              if (r4._cheater = !i3, (!a4 || zZe(i3)) && (!s3 || zZe(o4))) {\n                var l3 = a4 ? i3.length : 1 / 0;\n                s3 && (l3 = Math.min(l3, o4.length)), r4.a && r4.a.length && (l3 = Math.min(l3, r4.a.length)), r4.b && r4.b.length && (l3 = Math.min(l3, r4.b.length)), r4._length = l3;\n              } else r4._length = null;\n              return true;\n            };\n          });\n          var UZe = ye((C2r, NZe) => {\n            "use strict";\n            var xKt = H7(), BZe = ka().addOpacity, bKt = qa(), aC = Dr(), wKt = bb(), TKt = e_(), AKt = t_(), SKt = oI(), MKt = ym(), EKt = R3();\n            NZe.exports = function(t3, r4, n4) {\n              var i3 = n4.letter, a4 = n4.font || {}, o4 = xKt[i3 + "axis"];\n              function s3(g3, P3) {\n                return aC.coerce(t3, r4, o4, g3, P3);\n              }\n              function l3(g3, P3) {\n                return aC.coerce2(t3, r4, o4, g3, P3);\n              }\n              n4.name && (r4._name = n4.name, r4._id = n4.name), s3("autotypenumbers", n4.autotypenumbersDflt);\n              var u4 = s3("type");\n              if (u4 === "-" && (n4.data && kKt(r4, n4.data), r4.type === "-" ? r4.type = "linear" : u4 = t3.type = r4.type), s3("smoothing"), s3("cheatertype"), s3("showticklabels"), s3("labelprefix", i3 + " = "), s3("labelsuffix"), s3("showtickprefix"), s3("showticksuffix"), s3("separatethousands"), s3("tickformat"), s3("exponentformat"), s3("minexponent"), s3("showexponent"), s3("categoryorder"), s3("tickmode"), s3("tickvals"), s3("ticktext"), s3("tick0"), s3("dtick"), r4.tickmode === "array" && (s3("arraytick0"), s3("arraydtick")), s3("labelpadding"), r4._hovertitle = i3, u4 === "date") {\n                var c5 = bKt.getComponentMethod("calendars", "handleDefaults");\n                c5(t3, r4, "calendar", n4.calendar);\n              }\n              MKt(r4, n4.fullLayout), r4.c2p = aC.identity;\n              var f4 = s3("color", n4.dfltColor), h3 = f4 === t3.color ? f4 : a4.color, d3 = s3("title.text");\n              d3 && (aC.coerceFont(s3, "title.font", a4, { overrideDflt: { size: aC.bigFont(a4.size), color: h3 } }), s3("title.offset")), s3("tickangle");\n              var v3 = s3("autorange", !r4.isValidRange(t3.range));\n              v3 && s3("rangemode"), s3("range"), r4.cleanRange(), s3("fixedrange"), wKt(t3, r4, s3, u4), AKt(t3, r4, s3, u4, n4), TKt(t3, r4, s3, u4, n4), SKt(t3, r4, s3, { data: n4.data, dataAttr: i3 });\n              var _2 = l3("gridcolor", BZe(f4, 0.3)), b = l3("gridwidth"), p3 = l3("griddash"), k4 = s3("showgrid");\n              k4 || (delete r4.gridcolor, delete r4.gridwidth, delete r4.griddash);\n              var E3 = l3("startlinecolor", f4), S2 = l3("startlinewidth", b), L3 = s3("startline", r4.showgrid || !!E3 || !!S2);\n              L3 || (delete r4.startlinecolor, delete r4.startlinewidth);\n              var x2 = l3("endlinecolor", f4), C3 = l3("endlinewidth", b), M4 = s3("endline", r4.showgrid || !!x2 || !!C3);\n              return M4 || (delete r4.endlinecolor, delete r4.endlinewidth), k4 ? (s3("minorgridcount"), s3("minorgridwidth", b), s3("minorgriddash", p3), s3("minorgridcolor", BZe(_2, 0.06)), r4.minorgridcount || (delete r4.minorgridwidth, delete r4.minorgriddash, delete r4.minorgridcolor)) : (delete r4.gridcolor, delete r4.gridwidth, delete r4.griddash), r4.showticklabels === "none" && (delete r4.tickfont, delete r4.tickangle, delete r4.showexponent, delete r4.exponentformat, delete r4.minexponent, delete r4.tickformat, delete r4.showticksuffix, delete r4.showtickprefix), r4.showticksuffix || delete r4.ticksuffix, r4.showtickprefix || delete r4.tickprefix, s3("tickmode"), r4;\n            };\n            function kKt(e3, t3) {\n              if (e3.type === "-") {\n                var r4 = e3._id, n4 = r4.charAt(0), i3 = n4 + "calendar", a4 = e3[i3];\n                e3.type = EKt(t3, a4, { autotypenumbers: e3.autotypenumbers });\n              }\n            }\n          });\n          var GZe = ye((L2r, VZe) => {\n            "use strict";\n            var CKt = UZe(), LKt = vl();\n            VZe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = i3("a");\n              o4 || (i3("da"), i3("a0"));\n              var s3 = i3("b");\n              s3 || (i3("db"), i3("b0")), PKt(t3, r4, n4, a4);\n            };\n            function PKt(e3, t3, r4, n4) {\n              var i3 = ["aaxis", "baxis"];\n              i3.forEach(function(a4) {\n                var o4 = a4.charAt(0), s3 = e3[a4] || {}, l3 = LKt.newContainer(t3, a4), u4 = { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, tickfont: "x", id: o4 + "axis", letter: o4, font: t3.font, name: a4, data: e3[o4], calendar: t3.calendar, dfltColor: n4, bgColor: r4.paper_bgcolor, autotypenumbersDflt: r4.autotypenumbers, fullLayout: r4 };\n                CKt(s3, l3, u4), l3._categories = l3._categories || [], !e3[a4] && s3.type !== "-" && (e3[a4] = { type: s3.type });\n              });\n            }\n          });\n          var WZe = ye((P2r, jZe) => {\n            "use strict";\n            var HZe = Dr(), IKt = qZe(), RKt = GZe(), DKt = H7(), FKt = Lh();\n            jZe.exports = function(t3, r4, n4, i3) {\n              function a4(l3, u4) {\n                return HZe.coerce(t3, r4, DKt, l3, u4);\n              }\n              r4._clipPathId = "clip" + r4.uid + "carpet";\n              var o4 = a4("color", FKt.defaultLine);\n              if (HZe.coerceFont(a4, "font", i3.font), a4("carpet"), RKt(t3, r4, i3, a4, o4), !r4.a || !r4.b) {\n                r4.visible = false;\n                return;\n              }\n              r4.a.length < 3 && (r4.aaxis.smoothing = 0), r4.b.length < 3 && (r4.baxis.smoothing = 0);\n              var s3 = IKt(t3, r4, a4);\n              s3 || (r4.visible = false), r4._cheater && a4("cheaterslope"), a4("zorder");\n            };\n          });\n          var S$ = ye((I2r, XZe) => {\n            "use strict";\n            var zKt = Dr().isArrayOrTypedArray;\n            XZe.exports = function(t3, r4, n4) {\n              var i3;\n              for (zKt(t3) ? t3.length > r4.length && (t3 = t3.slice(0, r4.length)) : t3 = [], i3 = 0; i3 < r4.length; i3++) t3[i3] = n4(r4[i3]);\n              return t3;\n            };\n          });\n          var M$ = ye((R2r, ZZe) => {\n            "use strict";\n            ZZe.exports = function(t3, r4, n4) {\n              if (t3.length === 0) return "";\n              var i3, a4 = [], o4 = n4 ? 3 : 1;\n              for (i3 = 0; i3 < t3.length; i3 += o4) a4.push(t3[i3] + "," + r4[i3]), n4 && i3 < t3.length - o4 && (a4.push("C"), a4.push([t3[i3 + 1] + "," + r4[i3 + 1], t3[i3 + 2] + "," + r4[i3 + 2] + " "].join(" ")));\n              return a4.join(n4 ? "" : "L");\n            };\n          });\n          var KZe = ye((D2r, YZe) => {\n            "use strict";\n            YZe.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3 = a4[0] * t3.dpdx(r4), l3 = a4[1] * t3.dpdy(n4), u4 = 1, c5 = 1;\n              if (o4) {\n                var f4 = Math.sqrt(a4[0] * a4[0] + a4[1] * a4[1]), h3 = Math.sqrt(o4[0] * o4[0] + o4[1] * o4[1]), d3 = (a4[0] * o4[0] + a4[1] * o4[1]) / f4 / h3;\n                c5 = Math.max(0, d3);\n              }\n              var v3 = Math.atan2(l3, s3) * 180 / Math.PI;\n              return v3 < -90 ? (v3 += 180, u4 = -u4) : v3 > 90 && (v3 -= 180, u4 = -u4), { angle: v3, flip: u4, p: t3.c2p(i3, r4, n4), offsetMultplier: c5 };\n            };\n          });\n          var nYe = ye((F2r, iYe) => {\n            "use strict";\n            var Z7 = Oa(), j7 = So(), W7 = S$(), QZe = M$(), oC = KZe(), E$ = ru(), Up = Dr(), eYe = Up.strRotate, X7 = Up.strTranslate, tYe = $h();\n            iYe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3._context.staticPlot, o4 = r4.xaxis, s3 = r4.yaxis, l3 = t3._fullLayout, u4 = l3._clips;\n              Up.makeTraceGroups(i3, n4, "trace").each(function(c5) {\n                var f4 = Z7.select(this), h3 = c5[0], d3 = h3.trace, v3 = d3.aaxis, _2 = d3.baxis, b = Up.ensureSingle(f4, "g", "minorlayer"), p3 = Up.ensureSingle(f4, "g", "majorlayer"), k4 = Up.ensureSingle(f4, "g", "boundarylayer"), E3 = Up.ensureSingle(f4, "g", "labellayer");\n                f4.style("opacity", d3.opacity), B5(o4, s3, p3, v3, "a", v3._gridlines, true, a4), B5(o4, s3, p3, _2, "b", _2._gridlines, true, a4), B5(o4, s3, b, v3, "a", v3._minorgridlines, true, a4), B5(o4, s3, b, _2, "b", _2._minorgridlines, true, a4), B5(o4, s3, k4, v3, "a-boundary", v3._boundarylines, a4), B5(o4, s3, k4, _2, "b-boundary", _2._boundarylines, a4);\n                var S2 = JZe(t3, o4, s3, d3, h3, E3, v3._labels, "a-label"), L3 = JZe(t3, o4, s3, d3, h3, E3, _2._labels, "b-label");\n                qKt(t3, E3, d3, h3, o4, s3, S2, L3), OKt(d3, h3, u4, o4, s3);\n              });\n            };\n            function OKt(e3, t3, r4, n4, i3) {\n              var a4, o4, s3, l3, u4 = r4.select("#" + e3._clipPathId);\n              u4.size() || (u4 = r4.append("clipPath").classed("carpetclip", true));\n              var c5 = Up.ensureSingle(u4, "path", "carpetboundary"), f4 = t3.clipsegments, h3 = [];\n              for (l3 = 0; l3 < f4.length; l3++) a4 = f4[l3], o4 = W7([], a4.x, n4.c2p), s3 = W7([], a4.y, i3.c2p), h3.push(QZe(o4, s3, a4.bicubic));\n              var d3 = "M" + h3.join("L") + "Z";\n              u4.attr("id", e3._clipPathId), c5.attr("d", d3);\n            }\n            function B5(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = "const-" + i3 + "-lines", l3 = r4.selectAll("." + s3).data(a4);\n              l3.enter().append("path").classed(s3, true).style("vector-effect", o4 ? "none" : "non-scaling-stroke"), l3.each(function(u4) {\n                var c5 = u4, f4 = c5.x, h3 = c5.y, d3 = W7([], f4, e3.c2p), v3 = W7([], h3, t3.c2p), _2 = "M" + QZe(d3, v3, c5.smoothing), b = Z7.select(this);\n                b.attr("d", _2).style("stroke-width", c5.width).style("stroke", c5.color).style("stroke-dasharray", j7.dashStyle(c5.dash, c5.width)).style("fill", "none");\n              }), l3.exit().remove();\n            }\n            function JZe(e3, t3, r4, n4, i3, a4, o4, s3) {\n              var l3 = a4.selectAll("text." + s3).data(o4);\n              l3.enter().append("text").classed(s3, true);\n              var u4 = 0, c5 = {};\n              return l3.each(function(f4, h3) {\n                var d3;\n                if (f4.axis.tickangle === "auto") d3 = oC(n4, t3, r4, f4.xy, f4.dxy);\n                else {\n                  var v3 = (f4.axis.tickangle + 180) * Math.PI / 180;\n                  d3 = oC(n4, t3, r4, f4.xy, [Math.cos(v3), Math.sin(v3)]);\n                }\n                h3 || (c5 = { angle: d3.angle, flip: d3.flip });\n                var _2 = (f4.endAnchor ? -1 : 1) * d3.flip, b = Z7.select(this).attr({ "text-anchor": _2 > 0 ? "start" : "end", "data-notex": 1 }).call(j7.font, f4.font).text(f4.text).call(E$.convertToTspans, e3), p3 = j7.bBox(this);\n                b.attr("transform", X7(d3.p[0], d3.p[1]) + eYe(d3.angle) + X7(f4.axis.labelpadding * _2, p3.height * 0.3)), u4 = Math.max(u4, p3.width + f4.axis.labelpadding);\n              }), l3.exit().remove(), c5.maxExtent = u4, c5;\n            }\n            function qKt(e3, t3, r4, n4, i3, a4, o4, s3) {\n              var l3, u4, c5, f4, h3 = Up.aggNums(Math.min, null, r4.a), d3 = Up.aggNums(Math.max, null, r4.a), v3 = Up.aggNums(Math.min, null, r4.b), _2 = Up.aggNums(Math.max, null, r4.b);\n              l3 = 0.5 * (h3 + d3), u4 = v3, c5 = r4.ab2xy(l3, u4, true), f4 = r4.dxyda_rough(l3, u4), o4.angle === void 0 && Up.extendFlat(o4, oC(r4, i3, a4, c5, r4.dxydb_rough(l3, u4))), $Ze(e3, t3, r4, n4, c5, f4, r4.aaxis, i3, a4, o4, "a-title"), l3 = h3, u4 = 0.5 * (v3 + _2), c5 = r4.ab2xy(l3, u4, true), f4 = r4.dxydb_rough(l3, u4), s3.angle === void 0 && Up.extendFlat(s3, oC(r4, i3, a4, c5, r4.dxyda_rough(l3, u4))), $Ze(e3, t3, r4, n4, c5, f4, r4.baxis, i3, a4, s3, "b-title");\n            }\n            var rYe = tYe.LINE_SPACING, BKt = (1 - tYe.MID_SHIFT) / rYe + 1;\n            function $Ze(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4, c5) {\n              var f4 = [];\n              o4.title.text && f4.push(o4.title.text);\n              var h3 = t3.selectAll("text." + c5).data(f4), d3 = u4.maxExtent;\n              h3.enter().append("text").classed(c5, true), h3.each(function() {\n                var v3 = oC(r4, s3, l3, i3, a4);\n                ["start", "both"].indexOf(o4.showticklabels) === -1 && (d3 = 0);\n                var _2 = o4.title.font.size;\n                d3 += _2 + o4.title.offset;\n                var b = u4.angle + (u4.flip < 0 ? 180 : 0), p3 = (b - v3.angle + 450) % 360, k4 = p3 > 90 && p3 < 270, E3 = Z7.select(this);\n                E3.text(o4.title.text).call(E$.convertToTspans, e3), k4 && (d3 = (-E$.lineCount(E3) + BKt) * rYe * _2 - d3), E3.attr("transform", X7(v3.p[0], v3.p[1]) + eYe(v3.angle) + X7(0, d3)).attr("text-anchor", "middle").call(j7.font, o4.title.font);\n              }), h3.exit().remove();\n            }\n          });\n          var oYe = ye((z2r, aYe) => {\n            "use strict";\n            var Y7 = Dr().isArrayOrTypedArray;\n            aYe.exports = function(e3, t3, r4) {\n              var n4, i3, a4, o4, s3, l3, u4 = [], c5 = Y7(e3) ? e3.length : e3, f4 = Y7(t3) ? t3.length : t3, h3 = Y7(e3) ? e3 : null, d3 = Y7(t3) ? t3 : null;\n              h3 && (a4 = (h3.length - 1) / (h3[h3.length - 1] - h3[0]) / (c5 - 1)), d3 && (o4 = (d3.length - 1) / (d3[d3.length - 1] - d3[0]) / (f4 - 1));\n              var v3, _2 = 1 / 0, b = -1 / 0;\n              for (i3 = 0; i3 < f4; i3++) for (u4[i3] = [], l3 = d3 ? (d3[i3] - d3[0]) * o4 : i3 / (f4 - 1), n4 = 0; n4 < c5; n4++) s3 = h3 ? (h3[n4] - h3[0]) * a4 : n4 / (c5 - 1), v3 = s3 - l3 * r4, _2 = Math.min(v3, _2), b = Math.max(v3, b), u4[i3][n4] = v3;\n              var p3 = 1 / (b - _2), k4 = -_2 * p3;\n              for (i3 = 0; i3 < f4; i3++) for (n4 = 0; n4 < c5; n4++) u4[i3][n4] = p3 * u4[i3][n4] + k4;\n              return u4;\n            };\n          });\n          var cYe = ye((O2r, uYe) => {\n            "use strict";\n            var sYe = Dr().isArrayOrTypedArray;\n            uYe.exports = function(e3) {\n              return lYe(e3, 0);\n            };\n            function lYe(e3, t3) {\n              if (!sYe(e3) || t3 >= 10) return null;\n              for (var r4 = 1 / 0, n4 = -1 / 0, i3 = e3.length, a4 = 0; a4 < i3; a4++) {\n                var o4 = e3[a4];\n                if (sYe(o4)) {\n                  var s3 = lYe(o4, t3 + 1);\n                  s3 && (r4 = Math.min(s3[0], r4), n4 = Math.max(s3[1], n4));\n                } else r4 = Math.min(o4, r4), n4 = Math.max(o4, n4);\n              }\n              return [r4, n4];\n            }\n          });\n          var hYe = ye((q2r, fYe) => {\n            "use strict";\n            var NKt = ho(), kx = Ao().extendFlat;\n            fYe.exports = function(t3, r4, n4) {\n              var i3, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3, _2, b, p3, k4 = t3["_" + r4], E3 = t3[r4 + "axis"], S2 = E3._gridlines = [], L3 = E3._minorgridlines = [], x2 = E3._boundarylines = [], C3 = t3["_" + n4], M4 = t3[n4 + "axis"];\n              E3.tickmode === "array" && (E3.tickvals = k4.slice());\n              var g3 = t3._xctrl, P3 = t3._yctrl, T3 = g3[0].length, z3 = g3.length, O3 = t3._a.length, V2 = t3._b.length;\n              NKt.prepTicks(E3), E3.tickmode === "array" && delete E3.tickvals;\n              var G2 = E3.smoothing ? 3 : 1;\n              function Z(N2) {\n                var H, te, oe, _e, Ee, Ce, me, ie, Se, Le, Ae, Fe, Pe = [], ge = [], Re = {};\n                if (r4 === "b") for (te = t3.b2j(N2), oe = Math.floor(Math.max(0, Math.min(V2 - 2, te))), _e = te - oe, Re.length = V2, Re.crossLength = O3, Re.xy = function(ce) {\n                  return t3.evalxy([], ce, te);\n                }, Re.dxy = function(ce, Ze) {\n                  return t3.dxydi([], ce, oe, Ze, _e);\n                }, H = 0; H < O3; H++) Ce = Math.min(O3 - 2, H), me = H - Ce, ie = t3.evalxy([], H, te), M4.smoothing && H > 0 && (Se = t3.dxydi([], H - 1, oe, 0, _e), Pe.push(Ee[0] + Se[0] / 3), ge.push(Ee[1] + Se[1] / 3), Le = t3.dxydi([], H - 1, oe, 1, _e), Pe.push(ie[0] - Le[0] / 3), ge.push(ie[1] - Le[1] / 3)), Pe.push(ie[0]), ge.push(ie[1]), Ee = ie;\n                else for (H = t3.a2i(N2), Ce = Math.floor(Math.max(0, Math.min(O3 - 2, H))), me = H - Ce, Re.length = O3, Re.crossLength = V2, Re.xy = function(ce) {\n                  return t3.evalxy([], H, ce);\n                }, Re.dxy = function(ce, Ze) {\n                  return t3.dxydj([], Ce, ce, me, Ze);\n                }, te = 0; te < V2; te++) oe = Math.min(V2 - 2, te), _e = te - oe, ie = t3.evalxy([], H, te), M4.smoothing && te > 0 && (Ae = t3.dxydj([], Ce, te - 1, me, 0), Pe.push(Ee[0] + Ae[0] / 3), ge.push(Ee[1] + Ae[1] / 3), Fe = t3.dxydj([], Ce, te - 1, me, 1), Pe.push(ie[0] - Fe[0] / 3), ge.push(ie[1] - Fe[1] / 3)), Pe.push(ie[0]), ge.push(ie[1]), Ee = ie;\n                return Re.axisLetter = r4, Re.axis = E3, Re.crossAxis = M4, Re.value = N2, Re.constvar = n4, Re.index = f4, Re.x = Pe, Re.y = ge, Re.smoothing = M4.smoothing, Re;\n              }\n              function j3(N2) {\n                var H, te, oe, _e, Ee, Ce = [], me = [], ie = {};\n                if (ie.length = k4.length, ie.crossLength = C3.length, r4 === "b") for (oe = Math.max(0, Math.min(V2 - 2, N2)), Ee = Math.min(1, Math.max(0, N2 - oe)), ie.xy = function(Se) {\n                  return t3.evalxy([], Se, N2);\n                }, ie.dxy = function(Se, Le) {\n                  return t3.dxydi([], Se, oe, Le, Ee);\n                }, H = 0; H < T3; H++) Ce[H] = g3[N2 * G2][H], me[H] = P3[N2 * G2][H];\n                else for (te = Math.max(0, Math.min(O3 - 2, N2)), _e = Math.min(1, Math.max(0, N2 - te)), ie.xy = function(Se) {\n                  return t3.evalxy([], N2, Se);\n                }, ie.dxy = function(Se, Le) {\n                  return t3.dxydj([], te, Se, _e, Le);\n                }, H = 0; H < z3; H++) Ce[H] = g3[H][N2 * G2], me[H] = P3[H][N2 * G2];\n                return ie.axisLetter = r4, ie.axis = E3, ie.crossAxis = M4, ie.value = k4[N2], ie.constvar = n4, ie.index = N2, ie.x = Ce, ie.y = me, ie.smoothing = M4.smoothing, ie;\n              }\n              if (E3.tickmode === "array") {\n                for (s3 = 5e-15, l3 = [Math.floor((k4.length - 1 - E3.arraytick0) / E3.arraydtick * (1 + s3)), Math.ceil(-E3.arraytick0 / E3.arraydtick / (1 + s3))].sort(function(N2, H) {\n                  return N2 - H;\n                }), u4 = l3[0] - 1, c5 = l3[1] + 1, f4 = u4; f4 < c5; f4++) a4 = E3.arraytick0 + E3.arraydtick * f4, !(a4 < 0 || a4 > k4.length - 1) && S2.push(kx(j3(a4), { color: E3.gridcolor, width: E3.gridwidth, dash: E3.griddash }));\n                for (f4 = u4; f4 < c5; f4++) if (o4 = E3.arraytick0 + E3.arraydtick * f4, v3 = Math.min(o4 + E3.arraydtick, k4.length - 1), !(o4 < 0 || o4 > k4.length - 1) && !(v3 < 0 || v3 > k4.length - 1)) for (_2 = k4[o4], b = k4[v3], i3 = 0; i3 < E3.minorgridcount; i3++) p3 = v3 - o4, !(p3 <= 0) && (d3 = _2 + (b - _2) * (i3 + 1) / (E3.minorgridcount + 1) * (E3.arraydtick / p3), !(d3 < k4[0] || d3 > k4[k4.length - 1]) && L3.push(kx(Z(d3), { color: E3.minorgridcolor, width: E3.minorgridwidth, dash: E3.minorgriddash })));\n                E3.startline && x2.push(kx(j3(0), { color: E3.startlinecolor, width: E3.startlinewidth })), E3.endline && x2.push(kx(j3(k4.length - 1), { color: E3.endlinecolor, width: E3.endlinewidth }));\n              } else {\n                for (s3 = 5e-15, l3 = [Math.floor((k4[k4.length - 1] - E3.tick0) / E3.dtick * (1 + s3)), Math.ceil((k4[0] - E3.tick0) / E3.dtick / (1 + s3))].sort(function(N2, H) {\n                  return N2 - H;\n                }), u4 = l3[0], c5 = l3[1], f4 = u4; f4 <= c5; f4++) h3 = E3.tick0 + E3.dtick * f4, S2.push(kx(Z(h3), { color: E3.gridcolor, width: E3.gridwidth, dash: E3.griddash }));\n                for (f4 = u4 - 1; f4 < c5 + 1; f4++) for (h3 = E3.tick0 + E3.dtick * f4, i3 = 0; i3 < E3.minorgridcount; i3++) d3 = h3 + E3.dtick * (i3 + 1) / (E3.minorgridcount + 1), !(d3 < k4[0] || d3 > k4[k4.length - 1]) && L3.push(kx(Z(d3), { color: E3.minorgridcolor, width: E3.minorgridwidth, dash: E3.minorgriddash }));\n                E3.startline && x2.push(kx(Z(k4[0]), { color: E3.startlinecolor, width: E3.startlinewidth })), E3.endline && x2.push(kx(Z(k4[k4.length - 1]), { color: E3.endlinecolor, width: E3.endlinewidth }));\n              }\n            };\n          });\n          var gYe = ye((B2r, pYe) => {\n            "use strict";\n            var dYe = ho(), vYe = Ao().extendFlat;\n            pYe.exports = function(t3, r4) {\n              var n4, i3, a4, o4, s3, l3 = r4._labels = [], u4 = r4._gridlines;\n              for (n4 = 0; n4 < u4.length; n4++) s3 = u4[n4], ["start", "both"].indexOf(r4.showticklabels) !== -1 && (i3 = dYe.tickText(r4, s3.value), vYe(i3, { prefix: a4, suffix: o4, endAnchor: true, xy: s3.xy(0), dxy: s3.dxy(0, 0), axis: s3.axis, length: s3.crossAxis.length, font: s3.axis.tickfont, isFirst: n4 === 0, isLast: n4 === u4.length - 1 }), l3.push(i3)), ["end", "both"].indexOf(r4.showticklabels) !== -1 && (i3 = dYe.tickText(r4, s3.value), vYe(i3, { endAnchor: false, xy: s3.xy(s3.crossLength - 1), dxy: s3.dxy(s3.crossLength - 2, 1), axis: s3.axis, length: s3.crossAxis.length, font: s3.axis.tickfont, isFirst: n4 === 0, isLast: n4 === u4.length - 1 }), l3.push(i3));\n            };\n          });\n          var yYe = ye((N2r, mYe) => {\n            "use strict";\n            mYe.exports = function(t3, r4, n4, i3) {\n              var a4, o4, s3, l3 = [], u4 = !!n4.smoothing, c5 = !!i3.smoothing, f4 = t3[0].length - 1, h3 = t3.length - 1;\n              for (a4 = 0, o4 = [], s3 = []; a4 <= f4; a4++) o4[a4] = t3[0][a4], s3[a4] = r4[0][a4];\n              for (l3.push({ x: o4, y: s3, bicubic: u4 }), a4 = 0, o4 = [], s3 = []; a4 <= h3; a4++) o4[a4] = t3[a4][f4], s3[a4] = r4[a4][f4];\n              for (l3.push({ x: o4, y: s3, bicubic: c5 }), a4 = f4, o4 = [], s3 = []; a4 >= 0; a4--) o4[f4 - a4] = t3[h3][a4], s3[f4 - a4] = r4[h3][a4];\n              for (l3.push({ x: o4, y: s3, bicubic: u4 }), a4 = h3, o4 = [], s3 = []; a4 >= 0; a4--) o4[h3 - a4] = t3[a4][0], s3[h3 - a4] = r4[a4][0];\n              return l3.push({ x: o4, y: s3, bicubic: c5 }), l3;\n            };\n          });\n          var xYe = ye((U2r, _Ye) => {\n            "use strict";\n            var UKt = Dr();\n            _Ye.exports = function(t3, r4, n4) {\n              var i3, a4, o4, s3 = [], l3 = [], u4 = t3[0].length, c5 = t3.length;\n              function f4(oe, _e) {\n                var Ee = 0, Ce, me = 0;\n                return oe > 0 && (Ce = t3[_e][oe - 1]) !== void 0 && (me++, Ee += Ce), oe < u4 - 1 && (Ce = t3[_e][oe + 1]) !== void 0 && (me++, Ee += Ce), _e > 0 && (Ce = t3[_e - 1][oe]) !== void 0 && (me++, Ee += Ce), _e < c5 - 1 && (Ce = t3[_e + 1][oe]) !== void 0 && (me++, Ee += Ce), Ee / Math.max(1, me);\n              }\n              var h3 = 0;\n              for (i3 = 0; i3 < u4; i3++) for (a4 = 0; a4 < c5; a4++) t3[a4][i3] === void 0 && (s3.push(i3), l3.push(a4), t3[a4][i3] = f4(i3, a4)), h3 = Math.max(h3, Math.abs(t3[a4][i3]));\n              if (!s3.length) return t3;\n              var d3, v3, _2, b, p3, k4, E3, S2, L3, x2, C3, M4 = 1e-5, g3 = 0, P3 = 100, T3 = 0, z3 = s3.length;\n              do {\n                for (g3 = 0, o4 = 0; o4 < z3; o4++) {\n                  i3 = s3[o4], a4 = l3[o4];\n                  var O3 = 0, V2 = 0, G2, Z, j3, N2, H, te;\n                  i3 === 0 ? (H = Math.min(u4 - 1, 2), j3 = r4[H], N2 = r4[1], G2 = t3[a4][H], Z = t3[a4][1], V2 += Z + (Z - G2) * (r4[0] - N2) / (N2 - j3), O3++) : i3 === u4 - 1 && (H = Math.max(0, u4 - 3), j3 = r4[H], N2 = r4[u4 - 2], G2 = t3[a4][H], Z = t3[a4][u4 - 2], V2 += Z + (Z - G2) * (r4[u4 - 1] - N2) / (N2 - j3), O3++), (i3 === 0 || i3 === u4 - 1) && a4 > 0 && a4 < c5 - 1 && (d3 = n4[a4 + 1] - n4[a4], v3 = n4[a4] - n4[a4 - 1], V2 += (v3 * t3[a4 + 1][i3] + d3 * t3[a4 - 1][i3]) / (v3 + d3), O3++), a4 === 0 ? (te = Math.min(c5 - 1, 2), j3 = n4[te], N2 = n4[1], G2 = t3[te][i3], Z = t3[1][i3], V2 += Z + (Z - G2) * (n4[0] - N2) / (N2 - j3), O3++) : a4 === c5 - 1 && (te = Math.max(0, c5 - 3), j3 = n4[te], N2 = n4[c5 - 2], G2 = t3[te][i3], Z = t3[c5 - 2][i3], V2 += Z + (Z - G2) * (n4[c5 - 1] - N2) / (N2 - j3), O3++), (a4 === 0 || a4 === c5 - 1) && i3 > 0 && i3 < u4 - 1 && (d3 = r4[i3 + 1] - r4[i3], v3 = r4[i3] - r4[i3 - 1], V2 += (v3 * t3[a4][i3 + 1] + d3 * t3[a4][i3 - 1]) / (v3 + d3), O3++), O3 ? V2 /= O3 : (_2 = r4[i3 + 1] - r4[i3], b = r4[i3] - r4[i3 - 1], p3 = n4[a4 + 1] - n4[a4], k4 = n4[a4] - n4[a4 - 1], E3 = _2 * b * (_2 + b), S2 = p3 * k4 * (p3 + k4), V2 = (E3 * (k4 * t3[a4 + 1][i3] + p3 * t3[a4 - 1][i3]) + S2 * (b * t3[a4][i3 + 1] + _2 * t3[a4][i3 - 1])) / (S2 * (b + _2) + E3 * (k4 + p3))), L3 = V2 - t3[a4][i3], x2 = L3 / h3, g3 += x2 * x2, C3 = O3 ? 0 : 0.85, t3[a4][i3] += L3 * (1 + C3);\n                }\n                g3 = Math.sqrt(g3);\n              } while (T3++ < P3 && g3 > M4);\n              return UKt.log("Smoother converged to", g3, "after", T3, "iterations"), t3;\n            };\n          });\n          var wYe = ye((V2r, bYe) => {\n            "use strict";\n            bYe.exports = { RELATIVE_CULL_TOLERANCE: 1e-6 };\n          });\n          var SYe = ye((G2r, AYe) => {\n            "use strict";\n            var TYe = 0.5;\n            AYe.exports = function(t3, r4, n4, i3) {\n              var a4 = t3[0] - r4[0], o4 = t3[1] - r4[1], s3 = n4[0] - r4[0], l3 = n4[1] - r4[1], u4 = Math.pow(a4 * a4 + o4 * o4, TYe / 2), c5 = Math.pow(s3 * s3 + l3 * l3, TYe / 2), f4 = (c5 * c5 * a4 - u4 * u4 * s3) * i3, h3 = (c5 * c5 * o4 - u4 * u4 * l3) * i3, d3 = c5 * (u4 + c5) * 3, v3 = u4 * (u4 + c5) * 3;\n              return [[r4[0] + (d3 && f4 / d3), r4[1] + (d3 && h3 / d3)], [r4[0] - (v3 && f4 / v3), r4[1] - (v3 && h3 / v3)]];\n            };\n          });\n          var EYe = ye((H2r, MYe) => {\n            "use strict";\n            var k$ = SYe(), K7 = Dr().ensureArray;\n            function N5(e3, t3, r4) {\n              var n4 = -0.5 * r4[0] + 1.5 * t3[0], i3 = -0.5 * r4[1] + 1.5 * t3[1];\n              return [(2 * n4 + e3[0]) / 3, (2 * i3 + e3[1]) / 3];\n            }\n            MYe.exports = function(t3, r4, n4, i3, a4, o4) {\n              var s3, l3, u4, c5, f4, h3, d3, v3, _2, b, p3 = n4[0].length, k4 = n4.length, E3 = a4 ? 3 * p3 - 2 : p3, S2 = o4 ? 3 * k4 - 2 : k4;\n              for (t3 = K7(t3, S2), r4 = K7(r4, S2), u4 = 0; u4 < S2; u4++) t3[u4] = K7(t3[u4], E3), r4[u4] = K7(r4[u4], E3);\n              for (l3 = 0, c5 = 0; l3 < k4; l3++, c5 += o4 ? 3 : 1) for (f4 = t3[c5], h3 = r4[c5], d3 = n4[l3], v3 = i3[l3], s3 = 0, u4 = 0; s3 < p3; s3++, u4 += a4 ? 3 : 1) f4[u4] = d3[s3], h3[u4] = v3[s3];\n              if (a4) for (l3 = 0, c5 = 0; l3 < k4; l3++, c5 += o4 ? 3 : 1) {\n                for (s3 = 1, u4 = 3; s3 < p3 - 1; s3++, u4 += 3) _2 = k$([n4[l3][s3 - 1], i3[l3][s3 - 1]], [n4[l3][s3], i3[l3][s3]], [n4[l3][s3 + 1], i3[l3][s3 + 1]], a4), t3[c5][u4 - 1] = _2[0][0], r4[c5][u4 - 1] = _2[0][1], t3[c5][u4 + 1] = _2[1][0], r4[c5][u4 + 1] = _2[1][1];\n                b = N5([t3[c5][0], r4[c5][0]], [t3[c5][2], r4[c5][2]], [t3[c5][3], r4[c5][3]]), t3[c5][1] = b[0], r4[c5][1] = b[1], b = N5([t3[c5][E3 - 1], r4[c5][E3 - 1]], [t3[c5][E3 - 3], r4[c5][E3 - 3]], [t3[c5][E3 - 4], r4[c5][E3 - 4]]), t3[c5][E3 - 2] = b[0], r4[c5][E3 - 2] = b[1];\n              }\n              if (o4) for (u4 = 0; u4 < E3; u4++) {\n                for (c5 = 3; c5 < S2 - 3; c5 += 3) _2 = k$([t3[c5 - 3][u4], r4[c5 - 3][u4]], [t3[c5][u4], r4[c5][u4]], [t3[c5 + 3][u4], r4[c5 + 3][u4]], o4), t3[c5 - 1][u4] = _2[0][0], r4[c5 - 1][u4] = _2[0][1], t3[c5 + 1][u4] = _2[1][0], r4[c5 + 1][u4] = _2[1][1];\n                b = N5([t3[0][u4], r4[0][u4]], [t3[2][u4], r4[2][u4]], [t3[3][u4], r4[3][u4]]), t3[1][u4] = b[0], r4[1][u4] = b[1], b = N5([t3[S2 - 1][u4], r4[S2 - 1][u4]], [t3[S2 - 3][u4], r4[S2 - 3][u4]], [t3[S2 - 4][u4], r4[S2 - 4][u4]]), t3[S2 - 2][u4] = b[0], r4[S2 - 2][u4] = b[1];\n              }\n              if (a4 && o4) for (c5 = 1; c5 < S2; c5 += (c5 + 1) % 3 === 0 ? 2 : 1) {\n                for (u4 = 3; u4 < E3 - 3; u4 += 3) _2 = k$([t3[c5][u4 - 3], r4[c5][u4 - 3]], [t3[c5][u4], r4[c5][u4]], [t3[c5][u4 + 3], r4[c5][u4 + 3]], a4), t3[c5][u4 - 1] = 0.5 * (t3[c5][u4 - 1] + _2[0][0]), r4[c5][u4 - 1] = 0.5 * (r4[c5][u4 - 1] + _2[0][1]), t3[c5][u4 + 1] = 0.5 * (t3[c5][u4 + 1] + _2[1][0]), r4[c5][u4 + 1] = 0.5 * (r4[c5][u4 + 1] + _2[1][1]);\n                b = N5([t3[c5][0], r4[c5][0]], [t3[c5][2], r4[c5][2]], [t3[c5][3], r4[c5][3]]), t3[c5][1] = 0.5 * (t3[c5][1] + b[0]), r4[c5][1] = 0.5 * (r4[c5][1] + b[1]), b = N5([t3[c5][E3 - 1], r4[c5][E3 - 1]], [t3[c5][E3 - 3], r4[c5][E3 - 3]], [t3[c5][E3 - 4], r4[c5][E3 - 4]]), t3[c5][E3 - 2] = 0.5 * (t3[c5][E3 - 2] + b[0]), r4[c5][E3 - 2] = 0.5 * (r4[c5][E3 - 2] + b[1]);\n              }\n              return [t3, r4];\n            };\n          });\n          var CYe = ye((j2r, kYe) => {\n            "use strict";\n            kYe.exports = function(e3, t3, r4, n4, i3) {\n              var a4 = t3 - 2, o4 = r4 - 2;\n              return n4 && i3 ? function(s3, l3, u4) {\n                s3 || (s3 = []);\n                var c5, f4, h3, d3, v3, _2, b = Math.max(0, Math.min(Math.floor(l3), a4)), p3 = Math.max(0, Math.min(Math.floor(u4), o4)), k4 = Math.max(0, Math.min(1, l3 - b)), E3 = Math.max(0, Math.min(1, u4 - p3));\n                b *= 3, p3 *= 3;\n                var S2 = k4 * k4, L3 = S2 * k4, x2 = 1 - k4, C3 = x2 * x2, M4 = C3 * x2, g3 = E3 * E3, P3 = g3 * E3, T3 = 1 - E3, z3 = T3 * T3, O3 = z3 * T3;\n                for (_2 = 0; _2 < e3.length; _2++) v3 = e3[_2], c5 = M4 * v3[p3][b] + 3 * (C3 * k4 * v3[p3][b + 1] + x2 * S2 * v3[p3][b + 2]) + L3 * v3[p3][b + 3], f4 = M4 * v3[p3 + 1][b] + 3 * (C3 * k4 * v3[p3 + 1][b + 1] + x2 * S2 * v3[p3 + 1][b + 2]) + L3 * v3[p3 + 1][b + 3], h3 = M4 * v3[p3 + 2][b] + 3 * (C3 * k4 * v3[p3 + 2][b + 1] + x2 * S2 * v3[p3 + 2][b + 2]) + L3 * v3[p3 + 2][b + 3], d3 = M4 * v3[p3 + 3][b] + 3 * (C3 * k4 * v3[p3 + 3][b + 1] + x2 * S2 * v3[p3 + 3][b + 2]) + L3 * v3[p3 + 3][b + 3], s3[_2] = O3 * c5 + 3 * (z3 * E3 * f4 + T3 * g3 * h3) + P3 * d3;\n                return s3;\n              } : n4 ? function(s3, l3, u4) {\n                s3 || (s3 = []);\n                var c5 = Math.max(0, Math.min(Math.floor(l3), a4)), f4 = Math.max(0, Math.min(Math.floor(u4), o4)), h3 = Math.max(0, Math.min(1, l3 - c5)), d3 = Math.max(0, Math.min(1, u4 - f4)), v3, _2, b, p3, k4, E3;\n                c5 *= 3;\n                var S2 = h3 * h3, L3 = S2 * h3, x2 = 1 - h3, C3 = x2 * x2, M4 = C3 * x2, g3 = 1 - d3;\n                for (k4 = 0; k4 < e3.length; k4++) E3 = e3[k4], v3 = g3 * E3[f4][c5] + d3 * E3[f4 + 1][c5], _2 = g3 * E3[f4][c5 + 1] + d3 * E3[f4 + 1][c5 + 1], b = g3 * E3[f4][c5 + 2] + d3 * E3[f4 + 1][c5 + 1], p3 = g3 * E3[f4][c5 + 3] + d3 * E3[f4 + 1][c5 + 1], s3[k4] = M4 * v3 + 3 * (C3 * h3 * _2 + x2 * S2 * b) + L3 * p3;\n                return s3;\n              } : i3 ? function(s3, l3, u4) {\n                s3 || (s3 = []);\n                var c5 = Math.max(0, Math.min(Math.floor(l3), a4)), f4 = Math.max(0, Math.min(Math.floor(u4), o4)), h3 = Math.max(0, Math.min(1, l3 - c5)), d3 = Math.max(0, Math.min(1, u4 - f4)), v3, _2, b, p3, k4, E3;\n                f4 *= 3;\n                var S2 = d3 * d3, L3 = S2 * d3, x2 = 1 - d3, C3 = x2 * x2, M4 = C3 * x2, g3 = 1 - h3;\n                for (k4 = 0; k4 < e3.length; k4++) E3 = e3[k4], v3 = g3 * E3[f4][c5] + h3 * E3[f4][c5 + 1], _2 = g3 * E3[f4 + 1][c5] + h3 * E3[f4 + 1][c5 + 1], b = g3 * E3[f4 + 2][c5] + h3 * E3[f4 + 2][c5 + 1], p3 = g3 * E3[f4 + 3][c5] + h3 * E3[f4 + 3][c5 + 1], s3[k4] = M4 * v3 + 3 * (C3 * d3 * _2 + x2 * S2 * b) + L3 * p3;\n                return s3;\n              } : function(s3, l3, u4) {\n                s3 || (s3 = []);\n                var c5 = Math.max(0, Math.min(Math.floor(l3), a4)), f4 = Math.max(0, Math.min(Math.floor(u4), o4)), h3 = Math.max(0, Math.min(1, l3 - c5)), d3 = Math.max(0, Math.min(1, u4 - f4)), v3, _2, b, p3, k4 = 1 - d3, E3 = 1 - h3;\n                for (b = 0; b < e3.length; b++) p3 = e3[b], v3 = E3 * p3[f4][c5] + h3 * p3[f4][c5 + 1], _2 = E3 * p3[f4 + 1][c5] + h3 * p3[f4 + 1][c5 + 1], s3[b] = k4 * v3 + d3 * _2;\n                return s3;\n              };\n            };\n          });\n          var PYe = ye((W2r, LYe) => {\n            "use strict";\n            LYe.exports = function(e3, t3, r4) {\n              return t3 && r4 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3, d3;\n                i3 *= 3, a4 *= 3;\n                var v3 = o4 * o4, _2 = 1 - o4, b = _2 * _2, p3 = _2 * o4 * 2, k4 = -3 * b, E3 = 3 * (b - p3), S2 = 3 * (p3 - v3), L3 = 3 * v3, x2 = s3 * s3, C3 = x2 * s3, M4 = 1 - s3, g3 = M4 * M4, P3 = g3 * M4;\n                for (d3 = 0; d3 < e3.length; d3++) h3 = e3[d3], l3 = k4 * h3[a4][i3] + E3 * h3[a4][i3 + 1] + S2 * h3[a4][i3 + 2] + L3 * h3[a4][i3 + 3], u4 = k4 * h3[a4 + 1][i3] + E3 * h3[a4 + 1][i3 + 1] + S2 * h3[a4 + 1][i3 + 2] + L3 * h3[a4 + 1][i3 + 3], c5 = k4 * h3[a4 + 2][i3] + E3 * h3[a4 + 2][i3 + 1] + S2 * h3[a4 + 2][i3 + 2] + L3 * h3[a4 + 2][i3 + 3], f4 = k4 * h3[a4 + 3][i3] + E3 * h3[a4 + 3][i3 + 1] + S2 * h3[a4 + 3][i3 + 2] + L3 * h3[a4 + 3][i3 + 3], n4[d3] = P3 * l3 + 3 * (g3 * s3 * u4 + M4 * x2 * c5) + C3 * f4;\n                return n4;\n              } : t3 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4;\n                i3 *= 3;\n                var h3 = o4 * o4, d3 = 1 - o4, v3 = d3 * d3, _2 = d3 * o4 * 2, b = -3 * v3, p3 = 3 * (v3 - _2), k4 = 3 * (_2 - h3), E3 = 3 * h3, S2 = 1 - s3;\n                for (c5 = 0; c5 < e3.length; c5++) f4 = e3[c5], l3 = b * f4[a4][i3] + p3 * f4[a4][i3 + 1] + k4 * f4[a4][i3 + 2] + E3 * f4[a4][i3 + 3], u4 = b * f4[a4 + 1][i3] + p3 * f4[a4 + 1][i3 + 1] + k4 * f4[a4 + 1][i3 + 2] + E3 * f4[a4 + 1][i3 + 3], n4[c5] = S2 * l3 + s3 * u4;\n                return n4;\n              } : r4 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3, d3;\n                a4 *= 3;\n                var v3 = s3 * s3, _2 = v3 * s3, b = 1 - s3, p3 = b * b, k4 = p3 * b;\n                for (h3 = 0; h3 < e3.length; h3++) d3 = e3[h3], l3 = d3[a4][i3 + 1] - d3[a4][i3], u4 = d3[a4 + 1][i3 + 1] - d3[a4 + 1][i3], c5 = d3[a4 + 2][i3 + 1] - d3[a4 + 2][i3], f4 = d3[a4 + 3][i3 + 1] - d3[a4 + 3][i3], n4[h3] = k4 * l3 + 3 * (p3 * s3 * u4 + b * v3 * c5) + _2 * f4;\n                return n4;\n              } : function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3 = 1 - s3;\n                for (c5 = 0; c5 < e3.length; c5++) f4 = e3[c5], l3 = f4[a4][i3 + 1] - f4[a4][i3], u4 = f4[a4 + 1][i3 + 1] - f4[a4 + 1][i3], n4[c5] = h3 * l3 + s3 * u4;\n                return n4;\n              };\n            };\n          });\n          var RYe = ye((X2r, IYe) => {\n            "use strict";\n            IYe.exports = function(e3, t3, r4) {\n              return t3 && r4 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3, d3;\n                i3 *= 3, a4 *= 3;\n                var v3 = o4 * o4, _2 = v3 * o4, b = 1 - o4, p3 = b * b, k4 = p3 * b, E3 = s3 * s3, S2 = 1 - s3, L3 = S2 * S2, x2 = S2 * s3 * 2, C3 = -3 * L3, M4 = 3 * (L3 - x2), g3 = 3 * (x2 - E3), P3 = 3 * E3;\n                for (d3 = 0; d3 < e3.length; d3++) h3 = e3[d3], l3 = C3 * h3[a4][i3] + M4 * h3[a4 + 1][i3] + g3 * h3[a4 + 2][i3] + P3 * h3[a4 + 3][i3], u4 = C3 * h3[a4][i3 + 1] + M4 * h3[a4 + 1][i3 + 1] + g3 * h3[a4 + 2][i3 + 1] + P3 * h3[a4 + 3][i3 + 1], c5 = C3 * h3[a4][i3 + 2] + M4 * h3[a4 + 1][i3 + 2] + g3 * h3[a4 + 2][i3 + 2] + P3 * h3[a4 + 3][i3 + 2], f4 = C3 * h3[a4][i3 + 3] + M4 * h3[a4 + 1][i3 + 3] + g3 * h3[a4 + 2][i3 + 3] + P3 * h3[a4 + 3][i3 + 3], n4[d3] = k4 * l3 + 3 * (p3 * o4 * u4 + b * v3 * c5) + _2 * f4;\n                return n4;\n              } : t3 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3, d3;\n                i3 *= 3;\n                var v3 = s3 * s3, _2 = v3 * s3, b = 1 - s3, p3 = b * b, k4 = p3 * b;\n                for (h3 = 0; h3 < e3.length; h3++) d3 = e3[h3], l3 = d3[a4 + 1][i3] - d3[a4][i3], u4 = d3[a4 + 1][i3 + 1] - d3[a4][i3 + 1], c5 = d3[a4 + 1][i3 + 2] - d3[a4][i3 + 2], f4 = d3[a4 + 1][i3 + 3] - d3[a4][i3 + 3], n4[h3] = k4 * l3 + 3 * (p3 * s3 * u4 + b * v3 * c5) + _2 * f4;\n                return n4;\n              } : r4 ? function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4;\n                a4 *= 3;\n                var h3 = 1 - o4, d3 = s3 * s3, v3 = 1 - s3, _2 = v3 * v3, b = v3 * s3 * 2, p3 = -3 * _2, k4 = 3 * (_2 - b), E3 = 3 * (b - d3), S2 = 3 * d3;\n                for (c5 = 0; c5 < e3.length; c5++) f4 = e3[c5], l3 = p3 * f4[a4][i3] + k4 * f4[a4 + 1][i3] + E3 * f4[a4 + 2][i3] + S2 * f4[a4 + 3][i3], u4 = p3 * f4[a4][i3 + 1] + k4 * f4[a4 + 1][i3 + 1] + E3 * f4[a4 + 2][i3 + 1] + S2 * f4[a4 + 3][i3 + 1], n4[c5] = h3 * l3 + o4 * u4;\n                return n4;\n              } : function(n4, i3, a4, o4, s3) {\n                n4 || (n4 = []);\n                var l3, u4, c5, f4, h3 = 1 - o4;\n                for (c5 = 0; c5 < e3.length; c5++) f4 = e3[c5], l3 = f4[a4 + 1][i3] - f4[a4][i3], u4 = f4[a4 + 1][i3 + 1] - f4[a4][i3 + 1], n4[c5] = h3 * l3 + o4 * u4;\n                return n4;\n              };\n            };\n          });\n          var OYe = ye((Z2r, zYe) => {\n            "use strict";\n            var DYe = wYe(), FYe = R6().findBin, VKt = EYe(), GKt = CYe(), HKt = PYe(), jKt = RYe();\n            zYe.exports = function(t3) {\n              var r4 = t3._a, n4 = t3._b, i3 = r4.length, a4 = n4.length, o4 = t3.aaxis, s3 = t3.baxis, l3 = r4[0], u4 = r4[i3 - 1], c5 = n4[0], f4 = n4[a4 - 1], h3 = r4[r4.length - 1] - r4[0], d3 = n4[n4.length - 1] - n4[0], v3 = h3 * DYe.RELATIVE_CULL_TOLERANCE, _2 = d3 * DYe.RELATIVE_CULL_TOLERANCE;\n              l3 -= v3, u4 += v3, c5 -= _2, f4 += _2, t3.isVisible = function(b, p3) {\n                return b > l3 && b < u4 && p3 > c5 && p3 < f4;\n              }, t3.isOccluded = function(b, p3) {\n                return b < l3 || b > u4 || p3 < c5 || p3 > f4;\n              }, t3.setScale = function() {\n                var b = t3._x, p3 = t3._y, k4 = VKt(t3._xctrl, t3._yctrl, b, p3, o4.smoothing, s3.smoothing);\n                t3._xctrl = k4[0], t3._yctrl = k4[1], t3.evalxy = GKt([t3._xctrl, t3._yctrl], i3, a4, o4.smoothing, s3.smoothing), t3.dxydi = HKt([t3._xctrl, t3._yctrl], o4.smoothing, s3.smoothing), t3.dxydj = jKt([t3._xctrl, t3._yctrl], o4.smoothing, s3.smoothing);\n              }, t3.i2a = function(b) {\n                var p3 = Math.max(0, Math.floor(b[0]), i3 - 2), k4 = b[0] - p3;\n                return (1 - k4) * r4[p3] + k4 * r4[p3 + 1];\n              }, t3.j2b = function(b) {\n                var p3 = Math.max(0, Math.floor(b[1]), i3 - 2), k4 = b[1] - p3;\n                return (1 - k4) * n4[p3] + k4 * n4[p3 + 1];\n              }, t3.ij2ab = function(b) {\n                return [t3.i2a(b[0]), t3.j2b(b[1])];\n              }, t3.a2i = function(b) {\n                var p3 = Math.max(0, Math.min(FYe(b, r4), i3 - 2)), k4 = r4[p3], E3 = r4[p3 + 1];\n                return Math.max(0, Math.min(i3 - 1, p3 + (b - k4) / (E3 - k4)));\n              }, t3.b2j = function(b) {\n                var p3 = Math.max(0, Math.min(FYe(b, n4), a4 - 2)), k4 = n4[p3], E3 = n4[p3 + 1];\n                return Math.max(0, Math.min(a4 - 1, p3 + (b - k4) / (E3 - k4)));\n              }, t3.ab2ij = function(b) {\n                return [t3.a2i(b[0]), t3.b2j(b[1])];\n              }, t3.i2c = function(b, p3) {\n                return t3.evalxy([], b, p3);\n              }, t3.ab2xy = function(b, p3, k4) {\n                if (!k4 && (b < r4[0] || b > r4[i3 - 1] | p3 < n4[0] || p3 > n4[a4 - 1])) return [false, false];\n                var E3 = t3.a2i(b), S2 = t3.b2j(p3), L3 = t3.evalxy([], E3, S2);\n                if (k4) {\n                  var x2 = 0, C3 = 0, M4 = [], g3, P3, T3, z3;\n                  b < r4[0] ? (g3 = 0, P3 = 0, x2 = (b - r4[0]) / (r4[1] - r4[0])) : b > r4[i3 - 1] ? (g3 = i3 - 2, P3 = 1, x2 = (b - r4[i3 - 1]) / (r4[i3 - 1] - r4[i3 - 2])) : (g3 = Math.max(0, Math.min(i3 - 2, Math.floor(E3))), P3 = E3 - g3), p3 < n4[0] ? (T3 = 0, z3 = 0, C3 = (p3 - n4[0]) / (n4[1] - n4[0])) : p3 > n4[a4 - 1] ? (T3 = a4 - 2, z3 = 1, C3 = (p3 - n4[a4 - 1]) / (n4[a4 - 1] - n4[a4 - 2])) : (T3 = Math.max(0, Math.min(a4 - 2, Math.floor(S2))), z3 = S2 - T3), x2 && (t3.dxydi(M4, g3, T3, P3, z3), L3[0] += M4[0] * x2, L3[1] += M4[1] * x2), C3 && (t3.dxydj(M4, g3, T3, P3, z3), L3[0] += M4[0] * C3, L3[1] += M4[1] * C3);\n                }\n                return L3;\n              }, t3.c2p = function(b, p3, k4) {\n                return [p3.c2p(b[0]), k4.c2p(b[1])];\n              }, t3.p2x = function(b, p3, k4) {\n                return [p3.p2c(b[0]), k4.p2c(b[1])];\n              }, t3.dadi = function(b) {\n                var p3 = Math.max(0, Math.min(r4.length - 2, b));\n                return r4[p3 + 1] - r4[p3];\n              }, t3.dbdj = function(b) {\n                var p3 = Math.max(0, Math.min(n4.length - 2, b));\n                return n4[p3 + 1] - n4[p3];\n              }, t3.dxyda = function(b, p3, k4, E3) {\n                var S2 = t3.dxydi(null, b, p3, k4, E3), L3 = t3.dadi(b, k4);\n                return [S2[0] / L3, S2[1] / L3];\n              }, t3.dxydb = function(b, p3, k4, E3) {\n                var S2 = t3.dxydj(null, b, p3, k4, E3), L3 = t3.dbdj(p3, E3);\n                return [S2[0] / L3, S2[1] / L3];\n              }, t3.dxyda_rough = function(b, p3, k4) {\n                var E3 = h3 * (k4 || 0.1), S2 = t3.ab2xy(b + E3, p3, true), L3 = t3.ab2xy(b - E3, p3, true);\n                return [(S2[0] - L3[0]) * 0.5 / E3, (S2[1] - L3[1]) * 0.5 / E3];\n              }, t3.dxydb_rough = function(b, p3, k4) {\n                var E3 = d3 * (k4 || 0.1), S2 = t3.ab2xy(b, p3 + E3, true), L3 = t3.ab2xy(b, p3 - E3, true);\n                return [(S2[0] - L3[0]) * 0.5 / E3, (S2[1] - L3[1]) * 0.5 / E3];\n              }, t3.dpdx = function(b) {\n                return b._m;\n              }, t3.dpdy = function(b) {\n                return b._m;\n              };\n            };\n          });\n          var jYe = ye((Y2r, HYe) => {\n            "use strict";\n            var J7 = ho(), qYe = Dr().isArray1D, WKt = oYe(), BYe = cYe(), NYe = hYe(), UYe = gYe(), XKt = yYe(), VYe = a8(), GYe = xYe(), ZKt = i8(), YKt = OYe();\n            HYe.exports = function(t3, r4) {\n              var n4 = J7.getFromId(t3, r4.xaxis), i3 = J7.getFromId(t3, r4.yaxis), a4 = r4.aaxis, o4 = r4.baxis, s3 = r4.x, l3 = r4.y, u4 = [];\n              s3 && qYe(s3) && u4.push("x"), l3 && qYe(l3) && u4.push("y"), u4.length && ZKt(r4, a4, o4, "a", "b", u4);\n              var c5 = r4._a = r4._a || r4.a, f4 = r4._b = r4._b || r4.b;\n              s3 = r4._x || r4.x, l3 = r4._y || r4.y;\n              var h3 = {};\n              if (r4._cheater) {\n                var d3 = a4.cheatertype === "index" ? c5.length : c5, v3 = o4.cheatertype === "index" ? f4.length : f4;\n                s3 = WKt(d3, v3, r4.cheaterslope);\n              }\n              r4._x = s3 = VYe(s3), r4._y = l3 = VYe(l3), GYe(s3, c5, f4), GYe(l3, c5, f4), YKt(r4), r4.setScale();\n              var _2 = BYe(s3), b = BYe(l3), p3 = 0.5 * (_2[1] - _2[0]), k4 = 0.5 * (_2[1] + _2[0]), E3 = 0.5 * (b[1] - b[0]), S2 = 0.5 * (b[1] + b[0]), L3 = 1.3;\n              return _2 = [k4 - p3 * L3, k4 + p3 * L3], b = [S2 - E3 * L3, S2 + E3 * L3], r4._extremes[n4._id] = J7.findExtremes(n4, _2, { padded: true }), r4._extremes[i3._id] = J7.findExtremes(i3, b, { padded: true }), NYe(r4, "a", "b"), NYe(r4, "b", "a"), UYe(r4, a4), UYe(r4, o4), h3.clipsegments = XKt(r4._xctrl, r4._yctrl, a4, o4), h3.x = s3, h3.y = l3, h3.a = c5, h3.b = f4, [h3];\n            };\n          });\n          var XYe = ye((K2r, WYe) => {\n            "use strict";\n            WYe.exports = { attributes: H7(), supplyDefaults: WZe(), plot: nYe(), calc: jYe(), animatable: true, isContainer: true, moduleType: "trace", name: "carpet", basePlotModule: ph(), categories: ["cartesian", "svg", "carpet", "carpetAxis", "notLegendIsolatable", "noMultiCategory", "noHover", "noSortingByValue"], meta: {} };\n          });\n          var YYe = ye((J2r, ZYe) => {\n            "use strict";\n            ZYe.exports = XYe();\n          });\n          var C$ = ye(($2r, $Ye) => {\n            "use strict";\n            var KKt = Cg(), u0 = pf(), JKt = Gl(), { hovertemplateAttrs: $Kt, texttemplateAttrs: QKt, templatefallbackAttrs: KYe } = Ll(), JYe = Tu(), Cx = Ao().extendFlat, sg = u0.marker, U5 = u0.line, eJt = sg.line;\n            $Ye.exports = { carpet: { valType: "string", editType: "calc" }, a: { valType: "data_array", editType: "calc" }, b: { valType: "data_array", editType: "calc" }, mode: Cx({}, u0.mode, { dflt: "markers" }), text: Cx({}, u0.text, {}), texttemplate: QKt({ editType: "plot" }, { keys: ["a", "b", "text"] }), texttemplatefallback: KYe({ editType: "plot" }), hovertext: Cx({}, u0.hovertext, {}), line: { color: U5.color, width: U5.width, dash: U5.dash, backoff: U5.backoff, shape: Cx({}, U5.shape, { values: ["linear", "spline"] }), smoothing: U5.smoothing, editType: "calc" }, connectgaps: u0.connectgaps, fill: Cx({}, u0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: KKt(), marker: Cx({ symbol: sg.symbol, opacity: sg.opacity, maxdisplayed: sg.maxdisplayed, angle: sg.angle, angleref: sg.angleref, standoff: sg.standoff, size: sg.size, sizeref: sg.sizeref, sizemin: sg.sizemin, sizemode: sg.sizemode, line: Cx({ width: eJt.width, editType: "calc" }, JYe("marker.line")), gradient: sg.gradient, editType: "calc" }, JYe("marker")), textfont: u0.textfont, textposition: u0.textposition, selected: u0.selected, unselected: u0.unselected, hoverinfo: Cx({}, JKt.hoverinfo, { flags: ["a", "b", "text", "name"] }), hoveron: u0.hoveron, hovertemplate: $Kt(), hovertemplatefallback: KYe(), zorder: u0.zorder };\n          });\n          var rKe = ye((Q2r, tKe) => {\n            "use strict";\n            var QYe = Dr(), tJt = Sm(), V5 = Ru(), rJt = $p(), iJt = R0(), eKe = tT(), nJt = D0(), aJt = Rg(), oJt = C$();\n            tKe.exports = function(t3, r4, n4, i3) {\n              function a4(h3, d3) {\n                return QYe.coerce(t3, r4, oJt, h3, d3);\n              }\n              a4("carpet"), r4.xaxis = "x", r4.yaxis = "y";\n              var o4 = a4("a"), s3 = a4("b"), l3 = Math.min(o4.length, s3.length);\n              if (!l3) {\n                r4.visible = false;\n                return;\n              }\n              r4._length = l3, a4("text"), a4("texttemplate"), a4("texttemplatefallback"), a4("hovertext");\n              var u4 = l3 < tJt.PTS_LINESONLY ? "lines+markers" : "lines";\n              a4("mode", u4), V5.hasMarkers(r4) && rJt(t3, r4, n4, i3, a4, { gradient: true }), V5.hasLines(r4) && (iJt(t3, r4, n4, i3, a4, { backoff: true }), eKe(t3, r4, a4), a4("connectgaps")), V5.hasText(r4) && nJt(t3, r4, i3, a4);\n              var c5 = [];\n              (V5.hasMarkers(r4) || V5.hasText(r4)) && (a4("marker.maxdisplayed"), c5.push("points")), a4("fill"), r4.fill !== "none" && (aJt(t3, r4, n4, a4), V5.hasLines(r4) || eKe(t3, r4, a4)), (r4.fill === "tonext" || r4.fill === "toself") && c5.push("fills");\n              var f4 = a4("hoveron", c5.join("+") || "points");\n              f4 !== "fills" && (a4("hovertemplate"), a4("hovertemplatefallback")), a4("zorder"), QYe.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var nKe = ye((ewr, iKe) => {\n            "use strict";\n            iKe.exports = function(t3, r4) {\n              var n4 = {}, i3 = r4._carpet, a4 = i3.ab2ij([t3.a, t3.b]), o4 = Math.floor(a4[0]), s3 = a4[0] - o4, l3 = Math.floor(a4[1]), u4 = a4[1] - l3, c5 = i3.evalxy([], o4, l3, s3, u4);\n              return n4.yLabel = c5[1].toFixed(3), n4;\n            };\n          });\n          var $7 = ye((twr, aKe) => {\n            "use strict";\n            aKe.exports = function(e3, t3) {\n              for (var r4 = e3._fullData.length, n4, i3 = 0; i3 < r4; i3++) {\n                var a4 = e3._fullData[i3];\n                if (a4.index !== t3.index && a4.type === "carpet" && (n4 || (n4 = a4), a4.carpet === t3.carpet)) return a4;\n              }\n              return n4;\n            };\n          });\n          var lKe = ye((rwr, sKe) => {\n            "use strict";\n            var oKe = Eo(), sJt = F0(), lJt = km(), uJt = z0(), cJt = O0().calcMarkerSize, fJt = $7();\n            sKe.exports = function(t3, r4) {\n              var n4 = r4._carpetTrace = fJt(t3, r4);\n              if (!(!n4 || !n4.visible || n4.visible === "legendonly")) {\n                var i3;\n                r4.xaxis = n4.xaxis, r4.yaxis = n4.yaxis;\n                var a4 = r4._length, o4 = new Array(a4), s3, l3, u4 = false;\n                for (i3 = 0; i3 < a4; i3++) if (s3 = r4.a[i3], l3 = r4.b[i3], oKe(s3) && oKe(l3)) {\n                  var c5 = n4.ab2xy(+s3, +l3, true), f4 = n4.isVisible(+s3, +l3);\n                  f4 || (u4 = true), o4[i3] = { x: c5[0], y: c5[1], a: s3, b: l3, vis: f4 };\n                } else o4[i3] = { x: false, y: false };\n                return r4._needsCull = u4, o4[0].carpet = n4, o4[0].trace = r4, cJt(r4, a4), sJt(t3, r4), lJt(o4, r4), uJt(o4, r4), o4;\n              }\n            };\n          });\n          var fKe = ye((iwr, cKe) => {\n            "use strict";\n            var hJt = sT(), uKe = ho(), dJt = So();\n            cKe.exports = function(t3, r4, n4, i3) {\n              var a4, o4, s3, l3 = n4[0][0].carpet, u4 = uKe.getFromId(t3, l3.xaxis || "x"), c5 = uKe.getFromId(t3, l3.yaxis || "y"), f4 = { xaxis: u4, yaxis: c5, plot: r4.plot };\n              for (a4 = 0; a4 < n4.length; a4++) o4 = n4[a4][0].trace, o4._xA = u4, o4._yA = c5;\n              for (hJt(t3, f4, n4, i3), a4 = 0; a4 < n4.length; a4++) o4 = n4[a4][0].trace, s3 = i3.selectAll("g.trace" + o4.uid + " .js-line"), dJt.setClipUrl(s3, n4[a4][0].carpet._clipPathId, t3);\n            };\n          });\n          var dKe = ye((nwr, hKe) => {\n            "use strict";\n            var vJt = fT(), pJt = Dr().fillText;\n            hKe.exports = function(t3, r4, n4, i3) {\n              var a4 = vJt(t3, r4, n4, i3);\n              if (!a4 || a4[0].index === false) return;\n              var o4 = a4[0];\n              if (o4.index === void 0) {\n                var s3 = 1 - o4.y0 / t3.ya._length, l3 = t3.xa._length, u4 = l3 * s3 / 2, c5 = l3 - u4;\n                return o4.x0 = Math.max(Math.min(o4.x0, c5), u4), o4.x1 = Math.max(Math.min(o4.x1, c5), u4), a4;\n              }\n              var f4 = o4.cd[o4.index];\n              o4.a = f4.a, o4.b = f4.b, o4.xLabelVal = void 0, o4.yLabelVal = void 0;\n              var h3 = o4.trace, d3 = h3._carpet, v3 = h3._module.formatLabels(f4, h3);\n              o4.yLabel = v3.yLabel, delete o4.text;\n              var _2 = [];\n              function b(E3, S2) {\n                var L3;\n                E3.labelprefix && E3.labelprefix.length > 0 ? L3 = E3.labelprefix.replace(/ = $/, "") : L3 = E3._hovertitle, _2.push(L3 + ": " + S2.toFixed(3) + E3.labelsuffix);\n              }\n              if (!h3.hovertemplate) {\n                var p3 = f4.hi || h3.hoverinfo, k4 = p3.split("+");\n                k4.indexOf("all") !== -1 && (k4 = ["a", "b", "text"]), k4.indexOf("a") !== -1 && b(d3.aaxis, f4.a), k4.indexOf("b") !== -1 && b(d3.baxis, f4.b), _2.push("y: " + o4.yLabel), k4.indexOf("text") !== -1 && pJt(f4, h3, _2), o4.extraText = _2.join("<br>");\n              }\n              return a4;\n            };\n          });\n          var pKe = ye((awr, vKe) => {\n            "use strict";\n            vKe.exports = function(t3, r4, n4, i3, a4) {\n              var o4 = i3[a4];\n              return t3.a = o4.a, t3.b = o4.b, t3.y = o4.y, t3;\n            };\n          });\n          var mKe = ye((owr, gKe) => {\n            "use strict";\n            gKe.exports = { attributes: C$(), supplyDefaults: rKe(), colorbar: $d(), formatLabels: nKe(), calc: lKe(), plot: fKe(), style: op().style, styleOnSelect: op().styleOnSelect, hoverPoints: dKe(), selectPoints: hT(), eventData: pKe(), moduleType: "trace", name: "scattercarpet", basePlotModule: ph(), categories: ["svg", "carpet", "symbols", "showLegend", "carpetDependent", "zoomScale"], meta: {} };\n          });\n          var _Ke = ye((swr, yKe) => {\n            "use strict";\n            yKe.exports = mKe();\n          });\n          var L$ = ye((lwr, xKe) => {\n            "use strict";\n            var lg = PT(), g1 = C4(), gJt = Tu(), mJt = Ao().extendFlat, ry = g1.contours;\n            xKe.exports = mJt({ carpet: { valType: "string", editType: "calc" }, z: lg.z, a: lg.x, a0: lg.x0, da: lg.dx, b: lg.y, b0: lg.y0, db: lg.dy, text: lg.text, hovertext: lg.hovertext, transpose: lg.transpose, atype: lg.xtype, btype: lg.ytype, fillcolor: g1.fillcolor, autocontour: g1.autocontour, ncontours: g1.ncontours, contours: { type: ry.type, start: ry.start, end: ry.end, size: ry.size, coloring: { valType: "enumerated", values: ["fill", "lines", "none"], dflt: "fill", editType: "calc" }, showlines: ry.showlines, showlabels: ry.showlabels, labelfont: ry.labelfont, labelformat: ry.labelformat, operation: ry.operation, value: ry.value, editType: "calc", impliedEdits: { autocontour: false } }, line: { color: g1.line.color, width: g1.line.width, dash: g1.line.dash, smoothing: g1.line.smoothing, editType: "plot" }, zorder: g1.zorder }, gJt("", { cLetter: "z", autoColorDflt: false }));\n          });\n          var P$ = ye((uwr, TKe) => {\n            "use strict";\n            var bKe = Dr(), yJt = e8(), wKe = L$(), _Jt = MG(), xJt = A8(), bJt = S8();\n            TKe.exports = function(t3, r4, n4, i3) {\n              function a4(u4, c5) {\n                return bKe.coerce(t3, r4, wKe, u4, c5);\n              }\n              function o4(u4) {\n                return bKe.coerce2(t3, r4, wKe, u4);\n              }\n              if (a4("carpet"), t3.a && t3.b) {\n                var s3 = yJt(t3, r4, a4, i3, "a", "b");\n                if (!s3) {\n                  r4.visible = false;\n                  return;\n                }\n                a4("text");\n                var l3 = a4("contours.type") === "constraint";\n                l3 ? _Jt(t3, r4, a4, i3, n4, { hasHover: false }) : (xJt(t3, r4, a4, o4), bJt(t3, r4, a4, i3, { hasHover: false }));\n              } else r4._defaultColor = n4, r4._length = null;\n              a4("zorder");\n            };\n          });\n          var EKe = ye((cwr, MKe) => {\n            "use strict";\n            var wJt = gv(), AKe = Dr(), TJt = i8(), AJt = a8(), SJt = o8(), MJt = s8(), SKe = YV(), EJt = P$(), kJt = $7(), CJt = vG();\n            MKe.exports = function(t3, r4) {\n              var n4 = r4._carpetTrace = kJt(t3, r4);\n              if (!(!n4 || !n4.visible || n4.visible === "legendonly")) {\n                if (!r4.a || !r4.b) {\n                  var i3 = t3.data[n4.index], a4 = t3.data[r4.index];\n                  a4.a || (a4.a = i3.a), a4.b || (a4.b = i3.b), EJt(a4, r4, r4._defaultColor, t3._fullLayout);\n                }\n                var o4 = LJt(t3, r4);\n                return CJt(r4, r4._z), o4;\n              }\n            };\n            function LJt(e3, t3) {\n              var r4 = t3._carpetTrace, n4 = r4.aaxis, i3 = r4.baxis, a4, o4, s3, l3, u4, c5, f4;\n              n4._minDtick = 0, i3._minDtick = 0, AKe.isArray1D(t3.z) && TJt(t3, n4, i3, "a", "b", ["z"]), a4 = t3._a = t3._a || t3.a, l3 = t3._b = t3._b || t3.b, a4 = a4 ? n4.makeCalcdata(t3, "_a") : [], l3 = l3 ? i3.makeCalcdata(t3, "_b") : [], o4 = t3.a0 || 0, s3 = t3.da || 1, u4 = t3.b0 || 0, c5 = t3.db || 1, f4 = t3._z = AJt(t3._z || t3.z, t3.transpose), t3._emptypoints = MJt(f4), SJt(f4, t3._emptypoints);\n              var h3 = AKe.maxRowLength(f4), d3 = t3.xtype === "scaled" ? "" : a4, v3 = SKe(t3, d3, o4, s3, h3, n4), _2 = t3.ytype === "scaled" ? "" : l3, b = SKe(t3, _2, u4, c5, f4.length, i3), p3 = { a: v3, b, z: f4 };\n              return t3.contours.type === "levels" && t3.contours.coloring !== "none" && wJt(e3, t3, { vals: f4, containerStr: "", cLetter: "z" }), [p3];\n            }\n          });\n          var CKe = ye((fwr, kKe) => {\n            "use strict";\n            var PJt = Dr().isArrayOrTypedArray;\n            kKe.exports = function(e3, t3, r4, n4) {\n              var i3, a4, o4, s3, l3, u4, c5, f4, h3, d3, v3, _2, b, p3 = PJt(r4) ? "a" : "b", k4 = p3 === "a" ? e3.aaxis : e3.baxis, E3 = k4.smoothing, S2 = p3 === "a" ? e3.a2i : e3.b2j, L3 = p3 === "a" ? r4 : n4, x2 = p3 === "a" ? n4 : r4, C3 = p3 === "a" ? t3.a.length : t3.b.length, M4 = p3 === "a" ? t3.b.length : t3.a.length, g3 = Math.floor(p3 === "a" ? e3.b2j(x2) : e3.a2i(x2)), P3 = p3 === "a" ? function(_e) {\n                return e3.evalxy([], _e, g3);\n              } : function(_e) {\n                return e3.evalxy([], g3, _e);\n              };\n              E3 && (o4 = Math.max(0, Math.min(M4 - 2, g3)), s3 = g3 - o4, a4 = p3 === "a" ? function(_e, Ee) {\n                return e3.dxydi([], _e, o4, Ee, s3);\n              } : function(_e, Ee) {\n                return e3.dxydj([], o4, _e, s3, Ee);\n              });\n              var T3 = S2(L3[0]), z3 = S2(L3[1]), O3 = T3 < z3 ? 1 : -1, V2 = (z3 - T3) * 1e-8, G2 = O3 > 0 ? Math.floor : Math.ceil, Z = O3 > 0 ? Math.ceil : Math.floor, j3 = O3 > 0 ? Math.min : Math.max, N2 = O3 > 0 ? Math.max : Math.min, H = G2(T3 + V2), te = Z(z3 - V2);\n              c5 = P3(T3);\n              var oe = [[c5]];\n              for (i3 = H; i3 * O3 < te * O3; i3 += O3) l3 = [], v3 = N2(T3, i3), _2 = j3(z3, i3 + O3), b = _2 - v3, u4 = Math.max(0, Math.min(C3 - 2, Math.floor(0.5 * (v3 + _2)))), f4 = P3(_2), E3 && (h3 = a4(u4, v3 - u4), d3 = a4(u4, _2 - u4), l3.push([c5[0] + h3[0] / 3 * b, c5[1] + h3[1] / 3 * b]), l3.push([f4[0] - d3[0] / 3 * b, f4[1] - d3[1] / 3 * b])), l3.push(f4), oe.push(l3), c5 = f4;\n              return oe;\n            };\n          });\n          var zKe = ye((hwr, FKe) => {\n            "use strict";\n            var e9 = Oa(), t9 = S$(), DKe = M$(), sC = So(), m1 = Dr(), IJt = gG(), RJt = mG(), vw = k8(), Q7 = P4(), DJt = bG(), FJt = xG(), zJt = wG(), OJt = $7(), LKe = CKe();\n            FKe.exports = function(t3, r4, n4, i3) {\n              var a4 = r4.xaxis, o4 = r4.yaxis;\n              m1.makeTraceGroups(i3, n4, "contour").each(function(s3) {\n                var l3 = e9.select(this), u4 = s3[0], c5 = u4.trace, f4 = c5._carpetTrace = OJt(t3, c5), h3 = t3.calcdata[f4.index][0];\n                if (!f4.visible || f4.visible === "legendonly") return;\n                var d3 = u4.a, v3 = u4.b, _2 = c5.contours, b = FJt(_2, r4, u4), p3 = _2.type === "constraint", k4 = _2._operation, E3 = p3 ? k4 === "=" ? "lines" : "fill" : _2.coloring;\n                function S2(G2) {\n                  var Z = f4.ab2xy(G2[0], G2[1], true);\n                  return [a4.c2p(Z[0]), o4.c2p(Z[1])];\n                }\n                var L3 = [[d3[0], v3[v3.length - 1]], [d3[d3.length - 1], v3[v3.length - 1]], [d3[d3.length - 1], v3[0]], [d3[0], v3[0]]];\n                IJt(b);\n                var x2 = (d3[d3.length - 1] - d3[0]) * 1e-8, C3 = (v3[v3.length - 1] - v3[0]) * 1e-8;\n                RJt(b, x2, C3);\n                var M4 = b;\n                _2.type === "constraint" && (M4 = DJt(b, k4)), qJt(b, S2);\n                var g3, P3, T3, z3, O3 = [];\n                for (z3 = h3.clipsegments.length - 1; z3 >= 0; z3--) g3 = h3.clipsegments[z3], P3 = t9([], g3.x, a4.c2p), T3 = t9([], g3.y, o4.c2p), P3.reverse(), T3.reverse(), O3.push(DKe(P3, T3, g3.bicubic));\n                var V2 = "M" + O3.join("L") + "Z";\n                UJt(l3, h3.clipsegments, a4, o4, p3, E3), VJt(c5, l3, a4, o4, M4, L3, S2, f4, h3, E3, V2), BJt(l3, b, t3, u4, _2, r4, f4), sC.setClipUrl(l3, f4._clipPathId, t3);\n              });\n            };\n            function qJt(e3, t3) {\n              var r4, n4, i3, a4, o4, s3, l3, u4, c5;\n              for (r4 = 0; r4 < e3.length; r4++) {\n                for (a4 = e3[r4], o4 = a4.pedgepaths = [], s3 = a4.ppaths = [], n4 = 0; n4 < a4.edgepaths.length; n4++) {\n                  for (c5 = a4.edgepaths[n4], l3 = [], i3 = 0; i3 < c5.length; i3++) l3[i3] = t3(c5[i3]);\n                  o4.push(l3);\n                }\n                for (n4 = 0; n4 < a4.paths.length; n4++) {\n                  for (c5 = a4.paths[n4], u4 = [], i3 = 0; i3 < c5.length; i3++) u4[i3] = t3(c5[i3]);\n                  s3.push(u4);\n                }\n              }\n            }\n            function BJt(e3, t3, r4, n4, i3, a4, o4) {\n              var s3 = r4._context.staticPlot, l3 = m1.ensureSingle(e3, "g", "contourlines"), u4 = i3.showlines !== false, c5 = i3.showlabels, f4 = u4 && c5, h3 = vw.createLines(l3, u4 || c5, t3, s3), d3 = vw.createLineClip(l3, f4, r4, n4.trace.uid), v3 = e3.selectAll("g.contourlabels").data(c5 ? [0] : []);\n              if (v3.exit().remove(), v3.enter().append("g").classed("contourlabels", true), c5) {\n                var _2 = a4.xaxis, b = a4.yaxis, p3 = _2._length, k4 = b._length, E3 = [[[0, 0], [p3, 0], [p3, k4], [0, k4]]], S2 = [];\n                m1.clearLocationCache();\n                var L3 = vw.labelFormatter(r4, n4), x2 = sC.tester.append("text").attr("data-notex", 1).call(sC.font, i3.labelfont), C3 = { left: 0, right: p3, center: p3 / 2, top: 0, bottom: k4, middle: k4 / 2 }, M4 = Math.sqrt(p3 * p3 + k4 * k4), g3 = Q7.LABELDISTANCE * M4 / Math.max(1, t3.length / Q7.LABELINCREASE);\n                h3.each(function(P3) {\n                  var T3 = vw.calcTextOpts(P3.level, L3, x2, r4);\n                  e9.select(this).selectAll("path").each(function(z3) {\n                    var O3 = this, V2 = m1.getVisibleSegment(O3, C3, T3.height / 2);\n                    if (V2 && (NJt(O3, z3, P3, V2, o4, T3.height), !(V2.len < (T3.width + T3.height) * Q7.LABELMIN))) for (var G2 = Math.min(Math.ceil(V2.len / g3), Q7.LABELMAX), Z = 0; Z < G2; Z++) {\n                      var j3 = vw.findBestTextLocation(O3, V2, T3, S2, C3);\n                      if (!j3) break;\n                      vw.addLabelData(j3, T3, S2, E3);\n                    }\n                  });\n                }), x2.remove(), vw.drawLabels(v3, S2, r4, d3, f4 ? E3 : null);\n              }\n              c5 && !u4 && h3.remove();\n            }\n            function NJt(e3, t3, r4, n4, i3, a4) {\n              for (var o4, s3 = 0; s3 < r4.pedgepaths.length; s3++) t3 === r4.pedgepaths[s3] && (o4 = r4.edgepaths[s3]);\n              if (!o4) return;\n              var l3 = i3.a[0], u4 = i3.a[i3.a.length - 1], c5 = i3.b[0], f4 = i3.b[i3.b.length - 1];\n              function h3(p3, k4) {\n                var E3 = 0, S2, L3 = 0.1;\n                return (Math.abs(p3[0] - l3) < L3 || Math.abs(p3[0] - u4) < L3) && (S2 = IKe(i3.dxydb_rough(p3[0], p3[1], L3)), E3 = Math.max(E3, a4 * RKe(k4, S2) / 2)), (Math.abs(p3[1] - c5) < L3 || Math.abs(p3[1] - f4) < L3) && (S2 = IKe(i3.dxyda_rough(p3[0], p3[1], L3)), E3 = Math.max(E3, a4 * RKe(k4, S2) / 2)), E3;\n              }\n              var d3 = PKe(e3, 0, 1), v3 = PKe(e3, n4.total, n4.total - 1), _2 = h3(o4[0], d3), b = n4.total - h3(o4[o4.length - 1], v3);\n              n4.min < _2 && (n4.min = _2), n4.max > b && (n4.max = b), n4.len = n4.max - n4.min;\n            }\n            function PKe(e3, t3, r4) {\n              var n4 = e3.getPointAtLength(t3), i3 = e3.getPointAtLength(r4), a4 = i3.x - n4.x, o4 = i3.y - n4.y, s3 = Math.sqrt(a4 * a4 + o4 * o4);\n              return [a4 / s3, o4 / s3];\n            }\n            function IKe(e3) {\n              var t3 = Math.sqrt(e3[0] * e3[0] + e3[1] * e3[1]);\n              return [e3[0] / t3, e3[1] / t3];\n            }\n            function RKe(e3, t3) {\n              var r4 = Math.abs(e3[0] * t3[0] + e3[1] * t3[1]), n4 = Math.sqrt(1 - r4 * r4);\n              return n4 / r4;\n            }\n            function UJt(e3, t3, r4, n4, i3, a4) {\n              var o4, s3, l3, u4, c5 = m1.ensureSingle(e3, "g", "contourbg"), f4 = c5.selectAll("path").data(a4 === "fill" && !i3 ? [0] : []);\n              f4.enter().append("path"), f4.exit().remove();\n              var h3 = [];\n              for (u4 = 0; u4 < t3.length; u4++) o4 = t3[u4], s3 = t9([], o4.x, r4.c2p), l3 = t9([], o4.y, n4.c2p), h3.push(DKe(s3, l3, o4.bicubic));\n              f4.attr("d", "M" + h3.join("L") + "Z").style("stroke", "none");\n            }\n            function VJt(e3, t3, r4, n4, i3, a4, o4, s3, l3, u4, c5) {\n              var f4 = u4 === "fill";\n              f4 && zJt(i3, e3.contours);\n              var h3 = m1.ensureSingle(t3, "g", "contourfill"), d3 = h3.selectAll("path").data(f4 ? i3 : []);\n              d3.enter().append("path"), d3.exit().remove(), d3.each(function(v3) {\n                var _2 = (v3.prefixBoundary ? c5 : "") + GJt(e3, v3, a4, o4, s3, l3, r4, n4);\n                _2 ? e9.select(this).attr("d", _2).style("stroke", "none") : e9.select(this).remove();\n              });\n            }\n            function GJt(e3, t3, r4, n4, i3, a4, o4, s3) {\n              var l3, u4 = "", c5 = t3.edgepaths.map(function(T3, z3) {\n                return z3;\n              }), f4 = true, h3, d3, v3, _2, b, p3, k4 = Math.abs(r4[0][0] - r4[2][0]) * 1e-4, E3 = Math.abs(r4[0][1] - r4[2][1]) * 1e-4;\n              function S2(T3) {\n                return Math.abs(T3[1] - r4[0][1]) < E3;\n              }\n              function L3(T3) {\n                return Math.abs(T3[1] - r4[2][1]) < E3;\n              }\n              function x2(T3) {\n                return Math.abs(T3[0] - r4[0][0]) < k4;\n              }\n              function C3(T3) {\n                return Math.abs(T3[0] - r4[2][0]) < k4;\n              }\n              function M4(T3, z3) {\n                var O3, V2, G2, Z, j3 = "";\n                for (S2(T3) && !C3(T3) || L3(T3) && !x2(T3) ? (Z = i3.aaxis, G2 = LKe(i3, a4, [T3[0], z3[0]], 0.5 * (T3[1] + z3[1]))) : (Z = i3.baxis, G2 = LKe(i3, a4, 0.5 * (T3[0] + z3[0]), [T3[1], z3[1]])), O3 = 1; O3 < G2.length; O3++) for (j3 += Z.smoothing ? "C" : "L", V2 = 0; V2 < G2[O3].length; V2++) {\n                  var N2 = G2[O3][V2];\n                  j3 += [o4.c2p(N2[0]), s3.c2p(N2[1])] + " ";\n                }\n                return j3;\n              }\n              for (l3 = 0, h3 = null; c5.length; ) {\n                var g3 = t3.edgepaths[l3][0];\n                for (h3 && (u4 += M4(h3, g3)), p3 = sC.smoothopen(t3.edgepaths[l3].map(n4), t3.smoothing), u4 += f4 ? p3 : p3.replace(/^M/, "L"), c5.splice(c5.indexOf(l3), 1), h3 = t3.edgepaths[l3][t3.edgepaths[l3].length - 1], _2 = -1, v3 = 0; v3 < 4; v3++) {\n                  if (!h3) {\n                    m1.log("Missing end?", l3, t3);\n                    break;\n                  }\n                  for (S2(h3) && !C3(h3) ? d3 = r4[1] : x2(h3) ? d3 = r4[0] : L3(h3) ? d3 = r4[3] : C3(h3) && (d3 = r4[2]), b = 0; b < t3.edgepaths.length; b++) {\n                    var P3 = t3.edgepaths[b][0];\n                    Math.abs(h3[0] - d3[0]) < k4 ? Math.abs(h3[0] - P3[0]) < k4 && (P3[1] - h3[1]) * (d3[1] - P3[1]) >= 0 && (d3 = P3, _2 = b) : Math.abs(h3[1] - d3[1]) < E3 ? Math.abs(h3[1] - P3[1]) < E3 && (P3[0] - h3[0]) * (d3[0] - P3[0]) >= 0 && (d3 = P3, _2 = b) : m1.log("endpt to newendpt is not vert. or horz.", h3, d3, P3);\n                  }\n                  if (_2 >= 0) break;\n                  u4 += M4(h3, d3), h3 = d3;\n                }\n                if (_2 === t3.edgepaths.length) {\n                  m1.log("unclosed perimeter path");\n                  break;\n                }\n                l3 = _2, f4 = c5.indexOf(l3) === -1, f4 && (l3 = c5[0], u4 += M4(h3, d3) + "Z", h3 = null);\n              }\n              for (l3 = 0; l3 < t3.paths.length; l3++) u4 += sC.smoothclosed(t3.paths[l3].map(n4), t3.smoothing);\n              return u4;\n            }\n          });\n          var qKe = ye((dwr, OKe) => {\n            "use strict";\n            OKe.exports = { attributes: L$(), supplyDefaults: P$(), colorbar: P8(), calc: EKe(), plot: zKe(), style: L8(), moduleType: "trace", name: "contourcarpet", basePlotModule: ph(), categories: ["cartesian", "svg", "carpet", "contour", "symbols", "showLegend", "hasLines", "carpetDependent", "noHover", "noSortingByValue"], meta: {} };\n          });\n          var NKe = ye((vwr, BKe) => {\n            "use strict";\n            BKe.exports = qKe();\n          });\n          var i9 = ye((pwr, jKe) => {\n            "use strict";\n            var r9 = Dr().extendFlat, lC = pf(), UKe = df().axisHoverFormat, { hovertemplateAttrs: HJt, templatefallbackAttrs: jJt } = Ll(), GKe = Pd().dash, WJt = a3(), HKe = XT(), XJt = HKe.INCREASING.COLOR, ZJt = HKe.DECREASING.COLOR, I$ = lC.line;\n            function VKe(e3) {\n              return { line: { color: r9({}, I$.color, { dflt: e3 }), width: I$.width, dash: GKe, editType: "style" }, editType: "style" };\n            }\n            jKe.exports = { xperiod: lC.xperiod, xperiod0: lC.xperiod0, xperiodalignment: lC.xperiodalignment, xhoverformat: UKe("x"), yhoverformat: UKe("y"), x: { valType: "data_array", editType: "calc+clearAxisTypes" }, open: { valType: "data_array", editType: "calc" }, high: { valType: "data_array", editType: "calc" }, low: { valType: "data_array", editType: "calc" }, close: { valType: "data_array", editType: "calc" }, line: { width: r9({}, I$.width, {}), dash: r9({}, GKe, {}), editType: "style" }, increasing: VKe(XJt), decreasing: VKe(ZJt), text: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertext: { valType: "string", dflt: "", arrayOk: true, editType: "calc" }, hovertemplate: HJt({}, { keys: ["open", "high", "low", "close"] }), hovertemplatefallback: jJt(), tickwidth: { valType: "number", min: 0, max: 0.5, dflt: 0.3, editType: "calc" }, hoverlabel: r9({}, WJt.hoverlabel, { split: { valType: "boolean", dflt: false, editType: "style" } }), zorder: lC.zorder };\n          });\n          var R$ = ye((gwr, WKe) => {\n            "use strict";\n            var YJt = qa(), KJt = Dr();\n            WKe.exports = function(t3, r4, n4, i3) {\n              var a4 = n4("x"), o4 = n4("open"), s3 = n4("high"), l3 = n4("low"), u4 = n4("close");\n              n4("hoverlabel.split");\n              var c5 = YJt.getComponentMethod("calendars", "handleTraceDefaults");\n              if (c5(t3, r4, ["x"], i3), !!(o4 && s3 && l3 && u4)) {\n                var f4 = Math.min(o4.length, s3.length, l3.length, u4.length);\n                return a4 && (f4 = Math.min(f4, KJt.minRowLength(a4))), r4._length = f4, f4;\n              }\n            };\n          });\n          var YKe = ye((mwr, ZKe) => {\n            "use strict";\n            var JJt = Dr(), $Jt = R$(), QJt = Ig(), e$t = i9();\n            ZKe.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return JJt.coerce(t3, r4, e$t, s3, l3);\n              }\n              var o4 = $Jt(t3, r4, a4, i3);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              QJt(t3, r4, i3, a4, { x: true }), a4("xhoverformat"), a4("yhoverformat"), a4("line.width"), a4("line.dash"), XKe(t3, r4, a4, "increasing"), XKe(t3, r4, a4, "decreasing"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("tickwidth"), i3._requestRangeslider[r4.xaxis] = true, a4("zorder");\n            };\n            function XKe(e3, t3, r4, n4) {\n              r4(n4 + ".line.color"), r4(n4 + ".line.width", t3.line.width), r4(n4 + ".line.dash", t3.line.dash);\n            }\n          });\n          var D$ = ye((ywr, JKe) => {\n            "use strict";\n            var G5 = Dr(), n9 = G5._, a9 = ho(), t$t = Dg(), uC = fs().BADNUM;\n            function r$t(e3, t3) {\n              var r4 = a9.getFromId(e3, t3.xaxis), n4 = a9.getFromId(e3, t3.yaxis), i3 = n$t(e3, r4, t3), a4 = t3._minDiff;\n              t3._minDiff = null;\n              var o4 = t3._origX;\n              t3._origX = null;\n              var s3 = t3._xcalc;\n              t3._xcalc = null;\n              var l3 = KKe(e3, t3, o4, s3, n4, i$t);\n              return t3._extremes[r4._id] = a9.findExtremes(r4, s3, { vpad: a4 / 2 }), l3.length ? (G5.extendFlat(l3[0].t, { wHover: a4 / 2, tickLen: i3 }), l3) : [{ t: { empty: true } }];\n            }\n            function i$t(e3, t3, r4, n4) {\n              return { o: e3, h: t3, l: r4, c: n4 };\n            }\n            function KKe(e3, t3, r4, n4, i3, a4) {\n              for (var o4 = i3.makeCalcdata(t3, "open"), s3 = i3.makeCalcdata(t3, "high"), l3 = i3.makeCalcdata(t3, "low"), u4 = i3.makeCalcdata(t3, "close"), c5 = G5.isArrayOrTypedArray(t3.text), f4 = G5.isArrayOrTypedArray(t3.hovertext), h3 = true, d3 = null, v3 = !!t3.xperiodalignment, _2 = [], b = 0; b < n4.length; b++) {\n                var p3 = n4[b], k4 = o4[b], E3 = s3[b], S2 = l3[b], L3 = u4[b];\n                if (p3 !== uC && k4 !== uC && E3 !== uC && S2 !== uC && L3 !== uC) {\n                  L3 === k4 ? d3 !== null && L3 !== d3 && (h3 = L3 > d3) : h3 = L3 > k4, d3 = L3;\n                  var x2 = a4(k4, E3, S2, L3);\n                  x2.pos = p3, x2.yc = (k4 + L3) / 2, x2.i = b, x2.dir = h3 ? "increasing" : "decreasing", x2.x = x2.pos, x2.y = [S2, E3], v3 && (x2.orig_p = r4[b]), c5 && (x2.tx = t3.text[b]), f4 && (x2.htx = t3.hovertext[b]), _2.push(x2);\n                } else _2.push({ pos: p3, empty: true });\n              }\n              return t3._extremes[i3._id] = a9.findExtremes(i3, G5.concat(l3, s3), { padded: true }), _2.length && (_2[0].t = { labels: { open: n9(e3, "open:") + " ", high: n9(e3, "high:") + " ", low: n9(e3, "low:") + " ", close: n9(e3, "close:") + " " } }), _2;\n            }\n            function n$t(e3, t3, r4) {\n              var n4 = r4._minDiff;\n              if (!n4) {\n                var i3 = e3._fullData, a4 = [];\n                n4 = 1 / 0;\n                var o4;\n                for (o4 = 0; o4 < i3.length; o4++) {\n                  var s3 = i3[o4];\n                  if (s3.type === "ohlc" && s3.visible === true && s3.xaxis === t3._id) {\n                    a4.push(s3);\n                    var l3 = t3.makeCalcdata(s3, "x");\n                    s3._origX = l3;\n                    var u4 = t$t(r4, t3, "x", l3).vals;\n                    s3._xcalc = u4;\n                    var c5 = G5.distinctVals(u4).minDiff;\n                    c5 && isFinite(c5) && (n4 = Math.min(n4, c5));\n                  }\n                }\n                for (n4 === 1 / 0 && (n4 = 1), o4 = 0; o4 < a4.length; o4++) a4[o4]._minDiff = n4;\n              }\n              return n4 * r4.tickwidth;\n            }\n            JKe.exports = { calc: r$t, calcCommon: KKe };\n          });\n          var eJe = ye((_wr, QKe) => {\n            "use strict";\n            var a$t = Oa(), $Ke = Dr();\n            QKe.exports = function(t3, r4, n4, i3) {\n              var a4 = r4.yaxis, o4 = r4.xaxis, s3 = !!o4.rangebreaks;\n              $Ke.makeTraceGroups(i3, n4, "trace ohlc").each(function(l3) {\n                var u4 = a$t.select(this), c5 = l3[0], f4 = c5.t, h3 = c5.trace;\n                if (h3.visible !== true || f4.empty) {\n                  u4.remove();\n                  return;\n                }\n                var d3 = f4.tickLen, v3 = u4.selectAll("path").data($Ke.identity);\n                v3.enter().append("path"), v3.exit().remove(), v3.attr("d", function(_2) {\n                  if (_2.empty) return "M0,0Z";\n                  var b = o4.c2p(_2.pos - d3, true), p3 = o4.c2p(_2.pos + d3, true), k4 = s3 ? (b + p3) / 2 : o4.c2p(_2.pos, true), E3 = a4.c2p(_2.o, true), S2 = a4.c2p(_2.h, true), L3 = a4.c2p(_2.l, true), x2 = a4.c2p(_2.c, true);\n                  return "M" + b + "," + E3 + "H" + k4 + "M" + k4 + "," + S2 + "V" + L3 + "M" + p3 + "," + x2 + "H" + k4;\n                });\n              });\n            };\n          });\n          var rJe = ye((xwr, tJe) => {\n            "use strict";\n            var F$ = Oa(), o$t = So(), s$t = ka();\n            tJe.exports = function(t3, r4, n4) {\n              var i3 = n4 || F$.select(t3).selectAll("g.ohlclayer").selectAll("g.trace");\n              i3.style("opacity", function(a4) {\n                return a4[0].trace.opacity;\n              }), i3.each(function(a4) {\n                var o4 = a4[0].trace;\n                F$.select(this).selectAll("path").each(function(s3) {\n                  if (!s3.empty) {\n                    var l3 = o4[s3.dir].line;\n                    F$.select(this).style("fill", "none").call(s$t.stroke, l3.color).call(o$t.dashLine, l3.dash, l3.width).style("opacity", o4.selectedpoints && !s3.selected ? 0.3 : 1);\n                  }\n                });\n              });\n            };\n          });\n          var O$ = ye((bwr, sJe) => {\n            "use strict";\n            var z$ = ho(), l$t = Dr(), o9 = vf(), u$t = ka(), c$t = Dr().fillText, iJe = XT(), f$t = { increasing: iJe.INCREASING.SYMBOL, decreasing: iJe.DECREASING.SYMBOL };\n            function h$t(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = i3[0].trace;\n              return a4.hoverlabel.split ? aJe(e3, t3, r4, n4) : oJe(e3, t3, r4, n4);\n            }\n            function nJe(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = e3.xa, o4 = i3[0].trace, s3 = i3[0].t, l3 = o4.type, u4 = l3 === "ohlc" ? "l" : "min", c5 = l3 === "ohlc" ? "h" : "max", f4, h3, d3 = s3.bPos || 0, v3 = function(P3) {\n                return P3.pos + d3 - t3;\n              }, _2 = s3.bdPos || s3.tickLen, b = s3.wHover, p3 = Math.min(1, _2 / Math.abs(a4.r2c(a4.range[1]) - a4.r2c(a4.range[0])));\n              f4 = e3.maxHoverDistance - p3, h3 = e3.maxSpikeDistance - p3;\n              function k4(P3) {\n                var T3 = v3(P3);\n                return o9.inbox(T3 - b, T3 + b, f4);\n              }\n              function E3(P3) {\n                var T3 = P3[u4], z3 = P3[c5];\n                return T3 === z3 || o9.inbox(T3 - r4, z3 - r4, f4);\n              }\n              function S2(P3) {\n                return (k4(P3) + E3(P3)) / 2;\n              }\n              var L3 = o9.getDistanceFunction(n4, k4, E3, S2);\n              if (o9.getClosest(i3, L3, e3), e3.index === false) return null;\n              var x2 = i3[e3.index];\n              if (x2.empty) return null;\n              var C3 = x2.dir, M4 = o4[C3], g3 = M4.line.color;\n              return u$t.opacity(g3) && M4.line.width ? e3.color = g3 : e3.color = M4.fillcolor, e3.x0 = a4.c2p(x2.pos + d3 - _2, true), e3.x1 = a4.c2p(x2.pos + d3 + _2, true), e3.xLabelVal = x2.orig_p !== void 0 ? x2.orig_p : x2.pos, e3.spikeDistance = S2(x2) * h3 / f4, e3.xSpike = a4.c2p(x2.pos, true), e3;\n            }\n            function aJe(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = e3.ya, o4 = i3[0].trace, s3 = i3[0].t, l3 = [], u4 = nJe(e3, t3, r4, n4);\n              if (!u4) return [];\n              var c5 = i3[u4.index], f4 = c5.hi || o4.hoverinfo || "";\n              if (f4 === "none" || f4 === "skip") return [];\n              for (var h3 = ["high", "open", "close", "low"], d3 = {}, v3 = 0; v3 < h3.length; v3++) {\n                var _2 = h3[v3], b = o4[_2][u4.index], p3 = a4.c2p(b, true), k4;\n                b in d3 ? (k4 = d3[b], k4.yLabel += "<br>" + s3.labels[_2] + z$.hoverLabelText(a4, b, o4.yhoverformat)) : (k4 = l$t.extendFlat({}, u4), k4.y0 = k4.y1 = p3, k4.yLabelVal = b, k4.yLabel = s3.labels[_2] + z$.hoverLabelText(a4, b, o4.yhoverformat), k4.name = "", l3.push(k4), d3[b] = k4);\n              }\n              return l3;\n            }\n            function oJe(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = e3.ya, o4 = i3[0].trace, s3 = i3[0].t, l3 = nJe(e3, t3, r4, n4);\n              if (!l3) return [];\n              var u4 = l3.index, c5 = i3[u4], f4 = l3.index = c5.i, h3 = c5.dir;\n              function d3(S2) {\n                return s3.labels[S2] + z$.hoverLabelText(a4, o4[S2][f4], o4.yhoverformat);\n              }\n              var v3 = c5.hi || o4.hoverinfo || "", _2 = v3.split("+"), b = v3 === "all", p3 = b || _2.indexOf("y") !== -1, k4 = b || _2.indexOf("text") !== -1, E3 = p3 ? [d3("open"), d3("high"), d3("low"), d3("close") + "  " + f$t[h3]] : [];\n              return k4 && c$t(c5, o4, E3), l3.extraText = E3.join("<br>"), l3.y0 = l3.y1 = a4.c2p(c5.yc, true), [l3];\n            }\n            sJe.exports = { hoverPoints: h$t, hoverSplit: aJe, hoverOnPoints: oJe };\n          });\n          var q$ = ye((wwr, lJe) => {\n            "use strict";\n            lJe.exports = function(t3, r4) {\n              var n4 = t3.cd, i3 = t3.xaxis, a4 = t3.yaxis, o4 = [], s3, l3 = n4[0].t.bPos || 0;\n              if (r4 === false) for (s3 = 0; s3 < n4.length; s3++) n4[s3].selected = 0;\n              else for (s3 = 0; s3 < n4.length; s3++) {\n                var u4 = n4[s3];\n                r4.contains([i3.c2p(u4.pos + l3), a4.c2p(u4.yc)], null, u4.i, t3) ? (o4.push({ pointNumber: u4.i, x: i3.c2d(u4.pos), y: a4.c2d(u4.yc) }), u4.selected = 1) : u4.selected = 0;\n              }\n              return o4;\n            };\n          });\n          var cJe = ye((Twr, uJe) => {\n            "use strict";\n            uJe.exports = { moduleType: "trace", name: "ohlc", basePlotModule: ph(), categories: ["cartesian", "svg", "showLegend"], meta: {}, attributes: i9(), supplyDefaults: YKe(), calc: D$().calc, plot: eJe(), style: rJe(), hoverPoints: O$().hoverPoints, selectPoints: q$() };\n          });\n          var hJe = ye((Awr, fJe) => {\n            "use strict";\n            fJe.exports = cJe();\n          });\n          var N$ = ye((Swr, pJe) => {\n            "use strict";\n            var B$ = Dr().extendFlat, dJe = df().axisHoverFormat, dp = i9(), H5 = x4();\n            function vJe(e3) {\n              return { line: { color: B$({}, H5.line.color, { dflt: e3 }), width: H5.line.width, editType: "style" }, fillcolor: H5.fillcolor, editType: "style" };\n            }\n            pJe.exports = { xperiod: dp.xperiod, xperiod0: dp.xperiod0, xperiodalignment: dp.xperiodalignment, xhoverformat: dJe("x"), yhoverformat: dJe("y"), x: dp.x, open: dp.open, high: dp.high, low: dp.low, close: dp.close, line: { width: B$({}, H5.line.width, {}), editType: "style" }, increasing: vJe(dp.increasing.line.color.dflt), decreasing: vJe(dp.decreasing.line.color.dflt), text: dp.text, hovertext: dp.hovertext, hovertemplate: dp.hovertemplate, hovertemplatefallback: dp.hovertemplatefallback, whiskerwidth: B$({}, H5.whiskerwidth, { dflt: 0 }), hoverlabel: dp.hoverlabel, zorder: H5.zorder };\n          });\n          var yJe = ye((Mwr, mJe) => {\n            "use strict";\n            var d$t = Dr(), v$t = ka(), p$t = R$(), g$t = Ig(), m$t = N$();\n            mJe.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return d$t.coerce(t3, r4, m$t, s3, l3);\n              }\n              var o4 = p$t(t3, r4, a4, i3);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              g$t(t3, r4, i3, a4, { x: true }), a4("xhoverformat"), a4("yhoverformat"), a4("line.width"), gJe(t3, r4, a4, "increasing"), gJe(t3, r4, a4, "decreasing"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), a4("whiskerwidth"), i3._requestRangeslider[r4.xaxis] = true, a4("zorder");\n            };\n            function gJe(e3, t3, r4, n4) {\n              var i3 = r4(n4 + ".line.color");\n              r4(n4 + ".line.width", t3.line.width), r4(n4 + ".fillcolor", v$t.addOpacity(i3, 0.5));\n            }\n          });\n          var wJe = ye((Ewr, bJe) => {\n            "use strict";\n            var _Je = Dr(), xJe = ho(), y$t = Dg(), _$t = D$().calcCommon;\n            bJe.exports = function(e3, t3) {\n              var r4 = e3._fullLayout, n4 = xJe.getFromId(e3, t3.xaxis), i3 = xJe.getFromId(e3, t3.yaxis), a4 = n4.makeCalcdata(t3, "x"), o4 = y$t(t3, n4, "x", a4).vals, s3 = _$t(e3, t3, a4, o4, i3, x$t);\n              return s3.length ? (_Je.extendFlat(s3[0].t, { num: r4._numBoxes, dPos: _Je.distinctVals(o4).minDiff / 2, posLetter: "x", valLetter: "y" }), r4._numBoxes++, s3) : [{ t: { empty: true } }];\n            };\n            function x$t(e3, t3, r4, n4) {\n              return { min: r4, q1: Math.min(e3, n4), med: n4, q3: Math.max(e3, n4), max: t3 };\n            }\n          });\n          var AJe = ye((kwr, TJe) => {\n            "use strict";\n            TJe.exports = { moduleType: "trace", name: "candlestick", basePlotModule: ph(), categories: ["cartesian", "svg", "showLegend", "candlestick", "boxLayout"], meta: {}, attributes: N$(), layoutAttributes: b4(), supplyLayoutDefaults: ZI().supplyLayoutDefaults, crossTraceCalc: KI().crossTraceCalc, supplyDefaults: yJe(), calc: wJe(), plot: JI().plot, layerName: "boxlayer", style: $I().style, hoverPoints: O$().hoverPoints, selectPoints: q$() };\n          });\n          var MJe = ye((Cwr, SJe) => {\n            "use strict";\n            SJe.exports = AJe();\n          });\n          var V$ = ye((Lwr, EJe) => {\n            "use strict";\n            var l9 = Dr(), b$t = ym(), s9 = l9.deg2rad, U$ = l9.rad2deg;\n            EJe.exports = function(t3, r4, n4) {\n              switch (b$t(t3, n4), t3._id) {\n                case "x":\n                case "radialaxis":\n                  w$t(t3, r4);\n                  break;\n                case "angularaxis":\n                  S$t(t3, r4);\n                  break;\n              }\n            };\n            function w$t(e3, t3) {\n              var r4 = t3._subplot;\n              e3.setGeometry = function() {\n                var n4 = e3._rl[0], i3 = e3._rl[1], a4 = r4.innerRadius, o4 = (r4.radius - a4) / (i3 - n4), s3 = a4 / o4, l3 = n4 > i3 ? function(u4) {\n                  return u4 <= 0;\n                } : function(u4) {\n                  return u4 >= 0;\n                };\n                e3.c2g = function(u4) {\n                  var c5 = e3.c2l(u4) - n4;\n                  return (l3(c5) ? c5 : 0) + s3;\n                }, e3.g2c = function(u4) {\n                  return e3.l2c(u4 + n4 - s3);\n                }, e3.g2p = function(u4) {\n                  return u4 * o4;\n                }, e3.c2p = function(u4) {\n                  return e3.g2p(e3.c2g(u4));\n                };\n              };\n            }\n            function T$t(e3, t3) {\n              return t3 === "degrees" ? s9(e3) : e3;\n            }\n            function A$t(e3, t3) {\n              return t3 === "degrees" ? U$(e3) : e3;\n            }\n            function S$t(e3, t3) {\n              var r4 = e3.type;\n              if (r4 === "linear") {\n                var n4 = e3.d2c, i3 = e3.c2d;\n                e3.d2c = function(a4, o4) {\n                  return T$t(n4(a4), o4);\n                }, e3.c2d = function(a4, o4) {\n                  return i3(A$t(a4, o4));\n                };\n              }\n              e3.makeCalcdata = function(a4, o4) {\n                var s3 = a4[o4], l3 = a4._length, u4, c5, f4 = function(b) {\n                  return e3.d2c(b, a4.thetaunit);\n                };\n                if (s3) for (u4 = new Array(l3), c5 = 0; c5 < l3; c5++) u4[c5] = f4(s3[c5]);\n                else {\n                  var h3 = o4 + "0", d3 = "d" + o4, v3 = h3 in a4 ? f4(a4[h3]) : 0, _2 = a4[d3] ? f4(a4[d3]) : (e3.period || 2 * Math.PI) / l3;\n                  for (u4 = new Array(l3), c5 = 0; c5 < l3; c5++) u4[c5] = v3 + c5 * _2;\n                }\n                return u4;\n              }, e3.setGeometry = function() {\n                var a4 = t3.sector, o4 = a4.map(s9), s3 = { clockwise: -1, counterclockwise: 1 }[e3.direction], l3 = s9(e3.rotation), u4 = function(p3) {\n                  return s3 * p3 + l3;\n                }, c5 = function(p3) {\n                  return (p3 - l3) / s3;\n                }, f4, h3, d3, v3;\n                switch (r4) {\n                  case "linear":\n                    h3 = f4 = l9.identity, v3 = s9, d3 = U$, e3.range = l9.isFullCircle(o4) ? [a4[0], a4[0] + 360] : o4.map(c5).map(U$);\n                    break;\n                  case "category":\n                    var _2 = e3._categories.length, b = e3.period ? Math.max(e3.period, _2) : _2;\n                    b === 0 && (b = 1), h3 = v3 = function(p3) {\n                      return p3 * 2 * Math.PI / b;\n                    }, f4 = d3 = function(p3) {\n                      return p3 * b / Math.PI / 2;\n                    }, e3.range = [0, b];\n                    break;\n                }\n                e3.c2g = function(p3) {\n                  return u4(h3(p3));\n                }, e3.g2c = function(p3) {\n                  return f4(c5(p3));\n                }, e3.t2g = function(p3) {\n                  return u4(v3(p3));\n                }, e3.g2t = function(p3) {\n                  return d3(c5(p3));\n                };\n              };\n            }\n          });\n          var u9 = ye((Pwr, kJe) => {\n            "use strict";\n            kJe.exports = { attr: "subplot", name: "polar", axisNames: ["angularaxis", "radialaxis"], axisName2dataArray: { angularaxis: "theta", radialaxis: "r" }, layerNames: ["draglayer", "plotbg", "backplot", "angular-grid", "radial-grid", "frontplot", "angular-line", "radial-line", "angular-axis", "radial-axis"], radialDragBoxSize: 50, angularDragBoxSize: 30, cornerLen: 25, cornerHalfWidth: 2, MINDRAG: 8, MINZOOM: 20, OFFEDGE: 20 };\n          });\n          var f9 = ye((Iwr, RJe) => {\n            "use strict";\n            var pw = Dr(), CJe = kM().tester, G$ = pw.findIndexOfMin, PJe = pw.isAngleInsideSector, M$t = pw.angleDelta, LJe = pw.angleDist;\n            function E$t(e3, t3, r4, n4, i3) {\n              if (!PJe(t3, n4)) return false;\n              var a4, o4;\n              r4[0] < r4[1] ? (a4 = r4[0], o4 = r4[1]) : (a4 = r4[1], o4 = r4[0]);\n              var s3 = CJe(j5(a4, n4[0], n4[1], i3)), l3 = CJe(j5(o4, n4[0], n4[1], i3)), u4 = [e3 * Math.cos(t3), e3 * Math.sin(t3)];\n              return l3.contains(u4) && !s3.contains(u4);\n            }\n            function IJe(e3, t3, r4, n4) {\n              var i3, a4, o4 = n4[0], s3 = n4[1], l3 = c9(Math.sin(t3) - Math.sin(e3)), u4 = c9(Math.cos(t3) - Math.cos(e3)), c5 = Math.tan(r4), f4 = c9(1 / c5), h3 = l3 / u4, d3 = s3 - h3 * o4;\n              return f4 ? l3 && u4 ? (i3 = d3 / (c5 - h3), a4 = c5 * i3) : u4 ? (i3 = s3 * f4, a4 = s3) : (i3 = o4, a4 = o4 * c5) : l3 && u4 ? (i3 = 0, a4 = d3) : u4 ? (i3 = 0, a4 = s3) : i3 = a4 = NaN, [i3, a4];\n            }\n            function k$t(e3, t3, r4, n4) {\n              var i3 = -t3 * r4, a4 = t3 * t3 + 1, o4 = 2 * (t3 * i3 - r4), s3 = i3 * i3 + r4 * r4 - e3 * e3, l3 = Math.sqrt(o4 * o4 - 4 * a4 * s3), u4 = (-o4 + l3) / (2 * a4), c5 = (-o4 - l3) / (2 * a4);\n              return [[u4, t3 * u4 + i3 + n4], [c5, t3 * c5 + i3 + n4]];\n            }\n            function C$t(e3, t3) {\n              var r4 = t3.length, n4 = new Array(r4 + 1), i3;\n              for (i3 = 0; i3 < r4; i3++) {\n                var a4 = t3[i3];\n                n4[i3] = [e3 * Math.cos(a4), e3 * Math.sin(a4)];\n              }\n              return n4[i3] = n4[0].slice(), n4;\n            }\n            function L$t(e3, t3, r4, n4) {\n              var i3 = n4.length, a4 = [], o4, s3;\n              function l3(p3) {\n                return [e3 * Math.cos(p3), e3 * Math.sin(p3)];\n              }\n              function u4(p3, k4, E3) {\n                return IJe(p3, k4, E3, l3(p3));\n              }\n              function c5(p3) {\n                return pw.mod(p3, i3);\n              }\n              function f4(p3) {\n                return PJe(p3, [t3, r4]);\n              }\n              var h3 = G$(n4, function(p3) {\n                return f4(p3) ? LJe(p3, t3) : 1 / 0;\n              }), d3 = u4(n4[h3], n4[c5(h3 - 1)], t3);\n              for (a4.push(d3), o4 = h3, s3 = 0; s3 < i3; o4++, s3++) {\n                var v3 = n4[c5(o4)];\n                if (!f4(v3)) break;\n                a4.push(l3(v3));\n              }\n              var _2 = G$(n4, function(p3) {\n                return f4(p3) ? LJe(p3, r4) : 1 / 0;\n              }), b = u4(n4[_2], n4[c5(_2 + 1)], r4);\n              return a4.push(b), a4.push([0, 0]), a4.push(a4[0].slice()), a4;\n            }\n            function j5(e3, t3, r4, n4) {\n              return pw.isFullCircle([t3, r4]) ? C$t(e3, n4) : L$t(e3, t3, r4, n4);\n            }\n            function P$t(e3, t3, r4, n4) {\n              for (var i3 = 1 / 0, a4 = 1 / 0, o4 = j5(e3, t3, r4, n4), s3 = 0; s3 < o4.length; s3++) {\n                var l3 = o4[s3];\n                i3 = Math.min(i3, l3[0]), a4 = Math.min(a4, -l3[1]);\n              }\n              return [i3, a4];\n            }\n            function I$t(e3, t3) {\n              var r4 = function(a4) {\n                var o4 = M$t(a4, e3);\n                return o4 > 0 ? o4 : 1 / 0;\n              }, n4 = G$(t3, r4), i3 = pw.mod(n4 + 1, t3.length);\n              return [t3[n4], t3[i3]];\n            }\n            function c9(e3) {\n              return Math.abs(e3) > 1e-10 ? e3 : 0;\n            }\n            function H$(e3, t3, r4) {\n              t3 = t3 || 0, r4 = r4 || 0;\n              for (var n4 = e3.length, i3 = new Array(n4), a4 = 0; a4 < n4; a4++) {\n                var o4 = e3[a4];\n                i3[a4] = [t3 + o4[0], r4 - o4[1]];\n              }\n              return i3;\n            }\n            function R$t(e3, t3, r4, n4, i3, a4) {\n              var o4 = j5(e3, t3, r4, n4);\n              return "M" + H$(o4, i3, a4).join("L");\n            }\n            function D$t(e3, t3, r4, n4, i3, a4, o4) {\n              var s3, l3;\n              e3 < t3 ? (s3 = e3, l3 = t3) : (s3 = t3, l3 = e3);\n              var u4 = H$(j5(s3, r4, n4, i3), a4, o4), c5 = H$(j5(l3, r4, n4, i3), a4, o4);\n              return "M" + c5.reverse().join("L") + "M" + u4.join("L");\n            }\n            RJe.exports = { isPtInsidePolygon: E$t, findPolygonOffset: P$t, findEnclosingVertexAngles: I$t, findIntersectionXY: IJe, findXYatLength: k$t, clampTiny: c9, pathPolygon: R$t, pathPolygonAnnulus: D$t };\n          });\n          var j$ = ye((Rwr, zJe) => {\n            "use strict";\n            function DJe(e3) {\n              return e3 < 0 ? -1 : e3 > 0 ? 1 : 0;\n            }\n            function W5(e3) {\n              var t3 = e3[0], r4 = e3[1];\n              if (!isFinite(t3) || !isFinite(r4)) return [1, 0];\n              var n4 = (t3 + 1) * (t3 + 1) + r4 * r4;\n              return [(t3 * t3 + r4 * r4 - 1) / n4, 2 * r4 / n4];\n            }\n            function X5(e3, t3) {\n              var r4 = t3[0], n4 = t3[1];\n              return [r4 * e3.radius + e3.cx, -n4 * e3.radius + e3.cy];\n            }\n            function FJe(e3, t3) {\n              return t3 * e3.radius;\n            }\n            function F$t(e3, t3, r4, n4) {\n              var i3 = X5(e3, W5([r4, t3])), a4 = i3[0], o4 = i3[1], s3 = X5(e3, W5([n4, t3])), l3 = s3[0], u4 = s3[1];\n              if (t3 === 0) return ["M" + a4 + "," + o4, "L" + l3 + "," + u4].join(" ");\n              var c5 = FJe(e3, 1 / Math.abs(t3));\n              return ["M" + a4 + "," + o4, "A" + c5 + "," + c5 + " 0 0," + (t3 < 0 ? 1 : 0) + " " + l3 + "," + u4].join(" ");\n            }\n            function z$t(e3, t3, r4, n4) {\n              var i3 = FJe(e3, 1 / (t3 + 1)), a4 = X5(e3, W5([t3, r4])), o4 = a4[0], s3 = a4[1], l3 = X5(e3, W5([t3, n4])), u4 = l3[0], c5 = l3[1];\n              if (DJe(r4) !== DJe(n4)) {\n                var f4 = X5(e3, W5([t3, 0])), h3 = f4[0], d3 = f4[1];\n                return ["M" + o4 + "," + s3, "A" + i3 + "," + i3 + " 0 0," + (0 < r4 ? 0 : 1) + " " + h3 + "," + d3, "A" + i3 + "," + i3 + " 0 0," + (n4 < 0 ? 0 : 1) + u4 + "," + c5].join(" ");\n              }\n              return ["M" + o4 + "," + s3, "A" + i3 + "," + i3 + " 0 0," + (n4 < r4 ? 0 : 1) + " " + u4 + "," + c5].join(" ");\n            }\n            zJe.exports = { smith: W5, reactanceArc: F$t, resistanceArc: z$t, smithTransform: X5 };\n          });\n          var Z$ = ye((Dwr, jJe) => {\n            "use strict";\n            var gw = Oa(), O$t = cd(), yw = qa(), Xc = Dr(), iy = Xc.strRotate, xd = Xc.strTranslate, W$ = ka(), cC = So(), q$t = Mc(), vp = ho(), B$t = ym(), N$t = V$(), U$t = Ag().doAutoRange, y1 = NN(), v9 = yv(), OJe = vf(), V$t = Eb(), G$t = Of().prepSelect, H$t = Of().selectOnClick, X$ = Of().clearOutline, qJe = Sg(), BJe = vM(), NJe = wM().redrawReglTraces, j$t = $h().MID_SHIFT, Lx = u9(), _1 = f9(), p9 = j$(), h9 = p9.smith, W$t = p9.reactanceArc, X$t = p9.resistanceArc, d9 = p9.smithTransform, Z$t = Xc._, UJe = Xc.mod, Px = Xc.deg2rad, mw = Xc.rad2deg;\n            function VJe(e3, t3, r4) {\n              this.isSmith = r4 || false, this.id = t3, this.gd = e3, this._hasClipOnAxisFalse = null, this.vangles = null, this.radialAxisAngle = null, this.traceHash = {}, this.layers = {}, this.clipPaths = {}, this.clipIds = {}, this.viewInitial = {};\n              var n4 = e3._fullLayout, i3 = "clip" + n4._uid + t3;\n              this.clipIds.forTraces = i3 + "-for-traces", this.clipPaths.forTraces = n4._clips.append("clipPath").attr("id", this.clipIds.forTraces), this.clipPaths.forTraces.append("path"), this.framework = n4["_" + (r4 ? "smith" : "polar") + "layer"].append("g").attr("class", t3), this.getHole = function(a4) {\n                return this.isSmith ? 0 : a4.hole;\n              }, this.getSector = function(a4) {\n                return this.isSmith ? [0, 360] : a4.sector;\n              }, this.getRadial = function(a4) {\n                return this.isSmith ? a4.realaxis : a4.radialaxis;\n              }, this.getAngular = function(a4) {\n                return this.isSmith ? a4.imaginaryaxis : a4.angularaxis;\n              }, r4 || (this.radialTickLayout = null, this.angularTickLayout = null);\n            }\n            var Nd = VJe.prototype;\n            jJe.exports = function(t3, r4, n4) {\n              return new VJe(t3, r4, n4);\n            };\n            Nd.plot = function(e3, t3) {\n              for (var r4 = this, n4 = t3[r4.id], i3 = false, a4 = 0; a4 < e3.length; a4++) {\n                var o4 = e3[a4][0].trace;\n                if (o4.cliponaxis === false) {\n                  i3 = true;\n                  break;\n                }\n              }\n              r4._hasClipOnAxisFalse = i3, r4.updateLayers(t3, n4), r4.updateLayout(t3, n4), q$t.generalUpdatePerTraceModule(r4.gd, r4, e3, n4), r4.updateFx(t3, n4), r4.isSmith && (delete n4.realaxis.range, delete n4.imaginaryaxis.range);\n            };\n            Nd.updateLayers = function(e3, t3) {\n              var r4 = this, n4 = r4.isSmith, i3 = r4.layers, a4 = r4.getRadial(t3), o4 = r4.getAngular(t3), s3 = Lx.layerNames, l3 = s3.indexOf("frontplot"), u4 = s3.slice(0, l3), c5 = o4.layer === "below traces", f4 = a4.layer === "below traces";\n              c5 && u4.push("angular-line"), f4 && u4.push("radial-line"), c5 && u4.push("angular-axis"), f4 && u4.push("radial-axis"), u4.push("frontplot"), c5 || u4.push("angular-line"), f4 || u4.push("radial-line"), c5 || u4.push("angular-axis"), f4 || u4.push("radial-axis");\n              var h3 = (n4 ? "smith" : "polar") + "sublayer", d3 = r4.framework.selectAll("." + h3).data(u4, String);\n              d3.enter().append("g").attr("class", function(v3) {\n                return h3 + " " + v3;\n              }).each(function(v3) {\n                var _2 = i3[v3] = gw.select(this);\n                switch (v3) {\n                  case "frontplot":\n                    n4 || _2.append("g").classed("barlayer", true), _2.append("g").classed("scatterlayer", true);\n                    break;\n                  case "backplot":\n                    _2.append("g").classed("maplayer", true);\n                    break;\n                  case "plotbg":\n                    i3.bg = _2.append("path");\n                    break;\n                  case "radial-grid":\n                    _2.style("fill", "none");\n                    break;\n                  case "angular-grid":\n                    _2.style("fill", "none");\n                    break;\n                  case "radial-line":\n                    _2.append("line").style("fill", "none");\n                    break;\n                  case "angular-line":\n                    _2.append("path").style("fill", "none");\n                    break;\n                }\n              }), d3.order();\n            };\n            Nd.updateLayout = function(e3, t3) {\n              var r4 = this, n4 = r4.layers, i3 = e3._size, a4 = r4.getRadial(t3), o4 = r4.getAngular(t3), s3 = t3.domain.x, l3 = t3.domain.y;\n              r4.xOffset = i3.l + i3.w * s3[0], r4.yOffset = i3.t + i3.h * (1 - l3[1]);\n              var u4 = r4.xLength = i3.w * (s3[1] - s3[0]), c5 = r4.yLength = i3.h * (l3[1] - l3[0]), f4 = r4.getSector(t3);\n              r4.sectorInRad = f4.map(Px);\n              var h3 = r4.sectorBBox = Y$t(f4), d3 = h3[2] - h3[0], v3 = h3[3] - h3[1], _2 = c5 / u4, b = Math.abs(v3 / d3), p3, k4, E3, S2, L3;\n              _2 > b ? (p3 = u4, k4 = u4 * b, L3 = (c5 - k4) / i3.h / 2, E3 = [s3[0], s3[1]], S2 = [l3[0] + L3, l3[1] - L3]) : (p3 = c5 / b, k4 = c5, L3 = (u4 - p3) / i3.w / 2, E3 = [s3[0] + L3, s3[1] - L3], S2 = [l3[0], l3[1]]), r4.xLength2 = p3, r4.yLength2 = k4, r4.xDomain2 = E3, r4.yDomain2 = S2;\n              var x2 = r4.xOffset2 = i3.l + i3.w * E3[0], C3 = r4.yOffset2 = i3.t + i3.h * (1 - S2[1]), M4 = r4.radius = p3 / d3, g3 = r4.innerRadius = r4.getHole(t3) * M4, P3 = r4.cx = x2 - M4 * h3[0], T3 = r4.cy = C3 + M4 * h3[3], z3 = r4.cxx = P3 - x2, O3 = r4.cyy = T3 - C3, V2 = a4.side, G2;\n              V2 === "counterclockwise" ? (G2 = V2, V2 = "top") : V2 === "clockwise" && (G2 = V2, V2 = "bottom"), r4.radialAxis = r4.mockAxis(e3, t3, a4, { _id: "x", side: V2, _trueSide: G2, domain: [g3 / i3.w, M4 / i3.w] }), r4.angularAxis = r4.mockAxis(e3, t3, o4, { side: "right", domain: [0, Math.PI], autorange: false }), r4.doAutoRange(e3, t3), r4.updateAngularAxis(e3, t3), r4.updateRadialAxis(e3, t3), r4.updateRadialAxisTitle(e3, t3), r4.xaxis = r4.mockCartesianAxis(e3, t3, { _id: "x", domain: E3 }), r4.yaxis = r4.mockCartesianAxis(e3, t3, { _id: "y", domain: S2 });\n              var Z = r4.pathSubplot();\n              r4.clipPaths.forTraces.select("path").attr("d", Z).attr("transform", xd(z3, O3)), n4.frontplot.attr("transform", xd(x2, C3)).call(cC.setClipUrl, r4._hasClipOnAxisFalse ? null : r4.clipIds.forTraces, r4.gd), n4.bg.attr("d", Z).attr("transform", xd(P3, T3)).call(W$.fill, t3.bgcolor);\n            };\n            Nd.mockAxis = function(e3, t3, r4, n4) {\n              var i3 = Xc.extendFlat({}, r4, n4);\n              return N$t(i3, t3, e3), i3;\n            };\n            Nd.mockCartesianAxis = function(e3, t3, r4) {\n              var n4 = this, i3 = n4.isSmith, a4 = r4._id, o4 = Xc.extendFlat({ type: "linear" }, r4);\n              B$t(o4, e3);\n              var s3 = { x: [0, 2], y: [1, 3] };\n              return o4.setRange = function() {\n                var l3 = n4.sectorBBox, u4 = s3[a4], c5 = n4.radialAxis._rl, f4 = (c5[1] - c5[0]) / (1 - n4.getHole(t3));\n                o4.range = [l3[u4[0]] * f4, l3[u4[1]] * f4];\n              }, o4.isPtWithinRange = a4 === "x" && !i3 ? function(l3) {\n                return n4.isPtInside(l3);\n              } : function() {\n                return true;\n              }, o4.setRange(), o4.setScale(), o4;\n            };\n            Nd.doAutoRange = function(e3, t3) {\n              var r4 = this, n4 = r4.gd, i3 = r4.radialAxis, a4 = r4.getRadial(t3);\n              U$t(n4, i3);\n              var o4 = i3.range;\n              if (a4.range = o4.slice(), a4._input.range = o4.slice(), i3._rl = [i3.r2l(o4[0], null, "gregorian"), i3.r2l(o4[1], null, "gregorian")], i3.minallowed !== void 0) {\n                var s3 = i3.r2l(i3.minallowed);\n                i3._rl[0] > i3._rl[1] ? i3._rl[1] = Math.max(i3._rl[1], s3) : i3._rl[0] = Math.max(i3._rl[0], s3);\n              }\n              if (i3.maxallowed !== void 0) {\n                var l3 = i3.r2l(i3.maxallowed);\n                i3._rl[0] < i3._rl[1] ? i3._rl[1] = Math.min(i3._rl[1], l3) : i3._rl[0] = Math.min(i3._rl[0], l3);\n              }\n            };\n            Nd.updateRadialAxis = function(e3, t3) {\n              var r4 = this, n4 = r4.gd, i3 = r4.layers, a4 = r4.radius, o4 = r4.innerRadius, s3 = r4.cx, l3 = r4.cy, u4 = r4.getRadial(t3), c5 = UJe(r4.getSector(t3)[0], 360), f4 = r4.radialAxis, h3 = o4 < a4, d3 = r4.isSmith;\n              d3 || (r4.fillViewInitialKey("radialaxis.angle", u4.angle), r4.fillViewInitialKey("radialaxis.range", f4.range.slice()), f4.setGeometry()), f4.tickangle === "auto" && c5 > 90 && c5 <= 270 && (f4.tickangle = 180);\n              var v3 = d3 ? function(M4) {\n                var g3 = d9(r4, h9([M4.x, 0]));\n                return xd(g3[0] - s3, g3[1] - l3);\n              } : function(M4) {\n                return xd(f4.l2p(M4.x) + o4, 0);\n              }, _2 = d3 ? function(M4) {\n                return X$t(r4, M4.x, -1 / 0, 1 / 0);\n              } : function(M4) {\n                return r4.pathArc(f4.r2p(M4.x) + o4);\n              }, b = GJe(u4);\n              if (r4.radialTickLayout !== b && (i3["radial-axis"].selectAll(".xtick").remove(), r4.radialTickLayout = b), h3) {\n                f4.setScale();\n                var p3 = 0, k4 = d3 ? (f4.tickvals || []).filter(function(M4) {\n                  return M4 >= 0;\n                }).map(function(M4) {\n                  return vp.tickText(f4, M4, true, false);\n                }) : vp.calcTicks(f4), E3 = d3 ? k4 : vp.clipEnds(f4, k4), S2 = vp.getTickSigns(f4)[2];\n                d3 && ((f4.ticks === "top" && f4.side === "bottom" || f4.ticks === "bottom" && f4.side === "top") && (S2 = -S2), f4.ticks === "top" && f4.side === "top" && (p3 = -f4.ticklen), f4.ticks === "bottom" && f4.side === "bottom" && (p3 = f4.ticklen)), vp.drawTicks(n4, f4, { vals: k4, layer: i3["radial-axis"], path: vp.makeTickPath(f4, 0, S2), transFn: v3, crisp: false }), vp.drawGrid(n4, f4, { vals: E3, layer: i3["radial-grid"], path: _2, transFn: Xc.noop, crisp: false }), vp.drawLabels(n4, f4, { vals: k4, layer: i3["radial-axis"], transFn: v3, labelFns: vp.makeLabelFns(f4, p3) });\n              }\n              var L3 = r4.radialAxisAngle = r4.vangles ? mw(HJe(Px(u4.angle), r4.vangles)) : u4.angle, x2 = xd(s3, l3), C3 = x2 + iy(-L3);\n              fC(i3["radial-axis"], h3 && (u4.showticklabels || u4.ticks), { transform: C3 }), fC(i3["radial-grid"], h3 && u4.showgrid, { transform: d3 ? "" : x2 }), fC(i3["radial-line"].select("line"), h3 && u4.showline, { x1: d3 ? -a4 : o4, y1: 0, x2: a4, y2: 0, transform: C3 }).attr("stroke-width", u4.linewidth).call(W$.stroke, u4.linecolor);\n            };\n            Nd.updateRadialAxisTitle = function(e3, t3, r4) {\n              if (!this.isSmith) {\n                var n4 = this, i3 = n4.gd, a4 = n4.radius, o4 = n4.cx, s3 = n4.cy, l3 = n4.getRadial(t3), u4 = n4.id + "title", c5 = 0;\n                if (l3.title) {\n                  var f4 = cC.bBox(n4.layers["radial-axis"].node()).height, h3 = l3.title.font.size, d3 = l3.side;\n                  c5 = d3 === "top" ? h3 : d3 === "counterclockwise" ? -(f4 + h3 * 0.4) : f4 + h3 * 0.8;\n                }\n                var v3 = r4 !== void 0 ? r4 : n4.radialAxisAngle, _2 = Px(v3), b = Math.cos(_2), p3 = Math.sin(_2), k4 = o4 + a4 / 2 * b + c5 * p3, E3 = s3 - a4 / 2 * p3 + c5 * b;\n                n4.layers["radial-axis-title"] = V$t.draw(i3, u4, { propContainer: l3, propName: n4.id + ".radialaxis.title.text", placeholder: Z$t(i3, "Click to enter radial axis title"), attributes: { x: k4, y: E3, "text-anchor": "middle" }, transform: { rotate: -v3 } });\n              }\n            };\n            Nd.updateAngularAxis = function(e3, t3) {\n              var r4 = this, n4 = r4.gd, i3 = r4.layers, a4 = r4.radius, o4 = r4.innerRadius, s3 = r4.cx, l3 = r4.cy, u4 = r4.getAngular(t3), c5 = r4.angularAxis, f4 = r4.isSmith;\n              f4 || (r4.fillViewInitialKey("angularaxis.rotation", u4.rotation), c5.setGeometry(), c5.setScale());\n              var h3 = f4 ? function(g3) {\n                var P3 = d9(r4, h9([0, g3.x]));\n                return Math.atan2(P3[0] - s3, P3[1] - l3) - Math.PI / 2;\n              } : function(g3) {\n                return c5.t2g(g3.x);\n              };\n              c5.type === "linear" && c5.thetaunit === "radians" && (c5.tick0 = mw(c5.tick0), c5.dtick = mw(c5.dtick));\n              var d3 = function(g3) {\n                return xd(s3 + a4 * Math.cos(g3), l3 - a4 * Math.sin(g3));\n              }, v3 = f4 ? function(g3) {\n                var P3 = d9(r4, h9([0, g3.x]));\n                return xd(P3[0], P3[1]);\n              } : function(g3) {\n                return d3(h3(g3));\n              }, _2 = f4 ? function(g3) {\n                var P3 = d9(r4, h9([0, g3.x])), T3 = Math.atan2(P3[0] - s3, P3[1] - l3) - Math.PI / 2;\n                return xd(P3[0], P3[1]) + iy(-mw(T3));\n              } : function(g3) {\n                var P3 = h3(g3);\n                return d3(P3) + iy(-mw(P3));\n              }, b = f4 ? function(g3) {\n                return W$t(r4, g3.x, 0, 1 / 0);\n              } : function(g3) {\n                var P3 = h3(g3), T3 = Math.cos(P3), z3 = Math.sin(P3);\n                return "M" + [s3 + o4 * T3, l3 - o4 * z3] + "L" + [s3 + a4 * T3, l3 - a4 * z3];\n              }, p3 = vp.makeLabelFns(c5, 0), k4 = p3.labelStandoff, E3 = {};\n              E3.xFn = function(g3) {\n                var P3 = h3(g3);\n                return Math.cos(P3) * k4;\n              }, E3.yFn = function(g3) {\n                var P3 = h3(g3), T3 = Math.sin(P3) > 0 ? 0.2 : 1;\n                return -Math.sin(P3) * (k4 + g3.fontSize * T3) + Math.abs(Math.cos(P3)) * (g3.fontSize * j$t);\n              }, E3.anchorFn = function(g3) {\n                var P3 = h3(g3), T3 = Math.cos(P3);\n                return Math.abs(T3) < 0.1 ? "middle" : T3 > 0 ? "start" : "end";\n              }, E3.heightFn = function(g3, P3, T3) {\n                var z3 = h3(g3);\n                return -0.5 * (1 + Math.sin(z3)) * T3;\n              };\n              var S2 = GJe(u4);\n              r4.angularTickLayout !== S2 && (i3["angular-axis"].selectAll("." + c5._id + "tick").remove(), r4.angularTickLayout = S2);\n              var L3 = f4 ? [1 / 0].concat(c5.tickvals || []).map(function(g3) {\n                return vp.tickText(c5, g3, true, false);\n              }) : vp.calcTicks(c5);\n              f4 && (L3[0].text = "\\u221E", L3[0].fontSize *= 1.75);\n              var x2;\n              if (t3.gridshape === "linear" ? (x2 = L3.map(h3), Xc.angleDelta(x2[0], x2[1]) < 0 && (x2 = x2.slice().reverse())) : x2 = null, r4.vangles = x2, c5.type === "category" && (L3 = L3.filter(function(g3) {\n                return Xc.isAngleInsideSector(h3(g3), r4.sectorInRad);\n              })), c5.visible) {\n                var C3 = c5.ticks === "inside" ? -1 : 1, M4 = (c5.linewidth || 1) / 2;\n                vp.drawTicks(n4, c5, { vals: L3, layer: i3["angular-axis"], path: "M" + C3 * M4 + ",0h" + C3 * c5.ticklen, transFn: _2, crisp: false }), vp.drawGrid(n4, c5, { vals: L3, layer: i3["angular-grid"], path: b, transFn: Xc.noop, crisp: false }), vp.drawLabels(n4, c5, { vals: L3, layer: i3["angular-axis"], repositionOnUpdate: true, transFn: v3, labelFns: E3 });\n              }\n              fC(i3["angular-line"].select("path"), u4.showline, { d: r4.pathSubplot(), transform: xd(s3, l3) }).attr("stroke-width", u4.linewidth).call(W$.stroke, u4.linecolor);\n            };\n            Nd.updateFx = function(e3, t3) {\n              if (!this.gd._context.staticPlot) {\n                var r4 = !this.isSmith;\n                r4 && (this.updateAngularDrag(e3), this.updateRadialDrag(e3, t3, 0), this.updateRadialDrag(e3, t3, 1)), this.updateHoverAndMainDrag(e3);\n              }\n            };\n            Nd.updateHoverAndMainDrag = function(e3) {\n              var t3 = this, r4 = t3.isSmith, n4 = t3.gd, i3 = t3.layers, a4 = e3._zoomlayer, o4 = Lx.MINZOOM, s3 = Lx.OFFEDGE, l3 = t3.radius, u4 = t3.innerRadius, c5 = t3.cx, f4 = t3.cy, h3 = t3.cxx, d3 = t3.cyy, v3 = t3.sectorInRad, _2 = t3.vangles, b = t3.radialAxis, p3 = _1.clampTiny, k4 = _1.findXYatLength, E3 = _1.findEnclosingVertexAngles, S2 = Lx.cornerHalfWidth, L3 = Lx.cornerLen / 2, x2, C3, M4 = y1.makeDragger(i3, "path", "maindrag", e3.dragmode === false ? "none" : "crosshair");\n              gw.select(M4).attr("d", t3.pathSubplot()).attr("transform", xd(c5, f4)), M4.onmousemove = function(ce) {\n                OJe.hover(n4, ce, t3.id), n4._fullLayout._lasthover = M4, n4._fullLayout._hoversubplot = t3.id;\n              }, M4.onmouseout = function(ce) {\n                n4._dragging || v9.unhover(n4, ce);\n              };\n              var g3 = { element: M4, gd: n4, subplot: t3.id, plotinfo: { id: t3.id, xaxis: t3.xaxis, yaxis: t3.yaxis }, xaxes: [t3.xaxis], yaxes: [t3.yaxis] }, P3, T3, z3, O3, V2, G2, Z, j3, N2;\n              function H(ce, Ze) {\n                return Math.sqrt(ce * ce + Ze * Ze);\n              }\n              function te(ce, Ze) {\n                return H(ce - h3, Ze - d3);\n              }\n              function oe(ce, Ze) {\n                return Math.atan2(d3 - Ze, ce - h3);\n              }\n              function _e(ce, Ze) {\n                return [ce * Math.cos(Ze), ce * Math.sin(-Ze)];\n              }\n              function Ee(ce, Ze) {\n                if (ce === 0) return t3.pathSector(2 * S2);\n                var ut = L3 / ce, pt = Ze - ut, Zt = Ze + ut, st = Math.max(0, Math.min(ce, l3)), lt = st - S2, Gt = st + S2;\n                return "M" + _e(lt, pt) + "A" + [lt, lt] + " 0,0,0 " + _e(lt, Zt) + "L" + _e(Gt, Zt) + "A" + [Gt, Gt] + " 0,0,1 " + _e(Gt, pt) + "Z";\n              }\n              function Ce(ce, Ze, ut) {\n                if (ce === 0) return t3.pathSector(2 * S2);\n                var pt = _e(ce, Ze), Zt = _e(ce, ut), st = p3((pt[0] + Zt[0]) / 2), lt = p3((pt[1] + Zt[1]) / 2), Gt, Nt;\n                if (st && lt) {\n                  var Jt = lt / st, sr = -1 / Jt, wr = k4(S2, Jt, st, lt);\n                  Gt = k4(L3, sr, wr[0][0], wr[0][1]), Nt = k4(L3, sr, wr[1][0], wr[1][1]);\n                } else {\n                  var cr, $e;\n                  lt ? (cr = L3, $e = S2) : (cr = S2, $e = L3), Gt = [[st - cr, lt - $e], [st + cr, lt - $e]], Nt = [[st - cr, lt + $e], [st + cr, lt + $e]];\n                }\n                return "M" + Gt.join("L") + "L" + Nt.reverse().join("L") + "Z";\n              }\n              function me() {\n                z3 = null, O3 = null, V2 = t3.pathSubplot(), G2 = false;\n                var ce = n4._fullLayout[t3.id];\n                Z = O$t(ce.bgcolor).getLuminance(), j3 = y1.makeZoombox(a4, Z, c5, f4, V2), j3.attr("fill-rule", "evenodd"), N2 = y1.makeCorners(a4, c5, f4), X$(n4);\n              }\n              function ie(ce, Ze) {\n                return Ze = Math.max(Math.min(Ze, l3), u4), ce < s3 ? ce = 0 : l3 - ce < s3 ? ce = l3 : Ze < s3 ? Ze = 0 : l3 - Ze < s3 && (Ze = l3), Math.abs(Ze - ce) > o4 ? (ce < Ze ? (z3 = ce, O3 = Ze) : (z3 = Ze, O3 = ce), true) : (z3 = null, O3 = null, false);\n              }\n              function Se(ce, Ze) {\n                ce = ce || V2, Ze = Ze || "M0,0Z", j3.attr("d", ce), N2.attr("d", Ze), y1.transitionZoombox(j3, N2, G2, Z), G2 = true;\n                var ut = {};\n                ge(ut), n4.emit("plotly_relayouting", ut);\n              }\n              function Le(ce, Ze) {\n                ce = ce * x2, Ze = Ze * C3;\n                var ut = P3 + ce, pt = T3 + Ze, Zt = te(P3, T3), st = Math.min(te(ut, pt), l3), lt = oe(P3, T3), Gt, Nt;\n                ie(Zt, st) && (Gt = V2 + t3.pathSector(O3), z3 && (Gt += t3.pathSector(z3)), Nt = Ee(z3, lt) + Ee(O3, lt)), Se(Gt, Nt);\n              }\n              function Ae(ce, Ze, ut, pt) {\n                var Zt = _1.findIntersectionXY(ut, pt, ut, [ce - h3, d3 - Ze]);\n                return H(Zt[0], Zt[1]);\n              }\n              function Fe(ce, Ze) {\n                var ut = P3 + ce, pt = T3 + Ze, Zt = oe(P3, T3), st = oe(ut, pt), lt = E3(Zt, _2), Gt = E3(st, _2), Nt = Ae(P3, T3, lt[0], lt[1]), Jt = Math.min(Ae(ut, pt, Gt[0], Gt[1]), l3), sr, wr;\n                ie(Nt, Jt) && (sr = V2 + t3.pathSector(O3), z3 && (sr += t3.pathSector(z3)), wr = [Ce(z3, lt[0], lt[1]), Ce(O3, lt[0], lt[1])].join(" ")), Se(sr, wr);\n              }\n              function Pe() {\n                if (y1.removeZoombox(n4), !(z3 === null || O3 === null)) {\n                  var ce = {};\n                  ge(ce), y1.showDoubleClickNotifier(n4), yw.call("_guiRelayout", n4, ce);\n                }\n              }\n              function ge(ce) {\n                var Ze = b._rl, ut = (Ze[1] - Ze[0]) / (1 - u4 / l3) / l3, pt = [Ze[0] + (z3 - u4) * ut, Ze[0] + (O3 - u4) * ut];\n                ce[t3.id + ".radialaxis.range"] = pt;\n              }\n              function Re(ce, Ze) {\n                var ut = n4._fullLayout.clickmode;\n                if (y1.removeZoombox(n4), ce === 2) {\n                  var pt = {};\n                  for (var Zt in t3.viewInitial) pt[t3.id + "." + Zt] = t3.viewInitial[Zt];\n                  n4.emit("plotly_doubleclick", null), yw.call("_guiRelayout", n4, pt);\n                }\n                ut.indexOf("select") > -1 && ce === 1 && H$t(Ze, n4, [t3.xaxis], [t3.yaxis], t3.id, g3), ut.indexOf("event") > -1 && OJe.click(n4, Ze, t3.id);\n              }\n              g3.prepFn = function(ce, Ze, ut) {\n                var pt = n4._fullLayout.dragmode, Zt = M4.getBoundingClientRect();\n                n4._fullLayout._calcInverseTransform(n4);\n                var st = n4._fullLayout._invTransform;\n                x2 = n4._fullLayout._invScaleX, C3 = n4._fullLayout._invScaleY;\n                var lt = Xc.apply3DTransform(st)(Ze - Zt.left, ut - Zt.top);\n                if (P3 = lt[0], T3 = lt[1], _2) {\n                  var Gt = _1.findPolygonOffset(l3, v3[0], v3[1], _2);\n                  P3 += h3 + Gt[0], T3 += d3 + Gt[1];\n                }\n                switch (pt) {\n                  case "zoom":\n                    g3.clickFn = Re, r4 || (_2 ? g3.moveFn = Fe : g3.moveFn = Le, g3.doneFn = Pe, me(ce, Ze, ut));\n                    break;\n                  case "select":\n                  case "lasso":\n                    G$t(ce, Ze, ut, g3, pt);\n                    break;\n                }\n              }, v9.init(g3);\n            };\n            Nd.updateRadialDrag = function(e3, t3, r4) {\n              var n4 = this, i3 = n4.gd, a4 = n4.layers, o4 = n4.radius, s3 = n4.innerRadius, l3 = n4.cx, u4 = n4.cy, c5 = n4.radialAxis, f4 = Lx.radialDragBoxSize, h3 = f4 / 2;\n              if (!c5.visible) return;\n              var d3 = Px(n4.radialAxisAngle), v3 = c5._rl, _2 = v3[0], b = v3[1], p3 = v3[r4], k4 = 0.75 * (v3[1] - v3[0]) / (1 - n4.getHole(t3)) / o4, E3, S2, L3;\n              r4 ? (E3 = l3 + (o4 + h3) * Math.cos(d3), S2 = u4 - (o4 + h3) * Math.sin(d3), L3 = "radialdrag") : (E3 = l3 + (s3 - h3) * Math.cos(d3), S2 = u4 - (s3 - h3) * Math.sin(d3), L3 = "radialdrag-inner");\n              var x2 = y1.makeRectDragger(a4, L3, "crosshair", -h3, -h3, f4, f4), C3 = { element: x2, gd: i3 };\n              e3.dragmode === false && (C3.dragmode = false), fC(gw.select(x2), c5.visible && s3 < o4, { transform: xd(E3, S2) });\n              var M4, g3, P3;\n              function T3(Z, j3) {\n                if (M4) M4(Z, j3);\n                else {\n                  var N2 = [Z, -j3], H = [Math.cos(d3), Math.sin(d3)], te = Math.abs(Xc.dot(N2, H) / Math.sqrt(Xc.dot(N2, N2)));\n                  isNaN(te) || (M4 = te < 0.5 ? V2 : G2);\n                }\n                var oe = {};\n                z3(oe), i3.emit("plotly_relayouting", oe);\n              }\n              function z3(Z) {\n                g3 !== null ? Z[n4.id + ".radialaxis.angle"] = g3 : P3 !== null && (Z[n4.id + ".radialaxis.range[" + r4 + "]"] = P3);\n              }\n              function O3() {\n                g3 !== null ? yw.call("_guiRelayout", i3, n4.id + ".radialaxis.angle", g3) : P3 !== null && yw.call("_guiRelayout", i3, n4.id + ".radialaxis.range[" + r4 + "]", P3);\n              }\n              function V2(Z, j3) {\n                if (r4 !== 0) {\n                  var N2 = E3 + Z, H = S2 + j3;\n                  g3 = Math.atan2(u4 - H, N2 - l3), n4.vangles && (g3 = HJe(g3, n4.vangles)), g3 = mw(g3);\n                  var te = xd(l3, u4) + iy(-g3);\n                  a4["radial-axis"].attr("transform", te), a4["radial-line"].select("line").attr("transform", te);\n                  var oe = n4.gd._fullLayout, _e = oe[n4.id];\n                  n4.updateRadialAxisTitle(oe, _e, g3);\n                }\n              }\n              function G2(Z, j3) {\n                var N2 = Xc.dot([Z, -j3], [Math.cos(d3), Math.sin(d3)]);\n                if (P3 = p3 - k4 * N2, k4 > 0 != (r4 ? P3 > _2 : P3 < b)) {\n                  P3 = null;\n                  return;\n                }\n                var H = i3._fullLayout, te = H[n4.id];\n                c5.range[r4] = P3, c5._rl[r4] = P3, n4.updateRadialAxis(H, te), n4.xaxis.setRange(), n4.xaxis.setScale(), n4.yaxis.setRange(), n4.yaxis.setScale();\n                var oe = false;\n                for (var _e in n4.traceHash) {\n                  var Ee = n4.traceHash[_e], Ce = Xc.filterVisible(Ee), me = Ee[0][0].trace._module;\n                  me.plot(i3, n4, Ce, te), yw.traceIs(_e, "gl") && Ce.length && (oe = true);\n                }\n                oe && (BJe(i3), NJe(i3));\n              }\n              C3.prepFn = function() {\n                M4 = null, g3 = null, P3 = null, C3.moveFn = T3, C3.doneFn = O3, X$(i3);\n              }, C3.clampFn = function(Z, j3) {\n                return Math.sqrt(Z * Z + j3 * j3) < Lx.MINDRAG && (Z = 0, j3 = 0), [Z, j3];\n              }, v9.init(C3);\n            };\n            Nd.updateAngularDrag = function(e3) {\n              var t3 = this, r4 = t3.gd, n4 = t3.layers, i3 = t3.radius, a4 = t3.angularAxis, o4 = t3.cx, s3 = t3.cy, l3 = t3.cxx, u4 = t3.cyy, c5 = Lx.angularDragBoxSize, f4 = y1.makeDragger(n4, "path", "angulardrag", e3.dragmode === false ? "none" : "move"), h3 = { element: f4, gd: r4 };\n              e3.dragmode === false ? h3.dragmode = false : gw.select(f4).attr("d", t3.pathAnnulus(i3, i3 + c5)).attr("transform", xd(o4, s3)).call(qJe, "move");\n              function d3(P3, T3) {\n                return Math.atan2(u4 + c5 - T3, P3 - l3 - c5);\n              }\n              var v3 = n4.frontplot.select(".scatterlayer").selectAll(".trace"), _2 = v3.selectAll(".point"), b = v3.selectAll(".textpoint"), p3, k4, E3, S2, L3, x2;\n              function C3(P3, T3) {\n                var z3 = t3.gd._fullLayout, O3 = z3[t3.id], V2 = p3 + P3 * e3._invScaleX, G2 = k4 + T3 * e3._invScaleY, Z = d3(V2, G2), j3 = mw(Z - x2);\n                if (S2 = E3 + j3, n4.frontplot.attr("transform", xd(t3.xOffset2, t3.yOffset2) + iy([-j3, l3, u4])), t3.vangles) {\n                  L3 = t3.radialAxisAngle + j3;\n                  var N2 = xd(o4, s3) + iy(-j3), H = xd(o4, s3) + iy(-L3);\n                  n4.bg.attr("transform", N2), n4["radial-grid"].attr("transform", N2), n4["radial-axis"].attr("transform", H), n4["radial-line"].select("line").attr("transform", H), t3.updateRadialAxisTitle(z3, O3, L3);\n                } else t3.clipPaths.forTraces.select("path").attr("transform", xd(l3, u4) + iy(j3));\n                _2.each(function() {\n                  var ie = gw.select(this), Se = cC.getTranslate(ie);\n                  ie.attr("transform", xd(Se.x, Se.y) + iy([j3]));\n                }), b.each(function() {\n                  var ie = gw.select(this), Se = ie.select("text"), Le = cC.getTranslate(ie);\n                  ie.attr("transform", iy([j3, Se.attr("x"), Se.attr("y")]) + xd(Le.x, Le.y));\n                }), a4.rotation = Xc.modHalf(S2, 360), t3.updateAngularAxis(z3, O3), t3._hasClipOnAxisFalse && !Xc.isFullCircle(t3.sectorInRad) && v3.call(cC.hideOutsideRangePoints, t3);\n                var te = false;\n                for (var oe in t3.traceHash) if (yw.traceIs(oe, "gl")) {\n                  var _e = t3.traceHash[oe], Ee = Xc.filterVisible(_e), Ce = _e[0][0].trace._module;\n                  Ce.plot(r4, t3, Ee, O3), Ee.length && (te = true);\n                }\n                te && (BJe(r4), NJe(r4));\n                var me = {};\n                M4(me), r4.emit("plotly_relayouting", me);\n              }\n              function M4(P3) {\n                P3[t3.id + ".angularaxis.rotation"] = S2, t3.vangles && (P3[t3.id + ".radialaxis.angle"] = L3);\n              }\n              function g3() {\n                b.select("text").attr("transform", null);\n                var P3 = {};\n                M4(P3), yw.call("_guiRelayout", r4, P3);\n              }\n              h3.prepFn = function(P3, T3, z3) {\n                var O3 = e3[t3.id];\n                E3 = O3.angularaxis.rotation;\n                var V2 = f4.getBoundingClientRect();\n                p3 = T3 - V2.left, k4 = z3 - V2.top, r4._fullLayout._calcInverseTransform(r4);\n                var G2 = Xc.apply3DTransform(e3._invTransform)(p3, k4);\n                p3 = G2[0], k4 = G2[1], x2 = d3(p3, k4), h3.moveFn = C3, h3.doneFn = g3, X$(r4);\n              }, t3.vangles && !Xc.isFullCircle(t3.sectorInRad) && (h3.prepFn = Xc.noop, qJe(gw.select(f4), null)), v9.init(h3);\n            };\n            Nd.isPtInside = function(e3) {\n              if (this.isSmith) return true;\n              var t3 = this.sectorInRad, r4 = this.vangles, n4 = this.angularAxis.c2g(e3.theta), i3 = this.radialAxis, a4 = i3.c2l(e3.r), o4 = i3._rl, s3 = r4 ? _1.isPtInsidePolygon : Xc.isPtInsideSector;\n              return s3(a4, n4, o4, t3, r4);\n            };\n            Nd.pathArc = function(e3) {\n              var t3 = this.sectorInRad, r4 = this.vangles, n4 = r4 ? _1.pathPolygon : Xc.pathArc;\n              return n4(e3, t3[0], t3[1], r4);\n            };\n            Nd.pathSector = function(e3) {\n              var t3 = this.sectorInRad, r4 = this.vangles, n4 = r4 ? _1.pathPolygon : Xc.pathSector;\n              return n4(e3, t3[0], t3[1], r4);\n            };\n            Nd.pathAnnulus = function(e3, t3) {\n              var r4 = this.sectorInRad, n4 = this.vangles, i3 = n4 ? _1.pathPolygonAnnulus : Xc.pathAnnulus;\n              return i3(e3, t3, r4[0], r4[1], n4);\n            };\n            Nd.pathSubplot = function() {\n              var e3 = this.innerRadius, t3 = this.radius;\n              return e3 ? this.pathAnnulus(e3, t3) : this.pathSector(t3);\n            };\n            Nd.fillViewInitialKey = function(e3, t3) {\n              e3 in this.viewInitial || (this.viewInitial[e3] = t3);\n            };\n            function GJe(e3) {\n              var t3 = e3.ticks + String(e3.ticklen) + String(e3.showticklabels);\n              return "side" in e3 && (t3 += e3.side), t3;\n            }\n            function Y$t(e3) {\n              var t3 = e3[0], r4 = e3[1], n4 = r4 - t3, i3 = UJe(t3, 360), a4 = i3 + n4, o4 = Math.cos(Px(i3)), s3 = Math.sin(Px(i3)), l3 = Math.cos(Px(a4)), u4 = Math.sin(Px(a4)), c5, f4, h3, d3;\n              return i3 <= 90 && a4 >= 90 || i3 > 90 && a4 >= 450 ? d3 = 1 : s3 <= 0 && u4 <= 0 ? d3 = 0 : d3 = Math.max(s3, u4), i3 <= 180 && a4 >= 180 || i3 > 180 && a4 >= 540 ? c5 = -1 : o4 >= 0 && l3 >= 0 ? c5 = 0 : c5 = Math.min(o4, l3), i3 <= 270 && a4 >= 270 || i3 > 270 && a4 >= 630 ? f4 = -1 : s3 >= 0 && u4 >= 0 ? f4 = 0 : f4 = Math.min(s3, u4), a4 >= 360 ? h3 = 1 : o4 <= 0 && l3 <= 0 ? h3 = 0 : h3 = Math.max(o4, l3), [c5, f4, h3, d3];\n            }\n            function HJe(e3, t3) {\n              var r4 = function(i3) {\n                return Xc.angleDist(e3, i3);\n              }, n4 = Xc.findIndexOfMin(t3, r4);\n              return t3[n4];\n            }\n            function fC(e3, t3, r4) {\n              return t3 ? (e3.attr("display", null), e3.attr(r4)) : e3 && e3.attr("display", "none"), e3;\n            }\n          });\n          var Y$ = ye((Fwr, JJe) => {\n            "use strict";\n            var K$t = Lh(), os = Rd(), J$t = Cc().attributes, c0 = Dr().extendFlat, WJe = mc().overrideAll, XJe = WJe({ color: os.color, showline: c0({}, os.showline, { dflt: true }), linecolor: os.linecolor, linewidth: os.linewidth, showgrid: c0({}, os.showgrid, { dflt: true }), gridcolor: os.gridcolor, gridwidth: os.gridwidth, griddash: os.griddash }, "plot", "from-root"), ZJe = WJe({ tickmode: os.minor.tickmode, nticks: os.nticks, tick0: os.tick0, dtick: os.dtick, tickvals: os.tickvals, ticktext: os.ticktext, ticks: os.ticks, ticklen: os.ticklen, tickwidth: os.tickwidth, tickcolor: os.tickcolor, ticklabelstep: os.ticklabelstep, showticklabels: os.showticklabels, labelalias: os.labelalias, minorloglabels: os.minorloglabels, showtickprefix: os.showtickprefix, tickprefix: os.tickprefix, showticksuffix: os.showticksuffix, ticksuffix: os.ticksuffix, showexponent: os.showexponent, exponentformat: os.exponentformat, minexponent: os.minexponent, separatethousands: os.separatethousands, tickfont: os.tickfont, tickangle: os.tickangle, tickformat: os.tickformat, tickformatstops: os.tickformatstops, layer: os.layer }, "plot", "from-root"), YJe = { visible: c0({}, os.visible, { dflt: true }), type: c0({}, os.type, { values: ["-", "linear", "log", "date", "category"] }), autotypenumbers: os.autotypenumbers, autorangeoptions: { minallowed: os.autorangeoptions.minallowed, maxallowed: os.autorangeoptions.maxallowed, clipmin: os.autorangeoptions.clipmin, clipmax: os.autorangeoptions.clipmax, include: os.autorangeoptions.include, editType: "plot" }, autorange: c0({}, os.autorange, { editType: "plot" }), rangemode: { valType: "enumerated", values: ["tozero", "nonnegative", "normal"], dflt: "tozero", editType: "calc" }, minallowed: c0({}, os.minallowed, { editType: "plot" }), maxallowed: c0({}, os.maxallowed, { editType: "plot" }), range: c0({}, os.range, { items: [{ valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }, { valType: "any", editType: "plot", impliedEdits: { "^autorange": false } }], editType: "plot" }), categoryorder: os.categoryorder, categoryarray: os.categoryarray, angle: { valType: "angle", editType: "plot" }, autotickangles: os.autotickangles, side: { valType: "enumerated", values: ["clockwise", "counterclockwise"], dflt: "clockwise", editType: "plot" }, title: { text: c0({}, os.title.text, { editType: "plot", dflt: "" }), font: c0({}, os.title.font, { editType: "plot" }), editType: "plot" }, hoverformat: os.hoverformat, uirevision: { valType: "any", editType: "none" }, editType: "calc" };\n            c0(YJe, XJe, ZJe);\n            var KJe = { visible: c0({}, os.visible, { dflt: true }), type: { valType: "enumerated", values: ["-", "linear", "category"], dflt: "-", editType: "calc", _noTemplating: true }, autotypenumbers: os.autotypenumbers, categoryorder: os.categoryorder, categoryarray: os.categoryarray, thetaunit: { valType: "enumerated", values: ["radians", "degrees"], dflt: "degrees", editType: "calc" }, period: { valType: "number", editType: "calc", min: 0 }, direction: { valType: "enumerated", values: ["counterclockwise", "clockwise"], dflt: "counterclockwise", editType: "calc" }, rotation: { valType: "angle", editType: "calc" }, hoverformat: os.hoverformat, uirevision: { valType: "any", editType: "none" }, editType: "calc" };\n            c0(KJe, XJe, ZJe);\n            JJe.exports = { domain: J$t({ name: "polar", editType: "plot" }), sector: { valType: "info_array", items: [{ valType: "number", editType: "plot" }, { valType: "number", editType: "plot" }], dflt: [0, 360], editType: "plot" }, hole: { valType: "number", min: 0, max: 1, dflt: 0, editType: "plot" }, bgcolor: { valType: "color", editType: "plot", dflt: K$t.background }, radialaxis: YJe, angularaxis: KJe, gridshape: { valType: "enumerated", values: ["circular", "linear"], dflt: "circular", editType: "plot" }, uirevision: { valType: "any", editType: "none" }, editType: "calc" };\n          });\n          var t$e = ye((zwr, e$e) => {\n            "use strict";\n            var g9 = Dr(), $$t = ka(), Q$t = vl(), eQt = k_(), tQt = Id().getSubplotData, rQt = bb(), iQt = M3(), nQt = e_(), aQt = t_(), oQt = oI(), sQt = t4(), lQt = _B(), uQt = R3(), QJe = Y$(), cQt = V$(), m9 = u9(), $Je = m9.axisNames;\n            function fQt(e3, t3, r4, n4) {\n              var i3 = r4("bgcolor");\n              n4.bgColor = $$t.combine(i3, n4.paper_bgcolor);\n              var a4 = r4("sector");\n              r4("hole");\n              var o4 = tQt(n4.fullData, m9.name, n4.id), s3 = n4.layoutOut, l3;\n              function u4(j3, N2) {\n                return r4(l3 + "." + j3, N2);\n              }\n              for (var c5 = 0; c5 < $Je.length; c5++) {\n                l3 = $Je[c5], g9.isPlainObject(e3[l3]) || (e3[l3] = {});\n                var f4 = e3[l3], h3 = Q$t.newContainer(t3, l3);\n                h3._id = h3._name = l3, h3._attr = n4.id + "." + l3, h3._traceIndices = o4.map(function(j3) {\n                  return j3.index;\n                });\n                var d3 = m9.axisName2dataArray[l3], v3 = hQt(f4, h3, u4, o4, d3, n4);\n                oQt(f4, h3, u4, { axData: o4, dataAttr: d3 });\n                var _2 = u4("visible");\n                switch (cQt(h3, t3, s3), u4("uirevision", t3.uirevision), h3._m = 1, l3) {\n                  case "radialaxis":\n                    u4("minallowed"), u4("maxallowed");\n                    var b = u4("range"), p3 = h3.getAutorangeDflt(b), k4 = u4("autorange", p3), E3;\n                    b && (b[0] === null && b[1] === null || (b[0] === null || b[1] === null) && (k4 === "reversed" || k4 === true) || b[0] !== null && (k4 === "min" || k4 === "max reversed") || b[1] !== null && (k4 === "max" || k4 === "min reversed")) && (b = void 0, delete h3.range, h3.autorange = true, E3 = true), E3 || (p3 = h3.getAutorangeDflt(b), k4 = u4("autorange", p3)), f4.autorange = k4, k4 && (lQt(u4, k4, b), (v3 === "linear" || v3 === "-") && u4("rangemode"), h3.isReversed() && (h3._m = -1)), h3.cleanRange("range", { dfltRange: [0, 1] });\n                    break;\n                  case "angularaxis":\n                    if (v3 === "date") {\n                      g9.log("Polar plots do not support date angular axes yet.");\n                      for (var S2 = 0; S2 < o4.length; S2++) o4[S2].visible = false;\n                      v3 = f4.type = h3.type = "linear";\n                    }\n                    u4(v3 === "linear" ? "thetaunit" : "period");\n                    var L3 = u4("direction");\n                    u4("rotation", { counterclockwise: 0, clockwise: 90 }[L3]);\n                    break;\n                }\n                if (aQt(f4, h3, u4, h3.type, { tickSuffixDflt: h3.thetaunit === "degrees" ? "\\xB0" : void 0 }), _2) {\n                  var x2, C3, M4, g3, P3, T3, z3, O3, V2, G2, Z = n4.font || {};\n                  x2 = u4("color"), C3 = x2 === f4.color ? x2 : Z.color, M4 = Z.size, g3 = Z.family, P3 = Z.weight, T3 = Z.style, z3 = Z.variant, O3 = Z.textcase, V2 = Z.lineposition, G2 = Z.shadow, rQt(f4, h3, u4, h3.type), nQt(f4, h3, u4, h3.type, { font: { weight: P3, style: T3, variant: z3, textcase: O3, lineposition: V2, shadow: G2, color: C3, size: M4, family: g3 }, noAutotickangles: l3 === "angularaxis", noTicklabelshift: true, noTicklabelstandoff: true }), iQt(f4, h3, u4, { outerTicks: true }), sQt(f4, h3, u4, { dfltColor: x2, bgColor: n4.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: QJe[l3] }), u4("layer"), l3 === "radialaxis" && (u4("side"), u4("angle", a4[0]), u4("title.text"), g9.coerceFont(u4, "title.font", { weight: P3, style: T3, variant: z3, textcase: O3, lineposition: V2, shadow: G2, color: C3, size: g9.bigFont(M4), family: g3 }));\n                }\n                v3 !== "category" && u4("hoverformat"), h3._input = f4;\n              }\n              t3.angularaxis.type === "category" && r4("gridshape");\n            }\n            function hQt(e3, t3, r4, n4, i3, a4) {\n              var o4 = r4("autotypenumbers", a4.autotypenumbersDflt), s3 = r4("type");\n              if (s3 === "-") {\n                for (var l3, u4 = 0; u4 < n4.length; u4++) if (n4[u4].visible) {\n                  l3 = n4[u4];\n                  break;\n                }\n                l3 && l3[i3] && (t3.type = uQt(l3[i3], "gregorian", { noMultiCategory: true, autotypenumbers: o4 })), t3.type === "-" ? t3.type = "linear" : e3.type = t3.type;\n              }\n              return t3.type;\n            }\n            e$e.exports = function(t3, r4, n4) {\n              eQt(t3, r4, n4, { type: m9.name, attributes: QJe, handleDefaults: fQt, font: r4.font, autotypenumbersDflt: r4.autotypenumbers, paper_bgcolor: r4.paper_bgcolor, fullData: n4, layoutOut: r4 });\n            };\n          });\n          var y9 = ye((Owr, o$e) => {\n            "use strict";\n            var dQt = Id().getSubplotCalcData, vQt = Dr().counterRegex, pQt = Z$(), i$e = u9(), n$e = i$e.attr, _w = i$e.name, r$e = vQt(_w), a$e = {};\n            a$e[n$e] = { valType: "subplotid", dflt: _w, editType: "calc" };\n            function gQt(e3) {\n              for (var t3 = e3._fullLayout, r4 = e3.calcdata, n4 = t3._subplots[_w], i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3], o4 = dQt(r4, _w, a4), s3 = t3[a4]._subplot;\n                s3 || (s3 = pQt(e3, a4), t3[a4]._subplot = s3), s3.plot(o4, t3, e3._promises);\n              }\n            }\n            function mQt(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[_w] || [], a4 = n4._has && n4._has("gl"), o4 = t3._has && t3._has("gl"), s3 = a4 && !o4, l3 = 0; l3 < i3.length; l3++) {\n                var u4 = i3[l3], c5 = n4[u4]._subplot;\n                if (!t3[u4] && c5) {\n                  c5.framework.remove(), c5.layers["radial-axis-title"].remove();\n                  for (var f4 in c5.clipPaths) c5.clipPaths[f4].remove();\n                }\n                s3 && c5._scene && (c5._scene.destroy(), c5._scene = null);\n              }\n            }\n            o$e.exports = { attr: n$e, name: _w, idRoot: _w, idRegex: r$e, attrRegex: r$e, attributes: a$e, layoutAttributes: Y$(), supplyLayoutDefaults: t$e(), plot: gQt, clean: mQt, toSVG: ph().toSVG };\n          });\n          var hC = ye((qwr, l$e) => {\n            "use strict";\n            var { hovertemplateAttrs: yQt, texttemplateAttrs: _Qt, templatefallbackAttrs: s$e } = Ll(), _9 = Ao().extendFlat, xQt = Cg(), f0 = pf(), bQt = Gl(), Z5 = f0.line;\n            l$e.exports = { mode: f0.mode, r: { valType: "data_array", editType: "calc+clearAxisTypes" }, theta: { valType: "data_array", editType: "calc+clearAxisTypes" }, r0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dr: { valType: "number", dflt: 1, editType: "calc" }, theta0: { valType: "any", dflt: 0, editType: "calc+clearAxisTypes" }, dtheta: { valType: "number", editType: "calc" }, thetaunit: { valType: "enumerated", values: ["radians", "degrees", "gradians"], dflt: "degrees", editType: "calc+clearAxisTypes" }, text: f0.text, texttemplate: _Qt({ editType: "plot" }, { keys: ["r", "theta", "text"] }), texttemplatefallback: s$e({ editType: "plot" }), hovertext: f0.hovertext, line: { color: Z5.color, width: Z5.width, dash: Z5.dash, backoff: Z5.backoff, shape: _9({}, Z5.shape, { values: ["linear", "spline"] }), smoothing: Z5.smoothing, editType: "calc" }, connectgaps: f0.connectgaps, marker: f0.marker, cliponaxis: _9({}, f0.cliponaxis, { dflt: false }), textposition: f0.textposition, textfont: f0.textfont, fill: _9({}, f0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: xQt(), hoverinfo: _9({}, bQt.hoverinfo, { flags: ["r", "theta", "text", "name"] }), hoveron: f0.hoveron, hovertemplate: yQt(), hovertemplatefallback: s$e(), selected: f0.selected, unselected: f0.unselected };\n          });\n          var b9 = ye((Bwr, f$e) => {\n            "use strict";\n            var x9 = Dr(), Y5 = Ru(), wQt = $p(), TQt = R0(), u$e = tT(), AQt = D0(), SQt = Rg(), MQt = Sm().PTS_LINESONLY, EQt = hC();\n            function kQt(e3, t3, r4, n4) {\n              function i3(s3, l3) {\n                return x9.coerce(e3, t3, EQt, s3, l3);\n              }\n              var a4 = c$e(e3, t3, n4, i3);\n              if (!a4) {\n                t3.visible = false;\n                return;\n              }\n              i3("thetaunit"), i3("mode", a4 < MQt ? "lines+markers" : "lines"), i3("text"), i3("hovertext"), t3.hoveron !== "fills" && (i3("hovertemplate"), i3("hovertemplatefallback")), Y5.hasMarkers(t3) && wQt(e3, t3, r4, n4, i3, { gradient: true }), Y5.hasLines(t3) && (TQt(e3, t3, r4, n4, i3, { backoff: true }), u$e(e3, t3, i3), i3("connectgaps")), Y5.hasText(t3) && (i3("texttemplate"), i3("texttemplatefallback"), AQt(e3, t3, n4, i3));\n              var o4 = [];\n              (Y5.hasMarkers(t3) || Y5.hasText(t3)) && (i3("cliponaxis"), i3("marker.maxdisplayed"), o4.push("points")), i3("fill"), t3.fill !== "none" && (SQt(e3, t3, r4, i3), Y5.hasLines(t3) || u$e(e3, t3, i3)), (t3.fill === "tonext" || t3.fill === "toself") && o4.push("fills"), i3("hoveron", o4.join("+") || "points"), x9.coerceSelectionMarkerOpacity(t3, i3);\n            }\n            function c$e(e3, t3, r4, n4) {\n              var i3 = n4("r"), a4 = n4("theta");\n              x9.isTypedArray(i3) && (t3.r = i3 = Array.from(i3)), x9.isTypedArray(a4) && (t3.theta = a4 = Array.from(a4));\n              var o4;\n              if (i3) a4 ? o4 = Math.min(i3.length, a4.length) : (o4 = i3.length, n4("theta0"), n4("dtheta"));\n              else {\n                if (!a4) return 0;\n                o4 = t3.theta.length, n4("r0"), n4("dr");\n              }\n              return t3._length = o4, o4;\n            }\n            f$e.exports = { handleRThetaDefaults: c$e, supplyDefaults: kQt };\n          });\n          var w9 = ye((Nwr, d$e) => {\n            "use strict";\n            var CQt = Dr(), h$e = ho();\n            d$e.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.subplot]._subplot, o4, s3;\n              a4 ? (o4 = a4.radialAxis, s3 = a4.angularAxis) : (a4 = n4[r4.subplot], o4 = a4.radialaxis, s3 = a4.angularaxis);\n              var l3 = o4.c2l(t3.r);\n              i3.rLabel = h$e.tickText(o4, l3, true).text;\n              var u4 = s3.thetaunit === "degrees" ? CQt.rad2deg(t3.theta) : t3.theta;\n              return i3.thetaLabel = h$e.tickText(s3, u4, true).text, i3;\n            };\n          });\n          var g$e = ye((Uwr, p$e) => {\n            "use strict";\n            var v$e = Eo(), LQt = fs().BADNUM, PQt = ho(), IQt = F0(), RQt = km(), DQt = z0(), FQt = O0().calcMarkerSize;\n            p$e.exports = function(t3, r4) {\n              for (var n4 = t3._fullLayout, i3 = r4.subplot, a4 = n4[i3].radialaxis, o4 = n4[i3].angularaxis, s3 = a4.makeCalcdata(r4, "r"), l3 = o4.makeCalcdata(r4, "theta"), u4 = r4._length, c5 = new Array(u4), f4 = 0; f4 < u4; f4++) {\n                var h3 = s3[f4], d3 = l3[f4], v3 = c5[f4] = {};\n                v$e(h3) && v$e(d3) ? (v3.r = h3, v3.theta = d3) : v3.r = LQt;\n              }\n              var _2 = FQt(r4, u4);\n              return r4._extremes.x = PQt.findExtremes(a4, s3, { ppad: _2 }), IQt(t3, r4), RQt(c5, r4), DQt(c5, r4), c5;\n            };\n          });\n          var _$e = ye((Vwr, y$e) => {\n            "use strict";\n            var zQt = sT(), m$e = fs().BADNUM;\n            y$e.exports = function(t3, r4, n4) {\n              for (var i3 = r4.layers.frontplot.select("g.scatterlayer"), a4 = r4.xaxis, o4 = r4.yaxis, s3 = { xaxis: a4, yaxis: o4, plot: r4.framework, layerClipId: r4._hasClipOnAxisFalse ? r4.clipIds.forTraces : null }, l3 = r4.radialAxis, u4 = r4.angularAxis, c5 = 0; c5 < n4.length; c5++) for (var f4 = n4[c5], h3 = 0; h3 < f4.length; h3++) {\n                h3 === 0 && (f4[0].trace._xA = a4, f4[0].trace._yA = o4);\n                var d3 = f4[h3], v3 = d3.r;\n                if (v3 === m$e) d3.x = d3.y = m$e;\n                else {\n                  var _2 = l3.c2g(v3), b = u4.c2g(d3.theta);\n                  d3.x = _2 * Math.cos(b), d3.y = _2 * Math.sin(b);\n                }\n              }\n              zQt(t3, s3, n4, i3);\n            };\n          });\n          var T9 = ye((Gwr, b$e) => {\n            "use strict";\n            var OQt = fT();\n            function qQt(e3, t3, r4, n4) {\n              var i3 = OQt(e3, t3, r4, n4);\n              if (!(!i3 || i3[0].index === false)) {\n                var a4 = i3[0];\n                if (a4.index === void 0) return i3;\n                var o4 = e3.subplot, s3 = a4.cd[a4.index], l3 = a4.trace;\n                if (o4.isPtInside(s3)) return a4.xLabelVal = void 0, a4.yLabelVal = void 0, x$e(s3, l3, o4, a4), a4.hovertemplate = l3.hovertemplate, i3;\n              }\n            }\n            function x$e(e3, t3, r4, n4) {\n              var i3 = r4.radialAxis, a4 = r4.angularAxis;\n              i3._hovertitle = "r", a4._hovertitle = "\\u03B8";\n              var o4 = {};\n              o4[t3.subplot] = { _subplot: r4 };\n              var s3 = t3._module.formatLabels(e3, t3, o4);\n              n4.rLabel = s3.rLabel, n4.thetaLabel = s3.thetaLabel;\n              var l3 = e3.hi || t3.hoverinfo, u4 = [];\n              function c5(h3, d3) {\n                u4.push(h3._hovertitle + ": " + d3);\n              }\n              if (!t3.hovertemplate) {\n                var f4 = l3.split("+");\n                f4.indexOf("all") !== -1 && (f4 = ["r", "theta", "text"]), f4.indexOf("r") !== -1 && c5(i3, n4.rLabel), f4.indexOf("theta") !== -1 && c5(a4, n4.thetaLabel), f4.indexOf("text") !== -1 && n4.text && (u4.push(n4.text), delete n4.text), n4.extraText = u4.join("<br>");\n              }\n            }\n            b$e.exports = { hoverPoints: qQt, makeHoverPointText: x$e };\n          });\n          var T$e = ye((Hwr, w$e) => {\n            "use strict";\n            w$e.exports = { moduleType: "trace", name: "scatterpolar", basePlotModule: y9(), categories: ["polar", "symbols", "showLegend", "scatter-like"], attributes: hC(), supplyDefaults: b9().supplyDefaults, colorbar: $d(), formatLabels: w9(), calc: g$e(), plot: _$e(), style: op().style, styleOnSelect: op().styleOnSelect, hoverPoints: T9().hoverPoints, selectPoints: hT(), meta: {} };\n          });\n          var S$e = ye((jwr, A$e) => {\n            "use strict";\n            A$e.exports = T$e();\n          });\n          var K$ = ye((Zwr, E$e) => {\n            "use strict";\n            var M$e = hC(), { cliponaxis: Wwr, hoveron: Xwr } = M$e, BQt = uee(M$e, ["cliponaxis", "hoveron"]), { connectgaps: NQt, line: { color: UQt, dash: VQt, width: GQt }, fill: HQt, fillcolor: jQt, marker: WQt, textfont: XQt, textposition: ZQt } = lk();\n            E$e.exports = q1(mg({}, BQt), { connectgaps: NQt, fill: HQt, fillcolor: jQt, line: { color: UQt, dash: VQt, editType: "calc", width: GQt }, marker: WQt, textfont: XQt, textposition: ZQt });\n          });\n          var L$e = ye((Kwr, C$e) => {\n            "use strict";\n            var k$e = Dr(), J$ = Ru(), YQt = b9().handleRThetaDefaults, KQt = $p(), JQt = R0(), $Qt = D0(), QQt = Rg(), eer = Sm().PTS_LINESONLY, ter = K$();\n            C$e.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return k$e.coerce(t3, r4, ter, s3, l3);\n              }\n              var o4 = YQt(t3, r4, i3, a4);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              a4("thetaunit"), a4("mode", o4 < eer ? "lines+markers" : "lines"), a4("text"), a4("hovertext"), r4.hoveron !== "fills" && (a4("hovertemplate"), a4("hovertemplatefallback")), J$.hasMarkers(r4) && KQt(t3, r4, n4, i3, a4, { noAngleRef: true, noStandOff: true }), J$.hasLines(r4) && (JQt(t3, r4, n4, i3, a4), a4("connectgaps")), J$.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), $Qt(t3, r4, i3, a4, { noFontShadow: true, noFontLineposition: true, noFontTextcase: true })), a4("fill"), r4.fill !== "none" && QQt(t3, r4, n4, a4), k$e.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var I$e = ye((Jwr, P$e) => {\n            "use strict";\n            var rer = w9();\n            P$e.exports = function(t3, r4, n4) {\n              var i3 = t3.i;\n              return "r" in t3 || (t3.r = r4._r[i3]), "theta" in t3 || (t3.theta = r4._theta[i3]), rer(t3, r4, n4);\n            };\n          });\n          var D$e = ye(($wr, R$e) => {\n            "use strict";\n            var ier = F0(), ner = O0().calcMarkerSize, aer = J2(), oer = ho(), ser = ox().TOO_MANY_POINTS;\n            R$e.exports = function(t3, r4) {\n              var n4 = t3._fullLayout, i3 = r4.subplot, a4 = n4[i3].radialaxis, o4 = n4[i3].angularaxis, s3 = r4._r = a4.makeCalcdata(r4, "r"), l3 = r4._theta = o4.makeCalcdata(r4, "theta"), u4 = r4._length, c5 = {};\n              u4 < s3.length && (s3 = s3.slice(0, u4)), u4 < l3.length && (l3 = l3.slice(0, u4)), c5.r = s3, c5.theta = l3, ier(t3, r4);\n              var f4 = c5.opts = aer.style(t3, r4), h3;\n              return u4 < ser ? h3 = ner(r4, u4) : f4.marker && (h3 = 2 * (f4.marker.sizeAvg || Math.max(f4.marker.size, 3))), r4._extremes.x = oer.findExtremes(a4, s3, { ppad: h3 }), [{ x: false, y: false, t: c5, trace: r4 }];\n            };\n          });\n          var z$e = ye((Qwr, F$e) => {\n            "use strict";\n            var ler = UF(), uer = T9().makeHoverPointText;\n            function cer(e3, t3, r4, n4) {\n              var i3 = e3.cd, a4 = i3[0].t, o4 = a4.r, s3 = a4.theta, l3 = ler.hoverPoints(e3, t3, r4, n4);\n              if (!(!l3 || l3[0].index === false)) {\n                var u4 = l3[0];\n                if (u4.index === void 0) return l3;\n                var c5 = e3.subplot, f4 = u4.cd[u4.index], h3 = u4.trace;\n                if (f4.r = o4[u4.index], f4.theta = s3[u4.index], !!c5.isPtInside(f4)) return u4.xLabelVal = void 0, u4.yLabelVal = void 0, uer(f4, h3, c5, u4), l3;\n              }\n            }\n            F$e.exports = { hoverPoints: cer };\n          });\n          var q$e = ye((e3r, O$e) => {\n            "use strict";\n            O$e.exports = { moduleType: "trace", name: "scatterpolargl", basePlotModule: y9(), categories: ["gl", "regl", "polar", "symbols", "showLegend", "scatter-like"], attributes: K$(), supplyDefaults: L$e(), colorbar: $d(), formatLabels: I$e(), calc: D$e(), hoverPoints: z$e().hoverPoints, selectPoints: uY(), meta: {} };\n          });\n          var B$e = ye((t3r, $$) => {\n            "use strict";\n            var fer = HF(), her = Eo(), der = dK(), ver = oY(), A9 = J2(), S9 = Dr(), per = ox().TOO_MANY_POINTS, ger = {};\n            $$.exports = function(t3, r4, n4) {\n              if (n4.length) {\n                var i3 = r4.radialAxis, a4 = r4.angularAxis, o4 = ver(t3, r4);\n                return n4.forEach(function(s3) {\n                  if (!(!s3 || !s3[0] || !s3[0].trace)) {\n                    var l3 = s3[0], u4 = l3.trace, c5 = l3.t, f4 = u4._length, h3 = c5.r, d3 = c5.theta, v3 = c5.opts, _2, b = h3.slice(), p3 = d3.slice();\n                    for (_2 = 0; _2 < h3.length; _2++) r4.isPtInside({ r: h3[_2], theta: d3[_2] }) || (b[_2] = NaN, p3[_2] = NaN);\n                    var k4 = new Array(f4 * 2), E3 = Array(f4), S2 = Array(f4);\n                    for (_2 = 0; _2 < f4; _2++) {\n                      var L3 = b[_2], x2, C3;\n                      if (her(L3)) {\n                        var M4 = i3.c2g(L3), g3 = a4.c2g(p3[_2], u4.thetaunit);\n                        x2 = M4 * Math.cos(g3), C3 = M4 * Math.sin(g3);\n                      } else x2 = C3 = NaN;\n                      E3[_2] = k4[_2 * 2] = x2, S2[_2] = k4[_2 * 2 + 1] = C3;\n                    }\n                    c5.tree = fer(k4), v3.marker && f4 >= per && (v3.marker.cluster = c5.tree), v3.marker && (v3.markerSel.positions = v3.markerUnsel.positions = v3.marker.positions = k4), v3.line && k4.length > 1 && S9.extendFlat(v3.line, A9.linePositions(t3, u4, k4)), v3.text && (S9.extendFlat(v3.text, { positions: k4 }, A9.textPosition(t3, u4, v3.text, v3.marker)), S9.extendFlat(v3.textSel, { positions: k4 }, A9.textPosition(t3, u4, v3.text, v3.markerSel)), S9.extendFlat(v3.textUnsel, { positions: k4 }, A9.textPosition(t3, u4, v3.text, v3.markerUnsel))), v3.fill && !o4.fill2d && (o4.fill2d = true), v3.marker && !o4.scatter2d && (o4.scatter2d = true), v3.line && !o4.line2d && (o4.line2d = true), v3.text && !o4.glText && (o4.glText = true), o4.lineOptions.push(v3.line), o4.fillOptions.push(v3.fill), o4.markerOptions.push(v3.marker), o4.markerSelectedOptions.push(v3.markerSel), o4.markerUnselectedOptions.push(v3.markerUnsel), o4.textOptions.push(v3.text), o4.textSelectedOptions.push(v3.textSel), o4.textUnselectedOptions.push(v3.textUnsel), o4.selectBatch.push([]), o4.unselectBatch.push([]), c5.x = E3, c5.y = S2, c5.rawx = E3, c5.rawy = S2, c5.r = h3, c5.theta = d3, c5.positions = k4, c5._scene = o4, c5.index = o4.count, o4.count++;\n                  }\n                }), der(t3, r4, n4);\n              }\n            };\n            $$.exports.reglPrecompiled = ger;\n          });\n          var V$e = ye((r3r, U$e) => {\n            "use strict";\n            var N$e = q$e();\n            N$e.plot = B$e();\n            U$e.exports = N$e;\n          });\n          var H$e = ye((i3r, G$e) => {\n            "use strict";\n            G$e.exports = V$e();\n          });\n          var Q$ = ye((n3r, j$e) => {\n            "use strict";\n            var { hovertemplateAttrs: mer, templatefallbackAttrs: yer } = Ll(), K5 = Ao().extendFlat, Ix = hC(), Rx = Lm();\n            j$e.exports = { r: Ix.r, theta: Ix.theta, r0: Ix.r0, dr: Ix.dr, theta0: Ix.theta0, dtheta: Ix.dtheta, thetaunit: Ix.thetaunit, base: K5({}, Rx.base, {}), offset: K5({}, Rx.offset, {}), width: K5({}, Rx.width, {}), text: K5({}, Rx.text, {}), hovertext: K5({}, Rx.hovertext, {}), marker: _er(), hoverinfo: Ix.hoverinfo, hovertemplate: mer(), hovertemplatefallback: yer(), selected: Rx.selected, unselected: Rx.unselected };\n            function _er() {\n              var e3 = K5({}, Rx.marker);\n              return delete e3.cornerradius, e3;\n            }\n          });\n          var eQ = ye((a3r, W$e) => {\n            "use strict";\n            W$e.exports = { barmode: { valType: "enumerated", values: ["stack", "overlay"], dflt: "stack", editType: "calc" }, bargap: { valType: "number", dflt: 0.1, min: 0, max: 1, editType: "calc" } };\n          });\n          var Y$e = ye((o3r, Z$e) => {\n            "use strict";\n            var X$e = Dr(), xer = b9().handleRThetaDefaults, ber = VI(), wer = Q$();\n            Z$e.exports = function(t3, r4, n4, i3) {\n              function a4(s3, l3) {\n                return X$e.coerce(t3, r4, wer, s3, l3);\n              }\n              var o4 = xer(t3, r4, i3, a4);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              a4("thetaunit"), a4("base"), a4("offset"), a4("width"), a4("text"), a4("hovertext"), a4("hovertemplate"), a4("hovertemplatefallback"), ber(t3, r4, a4, n4, i3), X$e.coerceSelectionMarkerOpacity(r4, a4);\n            };\n          });\n          var J$e = ye((s3r, K$e) => {\n            "use strict";\n            var Ter = Dr(), Aer = eQ();\n            K$e.exports = function(e3, t3, r4) {\n              var n4 = {}, i3;\n              function a4(l3, u4) {\n                return Ter.coerce(e3[i3] || {}, t3[i3], Aer, l3, u4);\n              }\n              for (var o4 = 0; o4 < r4.length; o4++) {\n                var s3 = r4[o4];\n                s3.type === "barpolar" && s3.visible === true && (i3 = s3.subplot, n4[i3] || (a4("barmode"), a4("bargap"), n4[i3] = 1));\n              }\n            };\n          });\n          var tQ = ye((l3r, eQe) => {\n            "use strict";\n            var $$e = pv().hasColorscale, Q$e = gv(), Ser = Dr().isArrayOrTypedArray, Mer = g4(), Eer = jb().setGroupPositions, ker = z0(), Cer = qa().traceIs, Ler = Dr().extendFlat;\n            function Per(e3, t3) {\n              for (var r4 = e3._fullLayout, n4 = t3.subplot, i3 = r4[n4].radialaxis, a4 = r4[n4].angularaxis, o4 = i3.makeCalcdata(t3, "r"), s3 = a4.makeCalcdata(t3, "theta"), l3 = t3._length, u4 = new Array(l3), c5 = o4, f4 = s3, h3 = 0; h3 < l3; h3++) u4[h3] = { p: f4[h3], s: c5[h3] };\n              function d3(v3) {\n                var _2 = t3[v3];\n                _2 !== void 0 && (t3["_" + v3] = Ser(_2) ? a4.makeCalcdata(t3, v3) : a4.d2c(_2, t3.thetaunit));\n              }\n              return a4.type === "linear" && (d3("width"), d3("offset")), $$e(t3, "marker") && Q$e(e3, t3, { vals: t3.marker.color, containerStr: "marker", cLetter: "c" }), $$e(t3, "marker.line") && Q$e(e3, t3, { vals: t3.marker.line.color, containerStr: "marker.line", cLetter: "c" }), Mer(u4, t3), ker(u4, t3), u4;\n            }\n            function Ier(e3, t3, r4) {\n              for (var n4 = e3.calcdata, i3 = [], a4 = 0; a4 < n4.length; a4++) {\n                var o4 = n4[a4], s3 = o4[0].trace;\n                s3.visible === true && Cer(s3, "bar") && s3.subplot === r4 && i3.push(o4);\n              }\n              var l3 = Ler({}, t3.radialaxis, { _id: "x" }), u4 = t3.angularaxis;\n              Eer(e3, u4, l3, i3, { mode: t3.barmode, norm: t3.barnorm, gap: t3.bargap, groupgap: t3.bargroupgap });\n            }\n            eQe.exports = { calc: Per, crossTraceCalc: Ier };\n          });\n          var iQe = ye((u3r, rQe) => {\n            "use strict";\n            var tQe = Oa(), M9 = Eo(), J5 = Dr(), Rer = So(), rQ = f9();\n            rQe.exports = function(t3, r4, n4) {\n              var i3 = t3._context.staticPlot, a4 = r4.xaxis, o4 = r4.yaxis, s3 = r4.radialAxis, l3 = r4.angularAxis, u4 = Der(r4), c5 = r4.layers.frontplot.select("g.barlayer");\n              J5.makeTraceGroups(c5, n4, "trace bars").each(function() {\n                var f4 = tQe.select(this), h3 = J5.ensureSingle(f4, "g", "points"), d3 = h3.selectAll("g.point").data(J5.identity);\n                d3.enter().append("g").style("vector-effect", i3 ? "none" : "non-scaling-stroke").style("stroke-miterlimit", 2).classed("point", true), d3.exit().remove(), d3.each(function(v3) {\n                  var _2 = tQe.select(this), b = v3.rp0 = s3.c2p(v3.s0), p3 = v3.rp1 = s3.c2p(v3.s1), k4 = v3.thetag0 = l3.c2g(v3.p0), E3 = v3.thetag1 = l3.c2g(v3.p1), S2;\n                  if (!M9(b) || !M9(p3) || !M9(k4) || !M9(E3) || b === p3 || k4 === E3) S2 = "M0,0Z";\n                  else {\n                    var L3 = s3.c2g(v3.s1), x2 = (k4 + E3) / 2;\n                    v3.ct = [a4.c2p(L3 * Math.cos(x2)), o4.c2p(L3 * Math.sin(x2))], S2 = u4(b, p3, k4, E3);\n                  }\n                  J5.ensureSingle(_2, "path").attr("d", S2);\n                }), Rer.setClipUrl(f4, r4._hasClipOnAxisFalse ? r4.clipIds.forTraces : null, t3);\n              });\n            };\n            function Der(e3) {\n              var t3 = e3.cxx, r4 = e3.cyy;\n              return e3.vangles ? function(n4, i3, a4, o4) {\n                var s3, l3;\n                J5.angleDelta(a4, o4) > 0 ? (s3 = a4, l3 = o4) : (s3 = o4, l3 = a4);\n                var u4 = rQ.findEnclosingVertexAngles(s3, e3.vangles)[0], c5 = rQ.findEnclosingVertexAngles(l3, e3.vangles)[1], f4 = [u4, (s3 + l3) / 2, c5];\n                return rQ.pathPolygonAnnulus(n4, i3, s3, l3, f4, t3, r4);\n              } : function(n4, i3, a4, o4) {\n                return J5.pathAnnulus(n4, i3, a4, o4, t3, r4);\n              };\n            }\n          });\n          var aQe = ye((c3r, nQe) => {\n            "use strict";\n            var Fer = vf(), iQ = Dr(), zer = ET().getTraceColor, Oer = iQ.fillText, qer = T9().makeHoverPointText, Ber = f9().isPtInsidePolygon;\n            nQe.exports = function(t3, r4, n4) {\n              var i3 = t3.cd, a4 = i3[0].trace, o4 = t3.subplot, s3 = o4.radialAxis, l3 = o4.angularAxis, u4 = o4.vangles, c5 = u4 ? Ber : iQ.isPtInsideSector, f4 = t3.maxHoverDistance, h3 = l3._period || 2 * Math.PI, d3 = Math.abs(s3.g2p(Math.sqrt(r4 * r4 + n4 * n4))), v3 = Math.atan2(n4, r4);\n              s3.range[0] > s3.range[1] && (v3 += Math.PI);\n              var _2 = function(E3) {\n                return c5(d3, v3, [E3.rp0, E3.rp1], [E3.thetag0, E3.thetag1], u4) ? f4 + Math.min(1, Math.abs(E3.thetag1 - E3.thetag0) / h3) - 1 + (E3.rp1 - d3) / (E3.rp1 - E3.rp0) - 1 : 1 / 0;\n              };\n              if (Fer.getClosest(i3, _2, t3), t3.index !== false) {\n                var b = t3.index, p3 = i3[b];\n                t3.x0 = t3.x1 = p3.ct[0], t3.y0 = t3.y1 = p3.ct[1];\n                var k4 = iQ.extendFlat({}, p3, { r: p3.s, theta: p3.p });\n                return Oer(p3, a4, t3), qer(k4, a4, o4, t3), t3.hovertemplate = a4.hovertemplate, t3.color = zer(a4, p3), t3.xLabelVal = t3.yLabelVal = void 0, p3.s < 0 && (t3.idealAlign = "left"), [t3];\n              }\n            };\n          });\n          var sQe = ye((f3r, oQe) => {\n            "use strict";\n            oQe.exports = { moduleType: "trace", name: "barpolar", basePlotModule: y9(), categories: ["polar", "bar", "showLegend"], attributes: Q$(), layoutAttributes: eQ(), supplyDefaults: Y$e(), supplyLayoutDefaults: J$e(), calc: tQ().calc, crossTraceCalc: tQ().crossTraceCalc, plot: iQe(), colorbar: $d(), formatLabels: w9(), style: N0().style, styleOnSelect: N0().styleOnSelect, hoverPoints: aQe(), selectPoints: kT(), meta: {} };\n          });\n          var uQe = ye((h3r, lQe) => {\n            "use strict";\n            lQe.exports = sQe();\n          });\n          var nQ = ye((d3r, cQe) => {\n            "use strict";\n            cQe.exports = { attr: "subplot", name: "smith", axisNames: ["realaxis", "imaginaryaxis"], axisName2dataArray: { imaginaryaxis: "imag", realaxis: "real" } };\n          });\n          var aQ = ye((v3r, vQe) => {\n            "use strict";\n            var Ner = Lh(), Nf = Rd(), Uer = Cc().attributes, Dx = Dr().extendFlat, fQe = mc().overrideAll, hQe = fQe({ color: Nf.color, showline: Dx({}, Nf.showline, { dflt: true }), linecolor: Nf.linecolor, linewidth: Nf.linewidth, showgrid: Dx({}, Nf.showgrid, { dflt: true }), gridcolor: Nf.gridcolor, gridwidth: Nf.gridwidth, griddash: Nf.griddash }, "plot", "from-root"), dQe = fQe({ ticklen: Nf.ticklen, tickwidth: Dx({}, Nf.tickwidth, { dflt: 2 }), tickcolor: Nf.tickcolor, showticklabels: Nf.showticklabels, labelalias: Nf.labelalias, showtickprefix: Nf.showtickprefix, tickprefix: Nf.tickprefix, showticksuffix: Nf.showticksuffix, ticksuffix: Nf.ticksuffix, tickfont: Nf.tickfont, tickformat: Nf.tickformat, hoverformat: Nf.hoverformat, layer: Nf.layer }, "plot", "from-root"), Ver = Dx({ visible: Dx({}, Nf.visible, { dflt: true }), tickvals: { dflt: [0.2, 0.5, 1, 2, 5], valType: "data_array", editType: "plot" }, tickangle: Dx({}, Nf.tickangle, { dflt: 90 }), ticks: { valType: "enumerated", values: ["top", "bottom", ""], editType: "ticks" }, side: { valType: "enumerated", values: ["top", "bottom"], dflt: "top", editType: "plot" }, editType: "calc" }, hQe, dQe), Ger = Dx({ visible: Dx({}, Nf.visible, { dflt: true }), tickvals: { valType: "data_array", editType: "plot" }, ticks: Nf.ticks, editType: "calc" }, hQe, dQe);\n            vQe.exports = { domain: Uer({ name: "smith", editType: "plot" }), bgcolor: { valType: "color", editType: "plot", dflt: Ner.background }, realaxis: Ver, imaginaryaxis: Ger, editType: "calc" };\n          });\n          var mQe = ye((p3r, gQe) => {\n            "use strict";\n            var $5 = Dr(), Her = ka(), jer = vl(), Wer = k_(), Xer = Id().getSubplotData, Zer = t_(), Yer = e_(), Ker = t4(), Jer = ym(), Q5 = aQ(), oQ = nQ(), pQe = oQ.axisNames, $er = etr(function(e3) {\n              return $5.isTypedArray(e3) && (e3 = Array.from(e3)), e3.slice().reverse().map(function(t3) {\n                return -t3;\n              }).concat([0]).concat(e3);\n            }, String);\n            function Qer(e3, t3, r4, n4) {\n              var i3 = r4("bgcolor");\n              n4.bgColor = Her.combine(i3, n4.paper_bgcolor);\n              var a4 = Xer(n4.fullData, oQ.name, n4.id), o4 = n4.layoutOut, s3;\n              function l3(L3, x2) {\n                return r4(s3 + "." + L3, x2);\n              }\n              for (var u4 = 0; u4 < pQe.length; u4++) {\n                s3 = pQe[u4], $5.isPlainObject(e3[s3]) || (e3[s3] = {});\n                var c5 = e3[s3], f4 = jer.newContainer(t3, s3);\n                f4._id = f4._name = s3, f4._attr = n4.id + "." + s3, f4._traceIndices = a4.map(function(L3) {\n                  return L3.index;\n                });\n                var h3 = l3("visible");\n                if (f4.type = "linear", Jer(f4, o4), Zer(c5, f4, l3, f4.type), h3) {\n                  var d3 = s3 === "realaxis";\n                  if (d3 && l3("side"), d3) l3("tickvals");\n                  else {\n                    var v3 = $er(t3.realaxis.tickvals || Q5.realaxis.tickvals.dflt);\n                    l3("tickvals", v3);\n                  }\n                  $5.isTypedArray(f4.tickvals) && (f4.tickvals = Array.from(f4.tickvals));\n                  var _2, b, p3, k4, E3 = n4.font || {};\n                  h3 && (_2 = l3("color"), b = _2 === c5.color ? _2 : E3.color, p3 = E3.size, k4 = E3.family), Yer(c5, f4, l3, f4.type, { noAutotickangles: true, noTicklabelshift: true, noTicklabelstandoff: true, noTicklabelstep: true, noAng: !d3, noExp: true, font: { color: b, size: p3, family: k4 } }), $5.coerce2(e3, t3, Q5, s3 + ".ticklen"), $5.coerce2(e3, t3, Q5, s3 + ".tickwidth"), $5.coerce2(e3, t3, Q5, s3 + ".tickcolor", t3.color);\n                  var S2 = l3("ticks");\n                  S2 || (delete t3[s3].ticklen, delete t3[s3].tickwidth, delete t3[s3].tickcolor), Ker(c5, f4, l3, { dfltColor: _2, bgColor: n4.bgColor, blend: 60, showLine: true, showGrid: true, noZeroLine: true, attributes: Q5[s3] }), l3("layer");\n                }\n                l3("hoverformat"), delete f4.type, f4._input = c5;\n              }\n            }\n            gQe.exports = function(t3, r4, n4) {\n              Wer(t3, r4, n4, { noUirevision: true, type: oQ.name, attributes: Q5, handleDefaults: Qer, font: r4.font, paper_bgcolor: r4.paper_bgcolor, fullData: n4, layoutOut: r4 });\n            };\n            function etr(e3, t3) {\n              var r4 = {};\n              return function(n4) {\n                var i3 = t3 ? t3(n4) : n4;\n                if (i3 in r4) return r4[i3];\n                var a4 = e3(n4);\n                return r4[i3] = a4, a4;\n              };\n            }\n          });\n          var TQe = ye((g3r, wQe) => {\n            "use strict";\n            var ttr = Id().getSubplotCalcData, rtr = Dr().counterRegex, itr = Z$(), _Qe = nQ(), xQe = _Qe.attr, xw = _Qe.name, yQe = rtr(xw), bQe = {};\n            bQe[xQe] = { valType: "subplotid", dflt: xw, editType: "calc" };\n            function ntr(e3) {\n              for (var t3 = e3._fullLayout, r4 = e3.calcdata, n4 = t3._subplots[xw], i3 = 0; i3 < n4.length; i3++) {\n                var a4 = n4[i3], o4 = ttr(r4, xw, a4), s3 = t3[a4]._subplot;\n                s3 || (s3 = itr(e3, a4, true), t3[a4]._subplot = s3), s3.plot(o4, t3, e3._promises);\n              }\n            }\n            function atr(e3, t3, r4, n4) {\n              for (var i3 = n4._subplots[xw] || [], a4 = 0; a4 < i3.length; a4++) {\n                var o4 = i3[a4], s3 = n4[o4]._subplot;\n                if (!t3[o4] && s3) {\n                  s3.framework.remove();\n                  for (var l3 in s3.clipPaths) s3.clipPaths[l3].remove();\n                }\n              }\n            }\n            wQe.exports = { attr: xQe, name: xw, idRoot: xw, idRegex: yQe, attrRegex: yQe, attributes: bQe, layoutAttributes: aQ(), supplyLayoutDefaults: mQe(), plot: ntr, clean: atr, toSVG: ph().toSVG };\n          });\n          var sQ = ye((m3r, SQe) => {\n            "use strict";\n            var { hovertemplateAttrs: otr, texttemplateAttrs: str, templatefallbackAttrs: AQe } = Ll(), E9 = Ao().extendFlat, ltr = Cg(), h0 = pf(), utr = Gl(), eS = h0.line;\n            SQe.exports = { mode: h0.mode, real: { valType: "data_array", editType: "calc+clearAxisTypes" }, imag: { valType: "data_array", editType: "calc+clearAxisTypes" }, text: h0.text, texttemplate: str({ editType: "plot" }, { keys: ["real", "imag", "text"] }), texttemplatefallback: AQe({ editType: "plot" }), hovertext: h0.hovertext, line: { color: eS.color, width: eS.width, dash: eS.dash, backoff: eS.backoff, shape: E9({}, eS.shape, { values: ["linear", "spline"] }), smoothing: eS.smoothing, editType: "calc" }, connectgaps: h0.connectgaps, marker: h0.marker, cliponaxis: E9({}, h0.cliponaxis, { dflt: false }), textposition: h0.textposition, textfont: h0.textfont, fill: E9({}, h0.fill, { values: ["none", "toself", "tonext"], dflt: "none" }), fillcolor: ltr(), hoverinfo: E9({}, utr.hoverinfo, { flags: ["real", "imag", "text", "name"] }), hoveron: h0.hoveron, hovertemplate: otr(), hovertemplatefallback: AQe(), selected: h0.selected, unselected: h0.unselected };\n          });\n          var kQe = ye((y3r, EQe) => {\n            "use strict";\n            var k9 = Dr(), tS = Ru(), ctr = $p(), ftr = R0(), MQe = tT(), htr = D0(), dtr = Rg(), vtr = Sm().PTS_LINESONLY, ptr = sQ();\n            EQe.exports = function(t3, r4, n4, i3) {\n              function a4(l3, u4) {\n                return k9.coerce(t3, r4, ptr, l3, u4);\n              }\n              var o4 = gtr(t3, r4, i3, a4);\n              if (!o4) {\n                r4.visible = false;\n                return;\n              }\n              a4("mode", o4 < vtr ? "lines+markers" : "lines"), a4("text"), a4("hovertext"), r4.hoveron !== "fills" && (a4("hovertemplate"), a4("hovertemplatefallback")), tS.hasMarkers(r4) && ctr(t3, r4, n4, i3, a4, { gradient: true }), tS.hasLines(r4) && (ftr(t3, r4, n4, i3, a4, { backoff: true }), MQe(t3, r4, a4), a4("connectgaps")), tS.hasText(r4) && (a4("texttemplate"), a4("texttemplatefallback"), htr(t3, r4, i3, a4));\n              var s3 = [];\n              (tS.hasMarkers(r4) || tS.hasText(r4)) && (a4("cliponaxis"), a4("marker.maxdisplayed"), s3.push("points")), a4("fill"), r4.fill !== "none" && (dtr(t3, r4, n4, a4), tS.hasLines(r4) || MQe(t3, r4, a4)), (r4.fill === "tonext" || r4.fill === "toself") && s3.push("fills"), a4("hoveron", s3.join("+") || "points"), k9.coerceSelectionMarkerOpacity(r4, a4);\n            };\n            function gtr(e3, t3, r4, n4) {\n              var i3 = n4("real"), a4 = n4("imag"), o4;\n              return i3 && a4 && (o4 = Math.min(i3.length, a4.length)), k9.isTypedArray(i3) && (t3.real = i3 = Array.from(i3)), k9.isTypedArray(a4) && (t3.imag = a4 = Array.from(a4)), t3._length = o4, o4;\n            }\n          });\n          var PQe = ye((_3r, LQe) => {\n            "use strict";\n            var CQe = ho();\n            LQe.exports = function(t3, r4, n4) {\n              var i3 = {}, a4 = n4[r4.subplot]._subplot;\n              return i3.realLabel = CQe.tickText(a4.radialAxis, t3.real, true).text, i3.imagLabel = CQe.tickText(a4.angularAxis, t3.imag, true).text, i3;\n            };\n          });\n          var DQe = ye((x3r, RQe) => {\n            "use strict";\n            var IQe = Eo(), mtr = fs().BADNUM, ytr = F0(), _tr = km(), xtr = z0(), btr = O0().calcMarkerSize;\n            RQe.exports = function(t3, r4) {\n              for (var n4 = t3._fullLayout, i3 = r4.subplot, a4 = n4[i3].realaxis, o4 = n4[i3].imaginaryaxis, s3 = a4.makeCalcdata(r4, "real"), l3 = o4.makeCalcdata(r4, "imag"), u4 = r4._length, c5 = new Array(u4), f4 = 0; f4 < u4; f4++) {\n                var h3 = s3[f4], d3 = l3[f4], v3 = c5[f4] = {};\n                IQe(h3) && IQe(d3) ? (v3.real = h3, v3.imag = d3) : v3.real = mtr;\n              }\n              return btr(r4, u4), ytr(t3, r4), _tr(c5, r4), xtr(c5, r4), c5;\n            };\n          });\n          var OQe = ye((b3r, zQe) => {\n            "use strict";\n            var wtr = sT(), FQe = fs().BADNUM, Ttr = j$(), Atr = Ttr.smith;\n            zQe.exports = function(t3, r4, n4) {\n              for (var i3 = r4.layers.frontplot.select("g.scatterlayer"), a4 = r4.xaxis, o4 = r4.yaxis, s3 = { xaxis: a4, yaxis: o4, plot: r4.framework, layerClipId: r4._hasClipOnAxisFalse ? r4.clipIds.forTraces : null }, l3 = 0; l3 < n4.length; l3++) for (var u4 = n4[l3], c5 = 0; c5 < u4.length; c5++) {\n                c5 === 0 && (u4[0].trace._xA = a4, u4[0].trace._yA = o4);\n                var f4 = u4[c5], h3 = f4.real;\n                if (h3 === FQe) f4.x = f4.y = FQe;\n                else {\n                  var d3 = Atr([h3, f4.imag]);\n                  f4.x = d3[0], f4.y = d3[1];\n                }\n              }\n              wtr(t3, s3, n4, i3);\n            };\n          });\n          var NQe = ye((w3r, BQe) => {\n            "use strict";\n            var Str = fT();\n            function Mtr(e3, t3, r4, n4) {\n              var i3 = Str(e3, t3, r4, n4);\n              if (!(!i3 || i3[0].index === false)) {\n                var a4 = i3[0];\n                if (a4.index === void 0) return i3;\n                var o4 = e3.subplot, s3 = a4.cd[a4.index], l3 = a4.trace;\n                if (o4.isPtInside(s3)) return a4.xLabelVal = void 0, a4.yLabelVal = void 0, qQe(s3, l3, o4, a4), a4.hovertemplate = l3.hovertemplate, i3;\n              }\n            }\n            function qQe(e3, t3, r4, n4) {\n              var i3 = r4.radialAxis, a4 = r4.angularAxis;\n              i3._hovertitle = "real", a4._hovertitle = "imag";\n              var o4 = {};\n              o4[t3.subplot] = { _subplot: r4 };\n              var s3 = t3._module.formatLabels(e3, t3, o4);\n              n4.realLabel = s3.realLabel, n4.imagLabel = s3.imagLabel;\n              var l3 = e3.hi || t3.hoverinfo, u4 = [];\n              function c5(h3, d3) {\n                u4.push(h3._hovertitle + ": " + d3);\n              }\n              if (!t3.hovertemplate) {\n                var f4 = l3.split("+");\n                f4.indexOf("all") !== -1 && (f4 = ["real", "imag", "text"]), f4.indexOf("real") !== -1 && c5(i3, n4.realLabel), f4.indexOf("imag") !== -1 && c5(a4, n4.imagLabel), f4.indexOf("text") !== -1 && n4.text && (u4.push(n4.text), delete n4.text), n4.extraText = u4.join("<br>");\n              }\n            }\n            BQe.exports = { hoverPoints: Mtr, makeHoverPointText: qQe };\n          });\n          var VQe = ye((T3r, UQe) => {\n            "use strict";\n            UQe.exports = { moduleType: "trace", name: "scattersmith", basePlotModule: TQe(), categories: ["smith", "symbols", "showLegend", "scatter-like"], attributes: sQ(), supplyDefaults: kQe(), colorbar: $d(), formatLabels: PQe(), calc: DQe(), plot: OQe(), style: op().style, styleOnSelect: op().styleOnSelect, hoverPoints: NQe().hoverPoints, selectPoints: hT(), meta: {} };\n          });\n          var HQe = ye((A3r, GQe) => {\n            "use strict";\n            GQe.exports = VQe();\n          });\n          var kv = ye((S3r, WQe) => {\n            var L9 = Oh();\n            function jQe() {\n              this.regionalOptions = [], this.regionalOptions[""] = { invalidCalendar: "Calendar {0} not found", invalidDate: "Invalid {0} date", invalidMonth: "Invalid {0} month", invalidYear: "Invalid {0} year", differentCalendars: "Cannot mix {0} and {1} dates" }, this.local = this.regionalOptions[""], this.calendars = {}, this._localCals = {};\n            }\n            L9(jQe.prototype, { instance: function(e3, t3) {\n              e3 = (e3 || "gregorian").toLowerCase(), t3 = t3 || "";\n              var r4 = this._localCals[e3 + "-" + t3];\n              if (!r4 && this.calendars[e3] && (r4 = new this.calendars[e3](t3), this._localCals[e3 + "-" + t3] = r4), !r4) throw (this.local.invalidCalendar || this.regionalOptions[""].invalidCalendar).replace(/\\{0\\}/, e3);\n              return r4;\n            }, newDate: function(e3, t3, r4, n4, i3) {\n              return n4 = (e3 != null && e3.year ? e3.calendar() : typeof n4 == "string" ? this.instance(n4, i3) : n4) || this.instance(), n4.newDate(e3, t3, r4);\n            }, substituteDigits: function(e3) {\n              return function(t3) {\n                return (t3 + "").replace(/[0-9]/g, function(r4) {\n                  return e3[r4];\n                });\n              };\n            }, substituteChineseDigits: function(e3, t3) {\n              return function(r4) {\n                for (var n4 = "", i3 = 0; r4 > 0; ) {\n                  var a4 = r4 % 10;\n                  n4 = (a4 === 0 ? "" : e3[a4] + t3[i3]) + n4, i3++, r4 = Math.floor(r4 / 10);\n                }\n                return n4.indexOf(e3[1] + t3[1]) === 0 && (n4 = n4.substr(1)), n4 || e3[0];\n              };\n            } });\n            function lQ(e3, t3, r4, n4) {\n              if (this._calendar = e3, this._year = t3, this._month = r4, this._day = n4, this._calendar._validateLevel === 0 && !this._calendar.isValid(this._year, this._month, this._day)) throw (Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate).replace(/\\{0\\}/, this._calendar.local.name);\n            }\n            function C9(e3, t3) {\n              return e3 = "" + e3, "000000".substring(0, t3 - e3.length) + e3;\n            }\n            L9(lQ.prototype, { newDate: function(e3, t3, r4) {\n              return this._calendar.newDate(e3 == null ? this : e3, t3, r4);\n            }, year: function(e3) {\n              return arguments.length === 0 ? this._year : this.set(e3, "y");\n            }, month: function(e3) {\n              return arguments.length === 0 ? this._month : this.set(e3, "m");\n            }, day: function(e3) {\n              return arguments.length === 0 ? this._day : this.set(e3, "d");\n            }, date: function(e3, t3, r4) {\n              if (!this._calendar.isValid(e3, t3, r4)) throw (Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate).replace(/\\{0\\}/, this._calendar.local.name);\n              return this._year = e3, this._month = t3, this._day = r4, this;\n            }, leapYear: function() {\n              return this._calendar.leapYear(this);\n            }, epoch: function() {\n              return this._calendar.epoch(this);\n            }, formatYear: function() {\n              return this._calendar.formatYear(this);\n            }, monthOfYear: function() {\n              return this._calendar.monthOfYear(this);\n            }, weekOfYear: function() {\n              return this._calendar.weekOfYear(this);\n            }, daysInYear: function() {\n              return this._calendar.daysInYear(this);\n            }, dayOfYear: function() {\n              return this._calendar.dayOfYear(this);\n            }, daysInMonth: function() {\n              return this._calendar.daysInMonth(this);\n            }, dayOfWeek: function() {\n              return this._calendar.dayOfWeek(this);\n            }, weekDay: function() {\n              return this._calendar.weekDay(this);\n            }, extraInfo: function() {\n              return this._calendar.extraInfo(this);\n            }, add: function(e3, t3) {\n              return this._calendar.add(this, e3, t3);\n            }, set: function(e3, t3) {\n              return this._calendar.set(this, e3, t3);\n            }, compareTo: function(e3) {\n              if (this._calendar.name !== e3._calendar.name) throw (Gs.local.differentCalendars || Gs.regionalOptions[""].differentCalendars).replace(/\\{0\\}/, this._calendar.local.name).replace(/\\{1\\}/, e3._calendar.local.name);\n              var t3 = this._year !== e3._year ? this._year - e3._year : this._month !== e3._month ? this.monthOfYear() - e3.monthOfYear() : this._day - e3._day;\n              return t3 === 0 ? 0 : t3 < 0 ? -1 : 1;\n            }, calendar: function() {\n              return this._calendar;\n            }, toJD: function() {\n              return this._calendar.toJD(this);\n            }, fromJD: function(e3) {\n              return this._calendar.fromJD(e3);\n            }, toJSDate: function() {\n              return this._calendar.toJSDate(this);\n            }, fromJSDate: function(e3) {\n              return this._calendar.fromJSDate(e3);\n            }, toString: function() {\n              return (this.year() < 0 ? "-" : "") + C9(Math.abs(this.year()), 4) + "-" + C9(this.month(), 2) + "-" + C9(this.day(), 2);\n            } });\n            function uQ() {\n              this.shortYearCutoff = "+10";\n            }\n            L9(uQ.prototype, { _validateLevel: 0, newDate: function(e3, t3, r4) {\n              return e3 == null ? this.today() : (e3.year && (this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), r4 = e3.day(), t3 = e3.month(), e3 = e3.year()), new lQ(this, e3, t3, r4));\n            }, today: function() {\n              return this.fromJSDate(/* @__PURE__ */ new Date());\n            }, epoch: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);\n              return t3.year() < 0 ? this.local.epochs[0] : this.local.epochs[1];\n            }, formatYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);\n              return (t3.year() < 0 ? "-" : "") + C9(Math.abs(t3.year()), 4);\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear), 12;\n            }, monthOfYear: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth);\n              return (r4.month() + this.monthsInYear(r4) - this.firstMonth) % this.monthsInYear(r4) + this.minMonth;\n            }, fromMonthOfYear: function(e3, t3) {\n              var r4 = (t3 + this.firstMonth - 2 * this.minMonth) % this.monthsInYear(e3) + this.minMonth;\n              return this._validate(e3, r4, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth), r4;\n            }, daysInYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear);\n              return this.leapYear(t3) ? 366 : 365;\n            }, dayOfYear: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);\n              return n4.toJD() - this.newDate(n4.year(), this.fromMonthOfYear(n4.year(), this.minMonth), this.minDay).toJD() + 1;\n            }, daysInWeek: function() {\n              return 7;\n            }, dayOfWeek: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);\n              return (Math.floor(this.toJD(n4)) + 2) % this.daysInWeek();\n            }, extraInfo: function(e3, t3, r4) {\n              return this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), {};\n            }, add: function(e3, t3, r4) {\n              return this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), this._correctAdd(e3, this._add(e3, t3, r4), t3, r4);\n            }, _add: function(e3, t3, r4) {\n              if (this._validateLevel++, r4 === "d" || r4 === "w") {\n                var n4 = e3.toJD() + t3 * (r4 === "w" ? this.daysInWeek() : 1), i3 = e3.calendar().fromJD(n4);\n                return this._validateLevel--, [i3.year(), i3.month(), i3.day()];\n              }\n              try {\n                var a4 = e3.year() + (r4 === "y" ? t3 : 0), o4 = e3.monthOfYear() + (r4 === "m" ? t3 : 0), i3 = e3.day(), s3 = function(c5) {\n                  for (; o4 < c5.minMonth; ) a4--, o4 += c5.monthsInYear(a4);\n                  for (var f4 = c5.monthsInYear(a4); o4 > f4 - 1 + c5.minMonth; ) a4++, o4 -= f4, f4 = c5.monthsInYear(a4);\n                };\n                r4 === "y" ? (e3.month() !== this.fromMonthOfYear(a4, o4) && (o4 = this.newDate(a4, e3.month(), this.minDay).monthOfYear()), o4 = Math.min(o4, this.monthsInYear(a4)), i3 = Math.min(i3, this.daysInMonth(a4, this.fromMonthOfYear(a4, o4)))) : r4 === "m" && (s3(this), i3 = Math.min(i3, this.daysInMonth(a4, this.fromMonthOfYear(a4, o4))));\n                var l3 = [a4, this.fromMonthOfYear(a4, o4), i3];\n                return this._validateLevel--, l3;\n              } catch (u4) {\n                throw this._validateLevel--, u4;\n              }\n            }, _correctAdd: function(e3, t3, r4, n4) {\n              if (!this.hasYearZero && (n4 === "y" || n4 === "m") && (t3[0] === 0 || e3.year() > 0 != t3[0] > 0)) {\n                var i3 = { y: [1, 1, "y"], m: [1, this.monthsInYear(-1), "m"], w: [this.daysInWeek(), this.daysInYear(-1), "d"], d: [1, this.daysInYear(-1), "d"] }[n4], a4 = r4 < 0 ? -1 : 1;\n                t3 = this._add(e3, r4 * i3[0] + a4 * i3[1], i3[2]);\n              }\n              return e3.date(t3[0], t3[1], t3[2]);\n            }, set: function(e3, t3, r4) {\n              this._validate(e3, this.minMonth, this.minDay, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);\n              var n4 = r4 === "y" ? t3 : e3.year(), i3 = r4 === "m" ? t3 : e3.month(), a4 = r4 === "d" ? t3 : e3.day();\n              return (r4 === "y" || r4 === "m") && (a4 = Math.min(a4, this.daysInMonth(n4, i3))), e3.date(n4, i3, a4);\n            }, isValid: function(e3, t3, r4) {\n              this._validateLevel++;\n              var n4 = this.hasYearZero || e3 !== 0;\n              if (n4) {\n                var i3 = this.newDate(e3, t3, this.minDay);\n                n4 = t3 >= this.minMonth && t3 - this.minMonth < this.monthsInYear(i3) && r4 >= this.minDay && r4 - this.minDay < this.daysInMonth(i3);\n              }\n              return this._validateLevel--, n4;\n            }, toJSDate: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);\n              return Gs.instance().fromJD(this.toJD(n4)).toJSDate();\n            }, fromJSDate: function(e3) {\n              return this.fromJD(Gs.instance().fromJSDate(e3).toJD());\n            }, _validate: function(e3, t3, r4, n4) {\n              if (e3.year) {\n                if (this._validateLevel === 0 && this.name !== e3.calendar().name) throw (Gs.local.differentCalendars || Gs.regionalOptions[""].differentCalendars).replace(/\\{0\\}/, this.local.name).replace(/\\{1\\}/, e3.calendar().local.name);\n                return e3;\n              }\n              try {\n                if (this._validateLevel++, this._validateLevel === 1 && !this.isValid(e3, t3, r4)) throw n4.replace(/\\{0\\}/, this.local.name);\n                var i3 = this.newDate(e3, t3, r4);\n                return this._validateLevel--, i3;\n              } catch (a4) {\n                throw this._validateLevel--, a4;\n              }\n            } });\n            function cQ(e3) {\n              this.local = this.regionalOptions[e3] || this.regionalOptions[""];\n            }\n            cQ.prototype = new uQ();\n            L9(cQ.prototype, { name: "Gregorian", jdEpoch: 17214255e-1, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Gregorian", epochs: ["BCE", "CE"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "mm/dd/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, Gs.local.invalidYear || Gs.regionalOptions[""].invalidYear), r4 = t3.year() + (t3.year() < 0 ? 1 : 0);\n              return r4 % 4 === 0 && (r4 % 100 !== 0 || r4 % 400 === 0);\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(4 - (n4.dayOfWeek() || 7), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, Gs.local.invalidMonth || Gs.regionalOptions[""].invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 2 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate);\n              e3 = n4.year(), t3 = n4.month(), r4 = n4.day(), e3 < 0 && e3++, t3 < 3 && (t3 += 12, e3--);\n              var i3 = Math.floor(e3 / 100), a4 = 2 - i3 + Math.floor(i3 / 4);\n              return Math.floor(365.25 * (e3 + 4716)) + Math.floor(30.6001 * (t3 + 1)) + r4 + a4 - 1524.5;\n            }, fromJD: function(e3) {\n              var t3 = Math.floor(e3 + 0.5), r4 = Math.floor((t3 - 186721625e-2) / 36524.25);\n              r4 = t3 + 1 + r4 - Math.floor(r4 / 4);\n              var n4 = r4 + 1524, i3 = Math.floor((n4 - 122.1) / 365.25), a4 = Math.floor(365.25 * i3), o4 = Math.floor((n4 - a4) / 30.6001), s3 = n4 - a4 - Math.floor(o4 * 30.6001), l3 = o4 - (o4 > 13.5 ? 13 : 1), u4 = i3 - (l3 > 2.5 ? 4716 : 4715);\n              return u4 <= 0 && u4--, this.newDate(u4, l3, s3);\n            }, toJSDate: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Gs.local.invalidDate || Gs.regionalOptions[""].invalidDate), i3 = new Date(n4.year(), n4.month() - 1, n4.day());\n              return i3.setHours(0), i3.setMinutes(0), i3.setSeconds(0), i3.setMilliseconds(0), i3.setHours(i3.getHours() > 12 ? i3.getHours() + 2 : 0), i3;\n            }, fromJSDate: function(e3) {\n              return this.newDate(e3.getFullYear(), e3.getMonth() + 1, e3.getDate());\n            } });\n            var Gs = WQe.exports = new jQe();\n            Gs.cdate = lQ;\n            Gs.baseCalendar = uQ;\n            Gs.calendars.gregorian = cQ;\n          });\n          var XQe = ye(() => {\n            var fQ = Oh(), Ud = kv();\n            fQ(Ud.regionalOptions[""], { invalidArguments: "Invalid arguments", invalidFormat: "Cannot format a date from another calendar", missingNumberAt: "Missing number at position {0}", unknownNameAt: "Unknown name at position {0}", unexpectedLiteralAt: "Unexpected literal at position {0}", unexpectedText: "Additional text found at end" });\n            Ud.local = Ud.regionalOptions[""];\n            fQ(Ud.cdate.prototype, { formatDate: function(e3, t3) {\n              return typeof e3 != "string" && (t3 = e3, e3 = ""), this._calendar.formatDate(e3 || "", this, t3);\n            } });\n            fQ(Ud.baseCalendar.prototype, { UNIX_EPOCH: Ud.instance().newDate(1970, 1, 1).toJD(), SECS_PER_DAY: 24 * 60 * 60, TICKS_EPOCH: Ud.instance().jdEpoch, TICKS_PER_DAY: 24 * 60 * 60 * 1e7, ATOM: "yyyy-mm-dd", COOKIE: "D, dd M yyyy", FULL: "DD, MM d, yyyy", ISO_8601: "yyyy-mm-dd", JULIAN: "J", RFC_822: "D, d M yy", RFC_850: "DD, dd-M-yy", RFC_1036: "D, d M yy", RFC_1123: "D, d M yyyy", RFC_2822: "D, d M yyyy", RSS: "D, d M yy", TICKS: "!", TIMESTAMP: "@", W3C: "yyyy-mm-dd", formatDate: function(e3, t3, r4) {\n              if (typeof e3 != "string" && (r4 = t3, t3 = e3, e3 = ""), !t3) return "";\n              if (t3.calendar() !== this) throw Ud.local.invalidFormat || Ud.regionalOptions[""].invalidFormat;\n              e3 = e3 || this.local.dateFormat, r4 = r4 || {};\n              for (var n4 = r4.dayNamesShort || this.local.dayNamesShort, i3 = r4.dayNames || this.local.dayNames, a4 = r4.monthNumbers || this.local.monthNumbers, o4 = r4.monthNamesShort || this.local.monthNamesShort, s3 = r4.monthNames || this.local.monthNames, l3 = r4.calculateWeek || this.local.calculateWeek, u4 = function(S2, L3) {\n                for (var x2 = 1; E3 + x2 < e3.length && e3.charAt(E3 + x2) === S2; ) x2++;\n                return E3 += x2 - 1, Math.floor(x2 / (L3 || 1)) > 1;\n              }, c5 = function(S2, L3, x2, C3) {\n                var M4 = "" + L3;\n                if (u4(S2, C3)) for (; M4.length < x2; ) M4 = "0" + M4;\n                return M4;\n              }, f4 = function(S2, L3, x2, C3) {\n                return u4(S2) ? C3[L3] : x2[L3];\n              }, h3 = this, d3 = function(S2) {\n                return typeof a4 == "function" ? a4.call(h3, S2, u4("m")) : b(c5("m", S2.month(), 2));\n              }, v3 = function(S2, L3) {\n                return L3 ? typeof s3 == "function" ? s3.call(h3, S2) : s3[S2.month() - h3.minMonth] : typeof o4 == "function" ? o4.call(h3, S2) : o4[S2.month() - h3.minMonth];\n              }, _2 = this.local.digits, b = function(S2) {\n                return r4.localNumbers && _2 ? _2(S2) : S2;\n              }, p3 = "", k4 = false, E3 = 0; E3 < e3.length; E3++) if (k4) e3.charAt(E3) === "\'" && !u4("\'") ? k4 = false : p3 += e3.charAt(E3);\n              else switch (e3.charAt(E3)) {\n                case "d":\n                  p3 += b(c5("d", t3.day(), 2));\n                  break;\n                case "D":\n                  p3 += f4("D", t3.dayOfWeek(), n4, i3);\n                  break;\n                case "o":\n                  p3 += c5("o", t3.dayOfYear(), 3);\n                  break;\n                case "w":\n                  p3 += c5("w", t3.weekOfYear(), 2);\n                  break;\n                case "m":\n                  p3 += d3(t3);\n                  break;\n                case "M":\n                  p3 += v3(t3, u4("M"));\n                  break;\n                case "y":\n                  p3 += u4("y", 2) ? t3.year() : (t3.year() % 100 < 10 ? "0" : "") + t3.year() % 100;\n                  break;\n                case "Y":\n                  u4("Y", 2), p3 += t3.formatYear();\n                  break;\n                case "J":\n                  p3 += t3.toJD();\n                  break;\n                case "@":\n                  p3 += (t3.toJD() - this.UNIX_EPOCH) * this.SECS_PER_DAY;\n                  break;\n                case "!":\n                  p3 += (t3.toJD() - this.TICKS_EPOCH) * this.TICKS_PER_DAY;\n                  break;\n                case "\'":\n                  u4("\'") ? p3 += "\'" : k4 = true;\n                  break;\n                default:\n                  p3 += e3.charAt(E3);\n              }\n              return p3;\n            }, parseDate: function(e3, t3, r4) {\n              if (t3 == null) throw Ud.local.invalidArguments || Ud.regionalOptions[""].invalidArguments;\n              if (t3 = typeof t3 == "object" ? t3.toString() : t3 + "", t3 === "") return null;\n              e3 = e3 || this.local.dateFormat, r4 = r4 || {};\n              var n4 = r4.shortYearCutoff || this.shortYearCutoff;\n              n4 = typeof n4 != "string" ? n4 : this.today().year() % 100 + parseInt(n4, 10);\n              for (var i3 = r4.dayNamesShort || this.local.dayNamesShort, a4 = r4.dayNames || this.local.dayNames, o4 = r4.parseMonth || this.local.parseMonth, s3 = r4.monthNumbers || this.local.monthNumbers, l3 = r4.monthNamesShort || this.local.monthNamesShort, u4 = r4.monthNames || this.local.monthNames, c5 = -1, f4 = -1, h3 = -1, d3 = -1, v3 = -1, _2 = false, b = false, p3 = function(z3, O3) {\n                for (var V2 = 1; g3 + V2 < e3.length && e3.charAt(g3 + V2) === z3; ) V2++;\n                return g3 += V2 - 1, Math.floor(V2 / (O3 || 1)) > 1;\n              }, k4 = function(z3, O3) {\n                var V2 = p3(z3, O3), G2 = [2, 3, V2 ? 4 : 2, V2 ? 4 : 2, 10, 11, 20]["oyYJ@!".indexOf(z3) + 1], Z = new RegExp("^-?\\\\d{1," + G2 + "}"), j3 = t3.substring(M4).match(Z);\n                if (!j3) throw (Ud.local.missingNumberAt || Ud.regionalOptions[""].missingNumberAt).replace(/\\{0\\}/, M4);\n                return M4 += j3[0].length, parseInt(j3[0], 10);\n              }, E3 = this, S2 = function() {\n                if (typeof s3 == "function") {\n                  p3("m");\n                  var z3 = s3.call(E3, t3.substring(M4));\n                  return M4 += z3.length, z3;\n                }\n                return k4("m");\n              }, L3 = function(z3, O3, V2, G2) {\n                for (var Z = p3(z3, G2) ? V2 : O3, j3 = 0; j3 < Z.length; j3++) if (t3.substr(M4, Z[j3].length).toLowerCase() === Z[j3].toLowerCase()) return M4 += Z[j3].length, j3 + E3.minMonth;\n                throw (Ud.local.unknownNameAt || Ud.regionalOptions[""].unknownNameAt).replace(/\\{0\\}/, M4);\n              }, x2 = function() {\n                if (typeof u4 == "function") {\n                  var z3 = p3("M") ? u4.call(E3, t3.substring(M4)) : l3.call(E3, t3.substring(M4));\n                  return M4 += z3.length, z3;\n                }\n                return L3("M", l3, u4);\n              }, C3 = function() {\n                if (t3.charAt(M4) !== e3.charAt(g3)) throw (Ud.local.unexpectedLiteralAt || Ud.regionalOptions[""].unexpectedLiteralAt).replace(/\\{0\\}/, M4);\n                M4++;\n              }, M4 = 0, g3 = 0; g3 < e3.length; g3++) if (b) e3.charAt(g3) === "\'" && !p3("\'") ? b = false : C3();\n              else switch (e3.charAt(g3)) {\n                case "d":\n                  d3 = k4("d");\n                  break;\n                case "D":\n                  L3("D", i3, a4);\n                  break;\n                case "o":\n                  v3 = k4("o");\n                  break;\n                case "w":\n                  k4("w");\n                  break;\n                case "m":\n                  h3 = S2();\n                  break;\n                case "M":\n                  h3 = x2();\n                  break;\n                case "y":\n                  var P3 = g3;\n                  _2 = !p3("y", 2), g3 = P3, f4 = k4("y", 2);\n                  break;\n                case "Y":\n                  f4 = k4("Y", 2);\n                  break;\n                case "J":\n                  c5 = k4("J") + 0.5, t3.charAt(M4) === "." && (M4++, k4("J"));\n                  break;\n                case "@":\n                  c5 = k4("@") / this.SECS_PER_DAY + this.UNIX_EPOCH;\n                  break;\n                case "!":\n                  c5 = k4("!") / this.TICKS_PER_DAY + this.TICKS_EPOCH;\n                  break;\n                case "*":\n                  M4 = t3.length;\n                  break;\n                case "\'":\n                  p3("\'") ? C3() : b = true;\n                  break;\n                default:\n                  C3();\n              }\n              if (M4 < t3.length) throw Ud.local.unexpectedText || Ud.regionalOptions[""].unexpectedText;\n              if (f4 === -1 ? f4 = this.today().year() : f4 < 100 && _2 && (f4 += n4 === -1 ? 1900 : this.today().year() - this.today().year() % 100 - (f4 <= n4 ? 0 : 100)), typeof h3 == "string" && (h3 = o4.call(this, f4, h3)), v3 > -1) {\n                h3 = 1, d3 = v3;\n                for (var T3 = this.daysInMonth(f4, h3); d3 > T3; T3 = this.daysInMonth(f4, h3)) h3++, d3 -= T3;\n              }\n              return c5 > -1 ? this.fromJD(c5) : this.newDate(f4, h3, d3);\n            }, determineDate: function(e3, t3, r4, n4, i3) {\n              r4 && typeof r4 != "object" && (i3 = n4, n4 = r4, r4 = null), typeof n4 != "string" && (i3 = n4, n4 = "");\n              var a4 = this, o4 = function(s3) {\n                try {\n                  return a4.parseDate(n4, s3, i3);\n                } catch (f4) {\n                }\n                s3 = s3.toLowerCase();\n                for (var l3 = (s3.match(/^c/) && r4 ? r4.newDate() : null) || a4.today(), u4 = /([+-]?[0-9]+)\\s*(d|w|m|y)?/g, c5 = u4.exec(s3); c5; ) l3.add(parseInt(c5[1], 10), c5[2] || "d"), c5 = u4.exec(s3);\n                return l3;\n              };\n              return t3 = t3 ? t3.newDate() : null, e3 = e3 == null ? t3 : typeof e3 == "string" ? o4(e3) : typeof e3 == "number" ? isNaN(e3) || e3 === 1 / 0 || e3 === -1 / 0 ? t3 : a4.today().add(e3, "d") : a4.newDate(e3), e3;\n            } });\n          });\n          var ZQe = ye(() => {\n            var Fx = kv(), Etr = Oh(), hQ = Fx.instance();\n            function P9(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            P9.prototype = new Fx.baseCalendar();\n            Etr(P9.prototype, { name: "Chinese", jdEpoch: 17214255e-1, hasYearZero: false, minMonth: 0, firstMonth: 0, minDay: 1, regionalOptions: { "": { name: "Chinese", epochs: ["BEC", "EC"], monthNumbers: function(e3, t3) {\n              if (typeof e3 == "string") {\n                var r4 = e3.match(Ctr);\n                return r4 ? r4[0] : "";\n              }\n              var n4 = this._validateYear(e3), i3 = e3.month(), a4 = "" + this.toChineseMonth(n4, i3);\n              return t3 && a4.length < 2 && (a4 = "0" + a4), this.isIntercalaryMonth(n4, i3) && (a4 += "i"), a4;\n            }, monthNames: function(e3) {\n              if (typeof e3 == "string") {\n                var t3 = e3.match(Ltr);\n                return t3 ? t3[0] : "";\n              }\n              var r4 = this._validateYear(e3), n4 = e3.month(), i3 = this.toChineseMonth(r4, n4), a4 = ["\\u4E00\\u6708", "\\u4E8C\\u6708", "\\u4E09\\u6708", "\\u56DB\\u6708", "\\u4E94\\u6708", "\\u516D\\u6708", "\\u4E03\\u6708", "\\u516B\\u6708", "\\u4E5D\\u6708", "\\u5341\\u6708", "\\u5341\\u4E00\\u6708", "\\u5341\\u4E8C\\u6708"][i3 - 1];\n              return this.isIntercalaryMonth(r4, n4) && (a4 = "\\u95F0" + a4), a4;\n            }, monthNamesShort: function(e3) {\n              if (typeof e3 == "string") {\n                var t3 = e3.match(Ptr);\n                return t3 ? t3[0] : "";\n              }\n              var r4 = this._validateYear(e3), n4 = e3.month(), i3 = this.toChineseMonth(r4, n4), a4 = ["\\u4E00", "\\u4E8C", "\\u4E09", "\\u56DB", "\\u4E94", "\\u516D", "\\u4E03", "\\u516B", "\\u4E5D", "\\u5341", "\\u5341\\u4E00", "\\u5341\\u4E8C"][i3 - 1];\n              return this.isIntercalaryMonth(r4, n4) && (a4 = "\\u95F0" + a4), a4;\n            }, parseMonth: function(e3, t3) {\n              e3 = this._validateYear(e3);\n              var r4 = parseInt(t3), n4;\n              if (isNaN(r4)) t3[0] === "\\u95F0" && (n4 = true, t3 = t3.substring(1)), t3[t3.length - 1] === "\\u6708" && (t3 = t3.substring(0, t3.length - 1)), r4 = 1 + ["\\u4E00", "\\u4E8C", "\\u4E09", "\\u56DB", "\\u4E94", "\\u516D", "\\u4E03", "\\u516B", "\\u4E5D", "\\u5341", "\\u5341\\u4E00", "\\u5341\\u4E8C"].indexOf(t3);\n              else {\n                var i3 = t3[t3.length - 1];\n                n4 = i3 === "i" || i3 === "I";\n              }\n              var a4 = this.toMonthIndex(e3, r4, n4);\n              return a4;\n            }, dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 1, isRTL: false } }, _validateYear: function(e3, t3) {\n              if (e3.year && (e3 = e3.year()), typeof e3 != "number" || e3 < 1888 || e3 > 2111) throw t3.replace(/\\{0\\}/, this.local.name);\n              return e3;\n            }, toMonthIndex: function(e3, t3, r4) {\n              var n4 = this.intercalaryMonth(e3), i3 = r4 && t3 !== n4;\n              if (i3 || t3 < 1 || t3 > 12) throw Fx.local.invalidMonth.replace(/\\{0\\}/, this.local.name);\n              var a4;\n              return n4 ? !r4 && t3 <= n4 ? a4 = t3 - 1 : a4 = t3 : a4 = t3 - 1, a4;\n            }, toChineseMonth: function(e3, t3) {\n              e3.year && (e3 = e3.year(), t3 = e3.month());\n              var r4 = this.intercalaryMonth(e3), n4 = r4 ? 12 : 11;\n              if (t3 < 0 || t3 > n4) throw Fx.local.invalidMonth.replace(/\\{0\\}/, this.local.name);\n              var i3;\n              return r4 ? t3 < r4 ? i3 = t3 + 1 : i3 = t3 : i3 = t3 + 1, i3;\n            }, intercalaryMonth: function(e3) {\n              e3 = this._validateYear(e3);\n              var t3 = zx[e3 - zx[0]], r4 = t3 >> 13;\n              return r4;\n            }, isIntercalaryMonth: function(e3, t3) {\n              e3.year && (e3 = e3.year(), t3 = e3.month());\n              var r4 = this.intercalaryMonth(e3);\n              return !!r4 && r4 === t3;\n            }, leapYear: function(e3) {\n              return this.intercalaryMonth(e3) !== 0;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this._validateYear(e3, Fx.local.invalidyear), i3 = Ox[n4 - Ox[0]], a4 = i3 >> 9 & 4095, o4 = i3 >> 5 & 15, s3 = i3 & 31, l3;\n              l3 = hQ.newDate(a4, o4, s3), l3.add(4 - (l3.dayOfWeek() || 7), "d");\n              var u4 = this.toJD(e3, t3, r4) - l3.toJD();\n              return 1 + Math.floor(u4 / 7);\n            }, monthsInYear: function(e3) {\n              return this.leapYear(e3) ? 13 : 12;\n            }, daysInMonth: function(e3, t3) {\n              e3.year && (t3 = e3.month(), e3 = e3.year()), e3 = this._validateYear(e3);\n              var r4 = zx[e3 - zx[0]], n4 = r4 >> 13, i3 = n4 ? 12 : 11;\n              if (t3 > i3) throw Fx.local.invalidMonth.replace(/\\{0\\}/, this.local.name);\n              var a4 = r4 & 1 << 12 - t3 ? 30 : 29;\n              return a4;\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, a4, r4, Fx.local.invalidDate);\n              e3 = this._validateYear(n4.year()), t3 = n4.month(), r4 = n4.day();\n              var i3 = this.isIntercalaryMonth(e3, t3), a4 = this.toChineseMonth(e3, t3), o4 = Rtr(e3, a4, r4, i3);\n              return hQ.toJD(o4.year, o4.month, o4.day);\n            }, fromJD: function(e3) {\n              var t3 = hQ.fromJD(e3), r4 = Itr(t3.year(), t3.month(), t3.day()), n4 = this.toMonthIndex(r4.year, r4.month, r4.isIntercalary);\n              return this.newDate(r4.year, n4, r4.day);\n            }, fromString: function(e3) {\n              var t3 = e3.match(ktr), r4 = this._validateYear(+t3[1]), n4 = +t3[2], i3 = !!t3[3], a4 = this.toMonthIndex(r4, n4, i3), o4 = +t3[4];\n              return this.newDate(r4, a4, o4);\n            }, add: function(e3, t3, r4) {\n              var n4 = e3.year(), i3 = e3.month(), a4 = this.isIntercalaryMonth(n4, i3), o4 = this.toChineseMonth(n4, i3), s3 = Object.getPrototypeOf(P9.prototype).add.call(this, e3, t3, r4);\n              if (r4 === "y") {\n                var l3 = s3.year(), u4 = s3.month(), c5 = this.isIntercalaryMonth(l3, o4), f4 = a4 && c5 ? this.toMonthIndex(l3, o4, true) : this.toMonthIndex(l3, o4, false);\n                f4 !== u4 && s3.month(f4);\n              }\n              return s3;\n            } });\n            var ktr = /^\\s*(-?\\d\\d\\d\\d|\\d\\d)[-/](\\d?\\d)([iI]?)[-/](\\d?\\d)/m, Ctr = /^\\d?\\d[iI]?/m, Ltr = /^\u95F0?\u5341?[\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D]?\u6708/m, Ptr = /^\u95F0?\u5341?[\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D]?/m;\n            Fx.calendars.chinese = P9;\n            var zx = [1887, 5780, 5802, 19157, 2742, 50359, 1198, 2646, 46378, 7466, 3412, 30122, 5482, 67949, 2396, 5294, 43597, 6732, 6954, 36181, 2772, 4954, 18781, 2396, 54427, 5274, 6730, 47781, 5800, 6868, 21210, 4790, 59703, 2350, 5270, 46667, 3402, 3496, 38325, 1388, 4782, 18735, 2350, 52374, 6804, 7498, 44457, 2906, 1388, 29294, 4700, 63789, 6442, 6804, 56138, 5802, 2772, 38235, 1210, 4698, 22827, 5418, 63125, 3476, 5802, 43701, 2484, 5302, 27223, 2646, 70954, 7466, 3412, 54698, 5482, 2412, 38062, 5294, 2636, 32038, 6954, 60245, 2772, 4826, 43357, 2394, 5274, 39501, 6730, 72357, 5800, 5844, 53978, 4790, 2358, 38039, 5270, 87627, 3402, 3496, 54708, 5484, 4782, 43311, 2350, 3222, 27978, 7498, 68965, 2904, 5484, 45677, 4700, 6444, 39573, 6804, 6986, 19285, 2772, 62811, 1210, 4698, 47403, 5418, 5780, 38570, 5546, 76469, 2420, 5302, 51799, 2646, 5414, 36501, 3412, 5546, 18869, 2412, 54446, 5276, 6732, 48422, 6822, 2900, 28010, 4826, 92509, 2394, 5274, 55883, 6730, 6820, 47956, 5812, 2778, 18779, 2358, 62615, 5270, 5450, 46757, 3492, 5556, 27318, 4718, 67887, 2350, 3222, 52554, 7498, 3428, 38252, 5468, 4700, 31022, 6444, 64149, 6804, 6986, 43861, 2772, 5338, 35421, 2650, 70955, 5418, 5780, 54954, 5546, 2740, 38074, 5302, 2646, 29991, 3366, 61011, 3412, 5546, 43445, 2412, 5294, 35406, 6732, 72998, 6820, 6996, 52586, 2778, 2396, 38045, 5274, 6698, 23333, 6820, 64338, 5812, 2746, 43355, 2358, 5270, 39499, 5450, 79525, 3492, 5548], Ox = [1887, 966732, 967231, 967733, 968265, 968766, 969297, 969798, 970298, 970829, 971330, 971830, 972362, 972863, 973395, 973896, 974397, 974928, 975428, 975929, 976461, 976962, 977462, 977994, 978494, 979026, 979526, 980026, 980558, 981059, 981559, 982091, 982593, 983124, 983624, 984124, 984656, 985157, 985656, 986189, 986690, 987191, 987722, 988222, 988753, 989254, 989754, 990286, 990788, 991288, 991819, 992319, 992851, 993352, 993851, 994383, 994885, 995385, 995917, 996418, 996918, 997450, 997949, 998481, 998982, 999483, 1000014, 1000515, 1001016, 1001548, 1002047, 1002578, 1003080, 1003580, 1004111, 1004613, 1005113, 1005645, 1006146, 1006645, 1007177, 1007678, 1008209, 1008710, 1009211, 1009743, 1010243, 1010743, 1011275, 1011775, 1012306, 1012807, 1013308, 1013840, 1014341, 1014841, 1015373, 1015874, 1016404, 1016905, 1017405, 1017937, 1018438, 1018939, 1019471, 1019972, 1020471, 1021002, 1021503, 1022035, 1022535, 1023036, 1023568, 1024069, 1024568, 1025100, 1025601, 1026102, 1026633, 1027133, 1027666, 1028167, 1028666, 1029198, 1029699, 1030199, 1030730, 1031231, 1031763, 1032264, 1032764, 1033296, 1033797, 1034297, 1034828, 1035329, 1035830, 1036362, 1036861, 1037393, 1037894, 1038394, 1038925, 1039427, 1039927, 1040459, 1040959, 1041491, 1041992, 1042492, 1043023, 1043524, 1044024, 1044556, 1045057, 1045558, 1046090, 1046590, 1047121, 1047622, 1048122, 1048654, 1049154, 1049655, 1050187, 1050689, 1051219, 1051720, 1052220, 1052751, 1053252, 1053752, 1054284, 1054786, 1055285, 1055817, 1056317, 1056849, 1057349, 1057850, 1058382, 1058883, 1059383, 1059915, 1060415, 1060947, 1061447, 1061947, 1062479, 1062981, 1063480, 1064012, 1064514, 1065014, 1065545, 1066045, 1066577, 1067078, 1067578, 1068110, 1068611, 1069112, 1069642, 1070142, 1070674, 1071175, 1071675, 1072207, 1072709, 1073209, 1073740, 1074241, 1074741, 1075273, 1075773, 1076305, 1076807, 1077308, 1077839, 1078340, 1078840, 1079372, 1079871, 1080403, 1080904];\n            function Itr(e3, t3, r4, n4) {\n              var i3, a4;\n              if (typeof e3 == "object") i3 = e3, a4 = t3 || {};\n              else {\n                var o4 = typeof e3 == "number" && e3 >= 1888 && e3 <= 2111;\n                if (!o4) throw new Error("Solar year outside range 1888-2111");\n                var s3 = typeof t3 == "number" && t3 >= 1 && t3 <= 12;\n                if (!s3) throw new Error("Solar month outside range 1 - 12");\n                var l3 = typeof r4 == "number" && r4 >= 1 && r4 <= 31;\n                if (!l3) throw new Error("Solar day outside range 1 - 31");\n                i3 = { year: e3, month: t3, day: r4 }, a4 = n4 || {};\n              }\n              var u4 = Ox[i3.year - Ox[0]], c5 = i3.year << 9 | i3.month << 5 | i3.day;\n              a4.year = c5 >= u4 ? i3.year : i3.year - 1, u4 = Ox[a4.year - Ox[0]];\n              var f4 = u4 >> 9 & 4095, h3 = u4 >> 5 & 15, d3 = u4 & 31, v3, _2 = new Date(f4, h3 - 1, d3), b = new Date(i3.year, i3.month - 1, i3.day);\n              v3 = Math.round((b - _2) / (24 * 3600 * 1e3));\n              var p3 = zx[a4.year - zx[0]], k4;\n              for (k4 = 0; k4 < 13; k4++) {\n                var E3 = p3 & 1 << 12 - k4 ? 30 : 29;\n                if (v3 < E3) break;\n                v3 -= E3;\n              }\n              var S2 = p3 >> 13;\n              return !S2 || k4 < S2 ? (a4.isIntercalary = false, a4.month = 1 + k4) : k4 === S2 ? (a4.isIntercalary = true, a4.month = k4) : (a4.isIntercalary = false, a4.month = k4), a4.day = 1 + v3, a4;\n            }\n            function Rtr(e3, t3, r4, n4, i3) {\n              var a4, o4;\n              if (typeof e3 == "object") o4 = e3, a4 = t3 || {};\n              else {\n                var s3 = typeof e3 == "number" && e3 >= 1888 && e3 <= 2111;\n                if (!s3) throw new Error("Lunar year outside range 1888-2111");\n                var l3 = typeof t3 == "number" && t3 >= 1 && t3 <= 12;\n                if (!l3) throw new Error("Lunar month outside range 1 - 12");\n                var u4 = typeof r4 == "number" && r4 >= 1 && r4 <= 30;\n                if (!u4) throw new Error("Lunar day outside range 1 - 30");\n                var c5;\n                typeof n4 == "object" ? (c5 = false, a4 = n4) : (c5 = !!n4, a4 = i3 || {}), o4 = { year: e3, month: t3, day: r4, isIntercalary: c5 };\n              }\n              var f4;\n              f4 = o4.day - 1;\n              var h3 = zx[o4.year - zx[0]], d3 = h3 >> 13, v3;\n              d3 && (o4.month > d3 || o4.isIntercalary) ? v3 = o4.month : v3 = o4.month - 1;\n              for (var _2 = 0; _2 < v3; _2++) {\n                var b = h3 & 1 << 12 - _2 ? 30 : 29;\n                f4 += b;\n              }\n              var p3 = Ox[o4.year - Ox[0]], k4 = p3 >> 9 & 4095, E3 = p3 >> 5 & 15, S2 = p3 & 31, L3 = new Date(k4, E3 - 1, S2 + f4);\n              return a4.year = L3.getFullYear(), a4.month = 1 + L3.getMonth(), a4.day = L3.getDate(), a4;\n            }\n          });\n          var YQe = ye(() => {\n            var bw = kv(), Dtr = Oh();\n            function dQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            dQ.prototype = new bw.baseCalendar();\n            Dtr(dQ.prototype, { name: "Coptic", jdEpoch: 18250295e-1, daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Coptic", epochs: ["BAM", "AM"], monthNames: ["Thout", "Paopi", "Hathor", "Koiak", "Tobi", "Meshir", "Paremhat", "Paremoude", "Pashons", "Paoni", "Epip", "Mesori", "Pi Kogi Enavot"], monthNamesShort: ["Tho", "Pao", "Hath", "Koi", "Tob", "Mesh", "Pat", "Pad", "Pash", "Pao", "Epi", "Meso", "PiK"], dayNames: ["Tkyriaka", "Pesnau", "Pshoment", "Peftoou", "Ptiou", "Psoou", "Psabbaton"], dayNamesShort: ["Tky", "Pes", "Psh", "Pef", "Pti", "Pso", "Psa"], dayNamesMin: ["Tk", "Pes", "Psh", "Pef", "Pt", "Pso", "Psa"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, bw.local.invalidYear), r4 = t3.year() + (t3.year() < 0 ? 1 : 0);\n              return r4 % 4 === 3 || r4 % 4 === -1;\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, bw.local.invalidYear || bw.regionalOptions[""].invalidYear), 13;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, bw.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 13 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, bw.local.invalidDate);\n              return e3 = n4.year(), e3 < 0 && e3++, n4.day() + (n4.month() - 1) * 30 + (e3 - 1) * 365 + Math.floor(e3 / 4) + this.jdEpoch - 1;\n            }, fromJD: function(e3) {\n              var t3 = Math.floor(e3) + 0.5 - this.jdEpoch, r4 = Math.floor((t3 - Math.floor((t3 + 366) / 1461)) / 365) + 1;\n              r4 <= 0 && r4--, t3 = Math.floor(e3) + 0.5 - this.newDate(r4, 1, 1).toJD();\n              var n4 = Math.floor(t3 / 30) + 1, i3 = t3 - (n4 - 1) * 30 + 1;\n              return this.newDate(r4, n4, i3);\n            } });\n            bw.calendars.coptic = dQ;\n          });\n          var KQe = ye(() => {\n            var x1 = kv(), Ftr = Oh();\n            function vQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            vQ.prototype = new x1.baseCalendar();\n            Ftr(vQ.prototype, { name: "Discworld", jdEpoch: 17214255e-1, daysPerMonth: [16, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Discworld", epochs: ["BUC", "UC"], monthNames: ["Ick", "Offle", "February", "March", "April", "May", "June", "Grune", "August", "Spune", "Sektober", "Ember", "December"], monthNamesShort: ["Ick", "Off", "Feb", "Mar", "Apr", "May", "Jun", "Gru", "Aug", "Spu", "Sek", "Emb", "Dec"], dayNames: ["Sunday", "Octeday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Oct", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Oc", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 2, isRTL: false } }, leapYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, x1.local.invalidYear), false;\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, x1.local.invalidYear), 13;\n            }, daysInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, x1.local.invalidYear), 400;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 8) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, x1.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1];\n            }, daysInWeek: function() {\n              return 8;\n            }, dayOfWeek: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, x1.local.invalidDate);\n              return (n4.day() + 1) % 8;\n            }, weekDay: function(e3, t3, r4) {\n              var n4 = this.dayOfWeek(e3, t3, r4);\n              return n4 >= 2 && n4 <= 6;\n            }, extraInfo: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, x1.local.invalidDate);\n              return { century: ztr[Math.floor((n4.year() - 1) / 100) + 1] || "" };\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, x1.local.invalidDate);\n              return e3 = n4.year() + (n4.year() < 0 ? 1 : 0), t3 = n4.month(), r4 = n4.day(), r4 + (t3 > 1 ? 16 : 0) + (t3 > 2 ? (t3 - 2) * 32 : 0) + (e3 - 1) * 400 + this.jdEpoch - 1;\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3 + 0.5) - Math.floor(this.jdEpoch) - 1;\n              var t3 = Math.floor(e3 / 400) + 1;\n              e3 -= (t3 - 1) * 400, e3 += e3 > 15 ? 16 : 0;\n              var r4 = Math.floor(e3 / 32) + 1, n4 = e3 - (r4 - 1) * 32 + 1;\n              return this.newDate(t3 <= 0 ? t3 - 1 : t3, r4, n4);\n            } });\n            var ztr = { 20: "Fruitbat", 21: "Anchovy" };\n            x1.calendars.discworld = vQ;\n          });\n          var JQe = ye(() => {\n            var ww = kv(), Otr = Oh();\n            function pQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            pQ.prototype = new ww.baseCalendar();\n            Otr(pQ.prototype, { name: "Ethiopian", jdEpoch: 17242205e-1, daysPerMonth: [30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 5], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Ethiopian", epochs: ["BEE", "EE"], monthNames: ["Meskerem", "Tikemet", "Hidar", "Tahesas", "Tir", "Yekatit", "Megabit", "Miazia", "Genbot", "Sene", "Hamle", "Nehase", "Pagume"], monthNamesShort: ["Mes", "Tik", "Hid", "Tah", "Tir", "Yek", "Meg", "Mia", "Gen", "Sen", "Ham", "Neh", "Pag"], dayNames: ["Ehud", "Segno", "Maksegno", "Irob", "Hamus", "Arb", "Kidame"], dayNamesShort: ["Ehu", "Seg", "Mak", "Iro", "Ham", "Arb", "Kid"], dayNamesMin: ["Eh", "Se", "Ma", "Ir", "Ha", "Ar", "Ki"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, ww.local.invalidYear), r4 = t3.year() + (t3.year() < 0 ? 1 : 0);\n              return r4 % 4 === 3 || r4 % 4 === -1;\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, ww.local.invalidYear || ww.regionalOptions[""].invalidYear), 13;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, ww.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 13 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, ww.local.invalidDate);\n              return e3 = n4.year(), e3 < 0 && e3++, n4.day() + (n4.month() - 1) * 30 + (e3 - 1) * 365 + Math.floor(e3 / 4) + this.jdEpoch - 1;\n            }, fromJD: function(e3) {\n              var t3 = Math.floor(e3) + 0.5 - this.jdEpoch, r4 = Math.floor((t3 - Math.floor((t3 + 366) / 1461)) / 365) + 1;\n              r4 <= 0 && r4--, t3 = Math.floor(e3) + 0.5 - this.newDate(r4, 1, 1).toJD();\n              var n4 = Math.floor(t3 / 30) + 1, i3 = t3 - (n4 - 1) * 30 + 1;\n              return this.newDate(r4, n4, i3);\n            } });\n            ww.calendars.ethiopian = pQ;\n          });\n          var $Qe = ye(() => {\n            var qx = kv(), qtr = Oh();\n            function gQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            gQ.prototype = new qx.baseCalendar();\n            qtr(gQ.prototype, { name: "Hebrew", jdEpoch: 347995.5, daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 29], hasYearZero: false, minMonth: 1, firstMonth: 7, minDay: 1, regionalOptions: { "": { name: "Hebrew", epochs: ["BAM", "AM"], monthNames: ["Nisan", "Iyar", "Sivan", "Tammuz", "Av", "Elul", "Tishrei", "Cheshvan", "Kislev", "Tevet", "Shevat", "Adar", "Adar II"], monthNamesShort: ["Nis", "Iya", "Siv", "Tam", "Av", "Elu", "Tis", "Che", "Kis", "Tev", "She", "Ada", "Ad2"], dayNames: ["Yom Rishon", "Yom Sheni", "Yom Shlishi", "Yom Revi\'i", "Yom Chamishi", "Yom Shishi", "Yom Shabbat"], dayNamesShort: ["Ris", "She", "Shl", "Rev", "Cha", "Shi", "Sha"], dayNamesMin: ["Ri", "She", "Shl", "Re", "Ch", "Shi", "Sha"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, qx.local.invalidYear);\n              return this._leapYear(t3.year());\n            }, _leapYear: function(e3) {\n              return e3 = e3 < 0 ? e3 + 1 : e3, I9(e3 * 7 + 1, 19) < 7;\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, qx.local.invalidYear), this._leapYear(e3.year ? e3.year() : e3) ? 13 : 12;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, qx.local.invalidYear);\n              return e3 = t3.year(), this.toJD(e3 === -1 ? 1 : e3 + 1, 7, 1) - this.toJD(e3, 7, 1);\n            }, daysInMonth: function(e3, t3) {\n              return e3.year && (t3 = e3.month(), e3 = e3.year()), this._validate(e3, t3, this.minDay, qx.local.invalidMonth), t3 === 12 && this.leapYear(e3) || t3 === 8 && I9(this.daysInYear(e3), 10) === 5 ? 30 : t3 === 9 && I9(this.daysInYear(e3), 10) === 3 ? 29 : this.daysPerMonth[t3 - 1];\n            }, weekDay: function(e3, t3, r4) {\n              return this.dayOfWeek(e3, t3, r4) !== 6;\n            }, extraInfo: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, qx.local.invalidDate);\n              return { yearType: (this.leapYear(n4) ? "embolismic" : "common") + " " + ["deficient", "regular", "complete"][this.daysInYear(n4) % 10 - 3] };\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, qx.local.invalidDate);\n              e3 = n4.year(), t3 = n4.month(), r4 = n4.day();\n              var i3 = e3 <= 0 ? e3 + 1 : e3, a4 = this.jdEpoch + this._delay1(i3) + this._delay2(i3) + r4 + 1;\n              if (t3 < 7) {\n                for (var o4 = 7; o4 <= this.monthsInYear(e3); o4++) a4 += this.daysInMonth(e3, o4);\n                for (var o4 = 1; o4 < t3; o4++) a4 += this.daysInMonth(e3, o4);\n              } else for (var o4 = 7; o4 < t3; o4++) a4 += this.daysInMonth(e3, o4);\n              return a4;\n            }, _delay1: function(e3) {\n              var t3 = Math.floor((235 * e3 - 234) / 19), r4 = 12084 + 13753 * t3, n4 = t3 * 29 + Math.floor(r4 / 25920);\n              return I9(3 * (n4 + 1), 7) < 3 && n4++, n4;\n            }, _delay2: function(e3) {\n              var t3 = this._delay1(e3 - 1), r4 = this._delay1(e3), n4 = this._delay1(e3 + 1);\n              return n4 - r4 === 356 ? 2 : r4 - t3 === 382 ? 1 : 0;\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3) + 0.5;\n              for (var t3 = Math.floor((e3 - this.jdEpoch) * 98496 / 35975351) - 1; e3 >= this.toJD(t3 === -1 ? 1 : t3 + 1, 7, 1); ) t3++;\n              for (var r4 = e3 < this.toJD(t3, 1, 1) ? 7 : 1; e3 > this.toJD(t3, r4, this.daysInMonth(t3, r4)); ) r4++;\n              var n4 = e3 - this.toJD(t3, r4, 1) + 1;\n              return this.newDate(t3, r4, n4);\n            } });\n            function I9(e3, t3) {\n              return e3 - t3 * Math.floor(e3 / t3);\n            }\n            qx.calendars.hebrew = gQ;\n          });\n          var QQe = ye(() => {\n            var dC = kv(), Btr = Oh();\n            function mQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            mQ.prototype = new dC.baseCalendar();\n            Btr(mQ.prototype, { name: "Islamic", jdEpoch: 19484395e-1, daysPerMonth: [30, 29, 30, 29, 30, 29, 30, 29, 30, 29, 30, 29], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Islamic", epochs: ["BH", "AH"], monthNames: ["Muharram", "Safar", "Rabi\' al-awwal", "Rabi\' al-thani", "Jumada al-awwal", "Jumada al-thani", "Rajab", "Sha\'aban", "Ramadan", "Shawwal", "Dhu al-Qi\'dah", "Dhu al-Hijjah"], monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha\'", "Ram", "Shaw", "DhuQ", "DhuH"], dayNames: ["Yawm al-ahad", "Yawm al-ithnayn", "Yawm ath-thulaathaa\'", "Yawm al-arbi\'aa\'", "Yawm al-kham\\u012Bs", "Yawm al-jum\'a", "Yawm as-sabt"], dayNamesShort: ["Aha", "Ith", "Thu", "Arb", "Kha", "Jum", "Sab"], dayNamesMin: ["Ah", "It", "Th", "Ar", "Kh", "Ju", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: false } }, leapYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, dC.local.invalidYear);\n              return (t3.year() * 11 + 14) % 30 < 11;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInYear: function(e3) {\n              return this.leapYear(e3) ? 355 : 354;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, dC.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 12 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return this.dayOfWeek(e3, t3, r4) !== 5;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, dC.local.invalidDate);\n              return e3 = n4.year(), t3 = n4.month(), r4 = n4.day(), e3 = e3 <= 0 ? e3 + 1 : e3, r4 + Math.ceil(29.5 * (t3 - 1)) + (e3 - 1) * 354 + Math.floor((3 + 11 * e3) / 30) + this.jdEpoch - 1;\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3) + 0.5;\n              var t3 = Math.floor((30 * (e3 - this.jdEpoch) + 10646) / 10631);\n              t3 = t3 <= 0 ? t3 - 1 : t3;\n              var r4 = Math.min(12, Math.ceil((e3 - 29 - this.toJD(t3, 1, 1)) / 29.5) + 1), n4 = e3 - this.toJD(t3, r4, 1) + 1;\n              return this.newDate(t3, r4, n4);\n            } });\n            dC.calendars.islamic = mQ;\n          });\n          var eet = ye(() => {\n            var vC = kv(), Ntr = Oh();\n            function yQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            yQ.prototype = new vC.baseCalendar();\n            Ntr(yQ.prototype, { name: "Julian", jdEpoch: 17214235e-1, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Julian", epochs: ["BC", "AD"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "mm/dd/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, vC.local.invalidYear), r4 = t3.year() < 0 ? t3.year() + 1 : t3.year();\n              return r4 % 4 === 0;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(4 - (n4.dayOfWeek() || 7), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, vC.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 2 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, vC.local.invalidDate);\n              return e3 = n4.year(), t3 = n4.month(), r4 = n4.day(), e3 < 0 && e3++, t3 <= 2 && (e3--, t3 += 12), Math.floor(365.25 * (e3 + 4716)) + Math.floor(30.6001 * (t3 + 1)) + r4 - 1524.5;\n            }, fromJD: function(e3) {\n              var t3 = Math.floor(e3 + 0.5), r4 = t3 + 1524, n4 = Math.floor((r4 - 122.1) / 365.25), i3 = Math.floor(365.25 * n4), a4 = Math.floor((r4 - i3) / 30.6001), o4 = a4 - Math.floor(a4 < 14 ? 1 : 13), s3 = n4 - Math.floor(o4 > 2 ? 4716 : 4715), l3 = r4 - i3 - Math.floor(30.6001 * a4);\n              return s3 <= 0 && s3--, this.newDate(s3, o4, l3);\n            } });\n            vC.calendars.julian = yQ;\n          });\n          var ret = ye(() => {\n            var ug = kv(), Utr = Oh();\n            function xQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            xQ.prototype = new ug.baseCalendar();\n            Utr(xQ.prototype, { name: "Mayan", jdEpoch: 584282.5, hasYearZero: true, minMonth: 0, firstMonth: 0, minDay: 0, regionalOptions: { "": { name: "Mayan", epochs: ["", ""], monthNames: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"], monthNamesShort: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"], dayNames: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], dayNamesShort: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], dayNamesMin: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"], digits: null, dateFormat: "YYYY.m.d", firstDay: 0, isRTL: false, haabMonths: ["Pop", "Uo", "Zip", "Zotz", "Tzec", "Xul", "Yaxkin", "Mol", "Chen", "Yax", "Zac", "Ceh", "Mac", "Kankin", "Muan", "Pax", "Kayab", "Cumku", "Uayeb"], tzolkinMonths: ["Imix", "Ik", "Akbal", "Kan", "Chicchan", "Cimi", "Manik", "Lamat", "Muluc", "Oc", "Chuen", "Eb", "Ben", "Ix", "Men", "Cib", "Caban", "Etznab", "Cauac", "Ahau"] } }, leapYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, ug.local.invalidYear), false;\n            }, formatYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, ug.local.invalidYear);\n              e3 = t3.year();\n              var r4 = Math.floor(e3 / 400);\n              e3 = e3 % 400, e3 += e3 < 0 ? 400 : 0;\n              var n4 = Math.floor(e3 / 20);\n              return r4 + "." + n4 + "." + e3 % 20;\n            }, forYear: function(e3) {\n              if (e3 = e3.split("."), e3.length < 3) throw "Invalid Mayan year";\n              for (var t3 = 0, r4 = 0; r4 < e3.length; r4++) {\n                var n4 = parseInt(e3[r4], 10);\n                if (Math.abs(n4) > 19 || r4 > 0 && n4 < 0) throw "Invalid Mayan year";\n                t3 = t3 * 20 + n4;\n              }\n              return t3;\n            }, monthsInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, ug.local.invalidYear), 18;\n            }, weekOfYear: function(e3, t3, r4) {\n              return this._validate(e3, t3, r4, ug.local.invalidDate), 0;\n            }, daysInYear: function(e3) {\n              return this._validate(e3, this.minMonth, this.minDay, ug.local.invalidYear), 360;\n            }, daysInMonth: function(e3, t3) {\n              return this._validate(e3, t3, this.minDay, ug.local.invalidMonth), 20;\n            }, daysInWeek: function() {\n              return 5;\n            }, dayOfWeek: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, ug.local.invalidDate);\n              return n4.day();\n            }, weekDay: function(e3, t3, r4) {\n              return this._validate(e3, t3, r4, ug.local.invalidDate), true;\n            }, extraInfo: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, ug.local.invalidDate), i3 = n4.toJD(), a4 = this._toHaab(i3), o4 = this._toTzolkin(i3);\n              return { haabMonthName: this.local.haabMonths[a4[0] - 1], haabMonth: a4[0], haabDay: a4[1], tzolkinDayName: this.local.tzolkinMonths[o4[0] - 1], tzolkinDay: o4[0], tzolkinTrecena: o4[1] };\n            }, _toHaab: function(e3) {\n              e3 -= this.jdEpoch;\n              var t3 = _Q(e3 + 8 + 17 * 20, 365);\n              return [Math.floor(t3 / 20) + 1, _Q(t3, 20)];\n            }, _toTzolkin: function(e3) {\n              return e3 -= this.jdEpoch, [tet(e3 + 20, 20), tet(e3 + 4, 13)];\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, ug.local.invalidDate);\n              return n4.day() + n4.month() * 20 + n4.year() * 360 + this.jdEpoch;\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3) + 0.5 - this.jdEpoch;\n              var t3 = Math.floor(e3 / 360);\n              e3 = e3 % 360, e3 += e3 < 0 ? 360 : 0;\n              var r4 = Math.floor(e3 / 20), n4 = e3 % 20;\n              return this.newDate(t3, r4, n4);\n            } });\n            function _Q(e3, t3) {\n              return e3 - t3 * Math.floor(e3 / t3);\n            }\n            function tet(e3, t3) {\n              return _Q(e3 - 1, t3) + 1;\n            }\n            ug.calendars.mayan = xQ;\n          });\n          var net = ye(() => {\n            var Tw = kv(), Vtr = Oh();\n            function bQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            bQ.prototype = new Tw.baseCalendar();\n            var iet = Tw.instance("gregorian");\n            Vtr(bQ.prototype, { name: "Nanakshahi", jdEpoch: 22576735e-1, daysPerMonth: [31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 30, 30], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Nanakshahi", epochs: ["BN", "AN"], monthNames: ["Chet", "Vaisakh", "Jeth", "Harh", "Sawan", "Bhadon", "Assu", "Katak", "Maghar", "Poh", "Magh", "Phagun"], monthNamesShort: ["Che", "Vai", "Jet", "Har", "Saw", "Bha", "Ass", "Kat", "Mgr", "Poh", "Mgh", "Pha"], dayNames: ["Somvaar", "Mangalvar", "Budhvaar", "Veervaar", "Shukarvaar", "Sanicharvaar", "Etvaar"], dayNamesShort: ["Som", "Mangal", "Budh", "Veer", "Shukar", "Sanichar", "Et"], dayNamesMin: ["So", "Ma", "Bu", "Ve", "Sh", "Sa", "Et"], digits: null, dateFormat: "dd-mm-yyyy", firstDay: 0, isRTL: false } }, leapYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Tw.local.invalidYear || Tw.regionalOptions[""].invalidYear);\n              return iet.leapYear(t3.year() + (t3.year() < 1 ? 1 : 0) + 1469);\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(1 - (n4.dayOfWeek() || 7), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, Tw.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 12 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(i3, t3, r4) {\n              var n4 = this._validate(i3, t3, r4, Tw.local.invalidMonth), i3 = n4.year();\n              i3 < 0 && i3++;\n              for (var a4 = n4.day(), o4 = 1; o4 < n4.month(); o4++) a4 += this.daysPerMonth[o4 - 1];\n              return a4 + iet.toJD(i3 + 1468, 3, 13);\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3 + 0.5);\n              for (var t3 = Math.floor((e3 - (this.jdEpoch - 1)) / 366); e3 >= this.toJD(t3 + 1, 1, 1); ) t3++;\n              for (var r4 = e3 - Math.floor(this.toJD(t3, 1, 1) + 0.5) + 1, n4 = 1; r4 > this.daysInMonth(t3, n4); ) r4 -= this.daysInMonth(t3, n4), n4++;\n              return this.newDate(t3, n4, r4);\n            } });\n            Tw.calendars.nanakshahi = bQ;\n          });\n          var aet = ye(() => {\n            var Aw = kv(), Gtr = Oh();\n            function wQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            wQ.prototype = new Aw.baseCalendar();\n            Gtr(wQ.prototype, { name: "Nepali", jdEpoch: 17007095e-1, daysPerMonth: [31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, daysPerYear: 365, regionalOptions: { "": { name: "Nepali", epochs: ["BBS", "ABS"], monthNames: ["Baisakh", "Jestha", "Ashadh", "Shrawan", "Bhadra", "Ashwin", "Kartik", "Mangsir", "Paush", "Mangh", "Falgun", "Chaitra"], monthNamesShort: ["Bai", "Je", "As", "Shra", "Bha", "Ash", "Kar", "Mang", "Pau", "Ma", "Fal", "Chai"], dayNames: ["Aaitabaar", "Sombaar", "Manglbaar", "Budhabaar", "Bihibaar", "Shukrabaar", "Shanibaar"], dayNamesShort: ["Aaita", "Som", "Mangl", "Budha", "Bihi", "Shukra", "Shani"], dayNamesMin: ["Aai", "So", "Man", "Bu", "Bi", "Shu", "Sha"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 1, isRTL: false } }, leapYear: function(e3) {\n              return this.daysInYear(e3) !== this.daysPerYear;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Aw.local.invalidYear);\n              if (e3 = t3.year(), typeof this.NEPALI_CALENDAR_DATA[e3] == "undefined") return this.daysPerYear;\n              for (var r4 = 0, n4 = this.minMonth; n4 <= 12; n4++) r4 += this.NEPALI_CALENDAR_DATA[e3][n4];\n              return r4;\n            }, daysInMonth: function(e3, t3) {\n              return e3.year && (t3 = e3.month(), e3 = e3.year()), this._validate(e3, t3, this.minDay, Aw.local.invalidMonth), typeof this.NEPALI_CALENDAR_DATA[e3] == "undefined" ? this.daysPerMonth[t3 - 1] : this.NEPALI_CALENDAR_DATA[e3][t3];\n            }, weekDay: function(e3, t3, r4) {\n              return this.dayOfWeek(e3, t3, r4) !== 6;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Aw.local.invalidDate);\n              e3 = n4.year(), t3 = n4.month(), r4 = n4.day();\n              var i3 = Aw.instance(), a4 = 0, o4 = t3, s3 = e3;\n              this._createMissingCalendarData(e3);\n              var l3 = e3 - (o4 > 9 || o4 === 9 && r4 >= this.NEPALI_CALENDAR_DATA[s3][0] ? 56 : 57);\n              for (t3 !== 9 && (a4 = r4, o4--); o4 !== 9; ) o4 <= 0 && (o4 = 12, s3--), a4 += this.NEPALI_CALENDAR_DATA[s3][o4], o4--;\n              return t3 === 9 ? (a4 += r4 - this.NEPALI_CALENDAR_DATA[s3][0], a4 < 0 && (a4 += i3.daysInYear(l3))) : a4 += this.NEPALI_CALENDAR_DATA[s3][9] - this.NEPALI_CALENDAR_DATA[s3][0], i3.newDate(l3, 1, 1).add(a4, "d").toJD();\n            }, fromJD: function(e3) {\n              var t3 = Aw.instance(), r4 = t3.fromJD(e3), n4 = r4.year(), i3 = r4.dayOfYear(), a4 = n4 + 56;\n              this._createMissingCalendarData(a4);\n              for (var o4 = 9, s3 = this.NEPALI_CALENDAR_DATA[a4][0], l3 = this.NEPALI_CALENDAR_DATA[a4][o4] - s3 + 1; i3 > l3; ) o4++, o4 > 12 && (o4 = 1, a4++), l3 += this.NEPALI_CALENDAR_DATA[a4][o4];\n              var u4 = this.NEPALI_CALENDAR_DATA[a4][o4] - (l3 - i3);\n              return this.newDate(a4, o4, u4);\n            }, _createMissingCalendarData: function(e3) {\n              var t3 = this.daysPerMonth.slice(0);\n              t3.unshift(17);\n              for (var r4 = e3 - 1; r4 < e3 + 2; r4++) typeof this.NEPALI_CALENDAR_DATA[r4] == "undefined" && (this.NEPALI_CALENDAR_DATA[r4] = t3);\n            }, NEPALI_CALENDAR_DATA: { 1970: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1971: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 1972: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 1973: [19, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1974: [19, 31, 31, 32, 30, 31, 31, 30, 29, 30, 29, 30, 30], 1975: [18, 31, 31, 32, 32, 30, 31, 30, 29, 30, 29, 30, 30], 1976: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1977: [18, 31, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31], 1978: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1979: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1980: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1981: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 1982: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1983: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1984: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1985: [18, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 1986: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1987: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1988: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 1989: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 1990: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1991: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 1992: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1993: [18, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 1994: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1995: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 1996: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 1997: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1998: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 1999: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2e3: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2001: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2002: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2003: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2004: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2005: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2006: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2007: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2008: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2009: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2010: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2011: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2012: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2013: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2014: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2015: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2016: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2017: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2018: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2019: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2020: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2021: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2022: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2023: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2024: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2025: [18, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2026: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2027: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2028: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2029: [18, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 2030: [17, 31, 32, 31, 32, 31, 30, 30, 30, 30, 30, 30, 31], 2031: [17, 31, 32, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31], 2032: [17, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32], 2033: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2034: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2035: [17, 30, 32, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2036: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2037: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2038: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2039: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2040: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2041: [18, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2042: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2043: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2044: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2045: [18, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2046: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2047: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2048: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2049: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2050: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2051: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2052: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2053: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2054: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2055: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 29, 30], 2056: [17, 31, 31, 32, 31, 32, 30, 30, 29, 30, 29, 30, 30], 2057: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2058: [17, 30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2059: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2060: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2061: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2062: [17, 30, 32, 31, 32, 31, 31, 29, 30, 29, 30, 29, 31], 2063: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2064: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2065: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2066: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 29, 31], 2067: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2068: [17, 31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2069: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2070: [17, 31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30], 2071: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2072: [17, 31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2073: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31], 2074: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2075: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2076: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2077: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31], 2078: [17, 31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30], 2079: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30], 2080: [16, 31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30], 2081: [17, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2082: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2083: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2084: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2085: [17, 31, 32, 31, 32, 31, 31, 30, 30, 29, 30, 30, 30], 2086: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2087: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30], 2088: [16, 30, 31, 32, 32, 30, 31, 30, 30, 29, 30, 30, 30], 2089: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2090: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2091: [16, 31, 31, 32, 31, 31, 31, 30, 30, 29, 30, 30, 30], 2092: [16, 31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2093: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2094: [17, 31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30], 2095: [17, 31, 31, 32, 31, 31, 31, 30, 29, 30, 30, 30, 30], 2096: [17, 30, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30], 2097: [17, 31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30], 2098: [17, 31, 31, 32, 31, 31, 31, 29, 30, 29, 30, 30, 31], 2099: [17, 31, 31, 32, 31, 31, 31, 30, 29, 29, 30, 30, 30], 2100: [17, 31, 32, 31, 32, 30, 31, 30, 29, 30, 29, 30, 30] } });\n            Aw.calendars.nepali = wQ;\n          });\n          var oet = ye(() => {\n            var rS = kv(), Htr = Oh();\n            function D9(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            function R9(e3) {\n              var t3 = e3 - 475;\n              e3 < 0 && t3++;\n              var r4 = 0.242197, n4 = r4 * t3, i3 = r4 * (t3 + 1), a4 = n4 - Math.floor(n4), o4 = i3 - Math.floor(i3);\n              return a4 > o4;\n            }\n            D9.prototype = new rS.baseCalendar();\n            Htr(D9.prototype, { name: "Persian", jdEpoch: 19483205e-1, daysPerMonth: [31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Persian", epochs: ["BP", "AP"], monthNames: ["Farvardin", "Ordibehesht", "Khordad", "Tir", "Mordad", "Shahrivar", "Mehr", "Aban", "Azar", "Dey", "Bahman", "Esfand"], monthNamesShort: ["Far", "Ord", "Kho", "Tir", "Mor", "Sha", "Meh", "Aba", "Aza", "Dey", "Bah", "Esf"], dayNames: ["Yekshanbeh", "Doshanbeh", "Seshanbeh", "Chah\\u0101rshanbeh", "Panjshanbeh", "Jom\'eh", "Shanbeh"], dayNamesShort: ["Yek", "Do", "Se", "Cha", "Panj", "Jom", "Sha"], dayNamesMin: ["Ye", "Do", "Se", "Ch", "Pa", "Jo", "Sh"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: false } }, leapYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, rS.local.invalidYear);\n              return R9(t3.year());\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-((n4.dayOfWeek() + 1) % 7), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, rS.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 12 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return this.dayOfWeek(e3, t3, r4) !== 5;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, rS.local.invalidDate);\n              e3 = n4.year(), t3 = n4.month(), r4 = n4.day();\n              var i3 = 0;\n              if (e3 > 0) for (var a4 = 1; a4 < e3; a4++) R9(a4) && i3++;\n              else if (e3 < 0) for (var a4 = e3; a4 < 0; a4++) R9(a4) && i3--;\n              return r4 + (t3 <= 7 ? (t3 - 1) * 31 : (t3 - 1) * 30 + 6) + (e3 > 0 ? e3 - 1 : e3) * 365 + i3 + this.jdEpoch - 1;\n            }, fromJD: function(e3) {\n              e3 = Math.floor(e3) + 0.5;\n              var t3 = 475 + (e3 - this.toJD(475, 1, 1)) / 365.242197, r4 = Math.floor(t3);\n              r4 <= 0 && r4--, e3 > this.toJD(r4, 12, R9(r4) ? 30 : 29) && (r4++, r4 === 0 && r4++);\n              var n4 = e3 - this.toJD(r4, 1, 1) + 1, i3 = n4 <= 186 ? Math.ceil(n4 / 31) : Math.ceil((n4 - 6) / 30), a4 = e3 - this.toJD(r4, i3, 1) + 1;\n              return this.newDate(r4, i3, a4);\n            } });\n            rS.calendars.persian = D9;\n            rS.calendars.jalali = D9;\n          });\n          var set = ye(() => {\n            var Sw = kv(), jtr = Oh(), F9 = Sw.instance();\n            function TQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            TQ.prototype = new Sw.baseCalendar();\n            jtr(TQ.prototype, { name: "Taiwan", jdEpoch: 24194025e-1, yearsOffset: 1911, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Taiwan", epochs: ["BROC", "ROC"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 1, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, Sw.local.invalidYear), r4 = this._t2gYear(t3.year());\n              return F9.leapYear(r4);\n            }, weekOfYear: function(i3, t3, r4) {\n              var n4 = this._validate(i3, this.minMonth, this.minDay, Sw.local.invalidYear), i3 = this._t2gYear(n4.year());\n              return F9.weekOfYear(i3, n4.month(), n4.day());\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, Sw.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 2 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(i3, t3, r4) {\n              var n4 = this._validate(i3, t3, r4, Sw.local.invalidDate), i3 = this._t2gYear(n4.year());\n              return F9.toJD(i3, n4.month(), n4.day());\n            }, fromJD: function(e3) {\n              var t3 = F9.fromJD(e3), r4 = this._g2tYear(t3.year());\n              return this.newDate(r4, t3.month(), t3.day());\n            }, _t2gYear: function(e3) {\n              return e3 + this.yearsOffset + (e3 >= -this.yearsOffset && e3 <= -1 ? 1 : 0);\n            }, _g2tYear: function(e3) {\n              return e3 - this.yearsOffset - (e3 >= 1 && e3 <= this.yearsOffset ? 1 : 0);\n            } });\n            Sw.calendars.taiwan = TQ;\n          });\n          var uet = ye(() => {\n            var Mw = kv(), Wtr = Oh(), z9 = Mw.instance();\n            function AQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            AQ.prototype = new Mw.baseCalendar();\n            Wtr(AQ.prototype, { name: "Thai", jdEpoch: 15230985e-1, yearsOffset: 543, daysPerMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Thai", epochs: ["BBE", "BE"], monthNames: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], dayNamesMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], digits: null, dateFormat: "dd/mm/yyyy", firstDay: 0, isRTL: false } }, leapYear: function(r4) {\n              var t3 = this._validate(r4, this.minMonth, this.minDay, Mw.local.invalidYear), r4 = this._t2gYear(t3.year());\n              return z9.leapYear(r4);\n            }, weekOfYear: function(i3, t3, r4) {\n              var n4 = this._validate(i3, this.minMonth, this.minDay, Mw.local.invalidYear), i3 = this._t2gYear(n4.year());\n              return z9.weekOfYear(i3, n4.month(), n4.day());\n            }, daysInMonth: function(e3, t3) {\n              var r4 = this._validate(e3, t3, this.minDay, Mw.local.invalidMonth);\n              return this.daysPerMonth[r4.month() - 1] + (r4.month() === 2 && this.leapYear(r4.year()) ? 1 : 0);\n            }, weekDay: function(e3, t3, r4) {\n              return (this.dayOfWeek(e3, t3, r4) || 7) < 6;\n            }, toJD: function(i3, t3, r4) {\n              var n4 = this._validate(i3, t3, r4, Mw.local.invalidDate), i3 = this._t2gYear(n4.year());\n              return z9.toJD(i3, n4.month(), n4.day());\n            }, fromJD: function(e3) {\n              var t3 = z9.fromJD(e3), r4 = this._g2tYear(t3.year());\n              return this.newDate(r4, t3.month(), t3.day());\n            }, _t2gYear: function(e3) {\n              return e3 - this.yearsOffset - (e3 >= 1 && e3 <= this.yearsOffset ? 1 : 0);\n            }, _g2tYear: function(e3) {\n              return e3 + this.yearsOffset + (e3 >= -this.yearsOffset && e3 <= -1 ? 1 : 0);\n            } });\n            Mw.calendars.thai = AQ;\n          });\n          var cet = ye(() => {\n            var Ew = kv(), Xtr = Oh();\n            function SQ(e3) {\n              this.local = this.regionalOptions[e3 || ""] || this.regionalOptions[""];\n            }\n            SQ.prototype = new Ew.baseCalendar();\n            Xtr(SQ.prototype, { name: "UmmAlQura", hasYearZero: false, minMonth: 1, firstMonth: 1, minDay: 1, regionalOptions: { "": { name: "Umm al-Qura", epochs: ["BH", "AH"], monthNames: ["Al-Muharram", "Safar", "Rabi\' al-awwal", "Rabi\' Al-Thani", "Jumada Al-Awwal", "Jumada Al-Thani", "Rajab", "Sha\'aban", "Ramadan", "Shawwal", "Dhu al-Qi\'dah", "Dhu al-Hijjah"], monthNamesShort: ["Muh", "Saf", "Rab1", "Rab2", "Jum1", "Jum2", "Raj", "Sha\'", "Ram", "Shaw", "DhuQ", "DhuH"], dayNames: ["Yawm al-Ahad", "Yawm al-Ithnain", "Yawm al-Thal\\u0101th\\u0101\\u2019", "Yawm al-Arba\\u2018\\u0101\\u2019", "Yawm al-Kham\\u012Bs", "Yawm al-Jum\\u2018a", "Yawm al-Sabt"], dayNamesMin: ["Ah", "Ith", "Th", "Ar", "Kh", "Ju", "Sa"], digits: null, dateFormat: "yyyy/mm/dd", firstDay: 6, isRTL: true } }, leapYear: function(e3) {\n              var t3 = this._validate(e3, this.minMonth, this.minDay, Ew.local.invalidYear);\n              return this.daysInYear(t3.year()) === 355;\n            }, weekOfYear: function(e3, t3, r4) {\n              var n4 = this.newDate(e3, t3, r4);\n              return n4.add(-n4.dayOfWeek(), "d"), Math.floor((n4.dayOfYear() - 1) / 7) + 1;\n            }, daysInYear: function(e3) {\n              for (var t3 = 0, r4 = 1; r4 <= 12; r4++) t3 += this.daysInMonth(e3, r4);\n              return t3;\n            }, daysInMonth: function(e3, t3) {\n              for (var r4 = this._validate(e3, t3, this.minDay, Ew.local.invalidMonth), n4 = r4.toJD() - 24e5 + 0.5, i3 = 0, a4 = 0; a4 < Bx.length; a4++) {\n                if (Bx[a4] > n4) return Bx[i3] - Bx[i3 - 1];\n                i3++;\n              }\n              return 30;\n            }, weekDay: function(e3, t3, r4) {\n              return this.dayOfWeek(e3, t3, r4) !== 5;\n            }, toJD: function(e3, t3, r4) {\n              var n4 = this._validate(e3, t3, r4, Ew.local.invalidDate), i3 = 12 * (n4.year() - 1) + n4.month() - 15292, a4 = n4.day() + Bx[i3 - 1] - 1;\n              return a4 + 24e5 - 0.5;\n            }, fromJD: function(e3) {\n              for (var t3 = e3 - 24e5 + 0.5, r4 = 0, n4 = 0; n4 < Bx.length && !(Bx[n4] > t3); n4++) r4++;\n              var i3 = r4 + 15292, a4 = Math.floor((i3 - 1) / 12), o4 = a4 + 1, s3 = i3 - 12 * a4, l3 = t3 - Bx[r4 - 1] + 1;\n              return this.newDate(o4, s3, l3);\n            }, isValid: function(e3, t3, r4) {\n              var n4 = Ew.baseCalendar.prototype.isValid.apply(this, arguments);\n              return n4 && (e3 = e3.year != null ? e3.year : e3, n4 = e3 >= 1276 && e3 <= 1500), n4;\n            }, _validate: function(e3, t3, r4, n4) {\n              var i3 = Ew.baseCalendar.prototype._validate.apply(this, arguments);\n              if (i3.year < 1276 || i3.year > 1500) throw n4.replace(/\\{0\\}/, this.local.name);\n              return i3;\n            } });\n            Ew.calendars.ummalqura = SQ;\n            var Bx = [20, 50, 79, 109, 138, 168, 197, 227, 256, 286, 315, 345, 374, 404, 433, 463, 492, 522, 551, 581, 611, 641, 670, 700, 729, 759, 788, 818, 847, 877, 906, 936, 965, 995, 1024, 1054, 1083, 1113, 1142, 1172, 1201, 1231, 1260, 1290, 1320, 1350, 1379, 1409, 1438, 1468, 1497, 1527, 1556, 1586, 1615, 1645, 1674, 1704, 1733, 1763, 1792, 1822, 1851, 1881, 1910, 1940, 1969, 1999, 2028, 2058, 2087, 2117, 2146, 2176, 2205, 2235, 2264, 2294, 2323, 2353, 2383, 2413, 2442, 2472, 2501, 2531, 2560, 2590, 2619, 2649, 2678, 2708, 2737, 2767, 2796, 2826, 2855, 2885, 2914, 2944, 2973, 3003, 3032, 3062, 3091, 3121, 3150, 3180, 3209, 3239, 3268, 3298, 3327, 3357, 3386, 3416, 3446, 3476, 3505, 3535, 3564, 3594, 3623, 3653, 3682, 3712, 3741, 3771, 3800, 3830, 3859, 3889, 3918, 3948, 3977, 4007, 4036, 4066, 4095, 4125, 4155, 4185, 4214, 4244, 4273, 4303, 4332, 4362, 4391, 4421, 4450, 4480, 4509, 4539, 4568, 4598, 4627, 4657, 4686, 4716, 4745, 4775, 4804, 4834, 4863, 4893, 4922, 4952, 4981, 5011, 5040, 5070, 5099, 5129, 5158, 5188, 5218, 5248, 5277, 5307, 5336, 5366, 5395, 5425, 5454, 5484, 5513, 5543, 5572, 5602, 5631, 5661, 5690, 5720, 5749, 5779, 5808, 5838, 5867, 5897, 5926, 5956, 5985, 6015, 6044, 6074, 6103, 6133, 6162, 6192, 6221, 6251, 6281, 6311, 6340, 6370, 6399, 6429, 6458, 6488, 6517, 6547, 6576, 6606, 6635, 6665, 6694, 6724, 6753, 6783, 6812, 6842, 6871, 6901, 6930, 6960, 6989, 7019, 7048, 7078, 7107, 7137, 7166, 7196, 7225, 7255, 7284, 7314, 7344, 7374, 7403, 7433, 7462, 7492, 7521, 7551, 7580, 7610, 7639, 7669, 7698, 7728, 7757, 7787, 7816, 7846, 7875, 7905, 7934, 7964, 7993, 8023, 8053, 8083, 8112, 8142, 8171, 8201, 8230, 8260, 8289, 8319, 8348, 8378, 8407, 8437, 8466, 8496, 8525, 8555, 8584, 8614, 8643, 8673, 8702, 8732, 8761, 8791, 8821, 8850, 8880, 8909, 8938, 8968, 8997, 9027, 9056, 9086, 9115, 9145, 9175, 9205, 9234, 9264, 9293, 9322, 9352, 9381, 9410, 9440, 9470, 9499, 9529, 9559, 9589, 9618, 9648, 9677, 9706, 9736, 9765, 9794, 9824, 9853, 9883, 9913, 9943, 9972, 10002, 10032, 10061, 10090, 10120, 10149, 10178, 10208, 10237, 10267, 10297, 10326, 10356, 10386, 10415, 10445, 10474, 10504, 10533, 10562, 10592, 10621, 10651, 10680, 10710, 10740, 10770, 10799, 10829, 10858, 10888, 10917, 10947, 10976, 11005, 11035, 11064, 11094, 11124, 11153, 11183, 11213, 11242, 11272, 11301, 11331, 11360, 11389, 11419, 11448, 11478, 11507, 11537, 11567, 11596, 11626, 11655, 11685, 11715, 11744, 11774, 11803, 11832, 11862, 11891, 11921, 11950, 11980, 12010, 12039, 12069, 12099, 12128, 12158, 12187, 12216, 12246, 12275, 12304, 12334, 12364, 12393, 12423, 12453, 12483, 12512, 12542, 12571, 12600, 12630, 12659, 12688, 12718, 12747, 12777, 12807, 12837, 12866, 12896, 12926, 12955, 12984, 13014, 13043, 13072, 13102, 13131, 13161, 13191, 13220, 13250, 13280, 13310, 13339, 13368, 13398, 13427, 13456, 13486, 13515, 13545, 13574, 13604, 13634, 13664, 13693, 13723, 13752, 13782, 13811, 13840, 13870, 13899, 13929, 13958, 13988, 14018, 14047, 14077, 14107, 14136, 14166, 14195, 14224, 14254, 14283, 14313, 14342, 14372, 14401, 14431, 14461, 14490, 14520, 14550, 14579, 14609, 14638, 14667, 14697, 14726, 14756, 14785, 14815, 14844, 14874, 14904, 14933, 14963, 14993, 15021, 15051, 15081, 15110, 15140, 15169, 15199, 15228, 15258, 15287, 15317, 15347, 15377, 15406, 15436, 15465, 15494, 15524, 15553, 15582, 15612, 15641, 15671, 15701, 15731, 15760, 15790, 15820, 15849, 15878, 15908, 15937, 15966, 15996, 16025, 16055, 16085, 16114, 16144, 16174, 16204, 16233, 16262, 16292, 16321, 16350, 16380, 16409, 16439, 16468, 16498, 16528, 16558, 16587, 16617, 16646, 16676, 16705, 16734, 16764, 16793, 16823, 16852, 16882, 16912, 16941, 16971, 17001, 17030, 17060, 17089, 17118, 17148, 17177, 17207, 17236, 17266, 17295, 17325, 17355, 17384, 17414, 17444, 17473, 17502, 17532, 17561, 17591, 17620, 17650, 17679, 17709, 17738, 17768, 17798, 17827, 17857, 17886, 17916, 17945, 17975, 18004, 18034, 18063, 18093, 18122, 18152, 18181, 18211, 18241, 18270, 18300, 18330, 18359, 18388, 18418, 18447, 18476, 18506, 18535, 18565, 18595, 18625, 18654, 18684, 18714, 18743, 18772, 18802, 18831, 18860, 18890, 18919, 18949, 18979, 19008, 19038, 19068, 19098, 19127, 19156, 19186, 19215, 19244, 19274, 19303, 19333, 19362, 19392, 19422, 19452, 19481, 19511, 19540, 19570, 19599, 19628, 19658, 19687, 19717, 19746, 19776, 19806, 19836, 19865, 19895, 19924, 19954, 19983, 20012, 20042, 20071, 20101, 20130, 20160, 20190, 20219, 20249, 20279, 20308, 20338, 20367, 20396, 20426, 20455, 20485, 20514, 20544, 20573, 20603, 20633, 20662, 20692, 20721, 20751, 20780, 20810, 20839, 20869, 20898, 20928, 20957, 20987, 21016, 21046, 21076, 21105, 21135, 21164, 21194, 21223, 21253, 21282, 21312, 21341, 21371, 21400, 21430, 21459, 21489, 21519, 21548, 21578, 21607, 21637, 21666, 21696, 21725, 21754, 21784, 21813, 21843, 21873, 21902, 21932, 21962, 21991, 22021, 22050, 22080, 22109, 22138, 22168, 22197, 22227, 22256, 22286, 22316, 22346, 22375, 22405, 22434, 22464, 22493, 22522, 22552, 22581, 22611, 22640, 22670, 22700, 22730, 22759, 22789, 22818, 22848, 22877, 22906, 22936, 22965, 22994, 23024, 23054, 23083, 23113, 23143, 23173, 23202, 23232, 23261, 23290, 23320, 23349, 23379, 23408, 23438, 23467, 23497, 23527, 23556, 23586, 23616, 23645, 23674, 23704, 23733, 23763, 23792, 23822, 23851, 23881, 23910, 23940, 23970, 23999, 24029, 24058, 24088, 24117, 24147, 24176, 24206, 24235, 24265, 24294, 24324, 24353, 24383, 24413, 24442, 24472, 24501, 24531, 24560, 24590, 24619, 24648, 24678, 24707, 24737, 24767, 24796, 24826, 24856, 24885, 24915, 24944, 24974, 25003, 25032, 25062, 25091, 25121, 25150, 25180, 25210, 25240, 25269, 25299, 25328, 25358, 25387, 25416, 25446, 25475, 25505, 25534, 25564, 25594, 25624, 25653, 25683, 25712, 25742, 25771, 25800, 25830, 25859, 25888, 25918, 25948, 25977, 26007, 26037, 26067, 26096, 26126, 26155, 26184, 26214, 26243, 26272, 26302, 26332, 26361, 26391, 26421, 26451, 26480, 26510, 26539, 26568, 26598, 26627, 26656, 26686, 26715, 26745, 26775, 26805, 26834, 26864, 26893, 26923, 26952, 26982, 27011, 27041, 27070, 27099, 27129, 27159, 27188, 27218, 27248, 27277, 27307, 27336, 27366, 27395, 27425, 27454, 27484, 27513, 27542, 27572, 27602, 27631, 27661, 27691, 27720, 27750, 27779, 27809, 27838, 27868, 27897, 27926, 27956, 27985, 28015, 28045, 28074, 28104, 28134, 28163, 28193, 28222, 28252, 28281, 28310, 28340, 28369, 28399, 28428, 28458, 28488, 28517, 28547, 28577, 28607, 28636, 28665, 28695, 28724, 28754, 28783, 28813, 28843, 28872, 28901, 28931, 28960, 28990, 29019, 29049, 29078, 29108, 29137, 29167, 29196, 29226, 29255, 29285, 29315, 29345, 29375, 29404, 29434, 29463, 29492, 29522, 29551, 29580, 29610, 29640, 29669, 29699, 29729, 29759, 29788, 29818, 29847, 29876, 29906, 29935, 29964, 29994, 30023, 30053, 30082, 30112, 30141, 30171, 30200, 30230, 30259, 30289, 30318, 30348, 30378, 30408, 30437, 30467, 30496, 30526, 30555, 30585, 30614, 30644, 30673, 30703, 30732, 30762, 30791, 30821, 30850, 30880, 30909, 30939, 30968, 30998, 31027, 31057, 31086, 31116, 31145, 31175, 31204, 31234, 31263, 31293, 31322, 31352, 31381, 31411, 31441, 31471, 31500, 31530, 31559, 31589, 31618, 31648, 31676, 31706, 31736, 31766, 31795, 31825, 31854, 31884, 31913, 31943, 31972, 32002, 32031, 32061, 32090, 32120, 32150, 32180, 32209, 32239, 32268, 32298, 32327, 32357, 32386, 32416, 32445, 32475, 32504, 32534, 32563, 32593, 32622, 32652, 32681, 32711, 32740, 32770, 32799, 32829, 32858, 32888, 32917, 32947, 32976, 33006, 33035, 33065, 33094, 33124, 33153, 33183, 33213, 33243, 33272, 33302, 33331, 33361, 33390, 33420, 33450, 33479, 33509, 33539, 33568, 33598, 33627, 33657, 33686, 33716, 33745, 33775, 33804, 33834, 33863, 33893, 33922, 33952, 33981, 34011, 34040, 34069, 34099, 34128, 34158, 34187, 34217, 34247, 34277, 34306, 34336, 34365, 34395, 34424, 34454, 34483, 34512, 34542, 34571, 34601, 34631, 34660, 34690, 34719, 34749, 34778, 34808, 34837, 34867, 34896, 34926, 34955, 34985, 35015, 35044, 35074, 35103, 35133, 35162, 35192, 35222, 35251, 35280, 35310, 35340, 35370, 35399, 35429, 35458, 35488, 35517, 35547, 35576, 35605, 35635, 35665, 35694, 35723, 35753, 35782, 35811, 35841, 35871, 35901, 35930, 35960, 35989, 36019, 36048, 36078, 36107, 36136, 36166, 36195, 36225, 36254, 36284, 36314, 36343, 36373, 36403, 36433, 36462, 36492, 36521, 36551, 36580, 36610, 36639, 36669, 36698, 36728, 36757, 36786, 36816, 36845, 36875, 36904, 36934, 36963, 36993, 37022, 37052, 37081, 37111, 37141, 37170, 37200, 37229, 37259, 37288, 37318, 37347, 37377, 37406, 37436, 37465, 37495, 37524, 37554, 37584, 37613, 37643, 37672, 37701, 37731, 37760, 37790, 37819, 37849, 37878, 37908, 37938, 37967, 37997, 38027, 38056, 38085, 38115, 38144, 38174, 38203, 38233, 38262, 38292, 38322, 38351, 38381, 38410, 38440, 38469, 38499, 38528, 38558, 38587, 38617, 38646, 38676, 38705, 38735, 38764, 38794, 38823, 38853, 38882, 38912, 38941, 38971, 39001, 39030, 39059, 39089, 39118, 39148, 39178, 39208, 39237, 39267, 39297, 39326, 39355, 39385, 39414, 39444, 39473, 39503, 39532, 39562, 39592, 39621, 39650, 39680, 39709, 39739, 39768, 39798, 39827, 39857, 39886, 39916, 39946, 39975, 40005, 40035, 40064, 40094, 40123, 40153, 40182, 40212, 40241, 40271, 40300, 40330, 40359, 40389, 40418, 40448, 40477, 40507, 40536, 40566, 40595, 40625, 40655, 40685, 40714, 40744, 40773, 40803, 40832, 40862, 40892, 40921, 40951, 40980, 41009, 41039, 41068, 41098, 41127, 41157, 41186, 41216, 41245, 41275, 41304, 41334, 41364, 41393, 41422, 41452, 41481, 41511, 41540, 41570, 41599, 41629, 41658, 41688, 41718, 41748, 41777, 41807, 41836, 41865, 41894, 41924, 41953, 41983, 42012, 42042, 42072, 42102, 42131, 42161, 42190, 42220, 42249, 42279, 42308, 42337, 42367, 42397, 42426, 42456, 42485, 42515, 42545, 42574, 42604, 42633, 42662, 42692, 42721, 42751, 42780, 42810, 42839, 42869, 42899, 42929, 42958, 42988, 43017, 43046, 43076, 43105, 43135, 43164, 43194, 43223, 43253, 43283, 43312, 43342, 43371, 43401, 43430, 43460, 43489, 43519, 43548, 43578, 43607, 43637, 43666, 43696, 43726, 43755, 43785, 43814, 43844, 43873, 43903, 43932, 43962, 43991, 44021, 44050, 44080, 44109, 44139, 44169, 44198, 44228, 44258, 44287, 44317, 44346, 44375, 44405, 44434, 44464, 44493, 44523, 44553, 44582, 44612, 44641, 44671, 44700, 44730, 44759, 44788, 44818, 44847, 44877, 44906, 44936, 44966, 44996, 45025, 45055, 45084, 45114, 45143, 45172, 45202, 45231, 45261, 45290, 45320, 45350, 45380, 45409, 45439, 45468, 45498, 45527, 45556, 45586, 45615, 45644, 45674, 45704, 45733, 45763, 45793, 45823, 45852, 45882, 45911, 45940, 45970, 45999, 46028, 46058, 46088, 46117, 46147, 46177, 46206, 46236, 46265, 46295, 46324, 46354, 46383, 46413, 46442, 46472, 46501, 46531, 46560, 46590, 46620, 46649, 46679, 46708, 46738, 46767, 46797, 46826, 46856, 46885, 46915, 46944, 46974, 47003, 47033, 47063, 47092, 47122, 47151, 47181, 47210, 47240, 47269, 47298, 47328, 47357, 47387, 47417, 47446, 47476, 47506, 47535, 47565, 47594, 47624, 47653, 47682, 47712, 47741, 47771, 47800, 47830, 47860, 47890, 47919, 47949, 47978, 48008, 48037, 48066, 48096, 48125, 48155, 48184, 48214, 48244, 48273, 48303, 48333, 48362, 48392, 48421, 48450, 48480, 48509, 48538, 48568, 48598, 48627, 48657, 48687, 48717, 48746, 48776, 48805, 48834, 48864, 48893, 48922, 48952, 48982, 49011, 49041, 49071, 49100, 49130, 49160, 49189, 49218, 49248, 49277, 49306, 49336, 49365, 49395, 49425, 49455, 49484, 49514, 49543, 49573, 49602, 49632, 49661, 49690, 49720, 49749, 49779, 49809, 49838, 49868, 49898, 49927, 49957, 49986, 50016, 50045, 50075, 50104, 50133, 50163, 50192, 50222, 50252, 50281, 50311, 50340, 50370, 50400, 50429, 50459, 50488, 50518, 50547, 50576, 50606, 50635, 50665, 50694, 50724, 50754, 50784, 50813, 50843, 50872, 50902, 50931, 50960, 50990, 51019, 51049, 51078, 51108, 51138, 51167, 51197, 51227, 51256, 51286, 51315, 51345, 51374, 51403, 51433, 51462, 51492, 51522, 51552, 51582, 51611, 51641, 51670, 51699, 51729, 51758, 51787, 51816, 51846, 51876, 51906, 51936, 51965, 51995, 52025, 52054, 52083, 52113, 52142, 52171, 52200, 52230, 52260, 52290, 52319, 52349, 52379, 52408, 52438, 52467, 52497, 52526, 52555, 52585, 52614, 52644, 52673, 52703, 52733, 52762, 52792, 52822, 52851, 52881, 52910, 52939, 52969, 52998, 53028, 53057, 53087, 53116, 53146, 53176, 53205, 53235, 53264, 53294, 53324, 53353, 53383, 53412, 53441, 53471, 53500, 53530, 53559, 53589, 53619, 53648, 53678, 53708, 53737, 53767, 53796, 53825, 53855, 53884, 53913, 53943, 53973, 54003, 54032, 54062, 54092, 54121, 54151, 54180, 54209, 54239, 54268, 54297, 54327, 54357, 54387, 54416, 54446, 54476, 54505, 54535, 54564, 54593, 54623, 54652, 54681, 54711, 54741, 54770, 54800, 54830, 54859, 54889, 54919, 54948, 54977, 55007, 55036, 55066, 55095, 55125, 55154, 55184, 55213, 55243, 55273, 55302, 55332, 55361, 55391, 55420, 55450, 55479, 55508, 55538, 55567, 55597, 55627, 55657, 55686, 55716, 55745, 55775, 55804, 55834, 55863, 55892, 55922, 55951, 55981, 56011, 56040, 56070, 56100, 56129, 56159, 56188, 56218, 56247, 56276, 56306, 56335, 56365, 56394, 56424, 56454, 56483, 56513, 56543, 56572, 56601, 56631, 56660, 56690, 56719, 56749, 56778, 56808, 56837, 56867, 56897, 56926, 56956, 56985, 57015, 57044, 57074, 57103, 57133, 57162, 57192, 57221, 57251, 57280, 57310, 57340, 57369, 57399, 57429, 57458, 57487, 57517, 57546, 57576, 57605, 57634, 57664, 57694, 57723, 57753, 57783, 57813, 57842, 57871, 57901, 57930, 57959, 57989, 58018, 58048, 58077, 58107, 58137, 58167, 58196, 58226, 58255, 58285, 58314, 58343, 58373, 58402, 58432, 58461, 58491, 58521, 58551, 58580, 58610, 58639, 58669, 58698, 58727, 58757, 58786, 58816, 58845, 58875, 58905, 58934, 58964, 58994, 59023, 59053, 59082, 59111, 59141, 59170, 59200, 59229, 59259, 59288, 59318, 59348, 59377, 59407, 59436, 59466, 59495, 59525, 59554, 59584, 59613, 59643, 59672, 59702, 59731, 59761, 59791, 59820, 59850, 59879, 59909, 59939, 59968, 59997, 60027, 60056, 60086, 60115, 60145, 60174, 60204, 60234, 60264, 60293, 60323, 60352, 60381, 60411, 60440, 60469, 60499, 60528, 60558, 60588, 60618, 60648, 60677, 60707, 60736, 60765, 60795, 60824, 60853, 60883, 60912, 60942, 60972, 61002, 61031, 61061, 61090, 61120, 61149, 61179, 61208, 61237, 61267, 61296, 61326, 61356, 61385, 61415, 61445, 61474, 61504, 61533, 61563, 61592, 61621, 61651, 61680, 61710, 61739, 61769, 61799, 61828, 61858, 61888, 61917, 61947, 61976, 62006, 62035, 62064, 62094, 62123, 62153, 62182, 62212, 62242, 62271, 62301, 62331, 62360, 62390, 62419, 62448, 62478, 62507, 62537, 62566, 62596, 62625, 62655, 62685, 62715, 62744, 62774, 62803, 62832, 62862, 62891, 62921, 62950, 62980, 63009, 63039, 63069, 63099, 63128, 63157, 63187, 63216, 63246, 63275, 63305, 63334, 63363, 63393, 63423, 63453, 63482, 63512, 63541, 63571, 63600, 63630, 63659, 63689, 63718, 63747, 63777, 63807, 63836, 63866, 63895, 63925, 63955, 63984, 64014, 64043, 64073, 64102, 64131, 64161, 64190, 64220, 64249, 64279, 64309, 64339, 64368, 64398, 64427, 64457, 64486, 64515, 64545, 64574, 64603, 64633, 64663, 64692, 64722, 64752, 64782, 64811, 64841, 64870, 64899, 64929, 64958, 64987, 65017, 65047, 65076, 65106, 65136, 65166, 65195, 65225, 65254, 65283, 65313, 65342, 65371, 65401, 65431, 65460, 65490, 65520, 65549, 65579, 65608, 65638, 65667, 65697, 65726, 65755, 65785, 65815, 65844, 65874, 65903, 65933, 65963, 65992, 66022, 66051, 66081, 66110, 66140, 66169, 66199, 66228, 66258, 66287, 66317, 66346, 66376, 66405, 66435, 66465, 66494, 66524, 66553, 66583, 66612, 66641, 66671, 66700, 66730, 66760, 66789, 66819, 66849, 66878, 66908, 66937, 66967, 66996, 67025, 67055, 67084, 67114, 67143, 67173, 67203, 67233, 67262, 67292, 67321, 67351, 67380, 67409, 67439, 67468, 67497, 67527, 67557, 67587, 67617, 67646, 67676, 67705, 67735, 67764, 67793, 67823, 67852, 67882, 67911, 67941, 67971, 68e3, 68030, 68060, 68089, 68119, 68148, 68177, 68207, 68236, 68266, 68295, 68325, 68354, 68384, 68414, 68443, 68473, 68502, 68532, 68561, 68591, 68620, 68650, 68679, 68708, 68738, 68768, 68797, 68827, 68857, 68886, 68916, 68946, 68975, 69004, 69034, 69063, 69092, 69122, 69152, 69181, 69211, 69240, 69270, 69300, 69330, 69359, 69388, 69418, 69447, 69476, 69506, 69535, 69565, 69595, 69624, 69654, 69684, 69713, 69743, 69772, 69802, 69831, 69861, 69890, 69919, 69949, 69978, 70008, 70038, 70067, 70097, 70126, 70156, 70186, 70215, 70245, 70274, 70303, 70333, 70362, 70392, 70421, 70451, 70481, 70510, 70540, 70570, 70599, 70629, 70658, 70687, 70717, 70746, 70776, 70805, 70835, 70864, 70894, 70924, 70954, 70983, 71013, 71042, 71071, 71101, 71130, 71159, 71189, 71218, 71248, 71278, 71308, 71337, 71367, 71397, 71426, 71455, 71485, 71514, 71543, 71573, 71602, 71632, 71662, 71691, 71721, 71751, 71781, 71810, 71839, 71869, 71898, 71927, 71957, 71986, 72016, 72046, 72075, 72105, 72135, 72164, 72194, 72223, 72253, 72282, 72311, 72341, 72370, 72400, 72429, 72459, 72489, 72518, 72548, 72577, 72607, 72637, 72666, 72695, 72725, 72754, 72784, 72813, 72843, 72872, 72902, 72931, 72961, 72991, 73020, 73050, 73080, 73109, 73139, 73168, 73197, 73227, 73256, 73286, 73315, 73345, 73375, 73404, 73434, 73464, 73493, 73523, 73552, 73581, 73611, 73640, 73669, 73699, 73729, 73758, 73788, 73818, 73848, 73877, 73907, 73936, 73965, 73995, 74024, 74053, 74083, 74113, 74142, 74172, 74202, 74231, 74261, 74291, 74320, 74349, 74379, 74408, 74437, 74467, 74497, 74526, 74556, 74586, 74615, 74645, 74675, 74704, 74733, 74763, 74792, 74822, 74851, 74881, 74910, 74940, 74969, 74999, 75029, 75058, 75088, 75117, 75147, 75176, 75206, 75235, 75264, 75294, 75323, 75353, 75383, 75412, 75442, 75472, 75501, 75531, 75560, 75590, 75619, 75648, 75678, 75707, 75737, 75766, 75796, 75826, 75856, 75885, 75915, 75944, 75974, 76003, 76032, 76062, 76091, 76121, 76150, 76180, 76210, 76239, 76269, 76299, 76328, 76358, 76387, 76416, 76446, 76475, 76505, 76534, 76564, 76593, 76623, 76653, 76682, 76712, 76741, 76771, 76801, 76830, 76859, 76889, 76918, 76948, 76977, 77007, 77036, 77066, 77096, 77125, 77155, 77185, 77214, 77243, 77273, 77302, 77332, 77361, 77390, 77420, 77450, 77479, 77509, 77539, 77569, 77598, 77627, 77657, 77686, 77715, 77745, 77774, 77804, 77833, 77863, 77893, 77923, 77952, 77982, 78011, 78041, 78070, 78099, 78129, 78158, 78188, 78217, 78247, 78277, 78307, 78336, 78366, 78395, 78425, 78454, 78483, 78513, 78542, 78572, 78601, 78631, 78661, 78690, 78720, 78750, 78779, 78808, 78838, 78867, 78897, 78926, 78956, 78985, 79015, 79044, 79074, 79104, 79133, 79163, 79192, 79222, 79251, 79281, 79310, 79340, 79369, 79399, 79428, 79458, 79487, 79517, 79546, 79576, 79606, 79635, 79665, 79695, 79724, 79753, 79783, 79812, 79841, 79871, 79900, 79930, 79960, 79990];\n          });\n          var het = ye((rTr, fet) => {\n            "use strict";\n            fet.exports = kv();\n            XQe();\n            ZQe();\n            YQe();\n            KQe();\n            JQe();\n            $Qe();\n            QQe();\n            eet();\n            ret();\n            net();\n            aet();\n            oet();\n            set();\n            uet();\n            cet();\n          });\n          var _et = ye((iTr, yet) => {\n            "use strict";\n            var vet = het(), pC = Dr(), pet = fs(), Ztr = pet.EPOCHJD, Ytr = pet.ONEDAY, kQ = { valType: "enumerated", values: pC.sortObjectKeys(vet.calendars), editType: "calc", dflt: "gregorian" }, get = function(e3, t3, r4, n4) {\n              var i3 = {};\n              return i3[r4] = kQ, pC.coerce(e3, t3, i3, r4, n4);\n            }, Ktr = function(e3, t3, r4, n4) {\n              for (var i3 = 0; i3 < r4.length; i3++) get(e3, t3, r4[i3] + "calendar", n4.calendar);\n            }, Jtr = { chinese: "2000-01-01", coptic: "2000-01-01", discworld: "2000-01-01", ethiopian: "2000-01-01", hebrew: "5000-01-01", islamic: "1000-01-01", julian: "2000-01-01", mayan: "5000-01-01", nanakshahi: "1000-01-01", nepali: "2000-01-01", persian: "1000-01-01", jalali: "1000-01-01", taiwan: "1000-01-01", thai: "2000-01-01", ummalqura: "1400-01-01" }, $tr = { chinese: "2000-01-02", coptic: "2000-01-03", discworld: "2000-01-03", ethiopian: "2000-01-05", hebrew: "5000-01-01", islamic: "1000-01-02", julian: "2000-01-03", mayan: "5000-01-01", nanakshahi: "1000-01-05", nepali: "2000-01-05", persian: "1000-01-01", jalali: "1000-01-01", taiwan: "1000-01-04", thai: "2000-01-04", ummalqura: "1400-01-06" }, Qtr = { chinese: ["2000-01-01", "2001-01-01"], coptic: ["1700-01-01", "1701-01-01"], discworld: ["1800-01-01", "1801-01-01"], ethiopian: ["2000-01-01", "2001-01-01"], hebrew: ["5700-01-01", "5701-01-01"], islamic: ["1400-01-01", "1401-01-01"], julian: ["2000-01-01", "2001-01-01"], mayan: ["5200-01-01", "5201-01-01"], nanakshahi: ["0500-01-01", "0501-01-01"], nepali: ["2000-01-01", "2001-01-01"], persian: ["1400-01-01", "1401-01-01"], jalali: ["1400-01-01", "1401-01-01"], taiwan: ["0100-01-01", "0101-01-01"], thai: ["2500-01-01", "2501-01-01"], ummalqura: ["1400-01-01", "1401-01-01"] }, O9 = "##", err = { d: { 0: "dd", "-": "d" }, e: { 0: "d", "-": "d" }, a: { 0: "D", "-": "D" }, A: { 0: "DD", "-": "DD" }, j: { 0: "oo", "-": "o" }, W: { 0: "ww", "-": "w" }, m: { 0: "mm", "-": "m" }, b: { 0: "M", "-": "M" }, B: { 0: "MM", "-": "MM" }, y: { 0: "yy", "-": "yy" }, Y: { 0: "yyyy", "-": "yyyy" }, U: O9, w: O9, c: { 0: "D M d %X yyyy", "-": "D M d %X yyyy" }, x: { 0: "mm/dd/yyyy", "-": "mm/dd/yyyy" } };\n            function trr(e3, t3, r4) {\n              for (var n4 = Math.floor((t3 + 0.05) / Ytr) + Ztr, i3 = met(r4).fromJD(n4), a4 = 0, o4, s3, l3, u4, c5; (a4 = e3.indexOf("%", a4)) !== -1; ) o4 = e3.charAt(a4 + 1), o4 === "0" || o4 === "-" || o4 === "_" ? (l3 = 3, s3 = e3.charAt(a4 + 2), o4 === "_" && (o4 = "-")) : (s3 = o4, o4 = "0", l3 = 2), u4 = err[s3], u4 ? (u4 === O9 ? c5 = O9 : c5 = i3.formatDate(u4[o4]), e3 = e3.slice(0, a4) + c5 + e3.slice(a4 + l3), a4 += c5.length) : a4 += l3;\n              return e3;\n            }\n            var det = {};\n            function met(e3) {\n              var t3 = det[e3];\n              return t3 || (t3 = det[e3] = vet.instance(e3), t3);\n            }\n            function gC(e3) {\n              return pC.extendFlat({}, kQ, { description: e3 });\n            }\n            function CQ(e3) {\n              return "Sets the calendar system to use with `" + e3 + "` date data.";\n            }\n            var EQ = { xcalendar: gC(CQ("x")) }, ny = pC.extendFlat({}, EQ, { ycalendar: gC(CQ("y")) }), MQ = pC.extendFlat({}, ny, { zcalendar: gC(CQ("z")) }), iS = gC(["Sets the calendar system to use for `range` and `tick0`", "if this is a date axis. This does not set the calendar for", "interpreting data on this axis, that\'s specified in the trace", "or via the global `layout.calendar`"].join(" "));\n            yet.exports = { moduleType: "component", name: "calendars", schema: { traces: { scatter: ny, bar: ny, box: ny, heatmap: ny, contour: ny, histogram: ny, histogram2d: ny, histogram2dcontour: ny, scatter3d: MQ, surface: MQ, mesh3d: MQ, scattergl: ny, ohlc: EQ, candlestick: EQ }, layout: { calendar: gC(["Sets the default calendar system to use for interpreting and", "displaying dates throughout the plot."].join(" ")) }, subplots: { xaxis: { calendar: iS }, yaxis: { calendar: iS }, scene: { xaxis: { calendar: iS }, yaxis: { calendar: iS }, zaxis: { calendar: iS } }, polar: { radialaxis: { calendar: iS } } } }, layoutAttributes: kQ, handleDefaults: get, handleTraceDefaults: Ktr, CANONICAL_SUNDAY: $tr, CANONICAL_TICK: Jtr, DFLTRANGE: Qtr, getCal: met, worldCalFmt: trr };\n          });\n          var bet = ye((nTr, xet) => {\n            "use strict";\n            xet.exports = _et();\n          });\n          var rrr = ye((aTr, Tet) => {\n            var wet = iye();\n            wet.register([o1e(), X1e(), sxe(), kxe(), Vxe(), qbe(), Jbe(), q2e(), dwe(), Ywe(), z3e(), ZEe(), Oke(), k6e(), gLe(), XLe(), mPe(), VIe(), s8e(), S8e(), O8e(), J8e(), hRe(), kRe(), rFe(), wFe(), BBe(), BNe(), YUe(), bVe(), PGe(), WGe(), gHe(), kje(), Gje(), dWe(), wXe(), WXe(), EZe(), YYe(), _Ke(), NKe(), hJe(), MJe(), S$e(), H$e(), uQe(), HQe(), bet()]);\n            Tet.exports = wet;\n          });\n          return rrr();\n        })();\n        window.Plotly = Plotly3;\n        return Plotly3;\n      });\n    }\n  });\n\n  // node_modules/.pnpm/preact@10.28.1/node_modules/preact/dist/preact.module.js\n  var n;\n  var l;\n  var u;\n  var t;\n  var i;\n  var r;\n  var o;\n  var e;\n  var f;\n  var c;\n  var s;\n  var a;\n  var h;\n  var p = {};\n  var v = [];\n  var y = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\n  var w = Array.isArray;\n  function d(n2, l3) {\n    for (var u4 in l3) n2[u4] = l3[u4];\n    return n2;\n  }\n  function g(n2) {\n    n2 && n2.parentNode && n2.parentNode.removeChild(n2);\n  }\n  function _(l3, u4, t3) {\n    var i3, r3, o3, e3 = {};\n    for (o3 in u4) "key" == o3 ? i3 = u4[o3] : "ref" == o3 ? r3 = u4[o3] : e3[o3] = u4[o3];\n    if (arguments.length > 2 && (e3.children = arguments.length > 3 ? n.call(arguments, 2) : t3), "function" == typeof l3 && null != l3.defaultProps) for (o3 in l3.defaultProps) void 0 === e3[o3] && (e3[o3] = l3.defaultProps[o3]);\n    return m(l3, e3, i3, r3, null);\n  }\n  function m(n2, t3, i3, r3, o3) {\n    var e3 = { type: n2, props: t3, key: i3, ref: r3, __k: null, __: null, __b: 0, __e: null, __c: null, constructor: void 0, __v: null == o3 ? ++u : o3, __i: -1, __u: 0 };\n    return null == o3 && null != l.vnode && l.vnode(e3), e3;\n  }\n  function k(n2) {\n    return n2.children;\n  }\n  function x(n2, l3) {\n    this.props = n2, this.context = l3;\n  }\n  function S(n2, l3) {\n    if (null == l3) return n2.__ ? S(n2.__, n2.__i + 1) : null;\n    for (var u4; l3 < n2.__k.length; l3++) if (null != (u4 = n2.__k[l3]) && null != u4.__e) return u4.__e;\n    return "function" == typeof n2.type ? S(n2) : null;\n  }\n  function C(n2) {\n    var l3, u4;\n    if (null != (n2 = n2.__) && null != n2.__c) {\n      for (n2.__e = n2.__c.base = null, l3 = 0; l3 < n2.__k.length; l3++) if (null != (u4 = n2.__k[l3]) && null != u4.__e) {\n        n2.__e = n2.__c.base = u4.__e;\n        break;\n      }\n      return C(n2);\n    }\n  }\n  function M(n2) {\n    (!n2.__d && (n2.__d = true) && i.push(n2) && !$.__r++ || r != l.debounceRendering) && ((r = l.debounceRendering) || o)($);\n  }\n  function $() {\n    for (var n2, u4, t3, r3, o3, f4, c3, s3 = 1; i.length; ) i.length > s3 && i.sort(e), n2 = i.shift(), s3 = i.length, n2.__d && (t3 = void 0, r3 = void 0, o3 = (r3 = (u4 = n2).__v).__e, f4 = [], c3 = [], u4.__P && ((t3 = d({}, r3)).__v = r3.__v + 1, l.vnode && l.vnode(t3), O(u4.__P, t3, r3, u4.__n, u4.__P.namespaceURI, 32 & r3.__u ? [o3] : null, f4, null == o3 ? S(r3) : o3, !!(32 & r3.__u), c3), t3.__v = r3.__v, t3.__.__k[t3.__i] = t3, N(f4, t3, c3), r3.__e = r3.__ = null, t3.__e != o3 && C(t3)));\n    $.__r = 0;\n  }\n  function I(n2, l3, u4, t3, i3, r3, o3, e3, f4, c3, s3) {\n    var a3, h3, y3, w3, d3, g2, _2, m3 = t3 && t3.__k || v, b = l3.length;\n    for (f4 = P(u4, l3, m3, f4, b), a3 = 0; a3 < b; a3++) null != (y3 = u4.__k[a3]) && (h3 = -1 == y3.__i ? p : m3[y3.__i] || p, y3.__i = a3, g2 = O(n2, y3, h3, i3, r3, o3, e3, f4, c3, s3), w3 = y3.__e, y3.ref && h3.ref != y3.ref && (h3.ref && B(h3.ref, null, y3), s3.push(y3.ref, y3.__c || w3, y3)), null == d3 && null != w3 && (d3 = w3), (_2 = !!(4 & y3.__u)) || h3.__k === y3.__k ? f4 = A(y3, f4, n2, _2) : "function" == typeof y3.type && void 0 !== g2 ? f4 = g2 : w3 && (f4 = w3.nextSibling), y3.__u &= -7);\n    return u4.__e = d3, f4;\n  }\n  function P(n2, l3, u4, t3, i3) {\n    var r3, o3, e3, f4, c3, s3 = u4.length, a3 = s3, h3 = 0;\n    for (n2.__k = new Array(i3), r3 = 0; r3 < i3; r3++) null != (o3 = l3[r3]) && "boolean" != typeof o3 && "function" != typeof o3 ? ("string" == typeof o3 || "number" == typeof o3 || "bigint" == typeof o3 || o3.constructor == String ? o3 = n2.__k[r3] = m(null, o3, null, null, null) : w(o3) ? o3 = n2.__k[r3] = m(k, { children: o3 }, null, null, null) : null == o3.constructor && o3.__b > 0 ? o3 = n2.__k[r3] = m(o3.type, o3.props, o3.key, o3.ref ? o3.ref : null, o3.__v) : n2.__k[r3] = o3, f4 = r3 + h3, o3.__ = n2, o3.__b = n2.__b + 1, e3 = null, -1 != (c3 = o3.__i = L(o3, u4, f4, a3)) && (a3--, (e3 = u4[c3]) && (e3.__u |= 2)), null == e3 || null == e3.__v ? (-1 == c3 && (i3 > s3 ? h3-- : i3 < s3 && h3++), "function" != typeof o3.type && (o3.__u |= 4)) : c3 != f4 && (c3 == f4 - 1 ? h3-- : c3 == f4 + 1 ? h3++ : (c3 > f4 ? h3-- : h3++, o3.__u |= 4))) : n2.__k[r3] = null;\n    if (a3) for (r3 = 0; r3 < s3; r3++) null != (e3 = u4[r3]) && 0 == (2 & e3.__u) && (e3.__e == t3 && (t3 = S(e3)), D(e3, e3));\n    return t3;\n  }\n  function A(n2, l3, u4, t3) {\n    var i3, r3;\n    if ("function" == typeof n2.type) {\n      for (i3 = n2.__k, r3 = 0; i3 && r3 < i3.length; r3++) i3[r3] && (i3[r3].__ = n2, l3 = A(i3[r3], l3, u4, t3));\n      return l3;\n    }\n    n2.__e != l3 && (t3 && (l3 && n2.type && !l3.parentNode && (l3 = S(n2)), u4.insertBefore(n2.__e, l3 || null)), l3 = n2.__e);\n    do {\n      l3 = l3 && l3.nextSibling;\n    } while (null != l3 && 8 == l3.nodeType);\n    return l3;\n  }\n  function L(n2, l3, u4, t3) {\n    var i3, r3, o3, e3 = n2.key, f4 = n2.type, c3 = l3[u4], s3 = null != c3 && 0 == (2 & c3.__u);\n    if (null === c3 && null == e3 || s3 && e3 == c3.key && f4 == c3.type) return u4;\n    if (t3 > (s3 ? 1 : 0)) {\n      for (i3 = u4 - 1, r3 = u4 + 1; i3 >= 0 || r3 < l3.length; ) if (null != (c3 = l3[o3 = i3 >= 0 ? i3-- : r3++]) && 0 == (2 & c3.__u) && e3 == c3.key && f4 == c3.type) return o3;\n    }\n    return -1;\n  }\n  function T(n2, l3, u4) {\n    "-" == l3[0] ? n2.setProperty(l3, null == u4 ? "" : u4) : n2[l3] = null == u4 ? "" : "number" != typeof u4 || y.test(l3) ? u4 : u4 + "px";\n  }\n  function j(n2, l3, u4, t3, i3) {\n    var r3, o3;\n    n: if ("style" == l3) if ("string" == typeof u4) n2.style.cssText = u4;\n    else {\n      if ("string" == typeof t3 && (n2.style.cssText = t3 = ""), t3) for (l3 in t3) u4 && l3 in u4 || T(n2.style, l3, "");\n      if (u4) for (l3 in u4) t3 && u4[l3] == t3[l3] || T(n2.style, l3, u4[l3]);\n    }\n    else if ("o" == l3[0] && "n" == l3[1]) r3 = l3 != (l3 = l3.replace(f, "$1")), o3 = l3.toLowerCase(), l3 = o3 in n2 || "onFocusOut" == l3 || "onFocusIn" == l3 ? o3.slice(2) : l3.slice(2), n2.l || (n2.l = {}), n2.l[l3 + r3] = u4, u4 ? t3 ? u4.u = t3.u : (u4.u = c, n2.addEventListener(l3, r3 ? a : s, r3)) : n2.removeEventListener(l3, r3 ? a : s, r3);\n    else {\n      if ("http://www.w3.org/2000/svg" == i3) l3 = l3.replace(/xlink(H|:h)/, "h").replace(/sName$/, "s");\n      else if ("width" != l3 && "height" != l3 && "href" != l3 && "list" != l3 && "form" != l3 && "tabIndex" != l3 && "download" != l3 && "rowSpan" != l3 && "colSpan" != l3 && "role" != l3 && "popover" != l3 && l3 in n2) try {\n        n2[l3] = null == u4 ? "" : u4;\n        break n;\n      } catch (n3) {\n      }\n      "function" == typeof u4 || (null == u4 || false === u4 && "-" != l3[4] ? n2.removeAttribute(l3) : n2.setAttribute(l3, "popover" == l3 && 1 == u4 ? "" : u4));\n    }\n  }\n  function F(n2) {\n    return function(u4) {\n      if (this.l) {\n        var t3 = this.l[u4.type + n2];\n        if (null == u4.t) u4.t = c++;\n        else if (u4.t < t3.u) return;\n        return t3(l.event ? l.event(u4) : u4);\n      }\n    };\n  }\n  function O(n2, u4, t3, i3, r3, o3, e3, f4, c3, s3) {\n    var a3, h3, p3, v3, y3, _2, m3, b, S2, C3, M2, $2, P2, A3, H, L2, T3, j3 = u4.type;\n    if (null != u4.constructor) return null;\n    128 & t3.__u && (c3 = !!(32 & t3.__u), o3 = [f4 = u4.__e = t3.__e]), (a3 = l.__b) && a3(u4);\n    n: if ("function" == typeof j3) try {\n      if (b = u4.props, S2 = "prototype" in j3 && j3.prototype.render, C3 = (a3 = j3.contextType) && i3[a3.__c], M2 = a3 ? C3 ? C3.props.value : a3.__ : i3, t3.__c ? m3 = (h3 = u4.__c = t3.__c).__ = h3.__E : (S2 ? u4.__c = h3 = new j3(b, M2) : (u4.__c = h3 = new x(b, M2), h3.constructor = j3, h3.render = E), C3 && C3.sub(h3), h3.state || (h3.state = {}), h3.__n = i3, p3 = h3.__d = true, h3.__h = [], h3._sb = []), S2 && null == h3.__s && (h3.__s = h3.state), S2 && null != j3.getDerivedStateFromProps && (h3.__s == h3.state && (h3.__s = d({}, h3.__s)), d(h3.__s, j3.getDerivedStateFromProps(b, h3.__s))), v3 = h3.props, y3 = h3.state, h3.__v = u4, p3) S2 && null == j3.getDerivedStateFromProps && null != h3.componentWillMount && h3.componentWillMount(), S2 && null != h3.componentDidMount && h3.__h.push(h3.componentDidMount);\n      else {\n        if (S2 && null == j3.getDerivedStateFromProps && b !== v3 && null != h3.componentWillReceiveProps && h3.componentWillReceiveProps(b, M2), u4.__v == t3.__v || !h3.__e && null != h3.shouldComponentUpdate && false === h3.shouldComponentUpdate(b, h3.__s, M2)) {\n          for (u4.__v != t3.__v && (h3.props = b, h3.state = h3.__s, h3.__d = false), u4.__e = t3.__e, u4.__k = t3.__k, u4.__k.some(function(n3) {\n            n3 && (n3.__ = u4);\n          }), $2 = 0; $2 < h3._sb.length; $2++) h3.__h.push(h3._sb[$2]);\n          h3._sb = [], h3.__h.length && e3.push(h3);\n          break n;\n        }\n        null != h3.componentWillUpdate && h3.componentWillUpdate(b, h3.__s, M2), S2 && null != h3.componentDidUpdate && h3.__h.push(function() {\n          h3.componentDidUpdate(v3, y3, _2);\n        });\n      }\n      if (h3.context = M2, h3.props = b, h3.__P = n2, h3.__e = false, P2 = l.__r, A3 = 0, S2) {\n        for (h3.state = h3.__s, h3.__d = false, P2 && P2(u4), a3 = h3.render(h3.props, h3.state, h3.context), H = 0; H < h3._sb.length; H++) h3.__h.push(h3._sb[H]);\n        h3._sb = [];\n      } else do {\n        h3.__d = false, P2 && P2(u4), a3 = h3.render(h3.props, h3.state, h3.context), h3.state = h3.__s;\n      } while (h3.__d && ++A3 < 25);\n      h3.state = h3.__s, null != h3.getChildContext && (i3 = d(d({}, i3), h3.getChildContext())), S2 && !p3 && null != h3.getSnapshotBeforeUpdate && (_2 = h3.getSnapshotBeforeUpdate(v3, y3)), L2 = a3, null != a3 && a3.type === k && null == a3.key && (L2 = V(a3.props.children)), f4 = I(n2, w(L2) ? L2 : [L2], u4, t3, i3, r3, o3, e3, f4, c3, s3), h3.base = u4.__e, u4.__u &= -161, h3.__h.length && e3.push(h3), m3 && (h3.__E = h3.__ = null);\n    } catch (n3) {\n      if (u4.__v = null, c3 || null != o3) if (n3.then) {\n        for (u4.__u |= c3 ? 160 : 128; f4 && 8 == f4.nodeType && f4.nextSibling; ) f4 = f4.nextSibling;\n        o3[o3.indexOf(f4)] = null, u4.__e = f4;\n      } else {\n        for (T3 = o3.length; T3--; ) g(o3[T3]);\n        z(u4);\n      }\n      else u4.__e = t3.__e, u4.__k = t3.__k, n3.then || z(u4);\n      l.__e(n3, u4, t3);\n    }\n    else null == o3 && u4.__v == t3.__v ? (u4.__k = t3.__k, u4.__e = t3.__e) : f4 = u4.__e = q(t3.__e, u4, t3, i3, r3, o3, e3, c3, s3);\n    return (a3 = l.diffed) && a3(u4), 128 & u4.__u ? void 0 : f4;\n  }\n  function z(n2) {\n    n2 && n2.__c && (n2.__c.__e = true), n2 && n2.__k && n2.__k.forEach(z);\n  }\n  function N(n2, u4, t3) {\n    for (var i3 = 0; i3 < t3.length; i3++) B(t3[i3], t3[++i3], t3[++i3]);\n    l.__c && l.__c(u4, n2), n2.some(function(u5) {\n      try {\n        n2 = u5.__h, u5.__h = [], n2.some(function(n3) {\n          n3.call(u5);\n        });\n      } catch (n3) {\n        l.__e(n3, u5.__v);\n      }\n    });\n  }\n  function V(n2) {\n    return "object" != typeof n2 || null == n2 || n2.__b && n2.__b > 0 ? n2 : w(n2) ? n2.map(V) : d({}, n2);\n  }\n  function q(u4, t3, i3, r3, o3, e3, f4, c3, s3) {\n    var a3, h3, v3, y3, d3, _2, m3, b = i3.props || p, k3 = t3.props, x2 = t3.type;\n    if ("svg" == x2 ? o3 = "http://www.w3.org/2000/svg" : "math" == x2 ? o3 = "http://www.w3.org/1998/Math/MathML" : o3 || (o3 = "http://www.w3.org/1999/xhtml"), null != e3) {\n      for (a3 = 0; a3 < e3.length; a3++) if ((d3 = e3[a3]) && "setAttribute" in d3 == !!x2 && (x2 ? d3.localName == x2 : 3 == d3.nodeType)) {\n        u4 = d3, e3[a3] = null;\n        break;\n      }\n    }\n    if (null == u4) {\n      if (null == x2) return document.createTextNode(k3);\n      u4 = document.createElementNS(o3, x2, k3.is && k3), c3 && (l.__m && l.__m(t3, e3), c3 = false), e3 = null;\n    }\n    if (null == x2) b === k3 || c3 && u4.data == k3 || (u4.data = k3);\n    else {\n      if (e3 = e3 && n.call(u4.childNodes), !c3 && null != e3) for (b = {}, a3 = 0; a3 < u4.attributes.length; a3++) b[(d3 = u4.attributes[a3]).name] = d3.value;\n      for (a3 in b) if (d3 = b[a3], "children" == a3) ;\n      else if ("dangerouslySetInnerHTML" == a3) v3 = d3;\n      else if (!(a3 in k3)) {\n        if ("value" == a3 && "defaultValue" in k3 || "checked" == a3 && "defaultChecked" in k3) continue;\n        j(u4, a3, null, d3, o3);\n      }\n      for (a3 in k3) d3 = k3[a3], "children" == a3 ? y3 = d3 : "dangerouslySetInnerHTML" == a3 ? h3 = d3 : "value" == a3 ? _2 = d3 : "checked" == a3 ? m3 = d3 : c3 && "function" != typeof d3 || b[a3] === d3 || j(u4, a3, d3, b[a3], o3);\n      if (h3) c3 || v3 && (h3.__html == v3.__html || h3.__html == u4.innerHTML) || (u4.innerHTML = h3.__html), t3.__k = [];\n      else if (v3 && (u4.innerHTML = ""), I("template" == t3.type ? u4.content : u4, w(y3) ? y3 : [y3], t3, i3, r3, "foreignObject" == x2 ? "http://www.w3.org/1999/xhtml" : o3, e3, f4, e3 ? e3[0] : i3.__k && S(i3, 0), c3, s3), null != e3) for (a3 = e3.length; a3--; ) g(e3[a3]);\n      c3 || (a3 = "value", "progress" == x2 && null == _2 ? u4.removeAttribute("value") : null != _2 && (_2 !== u4[a3] || "progress" == x2 && !_2 || "option" == x2 && _2 != b[a3]) && j(u4, a3, _2, b[a3], o3), a3 = "checked", null != m3 && m3 != u4[a3] && j(u4, a3, m3, b[a3], o3));\n    }\n    return u4;\n  }\n  function B(n2, u4, t3) {\n    try {\n      if ("function" == typeof n2) {\n        var i3 = "function" == typeof n2.__u;\n        i3 && n2.__u(), i3 && null == u4 || (n2.__u = n2(u4));\n      } else n2.current = u4;\n    } catch (n3) {\n      l.__e(n3, t3);\n    }\n  }\n  function D(n2, u4, t3) {\n    var i3, r3;\n    if (l.unmount && l.unmount(n2), (i3 = n2.ref) && (i3.current && i3.current != n2.__e || B(i3, null, u4)), null != (i3 = n2.__c)) {\n      if (i3.componentWillUnmount) try {\n        i3.componentWillUnmount();\n      } catch (n3) {\n        l.__e(n3, u4);\n      }\n      i3.base = i3.__P = null;\n    }\n    if (i3 = n2.__k) for (r3 = 0; r3 < i3.length; r3++) i3[r3] && D(i3[r3], u4, t3 || "function" != typeof n2.type);\n    t3 || g(n2.__e), n2.__c = n2.__ = n2.__e = void 0;\n  }\n  function E(n2, l3, u4) {\n    return this.constructor(n2, u4);\n  }\n  function G(u4, t3, i3) {\n    var r3, o3, e3, f4;\n    t3 == document && (t3 = document.documentElement), l.__ && l.__(u4, t3), o3 = (r3 = "function" == typeof i3) ? null : i3 && i3.__k || t3.__k, e3 = [], f4 = [], O(t3, u4 = (!r3 && i3 || t3).__k = _(k, null, [u4]), o3 || p, p, t3.namespaceURI, !r3 && i3 ? [i3] : o3 ? null : t3.firstChild ? n.call(t3.childNodes) : null, e3, !r3 && i3 ? i3 : o3 ? o3.__e : t3.firstChild, r3, f4), N(e3, u4, f4);\n  }\n  n = v.slice, l = { __e: function(n2, l3, u4, t3) {\n    for (var i3, r3, o3; l3 = l3.__; ) if ((i3 = l3.__c) && !i3.__) try {\n      if ((r3 = i3.constructor) && null != r3.getDerivedStateFromError && (i3.setState(r3.getDerivedStateFromError(n2)), o3 = i3.__d), null != i3.componentDidCatch && (i3.componentDidCatch(n2, t3 || {}), o3 = i3.__d), o3) return i3.__E = i3;\n    } catch (l4) {\n      n2 = l4;\n    }\n    throw n2;\n  } }, u = 0, t = function(n2) {\n    return null != n2 && null == n2.constructor;\n  }, x.prototype.setState = function(n2, l3) {\n    var u4;\n    u4 = null != this.__s && this.__s != this.state ? this.__s : this.__s = d({}, this.state), "function" == typeof n2 && (n2 = n2(d({}, u4), this.props)), n2 && d(u4, n2), null != n2 && this.__v && (l3 && this._sb.push(l3), M(this));\n  }, x.prototype.forceUpdate = function(n2) {\n    this.__v && (this.__e = true, n2 && this.__h.push(n2), M(this));\n  }, x.prototype.render = k, i = [], o = "function" == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout, e = function(n2, l3) {\n    return n2.__v.__b - l3.__v.__b;\n  }, $.__r = 0, f = /(PointerCapture)$|Capture$/i, c = 0, s = F(false), a = F(true), h = 0;\n\n  // src/core/defaults.ts\n  var theme = {\n    colors: {\n      primary: "#3498db",\n      secondary: "#2ecc71",\n      accent: "#e74c3c",\n      accentDark: "#c0392b",\n      reference: "#bdc3c7",\n      background: "#fafafa",\n      border: "#ffffff",\n      text: "#2c3e50",\n      infoBackground: "#f8f9fa",\n      infoBorder: "#dee2e6",\n      obstacle: "#7f8c8d",\n      obstacleBorder: "#5a6263",\n      forecast: "#9b59b6"\n    },\n    sizes: {\n      vehicleSize: 15,\n      lineWidth: 3,\n      markerSize: 10,\n      defaultVehicleWidth: 1.2,\n      defaultWheelbase: 2.5\n    },\n    animation: {\n      speeds: [\n        { label: "0.5x", ms: 200 },\n        { label: "1x", ms: 100 },\n        { label: "2x", ms: 50 },\n        { label: "4x", ms: 25 }\n      ]\n    }\n  };\n  var defaults = {\n    timeStep: 0.1,\n    vehicleType: "triangle",\n    wheelbase: 2.5,\n    vehicleWidth: 1.2,\n    title: "Simulation Visualization",\n    confidenceScale: 2\n  };\n\n  // node_modules/.pnpm/preact@10.28.1/node_modules/preact/hooks/dist/hooks.module.js\n  var t2;\n  var r2;\n  var u2;\n  var i2;\n  var o2 = 0;\n  var f2 = [];\n  var c2 = l;\n  var e2 = c2.__b;\n  var a2 = c2.__r;\n  var v2 = c2.diffed;\n  var l2 = c2.__c;\n  var m2 = c2.unmount;\n  var s2 = c2.__;\n  function p2(n2, t3) {\n    c2.__h && c2.__h(r2, n2, o2 || t3), o2 = 0;\n    var u4 = r2.__H || (r2.__H = { __: [], __h: [] });\n    return n2 >= u4.__.length && u4.__.push({}), u4.__[n2];\n  }\n  function d2(n2) {\n    return o2 = 1, h2(D2, n2);\n  }\n  function h2(n2, u4, i3) {\n    var o3 = p2(t2++, 2);\n    if (o3.t = n2, !o3.__c && (o3.__ = [i3 ? i3(u4) : D2(void 0, u4), function(n3) {\n      var t3 = o3.__N ? o3.__N[0] : o3.__[0], r3 = o3.t(t3, n3);\n      t3 !== r3 && (o3.__N = [r3, o3.__[1]], o3.__c.setState({}));\n    }], o3.__c = r2, !r2.__f)) {\n      var f4 = function(n3, t3, r3) {\n        if (!o3.__c.__H) return true;\n        var u5 = o3.__c.__H.__.filter(function(n4) {\n          return !!n4.__c;\n        });\n        if (u5.every(function(n4) {\n          return !n4.__N;\n        })) return !c3 || c3.call(this, n3, t3, r3);\n        var i4 = o3.__c.props !== n3;\n        return u5.forEach(function(n4) {\n          if (n4.__N) {\n            var t4 = n4.__[0];\n            n4.__ = n4.__N, n4.__N = void 0, t4 !== n4.__[0] && (i4 = true);\n          }\n        }), c3 && c3.call(this, n3, t3, r3) || i4;\n      };\n      r2.__f = true;\n      var c3 = r2.shouldComponentUpdate, e3 = r2.componentWillUpdate;\n      r2.componentWillUpdate = function(n3, t3, r3) {\n        if (this.__e) {\n          var u5 = c3;\n          c3 = void 0, f4(n3, t3, r3), c3 = u5;\n        }\n        e3 && e3.call(this, n3, t3, r3);\n      }, r2.shouldComponentUpdate = f4;\n    }\n    return o3.__N || o3.__;\n  }\n  function y2(n2, u4) {\n    var i3 = p2(t2++, 3);\n    !c2.__s && C2(i3.__H, u4) && (i3.__ = n2, i3.u = u4, r2.__H.__h.push(i3));\n  }\n  function A2(n2) {\n    return o2 = 5, T2(function() {\n      return { current: n2 };\n    }, []);\n  }\n  function T2(n2, r3) {\n    var u4 = p2(t2++, 7);\n    return C2(u4.__H, r3) && (u4.__ = n2(), u4.__H = r3, u4.__h = n2), u4.__;\n  }\n  function j2() {\n    for (var n2; n2 = f2.shift(); ) if (n2.__P && n2.__H) try {\n      n2.__H.__h.forEach(z2), n2.__H.__h.forEach(B2), n2.__H.__h = [];\n    } catch (t3) {\n      n2.__H.__h = [], c2.__e(t3, n2.__v);\n    }\n  }\n  c2.__b = function(n2) {\n    r2 = null, e2 && e2(n2);\n  }, c2.__ = function(n2, t3) {\n    n2 && t3.__k && t3.__k.__m && (n2.__m = t3.__k.__m), s2 && s2(n2, t3);\n  }, c2.__r = function(n2) {\n    a2 && a2(n2), t2 = 0;\n    var i3 = (r2 = n2.__c).__H;\n    i3 && (u2 === r2 ? (i3.__h = [], r2.__h = [], i3.__.forEach(function(n3) {\n      n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;\n    })) : (i3.__h.forEach(z2), i3.__h.forEach(B2), i3.__h = [], t2 = 0)), u2 = r2;\n  }, c2.diffed = function(n2) {\n    v2 && v2(n2);\n    var t3 = n2.__c;\n    t3 && t3.__H && (t3.__H.__h.length && (1 !== f2.push(t3) && i2 === c2.requestAnimationFrame || ((i2 = c2.requestAnimationFrame) || w2)(j2)), t3.__H.__.forEach(function(n3) {\n      n3.u && (n3.__H = n3.u), n3.u = void 0;\n    })), u2 = r2 = null;\n  }, c2.__c = function(n2, t3) {\n    t3.some(function(n3) {\n      try {\n        n3.__h.forEach(z2), n3.__h = n3.__h.filter(function(n4) {\n          return !n4.__ || B2(n4);\n        });\n      } catch (r3) {\n        t3.some(function(n4) {\n          n4.__h && (n4.__h = []);\n        }), t3 = [], c2.__e(r3, n3.__v);\n      }\n    }), l2 && l2(n2, t3);\n  }, c2.unmount = function(n2) {\n    m2 && m2(n2);\n    var t3, r3 = n2.__c;\n    r3 && r3.__H && (r3.__H.__.forEach(function(n3) {\n      try {\n        z2(n3);\n      } catch (n4) {\n        t3 = n4;\n      }\n    }), r3.__H = void 0, t3 && c2.__e(t3, r3.__v));\n  };\n  var k2 = "function" == typeof requestAnimationFrame;\n  function w2(n2) {\n    var t3, r3 = function() {\n      clearTimeout(u4), k2 && cancelAnimationFrame(t3), setTimeout(n2);\n    }, u4 = setTimeout(r3, 35);\n    k2 && (t3 = requestAnimationFrame(r3));\n  }\n  function z2(n2) {\n    var t3 = r2, u4 = n2.__c;\n    "function" == typeof u4 && (n2.__c = void 0, u4()), r2 = t3;\n  }\n  function B2(n2) {\n    var t3 = r2;\n    n2.__c = n2.__(), r2 = t3;\n  }\n  function C2(n2, t3) {\n    return !n2 || n2.length !== t3.length || t3.some(function(t4, r3) {\n      return t4 !== n2[r3];\n    });\n  }\n  function D2(n2, t3) {\n    return "function" == typeof t3 ? t3(n2) : t3;\n  }\n\n  // src/browser/components/additional-plot.ts\n  var import_plotly = __toESM(require_plotly_min(), 1);\n\n  // src/utils/plot.ts\n  function withoutAutorange(layout) {\n    return {\n      ...layout,\n      xaxis: {\n        ...layout.xaxis,\n        autorange: false\n      },\n      yaxis: {\n        ...layout.yaxis,\n        autorange: false\n      }\n    };\n  }\n\n  // src/browser/components/additional-plot.ts\n  var DEFAULT_COLORS = [\n    "#3498db",\n    "#e74c3c",\n    "#2ecc71",\n    "#9b59b6",\n    "#f39c12",\n    "#1abc9c",\n    "#e91e63",\n    "#795548"\n  ];\n  var DEFAULT_BAND_COLOR = "#3498db";\n  function hexToRgba(hex, alpha) {\n    const r3 = parseInt(hex.slice(1, 3), 16);\n    const g2 = parseInt(hex.slice(3, 5), 16);\n    const b = parseInt(hex.slice(5, 7), 16);\n    return `rgba(${r3}, ${g2}, ${b}, ${alpha})`;\n  }\n  function groupPlots(plots) {\n    const groupMap = /* @__PURE__ */ new Map();\n    const ungrouped = [];\n    for (const plot of plots) {\n      if (plot.group) {\n        const existing = groupMap.get(plot.group) ?? [];\n        existing.push(plot);\n        groupMap.set(plot.group, existing);\n      } else {\n        ungrouped.push(plot);\n      }\n    }\n    const groups = [];\n    for (const [groupId, groupPlots2] of groupMap) {\n      groups.push({\n        id: groupId,\n        name: groupPlots2.map((p3) => p3.name).join(" & "),\n        plots: groupPlots2\n      });\n    }\n    for (const plot of ungrouped) {\n      groups.push({\n        id: plot.id,\n        name: plot.name,\n        plots: [plot]\n      });\n    }\n    return groups;\n  }\n  function getBoundValues(bound, timestepCount) {\n    if (typeof bound.values === "number") {\n      return Array(timestepCount).fill(bound.values);\n    }\n    return bound.values;\n  }\n  function computeYAxisRange(plots, timestepCount) {\n    let minValue = Infinity;\n    let maxValue = -Infinity;\n    for (const plot of plots) {\n      for (const series of plot.series) {\n        for (const value of series.values) {\n          minValue = Math.min(minValue, value);\n          maxValue = Math.max(maxValue, value);\n        }\n      }\n      if (plot.upperBound) {\n        const values = getBoundValues(plot.upperBound, timestepCount);\n        for (const value of values) {\n          maxValue = Math.max(maxValue, value);\n        }\n      }\n      if (plot.lowerBound) {\n        const values = getBoundValues(plot.lowerBound, timestepCount);\n        for (const value of values) {\n          minValue = Math.min(minValue, value);\n        }\n      }\n      if (plot.bands) {\n        for (const band of plot.bands) {\n          for (const value of band.lower) {\n            minValue = Math.min(minValue, value);\n          }\n          for (const value of band.upper) {\n            maxValue = Math.max(maxValue, value);\n          }\n        }\n      }\n    }\n    const padding = (maxValue - minValue) * 0.1 || 0.1;\n    return [minValue - padding, maxValue + padding];\n  }\n  function getSeriesColor(series, index) {\n    return series.color ?? DEFAULT_COLORS[index % DEFAULT_COLORS.length];\n  }\n  function computeBandWidth(band) {\n    return Math.max(...band.upper) - Math.min(...band.lower);\n  }\n  function buildBandTraces(plot, times, traces) {\n    if (!plot.bands || plot.bands.length === 0) {\n      return;\n    }\n    const sortedBands = [...plot.bands].sort((a3, b) => computeBandWidth(b) - computeBandWidth(a3));\n    for (const band of sortedBands) {\n      const color = band.color ?? DEFAULT_BAND_COLOR;\n      const borderColor = hexToRgba(color, 0.4);\n      const fillColor = hexToRgba(color, 0.2);\n      const legendGroup = `band-${band.label ?? "range"}`;\n      traces.push({\n        x: times,\n        y: band.lower,\n        mode: "lines",\n        line: { color: borderColor, width: 1 },\n        legendgroup: legendGroup,\n        showlegend: false,\n        hoverinfo: "skip"\n      });\n      traces.push({\n        x: times,\n        y: band.upper,\n        mode: "lines",\n        fill: "tonexty",\n        fillcolor: fillColor,\n        line: { color: borderColor, width: 1 },\n        legendgroup: legendGroup,\n        name: band.label ?? "Range",\n        showlegend: !!band.label\n      });\n    }\n  }\n  function buildBoundsTraces(plot, times, timestepCount, traces) {\n    const firstSeries = plot.series[0];\n    const color = getSeriesColor(firstSeries, 0);\n    const legendGroup = firstSeries.label;\n    if (plot.upperBound) {\n      traces.push({\n        x: times,\n        y: getBoundValues(plot.upperBound, timestepCount),\n        mode: "lines",\n        line: { color, dash: "dash", width: 1 },\n        name: plot.upperBound.label ?? "Upper Bound",\n        showlegend: !!plot.upperBound.label,\n        legendgroup: legendGroup\n      });\n    }\n    if (plot.lowerBound) {\n      traces.push({\n        x: times,\n        y: getBoundValues(plot.lowerBound, timestepCount),\n        mode: "lines",\n        line: { color, dash: "dash", width: 1 },\n        name: plot.lowerBound.label ?? "Lower Bound",\n        showlegend: !!plot.lowerBound.label,\n        legendgroup: legendGroup\n      });\n    }\n  }\n  function buildSeriesTraces(plot, times, {\n    seriesIndex,\n    seriesCount,\n    markerTime,\n    currentTimestep\n  }, traces) {\n    plot.series.forEach((series, index) => {\n      const color = getSeriesColor(series, seriesIndex + index);\n      traces.push({\n        x: times,\n        y: series.values,\n        mode: "lines",\n        line: { color, width: 2 },\n        name: series.label,\n        showlegend: seriesCount > 1,\n        legendgroup: series.label\n      });\n      traces.push({\n        x: [markerTime],\n        y: [series.values[currentTimestep]],\n        mode: "markers",\n        marker: { color, size: 10 },\n        showlegend: false,\n        legendgroup: series.label,\n        name: `Current ${series.label}`\n      });\n    });\n    return seriesIndex + plot.series.length;\n  }\n  function buildTraces(group, times, timestepCount, currentTimestep) {\n    const traces = [];\n    const allSeries = group.plots.flatMap((plot) => plot.series);\n    const markerTime = times[currentTimestep];\n    let seriesIndex = 0;\n    for (const plot of group.plots) {\n      buildBandTraces(plot, times, traces);\n      buildBoundsTraces(plot, times, timestepCount, traces);\n      seriesIndex = buildSeriesTraces(\n        plot,\n        times,\n        { seriesIndex, seriesCount: allSeries.length, markerTime, currentTimestep },\n        traces\n      );\n    }\n    return traces;\n  }\n  function createAdditionalPlot(container, group, data, state, updateManager) {\n    const times = data.positionsX.map((_2, i3) => i3 * data.timeStep);\n    const allSeries = group.plots.flatMap((plot) => plot.series);\n    const hasBands = group.plots.some((plot) => plot.bands && plot.bands.length > 0);\n    const yAxisLabel = group.plots[0]?.yAxisLabel ?? "";\n    const yRange = computeYAxisRange(group.plots, data.timestepCount);\n    const isLogScale = group.plots[0]?.yAxisScale === "log";\n    let initialized = false;\n    const layout = {\n      title: { text: group.name, font: { size: 12 } },\n      xaxis: {\n        title: { text: "Time (s)", font: { size: 10 } },\n        showgrid: true,\n        gridcolor: "#e0e0e0",\n        tickfont: { size: 9 }\n      },\n      yaxis: {\n        title: { text: yAxisLabel, font: { size: 10 } },\n        type: isLogScale ? "log" : void 0,\n        range: isLogScale ? void 0 : yRange,\n        showgrid: true,\n        gridcolor: "#e0e0e0",\n        zeroline: !isLogScale,\n        zerolinecolor: "#0000006a",\n        tickfont: { size: 9 }\n      },\n      margin: { t: 75, r: 10, b: 50, l: 50 },\n      showlegend: allSeries.length > 1 || hasBands,\n      legend: {\n        x: 1,\n        y: 1,\n        xanchor: "right",\n        yanchor: "top",\n        font: { size: 9 },\n        bgcolor: "rgba(255,255,255,0.8)"\n      },\n      hovermode: "closest",\n      uirevision: "constant",\n      autosize: true\n    };\n    const reactLayout = withoutAutorange(layout);\n    function render() {\n      const traces = buildTraces(group, times, data.timestepCount, state.currentTimestep);\n      if (!initialized) {\n        import_plotly.default.newPlot(container, traces, layout, {\n          scrollZoom: true,\n          responsive: true,\n          displayModeBar: "hover",\n          displaylogo: false\n        });\n        initialized = true;\n      } else {\n        import_plotly.default.react(container, traces, reactLayout);\n      }\n    }\n    render();\n    updateManager.subscribe(render);\n  }\n\n  // node_modules/.pnpm/preact@10.28.1/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js\n  var f3 = 0;\n  function u3(e3, t3, n2, o3, i3, u4) {\n    t3 || (t3 = {});\n    var a3, c3, p3 = t3;\n    if ("ref" in p3) for (c3 in p3 = {}, t3) "ref" == c3 ? a3 = t3[c3] : p3[c3] = t3[c3];\n    var l3 = { type: e3, props: p3, key: n2, ref: a3, __k: null, __: null, __b: 0, __e: null, __c: null, constructor: void 0, __v: --f3, __i: -1, __u: 0, __source: i3, __self: u4 };\n    if ("function" == typeof e3 && (a3 = e3.defaultProps)) for (c3 in a3) void 0 === p3[c3] && (p3[c3] = a3[c3]);\n    return l.vnode && l.vnode(l3), l3;\n  }\n\n  // src/browser/components/AdditionalPlotsContainer.tsx\n  var TabHeader = ({ groups, activeIndex, onTabChange }) => /* @__PURE__ */ u3("div", { class: "plot-tabs-header", children: groups.map((group, index) => /* @__PURE__ */ u3(\n    "button",\n    {\n      type: "button",\n      class: `plot-tab ${index === activeIndex ? "active" : ""}`,\n      onClick: () => onTabChange(index),\n      title: group.name,\n      children: truncateName(group.name, 15)\n    },\n    group.id\n  )) });\n  function truncateName(name2, maxLength) {\n    return name2.length <= maxLength ? name2 : `${name2.slice(0, maxLength - 1)}\\u2026`;\n  }\n  var SinglePlotPanel = ({\n    group,\n    data,\n    state,\n    updateManager\n  }) => {\n    const containerRef = A2(null);\n    const initializedRef = A2(false);\n    y2(() => {\n      if (containerRef.current && !initializedRef.current) {\n        initializedRef.current = true;\n        requestAnimationFrame(() => {\n          if (containerRef.current) {\n            createAdditionalPlot(containerRef.current, group, data, state, updateManager);\n          }\n        });\n      }\n    }, [group.id]);\n    return /* @__PURE__ */ u3("div", { ref: containerRef, class: "additional-plot-content" });\n  };\n  var AdditionalPlotsContainer = ({\n    data,\n    state,\n    updateManager\n  }) => {\n    const plots = data.additionalPlots ?? [];\n    if (plots.length === 0) {\n      return null;\n    }\n    const groups = groupPlots(plots);\n    const [activeTabIndex, setActiveTabIndex] = d2(0);\n    const showTabs = groups.length > 2;\n    const visibleGroups = showTabs ? [groups[activeTabIndex]] : groups;\n    return /* @__PURE__ */ u3("div", { class: "additional-plots-container", children: [\n      showTabs && /* @__PURE__ */ u3(\n        TabHeader,\n        {\n          groups,\n          activeIndex: activeTabIndex,\n          onTabChange: setActiveTabIndex\n        }\n      ),\n      /* @__PURE__ */ u3("div", { class: `additional-plots-content ${showTabs ? "tabbed" : ""}`, children: visibleGroups.map((group) => /* @__PURE__ */ u3("div", { class: "plot-container", children: /* @__PURE__ */ u3(\n        SinglePlotPanel,\n        {\n          group,\n          data,\n          state,\n          updateManager\n        }\n      ) }, group.id)) })\n    ] });\n  };\n\n  // src/utils/math.ts\n  function covarianceToEllipse([[a3, b], [c3, d3]], confidence = defaults.confidenceScale) {\n    const trace = a3 + d3;\n    const det = a3 * d3 - b * c3;\n    const discriminant = Math.sqrt(Math.max(0, trace * trace / 4 - det));\n    const lambda1 = trace / 2 + discriminant;\n    const lambda2 = trace / 2 - discriminant;\n    return {\n      width: 2 * Math.sqrt(Math.max(lambda1, 0)) * confidence,\n      height: 2 * Math.sqrt(Math.max(lambda2, 0)) * confidence,\n      angle: eigenvectorAngle(a3, b, c3, d3, lambda1)\n    };\n  }\n  function radiansToDegrees(radians) {\n    return radians * 180 / Math.PI;\n  }\n  function eigenvectorAngle(a3, b, c3, d3, lambda) {\n    if (Math.abs(b) > 1e-10) {\n      return Math.atan2(lambda - a3, b);\n    } else if (Math.abs(c3) > 1e-10) {\n      return Math.atan2(c3, lambda - d3);\n    } else {\n      return a3 >= d3 ? 0 : Math.PI / 2;\n    }\n  }\n\n  // src/browser/components/InfoPanel.tsx\n  var InfoPanel = ({ currentTimestep, data }) => {\n    const t3 = currentTimestep;\n    const time = (t3 * data.timeStep).toFixed(2);\n    const posX = data.positionsX[t3].toFixed(2);\n    const posY = data.positionsY[t3].toFixed(2);\n    const heading = radiansToDegrees(data.headings[t3]).toFixed(1);\n    const pathParam = data.pathParameters[t3].toFixed(2);\n    const pathLength = data.pathLength.toFixed(1);\n    const progress = (100 * data.pathParameters[t3] / data.pathLength).toFixed(1);\n    return /* @__PURE__ */ u3("div", { class: "info-panel", id: "info-panel", children: [\n      /* @__PURE__ */ u3("h3", { children: "Simulation State" }),\n      /* @__PURE__ */ u3("table", { class: "info-table", children: [\n        /* @__PURE__ */ u3("tr", { children: [\n          /* @__PURE__ */ u3("td", { children: "Time" }),\n          /* @__PURE__ */ u3("td", { children: [\n            time,\n            " s"\n          ] })\n        ] }),\n        /* @__PURE__ */ u3("tr", { children: [\n          /* @__PURE__ */ u3("td", { children: "Position" }),\n          /* @__PURE__ */ u3("td", { children: [\n            "(",\n            posX,\n            ", ",\n            posY,\n            ") m"\n          ] })\n        ] }),\n        /* @__PURE__ */ u3("tr", { children: [\n          /* @__PURE__ */ u3("td", { children: "Heading" }),\n          /* @__PURE__ */ u3("td", { children: [\n            heading,\n            "\\xB0"\n          ] })\n        ] }),\n        /* @__PURE__ */ u3("tr", { children: [\n          /* @__PURE__ */ u3("td", { children: "Path Parameter" }),\n          /* @__PURE__ */ u3("td", { children: [\n            pathParam,\n            " / ",\n            pathLength,\n            " m"\n          ] })\n        ] }),\n        /* @__PURE__ */ u3("tr", { children: [\n          /* @__PURE__ */ u3("td", { children: "Progress" }),\n          /* @__PURE__ */ u3("td", { children: [\n            progress,\n            "%"\n          ] })\n        ] })\n      ] })\n    ] });\n  };\n\n  // src/browser/components/App.tsx\n  var App = ({ data, state, updateManager }) => {\n    const [, forceUpdate] = d2(0);\n    y2(() => {\n      const callback = () => {\n        forceUpdate((n2) => n2 + 1);\n      };\n      updateManager.subscribe(callback);\n    }, []);\n    return /* @__PURE__ */ u3(InfoPanel, { currentTimestep: state.currentTimestep, data });\n  };\n\n  // src/browser/components/Controls.tsx\n  var Controls = ({\n    isPlaying,\n    speedIndex,\n    currentTimestep,\n    timestepCount,\n    speeds,\n    onPlay,\n    onReset,\n    onSpeedChange,\n    onSliderChange\n  }) => {\n    const handleSliderInput = (e3) => {\n      const target = e3.target;\n      onSliderChange(Number.parseInt(target.value, 10));\n    };\n    return /* @__PURE__ */ u3("div", { class: "controls", children: [\n      /* @__PURE__ */ u3(\n        "button",\n        {\n          class: `control-btn play-btn${isPlaying ? " paused" : ""}`,\n          onClick: onPlay,\n          type: "button",\n          children: isPlaying ? "\\u23F8 Pause" : "\\u25B6 Play"\n        }\n      ),\n      /* @__PURE__ */ u3("button", { class: "control-btn reset-btn", onClick: onReset, type: "button", children: "\\u21BA" }),\n      /* @__PURE__ */ u3("button", { class: "control-btn speed-btn", onClick: onSpeedChange, type: "button", children: speeds[speedIndex].label }),\n      /* @__PURE__ */ u3("div", { class: "slider-container", children: /* @__PURE__ */ u3(\n        "input",\n        {\n          type: "range",\n          class: "time-slider",\n          min: "0",\n          max: timestepCount - 1,\n          value: currentTimestep,\n          onInput: handleSliderInput\n        }\n      ) })\n    ] });\n  };\n\n  // src/browser/components/ControlsContainer.tsx\n  var ControlsContainer = ({\n    data,\n    theme: theme2,\n    state,\n    updateManager\n  }) => {\n    const [, forceUpdate] = d2(0);\n    const speeds = theme2.animation.speeds;\n    const timestepCount = data.timestepCount;\n    const notifyUpdate = (timestep) => {\n      state.currentTimestep = timestep;\n      updateManager.notify();\n      forceUpdate((n2) => n2 + 1);\n    };\n    const startAnimation = () => {\n      state.animationInterval = window.setInterval(() => {\n        state.currentTimestep = state.currentTimestep >= timestepCount - 1 ? 0 : state.currentTimestep + 1;\n        updateManager.notify();\n        forceUpdate((n2) => n2 + 1);\n      }, speeds[state.speedIndex].ms);\n    };\n    const stopAnimation = () => {\n      if (state.animationInterval !== null) {\n        clearInterval(state.animationInterval);\n        state.animationInterval = null;\n      }\n    };\n    const handlePlay = () => {\n      if (state.isPlaying) {\n        stopAnimation();\n        state.isPlaying = false;\n      } else {\n        startAnimation();\n        state.isPlaying = true;\n      }\n      forceUpdate((n2) => n2 + 1);\n    };\n    const handleReset = () => {\n      notifyUpdate(0);\n    };\n    const handleSpeedChange = () => {\n      state.speedIndex = (state.speedIndex + 1) % speeds.length;\n      if (state.isPlaying) {\n        stopAnimation();\n        startAnimation();\n      }\n      forceUpdate((n2) => n2 + 1);\n    };\n    const handleSliderChange = (timestep) => {\n      if (state.isPlaying) {\n        stopAnimation();\n        state.isPlaying = false;\n      }\n      notifyUpdate(timestep);\n    };\n    y2(() => {\n      const callback = () => {\n        forceUpdate((n2) => n2 + 1);\n      };\n      updateManager.subscribe(callback);\n    }, []);\n    y2(() => {\n      return () => {\n        stopAnimation();\n      };\n    }, []);\n    return /* @__PURE__ */ u3(\n      Controls,\n      {\n        isPlaying: state.isPlaying,\n        speedIndex: state.speedIndex,\n        currentTimestep: state.currentTimestep,\n        timestepCount,\n        speeds,\n        onPlay: handlePlay,\n        onReset: handleReset,\n        onSpeedChange: handleSpeedChange,\n        onSliderChange: handleSliderChange\n      }\n    );\n  };\n\n  // src/browser/components/trajectory-plot.ts\n  var import_plotly2 = __toESM(require_plotly_min(), 1);\n  function createTrajectoryPlot(container, data, state, theme2, updateManager) {\n    let initialized = false;\n    const layout = {\n      title: { text: "Vehicle Trajectory" },\n      xaxis: { ...createAxisConfig("X Position (m)"), scaleanchor: "y" },\n      yaxis: createAxisConfig("Y Position (m)"),\n      showlegend: true,\n      dragmode: "pan",\n      hovermode: "closest",\n      uirevision: "constant",\n      margin: { t: 60, r: 20, b: 60, l: 60 }\n    };\n    const reactLayout = withoutAutorange(layout);\n    function render() {\n      const t3 = state.currentTimestep;\n      const traces = buildTraces2(data, theme2, t3);\n      if (!initialized) {\n        import_plotly2.default.newPlot(container, traces, layout, {\n          scrollZoom: true,\n          responsive: true,\n          displayModeBar: "hover",\n          displaylogo: false\n        });\n        initialized = true;\n      } else {\n        import_plotly2.default.react(container, traces, reactLayout);\n      }\n    }\n    render();\n    updateManager.subscribe(render);\n  }\n  function buildTraces2(data, theme2, t3) {\n    const traces = [];\n    traces.push(createReferenceTrace(data, theme2));\n    traces.push(createActualPathTrace(data, theme2, t3));\n    traces.push(createVehicleTrace(data, theme2, t3));\n    if (data.ghostX?.[t3]) {\n      traces.push(createGhostTrace(data, theme2, t3));\n    }\n    if (data.optimalTrajectoryX?.[t3]) {\n      traces.push(createOptimalTrajectoryTrace(data, t3));\n    }\n    if (data.nominalTrajectoryX?.[t3]) {\n      traces.push(createNominalTrajectoryTrace(data, t3));\n    }\n    if (data.obstaclePositionsX?.[t3]) {\n      traces.push(...createObstacleTraces(data, theme2, t3));\n    }\n    if (data.obstacleForecastX?.[t3]?.length) {\n      traces.push(...createForecastTraces(data, theme2, t3));\n    }\n    if (data.obstacleForecastCovariance?.[t3]) {\n      traces.push(...createUncertaintyTraces(data, theme2, t3));\n    }\n    return traces;\n  }\n  function createReferenceTrace(data, theme2) {\n    return {\n      x: data.reference.x,\n      y: data.reference.y,\n      mode: "lines",\n      line: { color: theme2.colors.reference, dash: "dash", width: 2 },\n      name: "Reference",\n      legendgroup: "reference"\n    };\n  }\n  function createActualPathTrace(data, theme2, t3) {\n    return {\n      x: data.positionsX.slice(0, t3 + 1),\n      y: data.positionsY.slice(0, t3 + 1),\n      mode: "lines",\n      line: { color: theme2.colors.primary, width: 2 },\n      name: "Actual",\n      legendgroup: "actual"\n    };\n  }\n  function createVehicleTrace(data, theme2, t3) {\n    const corners = transformCorners(\n      data.positionsX[t3],\n      data.positionsY[t3],\n      data.headings[t3],\n      data.wheelbase,\n      data.vehicleWidth\n    );\n    return {\n      x: corners.map((c3) => c3[0]),\n      y: corners.map((c3) => c3[1]),\n      mode: "lines",\n      fill: "toself",\n      fillcolor: theme2.colors.accent,\n      line: { color: theme2.colors.accent, width: 2 },\n      opacity: 0.9,\n      name: "Ego Vehicle",\n      legendgroup: "ego"\n    };\n  }\n  function createGhostTrace(data, theme2, t3) {\n    return {\n      x: [data.ghostX[t3]],\n      y: [data.ghostY[t3]],\n      mode: "markers",\n      marker: { color: theme2.colors.secondary, size: 12, opacity: 0.5 },\n      name: "Ghost",\n      legendgroup: "ghost"\n    };\n  }\n  function createOptimalTrajectoryTrace(data, t3) {\n    return {\n      x: data.optimalTrajectoryX[t3],\n      y: data.optimalTrajectoryY[t3],\n      mode: "lines+markers",\n      line: { color: "#e63946", width: 2 },\n      marker: { color: "#e63946", size: 5, symbol: "circle" },\n      opacity: 0.8,\n      name: "Optimal",\n      legendgroup: "optimal"\n    };\n  }\n  function createNominalTrajectoryTrace(data, t3) {\n    return {\n      x: data.nominalTrajectoryX[t3],\n      y: data.nominalTrajectoryY[t3],\n      mode: "lines+markers",\n      line: { color: "#2a9d8f", width: 2 },\n      marker: { color: "#2a9d8f", size: 5, symbol: "circle" },\n      opacity: 0.8,\n      name: "Nominal",\n      legendgroup: "nominal"\n    };\n  }\n  function createObstacleTraces(data, theme2, t3) {\n    return data.obstaclePositionsX[t3].map((ox, i3) => {\n      const corners = transformCorners(\n        ox,\n        data.obstaclePositionsY[t3][i3],\n        data.obstacleHeadings?.[t3]?.[i3] ?? 0,\n        data.wheelbase,\n        data.vehicleWidth\n      );\n      return {\n        x: corners.map((c3) => c3[0]),\n        y: corners.map((c3) => c3[1]),\n        mode: "lines",\n        fill: "toself",\n        fillcolor: theme2.colors.obstacle,\n        line: { color: theme2.colors.obstacle, width: 2 },\n        opacity: 0.9,\n        name: "Obstacle",\n        legendgroup: "obstacle",\n        showlegend: i3 === 0\n      };\n    });\n  }\n  function createForecastTraces(data, theme2, t3) {\n    const obstacleCount = data.obstacleForecastX[t3][0].length;\n    return Array.from({ length: obstacleCount }, (_2, k3) => {\n      const xPoints = data.obstacleForecastX[t3].map((h3) => h3[k3]);\n      const yPoints = data.obstacleForecastY[t3].map((h3) => h3[k3]);\n      const lastIdx = xPoints.length - 1;\n      const dx = xPoints[lastIdx] - xPoints[lastIdx - 1];\n      const dy = yPoints[lastIdx] - yPoints[lastIdx - 1];\n      const angle = radiansToDegrees(Math.atan2(dy, dx));\n      return {\n        x: xPoints,\n        y: yPoints,\n        mode: "lines+markers",\n        line: { color: theme2.colors.forecast, width: 2 },\n        marker: {\n          size: xPoints.map((_3, i3) => i3 === lastIdx ? 10 : 4),\n          symbol: xPoints.map((_3, i3) => i3 === lastIdx ? "triangle-up" : "circle"),\n          angle: xPoints.map((_3, i3) => i3 === lastIdx ? 90 - angle : 0),\n          color: theme2.colors.forecast\n        },\n        opacity: 0.6,\n        name: "Forecast",\n        legendgroup: "forecast",\n        showlegend: k3 === 0\n      };\n    });\n  }\n  function createUncertaintyTraces(data, theme2, t3) {\n    const traces = [];\n    const cov = data.obstacleForecastCovariance[t3];\n    const obstacleCount = cov[0][0][0].length;\n    let isFirst = true;\n    cov.forEach((_2, h3) => {\n      for (let k3 = 0; k3 < obstacleCount; k3++) {\n        const ellipse = covarianceToEllipse(\n          [\n            [cov[h3][0][0][k3], cov[h3][0][1][k3]],\n            [cov[h3][1][0][k3], cov[h3][1][1][k3]]\n          ],\n          defaults.confidenceScale\n        );\n        const points = generateEllipsePoints(\n          data.obstacleForecastX[t3][h3][k3],\n          data.obstacleForecastY[t3][h3][k3],\n          ellipse.width / 2,\n          ellipse.height / 2,\n          ellipse.angle\n        );\n        traces.push({\n          x: points.map((p3) => p3[0]),\n          y: points.map((p3) => p3[1]),\n          mode: "lines",\n          fill: "toself",\n          fillcolor: theme2.colors.forecast,\n          line: { color: theme2.colors.forecast, width: 1 },\n          opacity: 0.1,\n          name: "Uncertainty",\n          legendgroup: "uncertainty",\n          showlegend: isFirst\n        });\n        isFirst = false;\n      }\n    });\n    return traces;\n  }\n  function transformCorners(x2, y3, heading, width, height) {\n    const cos = Math.cos(heading);\n    const sin = Math.sin(heading);\n    const halfW = width / 2;\n    const halfH = height / 2;\n    return [\n      [-halfW, -halfH],\n      [halfW, -halfH],\n      [halfW, halfH],\n      [-halfW, halfH],\n      [-halfW, -halfH]\n    ].map(([dx, dy]) => [x2 + dx * cos - dy * sin, y3 + dx * sin + dy * cos]);\n  }\n  function generateEllipsePoints(cx, cy, rx, ry, angle, segments = 36) {\n    const cos = Math.cos(angle);\n    const sin = Math.sin(angle);\n    return Array.from({ length: segments + 1 }, (_2, i3) => {\n      const theta = i3 / segments * 2 * Math.PI;\n      const ex = rx * Math.cos(theta);\n      const ey = ry * Math.sin(theta);\n      return [cx + ex * cos - ey * sin, cy + ex * sin + ey * cos];\n    });\n  }\n  function createAxisConfig(title) {\n    return {\n      title: { text: title },\n      showline: false,\n      showgrid: true,\n      gridcolor: "#e0e0e0",\n      zeroline: false\n    };\n  }\n\n  // src/browser/state.ts\n  function createInitialState() {\n    return {\n      currentTimestep: 0,\n      isPlaying: false,\n      animationInterval: null,\n      speedIndex: 2\n    };\n  }\n\n  // src/browser/update.ts\n  function createUpdateManager() {\n    const subscribers = [];\n    return {\n      notify() {\n        for (const callback of subscribers) {\n          callback();\n        }\n      },\n      subscribe(callback) {\n        subscribers.push(callback);\n      }\n    };\n  }\n\n  // src/browser/index.tsx\n  function requireElement(id) {\n    const element = document.getElementById(id);\n    if (!element) {\n      throw new Error(`Element with id "${id}" not found`);\n    }\n    return element;\n  }\n  function initialize() {\n    const data = window.SIMULATION_DATA;\n    if (!data) {\n      console.error("No simulation data found");\n      return;\n    }\n    const state = createInitialState();\n    const theme2 = theme;\n    const updateManager = createUpdateManager();\n    G(\n      /* @__PURE__ */ u3(App, { data, state, updateManager }),\n      requireElement("app-root")\n    );\n    G(\n      /* @__PURE__ */ u3(ControlsContainer, { data, theme: theme2, state, updateManager }),\n      requireElement("controls-root")\n    );\n    G(\n      /* @__PURE__ */ u3(AdditionalPlotsContainer, { data, state, updateManager }),\n      requireElement("additional-plots-root")\n    );\n    requestAnimationFrame(() => {\n      createTrajectoryPlot(requireElement("trajectory-plot"), data, state, theme2, updateManager);\n      updateManager.notify();\n    });\n  }\n  if (document.readyState === "loading") {\n    document.addEventListener("DOMContentLoaded", initialize);\n  } else {\n    initialize();\n  }\n})();\n/*! Bundled license information:\n\nplotly.js-dist-min/plotly.min.js:\n  (*!\n   * pad-left <https://github.com/jonschlinkert/pad-left>\n   *\n   * Copyright (c) 2014-2015, Jon Schlinkert.\n   * Licensed under the MIT license.\n   *)\n  (*!\n   * repeat-string <https://github.com/jonschlinkert/repeat-string>\n   *\n   * Copyright (c) 2014-2015, Jon Schlinkert.\n   * Licensed under the MIT License.\n   *)\n  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n  (*!\n   * The buffer module from node.js, for the browser.\n   *\n   * @author   Feross Aboukhadijeh <https://feross.org>\n   * @license  MIT\n   *)\n  (*!\n   * Determine if an object is a Buffer\n   *\n   * @author   Feross Aboukhadijeh <https://feross.org>\n   * @license  MIT\n   *)\n  (*! Bundled license information:\n  \n  native-promise-only/lib/npo.src.js:\n    (*! Native Promise Only\n        v0.8.1 (c) Kyle Simpson\n        MIT License: http://getify.mit-license.org\n    *)\n  \n  polybooljs/index.js:\n    (*\n     * @copyright 2016 Sean Connelly (@voidqk), http://syntheti.cc\n     * @license MIT\n     * @preserve Project Home: https://github.com/voidqk/polybooljs\n     *)\n  \n  ieee754/index.js:\n    (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n  \n  buffer/index.js:\n    (*!\n     * The buffer module from node.js, for the browser.\n     *\n     * @author   Feross Aboukhadijeh <https://feross.org>\n     * @license  MIT\n     *)\n  \n  safe-buffer/index.js:\n    (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)\n  \n  assert/build/internal/util/comparisons.js:\n    (*!\n     * The buffer module from node.js, for the browser.\n     *\n     * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n     * @license  MIT\n     *)\n  \n  object-assign/index.js:\n    (*\n    object-assign\n    (c) Sindre Sorhus\n    @license MIT\n    *)\n  \n  maplibre-gl/dist/maplibre-gl.js:\n    (**\n     * MapLibre GL JS\n     * @license 3-Clause BSD. Full text of license: https://github.com/maplibre/maplibre-gl-js/blob/v4.7.1/LICENSE.txt\n     *)\n  *)\n*/\n';

// src/visualization/visualizer.ts
function generate(rawData, title = defaults.title) {
  const data = processData(parseSimulationData(rawData));
  return visualizerTemplate({
    title,
    styles: main_default,
    data: JSON.stringify(data),
    script: browser_bundle_default
  });
}
function processData(data) {
  return { ...data, timestepCount: data.positionsX.length };
}

// src/cli/index.ts
var readJson = (path) => JSON.parse((0, import_node_fs.readFileSync)(path, "utf-8"));
var ensureDir = (path) => {
  const dir = (0, import_node_path.dirname)(path);
  if (!(0, import_node_fs.existsSync)(dir)) (0, import_node_fs.mkdirSync)(dir, { recursive: true });
};
program.name("visualizer").description("Generate HTML visualizations from simulation data").version("1.0.0");
program.command("generate").description("Generate HTML visualization from JSON").argument("<input>", "Input JSON file").option("-o, --output <path>", "Output HTML file", "visualization.html").option("-t, --title <string>", "Page title", "Simulation Visualization").action((input, options) => {
  const inputPath = (0, import_node_path.resolve)(input);
  const outputPath = (0, import_node_path.resolve)(options.output);
  console.log(`Reading: ${inputPath}`);
  const html = generate(readJson(inputPath), options.title);
  ensureDir(outputPath);
  (0, import_node_fs.writeFileSync)(outputPath, html, "utf-8");
  console.log(`Generated: ${outputPath}`);
});
program.parse();
